← Back to Skills Marketplace
donovanpankratz-del

Correction Memory

by dp-del · GitHub ↗ · v1.1.0
cross-platform ✓ Security Clean
497
Downloads
0
Stars
0
Active Installs
2
Versions
Install in OpenClaw
/install correction-memory
Description
Makes agent corrections persistent and reusable. When you override, reject, or correct an agent's output, this skill logs the correction and automatically in...
README (SKILL.md)

Correction Memory

The Problem

When you correct an agent, that correction evaporates after the session. Next time you spawn the same agent type, it makes the same mistake. There's no memory of what you've already taught it.

What This Skill Installs

  • lib/correction-tracker.js — logs corrections per agent type to memory/corrections/[AgentType].jsonl
  • Hook into agent-context-loader.js — correction preamble prepended to spawns automatically (if intent-engineering is also installed)

Installation

Step 1 — Install correction-tracker

cp references/correction-tracker-template.js $OPENCLAW_WORKSPACE/lib/correction-tracker.js

Verify it runs:

node $OPENCLAW_WORKSPACE/lib/correction-tracker.js

Step 2 — Wire agent-context-loader (if using intent-engineering)

If lib/agent-context-loader.js is installed (from intent-engineering skill), correction injection is automatic — no wiring needed. The loader checks for correction-tracker.js at startup and loads it if present.

If you are NOT using intent-engineering, add this to your spawn logic manually:

const { buildCorrectionPreamble } = require('./lib/correction-tracker');

const agentType   = 'CoderAgent'; // or whatever agent you're spawning
const corrections = buildCorrectionPreamble(agentType, workspaceRoot);
const fullTask    = corrections ? corrections + '\
\
---\
\
' + originalTask : originalTask;

Logging Corrections

Programmatic

const { logCorrection } = require('./lib/correction-tracker');

logCorrection(
  'CoderAgent',                                    // agent type
  'Used ESM import instead of require()',          // what was wrong
  'Always use require() for Node.js stdlib modules', // correct behavior
  workspaceRoot,
  { session_channel: 'discord' }                  // optional metadata
);

Via main agent (natural language)

Just tell the main agent:

"Note that [AgentType]: [what it did wrong] — [correct behavior]"

The main agent will log it programmatically.

How Corrections Are Replayed

On every subagent spawn, agent-context-loader detects the agent type from the task description and prepends:

## Corrections from Previous Sessions

The following corrections were logged for CoderAgent. Apply these behaviors:

1. **[2026-03-01] Issue:** Used ESM import instead of require()
   **Correction:** Always use require() for Node.js stdlib modules

Only corrections from the last 30 days are injected. Older corrections expire automatically — stale rules don't accumulate.

Viewing Corrections

# All corrections for an agent type
cat $OPENCLAW_WORKSPACE/memory/corrections/CoderAgent.jsonl | jq .

# List all agent types with corrections
ls $OPENCLAW_WORKSPACE/memory/corrections/

