cclaw-cli 0.51.28 → 0.51.30

package/dist/content/meta-skill.js

@@ -13,7 +13,7 @@ function generatedHelperSkillList() {
 export function usingCclawSkillMarkdown() {
     return `---
 name: using-cclaw
-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."
+description: "Routing brain for cclaw. Decide whether to start/resume a stage, answer directly, or use visible commands like /cc, /cc-ideate, and /cc-cancel."
 ---
 
 # Using Cclaw
@@ -65,11 +65,10 @@ Task arrives
   ├─ Pure question / non-software ask? -> answer directly (no stage)
   ├─ New software work? -> /cc <idea>
   ├─ Repo-improvement discovery? -> /cc-ideate
-  ├─ Resume existing flow? -> /cc or /cc-next
+  ├─ Resume existing flow? -> /cc
   ├─ Knowledge operation? -> load the learnings skill
-  ├─ Read-only workspace view? -> /cc-view [status|tree|diff]
-  ├─ Normal post-ship closeout? -> /cc-next drives ${closeoutChainInline()}
-  └─ Explicit early archival/reset? -> npx cclaw-cli archive [--name=<slug>]
+  ├─ Normal post-ship closeout? -> /cc drives ${closeoutChainInline()}
+  └─ Explicit early cancellation/abandonment? -> /cc-cancel
 \`\`\`
 
 ## Task classification
@@ -87,7 +86,7 @@ Task arrives
 Before stage work:
 
 1. Read \`.cclaw/state/flow-state.json\`.
-2. If active stage exists, continue with \`/cc\` or \`/cc-next\`.
+2. If active stage exists, continue with \`/cc\`.
 3. Do not jump directly to stage-specific commands.
 
 ## Platform reliability notes
@@ -98,13 +97,12 @@ Before stage work:
 
 ## Stage quick map
 
-Use \`/cc <idea>\` for new work, \`/cc-next\` for progression and closeout, \`/cc-view\` for read-only state, and \`/cc-ideate\` for backlog discovery.
+Use \`/cc <idea>\` for new work, \`/cc\` for progression and closeout, \`/cc-ideate\` for backlog discovery, and \`/cc-cancel\` for cancellation/abandonment.
 
 ## Main vs Operator Surfaces
 
-- **Main workflow:** \`/cc\`, \`/cc-next\`, \`/cc-ideate\`, \`/cc-view status\`, and \`node .cclaw/hooks/stage-complete.mjs <stage>\` inside the installed harness runtime.
+- **Main workflow:** \`/cc\`, \`/cc-ideate\`, and \`/cc-cancel\` 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.
 
 ## Whole flow map

package/dist/content/next-command.d.ts

@@ -10,8 +10,8 @@
 export declare const RALPH_LOOP_CONTRACT_MARKER = "ralph-loop-contract:v1";
 export declare function ralphLoopContractSnippet(): string;
 /**
- * Command contract for /cc-next — the primary progression command.
- * Reads flow-state, starts the current stage if unfinished, or advances if all gates pass.
+ * Internal compatibility contract for /cc-next.
+ * /cc is the promoted public progression command; this remains as an internal/legacy alias.
  */
 export declare function nextCommandContract(): string;
 /**

package/dist/content/next-command.js

@@ -44,8 +44,8 @@ Ralph Loop fields never gate-check on their own.
 <!-- ${RALPH_LOOP_CONTRACT_MARKER} -->`;
 }
 /**
- * Command contract for /cc-next — the primary progression command.
- * Reads flow-state, starts the current stage if unfinished, or advances if all gates pass.
+ * Internal compatibility contract for /cc-next.
+ * /cc is the promoted public progression command; this remains as an internal/legacy alias.
  */
 export function nextCommandContract() {
     const flowPath = flowStatePath();
@@ -56,14 +56,14 @@ export function nextCommandContract() {
 
 ## Purpose
 
-**The primary progression command.** Read flow state, determine what to do:
+**Internal compatibility progression command.** \`/cc\` is the promoted public start/resume/continue command. This contract remains for legacy shims and internal references; read flow state, determine what to do:
 
 - **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.
-- **Ship complete** → continue the resumable ${closeoutChainInline()} closeout via \`/cc-next\`.
+- **Ship complete** → continue the resumable ${closeoutChainInline()} closeout. Public habit: use \`/cc\`.
 - **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\`.
+The public habit is \`/cc\`; this command is a compatibility/internal route for the same progression behavior. Stage command contracts are internal implementation details.
 
 ## HARD-GATE
 
@@ -74,17 +74,17 @@ ${conversationLanguagePolicyMarkdown()}
 
 ## Algorithm (mandatory)
 
-1. Read **\`${flowPath}\`**. If missing → **BLOCKED** (state missing).
+1. Read **\`${flowPath}\`**. If missing → **BLOCKED** (state missing). Next action: run \`cclaw sync\` to safely regenerate generated runtime files, then \`cclaw doctor --explain\`; do not hand-edit state unless doctor says user repair is required.
 2. Parse JSON. Capture \`currentStage\` and \`stageGateCatalog[currentStage]\`.
-3. If \`staleStages[currentStage]\` exists, do not advance automatically. Report the stale marker reason/rewindId, re-run the stage artifact work, then clear only the current stage 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.
+3. If \`staleStages[currentStage]\` exists, do not advance automatically. Report \`Blocked by: stale stage\`, the marker reason/rewindId, the stage artifact work to re-run, and clear only the current stage marker with \`cclaw internal rewind --ack <currentStage>\` after rework.
+4. Read **\`${reconciliationNoticesPath}\`** when present. If it contains entries for \`activeRunId + currentStage\` and the listed gate is still blocked in \`stageGateCatalog[currentStage].blocked\`, emit \`Blocked by: reconciliation notice\` with gate id, reason, and next action \`cclaw doctor --reconcile-gates --explain\`. Clarify that reconciliation refreshes derived gate status only; it does not repair missing artifacts or tests.
 5. Let \`G\` = \`requiredGates\` for **\`currentStage\`** from the stage schema.
 6. Let \`catalog\` = \`stageGateCatalog[currentStage]\` from flow state.
 7. **Satisfied** for gate id \`g\`: \`g\` in \`catalog.passed\` and \`g\` not in \`catalog.blocked\`.
 8. Let \`M\` = \`mandatoryDelegations\` for \`currentStage\`.
 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.
+11. If any mandatory delegation is missing and no waiver exists: **STOP** and ask the user whether to dispatch \`<agent>\` now or waive with rationale. State who must run, why the role is mandatory, whether the gap is ledger status, event-log dispatch proof, or artifact \`evidenceRefs\`, and 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 the managed command \`cclaw internal rewind tdd "review_blocked_by_critical <finding-ids>"\`, and do not attempt to advance toward ship. After TDD rework, require \`cclaw internal rewind --ack tdd\` before continuing.
 
 ### Path A: Current stage is NOT complete (any gate unmet or delegation missing)
@@ -109,20 +109,20 @@ ${ralphLoopContractSnippet()}
 
 \`flow-state.json\` carries a \`track\` field (\`"quick"\`, \`"medium"\`, or \`"standard"\`) and a \`skippedStages\` array.
 
-- If \`track === "quick"\`, the critical path is **spec → tdd → review → ship**. When advancing, skip any stage listed in \`skippedStages\` — i.e. after the current stage completes, pick the next stage that is NOT in \`skippedStages\`.
+- If \`track === "quick"\`, the critical path is **spec → tdd → review → ship**. Quick skips ceremony, not safety: spec approval, RED/GREEN/REFACTOR evidence, review, and ship gates still apply. When advancing, skip any stage listed in \`skippedStages\` — i.e. after the current stage completes, pick the next stage that is NOT in \`skippedStages\`.
 - If \`track === "medium"\`, the critical path is **brainstorm → spec → plan → tdd → review → ship**. Scope and design are intentionally skipped unless the run is reclassified to standard.
 - If \`track === "standard"\`, advance through all 8 stages in their natural order.
 - Never manually reintroduce a skipped stage mid-run. If evidence shows the track was wrong, stop and use the managed start-flow helper with \`--reclassify\`; only that managed reclassification may add upstream stages back into the active track.
 
 ## Resume Semantics
 
-\`/cc-next\` in a **new session** = resume from where you left off:
+\`/cc\` in a **new session** resumes from where you left off; \`/cc-next\` is a compatibility alias:
 - Flow-state records \`currentStage\` and which gates have passed.
 - The stage skill reads upstream artifacts and picks up context.
 - ${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.
+- No special resume command needed — \`/cc\` is the public resume/progression command.
 
 ## Headless mode
 
@@ -171,14 +171,14 @@ export function nextCommandSkillMarkdown() {
         .join("\n");
     return `---
 name: ${NEXT_SKILL_NAME}
-description: "The primary progression command. Reads flow state, starts/resumes the current stage or advances to the next one."
+description: "Internal compatibility progression command. Prefer /cc for start, resume, continue, and closeout."
 ---
 
-# /cc-next — Flow Progression
+# /cc-next — Flow Progression Compatibility
 
 ## Overview
 
-\`/cc-next\` is **the only command you need** to drive the entire cclaw flow.
+\`/cc\` is the public command to drive the cclaw flow. \`/cc-next\` remains as an internal/compatibility alias for progression.
 
 ## Operator Output Contract
 
@@ -190,13 +190,16 @@ Current: <currentStage or closeout.shipSubstate> (<track>)
 Stage: <currentStage>
 Gates: <passed>/<required> passed, <blocked> blocked
 Delegations: <done>/<mandatory> done
-Blocked by: <none | gate/delegation/reconciliation/stale/TDD/review ids>
-Next: <exact next action, usually /cc-next or one named remediation>
+Blocked by: <none | gate/delegation/reconciliation/stale/TDD/review/closeout ids>
+Blocker category: <sync-recovery | user-decision | stage-work | delegation-proof | review-rework | closeout>
+Next: <exact next action, usually /cc or one named remediation>
 Evidence needed: <artifact/test/review/delegation evidence required to unblock>
 \`\`\`
 
 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.
+the user explicitly requests detail. When blocked, name the blocker category,
+why it blocks progression, the one next command/action, and the exact proof that
+would unblock it. Do not dump full artifacts in progression output.
 
 **How it works:**
 1. Reads \`flow-state.json\` to find \`currentStage\`
@@ -204,7 +207,7 @@ the user explicitly requests detail. Do not dump full artifacts in progression o
 3. If **not** → loads the stage skill and starts/resumes execution
 4. If **yes** → advances to the next stage and loads its skill
 
-**Resume:** \`/cc-next\` in a new session picks up from where \`flow-state.json\` says you are.
+**Resume:** \`/cc\` in a new session picks up from where \`flow-state.json\` says you are.
 
 ## HARD-GATE
 
@@ -216,9 +219,9 @@ 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, show the marker reason/rewindId, re-run the stage, and clear only the current 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.
+3. If \`staleStages[currentStage]\` exists, show \`Blocked by: stale stage\`, the marker reason/rewindId, re-run the stage, and clear only the current marker via \`cclaw internal rewind --ack <currentStage>\` before advancing.
+4. If the file is missing or invalid JSON → **BLOCKED** (state missing/corrupt). Next action: run \`cclaw sync\` for safe regeneration of generated runtime files, then \`cclaw doctor --explain\`; do not hand-edit flow state unless doctor says user repair is required.
+5. Read \`${reconciliationNoticesPath}\` when present. For entries matching \`activeRunId + currentStage\` whose gate is still in \`stageGateCatalog[currentStage].blocked\`, show \`Blocked by: reconciliation notice\` with gate id + reason before proceeding; \`cclaw doctor --reconcile-gates --explain\` refreshes derived gate-state only; it does not repair missing artifacts or tests.
 
 ### Step 2: Evaluate gates
 
@@ -229,7 +232,8 @@ For each gate id in \`requiredGates\` for \`currentStage\`:
 Check \`mandatoryDelegations\` via **\`${delegationPath}\`** — satisfied only if **completed** or **waived**.
 Also verify each completed mandatory delegation row has non-empty \`evidenceRefs\` (waived rows must include rationale).
 If a mandatory delegation is missing and no waiver exists, **STOP** and ask:
-(A) dispatch now, (B) waive with rationale, (C) cancel stage advance.
+(A) dispatch \`<agent>\` now, (B) waive with rationale, (C) cancel stage advance.
+Explain who must run, why that role is mandatory for this stage, and whether the missing proof is ledger status, event-log dispatch proof, or artifact \`evidenceRefs\`. Waivers must include a user-visible safety reason.
 
 If reconciliation warnings were emitted in Step 1, treat them as a pre-advance stop point: require explicit acknowledgement before continuing Path A or Path B.
 
@@ -246,7 +250,7 @@ ${ralphLoopContractSnippet()}
 
 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 <finding-ids>"\`, then \`cclaw internal rewind --ack tdd\` after TDD rework.
 
-Special-case for TDD blockers: when \`06-tdd.md\` records \`NO_SOURCE_CONTEXT\`, \`NO_TEST_SURFACE\`, \`NO_IMPLEMENTABLE_SLICE\`, \`RED_NOT_EXPRESSIBLE\`, or \`NO_VCS_MODE\`, keep status BLOCKED and print \`Current\`, \`Blocked by\`, \`Next\`, and \`Evidence needed\` instead of retrying speculative RED/GREEN work.
+Special-case for TDD blockers: when \`06-tdd.md\` records \`NO_SOURCE_CONTEXT\`, \`NO_TEST_SURFACE\`, \`NO_IMPLEMENTABLE_SLICE\`, \`RED_NOT_EXPRESSIBLE\`, or \`NO_VCS_MODE\`, keep status BLOCKED and print \`Current\`, \`Blocked by\`, \`Next\`, \`Repair path\`, and \`Evidence needed\` instead of retrying speculative RED/GREEN work. RED blockers need a runnable failing test surface, GREEN blockers need passing full-suite evidence, REFACTOR blockers need behavior-preservation evidence.
 
 **Path B — stage IS complete (all gates met, all delegations done):**
 
@@ -263,7 +267,7 @@ by inspecting ${closeoutSubstateInline()}:
 | \`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\` keeps retro and compound
+Each step owns its own state transition. \`/cc\` 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.
@@ -272,7 +276,7 @@ Otherwise (non-terminal \`next\`): load the next stage skill and begin execution
 
 ## Stage order
 
-This table is the track-aware critical path. It must match \`flow-state.json.track\`; do not follow the natural schema edge when the active track skips a stage. After \`ship\`, \`/cc-next\` continues closeout via ${closeoutSubstateInline()}: ${closeoutChainInline()}.
+This table is the track-aware critical path. It must match \`flow-state.json.track\`; do not follow the natural schema edge when the active track skips a stage. Quick skips ceremony, not safety: spec approval, RED/GREEN/REFACTOR evidence, review, and ship gates still apply. After \`ship\`, \`/cc\` continues closeout via ${closeoutSubstateInline()}: ${closeoutChainInline()}.
 
 | Stage | Standard next | Medium next | Quick next | Skill path |
 |---|---|---|---|---|
@@ -289,6 +293,6 @@ ${naturalStageRows}
 - Advancing when \`blocked\` is non-empty for the current stage.
 - Treating \`passed\` as trusted when artifact evidence contradicts it.
 - Skipping **review** or **ship** because "the code looks fine".
-- Loading a stage skill directly instead of using \`/cc-next\` for progression.
+- Loading a stage skill directly instead of using \`/cc\` for progression.
 `;
 }

package/dist/content/node-hooks.js

@@ -10,7 +10,7 @@ function normalizePatterns(patterns, fallback) {
         return [...fallback];
     return patterns.map((value) => value.trim()).filter((value) => value.length > 0);
 }
-function resolveCliEntrypointForGeneratedHook() {
+function resolveCliRuntimeForGeneratedHook() {
     const here = fileURLToPath(import.meta.url);
     const candidates = [
         path.resolve(path.dirname(here), "..", "cli.js"),
@@ -19,9 +19,18 @@ function resolveCliEntrypointForGeneratedHook() {
     for (const candidate of candidates) {
         // Synchronous probe runs only during cclaw-cli init/sync generation.
         if (existsSync(candidate))
-            return candidate;
+            return { entrypoint: candidate, argsPrefix: [] };
     }
-    return null;
+    // Vitest exercises init/sync directly from src/ without a compiled dist/.
+    // Route that dev-only shape through vite-node so hooks still prove a local runtime.
+    if (process.env.VITEST === "true") {
+        const sourceCli = path.resolve(path.dirname(here), "..", "cli.ts");
+        const viteNode = path.resolve(path.dirname(here), "..", "..", "node_modules", "vite-node", "vite-node.mjs");
+        if (existsSync(sourceCli) && existsSync(viteNode)) {
+            return { entrypoint: viteNode, argsPrefix: ["--script", sourceCli] };
+        }
+    }
+    return { entrypoint: null, argsPrefix: [] };
 }
 /**
  * Node-only hook runtime (single entrypoint).
@@ -42,7 +51,7 @@ export function nodeHookRuntimeScript(options = {}) {
         options.compoundRecurrenceThreshold >= 1
         ? options.compoundRecurrenceThreshold
         : DEFAULT_COMPOUND_RECURRENCE_THRESHOLD;
-    const cliEntrypoint = resolveCliEntrypointForGeneratedHook();
+    const cliRuntime = resolveCliRuntimeForGeneratedHook();
     return `#!/usr/bin/env node
 import fs from "node:fs/promises";
 import path from "node:path";
@@ -64,7 +73,8 @@ const DEFAULT_TDD_PRODUCTION_PATH_PATTERNS = ${JSON.stringify(tddProductionPathP
 const COMPOUND_RECURRENCE_THRESHOLD = ${JSON.stringify(compoundRecurrenceThreshold)};
 const SMALL_PROJECT_ARCHIVE_RUNS_THRESHOLD = ${JSON.stringify(SMALL_PROJECT_ARCHIVE_RUNS_THRESHOLD)};
 const SMALL_PROJECT_RECURRENCE_THRESHOLD = ${JSON.stringify(SMALL_PROJECT_RECURRENCE_THRESHOLD)};
-const CCLAW_CLI_ENTRYPOINT = ${JSON.stringify(cliEntrypoint)};
+const CCLAW_CLI_ENTRYPOINT = ${JSON.stringify(cliRuntime.entrypoint)};
+const CCLAW_CLI_ARGS_PREFIX = ${JSON.stringify(cliRuntime.argsPrefix)};
 
 function resolveStrictness() {
   return process.env.CCLAW_STRICTNESS === "strict" ? "strict" : DEFAULT_STRICTNESS;
@@ -313,6 +323,7 @@ async function readStdin() {
 
 async function runCclawInternal(root, args, options = {}) {
   const cliEntrypoint = process.env.CCLAW_CLI_JS || CCLAW_CLI_ENTRYPOINT;
+  const cliArgsPrefix = process.env.CCLAW_CLI_JS ? [] : CCLAW_CLI_ARGS_PREFIX;
   if (!cliEntrypoint || String(cliEntrypoint).trim().length === 0) {
     return {
       code: 1,
@@ -324,6 +335,11 @@ async function runCclawInternal(root, args, options = {}) {
   try {
     const stat = await fs.stat(cliEntrypoint);
     if (!stat.isFile()) throw new Error("not-file");
+    for (const argPath of cliArgsPrefix) {
+      if (typeof argPath !== "string" || argPath.startsWith("-")) continue;
+      const argStat = await fs.stat(argPath);
+      if (!argStat.isFile()) throw new Error("arg-not-file");
+    }
   } catch {
     return {
       code: 1,
@@ -345,7 +361,7 @@ async function runCclawInternal(root, args, options = {}) {
     };
     let child;
     try {
-      child = spawn(process.execPath, [cliEntrypoint, "internal", ...args], {
+      child = spawn(process.execPath, [cliEntrypoint, ...cliArgsPrefix, "internal", ...args], {
         cwd: root,
         env: process.env,
         stdio: ["ignore", captureStdout ? "pipe" : "ignore", "pipe"]
@@ -922,7 +938,7 @@ async function handleSessionStart(runtime) {
   );
   const knowledge = await buildKnowledgeDigest(runtime.root, state.currentStage, knowledgeRaw);
 
-  // Refresh Ralph Loop status each session-start so /cc-next and the model
+  // Refresh Ralph Loop status each session-start so /cc and the model
   // both read a consistent "iter=N, acClosed=[...]" snapshot. Runs only when
   // we are in tdd — other stages skip the write to keep the file stable.
   let ralphLoopLine = "";
@@ -1121,7 +1137,7 @@ async function handleStopHandoff(runtime) {
   const shipSubstate = typeof closeoutObj.shipSubstate === "string" ? closeoutObj.shipSubstate : "idle";
   const closeoutContext =
     state.currentStage === "ship" || shipSubstate !== "idle"
-      ? " closeout.shipSubstate=" + shipSubstate + "; closeout chain=retro -> compound -> archive; continue closeout with /cc-next."
+      ? " closeout.shipSubstate=" + shipSubstate + "; closeout chain=retro -> compound -> archive; continue closeout with /cc."
       : "";
 
   const message =

package/dist/content/opencode-plugin.js

@@ -131,7 +131,7 @@ export default function cclawPlugin(ctx) {
     if (stageSupport.length > 0) parts.push(...stageSupport);
 
     parts.push(
-      "If you discover a non-obvious rule or pattern during stage work, add it to the current artifact ## Learnings section; stage-complete harvests it into .cclaw/knowledge.jsonl. Direct JSONL append is only for explicit manual learnings operations."
+      "If you discover a non-obvious rule or pattern during stage work, add it to the current artifact ## Learnings section; stage-complete harvests it into .cclaw/knowledge.jsonl. If this plugin does not load, run \`cclaw sync\`, verify opencode.json(.c) includes the cclaw plugin registration, then run \`cclaw doctor --explain\`. Direct JSONL append is only for explicit manual learnings operations."
     );
 
     const meta = (await readFileText(metaSkillPath)).trim();

package/dist/content/session-hooks.js

@@ -36,7 +36,7 @@ When a new session begins in any harness:
 \`\`\`
 Cclaw flow state: [current stage] ([N] of 8 stages completed)
 Knowledge highlights: [rule/pattern 1], [rule/pattern 2], [rule/pattern 3]
-Next action: /cc-next to continue, /cc to start new work, or describe what you'd like to do.
+Next action: /cc to continue or start work, /cc-cancel to cancel, or describe what you'd like to do.
 \`\`\`
 
 ## Session Stop Protocol

package/dist/content/stage-command.js

@@ -10,7 +10,7 @@ Load and follow the authoritative stage skill:
 
 - \`${skillPath}\`
 
-Normal stage resume and advancement uses \`/cc-next\`. Use \`/cc-next\` to read
+Normal stage resume and advancement uses \`/cc\`. Use \`/cc\` to read
 \`.cclaw/state/flow-state.json\`, select the active stage, and advance only after
 that stage's gates pass. Do not duplicate the stage protocol here.
 `;

package/dist/content/stage-common-guidance.js

@@ -11,7 +11,7 @@ ${conversationLanguagePolicyMarkdown()}
 - Stage-specific skills expose **Completion Parameters** plus the gates that
   matter for that stage.
 - Generic execution stays inline: verify required gates, update the artifact,
-  harvest learnings, then use \`/cc-next\` for progression.
+  harvest learnings, then use \`/cc\` for progression.
 - Do not create separate protocol files.
 
 ## Context readiness
@@ -30,11 +30,11 @@ ${conversationLanguagePolicyMarkdown()}
 
 Use this same closeout menu for every stage:
 
-- **A) Advance** — run \`/cc-next\` and continue the critical path; after \`ship\`, the same command drives \`retro -> compound -> archive\`.
+- **A) Advance** — run \`/cc\` and continue the critical path; after \`ship\`, the same command drives \`retro -> compound -> archive\`.
 - **B) Revise this stage** — stay on current stage and apply feedback.
-- **C) Pause / park** — run \`/cc-view status\`, then stop and resume later.
+- **C) Pause / park** — stop after summarizing current stage, blockers, and next \`/cc\` action.
 - **D) Rewind** — run \`npx cclaw-cli internal rewind <target-stage> "<reason>"\` as the managed support/runtime repair action; after redoing the target stage, run \`npx cclaw-cli internal rewind --ack <target-stage>\` to clear the stale marker.
-- **E) Abandon** — only when the user explicitly wants to end a non-ship active run early, archive with \`npx cclaw-cli archive --skip-retro --retro-reason="<reason>"\`. Once in post-ship closeout, continue \`/cc-next\` through retro/compound/archive instead.
+- **E) Abandon** — only when the user explicitly wants to end a non-ship active run early, archive with \`npx cclaw-cli archive --skip-retro --retro-reason="<reason>"\`. Once in post-ship closeout, continue \`/cc\` through retro/compound/archive instead.
 
 Recommendation defaults:
 

package/dist/content/stages/plan.js

@@ -50,7 +50,7 @@ export const PLAN = {
             "Run anti-placeholder + anti-scope-reduction scans — block `TODO/TBD/...` and phrasing like `v1`, `for now`, `later` for locked boundaries.",
             "Define validation points — mark where progress must be checked before continuing, with concrete command and expected evidence.",
             "Define execution posture — record whether execution should be sequential, dependency-batched, parallel-safe, or blocked; include risk triggers and RED/GREEN/REFACTOR checkpoint/commit expectations when the repo workflow supports them. This fulfills the `plan_execution_posture_recorded` gate.",
-            "WAIT_FOR_CONFIRM — write plan artifact and explicitly pause. **STOP.** Do NOT proceed until user confirms. Then close the stage with `node .cclaw/hooks/stage-complete.mjs plan` and tell user to run `/cc-next`."
+            "WAIT_FOR_CONFIRM — write plan artifact and explicitly pause. **STOP.** Do NOT proceed until user confirms. Then close the stage with `node .cclaw/hooks/stage-complete.mjs plan` and tell user to run `/cc`."
         ],
         interactionProtocol: [
             "Plan in read-only mode relative to implementation.",
@@ -61,7 +61,7 @@ export const PLAN = {
             "Preserve locked scope boundaries: no silent scope reduction language in task rows.",
             "Enforce WAIT_FOR_CONFIRM: present the plan summary with options (A) Approve / (B) Revise / (C) Reject.",
             "**STOP.** Do NOT proceed until user explicitly approves.",
-            "**STOP BEFORE ADVANCE.** Mandatory delegation `planner` must be marked completed or explicitly waived in `.cclaw/state/delegation-log.json`. Then close the stage via `node .cclaw/hooks/stage-complete.mjs plan` and tell the user to run `/cc-next`."
+            "**STOP BEFORE ADVANCE.** Mandatory delegation `planner` must be marked completed or explicitly waived in `.cclaw/state/delegation-log.json`. Then close the stage via `node .cclaw/hooks/stage-complete.mjs plan` and tell the user to run `/cc`."
         ],
         process: [
             "Build dependency graph and ordered slices.",

package/dist/content/stages/review.js

@@ -47,7 +47,7 @@ export const REVIEW = {
             "Classify findings — Critical (blocks ship), Important (should fix), Suggestion (optional improvement).",
             "Victory Detector — before verdict, confirm Layer 1, Layer 2, security sweep, structured findings, trace evidence, and unresolved-critical status are complete; otherwise iterate findings or route back to TDD.",
             "Produce verdict — APPROVED, APPROVED_WITH_CONCERNS, or BLOCKED.",
-            "If verdict is BLOCKED, emit remediation route token `ROUTE_BACK_TO_TDD`, include the managed command `cclaw internal rewind tdd \"review_blocked_by_critical <finding-ids>\"`, and satisfy the special transition guard `review_verdict_blocked` instead of `review_criticals_resolved`. After TDD rework, clear the stale marker with `cclaw internal rewind --ack tdd` before `/cc-next`."
+            "If verdict is BLOCKED, emit remediation route token `ROUTE_BACK_TO_TDD`, include the managed command `cclaw internal rewind tdd \"review_blocked_by_critical <finding-ids>\"`, list the critical finding IDs and required TDD evidence to repair, and satisfy the special transition guard `review_verdict_blocked` instead of `review_criticals_resolved`. After TDD rework, clear the stale marker with `cclaw internal rewind --ack tdd` before `/cc`."
         ],
         interactionProtocol: [
             "Run Layer 1 (spec compliance) completely before starting Layer 2.",

package/dist/content/stages/tdd.js

@@ -118,7 +118,7 @@ export const TDD = {
             "full suite not green",
             "behavior changed during refactor",
             "no evidence recorded",
-            "RED/GREEN blocked — classify with the managed taxonomy `NO_SOURCE_CONTEXT`, `NO_TEST_SURFACE`, `NO_IMPLEMENTABLE_SLICE`, `RED_NOT_EXPRESSIBLE`, or `NO_VCS_MODE` and capture blockedBecause, missingInputs, recommendedRoute, nextCommand, and resumeCriteria.",
+            "RED/GREEN blocked — classify with the managed taxonomy `NO_SOURCE_CONTEXT`, `NO_TEST_SURFACE`, `NO_IMPLEMENTABLE_SLICE`, `RED_NOT_EXPRESSIBLE`, or `NO_VCS_MODE` and capture blockedBecause, missingInputs, recommendedRoute, nextCommand, resumeCriteria, and the repair path: RED needs a failing test surface, GREEN needs full-suite pass evidence, REFACTOR needs behavior-preservation evidence.",
             "no-VCS workspace without explicit `vcs: none`, no-vcs reason, content/artifact hash, or `tdd.verificationRef: disabled`"
         ],
         exitCriteria: [

package/dist/content/start-command.d.ts

@@ -1,7 +1,7 @@
 /**
  * Command contract for /cc — the unified entry point.
- * No args → reads existing flow state and behaves like /cc-next only when a
- * tracked flow already exists; missing state/fresh placeholder state blocks with
+ * No args → reads existing flow state and progresses it when a tracked flow
+ * already exists; missing state/fresh placeholder state blocks with
  * init/start guidance. With prompt → classifies the idea, selects a track, and
  * starts the first stage of that track (brainstorm for medium/standard, spec for quick).
  */

package/dist/content/start-command.js

@@ -7,8 +7,8 @@ function flowStatePath() {
 }
 /**
  * Command contract for /cc — the unified entry point.
- * No args → reads existing flow state and behaves like /cc-next only when a
- * tracked flow already exists; missing state/fresh placeholder state blocks with
+ * No args → reads existing flow state and progresses it when a tracked flow
+ * already exists; missing state/fresh placeholder state blocks with
  * init/start guidance. With prompt → classifies the idea, selects a track, and
  * starts the first stage of that track (brainstorm for medium/standard, spec for quick).
  */
@@ -20,10 +20,10 @@ export function startCommandContract() {
 
 **The unified entry point for the cclaw flow.**
 
-- \`/cc\` (no arguments) → reads existing flow state and resumes/progresses it through \`/cc-next\`. If flow state is missing or still a fresh init placeholder, stop and guide the user to run \`/cc <prompt>\` or \`cclaw init\`; do not silently create a brainstorm run.
+- \`/cc\` (no arguments) → reads existing flow state and resumes/progresses the active flow. If flow state is missing or still a fresh init placeholder, stop and guide the user to run \`/cc <prompt>\` or \`cclaw init\`; do not silently create a brainstorm run.
 - \`/cc <prompt>\` (with an idea/description) → saves the prompt as idea context and starts the first stage of the resolved track.
 
-This is the **recommended way to start** working with cclaw. Use \`/cc-next\` for subsequent stage progression.
+This is the **recommended way to start, resume, and continue** working with cclaw.
 
 ## HARD-GATE
 
@@ -74,18 +74,19 @@ ${conversationLanguagePolicyMarkdown()}
 6. If flow already has completed stages, warn the user that starting a new tracked flow will reset progress. Ask for confirmation before proceeding. A fresh init placeholder state with \`completedStages: []\`, no passed gates, and no \`00-idea.md\` is **not** an active flow; do not ask the user to resume it.
 7. **Track heuristic** — classify the idea text and **recommend** a track (the user can override before any state mutation):
    - First, load \`${RUNTIME_ROOT}/config.yaml\`. If \`trackHeuristics\` is defined, apply those per-track vocabulary hints (\`fallback\`, \`tracks.<id>.{triggers,veto}\`) on top of the built-in defaults. Evaluation order is always \`standard -> medium -> quick\` (narrow-to-broad).
-   - **quick** (\`spec → tdd → review → ship\`) — single-purpose work where the spec is essentially already known.
+   - **quick** (\`spec → tdd → review → ship\`) — single-purpose work where the spec is essentially already known. Quick skips ceremony, not safety: spec approval, TDD evidence, review, and ship gates remain mandatory.
      Triggers (case-insensitive substring or close variant): \`bug\`, \`bugfix\`, \`fix\`, \`hotfix\`, \`patch\`, \`typo\`, \`regression\`, \`copy change\`, \`rename\`, \`bump\`, \`upgrade dep\`, \`config tweak\`, \`docs only\`, \`comment\`, \`lint\`, \`format\`, \`small\`, \`tiny\`, \`one-liner\`, \`revert\`.
    - **medium** (\`brainstorm → spec → plan → tdd → review → ship\`) — additive work that fits existing architecture and still needs product framing.
      Triggers: \`add endpoint\`, \`add field\`, \`extend existing\`, \`wire integration\`, \`small migration\`, \`new screen following existing patterns\`.
    - **standard** (full 8 stages — default fallback) — anything that introduces a new capability with architecture uncertainty, touches many modules, or has unclear scope.
      Triggers: \`new feature\`, \`refactor\`, \`migration\`, \`platform\`, \`architecture\`, \`schema\`, \`integrate\`, \`workflow\`, \`onboarding\`, or any prompt that does not match quick/medium confidently.
    - When triggers conflict, prefer **standard** over **medium**, and **medium** over **quick**.
-   - Report **track selection confidence** as high/medium/low with the matched trigger or fallback reason. Be explicit that this recommendation is advisory until the user accepts and the managed helper writes state; after that, \`/cc-next\` follows the configured track.
+   - Report **track selection confidence** as high/medium/low with the matched trigger or fallback reason, plus one sentence explaining what the selected track skips and what safety gates remain. Be explicit that this recommendation is advisory until the user accepts and the managed helper writes state; after that, \`/cc\` follows the configured track.
 8. Present one compact **Start framing** summary: class, recommended track, track selection confidence, stack, origin docs, seed recalls, and the recommended next action. Ask a single confirmation question only when there is a destructive reset, a real contradiction, or ambiguous software/non-software classification.
 9. Present the recommendation as a single decision with explicit options:
    > \`Recommended track: <quick|medium|standard>\` because \`<one-line reason citing matched triggers>\`.
-   > Override? (A) keep \`<recommended>\`  (B) switch track  (C) cancel.
+   > \`Safety retained: <spec/TDD/review/ship gates that still apply>\`.
+   > Override? (A) keep \`<recommended>\`  (B) switch track with reason  (C) cancel.
    If the harness's native ask tool is available (\`AskUserQuestion\` / \`AskQuestion\` / \`question\` / \`request_user_input\`), send exactly ONE question; on schema error, fall back to a plain-text lettered list.
 10. Start the tracked flow only through the managed helper:
    \`node .cclaw/hooks/start-flow.mjs --track=<quick|medium|standard> --class=<class> --prompt=<prompt> --stack=<stack> --reason=<matched heuristic>\`
@@ -111,7 +112,7 @@ If during any stage the agent discovers evidence that contradicts the initial Ph
 1. Read \`${flowPath}\`.
 2. If flow state is missing → guide the user to run \`cclaw init\` and stop.
 3. If flow state is only a fresh init placeholder (\`completedStages: []\`, all \`passed\` arrays empty, and no \`00-idea.md\`) → stop and ask for \`/cc <prompt>\` to start a tracked run. Do not create a brainstorm state implicitly.
-4. Otherwise behave exactly like \`/cc-next\`: check current stage gates, resume if incomplete, advance if complete.
+4. Otherwise check current stage gates, resume if incomplete, and advance if complete.
 
 ## Headless mode
 
@@ -150,7 +151,7 @@ description: "Unified entry point for the cclaw flow. No args = resume/next. Wit
 
 \`/cc\` is the **starting command** for cclaw. It intelligently routes:
 
-- **No arguments** → acts as \`/cc-next\` only for an existing tracked flow; missing/fresh placeholder state blocks with start guidance
+- **No arguments** → resumes or progresses an existing tracked flow; missing/fresh placeholder state blocks with start guidance
 - **With a prompt** → classifies the task, picks a track (quick/medium/standard), and starts the **first stage of that track** (not always brainstorm — e.g. the \`quick\` track starts at \`spec\`)
 
 ## HARD-GATE
@@ -179,12 +180,12 @@ ${conversationLanguagePolicyMarkdown()}
 
    | Track | Triggers | Use when |
    |---|---|---|
-   | \`quick\` | \`bug\`, \`bugfix\`, \`fix\`, \`hotfix\`, \`patch\`, \`typo\`, \`regression\`, \`rename\`, \`bump\`, \`upgrade dep\`, \`docs only\`, \`comment\`, \`lint\`, \`format\`, \`small\`, \`tiny\`, \`one-liner\`, \`revert\`, \`copy change\` | Single-purpose, spec is essentially known, low blast radius |
+   | \`quick\` | \`bug\`, \`bugfix\`, \`fix\`, \`hotfix\`, \`patch\`, \`typo\`, \`regression\`, \`rename\`, \`bump\`, \`upgrade dep\`, \`docs only\`, \`comment\`, \`lint\`, \`format\`, \`small\`, \`tiny\`, \`one-liner\`, \`revert\`, \`copy change\` | Single-purpose, spec is essentially known, low blast radius; skips ceremony, not safety |
    | \`medium\` | \`add endpoint\`, \`add field\`, \`extend existing\`, \`wire integration\`, \`small migration\`, \`new screen following existing pattern\` | Additive work with existing architecture |
    | \`standard\` | \`new feature\`, \`refactor\`, \`migration\`, \`platform\`, \`architecture\`, \`schema\`, \`integrate\`, \`workflow\`, \`onboarding\` (or no confident quick/medium match) | New or uncertain multi-module work |
 
    - On conflict, prefer \`standard\` over \`medium\`, and \`medium\` over \`quick\`.
-   - Always state the recommendation as a one-line reason citing matched triggers and a high/medium/low track selection confidence. Clarify that the heuristic is advisory until the managed helper writes state; after that, \`/cc-next\` follows the selected track.
+   - Always state the recommendation as a one-line reason citing matched triggers and a high/medium/low track selection confidence. Clarify that the heuristic is advisory until the managed helper writes state; after that, \`/cc\` follows the selected track. Include override guidance: switch to standard when architecture, schema, migration, security, or unclear scope appears; switch to medium when product framing is needed but architecture is known.
 8. Run the managed start helper: \`node .cclaw/hooks/start-flow.mjs --track=<quick|medium|standard> --class=<class> --prompt=<prompt> --stack=<stack> --reason=<matched heuristic>\`. The helper writes \`${flowPath}\`, computes \`skippedStages\`, resets the gate catalog, and writes \`${RUNTIME_ROOT}/artifacts/00-idea.md\`. If it fails, STOP and report the exact command/output; do not manually edit flow state.
 9. Load and execute the **first stage skill of the chosen track** (\`brainstorming\` for medium/standard, \`specification-authoring\` for quick) plus its matching command file.
 
@@ -194,7 +195,7 @@ If mid-stage evidence contradicts the initial Class/Track decision (the "trivial
 
 ### Path B: \`/cc\` (no arguments)
 
-Delegate to \`/cc-next\` behavior only when a tracked flow exists:
+Progress the tracked flow only when one exists:
 
 1. Read \`${flowPath}\`.
 2. If missing, guide the user to run \`cclaw init\` and stop.
@@ -204,15 +205,17 @@ Delegate to \`/cc-next\` behavior only when a tracked flow exists:
 6. If complete → advance to next stage and execute.
 7. If flow is done → report completion.
 
-## When to use \`/cc\` vs \`/cc-next\`
+## Public flow habit
+
+Use \`/cc\` for the happy path:
 
 | Scenario | Command |
 |---|---|
 | Starting work for the first time | \`/cc\` or \`/cc <idea>\` |
 | Resuming in a new session | \`/cc\` |
-| Progressing after completing a stage | \`/cc-next\` |
+| Progressing after completing a stage | \`/cc\` |
 | Starting with a specific idea | \`/cc <idea>\` |
 
-Both commands read the same \`flow-state.json\`. The difference is that \`/cc <prompt>\` resolves class + track and starts that track's first stage, while \`/cc\` and \`/cc-next\` follow the current state.
+\`/cc <prompt>\` resolves class + track and starts that track's first stage; \`/cc\` without a prompt follows the current \`flow-state.json\`.
 `;
 }

package/dist/content/status-command.js

@@ -28,7 +28,8 @@ export function statusSubcommandMarkdown() {
 ## Overview
 
 \`/cc-view status\` is the quickest way to answer "where are we in the flow?" without
-advancing or mutating anything. Safe to run at any point. The snapshot reflects:
+advancing or mutating anything. Treat it as an operator note, not a JSON dump:
+progress, blockers, risks, next action, and human-readable gate/delegation/closeout labels. Safe to run at any point. The snapshot reflects:
 
 - progress across stages with per-stage markers,
 - gate coverage,
@@ -77,21 +78,21 @@ a read-only command.
     - harness row
     - stale stage row
 11. Suggest the next action:
-    - If current stage has unmet gates -> \`/cc-next\` to resume.
+    - If current stage has unmet gates -> \`/cc\` to resume.
     - If a mandatory delegation is missing evidence -> dispatch the worker/reviewer or waive with rationale; do not advance silently.
     - If a TDD blocker taxonomy code is present (\`NO_SOURCE_CONTEXT\`, \`NO_TEST_SURFACE\`, \`NO_IMPLEMENTABLE_SLICE\`, \`RED_NOT_EXPRESSIBLE\`, \`NO_VCS_MODE\`) -> name the blocker and the rewind/config route.
     - If review is blocked by critical findings -> show \`cclaw internal rewind tdd "review_blocked_by_critical <finding-ids>"\` plus the later \`cclaw internal rewind --ack tdd\`.
-    - If closeout substate is non-idle -> \`/cc-next\` to continue the chain.
-    - If current stage is complete -> \`/cc-next\` to advance (or report "Flow complete" if terminal).
+    - If closeout substate is non-idle -> \`/cc\` to continue the chain.
+    - If current stage is complete -> \`/cc\` to advance (or report "Flow complete" if terminal).
 
 ## Output Guidelines
 
 - Keep output compact (≤ 40 lines) — status, not narrative.
-- Start with the same operator rows as \`/cc-next\` when possible:
-  \`Current\`, \`Stage\`, \`Gates\`, \`Delegations\`, \`Blocked by\`, \`Next\`, \`Evidence needed\`.
+- Start with the same operator rows as \`/cc\` when possible:
+  \`Current\`, \`Stage\`, \`Progress\`, \`Gates\`, \`Delegations\`, \`Risks\`, \`Blocked by\`, \`Next\`, \`Evidence needed\`. Use labels like \`gate: tdd_green_full_suite\`, \`delegation proof: reviewer evidenceRefs\`, and \`closeout: compound_review\` instead of raw JSON tone.
 - When blocked, include a plain-English action block:
   \`Current: <stage or closeout substate>\`; \`Blocked by: <gate/delegation/blocker code>\`; \`Next: <exact command or managed remediation>\`; \`Evidence needed: <artifact/test/review/delegation evidence>\`.
-- Report counts, not full artifact contents. Include active subagent count from \`${subagentsPath()}\` and proof gaps from \`${delegationEventsPath()}\` when present.
+- Report counts, not full artifact contents. Include active subagent count from \`${subagentsPath()}\` and proof gaps from \`${delegationEventsPath()}\` when present. Convert gate/delegation state into human labels: \`passed\`, \`blocked\`, \`missing proof\`, \`waived with reason\`, \`stale\`, \`ready to advance\`, or the closeout substate label.
 - If any data source is missing or corrupt, say so explicitly rather than guessing.
 - Include \`/cc-view tree\` for deep structure and \`/cc-view diff\` for before/after map in the final line.
 
@@ -102,7 +103,7 @@ a read-only command.
 - Collapsing \`◎ missing-evidence\` into \`✓ completed\` — role-switch gaps must stay
   visible so the stage cannot advance silently.
 - Omitting the closeout row when \`shipSubstate !== "idle"\`; it is the only signal
-  that tells the user why \`/cc-next\` is about to run retro/compound/archive.
+  that tells the user why \`/cc\` is about to run retro/compound/archive.
 - Mutating state to "clean up" during a status check.
 `;
 }