cclaw-cli 6.13.1 → 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

@@ -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,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."
         });
     }
@@ -632,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 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 +889,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 +985,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/hooks.js

@@ -343,7 +343,7 @@ function usage() {
     "Usage:",
     "  node .cclaw/hooks/delegation-record.mjs --stage=<stage> --agent=<agent> --mode=<mandatory|proactive> --status=<scheduled|launched|acknowledged|completed|failed|waived|stale> --span-id=<id> [--dispatch-id=<id>] [--worker-run-id=<id>] [--dispatch-surface=<surface>] [--agent-definition-path=<path>] [--ack-ts=<iso>] [--launched-ts=<iso>] [--completed-ts=<iso>] [--evidence-ref=<ref>] [--waiver-reason=<text>] [--supersede=<prevSpanId>] [--allow-parallel] [--paths=<comma-separated>] [--override-cap=<int>] [--json]",
     "  node .cclaw/hooks/delegation-record.mjs --rerecord --span-id=<id> --dispatch-id=<id> --dispatch-surface=<surface> --agent-definition-path=<path> [--ack-ts=<iso>] [--completed-ts=<iso>] [--evidence-ref=<ref>] [--json]",
-    "  node .cclaw/hooks/delegation-record.mjs --repair --span-id=<id> --repair-reason=\"<why>\" [--json]",
+    "  node .cclaw/hooks/delegation-record.mjs --repair --span-id=<id> --repair-reason=\\\"<why>\\\" [--json]",
     "",
     "Allowed --dispatch-surface values:",
     "  " + VALID_DISPATCH_SURFACES.join(", "),
@@ -362,12 +362,14 @@ function usage() {
     "TDD slice phase tagging (v6.11.0):",
     "  --slice=<id>              TDD slice identifier (e.g. S-1) used by the linter to auto-derive the Watched-RED + Vertical Slice Cycle tables.",
     "  --phase=<phase>           one of " + VALID_DELEGATION_PHASES.join(", ") + ". Pair with --slice to record a TDD slice phase event.",
-    "  --refactor-rationale=<t>  required when --phase=refactor-deferred unless --evidence-ref carries the rationale text.",
+    "  --refactor-rationale=<t>  required when --phase=refactor-deferred unless --evidence-ref carries the rationale text. v6.14.0: also paired with --refactor-outcome on phase=green.",
     "  --claim-token=<opaque>    v6.13 — required for worktree-first slice-implementer schedules with --slice (echo on all terminal rows for the span).",
     "  --lane-id=<id>            v6.13 — worktree lane id (ownerLaneId metadata).",
     "  --lease-until=<iso>       v6.13 — ISO8601 lease expiry for reclaim tooling.",
     "  --depends-on=<a,b>       v6.13 — comma-separated plan unit ids for scheduler diagnostics.",
     "  --integration-state=<s>  v6.13 — one of pending|applied|conflict|resolved|abandoned.",
+    "  --refactor-outcome=<m>   v6.14.0 — one of inline|deferred. Folds REFACTOR into the phase=green event so a single row can close RED→GREEN→REFACTOR. Pair --refactor-outcome=deferred with --refactor-rationale.",
+    "  --risk-tier=<t>          v6.14.0 — one of low|medium|high. high triggers integration-overseer in conditional mode.",
     ""
   ].join("\\n") + "\\n");
 }
@@ -538,6 +540,40 @@ function buildRow(args, status, runId, now, options) {
       : undefined;
   const leaseState =
     leasedUntil && status === "scheduled" ? "claimed" : undefined;
+  // v6.14.0: refactorOutcome folds REFACTOR into a phase=green event. We
+  // also accept it on phase=refactor / phase=refactor-deferred for forward
+  // compatibility with controllers that emit it on the legacy lifecycle.
+  // When mode=deferred and a --refactor-rationale is supplied we also
+  // mirror the rationale into evidenceRefs[0] so legacy linters keep
+  // reading evidence (matches the v6.11.0 refactor-deferred behavior).
+  const refactorOutcomeMode =
+    typeof args["refactor-outcome"] === "string"
+      ? args["refactor-outcome"].trim()
+      : "";
+  let refactorOutcome;
+  if (refactorOutcomeMode === "inline" || refactorOutcomeMode === "deferred") {
+    const rationaleRaw =
+      typeof args["refactor-rationale"] === "string"
+        ? args["refactor-rationale"].trim()
+        : "";
+    refactorOutcome = {
+      mode: refactorOutcomeMode,
+      ...(rationaleRaw.length > 0 ? { rationale: rationaleRaw } : {})
+    };
+    if (
+      refactorOutcomeMode === "deferred" &&
+      rationaleRaw.length > 0 &&
+      !resolvedEvidenceRefs.includes(rationaleRaw)
+    ) {
+      resolvedEvidenceRefs = [rationaleRaw, ...resolvedEvidenceRefs];
+    }
+  }
+  const riskTierRaw =
+    typeof args["risk-tier"] === "string" ? args["risk-tier"].trim() : "";
+  const riskTier =
+    riskTierRaw === "low" || riskTierRaw === "medium" || riskTierRaw === "high"
+      ? riskTierRaw
+      : undefined;
   return {
     stage: args.stage,
     agent: args.agent,
@@ -568,7 +604,9 @@ function buildRow(args, status, runId, now, options) {
     leasedUntil,
     leaseState,
     dependsOn,
-    integrationState
+    integrationState,
+    refactorOutcome,
+    riskTier
   };
 }
 
@@ -1139,6 +1177,44 @@ async function main() {
     }
   }
 
