cclaw-cli 6.13.1 → 6.14.1

package/dist/artifact-linter/shared.d.ts

@@ -639,4 +639,19 @@ export interface StageLintContext {
      * v6.13.0 — effective worktree execution mode for TDD linters.
      */
     worktreeExecutionMode: "single-tree" | "worktree-first";
+    /**
+     * v6.14.0 — effective TDD checkpoint mode. `per-slice` enforces
+     * RED-before-GREEN per slice (the default for new projects);
+     * `global-red` keeps the v6.12/v6.13 wave-batch barrier (auto-applied
+     * for `legacyContinuation: true` projects on `cclaw-cli sync`).
+     */
+    tddCheckpointMode: "per-slice" | "global-red";
+    /**
+     * v6.14.0 — effective integration-overseer dispatch mode.
+     * `conditional` runs the overseer only when
+     * `integrationCheckRequired()` returns `required: true`; `always`
+     * preserves the v6.13 behavior of running it on every multi-slice
+     * wave.
+     */
+    integrationOverseerMode: "conditional" | "always";
 }

package/dist/artifact-linter/tdd.d.ts

@@ -65,20 +65,50 @@ export declare function evaluateWavePlanDispatchIgnored(params: {
     legacyContinuation: boolean;
 }): Promise<LintFinding | null>;
 /**
- * v6.12.0 Phase W — RED checkpoint enforcement. The wave protocol
- * requires ALL Phase A REDs to land before ANY Phase B GREEN starts.
- * The rule is enforced on a per-wave basis, where a wave is defined by
- * the managed `## Parallel Execution Plan` block in `05-plan.md` and/or
- * `<artifacts-dir>/wave-plans/wave-NN.md` files. When no wave manifest
- * exists, the linter falls back to a conservative implicit detection: a
- * wave is a contiguous run of `phase=red` events with no other-phase
- * events between them; the rule fires only when the implicit wave has
- * 2+ members.
+ * v6.12.0 Phase W (legacy `global-red` mode) — RED checkpoint enforcement.
+ * The wave protocol requires ALL Phase A REDs to land before ANY Phase B
+ * GREEN starts. The rule is enforced on a per-wave basis, where a wave is
+ * defined by the managed `## Parallel Execution Plan` block in
+ * `05-plan.md` and/or `<artifacts-dir>/wave-plans/wave-NN.md` files. When
+ * no wave manifest exists, the linter falls back to a conservative
+ * implicit detection: a wave is a contiguous run of `phase=red` events
+ * with no other-phase events between them; the rule fires only when the
+ * implicit wave has 2+ members.
+ *
+ * v6.14.0: this function powers the `global-red` checkpoint mode. New
+ * projects default to `per-slice` mode (see
+ * `evaluatePerSliceRedBeforeGreen`); `legacyContinuation: true` projects
+ * auto-keep this behavior. Exported under both `evaluateGlobalRedCheckpoint`
+ * (canonical name) and `evaluateRedCheckpoint` (back-compat alias for
+ * existing tests/consumers).
  *
  * @param waveMembers Optional explicit wave manifest. Map key is wave
  * name (e.g. `"W-01"`); value is the set of slice ids in that wave.
  */
