@brainervirus/workit-claude-code 8.44.0 → 8.44.2

package/dist/workit.js

@@ -9431,7 +9431,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@brainervirus/workit-cli",
-    version: "8.44.0",
+    version: "8.44.2",
     private: false,
     description: "Workit CLI — setup wizard, doctor, and task control for agentic coding workflows",
     keywords: [
@@ -9469,13 +9469,13 @@ var init_package = __esm(() => {
     },
     dependencies: {
       "@babel/parser": "7.29.9",
-      "@brainervirus/workit-cursor": "^8.44.0",
+      "@brainervirus/workit-cursor": "^8.44.2",
       "@inkjs/ui": "2.0.0",
       ink: "7.1.1",
       react: "19.2.8"
     },
     devDependencies: {
-      "@brainervirus/workit-core": "^8.44.0"
+      "@brainervirus/workit-core": "^8.44.2"
     },
     engines: {
       node: ">=24"
@@ -68214,7 +68214,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
       found.push({ pid: Number(m[1]), startedMs, args: m[3] });
   }
   return found;
-}, listClaudeProcesses = () => listProcessesMatching((args) => /^(\S*\/)?claude(\s|$)/.test(args)), listCodexProcesses = () => listProcessesMatching((args) => /^(\S*\/)?codex(\.js)?(\s|$)|^(\S*\/)?node(js)?\s+(\S+\s+)*?\S*\/codex(\.js)?(\s|$)/.test(args) && !/\bdaemon\s+pid-update-loop\b/.test(args)), resolve = (options) => {
+}, PS_START_SLACK_MS = 2000, startedBefore = (proc, installedMs) => proc.startedMs + PS_START_SLACK_MS < installedMs, listClaudeProcesses = () => listProcessesMatching((args) => /^(\S*\/)?claude(\s|$)/.test(args)), listCodexProcesses = () => listProcessesMatching((args) => /^(\S*\/)?codex(\.js)?(\s|$)|^(\S*\/)?node(js)?\s+(\S+\s+)*?\S*\/codex(\.js)?(\s|$)/.test(args) && !/\bdaemon\s+pid-update-loop\b/.test(args)), resolve = (options) => {
   const env = options.env ?? process.env;
   const home = options.home ?? env.HOME ?? os13.homedir();
   const configDir = options.configDir ?? env.WORKFLOW_TOOLKIT_CONFIG ?? env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path40.join(home, ".config", "workit");
@@ -68230,7 +68230,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     cwd,
     workspaceRoot: options.workspaceRoot ?? env.WORKFLOW_WORKSPACE_ROOT ?? cwd,
     dev,
-    opencodeConfig: options.opencodeConfig ?? path40.join(home, ".config", "opencode", "opencode.json"),
+    opencodeConfig: options.opencodeConfig ?? path40.join(env.XDG_CONFIG_HOME || path40.join(home, ".config"), "opencode", "opencode.json"),
     opencodePackageCacheDir: options.opencodePackageCacheDir ?? null,
     cursorSettings: options.cursorSettings ?? path40.join(home, ".cursor", "settings.json"),
     cursorMcp: options.cursorMcp ?? path40.join(home, ".cursor", "mcp.json"),
@@ -69369,9 +69369,25 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     detail: `OpenCode @latest cache workit-opencode ${installed} matches published ${expected}`
   };
 }, checkStaleInstall = (res) => {
-  if (res.host === "opencode") {
+  if (res.host === "opencode")
     return checkOpenCodePackageCache(res);
-  }
+  const cursor = checkCursorStaleInstall(res);
+  if (res.host !== "cli")
+    return cursor;
+  const oc = checkOpenCodePackageCache(res);
+  if (oc.status === "pass")
+    return cursor;
+  if (cursor.status === "pass")
+    return oc;
+  if (oc.id !== "stale_install")
+    return cursor;
+  return {
+    ...cursor,
+    registryProbed: Boolean(cursor.registryProbed || oc.registryProbed),
+    detail: `${cursor.detail}; ${oc.detail}`,
+    fix: [cursor.fix, oc.fix].filter(Boolean).join("; ")
+  };
+}, checkCursorStaleInstall = (res) => {
   if (res.host !== "cursor" && res.host !== "cli") {
     return {
       id: "stale_install",
@@ -69479,11 +69495,6 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
       registryProbed: true,
       detail: `installed local-dist workit-cursor ${installed} matches the published runtime ${expected}`
     };
-    if (res.host === "cli") {
-      const oc = checkOpenCodePackageCache(res);
-      if (oc.status !== "pass")
-        return oc;
-    }
     return cursorOk;
   }
   const cursorOk = {
@@ -69491,11 +69502,6 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     status: "pass",
     detail: installed === null ? "installed workit-cursor selectors are canonical" : `installed workit-cursor ${installed} on canonical selectors (hooks run this version through the pinned launcher; MCP resolves @latest at launch)`
   };
-  if (res.host === "cli") {
-    const oc = checkOpenCodePackageCache(res);
-    if (oc.status !== "pass")
-      return oc;
-  }
   return cursorOk;
 }, checkDuplicateRegistration = (res) => {
   const problems = [];
@@ -70223,7 +70229,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
       status: "info",
       detail: "could not list running claude processes (ps) — skipping"
     };
-  const stale = running.filter((proc) => proc.startedMs < latest.at);
+  const stale = running.filter((proc) => startedBefore(proc, latest.at));
   if (stale.length === 0)
     return {
       id,
@@ -70271,7 +70277,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
       status: "info",
       detail: "could not list running codex processes (ps) — skipping"
     };
