Reseed

Reseed: Seed-and-Clear Context Reduction

The window is filling up and work is mid-flight, and invoking /reseed is the choice to take the careful path: author a detailed seed → /clear → revive from it. There is no decision step — in ~50 real uses, seed-and-clear won 100% of the time, and deliberating a foregone conclusion would only burn the dying window this skill exists to protect. For a cheap summarize where little is at stake, don't run this — just /compact directly.

The load-bearing idea: a good seed points at durable artifacts and carries only volatile working-state. It mirrors CLAUDE.md's own compact-instructions ("if it's on disk, reference the path"). Anything already on disk — or auto-reloaded at session start — does not belong in the seed.

Step 1 — Author the seed

Write the seed following the kernel. Carry:

• Pointers to the durable artifacts that ARE the state — design docs,

memory file names, issue numbers, key file:line ranges. Reference them; never duplicate their contents.

• Volatile working-state — current branch, uncommitted/modified files, the

immediate next action (be explicit about intent), and open threads.

• Communication / relationship nuance not re-derivable — e.g. "user is on a

phone, expect typos, confirm side-effectful actions," tone, who decides what.

• Gotchas not to relearn the hard way — sharp edges, things that already

bit this session.

• Conversation-only operating-decisions — the things said this session that change

how you operate or what you prioritize and have no durable home: grants/waivers ("auto-approve prechecks", standing /scpmmr, "don't ask", "I'll handle X"), and the priority stack you agreed (focus, ordering, what to do vs defer vs skip). The seed's instinct is "point at durable state" — so it systematically drops these, because the conversation that holds them is the very thing being dropped; there is nothing to point at. Carry each as decision + why + scope:

• the decision outright, so the revived agent never re-derives it — re-deriving

from a hint is where a fresh agent mis-scopes a grant or re-litigates a priority;

• the why, so it can adapt when the situation deviates instead of blind-following;
• the scope/condition/expiry as the user framed it **AND whether that condition still

holds right now** — a "while I'm away" grant when the user is back must be carried with its scope and flagged likely-lapsed, never as a permanent grant (feedback_approval_requires_intent). Flattening a scoped grant to an unconditional one is the single most common fidelity failure — for every grant, state its live status, not just its original scope.

Elaborate enough to apply without re-deriving; terse enough to stay signal. (The reader is a fresh window, not a starved one — optimize for signal-density, not minimalism.)

• Ownership / role assignments — who owns, reviews, or is blocked on what; lane splits

and review-reversals agreed this session. A fresh agent that loses these re-collides with teammates.

• Error→fix pairs and open threads — what bit and how it was resolved, and what's still

in-flight, so the revived agent neither re-hits the wall nor re-opens settled ground.

Accuracy over completeness: state issue/MR/PR open-vs-closed status, commit tips, and "done/merged" claims only as the conversation actually established them — never overclaim closure or progress. A confidently-wrong status ("#73 is closed") is worse than an honest "open/unsure": it sends the revived agent down a path that no longer exists.

Do NOT carry (it is noise that re-bloats the window):

• Anything that auto-reloads at session start — CLAUDE.md, the MEMORY.md index,

SessionStart hooks. Trust them; don't restate them.

• Anything already on disk — point at the path instead.

Open the seed with a one-line revival instruction and an ordered "read these first" list so the revived agent rehydrates deterministically.

Final re-scan before you hand off. Re-read your draft seed against the conversation once more and (a) add any operating decision, open thread, or ownership assignment you dropped, and (b) verify every grant carries its live status, not just its original scope. This single pass is where the recall the first draft missed gets recovered — a state-focused seed under-captures on the first pass by construction, so the re-scan is not optional polish.

Step 2 — Write seed and arm the auto-revive hook

Always write to a durable path (not /tmp — reboot-wiped per lesson_tmp_identity_boot_wipe):

project_root=$(pwd)
seed_path="${project_root}/.claude/-reseed.md"

After writing the seed, arm the hook so the next /clear auto-revives without any user action:

project_root=$(pwd)
cat > "${project_root}/.claude/reseed-armed.json" -reseed.md",
  "armed_at": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
  "tmux_pane": "${TMUX_PANE:-}"
}
EOF

Step 3 — Trigger the clear

With the hook armed, trigger /clear immediately via tmux — do not ask the user to do it:

tmux send-keys -t "${TMUX_PANE}" "/clear" Enter

Then end your turn with a brief note:

> "Seed written and armed. Clearing now — I'll auto-revive and continue."

The SessionStart{clear} hook (reseed-revive.sh) fires on the fresh session, injects the seed content, and sends a continue keystroke. The agent revives and picks up where it left off — no user action needed.

If tmux is not available ($TMUX_PANE empty): fall back to the manual flow:

> "Seed written to `. Run /clear, then paste: Read and revive`."

Important

• Point at disk; carry only volatile state — the whole skill in one line.
• Carry the conversation-only decisions — grants, priorities, and rulings that

change how you operate and have no durable home; they're the thing a state-focused seed silently drops (see Step 1).

• Live status, not just scope — every grant must say whether its condition still

holds now; a scoped grant flattened to unconditional is the top fidelity failure. State issue/MR status only as the conversation established it, and re-scan once for dropped decisions before handing off. (Bench-validated: these lift recall+fidelity from ~0.87 to ~0.95 — reference_reseed_improvement_techniques.)

• A seed that duplicates a design doc or a memory file has failed its purpose:

it re-creates the bloat the reduction was meant to remove.

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: Wave-Engineering
• Source: Wave-Engineering/claudecode-workflow
• License: MIT

Install and usage instructions live in the source repository linked above.