-export declare function evaluateRedCheckpoint(slices: Map<string, DelegationEntry[]>, waveMembers?: Map<string, Set<string>> | null): RedCheckpointResult;
+export declare function evaluateGlobalRedCheckpoint(slices: Map<string, DelegationEntry[]>, waveMembers?: Map<string, Set<string>> | null): RedCheckpointResult;
+/**
+ * Back-compat alias for `evaluateGlobalRedCheckpoint` (v6.12.0 Phase W
+ * behavior). Existing tests/consumers can keep importing
+ * `evaluateRedCheckpoint`. The v6.14.0 stream-style mode uses
+ * `evaluatePerSliceRedBeforeGreen` instead.
+ */
+export declare const evaluateRedCheckpoint: typeof evaluateGlobalRedCheckpoint;
+/**
+ * v6.14.0 — per-slice RED-before-GREEN enforcement (default mode).
+ *
+ * For each slice with both phase=red and phase=green completed events,
+ * fail if any green completedTs precedes the slice's last red completedTs.
+ * No global wave barrier — different slices may freely interleave their
+ * RED/GREEN/REFACTOR phases.
+ *
+ * Note: this is intentionally weaker than `evaluateGlobalRedCheckpoint`
+ * because the W-02 measurement on hox showed ~6 minutes of barrier
+ * overhead when slices were already disjoint (file-overlap scheduler did
+ * the parallelism job). The per-slice rule retains the only invariant
+ * that mattered for correctness: no slice goes GREEN before its own
+ * RED is observed failing.
+ */
+export declare function evaluatePerSliceRedBeforeGreen(slices: Map<string, DelegationEntry[]>): RedCheckpointResult;
 export declare function parseVerticalSliceCycle(body: string): ParsedSliceCycleResult;
 interface VerificationLadderResult {
     ok: boolean;

package/dist/artifact-linter/tdd.js

@@ -1,6 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { loadTddReadySlicePool, readDelegationLedger, readDelegationEvents, selectReadySlices } from "../delegation.js";
+import { integrationCheckRequired, loadTddReadySlicePool, readDelegationLedger, readDelegationEvents, selectReadySlices } from "../delegation.js";
 import { mergeParallelWaveDefinitions, parseParallelExecutionPlanWaves, parseWavePlanDirectory } from "../internal/plan-split-waves.js";
 import { evaluateInvestigationTrace, sectionBodyByName } from "./shared.js";
 const SLICE_SUMMARY_START = "<!-- auto-start: tdd-slice-summary -->";
@@ -27,7 +27,7 @@ const SLICES_INDEX_END = "<!-- auto-end: slices-index -->";
  *    via `## Slices Index`.
  */
 export async function lintTddStage(ctx) {
-    const { projectRoot, discoveryMode, raw, absFile, sections, findings, parsedFrontmatter, worktreeExecutionMode, legacyContinuation } = ctx;
+    const { projectRoot, discoveryMode, raw, absFile, sections, findings, parsedFrontmatter, worktreeExecutionMode, legacyContinuation, tddCheckpointMode, integrationOverseerMode } = ctx;
     void parsedFrontmatter;
     const artifactsDir = path.dirname(absFile);
     const planPath = path.join(artifactsDir, "05-plan.md");
@@ -144,21 +144,27 @@ export async function lintTddStage(ctx) {
             });
         }
     }
-    // v6.12.0 Phase R — slice-documenter coverage is mandatory on every
-    // TDD run regardless of discoveryMode. `discoveryMode` is now strictly
-    // an early-stage knob (brainstorm/scope/design); TDD parallelism must
-    // be uniform across lean/guided/deep so the controller cannot quietly
-    // skip per-slice prose by picking a non-deep mode.
-    void discoveryMode;
+    // v6.14.0 Phase 4 — slice-documenter coverage is mandatory only on
+    // `discoveryMode === "deep"` runs. lean/guided still emit the finding
+    // but as advisory (`required: false`) so the controller can choose to
+    // run a tighter inline-doc pass instead. The DOC role still exists;
+    // the linter just stops blocking the gate on lean/guided. Reference
+    // research report Section 4: "soften slice-documenter mandate".
     if (eventsActive) {
         const docResult = evaluateSliceDocumenterCoverage(slicesByEvents);
         if (docResult.missing.length > 0) {
+            const required = discoveryMode === "deep";
             findings.push({
                 section: "tdd_slice_documenter_missing",
-                required: true,
-                rule: "Every TDD slice with a phase=green event must also carry a slice-documenter `phase=doc` event whose evidenceRefs reference `<artifacts-dir>/tdd-slices/S-<id>.md`. The requirement is independent of discoveryMode (v6.12.0 Phase R).",
+                required,
+                rule: required
+                    ? "deep mode: every TDD slice with a phase=green event must also carry a slice-documenter `phase=doc` event whose evidenceRefs reference `<artifacts-dir>/tdd-slices/S-<id>.md`."
+                    : "lean/guided modes (v6.14.0): the slice-documenter `phase=doc` event is advisory; controllers may use slice-implementer --finalize-doc inline instead. Required only for deep mode.",
                 found: false,
-                details: `Slices missing slice-documenter coverage: ${docResult.missing.join(", ")}. Dispatch slice-documenter --slice <id> --phase doc in parallel with slice-implementer --phase green for each slice.`
+                details: `Slices missing slice-documenter coverage: ${docResult.missing.join(", ")}. ` +
+                    (required
+                        ? "Dispatch slice-documenter --slice <id> --phase doc in parallel with slice-implementer --phase green for each slice."
+                        : "Either dispatch slice-documenter --phase doc or call slice-implementer --finalize-doc inline at GREEN-completion.")
             });
         }
     }
