cclaw-cli 6.13.0 → 6.14.0

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

@@ -1,4 +1,4 @@
-import type { DelegationEntry } from "../delegation.js";
+import type { DelegationEntry, DelegationEvent } from "../delegation.js";
 import { type LintFinding, type StageLintContext } from "./shared.js";
 /**
  * v6.11.0 — TDD stage linter.
@@ -53,19 +53,62 @@ interface RedCheckpointResult {
     details: string;
 }
 /**
- * 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
- * `<artifacts-dir>/wave-plans/wave-NN.md` files (when present) listing
- * slice ids. 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.13.1 — detect single-slice dispatch when the merged wave plan
+ * requires parallel ready slice-implementer fan-out.
+ */
+export declare function evaluateWavePlanDispatchIgnored(params: {
+    artifactsDir: string;
+    planMarkdown: string;
+    runEvents: DelegationEvent[];
+    runId: string;
+    slices: Map<string, DelegationEntry[]>;
+    legacyContinuation: boolean;
+}): Promise<LintFinding | null>;
+/**
+ * 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,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { readDelegationLedger, readDelegationEvents } 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 -->";
 const SLICE_SUMMARY_END = "<!-- auto-end: tdd-slice-summary -->";
@@ -26,8 +27,17 @@ 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 } = 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");
+    let planRaw = "";
+    try {
+        planRaw = await fs.readFile(planPath, "utf8");
+    }
+    catch {
+        planRaw = "";
+    }
     evaluateInvestigationTrace(ctx, "Watched-RED Proof");
     const delegationLedger = await readDelegationLedger(ctx.projectRoot);
     const activeRunEntries = delegationLedger.entries.filter((entry) => entry.stage === "tdd" && entry.runId === delegationLedger.runId);
@@ -134,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.")
             });
         }
     }
@@ -169,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 readWaveManifest(path.dirname(absFile));
-        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
@@ -203,52 +238,69 @@ export async function lintTddStage(ctx) {
     }
     const { events: jsonlEvents, fanInAudits } = await readDelegationEvents(projectRoot);
     const runEvents = jsonlEvents.filter((e) => e.runId === delegationLedger.runId);
+    if (eventsActive && planRaw.length > 0) {
+        const ignoredWave = await evaluateWavePlanDispatchIgnored({
+            artifactsDir,
+            planMarkdown: planRaw,
+            runEvents,
+            runId: delegationLedger.runId,
+            slices: slicesByEvents,
+            legacyContinuation
+        });
+        if (ignoredWave) {
+            findings.push(ignoredWave);
+        }
+    }
     if (eventsActive && worktreeExecutionMode === "worktree-first") {
         const terminalPhases = new Set([
-            "green",
             "refactor",
             "refactor-deferred",
             "resolve-conflict"
         ]);
-        const missingClaim = new Set();
+        const missingGreenMeta = new Set();
         for (const ev of runEvents) {
             if (ev.stage !== "tdd" || ev.agent !== "slice-implementer")
                 continue;
-            if (ev.status !== "completed" && ev.status !== "failed")
+            if (ev.status !== "completed" || ev.phase !== "green")
                 continue;
-            if (!ev.phase || !terminalPhases.has(ev.phase))
+            if (typeof ev.sliceId !== "string")
                 continue;
             const tok = ev.claimToken?.trim() ?? "";
-            if (tok.length === 0 && typeof ev.sliceId === "string") {
-                missingClaim.add(ev.sliceId);
+            const lane = ev.ownerLaneId?.trim() ?? "";
+            const lease = ev.leasedUntil?.trim() ?? "";
+            if (tok.length === 0 || lane.length === 0 || lease.length === 0) {
+                missingGreenMeta.add(ev.sliceId);
             }
         }
-        if (missingClaim.size > 0) {
+        if (missingGreenMeta.size > 0) {
             findings.push({
-                section: "tdd_slice_claim_token_missing",
+                section: "tdd_slice_lane_metadata_missing",
                 required: true,
-                rule: "Worktree-first: terminal slice-implementer rows must echo --claim-token. Remediation: pass the same --claim-token used on the scheduled row for every completed/failed terminal phase.",
+                rule: "Worktree-first: every completed slice-implementer phase=green row must record claimToken, ownerLaneId (--lane-id), and leasedUntil (--lease-until).",
                 found: false,
-                details: `Slices missing claim token on terminal rows: ${[...missingClaim].join(", ")}.`
+                details: `Slices missing one or more lane fields on GREEN: ${[...missingGreenMeta].sort().join(", ")}. Remediation: include --claim-token, --lane-id, and --lease-until on every slice-implementer --phase green delegation-record write (schedule through completion); the hook fails fast with dispatch_lane_metadata_missing when they are omitted.`
             });
         }
-        const missingLane = new Set();
+        const missingClaim = new Set();
         for (const ev of runEvents) {
             if (ev.stage !== "tdd" || ev.agent !== "slice-implementer")
                 continue;
-            if (ev.status !== "completed" || ev.phase !== "green")
+            if (ev.status !== "completed" && ev.status !== "failed")
                 continue;
-            if (!ev.ownerLaneId?.trim() && typeof ev.sliceId === "string") {
-                missingLane.add(ev.sliceId);
+            if (!ev.phase || !terminalPhases.has(ev.phase))
+                continue;
+            const tok = ev.claimToken?.trim() ?? "";
+            if (tok.length === 0 && typeof ev.sliceId === "string") {
+                missingClaim.add(ev.sliceId);
             }
         }
-        if (missingLane.size > 0) {
+        if (missingClaim.size > 0) {
             findings.push({
-                section: "tdd_slice_worktree_metadata_missing",
+                section: "tdd_slice_claim_token_missing",
                 required: true,
-                rule: "Worktree-first: completed GREEN rows must record --lane-id (ownerLaneId) for the lane worktree.",
+                rule: "Worktree-first: terminal slice-implementer rows (refactor / refactor-deferred / resolve-conflict) must echo --claim-token. Remediation: pass the same --claim-token used on the scheduled row for every completed/failed terminal phase.",
                 found: false,
-                details: `Slices missing ownerLaneId on GREEN completion: ${[...missingLane].join(", ")}.`
+                details: `Slices missing claim token on non-GREEN terminal rows: ${[...missingClaim].join(", ")}.`
             });
         }
         const conflictSlices = [
@@ -338,7 +390,6 @@ export async function lintTddStage(ctx) {
     const completedSliceImplementers = activeRunEntries.filter((entry) => entry.agent === "slice-implementer" && entry.status === "completed");
     const fanOutDetected = completedSliceImplementers.length > 1;
     if (fanOutDetected) {
-        const artifactsDir = path.dirname(absFile);
         const cohesionContractMarkdownPath = path.join(artifactsDir, "cohesion-contract.md");
         const cohesionContractJsonPath = path.join(artifactsDir, "cohesion-contract.json");
         let cohesionContractFound = true;
@@ -392,15 +443,41 @@ 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.
+        let overseerVerdict = null;
+        let overseerRequired = true;
+        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) {
+                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 — record an audit row via delegation events for traceability.`
+                });
+            }
+        }
         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."
+                        : "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."
         });
     }
@@ -418,7 +495,6 @@ export async function lintTddStage(ctx) {
     // Phase S — sharded slice files. Validate per-slice file presence
     // and required headings. `tdd-slices/` is optional; missing folder
     // simply means main-only mode (legacy fallback).
-    const artifactsDir = path.dirname(absFile);
     const slicesDir = path.join(artifactsDir, "tdd-slices");
     const sliceFiles = await listSliceFiles(slicesDir);
     for (const sliceFile of sliceFiles) {
@@ -607,19 +683,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 / 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}: no phase=refactor or phase=refactor-deferred event.`
+                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) {
@@ -694,20 +794,122 @@ export function evaluateSliceImplementerCoverage(slices) {
     }
     return { missing };
 }
+async function readMergedWaveManifestForCheckpoint(artifactsDir, planMarkdown) {
+    try {
+        const merged = mergeParallelWaveDefinitions(parseParallelExecutionPlanWaves(planMarkdown), await parseWavePlanDirectory(artifactsDir));
+        if (merged.length === 0)
+            return null;
+        const map = new Map();
+        for (const w of merged) {
+            map.set(w.waveId, new Set(w.members.map((m) => m.sliceId)));
+        }
+        return map.size > 0 ? map : null;
+    }
+    catch {
+        return null;
+    }
+}
+function sliceRefactorTerminal(sliceId, slices) {
+    const rows = slices.get(sliceId);
+    if (!rows)
+        return false;
+    return rows.some((e) => e.agent === "slice-implementer" &&
+        (e.phase === "refactor" || e.phase === "refactor-deferred") &&
+        (e.status === "completed" || e.status === "failed"));
+}
+/**
+ * v6.13.1 — detect single-slice dispatch when the merged wave plan
+ * requires parallel ready slice-implementer fan-out.
+ */
+export async function evaluateWavePlanDispatchIgnored(params) {
+    let merged;
+    try {
+        merged = mergeParallelWaveDefinitions(parseParallelExecutionPlanWaves(params.planMarkdown), await parseWavePlanDirectory(params.artifactsDir));
+    }
+    catch {
+        return null;
+    }
+    if (merged.length === 0)
+        return null;
+    let pool;
+    try {
+        pool = await loadTddReadySlicePool(params.planMarkdown, params.artifactsDir, {
+            legacyParallelDefaultSerial: params.legacyContinuation
+        });
+    }
+    catch {
+        return null;
+    }
+    if (pool.length === 0)
+        return null;
+    const completedUnitIds = new Set();
+    for (const u of pool) {
+        if (sliceRefactorTerminal(u.sliceId, params.slices)) {
+            completedUnitIds.add(u.unitId);
+        }
+    }
+    const scoped = params.runEvents.filter((e) => e.runId === params.runId);
+    const tail = scoped.slice(-20);
+    const implInTail = new Set();
+    for (const e of tail) {
+        if (e.agent === "slice-implementer" && typeof e.sliceId === "string" && e.sliceId.length > 0) {
+            implInTail.add(e.sliceId);
+        }
+    }
+    if (implInTail.size !== 1)
+        return null;
+    for (const wave of merged) {
+        const waveSliceSet = new Set(wave.members.map((m) => m.sliceId));
+        const wavePool = pool.filter((u) => waveSliceSet.has(u.sliceId));
+        if (wavePool.length < 2)
+            continue;
+        const waveIncomplete = wave.members.some((m) => !sliceRefactorTerminal(m.sliceId, params.slices));
+        if (!waveIncomplete)
+            continue;
+        const ready = selectReadySlices(wavePool, {
+            cap: Math.max(32, wavePool.length),
+            completedUnitIds,
+            activePathHolders: [],
+            legacyContinuation: params.legacyContinuation
+        });
+        if (ready.length < 2)
+            continue;
+        const only = [...implInTail][0];
+        const missed = ready.map((r) => r.sliceId).filter((s) => s !== only);
+        if (missed.length === 0)
+            continue;
+        return {
+            section: "tdd_wave_plan_ignored",
+            required: true,
+            rule: "When the Parallel Execution Plan (or wave-plans/) defines an open wave with two or more ready parallelizable slices, the controller must fan out slice-implementer work for each ready slice instead of serializing to one slice only.",
+            found: false,
+            details: `Wave ${wave.waveId}: scheduler-ready members ${ready.map((r) => r.sliceId).join(", ")}; last 20 delegation events show slice-implementer only for ${only}. Missed parallel dispatch: ${missed.join(", ")}. Remediation: load \`05-plan.md\` (Parallel Execution Plan) and \`wave-plans/\` before routing, launch the wave (AskQuestion only when waveCount>=2 and single-slice is a real alternative), then dispatch GREEN+DOC for every ready slice with mandatory worktree-first flags on GREEN.`
+        };
+    }
+    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
- * `<artifacts-dir>/wave-plans/wave-NN.md` files (when present) listing
- * slice ids. 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) {
@@ -784,40 +986,61 @@ export function evaluateRedCheckpoint(slices, waveMembers = null) {
     };
 }
 /**
- * Read explicit wave manifest from `<artifacts-dir>/wave-plans/wave-NN.md`
- * files. Returns a map from wave name to the set of slice ids it
- * contains. Slice ids are extracted via `S-<digits>` regex matches in
- * each wave file. Returns null when no wave files exist or all are
- * empty/unparseable.
+ * 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.
  */
-async function readWaveManifest(artifactsDir) {
-    const wavePlansDir = path.join(artifactsDir, "wave-plans");
-    let entries = [];
-    try {
-        entries = await fs.readdir(wavePlansDir);
-    }
-    catch {
-        return null;
-    }
-    const waves = new Map();
-    for (const name of entries) {
-        const match = /^wave-(\d+)\.md$/u.exec(name);
-        if (!match)
+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 wavePath = path.join(wavePlansDir, name);
-        let body = "";
-        try {
-            body = await fs.readFile(wavePath, "utf8");
-        }
-        catch {
+        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})`);
         }
-        const ids = extractSliceIdsFromBody(body);
-        if (ids.length === 0)
-            continue;
-        waves.set(`W-${match[1]}`, new Set(ids));
     }
-    return waves.size > 0 ? waves : null;
+    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",