cclaw-cli 0.49.0 → 0.51.1

package/dist/content/learnings.js

@@ -1,5 +1,5 @@
 // ---------------------------------------------------------------------------
-// Knowledge store content for /cc-learn and stage self-improvement prompts.
+// Knowledge store content for the learnings skill and stage self-improvement prompts.
 //
 // The knowledge store is a single canonical JSONL file. Each line is one
 // self-contained JSON object matching the strict schema in this module.
@@ -11,8 +11,8 @@ const LEARN_SKILL_NAME = "learnings";
 const LEARN_SKILL_DESCRIPTION = "Project-scoped knowledge store: append and query rule/pattern/lesson/compound entries in the canonical JSONL file at .cclaw/knowledge.jsonl. Strict schema, append-only, machine-queryable.";
 /**
  * Canonical required JSONL field order (matches strict validator keys).
- * Optional keys (for now: `source`, `severity`) may be appended after these
- * required fields.
+ * Optional keys (`source`, `severity`, `supersedes`, `superseded_by`) may
+ * be appended after these required fields.
  * Exported for tests and any programmatic writer that wants a stable base shape.
  */
 export const KNOWLEDGE_JSONL_FIELDS = [
@@ -23,7 +23,7 @@ export const KNOWLEDGE_JSONL_FIELDS = [
     "domain",
     "stage",
     "origin_stage",
-    "origin_feature",
+    "origin_run",
     "frequency",
     "universality",
     "maturity",
@@ -49,7 +49,7 @@ Use the store to keep durable knowledge that should survive sessions:
 - **rule**: hard constraint to follow every time.
 - **pattern**: repeatable way that works well in this project.
 - **lesson**: non-obvious outcome from a failure or trade-off.
-- **compound**: post-ship insight about how to make the *next* feature faster (process accelerator, not domain rule).
+- **compound**: post-ship insight about how to make the *next* run faster (process accelerator, not domain rule).
 
 ## Continuous capture (stage closeout path)
 
@@ -63,22 +63,25 @@ Knowledge capture is now stage-native:
   2. appends deduped entries to \`${KNOWLEDGE_PATH}\`,
   3. writes a harvest marker into the artifact.
 
-\`/cc-learn\` remains the manual/query surface (search, backfill, curation).
+Manual/query operations (search, backfill, curation) use this skill when the
+user asks for knowledge work. If a stage artifact contains JSON learnings but
+\`${KNOWLEDGE_PATH}\` did not change, the missing step is almost always running
+\`node .cclaw/hooks/stage-complete.mjs <stage>\` successfully.
 
 ## HARD-GATE
 
-Under \`/cc-learn\`, only modify \`${KNOWLEDGE_PATH}\`, \`${KNOWLEDGE_ARCHIVE_PATH}\`,
+During manual knowledge operations, only modify \`${KNOWLEDGE_PATH}\`, \`${KNOWLEDGE_ARCHIVE_PATH}\`,
 or an explicitly user-approved summary file. Do not modify application code here.
 Do not invent alternate stores (no markdown mirror, no SQLite, no per-stage files).
 
 ## Entry format — strict JSONL schema
 
 Exactly one JSON object per line. Required fields must appear in the order:
-\`type, trigger, action, confidence, domain, stage, origin_stage, origin_feature, frequency, universality, maturity, created, first_seen_ts, last_seen_ts, project\`.
+\`type, trigger, action, confidence, domain, stage, origin_stage, origin_run, frequency, universality, maturity, created, first_seen_ts, last_seen_ts, project\`.
 Optional fields \`source\` and \`severity\` may be appended after \`project\`.
 
 \`\`\`json
-{"type":"pattern","trigger":"when reviewing external payloads","action":"parse through zod before touching service layer","confidence":"high","domain":"api","stage":"review","origin_stage":"review","origin_feature":"payload-hardening","frequency":1,"universality":"project","maturity":"raw","created":"2026-04-14T12:00:00Z","first_seen_ts":"2026-04-14T12:00:00Z","last_seen_ts":"2026-04-14T12:00:00Z","project":"cclaw"}
+{"type":"pattern","trigger":"when reviewing external payloads","action":"parse through zod before touching service layer","confidence":"high","domain":"api","stage":"review","origin_stage":"review","origin_run":"payload-hardening","frequency":1,"universality":"project","maturity":"raw","created":"2026-04-14T12:00:00Z","first_seen_ts":"2026-04-14T12:00:00Z","last_seen_ts":"2026-04-14T12:00:00Z","project":"cclaw"}
 \`\`\`
 
 | field | type | required | notes |
@@ -90,7 +93,7 @@ Optional fields \`source\` and \`severity\` may be appended after \`project\`.
 | \`domain\` | string \\| null | yes | Free-form taxonomy (\`api\`, \`infra\`, \`ui\`, \`security\`, \`testing\`, …). Use \`null\` when cross-cutting. |
 | \`stage\` | \`FlowStage\` \\| null | yes | One of brainstorm / scope / design / spec / plan / tdd / review / ship, or \`null\` when cross-stage. |
 | \`origin_stage\` | \`FlowStage\` \\| null | yes | Stage where this learning was first observed. |
-| \`origin_feature\` | string \\| null | yes | Feature/worktree label where it was observed first. |
+| \`origin_run\` | string \\| null | yes | Optional run, branch, or topic label where it was observed first. |
 | \`frequency\` | integer >= 1 | yes | Number of times this same trigger/action pair has been observed. |
 | \`universality\` | \`"project" \\| "personal" \\| "universal"\` | yes | Scope of applicability. |
 | \`maturity\` | \`"raw" \\| "lifted-to-rule" \\| "lifted-to-enforcement"\` | yes | Lifecycle state of the learning. |
@@ -99,7 +102,7 @@ Optional fields \`source\` and \`severity\` may be appended after \`project\`.
 | \`last_seen_ts\` | ISO 8601 UTC string | yes | Last re-confirmed timestamp. |
 | \`project\` | string \\| null | yes | Repo or scope name. Use \`null\` when the entry crosses projects. |
 | \`source\` | \`"stage" \\| "retro" \\| "compound" \\| "ideate" \\| "manual" \\| null\` | no | Origin channel for the entry when known. |
-| \`severity\` | \`"critical" \\| "important" \\| "suggestion"\` | no | Priority signal for compound lifts; \`critical\` enables single-hit override in \`/cc-ops compound\`. |
+| \`severity\` | \`"critical" \\| "important" \\| "suggestion"\` | no | Priority signal for compound lifts; \`critical\` enables single-hit override in compound readiness analysis. |
 
 Rules:
 - No other fields beyond the table above. Extra keys are forbidden and MUST be rejected by any writer.
@@ -111,68 +114,41 @@ Rules:
 ## Curation policy (target: ≤ 50 active entries)
 
 - The file is append-only — entries are never physically deleted.
-- When the canonical file exceeds 50 lines, \`/cc-learn curate\` proposes
+- When the canonical file exceeds 50 lines, a curation pass proposes
   soft-archiving: the approved lines are **moved** to \`${KNOWLEDGE_ARCHIVE_PATH}\`
   verbatim (same JSONL shape). The working file stays lean.
-- See the **knowledge-curation** utility skill for the full curation protocol.
+- Use the **Curate** action below for the full read-only audit and
+  user-approved soft-archive plan.
 
-## Subcommands
+## Manual Actions
 
-### \`/cc-learn\` (default)
+### Show recent entries
 - Read \`${KNOWLEDGE_PATH}\`. Stream the last 30 lines; pretty-print each
   line's \`type\` / \`trigger\` / \`action\` for human review.
-- If file is missing or empty, report that clearly and suggest \`/cc-learn add\`.
+- If file is missing or empty, report that clearly and suggest adding a
+  manual entry through this skill.
 
-### \`/cc-learn search <query>\`
+### Search \`<query>\`
 - Stream \`${KNOWLEDGE_PATH}\`, JSON.parse each line, filter where any of
   \`trigger\`, \`action\`, \`domain\`, \`project\` contains \`<query>\` (case-insensitive).
 - Return the matched lines pretty-printed (do not mutate the file).
 
-### \`/cc-learn add\`
+### Add
 - Ask for required user-facing fields in order: \`type\`, \`trigger\`, \`action\`, \`confidence\`, \`domain\`, \`stage\`, \`universality\`, \`project\`.
 - \`confidence\` must be one of \`high\`, \`medium\`, \`low\`. Default to \`medium\` if the user declines to set it.
 - \`domain\`, \`stage\`, and \`project\` may be explicitly \`null\`.
 - Prefer stage-native \`## Learnings\` capture for new flow work; use \`add\` mainly for backfilling historical lessons or ad-hoc entries outside a stage closeout.
-- \`origin_stage\` defaults to \`stage\`; \`origin_feature\` defaults to active feature (or \`null\` if unknown).
+- \`origin_stage\` defaults to \`stage\`; \`origin_run\` defaults to the current run, branch, or topic label (or \`null\` if unknown).
 - \`frequency\` starts at \`1\`.
 - \`maturity\` starts at \`raw\`.
 - \`created\`, \`first_seen_ts\`, and \`last_seen_ts\` are set automatically to current UTC ISO timestamp.
 - Append exactly one JSON line to \`${KNOWLEDGE_PATH}\` with the field order from the schema table above.
 - Re-read the file tail to confirm the new line is valid JSON and parses back to the same object.
 
-### \`/cc-learn curate\`
-- Hand off to the **knowledge-curation** skill (read-only audit + soft-archive plan).
+### Curate
+- Produce a read-only audit + soft-archive plan.
 - Never deletes. Soft-archive means **moving** full JSON lines from
   \`${KNOWLEDGE_PATH}\` to \`${KNOWLEDGE_ARCHIVE_PATH}\` as part of a
   user-approved curation pass.
 `;
 }
-export function learnCommandContract() {
-    return `# /cc-learn
-
-## Purpose
-
-Manage the project knowledge store. One canonical file, strict JSONL:
-- \`${KNOWLEDGE_PATH}\` — append-only JSONL, one entry per line.
-- \`${KNOWLEDGE_ARCHIVE_PATH}\` — soft-archive target written only by curate.
-
-Stage-native pipeline:
-- During \`stage-complete.mjs\`, cclaw harvests \`## Learnings\` from the current
-  stage artifact into \`${KNOWLEDGE_PATH}\` automatically.
-- Use \`/cc-learn\` for query, backfill, and curation workflows.
-
-## HARD-GATE
-
-Do not edit source code from this command. Only operate on \`${KNOWLEDGE_PATH}\`,
-\`${KNOWLEDGE_ARCHIVE_PATH}\`, or user-approved summary output.
-
-## Subcommands
-
-| subcommand | args | description |
-|---|---|---|
-| (default) | — | Show recent knowledge entries (tail of JSONL, pretty-printed). |
-| \`search\` | \`<query>\` | Stream-filter the JSONL for matching \`trigger\`, \`action\`, \`domain\`, \`project\`. |
-| \`add\` | — | Append one JSON line (\`rule\` / \`pattern\` / \`lesson\` / \`compound\`) with the strict JSONL schema (15 required fields + optional \`source\` / \`severity\`). |
-| \`curate\` | — | Hand off to the **knowledge-curation** skill: read-only audit + soft-archive plan when the file exceeds the curation threshold. |
-`;
-}

package/dist/content/meta-skill.js

@@ -1,10 +1,10 @@
-import { FLOW_MAP_REL_PATH } from "./flow-map.js";
-import { COMPLETION_PROTOCOL_REL_PATH, DECISION_PROTOCOL_REL_PATH, ETHOS_PROTOCOL_REL_PATH } from "./protocols.js";
+import { conversationLanguagePolicyMarkdown } from "./language-policy.js";
+import { CLOSEOUT_CHAIN, closeoutChainInline, closeoutFlowMapSentence, closeoutProtocolBehaviorSentence } from "./closeout-guidance.js";
 export const META_SKILL_NAME = "using-cclaw";
 export function usingCclawSkillMarkdown() {
     return `---
 name: using-cclaw
-description: "Routing brain for cclaw. Decide whether to start/resume a stage, answer directly, or use utility commands like /cc-learn, /cc-ideate, /cc-view, and /cc-ops."
+description: "Routing brain for cclaw. Decide whether to start/resume a stage, answer directly, or use visible commands like /cc, /cc-next, /cc-ideate, and /cc-view."
 ---
 
 # Using Cclaw
@@ -19,6 +19,7 @@ description: "Routing brain for cclaw. Decide whether to start/resume a stage, a
 
 If the user explicitly overrides a stage rule, record it in the artifact.
 
+${conversationLanguagePolicyMarkdown()}
 ## Skill-before-response gate
 
 If \`.cclaw/state/flow-state.json\` exists and \`currentStage\` is set,
@@ -58,9 +59,10 @@ Task arrives
   ├─ New software work? -> /cc <idea>
   ├─ Repo-improvement discovery? -> /cc-ideate
   ├─ Resume existing flow? -> /cc or /cc-next
-  ├─ Knowledge operation? -> /cc-learn
+  ├─ Knowledge operation? -> load the learnings skill
   ├─ Read-only workspace view? -> /cc-view [status|tree|diff]
-  └─ Workspace operation? -> /cc-ops [feature|tdd-log|retro|compound|archive|rewind]
+  ├─ Normal post-ship closeout? -> /cc-next drives ${closeoutChainInline()}
+  └─ Explicit early archival/reset? -> npx cclaw-cli archive [--name=<slug>]
 \`\`\`
 
 ## Task classification
@@ -84,35 +86,44 @@ Before stage work:
 ## Platform reliability notes
 
 - Managed hook dispatch uses \`.cclaw/hooks/run-hook.cmd\` (cross-platform wrapper).
-- If hooks fail due missing runtime deps (for example \`node\` not on \`PATH\`), run \`cclaw doctor\` before continuing.
+- If hooks fail due missing runtime deps (for example \`node\` not on \`PATH\`), run \`npx cclaw-cli doctor\` before continuing.
 - Prefer cross-platform commands in artifacts/examples (\`npm test\`, \`pnpm test\`, \`python -m pytest\`, etc.) over shell-specific aliases whenever possible.
 
 ## Stage quick map
 
-brainstorm -> scope -> design -> spec -> plan -> tdd -> review -> ship
+Use \`/cc <idea>\` for new work, \`/cc-next\` for progression and closeout, \`/cc-view\` for read-only state, and \`/cc-ideate\` for backlog discovery.
 
-Tracks may skip stages via \`flow-state.track\` + \`skippedStages\`.
-For the full surface (stages, routers, Ralph Loop, state files) load
-\`${FLOW_MAP_REL_PATH}\` — it is the single-page overview of cclaw.
+## Main vs Operator Surfaces
 
-## Contextual skill activation
+- **Main workflow:** \`/cc\`, \`/cc-next\`, \`/cc-ideate\`, \`/cc-view status\`, and \`node .cclaw/hooks/stage-complete.mjs <stage>\` inside the installed harness runtime.
+- **Installer/support surface:** \`npx cclaw-cli init\`, \`npx cclaw-cli sync\`, \`npx cclaw-cli upgrade\`, \`npx cclaw-cli doctor\`, and explicit support/archive actions. Do not ask users to install or run a \`cclaw\` binary during normal stage flow.
+- **Read-only support:** \`/cc-view tree\` and \`/cc-view diff\`.
+- Use operator/support surfaces only for install/runtime diagnosis, explicit archival, or deeper inspection. Do not make them part of the happy path.
 
-Load utility skills only when triggered by the current task:
+## Whole flow map
 
-- security, performance, debugging, docs, ci-cd
-- verification-before-completion before completion claims
-- finishing-a-development-branch during ship/finalization
-- document-review, receiving-code-review, and execution context skills
+standard: brainstorm -> scope -> design -> spec -> plan -> tdd -> review -> ship -> ${CLOSEOUT_CHAIN}
+medium: brainstorm -> spec -> plan -> tdd -> review -> ship -> ${CLOSEOUT_CHAIN}
+quick: spec -> tdd -> review -> ship -> ${CLOSEOUT_CHAIN}
+
+${closeoutFlowMapSentence()}
+
+Tracks may skip critical-path stages via \`flow-state.track\` + \`skippedStages\`.
+Use the current stage skill plus \`.cclaw/state/flow-state.json\` for orientation.
+
+## Contextual Skill Activation
+
+Use built-in judgment only when triggered by the current task:
+
+- security, performance, debugging, docs, and CI/CD review lenses
+- verification discipline before completion claims
+- branch-finishing discipline during ship/finalization
 - iron-laws as policy arbitration when instructions conflict
 - language rule packs from \`.cclaw/config.yaml\` when enabled
 
-## Protocol references
-
-Do not inline these protocols in stage skills; cite by path:
+## Protocol Behavior
 
-- Decision protocol: \`${DECISION_PROTOCOL_REL_PATH}\`
-- Completion/resume protocol: \`${COMPLETION_PROTOCOL_REL_PATH}\`
-- Engineering ethos + announce discipline: \`${ETHOS_PROTOCOL_REL_PATH}\`
+${closeoutProtocolBehaviorSentence()}
 
 ## Knowledge guidance
 

package/dist/content/next-command.js

@@ -1,6 +1,7 @@
 import { RUNTIME_ROOT } from "../constants.js";
-import { FLOW_MAP_REL_PATH } from "./flow-map.js";
+import { conversationLanguagePolicyMarkdown } from "./language-policy.js";
 import { stageSchema } from "./stage-schema.js";
+import { closeoutChainInline, closeoutNextCommandGuidance, closeoutSubstateInline, closeoutSubstateProtocolBullets } from "./closeout-guidance.js";
 import { stageSkillFolder } from "./skills.js";
 const NEXT_SKILL_FOLDER = "flow-next-step";
 const NEXT_SKILL_NAME = "flow-next-step";
@@ -58,21 +59,23 @@ export function nextCommandContract() {
 
 - **Current stage not started / in progress** → load its skill and execute it.
 - **Current stage complete (all gates passed)** → advance \`currentStage\` and load the next skill.
-- **Flow complete** → report done.
+- **Ship complete** → continue the resumable ${closeoutChainInline()} closeout via \`/cc-next\`.
+- **Flow complete** → report done after closeout has archived the run.
 
 This is the only progression command the user needs to drive the entire flow. Stage command contracts are internal implementation details loaded by \`/cc-next\`.
 
 ## HARD-GATE
 
+${conversationLanguagePolicyMarkdown()}
 - **Do not** invent gate completion: use only \`${flowPath}\` plus observable evidence in repo artifacts.
 - **Do not** skip stages: advance only from \`currentStage\` to its configured successor.
-- After ship completes, the closeout chain **retro -> compound -> archive** runs automatically, driven by \`closeout.shipSubstate\`. Do not ask the user to type those commands manually — follow the substate switch in Path B below.
+- ${closeoutNextCommandGuidance()}
 
 ## Algorithm (mandatory)
 
 1. Read **\`${flowPath}\`**. If missing → **BLOCKED** (state missing).
 2. Parse JSON. Capture \`currentStage\` and \`stageGateCatalog[currentStage]\`.
-3. If \`staleStages[currentStage]\` exists, do not advance automatically. Re-run the stage artifact work, then clear the marker with \`/cc-ops rewind --ack <currentStage>\`.
+3. If \`staleStages[currentStage]\` exists, do not advance automatically. Re-run the stage artifact work, then clear the marker with \`cclaw internal rewind --ack <currentStage>\`.
 4. Read **\`${reconciliationNoticesPath}\`** when present. If it contains entries for \`activeRunId + currentStage\` and the listed gate is still blocked in \`stageGateCatalog[currentStage].blocked\`, emit a structured warning before any stage-advance decision.
 5. Let \`G\` = \`requiredGates\` for **\`currentStage\`** from the stage schema.
 6. Let \`catalog\` = \`stageGateCatalog[currentStage]\` from flow state.
@@ -81,11 +84,11 @@ This is the only progression command the user needs to drive the entire flow. St
 9. If \`M\` is non-empty, inspect **\`${delegationPath}\`**. Treat as satisfied only if each mandatory agent is **completed** or **waived**.
 10. For each satisfied mandatory delegation row, verify \`evidenceRefs\` is a non-empty array (unless status is \`waived\` with rationale). Missing evidenceRefs means delegation is unresolved.
 11. If any mandatory delegation is missing and no waiver exists: **STOP** and ask the user whether to dispatch now or waive with rationale. Do not mark gates passed while delegation is unresolved.
-12. If \`currentStage === "review"\` and \`catalog.blocked\` includes \`review_criticals_resolved\`, treat this as a hard remediation branch: recommend \`/cc-ops rewind tdd "review_blocked_by_critical"\` with the blocking finding IDs, and do not attempt to advance toward ship.
+12. If \`currentStage === "review"\` and \`catalog.blocked\` includes \`review_criticals_resolved\`, treat this as a hard remediation branch: recommend \`cclaw internal rewind tdd "review_blocked_by_critical"\` with the blocking finding IDs, and do not attempt to advance toward ship.
 
 ### Path A: Current stage is NOT complete (any gate unmet or delegation missing)
 
-→ Load **\`${RUNTIME_ROOT}/skills/<skillFolder>/SKILL.md\`** and **\`${RUNTIME_ROOT}/commands/<currentStage>.md\`** for the current stage.
+→ Load **\`${RUNTIME_ROOT}/skills/<skillFolder>/SKILL.md\`** for the current stage.
 → Execute that stage's protocol. The stage skill handles the full interaction including STOP points and gate tracking.
 → Stage completion must use \`node .cclaw/hooks/stage-complete.mjs <currentStage>\` (canonical), which validates delegations + gate evidence before mutating \`flow-state.json\`.
 
@@ -95,24 +98,11 @@ ${ralphLoopContractSnippet()}
 
 → If current stage's \`next\` is **\`done\`**:
 
-  When \`currentStage === "ship"\`, route by **\`closeout.shipSubstate\`**:
-  - \`"idle"\` or missing -> set \`closeout.shipSubstate = "retro_review"\`, then
-    load \`${RUNTIME_ROOT}/commands/retro.md\` + \`${RUNTIME_ROOT}/skills/flow-retro/SKILL.md\`
-    and execute the retro protocol (draft + one structured accept/edit/skip ask).
-  - \`"retro_review"\` -> continue the retro protocol (re-ask the structured
-    question; the draft already exists — do not regenerate it).
-  - \`"compound_review"\` -> load \`${RUNTIME_ROOT}/commands/compound.md\` +
-    \`${RUNTIME_ROOT}/skills/flow-compound/SKILL.md\`, execute the compound
-    scan, ask user **one** structured question (apply / skip) per candidate
-    cluster or a single accept-all / skip choice, and advance substate on
-    completion or skip.
-  - \`"ready_to_archive"\` -> load \`${RUNTIME_ROOT}/commands/archive.md\` +
-    \`${RUNTIME_ROOT}/skills/flow-archive/SKILL.md\`, run archive, reset state.
-  - \`"archived"\` (transient) -> report "run archived" and stop.
+  ${closeoutSubstateProtocolBullets()}
 
   Otherwise report **"Flow complete. All stages finished."** and stop.
 
-→ Otherwise: load **\`${RUNTIME_ROOT}/skills/<skillFolder>/SKILL.md\`** and **\`${RUNTIME_ROOT}/commands/<nextStage>.md\`** for the successor stage. Execute that stage's protocol.
+→ Otherwise: load **\`${RUNTIME_ROOT}/skills/<skillFolder>/SKILL.md\`** for the successor stage. Execute that stage's protocol.
 
 ### Track-aware successor resolution
 
@@ -128,7 +118,7 @@ ${ralphLoopContractSnippet()}
 \`/cc-next\` in a **new session** = resume from where you left off:
 - Flow-state records \`currentStage\` and which gates have passed.
 - The stage skill reads upstream artifacts and picks up context.
-- \`closeout.shipSubstate\` carries the post-ship substate, so a crashed
+- ${closeoutSubstateInline()} carries the post-ship substate, so a crashed
   session during retro/compound/archive resumes at the exact step without
   regenerating the retro draft.
 - No special resume command needed — \`/cc-next\` IS the resume command.
@@ -151,9 +141,7 @@ Validate envelopes with:
 
 ## Surface reference
 
-When you need the full shape of cclaw (stages, routers, Ralph Loop,
-state files) load \`${FLOW_MAP_REL_PATH}\`. It is the single-page
-overview and is safe to read at any time.
+Use the flow-start skill plus \`.cclaw/state/flow-state.json\` for orientation when needed.
 `;
 }
 /**
@@ -182,6 +170,22 @@ description: "The primary progression command. Reads flow state, starts/resumes
 
 \`/cc-next\` is **the only command you need** to drive the entire cclaw flow.
 
+## Operator Output Contract
+
+${conversationLanguagePolicyMarkdown()}
+Default output should be compact, like OMC/OMX operator surfaces:
+
+\`\`\`
+Stage: <currentStage> (<track>)
+Gates: <passed>/<required> passed, <blocked> blocked
+Delegations: <done>/<mandatory> done
+Blockers: <none | gate/delegation/reconciliation ids>
+Next: <exact next action, usually /cc-next or one named remediation>
+\`\`\`
+
+Only expand beyond this when blocked, when asking a structured question, or when
+the user explicitly requests detail. Do not dump full artifacts in progression output.
+
 **How it works:**
 1. Reads \`flow-state.json\` to find \`currentStage\`
 2. Checks if all gates for that stage are satisfied
@@ -200,7 +204,7 @@ Do **not** mark gates satisfied from memory alone. Cite **artifact evidence** (p
 
 1. Open **\`${flowPath}\`**.
 2. Record \`currentStage\` and \`stageGateCatalog[currentStage]\`.
-3. If \`staleStages[currentStage]\` exists, re-run the stage and clear marker via \`/cc-ops rewind --ack <currentStage>\` before advancing.
+3. If \`staleStages[currentStage]\` exists, re-run the stage and clear marker via \`cclaw internal rewind --ack <currentStage>\` before advancing.
 4. If the file is missing or invalid JSON → **BLOCKED** (report and stop).
 5. Read \`${reconciliationNoticesPath}\` when present. For entries matching \`activeRunId + currentStage\` whose gate is still in \`stageGateCatalog[currentStage].blocked\`, show a warning with gate id + reason before proceeding.
 
@@ -221,42 +225,41 @@ If reconciliation warnings were emitted in Step 1, treat them as a pre-advance s
 
 **Path A — stage NOT complete (any gate unmet):**
 
-Load the current stage's skill and command contract:
+Load the current stage skill:
 - \`${RUNTIME_ROOT}/skills/<skillFolder>/SKILL.md\`
-- \`${RUNTIME_ROOT}/commands/<currentStage>.md\`
 
 Execute the stage protocol. The stage skill handles interaction, STOP points, gate tracking, and stage completion via \`node .cclaw/hooks/stage-complete.mjs <stage>\` (canonical flow-state mutation path).
 
 ${ralphLoopContractSnippet()}
 
-Special-case for review: if \`review_criticals_resolved\` is in \`blocked\`, route to rework instead of looping review forever — recommend \`/cc-ops rewind tdd "review_blocked_by_critical"\`.
+Special-case for review: if \`review_criticals_resolved\` is in \`blocked\`, route to rework instead of looping review forever — recommend \`cclaw internal rewind tdd "review_blocked_by_critical"\`.
 
 **Path B — stage IS complete (all gates met, all delegations done):**
 
 If \`next\` is \`done\`:
 
 When \`currentStage\` is \`ship\`, automatically drive the **closeout chain**
-by inspecting \`closeout.shipSubstate\`:
+by inspecting ${closeoutSubstateInline()}:
 
 | shipSubstate          | Action                                              |
 |-----------------------|-----------------------------------------------------|
 | \`idle\` / missing      | Flip to \`retro_review\` and start retro protocol     |
-| \`retro_review\`        | Continue retro protocol (re-ask accept/edit/skip)   |
-| \`compound_review\`     | Run compound scan with a single approve/skip ask    |
-| \`ready_to_archive\`    | Run archive skill; reset flow-state on success      |
+| \`retro_review\`        | Draft/update \`09-retro.md\`, ask accept/edit/skip  |
+| \`compound_review\`     | Compound closeout: overlap scan, refresh/supersede, ask approve/skip |
+| \`ready_to_archive\`    | Run \`npx cclaw-cli archive\`; reset flow-state on success |
 | \`archived\`            | Report "run archived"; stop                         |
 
-Each step owns its own state transition. \`/cc-next\` never shells out to
-\`cclaw doctor\` or \`cclaw archive\` automatically — it loads the matching
-skill and command contract and executes the protocol in-session.
+Each step owns its own state transition. \`/cc-next\` keeps retro and compound
+in-session, then uses the archive runtime only at \`ready_to_archive\`.
 
 Otherwise report **"Flow complete. All stages finished."** and stop.
 
-Otherwise (non-terminal \`next\`): load the next stage's skill and command
-contract, begin execution.
+Otherwise (non-terminal \`next\`): load the next stage skill and begin execution.
 
 ## Stage order
 
+This table is the critical path. After \`ship\`, \`/cc-next\` continues closeout via ${closeoutSubstateInline()}: ${closeoutChainInline()}.
+
 | Stage | Next | Skill path |
 |---|---|---|
 ${stageRows}