cclaw-cli 0.49.0 → 0.51.0

package/dist/content/stages/tdd.js

@@ -1,3 +1,4 @@
+import { renderTrackTerminology, trackRenderContext } from "../track-render-context.js";
 // ---------------------------------------------------------------------------
 // TDD — RED → GREEN → REFACTOR cycle (merged test + build)
 // ---------------------------------------------------------------------------
@@ -7,9 +8,9 @@ export const TDD = {
     complexityTier: "standard",
     skillFolder: "test-driven-development",
     skillName: "test-driven-development",
-    skillDescription: "Full TDD cycle: RED (failing tests), GREEN (minimal implementation), REFACTOR (cleanup). One plan slice at a time with strict traceability.",
+    skillDescription: "Full TDD cycle: discover existing tests and system impact, then RED (failing tests), GREEN (minimal implementation), REFACTOR (cleanup). One plan slice at a time with strict traceability.",
     philosophy: {
-        hardGate: "Do NOT merge, ship, or skip review. Follow RED → GREEN → REFACTOR strictly for each plan slice. Do NOT write implementation code before RED tests exist. Do NOT skip the REFACTOR step.",
+        hardGate: "Do NOT merge, ship, or skip review. Follow RED → GREEN → REFACTOR strictly for each plan slice. Do NOT write implementation code before RED tests exist. Do NOT write RED tests before discovering relevant existing tests and impacted contracts. Do NOT skip the REFACTOR step.",
         ironLaw: "NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST — THE RED FAILURE IS THE SPEC.",
         purpose: "Implement features through the TDD cycle: write failing tests, make them pass with minimal code, then refactor.",
         whenToUse: [
@@ -28,50 +29,64 @@ export const TDD = {
             "Skipping evidence capture",
             "Undocumented refactor changes",
             "No full-suite GREEN evidence",
-            "Multiple tasks implemented in one pass without justification"
+            "Multiple tasks implemented in one pass without justification",
+            "Skipping test discovery and duplicating an existing test pattern blindly",
+            "Ignoring callbacks, state transitions, interfaces, or contract surfaces affected by the slice",
+            "Collapsing RED/GREEN/REFACTOR into one unreviewable checkpoint"
         ]
     },
     executionModel: {
         checklist: [
-            "Select plan slice — pick one task from the plan. Do not batch multiple tasks. Before starting, read `.cclaw/state/ralph-loop.json` (`loopIteration`, `acClosed[]`, `redOpenSlices[]`) so you skip cycles already closed.",
+            "Select plan slice — pick one task from the plan. Do not batch multiple tasks. Before starting, read `.cclaw/state/ralph-loop.json` (`loopIteration`, `acClosed[]`, `redOpenSlices[]`) so you skip cycles already closed. If `redOpenSlices[]` is non-empty, repair or explicitly park those slices before opening a new RED.",
             "Map to acceptance criterion — identify the specific spec criterion this test proves.",
-            "Dispatch mandatory `tdd-red` execution (or `test-author` in TEST_RED_ONLY mode) — produce failing behavior tests and RED evidence only (no production edits). Set `CCLAW_ACTIVE_AGENT=tdd-red` when supported.",
+            "Discover the test surface — inspect existing tests, fixtures, helpers, test commands, and nearby assertions before authoring RED. Reuse the local test style unless the slice genuinely needs a new pattern.",
+            "Run a system-wide impact check — name callbacks, state transitions, interfaces, schemas, CLI/config/API contracts, persistence, or event boundaries that this slice can affect. Add RED coverage for each affected public contract or record why it is out of scope.",
+            "Set execution posture — record whether this slice is sequential, batch-safe, or blocked; when the existing git workflow permits small commits, checkpoint after RED, GREEN, and REFACTOR (or record why commits are deferred).",
+            "Use the mandatory `test-author` delegation for RED — after discovery and impact check, produce failing behavior tests and RED evidence only (no production edits). Set `CCLAW_ACTIVE_AGENT=tdd-red` when the harness supports phase labels.",
             "RED: Capture failure output — copy the exact failure output as RED evidence. Record in artifact.",
-            "Dispatch `tdd-green` execution (or `test-author` in BUILD_GREEN_REFACTOR mode) — minimal implementation + full-suite GREEN. Set `CCLAW_ACTIVE_AGENT=tdd-green` when supported.",
+            "Continue the same `test-author` delegation intent for GREEN — minimal implementation plus full-suite GREEN evidence. Set `CCLAW_ACTIVE_AGENT=tdd-green` when the harness supports phase labels.",
             "GREEN: Run full suite — execute ALL tests, not just the ones you wrote. The full suite must be GREEN.",
             "GREEN: Verify no regressions — if any existing test breaks, fix the regression before proceeding.",
             "Run verification-before-completion discipline for the slice — capture a fresh test command, commit SHA, and explicit PASS/FAIL status before completion claims.",
-            "REFACTOR: Dispatch `tdd-refactor` execution (or dedicated refactor mode) to improve code quality without behavior changes. Set `CCLAW_ACTIVE_AGENT=tdd-refactor` when supported.",
-            "Record evidence — capture RED failure, GREEN output, and REFACTOR notes in the TDD artifact. When logging the `green` row via `/cc-ops tdd-log green`, attach the closed acceptance-criterion IDs in `acIds` so Ralph Loop status counts them.",
+            "REFACTOR: continue the `test-author` evidence cycle (or a dedicated refactor mode when available) to improve code quality without behavior changes. Set `CCLAW_ACTIVE_AGENT=tdd-refactor` when the harness supports phase labels.",
+            "Record evidence — capture test discovery, system-wide impact check, RED failure, GREEN output, and REFACTOR notes in the TDD artifact. When logging a `green` row, attach the closed acceptance-criterion IDs in `acIds` so Ralph Loop status counts them.",
             "Annotate traceability — link to plan task ID and spec criterion.",
             "Per-Slice Review (conditional) — if `.cclaw/config.yaml::sliceReview.enabled` is true and the slice meets any trigger (touchCount >= filesChangedThreshold, touchPaths match touchTriggers, or highRisk=true), append a `## Per-Slice Review` entry for this slice before moving on (see the dedicated section below).",
             "Repeat for each slice — return to step 1 for the next plan slice."
         ],
         interactionProtocol: [
             "Pick one planned slice at a time.",
-            "Controller owns orchestration; execution runs through phase-specific delegation (`tdd-red` -> `tdd-green` -> `tdd-refactor`) or equivalent `test-author` modes.",
+            "Controller owns orchestration; one mandatory `test-author` delegation carries phase-specific RED -> GREEN -> REFACTOR evidence instead of spawning separate workers by default.",
+            "Before writing RED tests, discover relevant existing tests and commands so the new test extends the suite instead of fighting it.",
+            "Before implementation, perform a system-wide impact check across callbacks, state, interfaces, schemas, and external contracts touched by the slice.",
             "Write behavior-focused tests before changing implementation (RED).",
             "Capture and store failing output as RED evidence.",
             "Apply minimal change to satisfy RED tests (GREEN).",
             "Run full suite, not partial checks, for GREEN validation.",
             "Before declaring the slice complete, run a fresh verification check and record command + commit SHA + PASS/FAIL.",
             "Refactor without changing behavior and document rationale (REFACTOR).",
+            "Use incremental RED/GREEN/REFACTOR commits when the repository workflow and working tree make that appropriate; otherwise record the checkpoint boundaries in the artifact.",
             "Stop if regressions appear and fix before proceeding.",
             "If a test passes unexpectedly, investigate: does the behavior already exist, or is the test wrong?",
-            "**Per-Slice Review checkpoint (conditional, opt-in).** When `.cclaw/config.yaml::sliceReview.enabled` is true, check every slice against the triggers before declaring it DONE. Triggers: `touchCount >= filesChangedThreshold`, any `touchPaths` match a `touchTriggers` glob, or the plan row declares `highRisk: true`. On a trigger, run two passes on the slice alone — (1) Spec-Compliance: trace RED/GREEN/REFACTOR evidence back to its plan task + spec criterion, noting edge cases the tests skip; (2) Quality: diff-scan for naming, error handling, dead code, simpler alternatives. Record both under `## Per-Slice Review` in `06-tdd.md`, naming the trigger that fired. Dispatch the `reviewer` subagent natively when available (log `fulfillmentMode: \"isolated\"`); otherwise fulfil via in-session role switch (`fulfillmentMode: \"role-switch\"`). Never fabricate an isolated pass from memory. Tracks outside `sliceReview.enforceOnTracks` still emit the section; doctor only escalates missed reviews on enforced tracks."
+            "**Per-Slice Review point (conditional, opt-in).** When `.cclaw/config.yaml::sliceReview.enabled` is true, check every slice against the triggers before declaring it DONE. Triggers: `touchCount >= filesChangedThreshold`, any `touchPaths` match a `touchTriggers` glob, or the plan row declares `highRisk: true`. On a trigger, run two passes on the slice alone — (1) Spec-Compliance: trace RED/GREEN/REFACTOR evidence back to its plan task + spec criterion, noting edge cases the tests skip; (2) Quality: diff-scan for naming, error handling, dead code, simpler alternatives. Record both under `## Per-Slice Review` in `06-tdd.md`, naming the trigger that fired. Dispatch the `reviewer` subagent natively when available (log `fulfillmentMode: \"isolated\"`); otherwise fulfil via in-session role switch (`fulfillmentMode: \"role-switch\"`). Never fabricate an isolated pass from memory. Tracks outside `sliceReview.enforceOnTracks` still emit the section; doctor only escalates missed reviews on enforced tracks."
         ],
         process: [
             "Select slice and map to acceptance criterion.",
-            "Dispatch `tdd-red` (or `test-author` TEST_RED_ONLY mode) and produce failing test(s) for expected reason (RED).",
+            "Discover existing tests, fixtures, helpers, and exact test commands for the affected area.",
+            "Check system-wide impact across callbacks, state transitions, interfaces, schemas, and external contracts.",
+            "Record execution posture and checkpoint plan for RED/GREEN/REFACTOR commits or deferred commits.",
+            "Use `test-author` in RED intent and produce failing test(s) for the expected reason (RED).",
             "Run tests and capture failure output.",
-            "Dispatch `tdd-green` (or `test-author` BUILD_GREEN_REFACTOR mode) and implement smallest change needed for GREEN.",
+            "Use `test-author` in GREEN intent and implement the smallest change needed for GREEN.",
             "Run full tests and build checks.",
             "Run a fresh verification-before-completion check and capture command + commit SHA + PASS/FAIL in guard evidence.",
-            "Dispatch `tdd-refactor` pass preserving behavior.",
+            "Run the REFACTOR intent preserving behavior.",
             "Record RED, GREEN, and REFACTOR evidence in artifact.",
             "Annotate traceability to plan task and spec criterion; on `sliceReview` triggers, append a Per-Slice Review entry before closing the slice."
         ],
         requiredGates: [
+            { id: "tdd_test_discovery_complete", description: "Relevant existing tests, fixtures, helpers, and runnable commands were discovered before RED tests were written." },
+            { id: "tdd_impact_check_complete", description: "Callbacks, state transitions, interfaces, schemas, and contracts affected by the slice were checked before implementation." },
             { id: "tdd_red_test_written", description: "Failing tests exist before implementation changes." },
             { id: "tdd_green_full_suite", description: "Full relevant suite passes in GREEN state." },
             { id: "tdd_refactor_completed", description: "Refactor pass completed with behavior preservation verified." },
@@ -80,7 +95,10 @@ export const TDD = {
             { id: "tdd_docs_drift_check", description: "When public API/config/CLI surfaces change, docs drift is addressed via a completed doc-updater pass." }
         ],
         requiredEvidence: [
-            "Artifact updated at `.cclaw/artifacts/06-tdd.md` with RED, GREEN, and REFACTOR sections.",
+            "Artifact updated at `.cclaw/artifacts/06-tdd.md` with Test Discovery, System-Wide Impact Check, RED, GREEN, and REFACTOR sections.",
+            "Relevant existing test files, helpers, fixtures, and exact commands identified before RED.",
+            "Callbacks, state transitions, interfaces, schemas, and contracts checked for impact before implementation.",
+            "Execution posture and RED/GREEN/REFACTOR checkpoint plan recorded, including commit boundaries when the repo workflow supports them.",
             "Failing command output captured (RED).",
             "Full test/build output recorded (GREEN).",
             "Fresh verification evidence recorded with command, commit SHA, and PASS/FAIL status before completion.",
@@ -90,14 +108,17 @@ export const TDD = {
             "Traceability to task identifier is documented."
         ],
         inputs: ["approved plan slice", "spec acceptance criterion", "test harness configuration", "coding standards and constraints"],
-        requiredContext: ["plan artifact", "spec artifact", "existing test patterns"],
+        requiredContext: ["plan artifact", "spec artifact", "existing test patterns", "affected contracts and state boundaries"],
         blockers: [
+            "test discovery skipped before RED",
+            "system-wide impact check missing for callbacks/state/interfaces/contracts",
             "tests pass before behavior change (RED failure missing)",
             "full suite not green",
             "behavior changed during refactor",
             "no evidence recorded"
         ],
         exitCriteria: [
+            "test discovery and system-wide impact check are recorded",
             "RED evidence exists and is traceable",
             "GREEN evidence captured with full suite pass",
             "REFACTOR evidence captured",
@@ -120,6 +141,10 @@ export const TDD = {
             traceabilityRule: "Every RED test traces to a plan task. Every GREEN change traces to a RED test. Every plan task traces to a spec criterion. Design decisions inform test strategy. Evidence chain must be unbroken."
         },
         artifactValidation: [
+            { section: "Upstream Handoff", required: false, validationRule: "Summarizes plan/spec/design decisions, constraints, open questions, and explicit drift before RED work." },
+            { section: "Test Discovery", required: true, validationRule: "Before RED: lists existing tests, fixtures/helpers, exact commands, and the chosen local pattern to extend." },
+            { section: "System-Wide Impact Check", required: true, validationRule: "Before implementation: names affected callbacks, state transitions, interfaces, schemas, public APIs/config/CLI, persistence, or event contracts, with coverage or explicit out-of-scope notes." },
+            { section: "Execution Posture", required: false, validationRule: "Records sequential/batch/blocked posture and RED/GREEN/REFACTOR checkpoint plan, including incremental commit boundaries when consistent with the repository git workflow." },
             { section: "RED Evidence", required: true, validationRule: "Failing test output captured per slice." },
             { section: "Acceptance Mapping", required: false, validationRule: "Each RED test links to a plan task and spec criterion." },
             { section: "Failure Analysis", required: false, validationRule: "Failure reason matches expected missing behavior." },
@@ -139,6 +164,8 @@ export const TDD = {
             {
                 title: "RED Evidence Audit",
                 evaluationPoints: [
+                    "Did every slice discover relevant existing tests, helpers, fixtures, and commands before adding RED coverage?",
+                    "Does the system-wide impact check cover callbacks, state transitions, interfaces, schemas, and public contracts touched by the slice?",
                     "Does every slice have a captured failing test output?",
                     "Does each failure reason match the expected missing behavior (not a typo or config error)?",
                     "Were tests written BEFORE any production code for that slice?",
@@ -152,6 +179,7 @@ export const TDD = {
                 evaluationPoints: [
                     "Does GREEN evidence show a FULL suite pass (not partial)?",
                     "Is the GREEN implementation minimal — no features beyond what RED tests require?",
+                    "Do checkpoint notes or commits keep RED, GREEN, and REFACTOR reviewable according to the repository git workflow?",
                     "Does the REFACTOR step preserve all existing behavior (no new failures)?",
                     "Are REFACTOR notes documented with rationale?",
                     "Is traceability complete: every change links to plan task ID and spec criterion?"
@@ -203,53 +231,48 @@ export const TDD = {
     next: "review",
     batchExecutionAllowed: true
 };
-function quickTrackText(value) {
-    return value
-        .replace(/\btask from the plan\b/giu, "acceptance criterion from the spec")
-        .replace(/\bplan task ID\b/giu, "acceptance criterion ID")
-        .replace(/\bplan task\b/giu, "acceptance criterion")
-        .replace(/\bplan row\b/giu, "acceptance row")
-        .replace(/\bplan slice\b/giu, "acceptance slice")
-        .replace(/\bplan artifact\b/giu, "spec artifact")
-        .replace(/\btraceable to plan slice\b/giu, "traceable to acceptance criterion")
-        .replace(/05-plan\.md/gu, "04-spec.md");
-}
-function tddQuickTrackVariant() {
+function tddStageVariantForTrack(track) {
+    const renderContext = trackRenderContext(track);
+    if (renderContext.usesPlanTerminology) {
+        return TDD;
+    }
     return {
         ...TDD,
-        // Quick track keeps the same stage intent but rewrites plan-centric language to spec-centric language.
-        skillDescription: quickTrackText(TDD.skillDescription),
+        skillDescription: renderTrackTerminology(TDD.skillDescription, renderContext),
         philosophy: {
             ...TDD.philosophy,
-            hardGate: quickTrackText(TDD.philosophy.hardGate)
+            hardGate: renderTrackTerminology(TDD.philosophy.hardGate, renderContext)
         },
         executionModel: {
             ...TDD.executionModel,
-            checklist: TDD.executionModel.checklist.map(quickTrackText),
-            interactionProtocol: TDD.executionModel.interactionProtocol.map(quickTrackText),
-            process: TDD.executionModel.process.map(quickTrackText),
+            checklist: TDD.executionModel.checklist.map((value) => renderTrackTerminology(value, renderContext)),
+            interactionProtocol: TDD.executionModel.interactionProtocol
+                .map((value) => renderTrackTerminology(value, renderContext)),
+            process: TDD.executionModel.process.map((value) => renderTrackTerminology(value, renderContext)),
             requiredGates: TDD.executionModel.requiredGates
                 .filter((gate) => gate.id !== "tdd_traceable_to_plan")
                 .map((gate) => ({
                 ...gate,
-                description: quickTrackText(gate.description)
+                description: renderTrackTerminology(gate.description, renderContext)
             })),
-            requiredEvidence: TDD.executionModel.requiredEvidence.map(quickTrackText),
-            inputs: TDD.executionModel.inputs.map(quickTrackText),
-            requiredContext: ["spec artifact", "existing test patterns"]
+            requiredEvidence: TDD.executionModel.requiredEvidence
+                .map((value) => renderTrackTerminology(value, renderContext)),
+            inputs: TDD.executionModel.inputs.map((value) => renderTrackTerminology(value, renderContext)),
+            requiredContext: [renderContext.upstreamArtifactLabel, "existing test patterns", "affected contracts and state boundaries"]
         },
         reviewLens: {
             ...TDD.reviewLens,
             reviewSections: TDD.reviewLens.reviewSections.map((section) => ({
                 ...section,
-                evaluationPoints: section.evaluationPoints.map(quickTrackText)
+                evaluationPoints: section.evaluationPoints
+                    .map((point) => renderTrackTerminology(point, renderContext))
             }))
         },
         artifactRules: {
             ...TDD.artifactRules,
             crossStageTrace: {
                 ...TDD.artifactRules.crossStageTrace,
-                readsFrom: [".cclaw/artifacts/04-spec.md"],
+                readsFrom: [renderContext.upstreamArtifactPath],
                 traceabilityRule: "Every RED test traces to an acceptance criterion. Every GREEN change traces to a RED test. Evidence chain must be unbroken."
             },
             artifactValidation: TDD.artifactRules.artifactValidation.map((row) => {
@@ -268,15 +291,12 @@ function tddQuickTrackVariant() {
                 }
                 return {
                     ...row,
-                    validationRule: quickTrackText(row.validationRule)
+                    validationRule: renderTrackTerminology(row.validationRule, renderContext)
                 };
             })
         }
     };
 }
 export function tddStageForTrack(track) {
-    if (track === "quick") {
-        return tddQuickTrackVariant();
-    }
-    return TDD;
+    return tddStageVariantForTrack(track);
 }

package/dist/content/start-command.js

@@ -1,5 +1,4 @@
 import { RUNTIME_ROOT } from "../constants.js";
-import { FLOW_MAP_REL_PATH } from "./flow-map.js";
 const START_SKILL_FOLDER = "flow-start";
 const START_SKILL_NAME = "flow-start";
 function flowStatePath() {
@@ -79,17 +78,18 @@ This is the **recommended way to start** working with cclaw. Use \`/cc-next\` fo
    - **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**.
-8. Present the recommendation as a single decision with explicit options:
+8. Present one compact **Start framing** summary: class, recommended track, 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.
    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.
-9. Persist the chosen track to \`${flowPath}\` (\`track\` field). Compute \`skippedStages\` from the track and write that too. Use the **first stage of the chosen track** as \`currentStage\` (quick → \`spec\`, medium/standard → \`brainstorm\`, trivial fast-path → \`design\` or \`spec\` per Phase 0).
-10. Write the prompt to \`.cclaw/artifacts/00-idea.md\` with the following header lines: \`Class:\` (from Phase 0), \`Track:\` (chosen track + matched heuristic), \`Stack:\` (from Phase 2 detection, or \`unknown\`), and a \`Discovered context\` section if Phase 1/seed recall found references.
-11. Load the **first-stage skill for the chosen track** and its command file:
-    - quick → \`.cclaw/skills/specification-authoring/SKILL.md\` + \`.cclaw/commands/spec.md\`
-    - medium/standard → \`.cclaw/skills/brainstorming/SKILL.md\` + \`.cclaw/commands/brainstorm.md\`
+10. Persist the chosen track to \`${flowPath}\` (\`track\` field). Compute \`skippedStages\` from the track and write that too. Use the **first stage of the chosen track** as \`currentStage\` (quick → \`spec\`, medium/standard → \`brainstorm\`, trivial fast-path → \`design\` or \`spec\` per Phase 0).
+11. Write the prompt to \`.cclaw/artifacts/00-idea.md\` with the following header lines: \`Class:\` (from Phase 0), \`Track:\` (chosen track + matched heuristic), \`Stack:\` (from Phase 2 detection, or \`unknown\`), and a \`Discovered context\` section if Phase 1/seed recall found references.
+12. Load the **first-stage skill for the chosen track** and its command file:
+    - quick → \`.cclaw/skills/specification-authoring/SKILL.md\`
+    - medium/standard → \`.cclaw/skills/brainstorming/SKILL.md\`
     - trivial fast-path → design or spec skill per Phase 0 decision.
-12. Execute that stage with the prompt + Phase 1/Phase 2 + seed context as initial input.
+13. Execute that stage with the prompt + Phase 1/Phase 2 + seed context as initial input.
 
 ### Reclassification on discovery
 
@@ -124,9 +124,7 @@ Validate envelopes with:
 
 ## Surface reference
 
-For the 1-page overview of cclaw (stages, routers, Ralph Loop, state
-files) load \`${FLOW_MAP_REL_PATH}\` — useful when a fresh session
-needs orientation before \`/cc <prompt>\` runs.
+Use the start skill plus \`.cclaw/state/flow-state.json\` for orientation before \`/cc <prompt>\` runs.
 `;
 }
 /**
@@ -165,7 +163,7 @@ Do **not** silently discard an existing flow when the user provides a prompt. If
    - Inform: "You have an active flow at stage **{currentStage}** with {N} completed stages. Starting a new tracked flow will reset progress."
    - Ask: "Continue with reset? (A) Yes, start fresh (B) No, resume current flow"
    - If (B) → switch to Path B behavior.
-7. **Classify the idea** using the heuristic below and present a single track recommendation. Wait for explicit confirmation or override before mutating any state.
+7. **Classify the idea** using the heuristic below and present one compact Start framing summary (class, track, stack, origin docs, seed recalls, next action). Wait for explicit confirmation or override before mutating any state only when reset/conflict/ambiguity makes it necessary.
    - If \`${RUNTIME_ROOT}/config.yaml\` defines \`trackHeuristics\`, apply those vocabulary hints (\`fallback\`, \`tracks.<id>.{triggers,veto}\`) on top of built-in defaults. Evaluation order is fixed: \`standard -> medium -> quick\`. (Honest note: this is advisory prose; the LLM applies it, not a Node-level router.)
 
    **Track heuristic** (lowercase substring match against the user prompt):

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

@@ -1,9 +1,4 @@
 /**
- * Command contract for /cc-view status — a read-only snapshot command.
- * Does not mutate state. Always safe to run.
+ * Body for /cc-view status — read-only status snapshot embedded in flow-view.
  */
-export declare function statusCommandContract(): string;
-/**
- * Skill body for /cc-view status — read-only status snapshot.
- */
-export declare function statusCommandSkillMarkdown(): string;
+export declare function statusSubcommandMarkdown(): string;

package/dist/content/status-command.js

@@ -1,6 +1,4 @@
 import { RUNTIME_ROOT } from "../constants.js";
-const STATUS_SKILL_FOLDER = "flow-status";
-const STATUS_SKILL_NAME = "flow-status";
 function flowStatePath() {
     return `${RUNTIME_ROOT}/state/flow-state.json`;
 }
@@ -10,134 +8,16 @@ function delegationLogPath() {
 function knowledgePath() {
     return `${RUNTIME_ROOT}/knowledge.jsonl`;
 }
-function contextModePath() {
-    return `${RUNTIME_ROOT}/state/context-mode.json`;
-}
-function checkpointPath() {
-    return `${RUNTIME_ROOT}/state/checkpoint.json`;
-}
-function stageActivityPath() {
-    return `${RUNTIME_ROOT}/state/stage-activity.jsonl`;
-}
-function snapshotPath() {
-    return `${RUNTIME_ROOT}/state/flow-state.snapshot.json`;
-}
-function harnessGapsPath() {
-    return `${RUNTIME_ROOT}/state/harness-gaps.json`;
-}
 function retroArtifactPath() {
     return `${RUNTIME_ROOT}/artifacts/09-retro.md`;
 }
 /**
- * Command contract for /cc-view status — a read-only snapshot command.
- * Does not mutate state. Always safe to run.
- */
-export function statusCommandContract() {
-    const flowPath = flowStatePath();
-    const delegationPath = delegationLogPath();
-    return `# /cc-view status
-
-## Purpose
-
-**Read-only visual snapshot of the cclaw run.** Shows progress bar, current stage,
-gate coverage, delegation status with fulfillmentMode, closeout substate after
-ship, harness parity fallback, stale markers, and top knowledge highlights.
-
-This command **never mutates state**. Use it at session start to orient, or at any
-time to answer "where are we?" without advancing the flow.
-
-## HARD-GATE
-
-- **Do not** use \`/cc-view status\` output to infer gate completion for decisions — cite
-  artifact evidence via \`/cc-next\` when advancing.
-- **Do not** mutate \`${flowPath}\` or delegation log from this command.
-- **Do not** rewrite \`${snapshotPath()}\` from this command (use \`/cc-view diff\`).
-
-## Algorithm
-
-1. Read **\`${flowPath}\`** — capture \`track\`, \`currentStage\`, \`completedStages\`,
-   \`skippedStages\`, \`staleStages\`, per-stage gate catalog, and **\`closeout\`**
-   (shipSubstate + retro/compound flags).
-2. Read **\`${delegationPath}\`** — for each mandatory agent of the current stage,
-   capture \`status\`, \`fulfillmentMode\`, and whether \`evidenceRefs\` are present.
-3. Read **\`${contextModePath()}\`** — surface \`activeMode\` (default if missing).
-4. Compute **time in current stage** from the most recent stage-entry signal:
-   - Prefer \`${checkpointPath()}\`'s \`timestamp\` when its \`stage\` matches \`currentStage\`.
-   - Otherwise scan \`${stageActivityPath()}\` from the end for the first entry whose \`stage\` matches \`currentStage\` and use its \`ts\`.
-   - Compute the duration as \`now - signalTimestamp\` and render compactly: \`<X>m\`, \`<X>h<Y>m\`, or \`<X>d<Y>h\`.
-   - If no signal exists, render \`(unknown)\`.
-5. Optionally read **\`${snapshotPath()}\`** to compute gate delta versus prior baseline:
-   - If missing or invalid, render \`delta: (baseline unavailable; run /cc-view diff)\`.
-6. Read **\`${harnessGapsPath()}\`** (schemaVersion 2). For every installed harness
-   capture \`tier\`, \`subagentFallback\`, and \`playbookPath\` for the harness row.
-7. Read the top of **\`${knowledgePath()}\`** — surface up to 3 most recent entries
-   (by trailing timestamp or source marker).
-8. Detect **closeout artifacts**: check whether \`${retroArtifactPath()}\` exists on
-   disk and annotate the closeout row accordingly.
-9. Emit the visual status block described below. Do **not** load any stage skill.
-
-## Visual markers
-
-Default UTF markers: \`✓\` passed, \`▶\` current, \`○\` pending, \`⊘\` skipped, \`⏸\` stale, \`✗\` blocked.  
-ASCII fallback (no UTF locale): \`[x]\`, \`[>]\`, \`[ ]\`, \`[-]\`, \`[=]\`, \`[!]\`.
-
-Delegation markers: \`✓\` completed, \`◎\` completed-no-evidence (role-switch
-harness; **blocks stage**), \`○\` scheduled/pending, \`⊘\` waived, \`✗\` failed.
-
-## Status Block Format
-
-\`\`\`
-cclaw status
-  flow:    <track> · run=<runId> · feature=<feature-id>
-  stage:   <stage> (<N>/<total>) · time <Xd|XhYm|Xm|unknown> · mode <activeMode>
-  bar:     [✓ brainstorm] [✓ scope] [▶ design] [○ spec] [○ plan] [○ tdd] [○ review] [○ ship]
-  gates:   now <passed>/<required> · blocked <count> · delta <summary or baseline-unavailable>
-  delegations (<expectedMode>):
-    - planner      ✓ completed  mode=<isolated|generic-dispatch|role-switch>
-    - reviewer     ○ pending
-    - test-author  ◎ missing-evidence (role-switch; add evidenceRefs)
-  closeout: <shipSubstate> · retro=<drafted|accepted|skipped|—> · compound=<N promoted|skipped|—>
-  harness: <id>=<tier>/<fallback>, ... · playbooks: <M>/<N>
-  stale:   <list or none>
-  knowledge:
-    - <latest entry summary>
-    - <second entry summary>
-    - <third entry summary>
-  next: /cc-next · /cc-view tree · /cc-view diff
-\`\`\`
-
-- Omit the \`closeout:\` row when \`currentStage !== "ship"\` and \`shipSubstate === "idle"\`.
-- Omit \`delegations\` line when the current stage has zero mandatory delegations.
-- Omit \`harness\` line only when \`${harnessGapsPath()}\` is missing or invalid
-  (render \`harness: (report unavailable; run cclaw upgrade)\`).
-
-## Anti-patterns
-
-- Inventing gate status without reading \`${flowPath}\`.
-- Reporting delegations as satisfied when the log says \`pending\`.
-- Treating a \`completed\` role-switch delegation without \`evidenceRefs\` as green
-  — it must surface as \`◎ missing-evidence\`.
-- Advancing the stage from \`/cc-view status\` — progression belongs to \`/cc-next\`.
-- Hiding the closeout substate after ship; retro/compound/archive progress must
-  be visible so \`/cc-next\` resumes at the right step.
-
-## Primary skill
-
-**${RUNTIME_ROOT}/skills/${STATUS_SKILL_FOLDER}/SKILL.md**
-`;
-}
-/**
- * Skill body for /cc-view status — read-only status snapshot.
+ * Body for /cc-view status — read-only status snapshot embedded in flow-view.
  */
-export function statusCommandSkillMarkdown() {
+export function statusSubcommandMarkdown() {
     const flowPath = flowStatePath();
     const delegationPath = delegationLogPath();
-    return `---
-name: ${STATUS_SKILL_NAME}
-description: "Read-only visual snapshot of the cclaw flow with progress bar, gate delta, delegations (fulfillmentMode + evidence), closeout substate, and harness parity row."
----
-
-# /cc-view status — Flow Status Snapshot
+    return `# /cc-view status — Flow Status Snapshot
 
 ## Overview
 
@@ -145,38 +25,29 @@ description: "Read-only visual snapshot of the cclaw flow with progress bar, gat
 advancing or mutating anything. Safe to run at any point. The snapshot reflects:
 
 - progress across stages with per-stage markers,
-- gate coverage and delta vs. baseline,
+- gate coverage,
 - mandatory delegations with **fulfillmentMode** (isolated / generic-dispatch /
-  role-switch / harness-waiver) and evidence gate,
+  role-switch) plus explicit waived status and evidence gate,
 - **closeout substate** after ship (retro → compound → archive),
 - **harness parity row** (tier + fallback) for the active harness set.
 
 ## HARD-GATE
 
 Do **not** mutate \`${flowPath}\` or \`${delegationPath}\` from this skill. This is
-a read-only command. Do **not** update \`${snapshotPath()}\` here.
+a read-only command.
 
 ## Algorithm
 
 1. Read \`${flowPath}\`. If missing → report **BLOCKED: flow state absent** and suggest \`cclaw init\`.
 2. Read \`${delegationPath}\`. Missing → treat all mandatory delegations as pending.
-3. Read \`${contextModePath()}\` for \`activeMode\`. Missing → render \`activeMode = default\`.
-4. Compute **time in stage**:
-   - Prefer \`${checkpointPath()}\` when \`stage === currentStage\` and \`timestamp\` parses as ISO 8601.
-   - Else scan \`${stageActivityPath()}\` from tail for the most recent entry whose \`stage === currentStage\`; use its \`ts\`.
-   - Render \`<X>d<Y>h\`, \`<X>h<Y>m\`, \`<X>m\`, or \`(unknown)\`.
-5. Try reading \`${snapshotPath()}\` for gate delta:
-   - If available, compare current stage \`passed\` / \`blocked\` sets against baseline.
-   - If unavailable, render \`delta: (baseline unavailable; run /cc-view diff)\`.
-6. Read \`${harnessGapsPath()}\`:
-   - If \`schemaVersion === 2\`, for each entry render \`<harness>=<tier>/<subagentFallback>\`.
-   - Count existing \`playbookPath\` files on disk to print \`playbooks: <M>/<N>\`.
-   - If the file is missing or has an older schema, render
-     \`harness: (report unavailable; run cclaw upgrade)\`.
-7. Read \`${RUNTIME_ROOT}/knowledge.jsonl\`. If missing or empty → knowledge highlights are \`(none recorded)\`. Parse each line as JSON and surface its \`trigger\`/\`action\`.
-8. For each gate in \`stageGateCatalog[currentStage].required\`:
+3. Render **time in stage** as \`(unknown)\` unless visible conversation or
+   artifact handoff context gives a timestamp.
+4. Summarize current-stage gate counts from \`passed\`, \`blocked\`, and required gate metadata.
+5. Derive harness \`<tier>/<fallback>\` rows from cclaw capability metadata.
+6. Read \`${RUNTIME_ROOT}/knowledge.jsonl\`. If missing or empty → knowledge highlights are \`(none recorded)\`. Parse each line as JSON and surface its \`trigger\`/\`action\`.
+7. For each gate in \`stageGateCatalog[currentStage].required\`:
    - Satisfied if present in \`passed\` and absent from \`blocked\`.
-9. For each mandatory delegation of the current stage, evaluate:
+8. For each mandatory delegation of the current stage, evaluate:
    - \`✓ completed\` when \`status === "completed"\` and (harness is not role-switch
      **or** \`evidenceRefs.length >= 1\`).
    - \`◎ missing-evidence\` when \`status === "completed"\`, harness declares
@@ -184,22 +55,22 @@ a read-only command. Do **not** update \`${snapshotPath()}\` here.
    - \`○ <status>\` for \`scheduled\` / pending.
    - \`⊘ waived\` when \`status === "waived"\`.
    - \`✗ failed\` when \`status === "failed"\`.
-10. Compute **closeout row** when \`currentStage === "ship"\` or
+9. Compute **closeout row** when \`currentStage === "ship"\` or
     \`closeout.shipSubstate !== "idle"\`:
     - \`shipSubstate\` verbatim,
     - \`retro=drafted|accepted|skipped|—\` derived from \`closeout.retroDraftedAt\`,
       \`closeout.retroAcceptedAt\`, \`closeout.retroSkipped\`,
     - \`compound=<N promoted>|skipped|—\` from
       \`closeout.compoundPromoted\` / \`closeout.compoundSkipped\`.
-11. Build and print the visual status block:
+10. Build and print the visual status block:
     - stage header
     - one-line progress bar with per-stage markers
-    - gate summary + delta
+    - gate summary
     - delegation rows (per mandatory agent)
     - closeout row (when active)
     - harness row
     - stale stage row
-12. Suggest the next action:
+11. Suggest the next action:
     - If current stage has unmet gates → \`/cc-next\` to resume.
     - 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).
@@ -207,6 +78,8 @@ a read-only command. Do **not** update \`${snapshotPath()}\` here.
 ## Output Guidelines
 
 - Keep output compact (≤ 40 lines) — status, not narrative.
+- Start with the same operator rows as \`/cc-next\` when possible:
+  \`Stage\`, \`Gates\`, \`Delegations\`, \`Blockers\`, \`Next\`.
 - Report counts, not full artifact contents.
 - 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.

package/dist/content/subagents.d.ts

@@ -1,8 +1,3 @@
-/**
- * Markdown content generators for Cclaw’s subagent orchestration skills and enhanced
- * specialist payloads. Cclaw materializes static instructions — this module does not
- * execute orchestration logic at install time beyond string assembly.
- */
 export declare function subagentDrivenDevSkill(): string;
 export declare function parallelAgentsSkill(): string;
 /**