+  // v6.14.0 — --refactor-outcome must be one of inline|deferred. When
+  // mode=deferred a rationale is required (either --refactor-rationale or
+  // --evidence-ref carrying the rationale text). --risk-tier must be one of
+  // low|medium|high if provided.
+  if (
+    args["refactor-outcome"] !== undefined &&
+    args["refactor-outcome"] !== "inline" &&
+    args["refactor-outcome"] !== "deferred"
+  ) {
+    problems.push("invalid --refactor-outcome (allowed: inline, deferred)");
+    emitProblems(problems, json, 2);
+    return;
+  }
+  if (args["refactor-outcome"] === "deferred") {
+    const rationaleProvided =
+      typeof args["refactor-rationale"] === "string" && args["refactor-rationale"].trim().length > 0;
+    const evidenceProvided =
+      (typeof args["evidence-ref"] === "string" && args["evidence-ref"].trim().length > 0) ||
+      (Array.isArray(args["evidence-refs"]) && args["evidence-refs"].some(
+        (ref) => typeof ref === "string" && ref.trim().length > 0
+      ));
+    if (!rationaleProvided && !evidenceProvided) {
+      problems.push("--refactor-outcome=deferred requires --refactor-rationale=<text> or --evidence-ref=<text>");
+      emitProblems(problems, json, 2);
+      return;
+    }
+  }
+  if (
+    args["risk-tier"] !== undefined &&
+    args["risk-tier"] !== "low" &&
+    args["risk-tier"] !== "medium" &&
+    args["risk-tier"] !== "high"
+  ) {
+    problems.push("invalid --risk-tier (allowed: low, medium, high)");
+    emitProblems(problems, json, 2);
+    return;
+  }
+
   if (args.status === "completed" && args["dispatch-surface"] !== "role-switch") {
     for (const key of ["dispatch-id", "dispatch-surface", "agent-definition-path"]) {
       if (!args[key]) problems.push("completed isolated/generic status requires --" + key);

package/dist/content/stages/tdd.js

@@ -37,7 +37,7 @@ export const TDD = {
     },
     executionModel: {
         checklist: [
-            "**Wave dispatch (v6.13.1):** Before routing, read the Parallel Execution Plan (managed block in the track planning artifact) and `<artifacts-dir>/wave-plans/`. Multi-ready waves: one AskQuestion (launch wave vs single-slice); then RED checkpoint, parallel GREEN+DOC with worktree-first flags, per-lane REFACTOR. Resume partial waves by parallelizing remaining members only (see top-of-skill `## Wave Batch Mode`).",
+            "**Stream-style wave dispatch (v6.14.0):** Before routing, read the Parallel Execution Plan (managed block in the track planning artifact) and `<artifacts-dir>/wave-plans/`. Per-lane stream: each lane runs RED→GREEN→REFACTOR independently as soon as its `dependsOn` closes — no global RED checkpoint between Phase A and Phase B. The linter enforces RED-before-GREEN per slice via `tdd_slice_red_completed_before_green`; cross-lane interleaving is allowed. **Legacy `global-red` mode** is preserved for projects with `legacyContinuation: true` and any project that explicitly sets `flow-state.json::tddCheckpointMode: \"global-red\"` (rule `tdd_red_checkpoint_violation` still fires there). Multi-ready waves still get one AskQuestion (launch wave vs single-slice); then per-lane GREEN+DOC dispatch with worktree-first flags. Integration-overseer fires only on cross-slice trigger (see `integrationCheckRequired()` heuristic). Resume partial waves by parallelizing remaining members only (see top-of-skill `## Wave Batch Mode`).",
             "Select vertical slice — the active wave plan (or single ready slice) defines work. Do not ask \"which slice next?\" when the plan already resolves it. Before starting, read `.cclaw/state/ralph-loop.json` (`loopIteration`, `acClosed[]`, `redOpenSlices[]`) so you skip cycles already closed. If `redOpenSlices[]` is non-empty, repair or explicitly park those slices before opening a new RED.",
             "Map to acceptance criterion — identify the specific spec criterion this test proves.",
             "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.",
@@ -49,8 +49,8 @@ export const TDD = {
             "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).",
-            "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 paths and the file-overlap scheduler auto-allows the parallel dispatch. **Provisional-then-finalize:** append a provisional row/section in `tdd-slices/S-<id>.md` at dispatch time, then finalize that artifact after the matching `phase=green` event records evidence (never treat guesses as final before GREEN lands). Linter rule `tdd_slice_documenter_missing` blocks the gate when the `phase=doc` event is absent (regardless of `discoveryMode`).",
+            "REFACTOR (v6.14.0 — three forms): (1) re-dispatch `slice-implementer` with `--phase refactor` after GREEN; (2) re-dispatch with `--phase refactor-deferred --refactor-rationale \"<why>\"` to close without a separate pass; (3) **fold REFACTOR into GREEN** by adding `--refactor-outcome=inline|deferred [--refactor-rationale=\"<why>\"]` on the same `slice-implementer --phase green` dispatch. Form (3) is the v6.14.0 default; the linter accepts all three as REFACTOR coverage. Set `CCLAW_ACTIVE_AGENT=tdd-refactor` when the harness supports phase labels.",
+            "DOC (v6.14.0 — softened): in `discoveryMode=deep` runs DOC remains mandatory — 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 paths and the file-overlap scheduler auto-allows parallel dispatch. **In `lean` and `guided` modes DOC is advisory** (linter `tdd_slice_documenter_missing` becomes `required: false`); controllers may either keep parallel `slice-documenter` dispatch or call `slice-implementer --finalize-doc` inline at GREEN-completion. **Provisional-then-finalize still applies for parallel dispatch:** append a provisional row/section in `tdd-slices/S-<id>.md` at dispatch time, then finalize after the matching `phase=green` event records evidence.",
             "**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.",
@@ -58,7 +58,7 @@ export const TDD = {
             "Repeat for each slice — when not in multi-slice wave mode, return to wave-plan discovery; otherwise continue the active wave until members close.",
         ],
         interactionProtocol: [
-            "Pick one vertical slice at a time **only when** the merged wave plan leaves a single scheduler-ready slice or the operator chose single-slice mode. Parallel implementers are allowed 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.",
+            "Pick one vertical slice at a time **only when** the merged wave plan leaves a single scheduler-ready slice or the operator chose single-slice mode. Parallel implementers are allowed when lanes touch non-overlapping files (the file-overlap scheduler auto-allows parallel when `--paths` are disjoint). **Integration-overseer is conditional in v6.14.0** (see `flow-state.json::integrationOverseerMode`): with the default `\"conditional\"` it dispatches only when `integrationCheckRequired()` returns `required: true` (shared import boundaries between closed slices, any slice with `riskTier=high`, or a recorded `cclaw_fanin_conflict`). When the heuristic returns `required: false`, record an audit `cclaw_integration_overseer_skipped` and let the linter emit advisory `tdd_integration_overseer_skipped_by_disjoint_paths`. Projects with `legacyContinuation: true` or explicit `\"always\"` keep the v6.13.x mandatory dispatch.",
             "Slice implementers are sequential only when the plan serializes work; prefer wave-parallel GREEN+DOC when the Parallel Execution Plan marks multiple ready members.",
             "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.",

package/dist/content/start-command.js

@@ -115,7 +115,7 @@ If during any stage the agent discovers evidence that contradicts the initial Ph
 2. If flow state is missing → guide the user to run \`npx cclaw-cli init\` and stop.
 3. If flow state is only a fresh init placeholder (\`completedStages: []\`, all \`passed\` arrays empty, and no \`00-idea.md\`) → stop and ask for \`/cc <prompt>\` to start a tracked run. Do not create a brainstorm state implicitly.
 4. Otherwise check current stage gates, resume if incomplete, and advance if complete.
-5. **TDD wave dispatch (v6.13.1):** When \`currentStage\` is \`tdd\`, read \`${RUNTIME_ROOT}/artifacts/05-plan.md\` Parallel Execution Plan block and \`${RUNTIME_ROOT}/artifacts/wave-plans/\` **before** any slice-routing question. If an open wave still has multiple ready slices, resume parallel dispatch for the **remaining** members only (do not restart completed slices).
+5. **TDD wave dispatch (v6.14.0 — stream-style):** When \`currentStage\` is \`tdd\`, read \`${RUNTIME_ROOT}/artifacts/05-plan.md\` Parallel Execution Plan block and \`${RUNTIME_ROOT}/artifacts/wave-plans/\` **before** any slice-routing question. If an open wave still has multiple ready slices, resume per-lane stream dispatch for the **remaining** members only (do not restart completed slices). **No global RED checkpoint barrier** in default \`tddCheckpointMode: "per-slice"\` — each lane advances RED→GREEN→REFACTOR as soon as its \`dependsOn\` closes; the linter enforces RED-before-GREEN per slice. Projects with \`legacyContinuation: true\` or explicit \`tddCheckpointMode: "global-red"\` retain the v6.13.x global barrier.
 
 ## Headless mode (CI/automation only)
 
@@ -208,8 +208,8 @@ Progress the tracked flow only when one exists:
 2. If missing, guide the user to run \`npx cclaw-cli init\` and stop.
 3. If it is only a fresh init placeholder (\`completedStages: []\`, no passed gates, and no \`${RUNTIME_ROOT}/artifacts/00-idea.md\`), stop and ask for \`/cc <prompt>\` to start a tracked run. Do not silently create a brainstorm run.
 4. Check gates for \`currentStage\`.
-5. **TDD (v6.13.1):** When \`currentStage\` is \`tdd\`, read \`${RUNTIME_ROOT}/artifacts/05-plan.md\` (managed \`## Parallel Execution Plan\` between \`parallel-exec-managed\` markers) and scan \`${RUNTIME_ROOT}/artifacts/wave-plans/wave-NN.md\` **before** asking which slice runs next. Merge sources in controller memory: Parallel Execution Plan first, wave files second; the same slice must not disagree across sources.
-6. **Wave dispatch resume:** If a wave is partially closed (some members already past GREEN/REFACTOR), continue with the remaining members in parallel; never redo finished lanes.
+5. **TDD (v6.14.0 — stream-style):** When \`currentStage\` is \`tdd\`, read \`${RUNTIME_ROOT}/artifacts/05-plan.md\` (managed \`## Parallel Execution Plan\` between \`parallel-exec-managed\` markers) and scan \`${RUNTIME_ROOT}/artifacts/wave-plans/wave-NN.md\` **before** asking which slice runs next. Merge sources in controller memory: Parallel Execution Plan first, wave files second; the same slice must not disagree across sources.
+6. **Wave dispatch resume (per-lane stream):** If a wave is partially closed (some members already past GREEN/REFACTOR), continue with the remaining members in parallel as soon as their \`dependsOn\` closes — do **not** wait for a global RED-completion barrier in default \`tddCheckpointMode: "per-slice"\`. Never redo finished lanes. Integration-overseer fires only on cross-slice trigger (default \`integrationOverseerMode: "conditional"\`); skipped dispatches must record audit \`cclaw_integration_overseer_skipped\`.
 7. If incomplete → load current stage skill and execute.
 8. If complete → advance to next stage and execute.
 9. If flow is done → report completion.

package/dist/delegation.d.ts

@@ -183,6 +183,35 @@ export type DelegationEntry = {
      * v6.13.0 — integration branch merge status after deterministic fan-in.
      */
     integrationState?: "pending" | "applied" | "conflict" | "resolved" | "abandoned";
+    /**
+     * v6.14.0 — refactor outcome folded into `phase=green` events so a single
+     * row can close RED→GREEN→REFACTOR for the slice without a separate
+     * `phase=refactor` / `phase=refactor-deferred` lifecycle pass.
+     *
+     * - `mode: "inline"` — refactor pass ran inline as part of the GREEN
+     *   delegation (rationale optional but recommended for traceability).
+     * - `mode: "deferred"` — refactor was intentionally deferred; rationale
+     *   is required (carried in `rationale` and mirrored into
+     *   `evidenceRefs[0]` so legacy linters that read evidence still work).
+     *
+     * `phase=refactor` and `phase=refactor-deferred` events remain valid
+     * for backward compatibility; the linter accepts either form for
+     * REFACTOR coverage.
+     *
+     * keep in sync with the inline copy in
+     * `src/content/hooks.ts::delegationRecordScript`.
+     */
+    refactorOutcome?: {
+        mode: "inline" | "deferred";
+        rationale?: string;
+    };
+    /**
+     * v6.14.0 — risk tier hint copied from the plan slice. Used by
+     * `integrationCheckRequired()` to decide whether the
+     * integration-overseer must run. `low` and `medium` are advisory;
+     * `high` always triggers the overseer. Optional on every row.
+     */
+    riskTier?: "low" | "medium" | "high";
 };
 export declare const DELEGATION_PHASES: readonly ["red", "green", "refactor", "refactor-deferred", "doc", "resolve-conflict"];
 export type DelegationPhase = (typeof DELEGATION_PHASES)[number];
@@ -395,6 +424,56 @@ export declare function selectReadySlices(units: ReadySliceUnit[], opts: SelectR
  * v6.13.1 — build scheduler rows from merged parallel wave definitions + plan units.
  */
 export declare function readySliceUnitsFromMergedWaves(mergedWaves: ParsedParallelWave[], planMarkdown: string, options?: ParseImplementationUnitParallelOptions): ReadySliceUnit[];
+/**
+ * v6.14.0 — verdict from `integrationCheckRequired()`.
+ *
+ * `required: true` means the controller MUST dispatch
+ * `integration-overseer` before stage-complete; `reasons[]` lists the
+ * triggers that fired so the controller can quote them in artifacts.
+ *
+ * `required: false` means the integration check can be safely skipped
+ * (disjoint paths, no high-risk slices, no fan-in conflicts). Callers
+ * that skip dispatch should append a `cclaw_integration_overseer_skipped`
+ * audit row to `delegation-events.jsonl` so the run log stays honest
+ * about the decision.
+ */
+export interface IntegrationCheckVerdict {
+    required: boolean;
+    reasons: string[];
+}
+/**
+ * v6.14.0 — heuristic helper deciding whether a multi-slice wave needs
+ * the `integration-overseer` dispatch.
+ *
+ * Triggers (any one):
+ *   - **two or more closed slices share import boundaries** (heuristic:
+ *     two slices declare a `claimedPaths` whose first 2 path segments
+ *     match — same package/module directory);
+ *   - any slice has `riskTier === "high"`;
+ *   - any `cclaw_fanin_conflict` audit row exists in the supplied
+ *     events list (regardless of slice).
+ *
+ * When none fire, the verdict is `{ required: false, reasons: ["disjoint-paths"] }`
+ * and the caller should record a `cclaw_integration_overseer_skipped`
+ * audit before bypassing the dispatch.
+ *
+ * Note on inputs: this function reads from the supplied delegation
+ * events list directly so callers can inject synthetic data in tests.
+ * Use `readDelegationEvents(projectRoot)` in production paths.
+ */
+export declare function integrationCheckRequired(events: DelegationEvent[]): IntegrationCheckVerdict;
+export declare function integrationCheckRequired(events: DelegationEvent[], fanInAudits: FanInAuditRecord[]): IntegrationCheckVerdict;
+/**
+ * v6.14.0 — append a non-delegation audit event recording that the
+ * integration-overseer dispatch was skipped because
+ * `integrationCheckRequired()` returned `required: false`. Best-effort;
+ * never throws.
+ */
+export declare function recordIntegrationOverseerSkipped(projectRoot: string, params: {
+    runId: string;
+    reasons: string[];
+    sliceIds: string[];
+}): Promise<void>;
 /**
  * v6.13.1 — load merged wave plan (Parallel Execution Plan block + wave-plans/) and map to `ReadySliceUnit[]`.
  */

package/dist/delegation.js

@@ -257,7 +257,22 @@ function isDelegationEntry(value) {
             o.integrationState === "applied" ||
             o.integrationState === "conflict" ||
             o.integrationState === "resolved" ||
-            o.integrationState === "abandoned"));
+            o.integrationState === "abandoned") &&
+        (o.refactorOutcome === undefined || isRefactorOutcomeShape(o.refactorOutcome)) &&
+        (o.riskTier === undefined ||
+            o.riskTier === "low" ||
+            o.riskTier === "medium" ||
+            o.riskTier === "high"));
+}
+function isRefactorOutcomeShape(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const o = value;
+    if (o.mode !== "inline" && o.mode !== "deferred")
+        return false;
+    if (o.rationale !== undefined && typeof o.rationale !== "string")
+        return false;
+    return true;
 }
 function isDelegationDispatchSurface(value) {
     return typeof value === "string" && DELEGATION_DISPATCH_SURFACES.includes(value);
@@ -372,7 +387,8 @@ const NON_DELEGATION_AUDIT_EVENTS = new Set([
     "cclaw_fanin_applied",
     "cclaw_fanin_conflict",
     "cclaw_fanin_resolved",
-    "cclaw_fanin_abandoned"
+    "cclaw_fanin_abandoned",
+    "cclaw_integration_overseer_skipped"
 ]);
 function isAuditEventLine(parsed) {
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
@@ -771,6 +787,110 @@ export function readySliceUnitsFromMergedWaves(mergedWaves, planMarkdown, option
     }
     return out;
 }
+export function integrationCheckRequired(events, fanInAudits) {
+    const reasons = [];
+    // Closed slices = ones whose phase=green or phase=refactor row is
+    // completed. We collect each unique sliceId's representative paths
+    // and risk tier so the heuristic looks at terminal state only.
+    const sliceState = new Map();
+    for (const evt of events) {
+        if (evt.stage !== "tdd")
+            continue;
+        if (typeof evt.sliceId !== "string" || evt.sliceId.length === 0)
+            continue;
+        if (evt.status !== "completed")
+            continue;
+        if (evt.phase !== "green" && evt.phase !== "refactor" && evt.phase !== "refactor-deferred") {
+            continue;
+        }
+        const existing = sliceState.get(evt.sliceId) ?? { sliceId: evt.sliceId };
+        if (Array.isArray(evt.claimedPaths) && evt.claimedPaths.length > 0) {
+            const merged = new Set(existing.claimedPaths ?? []);
+            for (const p of evt.claimedPaths)
+                merged.add(p);
+            existing.claimedPaths = [...merged];
+        }
+        if (evt.riskTier === "low" || evt.riskTier === "medium" || evt.riskTier === "high") {
+            // Highest-wins so the verdict is conservative.
+            const order = { low: 0, medium: 1, high: 2 };
+            const prev = existing.riskTier ?? "low";
+            if (order[evt.riskTier] >= order[prev]) {
+                existing.riskTier = evt.riskTier;
+            }
+        }
+        sliceState.set(evt.sliceId, existing);
+    }
+    const slices = [...sliceState.values()];
+    if (slices.some((s) => s.riskTier === "high")) {
+        reasons.push("high-risk-slice");
+    }
+    // Shared-directory heuristic — two distinct slices with overlapping
+    // first-2-segment directory prefixes count as shared boundary.
+    const sliceDirs = new Map();
+    for (const s of slices) {
+        const dirs = new Set();
+        for (const raw of s.claimedPaths ?? []) {
+            const segments = raw.split("/").filter((seg) => seg.length > 0);
+            if (segments.length === 0)
+                continue;
+            // For top-level files like `package.json`, fall back to the
+            // first segment so single-segment paths still count as a shared
+            // directory when two slices both claim the file.
+            const prefix = segments.slice(0, Math.max(1, Math.min(2, segments.length))).join("/");
+            dirs.add(prefix);
+        }
+        if (dirs.size > 0)
+            sliceDirs.set(s.sliceId, dirs);
+    }
+    let sharedFound = false;
+    const ids = [...sliceDirs.keys()];
+    outer: for (let i = 0; i < ids.length; i += 1) {
+        const a = sliceDirs.get(ids[i]);
+        for (let j = i + 1; j < ids.length; j += 1) {
+            const b = sliceDirs.get(ids[j]);
+            for (const dir of a) {
+                if (b.has(dir)) {
+                    sharedFound = true;
+                    break outer;
+                }
+            }
+        }
+    }
+    if (sharedFound)
+        reasons.push("shared-import-boundary");
+    // Fan-in conflict trigger — any `cclaw_fanin_conflict` in the supplied
+    // audits forces the overseer regardless of paths/risk.
+    if (Array.isArray(fanInAudits) && fanInAudits.some((a) => a.event === "cclaw_fanin_conflict")) {
+        reasons.push("fanin-conflict");
+    }
+    if (reasons.length > 0) {
+        return { required: true, reasons };
+    }
+    return { required: false, reasons: ["disjoint-paths"] };
+}
+/**
+ * v6.14.0 — append a non-delegation audit event recording that the
+ * integration-overseer dispatch was skipped because
+ * `integrationCheckRequired()` returned `required: false`. Best-effort;
+ * never throws.
+ */
+export async function recordIntegrationOverseerSkipped(projectRoot, params) {
+    const eventsPath = delegationEventsPath(projectRoot);
+    const payload = {
+        event: "cclaw_integration_overseer_skipped",
+        runId: params.runId,
+        reasons: params.reasons,
+        sliceIds: params.sliceIds,
+        ts: new Date().toISOString()
+    };
+    try {
+        await fs.mkdir(path.dirname(eventsPath), { recursive: true });
+        await fs.appendFile(eventsPath, `${JSON.stringify(payload)}\n`, "utf8");
+    }
+    catch {
+        // best-effort audit; never block stage advance.
+    }
+}
 /**
  * v6.13.1 — load merged wave plan (Parallel Execution Plan block + wave-plans/) and map to `ReadySliceUnit[]`.
  */

package/dist/flow-state.d.ts

@@ -151,12 +151,57 @@ export interface FlowState {
      * defaults scheduler parallelism to opt-in only for those units.
      */
     legacyContinuation?: boolean;
+    /**
+     * v6.14.0 — TDD wave checkpoint mode (stream-style parallel TDD).
+     *
+     * - `per-slice` — default for new projects. Each lane runs RED→GREEN as
+     *   soon as its `dependsOn` closes; the linter enforces RED-before-GREEN
+     *   per slice only (`tdd_slice_red_completed_before_green`). No global
+     *   barrier between Phase A REDs and Phase B GREENs.
+     * - `global-red` — legacy v6.12/v6.13 behavior. ALL Phase A REDs in a
+     *   wave must complete before ANY Phase B GREEN starts. Auto-applied
+     *   for projects with `legacyContinuation: true` so hox-style runs
+     *   continue to enforce the wave barrier.
+     *
+     * Omitted on legacy state files (treated as `"global-red"` for
+     * `legacyContinuation: true` and `"per-slice"` otherwise via
+     * `effectiveTddCheckpointMode`).
+     */
+    tddCheckpointMode?: "per-slice" | "global-red";
+    /**
+     * v6.14.0 — integration-overseer dispatch mode.
+     *
+     * - `conditional` — default for new projects. The controller calls
+     *   `integrationCheckRequired(events)` after wave closeout; the
+     *   integration-overseer is dispatched only when (a) two or more
+     *   closed slices share import boundaries (heuristic: shared
+     *   directory in `evidenceRefs`/`claimedPaths`), (b) any slice has
+     *   `riskTier === "high"`, or (c) deterministic fan-in reported a
+     *   `cclaw_fanin_conflict`. Otherwise the linter emits the audit
+     *   row `cclaw_integration_overseer_skipped` and skips dispatch.
+     * - `always` — legacy v6.13 behavior. Run integration-overseer
+     *   after every multi-slice wave regardless of trigger.
+     *
+     * Omitted on legacy state files (treated as `"always"`).
+     */
+    integrationOverseerMode?: "conditional" | "always";
 }
 /**
  * Effective worktree mode: legacy state files without the field keep
  * single-tree scheduling to avoid breaking existing runs on upgrade.
  */
 export declare function effectiveWorktreeExecutionMode(state: FlowState): "single-tree" | "worktree-first";
+/**
+ * Effective v6.14 TDD checkpoint mode: legacy state files without the
+ * field default to `global-red` when `legacyContinuation: true` (hox)
+ * and `per-slice` otherwise. Explicit values always win.
+ */
+export declare function effectiveTddCheckpointMode(state: FlowState): "per-slice" | "global-red";
+/**
+ * Effective v6.14 integration-overseer mode: legacy state files without
+ * the field default to `always` (matches v6.13 behavior).
+ */
+export declare function effectiveIntegrationOverseerMode(state: FlowState): "conditional" | "always";
 export interface StageInteractionHint {
     skipQuestions?: boolean;
     sourceStage?: FlowStage;

package/dist/flow-state.js

@@ -51,6 +51,24 @@ export function createInitialCloseoutState() {
 export function effectiveWorktreeExecutionMode(state) {
     return state.worktreeExecutionMode ?? "single-tree";
 }
+/**
+ * Effective v6.14 TDD checkpoint mode: legacy state files without the
+ * field default to `global-red` when `legacyContinuation: true` (hox)
+ * and `per-slice` otherwise. Explicit values always win.
+ */
+export function effectiveTddCheckpointMode(state) {
+    if (state.tddCheckpointMode === "per-slice" || state.tddCheckpointMode === "global-red") {
+        return state.tddCheckpointMode;
+    }
+    return state.legacyContinuation === true ? "global-red" : "per-slice";
+}
+/**
+ * Effective v6.14 integration-overseer mode: legacy state files without
+ * the field default to `always` (matches v6.13 behavior).
+ */
+export function effectiveIntegrationOverseerMode(state) {
+    return state.integrationOverseerMode === "conditional" ? "conditional" : "always";
+}
 export function isFlowTrack(value) {
     return typeof value === "string" && FLOW_TRACKS.includes(value);
 }

package/dist/install.js

@@ -1003,6 +1003,90 @@ async function applyPlanLegacyContinuationIfNeeded(projectRoot) {
         // Best-effort: corrupt/missing state is handled elsewhere on sync.
     }
 }
+/**
+ * v6.14.0 — set stream-style defaults on `cclaw-cli sync` and print a
+ * one-line hint when defaults change. Strategy:
+ *
+ * - When `legacyContinuation: true` and `tddCheckpointMode` is unset, force
+ *   `tddCheckpointMode: "global-red"` (preserves hox wave protocol).
+ * - When `legacyContinuation: true` and `integrationOverseerMode` is unset,
+ *   force `integrationOverseerMode: "always"` (preserves v6.13 behavior).
+ * - When `legacyContinuation` is NOT true (new / standard projects) and
+ *   neither field is set, default to `tddCheckpointMode: "per-slice"`,
+ *   `integrationOverseerMode: "conditional"`. Also default
+ *   `worktreeExecutionMode: "worktree-first"` if unset.
+ *
+ * Returns a one-line hint string (or `null` if nothing changed) so callers
+ * can print it through the standard sync hint surface.
+ */
+async function applyV614DefaultsIfNeeded(projectRoot) {
+    // Defensive read — match `applyTddCutoverIfNeeded`'s pattern (raw +
+    // JSON.parse) so corrupt state is left untouched for the downstream
+    // fail-fast check in `materializeRuntime` (which expects to see the
+    // CorruptFlowStateError surfaced via `ensureRunSystem`). Calling
+    // `readFlowState` directly would quarantine the corrupt file and hide
+    // the failure from the caller.
+    const flowStatePath = runtimePath(projectRoot, "state", "flow-state.json");
+    let flowStateRaw;
+    try {
+        flowStateRaw = await fs.readFile(flowStatePath, "utf8");
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(flowStateRaw);
+    }
+    catch {
+        return null;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return null;
+    }
+    const obj = parsed;
+    const updates = {};
+    const summary = [];
+    const tddCheckpointModeSet = obj.tddCheckpointMode === "per-slice" || obj.tddCheckpointMode === "global-red";
+    const integrationOverseerModeSet = obj.integrationOverseerMode === "conditional" || obj.integrationOverseerMode === "always";
+    const worktreeExecutionModeSet = obj.worktreeExecutionMode === "worktree-first" || obj.worktreeExecutionMode === "single-tree";
+    const legacyContinuation = obj.legacyContinuation === true;
+    if (legacyContinuation) {
+        if (!tddCheckpointModeSet) {
+            updates.tddCheckpointMode = "global-red";
+            summary.push("tddCheckpointMode=global-red (legacyContinuation)");
+        }
+        if (!integrationOverseerModeSet) {
+            updates.integrationOverseerMode = "always";
+            summary.push("integrationOverseerMode=always (legacyContinuation)");
+        }
+    }
+    else {
+        if (!tddCheckpointModeSet) {
+            updates.tddCheckpointMode = "per-slice";
+            summary.push("tddCheckpointMode=per-slice");
+        }
+        if (!integrationOverseerModeSet) {
+            updates.integrationOverseerMode = "conditional";
+            summary.push("integrationOverseerMode=conditional");
+        }
+        if (!worktreeExecutionModeSet) {
+            updates.worktreeExecutionMode = "worktree-first";
+            summary.push("worktreeExecutionMode=worktree-first");
+        }
+    }
+    if (summary.length === 0) {
+        return null;
+    }
+    const merged = { ...obj, ...updates };
+    try {
+        await writeFileSafe(flowStatePath, `${JSON.stringify(merged, null, 2)}\n`, { mode: 0o600 });
+    }
+    catch {
+        return null;
+    }
+    return `v6.14.0 stream-style defaults applied: ${summary.join(", ")}. To opt out, edit .cclaw/state/flow-state.json directly or pin the legacy mode (tddCheckpointMode="global-red", integrationOverseerMode="always").`;
+}
 async function cleanLegacyArtifacts(projectRoot) {
     for (const legacyFolder of DEPRECATED_UTILITY_SKILL_FOLDERS) {
         await removeBestEffort(runtimePath(projectRoot, "skills", legacyFolder), true);
@@ -1178,6 +1262,10 @@ async function materializeRuntime(projectRoot, config, forceStateReset, operatio
         if (operation === "sync" || operation === "upgrade") {
             await applyTddCutoverIfNeeded(projectRoot);
             await applyPlanLegacyContinuationIfNeeded(projectRoot);
+            const v614Hint = await applyV614DefaultsIfNeeded(projectRoot);
+            if (v614Hint) {
+                process.stdout.write(`cclaw: ${v614Hint}\n`);
+            }
         }
         try {
             await ensureRunSystem(projectRoot, { createIfMissing: false });

package/dist/run-persistence.js

@@ -473,6 +473,8 @@ function coerceFlowState(parsed) {
     const completedStageMeta = sanitizeCompletedStageMeta(parsed.completedStageMeta);
     const tddCutoverSliceId = coerceTddCutoverSliceId(parsed.tddCutoverSliceId);
     const worktreeExecutionMode = coerceWorktreeExecutionMode(parsed.worktreeExecutionMode);
+    const tddCheckpointMode = coerceTddCheckpointMode(parsed.tddCheckpointMode);
+    const integrationOverseerMode = coerceIntegrationOverseerMode(parsed.integrationOverseerMode);
     const legacyContinuation = typeof parsed.legacyContinuation === "boolean" ? parsed.legacyContinuation : undefined;
     const state = {
         schemaVersion: FLOW_STATE_SCHEMA_VERSION,
@@ -488,6 +490,8 @@ function coerceFlowState(parsed) {
         ...(completedStageMeta ? { completedStageMeta } : {}),
         ...(tddCutoverSliceId ? { tddCutoverSliceId } : {}),
         ...(worktreeExecutionMode !== undefined ? { worktreeExecutionMode } : {}),
+        ...(tddCheckpointMode !== undefined ? { tddCheckpointMode } : {}),
+        ...(integrationOverseerMode !== undefined ? { integrationOverseerMode } : {}),
         ...(legacyContinuation !== undefined ? { legacyContinuation } : {}),
         skippedStages: sanitizeSkippedStages(parsed.skippedStages, track),
         staleStages: sanitizeStaleStages(parsed.staleStages),
@@ -514,6 +518,16 @@ function coerceWorktreeExecutionMode(value) {
         return value;
     return undefined;
 }
+function coerceTddCheckpointMode(value) {
+    if (value === "per-slice" || value === "global-red")
+        return value;
+    return undefined;
+}
+function coerceIntegrationOverseerMode(value) {
+    if (value === "conditional" || value === "always")
+        return value;
+    return undefined;
+}
 export class CorruptFlowStateError extends Error {
     statePath;
     quarantinedPath;

package/package.json

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