impag
Implement a plan full-auto; never stop to ask.
SKILL.md.claude/skills/impag/SKILL.md
GitHub$ARGUMENTS — plan file path (default: most recent in docs/plans/).
Deep dives → ~/.claude/references/impag-deep-dives.md — abnormal conditions only (this body carries every normal-path directive): rationale, evidence, conditional modes. Read it SCOPED: grep -n '^## ', then Read only that section.
Process
Load plan — scoped. Stage docs: grep the
^##stage headers, Read only the target stage. Roadmap/menu files: grep the item. Never full-read either shape. Identify tasks + dependencies.- Target = the "Next action" pointer (§project_state); default = most-recent plan in
docs/plans/. A plan-file arg the user types beats the pointer (the pointer's plan stays queued). Aretro owed: <items>marker runs FIRST:/retroscoped to those items, clear the marker, then load. - The pointer wins on the target, not its facts. On resume, reconcile every live claim against its own falsifier / ground truth — not only the target you're advancing.
- Plan COMPLETE (or
Status:already CLOSED/SHIPPED) → archive it now per step 8a — a prior session's skipped archive is this session's first commit, not a finding to report — then pull remaining work from its Out-of-scope / Deferred / Nice-to-have sections and announce the pivot. No open work anywhere → stop and report state; never invent tasks. - No executable plan → author one, don't execute this session. Same when work is identified (design doc, roadmap, or a rung too vague to run) but lacks concrete focus files + committable boundaries (
Stage N.M). Don't execute vague work and don't stop — run the bounded plan-authoring pass: (a) recon viaExploreonly — a condensed brief enters the parent, never the subsystem; (b) dispatchPlanto author the staged plan from that brief, never synthesize it in the orchestrator — requiring a Refactor-first assessment unless its own skip test fires (say so if skipped), with the plan's last stage a full verify + live e2e + review; (c) write it to a newdocs/plans/file, back-linked from the vague rung in the same commit (→ plan: docs/plans/<name>.md) — that rung now belongs to the sub-plan; never re-plan or re-execute it. (→ deep-dives §Step 1 — plan-authoring pass.) A genuine refactor decision is USER-OWNED — persist the alternatives as a[USER DECISION]block, point Next-action at it, STOP without arming the chain. Otherwise commit the plan doc, arm the sentinel at Stage 1, update Next-action, STOP — execution runs in the fresh chained session. - Genuinely ambiguous target or scope → defer to
/qimpag, never guess; already under a/qimpagdirective → fold it into that run's questions round. An unfinished plan is NOT this case — resume it, never offer a which-phase-next fork. - Surface plan hedges before Stage 1, one line each (
[AUDIT],[likely cut], "may duplicate", "not sure whether"): "should X be resolved first, or proceed with the confident siblings?" A constant cited with no value is itself a hedge — assign one at plan time, or mark "pick a default; <named test> validates". - An UNRESOLVED refactor
[USER DECISION]gates Stage 1 — never execute past one, even with concrete stages below it; defer to/qimpag. It is the one marker impag halts on. Once RULED, the ruling supersedes the stage BODY — execute the ruling, treat the body as stale. (→ deep-dives §Step 1 — uncertainty markers.) - Never measure or trim a file the plan didn't name — no size gates, no file-size budget checks (4f's context check is a different thing and still runs), no ad-hoc
condense, and neverwc -ca doc or instruction file. Auto-memory is the one carve-out:project_state.md/roadmap.md/MEMORY.mdare content-pruned by their writer at the write — drop the delete classes, never measure. Trimming a file the plan does name IS the work —/de-bloatemits such plans; execute them. Memory writes are silent. Another file looks bloated → aroadmap.mdNTH, never the pointer. (→ deep-dives §Step 1 — never measure a file.)
- Target = the "Next action" pointer (§project_state); default = most-recent plan in
Evaluate plan size — count implementation tasks (exclude docs-only/meta).
- Never ask whether to defer remaining stages, and never pre-commit to a stopping boundary — execute in order and let step 4f's wrap-up limit decide; the sentinel +
project_state.mdpostpone the rest to a fresh chained session. (→ deep-dives §Step 2 — never ask to defer.) - One rule, any task count: execute straight through in plan order as far as the budget allows. Don't pick K up front — track the stage boundaries (all code compiles, tests pass, no half-wired interfaces) so a wrap-up stops at the most recent clean boundary, not mid-task. Announce the shape once (N tasks; chaining the remainder if the limit hits). (→ deep-dives §Step 2 — one rule, any task count.)
- At that stop, contribute remaining tasks + the continuation sentinel to
memory/project_state.md(§project_state). Same on a budget-cap abort mid-stage if another/impagshould resume the stage.
- Never ask whether to defer remaining stages, and never pre-commit to a stopping boundary — execute in order and let step 4f's wrap-up limit decide; the sentinel +
Execute tasks — in plan order.
- Hard guard — execute HERE, never recon-and-defer. With an executable plan present you WRITE CODE this session; the recon → bank-notes → hand-off pattern is FORBIDDEN unless the launch prompt literally contains the word "eyeball". Recon is bounded grep + narrow window, then immediate edit. The legitimate stops are exactly five: (1) a step-4f wrap-up with committed code; (2) a
[USER DECISION]/plan-hedge gate (step 1); (3) step 1's plan-authoring pass (commits a plan doc, zero code); (4) an out-of-scope/ownership escalation (4b); (5) the same-issue-twice escalation (steps 5/7). Outside those five, zero committed file edits on an executable code plan is a defect. (→ deep-dives §Step 3 — the five legitimate stops.) - The dispatch unit is the STAGE, never an individual task. Triage the stage once against the gate below and state the choice in one line. An inline stage edits directly in the orchestrator; a delegating stage sizes each dispatch to ONE committable slice (
Stage N.M), never the whole multi-slice stage. When a stage needs whole-stage context, add "if budget runs tight, finish slice 1 completely and return a precise delta-handoff" — re-feed that to a fresh executor, never re-recon in the parent. A design-only subagent that exhausts budget before coding returns a VALID delta-handoff, not a failure. Task-level dispatch survives only as clause (b). - Stay where you were launched: do not create or switch branches; never create, switch into, or relocate to a git worktree, and never
cd— subagents work on the current tree. (→ deep-dives §Step 3 — stay where you were launched.) - Delegation gate — the READ is the cost, not the edit. Dispatch a subagent to do the stage's recon+edit in its own context (it returns a compact report) when ≥1 holds:
(a) grounding the stage needs the full bodies of ≥2 unheld large files (≥
800 lines each —300 lines)** — a 300–800-line file also edits inline, via Grep + windowed reads, never a full Read. Gate (a) outranks all three. A multi-file edit does NOT earn a direct pass — count large unheld READS, not files to edit. (→ deep-dives §Step 3 — delegate only when it pays.)rules/reading-large-files.md), or ONE big throwaway acquisition — one large unheld file alone does NOT fire it (Grep + offset windows inline); (b) tasks run in parallel with genuinely independent siblings (disjoint files, no shared state) — the one task-level dispatch; (c) it's review/verification wanting independent context (step 6); (d) it's recon informing plan-WRITING —Explorereturns a condensed brief; only the brief enters the parent (holds even when the orchestrator writes the plan itself); (e) context is already heavy (past the 4f zone) AND the task opens fresh territory. Inline recon is correct in ONLY three cases — outside them, delegate: (i) the file is already in the parent's context (Read this session); (ii) recon is bounded (pick-and-test, §Rules); (iii) the file you're editing is **short (< - Parallel exception: parallelize adjacent tasks only when independence is obvious without reading code (different dirs; one adds a new file while another modifies unrelated code; the plan says "parallel"). Serialize otherwise. Cross-file consistency check after parallel work →
~/.claude/references/subagent-dispatch.md§Parallelization discipline. - Research-style plans (web/analysis/docs, no code) use a different dispatch and commit a doc, not code → deep-dives §Step 3 — research-style plans.
- When the gate says delegate, brief the subagent: implement Stage N from [plan]; self-verify with the repo's targeted tests + its type-checker covering the change (name the commands in the brief); do NOT commit; touch only the stage's focus files (+ related imports/tests); and return a compact report AS YOUR FINAL MESSAGE (wait for the self-verify): pass/fail with the exact test command + green summary line (never the full log or a pasted diff), ALL files touched, and any issues. The orchestrator reads scope from
git status --short+ that files-touched list. When the gate says direct, edit in the orchestrator and self-verify the same way. Pre-resolve, then bound: resolve every command/probe/URL the brief names BEFORE dispatch (one grep in the parent) and pass it verbatim — if it fails, the subagent reports and stops that item, never searches for alternatives. Every test/gate/probe command in a brief runs as… 2>&1 | tail -20; on failure, re-run only the failing file. Verify-only briefs →~/.claude/references/subagent-dispatch.md§Verify-agent briefs. Every brief that AUTHORS or CHANGES assertions carries this clause verbatim (verify/measure-only briefs omit it) — a reference the orchestrator has read does NOT reach a subagent: "Any falsifier/grep/confirmer you author must be ABLE to fail (a confirmer likewise to ESTABLISH) — run it file-wide, exclude comment lines, never ship one vacuous by construction (a TS symbol in.sql) or indicting its own docblock. This binds TEST ASSERTIONS too: a new/changed assertion owes a red demo — mutate the exact line it guards, confirm the failure, then RESTORE it by re-typing (nevergit checkout -- <file>— it destroys the uncommitted work) — before calling the stage verified. A red demo lives in the WORKING TREE only: never commit the mutated state (a broken SHA on main = bisect landmine); record the failing output in the commit message."
- Hard guard — execute HERE, never recon-and-defer. With an executable plan present you WRITE CODE this session; the recon → bank-notes → hand-off pattern is FORBIDDEN unless the launch prompt literally contains the word "eyeball". Recon is bounded grep + narrow window, then immediate edit. The legitimate stops are exactly five: (1) a step-4f wrap-up with committed code; (2) a
After each task — the orchestrator scope-checks and commits; the heavy verify batches at the stage boundary (step 6): a. Run
git status --short— notgit diff. b. Check changed files (status + the subagent's files-touched list) against expected scope; revert out-of-scope files — first check they aren't user edits from another window; unsure → ask. For dispatched work whose report didn't name the behavior its tests asserted, also skimgit diffof the in-scope focus file(s) only. Direct edits skip this. c. Per task, do NOT re-run the suite in the orchestrator — trust the self-verify (the subagent's, or your own for a direct edit: targeted tests + the repo's type-checker; summary line on green, full output only on failure). The full suite + repo-wide type-check run ONCE at the stage boundary (step 6). These instruments cannot see a MEASURED CLAIM. When the deliverable is prose about a number (a docblock table, a plan finding, a commit-message measurement), dispatch a claim-check before committing (Haiku,general-purpose) holding ONLY (i) the probe's raw output and (ii) the authored prose — never the plan, the intent, or the rung's narrative — asked one question: does every sentence name the exact quantity the probe computed — which arm, which denominator, which window — and can each guard or pin it cites actually fail? Fix what it returns, then commit. (→ deep-dives §Step 4 — the measured-claim check.) d. Commit with a message listing the completed task. Do NOT writememory/project_state.mdper task — the commit log is the per-task record. e. Mark the task done only after the commit succeeds. f. Wrap-up check — budget OR turn count; run it after every commit. Wrap up when either trips: a context-budget warning (200k+ tokens), or this stage boundary is being reached past ~40 turns (or context simply feels heavy). A stage boundary past ~40 turns IS a session boundary — finish the current task, commit, and do NOT start the next stage. Wrapping up = write the remaining rungs plus the rulings already made this session back into the plan doc in this turn's commit burst (it is the handoff state), contribute the remaining tasks to the project_state burst (do NOTWritehere — the turn's single write fires at its last contributing step, §project_state), then jump to step 6. The stage still owes steps 6–9; resume re-runs from Step 1, idempotent. (→ deep-dives §Step 4f — the ~40-turn session boundary.)Failed task — direct-edit: fix inline (you hold the context). Dispatched subagent returning errors: do NOT fix manually — dispatch a fresh fix subagent with the error details. Either path failing twice on the same issue → ask user.
Final review — the stage-boundary quality gate. First run the repo's own full suite + its type-checker (the batch deferred from 4c) in the orchestrator as background Bash piped through
tail -15— never inside a verify subagent: read the command fromCLAUDE.md— never assume a stack (make test-batsin dotfiles;pytest tests/ -q+ repo-widepyrightwhen Python). A repo with no type-checker skips that half; never invent a gate the repo doesn't have. Then dispatch thecode-reviewersubagent over theBASE_SHA..HEAD_SHArange covering all changes.- Brief it compactly: the plan path + the 3–5 concrete verification targets (the risky seams/invariants this stage touched). Do NOT restate or paste the diff — the reviewer reads it via
git show BASE_SHA..HEAD_SHA.code-reviewernot registered → don't silently degrade → deep-dives §Step 6 — code-reviewer fallback. - Plan-scheduled review wins: a wrap-up before a plan's own scheduled final-stage review SKIPS the session review — record the deferral + range in project_state, and RE-MEASURE the range to the plan's OWN commits before dispatch → deep-dives §Step 6 — deferred plan-scheduled review.
- End the turn on the dispatch: a ≤2-line status (what's under review + the range), then stop — no stage recap while review is in flight; the summary is step 8's single block, after the fixes land.
- Brief it compactly: the plan path + the 3–5 concrete verification targets (the risky seams/invariants this stage touched). Do NOT restate or paste the diff — the reviewer reads it via
Fix review issues — auto-fix Critical/Important by dispatching fix subagent(s) immediately, then re-verify. Ask user only if a fix fails twice on the same issue.
- Stage-done timing: the stage is done when review fixes are committed and re-verified, NOT when the last task's commit lands. Only then contribute "Stage N complete" to project_state (the in-flight stage's resume payload only — deleted, not extended, once the next stage lands or the plan parks). Only Nice-to-have findings → done as-is, and the findings are then DROPPED — the review report and the commit message are their record. Filing one is the default defect, not the default move: you have already ruled it not worth doing, so its backlog entry's only drain (the commit that ships it) is the event that by construction never fires. It files as a follow-up ONLY if it is a defect CLASS you grepped file-wide (CLAUDE.md §Code review) or the user asked for it — "would be nicer", "add a pin", "tighten this", "unreachable today" file nowhere.
- Continuation sentinel (before Step 8): unexecuted automatable stages remain → append the sentinel per §project_state. Do NOT emit it when the only remaining work is blocked on a user decision — state "chain not re-armed — USER DECISION owed on X" in the Next-action line instead.
Finish the branch.
- 8a. Archive gate — BEFORE the status block, unconditionally, on every finishing turn. One question: is the target plan still LIVE? It is not live when every stage is committed on
mainwith only a USER-owed manual/eye/live confirm left, or when it closed without shipping (refuted, abandoned, measured-dead). Not live ⇒ in this turn's commit burst: flip theStatus:header (✅ SHIPPED/CLOSED WITHOUT SHIPPING),git mvthe doc intodocs/plans/archive/, pathspec BOTH halves of the rename, move any leftover user confirm to roadmap§OWED[USER]. Mechanism → the project's.claude/rules/plan-hygiene.md. Archiving is never a question, an offer, or a tier-2Needs you:line, and never a▶ Archive the plan docnote inproject_state.md— report it in one tier-3 clause, past tense, or not at all. An archived plan also stops being the Next-action target: repoint, or write "no open work". (→ deep-dives §Step 8 — archiving is mechanical.) - 8b. Status block — ONE block, never a per-task re-narration (the commit log records that), in three tiers: tier 1 one bold TL;DR sentence · tier 2
Needs you:— ≤3 bare imperatives actionable TODAY,<Verb> <object>, and omitting every line but the push is the common correct outcome · tier 3 — ≤3 bullets total, one per theme, NOT per change, file, or commit. AnyNeeds you:line other than the push is mirrored into memory the same turn. Both tiers' admission tests + the mirror routing → deep-dives §Step 8b — the two tier admission tests. - On a permanent integration branch (
dev/develop, or CLAUDE.md-flagged): SKIPfinishing-a-development-branch(merge+delete forbidden, tests already ran) — report branch, commits ahead ofmain, tests; discard → the user typesdiscardnext turn. On a disposable topic branch (feat/*): invoke it. Either way the push is a tier-2 imperative (Push <branch> from the host), never a hedged tier-3 note — and it is the one tier-2 line never mirrored into project_state. - Prune fully-merged branches as part of finishing: any branch merged into the integration branch (
git merge-base --is-ancestor <branch> <integration>true) →git branch -d <branch>(safe form; git refuses if unmerged). Never a permanent dev branch (main/dev/developor CLAUDE.md-flagged), even when merged. Delete the remote counterpart (git push origin --delete <branch>) only where push works (the host, not a devcontainer); otherwise list the stale remotes for the user. - Continue to step 9 in the same response; don't end the turn.
- 8a. Archive gate — BEFORE the status block, unconditionally, on every finishing turn. One question: is the target plan still LIVE? It is not live when every stage is committed on
Retrospective — capture-gated + budget-deferred.
/retroruns ONLY when a concrete capture item exists (a durable gotcha, a user correction, a superseded doc claim) whose class isn't already recorded — grep its destination first. Stage completion alone never triggers it; with no item sayretro skipped — no capture itemsso the skip is visible. ZERO items is the NORMAL outcome.- Never run it past the 4f zone (200k+): record
retro owed: <items>in the "Next action" line and end — the chained session runs it at step 1's small prefix. A marker is a POINTER — ≤1 line, no evidence, no routing prose. An item may enter it only if it is already stateable in one sentence WITH its destination doc named; that sentence IS the entire discharge payload. An item you cannot state that way has not cleared the admission test — drop it, never park it. Prefer writing the one-liner to its home in the wrap-up burst and setting no marker. (→ deep-dives §Step 9 — the retro marker's admission test.) - Within budget with items in hand: invoke after step 8 in the same turn, at the main conversation level (Skill tool), NOT as a subagent — retro needs full session context. Don't narrate the 7→8→9 transitions.
- Never run it past the 4f zone (200k+): record
project_state
memory/project_state.md — the auto-memory file at ~/.claude/projects/<cwd-slug>/memory/, never a memory/ dir in the project tree — is impag's live pointer and the contract impag-chain reads to re-fire. Role + reconcile/routing model are canonical in ~/.claude/references/memory-system.md §Rolling state (+ §Roles table). impag's every-run directives:
- ONE
Writeper turn, assembled — steps CONTRIBUTE lines, they don't each write. Step 1 (arm + Next-action), step 2 (remaining tasks at a stop), step 4f (wrap-up), step 7 (stage-done + sentinel), step 8 (mirroredNeeds you:imperatives), step 9 (retro owed:marker) hand lines to one burst; the singleWritefires at the last contributing step of the turn. A wrap-up running 4f→6→7→8→9 is still ONE write. - Admission test — a line enters ONLY if it is OPEN or OWED, the next session is wrong without it, and no cheaper source has it. ≤200 chars per item, no evidence, no rationale, never a paragraph — if it needs a paragraph it needs a doc, and the line here is that doc's name. (→ deep-dives §project_state — the admission test's exclusion lists.)
- The test re-applies on carry-forward — re-test each old line and drop the delete classes (
memory-system.md §Rolling state), the file's own header/guardrail prose included. (→ deep-dives §project_state — why the admission test re-applies on carry-forward.) - Holds ONLY the "Next action" pointer, chain/sentinel state, and active-task essentials — never a "SHIPPED X" log (the in-flight stage's completed list is the one exception). Everything else routes per §Rolling state: menus/evidence → roadmap, durable gotchas → retro Step 3b, a blocked graduation target parks in
roadmap.md, never here. - Re-read
project_state.mdimmediately before the wrap-up Write; on a modified-since-read trip, MERGE (re-point the live sentinel/Next-action) — never force-overwrite a parallel sibling session's burst. - At the write emit the whole burst: ONE in-flight "Next action" (other selectable ▶ work → the roadmap menu), remaining tasks as
plan/spec §Npointers + only deltas no git-tracked doc records, and (when chaining) the sentinel. Rewrite stale pointer prose so it never describes an earlier stage. - Mechanism vs content are not the same rule. Mechanism: re-read → merge → ONE full-body
Write, never Edit-appends. Content: the completed list is the in-flight stage's resume payload, while the Next-action pointer and chain/sentinel state are rewritten every burst. No size check — the file has no cap (memory-system.md §No size caps). Route before you write (armed state here · selectable/gated work + OWED → roadmap · evidence/rationale → the plan doc, named here in ≤1 line), and drop the delete classes from the merged body, carried-forward lines included. (mechanics → deep-dives §project_state — full mechanics.) - Live claims carry their falsifier. Reconcile only what you're advancing plus any falsifier already in hand — never a fresh sweep over every live claim at the wrap-up prefix. That bound limits falsifier RUNS, never deletions: the delete classes sweep the whole file at every write, falsifier-free — and step 1's resume read is the deep sweep (small prefix, whole file, items you are not advancing included).
- Terminal write — pointer-only. Plan fully COMPLETE, no chain armed, no automatable work left ⇒ do NOT persist the completed-task recap (git-derivable). Write the live pointer alone: the "Next action" line (user-owed items, or "no open work") plus the one-line roadmap pointer.
Continuation sentinel. To chain the next stage to a fresh session, append this verbatim sentinel on its own line — a machine-read contract with impag-chain; paraphrase or markdown formatting breaks unattended chained runs. Re-emit it on every stage that should chain forward (the driver consumes it after each detection); updating the "Next action" prose is not a substitute:
<!-- impag-chain-next-stage -->
"Chain ARMED" is a CLAIM — grep it in the SAME burst as the prose asserting it, with the driver's OWN path + regex (impag-chain §slug/$mem + its sentinel greps) — a project-relative memory/project_state.md never resolves, so the check can never ESTABLISH:
slug="${PWD//\//-}"; slug="${slug//./-}" # BOTH substitutions — a `claude --worktree` cwd has a dot
mem="$HOME/.claude/projects/${slug}/memory/project_state.md"
grep -qE '^<!-- impag-chain-next-stage(: [1-9][0-9]*)? -->$' "$mem"
(the : N suffix is the legacy form the driver still honors — match it, but always EMIT the no-suffix form above.) An absent sentinel fails silently (→ deep-dives §project_state — full mechanics).
Rules
- Sub-agent model routing — concrete pins live in
.claude/agents/*.mdfrontmatter, never here: subagents run at their pinned defaults; read-onlyExplore/search fan-out is pinned Haiku/low— push every bounded find/grep/locate there (the only downshift tier). Setmodel:only when it must differ from the pin (it overrides the pin, keeps the pinned effort);sonnetstays retired. - Thin-orchestrator on long chains: past the 4f zone with stages still queued, the orchestrator holds NO file bodies — it dispatches, scope-gates from the files-touched report, commits, and gates; all reading/editing lives in subagents returning compact reports (gate (e) at its limit). Below that threshold direct-edit-default still wins. (→ deep-dives §Rules — thin orchestrator + late-session recon.)
- Background agents auto-notify — don't babysit them: after dispatching one (e.g. the step-6 code-reviewer), end the turn and wait for the completion notification — no polling, no status pokes (→
~/.claude/references/subagent-dispatch.md§Background agents auto-notify — don't poll). - A late human-input pause is a stop, not a wait. Past the 4f zone, end the turn instead of holding a warm prefix open: write the question into project_state's "Next action" if it gates the armed item (otherwise roadmap
§OWED[USER]), leave the chain un-armed, let the answer land in a fresh session. Ask inline only when the user spoke this turn and the answer unblocks a task in flight. (cost math → deep-dives §Rules — late human-input pause.) - Late-session recon discipline: recon whose only deliverable is a roadmap note or a pass/fail verdict → delegate to
Exploreor defer; never inline at peak context. A plan-contract (qimpag questions, an addendum's anchors) needs a brief, not the subsystem. Gauge budget BEFORE deep-reading a next stage's files; prefer chaining. Reconned anyway → bank the design into the plan doc / its addendum, never as rationale inproject_state, which admits only the doc's name. (→ deep-dives §Step 3 — execution recon needs the same bound.) - Bound execution recon — pick-and-test over prove-by-hand: confirming a plan-cited symbol/file is one grep + a ~20–40-line window around the anchor — then START editing; let tests adjudicate, not a manual multi-file derivation. An underdetermined value → pick the plan's stated default and let the test decide, but sanity-bound a one-sided-verifiable constant (a too-large padding/lookback passes its test silently). A constant cited with no value at all is a plan gap — surface it at step 1, don't silently derive it inline.
- Per-stage plan files — a new file only when a session that is NOT executing the stage would otherwise re-read its plan. Absent that reader the stage needs no file at all; an unconditional one-file-per-stage rule manufactures files by construction. When a file IS warranted, never append the stage to a growing design doc (later sessions re-read every prior stage) — write it as its own
docs/plans/file (iteration specs too →~/.claude/references/iterative-spec-loop.md§Doc mechanics). - Numeric ecosystem constants in a plan (cache TTLs, autocompact thresholds, timeouts, retention counts) → web-verify before shipping (
~/.claude/references/pre-ship-sweeps.md§External-ecosystem constants — verify before shipping).