@@ -179,23 +185,42 @@ export async function lintTddStage(ctx) {
             });
         }
     }
-    // v6.12.0 Phase W — RED checkpoint enforcement. The wave protocol
-    // requires ALL Phase A REDs to land before ANY Phase B GREEN starts.
-    // Enforced per-wave: explicit `wave-plans/wave-NN.md` manifest if
-    // present, otherwise implicit detection via contiguous red blocks
-    // (size >= 2). Sequential per-slice runs (red→green→refactor in a
-    // tight loop) form size-1 implicit waves and are unaffected.
+    // v6.14.0 Phase 1 — RED checkpoint enforcement. The mode is selected
+    // by `flow-state.json::tddCheckpointMode`:
+    //
+    //   - `per-slice` (default for new projects): enforce RED-before-GREEN
+    //     per slice only. No global wave barrier; lanes run RED→GREEN as
+    //     soon as their dependsOn closes. Rule id:
+    //     `tdd_slice_red_completed_before_green`.
+    //   - `global-red` (auto-applied for legacyContinuation): enforce the
+    //     v6.12 wave-batch barrier — every slice in a wave must complete
+    //     phase=red before any slice in the same wave starts phase=green.
+    //     Rule id: `tdd_red_checkpoint_violation` (legacy).
     if (eventsActive) {
-        const waveManifest = await readMergedWaveManifestForCheckpoint(artifactsDir, planRaw);
-        const checkpointResult = evaluateRedCheckpoint(slicesByEvents, waveManifest);
-        if (!checkpointResult.ok) {
-            findings.push({
-                section: "tdd_red_checkpoint_violation",
-                required: true,
-                rule: "Wave Batch Mode (v6.12.0 Phase W): every slice in a wave must complete phase=red before any slice in the same wave starts phase=green. Detected: a phase=green completedTs precedes the last phase=red completedTs of the same wave.",
-                found: false,
-                details: checkpointResult.details
-            });
+        if (tddCheckpointMode === "global-red") {
+            const waveManifest = await readMergedWaveManifestForCheckpoint(artifactsDir, planRaw);
+            const checkpointResult = evaluateGlobalRedCheckpoint(slicesByEvents, waveManifest);
+            if (!checkpointResult.ok) {
+                findings.push({
+                    section: "tdd_red_checkpoint_violation",
+                    required: true,
+                    rule: "Wave Batch Mode (legacy global-red mode, v6.12.0 Phase W): every slice in a wave must complete phase=red before any slice in the same wave starts phase=green. Detected: a phase=green completedTs precedes the last phase=red completedTs of the same wave.",
+                    found: false,
+                    details: checkpointResult.details
+                });
+            }
+        }
+        else {
+            const perSliceResult = evaluatePerSliceRedBeforeGreen(slicesByEvents);
+            if (!perSliceResult.ok) {
+                findings.push({
+                    section: "tdd_slice_red_completed_before_green",
+                    required: true,
+                    rule: "Stream-style TDD (v6.14.0): each slice's phase=green completedTs must be >= the same slice's last phase=red completedTs. No global wave barrier — lanes run independently.",
+                    found: false,
+                    details: perSliceResult.details
+                });
+            }
         }
     }
     // v6.12.0 Phase L — advisory backslide detection. When a cutover is
@@ -418,15 +443,74 @@ export async function lintTddStage(ctx) {
         const overseerStatusInArtifact = /\bintegration-overseer\b[\s\S]{0,200}\b(?:PASS_WITH_GAPS|PASS)\b/iu.test(raw);
         const integrationOverseerFound = completedOverseerRows.length > 0 &&
             (overseerStatusInEvidence || overseerStatusInArtifact);
+        // v6.14.0 Phase 3 — conditional integration-overseer dispatch. When
+        // `integrationOverseerMode === "conditional"` and
+        // `integrationCheckRequired()` returns required=false, the gate is
+        // soft (advisory) and an audit-only finding is emitted so the
+        // controller can record the deliberate skip in artifacts.
+        //
+        // v6.14.1 — also surface the audit row presence. When the controller
+        // skips `integration-overseer` dispatch (or the heuristic returns
+        // false), the run log MUST contain a
+        // `cclaw_integration_overseer_skipped` audit row for traceability.
+        // The advisory `tdd_integration_overseer_skipped_audit_missing`
+        // surfaces a missing audit row when 2+ closed slices closed without
+        // any overseer dispatch AND no audit was recorded.
+        let overseerVerdict = null;
+        let overseerRequired = true;
+        const skippedAuditRowCount = await countIntegrationOverseerSkippedAudits(projectRoot, delegationLedger.runId);
+        const skippedAuditRowFound = skippedAuditRowCount > 0;
+        if (integrationOverseerMode === "conditional") {
+            const eventsForVerdict = runEvents.length > 0 ? runEvents : [];
+            const auditsForVerdict = fanInAudits.filter((a) => a.runId === delegationLedger.runId);
+            overseerVerdict = integrationCheckRequired(eventsForVerdict, auditsForVerdict);
+            overseerRequired = overseerVerdict.required;
+            if (!overseerVerdict.required) {
+                const auditRowSuffix = skippedAuditRowFound
+                    ? "audit row recorded — skip is fully traceable."
+                    : "audit row MISSING — controller should append `cclaw_integration_overseer_skipped` for traceability (see `tdd_integration_overseer_skipped_audit_missing`).";
+                findings.push({
+                    section: "tdd_integration_overseer_skipped_by_disjoint_paths",
+                    required: false,
+                    rule: "v6.14.0+ conditional integration-overseer mode: the heuristic returned `required: false` (disjoint claimedPaths, no high-risk slices, no fan-in conflicts). The controller may skip dispatching `integration-overseer` and emit a `cclaw_integration_overseer_skipped` audit row instead.",
+                    found: true,
+                    details: `integrationCheckRequired() reasons: ${overseerVerdict.reasons.join(", ")}. Skip is safe — ${auditRowSuffix}`
+                });
+            }
+        }
+        // v6.14.1 — `tdd_integration_overseer_skipped_audit_missing` (advisory).
+        // Fires when fan-out is detected (2+ completed slice-implementers),
+        // no `integration-overseer` was dispatched at all (no scheduled or
+        // completed row for the active run), AND no
+        // `cclaw_integration_overseer_skipped` audit row exists. This pairs
+        // with the controller skill text rule that the wave-closure decision
+        // ("dispatch overseer or skip") MUST leave a trail.
+        const overseerDispatched = activeRunEntries.some((entry) => entry.agent === "integration-overseer");
+        if (!overseerDispatched && !skippedAuditRowFound) {
+            findings.push({
+                section: "tdd_integration_overseer_skipped_audit_missing",
+                required: false,
+                rule: "v6.14.1: when a wave with 2+ closed slices closes without any integration-overseer dispatch, the controller should call `integrationCheckRequired()` and emit a `cclaw_integration_overseer_skipped` audit row so the decision is traceable. Advisory — never blocks stage-complete.",
+                found: false,
+                details: `Fan-out detected (${completedSliceImplementers.length} completed slice-implementer rows) but no integration-overseer dispatch row OR cclaw_integration_overseer_skipped audit row exists for active run. ` +
+                    "Remediation: emit `node .cclaw/hooks/delegation-record.mjs --audit-kind=cclaw_integration_overseer_skipped --audit-reason=\"<reasons>\" --slice-ids=\"<S-1,S-2,...>\"` after wave closure."
+            });
+        }
         findings.push({
             section: "tdd.integration_overseer_missing",
-            required: true,
-            rule: "When fan-out is detected, require completed `integration-overseer` evidence with PASS or PASS_WITH_GAPS.",
+            required: overseerRequired,
+            rule: overseerRequired
+                ? "When fan-out is detected, require completed `integration-overseer` evidence with PASS or PASS_WITH_GAPS."
+                : "v6.14.0+ conditional integration-overseer mode: integration-overseer dispatch is advisory because `integrationCheckRequired()` returned required=false. Run it anyway if the run touches new boundaries.",
             found: integrationOverseerFound,
             details: integrationOverseerFound
                 ? "integration-overseer completion recorded with PASS/PASS_WITH_GAPS evidence."
                 : completedOverseerRows.length === 0
-                    ? "Fan-out detected but no completed integration-overseer delegation row exists for active run."
+                    ? overseerRequired
+                        ? "Fan-out detected but no completed integration-overseer delegation row exists for active run."
+                        : skippedAuditRowFound
+                            ? "Fan-out detected; integration-overseer not dispatched (conditional mode skipped on disjoint paths) and `cclaw_integration_overseer_skipped` audit row recorded. Audit-only."
+                            : "Fan-out detected; integration-overseer not dispatched (conditional mode skipped on disjoint paths). Audit-only."
                     : "integration-overseer completion exists, but PASS/PASS_WITH_GAPS evidence is missing in delegation evidenceRefs and artifact text."
         });
     }
@@ -500,6 +584,46 @@ export async function lintTddStage(ctx) {
         }
     }
 }
