@kynver-app/runtime 0.1.17 → 0.1.19

package/dist/cli.js

@@ -16,6 +16,10 @@ function fail(message) {
   console.error(message);
   process.exit(1);
 }
+function hiddenSpawnOptions(opts) {
+  if (process.platform !== "win32") return opts;
+  return { windowsHide: true, ...opts };
+}
 function required(value, name) {
   if (!value) fail(`missing ${name}`);
   return value;
@@ -392,12 +396,12 @@ var DEFAULT_CRITICAL_FREE_BYTES = 15 * 1024 * 1024 * 1024;
 var DEFAULT_MAX_USED_PERCENT = 80;
 var DEFAULT_HARD_MAX_USED_PERCENT = 90;
 function observeRunnerDiskGate(input = {}) {
-  const path16 = input.diskPath?.trim() || "/";
+  const path17 = input.diskPath?.trim() || "/";
   const warnBelowBytes = input.diskFreeWarnBytes ?? DEFAULT_WARN_FREE_BYTES;
   const criticalBelowBytes = input.diskFreeCriticalBytes ?? DEFAULT_CRITICAL_FREE_BYTES;
   const maxUsedPercent = input.diskMaxUsedPercent ?? DEFAULT_MAX_USED_PERCENT;
   const hardMaxUsedPercent = input.diskHardMaxUsedPercent ?? DEFAULT_HARD_MAX_USED_PERCENT;
-  const stats = statfsSync(path16);
+  const stats = statfsSync(path17);
   const freeBytes = Number(stats.bavail) * Number(stats.bsize);
   const totalBytes = Number(stats.blocks) * Number(stats.bsize);
   const usedPercent = totalBytes > 0 ? (totalBytes - freeBytes) / totalBytes * 100 : 100;
@@ -417,7 +421,7 @@ function observeRunnerDiskGate(input = {}) {
   }
   return {
     ok,
-    path: path16,
+    path: path17,
     freeBytes,
     totalBytes,
     usedPercent,
@@ -604,6 +608,52 @@ function summarizeEvent(event) {
   return void 0;
 }
 
+// src/exit-classify.ts
+var FAILURE_PATTERNS = [
+  {
+    test: /\b(?:invalid|unknown|unsupported|unrecognized)\b[^.\n]*\bmodel\b/i,
+    label: "provider rejected the requested model"
+  },
+  {
+    test: /\bmodel\b[^.\n]*\b(?:not\s+(?:found|supported|available|recognized|valid)|is\s+not\s+valid|does\s+not\s+exist)/i,
+    label: "provider rejected the requested model"
+  },
+  {
+    test: /\b(?:did you mean|available models|choose (?:a|one of)|supported models)\b/i,
+    label: "provider rejected the requested model"
+  },
+  {
+    test: /model preflight failed/i,
+    label: "model/provider preflight failed"
+  },
+  {
+    test: /\b(?:command not found|ENOENT|is the .*CLI on PATH|executable not found|no such file or directory)\b/i,
+    label: "provider CLI is missing or not on PATH"
+  },
+  {
+    test: /\bfailed to spawn\b/i,
+    label: "provider failed to spawn the worker process"
+  },
+  {
+    test: /\b(?:not logged in|unauthorized|authentication (?:failed|required)|invalid api key|missing api key|401)\b/i,
+    label: "provider authentication failed"
+  }
+];
+function tidy(errorText, max = 240) {
+  const oneLine2 = errorText.replace(/\s+/g, " ").trim();
+  return oneLine2.length > max ? `${oneLine2.slice(0, max - 1)}\u2026` : oneLine2;
+}
+function classifyExitFailure(errorText) {
+  const text = (errorText ?? "").trim();
+  if (!text) return null;
+  for (const pattern of FAILURE_PATTERNS) {
+    if (pattern.test.test(text)) {
+      return { blocked: true, reason: `${pattern.label}: ${tidy(text)}` };
+    }
+  }
+  return null;
+}
+
 // src/git.ts
 import { spawnSync } from "node:child_process";
 function git(cwd, args, options = {}) {
@@ -719,7 +769,15 @@ var STALE_MS = 6e5;
 function computeAttention(input) {
   const now = Date.now();
   if (input.finalResult) return { state: "done", reason: "final result recorded" };
-  if (!input.alive) return { state: "needs_attention", reason: "process exited without a final result" };
+  if (!input.alive) {
+    const classified = classifyExitFailure(input.error);
+    if (classified) return { state: "blocked", reason: classified.reason };
+    const tail = input.error?.trim();
+    return {
+      state: "needs_attention",
+      reason: tail ? `process exited without a final result: ${tail}` : "process exited without a final result"
+    };
+  }
   if (input.heartbeatBlocker) {
     return { state: "blocked", reason: `worker heartbeat reported blocker: ${input.heartbeatBlocker}` };
   }
@@ -749,6 +807,7 @@ function computeWorkerStatus(worker, options = {}) {
     fileMtime(worker.stderrPath),
     fileMtime(worker.heartbeatPath)
   ]);
+  const error = parsed.error || (!alive && !parsed.finalResult ? tailFile(worker.stderrPath, 10).trim() || void 0 : void 0);
   const attention = computeAttention({
     alive,
     finalResult: parsed.finalResult,
@@ -757,7 +816,8 @@ function computeWorkerStatus(worker, options = {}) {
     heartbeatBytes,
     lastActivityAt,
     heartbeatBlocker: heartbeat.heartbeatBlocker,
-    startedAt: worker.startedAt
+    startedAt: worker.startedAt,
+    error
   });
   return {
     runId: worker.runId,
@@ -782,7 +842,7 @@ function computeWorkerStatus(worker, options = {}) {
     lastHeartbeatSummary: heartbeat.lastHeartbeatSummary,
     heartbeatBlocker: heartbeat.heartbeatBlocker,
     finalResult: parsed.finalResult,
-    error: parsed.error || (!alive && !parsed.finalResult ? tailFile(worker.stderrPath, 10).trim() || void 0 : void 0),
+    error,
     changedFiles,
     gitAncestry
   };
@@ -907,8 +967,8 @@ function observeRunnerResourceGate(input) {
 }
 
 // src/supervisor.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync3 } from "node:fs";
-import path9 from "node:path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync3 } from "node:fs";
+import path10 from "node:path";
 
 // src/prompt.ts
 function buildPrompt(input) {
@@ -942,10 +1002,74 @@ function buildPrompt(input) {
 // src/providers/claude.ts
 import { closeSync, openSync } from "node:fs";
 import { spawn } from "node:child_process";
+
+// src/providers/model-preflight.ts
+var REASONING_SUFFIX_RE = /-(?:thinking(?:-(?:high|medium|low|minimal|max|none))?|high|medium|low|minimal)$/i;
+function stripReasoningSuffix(model) {
+  return model.replace(REASONING_SUFFIX_RE, "");
+}
+var FOREIGN_MODEL_RE = /^(?:gpt-|gpt5|o1|o3|o4|gemini-|grok-|composer|deepseek|llama|mistral|qwen|command-)/i;
+function looksLikeClaudeModel(model) {
+  return /^claude[-_]/i.test(model) || /^(?:opus|sonnet|haiku)\b/i.test(model);
+}
+function preflightClaudeModel(model, defaultModel) {
+  const requested = (model ?? "").trim();
+  if (!requested) {
+    return { ok: true, model: defaultModel, normalized: false };
+  }
+  const stripped = stripReasoningSuffix(requested).trim();
+  const launch = stripped || defaultModel;
+  if (FOREIGN_MODEL_RE.test(launch) || !looksLikeClaudeModel(launch) && launch !== defaultModel) {
+    return {
+      ok: false,
+      model: requested,
+      normalized: false,
+      requested,
+      note: `model "${requested}" is not a Claude model \u2014 the "claude" provider drives the Claude CLI, which only accepts claude-* model ids (got "${launch}"). Pick a Claude model or switch the worker provider.`
+    };
+  }
+  if (launch !== requested) {
+    return {
+      ok: true,
+      model: launch,
+      normalized: true,
+      requested,
+      note: `normalized model "${requested}" \u2192 "${launch}" (the Claude CLI rejects reasoning-effort suffixes)`
+    };
+  }
+  return { ok: true, model: launch, normalized: false };
+}
+function preflightCursorModel(model, defaultModel) {
+  const requested = (model ?? "").trim();
+  if (!requested) {
+    return { ok: true, model: defaultModel, normalized: false };
+  }
+  if (looksLikeClaudeModel(requested)) {
+    return {
+      ok: false,
+      model: requested,
+      normalized: false,
+      requested,
+      note: `model "${requested}" is a Claude model but the worker provider is "cursor". Switch the provider to "claude" or pick a Cursor model.`
+    };
+  }
+  return { ok: true, model: requested, normalized: false };
+}
+
+// src/providers/claude.ts
+var CLAUDE_DEFAULT_MODEL = "claude-opus-4-7";
 var claudeProvider = {
   name: "claude",
+  defaultModel: CLAUDE_DEFAULT_MODEL,
+  preflightModel(model) {
+    return preflightClaudeModel(model, CLAUDE_DEFAULT_MODEL);
+  },
   start(opts) {
-    const model = opts.model || "claude-opus-4-7";
+    const preflight = preflightClaudeModel(opts.model, CLAUDE_DEFAULT_MODEL);
+    if (!preflight.ok) {
+      throw new Error(`claude provider model preflight failed: ${preflight.note}`);
+    }
+    const model = preflight.model;
     const stdoutFd = openSync(opts.stdoutPath, "a");
     const stderrFd = openSync(opts.stderrPath, "a");
     const child = spawn(
@@ -962,12 +1086,12 @@ var claudeProvider = {
         "--include-partial-messages",
         opts.prompt
       ],
-      {
+      hiddenSpawnOptions({
         cwd: opts.worktreePath,
         detached: true,
         stdio: ["ignore", stdoutFd, stderrFd],
         env: scrubClaudeEnv(process.env)
-      }
+      })
     );
     closeSync(stdoutFd);
     closeSync(stderrFd);
@@ -980,33 +1104,80 @@ var claudeProvider = {
 };
 
 // src/providers/cursor.ts
-import { closeSync as closeSync2, existsSync as existsSync7, openSync as openSync2, readdirSync as readdirSync3 } from "node:fs";
+import { closeSync as closeSync2, existsSync as existsSync8, openSync as openSync2 } from "node:fs";
 import { spawn as spawn2 } from "node:child_process";
+import path7 from "node:path";
+
+// src/providers/cursor-windows.ts
+import { existsSync as existsSync7, readdirSync as readdirSync3 } from "node:fs";
 import path6 from "node:path";
-var DEFAULT_CURSOR_MODEL = "composer-2.5";
-function latestVersionDir(versionsRoot) {
+var CURSOR_VERSION_DIR = /^\d{4}\.\d{1,2}\.\d{1,2}-[a-f0-9]+$/i;
+function parseCursorVersionSortKey(versionName) {
+  const datePart = versionName.split("-")[0];
+  const parts = datePart.split(".");
+  if (parts.length !== 3) return null;
+  const [year, month, day] = parts;
+  if (!year || !month || !day) return null;
+  return Number(`${year}${month.padStart(2, "0")}${day.padStart(2, "0")}`);
+}
+function pickLatestCursorVersionDir(agentRoot) {
+  const versionsRoot = path6.join(agentRoot, "versions");
   if (!existsSync7(versionsRoot)) return null;
-  const versions = readdirSync3(versionsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory() && /^\d{4}\.\d/.test(entry.name)).map((entry) => entry.name).sort((a, b) => b.localeCompare(a));
-  return versions[0] ? path6.join(versionsRoot, versions[0]) : null;
-}
-function resolveBundledCursor(versionDir) {
+  let bestDir = null;
+  let bestKey = -1;
+  for (const entry of readdirSync3(versionsRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !CURSOR_VERSION_DIR.test(entry.name)) continue;
+    const key = parseCursorVersionSortKey(entry.name);
+    if (key == null || key <= bestKey) continue;
+    bestKey = key;
+    bestDir = path6.join(versionsRoot, entry.name);
+  }
+  return bestDir;
+}
+function resolveWindowsCursorBundled(agentRoot) {
+  const root = agentRoot?.trim() || path6.join(process.env.LOCALAPPDATA || "", "cursor-agent");
+  const directNode = path6.join(root, "node.exe");
+  const directIndex = path6.join(root, "index.js");
+  if (existsSync7(directNode) && existsSync7(directIndex)) {
+    return { nodeExe: directNode, indexJs: directIndex, versionDir: root };
+  }
+  const versionDir = pickLatestCursorVersionDir(root);
+  if (!versionDir) return null;
   const nodeExe = path6.join(versionDir, "node.exe");
   const indexJs = path6.join(versionDir, "index.js");
   if (!existsSync7(nodeExe) || !existsSync7(indexJs)) return null;
-  return { executable: nodeExe, prefixArgs: [indexJs], shell: false, detached: true };
+  return { nodeExe, indexJs, versionDir };
 }
-function resolveWindowsCursorSpawn(agentBin) {
-  const agentRoot = path6.dirname(agentBin);
-  const direct = resolveBundledCursor(agentRoot);
-  if (direct) return direct;
-  const versionDir = latestVersionDir(path6.join(agentRoot, "versions"));
-  return versionDir ? resolveBundledCursor(versionDir) : null;
+
+// src/providers/cursor.ts
+var DEFAULT_CURSOR_MODEL = "composer-2.5";
+function bundledSpawnTarget(nodeExe, indexJs, versionDir) {
+  return {
+    executable: nodeExe,
+    prefixArgs: [indexJs],
+    shell: false,
+    detached: true,
+    bundledVersionDir: versionDir
+  };
 }
 function resolveCursorSpawn(agentBin) {
-  if (process.platform === "win32" && /\.(cmd|bat)$/i.test(agentBin)) {
-    const bundled = resolveWindowsCursorSpawn(agentBin);
-    if (bundled) return bundled;
-    return { executable: agentBin, prefixArgs: [], shell: true, detached: false };
+  if (process.platform === "win32") {
+    const isCursorWrapper = /\.(cmd|bat)$/i.test(agentBin);
+    const isBundledNode = /node\.exe$/i.test(agentBin) && existsSync8(path7.join(path7.dirname(agentBin), "index.js"));
+    const isDefaultShim = agentBin === "agent";
+    if (isCursorWrapper || isBundledNode || isDefaultShim) {
+      const bundled = isCursorWrapper ? resolveWindowsCursorBundled(path7.dirname(agentBin)) : isBundledNode ? {
+        nodeExe: agentBin,
+        indexJs: path7.join(path7.dirname(agentBin), "index.js"),
+        versionDir: path7.dirname(agentBin)
+      } : resolveWindowsCursorBundled();
+      if (bundled) {
+        return bundledSpawnTarget(bundled.nodeExe, bundled.indexJs, bundled.versionDir);
+      }
+      throw new Error(
+        "Cursor Agent on Windows has no headless bundled node.exe under %LOCALAPPDATA%\\cursor-agent\\versions\\\u2026. Run `agent login` / update Cursor Agent CLI, use `--provider claude`, or set KYNVER_CURSOR_AGENT_ROOT to the cursor-agent folder."
+      );
+    }
   }
   return { executable: agentBin, prefixArgs: [], shell: false, detached: true };
 }
@@ -1014,15 +1185,35 @@ function resolveAgentBin() {
   const configured = process.env.KYNVER_CURSOR_AGENT_BIN?.trim() || process.env.CURSOR_AGENT_BIN?.trim();
   if (configured) return configured;
   if (process.platform === "win32") {
-    const localAgent = path6.join(process.env.LOCALAPPDATA || "", "cursor-agent", "agent.cmd");
-    if (existsSync7(localAgent)) return localAgent;
+    const bundled = resolveWindowsCursorBundled(
+      process.env.KYNVER_CURSOR_AGENT_ROOT?.trim() || void 0
+    );
+    if (bundled) return bundled.nodeExe;
+    const localAgent = path7.join(process.env.LOCALAPPDATA || "", "cursor-agent", "agent.cmd");
+    if (existsSync8(localAgent)) return localAgent;
   }
   return "agent";
 }
+function cursorWorkerEnv(agentBin, spawnTarget) {
+  return {
+    ...process.env,
+    CI: "1",
+    NO_COLOR: "1",
+    ...spawnTarget.bundledVersionDir ? { CURSOR_INVOKED_AS: path7.basename(agentBin) || "agent.cmd" } : {}
+  };
+}
 var cursorProvider = {
   name: "cursor",
+  defaultModel: DEFAULT_CURSOR_MODEL,
+  preflightModel(model) {
+    return preflightCursorModel(model, DEFAULT_CURSOR_MODEL);
+  },
   start(opts) {
-    const model = opts.model || DEFAULT_CURSOR_MODEL;
+    const preflight = preflightCursorModel(opts.model, DEFAULT_CURSOR_MODEL);
+    if (!preflight.ok) {
+      throw new Error(`cursor provider model preflight failed: ${preflight.note}`);
+    }
+    const model = preflight.model;
     const stdoutFd = openSync2(opts.stdoutPath, "a");
     const stderrFd = openSync2(opts.stderrPath, "a");
     const agentBin = resolveAgentBin();
@@ -1043,16 +1234,13 @@ var cursorProvider = {
         model,
         opts.prompt
       ],
-      {
+      hiddenSpawnOptions({
         cwd: opts.worktreePath,
         detached: spawnTarget.detached,
         shell: spawnTarget.shell,
         stdio: ["ignore", stdoutFd, stderrFd],
-        env: {
-          ...process.env,
-          ...spawnTarget.prefixArgs.length > 0 ? { CURSOR_INVOKED_AS: path6.basename(agentBin) } : {}
-        }
-      }
+        env: cursorWorkerEnv(agentBin, spawnTarget)
+      })
     );
     closeSync2(stdoutFd);
     closeSync2(stderrFd);
@@ -1084,12 +1272,12 @@ function resolveWorkerProvider(name) {
 
 // src/auto-complete.ts
 import { spawn as spawn3 } from "node:child_process";
-import { existsSync as existsSync8, openSync as openSync3, closeSync as closeSync3 } from "node:fs";
-import path8 from "node:path";
+import { existsSync as existsSync9, openSync as openSync3, closeSync as closeSync3 } from "node:fs";
+import path9 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/worker-ops.ts
-import path7 from "node:path";
+import path8 from "node:path";
 async function postCompletion(url, secret, body) {
   const res = await fetch(url, {
     method: "POST",
@@ -1212,7 +1400,7 @@ async function completeWorker(args) {
 function workerStatus(args) {
   const worker = loadWorker(String(args.run), String(args.name));
   const status = computeWorkerStatus(worker);
-  writeJson(path7.join(worker.workerDir, "last-status.json"), status);
+  writeJson(path8.join(worker.workerDir, "last-status.json"), status);
   console.log(JSON.stringify(status, null, 2));
 }
 function runStatus(args) {
@@ -1220,7 +1408,7 @@ function runStatus(args) {
   const names = Object.keys(run.workers || {});
   const workers = names.map((name) => {
     const worker = readJson(
-      path7.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path8.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker) {
@@ -1256,7 +1444,7 @@ function runStatus(args) {
     needsAttention: workers.filter((w) => w.attention && w.attention !== "ok" && w.attention !== "done").map((w) => w.worker),
     workers
   };
-  writeJson(path7.join(runDirectory(run.id), "last-board.json"), board);
+  writeJson(path8.join(runDirectory(run.id), "last-board.json"), board);
   console.log(JSON.stringify(board, null, 2));
 }
 function tailWorker(args) {
@@ -1395,12 +1583,12 @@ async function autoCompleteWorkerCli(raw) {
   }
 }
 function resolveDefaultCliPath() {
-  return path8.join(fileURLToPath(new URL(".", import.meta.url)), "cli.js");
+  return path9.join(fileURLToPath(new URL(".", import.meta.url)), "cli.js");
 }
 function spawnCompletionSidecar(opts) {
   const cliPath = opts.cliPath ?? resolveDefaultCliPath();
-  if (!existsSync8(cliPath)) return void 0;
-  const logPath = path8.join(opts.workerDir, "auto-complete.log");
+  if (!existsSync9(cliPath)) return void 0;
+  const logPath = path9.join(opts.workerDir, "auto-complete.log");
   let logFd;
   try {
     logFd = openSync3(logPath, "a");
@@ -1426,11 +1614,15 @@ function spawnCompletionSidecar(opts) {
   if (opts.baseUrl) args.push("--base-url", opts.baseUrl);
   if (opts.secret) args.push("--secret", opts.secret);
   try {
-    const child = spawn3(nodeExecutable, args, {
-      detached: true,
-      stdio,
-      env: process.env
-    });
+    const child = spawn3(
+      nodeExecutable,
+      args,
+      hiddenSpawnOptions({
+        detached: true,
+        stdio,
+        env: process.env
+      })
+    );
     if (logFd !== void 0) closeSync3(logFd);
     child.unref();
     return { pid: child.pid, logPath, cliPath };
@@ -1454,31 +1646,44 @@ function spawnWorkerProcess(run, opts) {
   const name = safeSlug(rawName);
   if (run.workers?.[name]) throw new Error(`worker already exists in run ${run.id}: ${name}`);
   if (!opts.task) throw new Error(`missing task text for worker ${name}`);
+  const provider = resolveWorkerProvider(opts.provider);
+  let launchModel = opts.model;
+  if (provider.preflightModel) {
+    const preflight = provider.preflightModel(opts.model);
+    if (!preflight.ok) {
+      throw new Error(
+        `model preflight failed for provider "${provider.name}": ${preflight.note ?? "invalid model/provider combination"}`
+      );
+    }
+    if (preflight.normalized) {
+      console.error(`[supervisor] ${name}: ${preflight.note}`);
+    }
+    launchModel = preflight.model;
+  }
   const { worktreesDir } = getPaths();
-  const workerDir = path9.join(runDirectory(run.id), "workers", name);
+  const workerDir = path10.join(runDirectory(run.id), "workers", name);
   mkdirSync3(workerDir, { recursive: true });
-  const worktreePath = path9.join(worktreesDir, run.id, name);
+  const worktreePath = path10.join(worktreesDir, run.id, name);
   const branch = opts.branch || `agent/${run.id}/${name}`;
-  if (existsSync9(worktreePath)) throw new Error(`worktree path already exists: ${worktreePath}`);
+  if (existsSync10(worktreePath)) throw new Error(`worktree path already exists: ${worktreePath}`);
   git(run.repo, ["fetch", "origin", "--prune"], { allowFailure: true });
   git(run.repo, ["worktree", "add", "-b", branch, worktreePath, run.baseCommit], { throwError: true });
-  const stdoutPath = path9.join(workerDir, "stdout.jsonl");
-  const stderrPath = path9.join(workerDir, "stderr.log");
-  const heartbeatPath = path9.join(workerDir, "heartbeat.jsonl");
+  const stdoutPath = path10.join(workerDir, "stdout.jsonl");
+  const stderrPath = path10.join(workerDir, "stderr.log");
+  const heartbeatPath = path10.join(workerDir, "heartbeat.jsonl");
   const prompt = buildPrompt({
     task: opts.task,
     ownedPaths: opts.ownedPaths || [],
     worktreePath,
     heartbeatPath
   });
-  const provider = resolveWorkerProvider(opts.provider);
   let started;
   try {
     started = provider.start({
       name,
       task: opts.task,
       ownedPaths: opts.ownedPaths,
-      model: opts.model,
+      model: launchModel,
       branch,
       worktreePath,
       workerDir,
@@ -1492,7 +1697,7 @@ function spawnWorkerProcess(run, opts) {
     git(run.repo, ["branch", "-D", branch], { allowFailure: true });
     throw error;
   }
-  const model = started.model || opts.model || "claude-opus-4-7";
+  const model = started.model || launchModel || provider.defaultModel || "claude-opus-4-7";
   const worker = {
     name,
     runId: run.id,
@@ -1514,7 +1719,7 @@ function spawnWorkerProcess(run, opts) {
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   saveWorker(run.id, worker);
-  run.workers = { ...run.workers || {}, [name]: { workerDir, statusPath: path9.join(workerDir, "worker.json") } };
+  run.workers = { ...run.workers || {}, [name]: { workerDir, statusPath: path10.join(workerDir, "worker.json") } };
   run.status = "running";
   saveRun(run);
   if (worker.agentOsId && worker.taskId) {
@@ -1728,7 +1933,7 @@ async function dispatchRun(args) {
 }
 
 // src/sweep.ts
-import path10 from "node:path";
+import path11 from "node:path";
 async function sweepRun(args) {
   const pipeline = args.pipeline === true || args.pipeline === "true";
   try {
@@ -1740,7 +1945,7 @@ async function sweepRun(args) {
     const releasedLocalOrphans = [];
     for (const name of Object.keys(run.workers || {})) {
       const worker = readJson(
-        path10.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+        path11.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
         void 0
       );
       if (!worker || !worker.dispatched || !worker.taskId) continue;
@@ -1783,11 +1988,11 @@ async function sweepRun(args) {
 }
 
 // src/worktree.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync4 } from "node:fs";
-import path12 from "node:path";
+import { existsSync as existsSync11, mkdirSync as mkdirSync4 } from "node:fs";
+import path13 from "node:path";
 
 // src/validate.ts
-import path11 from "node:path";
+import path12 from "node:path";
 var RUN_ID_RE = /^[a-z0-9][a-z0-9._-]{0,127}$/i;
 function validateRunId(runId) {
   const trimmed = runId.trim();
@@ -1795,7 +2000,7 @@ function validateRunId(runId) {
   return trimmed;
 }
 function validateRepo(repo) {
-  const resolved = path11.resolve(repo);
+  const resolved = path12.resolve(repo);
   if (resolved.includes("..")) throw new Error("repo path must not contain .. segments");
   return resolved;
 }
@@ -1806,7 +2011,7 @@ function createRun(args) {
   ensureGitRepo(repo);
   const id = args.id ? validateRunId(String(args.id)) : timestampSlug(String(args.name || "run"));
   const dir = runDirectory(id);
-  if (existsSync10(dir)) failExists(`run already exists: ${id}`);
+  if (existsSync11(dir)) failExists(`run already exists: ${id}`);
   mkdirSync4(dir, { recursive: true });
   const base = String(args.base || "origin/main");
   const baseCommit = git(repo, ["rev-parse", base]).trim();
@@ -1820,12 +2025,12 @@ function createRun(args) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString(),
     workers: {}
   };
-  writeJson(path12.join(dir, "run.json"), run);
+  writeJson(path13.join(dir, "run.json"), run);
   console.log(JSON.stringify({ runId: id, runDir: dir, repo, base, baseCommit }, null, 2));
 }
 function listRuns() {
   const { runsDir } = getPaths();
-  const rows = listRunIds(runsDir).map((id) => readJson(path12.join(runDirectory(id), "run.json"), void 0)).filter(Boolean).map((run) => ({
+  const rows = listRunIds(runsDir).map((id) => readJson(path13.join(runDirectory(id), "run.json"), void 0)).filter(Boolean).map((run) => ({
     id: run.id,
     name: run.name,
     status: run.status,
@@ -1840,10 +2045,10 @@ function failExists(message) {
 }
 
 // src/pipeline-tick.ts
-import path15 from "node:path";
+import path16 from "node:path";
 
 // src/finalize.ts
-import path13 from "node:path";
+import path14 from "node:path";
 var ACTIVE_RUN_STATUSES = /* @__PURE__ */ new Set(["running", "dispatching", "pending", "queued"]);
 function terminalStatusFor(run) {
   const names = Object.keys(run.workers || {});
@@ -1853,7 +2058,7 @@ function terminalStatusFor(run) {
   let anyCompletionBlocked = false;
   for (const name of names) {
     const worker = readJson(
-      path13.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path14.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker) continue;
@@ -1886,7 +2091,7 @@ function finalizeStaleRuns() {
 }
 
 // src/plan-progress-daemon-sync.ts
-import path14 from "node:path";
+import path15 from "node:path";
 
 // src/plan-progress-sync.ts
 async function syncPlanProgress(args) {
@@ -1910,7 +2115,7 @@ async function syncActiveWorkerPlanProgress(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path14.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path15.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.dispatched || !worker.taskId) continue;
@@ -1964,7 +2169,7 @@ async function completeFinishedWorkers(runId, args) {
   const outcomes = [];
   for (const name of Object.keys(run.workers || {})) {
     const worker = readJson(
-      path15.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
+      path16.join(runDirectory(run.id), "workers", safeSlug(name), "worker.json"),
       void 0
     );
     if (!worker?.taskId) continue;