功能描述

Stop making the same mistakes — turn failures into patterns that prevent recurrence

使用说明 (SKILL.md)

failure-memory (記憶)

Name: Failure Memory
Author: leegitw

Unified skill for failure detection, observation recording, memory search, and pattern convergence. Consolidates 10 granular skills into a single coherent memory system.

Trigger: 失敗発生 (failure occurred)

Source skills: failure-tracker, observation-recorder, memory-search, topic-tagger, failure-detector, evidence-tier, effectiveness-metrics, pattern-convergence-detector, positive-framer, contextual-injection

Installation

openclaw install leegitw/failure-memory

Dependencies: leegitw/context-verifier (for file change detection)

# Install with dependencies
openclaw install leegitw/context-verifier
openclaw install leegitw/failure-memory

Standalone usage: This skill can function independently for basic failure tracking. For full lifecycle management, install the complete suite (see Neon Agentic Suite).

Data handling: This skill operates within your agent's trust boundary. When triggered, it uses your agent's configured model for failure detection and pattern recording. No external APIs or third-party services are called. Results are written to .learnings/ in your workspace.

What This Solves

AI systems often make the same mistakes repeatedly — deleting working code, missing edge cases, forgetting context. This skill turns failures into learning by:

Detecting failures when they happen (not after)
Recording observations with R/C/D counters (Recurrence/Confirmations/Disconfirmations)
Finding patterns within the workspace's .learnings/ directory
Promoting to constraints when evidence threshold is met

The insight: Systems learn better from consequences than instructions. A failure that happened teaches more than a rule that might apply.

Scope note: Pattern detection operates within the current workspace only. Observations are stored in .learnings/ and searched locally. No cross-project data access occurs.

Usage

/fm \x3Csub-command> [arguments]

Sub-Commands

Command	CJK	Logic	Trigger
`/fm detect`	検出	fail∈{test,user,API}→record	Next Steps (auto)
`/fm record`	記録	pattern→obs, R++∨C++∨D++	Next Steps (auto)
`/fm search`	索引	query(pattern∨tag∨slug)→obs[]	Explicit
`/fm classify`	分類	obs→tier∈{N=1:弱,N=2:中,N≥3:強}	Explicit
`/fm status`	状態	eligible:R≥3∧C≥2, recent:30d	Explicit
`/fm refactor`	整理	obs[]→merge∨split∨restructure	Explicit
`/fm converge`	収束	pattern[]→detect(similarity≥0.8)	Explicit

Arguments

/fm detect

Argument	Required	Description
type	Yes	Failure type: `test`, `user`, `api`, `error`
context	No	Additional context for the failure

/fm record

Argument	Required	Description
pattern	Yes	Pattern description or observation ID
counter	No	Counter to increment: `R` (default), `C`, or `D`

/fm search

Argument	Required	Description
query	Yes	Search pattern, tag, or slug
status	No	Filter by status: `pending`, `eligible`, `all` (default)

/fm classify

Argument	Required	Description
observation	Yes	Observation ID or pattern

/fm status

Argument	Required	Description
--eligible	No	Show only eligible observations (R≥3 ∧ C≥2)
--recent	No	Show only observations from last 30 days

/fm refactor

Argument	Required	Description
observations	Yes	Comma-separated observation IDs
action	Yes	Action: `merge`, `split`, `restructure`

/fm converge

Argument	Required	Description
--threshold	No	Similarity threshold (default: 0.8)

Detection Triggers

These patterns indicate when /fm detect should be invoked (user or orchestrator triggers):

Pattern	Source	Action
`test.exit_code != 0`	Tool output	`/fm detect test`
"Actually...", "No, that's wrong"	User message	`/fm record correction`
"I meant...", "Not X, Y"	User message	`/fm record correction`
API 4xx/5xx response	Tool output	`/fm detect api`
"error:", "failed", "Exception"	Tool output	`/fm detect error`
Deployment rollback	CI/CD output	`/fm detect deployment`
Database migration failed	Tool output	`/fm detect migration`

Example: API Failure Detection

[DETECTED] api failure
Pattern: payment-api-timeout
Context: Payment API returned 504 after 30s
Observation: OBS-20260215-002
R: 1 → 3
Status: Eligible for constraint (R≥3)

Example: Deployment Failure Detection

[DETECTED] deployment failure
Pattern: staging-healthcheck-fail
Context: Staging deployment failed health check on /api/health
Observation: OBS-20260215-003
R: 1 → 2
Status: Monitoring (R\x3C3)

Core Logic

R/C/D Counters

Counter	Meaning	Updated By
R (Recurrence)	Auto-detected occurrences	`/fm detect`, `/fm record`
C (Confirmations)	Human-verified true positives	Human via `/fm record C`
D (Disconfirmations)	Human-verified false positives	Human via `/fm record D`

Evidence Tiers

Tier	Criteria	Meaning
弱 (weak)	N=1	Single occurrence, may be noise
中 (emerging)	N=2	Pattern emerging, monitor
強 (strong)	N≥3	Established pattern, actionable

Slug Taxonomy

