---
name: memory-and-handoff
description: |
  Two-mode skill: (1) session memory — load/persist durable workflow state under .cc10x/
  (activeContext, patterns, progress) so context survives compaction; (2) handoff package —
  portable, secrets-redacted export for a coworker, different tool, or fresh non-cc10x session.
allowed-tools: Read Write Edit Bash Grep Glob
user-invocable: false
---

# Memory & Handoff

## Reference Files

- `references/memory-model-and-ownership.md` — memory surfaces, ownership, promotion, workflow markers
- `references/memory-operations.md` — permission-free operations, router-only persistence, edit patterns
- `references/memory-file-contracts.md` — required headings, stable anchors, templates, auto-heal rules
- `references/context-budget-and-checkpointing.md` — context-budget rules, warning signs, checkpoint triggers

---

## Mode: SESSION MEMORY

Memory is an index, not a transcript. Distill decisions, learnings, references, and verification evidence into durable, reusable notes.

### Memory Surfaces

| File | Holds |
| ------ | ------- |
| `.cc10x/activeContext.md` | current focus, recent changes, decisions, learnings, references, blockers |
| `.cc10x/patterns.md` | reusable project standards, gotchas, conventions, skill hints |
| `.cc10x/progress.md` | current workflow, tasks snapshot, completed items, verification evidence |
| `.cc10x/workflows/{wf}.json` + `.events.jsonl` | durable orchestration truth (machine-owned, verbatim) |
| `docs/plans/*`, `docs/research/*` | detailed artifacts; memory points to them |

### Ownership

- Router loads and auto-heals memory files before routing or resume
- WRITE agents read memory but do NOT edit `.cc10x/*.md` directly
- WRITE agents emit structured `MEMORY_NOTES` in their Router Contract
- READ-ONLY agents emit `### Memory Notes (For Workflow-Final Persistence)`
- Router-owned memory-finalize task is the only final writer of memory markdown files
- Router-owned markers (`[DEBUG-RESET: wf:{...}]`, `[cc10x-internal] memory_task_id`) are read and respected; agents do not invent replacements

### Load (MANDATORY at workflow start)

Read all three: `activeContext.md`, `patterns.md`, `progress.md`.

Re-read before: architectural decisions (`patterns.md` + `activeContext.md ## Decisions`), implementation choices (`patterns.md` + `activeContext.md`), debugging (all three), planning next steps (`progress.md` + `activeContext.md`), claiming completion (`progress.md` + plan/design/research refs), user says "continue" (all three).

### Persist

Emit `MEMORY_NOTES` in Router Contract:

```yaml
MEMORY_NOTES:
  learnings: ["Key causal insight"]
  patterns: ["Reusable gotcha or convention"]
  verification: ["`npm test` -> exit 0"]
  deferred: ["Non-blocking follow-up or risk"]
```

Keep each entry one line. Prefer stable nouns over temporary wording. Put verification truth in `verification`, not prose. Put non-blocking work in `deferred`, not ad-hoc tasks.

**Persist only memory-worthy items:** decisions that change direction, learnings that prevent mistakes, verification evidence with commands and exit truth, deferred non-blocking issues, plan/design/research references, clarified user standards.

**Do not persist:** whole diffs, verbose logs, celebratory narration, "looked correct" without evidence, duplicate notes, raw secrets/PII in outward artifacts.

### Secret Redaction (OUTWARD artifacts only)

Before router persists cc10x-authored content into outward artifacts (`docs/plans/*`, `docs/research/*`, design docs, persisted memory notes): redact pasted tokens, API keys, connection-strings, credentials, PII. Replace with `<redacted:secret>`. Keep surrounding constraint intact. Does NOT apply to internal machine-owned `.cc10x/` orchestration state — that stays verbatim for resume/dedupe keys.

### Compaction KEEP / SUMMARIZE / DROP Rubric

| Tier | What | Rule |
| ------ | ------ | ------ |
| KEEP | user hard-constraints/prohibitions, exact next step, open failures + errors | preserve VERBATIM — never paraphrase a constraint or error |
| SUMMARIZE | resolved decisions with rationale, concluded attempts, discovered file/module boundaries | distill to one durable line each |
| DROP | decorative prose, step-by-step diary, superseded speculation, redundant prompt retellings | discard |

Persist user PROHIBITIONS verbatim into workflow artifact's intent field as soon as stated — compaction may fire before router's normal persist.

### Project Skill Hints

After loading memory, check `patterns.md ## Project SKILL_HINTS`. Invoke listed skills when relevant and installed. Treat missing skills as non-fatal. Do not invent skill IDs. Do not edit `## Project SKILL_HINTS` directly — surface recommendations in planner output or memory notes.

