@brainervirus/workit-cli 8.40.7 → 8.41.0

package/dist/index.js

@@ -6537,6 +6537,15 @@ var nonBlank, branchPreset, commitPreset, workspaceBranchPolicySchema, workspace
     return cached;
   let dir = path2.resolve(cwd);
   while (!existsSync2(path2.join(dir, ".git"))) {
+    if (["HEAD", "objects", "refs"].every((name) => existsSync2(path2.join(dir, name)))) {
+      const real = realpathOf(dir);
+      const owner = ownInternals(real) === true ? gitDirOwner(real) : null;
+      if (owner === null)
+        return Error(`${cwd} is in a repository with no work tree at ${real}: no grants apply`);
+      const probe = { main: owner, superproject: null };
+      probes.set(cwd, probe);
+      return probe;
+    }
     const up = path2.dirname(dir);
     if (up === dir)
       return null;
@@ -6575,6 +6584,14 @@ var nonBlank, branchPreset, commitPreset, workspaceBranchPolicySchema, workspace
       if (owner !== realpathOf(dir))
         main = owner;
     }
+    const lender = ownInternals(real);
+    if (lender === false)
+      return Error(`${cwd} borrows git internals from outside ${real} that no checkout owns`);
+    if (lender !== true && lender !== realpathOf(dir)) {
+      if (main !== null && main !== lender)
+        return Error(`${cwd} mixes the repositories of ${main} and ${lender}`);
+      main = lender;
+    }
   } else {
     const list = git(["worktree", "list", "--porcelain"]);
     if (list === null)
@@ -6590,6 +6607,30 @@ var nonBlank, branchPreset, commitPreset, workspaceBranchPolicySchema, workspace
   } catch {
     return false;
   }