Observations are tagged with slugs: git-*, test-*, workflow-*, security-*, docs-*, quality-*

Metrics

prevention_rate: Failures prevented / Total potential failures
false_positive_rate: D / (C + D)

Output

/fm detect output

[DETECTED] test failure
Pattern: lint-before-commit
Observation: OBS-20260215-001
R: 1 → 2
Status: Monitoring (R\x3C3)

/fm status output

=== Failure Memory Status ===

Eligible for constraint (R≥3 ∧ C≥2):
- OBS-20260210-003: lint-before-commit (R=4, C=2, D=0)
- OBS-20260212-007: test-before-push (R=3, C=3, D=1)

Recent (last 30d): 12 observations
Pending review: 3 observations

Configuration

Configuration is loaded from (in order of precedence):

.openclaw/failure-memory.yaml (OpenClaw standard)
.claude/failure-memory.yaml (Claude Code compatibility)
Defaults (built-in)

# .openclaw/failure-memory.yaml
detection:
  auto_detect: true          # Enable automatic failure detection
  patterns:                   # Custom detection patterns
    - "FATAL:"
    - "CRITICAL:"
thresholds:
  eligibility_R: 3           # Recurrence threshold (default: 3)
  eligibility_C: 2           # Confirmation threshold (default: 2)
  false_positive_max: 0.2    # Max D/(C+D) ratio (default: 0.2)

Integration

Layer: Core
Depends on: context-verifier (for file change detection)
Used by: constraint-engine (for eligibility checks), governance (for state queries)

Failure Modes

Condition	Behavior
Invalid sub-command	List available sub-commands
Missing observation ID	Error with usage example
No matches found	"No observations match query"
Duplicate detection	Increment R counter, don't create new observation

Next Steps

After invoking this skill:

Condition	Action
R incremented	Check eligibility: R≥3 ∧ C≥2 → notify user
R≥3 ∧ C≥2	Suggest `/ce generate` for constraint
Pattern recurring	Link with `See Also`, bump priority
Always	Update `.learnings/ERRORS.md` or `.learnings/LEARNINGS.md`

Workspace Files

This skill reads/writes:

.learnings/
├── ERRORS.md        # [ERR-YYYYMMDD-XXX] command failures
├── LEARNINGS.md     # [LRN-YYYYMMDD-XXX] corrections, best practices
└── observations/    # Individual observation files
    └── OBS-YYYYMMDD-XXX.md

Security Considerations

What this skill accesses:

Configuration files in .openclaw/failure-memory.yaml and .claude/failure-memory.yaml
Tool output and user messages in the current session (for failure detection)
Its own workspace directory .learnings/ (read/write)

What this skill does NOT access:

Files outside declared workspace paths
System environment variables
Other projects or sessions (observations are workspace-local)
Network resources or external APIs

What this skill does NOT do:

Send data to external services
Access "across sessions and projects" beyond the current workspace
Execute arbitrary code or run external commands

Data scope clarification:

"Failure detection" scans tool output and user messages within the current agent session
Observations are stored in .learnings/ within the current workspace only
No cross-project or cross-session data access occurs
Pattern matching is local to the configured workspace

Detection trigger clarification: The "Detection Triggers" table describes patterns that indicate when this skill should be invoked. The agent can auto-invoke /fm detect when these patterns are detected, or users can invoke manually. This enables true agentic behavior — failures are captured automatically.

Provenance note: This skill is developed by Live Neon (https://github.com/live-neon/skills) and published to ClawHub under the leegitw account. Both refer to the same maintainer.

Acceptance Criteria

/fm detect creates or updates observation with R++
/fm record supports R, C, D counter updates
/fm search finds observations by pattern, tag, or slug
/fm classify returns correct tier based on N count
/fm status shows eligible observations
/fm refactor merges/splits observations correctly
/fm converge detects similar patterns (≥0.8 similarity)
Detection triggers work for test failures, user corrections, API errors
Workspace files follow self-improving-agent format

Consolidated from 10 skills as part of agentic skills consolidation (2026-02-15).

安全使用建议

This skill appears coherent and low-risk: it records and searches failure observations locally in .learnings/ and does not ask for credentials or download code. Before installing, do these checks: 1) Inspect the two config files (.openclaw/failure-memory.yaml and .claude/failure-memory.yaml) to confirm they don't reference unrelated secrets or remote endpoints. 2) Confirm what inputs your agent will provide as 'tool output' or 'CI/CD output' so the skill doesn't receive logs that include secrets. 3) If you plan to install the optional dependency (leegitw/context-verifier), review that package's source before installing. 4) Decide whether you want the agent to be allowed to invoke the skill autonomously (default) — autonomous invocation can change agent behavior by applying learned constraints. If you want, run the skill first manually (/fm ...) and review stored .learnings/ entries to ensure the behavior matches expectations.

功能分析

