cclaw-cli 6.10.0 → 6.12.0

package/dist/content/stages/tdd.js

@@ -42,15 +42,15 @@ export const TDD = {
             "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.",
             "Source/test preflight — before production edits, classify planned paths using test-path patterns; verify the RED touches a test path and the GREEN touches only source paths needed for the failing behavior.",
-            "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 the slice in `.cclaw/artifacts/06-tdd-slices.jsonl` via `cclaw-cli internal tdd-slice-record --slice <id> --status red --test-file <path> --command <cmd> --paths <comma-separated>` (the markdown `Watched-RED Proof` table is now auto-derived from this sidecar).",
-            "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.",
+            "Use the mandatory `test-author` delegation for RED — after discovery and impact check, dispatch with `--slice S-<id> --phase red`. Produce failing behavior tests only (no production edits) and let the harness record the dispatch via the generated `delegation-record` hook. Set `CCLAW_ACTIVE_AGENT=tdd-red` when the harness supports phase labels.",
+            "RED: do NOT hand-edit `## Watched-RED Proof`, `## Vertical Slice Cycle`, or `## RED Evidence` markdown tables. The linter auto-renders them from `delegation-events.jsonl` slice phase rows; manual edits inside the auto-render markers are overwritten on the next lint.",
+            "Dispatch the `slice-implementer` for GREEN with `--slice S-<id> --phase green` and explicit `--paths` so the file-overlap scheduler can auto-allow parallel slices. Attach an evidence ref (test path, span ref, or pasted-output pointer) so the Vertical Slice Cycle row is well-formed. 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, explicit PASS/FAIL status, and a config-aware ref (commit SHA when VCS is present/required, or no-vcs attestation when allowed).",
-            "GREEN: append a `green` row to `.cclaw/artifacts/06-tdd-slices.jsonl` via `cclaw-cli internal tdd-slice-record --slice <id> --status green [--green-output-ref <path|spanId:...>]` so the Vertical Slice Cycle linter validates the sidecar instead of a hand-edited table.",
-            "REFACTOR: continue the `test-author` evidence cycle (or a dedicated refactor mode when available) to improve code quality without behavior changes, then record `--status refactor-done` (or `--status refactor-deferred --refactor-rationale \"<why>\"`) via the same `tdd-slice-record` CLI. 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.",
+            "REFACTOR: re-dispatch the `slice-implementer` (or `test-author`) with `--phase refactor` once GREEN holds, OR `--phase refactor-deferred --refactor-rationale \"<why>\"` to close the slice without a refactor pass. Both options are recorded as a delegation event; the linter accepts either as REFACTOR coverage. Set `CCLAW_ACTIVE_AGENT=tdd-refactor` when the harness supports phase labels.",
+            "DOC (parallel, mandatory v6.12.0): dispatch `slice-documenter --slice S-<id> --phase doc --paths <artifacts-dir>/tdd-slices/S-<id>.md` IN PARALLEL with `slice-implementer --phase green` for the same slice — ONE message with TWO concurrent Task calls. The documenter only writes `tdd-slices/S-<id>.md`, so its `--paths` are disjoint from the implementer's production code and the file-overlap scheduler auto-allows the parallel dispatch. Linter rule `tdd_slice_documenter_missing` blocks the gate when the `phase=doc` event is absent (regardless of `discoveryMode`).",
+            "**slice-documenter writes per-slice prose** (test discovery, system-wide impact check, RED/GREEN/REFACTOR notes, acceptance mapping, failure analysis) into `tdd-slices/S-<id>.md`. Controller does NOT touch this content. When logging a `green` row, attach the closed acceptance-criterion IDs in `acIds` so Ralph Loop status counts them.",
             "Annotate traceability — link to the active track's source: plan task ID + spec criterion on standard/medium, or spec acceptance item / bug reproduction slice on quick.",
             "**Boundary with review (do NOT escalate single-slice findings to whole-diff review).** `tdd.Per-Slice Review` OWNS severity-classified findings WITHIN one slice (correctness, edge cases, regression). `review` OWNS whole-diff Layer 1 (spec compliance) plus Layer 2 (cross-slice integration, security sweep, dependency/version audit, observability). When a single-slice finding genuinely needs whole-diff escalation, surface it in `06-tdd.md > Per-Slice Review` first; review will cite it (not re-classify) and the cross-artifact-duplication linter requires matching severity/disposition.",
             "Per-Slice Review (conditional) — if 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).",
@@ -58,10 +58,11 @@ export const TDD = {
         ],
         interactionProtocol: [
             "Pick one vertical slice at a time: source item, RED test, GREEN implementation, REFACTOR, and verification evidence move together.",
-            "Slice implementers are sequential by default. Parallel implementers are allowed only when (a) lanes touch non-overlapping files, (b) the controller passes `--allow-parallel` on each ledger row, and (c) an `integration-overseer` is dispatched after the parallel lanes and writes cohesion-evidence into the artifact before the gate is marked passed.",
-            "Controller owns orchestration; one mandatory `test-author` delegation carries phase-specific RED -> GREEN -> REFACTOR evidence instead of spawning separate workers by default.",
+            "Slice implementers are sequential by default. Parallel implementers are allowed only when (a) lanes touch non-overlapping files (the file-overlap scheduler auto-allows parallel when `--paths` are disjoint), and (b) an `integration-overseer` is dispatched after the parallel lanes and writes cohesion-evidence into the artifact before the gate is marked passed.",
+            "Controller owns orchestration. For each slice S-<id>, dispatch in this order: (1) `test-author --slice S-<id> --phase red` (RED-only, no production edits), (2) `slice-implementer --slice S-<id> --phase green --paths <comma-separated>` for GREEN, (3) re-dispatch `--phase refactor` or `--phase refactor-deferred --refactor-rationale \"<why>\"` to close REFACTOR. Each dispatch records a row in `delegation-events.jsonl` and the linter auto-derives the Watched-RED + Vertical Slice Cycle tables from those rows. Do NOT hand-edit those tables.",
             "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.",
+            "Slice-documenter (mandatory v6.12.0, regardless of `discoveryMode`): in PARALLEL with `slice-implementer --phase green`, dispatch `slice-documenter --slice S-<id> --phase doc` whose only `claimedPaths` is `<artifacts-dir>/tdd-slices/S-<id>.md`. The two dispatches run concurrently because their paths are disjoint. The documenter writes per-slice prose so the main `06-tdd.md` stays thin. Controller MUST NOT author per-slice prose; controller MUST NOT author GREEN production code (use `slice-implementer`).",
             "Run source/test preflight using configured TDD path patterns where feasible; if path classification is impossible (generated files, non-file side effect), record why.",
             "Write behavior-focused tests before changing implementation (RED).",
             "Capture and store failing output as RED evidence.",
@@ -104,16 +105,16 @@ 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 Test Discovery, System-Wide Impact Check, RED, GREEN, and REFACTOR sections.",
+            "Artifact updated at `.cclaw/artifacts/06-tdd.md` with System-Wide Impact Check, Acceptance & Failure Map, REFACTOR Notes, Iron Law Acknowledgement, Verification Ladder, and Learnings.",
             "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 vertical-slice 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).",
+            "RED observability: a `phase=red` event in `delegation-events.jsonl` for each slice with non-empty evidenceRefs (test path, span ref, or pasted-output pointer). Slices created **before the v6.12.0 cutover marker** in `flow-state.json::tddCutoverSliceId` may retain legacy `## Watched-RED Proof` / `## RED Evidence` markdown tables; slices created **after the cutover marker** MUST use phase events + slice-documenter doc, and legacy table writes are surfaced by the advisory `tdd_legacy_section_writes_after_cutover` rule.",
+            "GREEN observability: a `phase=green` event in `delegation-events.jsonl` per slice whose `completedTs` >= the matching `phase=red` `completedTs`, authored by `slice-implementer` (linter rule `tdd_slice_implementer_missing` blocks the gate otherwise), and whose evidenceRefs name the failing-now-passing test. Pre-cutover slices may keep legacy `## GREEN Evidence` markdown.",
+            "REFACTOR observability: per slice, a `phase=refactor` event OR a `phase=refactor-deferred` event whose evidenceRefs / refactor rationale captures why refactor was deferred.",
+            "Per slice, a `phase=doc` event from `slice-documenter` whose evidenceRefs name `<artifacts-dir>/tdd-slices/S-<id>.md`. Mandatory regardless of `discoveryMode` (v6.12.0 Phase R). Linter rule `tdd_slice_documenter_missing` blocks the gate when missing.",
             "Fresh verification evidence recorded with command, PASS/FAIL status, and commit SHA or no-VCS reason plus content/artifact hash before completion.",
             "Iron Law Acknowledgement section explicitly states `Acknowledged: yes`.",
-            "Watched-RED Proof includes at least one populated row with an ISO timestamp.",
-            "Vertical Slice Cycle records RED, GREEN, and REFACTOR per active slice.",
             "Acceptance mapping documented.",
             "Failure reason analysis recorded.",
             "Refactor rationale captured.",
@@ -156,16 +157,16 @@ export const TDD = {
         },
         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: "Test Discovery", required: false, validationRule: "Overall narrative for how the stage discovered the existing test surface. Per-slice details live under `tdd-slices/S-<id>.md` from v6.11.0; the `## Test Discovery` heading is optional/advisory." },
             { 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: "RED Evidence", required: true, validationRule: "Failing test output captured per slice." },
-            { section: "Acceptance & Failure Map", required: false, validationRule: "Each slice row carries Source ID, AC ID, expected behavior, and a RED-link (delegation spanId, evidence path, or sidecar redOutputRef)." },
-            { section: "GREEN Evidence", required: true, validationRule: "Full suite pass output captured." },
+            { section: "RED Evidence", required: true, validationRule: "Failing test output per slice. From v6.11.0 this section is auto-satisfied by a `phase=red` event in `delegation-events.jsonl` with non-empty evidenceRefs; the markdown block remains required as a legacy fallback when phase events are absent." },
+            { section: "Acceptance & Failure Map", required: false, validationRule: "Each slice row carries Source ID, AC ID, expected behavior, and a RED-link (delegation spanId or evidence path). From v6.11.0 the column is auto-derivable from `phase=red` events." },
+            { section: "GREEN Evidence", required: true, validationRule: "Full suite pass output. From v6.11.0 this section is auto-satisfied by a `phase=green` event in `delegation-events.jsonl` with non-empty evidenceRefs; the markdown block remains required as a legacy fallback when phase events are absent." },
             { section: "REFACTOR Notes", required: true, validationRule: "What changed, why, behavior preservation confirmed." },
             { section: "Traceability", required: true, validationRule: "Plan task ID and spec criterion linked." },
             { section: "Iron Law Acknowledgement", required: true, validationRule: "Must include `Acknowledged: yes` and list exceptions (or `None`)." },
-            { section: "Watched-RED Proof", required: true, validationRule: "At least one populated row with ISO timestamp proving RED was observed before production edits." },
-            { section: "Vertical Slice Cycle", required: true, validationRule: "Per active slice records RED, GREEN, and REFACTOR timestamps (refactor may be deferred only with explicit rationale)." },
+            { section: "Watched-RED Proof", required: false, validationRule: "From v6.11.0 the Watched-RED summary is auto-rendered from `delegation-events.jsonl` slice phase events (see auto-start: tdd-slice-summary marker). Legacy markdown tables continue to validate via the fallback path." },
+            { section: "Vertical Slice Cycle", required: false, validationRule: "From v6.11.0 the Vertical Slice Cycle table is auto-rendered between `auto-start: tdd-slice-summary` markers. Legacy markdown tables continue to validate via the fallback path." },
             { section: "Verification Ladder", required: true, validationRule: "Per-slice verification tier (static, command, behavioral, human) with evidence captured for the highest tier reached this turn. Must include command + PASS/FAIL + commit SHA when VCS is present, or explicit no-vcs reason plus content/artifact hash/config override." },
             { section: "TDD Blocker Taxonomy", required: false, validationRule: "When blocked, classify as NO_SOURCE_CONTEXT, NO_TEST_SURFACE, NO_IMPLEMENTABLE_SLICE, RED_NOT_EXPRESSIBLE, or NO_VCS_MODE; include blockedBecause, missingInputs, recommendedRoute, nextCommand, and resumeCriteria." },
             { section: "Coverage Targets", required: false, validationRule: "If present: per-module or per-code-type coverage thresholds with current values and measurement commands." },
@@ -304,7 +305,7 @@ function tddStageVariantForTrack(track) {
                     return {
                         ...row,
                         required: true,
-                        validationRule: "Each slice row carries Source ID, AC ID (spec acceptance criterion ID, for example AC-1), expected behavior, and a RED-link (delegation spanId, evidence path, or sidecar redOutputRef)."
+                        validationRule: "Each slice row carries Source ID, AC ID (spec acceptance criterion ID, for example AC-1), expected behavior, and a RED-link (delegation spanId or evidence path). From v6.11.0 a `phase=red` event in `delegation-events.jsonl` with non-empty evidenceRefs satisfies the row."
                     };
                 }
                 if (row.section === "Traceability") {

package/dist/content/subagents.js

@@ -676,7 +676,7 @@ function sliceImplementerEnhancedBody() {
 ${MARKDOWN_CODE_FENCE}
 You are a slice-implementer subagent.
 
-SLICE: {single vertical slice}
+SLICE: {single vertical slice — controller MUST dispatch you with --slice S-<id> --phase green --paths <comma-separated>}
 RED_EVIDENCE: {failing test and expected failure}
 ALLOWED_FILES: {explicit file boundaries — surfaced to scheduler as Files: <paths>}
 FORBIDDEN_CHANGES: {scope/compatibility limits}
@@ -687,11 +687,11 @@ Rules:
 - Keep REFACTOR behavior-preserving.
 - Return the strict worker JSON schema first.
 
-Slice ledger contract (v6.10.0):
-- After observing the failing test, run \`cclaw-cli internal tdd-slice-record --slice <id> --status red --test-file <path> --command <cmd> --paths <comma-separated> [--ac <id>] [--plan-unit <id>]\`. The command appends to \`.cclaw/artifacts/06-tdd-slices.jsonl\`.
-- After the same test passes, run \`cclaw-cli internal tdd-slice-record --slice <id> --status green [--green-output-ref <path|spanId:...>]\`.
-- After REFACTOR, run \`cclaw-cli internal tdd-slice-record --slice <id> --status refactor-done\` or \`--status refactor-deferred --refactor-rationale "<why>"\`.
-- Do NOT hand-edit the Watched-RED Proof or Vertical Slice Cycle markdown tables; the linter reads the JSONL sidecar when present and the markdown becomes an auto-derived view.
+Slice phase-event contract (v6.11.0):
+- Do NOT hand-edit \`## Watched-RED Proof\`, \`## Vertical Slice Cycle\`, \`## RED Evidence\`, or \`## GREEN Evidence\` markdown tables in 06-tdd.md. The linter auto-renders them between \`<!-- auto-start: tdd-slice-summary -->\` markers from \`delegation-events.jsonl\` slice phase rows.
+- Your dispatch row IS the evidence: the harness-generated delegation-record hook stamps \`sliceId=S-<id>\`, \`phase=green\`, and \`completedTs\` automatically. Attach evidenceRefs (test path, span ref, or pasted-output pointer) so the linter validates the row.
+- After REFACTOR, ask the controller to re-dispatch you with \`--phase refactor\` (or \`--phase refactor-deferred --refactor-rationale "<why>"\`); each call appends a new ledger row.
+- Per-slice prose summary lives in \`<artifacts-dir>/tdd-slices/S-<id>.md\` and is owned by the parallel \`slice-documenter\` (or the controller). You do NOT touch that file.
 ${MARKDOWN_CODE_FENCE}
 
 `;
@@ -935,14 +935,15 @@ FIXTURES / PATTERNS: {links to helper modules by path + naming conventions}
 
 Process (mandatory):
 1) If STAGE_MODE=TEST_RED_ONLY:
-   - RED only — add failing tests proving the gap (show failing output excerpt).
+   - Controller dispatched you with \`--slice S-<id> --phase red\`. Add failing tests proving the gap (show failing output excerpt).
    - Do NOT edit production code.
-   - Append the slice to the sidecar via \`cclaw-cli internal tdd-slice-record --slice <id> --status red --test-file <path> --command <cmd> --paths <comma-separated>\` instead of editing the Watched-RED Proof markdown table.
+   - Do NOT hand-edit \`## Watched-RED Proof\` / \`## RED Evidence\` markdown tables in 06-tdd.md — the linter auto-renders them from your dispatch row in \`delegation-events.jsonl\`. Just ensure your worker return includes evidenceRefs (test path, span ref, or pasted-output pointer) so the harness can stamp them on the ledger row.
    - Report: TESTS_ADDED, RED_COMMAND_RUN, RED_EVIDENCE, STATUS: DONE|BLOCKED.
 2) If STAGE_MODE=BUILD_GREEN_REFACTOR:
+   - Controller dispatched you with \`--slice S-<id> --phase green\` (and later \`--phase refactor\` or \`--phase refactor-deferred --refactor-rationale "<why>"\`).
    - GREEN — minimal production code to satisfy existing RED tests, rerun full suite.
    - REFACTOR — only after full suite is green; preserve behavior.
-   - Append \`--status green\` (and \`--status refactor-done\` or \`--status refactor-deferred --refactor-rationale "<why>"\` after refactor) via \`cclaw-cli internal tdd-slice-record\`. The Vertical Slice Cycle markdown stays auto-derived from this sidecar.
+   - Do NOT hand-edit \`## Vertical Slice Cycle\` / \`## GREEN Evidence\` markdown tables — auto-rendered from your dispatch row.
    - Report: FILES_EDITED, GREEN_COMMAND_RUN, REFACTOR_NOTES, STATUS: DONE|BLOCKED.
 ${MARKDOWN_CODE_FENCE}
 

package/dist/content/templates.d.ts

@@ -17,4 +17,10 @@ export declare const RULEBOOK_MARKDOWN = "# Cclaw Rulebook\n\n## MUST_ALWAYS\n-
  */
 export declare const CURSOR_GUIDELINES_RULE_MDC = "---\ndescription: cclaw zero-install behavior baseline (always-on)\nglobs:\n  - \"**/*\"\nalwaysApply: true\n---\n\n<!-- cclaw-managed-cursor-guidelines-rule -->\n\n# Cclaw Baseline Guidelines\n\nThese three rules apply to every Cursor agent session in this project,\nregardless of whether stage skills loaded.\n\n## 1. Q&A floor before drafting (brainstorm/scope/design)\n\nBefore drafting any `.cclaw/artifacts/01-brainstorm-*.md`,\n`02-scope-*.md`, or `03-design-*.md`, verify that the artifact's\n`## Q&A Log` table demonstrates Ralph-Loop convergence: every\nforcing-question topic id is tagged `[topic:<id>]` on at least one row\n(see the stage's forcing-questions checklist for the id list), the last\n2 turns produce no new decision-changing impact, OR an explicit user\nstop-signal row is recorded. Walk the stage forcing questions one at a\ntime via the `AskQuestion` tool. If you find yourself proposing a\ndraft after 1-2 questions while forcing topic ids remain untagged, STOP\nand continue the loop.\n\nThe `qa_log_unconverged` linter rule will block `stage-complete` when\nconvergence has not been reached. Wave 24 (v6.0.0) made `[topic:<id>]`\ntagging mandatory; the English keyword fallback was removed because it\nmis-reported convergence on RU/UA Q&A logs.\n\n## 2. Mandatory subagents run after Q&A approval\n\nFor brainstorm / scope / design, mandatory subagents (\n`product-discovery`, `critic`, `planner`, `architect`,\n`test-author`) run **only AFTER the user approves the elicitation\noutcome**, never before the Q&A loop converges. Dispatching them early\npreempts the user dialogue and violates the elicitation contract \u2014 the\nlinter will block stage-complete.\n\nSee each stage's \"Run Phase: post-elicitation\" rows in the materialized\nAutomatic Subagent Dispatch table.\n\n## 3. Never echo cclaw command lines to chat\n\nThe user does not run cclaw helpers (`node .cclaw/hooks/...`) manually.\nNEVER paste full command lines, `--evidence-json '{...}'` payloads,\n`--waive-delegation=...`, or shell hash commands (`shasum`,\n`sha256sum`, `Get-FileHash`, `certutil`, etc.) into chat. Run the\nhelper via the tool layer and report only the resulting summary. On\nfailure, report a compact human-readable summary plus the helper JSON in\na single fenced `json` block.\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`.\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 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` = only progression path.\n- Knowledge capture and recall use the `learnings` skill when requested.\n\n## Verification Discipline\n\n- No completion claim without fresh command evidence in this turn.\n- Stage completion claim requires `stage-complete` exit 0 in the current turn. Quote the single-line success JSON printed to stdout (e.g. `{\"ok\":true,\"command\":\"stage-complete\",...}`); do not paraphrase, do not infer success from empty stdout or from skipped retries.\n\n## Protocol label hygiene\n\n`skip` wording means different things depending on phase: brainstorm/scope/design Q&A stop-signals may still literal **skip**/enough/move-on wording; structured ship closeout retros and compound clustering prompts should expose **no changes** (or accept-as-is language) rather than labeling the passive path as skip. Keep the verbs aligned with the harness question copy you present to the human.\n- Do not mark gates passed from memory.\n- Keep evidence in `.cclaw/artifacts/`; archive through closeout via `/cc` or cancel early via `node .cclaw/hooks/cancel-run.mjs`.\n\n## Delegation And Approvals\n\n- Machine-only checks in design/plan/tdd/review/ship should auto-dispatch when tooling supports it.\n- **For brainstorm / scope / design stages**: ask user input continuously via adaptive elicitation (one question per turn through the harness-native question tool \u2014 `AskQuestion` in Cursor). Walk the stage forcing-questions list one-by-one. **Tag each Q&A Log row's `Decision impact` cell with `[topic:<id>]`** (the id is given in the stage's forcing-questions checklist) so the linter can verify coverage in any natural language. Do NOT batch and do NOT defer to a single approval gate at the end. The `qa_log_unconverged` linter rule will block `stage-complete` when convergence is not reached (forcing topic ids untagged AND last 2 turns still produce decision-changing rows AND no stop-signal).\n- **For other stages** (spec/plan/tdd/build/review/ship): ask user input only at explicit approval gates (scope mode, plan approval, challenge resolution, ship finalization), not for routine progress updates.\n- If you find yourself proposing a draft after 1-2 questions in brainstorm/scope/design, STOP \u2014 go back to the forcing-questions list and continue.\n- Mandatory subagents in brainstorm/scope/design run only AFTER the user approves the elicitation outcome (see each stage's \"Run Phase: post-elicitation\" rows). Dispatching them before the Q&A loop converges violates the contract.\n- Never echo cclaw command lines (`node .cclaw/hooks/...`, `--evidence-json '{...}'`) to chat \u2014 the user does not run cclaw manually. Run helpers via the tool layer; report only the resulting summary.\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- Stage behavior: current stage skill plus `.cclaw/state/flow-state.json`.\n- Preamble budget: keep role/status announcements brief and avoid repeating\n  them unless the stage or role changes.\n";
+/**
+ * v6.11.0 (S2) — per-slice prose file written by `slice-documenter`
+ * (or the controller) to `<artifacts-dir>/tdd-slices/S-<id>.md`. The
+ * main `06-tdd.md` is auto-indexed via `## Slices Index`.
+ */
+export declare function tddSliceFileTemplate(sliceId: string): string;
 export declare function buildRulesJson(): Record<string, unknown>;

package/dist/content/templates.js

@@ -976,10 +976,14 @@ ${renderBehaviorAnchorTemplateLine("tdd")}
 - Open questions:
 - Drift from upstream (or \`None\`):
 
+<!-- auto-start: slices-index -->
+## Slices Index
+
+_Auto-rendered from \`tdd-slices/S-*.md\` once slice-documenter or controller writes per-slice files. Do not edit by hand._
+<!-- auto-end: slices-index -->
+
 ## Test Discovery
-| Slice | Existing tests / helpers / fixtures | Exact command(s) | Pattern to extend |
-|---|---|---|---|
-| S-1 |  |  |  |
+> Overall narrative for how this stage discovered the existing test surface. Per-slice details live in \`tdd-slices/S-<id>.md\`.
 
 ## System-Wide Impact Check
 | Slice | Callbacks/state/interfaces/contracts affected | Coverage decision |
@@ -987,20 +991,17 @@ ${renderBehaviorAnchorTemplateLine("tdd")}
 | S-1 |  | covered/out-of-scope because  |
 
 ## RED Evidence
-| Slice | Test name | Command | Failure output summary |
-|---|---|---|---|
-| S-1 |  |  |  |
+> From v6.11.0 the per-slice RED rows are auto-satisfied by \`phase=red\` events in \`delegation-events.jsonl\` (controller dispatches \`test-author --slice S-<id> --phase red\`). Legacy hand-filled tables continue to validate as a fallback. Use \`Evidence: <path>\` or \`Evidence: spanId:<id>\` pointers if you prefer a manual reference.
 
 ## Acceptance & Failure Map
 | Slice | Source ID | AC ID | Expected behavior | RED-link |
 |---|---|---|---|---|
 | S-1 | SRC-1 | AC-1 |  |  |
 
-> Each slice maps to the active track's source item (plan slice on standard/medium, or the \`Quick Reproduction Contract\` bug slice / spec acceptance item on quick) and to a spec criterion. The RED-link column is satisfied by either a \`spanId:<id>\` from the delegation ledger, an \`<artifacts-dir>/<file>\` evidence pointer, or a \`redOutputRef\` recorded via \`cclaw-cli internal tdd-slice-record\` in the sidecar ledger.
+> Each slice maps to the active track's source item (plan slice on standard/medium, or the \`Quick Reproduction Contract\` bug slice / spec acceptance item on quick) and to a spec criterion. The RED-link column is satisfied by either a \`spanId:<id>\` from the delegation ledger or an \`<artifacts-dir>/<file>\` evidence pointer. From v6.11.0 the column is auto-derivable: a \`phase=red\` event in \`delegation-events.jsonl\` with non-empty evidenceRefs auto-satisfies the row.
 
 ## GREEN Evidence
-- Full suite command:
-- Full suite result:
+> From v6.11.0 GREEN rows are auto-satisfied by \`phase=green\` events in \`delegation-events.jsonl\` (controller dispatches \`slice-implementer --slice S-<id> --phase green\`). Legacy hand-filled tables continue to validate as a fallback. Use \`Evidence: <path>\` or \`Evidence: spanId:<id>\` pointers if you prefer a manual reference.
 
 ## REFACTOR Notes
 - What changed:
@@ -1017,19 +1018,11 @@ ${renderBehaviorAnchorTemplateLine("tdd")}
 - Acknowledged: yes — code that landed before its test will be deleted and rewritten from the test.
 - Exceptions invoked (or \`- None.\`):
 
-## Watched-RED Proof
-> Required for every new test in this stage. Each row proves the test was *observed* failing before any production code was written.
-
-| Slice | Test name | Observed at (ISO ts) | Failure reason snippet | Source command/log |
-|---|---|---|---|---|
-| S-1 |  |  |  |  |
-
+<!-- auto-start: tdd-slice-summary -->
 ## Vertical Slice Cycle
-> Per slice: RED -> GREEN -> REFACTOR within the same cycle (refactor not deferred). The linter checks structural presence of all three phases.
 
-| Slice | RED ts | GREEN ts | REFACTOR ts (or \`deferred because <reason>\`) |
-|---|---|---|---|
-| S-1 |  |  |  |
+_Auto-rendered from \`delegation-events.jsonl\` once \`test-author\` and \`slice-implementer\` are dispatched with \`--slice <id> --phase red|green|refactor|refactor-deferred\`. Do not edit by hand._
+<!-- auto-end: tdd-slice-summary -->
 
 ## Assertion Correctness Notes
 > For each new test assertion, name a *plausible subtle bug* that would still pass it (mental mutation test). If you cannot, the assertion is too coarse — strengthen it.
@@ -1623,6 +1616,31 @@ Track-specific skips are allowed only when \`flow-state.track\` + \`skippedStage
 - Preamble budget: keep role/status announcements brief and avoid repeating
   them unless the stage or role changes.
 `;
+/**
+ * v6.11.0 (S2) — per-slice prose file written by `slice-documenter`
+ * (or the controller) to `<artifacts-dir>/tdd-slices/S-<id>.md`. The
+ * main `06-tdd.md` is auto-indexed via `## Slices Index`.
+ */
+export function tddSliceFileTemplate(sliceId) {
+    return `# Slice ${sliceId}
+
+## Plan unit
+T-...
+
+## Acceptance criteria
+AC-...
+
+## Why this slice
+
+## What was tested
+
+## What was implemented
+
+## REFACTOR notes
+
+## Learnings
+`;
+}
 export function buildRulesJson() {
     return {
         version: 1,

package/dist/delegation.d.ts

@@ -140,7 +140,34 @@ export type DelegationEntry = {
      * `src/content/hooks.ts::delegationRecordScript`.
      */
     claimedPaths?: string[];
+    /**
+     * v6.11.0 (D1) — TDD slice identifier, e.g. `"S-1"`. Recorded by the
+     * controller when dispatching `test-author` / `slice-implementer` /
+     * `slice-documenter` so the artifact linter can auto-derive the
+     * Watched-RED Proof + Vertical Slice Cycle tables from
+     * `delegation-events.jsonl` instead of requiring agents to maintain
+     * the markdown by hand. Optional: legacy and non-TDD rows omit it.
+     *
+     * keep in sync with the inline copy in
+     * `src/content/hooks.ts::delegationRecordScript`.
+     */
+    sliceId?: string;
+    /**
+     * v6.11.0 (D1) — explicit phase tag for TDD slice events. Combined
+     * with `sliceId`, the linter validates RED -> GREEN -> REFACTOR
+     * monotonicity per slice. `refactor-deferred` requires a rationale
+     * either via `--refactor-rationale` (recorded into evidenceRefs[0])
+     * or an `evidenceRefs` entry that contains the rationale text.
+     * `doc` is reserved for the parallel `slice-documenter` subagent
+     * (Phase C). Optional: legacy and non-TDD rows omit it.
+     *
+     * keep in sync with the inline copy in
+     * `src/content/hooks.ts::delegationRecordScript`.
+     */
+    phase?: "red" | "green" | "refactor" | "refactor-deferred" | "doc";
 };
+export declare const DELEGATION_PHASES: readonly ["red", "green", "refactor", "refactor-deferred", "doc"];
+export type DelegationPhase = (typeof DELEGATION_PHASES)[number];
 export declare const DELEGATION_LEDGER_SCHEMA_VERSION: 3;
 export type DelegationLedger = {
     runId: string;

package/dist/delegation.js

@@ -38,6 +38,13 @@ export const DELEGATION_DISPATCH_SURFACE_PATH_PREFIXES = {
     "role-switch": [],
     "manual": []
 };
+export const DELEGATION_PHASES = [
+    "red",
+    "green",
+    "refactor",
+    "refactor-deferred",
+    "doc"
+];
 export const DELEGATION_LEDGER_SCHEMA_VERSION = 3;
 function delegationLogPath(projectRoot) {
     return path.join(projectRoot, RUNTIME_ROOT, "state", "delegation-log.json");
@@ -226,7 +233,12 @@ function isDelegationEntry(value) {
         (o.allowParallel === undefined || typeof o.allowParallel === "boolean") &&
         (o.supersededBy === undefined || typeof o.supersededBy === "string") &&
         (o.claimedPaths === undefined ||
-            (Array.isArray(o.claimedPaths) && o.claimedPaths.every((item) => typeof item === "string"))));
+            (Array.isArray(o.claimedPaths) && o.claimedPaths.every((item) => typeof item === "string"))) &&
+        (o.sliceId === undefined ||
+            (typeof o.sliceId === "string" && o.sliceId.length > 0)) &&
+        (o.phase === undefined ||
+            (typeof o.phase === "string" &&
+                DELEGATION_PHASES.includes(o.phase))));
 }
 function isDelegationDispatchSurface(value) {
     return typeof value === "string" && DELEGATION_DISPATCH_SURFACES.includes(value);

package/dist/flow-state.d.ts

@@ -121,6 +121,21 @@ export interface FlowState {
     completedStageMeta?: Partial<Record<FlowStage, {
         completedAt: string;
     }>>;
+    /**
+     * v6.12.0 — TDD migration cutover marker. When `cclaw-cli sync` detects an
+     * existing `06-tdd.md` with legacy per-slice tables but no auto-render
+     * markers, it inserts the markers and records the highest legacy slice id
+     * here (e.g. `"S-10"`). The TDD linter uses this value to:
+     *   - exempt slices `<= cutoverSliceId` from new mandatory rules (legacy
+     *     slices keep their markdown tables);
+     *   - emit `tdd_legacy_section_writes_after_cutover` advisory when a slice
+     *     id `> cutoverSliceId` appears in legacy per-slice sections of
+     *     `06-tdd.md` (post-cutover prose belongs in `tdd-slices/S-<id>.md`).
+     *
+     * Optional + best-effort: omitted on fresh installs and on legacy files
+     * sync hasn't visited yet.
+     */
+    tddCutoverSliceId?: string;
 }
 export interface StageInteractionHint {
     skipQuestions?: boolean;

package/dist/install.js

@@ -168,6 +168,14 @@ const DEPRECATED_STATE_FILES = [
     // now reads cycle phase progression directly from the artifact table.
     "tdd-cycle-log.jsonl"
 ];
+// v6.11.0 (R5): files under `<runtime>/artifacts/` that previous releases
+// generated and v6.11.0 removed. `cclaw-cli sync` deletes each so existing
+// installs lose the obsolete sidecar without requiring manual cleanup.
+const DEPRECATED_ARTIFACT_FILES = [
+    // v6.10.0 sidecar — replaced in v6.11.0 by phase events in
+    // delegation-events.jsonl + auto-rendered tables in 06-tdd.md.
+    "06-tdd-slices.jsonl"
+];
 const DEPRECATED_HOOK_FILES = [
     "observe.sh",
     "summarize-observations.sh",
@@ -827,6 +835,112 @@ async function writeState(projectRoot, config, forceReset = false) {
     const state = createInitialFlowState({ track: "standard" });
     await writeFileSafe(statePath, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
 }
+/**
+ * v6.12.0 — TDD auto-cutover sync. When sync detects a legacy `06-tdd.md`
+ * (no auto-render markers) carrying observable slice activity (e.g. `S-N`
+ * referenced ≥3 times in slice-section bodies), insert the v6.11.0 marker
+ * skeleton + a one-line cutover banner and stamp the highest legacy slice
+ * id into `flow-state.json::tddCutoverSliceId`. Idempotent: re-running sync
+ * is byte-stable once markers are present.
+ *
+ * Design notes:
+ *   - Best-effort: read failures, missing flow-state, or unparseable JSON
+ *     all short-circuit silently. We never throw inside sync for migration
+ *     bookkeeping.
+ *   - We use `writeFlowState({ allowReset: true })` so we don't trip
+ *     `validateFlowTransition` (the only field we mutate is the new
+ *     additive `tddCutoverSliceId`; transition rules don't apply).
+ *   - The banner mirrors the language in the `## Per-Slice Ritual`
+ *     skill section so a reader of `06-tdd.md` who hasn't seen v6.12.0
+ *     understands the contract change.
+ */
+async function applyTddCutoverIfNeeded(projectRoot) {
+    const tddArtifactPath = runtimePath(projectRoot, "artifacts", "06-tdd.md");
+    let existing;
+    try {
+        existing = await fs.readFile(tddArtifactPath, "utf8");
+    }
+    catch {
+        return;
+    }
+    if (existing.includes("<!-- auto-start: tdd-slice-summary -->")) {
+        return;
+    }
+    const sliceMatches = [...existing.matchAll(/\bS-(\d+)\b/gu)];
+    if (sliceMatches.length < 3) {
+        return;
+    }
+    let maxSliceNum = 0;
+    for (const match of sliceMatches) {
+        const n = Number.parseInt(match[1], 10);
+        if (Number.isFinite(n) && n > maxSliceNum) {
+            maxSliceNum = n;
+        }
+    }
+    if (maxSliceNum <= 0) {
+        return;
+    }
+    const cutoverSliceId = `S-${maxSliceNum}`;
+    const banner = [
+        `<!-- v6.12.0 cutover: slices S-1..${cutoverSliceId} use legacy per-slice tables.`,
+        `     New slices (S-${maxSliceNum + 1}+) use phase events + tdd-slices/<id>.md.`,
+        "     Controller MUST NOT add new rows to legacy sections. -->"
+    ].join("\n");
+    const slicesIndexBlock = [
+        "<!-- auto-start: slices-index -->",
+        "## Slices Index",
+        "",
+        "_Auto-rendered from `tdd-slices/S-*.md` once slice-documenter or controller writes per-slice files. Do not edit by hand._",
+        "<!-- auto-end: slices-index -->"
+    ].join("\n");
+    const summaryBlock = [
+        "<!-- auto-start: tdd-slice-summary -->",
+        "<!-- auto-end: tdd-slice-summary -->"
+    ].join("\n");
+    let nextRaw;
+    if (existing.startsWith("---\n")) {
+        const fmEnd = existing.indexOf("\n---", 4);
+        if (fmEnd >= 0) {
+            const fmClose = fmEnd + 4;
+            const head = existing.slice(0, fmClose);
+            const tail = existing.slice(fmClose);
+            nextRaw = `${head}\n\n${banner}\n\n${slicesIndexBlock}\n\n${summaryBlock}\n${tail}`;
+        }
+        else {
+            nextRaw = `${banner}\n\n${slicesIndexBlock}\n\n${summaryBlock}\n\n${existing}`;
+        }
+    }
+    else {
+        nextRaw = `${banner}\n\n${slicesIndexBlock}\n\n${summaryBlock}\n\n${existing}`;
+    }
+    await writeFileSafe(tddArtifactPath, nextRaw);
+    const slicesDir = runtimePath(projectRoot, "artifacts", "tdd-slices");
+    await ensureDir(slicesDir);
+    const flowStatePath = runtimePath(projectRoot, "state", "flow-state.json");
+    let flowStateRaw;
+    try {
+        flowStateRaw = await fs.readFile(flowStatePath, "utf8");
+    }
+    catch {
+        return;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(flowStateRaw);
+    }
+    catch {
+        return;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return;
+    }
+    const obj = parsed;
+    if (typeof obj.tddCutoverSliceId === "string" && obj.tddCutoverSliceId.length > 0) {
+        return;
+    }
+    obj.tddCutoverSliceId = cutoverSliceId;
+    await writeFileSafe(flowStatePath, `${JSON.stringify(obj, null, 2)}\n`, { mode: 0o600 });
+}
 async function cleanLegacyArtifacts(projectRoot) {
     for (const legacyFolder of DEPRECATED_UTILITY_SKILL_FOLDERS) {
         await removeBestEffort(runtimePath(projectRoot, "skills", legacyFolder), true);
@@ -851,6 +965,7 @@ async function cleanLegacyArtifacts(projectRoot) {
         ...DEPRECATED_COMMAND_FILES.map((file) => runtimePath(projectRoot, "commands", file)),
         ...DEPRECATED_SKILL_FILES.map((segments) => runtimePath(projectRoot, "skills", ...segments)),
         ...DEPRECATED_STATE_FILES.map((file) => runtimePath(projectRoot, "state", file)),
+        ...DEPRECATED_ARTIFACT_FILES.map((file) => runtimePath(projectRoot, "artifacts", file)),
         ...DEPRECATED_RUNTIME_ROOT_FILES.map((file) => runtimePath(projectRoot, file)),
         ...DEPRECATED_HOOK_FILES.map((file) => runtimePath(projectRoot, "hooks", file))
     ]) {
@@ -976,6 +1091,9 @@ async function materializeRuntime(projectRoot, config, forceStateReset, operatio
             writeRulebook(projectRoot)
         ]);
         await writeState(projectRoot, config, forceStateReset);
+        if (operation === "sync" || operation === "upgrade") {
+            await applyTddCutoverIfNeeded(projectRoot);
+        }
         try {
             await ensureRunSystem(projectRoot, { createIfMissing: false });
         }

package/dist/internal/advance-stage.js

@@ -15,7 +15,6 @@ import { parseFlowStateRepairArgs, runFlowStateRepair } from "./flow-state-repai
 import { parseWaiverGrantArgs, runWaiverGrant } from "./waiver-grant.js";
 import { FlowStateGuardMismatchError, verifyFlowStateGuard } from "../run-persistence.js";
 import { DelegationTimestampError, DispatchCapError, DispatchDuplicateError, DispatchOverlapError } from "../delegation.js";
-import { parseTddSliceRecordArgs, runTddSliceRecord } from "../tdd-slices.js";
 import { parsePlanSplitWavesArgs, runPlanSplitWaves } from "./plan-split-waves.js";
 /**
  * Subcommands that mutate or consult flow-state.json via the CLI runtime.
@@ -34,7 +33,7 @@ const GUARD_ENFORCED_SUBCOMMANDS = new Set([
 export async function runInternalCommand(projectRoot, argv, io) {
     const [subcommand, ...tokens] = argv;
     if (!subcommand) {
-        io.stderr.write("cclaw internal requires a subcommand: advance-stage | start-flow | cancel-run | rewind | verify-flow-state-diff | verify-current-state | envelope-validate | tdd-red-evidence | tdd-loop-status | tdd-slice-record | early-loop-status | compound-readiness | runtime-integrity | hook | flow-state-repair | waiver-grant | plan-split-waves\n");
+        io.stderr.write("cclaw internal requires a subcommand: advance-stage | start-flow | cancel-run | rewind | verify-flow-state-diff | verify-current-state | envelope-validate | tdd-red-evidence | tdd-loop-status | early-loop-status | compound-readiness | runtime-integrity | hook | flow-state-repair | waiver-grant | plan-split-waves\n");
         return 1;
     }
     try {
@@ -86,13 +85,10 @@ export async function runInternalCommand(projectRoot, argv, io) {
         if (subcommand === "waiver-grant") {
             return await runWaiverGrant(projectRoot, parseWaiverGrantArgs(tokens), io);
         }
-        if (subcommand === "tdd-slice-record") {
-            return await runTddSliceRecord(projectRoot, parseTddSliceRecordArgs(tokens), io);
-        }
         if (subcommand === "plan-split-waves") {
             return await runPlanSplitWaves(projectRoot, parsePlanSplitWavesArgs(tokens), io);
         }
-        io.stderr.write(`Unknown internal subcommand: ${subcommand}. Expected advance-stage | start-flow | cancel-run | rewind | verify-flow-state-diff | verify-current-state | envelope-validate | tdd-red-evidence | tdd-loop-status | tdd-slice-record | early-loop-status | compound-readiness | runtime-integrity | hook | flow-state-repair | waiver-grant | plan-split-waves\n`);
+        io.stderr.write(`Unknown internal subcommand: ${subcommand}. Expected advance-stage | start-flow | cancel-run | rewind | verify-flow-state-diff | verify-current-state | envelope-validate | tdd-red-evidence | tdd-loop-status | early-loop-status | compound-readiness | runtime-integrity | hook | flow-state-repair | waiver-grant | plan-split-waves\n`);
         return 1;
     }
     catch (err) {

package/dist/run-persistence.js

@@ -471,6 +471,7 @@ function coerceFlowState(parsed) {
     const taskClass = coerceTaskClass(parsed.taskClass);
     const repoSignals = coerceRepoSignals(parsed.repoSignals);
     const completedStageMeta = sanitizeCompletedStageMeta(parsed.completedStageMeta);
+    const tddCutoverSliceId = coerceTddCutoverSliceId(parsed.tddCutoverSliceId);
     const state = {
         schemaVersion: FLOW_STATE_SCHEMA_VERSION,
         activeRunId,
@@ -483,6 +484,7 @@ function coerceFlowState(parsed) {
         ...(taskClass !== undefined ? { taskClass } : {}),
         ...(repoSignals ? { repoSignals } : {}),
         ...(completedStageMeta ? { completedStageMeta } : {}),
+        ...(tddCutoverSliceId ? { tddCutoverSliceId } : {}),
         skippedStages: sanitizeSkippedStages(parsed.skippedStages, track),
         staleStages: sanitizeStaleStages(parsed.staleStages),
         rewinds: sanitizeRewinds(parsed.rewinds),
@@ -492,6 +494,17 @@ function coerceFlowState(parsed) {
     };
     return { state };
 }
+/**
+ * v6.12.0 — best-effort coercion for `tddCutoverSliceId`. Returns the value
+ * only when it matches the canonical slice id shape `S-<digits>`; otherwise
+ * returns null so the field is omitted from the rehydrated state.
+ */
+function coerceTddCutoverSliceId(value) {
+    if (typeof value !== "string")
+        return null;
+    const trimmed = value.trim();
+    return /^S-\d+$/u.test(trimmed) ? trimmed : null;
+}
 export class CorruptFlowStateError extends Error {
     statePath;
     quarantinedPath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cclaw-cli",
-  "version": "6.10.0",
+  "version": "6.12.0",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {