cclaw-cli 7.1.0 → 7.1.1

package/dist/artifact-linter/plan.js

@@ -8,6 +8,14 @@ import { PLAN_SPLIT_SMALL_PLAN_THRESHOLD, parseImplementationUnits, parseImpleme
 const PARALLEL_EXEC_MANAGED_START = "<!-- parallel-exec-managed-start -->";
 const PARALLEL_EXEC_MANAGED_END = "<!-- parallel-exec-managed-end -->";
 const TASK_ID_PATTERN = /\bT-\d{3}[a-z]?(?:\.\d{1,3})?\b/giu;
+const PLAN_LANE_WHITELIST = new Set([
+    "production",
+    "test",
+    "docs",
+    "infra",
+    "scaffold",
+    "migration"
+]);
 /**
  * Extract every distinct T-NNN[a-z]?(.NNN)? id from a markdown body.
  *
@@ -36,6 +44,102 @@ function extractParallelExecManagedBody(planMarkdown) {
     }
     return planMarkdown.slice(startIdx + PARALLEL_EXEC_MANAGED_START.length, endIdx);
 }
+function normalizePathToken(raw) {
+    return raw.trim().replace(/^`|`$/gu, "").replace(/^\.\/+/u, "");
+}
+function parsePipeRow(trimmedLine) {
+    const inner = trimmedLine.replace(/^\|/u, "").replace(/\|\s*$/u, "");
+    return inner.split("|").map((cell) => cell.trim());
+}
+function headerIndexByName(cells) {
+    const map = new Map();
+    for (let i = 0; i < cells.length; i += 1) {
+        const key = cells[i].toLowerCase().replace(/[^a-z0-9]/gu, "");
+        if (key.length > 0 && !map.has(key)) {
+            map.set(key, i);
+        }
+    }
+    return map;
+}
+function parseParallelWaveTableMetadata(planMarkdown) {
+    const body = extractParallelExecManagedBody(planMarkdown);
+    if (body.trim().length === 0)
+        return [];
+    const lines = body.split(/\r?\n/u);
+    const out = [];
+    let current = null;
+    let headerIdx = null;
+    const flush = () => {
+        if (current)
+            out.push(current);
+    };
+    for (const rawLine of lines) {
+        const trimmed = rawLine.trim();
+        const waveMatch = /^###\s+Wave\s+(?:W-)?(\d+)\b/iu.exec(trimmed);
+        if (waveMatch) {
+            flush();
+            current = {
+                waveId: `W-${waveMatch[1].padStart(2, "0")}`,
+                rows: [],
+                notes: []
+            };
+            headerIdx = null;
+            continue;
+        }
+        if (!current)
+            continue;
+        current.notes.push(trimmed);
+        if (!trimmed.startsWith("|"))
+            continue;
+        const cells = parsePipeRow(trimmed);
+        if (cells.length === 0)
+            continue;
+        const first = cells[0].toLowerCase();
+        const isHeader = first === "sliceid" || first === "slice id";
+        if (isHeader) {
+            headerIdx = headerIndexByName(cells);
+            continue;
+        }
+        if (cells.every((cell) => /^:?-{3,}:?$/u.test(cell))) {
+            continue;
+        }
+        const sliceCell = cells[0];
+        if (!/^S-\d+$/iu.test(sliceCell))
+            continue;
+        const idx = headerIdx ?? new Map();
+        const unitIdx = idx.get("unit") ?? idx.get("taskid") ?? 1;
+        const pathsIdx = idx.get("claimedpaths");
+        const parallelizableIdx = idx.get("parallelizable");
+        const laneIdx = idx.get("lane");
+        const rawPaths = pathsIdx !== undefined ? (cells[pathsIdx] ?? "") : "";
+        const claimedPaths = rawPaths.length === 0
+            ? []
+            : rawPaths
+                .split(",")
+                .map((p) => normalizePathToken(p))
+                .filter((p) => p.length > 0);
+        const rawParallel = parallelizableIdx !== undefined ? (cells[parallelizableIdx] ?? "").toLowerCase() : "";
+        let parallelizable = null;
+        if (rawParallel === "true" || rawParallel === "yes")
+            parallelizable = true;
+        if (rawParallel === "false" || rawParallel === "no")
+            parallelizable = false;
+        const laneRaw = laneIdx !== undefined ? (cells[laneIdx] ?? "").trim().toLowerCase() : "";
+        current.rows.push({
+            sliceId: sliceCell.toUpperCase(),
+            unit: (cells[unitIdx] ?? "").trim(),
+            claimedPaths,
+            parallelizable,
+            lane: laneRaw.length > 0 ? laneRaw : null
+        });
+    }
+    flush();
+    return out;
+}
+function waveHasSequentialModeHint(wave) {
+    const noteText = wave.notes.join("\n").toLowerCase();
+    return /mode\s*:\s*sequential/iu.test(noteText) || /\bsequential\b/iu.test(noteText) || /\bserial\b/iu.test(noteText);
+}
 export async function lintPlanStage(ctx) {
     const { projectRoot, track, raw, absFile, sections, findings, parsedFrontmatter, brainstormShortCircuitBody, brainstormShortCircuitActivated, staleDiagramAuditEnabled, isTrivialOverride } = ctx;
     evaluateInvestigationTrace(ctx, "Implementation Units");
@@ -308,7 +412,8 @@ export async function lintPlanStage(ctx) {
                 : "Parallel-ready units detected or plan is single-unit."
         });
     }
-    // plan_parallel_exec_full_coverage: every T-NNN task listed in the
+    // plan_parallel_exec_full_coverage + atomic wave metadata checks.
+    // Every T-NNN task listed in the
     // plan's Task List must be assigned to a slice inside the
     // <!-- parallel-exec-managed-start --> block. Without this, TDD
     // cannot fan out work the plan never authored as waves; the previous
@@ -355,5 +460,86 @@ export async function lintPlanStage(ctx) {
                         ? `Parallel Execution Plan covers all ${authoredTaskIds.size} authored task id(s); ${deferredIds.size} task id(s) are explicitly deferred.`
                         : `Uncovered task id(s) — author waves for: ${uncovered.slice(0, 25).join(", ")}${uncovered.length > 25 ? `, … (${uncovered.length - 25} more)` : ""}. Either add slices for them inside <!-- parallel-exec-managed-start --> or move them under \`## Deferred Tasks\` with a reason.`
         });
+        const waveMeta = parseParallelWaveTableMetadata(raw);
+        const pathConflicts = [];
+        for (const wave of waveMeta) {
+            const rows = wave.rows;
+            for (let i = 0; i < rows.length; i += 1) {
+                for (let j = i + 1; j < rows.length; j += 1) {
+                    const left = rows[i];
+                    const right = rows[j];
+                    const rightPathSet = new Set(right.claimedPaths);
+                    const overlap = left.claimedPaths.filter((p) => rightPathSet.has(p));
+                    if (overlap.length === 0)
+                        continue;
+                    pathConflicts.push(`${wave.waveId} ${left.sliceId}<->${right.sliceId} overlap: ${overlap.join(", ")}`);
+                }
+            }
+        }
+        findings.push({
+            section: "plan_wave_paths_disjoint",
+            required: taskListPresent,
+            rule: "Slices within the same wave must keep `claimedPaths` disjoint so TDD can safely fan out parallel slice-builders.",
+            found: taskListPresent && blockPresent && pathConflicts.length === 0,
+            details: !taskListPresent
+                ? "Task List section is empty or missing T-NNN ids; disjoint-path wave check skipped."
+                : !blockPresent
+                    ? "`<!-- parallel-exec-managed-start -->` block is missing or empty; cannot validate wave path disjointness."
+                    : pathConflicts.length === 0
+                        ? "All parsed same-wave slice rows have disjoint claimedPaths."
+                        : `Overlapping claimedPaths detected: ${pathConflicts.slice(0, 12).join(" | ")}${pathConflicts.length > 12 ? ` | … (${pathConflicts.length - 12} more)` : ""}.`
+        });
+        const invalidLanes = [];
+        for (const wave of waveMeta) {
+            for (const row of wave.rows) {
+                if (!row.lane)
+                    continue;
+                if (!PLAN_LANE_WHITELIST.has(row.lane)) {
+                    invalidLanes.push(`${wave.waveId}/${row.sliceId}:${row.lane}`);
+                }
+            }
+        }
+        findings.push({
+            section: "plan_lane_meaningful",
+            required: false,
+            rule: "When a lane is declared, it must be one of: production, test, docs, infra, scaffold, migration.",
+            found: invalidLanes.length === 0,
+            details: invalidLanes.length === 0
+                ? "All declared lane values are either omitted or in the approved lane whitelist."
+                : `Invalid lane value(s): ${invalidLanes.join(", ")}. Remove lane or use a whitelisted value.`
+        });
+        const inconsistentParallelizable = [];
+        for (const wave of waveMeta) {
+            const hasSerialSlice = wave.rows.some((row) => row.parallelizable === false);
+            if (!hasSerialSlice)
+                continue;
+            if (!waveHasSequentialModeHint(wave)) {
+                const serialSlices = wave.rows
+                    .filter((row) => row.parallelizable === false)
+                    .map((row) => row.sliceId)
+                    .join(", ");
+                inconsistentParallelizable.push(`${wave.waveId} [${serialSlices}]`);
+            }
+        }
+        findings.push({
+            section: "plan_parallelizable_consistency",
+            required: false,
+            rule: "Waves containing `parallelizable: false` slices should be explicitly marked sequential in wave notes/mode.",
+            found: inconsistentParallelizable.length === 0,
+            details: inconsistentParallelizable.length === 0
+                ? "No serial slices were found outside a sequentially-labeled wave context."
+                : `Serial slice(s) found without sequential wave mode hints in: ${inconsistentParallelizable.join(", ")}. Add a wave mode/note indicating sequential execution.`
+        });
+        const mermaidBlocks = raw.match(/```mermaid[\s\S]*?```/giu) ?? [];
+        const hasParallelExecMermaid = mermaidBlocks.some((block) => /(flowchart|gantt)/iu.test(block) && /\bW-\d+\b/iu.test(block) && /\bS-\d+\b/iu.test(block));
+        findings.push({
+            section: "plan_parallel_exec_mermaid_present",
+            required: false,
+            rule: "Plan should include a mermaid flowchart/gantt for parallel waves and slice dependencies to make fanout shape visually reviewable.",
+            found: hasParallelExecMermaid,
+            details: hasParallelExecMermaid
+                ? "Mermaid visualization for parallel execution waves is present."
+                : "No mermaid parallel-execution visualization found (advisory). Add a ` ```mermaid ` flowchart or gantt with W-* and S-* nodes."
+        });
     }
 }

package/dist/content/skills.js

@@ -188,14 +188,14 @@ export function tddTopOfSkillBlock(stage) {
 **Step 1 — Wave status (always first):**
 \`node .cclaw/cli.mjs internal wave-status --json\`
 
-The output names: \`waves[]\` (closed/open), \`nextDispatch.waveId\`, \`nextDispatch.mode\` (\`wave-fanout\` or \`single-slice\`), \`nextDispatch.readyToDispatch\` (slice ids), and \`nextDispatch.pathConflicts\` (overlapping \`claimedPaths\` between members).
+The output names: \`waves[]\` (closed/open), \`nextDispatch.waveId\`, \`nextDispatch.mode\` (\`wave-fanout\`, \`single-slice\`, or \`blocked\`), \`nextDispatch.readyToDispatch\` (slice ids), and \`nextDispatch.pathConflicts\` (overlapping \`claimedPaths\` between members).
 
 **Step 2 — Decide automatically (no user question when paths disjoint):**
 
 | \`mode\`         | \`pathConflicts\` | Action                                                                                                                                  |
 |------------------|-------------------|-----------------------------------------------------------------------------------------------------------------------------------------|
 | \`wave-fanout\`  | \`[]\`            | **Fan out the entire wave in one tool batch.** Emit one \`Task\` per ready slice in a single controller message. Do NOT ask the user.   |
-| \`wave-fanout\`  | non-empty         | Issue exactly one AskQuestion (resolve the overlap, drop the conflicting slice, or downgrade to single-slice for the disputed member).  |
+| \`blocked\`      | non-empty         | Issue exactly one AskQuestion (resolve overlap, split/serialize, or adjust claimedPaths), then re-run \`wave-status\`.                    |
 | \`single-slice\` | —                 | One \`Task\` for the next ready slice.                                                                                                  |
 
 **Step 3 — Dispatch protocol per slice:** in the SAME controller message that issues the \`Task\` call:

package/dist/content/stage-schema.js

@@ -295,6 +295,7 @@ const REQUIRED_GATE_IDS = {
         "plan_acceptance_mapped",
         "plan_execution_posture_recorded",
         "plan_parallel_exec_full_coverage",
+        "plan_wave_paths_disjoint",
         "plan_wait_for_confirm"
     ],
     tdd: (track) => [

package/dist/content/stages/plan.js

@@ -52,6 +52,7 @@ export const PLAN = {
             "Define validation points — mark where progress must be checked before continuing, with concrete command and expected evidence.",
             "Define execution posture — record whether execution should be sequential, dependency-batched, parallel-safe, or blocked; include risk triggers and RED/GREEN/REFACTOR checkpoint/commit expectations when the repo workflow supports them. This fulfills the `plan_execution_posture_recorded` gate.",
             "**Author the FULL Parallel Execution Plan.** Inside the `<!-- parallel-exec-managed-start -->` block, enumerate ALL waves W-02..W-N covering EVERY T-NNN task in `## Task List` — no `we'll author waves later`, `next batch only`, or open-ended Backlog handwave is acceptable. Each task gets a slice with `sliceId | taskId | dependsOn | claimedPaths | parallelizable | riskTier | lane`. Spike rows (`S-N`) and tasks marked `deferred` in an explicit `Deferred:` column may be omitted, but every other T-NNN must be claimed. This fulfills the `plan_parallel_exec_full_coverage` gate. The TDD stage downstream is a pure consumer of these waves — if the plan does not author them, TDD cannot fan out that work.",
+            "After authoring/refreshing the managed parallel-exec block, render a Mermaid `flowchart` or `gantt` covering waves (`W-*`) and slice dependencies (`S-*`) so parallelism and fan-in boundaries are visually auditable.",
             "WAIT_FOR_CONFIRM — write plan artifact and explicitly pause. **STOP.** Do NOT proceed until user confirms. Then close the stage with `node .cclaw/hooks/stage-complete.mjs plan` and tell user to run `/cc`."
         ],
         interactionProtocol: [
@@ -59,6 +60,7 @@ export const PLAN = {
             "Split work into small vertical slices (target 2-5 minute tasks).",
             "Publish explicit dependency batches with entry and exit checks for each batch.",
             "Expose execution posture: sequential vs batch/parallel, stop conditions, and checkpoint cadence for the TDD handoff.",
+            "Keep same-wave `claimedPaths` disjoint; if overlap exists, split waves or serialize explicitly before handoff.",
             "Attach exact verification command/manual step and expected evidence to every task.",
             "Preserve locked scope boundaries: no silent scope reduction language in task rows.",
             "Enforce WAIT_FOR_CONFIRM: present the plan summary with options (A) Approve / (B) Revise / (C) Reject.",
@@ -82,6 +84,7 @@ export const PLAN = {
             { id: "plan_acceptance_mapped", description: "Each task maps to a spec acceptance criterion." },
             { id: "plan_execution_posture_recorded", description: "Execution posture is recorded before implementation handoff." },
             { id: "plan_parallel_exec_full_coverage", description: "Every T-NNN task in `## Task List` (other than spikes/explicitly-deferred) is assigned to at least one slice inside the `<!-- parallel-exec-managed-start -->` block; TDD cannot fan out work that the plan never authored as waves." },
+            { id: "plan_wave_paths_disjoint", description: "Within each authored wave, slice `claimedPaths` remain disjoint so `wave-fanout` can dispatch safely without overlap conflicts." },
             { id: "plan_wait_for_confirm", description: "Execution blocked until explicit user confirmation." }
         ],
         requiredEvidence: [

package/dist/content/start-command.js

@@ -119,7 +119,7 @@ If during any stage the agent discovers evidence that contradicts the initial Ph
 
    **The controller never edits production code in TDD.** When \`mode: wave-fanout\` and \`pathConflicts: []\`, fan out the entire wave in a SINGLE controller message: one harness \`Task(subagent_type=…, description="slice-builder S-<id>", prompt=<full slice context>)\` call per ready slice, **side by side in the same tool batch**. Each \`slice-builder\` span owns the full RED → GREEN → REFACTOR → DOC cycle for its slice and emits its own \`delegation-record --phase=red|green|refactor|refactor-deferred|doc\` rows. RED-before-GREEN is enforced per-slice by the linter.
 
-   When \`mode: wave-fanout\` reports \`pathConflicts\`, surface exactly one AskQuestion that lets the user resolve the overlap (drop / split / serialize). When \`mode: single-slice\`, dispatch one \`Task\` for the next ready slice.
+   When \`mode: blocked\` with \`pathConflicts\`, surface exactly one AskQuestion that lets the user resolve the overlap (drop / split / serialize). When \`mode: single-slice\`, dispatch one \`Task\` for the next ready slice.
 
 6. **Auto-advance after stage-complete:** when \`stage-complete\` returns \`ok\` with a new \`currentStage\`, immediately load the next stage skill and continue without waiting for the user to retype \`/cc\`. Announce \`Stage <prev> complete → entering <next>. Continuing.\` and proceed.
 
@@ -214,7 +214,7 @@ 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:** When \`currentStage\` is \`tdd\`, run \`wave-status --json\`, then reconcile the managed **Parallel Execution Plan** in \`05-plan.md\` with \`wave-plans/wave-NN.md\`. **The controller never edits production code in TDD.** When \`mode: wave-fanout\` and \`pathConflicts: []\`, fan out the wave in a SINGLE controller message — one \`Task\` per ready slice, side by side. Each \`slice-builder\` span owns its full RED → GREEN → REFACTOR → DOC cycle. Mirror plan \`dependsOn\` ordering between waves.
+5. **TDD:** When \`currentStage\` is \`tdd\`, run \`wave-status --json\`, then reconcile the managed **Parallel Execution Plan** in \`05-plan.md\` with \`wave-plans/wave-NN.md\`. **The controller never edits production code in TDD.** When \`mode: wave-fanout\` and \`pathConflicts: []\`, fan out the wave in a SINGLE controller message — one \`Task\` per ready slice, side by side. If \`mode: blocked\`, resolve overlaps first. Each \`slice-builder\` span owns its full RED → GREEN → REFACTOR → DOC cycle. Mirror plan \`dependsOn\` ordering between waves.
 6. **Wave resume:** Parallelize unfinished members; never restart completed lanes. Integration-overseer follows \`integrationCheckRequired\`; when skipped, emit \`cclaw_integration_overseer_skipped\` per the hook contract.
 7. If incomplete → load current stage skill and execute.
 8. If complete → advance to next stage and execute. **Auto-advance:** when \`stage-complete\` returns \`ok\`, immediately load the next stage skill and continue without waiting for the user to retype \`/cc\`.

package/dist/internal/wave-status.d.ts

@@ -16,7 +16,7 @@ export interface WaveStatusNextDispatch {
     waveId: string | null;
     readyToDispatch: string[];
     pathConflicts: string[];
-    mode: "single-slice" | "wave-fanout" | "none";
+    mode: "single-slice" | "wave-fanout" | "blocked" | "none";
 }
 export interface WaveStatusReport {
     activeRunId: string;

package/dist/internal/wave-status.js

@@ -4,6 +4,8 @@ import { RUNTIME_ROOT } from "../constants.js";
 import { readDelegationEvents, readDelegationLedger } from "../delegation.js";
 import { readFlowState } from "../runs.js";
 import { mergeParallelWaveDefinitions, parseParallelExecutionPlanWaves, parseWavePlanDirectory } from "./plan-split-waves.js";
+const PARALLEL_EXEC_MANAGED_START = "<!-- parallel-exec-managed-start -->";
+const PARALLEL_EXEC_MANAGED_END = "<!-- parallel-exec-managed-end -->";
 function parseArgs(tokens) {
     const args = { format: "json" };
     for (const token of tokens) {
@@ -33,6 +35,92 @@ function classifyWaveStatus(total, closedCount) {
         return "closed";
     return "partial";
 }
+function parsePipeRow(trimmedLine) {
+    const inner = trimmedLine.replace(/^\|/u, "").replace(/\|\s*$/u, "");
+    return inner.split("|").map((cell) => cell.trim());
+}
+function normalizePathToken(raw) {
+    return raw.trim().replace(/^`|`$/gu, "").replace(/^\.\/+/u, "");
+}
+function parseManagedWaveClaimedPaths(planMarkdown) {
+    const out = new Map();
+    const startIdx = planMarkdown.indexOf(PARALLEL_EXEC_MANAGED_START);
+    const endIdx = planMarkdown.indexOf(PARALLEL_EXEC_MANAGED_END);
+    if (startIdx < 0 || endIdx <= startIdx)
+        return out;
+    const body = planMarkdown.slice(startIdx + PARALLEL_EXEC_MANAGED_START.length, endIdx);
+    const lines = body.split(/\r?\n/u);
+    let currentWaveId = null;
+    let headerIdx = new Map();
+    for (const rawLine of lines) {
+        const trimmed = rawLine.trim();
+        const waveMatch = /^###\s+Wave\s+(?:W-)?(\d+)\b/iu.exec(trimmed);
+        if (waveMatch) {
+            currentWaveId = `W-${waveMatch[1].padStart(2, "0")}`;
+            if (!out.has(currentWaveId)) {
+                out.set(currentWaveId, new Map());
+            }
+            headerIdx = new Map();
+            continue;
+        }
+        if (!currentWaveId || !trimmed.startsWith("|"))
+            continue;
+        const cells = parsePipeRow(trimmed);
+        if (cells.length === 0)
+            continue;
+        const first = cells[0].toLowerCase();
+        if (first === "sliceid" || first === "slice id") {
+            headerIdx = new Map();
+            for (let i = 0; i < cells.length; i += 1) {
+                const key = cells[i].toLowerCase().replace(/[^a-z0-9]/gu, "");
+                if (key.length > 0 && !headerIdx.has(key)) {
+                    headerIdx.set(key, i);
+                }
+            }
+            continue;
+        }
+        if (cells.every((cell) => /^:?-{3,}:?$/u.test(cell))) {
+            continue;
+        }
+        const sliceId = cells[0].trim().toUpperCase();
+        if (!/^S-\d+$/u.test(sliceId))
+            continue;
+        const pathsIdx = headerIdx.get("claimedpaths");
+        const rawPaths = pathsIdx !== undefined ? (cells[pathsIdx] ?? "") : "";
+        const claimedPaths = rawPaths.length === 0
+            ? []
+            : rawPaths
+                .split(",")
+                .map((p) => normalizePathToken(p))
+                .filter((p) => p.length > 0);
+        out.get(currentWaveId).set(sliceId, claimedPaths);
+    }
+    return out;
+}
+function detectPathConflicts(readySlices, bySlice) {
+    const conflicts = new Set();
+    const ordered = [...readySlices].sort();
+    for (let i = 0; i < ordered.length; i += 1) {
+        const leftSlice = ordered[i];
+        const leftPaths = bySlice.get(leftSlice) ?? [];
+        if (leftPaths.length === 0)
+            continue;
+        const leftSet = new Set(leftPaths);
+        for (let j = i + 1; j < ordered.length; j += 1) {
+            const rightSlice = ordered[j];
+            const rightPaths = bySlice.get(rightSlice) ?? [];
+            if (rightPaths.length === 0)
+                continue;
+            for (const pathToken of rightPaths) {
+                if (!leftSet.has(pathToken))
+                    continue;
+                conflicts.add(`${leftSlice}:${pathToken}`);
+                conflicts.add(`${rightSlice}:${pathToken}`);
+            }
+        }
+    }
+    return [...conflicts].sort();
+}
 const TERMINAL_PHASES = new Set([
     "refactor",
     "refactor-deferred",
@@ -202,11 +290,20 @@ export async function runWaveStatus(projectRoot, options = {}) {
     }
     else {
         const readyToDispatch = [...firstOpenWave.readyMembers].sort();
+        const claimedPathsByWave = parseManagedWaveClaimedPaths(planRaw);
+        const conflicts = detectPathConflicts(readyToDispatch, claimedPathsByWave.get(firstOpenWave.waveId) ?? new Map());
+        const mode = conflicts.length > 0
+            ? "blocked"
+            : readyToDispatch.length > 1
+                ? "wave-fanout"
+                : readyToDispatch.length === 1
+                    ? "single-slice"
+                    : "none";
         nextDispatch = {
             waveId: firstOpenWave.waveId,
             readyToDispatch,
-            pathConflicts: [],
-            mode: readyToDispatch.length > 1 ? "wave-fanout" : "single-slice"
+            pathConflicts: conflicts,
+            mode
         };
     }
     return {

package/package.json

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