cclaw-cli 0.11.0 → 0.13.0

package/dist/content/status-command.js

@@ -19,6 +19,9 @@ function checkpointPath() {
 function stageActivityPath() {
     return `${RUNTIME_ROOT}/state/stage-activity.jsonl`;
 }
+function snapshotPath() {
+    return `${RUNTIME_ROOT}/state/flow-state.snapshot.json`;
+}
 /**
  * Command contract for /cc-status — a read-only snapshot command.
  * Does not mutate state. Always safe to run.
@@ -30,8 +33,8 @@ export function statusCommandContract() {
 
 ## Purpose
 
-**Read-only snapshot of the cclaw run.** Shows track, current stage, completed stages,
-gate coverage, mandatory delegations, and the top 3 knowledge highlights.
+**Read-only visual snapshot of the cclaw run.** Shows progress bar, current stage,
+gate coverage, delegation status, 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.
@@ -41,6 +44,7 @@ time to answer "where are we?" without advancing the flow.
 - **Do not** use \`/cc-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-diff\`).
 
 ## Algorithm
 
@@ -54,38 +58,32 @@ time to answer "where are we?" without advancing the flow.
    - 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. Read the top of **\`${knowledgePath}\`** — surface up to 3 most recent entries
+5. Optionally read **\`${snapshotPath()}\`** to compute gate delta versus prior baseline:
+   - If missing or invalid, render \`delta: (baseline unavailable; run /cc-diff)\`.
+6. Read the top of **\`${knowledgePath}\`** — surface up to 3 most recent entries
    (by trailing timestamp or source marker).
-6. Emit the status block described below. Do **not** load any stage skill.
+7. 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]\`, \`[>]\`, \`[ ]\`, \`[-]\`, \`[=]\`, \`[!]\`.
 
 ## Status Block Format
 
 \`\`\`
 cclaw status
-  track:            <quick|standard>
-  current stage:    <stage>     (<N>/<total> in track)
-  time in stage:    <Xd Yh | Yh Zm | Zm | unknown>
-  context mode:     <activeMode>     (default | execution | review | incident | …)
-  completed stages: <list or "none">
-  skipped stages:   <list or "none">
-
-  gates:
-    passed:   <count> of <required>
-    blocked:  <count>
-    unmet:    <list of gate ids>
-
-  delegations (current stage):
-    required:  <list>
-    completed: <list>
-    pending:   <list>
-
-  knowledge highlights:
-    - <latest entry summary line>
-    - <second entry summary line>
-    - <third entry summary line>
-
-  next action:
-    /cc-next  (advance or resume current stage)
+  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: [✓ <role>] [○ <role>] ...
+  stale:  <list or none>
+  knowledge:
+    - <latest entry summary>
+    - <second entry summary>
+    - <third entry summary>
+  next: /cc-next · /cc-tree · /cc-diff
 \`\`\`
 
 ## Anti-patterns
@@ -93,6 +91,7 @@ cclaw status
 - Inventing gate status without reading \`${flowPath}\`.
 - Reporting delegations as satisfied when the log says \`pending\`.
 - Advancing the stage from \`/cc-status\` — progression belongs to \`/cc-next\`.
+- Hiding stale stages; stale markers must be surfaced directly in the status line.
 
 ## Primary skill
 
@@ -107,7 +106,7 @@ export function statusCommandSkillMarkdown() {
     const delegationPath = delegationLogPath();
     return `---
 name: ${STATUS_SKILL_NAME}
-description: "Read-only snapshot of the cclaw flow: track, stage, gate coverage, delegations, knowledge highlights. Never mutates state."
+description: "Read-only visual snapshot of the cclaw flow with progress bar, gate delta, delegations, and stale markers."
 ---
 
 # /cc-status — Flow Status Snapshot
@@ -120,7 +119,7 @@ advancing or mutating anything. Safe to run at any point.
 ## HARD-GATE
 
 Do **not** mutate \`${flowPath}\` or \`${delegationPath}\` from this skill. This is
-a read-only command.
+a read-only command. Do **not** update \`${snapshotPath()}\` here.
 
 ## Algorithm
 
@@ -131,19 +130,28 @@ a read-only command.
    - 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. Read \`${RUNTIME_ROOT}/knowledge.jsonl\`. If missing or empty → knowledge highlights are \`(none recorded)\`. Parse each line as JSON and surface its \`trigger\`/\`action\`.
-6. For each gate in \`stageGateCatalog[currentStage].required\`:
+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-diff)\`.
+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\`.
-7. Build and print the status block (see command contract for layout).
-8. Suggest the next action:
+8. Build and print the visual status block:
+   - stage header
+   - one-line progress bar with per-stage markers
+   - gate summary + delta
+   - delegation row
+   - stale stage row
+9. Suggest the next action:
    - If current stage has unmet gates → \`/cc-next\` to resume.
    - If current stage is complete → \`/cc-next\` to advance (or report "Flow complete" if terminal).
 
 ## Output Guidelines
 
-- Keep output compact (≤ 25 lines) — status, not narrative.
+- Keep output compact (≤ 30 lines) — status, not narrative.
 - Report counts, not full artifact contents.
 - If any data source is missing or corrupt, say so explicitly rather than guessing.
+- Include \`/cc-tree\` for deep structure and \`/cc-diff\` for before/after map in the final line.
 
 ## Anti-patterns
 

package/dist/content/subagents.d.ts

@@ -7,7 +7,7 @@ export declare function subagentDrivenDevSkill(): string;
 export declare function parallelAgentsSkill(): string;
 /**
  * Returns markdown fragments augmenting each specialist persona with Task tool
- * delegation guidance. Combine with the existing `body` field from `agents.ts`.
+ * delegation guidance. Combine with the existing `body` field from `core-agents.ts`.
  */
 export declare function enhancedAgentBody(agentName: string): string;
 export declare function subagentsAgentsMdBlock(): string;

package/dist/content/subagents.js

@@ -5,16 +5,10 @@
  */
 const SUBAGENT_AGENT_NAMES = [
     "planner",
-    "spec-reviewer",
-    "code-reviewer",
+    "reviewer",
     "security-reviewer",
     "test-author",
-    "doc-updater",
-    "repo-research-analyst",
-    "learnings-researcher",
-    "framework-docs-researcher",
-    "best-practices-researcher",
-    "git-history-analyzer",
+    "doc-updater"
 ];
 export function subagentDrivenDevSkill() {
     return `---
@@ -40,7 +34,7 @@ For cclaw flow stages, machine-only specialist work should auto-dispatch without
 
 - **design/plan:** planner
 - **tdd:** test-author
-- **review:** spec-reviewer + code-reviewer + security-reviewer (security-reviewer is always mandatory; produce an explicit no-change attestation when no trust boundaries moved)
+- **review:** reviewer + security-reviewer (security-reviewer is always mandatory; produce an explicit no-change attestation when no trust boundaries moved)
 - **ship:** doc-updater
 
 Human input remains mandatory only at explicit approval gates (plan approval, user challenge resolution, release finalization mode).
@@ -69,8 +63,8 @@ If delegation tooling is unavailable in the active harness, run the same control
 | Tier | Use for | Example agents |
 |---|---|---|
 | \`deep\` | one heavy reasoning pass per stage (planner, final reconciliation) | planner |
-| \`balanced\` | spec compliance + code/security review with enough context | spec-reviewer, code-reviewer, security-reviewer, test-author |
-| \`fast\` | read-only research / narrow machine checks / docs updates — safe to fan out | repo-research-analyst, learnings-researcher, framework-docs-researcher, best-practices-researcher, git-history-analyzer, doc-updater |
+| \`balanced\` | spec compliance + code/security review with enough context | reviewer, security-reviewer, test-author |
+| \`fast\` | bounded maintenance updates and doc hygiene | doc-updater |
 
 **Routing rules:**
 - At most ONE \`deep\` agent per stage (planner OR final reconciliation, not both).
@@ -84,14 +78,14 @@ Concrete per-stage rules so the controller does not have to guess which tier fit
 
 | Stage | Deep slot | Balanced slot(s) | Fast fan-out | Trigger to escalate |
 |---|---|---|---|---|
-| brainstorm | planner (only if ambiguity spans >1 module) | — | repo-research-analyst · learnings-researcher (2 in parallel) | promote to \`balanced\` spec-reviewer once direction locks |
-| scope | planner (always) | — | git-history-analyzer (if churn / recent regression on the surface) | promote to \`balanced\` planner if scope touches external contracts |
-| design | planner (always) | security-reviewer (if trust boundary touched) | framework-docs-researcher · best-practices-researcher (up to 2 in parallel) | escalate one specialist to \`deep\` only if a failure mode is Critical-severity |
-| spec | — | spec-reviewer (if spec > 200 lines or multiple ACs) | — | escalate to \`deep\` only for spec ↔ design contradictions |
+| brainstorm | planner (only if ambiguity spans >1 module) | — | run in-thread research playbooks | promote to \`balanced\` reviewer once direction locks |
+| scope | planner (always) | — | run \`research/git-history.md\` in-thread when churn is high | promote to \`balanced\` planner if scope touches external contracts |
+| design | planner (always) | security-reviewer (if trust boundary touched) | run \`research/framework-docs-lookup.md\` + \`research/best-practices-lookup.md\` in-thread | escalate one specialist to \`deep\` only if a failure mode is Critical-severity |
+| spec | — | reviewer (if spec > 200 lines or multiple ACs) | — | escalate to \`deep\` only for spec ↔ design contradictions |
 | plan | planner (solo, always) | — | — | never fan out at plan stage; one owner for dependency graph |
-| tdd | — | test-author (each slice) · code-reviewer (slice-local) | doc-updater (API surface changes) | escalate to \`deep\` only when a RED test cannot be expressed (design leak) |
-| review | — | spec-reviewer · code-reviewer · security-reviewer (all mandatory) | doc-updater + framework-docs-researcher for narrow lookups | escalate a \`balanced\` reviewer to \`deep\` only when two reviewers disagree on severity |
-| ship | — | — | doc-updater (changelog/migration notes) | escalate to \`balanced\` code-reviewer only if preflight finds a regression |
+| tdd | — | test-author (each slice) · reviewer (slice-local) | doc-updater (API surface changes) | escalate to \`deep\` only when a RED test cannot be expressed (design leak) |
+| review | — | reviewer · security-reviewer (both mandatory) | doc-updater for release-note drift checks | escalate a \`balanced\` reviewer to \`deep\` only when two reviewers disagree on severity |
+| ship | — | security-reviewer (if blast radius is high) | doc-updater (changelog/migration notes) | escalate to \`balanced\` reviewer only if preflight finds a regression |
 
 **De-escalation rules (avoid over-spending):**
 - If a \`deep\` planner run returns low-uncertainty output (single unambiguous plan), do **not** add a second \`deep\` pass in the same stage.
@@ -121,7 +115,7 @@ If you catch yourself writing “read PLAN.md Task 3” or “implement the next
 2. **For each task sequentially (NEVER parallel implementation subagents — file conflicts):**
    1. **Dispatch implementer subagent** with the **full task text pasted in** (not a file reference).
    2. **Check return status:** \`DONE\` / \`DONE_WITH_CONCERNS\` / \`NEEDS_CONTEXT\` / \`BLOCKED\`
-   3. If \`DONE\`: dispatch **spec-reviewer** subagent to verify actual code matches spec.
+   3. If \`DONE\`: dispatch **reviewer** subagent to verify actual code matches spec and quality expectations.
    4. If spec review **FAIL**: dispatch **fixer subagent** (a **new** agent — not an inline patch from the parent — to avoid context pollution).
    5. Dispatch **code-quality reviewer** (maintainability/PR hygiene).
    6. **Mark task complete** only after concerns are triaged or explicitly accepted with rationale.
@@ -350,7 +344,7 @@ Write a structured reconciliation artifact at \`.cclaw/artifacts/07-review-army.
       "severity": "Critical|Important|Suggestion",
       "confidence": 1,
       "fingerprint": "hash-or-stable-key",
-      "reportedBy": ["spec-reviewer", "code-reviewer"],
+      "reportedBy": ["reviewer", "security-reviewer"],
       "status": "open|accepted|resolved",
       "location": { "file": "path", "line": 123 },
       "recommendation": "..."
@@ -501,7 +495,7 @@ function specReviewerEnhancedBody() {
 
 ## Task Tool Delegation
 
-For spec-compliance audits, use the Task tool with the following **spec-reviewer** payload (fill placeholders in the parent session).
+For review audits, use the Task tool with the following **reviewer** payload (fill placeholders in the parent session).
 
 \`\`\`
 You are a specification compliance reviewer (subagent).
@@ -544,6 +538,9 @@ Output format (mandatory):
 
 `;
 }
+function reviewerEnhancedBody() {
+    return `${specReviewerEnhancedBody()}${codeReviewerEnhancedBody()}`;
+}
 function securityReviewerEnhancedBody() {
     return `
 
@@ -603,7 +600,7 @@ function repoResearchAnalystEnhancedBody() {
 
 ## Task Tool Delegation
 
-Launch **read-only repo exploration** at the start of brainstorm/scope/design so the primary agent plans on a grounded map, not guesses. Run as a \`fast\` tier agent — cheap to fan out alongside learnings-researcher and best-practices-researcher.
+Launch **read-only repo exploration** at the start of brainstorm/scope/design so the primary agent plans on a grounded map, not guesses. Use this as an in-thread research procedure.
 
 \`\`\`
 You are a repo research analyst subagent.
@@ -761,32 +758,20 @@ Tasks:
 }
 /**
  * Returns markdown fragments augmenting each specialist persona with Task tool
- * delegation guidance. Combine with the existing `body` field from `agents.ts`.
+ * delegation guidance. Combine with the existing `body` field from `core-agents.ts`.
  */
 export function enhancedAgentBody(agentName) {
     switch (agentName) {
         case "planner":
             return plannerEnhancedBody();
-        case "spec-reviewer":
-            return specReviewerEnhancedBody();
-        case "code-reviewer":
-            return codeReviewerEnhancedBody();
+        case "reviewer":
+            return reviewerEnhancedBody();
         case "security-reviewer":
             return securityReviewerEnhancedBody();
         case "test-author":
             return testAuthorEnhancedBody();
         case "doc-updater":
             return docUpdaterEnhancedBody();
-        case "repo-research-analyst":
-            return repoResearchAnalystEnhancedBody();
-        case "learnings-researcher":
-            return learningsResearcherEnhancedBody();
-        case "framework-docs-researcher":
-            return frameworkDocsResearcherEnhancedBody();
-        case "best-practices-researcher":
-            return bestPracticesResearcherEnhancedBody();
-        case "git-history-analyzer":
-            return gitHistoryAnalyzerEnhancedBody();
         default:
             return `
 
@@ -809,7 +794,7 @@ Status contract: DONE | DONE_WITH_CONCERNS | NEEDS_CONTEXT | BLOCKED.
 
 - Controller sequentially dispatches **implementer → reviewer** loops per task.
 - HARD-GATE: paste **self-contained task text**; never point subagents at plan files to “discover” scope.
-- **Spec fixers** are **fresh agents** after failed spec reviews — avoids parent-context pollution.
+- **Review fixers** are **fresh agents** after failed review passes — avoids parent-context pollution.
 - **Machine-only flow checks auto-dispatch** by stage (design/plan/tdd/review/ship) without asking the user to trigger each specialist manually.
 
 ### Parallel Agents (\`dispatching-parallel-agents\` skill)

package/dist/content/tdd-log-command.d.ts

@@ -0,0 +1,2 @@
+export declare function tddLogCommandContract(): string;
+export declare function tddLogCommandSkillMarkdown(): string;

package/dist/content/tdd-log-command.js

@@ -0,0 +1,75 @@
+import { RUNTIME_ROOT } from "../constants.js";
+const TDD_LOG_SKILL_FOLDER = "tdd-cycle-log";
+const TDD_LOG_SKILL_NAME = "tdd-cycle-log";
+function logPath() {
+    return `${RUNTIME_ROOT}/state/tdd-cycle-log.jsonl`;
+}
+function flowStatePath() {
+    return `${RUNTIME_ROOT}/state/flow-state.json`;
+}
+export function tddLogCommandContract() {
+    return `# /cc-tdd-log
+
+## Purpose
+
+Record explicit RED/GREEN/REFACTOR evidence used by workflow guard and doctor checks.
+
+## HARD-GATE
+
+- Every implementation write in tdd must be preceded by a logged RED event.
+- Use append-only JSONL at \`${logPath()}\`; never rewrite prior lines.
+
+## Subcommands
+
+- \`/cc-tdd-log red <slice> <command> [note]\`
+- \`/cc-tdd-log green <slice> <command> [note]\`
+- \`/cc-tdd-log refactor <slice> <command> [note]\`
+- \`/cc-tdd-log show\`
+
+## Log Schema
+
+Each JSON line must include:
+- \`ts\` (ISO timestamp)
+- \`runId\` (from flow-state)
+- \`stage\` (usually \`tdd\`)
+- \`slice\` (e.g. \`S-1\`)
+- \`phase\` (\`red\` | \`green\` | \`refactor\`)
+- \`command\`
+- optional: \`files\`, \`exitCode\`, \`note\`
+
+## Primary skill
+
+**${RUNTIME_ROOT}/skills/${TDD_LOG_SKILL_FOLDER}/SKILL.md**
+`;
+}
+export function tddLogCommandSkillMarkdown() {
+    return `---
+name: ${TDD_LOG_SKILL_NAME}
+description: "Append RED/GREEN/REFACTOR entries into tdd-cycle-log.jsonl for guard/doctor enforcement."
+---
+
+# /cc-tdd-log
+
+## HARD-GATE
+
+Do not fake RED evidence. A \`red\` entry must correspond to a failing test command.
+
+## Protocol
+
+1. Read \`${flowStatePath()}\` and capture \`activeRunId\` + \`currentStage\`.
+2. Build JSON entry:
+   - \`ts\`: now ISO
+   - \`runId\`: activeRunId
+   - \`stage\`: currentStage
+   - \`slice\`: user-provided slice id
+   - \`phase\`: red|green|refactor
+   - \`command\`: test command or refactor verification command
+3. Append one line to \`${logPath()}\`.
+4. \`show\`: print the last 20 lines grouped by slice.
+
+## Validation
+
+- File remains valid JSONL (one JSON object per line).
+- For each slice, first phase must be \`red\`.
+`;
+}

package/dist/content/templates.d.ts

@@ -1,4 +1,4 @@
 export declare const ARTIFACT_TEMPLATES: Record<string, string>;
 export declare const RULEBOOK_MARKDOWN = "# Cclaw Rulebook\n\n## MUST_ALWAYS\n- Follow flow order: brainstorm -> scope -> design -> spec -> plan -> tdd -> review -> ship\n- Require explicit user confirmation after plan before TDD\n- Keep evidence artifacts in `.cclaw/artifacts/`\n- Enforce RED before GREEN in TDD\n- Run two-layer review (spec_compliance and code_quality) before ship\n- Validate all inputs before processing \u2014 never trust external data without sanitization\n- Prefer immutable data patterns and pure functions where the language supports them\n- Follow existing repo conventions, patterns, and directory structure \u2014 match the codebase\n- Verify claims with fresh evidence: \"tests pass\" requires running tests in this message\n- Use conventional commits: `type(scope): description` (feat, fix, refactor, test, docs, chore)\n\n## MUST_NEVER\n- Skip RED phase and jump directly to GREEN in TDD\n- Ship with critical review findings\n- Start implementation during /brainstorm\n- Modify generated cclaw files manually when CLI can regenerate them\n- Commit `.cclaw/` or generated shim files\n- Expose secrets, tokens, API keys, or absolute system paths in agent output\n- Duplicate existing functionality without explicit justification \u2014 search before building\n- Bypass security checks, linting hooks, or type checking to \"move faster\"\n- Claim success (\"Done,\" \"All good,\" \"Tests pass\") without running verification in this message\n- Make changes outside the blast radius of the current task without user consent\n\n## DELEGATION\nWhen a task requires specialist knowledge (security audit, performance profiling, database review),\ndelegate to a specialized agent or skill if the harness supports it. The primary agent should:\n1. Identify the specialist domain\n2. Provide focused context (relevant files, the specific concern)\n3. Evaluate the specialist output before acting on it \u2014 do not blindly apply recommendations\n";
-export declare const CURSOR_WORKFLOW_RULE_MDC = "---\ndescription: cclaw workflow guardrails for Cursor agent sessions\nglobs:\n  - \"**/*\"\nalwaysApply: true\n---\n\n<!-- cclaw-managed-cursor-workflow-rule -->\n\n# Cclaw Workflow Guardrails\n\n- Follow stage order: brainstorm -> scope -> design -> spec -> plan -> tdd -> review -> ship.\n- Read `.cclaw/state/flow-state.json` before acting; continue from current stage when active.\n- Use `/cc-next` only after required gates pass; never bypass explicit pause/approval rules.\n- Keep evidence in `.cclaw/artifacts/`; archive completed feature artifacts only via `cclaw archive`.\n- For machine-only checks in design/plan/tdd/review/ship, dispatch required specialists automatically when tooling supports it.\n- Ask for user input only at explicit approval gates (scope mode, plan approval, user challenge resolution, ship finalization).\n- Treat `.cclaw/skills/using-cclaw/SKILL.md` as routing source of truth; load contextual utility skills only when their triggers apply.\n";
+export declare const CURSOR_WORKFLOW_RULE_MDC = "---\ndescription: cclaw workflow guardrails for Cursor agent sessions\nglobs:\n  - \"**/*\"\nalwaysApply: true\n---\n\n<!-- cclaw-managed-cursor-workflow-rule -->\n\n# Cclaw Workflow Guardrails\n\n## Activation Rule\n\nBefore responding to coding work:\n1. Read `.cclaw/state/flow-state.json`.\n2. Start with `/cc` or continue with `/cc-next`.\n3. If no software-stage flow applies, respond normally.\n\n## Stage Order\n\n`brainstorm -> scope -> design -> spec -> plan -> tdd -> review -> ship`\n\nTrack-specific skips are allowed only when `flow-state.track` + `skippedStages` explicitly say so.\n\n## Task Classification\n\n| Class | Route |\n|---|---|\n| non-trivial software work | `/cc <idea>` |\n| trivial software fix | `/cc <idea>` (quick or medium track) |\n| bugfix with repro | `/cc <idea>` and enforce RED-first in tdd |\n| pure question / non-software | direct answer (no stage flow) |\n\n## Command Surface\n\n- `/cc` = entry and resume.\n- `/cc-next` = only progression path.\n- `/cc-learn` = knowledge capture and recall.\n\n## Verification Discipline\n\n- No completion claim without fresh command evidence in this turn.\n- Do not mark gates passed from memory.\n- Keep evidence in `.cclaw/artifacts/`; archive only via `cclaw archive`.\n\n## Delegation And Approvals\n\n- Machine-only checks in design/plan/tdd/review/ship should auto-dispatch when tooling supports it.\n- Ask for user input only at explicit approval gates (scope mode, plan approval, challenge resolution, ship finalization).\n- If harness capabilities are partial, record waiver reasons in delegation logs.\n\n## Routing Source Of Truth\n\n- Primary router: `.cclaw/skills/using-cclaw/SKILL.md`.\n- Protocols: `.cclaw/references/protocols/*.md`.\n- Preamble budget: `.cclaw/references/protocols/ethos.md`.\n";
 export declare function buildRulesJson(): Record<string, unknown>;

package/dist/content/templates.js

@@ -386,11 +386,11 @@ Execution rule: complete and verify each wave before starting the next wave.
 
 | Pass | Status | Completed at (UTC) | Reviewer / source | Commit at review | Drift vs HEAD |
 |---|---|---|---|---|---|
-| Layer 1 — spec compliance | pass / fail / pending | <ISO 8601> | spec-reviewer | <short sha> | <files changed since> |
-| Layer 2 — correctness | pass / fail / pending | <ISO 8601> | code-reviewer | <short sha> | <files changed since> |
+| Layer 1 — spec compliance | pass / fail / pending | <ISO 8601> | reviewer | <short sha> | <files changed since> |
+| Layer 2 — correctness | pass / fail / pending | <ISO 8601> | reviewer | <short sha> | <files changed since> |
 | Layer 2 — security | pass / fail / pending | <ISO 8601> | security-reviewer | <short sha> | <files changed since> |
-| Layer 2 — performance | pass / fail / pending | <ISO 8601> | code-reviewer | <short sha> | <files changed since> |
-| Layer 2 — architecture | pass / fail / pending | <ISO 8601> | code-reviewer | <short sha> | <files changed since> |
+| Layer 2 — performance | pass / fail / pending | <ISO 8601> | reviewer | <short sha> | <files changed since> |
+| Layer 2 — architecture | pass / fail / pending | <ISO 8601> | reviewer | <short sha> | <files changed since> |
 | Adversarial review | pass / fail / n/a | <ISO 8601 or —> | adversarial-review skill | <short sha or —> | <drift or —> |
 | Review army schema valid | pass / fail | <ISO 8601> | jsonschema | <short sha> | n/a |
 
@@ -480,11 +480,41 @@ Execution rule: complete and verify each wave before starting the next wave.
 - SHIPPED | SHIPPED_WITH_EXCEPTIONS | BLOCKED
 - Exceptions (if any):
 
-## Compound Step
-_Optional retrospective. The goal is to make the **next** feature faster, not to evaluate this one._
-_If you have nothing to add, write the explicit line: \`No compound insight this run.\`_
-- Insight: <one short line about what should accelerate the next run>
-- Action: append one strict-schema JSON line with \`"type":"compound"\` to \`.cclaw/knowledge.jsonl\` capturing the insight (fields: type, trigger, action, confidence, domain, stage, created, project)
+## Retro Gate Handoff
+- Run \`/cc-retro\` before archive.
+- Retro artifact path: \`.cclaw/artifacts/09-retro.md\`
+- Archive remains blocked until retro gate is complete.
+`,
+    "09-retro.md": `# Retro Artifact
+
+## Run Summary
+- Flow track:
+- Scope delivered:
+- Main outcome:
+
+## Friction Log
+| Category | What slowed us down | Evidence | Prevention rule |
+|---|---|---|---|
+|  |  |  |  |
+
+## Acceleration Log
+| Category | What helped | Evidence | Reuse trigger |
+|---|---|---|---|
+|  |  |  |  |
+
+## Compound Decisions
+| Insight | Trigger pattern | Action rule for next run |
+|---|---|---|
+|  |  |  |
+
+## Knowledge Writes
+- Compound entries appended to \`.cclaw/knowledge.jsonl\`: <N>
+- Entry ids / timestamps:
+
+## Retro Completion
+- RETRO_COMPLETE: yes
+- Completed at (UTC):
+- Notes:
 `
 };
 export const RULEBOOK_MARKDOWN = `# Cclaw Rulebook
@@ -531,13 +561,51 @@ alwaysApply: true
 
 # Cclaw Workflow Guardrails
 
-- Follow stage order: brainstorm -> scope -> design -> spec -> plan -> tdd -> review -> ship.
-- Read \`.cclaw/state/flow-state.json\` before acting; continue from current stage when active.
-- Use \`/cc-next\` only after required gates pass; never bypass explicit pause/approval rules.
-- Keep evidence in \`.cclaw/artifacts/\`; archive completed feature artifacts only via \`cclaw archive\`.
-- For machine-only checks in design/plan/tdd/review/ship, dispatch required specialists automatically when tooling supports it.
-- Ask for user input only at explicit approval gates (scope mode, plan approval, user challenge resolution, ship finalization).
-- Treat \`.cclaw/skills/using-cclaw/SKILL.md\` as routing source of truth; load contextual utility skills only when their triggers apply.
+## Activation Rule
+
+Before responding to coding work:
+1. Read \`.cclaw/state/flow-state.json\`.
+2. Start with \`/cc\` or continue with \`/cc-next\`.
+3. If no software-stage flow applies, respond normally.
+
+## Stage Order
+
+\`brainstorm -> scope -> design -> spec -> plan -> tdd -> review -> ship\`
+
+Track-specific skips are allowed only when \`flow-state.track\` + \`skippedStages\` explicitly say so.
+
+## Task Classification
+
+| Class | Route |
+|---|---|
+| non-trivial software work | \`/cc <idea>\` |
+| trivial software fix | \`/cc <idea>\` (quick or medium track) |
+| bugfix with repro | \`/cc <idea>\` and enforce RED-first in tdd |
+| pure question / non-software | direct answer (no stage flow) |
+
+## Command Surface
+
+- \`/cc\` = entry and resume.
+- \`/cc-next\` = only progression path.
+- \`/cc-learn\` = knowledge capture and recall.
+
+## Verification Discipline
+
+- No completion claim without fresh command evidence in this turn.
+- Do not mark gates passed from memory.
+- Keep evidence in \`.cclaw/artifacts/\`; archive only via \`cclaw archive\`.
+
+## Delegation And Approvals
+
+- Machine-only checks in design/plan/tdd/review/ship should auto-dispatch when tooling supports it.
+- Ask for user input only at explicit approval gates (scope mode, plan approval, challenge resolution, ship finalization).
+- If harness capabilities are partial, record waiver reasons in delegation logs.
+
+## Routing Source Of Truth
+
+- Primary router: \`.cclaw/skills/using-cclaw/SKILL.md\`.
+- Protocols: \`.cclaw/references/protocols/*.md\`.
+- Preamble budget: \`.cclaw/references/protocols/ethos.md\`.
 `;
 export function buildRulesJson() {
     return {

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

@@ -0,0 +1,2 @@
+export declare function treeCommandContract(): string;
+export declare function treeCommandSkillMarkdown(): string;

package/dist/content/tree-command.js

@@ -0,0 +1,91 @@
+import { RUNTIME_ROOT } from "../constants.js";
+const TREE_SKILL_FOLDER = "flow-tree";
+const TREE_SKILL_NAME = "flow-tree";
+function flowStatePath() {
+    return `${RUNTIME_ROOT}/state/flow-state.json`;
+}
+function delegationLogPath() {
+    return `${RUNTIME_ROOT}/state/delegation-log.json`;
+}
+function artifactsPath() {
+    return `${RUNTIME_ROOT}/artifacts`;
+}
+function rewindLogPath() {
+    return `${RUNTIME_ROOT}/state/rewind-log.jsonl`;
+}
+export function treeCommandContract() {
+    return `# /cc-tree
+
+## Purpose
+
+Render a visual flow tree for quick orientation across stages, gates, delegations,
+stale markers, and artifact presence.
+
+## HARD-GATE
+
+- \`/cc-tree\` is read-only. Do not mutate flow-state or artifacts.
+- Use values from \`${flowStatePath()}\` and \`${delegationLogPath()}\`; never infer missing evidence.
+
+## Algorithm
+
+1. Read \`${flowStatePath()}\`.
+2. Read \`${delegationLogPath()}\` (if missing, treat current-stage delegations as pending).
+3. Detect artifact files in \`${artifactsPath()}\`.
+4. Read rewind records from \`${rewindLogPath()}\` when present for stale-stage context.
+5. Render the tree using stage order from active track:
+   - stage node marker: passed/current/pending/skipped/stale
+   - gate summary: \`passed/required\`
+   - delegation summary for current stage
+   - artifact marker per stage (exists / stale copy / missing)
+
+## Tree Format
+
+\`\`\`
+cclaw flow tree (track=<track>, run=<runId>)
+├─ [✓] brainstorm  gates 6/6   artifact 01-brainstorm.md
+├─ [✓] scope       gates 5/5   artifact 02-scope.md
+├─ [▶] design      gates 2/7   artifact 03-design.md
+│  ├─ delegations: [✓] planner  [○] reviewer
+│  └─ stale: none
+├─ [○] spec        gates -     artifact missing
+└─ [○] plan        gates -     artifact missing
+\`\`\`
+
+Use UTF markers by default, ASCII fallback when terminal cannot render UTF.
+
+## Primary skill
+
+**${RUNTIME_ROOT}/skills/${TREE_SKILL_FOLDER}/SKILL.md**
+`;
+}
+export function treeCommandSkillMarkdown() {
+    return `---
+name: ${TREE_SKILL_NAME}
+description: "Render a visual flow tree for stages, gates, delegations, and artifacts."
+---
+
+# /cc-tree
+
+## HARD-GATE
+
+Do not modify state in this command. It is a pure read/render operation.
+
+## Protocol
+
+1. Read \`${flowStatePath()}\` as source of truth.
+2. Read \`${delegationLogPath()}\` for current-stage delegation status.
+3. Inspect \`${artifactsPath()}\` for per-stage artifact presence and stale copies.
+4. Render one compact tree:
+   - stage marker: passed/current/pending/skipped/stale
+   - gates summary
+   - artifact summary
+   - delegation branch for current stage
+5. If rewind records exist in \`${rewindLogPath()}\`, include latest rewind note in footer.
+
+## Validation
+
+- Output must mention the active \`track\` and \`currentStage\`.
+- Exactly one stage is marked current.
+- Missing files are reported explicitly; never guessed as complete.
+`;
+}

package/dist/delegation.d.ts

@@ -28,5 +28,6 @@ export declare function checkMandatoryDelegations(projectRoot: string, stage: Fl
     satisfied: boolean;
     missing: string[];
     waived: string[];
+    autoWaived: string[];
     staleIgnored: string[];
 }>;