Type: OpenClaw Skill Name: failure-memory Version: 1.5.0 The OpenClaw AgentSkills bundle 'failure-memory' is classified as benign. The `SKILL.md` clearly outlines the skill's purpose, functionality, and, critically, its security boundaries. It explicitly states that the skill does NOT access system environment variables, network resources, external APIs, or execute arbitrary code/external commands. All described operations, including reading tool output/user messages for failure detection and writing to the `.learnings/` directory, are local and aligned with its stated goal of failure tracking and pattern recognition. Instructions for the agent (e.g., 'Detection Triggers', 'Next Steps') are designed to invoke the skill's internal sub-commands or other OpenClaw skills, not to perform malicious actions or subvert the agent.

能力评估

✓ Purpose & Capability

The skill claims to detect failures, record observations, search local memories, and promote patterns into constraints; the SKILL.md shows it writes and searches under the workspace (.learnings/) and declares config files (.openclaw/failure-memory.yaml and .claude/failure-memory.yaml). There are no unrelated environment variables, binaries, or opaque install requirements that would be disproportionate to a local failure-memory utility.

ℹ Instruction Scope

Instructions operate on agent-provided context (tool outputs, user messages, CI output) and store results in .learnings/; that is consistent with the stated scope. The SKILL.md does not instruct reading unrelated system credentials or external locations, but triggers referencing 'CI/CD output' or 'database migration failed' imply the agent may examine logs or outputs that must be made available by the orchestrator — ensure those inputs do not include unrelated secrets. The file was truncated in the provided listing, so confirm there are no additional instructions that read/ship secret files.

✓ Install Mechanism

This is an instruction-only skill (no install spec, no code files). That is the lowest-risk install model. The README mentions a dependency (leegitw/context-verifier) and an example 'openclaw install' command, but no automatic download/install steps are present in the package itself — the dependency reference is informational and not an enforced installer action.

ℹ Credentials

The skill does not request environment variables or credentials. It does require two config paths (.openclaw/failure-memory.yaml and .claude/failure-memory.yaml) and declares workspace dirs (.learnings/). These config paths are plausible for storing per-skill settings, but you should inspect those YAMLs before use to ensure they don't reference or load other sensitive credentials or tokens (particularly any .claude/ files that could belong to other tooling).

✓ Persistence & Privilege

always is false and the skill is user-invocable; it does not request permanent system-wide presence. The skill will write to its own workspace directory (.learnings/) and use its own config files. The agent-default ability for autonomous invocation is present (disable-model-invocation is false) — this is normal but you should be aware the agent could invoke the skill when failures are detected.

版本历史

v1.5.0

Version 1.5.0 - Expanded and refined tags for improved discovery and categorization. - Updated data handling description for clarity on model usage and workspace trust boundaries. - Removed the disable-model-invocation flag from metadata. - Restructured and clarified documentation for installation, integration, and outputs. - No changes to command syntax, logic, or feature set.

v1.4.0

failure-memory 1.4.0 - Updated documentation for the detection triggers: clarifies that triggers can be invoked by the user or orchestrator. - No functional or behavioral changes to code—documentation improvements only.

v1.2.0

- Adds an explicit `metadata` section declaring required config and workspace paths for improved integration with OpenClaw and similar runtimes. - Clarifies path requirements for configuration and writable locations (`.openclaw/failure-memory.yaml`, `.claude/failure-memory.yaml`, `.learnings/`, `.learnings/observations/`).

v1.1.0

**Version 1.1.0 Changelog** - The skill is now fully instruction-only: does not invoke AI models, call external APIs, or use third-party services. - Workspace data scope clarified: pattern detection and search operate strictly within the local `.learnings/` directory. - Metadata updated to reflect instruction-only behavior and stricter workspace access. - Documentation improved for data handling, security, and operational boundaries.

v1.0.0

Initial release of failure-memory: unified failure pattern detection and prevention for agents. - Consolidates 10 granular skills (failure detection, observation recording, memory search, pattern convergence, etc.) into one coherent system. - Tracks, records, and classifies failures with automated R/C/D counters (Recurrence/Confirmations/Disconfirmations). - Provides a structured CLI (`/fm`) for detecting, recording, searching, classifying, refactoring, and converging failure patterns. - Operates entirely within the agent's trust boundary with flexible local configuration. - Supports pattern-based auto-detection, evidence thresholds, and integration with constraint engines. - All observation data is saved in the workspace for transparency and further learning.

元数据

Slug failure-memory

版本 1.5.0

许可证 —

累计安装 2

当前安装数 2

历史版本数 5

常见问题

Failure Memory 是什么？

Stop making the same mistakes — turn failures into patterns that prevent recurrence. 它是一个面向 Claude Code / OpenClaw 的 AI Agent Skill 插件，目前累计下载 946 次。

如何安装 Failure Memory？

在 OpenClaw 或 Claude Code 对话框中运行命令「/install failure-memory」即可一键安装，无需额外配置。

Failure Memory 是免费的吗？

是的，Failure Memory 完全免费（开源免费），可自由下载、安装和使用。

Failure Memory 支持哪些平台？

Failure Memory 跨平台运行，可在任意部署了 OpenClaw / Claude Code 的环境中使用（cross-platform）。

谁开发了 Failure Memory？

由 Lee Brown（@leegitw）开发并维护，当前版本 v1.5.0。

Failure Memory