cclaw-cli 6.12.0 → 6.13.1

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

@@ -3,11 +3,415 @@ import path from "node:path";
 import { resolveArtifactPath } from "../artifact-paths.js";
 import { exists, writeFileSafe } from "../fs-utils.js";
 import { readFlowState } from "../runs.js";
-export const PLAN_SPLIT_DEFAULT_WAVE_SIZE = 25;
+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+)$/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`
+ * 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 v6.13.0
+ * `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
@@ -193,10 +597,7 @@ export async function runPlanSplitWaves(projectRoot, args, io) {
         }
         return 0;
     }
-    const waves = [];
-    for (let i = 0; i < units.length; i += args.waveSize) {
-        waves.push(units.slice(i, i + args.waveSize));
-    }
+    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`);
@@ -217,7 +618,9 @@ export async function runPlanSplitWaves(projectRoot, args, io) {
             await writeFileSafe(path.join(artifactsDir, fileName), body);
         }
         const managed = buildWavePlansSection(waveFileNames);
-        const updatedPlan = upsertWavePlansSection(raw, managed);
+        let updatedPlan = upsertWavePlansSection(raw, managed);
+        const parallelBlock = buildParallelExecutionPlanSection(waves, args.waveSize);
+        updatedPlan = upsertParallelExecutionPlanSection(updatedPlan, parallelBlock);
         if (updatedPlan !== raw) {
             await writeFileSafe(planResolved.absPath, updatedPlan);
         }

package/dist/internal/set-worktree-mode.d.ts

@@ -0,0 +1,10 @@
+import type { Writable } from "node:stream";
+export declare function parseSetWorktreeModeArgs(tokens: string[]): {
+    mode: "single-tree" | "worktree-first";
+} | null;
+/**
+ * Set `flow-state.json::worktreeExecutionMode` without advancing the stage DAG.
+ */
+export declare function runSetWorktreeMode(projectRoot: string, tokens: string[], io: {
+    stderr: Writable;
+}): Promise<number>;

package/dist/internal/set-worktree-mode.js

@@ -0,0 +1,28 @@
+import { readFlowState, writeFlowState } from "../runs.js";
+export function parseSetWorktreeModeArgs(tokens) {
+    let mode = null;
+    for (const token of tokens) {
+        if (token.startsWith("--mode=")) {
+            const raw = token.slice("--mode=".length).trim();
+            if (raw === "single-tree" || raw === "worktree-first") {
+                mode = raw;
+            }
+        }
+    }
+    if (!mode)
+        return null;
+    return { mode };
+}
+/**
+ * Set `flow-state.json::worktreeExecutionMode` without advancing the stage DAG.
+ */
+export async function runSetWorktreeMode(projectRoot, tokens, io) {
+    const parsed = parseSetWorktreeModeArgs(tokens);
+    if (!parsed) {
+        io.stderr.write("cclaw internal set-worktree-mode: usage: --mode=single-tree|worktree-first\n");
+        return 1;
+    }
+    const state = await readFlowState(projectRoot);
+    await writeFlowState(projectRoot, { ...state, worktreeExecutionMode: parsed.mode }, { writerSubsystem: "set-worktree-mode" });
+    return 0;
+}

package/dist/managed-resources.js

@@ -60,6 +60,8 @@ export function isManagedGeneratedPath(relPath) {
         return false;
     if (relPath.startsWith(`${RUNTIME_ROOT}/artifacts/`))
         return false;
+    if (relPath.startsWith(`${RUNTIME_ROOT}/worktrees/`))
+        return false;
     if (relPath.startsWith(`${RUNTIME_ROOT}/archive/`))
         return false;
     if (relPath === `${RUNTIME_ROOT}/state/flow-state.json`)

package/dist/run-persistence.js

@@ -472,6 +472,8 @@ function coerceFlowState(parsed) {
     const repoSignals = coerceRepoSignals(parsed.repoSignals);
     const completedStageMeta = sanitizeCompletedStageMeta(parsed.completedStageMeta);
     const tddCutoverSliceId = coerceTddCutoverSliceId(parsed.tddCutoverSliceId);
+    const worktreeExecutionMode = coerceWorktreeExecutionMode(parsed.worktreeExecutionMode);
+    const legacyContinuation = typeof parsed.legacyContinuation === "boolean" ? parsed.legacyContinuation : undefined;
     const state = {
         schemaVersion: FLOW_STATE_SCHEMA_VERSION,
         activeRunId,
@@ -485,6 +487,8 @@ function coerceFlowState(parsed) {
         ...(repoSignals ? { repoSignals } : {}),
         ...(completedStageMeta ? { completedStageMeta } : {}),
         ...(tddCutoverSliceId ? { tddCutoverSliceId } : {}),
+        ...(worktreeExecutionMode !== undefined ? { worktreeExecutionMode } : {}),
+        ...(legacyContinuation !== undefined ? { legacyContinuation } : {}),
         skippedStages: sanitizeSkippedStages(parsed.skippedStages, track),
         staleStages: sanitizeStaleStages(parsed.staleStages),
         rewinds: sanitizeRewinds(parsed.rewinds),
@@ -505,6 +509,11 @@ function coerceTddCutoverSliceId(value) {
     const trimmed = value.trim();
     return /^S-\d+$/u.test(trimmed) ? trimmed : null;
 }
+function coerceWorktreeExecutionMode(value) {
+    if (value === "single-tree" || value === "worktree-first")
+        return value;
+    return undefined;
+}
 export class CorruptFlowStateError extends Error {
     statePath;
     quarantinedPath;

package/dist/worktree-manager.d.ts

@@ -0,0 +1,50 @@
+import type { GitBaseRef, WorktreeLaneId } from "./worktree-types.js";
+export interface CreateLaneOptions {
+    /** Repository root that owns `.cclaw/`. */
+    projectRoot: string;
+    /** TDD slice id (e.g. `S-7`). */
+    sliceId: string;
+    /** Git ref to create the worktree from (e.g. `HEAD`, branch name). */
+    baseRef: GitBaseRef;
+}
+export interface CreateLaneResult {
+    laneId: WorktreeLaneId;
+    workdir: string;
+    branchName: string;
+}
+/**
+ * Create a dedicated git worktree for a slice under `.cclaw/worktrees/`.
+ * Uses branch namespace `cclaw/lane/<sliceId>-<suffix>`. Does not commit.
+ */
+export declare function createLane(options: CreateLaneOptions): Promise<CreateLaneResult>;
+/**
+ * Assert the lane worktree exists, has a clean working tree, and matches
+ * the expected baseline ref (merge-base check with `baseRef`).
+ */
+export declare function verifyLaneClean(projectRoot: string, laneId: WorktreeLaneId, baseRef: GitBaseRef): Promise<{
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+}>;
+/**
+ * Prepare the lane for interactive work (no-op placeholder for harness parity).
+ */
+export declare function attachLane(_laneId: WorktreeLaneId): Promise<void>;
+/**
+ * Release local harness attachment (no-op).
+ */
+export declare function detachLane(_laneId: WorktreeLaneId): Promise<void>;
+/**
+ * Remove the worktree directory and prune git metadata.
+ */
+export declare function cleanupLane(projectRoot: string, laneId: WorktreeLaneId, options?: {
+    force?: boolean;
+}): Promise<void>;
+export interface PruneStaleLanesOptions {
+    olderThanHours: number;
+}
+/**
+ * Remove lane worktrees older than the threshold based on directory mtime.
+ */
+export declare function pruneStaleLanes(projectRoot: string, options: PruneStaleLanesOptions): Promise<string[]>;