cclaw-cli 0.12.0 → 0.14.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/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## 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 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 via `/cc-archive` (agent flow) or archive runtime.\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

@@ -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
@@ -563,7 +593,7 @@ Track-specific skips are allowed only when \`flow-state.track\` + \`skippedStage
 
 - 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\`.
+- Keep evidence in \`.cclaw/artifacts/\`; archive via \`/cc-archive\` (agent flow) or archive runtime.
 
 ## Delegation And Approvals
 

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/content/utility-skills.js

@@ -771,7 +771,7 @@ description: "Read-only curation pass over the canonical strict-JSONL knowledge
 ## When to run
 
 - Triggered automatically by **\`/cc-learn curate\`**.
-- Recommended after \`cclaw archive\` of a feature run, when knowledge has grown.
+- Recommended after \`/cc-archive\` (or archive runtime) of a feature run, when knowledge has grown.
 - Recommended when active entry count exceeds **50**.
 
 ## Audit dimensions

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

@@ -0,0 +1,2 @@
+export declare function viewCommandContract(): string;
+export declare function viewCommandSkillMarkdown(): string;

package/dist/content/view-command.js

@@ -0,0 +1,57 @@
+import { RUNTIME_ROOT } from "../constants.js";
+const VIEW_SKILL_FOLDER = "flow-view";
+const VIEW_SKILL_NAME = "flow-view";
+export function viewCommandContract() {
+    return `# /cc-view
+
+## Purpose
+
+Unified read-only command surface for flow visibility.
+
+Subcommands:
+- \`/cc-view\` or \`/cc-view status\` -> status snapshot
+- \`/cc-view tree\` -> structural flow tree
+- \`/cc-view diff\` -> baseline delta map
+
+## HARD-GATE
+
+- \`/cc-view\` is strictly read-only at wrapper level.
+- Do not mutate flow-state unless routing to \`diff\` (which updates snapshot baseline by design).
+
+## Routing
+
+1. Parse subcommand (default \`status\`).
+2. Route:
+   - \`status\` -> load \`${RUNTIME_ROOT}/commands/status.md\` + \`${RUNTIME_ROOT}/skills/flow-status/SKILL.md\`
+   - \`tree\` -> load \`${RUNTIME_ROOT}/commands/tree.md\` + \`${RUNTIME_ROOT}/skills/flow-tree/SKILL.md\`
+   - \`diff\` -> load \`${RUNTIME_ROOT}/commands/diff.md\` + \`${RUNTIME_ROOT}/skills/flow-diff/SKILL.md\`
+3. Unknown subcommand -> print supported values and stop.
+
+## Primary skill
+
+**${RUNTIME_ROOT}/skills/${VIEW_SKILL_FOLDER}/SKILL.md**
+`;
+}
+export function viewCommandSkillMarkdown() {
+    return `---
+name: ${VIEW_SKILL_NAME}
+description: "Unified read-only view router for status/tree/diff flow visibility commands."
+---
+
+# /cc-view
+
+## HARD-GATE
+
+Wrapper is read-only and dispatch-only. It must not mutate flow state directly.
+
+## Protocol
+
+1. Parse optional subcommand token:
+   - missing -> \`status\`
+   - \`status\` -> dispatch to \`/cc-status\`
+   - \`tree\` -> dispatch to \`/cc-tree\`
+   - \`diff\` -> dispatch to \`/cc-diff\`
+2. Execute the target command contract and skill.
+3. Return concise output and suggest \`/cc-view <subcommand>\` variants for navigation.
+`;
+}

package/dist/doctor-registry.js

@@ -119,9 +119,9 @@ export function doctorCheckMetadata(checkName) {
         }
     }
     return {
-        severity: "error",
-        summary: "Doctor runtime integrity check.",
-        fix: "Inspect check details, apply the suggested remediation, and re-run `cclaw doctor`.",
+        severity: "warning",
+        summary: "Unclassified doctor check.",
+        fix: "Review the check details and add a matching rule in doctor-registry when this check should be severity-scoped.",
         docRef: ref("README.md")
     };
 }