+}, INTERNALS, ownInternals = (real) => {
+  let lender = null;
+  for (const name of INTERNALS) {
+    const at = path2.join(real, name);
+    try {
+      lstatSync(at);
+    } catch {
+      continue;
+    }
+    let resolved;
+    try {
+      resolved = (realpathSync.native ?? realpathSync)(at);
+    } catch {
+      return false;
+    }
+    const rel = path2.relative(real, resolved);
+    if (rel && !rel.startsWith("..") && !path2.isAbsolute(rel))
+      continue;
+    const owner = path2.basename(resolved) === name ? gitDirOwner(path2.dirname(resolved)) : null;
+    if (owner === null || lender !== null && lender !== owner)
+      return false;
+    lender = owner;
+  }
+  return lender ?? true;
 }, gitDirOwner = (real) => {
   const parts = real.split(/[\\/]/u);
   const at = parts.lastIndexOf(".git");
@@ -7058,6 +7099,7 @@ var init_workspaces = __esm(() => {
     name = "WorkspaceConfigError";
   };
   probes = new Map;
+  INTERNALS = ["refs", "objects", "config", "packed-refs", "commondir"];
   runtimeWorkspaceIndexSchema = object({
     workspaces: array(object({ name: nonBlank, glob: nonBlank }).passthrough()).optional()
   }).passthrough();
@@ -9375,7 +9417,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@brainervirus/workit-cli",
-    version: "8.40.7",
+    version: "8.41.0",
     private: false,
     description: "Workit CLI — setup wizard, doctor, and task control for agentic coding workflows",
     keywords: [
@@ -9413,13 +9455,13 @@ var init_package = __esm(() => {
     },
     dependencies: {
       "@babel/parser": "7.29.9",
-      "@brainervirus/workit-cursor": "^8.40.7",
+      "@brainervirus/workit-cursor": "^8.41.0",
       "@inkjs/ui": "2.0.0",
       ink: "7.1.1",
       react: "19.2.8"
     },
     devDependencies: {
-      "@brainervirus/workit-core": "^8.40.7"
+      "@brainervirus/workit-core": "^8.41.0"
     },
     engines: {
       node: ">=24"
@@ -75176,7 +75218,124 @@ var init_setup2 = __esm(() => {
   ALL_HOSTS = ["claude-code", "codex", "cursor", "opencode", "pi"];
 });
 
+// packages/workit-cli/src/progress.ts
+function createProgress(options = {}) {
+  const env = options.env ?? process.env;
+  const mode = modeFor(options, env);
+  const stream = options.stream;
+  const now = options.now ?? Date.now;
+  const every = options.setInterval ?? ((tick, ms) => setInterval(tick, ms));
+  const stop = options.clearInterval ?? ((timer) => clearInterval(timer));
+  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) => {
+    if (mode === "off" || !stream)
+      return NOOP_STEP;
+    let text = initial;
+    let finished = false;
+    const began = now();
+    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 timer;
+    if (mode === "spinner") {
+      draw();
+      timer = every(() => {
+        frame += 1;
+        draw();
+      }, FRAME_MS);
+    }
+    const handlers = [];
+    const release = () => {
+      for (const [event, handler] of handlers)
+        proc.off(event, handler);
+      handlers.length = 0;
+    };
+    if (mode === "spinner") {
+      const onSignal = (signal) => () => {
+        if (!finished) {
+          finished = true;
+          if (timer !== undefined)
+            stop(timer);
+          stream.write(CLEAR);
+        }
+        release();
+        proc.kill(proc.pid, signal);
+      };
+      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);
+    }
+    return {
+      label: (next) => {
+        text = next;
+        if (mode === "spinner" && !finished)
+          draw();
+      },
+      end: (status, note) => {
+        if (finished)
+          return;
+        finished = true;
+        if (timer !== undefined)
+          stop(timer);
+        release();
+        stream.write(`${mode === "spinner" ? CLEAR : ""}${glyphs[status]} ${text}${note ? `: ${note}` : ""}
+`);
+      }
+    };
+  };
+  return {
+    mode,
+    start,
+    async run(label, fn, classify) {
+      const step = start(label);
+      try {
+        const value = await fn();
+        step.end(classify ? classify(value) : "done");
+        return value;
+      } catch (error) {
+        step.end("failed");
+        throw error;
+      }
+    },
+    runSync(label, fn, classify) {
+      const step = start(label);
+      try {
+        const value = fn();
+        step.end(classify ? classify(value) : "done");
+        return value;
+      } catch (error) {
+        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 init_progress = __esm(() => {
+  FRAMES = ["·", "✢", "✳", "∗", "✻", "✽"];
+  NOOP_STEP = { label: () => {}, end: () => {} };
+});
+
 // packages/workit-cli/src/upgrade/shared.ts
+import { spawn } from "node:child_process";
 import { existsSync as existsSync21, readFileSync as readFileSync22 } from "node:fs";
 import path44 from "node:path";
 import os16 from "node:os";
@@ -75237,7 +75396,61 @@ var LAUNCH_HOSTS, HOSTS2, LIVE_HOSTS, OPENCODE_PACKAGE = "@brainervirus/workit-o
   }
   const result = runHostCommand(step, { home, env });
   return { status: result.exitCode, stdout: result.stdout };
-}), errorText = (error) => error instanceof Error ? error.message : "installed source could not be read", piInstalledVersion = (listing, selector) => {
+}), COMMAND_TIMEOUT_MS = 60000, asyncRunner = (deps) => {
+  if (deps.runAsync)
+    return deps.runAsync;
+  const injected = deps.run;
+  if (injected)
+    return async (command, args) => injected(command, args);
+  return (command, args) => {
+    const { home, env } = upgradePaths(deps);
+    let step;
+    try {
+      step = hostCommand(command, args, { home, env });
+    } catch {
+      return Promise.resolve({ status: 1, stdout: "" });
+    }
+    if (process.platform === "win32" && /\.(?:cmd|bat)$/i.test(step.command))
+      return Promise.resolve({ status: 1, stdout: "" });
+    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");
+    return new Promise((resolve) => {
+      let stdout = "";
+      let settled = false;
+      const finish = (status) => {
+        if (settled)
+          return;
+        settled = true;
+        clearTimeout(timer);
+        resolve({ status, stdout });
+      };
+      let child;
+      try {
+        child = spawn(step.command, step.args, {
+          cwd: step.cwd,
+          env: childEnv,
+          stdio: ["ignore", "pipe", "ignore"],
+          windowsHide: true,
+          shell: false
+        });
+      } catch {
+        resolve({ status: 1, stdout: "" });
+        return;
+      }
+      const timer = setTimeout(() => {
+        child.kill("SIGKILL");
+        finish(1);
+      }, COMMAND_TIMEOUT_MS);
+      child.stdout?.setEncoding("utf8");
+      child.stdout?.on("data", (chunk) => stdout += chunk);
+      child.on("error", () => 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) => {
   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]))
@@ -75326,7 +75539,7 @@ var init_processes = __esm(() => {
 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 { createHash as createHash16 } from "node:crypto";
-function applyUpgrade(plan, deps = {}) {
+async function applyUpgrade(plan, deps = {}) {
   const hosts = [...plan.failed];
   const done = (backup) => {
     const failures = hosts.filter((entry) => entry.status === "failed");
@@ -75381,6 +75594,9 @@ function applyUpgrade(plan, deps = {}) {
 `, 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 {
@@ -75393,96 +75609,104 @@ function applyUpgrade(plan, deps = {}) {
   const listed = plan.entries.length ? listProcesses(deps) : [];
   const running = (listed ?? []).flatMap((entry) => classifyProcess(entry) ?? []);
   for (const entry of plan.entries) {
-    if (entry.host === "cursor" && cursorBackupError) {
-      hosts.push({
-        host: "cursor",
-        status: "failed",
-        reason: cursorBackupError,
-        fix: entry.fix
-      });
-      continue;
-    }
-    if (!LIVE_HOSTS.has(entry.host)) {
-      if (listed === null) {
+    const before = hosts.length;
+    const step = progress.start(`Updating ${entry.host}`);
+    try {
+      if (entry.host === "cursor" && cursorBackupError) {
         hosts.push({
-          host: entry.host,
-          status: "skipped",
-          reason: `running processes could not be listed; close ${entry.host} and rerun`,
-          fix: `workit upgrade --hosts=${entry.host}`
+          host: "cursor",
+          status: "failed",
+          reason: cursorBackupError,
+          fix: entry.fix
         });
         continue;
       }
-      const sessions = running.filter((proc) => proc.host === entry.host && proc.kind === "session");
-      if (sessions.length) {
+      if (!LIVE_HOSTS.has(entry.host)) {
+        if (listed === null) {
+          hosts.push({
+            host: entry.host,
+            status: "skipped",
+            reason: `running processes could not be listed; close ${entry.host} and rerun`,
+            fix: `workit upgrade --hosts=${entry.host}`
+          });
+          continue;
+        }
+        const sessions = running.filter((proc) => proc.host === entry.host && proc.kind === "session");
+        if (sessions.length) {
+          hosts.push({
+            host: entry.host,
+            status: "skipped",
+            reason: `close ${entry.host} (${sessions.map(describe2).join("; ")}), then rerun`,
+            fix: `workit upgrade --hosts=${entry.host}`
+          });
+          continue;
+        }
+      }
+      const daemons = running.filter((proc) => proc.host === "codex" && proc.kind === "daemon");
+      const stopDaemon = entry.host === "codex" && daemons.length > 0;
+      const stopped = stopDaemon ? await progress.run("Stopping the Codex app-server daemon", () => runAsync("codex", ["app-server", "daemon", "stop"]), (result) => result.status === 0 ? "done" : "failed") : null;
+      if (stopped && stopped.status !== 0) {
         hosts.push({
-          host: entry.host,
-          status: "skipped",
-          reason: `close ${entry.host} (${sessions.map(describe2).join("; ")}), then rerun`,
-          fix: `workit upgrade --hosts=${entry.host}`
+          host: "codex",
+          status: "failed",
+          reason: `could not stop the Codex app-server daemon (${daemons.map(describe2).join("; ")})`,
+          fix: "codex app-server daemon stop && workit upgrade --hosts=codex"
         });
         continue;
       }
-    }
-    const daemons = running.filter((proc) => proc.host === "codex" && proc.kind === "daemon");
-    const stopDaemon = entry.host === "codex" && daemons.length > 0;
-    if (stopDaemon && run("codex", ["app-server", "daemon", "stop"]).status !== 0) {
-      hosts.push({
-        host: "codex",
-        status: "failed",
-        reason: `could not stop the Codex app-server daemon (${daemons.map(describe2).join("; ")})`,
-        fix: "codex app-server daemon stop && workit upgrade --hosts=codex"
-      });
-      continue;
-    }
-    let outcome;
-    try {
-      outcome = applyEntry(entry, { run, paths, configDir });
-      if (entry.host === "codex" && outcome.status === "updated") {
-        const agents = refreshCodexAgents(run, paths.codexHome);
-        if (!agents.ok)
+      let outcome;
+      try {
+        outcome = await applyEntry(entry, { run, runAsync, paths, configDir });
+        if (entry.host === "codex" && outcome.status === "updated") {
+          const agents = await refreshCodexAgents(runAsync, paths.codexHome);
+          if (!agents.ok)
+            outcome = {
+              ...outcome,
+              status: "failed",
+              reason: `${outcome.reason}; ${agents.note}`,
+              fix: agents.fix
+            };
+          else if (agents.note)
+            outcome = { ...outcome, reason: `${outcome.reason}; ${agents.note}` };
+        }
+      } catch (error) {
+        outcome = {
+          host: entry.host,
+          status: "failed",
+          reason: errorText(error),
+          fix: entry.fix
+        };
+      }
+      if (stopDaemon) {
+        const started = (await progress.run("Restarting the Codex app-server daemon", () => runAsync("codex", ["app-server", "daemon", "start"]), (result) => result.status === 0 ? "done" : "failed")).status === 0;
+        outcome = started ? {
+          ...outcome,
+          reason: `${outcome.reason}; app-server daemon stopped and started again`
+        } : {
+          ...outcome,
+          status: "failed",
+          reason: `${outcome.reason}; the app-server daemon did not start again`,
+          fix: "codex app-server daemon start"
+        };
+      }
+      if (entry.host === "opencode") {
+        const servers = running.filter((proc) => proc.host === "opencode" && proc.kind === "daemon");
+        if (servers.length && outcome.status === "updated")
           outcome = {
             ...outcome,
-            status: "failed",
-            reason: `${outcome.reason}; ${agents.note}`,
-            fix: agents.fix
+            reason: `${outcome.reason}; restart opencode serve (${servers.map(describe2).join("; ")}) to load it`
           };
-        else if (agents.note)
-          outcome = { ...outcome, reason: `${outcome.reason}; ${agents.note}` };
       }
-    } catch (error) {
-      outcome = {
-        host: entry.host,
-        status: "failed",
-        reason: errorText(error),
-        fix: entry.fix
-      };
-    }
-    if (stopDaemon) {
-      const started = run("codex", ["app-server", "daemon", "start"]).status === 0;
-      outcome = started ? {
-        ...outcome,
-        reason: `${outcome.reason}; app-server daemon stopped and started again`
-      } : {
-        ...outcome,
-        status: "failed",
-        reason: `${outcome.reason}; the app-server daemon did not start again`,
-        fix: "codex app-server daemon start"
-      };
-    }
-    if (entry.host === "opencode") {
-      const servers = running.filter((proc) => proc.host === "opencode" && proc.kind === "daemon");
-      if (servers.length && outcome.status === "updated")
-        outcome = {
-          ...outcome,
-          reason: `${outcome.reason}; restart opencode serve (${servers.map(describe2).join("; ")}) to load it`
-        };
+      hosts.push(outcome);
+    } finally {
+      const added = hosts.length > before ? hosts[hosts.length - 1] : undefined;
+      step.end(statusOf(added), added && added.status !== "updated" ? added.reason : undefined);
     }
-    hosts.push(outcome);
   }
   if (hosts.some((entry) => entry.host === "codex" && entry.status === "current")) {
     let agents;
     try {
-      agents = refreshCodexAgents(run, paths.codexHome);
+      agents = await refreshCodexAgents(runAsync, paths.codexHome);
     } catch (error) {
       agents = {
         ok: false,
@@ -75506,7 +75730,7 @@ function applyUpgrade(plan, deps = {}) {
   }
   if (plan.cli)
     try {
-      hosts.push(applyCli(plan.cli, run, backup));
+      hosts.push(await progress.run("Updating the CLI", () => applyCli(plan.cli, runAsync, backup), statusOf));
     } catch (error) {
       hosts.push({
         host: "cli",
@@ -75527,8 +75751,8 @@ var codexPluginRoot = (codexHome) => {
   }
   const newest = versions.reduce((best, version) => best && versionAtLeast(best, version) ? best : version, null);
   return newest ? path46.join(dir, newest) : null;
-}, opencodeVersion = (run) => {
-  const listing = run("opencode", ["plugin", "list"]);
+}, opencodeVersion = async (run) => {
+  const listing = await run("opencode", ["plugin", "list"]);
   if (listing.status !== 0)
     return;
   for (const line of listing.stdout.split(/\r?\n/)) {
@@ -75541,8 +75765,8 @@ var codexPluginRoot = (codexHome) => {
       return version;
   }
   return;
-}, applyEntry = (entry, context) => {
-  const { run, paths, configDir } = context;
+}, applyEntry = async (entry, context) => {
+  const { run, runAsync, paths, configDir } = context;
   const { home, env } = paths;
   const fail = (reason) => ({
     host: entry.host,
@@ -75594,12 +75818,12 @@ var codexPluginRoot = (codexHome) => {
       reason: entry.repair ? `reinstalled missing plugin files (${entry.latest})` : `${entry.installedVersion ?? "?"} -> ${entry.latest}`
     };
   }
-  const before = entry.host === "opencode" ? opencodeVersion(run) : undefined;
+  const before = entry.host === "opencode" ? await opencodeVersion(runAsync) : undefined;
   for (const command of entry.commands)
-    if (run(command.command, command.args).status !== 0)
+    if ((await runAsync(command.command, command.args)).status !== 0)
       return fail(`\`${command.command} ${command.args.join(" ")}\` failed`);
   if (entry.host === "opencode") {
-    const after = opencodeVersion(run);
+    const after = await opencodeVersion(runAsync);
     if (before && after)
       return after === before ? {
         host: "opencode",
@@ -75628,7 +75852,7 @@ var codexPluginRoot = (codexHome) => {
       reason: `${entry.installedVersion ?? "?"} -> ${after ?? "?"}; new sessions load it`
     };
   }
-  const verify = entry.host === "codex" ? run("codex", ["plugin", "list", "--json"]) : run("pi", ["list"]);
+  const verify = entry.host === "codex" ? await runAsync("codex", ["plugin", "list", "--json"]) : await runAsync("pi", ["list"]);
   if (verify.status !== 0)
     return fail("update verification failed");
   if (entry.host === "codex") {
@@ -75646,28 +75870,28 @@ var codexPluginRoot = (codexHome) => {
     status: "updated",
     reason: entry.repair ? `reinstalled missing plugin files (${entry.latest})` : `${entry.installedVersion ?? "?"} -> ${entry.latest}`
   };
-}, refreshCodexAgents = (run, codexHome) => {
+}, refreshCodexAgents = async (run, codexHome) => {
   const root = codexPluginRoot(codexHome);
   const launcher = root && path46.join(root, "dist", "launch-mcp.js");
   if (!launcher || !existsSync22(launcher))
     return { ok: true, note: "" };
   const fix = `node ${JSON.stringify(launcher)} --install-agents`;
-  return run("node", [launcher, "--install-agents"]).status === 0 ? { ok: true, note: "agents refreshed" } : { ok: false, note: "agent refresh failed", fix };
-}, applyCli = (cli, run, backup) => {
+  return (await run("node", [launcher, "--install-agents"])).status === 0 ? { ok: true, note: "agents refreshed" } : { ok: false, note: "agent refresh failed", fix };
+}, applyCli = async (cli, run, backup) => {
   const fail = (reason) => ({
     host: "cli",
     status: "failed",
     reason,
     fix: CLI_FIX
   });
-  const currentRoot = run("npm", ["root", "--global"]);
+  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, {
     recursive: true
   });
-  if (run("npm", ["install", "--global", `@brainervirus/workit-cli@${cli.latest}`]).status !== 0)
+  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"));
   if (installed?.name !== "@brainervirus/workit-cli" || installed.version !== cli.latest)
@@ -75683,6 +75907,7 @@ var init_apply = __esm(() => {
   init_setup_state();
   init_setup();
   init_safe_write();
+  init_progress();
   init_processes();
   init_shared();
 });
@@ -76103,9 +76328,13 @@ async function runUpgradeCommand(argv, deps = {}) {
   const legacy = flags.has("--apply");
   const json = flags.has("--json") || legacy;
   const run = runner(deps);
-  const plan = previewUpgrade(raw, deps);
-  if (hostFlag === undefined || flags.has("--cli"))
-    planCli(plan, run);
+  const progress = deps.progress ?? createProgress({ stream: process.stderr, json });
+  const plan = progress.runSync("Planning the upgrade", () => {
+    const planned = previewUpgrade(raw, deps);
+    if (hostFlag === undefined || flags.has("--cli"))
+      planCli(planned, run);
+    return planned;
+  });
   plan.ok = plan.blocked.length === 0 && plan.failed.length === 0;
   const { home, env } = upgradePaths(deps);
   const permissions = planHostPermissions({
@@ -76156,11 +76385,11 @@ Nothing changed.
     for (const warning of plan.warnings ?? [])
       out.write(`warning: ${warning}
 `);
-  const result = applyUpgrade(plan, deps);
+  const result = await applyUpgrade(plan, { ...deps, progress });
   let permissionsOk = true;
   let written;
   if (permissions.changes.length && !permissions.refused && !result.error?.startsWith("configuration changed")) {
-    written = applyHostPermissions(permissions, { home, env });
+    written = progress.runSync("Refreshing the permission block", () => applyHostPermissions(permissions, { home, env }), (entries) => entries.every((entry) => entry.status === "written") ? "done" : "failed");
     permissionsOk = written.every((entry) => entry.status === "written");
     for (const entry of written)
       result.hosts.push({
@@ -76172,7 +76401,7 @@ Nothing changed.
   }
   const failed = !result.ok || !permissionsOk;
   const cliVersion = result.hosts.some((h) => h.host === "cli" && h.status === "updated") ? plan.cli.latest : package_default.version;
-  const report = (deps.doctor ?? ((version) => runDoctor({ home, env, cliVersion: version, only: "upgrade" })))(cliVersion);
+  const report = progress.runSync("Checking the result with workit doctor", () => (deps.doctor ?? ((version) => runDoctor({ home, env, cliVersion: version, only: "upgrade" })))(cliVersion));
   const left = report.checks.filter((check) => check.status === "warn" || check.status === "fail");
   if (json) {
     out.write(JSON.stringify({
@@ -76230,7 +76459,7 @@ async function runLaunchCommand(argv, deps = {}) {
       for (const skipped of plan.skipped)
         (deps.out ?? process.stderr).write(`${skipped.host}: ${skipped.reason}${skipped.fix ? ` (run: ${skipped.fix})` : ""}
 `);
-      const result = applyUpgrade(plan, deps);
+      const result = await applyUpgrade(plan, deps);
       if (!result.ok) {
         (deps.out ?? process.stdout).write(`${result.error}
 `);
@@ -76259,6 +76488,7 @@ var init_upgrade = __esm(() => {
   init_host_install();
   init_doctor();
   init_host_permissions();
+  init_progress();
   init_apply();
   init_plan();
   init_report();
@@ -76789,7 +77019,7 @@ var init_redact = __esm(() => {
 });
 
 // packages/workit-core/src/checks.ts
-import { spawn, spawnSync as spawnSync19 } from "node:child_process";
+import { spawn as spawn2, spawnSync as spawnSync19 } from "node:child_process";
 import { createHash as createHash17 } from "node:crypto";
 import fs21 from "node:fs";
 import os18 from "node:os";
@@ -77018,7 +77248,7 @@ function runCheckCommand(argv, options) {
       shell: plan.shell
     };
     try {
-      child = spawn(plan.file, plan.args, spawnOptions);
+      child = spawn2(plan.file, plan.args, spawnOptions);
     } catch (error) {
       finish(null, null, error.code ?? error.message);
       return;
@@ -79036,6 +79266,8 @@ async function prepareHeavy(io, settings, label, runCwd, timeoutMs) {
       wrapper: null,
       env: io.env
     };
+  const progress = createProgress({ stream: process.stderr, json: io.json });
+  let waiting = null;
   const acquired = await acquireLease({
     dir,
     slots: settings.slots,
@@ -79048,11 +79280,20 @@ async function prepareHeavy(io, settings, label, runCwd, timeoutMs) {
     onStatus: (status) => {
       const slots = `${settings.slots} slot${settings.slots === 1 ? "" : "s"}`;
       const holders = status.holders.map((holder) => describeHolder(holder)).join("; ");
+      if (progress.mode === "spinner") {
+        const text = `Waiting for the heavy-check lease: held by ${holders || "nobody; waiters ahead"}, queue position ${status.position}`;
+        if (waiting)
+          waiting.label(text);
+        else
+          waiting = progress.start(text);
+        return;
+      }
       io.stderr(status.first ? `workit: waiting for the heavy-check lease (${slots}): held by ${holders || "nobody; waiters ahead"}; queued at position ${status.position}, waiting up to ${formatWait(settings.waitMs)} (--wait <dur> sets it)
 ` : `workit: still queued for the heavy-check lease: position ${status.position}, ${formatWait(status.waitedMs)} of ${formatWait(settings.waitMs)} waited; held by ${holders || "nobody; waiters ahead"}
 `);
     }
   });
+  waiting?.end(acquired.ok ? "done" : "failed");
   if (!acquired.ok && acquired.reason === "timeout") {
     const holders = acquired.holders.map((holder) => describeHolder(holder)).join("; ");
     const waited = formatWait(acquired.waitedMs);
@@ -79334,6 +79575,7 @@ var init_check = __esm(() => {
   init_package();
   init_ledger();
   init_output();
+  init_progress();
   init_host_session();
   init_resources();
   MAX_UNVERIFIED_RUN_MS = 6 * 3600000;
@@ -87888,6 +88130,11 @@ 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 abort = (...args) => {
+    waiting.end("failed");
+    return forgeFail(io, ...args);
+  };
   for (;; ) {
     const read = resolved.forge.prStatus(number.data);
     polls += 1;
@@ -87897,7 +88144,7 @@ async function wait2(argv, io) {
       status = read.data;
       const doc = buildStatusDoc(io.cwd, resolved, status, { logLines: 0, behind: false });
       if (!doc.ok)
-        return forgeFail(io, doc);
+        return abort(doc);
       recordPrStatus(io.cwd, doc.data, actor);
       if (status.requiredContexts === null && baseContexts === null) {
         const base = resolved.forge.branchChecks(status.base);
@@ -87908,12 +88155,14 @@ async function wait2(argv, io) {
       verdict = waitVerdict(doc.data, { head, elapsedMs, expectedMissing });
       if (verdict.state !== "waiting")
         break;
+      const pending = doc.data.checks.pending;
+      waiting.label(`Waiting for CI: ${pending.length} check${pending.length === 1 ? "" : "s"} pending${pending.length ? ` (${pending.slice(0, 3).join(", ")}${pending.length > 3 ? ", …" : ""})` : ""}`);
     } else {
       errors += 1;
       if (read.code !== "unavailable" && read.code !== "failed")
-        return forgeFail(io, read);
+        return abort(read);
       if (errors >= MAX_POLL_ERRORS)
-        return forgeFail(io, read, { polls });
+        return abort(read, { polls });
     }
     const remaining = deadline - forgeDeps.now();
     if (remaining <= 0)
@@ -87921,6 +88170,7 @@ async function wait2(argv, io) {
     await forgeDeps.sleep(Math.min(pollDelay(intervalMs, polls - 1), remaining));
   }
   const elapsedMs = forgeDeps.now() - started;
+  waiting.end(verdict.state === "ready" ? "done" : verdict.state === "waiting" ? "skipped" : "failed");
   if (!status)
     return emit(io, fail2("unavailable", "no successful poll before the timeout", { data: { polls } }));
   const left = deadline - forgeDeps.now();
@@ -88087,6 +88337,7 @@ var init_ci = __esm(() => {
   init_ledger();
   init_autonomy();
   init_output();
+  init_progress();
   init_forge_common();
 });
 
@@ -106974,7 +107225,7 @@ var init_audit = __esm(() => {
 });
 
 // packages/workit-cli/src/test-audit/mutate.ts
-import { spawn as spawn2 } from "node:child_process";
+import { spawn as spawn3 } from "node:child_process";
 import {
   existsSync as existsSync29,
   lstatSync as lstatSync9,
@@ -107213,7 +107464,7 @@ function copyWorkingTree(repo) {
 function runCommand(command, cwd, timeoutMs, env) {
   const started = performance.now();
   return new Promise((resolve) => {
-    const child = spawn2(command, {
+    const child = spawn3(command, {
       cwd,
       env,
       shell: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-cli",
-  "version": "8.40.7",
+  "version": "8.41.0",
   "private": false,
   "description": "Workit CLI — setup wizard, doctor, and task control for agentic coding workflows",
   "keywords": [
@@ -38,13 +38,13 @@
   },
   "dependencies": {
     "@babel/parser": "7.29.9",
-    "@brainervirus/workit-cursor": "^8.40.7",
+    "@brainervirus/workit-cursor": "^8.41.0",
     "@inkjs/ui": "2.0.0",
     "ink": "7.1.1",
     "react": "19.2.8"
   },
   "devDependencies": {
-    "@brainervirus/workit-core": "^8.40.7"
+    "@brainervirus/workit-core": "^8.41.0"
   },
   "engines": {
     "node": ">=24"