---

## Mode: HANDOFF PACKAGE

A portable, human-readable export for when the next reader is NOT this cc10x session — a coworker, a different tool, or a clean session with no cc10x router.

cc10x's own resume is structural (`.cc10x/` + router rehydrates). The handoff package is the bridge OUT to a reader who cannot read `.cc10x/` orchestration state.

### Rules

1. **Write to OS temp dir, never into the repo.** `HANDOFF="${TMPDIR:-/tmp}/handoff-$(date +%Y%m%d-%H%M%S).md"`. Print the absolute path.
2. **Reference artifacts by path/URL, never paste contents.** The next reader has the repo. They need a map, not a copy. Prefer behavioral descriptions over `file:line` where code may still drift.
3. **Redact secrets and PII before writing.** Replace with `<redacted:secret>`, `<redacted:pii>`. Keep surrounding constraint intact. When unsure, redact.

### Contents

| Section | Holds |
| --------- | ------- |
| Goal | one-line objective, verbatim user intent if stated |
| Current state | where things stand, one short paragraph |
| What's done | reference artifacts by path; do not re-narrate |
| What's next | EXACT next step — concrete enough to start cold |
| Open blockers / failures | unresolved errors VERBATIM, failing commands, dead ends tried |
| Suggested skills / tools | which skills the next agent should invoke to continue |
| Artifacts (by path) | plan, diff/PR, key source files with behavioral descriptions |

The "suggested skills/tools" pointer is load-bearing: tell the next agent how to continue. If cc10x is present: invoke `cc10x-router`. If not: name domain skills and point at plan/research docs.

---

## Knowledge Compounding Loop

Memory is not just for context survival — it's for system self-improvement. After every BUILD or DEBUG cycle, structured learnings should compound into reusable knowledge.

### The Loop

1. **Capture** — During workflow-finalize, the router writes structured learnings from agent `MEMORY_NOTES` into `activeContext.md ## Learnings` and `patterns.md ## Common Gotchas`.
2. **Ground** — Before starting new work, agents read `patterns.md` and `activeContext.md` to avoid repeating solved problems.
3. **Consolidate** — When the same gotcha appears 3+ times in `patterns.md`, promote it to a dedicated reference file or skill section.

### Compounding Outcomes

When reviewing prior learnings during memory-finalize, apply one of five outcomes:

| Outcome | When | Action |
| ---------- | ------ | -------- |
| **Keep** | Learning is still accurate and useful | Leave as-is |
| **Update** | Learning is correct but incomplete | Add the missing detail |
| **Consolidate** | Same lesson appears multiple times | Merge into one entry, remove duplicates |
| **Replace** | Learning is outdated or superseded | Replace with the current truth |
| **Delete** | Learning no longer applies (framework changed, code removed) | Remove it |

**Why this matters:** Without consolidation, memory accumulates stale entries that mislead future work. The compounding loop ensures memory gets sharper over time, not just larger.

## Knowledge Compounding Loop (docs/solutions/)

Memory files (`activeContext.md`, `patterns.md`, `progress.md`) are for session-scoped context. For **durable, structured learnings that survive across projects and sessions**, write to `docs/solutions/`.

### When to Write a Solution Doc

After any non-trivial debug or build cycle, the router (during memory-finalize) should evaluate whether to write a solution doc:

- **Write** if: the problem took 3+ hypotheses to solve, OR the bug pattern appears in 3+ files, OR the solution contradicts a common assumption
- **Skip** if: the fix was mechanical (typo, import error, one-line change)
- **Offer neutrally** if: the lesson is one sentence (mention in memory notes instead)

### Solution Doc Format

```markdown
# [Problem Title]
Category: [debugging | architecture | testing | workflow | conventions]
Tags: [comma-separated]
Date: YYYY-MM-DD

## Problem
[What went wrong — symptoms, not just the error message]

## What Didn't Work
[Hypotheses that failed and why]

## Solution
[What actually worked — with code example if applicable]

## Why
[Why the solution works — the underlying principle]

## Prevention
[How to prevent this class of problem in the future]
```

### The Full Loop

1. **Capture** — Write solution doc after non-trivial cycles
2. **Ground** — Planning and debugging skills read `docs/solutions/` as context before starting new work
3. **Refresh** — Periodically audit solution docs: Keep / Update / Consolidate / Replace / Delete (same five-outcome model as memory consolidation)
4. **Discover** — Ensure `CLAUDE.md` or `AGENTS.md` points to `docs/solutions/` so agents can find it

This closes the loop: every solved problem makes the next problem easier. Without `docs/solutions/`, the system repeats mistakes. With it, the system compounds knowledge.