+/**
+ * v6.14.1 — count `cclaw_integration_overseer_skipped` audit rows in
+ * `delegation-events.jsonl` for a given runId. The audit row is not a
+ * `DelegationEvent` (no agent/status), so `readDelegationEvents`
+ * filters it out; we re-scan the raw file with a narrow JSON match.
+ *
+ * Best-effort: missing file or parse errors return 0.
+ */
+async function countIntegrationOverseerSkippedAudits(projectRoot, runId) {
+    const filePath = path.join(projectRoot, ".cclaw/state/delegation-events.jsonl");
+    let raw = "";
+    try {
+        raw = await fs.readFile(filePath, "utf8");
+    }
+    catch {
+        return 0;
+    }
+    let count = 0;
+    for (const line of raw.split(/\r?\n/u)) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            continue;
+        const obj = parsed;
+        if (obj.event !== "cclaw_integration_overseer_skipped")
+            continue;
+        if (typeof obj.runId === "string" && obj.runId !== runId)
+            continue;
+        count += 1;
+    }
+    return count;
+}
 async function listSliceFiles(slicesDir) {
     let entries = [];
     try {
@@ -632,19 +756,43 @@ export function evaluateEventsSliceCycle(slices) {
             });
             continue;
         }
-        if (refactors.length === 0) {
+        // v6.14.0 — refactorOutcome on phase=green satisfies REFACTOR coverage
+        // without a separate phase=refactor / phase=refactor-deferred row.
+        // - mode: "inline" → REFACTOR ran inline as part of GREEN.
+        // - mode: "deferred" → rationale required (carried in evidenceRefs[0]
+        //   by the hook helper so legacy linters keep working).
+        const greenWithOutcome = greens.find((entry) => entry.refactorOutcome &&
+            (entry.refactorOutcome.mode === "inline" || entry.refactorOutcome.mode === "deferred"));
+        if (refactors.length === 0 && !greenWithOutcome) {
             errors.push(`${sliceId}: phase=refactor or phase=refactor-deferred event missing.`);
             findings.push({
                 section: `tdd_slice_refactor_missing:${sliceId}`,
                 required: true,
-                rule: "Each TDD slice must close with a `phase=refactor` event or a `phase=refactor-deferred` event whose evidenceRefs / refactorRationale captures why refactor was deferred.",
+                rule: "Each TDD slice must close with a `phase=refactor` event, a `phase=refactor-deferred` event whose evidenceRefs / refactorRationale captures why refactor was deferred, OR a `phase=green` event carrying `refactorOutcome` (v6.14.0).",
                 found: false,
-                details: `${sliceId}: no phase=refactor or phase=refactor-deferred event.`
+                details: `${sliceId}: no phase=refactor / phase=refactor-deferred event and no refactorOutcome on phase=green.`
+            });
+            continue;
+        }
+        if (greenWithOutcome &&
+            greenWithOutcome.refactorOutcome?.mode === "deferred" &&
+            !greenWithOutcome.refactorOutcome.rationale &&
+            !(Array.isArray(greenWithOutcome.evidenceRefs) &&
+                greenWithOutcome.evidenceRefs.some((ref) => typeof ref === "string" && ref.trim().length > 0))) {
+            errors.push(`${sliceId}: phase=green refactorOutcome=deferred missing rationale.`);
+            findings.push({
+                section: `tdd_slice_refactor_missing:${sliceId}`,
+                required: true,
+                rule: "phase=green refactorOutcome=deferred requires a rationale (via --refactor-rationale or --evidence-ref).",
+                found: false,
+                details: `${sliceId}: phase=green refactorOutcome.mode=deferred recorded without rationale.`
             });
             continue;
         }
         const deferred = refactors.find((entry) => entry.phase === "refactor-deferred");
-        if (deferred && refactors.every((entry) => entry.phase === "refactor-deferred")) {
+        if (refactors.length > 0 &&
+            deferred &&
+            refactors.every((entry) => entry.phase === "refactor-deferred")) {
             const refs = Array.isArray(deferred.evidenceRefs) ? deferred.evidenceRefs : [];
             const hasRationale = refs.some((ref) => typeof ref === "string" && ref.trim().length > 0);
             if (!hasRationale) {
@@ -814,20 +962,27 @@ export async function evaluateWavePlanDispatchIgnored(params) {
     return null;
 }
 /**
- * v6.12.0 Phase W — RED checkpoint enforcement. The wave protocol
- * requires ALL Phase A REDs to land before ANY Phase B GREEN starts.
- * The rule is enforced on a per-wave basis, where a wave is defined by
- * the managed `## Parallel Execution Plan` block in `05-plan.md` and/or
- * `<artifacts-dir>/wave-plans/wave-NN.md` files. When no wave manifest
- * exists, the linter falls back to a conservative implicit detection: a
- * wave is a contiguous run of `phase=red` events with no other-phase
- * events between them; the rule fires only when the implicit wave has
- * 2+ members.
+ * v6.12.0 Phase W (legacy `global-red` mode) — RED checkpoint enforcement.
+ * The wave protocol requires ALL Phase A REDs to land before ANY Phase B
+ * GREEN starts. The rule is enforced on a per-wave basis, where a wave is
+ * defined by the managed `## Parallel Execution Plan` block in
+ * `05-plan.md` and/or `<artifacts-dir>/wave-plans/wave-NN.md` files. When
+ * no wave manifest exists, the linter falls back to a conservative
+ * implicit detection: a wave is a contiguous run of `phase=red` events
+ * with no other-phase events between them; the rule fires only when the
+ * implicit wave has 2+ members.
+ *
+ * v6.14.0: this function powers the `global-red` checkpoint mode. New
+ * projects default to `per-slice` mode (see
+ * `evaluatePerSliceRedBeforeGreen`); `legacyContinuation: true` projects
+ * auto-keep this behavior. Exported under both `evaluateGlobalRedCheckpoint`
+ * (canonical name) and `evaluateRedCheckpoint` (back-compat alias for
+ * existing tests/consumers).
  *
  * @param waveMembers Optional explicit wave manifest. Map key is wave
  * name (e.g. `"W-01"`); value is the set of slice ids in that wave.
  */
-export function evaluateRedCheckpoint(slices, waveMembers = null) {
+export function evaluateGlobalRedCheckpoint(slices, waveMembers = null) {
     const events = [];
     for (const [sliceId, rows] of slices.entries()) {
         for (const entry of rows) {
@@ -903,6 +1058,63 @@ export function evaluateRedCheckpoint(slices, waveMembers = null) {
             "Dispatch ALL Phase A test-author --phase red calls in one message, verify every phase=red event lands with non-empty evidenceRefs, and only then dispatch Phase B slice-implementer --phase green + slice-documenter --phase doc fan-out."
     };
 }
+/**
+ * Back-compat alias for `evaluateGlobalRedCheckpoint` (v6.12.0 Phase W
+ * behavior). Existing tests/consumers can keep importing
+ * `evaluateRedCheckpoint`. The v6.14.0 stream-style mode uses
+ * `evaluatePerSliceRedBeforeGreen` instead.
+ */
+export const evaluateRedCheckpoint = evaluateGlobalRedCheckpoint;
+/**
+ * v6.14.0 — per-slice RED-before-GREEN enforcement (default mode).
+ *
+ * For each slice with both phase=red and phase=green completed events,
+ * fail if any green completedTs precedes the slice's last red completedTs.
+ * No global wave barrier — different slices may freely interleave their
+ * RED/GREEN/REFACTOR phases.
+ *
+ * Note: this is intentionally weaker than `evaluateGlobalRedCheckpoint`
+ * because the W-02 measurement on hox showed ~6 minutes of barrier
+ * overhead when slices were already disjoint (file-overlap scheduler did
+ * the parallelism job). The per-slice rule retains the only invariant
+ * that mattered for correctness: no slice goes GREEN before its own
+ * RED is observed failing.
+ */
+export function evaluatePerSliceRedBeforeGreen(slices) {
+    const violations = [];
+    for (const [sliceId, rows] of slices.entries()) {
+        const reds = rows.filter((entry) => entry.phase === "red");
+        const greens = rows.filter((entry) => entry.phase === "green");
+        if (reds.length === 0 || greens.length === 0)
+            continue;
+        const redTs = reds
+            .map((entry) => entry.completedTs ?? entry.endTs ?? entry.ts ?? "")
+            .filter((ts) => ts.length > 0)
+            .sort();
+        const greenTs = greens
+            .map((entry) => entry.completedTs ?? entry.endTs ?? entry.ts ?? "")
+            .filter((ts) => ts.length > 0)
+            .sort();
+        if (redTs.length === 0 || greenTs.length === 0)
+            continue;
+        const lastRed = redTs[redTs.length - 1];
+        const earliestGreen = greenTs[0];
+        if (earliestGreen < lastRed) {
+            violations.push(`${sliceId}: phase=green completedTs (${earliestGreen}) precedes the slice's last phase=red completedTs (${lastRed})`);
+        }
+    }
+    if (violations.length === 0) {
+        return {
+            ok: true,
+            details: `Per-slice RED-before-GREEN holds: ${slices.size} slice(s) checked.`
+        };
+    }
+    return {
+        ok: false,
+        details: `Per-slice RED-before-GREEN violation: ${violations.join("; ")}. ` +
+            "Stream-style TDD requires each slice's RED to land before its own GREEN, but cross-lane interleaving is allowed."
+    };
+}
 const LEGACY_PER_SLICE_SECTIONS = [
     "Test Discovery",
     "RED Evidence",

package/dist/artifact-linter.js

@@ -1,7 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { resolveArtifactPath as resolveStageArtifactPath } from "./artifact-paths.js";
-import { effectiveWorktreeExecutionMode } from "./flow-state.js";
+import { effectiveIntegrationOverseerMode, effectiveTddCheckpointMode, effectiveWorktreeExecutionMode } from "./flow-state.js";
 import { exists } from "./fs-utils.js";
 import { stageSchema } from "./content/stage-schema.js";
 import { readFlowState } from "./run-persistence.js";
@@ -124,6 +124,8 @@ export async function lintArtifact(projectRoot, stage, track = "standard", optio
     let completedStageMetaForAudit;
     let legacyContinuation = false;
     let worktreeExecutionMode = "single-tree";
+    let tddCheckpointMode = "per-slice";
+    let integrationOverseerMode = "always";
     try {
         const flowState = await readFlowState(projectRoot);
         const hint = flowState.interactionHints?.[stage];
@@ -136,6 +138,8 @@ export async function lintArtifact(projectRoot, stage, track = "standard", optio
         completedStageMetaForAudit = flowState.completedStageMeta;
         legacyContinuation = flowState.legacyContinuation === true;
         worktreeExecutionMode = effectiveWorktreeExecutionMode(flowState);
+        tddCheckpointMode = effectiveTddCheckpointMode(flowState);
+        integrationOverseerMode = effectiveIntegrationOverseerMode(flowState);
     }
     catch {
         activeStageFlags = [];
@@ -146,6 +150,8 @@ export async function lintArtifact(projectRoot, stage, track = "standard", optio
         completedStageMetaForAudit = undefined;
         legacyContinuation = false;
         worktreeExecutionMode = "single-tree";
+        tddCheckpointMode = "per-slice";
+        integrationOverseerMode = "always";
     }
     for (const extra of options.extraStageFlags ?? []) {
         if (typeof extra === "string" && extra.length > 0 && !activeStageFlags.includes(extra)) {
@@ -283,7 +289,9 @@ export async function lintArtifact(projectRoot, stage, track = "standard", optio
         activeStageFlags,
         taskClass,
         legacyContinuation,
-        worktreeExecutionMode
+        worktreeExecutionMode,
+        tddCheckpointMode,
+        integrationOverseerMode
     };
     switch (stage) {
         case "brainstorm":

package/dist/content/core-agents.js

@@ -52,6 +52,56 @@ Before doing substantive work, return an ACK object that the parent can record:
 
 Finish with the required return schema plus the same \`spanId\` and \`dispatchId\`. The parent must not claim isolated completion unless ACK/result proof matches the ledger/event span.`;
 }
+/**
+ * v6.14.1 — TDD worker self-record contract. The parent records
+ * `scheduled` and `launched` rows BEFORE dispatching the Task; the
+ * worker is responsible for `acknowledged` (on entry) and `completed`
+ * (on exit). This contract restores the v6.13.1 discipline that
+ * v6.14.0 dropped — the controller-side fix in v6.14.1's TDD skill
+ * text is paired with this worker-side self-record helper template.
+ */
+function tddWorkerSelfRecordContract(agentName) {
+    const isImplementer = agentName === "slice-implementer";
+    const refactorOutcomeFlag = isImplementer
+        ? " --refactor-outcome=inline|deferred [--refactor-rationale=\"<why>\"]"
+        : "";
+    const laneFlags = isImplementer
+        ? " [--claim-token=<t>] [--lane-id=<lane>] [--lease-until=<iso>]"
+        : "";
+    return `## TDD Worker Self-Record Contract (v6.14.1)
+
+You are a TDD worker dispatched via \`Task\`. The parent already wrote your \`scheduled\` and \`launched\` ledger rows BEFORE invoking you. **Your responsibility is to self-record \`acknowledged\` on entry and \`completed\` on exit** by invoking \`.cclaw/hooks/delegation-record.mjs\` directly. Do NOT skip these — the controller depends on them, the linter validates them, and back-fill via \`--repair\` is reserved for recovery only.
+
+**On entry — record acknowledgement (BEFORE doing work):**
+
+\`\`\`bash
+ACK_TS="$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ 2>/dev/null || date -u +%Y-%m-%dT%H:%M:%SZ)"
+node .cclaw/hooks/delegation-record.mjs \\
+  --stage=tdd --agent=${agentName} --mode=mandatory \\
+  --status=acknowledged \\
+  --span-id=<spanId from controller dispatch> \\
+  --dispatch-id=<dispatchId from controller dispatch> \\
+  --dispatch-surface=<surface from controller dispatch> \\
+  --agent-definition-path=.cclaw/agents/${agentName}.md \\
+  --ack-ts="$ACK_TS" \\
+  --json
+\`\`\`
+
+**On exit — record completion (AFTER work + verification):**
+
+\`\`\`bash
+COMPLETED_TS="$(date -u +%Y-%m-%dT%H:%M:%S.%3NZ 2>/dev/null || date -u +%Y-%m-%dT%H:%M:%SZ)"
+node .cclaw/hooks/delegation-record.mjs \\
+  --stage=tdd --agent=${agentName} --mode=mandatory \\
+  --status=completed \\
+  --span-id=<same spanId> \\
+  --completed-ts="$COMPLETED_TS" \\
+  --evidence-ref="<test-path-or-artifact-ref>"${refactorOutcomeFlag}${laneFlags} \\
+  --json
+\`\`\`
+
+Reuse the same \`<spanId>\` and \`<dispatchId>\` across both rows. \`--ack-ts\` and \`--completed-ts\` must be monotonic on the span (\`startTs ≤ launchedTs ≤ ackTs ≤ completedTs\`); the helper rejects out-of-order writes with \`delegation_timestamp_non_monotonic\`. If the helper rejects with \`dispatch_active_span_collision\` against a stale span, surface the conflicting \`spanId\` to the parent — do NOT silently retry with \`--allow-parallel\`.`;
+}
 function formatReturnSchema(schema) {
     const lines = [
         `- Status field: \`${schema.statusField}\``,
@@ -600,6 +650,18 @@ export const CCLAW_AGENTS = [
         ].join("\n")
     }
 ];
+/**
+ * v6.14.1 — agents whose rendered `.cclaw/agents/<name>.md` file gets the
+ * TDD worker self-record helper template. These agents are the ones the
+ * controller dispatches via `Task` during a TDD wave; they are
+ * responsible for `acknowledged` and `completed` ledger writes.
+ */
+const TDD_WORKER_SELF_RECORD_AGENTS = new Set([
+    "test-author",
+    "slice-implementer",
+    "slice-documenter",
+    "integration-overseer"
+]);
 import { stageDelegationSummary } from "./stage-schema.js";
 /**
  * Render a complete cclaw agent markdown file (YAML frontmatter + body).
@@ -627,6 +689,9 @@ export function agentMarkdown(agent) {
     ].join("\n");
     const relatedStages = agent.relatedStages.length > 0 ? agent.relatedStages.join(", ") : "(none)";
     const taskDelegation = defaultTaskDelegationSection(agent.name);
+    const tddWorkerSelfRecordSection = TDD_WORKER_SELF_RECORD_AGENTS.has(agent.name)
+        ? `\n${tddWorkerSelfRecordContract(agent.name)}\n`
+        : "";
     return `${frontmatter}
 
 # ${agent.name}
@@ -639,7 +704,7 @@ ${agent.body}
 - Related stages: ${relatedStages}
 
 ${workerAckContract()}
-
+${tddWorkerSelfRecordSection}
 ## Required Return Schema
 
 STRICT_RETURN_SCHEMA: return a structured object matching this contract before any narrative when delegated. Include \`spanId\`, \`dispatchId\` or \`workerRunId\`, \`dispatchSurface\`, \`agentDefinitionPath\`, and lifecycle timestamps when provided by the parent.