cclaw-cli 6.14.4 → 7.0.0

package/dist/policy.js

@@ -71,7 +71,7 @@ export async function policyChecks(projectRoot, options = {}) {
         { file: runtimeFile("skills/flow-view/SKILL.md"), needle: "## Diff Subcommand", name: "utility_skill:view:diff_section" },
         { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:sdd:hard_gate" },
         { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "## Status Contract", name: "utility_skill:sdd:status_contract" },
-        { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "slice-implementer", name: "utility_skill:sdd:implementer_template" },
+        { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "slice-builder", name: "utility_skill:sdd:implementer_template" },
         { file: runtimeFile("skills/subagent-dev/SKILL.md"), needle: "## Model & Harness Routing Notes", name: "utility_skill:sdd:routing_notes" },
         { file: runtimeFile("skills/parallel-dispatch/SKILL.md"), needle: "## HARD-GATE", name: "utility_skill:parallel:hard_gate" },
         { file: runtimeFile("skills/parallel-dispatch/SKILL.md"), needle: "Review Army", name: "utility_skill:parallel:review_army" },

package/dist/run-persistence.js

@@ -232,10 +232,10 @@ function coerceRepoSignals(value) {
     };
 }
 /**
- * Wave 24 follow-up (v6.1.1) — preserve `flow-state.json#taskClass`
+ * preserve `flow-state.json#taskClass`
  * across read/write round-trips. Before this audit fix the persistence
- * layer silently dropped the field, which made the Wave 24 bugfix-skip
- * (`mandatoryAgentsFor` short-circuit) and the Wave 25 artifact-validation
+ * layer silently dropped the field, which made the bugfix-skip
+ * (`mandatoryAgentsFor` short-circuit) and the artifact-validation
  * demotion both dead in practice: the only entry point that classified
  * a run was the unit-test harness passing `options.taskClass` directly
  * to `checkMandatoryDelegations`. The accepted union mirrors
@@ -471,13 +471,10 @@ function coerceFlowState(parsed) {
     const taskClass = coerceTaskClass(parsed.taskClass);
     const repoSignals = coerceRepoSignals(parsed.repoSignals);
     const completedStageMeta = sanitizeCompletedStageMeta(parsed.completedStageMeta);
-    const tddCutoverSliceId = coerceTddCutoverSliceId(parsed.tddCutoverSliceId);
-    const tddWorktreeCutoverSliceId = coerceTddCutoverSliceId(parsed.tddWorktreeCutoverSliceId);
-    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 tddGreenMinElapsedMs = coerceTddGreenMinElapsedMs(parsed.tddGreenMinElapsedMs);
+    const packageVersion = typeof parsed.packageVersion === "string" && parsed.packageVersion.trim().length > 0
+        ? parsed.packageVersion.trim()
+        : undefined;
     const state = {
         schemaVersion: FLOW_STATE_SCHEMA_VERSION,
         activeRunId,
@@ -490,13 +487,8 @@ function coerceFlowState(parsed) {
         ...(taskClass !== undefined ? { taskClass } : {}),
         ...(repoSignals ? { repoSignals } : {}),
         ...(completedStageMeta ? { completedStageMeta } : {}),
-        ...(tddCutoverSliceId ? { tddCutoverSliceId } : {}),
-        ...(tddWorktreeCutoverSliceId ? { tddWorktreeCutoverSliceId } : {}),
-        ...(worktreeExecutionMode !== undefined ? { worktreeExecutionMode } : {}),
-        ...(tddCheckpointMode !== undefined ? { tddCheckpointMode } : {}),
-        ...(integrationOverseerMode !== undefined ? { integrationOverseerMode } : {}),
-        ...(legacyContinuation !== undefined ? { legacyContinuation } : {}),
         ...(tddGreenMinElapsedMs !== undefined ? { tddGreenMinElapsedMs } : {}),
+        ...(packageVersion ? { packageVersion } : {}),
         skippedStages: sanitizeSkippedStages(parsed.skippedStages, track),
         staleStages: sanitizeStaleStages(parsed.staleStages),
         rewinds: sanitizeRewinds(parsed.rewinds),
@@ -507,33 +499,7 @@ function coerceFlowState(parsed) {
     return { state };
 }
 /**
- * v6.12.0 — best-effort coercion for `tddCutoverSliceId`. Returns the value
- * only when it matches the canonical slice id shape `S-<digits>`; otherwise
- * returns null so the field is omitted from the rehydrated state.
- */
-function coerceTddCutoverSliceId(value) {
-    if (typeof value !== "string")
-        return null;
-    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;
-}
-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;
-}
-/**
- * v6.14.2 — coerce `tddGreenMinElapsedMs` from disk. Mirrors the
+ * coerce `tddGreenMinElapsedMs` from disk. Mirrors the
  * defensive read in `effectiveTddGreenMinElapsedMs`: numbers ≥ 0 round
  * down to integers; everything else (NaN, strings, negatives) returns
  * undefined so the field is omitted from the rehydrated state and the
@@ -757,10 +723,10 @@ export async function writeFlowStateGuarded(projectRoot, state, options = {}) {
     await writeFlowState(projectRoot, state, options);
 }
 /**
- * v6.9.0 — backfill missing `completedStageMeta` rows for any stage that
+ * backfill missing `completedStageMeta` rows for any stage that
  * already lives in `completedStages` but has no audit timestamp. Uses the
  * stage's artifact mtime when available, otherwise the current time. This
- * runs as part of `flow-state-repair` so legacy v6.8 flow-state.json files
+ * runs as part of `flow-state-repair` so older flow-state.json files
  * get their meta carried forward without a destructive rewrite.
  */
 async function backfillCompletedStageMeta(projectRoot, state) {

package/dist/runtime/run-hook.mjs

@@ -56,7 +56,7 @@ var REQUIRED_GITIGNORE_PATTERNS = [
   ".opencode/commands/cc-*.md",
   ".opencode/commands/cc.md",
   // Codex uses skill-kind shims under `.agents/skills/cc*/` since
-  // v0.40.0 (renamed from the `cclaw-cc*` layout in v0.39.0/v0.39.1).
+  // Codex shim layout (renamed from the older `cclaw-cc*` layout).
   // `cclaw sync` and `cclaw uninstall` both auto-remove the legacy
   // `cclaw-cc*` directories.
   ".agents/skills/cc/SKILL.md",
@@ -676,7 +676,7 @@ async function handleSessionStart(runtime) {
   );
   const knowledge = await buildKnowledgeDigest(runtime.root, state.currentStage, knowledgeRaw);
 
-  // Wave 21 honest-core: session-start no longer runs background helper
+  // honest-core: session-start no longer runs background helper
   // pipelines or digest caches. It rehydrates flow + knowledge only.
   const ralphLoopLine = "";
   const earlyLoopLine = "";
@@ -746,7 +746,7 @@ async function handleSessionStart(runtime) {
   if (metaContent.length > 0) {
     parts.push(metaContent);
   }
-  // v6.9.0: load iron-laws content into the session-start digest so the
+  // load iron-laws content into the session-start digest so the
   // non-negotiable workflow constraints are visible from the first turn,
   // not lazily on tool dispatch.
   if (ironLawsContent.length > 0) {

package/dist/track-heuristics.js

@@ -51,7 +51,7 @@ const DEFAULT_RULES = {
     }
 };
 // Fixed evaluation order: narrow-to-broad. Overriding this was never wired
-// into runtime, so cclaw stopped offering the knob in v0.38.0.
+// into runtime, so cclaw no longer offers that knob.
 const EVALUATION_ORDER = ["standard", "medium", "quick"];
 const DEFAULT_FALLBACK = "standard";
 const ADAPTIVE_ELICITATION_STAGES = new Set(["brainstorm", "scope", "design"]);

package/dist/types.d.ts

@@ -34,7 +34,7 @@ export type LanguageRulePack = (typeof LANGUAGE_RULE_PACKS)[number];
  * - `triggers`: additional substrings that push a prompt toward this track.
  * - `veto`:     substrings that forbid this track even if a trigger matches.
  *
- * Removed in v0.38.0:
+ * Removed:
  * - `patterns` (regex): no runtime ever consumed them; kept authors honest
  *   about what cclaw actually enforces.
  */
@@ -51,7 +51,7 @@ export interface TrackHeuristicRule {
  * result — which is why we only ship `triggers`, `veto`, and `fallback`, not
  * regex patterns or priority overrides.
  *
- * Removed in v0.38.0:
+ * Removed:
  * - `priority`: track evaluation order is always `standard -> medium -> quick`
  *   (narrow-to-broad matching). Overriding it was never wired.
  */

package/package.json

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

package/dist/integration-fanin.d.ts

@@ -1,44 +0,0 @@
-import { type FlowState } from "./flow-state.js";
-import type { WorktreeLaneId } from "./worktree-types.js";
-export type FanInEventKind = "applied" | "conflict" | "resolved" | "abandoned";
-export interface FanInLaneOptions {
-    projectRoot: string;
-    /** Lane directory under `.cclaw/worktrees/<laneId>`. */
-    laneId: WorktreeLaneId;
-    /** Integration branch to receive the patch (must already exist locally). */
-    integrationBranch: string;
-    /**
-     * Baseline ref for `git diff` in the lane (fork point vs integration).
-     * When omitted, computed as `git merge-base <integration> HEAD` in the lane.
-     */
-    baseRef?: string;
-}
-export interface FanInLaneResult {
-    ok: boolean;
-    event: FanInEventKind;
-    details: string;
-}
-/**
- * Build a unified diff from `baseRef..HEAD` in the lane worktree and apply it
- * to the integration branch in the main repo using three-way merge.
- * On conflict, the integration branch working tree is reset and, when possible,
- * git HEAD is restored to the branch that was checked out before fan-in.
- */
-export declare function fanInLane(options: FanInLaneOptions): Promise<FanInLaneResult>;
-export interface ResolverDispatchHint {
-    sliceId: string;
-    command: string;
-}
-/**
- * Returns the canonical CLI hint for resolving fan-in conflicts for a slice.
- */
-export declare function buildResolveConflictDispatchHint(sliceId: string): ResolverDispatchHint;
-/**
- * Merge every lane that recorded a completed GREEN `ownerLaneId` for the
- * active run, then emit `cclaw_fanin_*` audit rows. Does nothing in
- * `single-tree` mode or when git is unavailable.
- */
-export declare function runTddDeterministicFanInBeforeAdvance(projectRoot: string, flowState: FlowState): Promise<{
-    ok: boolean;
-    issues: string[];
-}>;

package/dist/integration-fanin.js

@@ -1,180 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-import { exists } from "./fs-utils.js";
-import { readDelegationEvents, recordCclawFanInAudit } from "./delegation.js";
-import { effectiveWorktreeExecutionMode } from "./flow-state.js";
-const execFileAsync = promisify(execFile);
-const WORKTREES_SEG = ".cclaw/worktrees";
-/**
- * Build a unified diff from `baseRef..HEAD` in the lane worktree and apply it
- * to the integration branch in the main repo using three-way merge.
- * On conflict, the integration branch working tree is reset and, when possible,
- * git HEAD is restored to the branch that was checked out before fan-in.
- */
-export async function fanInLane(options) {
-    const { projectRoot, laneId, integrationBranch } = options;
-    const workdir = path.join(projectRoot, WORKTREES_SEG, laneId);
-    if (!(await exists(workdir))) {
-        return { ok: false, event: "abandoned", details: `missing lane workdir ${workdir}` };
-    }
-    let integrationRef;
-    try {
-        integrationRef = (await execFileAsync("git", ["rev-parse", "--verify", integrationBranch], {
-            cwd: projectRoot
-        })).stdout.trim();
-    }
-    catch {
-        return {
-            ok: false,
-            event: "abandoned",
-            details: `integration branch/ref not found: ${integrationBranch}`
-        };
-    }
-    let baseRef = options.baseRef?.trim() ?? "";
-    if (baseRef.length === 0) {
-        try {
-            baseRef = (await execFileAsync("git", ["merge-base", integrationRef, "HEAD"], { cwd: workdir })).stdout.trim();
-        }
-        catch (err) {
-            return {
-                ok: false,
-                event: "abandoned",
-                details: `cannot merge-base lane ${laneId} with ${integrationBranch}: ${err instanceof Error ? err.message : String(err)}`
-            };
-        }
-    }
-    const patchFile = path.join(projectRoot, WORKTREES_SEG, `.fanin-${laneId}.patch`);
-    let restoreBranch = null;
-    try {
-        let curBranch = "";
-        try {
-            curBranch = (await execFileAsync("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: projectRoot })).stdout.trim();
-        }
-        catch {
-            curBranch = "";
-        }
-        if (curBranch.length > 0 && curBranch !== integrationBranch && curBranch !== "HEAD") {
-            restoreBranch = curBranch;
-        }
-        const { stdout: diffOut } = await execFileAsync("git", ["diff", `${baseRef}..HEAD`], { cwd: workdir, maxBuffer: 64 * 1024 * 1024 });
-        if (diffOut.trim().length === 0) {
-            return { ok: true, event: "applied", details: "empty diff; nothing to merge" };
-        }
-        await fs.writeFile(patchFile, diffOut, "utf8");
-        await execFileAsync("git", ["checkout", integrationBranch], { cwd: projectRoot });
-        try {
-            await execFileAsync("git", ["apply", "--3way", patchFile], { cwd: projectRoot });
-            return { ok: true, event: "applied", details: `applied lane ${laneId} onto ${integrationBranch}` };
-        }
-        catch (err) {
-            await execFileAsync("git", ["checkout", "--", "."], { cwd: projectRoot }).catch(() => undefined);
-            if (restoreBranch) {
-                await execFileAsync("git", ["checkout", restoreBranch], { cwd: projectRoot }).catch(() => undefined);
-            }
-            const msg = err instanceof Error ? err.message : String(err);
-            return {
-                ok: false,
-                event: "conflict",
-                details: `git apply --3way reported conflicts for lane ${laneId}: ${msg}`
-            };
-        }
-    }
-    finally {
-        await fs.rm(patchFile, { force: true });
-    }
-}
-/**
- * Returns the canonical CLI hint for resolving fan-in conflicts for a slice.
- */
-export function buildResolveConflictDispatchHint(sliceId) {
-    return {
-        sliceId,
-        command: `slice-implementer --phase resolve-conflict --slice ${sliceId}`
-    };
-}
-/**
- * Merge every lane that recorded a completed GREEN `ownerLaneId` for the
- * active run, then emit `cclaw_fanin_*` audit rows. Does nothing in
- * `single-tree` mode or when git is unavailable.
- */
-export async function runTddDeterministicFanInBeforeAdvance(projectRoot, flowState) {
-    if (effectiveWorktreeExecutionMode(flowState) !== "worktree-first") {
-        return { ok: true, issues: [] };
-    }
-    let integrationBranch;
-    try {
-        integrationBranch = (await execFileAsync("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: projectRoot })).stdout.trim();
-    }
-    catch {
-        return {
-            ok: false,
-            issues: ["worktree fan-in: cannot read current git branch (not a repository or detached HEAD unsupported here)."]
-        };
-    }
-    const { events } = await readDelegationEvents(projectRoot);
-    const runId = flowState.activeRunId;
-    const laneToSlices = new Map();
-    for (const e of events) {
-        if (e.runId !== runId || e.stage !== "tdd")
-            continue;
-        if (e.agent !== "slice-implementer")
-            continue;
-        if (e.status !== "completed" || e.phase !== "green")
-            continue;
-        const lane = e.ownerLaneId?.trim();
-        const sid = e.sliceId?.trim();
-        if (!lane || !sid)
-            continue;
-        if (!laneToSlices.has(lane))
-            laneToSlices.set(lane, new Set());
-        laneToSlices.get(lane).add(sid);
-    }
-    if (laneToSlices.size === 0) {
-        return { ok: true, issues: [] };
-    }
-    const issues = [];
-    for (const [laneId, sliceSet] of laneToSlices) {
-        const result = await fanInLane({
-            projectRoot,
-            laneId: laneId,
-            integrationBranch,
-            baseRef: undefined
-        });
-        const sliceIds = [...sliceSet].sort();
-        if (!result.ok && result.event === "conflict") {
-            await recordCclawFanInAudit(projectRoot, {
-                kind: "cclaw_fanin_conflict",
-                runId,
-                laneId,
-                sliceIds,
-                integrationBranch,
-                details: result.details
-            });
-            issues.push(`${result.details} — ${buildResolveConflictDispatchHint(sliceIds[0] ?? "S-1").command}`);
-            continue;
-        }
-        if (!result.ok) {
-            await recordCclawFanInAudit(projectRoot, {
-                kind: "cclaw_fanin_abandoned",
-                runId,
-                laneId,
-                sliceIds,
-                integrationBranch,
-                details: result.details
-            });
-            issues.push(result.details);
-            continue;
-        }
-        await recordCclawFanInAudit(projectRoot, {
-            kind: "cclaw_fanin_applied",
-            runId,
-            laneId,
-            sliceIds,
-            integrationBranch,
-            details: result.details
-        });
-    }
-    return { ok: issues.length === 0, issues };
-}

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

@@ -1,16 +0,0 @@
-import type { Writable } from "node:stream";
-export interface SetCheckpointModeArgs {
-    mode: "per-slice" | "global-red";
-    reason: string | null;
-}
-export declare function parseSetCheckpointModeArgs(tokens: string[]): SetCheckpointModeArgs | null;
-/**
- * v6.14.2 — set `flow-state.json::tddCheckpointMode` without advancing
- * the stage DAG. Mirrors `set-worktree-mode`. The `--reason` flag is
- * optional but recommended for the audit trail; it is currently passed
- * through to the writer subsystem string so operators can grep the
- * `.flow-state.guard.json` sidecar.
- */
-export declare function runSetCheckpointMode(projectRoot: string, tokens: string[], io: {
-    stderr: Writable;
-}): Promise<number>;

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

@@ -1,72 +0,0 @@
-import { readFlowState, writeFlowState } from "../runs.js";
-export function parseSetCheckpointModeArgs(tokens) {
-    let mode = null;
-    let reason = null;
-    let positional = null;
-    for (const token of tokens) {
-        if (token.startsWith("--mode=")) {
-            const raw = token.slice("--mode=".length).trim();
-            if (raw === "per-slice" || raw === "global-red") {
-                mode = raw;
-            }
-            else {
-                return null;
-            }
-            continue;
-        }
-        if (token.startsWith("--reason=")) {
-            const raw = token.slice("--reason=".length).trim();
-            if (raw.length > 0)
-                reason = raw;
-            continue;
-        }
-        if (token.startsWith("--")) {
-            // unknown flag — let the caller surface usage.
-            return null;
-        }
-        if (positional === null) {
-            positional = token.trim();
-            continue;
-        }
-        return null;
-    }
-    if (mode === null && positional !== null) {
-        if (positional === "per-slice" || positional === "global-red") {
-            mode = positional;
-        }
-        else {
-            return null;
-        }
-    }
-    if (mode === null)
-        return null;
-    return { mode, reason };
-}
-/**
- * v6.14.2 — set `flow-state.json::tddCheckpointMode` without advancing
- * the stage DAG. Mirrors `set-worktree-mode`. The `--reason` flag is
- * optional but recommended for the audit trail; it is currently passed
- * through to the writer subsystem string so operators can grep the
- * `.flow-state.guard.json` sidecar.
- */
-export async function runSetCheckpointMode(projectRoot, tokens, io) {
-    const parsed = parseSetCheckpointModeArgs(tokens);
-    if (!parsed) {
-        io.stderr.write("cclaw internal set-checkpoint-mode: usage: <per-slice|global-red> [--reason=\"<short>\"] " +
-            "(or --mode=<per-slice|global-red>)\n");
-        return 1;
-    }
-    const state = await readFlowState(projectRoot);
-    const writerSubsystem = parsed.reason
-        ? `set-checkpoint-mode:${slugifyReason(parsed.reason)}`
-        : "set-checkpoint-mode";
-    await writeFlowState(projectRoot, { ...state, tddCheckpointMode: parsed.mode }, { writerSubsystem });
-    return 0;
-}
-function slugifyReason(reason) {
-    return (reason
-        .toLowerCase()
-        .replace(/[^a-z0-9_-]+/gu, "-")
-        .replace(/^-+|-+$/gu, "")
-        .slice(0, 60) || "unspecified");
-}

package/dist/internal/set-integration-overseer-mode.d.ts

@@ -1,14 +0,0 @@
-import type { Writable } from "node:stream";
-export interface SetIntegrationOverseerModeArgs {
-    mode: "conditional" | "always";
-    reason: string | null;
-}
-export declare function parseSetIntegrationOverseerModeArgs(tokens: string[]): SetIntegrationOverseerModeArgs | null;
-/**
- * v6.14.2 — set `flow-state.json::integrationOverseerMode` without
- * advancing the stage DAG. Mirrors `set-worktree-mode` and
- * `set-checkpoint-mode`.
- */
-export declare function runSetIntegrationOverseerMode(projectRoot: string, tokens: string[], io: {
-    stderr: Writable;
-}): Promise<number>;

package/dist/internal/set-integration-overseer-mode.js

@@ -1,69 +0,0 @@
-import { readFlowState, writeFlowState } from "../runs.js";
-export function parseSetIntegrationOverseerModeArgs(tokens) {
-    let mode = null;
-    let reason = null;
-    let positional = null;
-    for (const token of tokens) {
-        if (token.startsWith("--mode=")) {
-            const raw = token.slice("--mode=".length).trim();
-            if (raw === "conditional" || raw === "always") {
-                mode = raw;
-            }
-            else {
-                return null;
-            }
-            continue;
-        }
-        if (token.startsWith("--reason=")) {
-            const raw = token.slice("--reason=".length).trim();
-            if (raw.length > 0)
-                reason = raw;
-            continue;
-        }
-        if (token.startsWith("--")) {
-            return null;
-        }
-        if (positional === null) {
-            positional = token.trim();
-            continue;
-        }
-        return null;
-    }
-    if (mode === null && positional !== null) {
-        if (positional === "conditional" || positional === "always") {
-            mode = positional;
-        }
-        else {
-            return null;
-        }
-    }
-    if (mode === null)
-        return null;
-    return { mode, reason };
-}
-/**
- * v6.14.2 — set `flow-state.json::integrationOverseerMode` without
- * advancing the stage DAG. Mirrors `set-worktree-mode` and
- * `set-checkpoint-mode`.
- */
-export async function runSetIntegrationOverseerMode(projectRoot, tokens, io) {
-    const parsed = parseSetIntegrationOverseerModeArgs(tokens);
-    if (!parsed) {
-        io.stderr.write("cclaw internal set-integration-overseer-mode: usage: <conditional|always> [--reason=\"<short>\"] " +
-            "(or --mode=<conditional|always>)\n");
-        return 1;
-    }
-    const state = await readFlowState(projectRoot);
-    const writerSubsystem = parsed.reason
-        ? `set-integration-overseer-mode:${slugifyReason(parsed.reason)}`
-        : "set-integration-overseer-mode";
-    await writeFlowState(projectRoot, { ...state, integrationOverseerMode: parsed.mode }, { writerSubsystem });
-    return 0;
-}
-function slugifyReason(reason) {
-    return (reason
-        .toLowerCase()
-        .replace(/[^a-z0-9_-]+/gu, "-")
-        .replace(/^-+|-+$/gu, "")
-        .slice(0, 60) || "unspecified");
-}

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

@@ -1,10 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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/worktree-manager.d.ts

@@ -1,50 +0,0 @@
-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[]>;