cclaw-cli 6.10.0 → 6.11.0

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/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",
@@ -851,6 +859,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))
     ]) {

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/package.json

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

package/dist/tdd-slices.d.ts

@@ -1,90 +0,0 @@
-/**
- * v6.10.0 — sidecar ledger that replaces the per-slice markdown tables in
- * `06-tdd.md` (Watched-RED Proof, Vertical Slice Cycle, RED/GREEN Evidence).
- *
- * The file lives next to the TDD artifact (`<artifacts-dir>/06-tdd-slices.jsonl`)
- * and is append-only — every CLI call writes a new row, and consumers fold
- * rows by `sliceId` taking the latest entry (by file order). Markdown tables
- * remain a legacy fallback when this sidecar is absent or empty.
- */
-export interface TddSliceLedgerEntry {
-    runId: string;
-    sliceId: string;
-    status: "red" | "green" | "refactor-deferred" | "refactor-done";
-    testFile: string;
-    testCommand: string;
-    redObservedAt?: string;
-    redOutputRef?: string;
-    greenAt?: string;
-    greenOutputRef?: string;
-    refactorAt?: string;
-    refactorRationale?: string;
-    claimedPaths: string[];
-    acceptanceCriterionId?: string;
-    planUnitId?: string;
-    schemaVersion: 1;
-}
-export declare const TDD_SLICE_LEDGER_FILENAME = "06-tdd-slices.jsonl";
-export declare const TDD_SLICE_LEDGER_SCHEMA_VERSION: 1;
-export declare const TDD_SLICE_STATUSES: readonly ["red", "green", "refactor-deferred", "refactor-done"];
-export type TddSliceStatus = (typeof TDD_SLICE_STATUSES)[number];
-/**
- * Resolve `<artifacts-dir>/06-tdd-slices.jsonl`. Mirrors the convention used
- * by the rest of the runtime (see `artifact-paths.ts::searchRoots`): the
- * sidecar always lives under `.cclaw/artifacts/` regardless of the active
- * topic slug for the TDD artifact.
- */
-export declare function tddSliceLedgerPath(projectRoot: string): string;
-export declare function isTddSliceLedgerEntry(value: unknown): value is TddSliceLedgerEntry;
-export declare function readTddSliceLedger(projectRoot: string): Promise<{
-    entries: TddSliceLedgerEntry[];
-    corruptLines: number[];
-}>;
-/**
- * Latest-row-wins fold by `sliceId`. Returns one entry per slice, ordered by
- * the index of its latest row. Mirrors the pattern used by
- * `computeActiveSubagents` for the delegation ledger.
- */
-export declare function foldTddSliceLedger(entries: TddSliceLedgerEntry[]): TddSliceLedgerEntry[];
-/**
- * Atomic append under a directory lock — reuses the same `withDirectoryLock`
- * primitive that `appendDelegation` uses so concurrent CLI invocations don't
- * tear a half-written JSON line.
- */
-export declare function appendSliceEntry(projectRoot: string, entry: TddSliceLedgerEntry): Promise<void>;
-export interface TddSliceRecordArgs {
-    sliceId: string;
-    status: TddSliceStatus;
-    testFile?: string;
-    testCommand?: string;
-    claimedPaths?: string[];
-    redOutputRef?: string;
-    greenOutputRef?: string;
-    redObservedAt?: string;
-    greenAt?: string;
-    refactorAt?: string;
-    refactorRationale?: string;
-    acceptanceCriterionId?: string;
-    planUnitId?: string;
-    json: boolean;
-}
-export declare function parseTddSliceRecordArgs(tokens: string[]): TddSliceRecordArgs;
-interface TddSliceRecordIo {
-    stdout: {
-        write(chunk: string): boolean;
-    };
-    stderr: {
-        write(chunk: string): boolean;
-    };
-}
-/**
- * Consume parsed CLI flags, fold against the existing sidecar to inherit
- * fields recorded on earlier rows of the same slice, auto-stamp the
- * status-relevant timestamp when not provided, and append the new row.
- *
- * The CLI surface is intentionally lenient: only the very first call for a
- * slice (status=red) needs `--test-file`, `--command`, `--paths`. Subsequent
- * green/refactor calls inherit those values from the latest prior row.
- */
-export declare function runTddSliceRecord(projectRoot: string, args: TddSliceRecordArgs, io: TddSliceRecordIo): Promise<number>;
-export {};