cclaw-cli 6.13.0 → 6.14.0

package/dist/internal/plan-split-waves.js

@@ -10,6 +10,215 @@ const WAVE_MANAGED_START = "<!-- wave-split-managed-start -->";
 const WAVE_MANAGED_END = "<!-- wave-split-managed-end -->";
 const PARALLEL_EXEC_MANAGED_START = "<!-- parallel-exec-managed-start -->";
 const PARALLEL_EXEC_MANAGED_END = "<!-- parallel-exec-managed-end -->";
+export class WavePlanDuplicateSliceError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "WavePlanDuplicateSliceError";
+    }
+}
+export class WavePlanMergeConflictError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "WavePlanMergeConflictError";
+    }
+}
+/**
+ * Raw body between parallel execution managed markers (no markers included).
+ */
+export function extractParallelExecutionManagedBody(planMarkdown) {
+    const startIdx = planMarkdown.indexOf(PARALLEL_EXEC_MANAGED_START);
+    const endIdx = planMarkdown.indexOf(PARALLEL_EXEC_MANAGED_END);
+    if (startIdx < 0 || endIdx <= startIdx)
+        return null;
+    return planMarkdown.slice(startIdx + PARALLEL_EXEC_MANAGED_START.length, endIdx).trim();
+}
+function tokenToSliceAndUnit(token) {
+    const t = token.trim().replace(/^[`"'[\]()]+|[`"'[\]()]+$/gu, "");
+    const u = /^U-(\d+)$/u.exec(t);
+    if (u) {
+        const n = u[1];
+        return { unitId: `U-${n}`, sliceId: `S-${n}` };
+    }
+    const s = /^S-(\d+)$/u.exec(t);
+    if (s) {
+        const n = s[1];
+        return { unitId: `U-${n}`, sliceId: `S-${n}` };
+    }
+    return null;
+}
+/**
+ * Members list after `Members:` in Parallel Execution Plan / wave-NN headers.
+ * Supports markdown bold `**Members:**` (colon between Members and closing `**`)
+ * and plain `Members:`.
+ */
+export function extractMembersListFromLine(trimmedLine) {
+    const bold = /^[-*]?\s*\*\*Members:\*\*\s*(.+)$/iu.exec(trimmedLine);
+    if (bold)
+        return bold[1].trim();
+    const plain = /^[-*]?\s*Members\s*:\s*(.+)$/iu.exec(trimmedLine);
+    if (plain)
+        return plain[1].trim();
+    return null;
+}
+/**
+ * Parse `## Parallel Execution Plan` managed block for wave headings and Members lines.
+ * Malformed member tokens are skipped. Duplicate slice ids in one plan source throw.
+ */
+export function parseParallelExecutionPlanWaves(planMarkdown) {
+    const body = extractParallelExecutionManagedBody(planMarkdown);
+    if (!body)
+        return [];
+    const lines = body.split(/\r?\n/u);
+    const waves = [];
+    let current = null;
+    const seenSlices = new Set();
+    const flushCurrent = () => {
+        if (current && current.members.length > 0) {
+            waves.push(current);
+        }
+    };
+    for (const rawLine of lines) {
+        const trimmed = rawLine.trim();
+        const waveMatch = /^###\s+Wave\s+(\d+)\s*$/iu.exec(trimmed);
+        if (waveMatch) {
+            flushCurrent();
+            const n = waveMatch[1];
+            current = { waveId: `W-${n.padStart(2, "0")}`, members: [] };
+            continue;
+        }
+        const membersCsv = extractMembersListFromLine(trimmed);
+        if (membersCsv !== null && current) {
+            const parts = membersCsv
+                .split(/,/u)
+                .map((p) => p.trim())
+                .filter((p) => p.length > 0);
+            for (const part of parts) {
+                const ids = tokenToSliceAndUnit(part);
+                if (!ids)
+                    continue;
+                if (seenSlices.has(ids.sliceId)) {
+                    throw new WavePlanDuplicateSliceError(`duplicate slice ${ids.sliceId} in Parallel Execution Plan managed block`);
+                }
+                seenSlices.add(ids.sliceId);
+                current.members.push(ids);
+            }
+        }
+    }
+    flushCurrent();
+    return waves;
+}
+/**
+ * Parse a single wave-NN.md: prefer a `Members:` line in the header; otherwise
+ * collect distinct S-N tokens in the first lines (legacy).
+ */
+export function parseWavePlanFileBody(body, waveId) {
+    const members = [];
+    const seen = new Set();
+    const headLines = body.split(/\r?\n/u).slice(0, 120);
+    let membersCsv = null;
+    for (const raw of headLines) {
+        membersCsv = extractMembersListFromLine(raw.trim());
+        if (membersCsv !== null)
+            break;
+    }
+    if (membersCsv !== null) {
+        for (const part of membersCsv.split(/,/u)) {
+            const ids = tokenToSliceAndUnit(part);
+            if (!ids)
+                continue;
+            if (seen.has(ids.sliceId)) {
+                throw new WavePlanDuplicateSliceError(`duplicate slice ${ids.sliceId} in ${waveId} wave file`);
+            }
+            seen.add(ids.sliceId);
+            members.push(ids);
+        }
+    }
+    if (members.length === 0) {
+        const regex = /\b(S-\d+)\b/gu;
+        let match;
+        while ((match = regex.exec(body)) !== null) {
+            const ids = tokenToSliceAndUnit(match[1]);
+            if (!ids)
+                continue;
+            if (seen.has(ids.sliceId))
+                continue;
+            seen.add(ids.sliceId);
+            members.push(ids);
+        }
+    }
+    return { waveId, members };
+}
+export async function parseWavePlanDirectory(artifactsDir) {
+    const wavePlansDir = path.join(artifactsDir, "wave-plans");
+    let entries = [];
+    try {
+        entries = await fs.readdir(wavePlansDir);
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of [...entries].sort()) {
+        const match = /^wave-(\d+)\.md$/u.exec(name);
+        if (!match)
+            continue;
+        const waveId = `W-${match[1].padStart(2, "0")}`;
+        const body = await fs.readFile(path.join(wavePlansDir, name), "utf8");
+        const wave = parseWavePlanFileBody(body, waveId);
+        if (wave.members.length > 0) {
+            out.push(wave);
+        }
+    }
+    return out;
+}
+/**
+ * Merge wave definitions: managed Parallel Execution Plan first, then wave-NN.md.
+ * Same slice must map to the same wave id and unit id in both sources or a
+ * `WavePlanMergeConflictError` is thrown.
+ */
+export function mergeParallelWaveDefinitions(primary, secondary) {
+    const byWave = new Map();
+    const sliceBinding = new Map();
+    const addWaves = (waves) => {
+        for (const wave of waves) {
+            let memMap = byWave.get(wave.waveId);
+            if (!memMap) {
+                memMap = new Map();
+                byWave.set(wave.waveId, memMap);
+            }
+            for (const member of wave.members) {
+                const prev = sliceBinding.get(member.sliceId);
+                if (prev) {
+                    if (prev.waveId !== wave.waveId || prev.unitId !== member.unitId) {
+                        throw new WavePlanMergeConflictError(`slice ${member.sliceId}: conflicting wave plan sources (wave ${prev.waveId} vs ${wave.waveId}, unit ${prev.unitId} vs ${member.unitId})`);
+                    }
+                }
+                else {
+                    sliceBinding.set(member.sliceId, { waveId: wave.waveId, unitId: member.unitId });
+                }
+                memMap.set(member.sliceId, member);
+            }
+        }
+    };
+    addWaves(primary);
+    addWaves(secondary);
+    return [...byWave.entries()]
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([wid, memMap]) => ({
+        waveId: wid,
+        members: [...memMap.values()].sort((p, q) => p.sliceId.localeCompare(q.sliceId))
+    }));
+}
+/**
+ * One-line operator hint after sync when a multi-member wave exists.
+ */
+export function formatNextParallelWaveSyncHint(merged) {
+    const candidate = merged.find((w) => w.members.length >= 2);
+    if (!candidate)
+        return null;
+    const ids = candidate.members.map((m) => m.sliceId).join(", ");
+    return `Parallel Execution Plan: ${candidate.waveId} has ${candidate.members.length} parallel members (${ids}).`;
+}
 /**
  * Parse v6.13 parallel-metadata bullets from an implementation unit body.
  * Missing keys use conservative defaults (`dependsOn: []`, `parallelizable: true`
@@ -18,12 +227,17 @@ const PARALLEL_EXEC_MANAGED_END = "<!-- parallel-exec-managed-end -->";
 export function parseImplementationUnitParallelFields(unit, options) {
     const text = unit.body;
     const pick = (label) => {
-        const re = new RegExp(`^[-*]\\s*\\*{0,2}${label}\\*{0,2}\\s*:\\s*(.*)$`, "imu");
+        const esc = label.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+        const bold = new RegExp(`^[-*]\\s*\\*\\*${esc}:\\*\\*\\s*(.*)$`, "imu");
+        const legacy = new RegExp(`^[-*]\\s*\\*{0,2}${esc}\\*{0,2}\\s*:\\s*(.*)$`, "imu");
         for (const rawLine of text.split(/\r?\n/u)) {
             const line = rawLine.trim();
-            const m = re.exec(line);
-            if (m)
-                return m[1]?.trim();
+            const mb = bold.exec(line);
+            if (mb)
+                return mb[1]?.trim();
+            const ml = legacy.exec(line);
+            if (ml)
+                return ml[1]?.trim();
         }
         return undefined;
     };
@@ -53,8 +267,13 @@ export function parseImplementationUnitParallelFields(unit, options) {
     return { unitId: id, dependsOn, claimedPaths, parallelizable, riskTier, lane };
 }
 function unitBodyHasV613ParallelBullet(body, label) {
-    const re = new RegExp(`^[-*]\\s*\\*{0,2}${label}\\*{0,2}\\s*:`, "imu");
-    return body.split(/\r?\n/u).some((raw) => re.test(raw.trim()));
+    const esc = label.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+    const bold = new RegExp(`^[-*]\\s*\\*\\*${esc}:\\*\\*`, "imu");
+    const legacy = new RegExp(`^[-*]\\s*\\*{0,2}${esc}\\*{0,2}\\s*:`, "imu");
+    return body.split(/\r?\n/u).some((raw) => {
+        const line = raw.trim();
+        return bold.test(line) || legacy.test(line);
+    });
 }
 /**
  * True when the plan has implementation units but any unit is missing v6.13.0

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.0",
+  "version": "6.14.0",
   "description": "Installer-first flow toolkit for coding agents",
   "type": "module",
   "bin": {