@brainervirus/workit-cli 8.41.0 → 8.42.0

package/dist/index.js

@@ -9417,7 +9417,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@brainervirus/workit-cli",
-    version: "8.41.0",
+    version: "8.42.0",
     private: false,
     description: "Workit CLI — setup wizard, doctor, and task control for agentic coding workflows",
     keywords: [
@@ -9455,13 +9455,13 @@ var init_package = __esm(() => {
     },
     dependencies: {
       "@babel/parser": "7.29.9",
-      "@brainervirus/workit-cursor": "^8.41.0",
+      "@brainervirus/workit-cursor": "^8.42.0",
       "@inkjs/ui": "2.0.0",
       ink: "7.1.1",
       react: "19.2.8"
     },
     devDependencies: {
-      "@brainervirus/workit-core": "^8.41.0"
+      "@brainervirus/workit-core": "^8.42.0"
     },
     engines: {
       node: ">=24"
@@ -21951,6 +21951,108 @@ var init_task = __esm(() => {
   };
 });
 
+// packages/workit-cli/src/style.ts
+import { stripVTControlCharacters } from "node:util";
+function createStyle(options = {}) {
+  const enabled = colorEnabled(options);
+  const pick = (open) => enabled ? sgr(open) : same2;
+  return {
+    enabled,
+    width: enabled ? options.stream?.columns || undefined : undefined,
+    ok: pick("32"),
+    fail: pick("1;31"),
+    warn: pick("33"),
+    info: pick("2"),
+    dim: pick("2"),
+    bold: pick("1"),
+    accent: pick("36"),
+    diffAdd: pick("32"),
+    diffDel: pick("31"),
+    diffHunk: pick("36"),
+    path: pick("2"),
+    command: pick("1;36")
+  };
+}
+function wrap(text, width, indent, firstUsed = indent) {
+  if (!width || width <= indent + 10)
+    return text;
+  const lines = [];
+  let line = "";
+  let room = width - firstUsed;
+  const place = (word) => {
+    let rest = word;
+    while (visibleLength(rest) > room) {
+      const chars = Array.from(rest);
+      lines.push(chars.slice(0, room).join(""));
+      rest = chars.slice(room).join("");
+      room = width - indent;
+    }
+    line = rest;
+  };
+  for (const word of text.split(/ +/)) {
+    if (word === "")
+      continue;
+    if (line === "")
+      place(word);
+    else if (visibleLength(line) + 1 + visibleLength(word) <= room)
+      line = `${line} ${word}`;
+    else {
+      lines.push(line);
+      room = width - indent;
+      place(word);
+    }
+  }
+  lines.push(line);
+  return lines.join(`
+${" ".repeat(indent)}`);
+}
+function colorDiff(text, style) {
+  if (!style.enabled)
+    return text;
+  return text.split(`
+`).map((line) => {
+    if (line.startsWith("+++") || line.startsWith("---"))
+      return style.bold(line);
+    if (line.startsWith("+"))
+      return style.diffAdd(line);
+    if (line.startsWith("-"))
+      return style.diffDel(line);
+    if (line.startsWith("@@") || line.trim() === "…" || line.trim() === "...")
+      return style.diffHunk(line);
+    return style.dim(line);
+  }).join(`
+`);
+}
+function spinnerPaint(elapsed, env, glyph) {
+  const k = (Math.sin(elapsed / 2400 * Math.PI * 2) + 1) / 2;
+  const [r, g, b] = [
+    [170, 80],
+    [120, 200],
+    [255, 255]
+  ].map(([from, to]) => Math.round(from + (to - from) * k));
+  const depth = (env.COLORTERM || "").toLowerCase();
+  const level = (v) => v < 48 ? 0 : v < 115 ? 1 : Math.min(5, Math.floor((v - 35) / 40));
+  const code = depth === "truecolor" || depth === "24bit" ? `38;2;${r};${g};${b}` : /256/.test(env.TERM || "") ? `38;5;${16 + 36 * level(r) + 6 * level(g) + level(b)}` : "36";
+  return `\x1B[${code}m${glyph}\x1B[0m`;
+}
+var truthy = (value) => value !== undefined && value !== "" && value !== "0" && value.toLowerCase() !== "false", terminalMode = (options) => {
+  const env = options.env ?? process.env;
+  if (options.json || !options.stream?.isTTY || truthy(env.CI))
+    return "off";
+  if (truthy(env.NO_COLOR) || env.TERM === "dumb")
+    return "plain";
+  return "spinner";
+}, colorEnabled = (options) => {
+  if (options.json || !options.stream)
+    return false;
+  if (truthy((options.env ?? process.env).FORCE_COLOR))
+    return true;
+  return terminalMode(options) === "spinner";
+}, sgr = (open) => (text) => text === "" ? text : `\x1B[${open}m${text}\x1B[0m`, same2 = (text) => text, visibleLength = (text) => Array.from(stripVTControlCharacters(text)).length, SPINNER_FRAMES, SPINNER_FRAME_MS = 140;
+var init_style = __esm(() => {
+  SPINNER_FRAMES = ["◐", "◓", "◑", "◒"];
+});
+
 // packages/workit-cli/src/output.ts
 function emit(io, envelope, human) {
   if (io.json) {
@@ -21988,11 +22090,12 @@ async function withFailureLine(io, command, run, outcome) {
   });
   if (code === 0)
     return code;
+  const red = createStyle({ stream: io.terminals?.stderr, env: io.env, json: io.json }).fail;
   if (outcome)
-    io.stderr(`workit: error: ${outcome} (${reason ?? EXIT_NAMES[code] ?? "failed"}, exit ${code})
+    io.stderr(`${red(`workit: error: ${outcome} (${reason ?? EXIT_NAMES[code] ?? "failed"}, exit ${code})`)}
 `);
   else if (!wrote)
-    io.stderr(`workit: error: ${command} failed (exit ${code})
+    io.stderr(`${red(`workit: error: ${command} failed (exit ${code})`)}
 `);
   return code;
 }
@@ -22017,6 +22120,7 @@ var EXIT, EXIT_BY_CODE, exitCodeFor = (code) => EXIT_BY_CODE[code], ok2 = (data)
   })));
 };
 var init_output = __esm(() => {
+  init_style();
   EXIT = {
     ok: 0,
     failed: 1,
@@ -66193,7 +66297,7 @@ import path33 from "node:path";
 function hostCommand(name, args, options = {}) {
   const executable = findHostExecutable(name, options);
   if (!executable)
-    throw new Error(`${name} executable was not found on PATH or supported user bin directories`);
+    throw new Error(path33.isAbsolute(name) || name.includes("/") || name.includes("\\") ? `${name} does not exist or is not executable` : `${name} executable was not found on PATH or supported user bin directories`);
   if (process.platform === "win32" && /\.(?:cmd|bat)$/i.test(executable)) {
     const node = findHostExecutable("node", options);
     if (!node)
@@ -66217,6 +66321,17 @@ function resolveWindowsShimEntry(contents, shim, exists = existsSync13) {
   return null;
 }
 function findHostExecutable(name, options = {}) {
+  if (path33.isAbsolute(name) || name.includes("/") || name.includes("\\")) {
+    try {
+      if (!statSync2(name).isFile())
+        return null;
+      if (process.platform !== "win32")
+        accessSync(name, constants2.X_OK);
+      return name;
+    } catch {
+      return null;
+    }
+  }
   const env = options.env ?? process.env;
   const home = options.home ?? env.HOME ?? os9.homedir();
   const suffixes = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
@@ -67761,7 +67876,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
       return null;
     dir = parent;
   }
-}, listClaudeProcesses = () => {
+}, listProcessesMatching = (match) => {
   const r = spawnSync16("ps", ["-eo", "pid=,lstart=,args="], {
     encoding: "utf8",
     timeout: 5000
@@ -67772,14 +67887,14 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   for (const row of r.stdout.split(`
 `)) {
     const m = /^\s*(\d+)\s+(\w{3}\s+\w{3}\s+\d+\s+[\d:]+\s+\d{4})\s+(.*)$/.exec(row);
-    if (!m || !/^(\S*\/)?claude(\s|$)/.test(m[3]))
+    if (!m || !match(m[3]))
       continue;
     const startedMs = Date.parse(m[2]);
     if (Number.isFinite(startedMs))
       found.push({ pid: Number(m[1]), startedMs, args: m[3] });
   }
   return found;
-}, resolve = (options) => {
+}, 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 ?? os12.homedir();
   const configDir = options.configDir ?? env.WORKFLOW_TOOLKIT_CONFIG ?? env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path39.join(home, ".config", "workit");
@@ -67807,7 +67922,8 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     installer: options.installer ?? false,
     cliVersion: options.cliVersion ?? null,
     scopeProbe: options.scopeProbe ?? probeScope,
-    claudeProcesses: options.claudeProcesses ?? listClaudeProcesses
+    claudeProcesses: options.claudeProcesses ?? listClaudeProcesses,
+    codexProcesses: options.codexProcesses ?? listCodexProcesses
   };
 }, readJson = (p) => {
   try {
@@ -68563,7 +68679,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
       id: "launcher",
       status: "fail",
       detail: `missing or invalid launcher entry: ${missing.join("; ")}`,
-      fix: `Rebuild and reinstall the workit package (bun run build) — dist entries must be non-empty Node launchers`
+      fix: dev ? `Rebuild and reinstall the workit package (bun run build) — dist entries must be non-empty Node launchers` : "workit upgrade --hosts=cursor — it reinstalls the plugin files and re-registers the MCP launcher"
     };
   }
   if (!dev && res.host !== "cursor") {
@@ -69804,6 +69920,49 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     status: "warn",
     detail: `started before Workit ${latest.install.version} was installed: ${rows.join("; ")}; quit and start \`claude --resume ${first ?? "<session id>"}\` to load it (\`/resume\` keeps the old plugin)`
   };
+}, checkCodexSessionPlugin = (res) => {
+  const id = "codex_session_plugin";
+  if (process.platform === "win32")
+    return {
+      id,
+      status: "info",
+      detail: "running Codex processes are not checked on Windows"
+    };
+  const installs = codexWorkitInstalls(res).filter((install) => install.root && install.version);
+  const stamped = installs.flatMap((install) => {
+    try {
+      return [{ install, at: statSync6(install.root).mtimeMs }];
+    } catch {
+      return [];
+    }
+  });
+  const latest = stamped.toSorted((a, b) => b.at - a.at)[0];
+  if (!latest)
+    return {
+      id,
+      status: "info",
+      detail: "no Workit Codex plugin install recorded — skipping"
+    };
+  const running = res.codexProcesses();
+  if (running === null)
+    return {
+      id,
+      status: "info",
+      detail: "could not list running codex processes (ps) — skipping"
+    };
+  const stale = running.filter((proc) => proc.startedMs < latest.at);
+  if (stale.length === 0)
+    return {
+      id,
+      status: "info",
+      detail: `${running.length} running codex process(es), none started before Workit ${latest.install.version} was installed`
+    };
+  const rows = stale.map((proc) => `pid ${proc.pid} started ${new Date(proc.startedMs).toISOString()} (${proc.args.slice(0, 60)})`);
+  return {
+    id,
+    status: "warn",
+    detail: `started before Workit ${latest.install.version} was installed: ${rows.join("; ")}; they keep the old plugin until restarted, new Codex sessions load it`
+  };
 }, HOOK_ISSUED_MARKER = "workit-issued-sessions/3", hookRecordsIssued = (root) => {
   let files;
   try {
@@ -70095,6 +70254,7 @@ var init_doctor = __esm(() => {
     checkOpencodeVersion,
     checkClaudePlugin,
     checkClaudeSessionPlugin,
+    checkCodexSessionPlugin,
     checkHookIssuedSessions,
     checkWorkitOnPath,
     checkAssets,
@@ -75135,14 +75295,18 @@ async function run4(argv, io) {
     ...io.env.HOME ? { home: io.env.HOME } : {}
   });
   const say = io.json ? io.stderr : io.stdout;
+  const style = createStyle({
+    stream: io.json ? io.terminals?.stderr : io.terminals?.stdout,
+    env: io.env
+  });
   for (const note of plan.notes)
     say(`${note}
 `);
   for (const blocked of plan.blocked)
-    say(`blocked: ${blocked}
+    say(`${style.warn("blocked:")} ${blocked}
 `);
   for (const change of plan.changes)
-    say(`${permissionDiff(change)}
+    say(`${colorDiff(permissionDiff(change), style)}
 `);
   const summary = {
     changes: plan.changes.map((c) => ({ host: c.host, file: c.file })),
@@ -75164,7 +75328,7 @@ async function run4(argv, io) {
         data: summary,
         unblock: `review the diff above, then run ${USAGE2.replace("[--dry-run | --yes]", "--yes")} or run it in a terminal`
       }));
-    const answer = await askOrCancel(io, () => askLine("Write Workit's permission block shown above? [y/N] ", io.json ? process.stderr : process.stdout));
+    const answer = await askOrCancel(io, () => askLine(`${style.bold("Write Workit's permission block shown above?")} [y/N] `, io.json ? process.stderr : process.stdout));
     if (answer === null)
       return cancelled(io);
     if (!/^y(es)?$/i.test(answer.trim()))
@@ -75179,7 +75343,7 @@ async function run4(argv, io) {
   if (failed.length)
     return emit(io, fail2("failed", failed.map((e) => `${e.file}: ${e.detail ?? "failed"}`).join("; "), { data }));
   return emit(io, ok2(data), () => [
-    ...entries.map((e) => `written ${e.file}`),
+    ...entries.map((e) => `${style.ok("written")} ${style.path(e.file)}`),
     "Restart the host sessions to load the new permissions. `workit uninstall` removes them."
   ]);
 }
@@ -75215,13 +75379,16 @@ var init_setup2 = __esm(() => {
   init_host_permissions();
   init_output();
   init_prompt();
+  init_style();
   ALL_HOSTS = ["claude-code", "codex", "cursor", "opencode", "pi"];
 });
 
 // packages/workit-cli/src/progress.ts
+import { spawn } from "node:child_process";
+import path44 from "node:path";
 function createProgress(options = {}) {
   const env = options.env ?? process.env;
-  const mode = modeFor(options, env);
+  const mode = terminalMode({ ...options, env });
   const stream = options.stream;
   const now = options.now ?? Date.now;
   const every = options.setInterval ?? ((tick, ms) => setInterval(tick, ms));
@@ -75229,7 +75396,7 @@ function createProgress(options = {}) {
   const proc = options.proc ?? process;
   const ascii = env.TERM === "dumb";
   const glyphs = mode === "spinner" ? { done: "\x1B[32m✓\x1B[0m", failed: "\x1B[31m✗\x1B[0m", skipped: "–" } : ascii ? { done: "ok", failed: "x", skipped: "-" } : { done: "✓", failed: "✗", skipped: "–" };
-  const start = (initial) => {
+  const start = (initial, signals = true) => {
     if (mode === "off" || !stream)
       return NOOP_STEP;
     let text = initial;
@@ -75238,10 +75405,11 @@ function createProgress(options = {}) {
     let frame = 0;
     const draw = () => {
       const seconds = Math.floor((now() - began) / 1000);
-      let line = `${FRAMES[frame % FRAMES.length]} ${text} (${seconds}s)`;
-      if (stream.columns && line.length >= stream.columns)
-        line = `${line.slice(0, Math.max(1, stream.columns - 2))}…`;
-      stream.write(`${CLEAR}${line}`);
+      let line = `${text} (${seconds}s)`;
+      if (stream.columns && line.length + 2 >= stream.columns)
+        line = `${line.slice(0, Math.max(1, stream.columns - 4))}…`;
+      const glyph = spinnerPaint(now() - began, env, FRAMES[frame % FRAMES.length] ?? "");
+      stream.write(`${CLEAR}${glyph} ${line}`);
     };
     let timer;
     if (mode === "spinner") {
@@ -75257,7 +75425,7 @@ function createProgress(options = {}) {
         proc.off(event, handler);
       handlers.length = 0;
     };
-    if (mode === "spinner") {
+    if (mode === "spinner" && signals) {
       const onSignal = (signal) => () => {
         if (!finished) {
           finished = true;
@@ -75268,11 +75436,13 @@ function createProgress(options = {}) {
         release();
         proc.kill(proc.pid, signal);
       };
+      handlers.push(["SIGINT", onSignal("SIGINT")], ["SIGTERM", onSignal("SIGTERM")]);
+    }
+    if (mode === "spinner") {
       const onExit = () => {
         if (!finished)
           stream.write(CLEAR);
       };
-      handlers.push(["SIGINT", onSignal("SIGINT")], ["SIGTERM", onSignal("SIGTERM")]);
       handlers.push(["exit", onExit]);
       for (const [event, handler] of handlers)
         proc.on(event, handler);
@@ -75299,7 +75469,7 @@ function createProgress(options = {}) {
     mode,
     start,
     async run(label, fn, classify) {
-      const step = start(label);
+      const step = start(label, false);
       try {
         const value = await fn();
         step.end(classify ? classify(value) : "done");
@@ -75310,63 +75480,111 @@ function createProgress(options = {}) {
       }
     },
     runSync(label, fn, classify) {
-      const step = start(label);
+      const step = start(label, false);
+      const ticker = mode === "spinner" && stream ? (options.spawnTicker ?? ((text, began) => defaultTicker(text, began, stream)))(label, now()) : undefined;
       try {
         const value = fn();
+        ticker?.stop();
         step.end(classify ? classify(value) : "done");
         return value;
       } catch (error) {
+        ticker?.stop();
         step.end("failed");
         throw error;
       }
     }
   };
 }
-var FRAMES, FRAME_MS = 120, CLEAR = "\r\x1B[2K", truthy = (value) => value !== undefined && value !== "" && value !== "0" && value.toLowerCase() !== "false", modeFor = (options, env) => {
-  if (options.json || !options.stream?.isTTY || truthy(env.CI))
-    return "off";
-  if (truthy(env.NO_COLOR) || env.TERM === "dumb")
-    return "plain";
-  return "spinner";
-}, NOOP_STEP;
+var FRAMES, FRAME_MS, CLEAR = "\r\x1B[2K", TICKER_SOURCE, defaultTicker = (label, began, stream) => {
+  if (stream !== process.stderr)
+    return;
+  if (!/^(?:node|nodejs|bun)(?:\.exe)?$/i.test(path44.basename(process.execPath)))
+    return;
+  try {
+    const child = spawn(process.execPath, ["-e", TICKER_SOURCE], {
+      env: {
+        ...process.env,
+        WORKIT_TICK_LABEL: label,
+        WORKIT_TICK_BEGAN: String(began),
+        WORKIT_TICK_COLS: String(stream.columns ?? 0)
+      },
+      stdio: ["ignore", "ignore", "inherit"],
+      windowsHide: true
+    });
+    child.on("error", () => {});
+    child.unref();
+    return { stop: () => void child.kill("SIGKILL") };
+  } catch {
+    return;
+  }
+}, NOOP_STEP, progressFor = (io) => {
+  const stderr = io.terminals?.stderr;
+  const stream = stderr?.write ? stderr : undefined;
+  return createProgress({ json: io.json, env: io.env, ...stream ? { stream } : {} });
+};
 var init_progress = __esm(() => {
-  FRAMES = ["·", "✢", "✳", "∗", "✻", "✽"];
+  init_style();
+  FRAMES = SPINNER_FRAMES;
+  FRAME_MS = SPINNER_FRAME_MS;
+  TICKER_SOURCE = `
+const frames = ${JSON.stringify(FRAMES)};
+const { WORKIT_TICK_LABEL: label, WORKIT_TICK_BEGAN: began, WORKIT_TICK_COLS: cols } = process.env;
+const spinnerPaint = ${spinnerPaint.toString()};
+const parent = process.ppid;
+let frame = 0;
+const timer = setInterval(() => {
+  let alive = process.ppid === parent;
+  if (alive) try { process.kill(parent, 0); } catch { alive = false; }
+  if (!alive || Date.now() - Number(began) > 600000) process.exit(0);
+  frame += 1;
+  const seconds = Math.floor((Date.now() - Number(began)) / 1000);
+  let line = label + " (" + seconds + "s)";
+  if (Number(cols) && line.length + 2 >= Number(cols)) line = line.slice(0, Math.max(1, Number(cols) - 4)) + "…";
+  process.stderr.write(${JSON.stringify(CLEAR)} + spinnerPaint(Date.now() - Number(began), process.env, frames[frame % frames.length]) + " " + line);
+}, ${FRAME_MS});
+`;
   NOOP_STEP = { label: () => {}, end: () => {} };
 });
 
 // packages/workit-cli/src/upgrade/shared.ts
-import { spawn } from "node:child_process";
+import { spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync21, readFileSync as readFileSync22 } from "node:fs";
-import path44 from "node:path";
+import path45 from "node:path";
 import os16 from "node:os";
 import { createHash as createHash15 } from "node:crypto";
-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", 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) => {
+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) => {
+  const tail = stderrTail(result.stderr);
+  return `\`${command.command} ${command.args.join(" ")}\` failed${tail ? `: ${tail}` : ""}`;
+}, 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 ?? os16.homedir();
   const env = {
     ...process.env,
     ...deps.home || deps.env?.HOME ? {
       HOME: home,
-      CODEX_HOME: path44.join(home, ".codex"),
-      CLAUDE_CONFIG_DIR: path44.join(home, ".claude"),
-      PI_CODING_AGENT_DIR: path44.join(home, ".pi/agent"),
-      XDG_CONFIG_HOME: path44.join(home, ".config"),
+      CODEX_HOME: path45.join(home, ".codex"),
+      CLAUDE_CONFIG_DIR: path45.join(home, ".claude"),
+      PI_CODING_AGENT_DIR: path45.join(home, ".pi/agent"),
+      XDG_CONFIG_HOME: path45.join(home, ".config"),
       WORKFLOW_TOOLKIT_CONFIG: undefined,
       WORKFLOW_TOOLKIT_CONFIG_DIR: undefined
     } : {},
     ...deps.env,
     HOME: home
   };
-  const xdg = env.XDG_CONFIG_HOME || path44.join(home, ".config");
-  const codexHome = env.CODEX_HOME ?? path44.join(home, ".codex");
+  const xdg = env.XDG_CONFIG_HOME || path45.join(home, ".config");
+  const codexHome = env.CODEX_HOME ?? path45.join(home, ".codex");
   return {
     home,
     env,
-    configDir: env.WORKFLOW_TOOLKIT_CONFIG ?? env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path44.join(xdg, "workit"),
-    opencodeConfig: path44.join(xdg, "opencode/opencode.json"),
-    piSettings: path44.join(env.PI_CODING_AGENT_DIR ?? path44.join(home, ".pi/agent"), "settings.json"),
+    configDir: env.WORKFLOW_TOOLKIT_CONFIG ?? env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path45.join(xdg, "workit"),
+    opencodeConfig: path45.join(xdg, "opencode/opencode.json"),
+    piSettings: path45.join(env.PI_CODING_AGENT_DIR ?? path45.join(home, ".pi/agent"), "settings.json"),
     codexHome,
-    codexConfig: path44.join(codexHome, "config.toml"),
-    cursorRoot: path44.join(home, ".cursor/plugins/local/workit")
+    codexConfig: path45.join(codexHome, "config.toml"),
+    cursorRoot: path45.join(home, ".cursor/plugins/local/workit")
   };
 }, object2 = (file) => {
   if (!existsSync21(file))
@@ -75391,11 +75609,11 @@ var LAUNCH_HOSTS, HOSTS2, LIVE_HOSTS, OPENCODE_PACKAGE = "@brainervirus/workit-o
   let step;
   try {
     step = hostCommand(command, args, { home, env });
-  } catch {
-    return { status: 1, stdout: "" };
+  } catch (error) {
+    return { status: 1, stdout: "", stderr: errorText(error) };
   }
   const result = runHostCommand(step, { home, env });
-  return { status: result.exitCode, stdout: result.stdout };
+  return { status: result.exitCode, stdout: result.stdout, stderr: result.stderr };
 }), COMMAND_TIMEOUT_MS = 60000, asyncRunner = (deps) => {
   if (deps.runAsync)
     return deps.runAsync;
@@ -75407,37 +75625,42 @@ var LAUNCH_HOSTS, HOSTS2, LIVE_HOSTS, OPENCODE_PACKAGE = "@brainervirus/workit-o
     let step;
     try {
       step = hostCommand(command, args, { home, env });
-    } catch {
-      return Promise.resolve({ status: 1, stdout: "" });
+    } catch (error) {
+      return Promise.resolve({ status: 1, stdout: "", stderr: errorText(error) });
     }
     if (process.platform === "win32" && /\.(?:cmd|bat)$/i.test(step.command))
-      return Promise.resolve({ status: 1, stdout: "" });
+      return Promise.resolve({
+        status: 1,
+        stdout: "",
+        stderr: `Cannot safely execute batch shim ${step.command}`
+      });
     const childEnv = { ...process.env, ...env, HOME: home };
-    childEnv.CODEX_HOME = env.CODEX_HOME ?? path44.join(home, ".codex");
-    childEnv.PI_CODING_AGENT_DIR = env.PI_CODING_AGENT_DIR ?? path44.join(home, ".pi", "agent");
-    childEnv.CLAUDE_CONFIG_DIR = env.CLAUDE_CONFIG_DIR ?? path44.join(home, ".claude");
-    childEnv.XDG_CONFIG_HOME = env.XDG_CONFIG_HOME ?? path44.join(home, ".config");
+    childEnv.CODEX_HOME = env.CODEX_HOME ?? path45.join(home, ".codex");
+    childEnv.PI_CODING_AGENT_DIR = env.PI_CODING_AGENT_DIR ?? path45.join(home, ".pi", "agent");
+    childEnv.CLAUDE_CONFIG_DIR = env.CLAUDE_CONFIG_DIR ?? path45.join(home, ".claude");
+    childEnv.XDG_CONFIG_HOME = env.XDG_CONFIG_HOME ?? path45.join(home, ".config");
     return new Promise((resolve) => {
       let stdout = "";
+      let stderr = "";
       let settled = false;
       const finish = (status) => {
         if (settled)
           return;
         settled = true;
         clearTimeout(timer);
-        resolve({ status, stdout });
+        resolve({ status, stdout, stderr });
       };
       let child;
       try {
-        child = spawn(step.command, step.args, {
+        child = spawn2(step.command, step.args, {
           cwd: step.cwd,
           env: childEnv,
-          stdio: ["ignore", "pipe", "ignore"],
+          stdio: ["ignore", "pipe", "pipe"],
           windowsHide: true,
           shell: false
         });
-      } catch {
-        resolve({ status: 1, stdout: "" });
+      } catch (error) {
+        resolve({ status: 1, stdout: "", stderr: errorText(error) });
         return;
       }
       const timer = setTimeout(() => {
@@ -75446,16 +75669,21 @@ var LAUNCH_HOSTS, HOSTS2, LIVE_HOSTS, OPENCODE_PACKAGE = "@brainervirus/workit-o
       }, COMMAND_TIMEOUT_MS);
       child.stdout?.setEncoding("utf8");
       child.stdout?.on("data", (chunk) => stdout += chunk);
-      child.on("error", () => finish(1));
+      child.stderr?.setEncoding("utf8");
+      child.stderr?.on("data", (chunk) => stderr = (stderr + chunk).slice(-4000));
+      child.on("error", (error) => {
+        stderr += error.message;
+        finish(1);
+      });
       child.on("close", (code) => finish(code ?? 1));
     });
   };
-}, errorText = (error) => error instanceof Error ? error.message : "installed source could not be read", piInstalledVersion = (listing, selector) => {
+}, piInstalledVersion = (listing, selector) => {
   const lines = listing.split(/\r?\n/).map((line) => line.trim());
   const index = lines.indexOf(selector);
-  if (index < 0 || !lines[index + 1] || !path44.isAbsolute(lines[index + 1]))
+  if (index < 0 || !lines[index + 1] || !path45.isAbsolute(lines[index + 1]))
     return;
-  const found = objectOrNull(path44.join(lines[index + 1], "package.json"));
+  const found = objectOrNull(path45.join(lines[index + 1], "package.json"));
   return found?.name === "@brainervirus/workit-pi" ? found.version : undefined;
 }, versionAtLeast = (installed, latest) => {
   if (!/^\d+\.\d+\.\d+$/.test(installed))
@@ -75481,12 +75709,12 @@ var init_shared = __esm(() => {
 });
 
 // packages/workit-cli/src/upgrade/processes.ts
-import path45 from "node:path";
+import path46 from "node:path";
 var PROCESS_HOSTS, SCRIPT_RUNTIMES, classifyProcess = (proc) => {
   if (proc.state.startsWith("Z") || proc.args.includes("<defunct>"))
     return null;
   const argv0 = proc.args.trim().split(/\s+/)[0] ?? "";
-  const baseName = (value) => path45.basename(value.replaceAll("\\", "/")).replace(/^\[|\]$/g, "").replace(/\.exe$/i, "").toLowerCase();
+  const baseName = (value) => path46.basename(value.replaceAll("\\", "/")).replace(/^\[|\]$/g, "").replace(/\.exe$/i, "").toLowerCase();
   let host = PROCESS_HOSTS[baseName(argv0)];
   if (!host && SCRIPT_RUNTIMES.has(baseName(argv0))) {
     const script = proc.args.trim().split(/\s+/).slice(1).find((arg) => !arg.startsWith("-"));
@@ -75537,7 +75765,7 @@ var init_processes = __esm(() => {
 
 // packages/workit-cli/src/upgrade/apply.ts
 import { existsSync as existsSync22, readdirSync as readdirSync12, mkdirSync as mkdirSync11, copyFileSync as copyFileSync6, chmodSync as chmodSync2, cpSync as cpSync5 } from "node:fs";
-import path46 from "node:path";
+import path47 from "node:path";
 import { createHash as createHash16 } from "node:crypto";
 async function applyUpgrade(plan, deps = {}) {
   const hosts = [...plan.failed];
@@ -75572,11 +75800,11 @@ async function applyUpgrade(plan, deps = {}) {
       };
   const paths = upgradePaths(deps);
   const { home, configDir } = paths;
-  const backup = path46.join(home, ".local/state/workit/upgrades", new Date().toISOString().replaceAll(":", "-"));
+  const backup = path47.join(home, ".local/state/workit/upgrades", new Date().toISOString().replaceAll(":", "-"));
   mkdirSync11(backup, { recursive: true, mode: 448 });
   for (const file of Object.keys(plan.configDigests))
     if (existsSync22(file)) {
-      const target = path46.join(backup, createHash16("sha256").update(file).digest("hex").slice(0, 12) + "-" + path46.basename(file));
+      const target = path47.join(backup, createHash16("sha256").update(file).digest("hex").slice(0, 12) + "-" + path47.basename(file));
       copyFileSync6(file, target);
       chmodSync2(target, 384);
     }
@@ -75593,14 +75821,13 @@ async function applyUpgrade(plan, deps = {}) {
     writeFileAtomic(migration.file, JSON.stringify(value, null, 2) + `
 `, 384);
   }
-  const run = runner(deps);
   const runAsync = asyncRunner(deps);
   const progress = deps.progress ?? createProgress({ json: true });
   const statusOf = (outcome) => outcome?.status === "failed" ? "failed" : outcome?.status === "updated" ? "done" : "skipped";
   let cursorBackupError = null;
   if (plan.entries.some((entry) => entry.host === "cursor") && existsSync22(paths.cursorRoot))
     try {
-      cpSync5(paths.cursorRoot, path46.join(backup, "cursor-package"), {
+      cpSync5(paths.cursorRoot, path47.join(backup, "cursor-package"), {
         recursive: true
       });
     } catch (error) {
@@ -75649,14 +75876,14 @@ async function applyUpgrade(plan, deps = {}) {
         hosts.push({
           host: "codex",
           status: "failed",
-          reason: `could not stop the Codex app-server daemon (${daemons.map(describe2).join("; ")})`,
+          reason: `could not stop the Codex app-server daemon (${daemons.map(describe2).join("; ")})${stderrTail(stopped.stderr) ? `: ${stderrTail(stopped.stderr)}` : ""}`,
           fix: "codex app-server daemon stop && workit upgrade --hosts=codex"
         });
         continue;
       }
       let outcome;
       try {
-        outcome = await applyEntry(entry, { run, runAsync, paths, configDir });
+        outcome = await applyEntry(entry, { runAsync, paths, configDir });
         if (entry.host === "codex" && outcome.status === "updated") {
           const agents = await refreshCodexAgents(runAsync, paths.codexHome);
           if (!agents.ok)
@@ -75667,7 +75894,10 @@ async function applyUpgrade(plan, deps = {}) {
               fix: agents.fix
             };
           else if (agents.note)
-            outcome = { ...outcome, reason: `${outcome.reason}; ${agents.note}` };
+            outcome = {
+              ...outcome,
+              reason: `${outcome.reason}; ${agents.note}`
+            };
         }
       } catch (error) {
         outcome = {
@@ -75741,8 +75971,11 @@ async function applyUpgrade(plan, deps = {}) {
     }
   return done(backup);
 }
-var codexPluginRoot = (codexHome) => {
-  const dir = path46.join(codexHome, "plugins", "cache", CODEX_MARKETPLACE, "workit");
+var briefDetail = (detail) => {
+  const lines = detail.split(/\r?\n/).filter((line) => line.trim());
+  return (lines.length > 6 ? [lines[0], ...lines.slice(-5)] : lines).join(" | ");
+}, codexPluginRoot = (codexHome) => {
+  const dir = path47.join(codexHome, "plugins", "cache", CODEX_MARKETPLACE, "workit");
   let versions = [];
   try {
     versions = readdirSync12(dir).filter((version) => /^\d+\.\d+\.\d+$/.test(version));
@@ -75750,7 +75983,7 @@ var codexPluginRoot = (codexHome) => {
     return null;
   }
   const newest = versions.reduce((best, version) => best && versionAtLeast(best, version) ? best : version, null);
-  return newest ? path46.join(dir, newest) : null;
+  return newest ? path47.join(dir, newest) : null;
 }, opencodeVersion = async (run) => {
   const listing = await run("opencode", ["plugin", "list"]);
   if (listing.status !== 0)
@@ -75766,7 +75999,7 @@ var codexPluginRoot = (codexHome) => {
   }
   return;
 }, applyEntry = async (entry, context) => {
-  const { run, runAsync, paths, configDir } = context;
+  const { runAsync, paths, configDir } = context;
   const { home, env } = paths;
   const fail = (reason) => ({
     host: entry.host,
@@ -75775,6 +76008,30 @@ var codexPluginRoot = (codexHome) => {
     fix: entry.fix
   });
   if (entry.host === "cursor") {
+    const commands = entry.commands.map((command) => ({
+      ...command,
+      purpose: command.purpose ?? "Upgrade Cursor"
+    }));
+    const recorded = new Map;
+    let history = "";
+    for (const command of commands) {
+      if (command.skipWhenOutputIncludes && history.includes(command.skipWhenOutputIncludes))
+        continue;
+      const outcome = await runAsync(command.command, command.args);
+      const result = {
+        exitCode: outcome.status ?? 1,
+        stdout: outcome.stdout,
+        stderr: outcome.stderr ?? ""
+      };
+      recorded.set(command, result);
+      history += `
+${result.stdout}
+${result.stderr}`;
+      if (result.exitCode !== 0)
+        break;
+    }
+    const cursorSettings = path47.join(home, ".cursor", "settings.json");
+    const cursorMcp = path47.join(home, ".cursor", "mcp.json");
     const preview = {
       ok: true,
       blocked: [],
@@ -75786,13 +76043,12 @@ var codexPluginRoot = (codexHome) => {
         {
           type: "install-host",
           platform: "cursor",
-          path: path46.join(home, ".cursor/plugins/local/.workit-package-bootstrap"),
-          commands: entry.commands.map((command) => ({
-            ...command,
-            purpose: command.purpose ?? "Upgrade Cursor"
-          }))
+          path: path47.join(home, ".cursor/plugins/local/.workit-package-bootstrap"),
+          commands
         },
-        { type: "install-adapter", platform: "cursor", path: paths.cursorRoot }
+        { type: "install-adapter", platform: "cursor", path: paths.cursorRoot },
+        { type: "register-platform", platform: "cursor", path: cursorSettings },
+        { type: "register-platform", platform: "cursor", path: cursorMcp }
       ]
     };
     const result = applySetupPreview(preview, {
@@ -75800,16 +76056,16 @@ var codexPluginRoot = (codexHome) => {
       env,
       cwd: home,
       preferInstalledAdapter: true,
-      runHostCommand: (command) => {
-        const outcome = run(command.command, command.args);
-        return {
-          exitCode: outcome.status ?? 1,
-          stdout: outcome.stdout,
-          stderr: ""
-        };
+      runHostCommand: (command) => recorded.get(command) ?? {
+        exitCode: 1,
+        stdout: "",
+        stderr: "command did not run"
       }
     });
-    const installed = objectOrNull(path46.join(paths.cursorRoot, "package.json"));
+    const installed = objectOrNull(path47.join(paths.cursorRoot, "package.json"));
+    const problems = result.entries.filter((one) => one.status === "Failed").map((one) => one.detail ?? `${one.file} failed`);
+    if (problems.length)
+      return fail(`Cursor install failed: ${problems.map(briefDetail).join("; ")}`);
     if (!result.ok || installed?.version !== entry.latest)
       return fail("Cursor install did not verify the requested package version; inspect the installer before retrying");
     return {
@@ -75819,9 +76075,13 @@ var codexPluginRoot = (codexHome) => {
     };
   }
   const before = entry.host === "opencode" ? await opencodeVersion(runAsync) : undefined;
-  for (const command of entry.commands)
-    if ((await runAsync(command.command, command.args)).status !== 0)
-      return fail(`\`${command.command} ${command.args.join(" ")}\` failed`);
+  for (const command of entry.commands) {
+    let result = await runAsync(command.command, command.args);
+    if (result.status !== 0 && entry.host === "opencode")
+      result = await runAsync(command.command, command.args);
+    if (result.status !== 0)
+      return fail(failureReason(command, result));
+  }
   if (entry.host === "opencode") {
     const after = await opencodeVersion(runAsync);
     if (before && after)
@@ -75854,7 +76114,7 @@ var codexPluginRoot = (codexHome) => {
   }
   const verify = entry.host === "codex" ? await runAsync("codex", ["plugin", "list", "--json"]) : await runAsync("pi", ["list"]);
   if (verify.status !== 0)
-    return fail("update verification failed");
+    return fail(`update verification failed${stderrTail(verify.stderr) ? `: ${stderrTail(verify.stderr)}` : ""}`);
   if (entry.host === "codex") {
     let installed = [];
     try {
@@ -75872,11 +76132,16 @@ var codexPluginRoot = (codexHome) => {
   };
 }, refreshCodexAgents = async (run, codexHome) => {
   const root = codexPluginRoot(codexHome);
-  const launcher = root && path46.join(root, "dist", "launch-mcp.js");
+  const launcher = root && path47.join(root, "dist", "launch-mcp.js");
   if (!launcher || !existsSync22(launcher))
     return { ok: true, note: "" };
   const fix = `node ${JSON.stringify(launcher)} --install-agents`;
-  return (await run("node", [launcher, "--install-agents"])).status === 0 ? { ok: true, note: "agents refreshed" } : { ok: false, note: "agent refresh failed", fix };
+  const refreshed = await run("node", [launcher, "--install-agents"]);
+  return refreshed.status === 0 ? { ok: true, note: "agents refreshed" } : {
+    ok: false,
+    note: `agent refresh failed${stderrTail(refreshed.stderr) ? `: ${stderrTail(refreshed.stderr)}` : ""}`,
+    fix
+  };
 }, applyCli = async (cli, run, backup) => {
   const fail = (reason) => ({
     host: "cli",
@@ -75887,13 +76152,18 @@ var codexPluginRoot = (codexHome) => {
   const currentRoot = await run("npm", ["root", "--global"]);
   if (currentRoot.status !== 0 || currentRoot.stdout.trim() !== cli.root)
     return fail("Global npm location changed; preview again");
-  const cliBackup = path46.join(backup, "cli-package");
-  cpSync5(path46.join(cli.root, "@brainervirus/workit-cli"), cliBackup, {
+  const cliBackup = path47.join(backup, "cli-package");
+  cpSync5(path47.join(cli.root, "@brainervirus/workit-cli"), cliBackup, {
     recursive: true
   });
-  if ((await run("npm", ["install", "--global", `@brainervirus/workit-cli@${cli.latest}`])).status !== 0)
-    return fail(`CLI update failed; preserved package at ${cliBackup}; use npm to repair or run node ${path46.join(cliBackup, "dist/index.js")}`);
-  const installed = objectOrNull(path46.join(cli.root, "@brainervirus/workit-cli/package.json"));
+  const install = await run("npm", [
+    "install",
+    "--global",
+    `@brainervirus/workit-cli@${cli.latest}`
+  ]);
+  if (install.status !== 0)
+    return fail(`CLI update failed${stderrTail(install.stderr) ? ` (${stderrTail(install.stderr)})` : ""}; preserved package at ${cliBackup}; use npm to repair or run node ${path47.join(cliBackup, "dist/index.js")}`);
+  const installed = objectOrNull(path47.join(cli.root, "@brainervirus/workit-cli/package.json"));
   if (installed?.name !== "@brainervirus/workit-cli" || installed.version !== cli.latest)
     return fail(`CLI update did not verify the requested version; preserved package at ${cliBackup}`);
   return {
@@ -75914,7 +76184,7 @@ var init_apply = __esm(() => {
 
 // packages/workit-cli/src/upgrade/plan.ts
 import { existsSync as existsSync23, mkdtempSync as mkdtempSync3, rmSync as rmSync8, lstatSync as lstatSync8, readFileSync as readFileSync23 } from "node:fs";
-import path47 from "node:path";
+import path48 from "node:path";
 import os17 from "node:os";
 function previewUpgrade(hosts = HOSTS2, deps = {}) {
   const paths = upgradePaths(deps);
@@ -75938,9 +76208,9 @@ function previewUpgrade(hosts = HOSTS2, deps = {}) {
   for (const file of [
     paths.opencodeConfig,
     paths.opencodeConfig + "c",
-    path47.join(home, ".cursor/settings.json"),
-    path47.join(home, ".cursor/mcp.json"),
-    path47.join(paths.cursorRoot, "package.json"),
+    path48.join(home, ".cursor/settings.json"),
+    path48.join(home, ".cursor/mcp.json"),
+    path48.join(paths.cursorRoot, "package.json"),
     paths.codexConfig,
     paths.piSettings
   ])
@@ -76110,8 +76380,8 @@ var codexRegistered = (configFile) => {
         result.push(classify("opencode", pin));
   });
   guard("cursor", () => {
-    const cursor = objectOrNull(path47.join(paths.cursorRoot, "package.json"));
-    const mcp = objectOrNull(path47.join(home, ".cursor/mcp.json"));
+    const cursor = objectOrNull(path48.join(paths.cursorRoot, "package.json"));
+    const mcp = objectOrNull(path48.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";
@@ -76122,7 +76392,7 @@ var codexRegistered = (configFile) => {
       });
       return;
     }
-    const settings = objectOrNull(path47.join(home, ".cursor/settings.json"));
+    const settings = objectOrNull(path48.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)
@@ -76137,7 +76407,7 @@ var codexRegistered = (configFile) => {
       if (typeof source !== "string")
         continue;
       const npm = /^(?:npm:)?@brainervirus\/workit-pi(?:@[^/]+)?$/.test(source);
-      const local = path47.isAbsolute(source) && source.replaceAll("\\", "/").endsWith("/packages/workit-pi") && object2(path47.join(source, "package.json"))?.name === "@brainervirus/workit-pi";
+      const local = path48.isAbsolute(source) && source.replaceAll("\\", "/").endsWith("/packages/workit-pi") && object2(path48.join(source, "package.json"))?.name === "@brainervirus/workit-pi";
       if (!npm && !local)
         continue;
       const found = classify("pi", source);
@@ -76197,15 +76467,15 @@ var codexRegistered = (configFile) => {
   });
   return result;
 }, opencodeProbe = (deps, args) => {
-  const scratch = mkdtempSync3(path47.join(os17.tmpdir(), "workit-upgrade-opencode-"));
+  const scratch = mkdtempSync3(path48.join(os17.tmpdir(), "workit-upgrade-opencode-"));
   try {
     return runner({
       ...deps,
       env: {
         ...deps.env,
-        XDG_DATA_HOME: path47.join(scratch, "data"),
-        XDG_STATE_HOME: path47.join(scratch, "state"),
-        XDG_CACHE_HOME: path47.join(scratch, "cache")
+        XDG_DATA_HOME: path48.join(scratch, "data"),
+        XDG_STATE_HOME: path48.join(scratch, "state"),
+        XDG_CACHE_HOME: path48.join(scratch, "cache")
       }
     })("opencode", args);
   } finally {
@@ -76213,7 +76483,7 @@ var codexRegistered = (configFile) => {
   }
 }, planCli = (plan, run) => {
   const root = run("npm", ["root", "--global"]);
-  if (root.status !== 0 || !path47.isAbsolute(root.stdout.trim())) {
+  if (root.status !== 0 || !path48.isAbsolute(root.stdout.trim())) {
     plan.skipped.push({
       host: "cli",
       reason: "global npm location could not be verified",
@@ -76221,9 +76491,9 @@ var codexRegistered = (configFile) => {
     });
     return;
   }
-  const packageFile = path47.join(root.stdout.trim(), "@brainervirus/workit-cli/package.json");
+  const packageFile = path48.join(root.stdout.trim(), "@brainervirus/workit-cli/package.json");
   const installed = objectOrNull(packageFile);
-  if (installed?.name !== "@brainervirus/workit-cli" || lstatSync8(path47.dirname(packageFile)).isSymbolicLink()) {
+  if (installed?.name !== "@brainervirus/workit-cli" || lstatSync8(path48.dirname(packageFile)).isSymbolicLink()) {
     plan.skipped.push({
       host: "cli",
       reason: "no managed global CLI install (local links preserved); use npx @brainervirus/workit-cli@latest"
@@ -76261,33 +76531,44 @@ var init_plan = __esm(() => {
 });
 
 // packages/workit-cli/src/upgrade/report.ts
-var pad2 = (text) => text.padEnd(12), summary = (plan, permissions) => {
-  const lines = ["Workit upgrade plan:"];
+var pad2 = (text) => text.padEnd(12), PLAIN, summary = (plan, permissions, style = PLAIN) => {
+  const host = (name) => `  ${style.bold(pad2(name))}`;
+  const run = (fix) => fix ? ` (run: ${style.command(fix)})` : "";
+  const version = (from, to) => `update ${style.dim(from)} -> ${style.ok(to)}`;
+  const lines = [style.bold("Workit upgrade plan:")];
   if (plan.cli)
-    lines.push(`  ${pad2("cli")}update ${plan.cli.installed} -> ${plan.cli.latest}`);
+    lines.push(`${host("cli")}${version(plan.cli.installed, plan.cli.latest)}`);
   for (const entry of plan.entries) {
-    const what = entry.repair ? `reinstall missing plugin files (${entry.latest})` : entry.latest ? `update ${entry.installedVersion ?? "?"} -> ${entry.latest}` : `update (${entry.commands.map((c) => `${c.command} ${c.args.join(" ")}`).join(" && ")})`;
-    lines.push(`  ${pad2(entry.host)}${what}`);
+    const what = entry.repair ? `reinstall missing plugin files (${entry.latest})` : entry.latest ? version(entry.installedVersion ?? "?", entry.latest) : `update (${style.command(entry.commands.map((c) => `${c.command} ${c.args.join(" ")}`).join(" && "))})`;
+    lines.push(`${host(entry.host)}${what}`);
   }
   for (const skipped of plan.skipped)
-    lines.push(`  ${pad2(skipped.host)}${skipped.reason.startsWith("already current") ? "" : "skip: "}${skipped.reason}${skipped.fix ? ` (run: ${skipped.fix})` : ""}`);
+    lines.push(`${host(skipped.host)}${skipped.reason.startsWith("already current") ? style.dim(skipped.reason) : `${style.warn("skip:")} ${skipped.reason}`}${run(skipped.fix)}`);
   for (const failed of plan.failed)
-    lines.push(`  ${pad2(failed.host)}cannot upgrade: ${failed.reason}${failed.fix ? ` (run: ${failed.fix})` : ""}`);
+    lines.push(`${host(failed.host)}${style.fail("cannot upgrade:")} ${failed.reason}${run(failed.fix)}`);
   for (const migration of plan.migrations)
-    lines.push(`  ${pad2("config")}${migration.description}`);
+    lines.push(`${host("config")}${migration.description}`);
   for (const change of permissions)
-    lines.push(`  ${pad2("permissions")}refresh the ${change.host} block in ${change.file}`);
+    lines.push(`${host("permissions")}refresh the ${change.host} block in ${style.path(change.file)}`);
   for (const blocked of plan.blocked)
-    lines.push(`  blocked: ${blocked}`);
+    lines.push(`  ${style.fail("blocked:")} ${blocked}`);
   for (const warning of plan.warnings ?? [])
-    lines.push(`  warning: ${warning}`);
+    lines.push(`  ${style.warn("warning:")} ${warning}`);
   return lines.join(`
 `) + `
 `;
-}, LABEL, table = (hosts) => [
-  "Result:",
-  ...hosts.map((entry) => `  ${pad2(entry.host)}${LABEL[entry.status].padEnd(16)}${entry.reason}${entry.fix && entry.status !== "updated" && entry.status !== "current" ? `
-  ${pad2("")}${"".padEnd(16)}fix: ${entry.fix}` : ""}`)
+}, LABEL, reasonFor = (entry) => {
+  const label = LABEL[entry.status];
+  const head = entry.reason.slice(0, label.length);
+  return entry.status !== "failed" && head.toLowerCase() === label.toLowerCase() && !/^[a-z]/i.test(entry.reason[label.length] ?? "") ? entry.reason.slice(label.length).replace(/^[\s:;,-]+/, "") : entry.reason;
+}, PAINT, table = (hosts, style = PLAIN) => [
+  style.bold("Result:"),
+  ...hosts.map((entry) => {
+    const paint = style[PAINT[entry.status]];
+    const reason = reasonFor(entry);
+    return `  ${style.bold(pad2(entry.host))}${paint(LABEL[entry.status])}${" ".repeat(16 - LABEL[entry.status].length)}${entry.status === "current" ? style.dim(reason) : reason}${entry.fix && entry.status !== "updated" && entry.status !== "current" ? `
+  ${pad2("")}${"".padEnd(16)}fix: ${style.command(entry.fix)}` : ""}`;
+  })
 ].join(`
 `) + `
 `, askConfirm = async (question, out) => {
@@ -76300,12 +76581,20 @@ var pad2 = (text) => text.padEnd(12), summary = (plan, permissions) => {
   return /^y(?:es)?$/i.test((await askLine(question)).trim());
 };
 var init_report = __esm(() => {
+  init_style();
+  PLAIN = createStyle({ json: true });
   LABEL = {
     updated: "updated",
     current: "already current",
     skipped: "skipped",
     failed: "FAILED"
   };
+  PAINT = {
+    updated: "ok",
+    current: "dim",
+    skipped: "warn",
+    failed: "fail"
+  };
 });
 
 // packages/workit-cli/src/upgrade.ts
@@ -76337,6 +76626,11 @@ async function runUpgradeCommand(argv, deps = {}) {
   });
   plan.ok = plan.blocked.length === 0 && plan.failed.length === 0;
   const { home, env } = upgradePaths(deps);
+  const style = createStyle({
+    stream: out === process.stdout ? process.stdout : undefined,
+    env,
+    json
+  });
   const permissions = planHostPermissions({
     hosts: raw,
     refreshOnly: true,
@@ -76354,7 +76648,7 @@ async function runUpgradeCommand(argv, deps = {}) {
   };
   const withPermissions = (value) => permissions.changes.length ? { ...value, permissions: permissionPreview } : value;
   const applyCommand = `workit upgrade ${[...hostFlag === undefined ? [] : [`--hosts=${hostFlag}`], ...flags.has("--cli") ? ["--cli"] : [], "--yes"].join(" ")}`;
-  const nothingChanged = `preview only; nothing changed. Apply with: ${applyCommand}
+  const nothingChanged = `${style.dim("preview only; nothing changed.")} Apply with: ${style.command(applyCommand)}
 `;
   if (json && !legacy && !flags.has("--yes")) {
     out.write(JSON.stringify(withPermissions(plan), null, 2) + `
@@ -76362,20 +76656,20 @@ async function runUpgradeCommand(argv, deps = {}) {
     return plan.blocked.length ? 1 : 0;
   }
   if (!json)
-    out.write(summary(plan, permissions.changes));
+    out.write(summary(plan, permissions.changes, style));
   if (flags.has("--preview")) {
     out.write(nothingChanged);
     return plan.blocked.length ? 1 : 0;
   }
   if (plan.blocked.length) {
-    out.write(`Upgrade blocked: ${plan.blocked.join("; ")}
+    out.write(`${style.fail("Upgrade blocked:")} ${plan.blocked.join("; ")}
 Nothing changed.
 `);
     return 1;
   }
   const work = plan.entries.length + plan.migrations.length + (plan.cli ? 1 : 0) + permissions.changes.length;
   if (work > 0 && !flags.has("--yes") && !legacy) {
-    const confirmed = await (deps.confirm ?? ((q) => askConfirm(q, out)))("Apply this upgrade? [y/N] ");
+    const confirmed = await (deps.confirm ?? ((q) => askConfirm(q, out)))(`${style.bold("Apply this upgrade?")} [y/N] `);
     if (!confirmed) {
       out.write(nothingChanged);
       return 0;
@@ -76393,9 +76687,9 @@ Nothing changed.
     permissionsOk = written.every((entry) => entry.status === "written");
     for (const entry of written)
       result.hosts.push({
-        host: entry.host,
+        host: "permissions",
         status: entry.status === "written" ? "updated" : "failed",
-        reason: `permission block ${entry.status === "written" ? "refreshed" : entry.status} in ${entry.file}`,
+        reason: `${entry.host} block ${entry.status === "written" ? "refreshed" : entry.status} in ${entry.file}`,
         ...entry.status === "written" ? {} : { fix: `workit setup --hosts=${entry.host}` }
       });
   }
@@ -76414,19 +76708,19 @@ Nothing changed.
     return failed ? 1 : 0;
   }
   if (result.error && result.hosts.every((h) => h.status !== "failed"))
-    out.write(`Upgrade stopped: ${result.error}
+    out.write(`${style.fail("Upgrade stopped:")} ${result.error}
 `);
-  out.write(table(result.hosts));
+  out.write(table(result.hosts, style));
   if (permissions.refused)
-    out.write(`permissions: not refreshed: ${permissions.refused}
+    out.write(`permissions: ${style.warn("not refreshed:")} ${permissions.refused}
 `);
   if (result.backup)
-    out.write(`Backup: ${result.backup}
+    out.write(`Backup: ${style.path(result.backup)}
 `);
-  out.write(left.length === 0 ? `Verified: workit doctor is clean for versions, assets, agents and permissions.
-` : `Left after upgrade (workit doctor):
-${left.map((check) => `  ${check.id}: ${check.detail}${check.fix ? `
-    fix: ${check.fix}` : ""}`).join(`
+  out.write(left.length === 0 ? `${style.ok("Verified:")} workit doctor is clean for versions, assets, agents 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(`
 `)}
 `);
   return failed ? 1 : 0;
@@ -76489,6 +76783,7 @@ var init_upgrade = __esm(() => {
   init_doctor();
   init_host_permissions();
   init_progress();
+  init_style();
   init_apply();
   init_plan();
   init_report();
@@ -76521,7 +76816,7 @@ var init_launch = __esm(() => {
 // packages/workit-core/src/knowledge.ts
 import { spawnSync as spawnSync18 } from "node:child_process";
 import fs20 from "node:fs";
-import path48 from "node:path";
+import path49 from "node:path";
 function lintKnowledge(root) {
   const seen = new Set;
   const unreadable = [];
@@ -76625,7 +76920,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 = path48.join(root, file);
+  const full = path49.join(root, file);
   try {
     fs20.lstatSync(full);
   } catch {
@@ -76666,7 +76961,7 @@ var AGENTS_BYTE_BUDGET, STEERING_FILES, NEED_BASED_FILES, STANDARDS_FILE = "CODI
   }
 }, brokenLinks = (root, doc, tracked) => {
   const findings = [];
-  const base = path48.dirname(path48.join(root, doc.file));
+  const base = path49.dirname(path49.join(root, doc.file));
   const missing = (target, line, how) => findings.push({
     rule: "broken-link",
     file: doc.file,
@@ -76685,7 +76980,7 @@ var AGENTS_BYTE_BUDGET, STEERING_FILES, NEED_BASED_FILES, STANDARDS_FILE = "CODI
       const local = localTarget(target);
       if (!local)
         continue;
-      const resolved = local.startsWith("/") ? path48.join(root, local) : path48.resolve(base, local);
+      const resolved = local.startsWith("/") ? path49.join(root, local) : path49.resolve(base, local);
       if (!exists2(resolved))
         missing(target, index + 1, "link");
     }
@@ -76695,9 +76990,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(path48.join(root, first))))
+      if (!relative && !(tracked ? tracked.has(first) : exists2(path49.join(root, first))))
         continue;
-      const resolved = relative ? path48.resolve(base, candidate) : path48.join(root, candidate);
+      const resolved = relative ? path49.resolve(base, candidate) : path49.join(root, candidate);
       if (!exists2(resolved))
         missing(span, index + 1, "pointer");
     }
@@ -76785,6 +77080,7 @@ var init_knowledge = __esm(() => {
 // packages/workit-cli/src/verbs/doctor.ts
 var exports_doctor = {};
 __export(exports_doctor, {
+  renderDoctor: () => renderDoctor,
   run: () => run7
 });
 async function confirmForcedLockClear(root, args, io) {
@@ -76849,12 +77145,12 @@ async function run7(argv, io) {
       };
     }
   }
-  const report = runDoctor({
+  const report = progressFor(io).runSync("Checking Workit (workit doctor)", () => runDoctor({
     host: "cli",
     cwd: io.cwd,
     workspaceRoot: root,
     cliVersion: package_default.version
-  });
+  }), (done) => done.ok ? "done" : "failed");
   let knowledge = null;
   try {
     knowledge = lintKnowledge(root);
@@ -76886,30 +77182,73 @@ async function run7(argv, io) {
   if (checksConfig && checksConfig.action !== "none")
     io.stdout(`fix: checks config ${checksConfig.action}: ${checksConfig.detail}
 `);
-  io.stdout(`workit doctor — ${report.ok ? "healthy" : "problems found"} (${report.offline ? "offline" : "online"})
+  for (const line of renderDoctor(report, knowledgeLine, createStyle({ stream: io.terminals?.stdout, env: io.env, json: io.json })))
+    io.stdout(`${line}
 `);
+  return report.exitCode;
+}
+function renderDoctor(report, knowledgeLine, style) {
+  const summary = `passed ${report.summary.passed} / warned ${report.summary.warned} / failed ${report.summary.failed}`;
+  const header = `workit doctor — ${report.ok ? "healthy" : "problems found"} (${report.offline ? "offline" : "online"})`;
+  if (!style.enabled) {
+    const lines = [header];
+    for (const check of report.checks) {
+      const mark = check.status === "fail" ? "FAIL" : check.status === "warn" ? "WARN" : "ok  ";
+      lines.push(`${mark} ${check.id} — ${check.detail}`);
+      if (check.fix)
+        lines.push(`     fix: ${check.fix.replaceAll(`
+`, `
+          `)}`);
+    }
+    return [...lines, knowledgeLine, summary];
+  }
+  const marks = {
+    pass: style.ok("ok  "),
+    info: style.info("info"),
+    warn: style.warn("WARN"),
+    fail: style.fail("FAIL")
+  };
+  const idWidth = Math.min(ID_COLUMN, Math.max(0, ...report.checks.map((check) => check.id.length)));
+  const column = 5 + idWidth + 2;
+  const fixLines = (fix) => `     fix: ${fix.split(`
+`).map((line) => style.command(line)).join(`
+          `)}`;
+  const row = (check) => {
+    const id = check.id.padEnd(idWidth);
+    const used = 5 + id.length + 2;
+    return `${marks[check.status]} ${style.bold(id)}  ${wrap(check.detail, style.width, column, used)}`;
+  };
+  const lines = [
+    `workit doctor — ${report.ok ? style.ok("healthy") : style.fail("problems found")} ${style.dim(`(${report.offline ? "offline" : "online"})`)}`
+  ];
   for (const check of report.checks) {
-    const mark = check.status === "fail" ? "FAIL" : check.status === "warn" ? "WARN" : "ok  ";
-    io.stdout(`${mark} ${check.id} — ${check.detail}
-`);
+    lines.push(row(check));
     if (check.fix)
-      io.stdout(`     fix: ${check.fix.replaceAll(`
-`, `
-          `)}
-`);
+      lines.push(fixLines(check.fix));
   }
-  io.stdout(`${knowledgeLine}
-`);
-  io.stdout(`passed ${report.summary.passed} / warned ${report.summary.warned} / failed ${report.summary.failed}
-`);
-  return report.exitCode;
+  lines.push(style.dim(wrap(knowledgeLine, style.width, 5)));
+  const attention = report.checks.filter((c) => c.status === "fail" || c.status === "warn");
+  if (attention.length > 0) {
+    lines.push("", style.bold("Needs attention:"));
+    for (const check of attention) {
+      lines.push(row(check));
+      if (check.fix)
+        lines.push(fixLines(check.fix));
+    }
+  }
+  const paint = report.summary.failed > 0 ? style.fail : report.summary.warned > 0 ? style.warn : style.ok;
+  lines.push(paint(summary));
+  return lines;
 }
+var ID_COLUMN = 28;
 var init_doctor2 = __esm(() => {
   init_package();
   init_doctor();
   init_knowledge();
   init_store_lock();
   init_output();
+  init_progress();
+  init_style();
   init_prompt();
   init_task();
 });
@@ -77019,11 +77358,11 @@ var init_redact = __esm(() => {
 });
 
 // packages/workit-core/src/checks.ts
-import { spawn as spawn2, spawnSync as spawnSync19 } from "node:child_process";
+import { spawn as spawn3, spawnSync as spawnSync19 } from "node:child_process";
 import { createHash as createHash17 } from "node:crypto";
 import fs21 from "node:fs";
 import os18 from "node:os";
-import path49 from "node:path";
+import path50 from "node:path";
 import { StringDecoder } from "node:string_decoder";
 function tailLines(text, lines = TAIL_LINES) {
   const all = text.replace(/\r\n?/gu, `
@@ -77143,7 +77482,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 = path49.win32;
+  const win = path50.win32;
   const isFile = options.isFile ?? ((file) => {
     try {
       return fs21.statSync(file).isFile();
@@ -77248,7 +77587,7 @@ function runCheckCommand(argv, options) {
       shell: plan.shell
     };
     try {
-      child = spawn2(plan.file, plan.args, spawnOptions);
+      child = spawn3(plan.file, plan.args, spawnOptions);
     } catch (error) {
       finish(null, null, error.code ?? error.message);
       return;
@@ -77305,10 +77644,10 @@ function runCheckCommand(argv, options) {
 function storeLog(storeRoot, log) {
   const digest = logDigest(log);
   const ref = `blobs/logs/${digest.slice("sha256:".length)}.log`;
-  const file = path49.join(storeRoot, ref);
+  const file = path50.join(storeRoot, ref);
   try {
     if (!fs21.existsSync(file)) {
-      fs21.mkdirSync(path49.dirname(file), { recursive: true });
+      fs21.mkdirSync(path50.dirname(file), { recursive: true });
       const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
       fs21.writeFileSync(temp, log, { mode: 384 });
       fs21.renameSync(temp, file);
@@ -77321,7 +77660,7 @@ function storeLog(storeRoot, log) {
 function pruneCheckLogs(storeRoot, options = {}) {
   const limits = { ...LOG_RETENTION, ...options.retention };
   const now = options.now ?? Date.now();
-  const dir = path49.join(storeRoot, "blobs", "logs");
+  const dir = path50.join(storeRoot, "blobs", "logs");
   const report = { removed: 0, removedBytes: 0, kept: 0 };
   let names;
   try {
@@ -77331,7 +77670,7 @@ function pruneCheckLogs(storeRoot, options = {}) {
   }
   const files = names.flatMap((name) => {
     try {
-      const stat = fs21.statSync(path49.join(dir, name));
+      const stat = fs21.statSync(path50.join(dir, name));
       return stat.isFile() ? [{ name, size: stat.size, mtimeMs: stat.mtimeMs }] : [];
     } catch {
       return [];
@@ -77350,7 +77689,7 @@ function pruneCheckLogs(storeRoot, options = {}) {
       continue;
     if (!options.dryRun)
       try {
-        fs21.rmSync(path49.join(dir, file.name), { force: true });
+        fs21.rmSync(path50.join(dir, file.name), { force: true });
       } catch {
         continue;
       }
@@ -77393,7 +77732,7 @@ async function run8(argv, io) {
   const store = new TaskStore(workspaceRootFor({ cwd: io.cwd }));
   const location = store.location();
   const logs = location.ok ? pruneCheckLogs(location.data.dir, { dryRun }) : null;
-  const result = store.collectGarbage({ dryRun, pruneRecovery });
+  const result = progressFor(io).runSync("Collecting garbage", () => store.collectGarbage({ dryRun, pruneRecovery }), (r) => r.ok ? "done" : "failed");
   if (!result.ok)
     return emit(io, fail2(result.code === "busy" ? "busy" : "failed", `${result.code}: ${result.error}`, {
       data: { code: result.code, details: result.details },
@@ -77418,6 +77757,7 @@ async function run8(argv, io) {
 }
 var megabytes = (bytes) => (bytes / 1048576).toFixed(1);
 var init_gc = __esm(() => {
+  init_progress();
   init_checks3();
   init_task_store();
   init_output();
@@ -78002,12 +78342,12 @@ var init_workspace = __esm(() => {
 
 // packages/workit-core/src/core/heavy-rules.ts
 import fs22 from "node:fs";
-import path50 from "node:path";
+import path51 from "node:path";
 function gitTop(cwd) {
-  for (let dir = path50.resolve(cwd);; dir = path50.dirname(dir)) {
-    if (fs22.existsSync(path50.join(dir, ".git")))
+  for (let dir = path51.resolve(cwd);; dir = path51.dirname(dir)) {
+    if (fs22.existsSync(path51.join(dir, ".git")))
       return dir;
-    if (path50.dirname(dir) === dir)
+    if (path51.dirname(dir) === dir)
       return null;
   }
 }
@@ -78049,18 +78389,18 @@ var init_heavy_rules = () => {};
 // packages/workit-core/src/core/heavy.ts
 import fs23 from "node:fs";
 import os19 from "node:os";
-import path51 from "node:path";
+import path52 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 path51.join(env.XDG_STATE_HOME, "workit");
+    return path52.join(env.XDG_STATE_HOME, "workit");
   const home = env.HOME || os19.homedir();
   if (platform === "darwin")
-    return path51.join(home, "Library", "Application Support", "workit");
+    return path52.join(home, "Library", "Application Support", "workit");
   if (platform === "win32")
-    return path51.join(env.LOCALAPPDATA ?? path51.join(home, "AppData", "Local"), "workit");
-  return path51.join(home, ".local", "state", "workit");
+    return path52.join(env.LOCALAPPDATA ?? path52.join(home, "AppData", "Local"), "workit");
+  return path52.join(home, ".local", "state", "workit");
 }
 function positional(words, from, values = PM_VALUES) {
   let index = from;
@@ -78200,7 +78540,7 @@ function machinePatterns(env) {
   return isRecord8(value) ? stringList2(value.patterns) : [];
 }
 function repoPatterns(cwd) {
-  return repoHeavyCommands(gitTop(cwd) ?? path51.resolve(cwd));
+  return repoHeavyCommands(gitTop(cwd) ?? path52.resolve(cwd));
 }
 function heavyLines(lines, options) {
   const found = [];
@@ -78279,7 +78619,7 @@ function leaseRewrite(command) {
     return null;
   return `${prefix}workit check --heavy -- ${rest}`;
 }
-var HEAVY_COMMANDS_FILE = "heavy-commands.json", heavyCommandsFile = (env) => path51.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) => path52.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 {
@@ -78426,7 +78766,7 @@ var init_heavy = __esm(() => {
 import { randomUUID as randomUUID5 } from "node:crypto";
 import fs24 from "node:fs";
 import os20 from "node:os";
-import path52 from "node:path";
+import path53 from "node:path";
 function memoryValue(value, host) {
   const text = typeof value === "number" ? String(value) : typeof value === "string" ? value : "";
   const percent = PERCENT.exec(text.trim());
@@ -78622,7 +78962,7 @@ function tryOnce(options, record, reclaimed) {
   const text = `${JSON.stringify(record)}
 `;
   for (let slot = 0;slot < options.slots; slot += 1) {
-    const file = path52.join(options.dir, `slot-${slot}.json`);
+    const file = path53.join(options.dir, `slot-${slot}.json`);
     for (let attempt = 0;attempt < 2; attempt += 1) {
       try {
         const fd = fs24.openSync(file, "wx", 384);
@@ -78667,7 +79007,7 @@ function leaseQueue(dir, probe = {}) {
   }
   const entries = [];
   for (const name of names.filter((item) => item.endsWith(".json")).toSorted()) {
-    const file = path52.join(queueDir(dir), name);
+    const file = path53.join(queueDir(dir), name);
     const record = parseLease(readText5(file));
     if (!record)
       continue;
@@ -78683,9 +79023,9 @@ function leaseQueue(dir, probe = {}) {
 function waitersAhead(options, own) {
   let ahead = 0;
   for (const entry of leaseQueue(options.dir, options.probe)) {
-    if (path52.basename(entry.file) >= own)
+    if (path53.basename(entry.file) >= own)
       break;
-    if (!TICKET.test(path52.basename(entry.file)))
+    if (!TICKET.test(path53.basename(entry.file)))
       continue;
     if (entry.stale && reclaim(entry.file, (current) => !current || staleReason(current, options.probe) !== null))
       continue;
@@ -78697,7 +79037,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(path52.dirname(file), { recursive: true, mode: 448 });
+  fs24.mkdirSync(path53.dirname(file), { recursive: true, mode: 448 });
   fs24.writeFileSync(file, `${JSON.stringify(record)}
 `, { mode: 384 });
 }
@@ -78742,7 +79082,7 @@ async function acquireLease(options) {
   const reclaimed = [];
   let waitedOn = [];
   const name = ticketName(started, record.id);
-  const ticket = path52.join(queueDir(options.dir), name);
+  const ticket = path53.join(queueDir(options.dir), name);
   const ticketRecord = {
     ...record,
     maxAgeMs: options.waitMs + 60000
@@ -78863,7 +79203,7 @@ function heldLease(dir, id, options = {}) {
   for (const name of names) {
     if (!/^slot-\d+\.json$/u.test(name))
       continue;
-    const lease = parseLease(readText5(path52.join(dir, name)));
+    const lease = parseLease(readText5(path53.join(dir, name)));
     if (lease?.id === id && !staleReason(lease, options.probe) && (options.ancestor ?? isAncestor)(lease.pid))
       return lease;
   }
@@ -78918,10 +79258,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 = path52.join(stateDir2(env), "notices");
+  const dir = path53.join(stateDir2(env), "notices");
   try {
     fs24.mkdirSync(dir, { recursive: true, mode: 448 });
-    fs24.writeFileSync(path52.join(dir, `${key}-${id}`), `${new Date(now).toISOString()}
+    fs24.writeFileSync(path53.join(dir, `${key}-${id}`), `${new Date(now).toISOString()}
 `, {
       flag: "wx",
       mode: 384
@@ -78931,7 +79271,7 @@ function firstNotice(env, session, key, now = Date.now()) {
   }
   try {
     for (const name of fs24.readdirSync(dir)) {
-      const file = path52.join(dir, name);
+      const file = path53.join(dir, name);
       if (now - fs24.statSync(file).mtimeMs > NOTICE_TTL_MS)
         fs24.rmSync(file, { force: true });
     }
@@ -78941,7 +79281,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(path52.join(dir, `slot-${slot}.json`)));
+    const lease = parseLease(readText5(path53.join(dir, `slot-${slot}.json`)));
     states.push({
       slot,
       holder: lease ? holderOf(lease) : null,
@@ -78953,7 +79293,7 @@ function leaseSlots(dir, slots, probe = {}) {
 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: os20.totalmem(),
   cpus: Math.max(1, os20.availableParallelism?.() ?? os20.cpus().length)
-}), isRecord9 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), SIZE, PERCENT, UNITS, leaseDir = (env) => path52.join(stateDir2(env), "leases"), readText5 = (file) => {
+}), isRecord9 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), SIZE, PERCENT, UNITS, leaseDir = (env) => path53.join(stateDir2(env), "leases"), readText5 = (file) => {
   try {
     return fs24.readFileSync(file, "utf8");
   } catch {
@@ -78984,7 +79324,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) => path52.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) => path53.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();
@@ -79014,7 +79354,7 @@ __export(exports_check, {
   workspaceResources: () => workspaceResources
 });
 import os21 from "node:os";
-import path53 from "node:path";
+import path54 from "node:path";
 function parse6(argv) {
   const split = argv.indexOf("--");
   const head = split >= 0 ? argv.slice(0, split) : [...argv];
@@ -79245,7 +79585,7 @@ ${footer}`;
 }
 async function workspaceResources(io) {
   const env = io.env;
-  const dir = env.WORKFLOW_TOOLKIT_CONFIG ?? env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path53.join(env.XDG_CONFIG_HOME || path53.join(env.HOME || os21.homedir(), ".config"), "workit");
+  const dir = env.WORKFLOW_TOOLKIT_CONFIG ?? env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path54.join(env.XDG_CONFIG_HOME || path54.join(env.HOME || os21.homedir(), ".config"), "workit");
   try {
     await Promise.resolve().then(() => init_workspaces());
     const workspace = resolveWorkspaceFrom(io.cwd, dir, env.WORKFLOW_WORKSPACE_NAME?.trim() || undefined);
@@ -79266,7 +79606,7 @@ async function prepareHeavy(io, settings, label, runCwd, timeoutMs) {
       wrapper: null,
       env: io.env
     };
-  const progress = createProgress({ stream: process.stderr, json: io.json });
+  const progress = progressFor(io);
   let waiting = null;
   const acquired = await acquireLease({
     dir,
@@ -79387,7 +79727,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(path53.relative(top, runCwd));
+  const relCwd = posix(path54.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)
@@ -79452,7 +79792,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 ? path53.join(store.value.root, blob.ref) : null;
+  const logPath = store.ok && blob ? path54.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);
@@ -79567,7 +79907,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(path53.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(path54.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_check = __esm(() => {
   init_check_config();
   init_checks3();
@@ -79598,7 +79938,7 @@ __export(exports_lock, {
   run: () => run13
 });
 import fs25 from "node:fs";
-import path54 from "node:path";
+import path55 from "node:path";
 async function settingsFor(io) {
   const workspace = await workspaceResources(io);
   const config = loadCheckConfig(io.cwd);
@@ -79690,7 +80030,7 @@ function readPatterns(file) {
   return { patterns: [] };
 }
 function writePatterns(file, value) {
-  fs25.mkdirSync(path54.dirname(file), { recursive: true, mode: 448 });
+  fs25.mkdirSync(path55.dirname(file), { recursive: true, mode: 448 });
   const temp = `${file}.${process.pid}.tmp`;
   fs25.writeFileSync(temp, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
@@ -79778,7 +80118,7 @@ __export(exports_models, {
 });
 import { existsSync as existsSync25, readdirSync as readdirSync13, readFileSync as readFileSync24, statSync as statSync9 } from "node:fs";
 import os22 from "node:os";
-import path55 from "node:path";
+import path56 from "node:path";
 async function run14(argv, io) {
   const [sub, ...args] = argv.filter((arg) => arg !== "--json");
   if (sub !== "show")
@@ -79853,20 +80193,20 @@ 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 = path55.join(env.CLAUDE_CONFIG_DIR || path55.join(env.HOME || os22.homedir(), ".claude"), "projects");
+  const projects = path56.join(env.CLAUDE_CONFIG_DIR || path56.join(env.HOME || os22.homedir(), ".claude"), "projects");
   const since = Date.now() - days * 86400000;
   const types = {};
   let agents = 0;
   const dirs = (dir) => {
     try {
-      return readdirSync13(dir).map((name) => path55.join(dir, name));
+      return readdirSync13(dir).map((name) => path56.join(dir, name));
     } catch {
       return [];
     }
   };
   for (const project of dirs(projects))
     for (const session of dirs(project))
-      for (const meta of dirs(path55.join(session, "subagents")).filter((f) => f.endsWith(".meta.json"))) {
+      for (const meta of dirs(path56.join(session, "subagents")).filter((f) => f.endsWith(".meta.json"))) {
         try {
           if (statSync9(meta).mtimeMs < since)
             continue;
@@ -80012,7 +80352,7 @@ var success2 = (data) => ({ ok: true, data }), failure3 = (code, error, unblock)
 // packages/workit-core/src/git/ops.ts
 import { spawnSync as spawnSync20 } from "node:child_process";
 import { existsSync as existsSync26, readFileSync as readFileSync25 } from "node:fs";
-import path56 from "node:path";
+import path57 from "node:path";
 function operationInProgress(cwd) {
   const markers = [
     ["rebase-merge", "rebase"],
@@ -80025,18 +80365,18 @@ function operationInProgress(cwd) {
   if (!run.ok)
     return null;
   const found = run.stdout.split(`
-`).map((line) => path56.resolve(cwd, line.trim()));
+`).map((line) => path57.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))
       continue;
-    if (index === 1 && existsSync26(path56.join(marker, "applying")))
+    if (index === 1 && existsSync26(path57.join(marker, "applying")))
       return { operation: "am", commitAllowed: false, branch: null };
-    if (index === 0 && existsSync26(path56.join(marker, "amend")) && !conflicted()) {
+    if (index === 0 && existsSync26(path57.join(marker, "amend")) && !conflicted()) {
       let headName = "";
       try {
-        headName = readFileSync25(path56.join(marker, "head-name"), "utf8").trim();
+        headName = readFileSync25(path57.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 };
@@ -80364,7 +80704,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(path56.resolve(cwd, value)) || [...tracked].some((file) => file === value || file.startsWith(`${value}/`)));
+    const addable = paths.filter((value) => existsSync26(path57.resolve(cwd, value)) || [...tracked].some((file) => file === value || file.startsWith(`${value}/`)));
     if (addable.length) {
       const added = git5(cwd, ["add", "-A", "--", ...addable]);
       if (!added.ok)
@@ -80903,12 +81243,12 @@ var init_ops = __esm(() => {
 
 // packages/workit-core/src/verdict-cover.ts
 import fs26 from "node:fs";
-import path57 from "node:path";
+import path58 from "node:path";
 function chainsAbove(cwd, branch) {
   const root = storeRoot(cwd);
   if (!root.ok)
     return [];
-  const dir = path57.join(root.value.root, "stacks");
+  const dir = path58.join(root.value.root, "stacks");
   let names = [];
   try {
     names = fs26.readdirSync(dir).filter((name) => name.endsWith(".json"));
@@ -80919,7 +81259,7 @@ function chainsAbove(cwd, branch) {
   for (const name of names.toSorted()) {
     let parsed;
     try {
-      parsed = JSON.parse(fs26.readFileSync(path57.join(dir, name), "utf8"));
+      parsed = JSON.parse(fs26.readFileSync(path58.join(dir, name), "utf8"));
     } catch {
       continue;
     }
@@ -81075,10 +81415,10 @@ var init_check_evidence = __esm(() => {
 
 // packages/workit-core/src/forge/reruns.ts
 import fs27 from "node:fs";
-import path58 from "node:path";
+import path59 from "node:path";
 function rerunLogPath(cwd) {
   const common = gitCommonDir(cwd);
-  return common ? path58.join(common, "workit", "ci-reruns.jsonl") : null;
+  return common ? path59.join(common, "workit", "ci-reruns.jsonl") : null;
 }
 function rerunCounts(cwd, key) {
   const counts = new Map;
@@ -81113,7 +81453,7 @@ function recordReruns(cwd, rows) {
   if (!file)
     return false;
   try {
-    fs27.mkdirSync(path58.dirname(file), { recursive: true });
+    fs27.mkdirSync(path59.dirname(file), { recursive: true });
     fs27.appendFileSync(file, rows.map((row) => `${JSON.stringify(row)}
 `).join(""));
     return true;
@@ -81126,7 +81466,7 @@ function withRerunLock(cwd, fn) {
   if (!file)
     return fn();
   const lock = `${file.slice(0, -".jsonl".length)}.lock`;
-  fs27.mkdirSync(path58.dirname(lock), { recursive: true });
+  fs27.mkdirSync(path59.dirname(lock), { recursive: true });
   const until = Date.now() + LOCK_WAIT_MS2;
   for (;; ) {
     try {
@@ -82122,7 +82462,7 @@ var init_pr_ops = __esm(() => {
 import { spawnSync as spawnSync22 } from "node:child_process";
 import { createHash as createHash18, randomBytes as randomBytes4 } from "node:crypto";
 import fs28 from "node:fs";
-import path59 from "node:path";
+import path60 from "node:path";
 function worktreeOf(cwd, branch) {
   const list = gitRun3(cwd, ["worktree", "list", "--porcelain"]);
   if (!list.ok)
@@ -82171,7 +82511,7 @@ function gitRestack(cwd, input) {
         error: "no store root"
       };
     fs28.mkdirSync(scratch, { recursive: true });
-    dir = path59.join(scratch, `${input.branch.replace(/[^A-Za-z0-9._-]+/gu, "_").slice(0, 40)}-${randomBytes4(4).toString("hex")}`);
+    dir = path60.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 {
@@ -82227,7 +82567,7 @@ function pruneScratch(cwd) {
   if (!scratch || !fs28.existsSync(scratch))
     return;
   for (const name of fs28.readdirSync(scratch)) {
-    const dir = path59.join(scratch, name);
+    const dir = path60.join(scratch, name);
     if (!rebaseInProgress(dir) && !trackedDirt(dir))
       gitRun3(cwd, ["worktree", "remove", "--force", dir]);
   }
@@ -82237,7 +82577,7 @@ function stacksDir(cwd) {
   const root = storeRoot(cwd);
   if (!root.ok)
     return stackFail(root.code, root.error, root.unblock);
-  return { ok: true, data: path59.join(root.value.root, "stacks") };
+  return { ok: true, data: path60.join(root.value.root, "stacks") };
 }
 function parseStack(raw) {
   if (!isRecord12(raw) || !Array.isArray(raw.branches))
@@ -82289,7 +82629,7 @@ function readStack(cwd, name) {
   const dir = stacksDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path59.join(dir.data, fileFor(name));
+  const file = path60.join(dir.data, fileFor(name));
   let text;
   try {
     text = fs28.readFileSync(file, "utf8");
@@ -82310,7 +82650,7 @@ function writeStack(cwd, stack, now = new Date) {
   const dir = stacksDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path59.join(dir.data, fileFor(stack.name));
+  const file = path60.join(dir.data, fileFor(stack.name));
   const temp = `${file}.${process.pid}.tmp`;
   try {
     fs28.mkdirSync(dir.data, { recursive: true });
@@ -82338,7 +82678,7 @@ function listStacks(cwd) {
   for (const name of names) {
     let parsed = null;
     try {
-      parsed = parseStack(JSON.parse(fs28.readFileSync(path59.join(dir.data, name), "utf8")));
+      parsed = parseStack(JSON.parse(fs28.readFileSync(path60.join(dir.data, name), "utf8")));
     } catch {
       parsed = null;
     }
@@ -82400,7 +82740,7 @@ function takeLock(lock) {
     host: localLockHost(),
     nonce: randomBytes4(8).toString("hex")
   };
-  fs28.writeFileSync(path59.join(lock, OWNER), JSON.stringify(owner));
+  fs28.writeFileSync(path60.join(lock, OWNER), JSON.stringify(owner));
   return owner;
 }
 function reapLock(lock, observed) {
@@ -82437,7 +82777,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 = path59.join(dir.data, `${fileFor(name)}.lock`);
+  const lock = path60.join(dir.data, `${fileFor(name)}.lock`);
   try {
     fs28.mkdirSync(dir.data, { recursive: true });
   } catch (error) {
@@ -82467,7 +82807,7 @@ async function withStackLock(cwd, name, fn, waitMs = LOCK_WAIT_MS3) {
   const touch = () => {
     try {
       const now = new Date;
-      fs28.utimesSync(path59.join(lock, OWNER), now, now);
+      fs28.utimesSync(path60.join(lock, OWNER), now, now);
     } catch {}
   };
   const beat = setInterval(touch, HEARTBEAT_MS);
@@ -83436,7 +83776,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 ? path59.join(dir.data, "worktrees") : null;
+  return dir.ok ? path60.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) => {
@@ -83451,12 +83791,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(path59.join(lock, OWNER), "utf8");
+    raw = fs28.readFileSync(path60.join(lock, OWNER), "utf8");
   } catch {
     raw = null;
   }
   let age = null;
-  for (const target of [path59.join(lock, OWNER), lock])
+  for (const target of [path60.join(lock, OWNER), lock])
     try {
       age = Date.now() - fs28.statSync(target).mtimeMs;
       break;
@@ -83500,7 +83840,7 @@ var init_stack = __esm(() => {
 import { spawnSync as spawnSync23 } from "node:child_process";
 import { createHash as createHash19 } from "node:crypto";
 import fs29 from "node:fs";
-import path60 from "node:path";
+import path61 from "node:path";
 function expandBraces2(pattern, limit = 64) {
   for (let index = 0;index < pattern.length; index += 1) {
     if (pattern[index] === "\\") {
@@ -83746,7 +84086,7 @@ function parsePlan(raw, defaults, name) {
       id,
       branch,
       base: optional("base") ?? "",
-      worktree: path60.resolve(defaults.root, optional("worktree") ?? path60.join(defaults.worktreeRoot, id)),
+      worktree: path61.resolve(defaults.root, optional("worktree") ?? path61.join(defaults.worktreeRoot, id)),
       tier,
       reason,
       dependsOn: [...new Set(dependsOn ?? [])],
@@ -83875,12 +84215,12 @@ function regeneratedFiles(root, tracked) {
   const found = new Map;
   let scripts;
   try {
-    const manifest = JSON.parse(fs29.readFileSync(path60.join(root, "package.json"), "utf8"));
+    const manifest = JSON.parse(fs29.readFileSync(path61.join(root, "package.json"), "utf8"));
     scripts = manifest.scripts ?? {};
   } catch {
     return found;
   }
-  const runner = fs29.existsSync(path60.join(root, "bun.lock")) ? "bun run" : fs29.existsSync(path60.join(root, "pnpm-lock.yaml")) ? "pnpm run" : fs29.existsSync(path60.join(root, "yarn.lock")) ? "yarn run" : "npm run";
+  const runner = fs29.existsSync(path61.join(root, "bun.lock")) ? "bun run" : fs29.existsSync(path61.join(root, "pnpm-lock.yaml")) ? "pnpm run" : fs29.existsSync(path61.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")
@@ -83888,7 +84228,7 @@ function regeneratedFiles(root, tracked) {
     for (const file of command.match(/[\w./-]+\.[cm]?[jt]s\b/gu) ?? []) {
       let source;
       try {
-        source = fs29.readFileSync(path60.join(root, file), "utf8");
+        source = fs29.readFileSync(path61.join(root, file), "utf8");
       } catch {
         continue;
       }
@@ -84010,11 +84350,11 @@ function defaultTrunk(cwd) {
 }
 function mainCheckout(cwd) {
   const common = gitCommonDir(cwd);
-  return common && path60.basename(common) === ".git" ? path60.dirname(common) : path60.resolve(cwd);
+  return common && path61.basename(common) === ".git" ? path61.dirname(common) : path61.resolve(cwd);
 }
 function worktreeRoot(cwd) {
   const main = mainCheckout(cwd);
-  return path60.join(path60.dirname(main), `${path60.basename(main)}-wt`);
+  return path61.join(path61.dirname(main), `${path61.basename(main)}-wt`);
 }
 function sliceHash(slice) {
   const {
@@ -84034,7 +84374,7 @@ function fanoutsDir(cwd) {
   const root = storeRoot(cwd);
   if (!root.ok)
     return fanoutFail(root.code, root.error, root.unblock);
-  return { ok: true, data: path60.join(root.value.root, "fanouts") };
+  return { ok: true, data: path61.join(root.value.root, "fanouts") };
 }
 function parseStored(raw) {
   if (!isRecord13(raw) || typeof raw.name !== "string" || typeof raw.trunk !== "string")
@@ -84102,7 +84442,7 @@ function readFanout(cwd, name) {
   const dir = fanoutsDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path60.join(dir.data, stackFileName(name));
+  const file = path61.join(dir.data, stackFileName(name));
   let parsed = null;
   try {
     parsed = parseStored(JSON.parse(fs29.readFileSync(file, "utf8")));
@@ -84127,7 +84467,7 @@ function listFanouts(cwd) {
   for (const entry of names) {
     let parsed = null;
     try {
-      parsed = parseStored(JSON.parse(fs29.readFileSync(path60.join(dir.data, entry), "utf8")));
+      parsed = parseStored(JSON.parse(fs29.readFileSync(path61.join(dir.data, entry), "utf8")));
     } catch {
       parsed = null;
     }
@@ -84166,7 +84506,7 @@ function writeFanout(cwd, plan) {
   const dir = fanoutsDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path60.join(dir.data, stackFileName(plan.name));
+  const file = path61.join(dir.data, stackFileName(plan.name));
   const temp = `${file}.${process.pid}.tmp`;
   try {
     fs29.mkdirSync(dir.data, { recursive: true });
@@ -84377,13 +84717,13 @@ var init_fanout = __esm(() => {
 // packages/workit-core/src/forge/exec.ts
 import { spawnSync as spawnSync24 } from "node:child_process";
 import fs30 from "node:fs";
-import path61 from "node:path";
+import path62 from "node:path";
 function findExecutable(bin, env) {
-  const dirs = (env.PATH ?? env.Path ?? "").split(path61.delimiter).filter(Boolean);
+  const dirs = (env.PATH ?? env.Path ?? "").split(path62.delimiter).filter(Boolean);
   const exts = process.platform === "win32" ? [".exe"] : [""];
   for (const dir of dirs)
     for (const ext of exts) {
-      const candidate = path61.join(dir, `${bin}${ext}`);
+      const candidate = path62.join(dir, `${bin}${ext}`);
       try {
         const stat = fs30.statSync(candidate);
         if (stat.isFile())
@@ -85511,13 +85851,13 @@ function placeRef(ref, forge, tracker, relation, youtrackBase) {
   const configured = tracker?.provider === ref.tracker;
   const home = ref.tracker === forge.kind ? forge.host : DEFAULT_HOST[ref.tracker];
   const host = ref.host ?? (configured ? tracker?.host : null) ?? home;
-  const repo = ref.repo ?? (configured ? tracker?.repo : null) ?? (ref.tracker === forge.kind && same2(host, forge.host) ? forge.repo : null);
+  const repo = ref.repo ?? (configured ? tracker?.repo : null) ?? (ref.tracker === forge.kind && same3(host, forge.host) ? forge.repo : null);
   if (!repo)
     return {
       error: `#${ref.id} is a ${ref.tracker} issue, but the PR is on ${forge.kind}: set issues.repo to the ${ref.tracker} project that holds it, or pass the issue URL`
     };
-  if (ref.tracker === forge.kind && same2(host, forge.host)) {
-    const own = same2(repo, forge.repo);
+  if (ref.tracker === forge.kind && same3(host, forge.host)) {
+    const own = same3(repo, forge.repo);
     return {
       tracker: ref.tracker,
       id: ref.id,
@@ -85654,7 +85994,7 @@ function issueForge(resolved, link, runner) {
   if (link.repo === null && link.host === null)
     return resolved.forge;
   const apiHost = resolved.forge.apiHost;
-  if (link.tracker !== resolved.forge.kind || !same2(link.host ?? apiHost, apiHost))
+  if (link.tracker !== resolved.forge.kind || !same3(link.host ?? apiHost, apiHost))
     return null;
   const options = {
     apiHost,
@@ -85721,7 +86061,7 @@ async function postBacklinks(cwd, resolved, pr, links, deps = {}) {
   }
   return out;
 }
-var DEFAULT_HOST, same2 = (left, right) => (left ?? "").toLowerCase() === (right ?? "").toLowerCase(), issueUrl = (kind, host, repo, id) => `https://${host}/${repo}/${kind === "gitlab" ? "-/" : ""}issues/${id}`, label = (link) => link.tracker === "youtrack" ? link.id : link.url ?? `${link.repo ?? ""}#${link.id}`, defaultYouTrackComment = (root, issueId, text, marker) => writeOnce(issueId, marker, "comments", async () => {
+var DEFAULT_HOST, same3 = (left, right) => (left ?? "").toLowerCase() === (right ?? "").toLowerCase(), issueUrl = (kind, host, repo, id) => `https://${host}/${repo}/${kind === "gitlab" ? "-/" : ""}issues/${id}`, label = (link) => link.tracker === "youtrack" ? link.id : link.url ?? `${link.repo ?? ""}#${link.id}`, defaultYouTrackComment = (root, issueId, text, marker) => writeOnce(issueId, marker, "comments", async () => {
   try {
     return {
       ok: true,
@@ -86173,7 +86513,7 @@ var init_live_session = __esm(() => {
 });
 
 // packages/workit-core/src/hooks/write-gate.ts
-import path62 from "node:path";
+import path63 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();
@@ -86213,7 +86553,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 = path62.resolve(path62.parse(process.cwd()).root, ".workit-unknown-dir");
+  UNKNOWN_DIR = path63.resolve(path63.parse(process.cwd()).root, ".workit-unknown-dir");
 });
 
 // packages/workit-core/src/hooks/worktree-confine.ts
@@ -86238,20 +86578,20 @@ var init_worktree_confine = __esm(() => {
 
 // packages/workit-core/src/worktree-deps.ts
 import fs31 from "node:fs";
-import path63 from "node:path";
+import path64 from "node:path";
 function moduleDirs(main) {
   const out = [];
   const walk = (relative, depth) => {
     let entries;
     try {
-      entries = fs31.readdirSync(path63.join(main, relative), { withFileTypes: true });
+      entries = fs31.readdirSync(path64.join(main, relative), { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const child = path63.join(relative, entry.name);
+      const child = path64.join(relative, entry.name);
       if (entry.name === MODULES)
         out.push(child);
       else if (depth < MAX_DEPTH2 && !entry.name.startsWith("."))
@@ -86265,8 +86605,8 @@ function linkEntry(main, worktree, source, target) {
   const stat = fs31.lstatSync(source);
   if (stat.isSymbolicLink()) {
     const link = fs31.readlinkSync(source);
-    const outside = path63.isAbsolute(link) && within(link, main) && !path63.relative(main, link).split(path63.sep).includes(MODULES);
-    const to = outside ? path63.join(worktree, path63.relative(main, link)) : link;
+    const outside = path64.isAbsolute(link) && within(link, main) && !path64.relative(main, link).split(path64.sep).includes(MODULES);
+    const to = outside ? path64.join(worktree, path64.relative(main, link)) : link;
     fs31.symlinkSync(to, target, process.platform === "win32" ? "junction" : undefined);
     return;
   }
@@ -86276,8 +86616,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 = path63.join(source, entry.name);
-    const to = path63.join(target, entry.name);
+    const from = path64.join(source, entry.name);
+    const to = path64.join(target, entry.name);
     if (top && entry.isDirectory() && (entry.name.startsWith("@") || entry.name === ".bin"))
       count += mirror(main, worktree, from, to, false);
     else {
@@ -86293,16 +86633,16 @@ function linkWorktreeDependencies(main, worktree) {
   const dirs = [];
   let entries = 0;
   for (const relative of moduleDirs(main)) {
-    const target = path63.join(worktree, relative);
-    if (!fs31.existsSync(path63.dirname(target)) || fs31.existsSync(target))
+    const target = path64.join(worktree, relative);
+    if (!fs31.existsSync(path64.dirname(target)) || fs31.existsSync(target))
       continue;
-    if (!gitRun4(worktree, ["check-ignore", "-q", `${relative.split(path63.sep).join("/")}/`]).ok) {
-      notes.push(`${relative.split(path63.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(path64.sep).join("/")}/`]).ok) {
+      notes.push(`${relative.split(path64.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, path63.join(main, relative), target, true);
-      dirs.push(relative.split(path63.sep).join("/"));
+      entries += mirror(main, worktree, path64.join(main, relative), target, true);
+      dirs.push(relative.split(path64.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`);
@@ -86315,8 +86655,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 = path63.relative(parent, child);
-  return relative === "" || !relative.startsWith("..") && !path63.isAbsolute(relative);
+  const relative = path64.relative(parent, child);
+  return relative === "" || !relative.startsWith("..") && !path64.isAbsolute(relative);
 };
 var init_worktree_deps = __esm(() => {
   init_fanout();
@@ -86325,7 +86665,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 path64 from "node:path";
+import path65 from "node:path";
 function rowSample(lines) {
   const out = [];
   let bytes = 0;
@@ -86385,7 +86725,7 @@ function adminDir(worktree) {
   const file = dir.stdout.trim();
   let token = null;
   try {
-    token = fs32.readFileSync(path64.join(file, FANOUT_TOKEN_FILE), "utf8").trim() || null;
+    token = fs32.readFileSync(path65.join(file, FANOUT_TOKEN_FILE), "utf8").trim() || null;
   } catch {
     token = null;
   }
@@ -86393,7 +86733,7 @@ function adminDir(worktree) {
     const stat = worktreeDeps.stat(file);
     return {
       path: file,
-      id: path64.basename(file),
+      id: path65.basename(file),
       ino: stat.ino.toString(),
       token,
       birthMs: stat.birthtimeNs > 0n ? Number(stat.birthtimeMs) : null,
@@ -86409,7 +86749,7 @@ function markAdminDir(worktree) {
     return null;
   const token = randomBytes5(16).toString("hex");
   try {
-    fs32.writeFileSync(path64.join(admin.path, FANOUT_TOKEN_FILE), `${token}
+    fs32.writeFileSync(path65.join(admin.path, FANOUT_TOKEN_FILE), `${token}
 `);
   } catch {
     return null;
@@ -86424,7 +86764,7 @@ function excludeScratch(cwd) {
   const common = gitCommonDir(cwd);
   if (!common)
     return;
-  const file = path64.join(common, "info", "exclude");
+  const file = path65.join(common, "info", "exclude");
   let text = "";
   try {
     text = fs32.readFileSync(file, "utf8");
@@ -86433,7 +86773,7 @@ function excludeScratch(cwd) {
   }
   if (text.split(/\r?\n/u).includes(EXCLUDE_LINE))
     return;
-  fs32.mkdirSync(path64.dirname(file), { recursive: true });
+  fs32.mkdirSync(path65.dirname(file), { recursive: true });
   fs32.appendFileSync(file, `${text && !text.endsWith(`
 `) ? `
 ` : ""}# workit fanout: per-worker scratch dirs
@@ -86442,13 +86782,13 @@ ${EXCLUDE_LINE}
 }
 function worktreeDependencies(main, worktree) {
   for (const [name, install] of LOCKFILES2) {
-    const ours = readBytes(path64.join(main, name));
-    const theirs = readBytes(path64.join(worktree, name));
+    const ours = readBytes(path65.join(main, name));
+    const theirs = readBytes(path65.join(worktree, name));
     if (ours === null && theirs === null)
       continue;
     if (ours !== null && theirs !== null && ours.equals(theirs))
       continue;
-    if (fs32.existsSync(path64.join(worktree, "node_modules")))
+    if (fs32.existsSync(path65.join(worktree, "node_modules")))
       break;
     const command = install(worktree);
     return {
@@ -86460,7 +86800,7 @@ function worktreeDependencies(main, worktree) {
     };
   }
   const stale = staleBunInstall(main);
-  if (stale && !fs32.existsSync(path64.join(worktree, "node_modules"))) {
+  if (stale && !fs32.existsSync(path65.join(worktree, "node_modules"))) {
     const command = `bun install --frozen-lockfile --cwd ${worktree}`;
     return {
       linked: null,
@@ -86473,9 +86813,9 @@ function worktreeDependencies(main, worktree) {
   return { ...linkWorktreeDependencies(main, worktree), install: null };
 }
 function staleBunInstall(main) {
-  if (!fs32.existsSync(path64.join(main, "node_modules")))
+  if (!fs32.existsSync(path65.join(main, "node_modules")))
     return null;
-  const text = readBytes(path64.join(main, "bun.lock"))?.toString("utf8");
+  const text = readBytes(path65.join(main, "bun.lock"))?.toString("utf8");
   if (!text)
     return null;
   let packages;
@@ -86502,7 +86842,7 @@ function staleBunInstall(main) {
     const version = spec.slice(at + 1);
     if (name !== key || version.includes(":"))
       continue;
-    const manifest = readBytes(path64.join(main, "node_modules", key, "package.json"));
+    const manifest = readBytes(path65.join(main, "node_modules", key, "package.json"));
     if (!manifest) {
       problems.push(`${key} missing`);
       continue;
@@ -86519,7 +86859,7 @@ function staleBunInstall(main) {
   return problems.length ? problems.join("; ") : null;
 }
 function ensureScratch(worktree) {
-  const scratch = path64.join(worktree, SCRATCH_DIR);
+  const scratch = path65.join(worktree, SCRATCH_DIR);
   fs32.mkdirSync(scratch, { recursive: true });
   return scratch;
 }
@@ -86793,7 +87133,7 @@ function unpushedCount(cwd, branch) {
   return count.ok ? Number(count.stdout.trim()) : null;
 }
 function removeScratch(worktree) {
-  const scratch = path64.join(worktree, SCRATCH_DIR);
+  const scratch = path65.join(worktree, SCRATCH_DIR);
   let stat;
   try {
     stat = fs32.lstatSync(scratch);
@@ -86809,16 +87149,16 @@ var SLOW, SCRATCH_DIR = ".workit-scratch", EXCLUDE_LINE, DIRTY_ROW_BYTES = 2000,
   try {
     return fs32.realpathSync.native(target);
   } catch {
-    return path64.resolve(target);
+    return path65.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 = path64.relative(canonical2(parent), canonical2(child));
-  return relative === "" || !relative.startsWith("..") && !path64.isAbsolute(relative);
-}, slicePath = (cwd, slice) => path64.isAbsolute(slice.worktree) ? slice.worktree : path64.resolve(mainCheckout(cwd), slice.worktree), CLOCK_SLACK_MS = 2000, worktreeDeps, LOCKFILES2, readBytes = (file) => {
+  const relative = path65.relative(canonical2(parent), canonical2(child));
+  return relative === "" || !relative.startsWith("..") && !path65.isAbsolute(relative);
+}, slicePath = (cwd, slice) => path65.isAbsolute(slice.worktree) ? slice.worktree : path65.resolve(mainCheckout(cwd), slice.worktree), CLOCK_SLACK_MS = 2000, worktreeDeps, LOCKFILES2, readBytes = (file) => {
   try {
     return fs32.readFileSync(file);
   } catch {
@@ -86850,7 +87190,7 @@ var init_fanout_worktree = __esm(() => {
 
 // packages/workit-core/src/forge/merge-cleanup.ts
 import fs33 from "node:fs";
-import path65 from "node:path";
+import path66 from "node:path";
 function cleanupMergedBranch(cwd, branch, mergedHead) {
   const out = { branchDeleted: false, worktreeRemoved: null, notes: [] };
   if (!branch || branch.startsWith("-"))
@@ -86910,13 +87250,13 @@ var SLOW2, isFanoutWorktree = (worktree) => {
   if (!dir.ok)
     return false;
   try {
-    return fs33.readFileSync(path65.join(dir.stdout.trim(), FANOUT_TOKEN_FILE), "utf8").trim() !== "";
+    return fs33.readFileSync(path66.join(dir.stdout.trim(), FANOUT_TOKEN_FILE), "utf8").trim() !== "";
   } catch {
     return false;
   }
 }, inside4 = (child, parent) => {
-  const relative = path65.relative(fs33.realpathSync.native(parent), fs33.realpathSync.native(child));
-  return relative === "" || !relative.startsWith("..") && !path65.isAbsolute(relative);
+  const relative = path66.relative(fs33.realpathSync.native(parent), fs33.realpathSync.native(child));
+  return relative === "" || !relative.startsWith("..") && !path66.isAbsolute(relative);
 };
 var init_merge_cleanup = __esm(() => {
   init_fanout();
@@ -87368,7 +87708,7 @@ __export(exports_pr, {
   run: () => run15
 });
 import { existsSync as existsSync27, readFileSync as readFileSync27 } from "node:fs";
-import path66 from "node:path";
+import path67 from "node:path";
 function titleRules(cwd) {
   let root;
   try {
@@ -87379,7 +87719,7 @@ function titleRules(cwd) {
   let text = null;
   let name = "";
   for (const candidate of COMMITLINT_FILES) {
-    const full = path66.join(root, candidate);
+    const full = path67.join(root, candidate);
     if (!existsSync27(full))
       continue;
     text = readFileSync27(full, "utf8");
@@ -87388,7 +87728,7 @@ function titleRules(cwd) {
   }
   if (text === null) {
     try {
-      const pkg = JSON.parse(readFileSync27(path66.join(root, "package.json"), "utf8"));
+      const pkg = JSON.parse(readFileSync27(path67.join(root, "package.json"), "utf8"));
       if (pkg.commitlint === undefined)
         return { rules: null, note: null };
       text = JSON.stringify(pkg.commitlint);
@@ -87485,7 +87825,7 @@ function refuseTitle(io, title, line) {
 function readBodyFile(io, file) {
   try {
     return {
-      body: file === "-" ? forgeDeps.readStdin() : readFileSync27(path66.resolve(io.cwd, file), "utf8")
+      body: file === "-" ? forgeDeps.readStdin() : readFileSync27(path67.resolve(io.cwd, file), "utf8")
     };
   } catch {
     return `cannot read --body-file ${file}`;
@@ -87681,7 +88021,7 @@ async function create4(argv, io) {
     return usage4(io, planned.error, CREATE_USAGE);
   const links = planned.data.links;
   const actor = actorFromEnv(io.env);
-  const result = await createPullRequest(io.cwd, connected.data, {
+  const result = await progressFor(io).run("Opening the pull request", () => createPullRequest(io.cwd, connected.data, {
     base,
     title,
     body: withIssueLines(body ?? "", links),
@@ -87689,12 +88029,12 @@ async function create4(argv, io) {
     actor,
     labels: flags.lists.label ?? [],
     reviewers: flags.lists.reviewer ?? []
-  }, forgeDeps.sleep);
+  }, forgeDeps.sleep), (r) => r.ok ? "done" : "failed");
   if (!result.ok)
     return forgeFail(io, result);
   const opened = result.data.created;
   const linked = opened ? recordIssueLinks(io.cwd, result.data, links, { actor, forge: forge.kind, repo: forge.repo }) : [];
-  const backlinks = opened && planned.data.backlink && links.length ? await postBacklinks(io.cwd, connected.data, result.data, links, { env: io.env }) : [];
+  const backlinks = opened && planned.data.backlink && links.length ? await progressFor(io).run("Posting issue backlinks", () => postBacklinks(io.cwd, connected.data, result.data, links, { env: io.env })) : [];
   const created = {
     ...result.data,
     issues: links.map((link) => ({
@@ -87803,7 +88143,7 @@ async function merge3(argv, io) {
   const connected = connect(io);
   if (!connected.ok)
     return forgeFail(io, connected);
-  const result = await mergePullRequest(io.cwd, connected.data, {
+  const result = await progressFor(io).run(`Merging PR #${pr}`, () => mergePullRequest(io.cwd, connected.data, {
     pr,
     method,
     deleteBranch: flags.booleans.has("delete-branch"),
@@ -87813,7 +88153,7 @@ async function merge3(argv, io) {
     ...baseRedOk && baseRedReason ? { baseRedOk: { reason: baseRedReason } } : {},
     ...subject !== undefined ? { subject } : {},
     ...body !== undefined ? { body } : {}
-  }, forgeDeps.sleep);
+  }, forgeDeps.sleep), (r) => r.ok ? "done" : "failed");
   if (!result.ok)
     return emit(io, fail2(result.code, result.error, {
       unblock: result.unblock,
@@ -88017,6 +88357,7 @@ var CONVENTIONAL_TYPES, COMMITLINT_FILES, DEFAULT_IGNORES, UNCHECKED = (what) =>
   return `verdict ${verdict.verdictId} accepted for that head${verdict.cover ? ` (stack verdict on ${verdict.cover.branch} @ ${verdict.cover.head.slice(0, 12)})` : verdict.carry ? ` (${carryLabel(verdict.carry)})` : ""}`;
 }, acceptedHow = (verdict) => verdict.cover ? `stack verdict ${verdict.cover.verdictId} on ${verdict.cover.branch} @ ${verdict.cover.head.slice(0, 12)}` : verdict.carry ? carryLabel(verdict.carry) : verdict.basis, METHODS2;
 var init_pr = __esm(() => {
+  init_progress();
   init_autonomy();
   init_issue_link();
   init_pr_edit();
@@ -88130,7 +88471,7 @@ async function wait2(argv, io) {
   let verdict = { state: "waiting", reason: "not_polled" };
   let baseContexts = null;
   let expectedMissing = [];
-  const waiting = createProgress({ stream: process.stderr, json: io.json }).start("Waiting for CI");
+  const waiting = progressFor(io).start("Waiting for CI");
   const abort = (...args) => {
     waiting.end("failed");
     return forgeFail(io, ...args);
@@ -88253,15 +88594,15 @@ async function rerun(argv, io) {
   const number = selectPr(io.cwd, resolved, { pr, branch: flags.values.branch ?? null });
   if (!number.ok)
     return forgeFail(io, number);
-  const status = resolved.forge.prStatus(number.data);
+  const status = progressFor(io).runSync(`Reading PR #${number.data} checks`, () => resolved.forge.prStatus(number.data), (r) => r.ok ? "done" : "failed");
   if (!status.ok)
     return forgeFail(io, status);
-  const done = executeRerun(io.cwd, resolved, status.data, {
+  const done = progressFor(io).runSync("Rerunning the checks", () => executeRerun(io.cwd, resolved, status.data, {
     failed: names.length === 0,
     names,
     reason,
     force: flags.booleans.has("force")
-  });
+  }), (r) => r.ok ? "done" : "failed");
   if (!done.ok)
     return forgeFail(io, done);
   const outcome = done.data;
@@ -88374,7 +88715,7 @@ __export(exports_git, {
   run: () => run17
 });
 import { readFileSync as readFileSync28 } from "node:fs";
-import path67 from "node:path";
+import path68 from "node:path";
 function kindHint(cwd, kind) {
   let kinds = [...BRANCH_KINDS];
   try {
@@ -88478,7 +88819,7 @@ function commitMessage(parsed, io) {
 
 `);
   try {
-    return file === "-" ? readFileSync28(0, "utf8") : readFileSync28(path67.resolve(io.cwd, file), "utf8");
+    return file === "-" ? readFileSync28(0, "utf8") : readFileSync28(path68.resolve(io.cwd, file), "utf8");
   } catch (error) {
     return {
       error: `cannot read -F ${file}: ${error instanceof Error ? error.message : String(error)}`
@@ -89375,17 +89716,17 @@ async function releasePr(io, plan, dryRun) {
   const switched = switchToRelease(io.cwd, plan);
   if (!switched.ok)
     return forgeFail(io, switched);
-  const pushed = await subVerb(() => Promise.resolve().then(() => (init_git2(), exports_git)), ["push", "--set-upstream"], io);
+  const pushed = await progressFor(io).run(`Pushing ${plan.branch}`, () => subVerb(() => Promise.resolve().then(() => (init_git2(), exports_git)), ["push", "--set-upstream"], io), (r) => r.ok ? "done" : "failed");
   if (!pushed.ok)
     return emit(io, pushed);
-  const pr = await subVerb(() => Promise.resolve().then(() => (init_pr(), exports_pr)), [
+  const pr = await progressFor(io).run("Opening the release PR", () => subVerb(() => Promise.resolve().then(() => (init_pr(), exports_pr)), [
     "create",
     "--base",
     plan.production,
     "--title",
     title,
     `--body=${plan.changelog ?? `Release ${plan.version}`}`
-  ], io);
+  ], io), (r) => r.ok ? "done" : "failed");
   if (!pr.ok)
     return emit(io, pr);
   recordReleaseStep(io.cwd, actorFromEnv(io.env), plan, {
@@ -89441,11 +89782,11 @@ async function finish2(argv, io) {
   if (!push.allowed)
     return blocked(io, push);
   const resume = `workit release finish ${plan.version}${plan.track ? ` --track ${plan.track}` : ""}`;
-  const merged = finishLocally(io.cwd, plan, actor);
+  const merged = progressFor(io).runSync(`Merging release ${plan.version} locally`, () => finishLocally(io.cwd, plan, actor), (r) => r.ok ? "done" : "failed");
   if (!merged.ok)
     return forgeFail(io, merged, { step: "merge", resume });
   const notes = [...plan.notes];
-  const pushed = await subVerb(() => Promise.resolve().then(() => (init_git2(), exports_git)), ["push", ...[...plan.pushBranches, plan.tag].flatMap((ref) => ["--release", ref])], io);
+  const pushed = await progressFor(io).run("Pushing the release branches and tag", () => subVerb(() => Promise.resolve().then(() => (init_git2(), exports_git)), ["push", ...[...plan.pushBranches, plan.tag].flatMap((ref) => ["--release", ref])], io), (r) => r.ok ? "done" : "failed");
   if (!pushed.ok)
     return emit(io, { ...pushed, data: { ...pushed.data, step: "push", resume } });
   if (plan.published && plan.remote) {
@@ -89577,6 +89918,7 @@ var START_USAGE = "workit release start <version> [--hotfix] [--track <t>] [--js
   { step: `verify ${plan.tag} on the remote`, done: false }
 ];
 var init_release2 = __esm(() => {
+  init_progress();
   init_autonomy();
   init_verify();
   init_ops();
@@ -89627,14 +89969,14 @@ async function run19(argv, io) {
   if (expect === "pushed") {
     if (pr)
       return usage4(io, "push is checked by --branch, not --pr", USAGE12);
-    result = verifyPushed(io.cwd, { branch, sha, actor });
+    result = progressFor(io).runSync("Checking the push", () => verifyPushed(io.cwd, { branch, sha, actor }), (r) => r.ok ? "done" : "failed");
   } else if (expect === "released") {
-    result = verifyReleased(io.cwd, { tag: flags.values.tag ?? null, pkg: flags.values.package ?? null, sha, actor }, forgeDeps.npm);
+    result = progressFor(io).runSync("Checking the release", () => verifyReleased(io.cwd, { tag: flags.values.tag ?? null, pkg: flags.values.package ?? null, sha, actor }, forgeDeps.npm), (r) => r.ok ? "done" : "failed");
   } else {
     const connected = connect(io, branch);
     if (!connected.ok)
       return forgeFail(io, connected);
-    result = expect === "pr" ? verifyPr(io.cwd, connected.data, { pr, branch, sha, actor }) : verifyMerged(io.cwd, connected.data, { pr, branch, actor });
+    result = expect === "pr" ? progressFor(io).runSync(`Checking the PR`, () => verifyPr(io.cwd, connected.data, { pr, branch, sha, actor }), (r) => r.ok ? "done" : "failed") : progressFor(io).runSync("Checking the merge", () => verifyMerged(io.cwd, connected.data, { pr, branch, actor }), (r) => r.ok ? "done" : "failed");
   }
   if (!result.ok)
     return forgeFail(io, result);
@@ -89661,6 +90003,7 @@ var USAGE12 = "workit verify-delivery [push|pr|merge|release] [--expect pushed|p
   ...report.observations.map((entry) => `  ${entry.ok ? "ok" : "x "} ${entry.kind}: expected ${entry.expected ?? "-"}, observed ${entry.observed ?? "(none)"}${entry.note ? ` — ${entry.note}` : ""}`)
 ];
 var init_verify_delivery = __esm(() => {
+  init_progress();
   init_verify();
   init_task_store();
   init_task_delivery();
@@ -89796,7 +90139,7 @@ async function sync(argv, io, restack = false) {
     };
   }
   const name = selected.data.name;
-  const result = await withStackLock(io.cwd, name, async () => {
+  const result = await progressFor(io).run(restack ? `Restacking ${name}` : `Syncing ${name}`, () => withStackLock(io.cwd, name, async () => {
     const fresh = readStack(io.cwd, name);
     if (!fresh.ok)
       return fresh;
@@ -89809,10 +90152,13 @@ async function sync(argv, io, restack = false) {
       ok: true,
       data: {
         ...synced.data,
-        pruned: pruneMergedBranches(io.cwd, ctx, stack, { dryRun, actor: actorFromEnv(io.env) })
+        pruned: pruneMergedBranches(io.cwd, ctx, stack, {
+          dryRun,
+          actor: actorFromEnv(io.env)
+        })
       }
     };
-  });
+  }), (r) => r.ok ? "done" : "failed");
   if (!result.ok)
     return stackFailed(io, result);
   if (restack)
@@ -89861,7 +90207,7 @@ async function land(argv, io) {
   if (!connected.ok)
     return forgeFail(io, connected);
   const name = selected.data.name;
-  const result = await withStackLock(io.cwd, name, async () => {
+  const result = await progressFor(io).run(`Landing ${name}`, () => withStackLock(io.cwd, name, async () => {
     const fresh = readStack(io.cwd, name);
     if (!fresh.ok)
       return fresh;
@@ -89879,7 +90225,7 @@ async function land(argv, io) {
       unverified,
       baseRedOk: baseRedOk && baseRedReason ? { reason: baseRedReason } : null
     });
-  });
+  }), (r) => r.ok ? "done" : "failed");
   if (!result.ok)
     return stackFailed(io, result);
   const kind = connected.data.forge.kind;
@@ -89926,6 +90272,7 @@ var PLAN_USAGE = "workit stack plan [--name <n>] [--trunk <b> | --track <t>] [<b
   ...data.pruned.kept.map((item) => `kept merged branch ${item.branch}: ${item.reason}`)
 ], METHODS3;
 var init_stack2 = __esm(() => {
+  init_progress();
   init_ledger();
   init_stack();
   init_output();
@@ -89936,7 +90283,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 path68 from "node:path";
+import path69 from "node:path";
 function workerSession(lead, slice, attempt) {
   const tail = attempt === null ? "" : `+try${attempt}`;
   const full = `${lead}-w-${slice}${tail}`;
@@ -90019,7 +90366,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(path68.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(path69.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)
   ];
@@ -90561,7 +90908,7 @@ __export(exports_fanout, {
   run: () => run21
 });
 import fs36 from "node:fs";
-import path69 from "node:path";
+import path70 from "node:path";
 function forgeFor(io, offline) {
   if (offline)
     return { forge: null, error: "--offline" };
@@ -90622,7 +90969,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 = path69.resolve(io.cwd, flags.positionals[0]);
+  const file = path70.resolve(io.cwd, flags.positionals[0]);
   let raw;
   try {
     raw = JSON.parse(fs36.readFileSync(file, "utf8"));
@@ -90688,11 +91035,11 @@ function check2(argv, io) {
   const selected = selectFanout(io.cwd, flags.values.name ?? null, currentBranch(io.cwd));
   if (!selected.ok)
     return failed(io, selected);
-  const result = checkFanout(io.cwd, selected.data, {
+  const result = progressFor(io).runSync("Checking the fan-out slices", () => checkFanout(io.cwd, selected.data, {
     only: flags.positionals,
     trunkRef: flags.values.base ?? null,
     forge: forgeFor(io, flags.booleans.has("offline")).forge
-  });
+  }), (r) => r.ok ? "done" : "failed");
   if (!result.ok)
     return failed(io, result);
   if (result.data.ready)
@@ -90721,11 +91068,11 @@ function status4(argv, io) {
   if (!selected.ok)
     return failed(io, selected);
   const forge = forgeFor(io, flags.booleans.has("offline"));
-  const result = fanoutStatus(io.cwd, selected.data, {
+  const result = progressFor(io).runSync("Reading the fan-out status", () => fanoutStatus(io.cwd, selected.data, {
     forge: forge.forge,
     forgeError: forge.error,
     stuckAfterMs
-  });
+  }), (r) => r.ok ? "done" : "failed");
   if (!result.ok)
     return failed(io, result);
   return emit(io, ok2(result.data), renderStatus2);
@@ -90831,6 +91178,7 @@ var PLAN_USAGE2 = "workit fanout plan <plan.json> [--name <n>] [--trunk <b> | --
   ];
 };
 var init_fanout2 = __esm(() => {
+  init_progress();
   init_fanout_brief();
   init_fanout_check();
   init_fanout_status();
@@ -106197,7 +106545,7 @@ var init_ast = __esm(() => {
 
 // packages/workit-cli/src/test-audit/rules.ts
 import { builtinModules } from "node:module";
-import path70 from "node:path";
+import path71 from "node:path";
 function testCallee(call) {
   let callee = call.callee;
   if (callee.type === "CallExpression")
@@ -106690,12 +107038,12 @@ function checkConstantsOnly(ctx, emit) {
 }
 function checkOverMocking(ctx, emit) {
   const { program } = ctx.parsed;
-  const unit = path70.basename(ctx.file).replace(/\.(?:[cm]?[jt]sx?)$/, "").replace(/\.(?:test|spec)$/, "");
+  const unit = path71.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 = path70.basename(spec.replace(/\/index(?:\.[cm]?[jt]sx?)?$/, "")).replace(/\.(?:[cm]?[jt]sx?)$/, "");
+    const base = path71.basename(spec.replace(/\/index(?:\.[cm]?[jt]sx?)?$/, "")).replace(/\.(?:[cm]?[jt]sx?)$/, "");
     if (base === unit)
       emit({
         rule: "over-mocking",
@@ -107085,7 +107433,7 @@ var init_rules = __esm(() => {
 // packages/workit-cli/src/test-audit/audit.ts
 import { spawnSync as spawnSync29 } from "node:child_process";
 import { existsSync as existsSync28, readdirSync as readdirSync14, readFileSync as readFileSync29, statSync as statSync10 } from "node:fs";
-import path71 from "node:path";
+import path72 from "node:path";
 function git7(cwd, args) {
   const run = spawnSync29("git", ["-c", "core.quotepath=off", ...args], {
     cwd,
@@ -107098,7 +107446,7 @@ function walkTests(dir, out) {
   for (const entry of readdirSync14(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".") && entry.name !== "." && entry.isDirectory())
       continue;
-    const full = path71.join(dir, entry.name);
+    const full = path72.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (!SKIP_DIRS.has(entry.name))
         walkTests(full, out);
@@ -107110,7 +107458,7 @@ function expandPaths(cwd, inputs) {
   const files = [];
   const missing = [];
   for (const input of inputs.length > 0 ? inputs : ["."]) {
-    const full = path71.resolve(cwd, input);
+    const full = path72.resolve(cwd, input);
     if (!existsSync28(full))
       missing.push(input);
     else if (statSync10(full).isDirectory())
@@ -107147,11 +107495,11 @@ function changedLines(cwd, base) {
       for (let offset = 0;offset < count; offset += 1)
         lines.add(start + offset);
     }
-    changed.set(path71.join(root, file), lines);
+    changed.set(path72.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(path71.join(root, file), "all");
+    changed.set(path72.join(root, file), "all");
   return changed;
 }
 function auditFiles(files, display) {
@@ -107213,7 +107561,7 @@ function auditFiles(files, display) {
     durationMs: Math.round(performance.now() - started)
   };
 }
-var TEST_FILE, CODE_FILE, SKIP_DIRS, toPosix = (file) => file.split(path71.sep).join("/"), SEVERITY_ORDER, ruleIds;
+var TEST_FILE, CODE_FILE, SKIP_DIRS, toPosix = (file) => file.split(path72.sep).join("/"), SEVERITY_ORDER, ruleIds;
 var init_audit = __esm(() => {
   init_ast();
   init_rules();
@@ -107225,7 +107573,7 @@ var init_audit = __esm(() => {
 });
 
 // packages/workit-cli/src/test-audit/mutate.ts
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 import {
   existsSync as existsSync29,
   lstatSync as lstatSync9,
@@ -107243,7 +107591,7 @@ import {
   copyFileSync as copyFileSync8
 } from "node:fs";
 import os23 from "node:os";
-import path72 from "node:path";
+import path73 from "node:path";
 function mutantsFor(source, file, lines) {
   const parsed = parseSource(source, file);
   const out = [];
@@ -107316,7 +107664,7 @@ function relatedTests(source, testFiles) {
     for (const match of text.matchAll(SPECIFIER)) {
       const spec = match[1];
       if (spec.startsWith(".")) {
-        if (stripExt(path72.posix.join(path72.posix.dirname(file), spec)) === target)
+        if (stripExt(path73.posix.join(path73.posix.dirname(file), spec)) === target)
           return true;
       } else if (spec.includes("/") && stripExt(spec).split("/").slice(-2).join("/") === tail)
         return true;
@@ -107336,12 +107684,12 @@ function removeStaleCopies(tmp = os23.tmpdir()) {
   for (const name of names) {
     if (!name.startsWith(TEMP_PREFIX))
       continue;
-    const dir = path72.join(tmp, name);
+    const dir = path73.join(tmp, name);
     try {
       const stat = lstatSync9(dir);
       if (!stat.isDirectory() || uid !== undefined && stat.uid !== uid)
         continue;
-      const pid = Number(readFileSync30(path72.join(dir, PID_FILE), "utf8"));
+      const pid = Number(readFileSync30(path73.join(dir, PID_FILE), "utf8"));
       if (Number.isInteger(pid) && pid > 0 && alive(pid))
         continue;
     } catch (error) {
@@ -107358,8 +107706,8 @@ function removeStaleCopies(tmp = os23.tmpdir()) {
 function linkNodeModules(origin, target, repo, copy) {
   mkdirSync12(target, { recursive: true });
   for (const entry of readdirSync15(origin, { withFileTypes: true })) {
-    const from = path72.join(origin, entry.name);
-    const to = path72.join(target, entry.name);
+    const from = path73.join(origin, entry.name);
+    const to = path73.join(target, entry.name);
     if (entry.name.startsWith("@") && entry.isDirectory()) {
       linkNodeModules(from, to, repo, copy);
       continue;
@@ -107375,9 +107723,9 @@ function linkNodeModules(origin, target, repo, copy) {
       } catch {
         continue;
       }
-      const relative = path72.relative(repo, real);
-      if (!relative.startsWith("..") && !path72.isAbsolute(relative) && !relative.split(path72.sep).includes("node_modules")) {
-        symlinkSync(path72.join(copy, relative), to, "junction");
+      const relative = path73.relative(repo, real);
+      if (!relative.startsWith("..") && !path73.isAbsolute(relative) && !relative.split(path73.sep).includes("node_modules")) {
+        symlinkSync(path73.join(copy, relative), to, "junction");
         continue;
       }
     }
@@ -107393,7 +107741,7 @@ function copySymlink(repo, tree, from, to) {
   }
   const realRepo = realpathSync11(repo);
   if (real && inside5(realRepo, real)) {
-    symlinkSync(path72.relative(path72.dirname(to), path72.join(tree, path72.relative(realRepo, real))), to);
+    symlinkSync(path73.relative(path73.dirname(to), path73.join(tree, path73.relative(realRepo, real))), to);
     return;
   }
   if (real && statSync11(real).isFile())
@@ -107402,10 +107750,10 @@ function copySymlink(repo, tree, from, to) {
     symlinkSync(readlinkSync3(from), to);
 }
 function writeInside(copy, file, content) {
-  const target = path72.join(copy, file);
+  const target = path73.join(copy, file);
   try {
     const stat = lstatSync9(target);
-    if (!stat.isFile() || !inside5(realpathSync11(copy), realpathSync11(path72.dirname(target))))
+    if (!stat.isFile() || !inside5(realpathSync11(copy), realpathSync11(path73.dirname(target))))
       return false;
   } catch {
     return false;
@@ -107416,9 +107764,9 @@ function writeInside(copy, file, content) {
   return true;
 }
 function copyWorkingTree(repo) {
-  const dir = mkdtempSync4(path72.join(os23.tmpdir(), TEMP_PREFIX));
-  writeFileSync13(path72.join(dir, PID_FILE), String(process.pid));
-  const tree = path72.join(dir, "tree");
+  const dir = mkdtempSync4(path73.join(os23.tmpdir(), TEMP_PREFIX));
+  writeFileSync13(path73.join(dir, PID_FILE), String(process.pid));
+  const tree = path73.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();
@@ -107435,36 +107783,36 @@ function copyWorkingTree(repo) {
   for (const relative of listed) {
     if (!relative)
       continue;
-    const from = path72.join(repo, relative);
+    const from = path73.join(repo, relative);
     let stat;
     try {
       stat = lstatSync9(from);
     } catch {
       continue;
     }
-    const to = path72.join(tree, relative);
-    mkdirSync12(path72.dirname(to), { recursive: true });
+    const to = path73.join(tree, relative);
+    mkdirSync12(path73.dirname(to), { recursive: true });
     if (stat.isSymbolicLink())
       copySymlink(repo, tree, from, to);
     else if (stat.isFile())
       copyFileSync8(from, to);
-    let parent = path72.dirname(relative);
+    let parent = path73.dirname(relative);
     while (parent !== "." && !dirs.has(parent)) {
       dirs.add(parent);
-      parent = path72.dirname(parent);
+      parent = path73.dirname(parent);
     }
   }
   for (const parent of dirs) {
-    const modules = path72.join(repo, parent, "node_modules");
-    if (existsSync29(modules) && !existsSync29(path72.join(tree, parent, "node_modules")))
-      linkNodeModules(modules, path72.join(tree, parent, "node_modules"), repo, tree);
+    const modules = path73.join(repo, parent, "node_modules");
+    if (existsSync29(modules) && !existsSync29(path73.join(tree, parent, "node_modules")))
+      linkNodeModules(modules, path73.join(tree, parent, "node_modules"), repo, tree);
   }
   return { dir, tree };
 }
 function runCommand(command, cwd, timeoutMs, env) {
   const started = performance.now();
   return new Promise((resolve) => {
-    const child = spawn3(command, {
+    const child = spawn4(command, {
       cwd,
       env,
       shell: true,
@@ -107496,14 +107844,14 @@ 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: readFileSync30(path72.join(repo, file), "utf8") };
+      return { file, text: readFileSync30(path73.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(path72.relative(repo, absolute));
+    const relative = toPosix(path73.relative(repo, absolute));
     if (!CODE_FILE.test(relative) || TEST_FILE.test(relative) || relative.endsWith(".d.ts"))
       continue;
     if (NOT_SOURCE.test(relative) || !existsSync29(absolute))
@@ -107517,9 +107865,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 = path72.relative(repo, options.cwd);
+  const cwdRelative = path73.relative(repo, options.cwd);
   const asArg = (file) => {
-    const relative = toPosix(path72.relative(cwdRelative, file));
+    const relative = toPosix(path73.relative(cwdRelative, file));
     return shellQuote(relative.startsWith(".") ? relative : `./${relative}`);
   };
   const commandFor = (tests) => options.command.replaceAll("{files}", () => tests.map(asArg).join(" "));
@@ -107555,7 +107903,7 @@ async function runMutation(options) {
     return finish3(options, 0, results, counts, started);
   removeStaleCopies();
   const { dir: copyDir, tree: copy } = copyWorkingTree(repo);
-  const copyCwd = path72.join(copy, cwdRelative);
+  const copyCwd = path73.join(copy, cwdRelative);
   let current = null;
   const restore = () => {
     if (current)
@@ -107590,7 +107938,7 @@ async function runMutation(options) {
         record({ ...mutant, status: "skipped", durationMs: 0, tests, reason: "budget" });
         continue;
       }
-      const original = readFileSync30(path72.join(copy, mutant.file), "utf8");
+      const original = readFileSync30(path73.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)) {
@@ -107647,8 +107995,8 @@ var NOT_SOURCE, FLIPS, isStringy = (node) => node.type === "StringLiteral" || no
     return error.code === "EPERM";
   }
 }, inside5 = (root, file) => {
-  const relative = path72.relative(root, file);
-  return relative === "" || !relative.startsWith("..") && !path72.isAbsolute(relative);
+  const relative = path73.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path73.isAbsolute(relative);
 }, active, killTree = (child) => {
   try {
     if (child.pid && process.platform !== "win32")
@@ -107697,7 +108045,7 @@ __export(exports_test_audit, {
   run: () => run23
 });
 import { existsSync as existsSync30 } from "node:fs";
-import path73 from "node:path";
+import path74 from "node:path";
 function parse8(argv) {
   const options = {
     paths: [],
@@ -107802,8 +108150,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 ? path73.resolve(top.stdout.trim()) : null;
-  const display = (file) => toPosix(path73.relative(io.cwd, file) || file);
+  const repo = top.ok ? path74.resolve(top.stdout.trim()) : null;
+  const display = (file) => toPosix(path74.relative(io.cwd, file) || file);
   let base = null;
   let changed = null;
   if (options.diff || options.mutate) {
@@ -107942,7 +108290,7 @@ __export(exports_youtrack, {
   run: () => run25
 });
 import { readFileSync as readFileSync31 } from "node:fs";
-import path74 from "node:path";
+import path75 from "node:path";
 async function run25(argv, io) {
   const [sub, ...rest] = argv;
   if (sub !== "note" && sub !== "time" && sub !== "meeting")
@@ -107988,7 +108336,7 @@ async function run25(argv, io) {
     let markdown = flags.values.markdown ?? "";
     if (flags.values.file)
       try {
-        markdown = readFileSync31(path74.resolve(io.cwd, flags.values.file), "utf8");
+        markdown = readFileSync31(path75.resolve(io.cwd, flags.values.file), "utf8");
       } catch (error) {
         return usage4(io, `cannot read ${flags.values.file}: ${String(error)}`, USAGE18);
       }
@@ -108009,7 +108357,7 @@ async function run25(argv, io) {
   }
   const results = [];
   for (const entry of steps) {
-    const outcome = await entry.run();
+    const outcome = await progressFor(io).run(entry.label, () => entry.run());
     results.push({
       step: entry.label,
       status: outcome.status,
@@ -108044,6 +108392,7 @@ var USAGE18 = "workit youtrack note <ISSUE> (--markdown <t> | --file <p>) [--min
   }
 };
 var init_youtrack2 = __esm(() => {
+  init_progress();
   init_youtrack();
   init_youtrack_tools();
   init_youtrack_writes();
@@ -108057,7 +108406,7 @@ __export(exports_changelog, {
   run: () => run26
 });
 import { readFileSync as readFileSync32 } from "node:fs";
-import path75 from "node:path";
+import path76 from "node:path";
 async function run26(argv, io) {
   const [sub, ...rest] = argv;
   if (sub !== "apply")
@@ -108103,7 +108452,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 === "-" ? readFileSync32(0, "utf8") : raw.startsWith("@") ? readFileSync32(path75.resolve(cwd, raw.slice(1)), "utf8") : raw;
+  const text = raw === "-" ? readFileSync32(0, "utf8") : raw.startsWith("@") ? readFileSync32(path76.resolve(cwd, raw.slice(1)), "utf8") : raw;
   return JSON.parse(text);
 };
 var init_changelog2 = __esm(() => {
@@ -108119,7 +108468,7 @@ __export(exports_handoff, {
   run: () => run27
 });
 import fs37 from "node:fs";
-import path76 from "node:path";
+import path77 from "node:path";
 import { parseArgs as parseArgs2 } from "node:util";
 function render3(brief) {
   const lines = [
@@ -108159,9 +108508,9 @@ function bounded(brief, cwd) {
   let file = null;
   if (store.ok)
     try {
-      const dir = path76.join(store.value.root, "handoff");
+      const dir = path77.join(store.value.root, "handoff");
       fs37.mkdirSync(dir, { recursive: true });
-      file = path76.join(dir, `${(brief.branch ?? "detached").replaceAll(/[^\w.-]+/gu, "-")}.txt`);
+      file = path77.join(dir, `${(brief.branch ?? "detached").replaceAll(/[^\w.-]+/gu, "-")}.txt`);
       fs37.writeFileSync(file, `${[...body, ...tail].join(`
 `)}
 `, {
@@ -108236,7 +108585,7 @@ var init_handoff = __esm(() => {
 });
 
 // packages/workit-cli/src/main.ts
-import path77 from "node:path";
+import path78 from "node:path";
 
 // packages/workit-core/src/git/env-redirect.ts
 var GIT_REDIRECT_ENV = [
@@ -109185,8 +109534,17 @@ var defaultIo = (json) => ({
 });
 async function main(argv, overrides = {}, options = {}) {
   const parsed = parseGlobals(argv);
-  const cwd = path77.resolve(overrides.cwd ?? process.cwd(), parsed.cwd ?? ".");
-  const io = { ...defaultIo(parsed.json), ...overrides, json: parsed.json, cwd };
+  const cwd = path78.resolve(overrides.cwd ?? process.cwd(), parsed.cwd ?? ".");
+  const io = {
+    ...defaultIo(parsed.json),
+    terminals: {
+      ...overrides.stdout ? {} : { stdout: process.stdout },
+      ...overrides.stderr ? {} : { stderr: process.stderr }
+    },
+    ...overrides,
+    json: parsed.json,
+    cwd
+  };
   if (parsed.error)
     return emit(io, fail2("invalid_input", parsed.error));
   if (parsed.session !== undefined) {