# Count corrections per agent
for f in $OPENCLAW_WORKSPACE/memory/corrections/*.jsonl; do
  echo "$(basename $f .jsonl): $(wc -l \x3C $f) corrections"
done

Agent Type Detection

The loader auto-detects agent type from the task description. Default rules:

Task keywords Agent type
code, coder, impl, debug CoderAgent
writ, author, novel, chapter AuthorAgent
world, build WorldbuilderAgent
(anything else) general

To add custom agent types, edit detectAgentType() in agent-context-loader.js.

References

  • references/correction-tracker-template.js — Full implementation of correction-tracker.js
Usage Guidance
This skill appears to do exactly what it says: store human corrections under $OPENCLAW_WORKSPACE/memory/corrections and prepend recent corrections to future agent prompts. Before installing: 1) Inspect the template file (already included) and confirm you’re comfortable with storing corrections as plain text under memory/corrections; corrections are free text and could include sensitive info if you or agents log it. 2) Confirm $OPENCLAW_WORKSPACE points to the intended workspace and check file permissions so other processes/users can't read the corrections if that’s a concern. 3) Be aware that if you also use an intent-engineering/agent-context-loader module, this file will be auto-loaded and will change spawn behavior across sessions. 4) The module’s smoke test creates a temp directory when run directly — that’s benign but expected. If you want additional assurance, run the smoke test in a safe environment and review memory/corrections files after creating a few test corrections.
Capability Analysis
Type: OpenClaw Skill Name: correction-memory Version: 1.1.0 The skill's purpose is to persist agent corrections, and its implementation demonstrates strong security practices. The `correction-tracker-template.js` file includes robust input sanitization for agent types and content, explicitly preventing path traversal and injection vulnerabilities. File operations are confined to the designated `memory/corrections` directory within the workspace. The `SKILL.md` instructions are straightforward, and the verification step executes the local, reviewed JavaScript file in a temporary, self-cleaning environment. There is no evidence of data exfiltration, malicious execution, persistence mechanisms, or prompt injection attempts within the skill's own content or instructions.
Capability Assessment
Purpose & Capability
Name/description match what is provided: an instruction-only skill plus a local JS module that logs corrections to workspace/memory/corrections/[AgentType].jsonl and builds a preamble for injection. No unrelated env vars, binaries, or remote installs are requested.
Instruction Scope
SKILL.md limits actions to copying the included template into $OPENCLAW_WORKSPACE/lib, optionally wiring it into spawn logic, and inspecting files under memory/corrections. It does not instruct reading other system files, exfiltrating data, or calling external endpoints.
Install Mechanism
No network downloads or package installs. The install is a local copy of the included template file into the workspace (cp), which is low risk and consistent with the described behavior. Running the module triggers a harmless smoke test that writes to a temp dir.
Credentials
The skill requests no environment variables, credentials, or config paths. It requires a workspaceRoot argument to operate (used to place/read files under memory/corrections), which is appropriate for the stated functionality.
Persistence & Privilege
The skill is not always-enabled and does not request elevated privileges. If present, agent-context-loader (from another skill) may auto-load correction-tracker.js and prepend corrections to spawned agent prompts — intended behavior but worth noting because it changes agent spawn context across sessions.
How to Use
  1. Make sure OpenClaw is installed (local or Docker)
  2. Run the install command in chat: /install correction-memory
  3. After installation, invoke the skill by name or use /correction-memory
  4. Provide required inputs per the skill's parameter spec and get structured output
Version History
v1.1.0
Security fix: agentType path traversal prevention (allowlist sanitization + path.resolve confinement), input length limits, control char stripping on correction content
v1.0.0
- Introduces persistent correction memory for agents by logging corrections and injecting them into future agent spawns. - Automatically logs and replays corrections per agent type, ensuring improved behavior across sessions. - Installs a correction tracker and integrates with agent-context-loader (intent-engineering compatible). - Only corrections from the last 30 days are applied; older rules expire automatically. - Supports both programmatic correction logging and natural language corrections via the main agent. - Includes tools for viewing and managing logged corrections for each agent type.
Metadata
Slug correction-memory
Version 1.1.0
License
All-time Installs 0
Active Installs 0
Total Versions 2
Frequently Asked Questions

What is Correction Memory?

Makes agent corrections persistent and reusable. When you override, reject, or correct an agent's output, this skill logs the correction and automatically in... It is an AI Agent Skill for Claude Code / OpenClaw, with 497 downloads so far.

How do I install Correction Memory?

Run "/install correction-memory" in the OpenClaw or Claude Code chat to install it in one step — no extra setup required.

Is Correction Memory free?

Yes, Correction Memory is completely free (open-source). You can download, install and use it at no cost.

Which platforms does Correction Memory support?

Correction Memory is cross-platform and runs anywhere OpenClaw / Claude Code is available (cross-platform).

Who created Correction Memory?

It is built and maintained by dp-del (@donovanpankratz-del); the current version is v1.1.0.

💬 Comments