-  const stale = running.filter((proc) => proc.startedMs < latest.at);
+  const stale = running.filter((proc) => startedBefore(proc, latest.at));
   if (stale.length === 0)
     return {
       id,
@@ -75769,9 +75775,13 @@ import { createHash as createHash15 } from "node:crypto";
 function errorText(error) {
   return error instanceof Error ? error.message : "installed source could not be read";
 }
-var LAUNCH_HOSTS, HOSTS2, LIVE_HOSTS, OPENCODE_PACKAGE = "@brainervirus/workit-opencode", OPENCODE_UPDATE, CODEX_MARKETPLACE = "workflow-toolkit", CLI_FIX = "npm install --global @brainervirus/workit-cli@latest", stderrTail = (text, lines = 5) => (text ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(-lines).join(" | "), failureReason = (command, result) => {
+var LAUNCH_HOSTS, HOSTS2, LIVE_HOSTS, OPENCODE_PACKAGE = "@brainervirus/workit-opencode", OPENCODE_UPDATE, CODEX_MARKETPLACE = "workflow-toolkit", CLI_FIX = "npm install --global @brainervirus/workit-cli@latest", stderrTail = (text, lines = 5) => (text ?? "").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).slice(-lines).join(" | "), errorLine = (result) => `${result.stdout}
+${result.stderr ?? ""}`.split(/\r?\n/).map((line) => line.trim()).find((line) => /\bError:/.test(line)), failureReason = (command, result) => {
   const tail = stderrTail(result.stderr);
-  return `\`${command.command} ${command.args.join(" ")}\` failed${tail ? `: ${tail}` : ""}`;
+  const message = errorLine(result);
+  const detail = message && !tail.includes(message) ? [message, tail].filter(Boolean) : [tail];
+  const text = detail.filter(Boolean).join(" | ");
+  return `\`${command.command} ${command.args.join(" ")}\` failed${text ? `: ${text}` : ""}`;
 }, fixFor = (host, selector = "") => host === "pi" ? `pi update --extension ${selector || "npm:@brainervirus/workit-pi"}` : host === "codex" ? `codex plugin marketplace upgrade ${CODEX_MARKETPLACE} && codex plugin add workit@${CODEX_MARKETPLACE}` : host === "claude-code" ? "claude plugin marketplace update workit && claude plugin update workit@workit" : host === "opencode" ? OPENCODE_UPDATE : host === "cursor" ? "workit upgrade --hosts=cursor" : CLI_FIX, upgradePaths = (deps) => {
   const home = deps.home ?? deps.env?.HOME ?? os17.homedir();
   const env = {
@@ -75818,27 +75828,27 @@ var LAUNCH_HOSTS, HOSTS2, LIVE_HOSTS, OPENCODE_PACKAGE = "@brainervirus/workit-o
   } catch {
     return null;
   }
-}, digest2 = (file) => existsSync21(file) ? createHash15("sha256").update(readFileSync23(file)).digest("hex") : "missing", runner = (deps) => deps.run ?? ((command, args) => {
+}, digest2 = (file) => existsSync21(file) ? createHash15("sha256").update(readFileSync23(file)).digest("hex") : "missing", runner = (deps) => deps.run ?? ((command, args, options) => {
   const { home, env } = upgradePaths(deps);
   let step;
   try {
-    step = hostCommand(command, args, { home, env });
+    step = hostCommand(command, args, { home, env, cwd: options?.cwd });
   } catch (error) {
     return { status: 1, stdout: "", stderr: errorText(error) };
   }
   const result = runHostCommand(step, { home, env });
   return { status: result.exitCode, stdout: result.stdout, stderr: result.stderr };
-}), COMMAND_TIMEOUT_MS = 60000, asyncRunner = (deps) => {
+}), COMMAND_TIMEOUT_MS = 60000, asyncRunner = (deps, timeoutMs = COMMAND_TIMEOUT_MS) => {
   if (deps.runAsync)
     return deps.runAsync;
   const injected = deps.run;
   if (injected)
-    return async (command, args) => injected(command, args);
-  return (command, args) => {
+    return async (command, args, options) => injected(command, args, options);
+  return (command, args, options) => {
     const { home, env } = upgradePaths(deps);
     let step;
     try {
-      step = hostCommand(command, args, { home, env });
+      step = hostCommand(command, args, { home, env, cwd: options?.cwd });
     } catch (error) {
       return Promise.resolve({ status: 1, stdout: "", stderr: errorText(error) });
     }
@@ -75880,7 +75890,7 @@ var LAUNCH_HOSTS, HOSTS2, LIVE_HOSTS, OPENCODE_PACKAGE = "@brainervirus/workit-o
       const timer = setTimeout(() => {
         child.kill("SIGKILL");
         finish(1);
-      }, COMMAND_TIMEOUT_MS);
+      }, timeoutMs);
       child.stdout?.setEncoding("utf8");
       child.stdout?.on("data", (chunk) => stdout += chunk);
       child.stderr?.setEncoding("utf8");
@@ -75978,11 +75988,95 @@ var init_processes = __esm(() => {
   SCRIPT_RUNTIMES = new Set(["node", "nodejs", "bun"]);
 });
 
+// packages/workit-cli/src/upgrade/opencode.ts
+var pluginApiArgs = (home) => [
+  "api",
+  "plugin.list",
+  "-H",
+  `x-opencode-directory:${home}`
+], PLUGIN_LIST, OPENCODE_READY_TIMEOUT_MS = 20000, READY_INTERVAL_MS = 500, OPENCODE_NOT_READY, isWorkitTarget = (target) => typeof target === "string" && /^(?:npm:)?@brainervirus\/workit-opencode(?:@[^/\s]+)?$/.test(target), lacksApi = (result) => result.status !== 0 && !result.timedOut && /\b(?:unknown|unrecognized|unsupported) (?:command|operation|argument)|\bno such (?:command|operation)/i.test(`${result.stdout}
+${result.stderr ?? ""}`), parsePluginApi = (result) => {
+  if (result.status !== 0)
+    return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(result.stdout);
+  } catch {
+    return null;
+  }
+  const data = parsed?.data;
+  if (!Array.isArray(data))
+    return null;
+  const entry = data.find((item) => isWorkitTarget(item?.source?.target));
+  if (!entry)
+    return { via: "api", listed: false };
+  const version = entry.source?.version;
+  return {
+    via: "api",
+    listed: true,
+    ...typeof version === "string" && /^\d+\.\d+\.\d+$/.test(version) ? { version } : {},
+    ...typeof entry.source?.outdated === "boolean" ? { outdated: entry.source.outdated } : {},
+    ...typeof entry.state?.status === "string" ? { status: entry.state.status } : {}
+  };
+}, parsePluginList = (result) => {
+  if (result.status === 0)
+    for (const line of result.stdout.split(/\r?\n/)) {
+      const fields = line.trim().split(/\s+/);
+      if (fields.length < 3)
+        continue;
+      const source = fields[fields.length - 1].replace(/^file:\/\//, "");
+      const version = fields[fields.length - 2];
+      if (isWorkitTarget(source) && /^\d+\.\d+\.\d+$/.test(version))
+        return { via: "list", listed: true, version };
+    }
+  return { via: "list", listed: false };
+}, readOpencodePlugin = async (run, home) => parsePluginApi(await run("opencode", pluginApiArgs(home), { cwd: home })) ?? parsePluginList(await run("opencode", PLUGIN_LIST, { cwd: home })), waitForOpencodePlugin = async (run, home, options = {}) => {
+  const timeoutMs = options.timeoutMs ?? OPENCODE_READY_TIMEOUT_MS;
+  const intervalMs = options.intervalMs ?? READY_INTERVAL_MS;
+  const now = options.now ?? Date.now;
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const deadline = now() + timeoutMs;
+  const [versionResult, firstApi] = await Promise.all([
+    run("opencode", ["--version"], { cwd: home }),
+    run("opencode", pluginApiArgs(home), { cwd: home })
+  ]);
+  const installed = versionResult.stdout.match(/\d+\.\d+\.\d+/)?.[0];
+  if (installed && !versionAtLeast(installed, SUPPORT_MATRIX.opencode.minimum)) {
+    const text = parsePluginList(await run("opencode", PLUGIN_LIST, { cwd: home }));
+    return text.listed ? text : { via: "list", listed: true };
+  }
+  let pending = firstApi;
+  let textOnly = false;
+  for (;; ) {
+    let api = null;
+    if (!textOnly) {
+      const result = pending ?? await run("opencode", pluginApiArgs(home), { cwd: home });
+      pending = undefined;
+      api = parsePluginApi(result);
+      textOnly = !api && lacksApi(result);
+    }
+    if (textOnly || api?.listed) {
+      const text = parsePluginList(await run("opencode", PLUGIN_LIST, { cwd: home }));
+      if (text.listed)
+        return api?.listed ? { ...api, version: api.version ?? text.version } : text;
+    }
+    if (now() >= deadline)
+      return null;
+    await sleep(Math.min(intervalMs, Math.max(0, deadline - now())));
+  }
+};
+var init_opencode = __esm(() => {
+  init_support_matrix();
+  init_shared();
+  PLUGIN_LIST = ["plugin", "list"];
+  OPENCODE_NOT_READY = `OpenCode did not finish loading its plugins (opencode api plugin.list never listed ${OPENCODE_PACKAGE})`;
+});
+
 // packages/workit-cli/src/upgrade/apply.ts
 import { existsSync as existsSync22, readdirSync as readdirSync12, mkdirSync as mkdirSync12, copyFileSync as copyFileSync6, chmodSync as chmodSync2, cpSync as cpSync5 } from "node:fs";
 import path48 from "node:path";
 import { createHash as createHash16 } from "node:crypto";
-async function applyUpgrade(plan, deps = {}) {
+async function applyUpgrade(plan, deps = {}, options = {}) {
   const hosts = [...plan.failed];
   const done = (backup) => {
     const failures = hosts.filter((entry) => entry.status === "failed");
@@ -76039,6 +76133,26 @@ async function applyUpgrade(plan, deps = {}) {
   const runAsync = asyncRunner(deps);
   const progress = deps.progress ?? createProgress({ json: true });
   const statusOf = (outcome) => outcome?.status === "failed" ? "failed" : outcome?.status === "updated" ? "done" : "skipped";
+  if (plan.cli) {
+    let cli;
+    try {
+      cli = await progress.run("Updating the CLI", () => applyCli(plan.cli, runAsync, backup), statusOf, { signals: true });
+    } catch (error) {
+      cli = { host: "cli", status: "failed", reason: errorText(error), fix: CLI_FIX };
+    }
+    if (cli.status === "updated" && options.handoff) {
+      const code = await options.handoff(cli);
+      if (code !== undefined)
+        return { ...done(backup), hosts: [...hosts, cli], handedOff: code };
+      if (plan.entries.length)
+        cli = {
+          ...cli,
+          reason: `${cli.reason}; the new CLI could not be started, hosts upgraded with workit ${package_default.version}`
+        };
+    } else if (cli.status === "failed" && plan.entries.length)
+      cli = { ...cli, reason: `${cli.reason}; hosts upgraded with workit ${package_default.version}` };
+    hosts.push(cli);
+  }
   let cursorBackupError = null;
   if (plan.entries.some((entry) => entry.host === "cursor") && existsSync22(paths.cursorRoot))
     try {
@@ -76098,7 +76212,12 @@ async function applyUpgrade(plan, deps = {}) {
       }
       let outcome;
       try {
-        outcome = await applyEntry(entry, { runAsync, paths, configDir });
+        outcome = await applyEntry(entry, {
+          runAsync,
+          paths,
+          configDir,
+          opencodeReady: deps.opencodeReady
+        });
         if (entry.host === "codex" && outcome.status === "updated") {
           const agents = await refreshCodexAgents(runAsync, paths.codexHome);
           if (!agents.ok)
@@ -76173,17 +76292,6 @@ async function applyUpgrade(plan, deps = {}) {
         reason: `${hosts[index].reason}; ${agents.note}`
       };
   }
-  if (plan.cli)
-    try {
-      hosts.push(await progress.run("Updating the CLI", () => applyCli(plan.cli, runAsync, backup), statusOf, { signals: true }));
-    } catch (error) {
-      hosts.push({
-        host: "cli",
-        status: "failed",
-        reason: errorText(error),
-        fix: CLI_FIX
-      });
-    }
   return done(backup);
 }
 var briefDetail = (detail) => {
@@ -76199,20 +76307,31 @@ var briefDetail = (detail) => {
   }
   const newest = versions.reduce((best, version) => best && versionAtLeast(best, version) ? best : version, null);
   return newest ? path48.join(dir, newest) : null;
-}, opencodeVersion = async (run) => {
-  const listing = await run("opencode", ["plugin", "list"]);
-  if (listing.status !== 0)
-    return;
-  for (const line of listing.stdout.split(/\r?\n/)) {
-    const fields = line.trim().split(/\s+/);
-    if (fields.length < 3)
-      continue;
-    const source = fields[fields.length - 1].replace(/^file:\/\//, "");
-    const version = fields[fields.length - 2];
-    if (/^(?:npm:)?@brainervirus\/workit-opencode(?:@[^/\s]+)?$/.test(source) && /^\d+\.\d+\.\d+$/.test(version))
-      return version;
-  }
-  return;
+}, opencodeVersion = async (run, home) => (await readOpencodePlugin(run, home)).version, opencodeOutcome = async (before, target, runAsync, home) => {
+  const below = (version) => target !== undefined && (version === undefined || !versionAtLeast(version, target));
+  let after = await opencodeVersion(runAsync, home);
+  if (below(after))
+    after = await opencodeVersion(runAsync, home) ?? after;
+  const live = "OpenCode V2 loads it live";
+  if (before && target && versionAtLeast(before, target))
+    return { host: "opencode", status: "current", reason: `already current (${before})` };
+  if (after && below(after))
+    return {
+      host: "opencode",
+      status: "updated",
+      reason: `update ran, but OpenCode still lists ${after} (published ${target}); the doctor below checks its package cache`
+    };
+  if (before && after && after !== before)
+    return { host: "opencode", status: "updated", reason: `${before} -> ${after}; ${live}` };
+  if (before && after)
+    return {
+      host: "opencode",
+      status: "current",
+      reason: `unchanged (${after}); the published version could not be read`
+    };
+  if (after)
+    return { host: "opencode", status: "updated", reason: `now ${after}; ${live}` };
+  return { host: "opencode", status: "updated", reason: `scoped update ran; ${live}` };
 }, applyEntry = async (entry, context) => {
   const { runAsync, paths, configDir } = context;
   const { home, env } = paths;
@@ -76289,32 +76408,23 @@ ${result.stderr}`;
       reason: entry.repair ? `reinstalled missing plugin files (${entry.latest})` : `${entry.installedVersion ?? "?"} -> ${entry.latest}`
     };
   }
-  const before = entry.host === "opencode" ? await opencodeVersion(runAsync) : undefined;
+  let before;
+  if (entry.host === "opencode") {
+    const ready = await waitForOpencodePlugin(runAsync, home, context.opencodeReady);
+    if (!ready)
+      return fail(OPENCODE_NOT_READY);
+    before = ready.version;
+  }
   for (const command of entry.commands) {
-    let result = await runAsync(command.command, command.args);
+    const where = command.cwd ? { cwd: command.cwd } : undefined;
+    let result = await runAsync(command.command, command.args, where);
     if (result.status !== 0 && entry.host === "opencode")
-      result = await runAsync(command.command, command.args);
+      result = await runAsync(command.command, command.args, where);
     if (result.status !== 0)
       return fail(failureReason(command, result));
   }
-  if (entry.host === "opencode") {
-    const after = await opencodeVersion(runAsync);
-    if (before && after)
-      return after === before ? {
-        host: "opencode",
-        status: "current",
-        reason: `already current (${after})`
-      } : {
-        host: "opencode",
-        status: "updated",
-        reason: `${before} -> ${after}; OpenCode V2 loads it live`
-      };
-    return {
-      host: "opencode",
-      status: "updated",
-      reason: "scoped update ran; OpenCode V2 loads it live"
-    };
-  }
+  if (entry.host === "opencode")
+    return opencodeOutcome(before, entry.published, runAsync, home);
   if (entry.host === "claude-code") {
     const after = claudeWorkitInstalls(home, env, null).find((install) => install.id === entry.selector)?.version;
     return after && after === entry.installedVersion ? {
@@ -76388,12 +76498,14 @@ ${result.stderr}`;
   };
 };
 var init_apply = __esm(() => {
+  init_package();
   init_host_install();
   init_setup_state();
   init_setup();
   init_safe_write();
   init_progress();
   init_processes();
+  init_opencode();
   init_shared();
 });
 
@@ -76558,14 +76670,107 @@ var init_update_check = __esm(() => {
   ]);
 });
 
-// packages/workit-cli/src/upgrade/plan.ts
-import { existsSync as existsSync23, mkdtempSync as mkdtempSync3, rmSync as rmSync8, lstatSync as lstatSync8, readFileSync as readFileSync25 } from "node:fs";
-import path50 from "node:path";
+// packages/workit-cli/src/upgrade/probes.ts
+import { existsSync as existsSync23, mkdtempSync as mkdtempSync3, rmSync as rmSync8 } from "node:fs";
 import os18 from "node:os";
-function previewUpgrade(hosts = HOSTS2, deps = {}) {
+import path50 from "node:path";
+var PROBE_TIMEOUT_MS = 20000, probeKey = (command, args) => [command, ...args].join(" "), opencodeScratchEnv = (deps, scratch) => ({
+  ...deps.env,
+  XDG_DATA_HOME: path50.join(scratch, "data"),
+  XDG_STATE_HOME: path50.join(scratch, "state"),
+  XDG_CACHE_HOME: path50.join(scratch, "cache")
+}), registry2 = (name) => ["npm", ["view", name, "version"]], OPENCODE_READY_KEY = "opencode-ready", opencodeReading = (probes) => {
+  const result = probes?.get(OPENCODE_READY_KEY);
+  if (!result)
+    return;
+  return result.status === 0 ? JSON.parse(result.stdout) : null;
+}, opencodeRegistersWorkit = (file) => {
+  const config = objectOrNull(file);
+  return [config?.plugins, config?.plugin].flatMap((value) => Array.isArray(value) ? value : []).some((pin) => typeof pin === "string" && /^(?:npm:)?@brainervirus\/workit-opencode(?:@[^/\s]+)?$/.test(pin));
+}, runProbes = async (hosts, cli, deps, options = {}) => {
+  const paths = upgradePaths(deps);
+  const timeoutMs = deps.probeTimeoutMs ?? PROBE_TIMEOUT_MS;
+  const run = asyncRunner(deps, timeoutMs);
+  const probes = [];
+  const add = (command, args, runner = run) => probes.push([command, args, runner]);
+  const scratch = mkdtempSync3(path50.join(os18.tmpdir(), "workit-upgrade-opencode-"));
+  try {
+    if (hosts.includes("opencode") && existsSync23(paths.opencodeConfig)) {
+      if (!options.check) {
+        const opencode = asyncRunner({ ...deps, env: opencodeScratchEnv(deps, scratch) }, timeoutMs);
+        add("opencode", ["--version"], opencode);
+        add("opencode", ["plugin", "--help"], opencode);
+      }
+      add(...registry2(OPENCODE_PACKAGE));
+    }
+    for (const name of options.registries ?? [])
+      add(...registry2(name));
+    if (hosts.includes("cursor"))
+      add(...registry2("@brainervirus/workit-cursor"));
+    if (hosts.includes("codex")) {
+      add("codex", ["plugin", "list", "--json"]);
+      add(...registry2("@brainervirus/workit-codex"));
+    }
+    if (hosts.includes("pi")) {
+      if (existsSync23(paths.piSettings))
+        add("pi", ["list"]);
+      add(...registry2("@brainervirus/workit-pi"));
+    }
+    if (cli) {
+      add("npm", ["root", "--global"]);
+      add(...registry2(CLI_PACKAGE2));
+    }
+    const ready = hosts.includes("opencode") && opencodeRegistersWorkit(paths.opencodeConfig) ? waitForOpencodePlugin((command, args, where) => run(command, args, where).catch((error) => ({
+      status: 1,
+      stdout: "",
+      stderr: error instanceof Error ? error.message : String(error)
+    })), paths.home, deps.opencodeReady).then((reading) => [
+      OPENCODE_READY_KEY,
+      reading ? { status: 0, stdout: JSON.stringify(reading) } : { status: 1, stdout: "", stderr: OPENCODE_NOT_READY }
+    ]) : undefined;
+    const results = await Promise.all(probes.map(async ([command, args, runner]) => {
+      let timer;
+      const timedOut = new Promise((resolve) => {
+        timer = setTimeout(() => resolve({
+          status: null,
+          stdout: "",
+          stderr: `\`${probeKey(command, args)}\` timed out after ${Math.round(timeoutMs / 1000)} s`,
+          timedOut: true
+        }), timeoutMs);
+      });
+      try {
+        const result = await Promise.race([
+          runner(command, args).catch((error) => ({
+            status: 1,
+            stdout: "",
+            stderr: error instanceof Error ? error.message : String(error)
+          })),
+          timedOut
+        ]);
+        return [probeKey(command, args), result];
+      } finally {
+        clearTimeout(timer);
+      }
+    }));
+    return new Map([...results, ...ready ? [await ready] : []]);
+  } finally {
+    rmSync8(scratch, { recursive: true, force: true });
+  }
+};
+var init_probes = __esm(() => {
+  init_update_check();
+  init_opencode();
+  init_shared();
+});
+
+// packages/workit-cli/src/upgrade/plan.ts
+import { existsSync as existsSync24, mkdtempSync as mkdtempSync4, rmSync as rmSync9, lstatSync as lstatSync8, readFileSync as readFileSync25 } from "node:fs";
+import path51 from "node:path";
+import os19 from "node:os";
+function previewUpgrade(hosts = HOSTS2, deps = {}, probes) {
   const paths = upgradePaths(deps);
   const { home, configDir } = paths;
-  const run = runner(deps);
+  const run = probedRunner(deps, probes);
   const state = readSetupState(configDir);
   const plan = {
     ok: true,
@@ -76584,9 +76789,9 @@ function previewUpgrade(hosts = HOSTS2, deps = {}) {
   for (const file of [
     paths.opencodeConfig,
     paths.opencodeConfig + "c",
-    path50.join(home, ".cursor/settings.json"),
-    path50.join(home, ".cursor/mcp.json"),
-    path50.join(paths.cursorRoot, "package.json"),
+    path51.join(home, ".cursor/settings.json"),
+    path51.join(home, ".cursor/mcp.json"),
+    path51.join(paths.cursorRoot, "package.json"),
     paths.codexConfig,
     paths.piSettings
   ])
@@ -76605,7 +76810,7 @@ function previewUpgrade(hosts = HOSTS2, deps = {}) {
   const installedSources = sources(paths, run, hosts, plan.failed);
   let opencodeHelp;
   if (installedSources.some((source) => source.host === "opencode")) {
-    const probe = opencodeProbe(deps, ["--version"]);
+    const probe = opencodeProbe(deps, ["--version"], probes);
     const installed = probe.status === 0 ? probe.stdout.match(/\d+\.\d+\.\d+/)?.[0] : undefined;
     if (installed && !versionAtLeast(installed, SUPPORT_MATRIX.opencode.minimum))
       (plan.warnings ??= []).push(`opencode ${installed}: ${OPENCODE_V1_FIX}`);
@@ -76646,7 +76851,17 @@ function previewUpgrade(hosts = HOSTS2, deps = {}) {
       continue;
     }
     if (source.host === "opencode") {
-      opencodeHelp ??= opencodeProbe(deps, ["plugin", "--help"]).stdout;
+      const help = opencodeProbe(deps, ["plugin", "--help"], probes);
+      if (help.timedOut) {
+        plan.failed.push({
+          host: "opencode",
+          status: "failed",
+          reason: `could not check: ${help.stderr}`,
+          fix: OPENCODE_UPDATE
+        });
+        continue;
+      }
+      opencodeHelp ??= help.stdout;
       if (!/^\s*(?:opencode\s+plugin\s+)?update\b/m.test(opencodeHelp)) {
         plan.skipped.push({
           host: "opencode",
@@ -76655,11 +76870,26 @@ function previewUpgrade(hosts = HOSTS2, deps = {}) {
         });
         continue;
       }
+      const reading = opencodeReading(probes);
+      if (reading === null) {
+        plan.failed.push({
+          host: "opencode",
+          status: "failed",
+          reason: OPENCODE_NOT_READY,
+          fix: OPENCODE_UPDATE
+        });
+        continue;
+      }
+      const published = registryVersion(run, OPENCODE_PACKAGE);
       plan.entries.push({
         host: "opencode",
         selector: source.selector,
         latest: "",
-        commands: [{ command: "opencode", args: ["plugin", "update", OPENCODE_PACKAGE] }],
+        ...published ? { published } : {},
+        ...reading?.version ? { installedVersion: reading.version } : {},
+        commands: [
+          { command: "opencode", args: ["plugin", "update", OPENCODE_PACKAGE], cwd: home }
+        ],
         fix: OPENCODE_UPDATE
       });
       continue;
@@ -76746,7 +76976,7 @@ var codexRegistered = (configFile) => {
     }
   };
   guard("opencode", () => {
-    if (existsSync23(paths.opencodeConfig + "c"))
+    if (existsSync24(paths.opencodeConfig + "c"))
       throw new Error("OpenCode JSONC config is present; inspect effective native configuration before updating");
     const oc = object2(paths.opencodeConfig);
     if (oc && [oc.plugins, oc.plugin].some((value) => value !== undefined && !Array.isArray(value)))
@@ -76756,8 +76986,8 @@ var codexRegistered = (configFile) => {
         result.push(classify("opencode", pin));
   });
   guard("cursor", () => {
-    const cursor = objectOrNull(path50.join(paths.cursorRoot, "package.json"));
-    const mcp = objectOrNull(path50.join(home, ".cursor/mcp.json"));
+    const cursor = objectOrNull(path51.join(paths.cursorRoot, "package.json"));
+    const mcp = objectOrNull(path51.join(home, ".cursor/mcp.json"));
     const args = mcp?.mcpServers?.workit?.args ?? [];
     const arg = args.find((value) => typeof value === "string" && value.startsWith("--package="));
     const selector = typeof arg === "string" ? arg.slice(10) : "local";
@@ -76768,7 +76998,7 @@ var codexRegistered = (configFile) => {
       });
       return;
     }
-    const settings = objectOrNull(path50.join(home, ".cursor/settings.json"));
+    const settings = objectOrNull(path51.join(home, ".cursor/settings.json"));
     const dirs = Array.isArray(settings?.plugin_dirs) ? settings.plugin_dirs : [];
     const registered = mcp?.mcpServers?.workit !== undefined || dirs.some((dir) => String(dir).replaceAll("\\", "/").replace(/\/+$/, "").endsWith("local/workit"));
     if (registered)
@@ -76783,12 +77013,14 @@ var codexRegistered = (configFile) => {
       if (typeof source !== "string")
         continue;
       const npm = /^(?:npm:)?@brainervirus\/workit-pi(?:@[^/]+)?$/.test(source);
-      const local = path50.isAbsolute(source) && source.replaceAll("\\", "/").endsWith("/packages/workit-pi") && object2(path50.join(source, "package.json"))?.name === "@brainervirus/workit-pi";
+      const local = path51.isAbsolute(source) && source.replaceAll("\\", "/").endsWith("/packages/workit-pi") && object2(path51.join(source, "package.json"))?.name === "@brainervirus/workit-pi";
       if (!npm && !local)
         continue;
       const found = classify("pi", source);
       if (found.kind === "floating") {
         const inventory = run("pi", ["list"]);
+        if (inventory.timedOut)
+          throw new Error(`could not check: ${inventory.stderr}`);
         if (inventory.status === 0)
           found.installedVersion = piInstalledVersion(inventory.stdout, source);
       }
@@ -76797,13 +77029,15 @@ var codexRegistered = (configFile) => {
   });
   guard("codex", () => {
     const listing = run("codex", ["plugin", "list", "--json"]);
+    if (listing.timedOut)
+      throw new Error(`could not check: ${listing.stderr}`);
     if (listing.status !== 0) {
       let available = false;
       try {
         hostCommand("codex", [], { home, env: paths.env });
         available = true;
       } catch {}
-      if (available || existsSync23(paths.codexConfig))
+      if (available || existsSync24(paths.codexConfig))
         throw new Error("Codex plugin inventory failed; inspect the native host before upgrading");
       return;
     }
@@ -76842,24 +77076,22 @@ var codexRegistered = (configFile) => {
       });
   });
   return result;
-}, opencodeProbe = (deps, args) => {
-  const scratch = mkdtempSync3(path50.join(os18.tmpdir(), "workit-upgrade-opencode-"));
+}, opencodeProbe = (deps, args, probes) => {
+  const cached = probes?.get(probeKey("opencode", args));
+  if (cached)
+    return cached;
+  const scratch = mkdtempSync4(path51.join(os19.tmpdir(), "workit-upgrade-opencode-"));
   try {
-    return runner({
-      ...deps,
-      env: {
-        ...deps.env,
-        XDG_DATA_HOME: path50.join(scratch, "data"),
-        XDG_STATE_HOME: path50.join(scratch, "state"),
-        XDG_CACHE_HOME: path50.join(scratch, "cache")
-      }
-    })("opencode", args);
+    return runner({ ...deps, env: opencodeScratchEnv(deps, scratch) })("opencode", args);
   } finally {
-    rmSync8(scratch, { recursive: true, force: true });
+    rmSync9(scratch, { recursive: true, force: true });
   }
+}, probedRunner = (deps, probes) => {
+  const run = runner(deps);
+  return probes ? (command, args) => probes.get(probeKey(command, args)) ?? run(command, args) : run;
 }, planCli = (plan, run) => {
   const root = run("npm", ["root", "--global"]);
-  if (root.status !== 0 || !path50.isAbsolute(root.stdout.trim())) {
+  if (root.status !== 0 || !path51.isAbsolute(root.stdout.trim())) {
     plan.skipped.push({
       host: "cli",
       reason: "global npm location could not be verified",
@@ -76867,9 +77099,9 @@ var codexRegistered = (configFile) => {
     });
     return;
   }
-  const packageFile = path50.join(root.stdout.trim(), "@brainervirus/workit-cli/package.json");
+  const packageFile = path51.join(root.stdout.trim(), "@brainervirus/workit-cli/package.json");
   const installed = objectOrNull(packageFile);
-  if (installed?.name !== "@brainervirus/workit-cli" || lstatSync8(path50.dirname(packageFile)).isSymbolicLink()) {
+  if (installed?.name !== "@brainervirus/workit-cli" || lstatSync8(path51.dirname(packageFile)).isSymbolicLink()) {
     plan.skipped.push({
       host: "cli",
       reason: "no managed global CLI install (local links preserved); use npx @brainervirus/workit-cli@latest"
@@ -76898,6 +77130,8 @@ var codexRegistered = (configFile) => {
     });
 };
 var init_plan = __esm(() => {
+  init_probes();
+  init_opencode();
   init_registration();
   init_setup_state();
   init_host_install();
@@ -76907,11 +77141,17 @@ var init_plan = __esm(() => {
 });
 
 // packages/workit-cli/src/upgrade/check.ts
-import path51 from "node:path";
-function runUpdateCheck(json, deps) {
+import path52 from "node:path";
+async function runUpdateCheck(json, deps) {
   const out = deps.out ?? process.stdout;
   const paths = upgradePaths(deps);
-  const run = runner(deps);
+  const progress = deps.progress ?? createProgress({ stream: process.stderr, json });
+  const checking = HOSTS2.length + 1;
+  const probes = await progress.run(`Checking ${checking} hosts`, () => runProbes(HOSTS2, true, deps, {
+    check: true,
+    registries: ["@brainervirus/workit-claude-code"]
+  }));
+  const run = probedRunner(deps, probes);
   const latest = (name) => registryVersion(run, name);
   const cliLatest = latest(CLI_PACKAGE2);
   if (cliLatest)
@@ -76952,14 +77192,27 @@ function runUpdateCheck(json, deps) {
     }
     if (!versionBy.has(host))
       continue;
-    const version = versionBy.get(host);
+    const reading = host === "opencode" ? opencodeReading(probes) : undefined;
+    if (reading === null) {
+      components.push({
+        component: host,
+        package: name,
+        installed: null,
+        latest: null,
+        status: "unreadable",
+        reason: OPENCODE_NOT_READY
+      });
+      continue;
+    }
+    const version = versionBy.get(host) ?? reading?.version;
     const newest = latest(name);
+    const status = statusOf(version, newest);
     components.push({
       component: host,
       package: name,
       installed: version ?? null,
       latest: newest ?? null,
-      status: statusOf(version, newest)
+      status: reading?.outdated && status === "current" ? "update" : status
     });
   }
   const pending = components.some((entry) => entry.status === "update" || entry.status === "unknown");
@@ -77009,7 +77262,7 @@ function runSetUpdates(value, deps) {
 `);
     return 1;
   }
-  out.write(`updates: ${value} (saved in ${path51.join(configDir, "config.json")})
+  out.write(`updates: ${value} (saved in ${path52.join(configDir, "config.json")})
 `);
   return 0;
 }
@@ -77019,7 +77272,10 @@ var init_check = __esm(() => {
   init_package();
   init_style();
   init_update_check();
+  init_progress();
+  init_opencode();
   init_plan();
+  init_probes();
   init_shared();
   SET_USAGE = `Usage: workit upgrade --set-updates=${UPDATES_MODES.join("|")}
 `;
@@ -77106,7 +77362,24 @@ __export(exports_upgrade, {
   runUpgradeCommand: () => runUpgradeCommand
 });
 import { spawnSync as spawnSync18 } from "node:child_process";
+import { mkdtempSync as mkdtempSync5, readFileSync as readFileSync26, rmSync as rmSync10, writeFileSync as writeFileSync14 } from "node:fs";
+import os20 from "node:os";
+import path53 from "node:path";
 async function runUpgradeCommand(argv, deps = {}) {
+  const { env } = upgradePaths(deps);
+  const handBack = env[CONTINUE_ENV] !== undefined ? env[ROWS_ENV] : undefined;
+  const handed = {};
+  const code = await upgradeOnce(argv, deps, handed);
+  if (!handBack)
+    return code;
+  try {
+    writeFileSync14(handBack, JSON.stringify({ code, rows: handed.rows ?? [] }));
+    return 0;
+  } catch {
+    return code;
+  }
+}
+async function upgradeOnce(argv, deps, handed) {
   const out = deps.out ?? process.stdout;
   const setting = argv.find((arg) => arg.startsWith("--set-updates="));
   if (argv.includes("--check") || setting) {
@@ -77115,7 +77388,7 @@ async function runUpgradeCommand(argv, deps = {}) {
       out.write(USAGE3);
       return 2;
     }
-    return setting ? runSetUpdates(setting.slice("--set-updates=".length), deps) : runUpdateCheck(argv.includes("--json"), deps);
+    return setting ? runSetUpdates(setting.slice("--set-updates=".length), deps) : await runUpdateCheck(argv.includes("--json"), deps);
   }
   const flags = new Set(argv);
   const unknown = argv.filter((arg) => !["--apply", "--confirm", "--json", "--cli", "--preview", "--yes"].includes(arg) && !arg.startsWith("--hosts="));
@@ -77132,16 +77405,19 @@ async function runUpgradeCommand(argv, deps = {}) {
   }
   const legacy = flags.has("--apply");
   const json = flags.has("--json") || legacy;
-  const run = runner(deps);
+  const { home, env } = upgradePaths(deps);
+  const continued = env[CONTINUE_ENV] !== undefined ? priorRows(env[CONTINUE_ENV]) : undefined;
   const progress = deps.progress ?? createProgress({ stream: process.stderr, json });
-  const plan = progress.runSync("Planning the upgrade", () => {
-    const planned = previewUpgrade(raw, deps);
-    if (hostFlag === undefined || flags.has("--cli"))
-      planCli(planned, run);
+  const withCli = !continued && (hostFlag === undefined || flags.has("--cli"));
+  const checking = raw.length + (withCli ? 1 : 0);
+  const plan = await progress.run(`Checking ${checking} ${checking === 1 ? "host" : "hosts"}`, async () => {
+    const probes = await runProbes(raw, withCli, deps);
+    const planned = previewUpgrade(raw, deps, probes);
+    if (withCli)
+      planCli(planned, probedRunner(deps, probes));
     return planned;
   });
   plan.ok = plan.blocked.length === 0 && plan.failed.length === 0;
-  const { home, env } = upgradePaths(deps);
   const style = createStyle({
     stream: out === process.stdout ? process.stdout : out === process.stderr ? process.stderr : undefined,
     env,
@@ -77172,7 +77448,8 @@ async function runUpgradeCommand(argv, deps = {}) {
     return plan.blocked.length ? 1 : 0;
   }
   if (!json)
-    out.write(summary(plan, permissions.changes, style));
+    out.write(continued ? `Continuing the upgrade with the new CLI (workit ${package_default.version}).
+` : summary(plan, permissions.changes, style));
   if (flags.has("--preview")) {
     out.write(nothingChanged);
     return plan.blocked.length ? 1 : 0;
@@ -77195,7 +77472,44 @@ Nothing changed.
     for (const warning of plan.warnings ?? [])
       out.write(`warning: ${warning}
 `);
-  const result = await applyUpgrade(plan, { ...deps, progress });
+  const reexec = deps.reexec ?? (deps.run && !deps.cliEntry ? undefined : spawnUpgrade({
+    entry: deps.cliEntry ?? process.argv[1],
+    out,
+    toStderr: out === process.stderr,
+    json
+  }));
+  const handoff = async (cli) => {
+    if (!reexec || (deps.cliOnDisk ?? runningCliVersion)() !== plan.cli?.latest)
+      return;
+    const scratch = mkdtempSync5(path53.join(os20.tmpdir(), "workit-upgrade-"));
+    const rowsFile = path53.join(scratch, "rows.json");
+    try {
+      const code = await reexec([
+        ...legacy ? ["--apply", "--confirm"] : ["--yes"],
+        ...flags.has("--json") ? ["--json"] : [],
+        `--hosts=${raw.length ? raw.join(",") : "none"}`
+      ], {
+        [CONTINUE_ENV]: JSON.stringify([cli]),
+        [ROWS_ENV]: rowsFile,
+        WORKIT_UPDATE_CHECK: "0"
+      });
+      if (code === undefined)
+        return;
+      const back = handedBack(readText5(rowsFile));
+      deps.onResult?.(back?.rows.length ? back.rows : [cli]);
+      return back?.code ?? code;
+    } finally {
+      rmSync10(scratch, { recursive: true, force: true });
+    }
+  };
+  const result = await applyUpgrade(plan, { ...deps, progress }, continued || !reexec ? {} : { handoff });
+  if (result.handedOff !== undefined)
+    return result.handedOff;
+  if (continued?.length) {
+    result.hosts.unshift(...continued);
+    if (continued.some((row) => row.status === "failed"))
+      result.ok = false;
+  }
   let permissionsOk = true;
   let written;
   if (permissions.changes.length && !permissions.refused && !result.error?.startsWith("configuration changed")) {
@@ -77210,8 +77524,9 @@ Nothing changed.
       });
   }
   deps.onResult?.(result.hosts);
+  handed.rows = result.hosts;
   const failed = !result.ok || !permissionsOk;
-  const cliVersion = result.hosts.some((h) => h.host === "cli" && h.status === "updated") ? plan.cli.latest : package_default.version;
+  const cliVersion = plan.cli && result.hosts.some((h) => h.host === "cli" && h.status === "updated") ? plan.cli.latest : package_default.version;
   const report = progress.runSync("Checking the result with workit doctor", () => (deps.doctor ?? ((version) => runDoctor({ home, env, cliVersion: version, only: "upgrade" })))(cliVersion));
   const left = report.checks.filter((check) => check.status === "warn" || check.status === "fail");
   if (json) {
@@ -77234,7 +77549,7 @@ Nothing changed.
   if (result.backup)
     out.write(`Backup: ${style.path(result.backup)}
 `);
-  out.write(left.length === 0 ? `${style.ok("Verified:")} workit doctor is clean for versions, assets, agents and permissions.
+  out.write(left.length === 0 ? `${style.ok("Verified:")} workit doctor is clean for versions, assets, agents, stale installs and permissions.
 ` : `${style.warn("Left after upgrade (workit doctor):")}
 ${left.map((check) => `  ${style.bold(check.id)}: ${check.detail}${check.fix ? `
     fix: ${style.command(check.fix)}` : ""}`).join(`
@@ -77295,7 +77610,68 @@ async function runLaunchCommand(argv, deps = {}) {
 var USAGE3 = `Usage: workit upgrade [--hosts=opencode,cursor,codex,pi,claude-code|none] [--cli] [--preview | --yes | --apply --confirm] [--json]
        workit upgrade --check [--json]
        workit upgrade --set-updates=prompt|auto|off
-`;
+`, CONTINUE_ENV = "WORKIT_UPGRADE_CONTINUE", ROWS_ENV = "WORKIT_UPGRADE_ROWS", readText5 = (file) => {
+  try {
+    return readFileSync26(file, "utf8");
+  } catch {
+    return;
+  }
+}, priorRows = (text) => {
+  if (text === undefined)
+    return;
+  try {
+    const rows = JSON.parse(text);
+    return Array.isArray(rows) ? rows.filter((row) => typeof row?.host === "string" && typeof row?.status === "string" && typeof row?.reason === "string") : [];
+  } catch {
+    return [];
+  }
+}, handedBack = (text) => {
+  if (text === undefined)
+    return;
+  try {
+    const value = JSON.parse(text);
+    return {
+      code: typeof value.code === "number" ? value.code : undefined,
+      rows: priorRows(JSON.stringify(value.rows ?? [])) ?? []
+    };
+  } catch {
+    return;
+  }
+}, runningCliVersion = () => {
+  const script = process.argv[1];
+  if (!script)
+    return;
+  let dir = path53.dirname(script);
+  for (let depth = 0;depth < 4; depth += 1, dir = path53.dirname(dir)) {
+    const found = cliPackageVersion(readText5(path53.join(dir, "package.json")));
+    if (found)
+      return found;
+  }
+  return;
+}, cliPackageVersion = (text) => {
+  if (text === undefined)
+    return;
+  try {
+    const found = JSON.parse(text);
+    return found.name === package_default.name && typeof found.version === "string" ? found.version : undefined;
+  } catch {
+    return;
+  }
+}, spawnUpgrade = (options) => (argv, extra) => {
+  if (!options.entry)
+    return;
+  const result = spawnSync18(process.execPath, [options.entry, "upgrade", ...argv], {
+    stdio: ["inherit", options.json ? "pipe" : options.toStderr ? 2 : "inherit", "inherit"],
+    encoding: "utf8",
+    maxBuffer: 64 * 1024 * 1024,
+    env: { ...process.env, ...extra }
+  });
+  if (result.error)
+    return;
+  if (options.json && result.stdout)
+    options.out.write(result.stdout);
+  return result.status ?? 1;
+};
 var init_upgrade = __esm(() => {
   init_package();
   init_host_install();
@@ -77306,6 +77682,7 @@ var init_upgrade = __esm(() => {
   init_apply();
   init_check();
   init_plan();
+  init_probes();
   init_report();
   init_shared();
   init_apply();
@@ -77336,7 +77713,7 @@ var init_launch = __esm(() => {
 // packages/workit-core/src/knowledge.ts
 import { spawnSync as spawnSync19 } from "node:child_process";
 import fs20 from "node:fs";
-import path52 from "node:path";
+import path54 from "node:path";
 function lintKnowledge(root) {
   const seen = new Set;
   const unreadable = [];
@@ -77440,7 +77817,7 @@ var AGENTS_BYTE_BUDGET, STEERING_FILES, NEED_BASED_FILES, STANDARDS_FILE = "CODI
   const end = lines.indexOf("---", 1);
   return end === -1 ? lines : [...lines.slice(0, end + 1).map(() => ""), ...lines.slice(end + 1)];
 }, read = (root, file) => {
-  const full = path52.join(root, file);
+  const full = path54.join(root, file);
   try {
     fs20.lstatSync(full);
   } catch {
@@ -77481,7 +77858,7 @@ var AGENTS_BYTE_BUDGET, STEERING_FILES, NEED_BASED_FILES, STANDARDS_FILE = "CODI
   }
 }, brokenLinks = (root, doc, tracked) => {
   const findings = [];
-  const base = path52.dirname(path52.join(root, doc.file));
+  const base = path54.dirname(path54.join(root, doc.file));
   const missing = (target, line, how) => findings.push({
     rule: "broken-link",
     file: doc.file,
@@ -77500,7 +77877,7 @@ var AGENTS_BYTE_BUDGET, STEERING_FILES, NEED_BASED_FILES, STANDARDS_FILE = "CODI
       const local = localTarget(target);
       if (!local)
         continue;
-      const resolved = local.startsWith("/") ? path52.join(root, local) : path52.resolve(base, local);
+      const resolved = local.startsWith("/") ? path54.join(root, local) : path54.resolve(base, local);
       if (!exists2(resolved))
         missing(target, index + 1, "link");
     }
@@ -77510,9 +77887,9 @@ var AGENTS_BYTE_BUDGET, STEERING_FILES, NEED_BASED_FILES, STANDARDS_FILE = "CODI
         continue;
       const relative = /^\.\.?\//.test(candidate);
       const first = candidate.split("/")[0];
-      if (!relative && !(tracked ? tracked.has(first) : exists2(path52.join(root, first))))
+      if (!relative && !(tracked ? tracked.has(first) : exists2(path54.join(root, first))))
         continue;
-      const resolved = relative ? path52.resolve(base, candidate) : path52.join(root, candidate);
+      const resolved = relative ? path54.resolve(base, candidate) : path54.join(root, candidate);
       if (!exists2(resolved))
         missing(span, index + 1, "pointer");
     }
@@ -77881,8 +78258,8 @@ var init_redact = __esm(() => {
 import { spawn as spawn4, spawnSync as spawnSync20 } from "node:child_process";
 import { createHash as createHash17 } from "node:crypto";
 import fs21 from "node:fs";
-import os19 from "node:os";
-import path53 from "node:path";
+import os21 from "node:os";
+import path55 from "node:path";
 import { StringDecoder } from "node:string_decoder";
 function tailLines(text, lines = TAIL_LINES) {
   const all = text.replace(/\r\n?/gu, `
@@ -78002,7 +78379,7 @@ function planSpawn(argv, options) {
     return { file: argv[0], args: [], verbatim: false, shell: true };
   if (options.platform !== "win32")
     return { file: argv[0], args: argv.slice(1), verbatim: false, shell: false };
-  const win = path53.win32;
+  const win = path55.win32;
   const isFile = options.isFile ?? ((file) => {
     try {
       return fs21.statSync(file).isFile();
@@ -78087,7 +78464,7 @@ function runCheckCommand(argv, options) {
 `);
       redactor.end();
       resolve({
-        exitCode: spawnError ? 127 : code !== null ? code : 128 + (signal ? os19.constants.signals[signal] ?? 1 : 1),
+        exitCode: spawnError ? 127 : code !== null ? code : 128 + (signal ? os21.constants.signals[signal] ?? 1 : 1),
         signal: signal ?? null,
         timedOut,
         durationMs: Date.now() - started,
@@ -78164,10 +78541,10 @@ function runCheckCommand(argv, options) {
 function storeLog(storeRoot, log) {
   const digest = logDigest(log);
   const ref = `blobs/logs/${digest.slice("sha256:".length)}.log`;
-  const file = path53.join(storeRoot, ref);
+  const file = path55.join(storeRoot, ref);
   try {
     if (!fs21.existsSync(file)) {
-      fs21.mkdirSync(path53.dirname(file), { recursive: true });
+      fs21.mkdirSync(path55.dirname(file), { recursive: true });
       const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
       fs21.writeFileSync(temp, log, { mode: 384 });
       fs21.renameSync(temp, file);
@@ -78180,7 +78557,7 @@ function storeLog(storeRoot, log) {
 function pruneCheckLogs(storeRoot, options = {}) {
   const limits = { ...LOG_RETENTION, ...options.retention };
   const now = options.now ?? Date.now();
-  const dir = path53.join(storeRoot, "blobs", "logs");
+  const dir = path55.join(storeRoot, "blobs", "logs");
   const report = { removed: 0, removedBytes: 0, kept: 0 };
   let names;
   try {
@@ -78190,7 +78567,7 @@ function pruneCheckLogs(storeRoot, options = {}) {
   }
   const files = names.flatMap((name) => {
     try {
-      const stat = fs21.statSync(path53.join(dir, name));
+      const stat = fs21.statSync(path55.join(dir, name));
       return stat.isFile() ? [{ name, size: stat.size, mtimeMs: stat.mtimeMs }] : [];
     } catch {
       return [];
@@ -78209,7 +78586,7 @@ function pruneCheckLogs(storeRoot, options = {}) {
       continue;
     if (!options.dryRun)
       try {
-        fs21.rmSync(path53.join(dir, file.name), { force: true });
+        fs21.rmSync(path55.join(dir, file.name), { force: true });
       } catch {
         continue;
       }
@@ -78479,7 +78856,7 @@ __export(exports_workspace, {
   run: () => run11,
   runWorkspace: () => runWorkspace
 });
-import { copyFileSync as copyFileSync7, existsSync as existsSync24 } from "node:fs";
+import { copyFileSync as copyFileSync7, existsSync as existsSync25 } from "node:fs";
 function list2(argv, io) {
   if (argv.length)
     return usage3(io, `unexpected argument ${argv[0]}`);
@@ -78788,7 +79165,7 @@ usage: ${USAGE5}`)), load = (io) => {
     return { ok: false, error: `${current.path} changed; retry` };
   let backup = null;
   try {
-    if (existsSync24(current.path)) {
+    if (existsSync25(current.path)) {
       backup = `${current.path}.bak`;
       copyFileSync7(current.path, backup);
     }
@@ -78862,12 +79239,12 @@ var init_workspace = __esm(() => {
 
 // packages/workit-core/src/core/heavy-rules.ts
 import fs22 from "node:fs";
-import path54 from "node:path";
+import path56 from "node:path";
 function gitTop(cwd) {
-  for (let dir = path54.resolve(cwd);; dir = path54.dirname(dir)) {
-    if (fs22.existsSync(path54.join(dir, ".git")))
+  for (let dir = path56.resolve(cwd);; dir = path56.dirname(dir)) {
+    if (fs22.existsSync(path56.join(dir, ".git")))
       return dir;
-    if (path54.dirname(dir) === dir)
+    if (path56.dirname(dir) === dir)
       return null;
   }
 }
@@ -78908,19 +79285,19 @@ var init_heavy_rules = () => {};
 
 // packages/workit-core/src/core/heavy.ts
 import fs23 from "node:fs";
-import os20 from "node:os";
-import path55 from "node:path";
+import os22 from "node:os";
+import path57 from "node:path";
 function stateDir2(env, platform = process.platform) {
   if (env.WORKFLOW_TOOLKIT_STATE)
     return env.WORKFLOW_TOOLKIT_STATE;
   if (env.XDG_STATE_HOME)
-    return path55.join(env.XDG_STATE_HOME, "workit");
-  const home = env.HOME || os20.homedir();
+    return path57.join(env.XDG_STATE_HOME, "workit");
+  const home = env.HOME || os22.homedir();
   if (platform === "darwin")
-    return path55.join(home, "Library", "Application Support", "workit");
+    return path57.join(home, "Library", "Application Support", "workit");
   if (platform === "win32")
-    return path55.join(env.LOCALAPPDATA ?? path55.join(home, "AppData", "Local"), "workit");
-  return path55.join(home, ".local", "state", "workit");
+    return path57.join(env.LOCALAPPDATA ?? path57.join(home, "AppData", "Local"), "workit");
+  return path57.join(home, ".local", "state", "workit");
 }
 function positional(words, from, values = PM_VALUES) {
   let index = from;
@@ -79060,7 +79437,7 @@ function machinePatterns(env) {
   return isRecord8(value) ? stringList2(value.patterns) : [];
 }
 function repoPatterns(cwd) {
-  return repoHeavyCommands(gitTop(cwd) ?? path55.resolve(cwd));
+  return repoHeavyCommands(gitTop(cwd) ?? path57.resolve(cwd));
 }
 function heavyLines(lines, options) {
   const found = [];
@@ -79139,7 +79516,7 @@ function leaseRewrite(command) {
     return null;
   return `${prefix}workit check --heavy -- ${rest}`;
 }
-var HEAVY_COMMANDS_FILE = "heavy-commands.json", heavyCommandsFile = (env) => path55.join(stateDir2(env), HEAVY_COMMANDS_FILE), HEAVY_SCRIPT, INFO_FLAGS, WATCH_FLAG, WATCH_SCRIPT, sub = (...names) => new Set(names), TOOLS, PM_VALUES, baseName2 = (word) => (word?.split(/[\\/]/u).at(-1) ?? "").toLowerCase().replace(/\.(?:exe|cmd|bat|ps1)$/u, ""), WORKIT, PYTHONS, NPM_INSTALL, NPM_RUN, NPM_TEST, EXEC, globWord = (word) => new RegExp(`^${word.replace(/[.+?^${}()|[\]\\]/gu, "\\$&").replaceAll("*", ".*")}$`, "u"), matches2 = (matchers, words) => matchers.length <= words.length && matchers.every((matcher, index) => index === 0 ? matcher.test(words[0]) || matcher.test(baseName2(words[0])) : matcher.test(words[index])), readJson2 = (file) => {
+var HEAVY_COMMANDS_FILE = "heavy-commands.json", heavyCommandsFile = (env) => path57.join(stateDir2(env), HEAVY_COMMANDS_FILE), HEAVY_SCRIPT, INFO_FLAGS, WATCH_FLAG, WATCH_SCRIPT, sub = (...names) => new Set(names), TOOLS, PM_VALUES, baseName2 = (word) => (word?.split(/[\\/]/u).at(-1) ?? "").toLowerCase().replace(/\.(?:exe|cmd|bat|ps1)$/u, ""), WORKIT, PYTHONS, NPM_INSTALL, NPM_RUN, NPM_TEST, EXEC, globWord = (word) => new RegExp(`^${word.replace(/[.+?^${}()|[\]\\]/gu, "\\$&").replaceAll("*", ".*")}$`, "u"), matches2 = (matchers, words) => matchers.length <= words.length && matchers.every((matcher, index) => index === 0 ? matcher.test(words[0]) || matcher.test(baseName2(words[0])) : matcher.test(words[index])), readJson2 = (file) => {
   try {
     return JSON.parse(fs23.readFileSync(file, "utf8"));
   } catch {
@@ -79285,8 +79662,8 @@ var init_heavy = __esm(() => {
 // packages/workit-core/src/core/resources.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
 import fs24 from "node:fs";
-import os21 from "node:os";
-import path56 from "node:path";
+import os23 from "node:os";
+import path58 from "node:path";
 function memoryValue(value, host) {
   const text = typeof value === "number" ? String(value) : typeof value === "string" ? value : "";
   const percent = PERCENT.exec(text.trim());
@@ -79412,7 +79789,7 @@ function scopeBusy(unit) {
     return false;
   const uid = process.getuid?.() ?? 0;
   const manager = `/sys/fs/cgroup/user.slice/user-${uid}.slice/user@${uid}.service`;
-  return [`${manager}/app.slice/${unit}`, `${manager}/${unit}`].some((dir) => (readText5(`${dir}/cgroup.procs`) ?? "").trim() !== "");
+  return [`${manager}/app.slice/${unit}`, `${manager}/${unit}`].some((dir) => (readText6(`${dir}/cgroup.procs`) ?? "").trim() !== "");
 }
 function isAncestor(pid) {
   if (process.platform !== "linux")
@@ -79469,7 +79846,7 @@ function reclaim(file, stale) {
     } catch {
       return true;
     }
-    if (!stale(parseLease(readText5(file)), ageMs))
+    if (!stale(parseLease(readText6(file)), ageMs))
       return false;
     fs24.rmSync(file, { force: true });
     return true;
@@ -79482,7 +79859,7 @@ function tryOnce(options, record, reclaimed) {
   const text = `${JSON.stringify(record)}
 `;
   for (let slot = 0;slot < options.slots; slot += 1) {
-    const file = path56.join(options.dir, `slot-${slot}.json`);
+    const file = path58.join(options.dir, `slot-${slot}.json`);
     for (let attempt = 0;attempt < 2; attempt += 1) {
       try {
         const fd = fs24.openSync(file, "wx", 384);
@@ -79496,7 +79873,7 @@ function tryOnce(options, record, reclaimed) {
         if (error.code !== "EEXIST")
           throw error;
       }
-      const lease = parseLease(readText5(file));
+      const lease = parseLease(readText6(file));
       let reason = null;
       const removed = reclaim(file, (current, ageMs) => {
         reason = current ? staleReason(current, options.probe) : ageMs > UNREADABLE_TTL_MS ? "unreadable" : null;
@@ -79515,7 +79892,7 @@ function tryOnce(options, record, reclaimed) {
   return { holders };
 }
 function removeOwn(file, id) {
-  if (parseLease(readText5(file))?.id === id)
+  if (parseLease(readText6(file))?.id === id)
     fs24.rmSync(file, { force: true });
 }
 function leaseQueue(dir, probe = {}) {
@@ -79527,8 +79904,8 @@ function leaseQueue(dir, probe = {}) {
   }
   const entries = [];
   for (const name of names.filter((item) => item.endsWith(".json")).toSorted()) {
-    const file = path56.join(queueDir(dir), name);
-    const record = parseLease(readText5(file));
+    const file = path58.join(queueDir(dir), name);
+    const record = parseLease(readText6(file));
     if (!record)
       continue;
     entries.push({
@@ -79543,9 +79920,9 @@ function leaseQueue(dir, probe = {}) {
 function waitersAhead(options, own) {
   let ahead = 0;
   for (const entry of leaseQueue(options.dir, options.probe)) {
-    if (path56.basename(entry.file) >= own)
+    if (path58.basename(entry.file) >= own)
       break;
-    if (!TICKET.test(path56.basename(entry.file)))
+    if (!TICKET.test(path58.basename(entry.file)))
       continue;
     if (entry.stale && reclaim(entry.file, (current) => !current || staleReason(current, options.probe) !== null))
       continue;
@@ -79557,7 +79934,7 @@ function liveHolders(options) {
   return leaseSlots(options.dir, options.slots, options.probe).filter((slot) => slot.holder && !slot.stale).map((slot) => slot.holder);
 }
 function writeTicket(file, record) {
-  fs24.mkdirSync(path56.dirname(file), { recursive: true, mode: 448 });
+  fs24.mkdirSync(path58.dirname(file), { recursive: true, mode: 448 });
   fs24.writeFileSync(file, `${JSON.stringify(record)}
 `, { mode: 384 });
 }
@@ -79602,7 +79979,7 @@ async function acquireLease(options) {
   const reclaimed = [];
   let waitedOn = [];
   const name = ticketName(started, record.id);
-  const ticket = path56.join(queueDir(options.dir), name);
+  const ticket = path58.join(queueDir(options.dir), name);
   const ticketRecord = {
     ...record,
     maxAgeMs: options.waitMs + 60000
@@ -79703,7 +80080,7 @@ async function acquireLease(options) {
 function updateLease(lease, patch) {
   Object.assign(lease.record, patch);
   try {
-    if (parseLease(readText5(lease.file))?.id !== lease.record.id)
+    if (parseLease(readText6(lease.file))?.id !== lease.record.id)
       return;
     const temp = `${lease.file}.${process.pid}.tmp`;
     fs24.writeFileSync(temp, `${JSON.stringify(lease.record)}
@@ -79723,7 +80100,7 @@ function heldLease(dir, id, options = {}) {
   for (const name of names) {
     if (!/^slot-\d+\.json$/u.test(name))
       continue;
-    const lease = parseLease(readText5(path56.join(dir, name)));
+    const lease = parseLease(readText6(path58.join(dir, name)));
     if (lease?.id === id && !staleReason(lease, options.probe) && (options.ancestor ?? isAncestor)(lease.pid))
       return lease;
   }
@@ -79778,10 +80155,10 @@ async function runScoped(run, wrapper, sinks) {
 }
 function firstNotice(env, session, key, now = Date.now()) {
   const id = (session ?? `ppid-${process.ppid}`).replace(/[^A-Za-z0-9_.-]/gu, "_").slice(0, 120);
-  const dir = path56.join(stateDir2(env), "notices");
+  const dir = path58.join(stateDir2(env), "notices");
   try {
     fs24.mkdirSync(dir, { recursive: true, mode: 448 });
-    fs24.writeFileSync(path56.join(dir, `${key}-${id}`), `${new Date(now).toISOString()}
+    fs24.writeFileSync(path58.join(dir, `${key}-${id}`), `${new Date(now).toISOString()}
 `, {
       flag: "wx",
       mode: 384
@@ -79791,7 +80168,7 @@ function firstNotice(env, session, key, now = Date.now()) {
   }
   try {
     for (const name of fs24.readdirSync(dir)) {
-      const file = path56.join(dir, name);
+      const file = path58.join(dir, name);
       if (now - fs24.statSync(file).mtimeMs > NOTICE_TTL_MS)
         fs24.rmSync(file, { force: true });
     }
@@ -79801,7 +80178,7 @@ function firstNotice(env, session, key, now = Date.now()) {
 function leaseSlots(dir, slots, probe = {}) {
   const states = [];
   for (let slot = 0;slot < slots; slot += 1) {
-    const lease = parseLease(readText5(path56.join(dir, `slot-${slot}.json`)));
+    const lease = parseLease(readText6(path58.join(dir, `slot-${slot}.json`)));
     states.push({
       slot,
       holder: lease ? holderOf(lease) : null,
@@ -79811,16 +80188,16 @@ function leaseSlots(dir, slots, probe = {}) {
   return states;
 }
 var DEFAULT_HEAVY_CHECKS, DEFAULT_LIGHT_CHECKS, DEFAULT_SLOTS = 1, DEFAULT_WAIT_S = 1800, DEFAULT_MEMORY_SHARE = 0.4, DEFAULT_CPU_SHARE = 0.7, MAX_SLOTS = 64, UNREADABLE_TTL_MS = 30000, GUARD_TTL_MS = 30000, hostShape = () => ({
-  totalMemBytes: os21.totalmem(),
-  cpus: Math.max(1, os21.availableParallelism?.() ?? os21.cpus().length)
-}), isRecord9 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), SIZE, PERCENT, UNITS, leaseDir = (env) => path56.join(stateDir2(env), "leases"), readText5 = (file) => {
+  totalMemBytes: os23.totalmem(),
+  cpus: Math.max(1, os23.availableParallelism?.() ?? os23.cpus().length)
+}), isRecord9 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), SIZE, PERCENT, UNITS, leaseDir = (env) => path58.join(stateDir2(env), "leases"), readText6 = (file) => {
   try {
     return fs24.readFileSync(file, "utf8");
   } catch {
     return null;
   }
-}, bootId = () => readText5("/proc/sys/kernel/random/boot_id")?.trim() || null, bootTime = () => Math.round((Date.now() - os21.uptime() * 1000) / 1000) * 1000, BOOT_SLACK_MS = 120000, statFields = (pid) => {
-  const stat = readText5(`/proc/${pid}/stat`);
+}, bootId = () => readText6("/proc/sys/kernel/random/boot_id")?.trim() || null, bootTime = () => Math.round((Date.now() - os23.uptime() * 1000) / 1000) * 1000, BOOT_SLACK_MS = 120000, statFields = (pid) => {
+  const stat = readText6(`/proc/${pid}/stat`);
   return stat ? stat.slice(stat.lastIndexOf(")") + 2).split(" ") : null;
 }, processStart = (pid) => statFields(pid)?.[19] ?? null, pidAlive2 = (pid) => {
   try {
@@ -79844,7 +80221,7 @@ var DEFAULT_HEAVY_CHECKS, DEFAULT_LIGHT_CHECKS, DEFAULT_SLOTS = 1, DEFAULT_WAIT_
   cwd: lease.cwd,
   session: lease.session,
   startedAt: lease.startedAt
-}), realClock, queueDir = (dir) => path56.join(dir, "queue"), TICKET, ticketName = (now, id) => `${String(now).padStart(15, "0")}-${String(process.hrtime.bigint() % 10n ** 16n).padStart(16, "0")}-${id}.json`, SCOPE_START_FAILURE, NOTICE_TTL_MS;
+}), realClock, queueDir = (dir) => path58.join(dir, "queue"), TICKET, ticketName = (now, id) => `${String(now).padStart(15, "0")}-${String(process.hrtime.bigint() % 10n ** 16n).padStart(16, "0")}-${id}.json`, SCOPE_START_FAILURE, NOTICE_TTL_MS;
 var init_resources = __esm(() => {
   init_checks3();
   init_heavy();
@@ -79873,8 +80250,8 @@ __export(exports_check, {
   run: () => run12,
   workspaceResources: () => workspaceResources
 });
-import os22 from "node:os";
-import path57 from "node:path";
+import os24 from "node:os";
+import path59 from "node:path";
 function parse6(argv) {
   const split = argv.indexOf("--");
   const head = split >= 0 ? argv.slice(0, split) : [...argv];
@@ -80105,7 +80482,7 @@ ${footer}`;
 }
 async function workspaceResources(io) {
   const env = io.env;
-  const dir = env.WORKFLOW_TOOLKIT_CONFIG ?? env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path57.join(env.XDG_CONFIG_HOME || path57.join(env.HOME || os22.homedir(), ".config"), "workit");
+  const dir = env.WORKFLOW_TOOLKIT_CONFIG ?? env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path59.join(env.XDG_CONFIG_HOME || path59.join(env.HOME || os24.homedir(), ".config"), "workit");
   try {
     await Promise.resolve().then(() => init_workspaces());
     const workspace = resolveWorkspaceFrom(io.cwd, dir, env.WORKFLOW_WORKSPACE_NAME?.trim() || undefined);
@@ -80247,7 +80624,7 @@ async function run12(argv, io) {
     if (options.shell && command.length !== 1)
       return emit(io, fail2("invalid_input", '--shell takes the command as one string: workit check --shell -- "<cmd>"'));
   }
-  const relCwd = posix(path57.relative(top, runCwd));
+  const relCwd = posix(path59.relative(top, runCwd));
   const configured = !options.shell && matchesNamedCheck(config, name, command, relCwd);
   const shadowed = !configured && name !== null ? config.checks.find((item) => item.name === name) : undefined;
   if (shadowed)
@@ -80312,7 +80689,7 @@ async function run12(argv, io) {
   const modifiedWorktree = key.tree !== null && treeAfter !== key.tree;
   const store = storeRoot(io.cwd);
   const blob = store.ok ? storeLog(store.value.root, result.log) : null;
-  const logPath = store.ok && blob ? path57.join(store.value.root, blob.ref) : null;
+  const logPath = store.ok && blob ? path59.join(store.value.root, blob.ref) : null;
   const tail = tailLines(result.log, TAIL_LINES);
   const passed = result.exitCode === 0 && !result.timedOut;
   const bounded = boundedArgv(command);
@@ -80427,7 +80804,7 @@ async function run12(argv, io) {
     return recordError.code === "busy" ? 4 : recordError.code === "invalid_input" ? 2 : 5;
   return 0;
 }
-var USAGE6 = 'workit check <name> [--full] [--wait <dur> | --no-wait] [--no-lease --reason "<why>"] | workit check [--name <n>] [--shell] [--heavy] [--full] [--wait <dur> | --no-wait] [--timeout <s>] [--task <id>] [--json] -- <cmd…>', OUTPUT_LINES = 60, MAX_UNVERIFIED_RUN_MS, RECORD_TAIL_LINES = 20, RECORD_TAIL_CHARS = 200, posix = (value) => value.split(path57.sep).join("/") || ".", ENGINE_CODES2, FINGERPRINT_VARS, ANSI_COLOR, WARNING_LINE, NO_WARNINGS, STDERR_TAIL_LINES = 10, STDERR_KEEP_CHARS = 65536, FAILURE_LINE, MAX_FAILURE_LINES = 15;
+var USAGE6 = 'workit check <name> [--full] [--wait <dur> | --no-wait] [--no-lease --reason "<why>"] | workit check [--name <n>] [--shell] [--heavy] [--full] [--wait <dur> | --no-wait] [--timeout <s>] [--task <id>] [--json] -- <cmd…>', OUTPUT_LINES = 60, MAX_UNVERIFIED_RUN_MS, RECORD_TAIL_LINES = 20, RECORD_TAIL_CHARS = 200, posix = (value) => value.split(path59.sep).join("/") || ".", ENGINE_CODES2, FINGERPRINT_VARS, ANSI_COLOR, WARNING_LINE, NO_WARNINGS, STDERR_TAIL_LINES = 10, STDERR_KEEP_CHARS = 65536, FAILURE_LINE, MAX_FAILURE_LINES = 15;
 var init_check2 = __esm(() => {
   init_check_config();
   init_checks3();
@@ -80458,7 +80835,7 @@ __export(exports_lock, {
   run: () => run13
 });
 import fs25 from "node:fs";
-import path58 from "node:path";
+import path60 from "node:path";
 async function settingsFor(io) {
   const workspace = await workspaceResources(io);
   const config = loadCheckConfig(io.cwd);
@@ -80550,7 +80927,7 @@ function readPatterns(file) {
   return { patterns: [] };
 }
 function writePatterns(file, value) {
-  fs25.mkdirSync(path58.dirname(file), { recursive: true, mode: 448 });
+  fs25.mkdirSync(path60.dirname(file), { recursive: true, mode: 448 });
   const temp = `${file}.${process.pid}.tmp`;
   fs25.writeFileSync(temp, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
@@ -80636,9 +81013,9 @@ var exports_models = {};
 __export(exports_models, {
   run: () => run14
 });
-import { existsSync as existsSync25, readdirSync as readdirSync13, readFileSync as readFileSync26, statSync as statSync9 } from "node:fs";
-import os23 from "node:os";
-import path59 from "node:path";
+import { existsSync as existsSync26, readdirSync as readdirSync13, readFileSync as readFileSync27, statSync as statSync9 } from "node:fs";
+import os25 from "node:os";
+import path61 from "node:path";
 async function run14(argv, io) {
   const [sub, ...args] = argv.filter((arg) => arg !== "--json");
   if (sub !== "show")
@@ -80699,7 +81076,7 @@ var USAGE8 = "workit models show [--role <role>] [--tier <tier>] [--host <host>]
   const found = new Set;
   let text = "";
   try {
-    text = readFileSync26(file, "utf8");
+    text = readFileSync27(file, "utf8");
   } catch {
     return found;
   }
@@ -80713,26 +81090,26 @@ var USAGE8 = "workit models show [--role <role>] [--tier <tier>] [--host <host>]
       } catch {}
   return found;
 }, matches3 = (ran, configured) => ran.toLowerCase().includes(configured.toLowerCase()), usageReport = (cwd, env, days) => {
-  const projects = path59.join(env.CLAUDE_CONFIG_DIR || path59.join(env.HOME || os23.homedir(), ".claude"), "projects");
+  const projects = path61.join(env.CLAUDE_CONFIG_DIR || path61.join(env.HOME || os25.homedir(), ".claude"), "projects");
   const since = Date.now() - days * 86400000;
   const types = {};
   let agents = 0;
   const dirs = (dir) => {
     try {
-      return readdirSync13(dir).map((name) => path59.join(dir, name));
+      return readdirSync13(dir).map((name) => path61.join(dir, name));
     } catch {
       return [];
     }
   };
   for (const project of dirs(projects))
     for (const session of dirs(project))
-      for (const meta of dirs(path59.join(session, "subagents")).filter((f) => f.endsWith(".meta.json"))) {
+      for (const meta of dirs(path61.join(session, "subagents")).filter((f) => f.endsWith(".meta.json"))) {
         try {
           if (statSync9(meta).mtimeMs < since)
             continue;
-          const agentType = JSON.parse(readFileSync26(meta, "utf8")).agentType;
+          const agentType = JSON.parse(readFileSync27(meta, "utf8")).agentType;
           const transcript = meta.replace(/\.meta\.json$/, ".jsonl");
-          if (typeof agentType !== "string" || !existsSync25(transcript))
+          if (typeof agentType !== "string" || !existsSync26(transcript))
             continue;
           const ran = modelsOf(transcript);
           if (!ran.size)
@@ -80871,8 +81248,8 @@ var success2 = (data) => ({ ok: true, data }), failure3 = (code, error, unblock)
 
 // packages/workit-core/src/git/ops.ts
 import { spawnSync as spawnSync21 } from "node:child_process";
-import { existsSync as existsSync26, readFileSync as readFileSync27 } from "node:fs";
-import path60 from "node:path";
+import { existsSync as existsSync27, readFileSync as readFileSync28 } from "node:fs";
+import path62 from "node:path";
 function operationInProgress(cwd) {
   const markers = [
     ["rebase-merge", "rebase"],
@@ -80885,18 +81262,18 @@ function operationInProgress(cwd) {
   if (!run.ok)
     return null;
   const found = run.stdout.split(`
-`).map((line) => path60.resolve(cwd, line.trim()));
+`).map((line) => path62.resolve(cwd, line.trim()));
   const conflicted = () => git5(cwd, ["ls-files", "-u"]).stdout.trim() !== "";
   for (const [index, [, operation]] of markers.entries()) {
     const marker = found[index];
-    if (!marker || !existsSync26(marker))
+    if (!marker || !existsSync27(marker))
       continue;
-    if (index === 1 && existsSync26(path60.join(marker, "applying")))
+    if (index === 1 && existsSync27(path62.join(marker, "applying")))
       return { operation: "am", commitAllowed: false, branch: null };
-    if (index === 0 && existsSync26(path60.join(marker, "amend")) && !conflicted()) {
+    if (index === 0 && existsSync27(path62.join(marker, "amend")) && !conflicted()) {
       let headName = "";
       try {
-        headName = readFileSync27(path60.join(marker, "head-name"), "utf8").trim();
+        headName = readFileSync28(path62.join(marker, "head-name"), "utf8").trim();
       } catch {}
       const branch = headName.startsWith("refs/heads/") ? headName.slice("refs/heads/".length) : null;
       return { operation, commitAllowed: branch !== null, branch };
@@ -81231,7 +81608,7 @@ function gitCommit(cwd, input) {
     if (paths.some((value) => value.startsWith("-") || !value.trim()))
       return failure3("invalid_input", "paths must not be empty or start with -");
     const tracked = new Set(nulList(git5(cwd, ["ls-files", "-z", "--", ...paths]).stdout));
-    const addable = paths.filter((value) => existsSync26(path60.resolve(cwd, value)) || [...tracked].some((file) => file === value || file.startsWith(`${value}/`)));
+    const addable = paths.filter((value) => existsSync27(path62.resolve(cwd, value)) || [...tracked].some((file) => file === value || file.startsWith(`${value}/`)));
     if (addable.length) {
       const added = git5(cwd, ["add", "-A", "--", ...addable]);
       if (!added.ok)
@@ -81772,12 +82149,12 @@ var init_ops = __esm(() => {
 
 // packages/workit-core/src/verdict-cover.ts
 import fs26 from "node:fs";
-import path61 from "node:path";
+import path63 from "node:path";
 function chainsAbove(cwd, branch) {
   const root = storeRoot(cwd);
   if (!root.ok)
     return [];
-  const dir = path61.join(root.value.root, "stacks");
+  const dir = path63.join(root.value.root, "stacks");
   let names = [];
   try {
     names = fs26.readdirSync(dir).filter((name) => name.endsWith(".json"));
@@ -81788,7 +82165,7 @@ function chainsAbove(cwd, branch) {
   for (const name of names.toSorted()) {
     let parsed;
     try {
-      parsed = JSON.parse(fs26.readFileSync(path61.join(dir, name), "utf8"));
+      parsed = JSON.parse(fs26.readFileSync(path63.join(dir, name), "utf8"));
     } catch {
       continue;
     }
@@ -81944,10 +82321,10 @@ var init_check_evidence = __esm(() => {
 
 // packages/workit-core/src/forge/reruns.ts
 import fs27 from "node:fs";
-import path62 from "node:path";
+import path64 from "node:path";
 function rerunLogPath(cwd) {
   const common = gitCommonDir(cwd);
-  return common ? path62.join(common, "workit", "ci-reruns.jsonl") : null;
+  return common ? path64.join(common, "workit", "ci-reruns.jsonl") : null;
 }
 function rerunCounts(cwd, key) {
   const counts = new Map;
@@ -81982,7 +82359,7 @@ function recordReruns(cwd, rows) {
   if (!file)
     return false;
   try {
-    fs27.mkdirSync(path62.dirname(file), { recursive: true });
+    fs27.mkdirSync(path64.dirname(file), { recursive: true });
     fs27.appendFileSync(file, rows.map((row) => `${JSON.stringify(row)}
 `).join(""));
     return true;
@@ -81995,7 +82372,7 @@ function withRerunLock(cwd, fn) {
   if (!file)
     return fn();
   const lock = `${file.slice(0, -".jsonl".length)}.lock`;
-  fs27.mkdirSync(path62.dirname(lock), { recursive: true });
+  fs27.mkdirSync(path64.dirname(lock), { recursive: true });
   const until = Date.now() + LOCK_WAIT_MS2;
   for (;; ) {
     try {
@@ -82991,7 +83368,7 @@ var init_pr_ops = __esm(() => {
 import { spawnSync as spawnSync23 } from "node:child_process";
 import { createHash as createHash18, randomBytes as randomBytes4 } from "node:crypto";
 import fs28 from "node:fs";
-import path63 from "node:path";
+import path65 from "node:path";
 function worktreeOf(cwd, branch) {
   const list = gitRun3(cwd, ["worktree", "list", "--porcelain"]);
   if (!list.ok)
@@ -83040,7 +83417,7 @@ function gitRestack(cwd, input) {
         error: "no store root"
       };
     fs28.mkdirSync(scratch, { recursive: true });
-    dir = path63.join(scratch, `${input.branch.replace(/[^A-Za-z0-9._-]+/gu, "_").slice(0, 40)}-${randomBytes4(4).toString("hex")}`);
+    dir = path65.join(scratch, `${input.branch.replace(/[^A-Za-z0-9._-]+/gu, "_").slice(0, 40)}-${randomBytes4(4).toString("hex")}`);
     const added = gitRun3(cwd, ["worktree", "add", "-q", dir, input.branch], GIT_TIMEOUTS.worktree);
     if (!added.ok)
       return {
@@ -83096,7 +83473,7 @@ function pruneScratch(cwd) {
   if (!scratch || !fs28.existsSync(scratch))
     return;
   for (const name of fs28.readdirSync(scratch)) {
-    const dir = path63.join(scratch, name);
+    const dir = path65.join(scratch, name);
     if (!rebaseInProgress(dir) && !trackedDirt(dir))
       gitRun3(cwd, ["worktree", "remove", "--force", dir]);
   }
@@ -83106,7 +83483,7 @@ function stacksDir(cwd) {
   const root = storeRoot(cwd);
   if (!root.ok)
     return stackFail(root.code, root.error, root.unblock);
-  return { ok: true, data: path63.join(root.value.root, "stacks") };
+  return { ok: true, data: path65.join(root.value.root, "stacks") };
 }
 function parseStack(raw) {
   if (!isRecord12(raw) || !Array.isArray(raw.branches))
@@ -83158,7 +83535,7 @@ function readStack(cwd, name) {
   const dir = stacksDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path63.join(dir.data, fileFor(name));
+  const file = path65.join(dir.data, fileFor(name));
   let text;
   try {
     text = fs28.readFileSync(file, "utf8");
@@ -83179,7 +83556,7 @@ function writeStack(cwd, stack, now = new Date) {
   const dir = stacksDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path63.join(dir.data, fileFor(stack.name));
+  const file = path65.join(dir.data, fileFor(stack.name));
   const temp = `${file}.${process.pid}.tmp`;
   try {
     fs28.mkdirSync(dir.data, { recursive: true });
@@ -83207,7 +83584,7 @@ function listStacks(cwd) {
   for (const name of names) {
     let parsed = null;
     try {
-      parsed = parseStack(JSON.parse(fs28.readFileSync(path63.join(dir.data, name), "utf8")));
+      parsed = parseStack(JSON.parse(fs28.readFileSync(path65.join(dir.data, name), "utf8")));
     } catch {
       parsed = null;
     }
@@ -83269,7 +83646,7 @@ function takeLock(lock) {
     host: localLockHost(),
     nonce: randomBytes4(8).toString("hex")
   };
-  fs28.writeFileSync(path63.join(lock, OWNER), JSON.stringify(owner));
+  fs28.writeFileSync(path65.join(lock, OWNER), JSON.stringify(owner));
   return owner;
 }
 function reapLock(lock, observed) {
@@ -83306,7 +83683,7 @@ async function withStackLock(cwd, name, fn, waitMs = LOCK_WAIT_MS3) {
     return dir;
   if (!validName(name))
     return stackFail("invalid_input", "a stack name must be 1-200 printable characters");
-  const lock = path63.join(dir.data, `${fileFor(name)}.lock`);
+  const lock = path65.join(dir.data, `${fileFor(name)}.lock`);
   try {
     fs28.mkdirSync(dir.data, { recursive: true });
   } catch (error) {
@@ -83336,7 +83713,7 @@ async function withStackLock(cwd, name, fn, waitMs = LOCK_WAIT_MS3) {
   const touch = () => {
     try {
       const now = new Date;
-      fs28.utimesSync(path63.join(lock, OWNER), now, now);
+      fs28.utimesSync(path65.join(lock, OWNER), now, now);
     } catch {}
   };
   const beat = setInterval(touch, HEARTBEAT_MS);
@@ -84305,7 +84682,7 @@ var STACK_VERSION = 1, stackFail = (code, error, unblock, data) => ({
   return !status.ok || status.stdout.trim() !== "";
 }, scratchDir = (cwd) => {
   const dir = stacksDir(cwd);
-  return dir.ok ? path63.join(dir.data, "worktrees") : null;
+  return dir.ok ? path65.join(dir.data, "worktrees") : null;
 }, firstLine = (run) => (`${run.stderr}
 ${run.stdout}`.split(`
 `).find((line) => line.trim()) ?? "git failed").trim().slice(0, 300), stackFileName = (name) => `${name.replace(/[^A-Za-z0-9._-]+/gu, "_").replace(/^[._]+/u, "").slice(0, 48).toLowerCase()}-${createHash18("sha256").update(name).digest("hex").slice(0, 12)}.json`, fileFor, validName = (name) => {
@@ -84320,12 +84697,12 @@ ${run.stdout}`.split(`
 }, isRecord12 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), str3 = (value) => typeof value === "string" && value ? value : null, LOCK_WAIT_MS3 = 2000, HEARTBEAT_MS = 20000, HEARTBEAT_STALE_MS, OWNERLESS_STALE_MS = 30000, OWNER = "owner", readOwner = (lock) => {
   let raw = null;
   try {
-    raw = fs28.readFileSync(path63.join(lock, OWNER), "utf8");
+    raw = fs28.readFileSync(path65.join(lock, OWNER), "utf8");
   } catch {
     raw = null;
   }
   let age = null;
-  for (const target of [path63.join(lock, OWNER), lock])
+  for (const target of [path65.join(lock, OWNER), lock])
     try {
       age = Date.now() - fs28.statSync(target).mtimeMs;
       break;
@@ -84369,7 +84746,7 @@ var init_stack = __esm(() => {
 import { spawnSync as spawnSync24 } from "node:child_process";
 import { createHash as createHash19 } from "node:crypto";
 import fs29 from "node:fs";
-import path64 from "node:path";
+import path66 from "node:path";
 function expandBraces2(pattern, limit = 64) {
   for (let index = 0;index < pattern.length; index += 1) {
     if (pattern[index] === "\\") {
@@ -84615,7 +84992,7 @@ function parsePlan(raw, defaults, name) {
       id,
       branch,
       base: optional("base") ?? "",
-      worktree: path64.resolve(defaults.root, optional("worktree") ?? path64.join(defaults.worktreeRoot, id)),
+      worktree: path66.resolve(defaults.root, optional("worktree") ?? path66.join(defaults.worktreeRoot, id)),
       tier,
       reason,
       dependsOn: [...new Set(dependsOn ?? [])],
@@ -84744,12 +85121,12 @@ function regeneratedFiles(root, tracked) {
   const found = new Map;
   let scripts;
   try {
-    const manifest = JSON.parse(fs29.readFileSync(path64.join(root, "package.json"), "utf8"));
+    const manifest = JSON.parse(fs29.readFileSync(path66.join(root, "package.json"), "utf8"));
     scripts = manifest.scripts ?? {};
   } catch {
     return found;
   }
-  const runner = fs29.existsSync(path64.join(root, "bun.lock")) ? "bun run" : fs29.existsSync(path64.join(root, "pnpm-lock.yaml")) ? "pnpm run" : fs29.existsSync(path64.join(root, "yarn.lock")) ? "yarn run" : "npm run";
+  const runner = fs29.existsSync(path66.join(root, "bun.lock")) ? "bun run" : fs29.existsSync(path66.join(root, "pnpm-lock.yaml")) ? "pnpm run" : fs29.existsSync(path66.join(root, "yarn.lock")) ? "yarn run" : "npm run";
   const outputs = tracked.filter((file) => !CODE.test(file));
   for (const [name, command] of Object.entries(scripts)) {
     if (!name.startsWith("write:") || typeof command !== "string")
@@ -84757,7 +85134,7 @@ function regeneratedFiles(root, tracked) {
     for (const file of command.match(/[\w./-]+\.[cm]?[jt]s\b/gu) ?? []) {
       let source;
       try {
-        source = fs29.readFileSync(path64.join(root, file), "utf8");
+        source = fs29.readFileSync(path66.join(root, file), "utf8");
       } catch {
         continue;
       }
@@ -84879,11 +85256,11 @@ function defaultTrunk(cwd) {
 }
 function mainCheckout(cwd) {
   const common = gitCommonDir(cwd);
-  return common && path64.basename(common) === ".git" ? path64.dirname(common) : path64.resolve(cwd);
+  return common && path66.basename(common) === ".git" ? path66.dirname(common) : path66.resolve(cwd);
 }
 function worktreeRoot(cwd) {
   const main = mainCheckout(cwd);
-  return path64.join(path64.dirname(main), `${path64.basename(main)}-wt`);
+  return path66.join(path66.dirname(main), `${path66.basename(main)}-wt`);
 }
 function sliceHash(slice) {
   const {
@@ -84903,7 +85280,7 @@ function fanoutsDir(cwd) {
   const root = storeRoot(cwd);
   if (!root.ok)
     return fanoutFail(root.code, root.error, root.unblock);
-  return { ok: true, data: path64.join(root.value.root, "fanouts") };
+  return { ok: true, data: path66.join(root.value.root, "fanouts") };
 }
 function parseStored(raw) {
   if (!isRecord13(raw) || typeof raw.name !== "string" || typeof raw.trunk !== "string")
@@ -84971,7 +85348,7 @@ function readFanout(cwd, name) {
   const dir = fanoutsDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path64.join(dir.data, stackFileName(name));
+  const file = path66.join(dir.data, stackFileName(name));
   let parsed = null;
   try {
     parsed = parseStored(JSON.parse(fs29.readFileSync(file, "utf8")));
@@ -84996,7 +85373,7 @@ function listFanouts(cwd) {
   for (const entry of names) {
     let parsed = null;
     try {
-      parsed = parseStored(JSON.parse(fs29.readFileSync(path64.join(dir.data, entry), "utf8")));
+      parsed = parseStored(JSON.parse(fs29.readFileSync(path66.join(dir.data, entry), "utf8")));
     } catch {
       parsed = null;
     }
@@ -85035,7 +85412,7 @@ function writeFanout(cwd, plan) {
   const dir = fanoutsDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path64.join(dir.data, stackFileName(plan.name));
+  const file = path66.join(dir.data, stackFileName(plan.name));
   const temp = `${file}.${process.pid}.tmp`;
   try {
     fs29.mkdirSync(dir.data, { recursive: true });
@@ -85246,13 +85623,13 @@ var init_fanout = __esm(() => {
 // packages/workit-core/src/forge/exec.ts
 import { spawnSync as spawnSync25 } from "node:child_process";
 import fs30 from "node:fs";
-import path65 from "node:path";
+import path67 from "node:path";
 function findExecutable(bin, env) {
-  const dirs = (env.PATH ?? env.Path ?? "").split(path65.delimiter).filter(Boolean);
+  const dirs = (env.PATH ?? env.Path ?? "").split(path67.delimiter).filter(Boolean);
   const exts = process.platform === "win32" ? [".exe"] : [""];
   for (const dir of dirs)
     for (const ext of exts) {
-      const candidate = path65.join(dir, `${bin}${ext}`);
+      const candidate = path67.join(dir, `${bin}${ext}`);
       try {
         const stat = fs30.statSync(candidate);
         if (stat.isFile())
@@ -87042,7 +87419,7 @@ var init_live_session = __esm(() => {
 });
 
 // packages/workit-core/src/hooks/write-gate.ts
-import path66 from "node:path";
+import path68 from "node:path";
 var CASE_INSENSITIVE, PREFIXES2, SCRIPT_SHELLS, cache3, MUTATING_GIT, DRY_N, MUTATING_WORKIT_GIT, CD2, PUSHD2, POPD2, UNKNOWN_DIR;
 var init_write_gate = __esm(() => {
   init_task_store();
@@ -87082,7 +87459,7 @@ var init_write_gate = __esm(() => {
   CD2 = new Set(["cd", "chdir", "set-location", "sl"]);
   PUSHD2 = new Set(["pushd", "push-location"]);
   POPD2 = new Set(["popd", "pop-location"]);
-  UNKNOWN_DIR = path66.resolve(path66.parse(process.cwd()).root, ".workit-unknown-dir");
+  UNKNOWN_DIR = path68.resolve(path68.parse(process.cwd()).root, ".workit-unknown-dir");
 });
 
 // packages/workit-core/src/hooks/worktree-confine.ts
@@ -87107,20 +87484,20 @@ var init_worktree_confine = __esm(() => {
 
 // packages/workit-core/src/worktree-deps.ts
 import fs31 from "node:fs";
-import path67 from "node:path";
+import path69 from "node:path";
 function moduleDirs(main) {
   const out = [];
   const walk = (relative, depth) => {
     let entries;
     try {
-      entries = fs31.readdirSync(path67.join(main, relative), { withFileTypes: true });
+      entries = fs31.readdirSync(path69.join(main, relative), { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const child = path67.join(relative, entry.name);
+      const child = path69.join(relative, entry.name);
       if (entry.name === MODULES)
         out.push(child);
       else if (depth < MAX_DEPTH2 && !entry.name.startsWith("."))
@@ -87134,8 +87511,8 @@ function linkEntry(main, worktree, source, target) {
   const stat = fs31.lstatSync(source);
   if (stat.isSymbolicLink()) {
     const link = fs31.readlinkSync(source);
-    const outside = path67.isAbsolute(link) && within(link, main) && !path67.relative(main, link).split(path67.sep).includes(MODULES);
-    const to = outside ? path67.join(worktree, path67.relative(main, link)) : link;
+    const outside = path69.isAbsolute(link) && within(link, main) && !path69.relative(main, link).split(path69.sep).includes(MODULES);
+    const to = outside ? path69.join(worktree, path69.relative(main, link)) : link;
     fs31.symlinkSync(to, target, process.platform === "win32" ? "junction" : undefined);
     return;
   }
@@ -87145,8 +87522,8 @@ function mirror(main, worktree, source, target, top) {
   fs31.mkdirSync(target);
   let count = 0;
   for (const entry of fs31.readdirSync(source, { withFileTypes: true })) {
-    const from = path67.join(source, entry.name);
-    const to = path67.join(target, entry.name);
+    const from = path69.join(source, entry.name);
+    const to = path69.join(target, entry.name);
     if (top && entry.isDirectory() && (entry.name.startsWith("@") || entry.name === ".bin"))
       count += mirror(main, worktree, from, to, false);
     else {
@@ -87162,16 +87539,16 @@ function linkWorktreeDependencies(main, worktree) {
   const dirs = [];
   let entries = 0;
   for (const relative of moduleDirs(main)) {
-    const target = path67.join(worktree, relative);
-    if (!fs31.existsSync(path67.dirname(target)) || fs31.existsSync(target))
+    const target = path69.join(worktree, relative);
+    if (!fs31.existsSync(path69.dirname(target)) || fs31.existsSync(target))
       continue;
-    if (!gitRun4(worktree, ["check-ignore", "-q", `${relative.split(path67.sep).join("/")}/`]).ok) {
-      notes.push(`${relative.split(path67.sep).join("/")} is not ignored by git, so it was not linked from ${main}; install dependencies in the worktree yourself`);
+    if (!gitRun4(worktree, ["check-ignore", "-q", `${relative.split(path69.sep).join("/")}/`]).ok) {
+      notes.push(`${relative.split(path69.sep).join("/")} is not ignored by git, so it was not linked from ${main}; install dependencies in the worktree yourself`);
       continue;
     }
     try {
-      entries += mirror(main, worktree, path67.join(main, relative), target, true);
-      dirs.push(relative.split(path67.sep).join("/"));
+      entries += mirror(main, worktree, path69.join(main, relative), target, true);
+      dirs.push(relative.split(path69.sep).join("/"));
     } catch (error) {
       fs31.rmSync(target, { recursive: true, force: true });
       notes.push(`could not link ${relative} from ${main} (${error.message}); install dependencies in the worktree yourself`);
@@ -87184,8 +87561,8 @@ function linkWorktreeDependencies(main, worktree) {
   return { linked: { from: main, dirs, entries, ms }, notes };
 }
 var MODULES = "node_modules", MAX_DEPTH2 = 2, within = (child, parent) => {
-  const relative = path67.relative(parent, child);
-  return relative === "" || !relative.startsWith("..") && !path67.isAbsolute(relative);
+  const relative = path69.relative(parent, child);
+  return relative === "" || !relative.startsWith("..") && !path69.isAbsolute(relative);
 };
 var init_worktree_deps = __esm(() => {
   init_fanout();
@@ -87194,7 +87571,7 @@ var init_worktree_deps = __esm(() => {
 // packages/workit-core/src/fanout-worktree.ts
 import { randomBytes as randomBytes5 } from "node:crypto";
 import fs32 from "node:fs";
-import path68 from "node:path";
+import path70 from "node:path";
 function rowSample(lines) {
   const out = [];
   let bytes = 0;
@@ -87254,7 +87631,7 @@ function adminDir(worktree) {
   const file = dir.stdout.trim();
   let token = null;
   try {
-    token = fs32.readFileSync(path68.join(file, FANOUT_TOKEN_FILE), "utf8").trim() || null;
+    token = fs32.readFileSync(path70.join(file, FANOUT_TOKEN_FILE), "utf8").trim() || null;
   } catch {
     token = null;
   }
@@ -87262,7 +87639,7 @@ function adminDir(worktree) {
     const stat = worktreeDeps.stat(file);
     return {
       path: file,
-      id: path68.basename(file),
+      id: path70.basename(file),
       ino: stat.ino.toString(),
       token,
       birthMs: stat.birthtimeNs > 0n ? Number(stat.birthtimeMs) : null,
@@ -87278,7 +87655,7 @@ function markAdminDir(worktree) {
     return null;
   const token = randomBytes5(16).toString("hex");
   try {
-    fs32.writeFileSync(path68.join(admin.path, FANOUT_TOKEN_FILE), `${token}
+    fs32.writeFileSync(path70.join(admin.path, FANOUT_TOKEN_FILE), `${token}
 `);
   } catch {
     return null;
@@ -87293,7 +87670,7 @@ function excludeScratch(cwd) {
   const common = gitCommonDir(cwd);
   if (!common)
     return;
-  const file = path68.join(common, "info", "exclude");
+  const file = path70.join(common, "info", "exclude");
   let text = "";
   try {
     text = fs32.readFileSync(file, "utf8");
@@ -87302,7 +87679,7 @@ function excludeScratch(cwd) {
   }
   if (text.split(/\r?\n/u).includes(EXCLUDE_LINE))
     return;
-  fs32.mkdirSync(path68.dirname(file), { recursive: true });
+  fs32.mkdirSync(path70.dirname(file), { recursive: true });
   fs32.appendFileSync(file, `${text && !text.endsWith(`
 `) ? `
 ` : ""}# workit fanout: per-worker scratch dirs
@@ -87311,13 +87688,13 @@ ${EXCLUDE_LINE}
 }
 function worktreeDependencies(main, worktree) {
   for (const [name, install] of LOCKFILES2) {
-    const ours = readBytes(path68.join(main, name));
-    const theirs = readBytes(path68.join(worktree, name));
+    const ours = readBytes(path70.join(main, name));
+    const theirs = readBytes(path70.join(worktree, name));
     if (ours === null && theirs === null)
       continue;
     if (ours !== null && theirs !== null && ours.equals(theirs))
       continue;
-    if (fs32.existsSync(path68.join(worktree, "node_modules")))
+    if (fs32.existsSync(path70.join(worktree, "node_modules")))
       break;
     const command = install(worktree);
     return {
@@ -87329,7 +87706,7 @@ function worktreeDependencies(main, worktree) {
     };
   }
   const stale = staleBunInstall(main);
-  if (stale && !fs32.existsSync(path68.join(worktree, "node_modules"))) {
+  if (stale && !fs32.existsSync(path70.join(worktree, "node_modules"))) {
     const command = `bun install --frozen-lockfile --cwd ${worktree}`;
     return {
       linked: null,
@@ -87342,9 +87719,9 @@ function worktreeDependencies(main, worktree) {
   return { ...linkWorktreeDependencies(main, worktree), install: null };
 }
 function staleBunInstall(main) {
-  if (!fs32.existsSync(path68.join(main, "node_modules")))
+  if (!fs32.existsSync(path70.join(main, "node_modules")))
     return null;
-  const text = readBytes(path68.join(main, "bun.lock"))?.toString("utf8");
+  const text = readBytes(path70.join(main, "bun.lock"))?.toString("utf8");
   if (!text)
     return null;
   let packages;
@@ -87371,7 +87748,7 @@ function staleBunInstall(main) {
     const version = spec.slice(at + 1);
     if (name !== key || version.includes(":"))
       continue;
-    const manifest = readBytes(path68.join(main, "node_modules", key, "package.json"));
+    const manifest = readBytes(path70.join(main, "node_modules", key, "package.json"));
     if (!manifest) {
       problems.push(`${key} missing`);
       continue;
@@ -87388,7 +87765,7 @@ function staleBunInstall(main) {
   return problems.length ? problems.join("; ") : null;
 }
 function ensureScratch(worktree) {
-  const scratch = path68.join(worktree, SCRATCH_DIR);
+  const scratch = path70.join(worktree, SCRATCH_DIR);
   fs32.mkdirSync(scratch, { recursive: true });
   return scratch;
 }
@@ -87662,7 +88039,7 @@ function unpushedCount(cwd, branch) {
   return count.ok ? Number(count.stdout.trim()) : null;
 }
 function removeScratch(worktree) {
-  const scratch = path68.join(worktree, SCRATCH_DIR);
+  const scratch = path70.join(worktree, SCRATCH_DIR);
   let stat;
   try {
     stat = fs32.lstatSync(scratch);
@@ -87678,16 +88055,16 @@ var SLOW, SCRATCH_DIR = ".workit-scratch", EXCLUDE_LINE, DIRTY_ROW_BYTES = 2000,
   try {
     return fs32.realpathSync.native(target);
   } catch {
-    return path68.resolve(target);
+    return path70.resolve(target);
   }
 }, samePath = (a, b) => {
   const left = canonical2(a);
   const right = canonical2(b);
   return process.platform === "win32" || process.platform === "darwin" ? left.toLowerCase() === right.toLowerCase() : left === right;
 }, inside3 = (child, parent) => {
-  const relative = path68.relative(canonical2(parent), canonical2(child));
-  return relative === "" || !relative.startsWith("..") && !path68.isAbsolute(relative);
-}, slicePath = (cwd, slice) => path68.isAbsolute(slice.worktree) ? slice.worktree : path68.resolve(mainCheckout(cwd), slice.worktree), CLOCK_SLACK_MS = 2000, worktreeDeps, LOCKFILES2, readBytes = (file) => {
+  const relative = path70.relative(canonical2(parent), canonical2(child));
+  return relative === "" || !relative.startsWith("..") && !path70.isAbsolute(relative);
+}, slicePath = (cwd, slice) => path70.isAbsolute(slice.worktree) ? slice.worktree : path70.resolve(mainCheckout(cwd), slice.worktree), CLOCK_SLACK_MS = 2000, worktreeDeps, LOCKFILES2, readBytes = (file) => {
   try {
     return fs32.readFileSync(file);
   } catch {
@@ -87719,7 +88096,7 @@ var init_fanout_worktree = __esm(() => {
 
 // packages/workit-core/src/forge/merge-cleanup.ts
 import fs33 from "node:fs";
-import path69 from "node:path";
+import path71 from "node:path";
 function cleanupMergedBranch(cwd, branch, mergedHead) {
   const out = { branchDeleted: false, worktreeRemoved: null, notes: [] };
   if (!branch || branch.startsWith("-"))
@@ -87779,13 +88156,13 @@ var SLOW2, isFanoutWorktree = (worktree) => {
   if (!dir.ok)
     return false;
   try {
-    return fs33.readFileSync(path69.join(dir.stdout.trim(), FANOUT_TOKEN_FILE), "utf8").trim() !== "";
+    return fs33.readFileSync(path71.join(dir.stdout.trim(), FANOUT_TOKEN_FILE), "utf8").trim() !== "";
   } catch {
     return false;
   }
 }, inside4 = (child, parent) => {
-  const relative = path69.relative(fs33.realpathSync.native(parent), fs33.realpathSync.native(child));
-  return relative === "" || !relative.startsWith("..") && !path69.isAbsolute(relative);
+  const relative = path71.relative(fs33.realpathSync.native(parent), fs33.realpathSync.native(child));
+  return relative === "" || !relative.startsWith("..") && !path71.isAbsolute(relative);
 };
 var init_merge_cleanup = __esm(() => {
   init_fanout();
@@ -88066,7 +88443,7 @@ var init_duration = __esm(() => {
 });
 
 // packages/workit-cli/src/verbs/forge-common.ts
-import { readFileSync as readFileSync28 } from "node:fs";
+import { readFileSync as readFileSync29 } from "node:fs";
 function parseFlags(argv, spec) {
   const parsed = { values: {}, booleans: new Set, lists: {}, positionals: [] };
   for (let index = 0;index < argv.length; index += 1) {
@@ -88224,7 +88601,7 @@ var init_forge_common = __esm(() => {
   forgeDeps = {
     runner: undefined,
     npm: undefined,
-    readStdin: () => readFileSync28(0, "utf8"),
+    readStdin: () => readFileSync29(0, "utf8"),
     sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
     now: () => Date.now()
   };
@@ -88236,8 +88613,8 @@ __export(exports_pr, {
   checkPrTitle: () => checkPrTitle,
   run: () => run15
 });
-import { existsSync as existsSync27, readFileSync as readFileSync29 } from "node:fs";
-import path70 from "node:path";
+import { existsSync as existsSync28, readFileSync as readFileSync30 } from "node:fs";
+import path72 from "node:path";
 function titleRules(cwd) {
   let root;
   try {
@@ -88248,16 +88625,16 @@ function titleRules(cwd) {
   let text = null;
   let name = "";
   for (const candidate of COMMITLINT_FILES) {
-    const full = path70.join(root, candidate);
-    if (!existsSync27(full))
+    const full = path72.join(root, candidate);
+    if (!existsSync28(full))
       continue;
-    text = readFileSync29(full, "utf8");
+    text = readFileSync30(full, "utf8");
     name = candidate;
     break;
   }
   if (text === null) {
     try {
-      const pkg = JSON.parse(readFileSync29(path70.join(root, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync30(path72.join(root, "package.json"), "utf8"));
       if (pkg.commitlint === undefined)
         return { rules: null, note: null };
       text = JSON.stringify(pkg.commitlint);
@@ -88354,7 +88731,7 @@ function refuseTitle(io, title, line) {
 function readBodyFile(io, file) {
   try {
     return {
-      body: file === "-" ? forgeDeps.readStdin() : readFileSync29(path70.resolve(io.cwd, file), "utf8")
+      body: file === "-" ? forgeDeps.readStdin() : readFileSync30(path72.resolve(io.cwd, file), "utf8")
     };
   } catch {
     return `cannot read --body-file ${file}`;
@@ -89243,8 +89620,8 @@ var exports_git = {};
 __export(exports_git, {
   run: () => run17
 });
-import { readFileSync as readFileSync30 } from "node:fs";
-import path71 from "node:path";
+import { readFileSync as readFileSync31 } from "node:fs";
+import path73 from "node:path";
 function kindHint(cwd, kind) {
   let kinds = [...BRANCH_KINDS];
   try {
@@ -89348,7 +89725,7 @@ function commitMessage(parsed, io) {
 
 `);
   try {
-    return file === "-" ? readFileSync30(0, "utf8") : readFileSync30(path71.resolve(io.cwd, file), "utf8");
+    return file === "-" ? readFileSync31(0, "utf8") : readFileSync31(path73.resolve(io.cwd, file), "utf8");
   } catch (error) {
     return {
       error: `cannot read -F ${file}: ${error instanceof Error ? error.message : String(error)}`
@@ -90812,7 +91189,7 @@ var init_stack2 = __esm(() => {
 // packages/workit-core/src/fanout-brief.ts
 import { createHash as createHash20 } from "node:crypto";
 import fs35 from "node:fs";
-import path72 from "node:path";
+import path74 from "node:path";
 function workerSession(lead, slice, attempt) {
   const tail = attempt === null ? "" : `+try${attempt}`;
   const full = `${lead}-w-${slice}${tail}`;
@@ -90895,7 +91272,7 @@ function renderBrief(cwd, plan, input) {
     "STANDING:",
     ...standing.length ? standing.map((order) => `  - ${order.what}`) : ["  - none recorded beyond this brief"],
     exists ? `WORKTREE: ${planned}  (made by \`workit fanout worktree create ${slice.id}\`; yours alone)` : `WORKTREE: ${planned}  (not made yet: the lead runs \`workit fanout worktree create ${slice.id}\` before spawning, then renders this brief again)`,
-    ...exists && typeof made?.install === "string" && !fs35.existsSync(path72.join(planned, "node_modules")) ? [`INSTALL: \`${made.install}\` first: the main checkout's node_modules was not linked here`] : [],
+    ...exists && typeof made?.install === "string" && !fs35.existsSync(path74.join(planned, "node_modules")) ? [`INSTALL: \`${made.install}\` first: the main checkout's node_modules was not linked here`] : [],
     ...identityLines(identity, minted),
     ...rules(mode, branch, sliceBase, exists ? planned : null)
   ];
@@ -91437,7 +91814,7 @@ __export(exports_fanout, {
   run: () => run21
 });
 import fs36 from "node:fs";
-import path73 from "node:path";
+import path75 from "node:path";
 function forgeFor(io, offline) {
   if (offline)
     return { forge: null, error: "--offline" };
@@ -91498,7 +91875,7 @@ function plan2(argv, io) {
     return usage4(io, "pass --trunk or --track, not both (--track picks the trunk)", PLAN_USAGE2);
   if (flags.positionals.length !== 1)
     return usage4(io, flags.positionals.length ? `unexpected argument ${flags.positionals[1]}` : "missing <plan.json>", PLAN_USAGE2);
-  const file = path73.resolve(io.cwd, flags.positionals[0]);
+  const file = path75.resolve(io.cwd, flags.positionals[0]);
   let raw;
   try {
     raw = JSON.parse(fs36.readFileSync(file, "utf8"));
@@ -107074,7 +107451,7 @@ var init_ast = __esm(() => {
 
 // packages/workit-cli/src/test-audit/rules.ts
 import { builtinModules } from "node:module";
-import path74 from "node:path";
+import path76 from "node:path";
 function testCallee(call) {
   let callee = call.callee;
   if (callee.type === "CallExpression")
@@ -107567,12 +107944,12 @@ function checkConstantsOnly(ctx, emit) {
 }
 function checkOverMocking(ctx, emit) {
   const { program } = ctx.parsed;
-  const unit = path74.basename(ctx.file).replace(/\.(?:[cm]?[jt]sx?)$/, "").replace(/\.(?:test|spec)$/, "");
+  const unit = path76.basename(ctx.file).replace(/\.(?:[cm]?[jt]sx?)$/, "").replace(/\.(?:test|spec)$/, "");
   const mocked = find2(program, (node) => node.type === "CallExpression" && MODULE_MOCK.test(calleeName(node.callee) ?? "") && node.arguments[0]?.type === "StringLiteral");
   const internal = mocked.filter((call) => /^(?:\.|@\/|~\/)/.test(call.arguments[0].value));
   for (const call of mocked) {
     const spec = call.arguments[0].value;
-    const base = path74.basename(spec.replace(/\/index(?:\.[cm]?[jt]sx?)?$/, "")).replace(/\.(?:[cm]?[jt]sx?)$/, "");
+    const base = path76.basename(spec.replace(/\/index(?:\.[cm]?[jt]sx?)?$/, "")).replace(/\.(?:[cm]?[jt]sx?)$/, "");
     if (base === unit)
       emit({
         rule: "over-mocking",
@@ -107961,8 +108338,8 @@ var init_rules = __esm(() => {
 
 // packages/workit-cli/src/test-audit/audit.ts
 import { spawnSync as spawnSync30 } from "node:child_process";
-import { existsSync as existsSync28, readdirSync as readdirSync14, readFileSync as readFileSync31, statSync as statSync10 } from "node:fs";
-import path75 from "node:path";
+import { existsSync as existsSync29, readdirSync as readdirSync14, readFileSync as readFileSync32, statSync as statSync10 } from "node:fs";
+import path77 from "node:path";
 function git7(cwd, args) {
   const run = spawnSync30("git", ["-c", "core.quotepath=off", ...args], {
     cwd,
@@ -107975,7 +108352,7 @@ function walkTests(dir, out) {
   for (const entry of readdirSync14(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".") && entry.name !== "." && entry.isDirectory())
       continue;
-    const full = path75.join(dir, entry.name);
+    const full = path77.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (!SKIP_DIRS.has(entry.name))
         walkTests(full, out);
@@ -107987,8 +108364,8 @@ function expandPaths(cwd, inputs) {
   const files = [];
   const missing = [];
   for (const input of inputs.length > 0 ? inputs : ["."]) {
-    const full = path75.resolve(cwd, input);
-    if (!existsSync28(full))
+    const full = path77.resolve(cwd, input);
+    if (!existsSync29(full))
       missing.push(input);
     else if (statSync10(full).isDirectory())
       walkTests(full, files);
@@ -108024,11 +108401,11 @@ function changedLines(cwd, base) {
       for (let offset = 0;offset < count; offset += 1)
         lines.add(start + offset);
     }
-    changed.set(path75.join(root, file), lines);
+    changed.set(path77.join(root, file), lines);
   }
   const untracked = git7(root, ["ls-files", "--others", "--exclude-standard", "-z"]);
   for (const file of untracked.stdout.split("\x00").filter(Boolean))
-    changed.set(path75.join(root, file), "all");
+    changed.set(path77.join(root, file), "all");
   return changed;
 }
 function auditFiles(files, display) {
@@ -108041,7 +108418,7 @@ function auditFiles(files, display) {
     const shown = display(file);
     let parsed;
     try {
-      parsed = parseSource(readFileSync31(file, "utf8"), file);
+      parsed = parseSource(readFileSync32(file, "utf8"), file);
     } catch (error) {
       parseErrors.push({
         file: shown,
@@ -108090,7 +108467,7 @@ function auditFiles(files, display) {
     durationMs: Math.round(performance.now() - started)
   };
 }
-var TEST_FILE, CODE_FILE, SKIP_DIRS, toPosix = (file) => file.split(path75.sep).join("/"), SEVERITY_ORDER, ruleIds;
+var TEST_FILE, CODE_FILE, SKIP_DIRS, toPosix = (file) => file.split(path77.sep).join("/"), SEVERITY_ORDER, ruleIds;
 var init_audit = __esm(() => {
   init_ast();
   init_rules();
@@ -108104,23 +108481,23 @@ var init_audit = __esm(() => {
 // packages/workit-cli/src/test-audit/mutate.ts
 import { spawn as spawn5 } from "node:child_process";
 import {
-  existsSync as existsSync29,
+  existsSync as existsSync30,
   lstatSync as lstatSync9,
   mkdirSync as mkdirSync13,
-  mkdtempSync as mkdtempSync4,
+  mkdtempSync as mkdtempSync6,
   readdirSync as readdirSync15,
-  readFileSync as readFileSync32,
+  readFileSync as readFileSync33,
   readlinkSync as readlinkSync3,
   realpathSync as realpathSync11,
   renameSync as renameSync8,
-  rmSync as rmSync9,
+  rmSync as rmSync11,
   statSync as statSync11,
   symlinkSync,
-  writeFileSync as writeFileSync14,
+  writeFileSync as writeFileSync15,
   copyFileSync as copyFileSync8
 } from "node:fs";
-import os24 from "node:os";
-import path76 from "node:path";
+import os26 from "node:os";
+import path78 from "node:path";
 function mutantsFor(source, file, lines) {
   const parsed = parseSource(source, file);
   const out = [];
@@ -108193,7 +108570,7 @@ function relatedTests(source, testFiles) {
     for (const match of text.matchAll(SPECIFIER)) {
       const spec = match[1];
       if (spec.startsWith(".")) {
-        if (stripExt(path76.posix.join(path76.posix.dirname(file), spec)) === target)
+        if (stripExt(path78.posix.join(path78.posix.dirname(file), spec)) === target)
           return true;
       } else if (spec.includes("/") && stripExt(spec).split("/").slice(-2).join("/") === tail)
         return true;
@@ -108201,7 +108578,7 @@ function relatedTests(source, testFiles) {
     return false;
   }).map((entry) => entry.file);
 }
-function removeStaleCopies(tmp = os24.tmpdir()) {
+function removeStaleCopies(tmp = os26.tmpdir()) {
   let removed = 0;
   let names = [];
   try {
@@ -108213,12 +108590,12 @@ function removeStaleCopies(tmp = os24.tmpdir()) {
   for (const name of names) {
     if (!name.startsWith(TEMP_PREFIX))
       continue;
-    const dir = path76.join(tmp, name);
+    const dir = path78.join(tmp, name);
     try {
       const stat = lstatSync9(dir);
       if (!stat.isDirectory() || uid !== undefined && stat.uid !== uid)
         continue;
-      const pid = Number(readFileSync32(path76.join(dir, PID_FILE), "utf8"));
+      const pid = Number(readFileSync33(path78.join(dir, PID_FILE), "utf8"));
       if (Number.isInteger(pid) && pid > 0 && alive(pid))
         continue;
     } catch (error) {
@@ -108226,7 +108603,7 @@ function removeStaleCopies(tmp = os24.tmpdir()) {
         continue;
     }
     try {
-      rmSync9(dir, { recursive: true, force: true });
+      rmSync11(dir, { recursive: true, force: true });
       removed += 1;
     } catch {}
   }
@@ -108235,8 +108612,8 @@ function removeStaleCopies(tmp = os24.tmpdir()) {
 function linkNodeModules(origin, target, repo, copy) {
   mkdirSync13(target, { recursive: true });
   for (const entry of readdirSync15(origin, { withFileTypes: true })) {
-    const from = path76.join(origin, entry.name);
-    const to = path76.join(target, entry.name);
+    const from = path78.join(origin, entry.name);
+    const to = path78.join(target, entry.name);
     if (entry.name.startsWith("@") && entry.isDirectory()) {
       linkNodeModules(from, to, repo, copy);
       continue;
@@ -108252,9 +108629,9 @@ function linkNodeModules(origin, target, repo, copy) {
       } catch {
         continue;
       }
-      const relative = path76.relative(repo, real);
-      if (!relative.startsWith("..") && !path76.isAbsolute(relative) && !relative.split(path76.sep).includes("node_modules")) {
-        symlinkSync(path76.join(copy, relative), to, "junction");
+      const relative = path78.relative(repo, real);
+      if (!relative.startsWith("..") && !path78.isAbsolute(relative) && !relative.split(path78.sep).includes("node_modules")) {
+        symlinkSync(path78.join(copy, relative), to, "junction");
         continue;
       }
     }
@@ -108270,7 +108647,7 @@ function copySymlink(repo, tree, from, to) {
   }
   const realRepo = realpathSync11(repo);
   if (real && inside5(realRepo, real)) {
-    symlinkSync(path76.relative(path76.dirname(to), path76.join(tree, path76.relative(realRepo, real))), to);
+    symlinkSync(path78.relative(path78.dirname(to), path78.join(tree, path78.relative(realRepo, real))), to);
     return;
   }
   if (real && statSync11(real).isFile())
@@ -108279,23 +108656,23 @@ function copySymlink(repo, tree, from, to) {
     symlinkSync(readlinkSync3(from), to);
 }
 function writeInside(copy, file, content) {
-  const target = path76.join(copy, file);
+  const target = path78.join(copy, file);
   try {
     const stat = lstatSync9(target);
-    if (!stat.isFile() || !inside5(realpathSync11(copy), realpathSync11(path76.dirname(target))))
+    if (!stat.isFile() || !inside5(realpathSync11(copy), realpathSync11(path78.dirname(target))))
       return false;
   } catch {
     return false;
   }
   const temp = `${target}.workit-mutant-${process.pid}`;
-  writeFileSync14(temp, content);
+  writeFileSync15(temp, content);
   renameSync8(temp, target);
   return true;
 }
 function copyWorkingTree(repo) {
-  const dir = mkdtempSync4(path76.join(os24.tmpdir(), TEMP_PREFIX));
-  writeFileSync14(path76.join(dir, PID_FILE), String(process.pid));
-  const tree = path76.join(dir, "tree");
+  const dir = mkdtempSync6(path78.join(os26.tmpdir(), TEMP_PREFIX));
+  writeFileSync15(path78.join(dir, PID_FILE), String(process.pid));
+  const tree = path78.join(dir, "tree");
   const head = git7(repo, ["rev-parse", "--verify", "--quiet", "HEAD"]).stdout.trim();
   if (head && git7(dir, ["clone", "-q", "--shared", "--no-checkout", repo, tree]).ok) {
     const branch = git7(repo, ["symbolic-ref", "--quiet", "--short", "HEAD"]).stdout.trim();
@@ -108312,29 +108689,29 @@ function copyWorkingTree(repo) {
   for (const relative of listed) {
     if (!relative)
       continue;
-    const from = path76.join(repo, relative);
+    const from = path78.join(repo, relative);
     let stat;
     try {
       stat = lstatSync9(from);
     } catch {
       continue;
     }
-    const to = path76.join(tree, relative);
-    mkdirSync13(path76.dirname(to), { recursive: true });
+    const to = path78.join(tree, relative);
+    mkdirSync13(path78.dirname(to), { recursive: true });
     if (stat.isSymbolicLink())
       copySymlink(repo, tree, from, to);
     else if (stat.isFile())
       copyFileSync8(from, to);
-    let parent = path76.dirname(relative);
+    let parent = path78.dirname(relative);
     while (parent !== "." && !dirs.has(parent)) {
       dirs.add(parent);
-      parent = path76.dirname(parent);
+      parent = path78.dirname(parent);
     }
   }
   for (const parent of dirs) {
-    const modules = path76.join(repo, parent, "node_modules");
-    if (existsSync29(modules) && !existsSync29(path76.join(tree, parent, "node_modules")))
-      linkNodeModules(modules, path76.join(tree, parent, "node_modules"), repo, tree);
+    const modules = path78.join(repo, parent, "node_modules");
+    if (existsSync30(modules) && !existsSync30(path78.join(tree, parent, "node_modules")))
+      linkNodeModules(modules, path78.join(tree, parent, "node_modules"), repo, tree);
   }
   return { dir, tree };
 }
@@ -108373,20 +108750,20 @@ async function runMutation(options) {
   const tracked = git7(repo, ["ls-files", "-co", "--exclude-standard", "-z"]).stdout.split("\x00").filter(Boolean);
   const testFiles = tracked.filter((file) => TEST_FILE.test(file)).map((file) => {
     try {
-      return { file, text: readFileSync32(path76.join(repo, file), "utf8") };
+      return { file, text: readFileSync33(path78.join(repo, file), "utf8") };
     } catch {
       return { file, text: "" };
     }
   });
   const candidates = [];
   for (const [absolute, lines] of [...options.changed].toSorted(([a], [b]) => a.localeCompare(b))) {
-    const relative = toPosix(path76.relative(repo, absolute));
+    const relative = toPosix(path78.relative(repo, absolute));
     if (!CODE_FILE.test(relative) || TEST_FILE.test(relative) || relative.endsWith(".d.ts"))
       continue;
-    if (NOT_SOURCE.test(relative) || !existsSync29(absolute))
+    if (NOT_SOURCE.test(relative) || !existsSync30(absolute))
       continue;
     try {
-      candidates.push(...mutantsFor(readFileSync32(absolute, "utf8"), relative, lines));
+      candidates.push(...mutantsFor(readFileSync33(absolute, "utf8"), relative, lines));
     } catch {}
   }
   const mutants = candidates.map((mutant, index) => ({ ...mutant, id: index + 1 }));
@@ -108394,9 +108771,9 @@ async function runMutation(options) {
   for (const mutant of mutants)
     if (!related.has(mutant.file))
       related.set(mutant.file, relatedTests(mutant.file, testFiles));
-  const cwdRelative = path76.relative(repo, options.cwd);
+  const cwdRelative = path78.relative(repo, options.cwd);
   const asArg = (file) => {
-    const relative = toPosix(path76.relative(cwdRelative, file));
+    const relative = toPosix(path78.relative(cwdRelative, file));
     return shellQuote(relative.startsWith(".") ? relative : `./${relative}`);
   };
   const commandFor = (tests) => options.command.replaceAll("{files}", () => tests.map(asArg).join(" "));
@@ -108432,7 +108809,7 @@ async function runMutation(options) {
     return finish3(options, 0, results, counts, started);
   removeStaleCopies();
   const { dir: copyDir, tree: copy } = copyWorkingTree(repo);
-  const copyCwd = path76.join(copy, cwdRelative);
+  const copyCwd = path78.join(copy, cwdRelative);
   let current = null;
   const restore = () => {
     if (current)
@@ -108443,7 +108820,7 @@ async function runMutation(options) {
     for (const child of active)
       killTree(child);
     restore();
-    rmSync9(copyDir, { recursive: true, force: true });
+    rmSync11(copyDir, { recursive: true, force: true });
   };
   const onSignal = (signal) => {
     cleanup();
@@ -108467,7 +108844,7 @@ async function runMutation(options) {
         record({ ...mutant, status: "skipped", durationMs: 0, tests, reason: "budget" });
         continue;
       }
-      const original = readFileSync32(path76.join(copy, mutant.file), "utf8");
+      const original = readFileSync33(path78.join(copy, mutant.file), "utf8");
       const mutated = original.slice(0, mutant.start) + mutant.replacement + original.slice(mutant.end);
       current = { file: mutant.file, original };
       if (!writeInside(copy, mutant.file, mutated)) {
@@ -108524,8 +108901,8 @@ var NOT_SOURCE, FLIPS, isStringy = (node) => node.type === "StringLiteral" || no
     return error.code === "EPERM";
   }
 }, inside5 = (root, file) => {
-  const relative = path76.relative(root, file);
-  return relative === "" || !relative.startsWith("..") && !path76.isAbsolute(relative);
+  const relative = path78.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path78.isAbsolute(relative);
 }, active, killTree = (child) => {
   try {
     if (child.pid && process.platform !== "win32")
@@ -108573,8 +108950,8 @@ var exports_test_audit = {};
 __export(exports_test_audit, {
   run: () => run23
 });
-import { existsSync as existsSync30 } from "node:fs";
-import path77 from "node:path";
+import { existsSync as existsSync31 } from "node:fs";
+import path79 from "node:path";
 function parse8(argv) {
   const options = {
     paths: [],
@@ -108679,8 +109056,8 @@ async function run23(argv, io) {
     return emit(io, fail2("invalid_input", `${options}
 usage: ${USAGE16}`));
   const top = git7(io.cwd, ["rev-parse", "--show-toplevel"]);
-  const repo = top.ok ? path77.resolve(top.stdout.trim()) : null;
-  const display = (file) => toPosix(path77.relative(io.cwd, file) || file);
+  const repo = top.ok ? path79.resolve(top.stdout.trim()) : null;
+  const display = (file) => toPosix(path79.relative(io.cwd, file) || file);
   let base = null;
   let changed = null;
   if (options.diff || options.mutate) {
@@ -108697,7 +109074,7 @@ usage: ${USAGE16}`));
   }
   let files;
   if (options.diff && changed)
-    files = [...changed.keys()].filter((file) => TEST_FILE.test(toPosix(file)) && existsSync30(file)).toSorted();
+    files = [...changed.keys()].filter((file) => TEST_FILE.test(toPosix(file)) && existsSync31(file)).toSorted();
   else {
     const expanded = expandPaths(io.cwd, options.paths);
     if (expanded.missing.length > 0)
@@ -108818,8 +109195,8 @@ var exports_youtrack = {};
 __export(exports_youtrack, {
   run: () => run25
 });
-import { readFileSync as readFileSync33 } from "node:fs";
-import path78 from "node:path";
+import { readFileSync as readFileSync34 } from "node:fs";
+import path80 from "node:path";
 async function run25(argv, io) {
   const [sub, ...rest] = argv;
   if (sub !== "note" && sub !== "time" && sub !== "meeting")
@@ -108865,7 +109242,7 @@ async function run25(argv, io) {
     let markdown = flags.values.markdown ?? "";
     if (flags.values.file)
       try {
-        markdown = readFileSync33(path78.resolve(io.cwd, flags.values.file), "utf8");
+        markdown = readFileSync34(path80.resolve(io.cwd, flags.values.file), "utf8");
       } catch (error) {
         return usage4(io, `cannot read ${flags.values.file}: ${String(error)}`, USAGE18);
       }
@@ -108936,8 +109313,8 @@ var exports_changelog = {};
 __export(exports_changelog, {
   run: () => run26
 });
-import { readFileSync as readFileSync34 } from "node:fs";
-import path79 from "node:path";
+import { readFileSync as readFileSync35 } from "node:fs";
+import path81 from "node:path";
 async function run26(argv, io) {
   const [sub, ...rest] = argv;
   if (sub !== "apply")
@@ -108983,7 +109360,7 @@ async function run26(argv, io) {
   ]);
 }
 var USAGE19 = "workit changelog apply (--entries <JSON|@file|-> | --normalize-only) [--path CHANGELOG.md] [--preview]", readEntries = (raw, cwd) => {
-  const text = raw === "-" ? readFileSync34(0, "utf8") : raw.startsWith("@") ? readFileSync34(path79.resolve(cwd, raw.slice(1)), "utf8") : raw;
+  const text = raw === "-" ? readFileSync35(0, "utf8") : raw.startsWith("@") ? readFileSync35(path81.resolve(cwd, raw.slice(1)), "utf8") : raw;
   return JSON.parse(text);
 };
 var init_changelog2 = __esm(() => {
@@ -108999,7 +109376,7 @@ __export(exports_handoff, {
   run: () => run27
 });
 import fs37 from "node:fs";
-import path80 from "node:path";
+import path82 from "node:path";
 import { parseArgs as parseArgs2 } from "node:util";
 function render3(brief) {
   const lines = [
@@ -109039,9 +109416,9 @@ function bounded(brief, cwd) {
   let file = null;
   if (store.ok)
     try {
-      const dir = path80.join(store.value.root, "handoff");
+      const dir = path82.join(store.value.root, "handoff");
       fs37.mkdirSync(dir, { recursive: true });
-      file = path80.join(dir, `${(brief.branch ?? "detached").replaceAll(/[^\w.-]+/gu, "-")}.txt`);
+      file = path82.join(dir, `${(brief.branch ?? "detached").replaceAll(/[^\w.-]+/gu, "-")}.txt`);
       fs37.writeFileSync(file, `${[...body, ...tail].join(`
 `)}
 `, {
@@ -109116,7 +109493,7 @@ var init_handoff = __esm(() => {
 });
 
 // packages/workit-cli/src/main.ts
-import path81 from "node:path";
+import path83 from "node:path";
 
 // packages/workit-core/src/git/env-redirect.ts
 var GIT_REDIRECT_ENV = [
@@ -110065,7 +110442,7 @@ var defaultIo = (json) => ({
 });
 async function main(argv, overrides = {}, options = {}) {
   const parsed = parseGlobals(argv);
-  const cwd = path81.resolve(overrides.cwd ?? process.cwd(), parsed.cwd ?? ".");
+  const cwd = path83.resolve(overrides.cwd ?? process.cwd(), parsed.cwd ?? ".");
   const io = {
     ...defaultIo(parsed.json),
     terminals: {