cclaw-cli 7.7.1 → 8.1.1

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

@@ -1,764 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { resolveArtifactPath } from "../artifact-paths.js";
-import { exists, writeFileSafe } from "../fs-utils.js";
-import { readFlowState } from "../runs.js";
-import { compareSliceIds, parseSliceId } from "../util/slice-id.js";
-export const PLAN_SPLIT_DEFAULT_WAVE_SIZE = 5;
-export const PLAN_SPLIT_SMALL_PLAN_THRESHOLD = 50;
-const WAVE_PLANS_DIR = "wave-plans";
-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+)([a-z][a-z0-9]*)?$/iu.exec(t);
-    if (u) {
-        const num = u[1];
-        const suffix = (u[2] ?? "").toLowerCase();
-        const tail = suffix.length > 0 ? `${num}${suffix}` : num;
-        return { unitId: `U-${tail}`, sliceId: `S-${tail}` };
-    }
-    const parsed = parseSliceId(t);
-    if (parsed) {
-        const tail = parsed.suffix.length > 0 ? `${parsed.numeric}${parsed.suffix}` : `${parsed.numeric}`;
-        return { unitId: `U-${tail}`, sliceId: parsed.id };
-    }
-    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;
-}
-/**
- * Extract a `(sliceId, unitId)` pair from a markdown table data row
- * whose first column is an `S-NN` token. Used by the wave parser to
- * recognize the table-format Parallel Execution Plan alongside (or
- * instead of) the `**Members:**` bullet line.
- *
- * Rules:
- * - The line must start with `|` (after trimming).
- * - Column 1 (after stripping markdown noise) may be either a slice id
- *   (`S-N`) or an implementation-unit id (`U-N`). Unit ids derive their
- *   execution slice as `S-N`, which lets 7.7+ plans schedule feature-atomic
- *   units without inventing a tiny `T-NNN` row per dispatch lane. Header rows
- *   (`| sliceId | …`, `| unit | …`) and separator rows (`|---|---|…`) are
- *   silently skipped.
- * - Column 2, when present and non-empty, becomes the `unitId`
- *   verbatim (after stripping whitespace + backticks/quotes/brackets).
- *   This lets authors record task ids (`T-010`, `T-008a`, …) in the
- *   `unit` column without forcing a `U-NN` derivation.
- * - When column 2 is absent or empty, fall back to the
- *   `S-NN → U-NN` derivation so the `**Members:**` parser path stays
- *   bit-identical for non-table plans.
- */
-export function parseTableRowMember(trimmedLine) {
-    if (!trimmedLine.startsWith("|"))
-        return null;
-    const inner = trimmedLine.replace(/^\|/u, "").replace(/\|\s*$/u, "");
-    if (inner.length === 0)
-        return null;
-    const cells = inner.split("|").map((cell) => cell.trim());
-    if (cells.length === 0)
-        return null;
-    const stripDecorations = (raw) => raw.replace(/^[`"'[\]()]+|[`"'[\]()]+$/gu, "").trim();
-    const col1 = stripDecorations(cells[0]);
-    const parsedSlice = parseSliceId(col1);
-    const parsedUnit = tokenToSliceAndUnit(col1);
-    if (!parsedSlice && !parsedUnit)
-        return null;
-    const sliceTail = parsedSlice
-        ? parsedSlice.suffix.length > 0
-            ? `${parsedSlice.numeric}${parsedSlice.suffix}`
-            : `${parsedSlice.numeric}`
-        : "";
-    const sliceId = parsedSlice ? parsedSlice.id : parsedUnit.sliceId;
-    let unitId = parsedSlice ? `U-${sliceTail}` : parsedUnit.unitId;
-    if (cells.length >= 2) {
-        const col2 = stripDecorations(cells[1]);
-        if (col2.length > 0) {
-            const normalized = tokenToSliceAndUnit(col2);
-            unitId = normalized ? normalized.unitId : col2;
-        }
-    }
-    return { sliceId, unitId };
-}
-/**
- * Parse `## Parallel Execution Plan` managed block for wave headings and
- * member declarations. Recognizes BOTH the `**Members:**` / `Members:`
- * line shape AND the markdown-table shape
- * (`| sliceId | unit | dependsOn | …`).
- *
- * Wave headings accepted (case-insensitive, trailing text allowed):
- * - `### Wave 04`
- * - `### Wave W-04`
- * - `### Wave W-04 — after fan-in W-03 (5 lanes …)`
- *
- * Within a single wave the parser dedupes by `sliceId`: if the same
- * slice appears in both `**Members:**` and a table row, the first
- * occurrence wins (line-order). Cross-wave duplicates still throw
- * `WavePlanDuplicateSliceError`.
- *
- * Malformed member tokens are skipped. Empty waves (heading present
- * but neither a Members line nor any matching `| S-NN |` row found
- * before the next heading) are RETURNED with `members: []` so callers
- * can surface the boundary; classification is up to the caller.
- */
-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();
-    let inWaveSlicesSeen = new Set();
-    const flushCurrent = () => {
-        if (current) {
-            waves.push(current);
-        }
-    };
-    /**
-     * Strict add: throw on duplicates within the same wave OR across waves.
-     * Used for the `**Members:**` path so the duplicate-detection
-     * contract is preserved bit-identically.
-     */
-    const addMemberStrict = (member) => {
-        if (!current)
-            return;
-        if (inWaveSlicesSeen.has(member.sliceId) ||
-            seenSlices.has(member.sliceId)) {
-            throw new WavePlanDuplicateSliceError(`duplicate slice ${member.sliceId} in Parallel Execution Plan managed block`);
-        }
-        seenSlices.add(member.sliceId);
-        inWaveSlicesSeen.add(member.sliceId);
-        current.members.push(member);
-    };
-    /**
-     * Lenient add: silently dedupe duplicates within the same wave (so the
-     * documented "Members + table both present" case keeps the Members
-     * declaration as authoritative); still throw on cross-wave duplicates
-     * to surface real plan-authoring bugs.
-     */
-    const addMemberDedupInWave = (member) => {
-        if (!current)
-            return;
-        if (inWaveSlicesSeen.has(member.sliceId))
-            return;
-        if (seenSlices.has(member.sliceId)) {
-            throw new WavePlanDuplicateSliceError(`duplicate slice ${member.sliceId} in Parallel Execution Plan managed block`);
-        }
-        seenSlices.add(member.sliceId);
-        inWaveSlicesSeen.add(member.sliceId);
-        current.members.push(member);
-    };
-    for (const rawLine of lines) {
-        const trimmed = rawLine.trim();
-        const waveMatch = /^###\s+Wave\s+(?:W-)?(\d+)\b/iu.exec(trimmed);
-        if (waveMatch) {
-            flushCurrent();
-            const n = waveMatch[1];
-            current = { waveId: `W-${n.padStart(2, "0")}`, members: [] };
-            inWaveSlicesSeen = new Set();
-            continue;
-        }
-        if (!current)
-            continue;
-        const membersCsv = extractMembersListFromLine(trimmed);
-        if (membersCsv !== null) {
-            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;
-                addMemberStrict(ids);
-            }
-            continue;
-        }
-        const tableMember = parseTableRowMember(trimmed);
-        if (tableMember) {
-            addMemberDedupInWave(tableMember);
-        }
-    }
-    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+(?:[a-z][a-z0-9]*)?)\b/giu;
-        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) => compareSliceIds(p.sliceId, 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 parallel-metadata bullets from an implementation unit body.
- * Missing keys use conservative defaults (`dependsOn: []`, `parallelizable: true`
- * unless `legacyParallelDefaultSerial` is set).
- */
-export function parseImplementationUnitParallelFields(unit, options) {
-    const text = unit.body;
-    const pick = (label) => {
-        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 mb = bold.exec(line);
-            if (mb)
-                return mb[1]?.trim();
-            const ml = legacy.exec(line);
-            if (ml)
-                return ml[1]?.trim();
-        }
-        return undefined;
-    };
-    const id = pick("id") ?? unit.id;
-    const depRaw = pick("dependsOn") ?? pick("depends on") ?? "";
-    const dependsOn = depRaw
-        .split(/,/u)
-        .map((s) => s.trim())
-        .filter((s) => s.length > 0 && !/^none$/iu.test(s));
-    const pathsRaw = pick("claimedPaths") ?? pick("claimed paths") ?? "";
-    const claimedPaths = pathsRaw.length > 0
-        ? pathsRaw
-            .split(",")
-            .map((s) => s.replace(/[`\s]/gu, "").trim())
-            .filter((s) => s.length > 0)
-        : [...unit.paths];
-    const explicitParallel = pick("parallelizable");
-    const parallelRaw = (explicitParallel ?? "true").toLowerCase();
-    let parallelizable = parallelRaw === "true" || parallelRaw === "yes" || parallelRaw === "y";
-    if (options?.legacyParallelDefaultSerial && explicitParallel === undefined) {
-        parallelizable = false;
-    }
-    const riskRaw = (pick("riskTier") ?? pick("risk tier") ?? "standard").toLowerCase();
-    const riskTier = riskRaw === "low" ? "low" : riskRaw === "high" ? "high" : "standard";
-    const laneRaw = pick("lane");
-    const lane = laneRaw && laneRaw.length > 0 ? laneRaw : undefined;
-    return { unitId: id, dependsOn, claimedPaths, parallelizable, riskTier, lane };
-}
-function unitBodyHasV613ParallelBullet(body, label) {
-    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
- * `dependsOn` / `claimedPaths` / `parallelizable` / `riskTier` bullets.
- */
-export function planArtifactLacksV613ParallelMetadata(planMarkdown) {
-    const units = parseImplementationUnits(planMarkdown);
-    if (units.length === 0)
-        return false;
-    const labels = ["dependsOn", "claimedPaths", "parallelizable", "riskTier"];
-    return units.some((u) => !labels.every((lab) => unitBodyHasV613ParallelBullet(u.body, lab)));
-}
-export function compareCanonicalUnitIds(a, b) {
-    const ma = /^U-(\d+)$/u.exec(a);
-    const mb = /^U-(\d+)$/u.exec(b);
-    if (ma && mb)
-        return Number(ma[1]) - Number(mb[1]);
-    return a.localeCompare(b);
-}
-function topoSortPlanUnits(meta) {
-    const idSet = new Set(meta.map((m) => m.unitId));
-    const incoming = new Map();
-    for (const m of meta)
-        incoming.set(m.unitId, 0);
-    for (const m of meta) {
-        for (const d of m.dependsOn) {
-            if (!idSet.has(d))
-                continue;
-            incoming.set(m.unitId, (incoming.get(m.unitId) ?? 0) + 1);
-        }
-    }
-    const queue = meta
-        .filter((m) => (incoming.get(m.unitId) ?? 0) === 0)
-        .sort((a, b) => compareCanonicalUnitIds(a.unitId, b.unitId));
-    const out = [];
-    while (queue.length > 0) {
-        const m = queue.shift();
-        out.push(m);
-        for (const other of meta) {
-            if (!other.dependsOn.includes(m.unitId))
-                continue;
-            const v = (incoming.get(other.unitId) ?? 0) - 1;
-            incoming.set(other.unitId, v);
-            if (v === 0) {
-                queue.push(other);
-                queue.sort((a, b) => compareCanonicalUnitIds(a.unitId, b.unitId));
-            }
-        }
-    }
-    if (out.length !== meta.length) {
-        return [...meta].sort((a, b) => compareCanonicalUnitIds(a.unitId, b.unitId));
-    }
-    return out;
-}
-/**
- * Group implementation units into waves: topological order, then greedy
- * placement with disjoint `claimedPaths` and `cap` members per wave.
- */
-export function buildConflictAwareWavesFromUnits(units, cap) {
-    const metaList = units.map((u) => parseImplementationUnitParallelFields(u));
-    const ordered = topoSortPlanUnits(metaList);
-    const unitById = new Map(units.map((u) => [parseImplementationUnitParallelFields(u).unitId, u]));
-    const waves = [];
-    const allMetaIds = new Set(metaList.map((m) => m.unitId));
-    for (const m of ordered) {
-        const u = unitById.get(m.unitId);
-        if (!u)
-            continue;
-        let placed = false;
-        for (let wi = 0; wi < waves.length; wi++) {
-            const wave = waves[wi];
-            if (wave.length >= cap)
-                continue;
-            const priorIds = new Set(waves
-                .slice(0, wi)
-                .flat()
-                .map((wu) => parseImplementationUnitParallelFields(wu).unitId));
-            const depsOk = m.dependsOn.every((d) => priorIds.has(d) || !allMetaIds.has(d));
-            if (!depsOk)
-                continue;
-            const pathsInWave = new Set();
-            for (const wu of wave) {
-                for (const p of parseImplementationUnitParallelFields(wu).claimedPaths) {
-                    pathsInWave.add(p);
-                }
-            }
-            const clash = m.claimedPaths.some((p) => pathsInWave.has(p));
-            if (clash)
-                continue;
-            wave.push(u);
-            placed = true;
-            break;
-        }
-        if (!placed) {
-            waves.push([u]);
-        }
-    }
-    return waves;
-}
-export function buildParallelExecutionPlanSection(waves, cap) {
-    const lines = [];
-    lines.push(PARALLEL_EXEC_MANAGED_START);
-    lines.push("## Parallel Execution Plan");
-    lines.push("");
-    lines.push(`- **Cap:** ${cap} parallel units per wave (conflict-aware via \`claimedPaths\`).`);
-    lines.push("");
-    for (let i = 0; i < waves.length; i += 1) {
-        const w = waves[i];
-        const ids = w.map((unit) => parseImplementationUnitParallelFields(unit).unitId);
-        const union = new Set();
-        for (const unit of w) {
-            for (const p of parseImplementationUnitParallelFields(unit).claimedPaths) {
-                union.add(p);
-            }
-        }
-        lines.push(`### Wave ${padWaveIndex(i + 1)}`);
-        lines.push(`- **Members:** ${ids.join(", ")}`);
-        lines.push(`- **Claimed paths union:** ${[...union].sort().join(", ") || "(none)"}`);
-        lines.push("");
-    }
-    lines.push(PARALLEL_EXEC_MANAGED_END);
-    return lines.join("\n");
-}
-/**
- * Replace or append the managed Parallel Execution Plan block.
- */
-export function upsertParallelExecutionPlanSection(planMarkdown, managedBlock) {
-    const startIdx = planMarkdown.indexOf(PARALLEL_EXEC_MANAGED_START);
-    const endIdx = planMarkdown.indexOf(PARALLEL_EXEC_MANAGED_END);
-    if (startIdx >= 0 && endIdx > startIdx) {
-        const before = planMarkdown.slice(0, startIdx);
-        const after = planMarkdown.slice(endIdx + PARALLEL_EXEC_MANAGED_END.length);
-        const joined = `${before}${managedBlock}${after}`;
-        return joined.endsWith("\n") ? joined : `${joined}\n`;
-    }
-    const trimmed = planMarkdown.replace(/\s+$/u, "");
-    return `${trimmed}\n\n${managedBlock}\n`;
-}
-/**
- * Parse `## Implementation Units` section into individual unit blocks.
- * Recognizes the canonical heading shape in the TDD-velocity plan template
- * (`### Implementation Unit U-<n>`). Tolerant of `Files:` listed either
- * inline or as a `- **Files (...):**` bullet block.
- */
-export function parseImplementationUnits(planMarkdown) {
-    const units = [];
-    const headingRegex = /(^|\n)###\s+Implementation Unit\s+(U-\d+)\b/gu;
-    const matches = [];
-    let match;
-    while ((match = headingRegex.exec(planMarkdown)) !== null) {
-        const offset = match[1] === "" ? 0 : 1; // strip the leading newline if present
-        matches.push({
-            id: match[2],
-            start: match.index + offset,
-            headingEnd: match.index + match[0].length
-        });
-    }
-    for (let i = 0; i < matches.length; i += 1) {
-        const current = matches[i];
-        const next = matches[i + 1];
-        let endIndex = next ? next.start : planMarkdown.length;
-        // If a higher-level H2 (`## ...`) appears before the next unit, end at the H2.
-        const tail = planMarkdown.slice(current.headingEnd, endIndex);
-        const sectionBreak = /\n##\s+\S/u.exec(tail);
-        if (sectionBreak) {
-            endIndex = current.headingEnd + sectionBreak.index + 1; // include the trailing newline
-        }
-        const body = planMarkdown.slice(current.start, endIndex).replace(/\s+$/u, "");
-        units.push({
-            id: current.id,
-            body,
-            paths: extractPathsLine(body)
-        });
-    }
-    return units;
-}
-/**
- * Pull repo-relative paths from a `Files:` line or the `Files (...)` bullet
- * block. Both shapes appear in the wild; the parser extracts after the colon
- * and splits on commas. Empty/whitespace items are dropped.
- */
-export function extractPathsLine(unitBody) {
-    const lines = unitBody.split(/\r?\n/u);
-    for (const rawLine of lines) {
-        const line = rawLine.trim();
-        const filesMatch = /^[-*]?\s*\*?\*?Files\s*(?:\([^)]*\))?\s*:\*?\*?\s*(.*)$/iu.exec(line);
-        if (!filesMatch)
-            continue;
-        const remainder = filesMatch[1].trim();
-        if (remainder.length === 0)
-            continue;
-        return remainder
-            .split(",")
-            .map((item) => item.replace(/[`*]/gu, "").trim())
-            .filter((item) => item.length > 0);
-    }
-    return [];
-}
-export function parsePlanSplitWavesArgs(tokens) {
-    let waveSize = PLAN_SPLIT_DEFAULT_WAVE_SIZE;
-    let dryRun = false;
-    let force = false;
-    let json = false;
-    for (let i = 0; i < tokens.length; i += 1) {
-        const token = tokens[i];
-        const next = tokens[i + 1];
-        if (token === "--dry-run") {
-            dryRun = true;
-            continue;
-        }
-        if (token === "--force") {
-            force = true;
-            continue;
-        }
-        if (token === "--json") {
-            json = true;
-            continue;
-        }
-        if (token === "--wave-size" || token.startsWith("--wave-size=")) {
-            let raw = "";
-            if (token.startsWith("--wave-size=")) {
-                raw = token.slice("--wave-size=".length);
-            }
-            else {
-                if (next === undefined || next.startsWith("--")) {
-                    throw new Error("--wave-size requires an integer value.");
-                }
-                raw = next;
-                i += 1;
-            }
-            const trimmed = raw.trim();
-            if (!/^[0-9]+$/u.test(trimmed)) {
-                throw new Error("--wave-size must be a positive integer.");
-            }
-            waveSize = Number(trimmed);
-            if (waveSize < 1) {
-                throw new Error("--wave-size must be >= 1.");
-            }
-            continue;
-        }
-        throw new Error(`Unknown flag for internal plan-split-waves: ${token}`);
-    }
-    return { waveSize, dryRun, force, json };
-}
-function padWaveIndex(index) {
-    return index.toString().padStart(2, "0");
-}
-function buildWaveFileBody(waveIndex, units, sourceLabel) {
-    const idsRange = `${units[0].id}..${units[units.length - 1].id}`;
-    return [
-        `# Wave ${padWaveIndex(waveIndex)}`,
-        "",
-        `Source: ${sourceLabel} units ${idsRange}`,
-        "",
-        "## Implementation Units",
-        "",
-        units.map((unit) => unit.body.trim()).join("\n\n"),
-        ""
-    ].join("\n");
-}
-function buildWavePlansSection(waveFiles) {
-    const lines = [];
-    lines.push(WAVE_MANAGED_START);
-    lines.push("## Wave Plans");
-    lines.push("");
-    for (let i = 0; i < waveFiles.length; i += 1) {
-        lines.push(`- Wave ${padWaveIndex(i + 1)}: \`${waveFiles[i]}\``);
-    }
-    lines.push("");
-    lines.push(WAVE_MANAGED_END);
-    return lines.join("\n");
-}
-/**
- * Replace any existing managed Wave Plans block with the new one, or append
- * it at the end of the file when no markers are present yet. The helper
- * never touches text outside the markers.
- */
-export function upsertWavePlansSection(planMarkdown, managedBlock) {
-    const startIdx = planMarkdown.indexOf(WAVE_MANAGED_START);
-    const endIdx = planMarkdown.indexOf(WAVE_MANAGED_END);
-    if (startIdx >= 0 && endIdx > startIdx) {
-        const before = planMarkdown.slice(0, startIdx);
-        const after = planMarkdown.slice(endIdx + WAVE_MANAGED_END.length);
-        const joined = `${before}${managedBlock}${after}`;
-        return joined.endsWith("\n") ? joined : `${joined}\n`;
-    }
-    const trimmed = planMarkdown.replace(/\s+$/u, "");
-    return `${trimmed}\n\n${managedBlock}\n`;
-}
-export async function runPlanSplitWaves(projectRoot, args, io) {
-    const flow = await readFlowState(projectRoot).catch(() => null);
-    const track = flow?.track;
-    const planResolved = await resolveArtifactPath("plan", {
-        projectRoot,
-        track,
-        intent: "read"
-    });
-    if (!(await exists(planResolved.absPath))) {
-        io.stderr.write(`cclaw internal plan-split-waves: plan artifact not found at ${planResolved.relPath}.\n`);
-        return 1;
-    }
-    const raw = await fs.readFile(planResolved.absPath, "utf8");
-    const units = parseImplementationUnits(raw);
-    if (units.length < PLAN_SPLIT_SMALL_PLAN_THRESHOLD) {
-        const outcome = {
-            ok: true,
-            command: "plan-split-waves",
-            totalUnits: units.length,
-            waveCount: 0,
-            waveSize: args.waveSize,
-            smallPlanNoOp: true,
-            dryRun: args.dryRun,
-            waveFiles: [],
-            planUpdated: false
-        };
-        if (args.json) {
-            io.stdout.write(`${JSON.stringify(outcome)}\n`);
-        }
-        else {
-            io.stdout.write(`plan is small (${units.length} unit(s), threshold ${PLAN_SPLIT_SMALL_PLAN_THRESHOLD}); no wave split needed.\n`);
-        }
-        return 0;
-    }
-    const waves = buildConflictAwareWavesFromUnits(units, args.waveSize);
-    const artifactsDir = path.dirname(planResolved.absPath);
-    const wavePlansAbsDir = path.join(artifactsDir, WAVE_PLANS_DIR);
-    const waveFileNames = waves.map((_, idx) => `${WAVE_PLANS_DIR}/wave-${padWaveIndex(idx + 1)}.md`);
-    if (!args.dryRun && !args.force) {
-        for (const fileName of waveFileNames) {
-            const abs = path.join(artifactsDir, fileName);
-            if (await exists(abs)) {
-                io.stderr.write(`cclaw internal plan-split-waves: wave file already exists: ${path.relative(projectRoot, abs)}. Pass --force to overwrite.\n`);
-                return 1;
-            }
-        }
-    }
-    if (!args.dryRun) {
-        await fs.mkdir(wavePlansAbsDir, { recursive: true });
-        for (let i = 0; i < waves.length; i += 1) {
-            const fileName = waveFileNames[i];
-            const body = buildWaveFileBody(i + 1, waves[i], planResolved.fileName);
-            await writeFileSafe(path.join(artifactsDir, fileName), body);
-        }
-        const managed = buildWavePlansSection(waveFileNames);
-        let updatedPlan = upsertWavePlansSection(raw, managed);
-        const parallelBlock = buildParallelExecutionPlanSection(waves, args.waveSize);
-        updatedPlan = upsertParallelExecutionPlanSection(updatedPlan, parallelBlock);
-        if (updatedPlan !== raw) {
-            await writeFileSafe(planResolved.absPath, updatedPlan);
-        }
-    }
-    const outcome = {
-        ok: true,
-        command: "plan-split-waves",
-        totalUnits: units.length,
-        waveCount: waves.length,
-        waveSize: args.waveSize,
-        smallPlanNoOp: false,
-        dryRun: args.dryRun,
-        waveFiles: waveFileNames,
-        planUpdated: !args.dryRun
-    };
-    if (args.json) {
-        io.stdout.write(`${JSON.stringify(outcome)}\n`);
-    }
-    else if (args.dryRun) {
-        io.stdout.write(`dry run: would split ${units.length} unit(s) into ${waves.length} wave file(s) of size ${args.waveSize}:\n`);
-        for (const fileName of waveFileNames) {
-            io.stdout.write(`  - ${fileName}\n`);
-        }
-    }
-    else {
-        io.stdout.write(`wrote ${waves.length} wave file(s) under ${path.relative(projectRoot, wavePlansAbsDir)} and refreshed Wave Plans section in ${planResolved.relPath}.\n`);
-    }
-    return 0;
-}