@brainervirus/workit-cli 8.27.0 → 8.28.1

package/dist/index.js

@@ -8412,11 +8412,15 @@ var withReleaseTracks = (workspaceRoot, policy) => {
     correction,
     error: `commit_style: commit subject ${JSON.stringify(attempted)} violates ${source} ${policy.preset} policy; ${correction}`
   };
+}, rethrowRuntimeBug = (error) => {
+  if (error instanceof TypeError || error instanceof ReferenceError)
+    throw error;
 }, validateBranchNameFor = (workspaceRoot, name) => {
   try {
     const resolved = branchPolicySnapshotFor(workspaceRoot);
     return validateBranchNamePolicy(name, resolved.namePolicy, resolved.source);
   } catch (error) {
+    rethrowRuntimeBug(error);
     const correction = "repair or select a valid workspace policy before creating a branch";
     return {
       ok: false,
@@ -8434,6 +8438,7 @@ var withReleaseTracks = (workspaceRoot, policy) => {
     const resolved = commitPolicySnapshotFor(workspaceRoot);
     return validateCommitMessagePolicy(message, resolved.policy, resolved.source);
   } catch (error) {
+    rethrowRuntimeBug(error);
     const correction = "repair or select a valid workspace policy before committing";
     return {
       ok: false,
@@ -9240,7 +9245,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@brainervirus/workit-cli",
-    version: "8.27.0",
+    version: "8.28.1",
     private: false,
     description: "Workit CLI — setup wizard, doctor, and task control for agentic coding workflows",
     keywords: [
@@ -9278,13 +9283,13 @@ var init_package = __esm(() => {
     },
     dependencies: {
       "@babel/parser": "7.29.9",
-      "@brainervirus/workit-cursor": "^8.27.0",
+      "@brainervirus/workit-cursor": "^8.28.1",
       "@inkjs/ui": "2.0.0",
       ink: "7.1.1",
       react: "19.2.8"
     },
     devDependencies: {
-      "@brainervirus/workit-core": "^8.27.0"
+      "@brainervirus/workit-core": "^8.28.1"
     },
     engines: {
       node: ">=24"
@@ -16358,7 +16363,7 @@ var str2 = (d, values) => ({
   description: typeof description === "string" ? description : "",
   paths: ["."],
   exclusions: []
-}), LISTS, ENVELOPE;
+}), LISTS, ENVELOPE, NOT_FLAT;
 var init_operation_input = __esm(() => {
   init_task_contract();
   scopeFields = {
@@ -16480,6 +16485,7 @@ var init_operation_input = __esm(() => {
     "expectedWorkspaceRevision",
     "judgment"
   ]);
+  NOT_FLAT = new Set(["schemaVersion", "action", "workspaceId"]);
 });
 
 // packages/workit-core/src/core/policy/judgment.ts
@@ -65551,6 +65557,21 @@ var MODEL_ROLES, MODEL_TIERS, HOST_KEYS, BUILT_IN_CLAUDE_CODE, isObject9 = (valu
     }
   }
   return issues;
+}, roleForAgentType = (agentType, prompt) => {
+  switch (agentType) {
+    case "workit:implementer": {
+      const tier = typeof prompt === "string" ? /^[ \t]*TIER:[ \t]*(mundane|standard|hard)\b/im.exec(prompt)?.[1] : undefined;
+      return { role: "implementer", tier: tier?.toLowerCase() ?? "standard" };
+    }
+    case "workit:verifier":
+      return { role: "verifier" };
+    case "workit:reviewer":
+      return { role: "reviewer" };
+    case "Explore":
+      return { role: "explore" };
+    default:
+      return null;
+  }
 };
 var init_role_models = __esm(() => {
   init_workspaces();
@@ -67025,6 +67046,21 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
       return null;
     dir = parent;
   }
+}, listClaudeProcesses = () => {
+  const r = spawnSync16("ps", ["-eo", "pid=,lstart=,args="], { encoding: "utf8", timeout: 5000 });
+  if (r.status !== 0 || typeof r.stdout !== "string")
+    return null;
+  const found = [];
+  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]))
+      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) => {
   const env = options.env ?? process.env;
   const home = options.home ?? env.HOME ?? os12.homedir();
@@ -67052,7 +67088,8 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     env,
     installer: options.installer ?? false,
     cliVersion: options.cliVersion ?? null,
-    scopeProbe: options.scopeProbe ?? probeScope
+    scopeProbe: options.scopeProbe ?? probeScope,
+    claudeProcesses: options.claudeProcesses ?? listClaudeProcesses
   };
 }, readJson = (p) => {
   try {
@@ -68892,6 +68929,68 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     fix: repair,
     registryProbed
   };
+}, checkClaudeSessionPlugin = (res) => {
+  const id = "claude_session_plugin";
+  if (process.platform === "win32")
+    return {
+      id,
+      status: "info",
+      detail: "running Claude Code sessions are not checked on Windows"
+    };
+  const installs = claudeWorkitInstalls(res.home, res.env, res.cwd).filter((install) => install.version);
+  if (installs.length === 0)
+    return {
+      id,
+      status: "info",
+      detail: "no Workit Claude Code plugin install recorded — skipping"
+    };
+  const registry = readJson(path38.join(claudeConfigDir(res.home, res.env), "plugins", "installed_plugins.json"));
+  const recorded = (install) => {
+    const entries = registry?.plugins?.[install.id];
+    const entry = Array.isArray(entries) ? entries.find((e) => e?.installPath === install.installPath) : null;
+    for (const stamp of [entry?.lastUpdated, entry?.installedAt]) {
+      const ms = typeof stamp === "string" ? Date.parse(stamp) : NaN;
+      if (Number.isFinite(ms))
+        return ms;
+    }
+    try {
+      return statSync6(install.installPath).mtimeMs;
+    } catch {
+      return null;
+    }
+  };
+  const latest = installs.map((install) => ({ install, at: recorded(install) })).filter((one) => one.at !== null).toSorted((a, b) => b.at - a.at)[0];
+  if (!latest)
+    return {
+      id,
+      status: "info",
+      detail: "no install time recorded for the Workit plugin — skipping"
+    };
+  const running = res.claudeProcesses();
+  if (running === null)
+    return {
+      id,
+      status: "info",
+      detail: "could not list running claude processes (ps) — skipping"
+    };
+  const stale = running.filter((proc) => proc.startedMs < latest.at);
+  if (stale.length === 0)
+    return {
+      id,
+      status: "info",
+      detail: `${running.length} running claude process(es), none started before Workit ${latest.install.version} was installed`
+    };
+  const sessionOf = (args) => /(?:--resume|--session-id|-r)[ =]([0-9a-f]{8}-[0-9a-f-]{27})/i.exec(args)?.[1] ?? null;
+  const rows = stale.map((proc) => {
+    const session = sessionOf(proc.args);
+    return `pid ${proc.pid} started ${new Date(proc.startedMs).toISOString()}${session ? ` (session ${session})` : ""}`;
+  });
+  const first = stale.map((proc) => sessionOf(proc.args)).find((one) => one);
+  return {
+    id,
+    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)`
+  };
 }, HOOK_ISSUED_MARKER = "workit-issued-sessions/3", hookRecordsIssued = (root) => {
   let files;
   try {
@@ -69093,6 +69192,7 @@ var init_doctor = __esm(() => {
     checkPiExtension,
     checkOpencodeVersion,
     checkClaudePlugin,
+    checkClaudeSessionPlugin,
     checkHookIssuedSessions,
     checkWorkitOnPath,
     checkAssets,
@@ -77403,6 +77503,9 @@ var exports_models = {};
 __export(exports_models, {
   run: () => run13
 });
+import { existsSync as existsSync21, readdirSync as readdirSync10, readFileSync as readFileSync21, statSync as statSync9 } from "node:fs";
+import os21 from "node:os";
+import path51 from "node:path";
 async function run13(argv, io) {
   const [sub, ...args] = argv.filter((arg) => arg !== "--json");
   if (sub !== "show")
@@ -77410,13 +77513,27 @@ async function run13(argv, io) {
   const role = flag3(args, "--role");
   const tier = flag3(args, "--tier");
   const hostFlag = flag3(args, "--host");
-  for (const value of [role, tier, hostFlag])
+  const daysFlag = flag3(args, "--days");
+  for (const value of [role, tier, hostFlag, daysFlag])
     if (value instanceof Error)
       return emit(io, fail2("invalid_input", value.message));
   if (role && !MODEL_ROLES.includes(role))
     return emit(io, fail2("invalid_input", `unknown role ${role}: ${MODEL_ROLES.join(", ")}`));
   if (tier && !MODEL_TIERS.includes(tier))
     return emit(io, fail2("invalid_input", `unknown tier ${tier}: ${MODEL_TIERS.join(", ")}`));
+  const days = daysFlag === null ? 7 : Number(daysFlag);
+  if (!Number.isFinite(days) || days <= 0)
+    return emit(io, fail2("invalid_input", "--days needs a positive number"));
+  if (args.includes("--report")) {
+    const report = usageReport(io.cwd, io.env, days);
+    return emit(io, ok2(report), (data) => [
+      `subagent models over the last ${data.days} days (${data.agents} agents)`,
+      ...Object.entries(data.types).flatMap(([type, use]) => [
+        `  ${type}${use.role ? ` (role ${use.role}, default ${use.defaults.join("/") || "host default"})` : ""}: ${Object.entries(use.models).map(([model, count]) => `${model} x${count}`).join(", ")}`,
+        ...use.flagged.map((model) => `    flag: ran on ${model}, not the role default`)
+      ])
+    ]);
+  }
   const envHost = actorFromEnv(io.env).host;
   const host = hostFlag ?? (envHost === "cli" ? "claude_code" : envHost);
   const row = (selector) => resolveRoleModel(io.cwd, selector, host) ?? { model: null, effort: null, source: "none" };
@@ -77439,13 +77556,73 @@ async function run13(argv, io) {
     ...(data.issues ?? []).map((issue) => `note: ${issue}`)
   ]);
 }
-var USAGE6 = "workit models show [--role <role>] [--tier <tier>] [--host <host>] [--json]", flag3 = (argv, name) => {
+var USAGE6 = "workit models show [--role <role>] [--tier <tier>] [--host <host>] [--report [--days <n>]] [--json]", flag3 = (argv, name) => {
   const at = argv.findIndex((arg) => arg === name || arg.startsWith(`${name}=`));
   if (at < 0)
     return null;
   const value = argv[at].includes("=") ? argv[at].slice(name.length + 1) : argv[at + 1];
   return value && !value.startsWith("--") ? value : new Error(`${name} needs a value`);
-}, line2 = (label, entry) => `  ${label}: ${entry.model ? `${entry.model}${entry.effort ? ` (effort ${entry.effort})` : ""}  [${entry.source}]` : "host default (nothing configured)"}`;
+}, line2 = (label, entry) => `  ${label}: ${entry.model ? `${entry.model}${entry.effort ? ` (effort ${entry.effort})` : ""}  [${entry.source}]` : "host default (nothing configured)"}`, modelsOf = (file) => {
+  const found = new Set;
+  let text = "";
+  try {
+    text = readFileSync21(file, "utf8");
+  } catch {
+    return found;
+  }
+  for (const row of text.split(`
+`))
+    if (row.includes('"type":"assistant"'))
+      try {
+        const model = JSON.parse(row).message?.model;
+        if (typeof model === "string" && model && !model.startsWith("<"))
+          found.add(model);
+      } catch {}
+  return found;
+}, matches3 = (ran, configured) => ran.toLowerCase().includes(configured.toLowerCase()), usageReport = (cwd, env, days) => {
+  const projects = path51.join(env.CLAUDE_CONFIG_DIR || path51.join(env.HOME || os21.homedir(), ".claude"), "projects");
+  const since = Date.now() - days * 86400000;
+  const types = {};
+  let agents = 0;
+  const dirs = (dir) => {
+    try {
+      return readdirSync10(dir).map((name) => path51.join(dir, name));
+    } catch {
+      return [];
+    }
+  };
+  for (const project of dirs(projects))
+    for (const session of dirs(project))
+      for (const meta of dirs(path51.join(session, "subagents")).filter((f) => f.endsWith(".meta.json"))) {
+        try {
+          if (statSync9(meta).mtimeMs < since)
+            continue;
+          const agentType = JSON.parse(readFileSync21(meta, "utf8")).agentType;
+          const transcript = meta.replace(/\.meta\.json$/, ".jsonl");
+          if (typeof agentType !== "string" || !existsSync21(transcript))
+            continue;
+          const ran = modelsOf(transcript);
+          if (!ran.size)
+            continue;
+          agents += 1;
+          const selector = roleForAgentType(agentType);
+          const entry = types[agentType] ??= {
+            role: selector?.role ?? null,
+            defaults: selector ? [
+              ...new Set((selector.role === "implementer" ? MODEL_TIERS.map((tier) => ({ ...selector, tier })) : [selector]).flatMap((one) => resolveRoleModel(cwd, one, "claude_code")?.model ?? []))
+            ] : [],
+            models: {},
+            flagged: []
+          };
+          for (const model of ran) {
+            entry.models[model] = (entry.models[model] ?? 0) + 1;
+            if (entry.models[model] === 1 && entry.defaults.length && !entry.defaults.some((d) => matches3(model, d)))
+              entry.flagged.push(model);
+          }
+        } catch {}
+      }
+  return { days, agents, types };
+};
 var init_models = __esm(() => {
   init_role_models();
   init_ledger();
@@ -77561,8 +77738,8 @@ 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 existsSync21, readFileSync as readFileSync21 } from "node:fs";
-import path51 from "node:path";
+import { existsSync as existsSync22, readFileSync as readFileSync22 } from "node:fs";
+import path52 from "node:path";
 function operationInProgress(cwd) {
   const markers = [
     ["rebase-merge", "rebase"],
@@ -77575,18 +77752,18 @@ function operationInProgress(cwd) {
   if (!run.ok)
     return null;
   const found = run.stdout.split(`
-`).map((line) => path51.resolve(cwd, line.trim()));
+`).map((line) => path52.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 || !existsSync21(marker))
+    if (!marker || !existsSync22(marker))
       continue;
-    if (index === 1 && existsSync21(path51.join(marker, "applying")))
+    if (index === 1 && existsSync22(path52.join(marker, "applying")))
       return { operation: "am", commitAllowed: false, branch: null };
-    if (index === 0 && existsSync21(path51.join(marker, "amend")) && !conflicted()) {
+    if (index === 0 && existsSync22(path52.join(marker, "amend")) && !conflicted()) {
       let headName = "";
       try {
-        headName = readFileSync21(path51.join(marker, "head-name"), "utf8").trim();
+        headName = readFileSync22(path52.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 };
@@ -77914,7 +78091,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) => existsSync21(path51.resolve(cwd, value)) || [...tracked].some((file) => file === value || file.startsWith(`${value}/`)));
+    const addable = paths.filter((value) => existsSync22(path52.resolve(cwd, value)) || [...tracked].some((file) => file === value || file.startsWith(`${value}/`)));
     if (addable.length) {
       const added = git5(cwd, ["add", "-A", "--", ...addable]);
       if (!added.ok)
@@ -78441,12 +78618,12 @@ var init_ops = __esm(() => {
 
 // packages/workit-core/src/verdict-cover.ts
 import fs26 from "node:fs";
-import path52 from "node:path";
+import path53 from "node:path";
 function chainsAbove(cwd, branch) {
   const root = storeRoot(cwd);
   if (!root.ok)
     return [];
-  const dir = path52.join(root.value.root, "stacks");
+  const dir = path53.join(root.value.root, "stacks");
   let names = [];
   try {
     names = fs26.readdirSync(dir).filter((name) => name.endsWith(".json"));
@@ -78457,7 +78634,7 @@ function chainsAbove(cwd, branch) {
   for (const name of names.toSorted()) {
     let parsed;
     try {
-      parsed = JSON.parse(fs26.readFileSync(path52.join(dir, name), "utf8"));
+      parsed = JSON.parse(fs26.readFileSync(path53.join(dir, name), "utf8"));
     } catch {
       continue;
     }
@@ -78552,10 +78729,10 @@ var init_pr_lane = __esm(() => {
 
 // packages/workit-core/src/forge/reruns.ts
 import fs27 from "node:fs";
-import path53 from "node:path";
+import path54 from "node:path";
 function rerunLogPath(cwd) {
   const common = gitCommonDir(cwd);
-  return common ? path53.join(common, "workit", "ci-reruns.jsonl") : null;
+  return common ? path54.join(common, "workit", "ci-reruns.jsonl") : null;
 }
 function rerunCounts(cwd, key) {
   const counts = new Map;
@@ -78590,7 +78767,7 @@ function recordReruns(cwd, rows) {
   if (!file)
     return false;
   try {
-    fs27.mkdirSync(path53.dirname(file), { recursive: true });
+    fs27.mkdirSync(path54.dirname(file), { recursive: true });
     fs27.appendFileSync(file, rows.map((row) => `${JSON.stringify(row)}
 `).join(""));
     return true;
@@ -78603,7 +78780,7 @@ function withRerunLock(cwd, fn) {
   if (!file)
     return fn();
   const lock = `${file.slice(0, -".jsonl".length)}.lock`;
-  fs27.mkdirSync(path53.dirname(lock), { recursive: true });
+  fs27.mkdirSync(path54.dirname(lock), { recursive: true });
   const until = Date.now() + LOCK_WAIT_MS2;
   for (;; ) {
     try {
@@ -79518,7 +79695,7 @@ var init_pr_ops = __esm(() => {
 import { spawnSync as spawnSync22 } from "node:child_process";
 import { createHash as createHash17, randomBytes as randomBytes4 } from "node:crypto";
 import fs28 from "node:fs";
-import path54 from "node:path";
+import path55 from "node:path";
 function worktreeOf(cwd, branch) {
   const list = gitRun3(cwd, ["worktree", "list", "--porcelain"]);
   if (!list.ok)
@@ -79562,7 +79739,7 @@ function gitRestack(cwd, input) {
     if (!scratch)
       return { ok: false, conflict: false, worktree: cwd, error: "no store root" };
     fs28.mkdirSync(scratch, { recursive: true });
-    dir = path54.join(scratch, `${input.branch.replace(/[^A-Za-z0-9._-]+/gu, "_").slice(0, 40)}-${randomBytes4(4).toString("hex")}`);
+    dir = path55.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 { ok: false, conflict: false, worktree: cwd, error: firstLine(added) };
@@ -79603,7 +79780,7 @@ function pruneScratch(cwd) {
   if (!scratch || !fs28.existsSync(scratch))
     return;
   for (const name of fs28.readdirSync(scratch)) {
-    const dir = path54.join(scratch, name);
+    const dir = path55.join(scratch, name);
     if (!rebaseInProgress(dir) && !trackedDirt(dir))
       gitRun3(cwd, ["worktree", "remove", "--force", dir]);
   }
@@ -79613,7 +79790,7 @@ function stacksDir(cwd) {
   const root = storeRoot(cwd);
   if (!root.ok)
     return stackFail(root.code, root.error, root.unblock);
-  return { ok: true, data: path54.join(root.value.root, "stacks") };
+  return { ok: true, data: path55.join(root.value.root, "stacks") };
 }
 function parseStack(raw) {
   if (!isRecord12(raw) || !Array.isArray(raw.branches))
@@ -79665,7 +79842,7 @@ function readStack(cwd, name) {
   const dir = stacksDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path54.join(dir.data, fileFor(name));
+  const file = path55.join(dir.data, fileFor(name));
   let text;
   try {
     text = fs28.readFileSync(file, "utf8");
@@ -79686,7 +79863,7 @@ function writeStack(cwd, stack, now = new Date) {
   const dir = stacksDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path54.join(dir.data, fileFor(stack.name));
+  const file = path55.join(dir.data, fileFor(stack.name));
   const temp = `${file}.${process.pid}.tmp`;
   try {
     fs28.mkdirSync(dir.data, { recursive: true });
@@ -79714,7 +79891,7 @@ function listStacks(cwd) {
   for (const name of names) {
     let parsed = null;
     try {
-      parsed = parseStack(JSON.parse(fs28.readFileSync(path54.join(dir.data, name), "utf8")));
+      parsed = parseStack(JSON.parse(fs28.readFileSync(path55.join(dir.data, name), "utf8")));
     } catch {
       parsed = null;
     }
@@ -79773,7 +79950,7 @@ function takeLock(lock) {
     host: localLockHost(),
     nonce: randomBytes4(8).toString("hex")
   };
-  fs28.writeFileSync(path54.join(lock, OWNER), JSON.stringify(owner));
+  fs28.writeFileSync(path55.join(lock, OWNER), JSON.stringify(owner));
   return owner;
 }
 function reapLock(lock, observed) {
@@ -79810,7 +79987,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 = path54.join(dir.data, `${fileFor(name)}.lock`);
+  const lock = path55.join(dir.data, `${fileFor(name)}.lock`);
   try {
     fs28.mkdirSync(dir.data, { recursive: true });
   } catch (error) {
@@ -79840,7 +80017,7 @@ async function withStackLock(cwd, name, fn, waitMs = LOCK_WAIT_MS3) {
   const touch = () => {
     try {
       const now = new Date;
-      fs28.utimesSync(path54.join(lock, OWNER), now, now);
+      fs28.utimesSync(path55.join(lock, OWNER), now, now);
     } catch {}
   };
   const beat = setInterval(touch, HEARTBEAT_MS);
@@ -80691,7 +80868,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 ? path54.join(dir.data, "worktrees") : null;
+  return dir.ok ? path55.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()}-${createHash17("sha256").update(name).digest("hex").slice(0, 12)}.json`, fileFor, validName = (name) => {
@@ -80706,12 +80883,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(path54.join(lock, OWNER), "utf8");
+    raw = fs28.readFileSync(path55.join(lock, OWNER), "utf8");
   } catch {
     raw = null;
   }
   let age = null;
-  for (const target of [path54.join(lock, OWNER), lock])
+  for (const target of [path55.join(lock, OWNER), lock])
     try {
       age = Date.now() - fs28.statSync(target).mtimeMs;
       break;
@@ -80754,7 +80931,7 @@ var init_stack = __esm(() => {
 import { spawnSync as spawnSync23 } from "node:child_process";
 import { createHash as createHash18 } from "node:crypto";
 import fs29 from "node:fs";
-import path55 from "node:path";
+import path56 from "node:path";
 function expandBraces2(pattern, limit = 64) {
   for (let index = 0;index < pattern.length; index += 1) {
     if (pattern[index] === "\\") {
@@ -81000,7 +81177,7 @@ function parsePlan(raw, defaults, name) {
       id,
       branch,
       base: optional("base") ?? "",
-      worktree: path55.resolve(defaults.root, optional("worktree") ?? path55.join(defaults.worktreeRoot, id)),
+      worktree: path56.resolve(defaults.root, optional("worktree") ?? path56.join(defaults.worktreeRoot, id)),
       tier,
       reason,
       dependsOn: [...new Set(dependsOn ?? [])],
@@ -81231,11 +81408,11 @@ function defaultTrunk(cwd) {
 }
 function mainCheckout(cwd) {
   const common = gitCommonDir(cwd);
-  return common && path55.basename(common) === ".git" ? path55.dirname(common) : path55.resolve(cwd);
+  return common && path56.basename(common) === ".git" ? path56.dirname(common) : path56.resolve(cwd);
 }
 function worktreeRoot(cwd) {
   const main = mainCheckout(cwd);
-  return path55.join(path55.dirname(main), `${path55.basename(main)}-wt`);
+  return path56.join(path56.dirname(main), `${path56.basename(main)}-wt`);
 }
 function sliceHash(slice) {
   const {
@@ -81255,7 +81432,7 @@ function fanoutsDir(cwd) {
   const root = storeRoot(cwd);
   if (!root.ok)
     return fanoutFail(root.code, root.error, root.unblock);
-  return { ok: true, data: path55.join(root.value.root, "fanouts") };
+  return { ok: true, data: path56.join(root.value.root, "fanouts") };
 }
 function parseStored(raw) {
   if (!isRecord13(raw) || typeof raw.name !== "string" || typeof raw.trunk !== "string")
@@ -81323,7 +81500,7 @@ function readFanout(cwd, name) {
   const dir = fanoutsDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path55.join(dir.data, stackFileName(name));
+  const file = path56.join(dir.data, stackFileName(name));
   let parsed = null;
   try {
     parsed = parseStored(JSON.parse(fs29.readFileSync(file, "utf8")));
@@ -81348,7 +81525,7 @@ function listFanouts(cwd) {
   for (const entry of names) {
     let parsed = null;
     try {
-      parsed = parseStored(JSON.parse(fs29.readFileSync(path55.join(dir.data, entry), "utf8")));
+      parsed = parseStored(JSON.parse(fs29.readFileSync(path56.join(dir.data, entry), "utf8")));
     } catch {
       parsed = null;
     }
@@ -81387,7 +81564,7 @@ function writeFanout(cwd, plan) {
   const dir = fanoutsDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path55.join(dir.data, stackFileName(plan.name));
+  const file = path56.join(dir.data, stackFileName(plan.name));
   const temp = `${file}.${process.pid}.tmp`;
   try {
     fs29.mkdirSync(dir.data, { recursive: true });
@@ -81594,13 +81771,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 path56 from "node:path";
+import path57 from "node:path";
 function findExecutable(bin, env) {
-  const dirs = (env.PATH ?? env.Path ?? "").split(path56.delimiter).filter(Boolean);
+  const dirs = (env.PATH ?? env.Path ?? "").split(path57.delimiter).filter(Boolean);
   const exts = process.platform === "win32" ? [".exe"] : [""];
   for (const dir of dirs)
     for (const ext of exts) {
-      const candidate = path56.join(dir, `${bin}${ext}`);
+      const candidate = path57.join(dir, `${bin}${ext}`);
       try {
         const stat = fs30.statSync(candidate);
         if (stat.isFile())
@@ -83344,7 +83521,7 @@ var init_duration = __esm(() => {
 });
 
 // packages/workit-cli/src/verbs/forge-common.ts
-import { readFileSync as readFileSync22 } from "node:fs";
+import { readFileSync as readFileSync23 } from "node:fs";
 function parseFlags(argv, spec) {
   const parsed = { values: {}, booleans: new Set, lists: {}, positionals: [] };
   for (let index = 0;index < argv.length; index += 1) {
@@ -83488,7 +83665,7 @@ var init_forge_common = __esm(() => {
   forgeDeps = {
     runner: undefined,
     npm: undefined,
-    readStdin: () => readFileSync22(0, "utf8"),
+    readStdin: () => readFileSync23(0, "utf8"),
     sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
     now: () => Date.now()
   };
@@ -83499,12 +83676,12 @@ var exports_pr = {};
 __export(exports_pr, {
   run: () => run14
 });
-import { readFileSync as readFileSync23 } from "node:fs";
-import path57 from "node:path";
+import { readFileSync as readFileSync24 } from "node:fs";
+import path58 from "node:path";
 function readBodyFile(io, file) {
   try {
     return {
-      body: file === "-" ? forgeDeps.readStdin() : readFileSync23(path57.resolve(io.cwd, file), "utf8")
+      body: file === "-" ? forgeDeps.readStdin() : readFileSync24(path58.resolve(io.cwd, file), "utf8")
     };
   } catch {
     return `cannot read --body-file ${file}`;
@@ -84209,8 +84386,8 @@ var exports_git = {};
 __export(exports_git, {
   run: () => run16
 });
-import { readFileSync as readFileSync24 } from "node:fs";
-import path58 from "node:path";
+import { readFileSync as readFileSync25 } from "node:fs";
+import path59 from "node:path";
 function kindHint(cwd, kind) {
   let kinds = [...BRANCH_KINDS];
   try {
@@ -84314,7 +84491,7 @@ function commitMessage(parsed, io) {
 
 `);
   try {
-    return file === "-" ? readFileSync24(0, "utf8") : readFileSync24(path58.resolve(io.cwd, file), "utf8");
+    return file === "-" ? readFileSync25(0, "utf8") : readFileSync25(path59.resolve(io.cwd, file), "utf8");
   } catch (error) {
     return {
       error: `cannot read -F ${file}: ${error instanceof Error ? error.message : String(error)}`
@@ -85735,7 +85912,7 @@ var init_live_session = __esm(() => {
 });
 
 // packages/workit-core/src/hooks/write-gate.ts
-import path59 from "node:path";
+import path60 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();
@@ -85775,7 +85952,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 = path59.resolve(path59.parse(process.cwd()).root, ".workit-unknown-dir");
+  UNKNOWN_DIR = path60.resolve(path60.parse(process.cwd()).root, ".workit-unknown-dir");
 });
 
 // packages/workit-core/src/hooks/worktree-confine.ts
@@ -85800,20 +85977,20 @@ var init_worktree_confine = __esm(() => {
 
 // packages/workit-core/src/worktree-deps.ts
 import fs32 from "node:fs";
-import path60 from "node:path";
+import path61 from "node:path";
 function moduleDirs(main) {
   const out = [];
   const walk = (relative, depth) => {
     let entries;
     try {
-      entries = fs32.readdirSync(path60.join(main, relative), { withFileTypes: true });
+      entries = fs32.readdirSync(path61.join(main, relative), { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const child = path60.join(relative, entry.name);
+      const child = path61.join(relative, entry.name);
       if (entry.name === MODULES)
         out.push(child);
       else if (depth < MAX_DEPTH2 && !entry.name.startsWith("."))
@@ -85827,8 +86004,8 @@ function linkEntry(main, worktree, source, target) {
   const stat = fs32.lstatSync(source);
   if (stat.isSymbolicLink()) {
     const link = fs32.readlinkSync(source);
-    const outside = path60.isAbsolute(link) && within(link, main) && !path60.relative(main, link).split(path60.sep).includes(MODULES);
-    const to = outside ? path60.join(worktree, path60.relative(main, link)) : link;
+    const outside = path61.isAbsolute(link) && within(link, main) && !path61.relative(main, link).split(path61.sep).includes(MODULES);
+    const to = outside ? path61.join(worktree, path61.relative(main, link)) : link;
     fs32.symlinkSync(to, target, process.platform === "win32" ? "junction" : undefined);
     return;
   }
@@ -85838,8 +86015,8 @@ function mirror(main, worktree, source, target, top) {
   fs32.mkdirSync(target);
   let count = 0;
   for (const entry of fs32.readdirSync(source, { withFileTypes: true })) {
-    const from = path60.join(source, entry.name);
-    const to = path60.join(target, entry.name);
+    const from = path61.join(source, entry.name);
+    const to = path61.join(target, entry.name);
     if (top && entry.isDirectory() && (entry.name.startsWith("@") || entry.name === ".bin"))
       count += mirror(main, worktree, from, to, false);
     else {
@@ -85855,16 +86032,16 @@ function linkWorktreeDependencies(main, worktree) {
   const dirs = [];
   let entries = 0;
   for (const relative of moduleDirs(main)) {
-    const target = path60.join(worktree, relative);
-    if (!fs32.existsSync(path60.dirname(target)) || fs32.existsSync(target))
+    const target = path61.join(worktree, relative);
+    if (!fs32.existsSync(path61.dirname(target)) || fs32.existsSync(target))
       continue;
-    if (!gitRun4(worktree, ["check-ignore", "-q", `${relative.split(path60.sep).join("/")}/`]).ok) {
-      notes.push(`${relative.split(path60.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(path61.sep).join("/")}/`]).ok) {
+      notes.push(`${relative.split(path61.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, path60.join(main, relative), target, true);
-      dirs.push(relative.split(path60.sep).join("/"));
+      entries += mirror(main, worktree, path61.join(main, relative), target, true);
+      dirs.push(relative.split(path61.sep).join("/"));
     } catch (error) {
       fs32.rmSync(target, { recursive: true, force: true });
       notes.push(`could not link ${relative} from ${main} (${error.message}); install dependencies in the worktree yourself`);
@@ -85877,8 +86054,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 = path60.relative(parent, child);
-  return relative === "" || !relative.startsWith("..") && !path60.isAbsolute(relative);
+  const relative = path61.relative(parent, child);
+  return relative === "" || !relative.startsWith("..") && !path61.isAbsolute(relative);
 };
 var init_worktree_deps = __esm(() => {
   init_fanout();
@@ -85887,7 +86064,7 @@ var init_worktree_deps = __esm(() => {
 // packages/workit-core/src/fanout-worktree.ts
 import { randomBytes as randomBytes5 } from "node:crypto";
 import fs33 from "node:fs";
-import path61 from "node:path";
+import path62 from "node:path";
 function rowSample(lines) {
   const out = [];
   let bytes = 0;
@@ -85947,7 +86124,7 @@ function adminDir(worktree) {
   const file = dir.stdout.trim();
   let token = null;
   try {
-    token = fs33.readFileSync(path61.join(file, FANOUT_TOKEN_FILE), "utf8").trim() || null;
+    token = fs33.readFileSync(path62.join(file, FANOUT_TOKEN_FILE), "utf8").trim() || null;
   } catch {
     token = null;
   }
@@ -85955,7 +86132,7 @@ function adminDir(worktree) {
     const stat = worktreeDeps.stat(file);
     return {
       path: file,
-      id: path61.basename(file),
+      id: path62.basename(file),
       ino: stat.ino.toString(),
       token,
       birthMs: stat.birthtimeNs > 0n ? Number(stat.birthtimeMs) : null,
@@ -85971,7 +86148,7 @@ function markAdminDir(worktree) {
     return null;
   const token = randomBytes5(16).toString("hex");
   try {
-    fs33.writeFileSync(path61.join(admin.path, FANOUT_TOKEN_FILE), `${token}
+    fs33.writeFileSync(path62.join(admin.path, FANOUT_TOKEN_FILE), `${token}
 `);
   } catch {
     return null;
@@ -85986,7 +86163,7 @@ function excludeScratch(cwd) {
   const common = gitCommonDir(cwd);
   if (!common)
     return;
-  const file = path61.join(common, "info", "exclude");
+  const file = path62.join(common, "info", "exclude");
   let text = "";
   try {
     text = fs33.readFileSync(file, "utf8");
@@ -85995,7 +86172,7 @@ function excludeScratch(cwd) {
   }
   if (text.split(/\r?\n/u).includes(EXCLUDE_LINE))
     return;
-  fs33.mkdirSync(path61.dirname(file), { recursive: true });
+  fs33.mkdirSync(path62.dirname(file), { recursive: true });
   fs33.appendFileSync(file, `${text && !text.endsWith(`
 `) ? `
 ` : ""}# workit fanout: per-worker scratch dirs
@@ -86003,7 +86180,7 @@ ${EXCLUDE_LINE}
 `);
 }
 function ensureScratch(worktree) {
-  const scratch = path61.join(worktree, SCRATCH_DIR);
+  const scratch = path62.join(worktree, SCRATCH_DIR);
   fs33.mkdirSync(scratch, { recursive: true });
   return scratch;
 }
@@ -86231,7 +86408,7 @@ function unpushedCount(cwd, branch) {
   return count.ok ? Number(count.stdout.trim()) : null;
 }
 function removeScratch(worktree) {
-  const scratch = path61.join(worktree, SCRATCH_DIR);
+  const scratch = path62.join(worktree, SCRATCH_DIR);
   let stat;
   try {
     stat = fs33.lstatSync(scratch);
@@ -86247,16 +86424,16 @@ var SLOW, SCRATCH_DIR = ".workit-scratch", EXCLUDE_LINE, DIRTY_ROW_BYTES = 2000,
   try {
     return fs33.realpathSync.native(target);
   } catch {
-    return path61.resolve(target);
+    return path62.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 = path61.relative(canonical2(parent), canonical2(child));
-  return relative === "" || !relative.startsWith("..") && !path61.isAbsolute(relative);
-}, slicePath = (cwd, slice) => path61.isAbsolute(slice.worktree) ? slice.worktree : path61.resolve(mainCheckout(cwd), slice.worktree), CLOCK_SLACK_MS = 2000, worktreeDeps, worktreeFailed = (stderr) => fanoutFail("failed", `git worktree add failed: ${stderr.trim().split(`
+  const relative = path62.relative(canonical2(parent), canonical2(child));
+  return relative === "" || !relative.startsWith("..") && !path62.isAbsolute(relative);
+}, slicePath = (cwd, slice) => path62.isAbsolute(slice.worktree) ? slice.worktree : path62.resolve(mainCheckout(cwd), slice.worktree), CLOCK_SLACK_MS = 2000, worktreeDeps, worktreeFailed = (stderr) => fanoutFail("failed", `git worktree add failed: ${stderr.trim().split(`
 `)[0] || "unknown error"}`);
 var init_fanout_worktree = __esm(() => {
   init_ops();
@@ -87092,7 +87269,7 @@ __export(exports_fanout, {
   run: () => run20
 });
 import fs34 from "node:fs";
-import path62 from "node:path";
+import path63 from "node:path";
 function forgeFor(io, offline) {
   if (offline)
     return { forge: null, error: "--offline" };
@@ -87153,7 +87330,7 @@ function plan2(argv, io) {
     return usage3(io, "pass --trunk or --track, not both (--track picks the trunk)", PLAN_USAGE2);
   if (flags.positionals.length !== 1)
     return usage3(io, flags.positionals.length ? `unexpected argument ${flags.positionals[1]}` : "missing <plan.json>", PLAN_USAGE2);
-  const file = path62.resolve(io.cwd, flags.positionals[0]);
+  const file = path63.resolve(io.cwd, flags.positionals[0]);
   let raw;
   try {
     raw = JSON.parse(fs34.readFileSync(file, "utf8"));
@@ -102692,7 +102869,7 @@ var init_ast = __esm(() => {
 
 // packages/workit-cli/src/test-audit/rules.ts
 import { builtinModules } from "node:module";
-import path63 from "node:path";
+import path64 from "node:path";
 function testCallee(call) {
   let callee = call.callee;
   if (callee.type === "CallExpression")
@@ -103185,12 +103362,12 @@ function checkConstantsOnly(ctx, emit) {
 }
 function checkOverMocking(ctx, emit) {
   const { program } = ctx.parsed;
-  const unit = path63.basename(ctx.file).replace(/\.(?:[cm]?[jt]sx?)$/, "").replace(/\.(?:test|spec)$/, "");
+  const unit = path64.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 = path63.basename(spec.replace(/\/index(?:\.[cm]?[jt]sx?)?$/, "")).replace(/\.(?:[cm]?[jt]sx?)$/, "");
+    const base = path64.basename(spec.replace(/\/index(?:\.[cm]?[jt]sx?)?$/, "")).replace(/\.(?:[cm]?[jt]sx?)$/, "");
     if (base === unit)
       emit({
         rule: "over-mocking",
@@ -103579,8 +103756,8 @@ var init_rules = __esm(() => {
 
 // packages/workit-cli/src/test-audit/audit.ts
 import { spawnSync as spawnSync29 } from "node:child_process";
-import { existsSync as existsSync22, readdirSync as readdirSync10, readFileSync as readFileSync25, statSync as statSync9 } from "node:fs";
-import path64 from "node:path";
+import { existsSync as existsSync23, readdirSync as readdirSync11, readFileSync as readFileSync26, statSync as statSync10 } from "node:fs";
+import path65 from "node:path";
 function git7(cwd, args) {
   const run = spawnSync29("git", ["-c", "core.quotepath=off", ...args], {
     cwd,
@@ -103590,10 +103767,10 @@ function git7(cwd, args) {
   return { ok: run.status === 0, stdout: run.stdout ?? "" };
 }
 function walkTests(dir, out) {
-  for (const entry of readdirSync10(dir, { withFileTypes: true })) {
+  for (const entry of readdirSync11(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".") && entry.name !== "." && entry.isDirectory())
       continue;
-    const full = path64.join(dir, entry.name);
+    const full = path65.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (!SKIP_DIRS.has(entry.name))
         walkTests(full, out);
@@ -103605,10 +103782,10 @@ function expandPaths(cwd, inputs) {
   const files = [];
   const missing = [];
   for (const input of inputs.length > 0 ? inputs : ["."]) {
-    const full = path64.resolve(cwd, input);
-    if (!existsSync22(full))
+    const full = path65.resolve(cwd, input);
+    if (!existsSync23(full))
       missing.push(input);
-    else if (statSync9(full).isDirectory())
+    else if (statSync10(full).isDirectory())
       walkTests(full, files);
     else
       files.push(full);
@@ -103642,11 +103819,11 @@ function changedLines(cwd, base) {
       for (let offset = 0;offset < count; offset += 1)
         lines.add(start + offset);
     }
-    changed.set(path64.join(root, file), lines);
+    changed.set(path65.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(path64.join(root, file), "all");
+    changed.set(path65.join(root, file), "all");
   return changed;
 }
 function auditFiles(files, display) {
@@ -103659,7 +103836,7 @@ function auditFiles(files, display) {
     const shown = display(file);
     let parsed;
     try {
-      parsed = parseSource(readFileSync25(file, "utf8"), file);
+      parsed = parseSource(readFileSync26(file, "utf8"), file);
     } catch (error) {
       parseErrors.push({
         file: shown,
@@ -103708,7 +103885,7 @@ function auditFiles(files, display) {
     durationMs: Math.round(performance.now() - started)
   };
 }
-var TEST_FILE, CODE_FILE, SKIP_DIRS, toPosix = (file) => file.split(path64.sep).join("/"), SEVERITY_ORDER, ruleIds;
+var TEST_FILE, CODE_FILE, SKIP_DIRS, toPosix = (file) => file.split(path65.sep).join("/"), SEVERITY_ORDER, ruleIds;
 var init_audit = __esm(() => {
   init_ast();
   init_rules();
@@ -103722,23 +103899,23 @@ var init_audit = __esm(() => {
 // packages/workit-cli/src/test-audit/mutate.ts
 import { spawn as spawn2 } from "node:child_process";
 import {
-  existsSync as existsSync23,
+  existsSync as existsSync24,
   lstatSync as lstatSync8,
   mkdirSync as mkdirSync11,
   mkdtempSync as mkdtempSync4,
-  readdirSync as readdirSync11,
-  readFileSync as readFileSync26,
+  readdirSync as readdirSync12,
+  readFileSync as readFileSync27,
   readlinkSync as readlinkSync3,
   realpathSync as realpathSync10,
   renameSync as renameSync7,
   rmSync as rmSync9,
-  statSync as statSync10,
+  statSync as statSync11,
   symlinkSync,
   writeFileSync as writeFileSync11,
   copyFileSync as copyFileSync7
 } from "node:fs";
-import os21 from "node:os";
-import path65 from "node:path";
+import os22 from "node:os";
+import path66 from "node:path";
 function mutantsFor(source, file, lines) {
   const parsed = parseSource(source, file);
   const out = [];
@@ -103811,7 +103988,7 @@ function relatedTests(source, testFiles) {
     for (const match of text.matchAll(SPECIFIER)) {
       const spec = match[1];
       if (spec.startsWith(".")) {
-        if (stripExt(path65.posix.join(path65.posix.dirname(file), spec)) === target)
+        if (stripExt(path66.posix.join(path66.posix.dirname(file), spec)) === target)
           return true;
       } else if (spec.includes("/") && stripExt(spec).split("/").slice(-2).join("/") === tail)
         return true;
@@ -103819,11 +103996,11 @@ function relatedTests(source, testFiles) {
     return false;
   }).map((entry) => entry.file);
 }
-function removeStaleCopies(tmp = os21.tmpdir()) {
+function removeStaleCopies(tmp = os22.tmpdir()) {
   let removed = 0;
   let names = [];
   try {
-    names = readdirSync11(tmp);
+    names = readdirSync12(tmp);
   } catch {
     return 0;
   }
@@ -103831,12 +104008,12 @@ function removeStaleCopies(tmp = os21.tmpdir()) {
   for (const name of names) {
     if (!name.startsWith(TEMP_PREFIX))
       continue;
-    const dir = path65.join(tmp, name);
+    const dir = path66.join(tmp, name);
     try {
       const stat = lstatSync8(dir);
       if (!stat.isDirectory() || uid !== undefined && stat.uid !== uid)
         continue;
-      const pid = Number(readFileSync26(path65.join(dir, PID_FILE), "utf8"));
+      const pid = Number(readFileSync27(path66.join(dir, PID_FILE), "utf8"));
       if (Number.isInteger(pid) && pid > 0 && alive(pid))
         continue;
     } catch (error) {
@@ -103852,9 +104029,9 @@ function removeStaleCopies(tmp = os21.tmpdir()) {
 }
 function linkNodeModules(origin, target, repo, copy) {
   mkdirSync11(target, { recursive: true });
-  for (const entry of readdirSync11(origin, { withFileTypes: true })) {
-    const from = path65.join(origin, entry.name);
-    const to = path65.join(target, entry.name);
+  for (const entry of readdirSync12(origin, { withFileTypes: true })) {
+    const from = path66.join(origin, entry.name);
+    const to = path66.join(target, entry.name);
     if (entry.name.startsWith("@") && entry.isDirectory()) {
       linkNodeModules(from, to, repo, copy);
       continue;
@@ -103870,9 +104047,9 @@ function linkNodeModules(origin, target, repo, copy) {
       } catch {
         continue;
       }
-      const relative = path65.relative(repo, real);
-      if (!relative.startsWith("..") && !path65.isAbsolute(relative) && !relative.split(path65.sep).includes("node_modules")) {
-        symlinkSync(path65.join(copy, relative), to, "junction");
+      const relative = path66.relative(repo, real);
+      if (!relative.startsWith("..") && !path66.isAbsolute(relative) && !relative.split(path66.sep).includes("node_modules")) {
+        symlinkSync(path66.join(copy, relative), to, "junction");
         continue;
       }
     }
@@ -103888,19 +104065,19 @@ function copySymlink(repo, tree, from, to) {
   }
   const realRepo = realpathSync10(repo);
   if (real && inside4(realRepo, real)) {
-    symlinkSync(path65.relative(path65.dirname(to), path65.join(tree, path65.relative(realRepo, real))), to);
+    symlinkSync(path66.relative(path66.dirname(to), path66.join(tree, path66.relative(realRepo, real))), to);
     return;
   }
-  if (real && statSync10(real).isFile())
+  if (real && statSync11(real).isFile())
     copyFileSync7(real, to);
   else
     symlinkSync(readlinkSync3(from), to);
 }
 function writeInside(copy, file, content) {
-  const target = path65.join(copy, file);
+  const target = path66.join(copy, file);
   try {
     const stat = lstatSync8(target);
-    if (!stat.isFile() || !inside4(realpathSync10(copy), realpathSync10(path65.dirname(target))))
+    if (!stat.isFile() || !inside4(realpathSync10(copy), realpathSync10(path66.dirname(target))))
       return false;
   } catch {
     return false;
@@ -103911,9 +104088,9 @@ function writeInside(copy, file, content) {
   return true;
 }
 function copyWorkingTree(repo) {
-  const dir = mkdtempSync4(path65.join(os21.tmpdir(), TEMP_PREFIX));
-  writeFileSync11(path65.join(dir, PID_FILE), String(process.pid));
-  const tree = path65.join(dir, "tree");
+  const dir = mkdtempSync4(path66.join(os22.tmpdir(), TEMP_PREFIX));
+  writeFileSync11(path66.join(dir, PID_FILE), String(process.pid));
+  const tree = path66.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();
@@ -103930,29 +104107,29 @@ function copyWorkingTree(repo) {
   for (const relative of listed) {
     if (!relative)
       continue;
-    const from = path65.join(repo, relative);
+    const from = path66.join(repo, relative);
     let stat;
     try {
       stat = lstatSync8(from);
     } catch {
       continue;
     }
-    const to = path65.join(tree, relative);
-    mkdirSync11(path65.dirname(to), { recursive: true });
+    const to = path66.join(tree, relative);
+    mkdirSync11(path66.dirname(to), { recursive: true });
     if (stat.isSymbolicLink())
       copySymlink(repo, tree, from, to);
     else if (stat.isFile())
       copyFileSync7(from, to);
-    let parent = path65.dirname(relative);
+    let parent = path66.dirname(relative);
     while (parent !== "." && !dirs.has(parent)) {
       dirs.add(parent);
-      parent = path65.dirname(parent);
+      parent = path66.dirname(parent);
     }
   }
   for (const parent of dirs) {
-    const modules = path65.join(repo, parent, "node_modules");
-    if (existsSync23(modules) && !existsSync23(path65.join(tree, parent, "node_modules")))
-      linkNodeModules(modules, path65.join(tree, parent, "node_modules"), repo, tree);
+    const modules = path66.join(repo, parent, "node_modules");
+    if (existsSync24(modules) && !existsSync24(path66.join(tree, parent, "node_modules")))
+      linkNodeModules(modules, path66.join(tree, parent, "node_modules"), repo, tree);
   }
   return { dir, tree };
 }
@@ -103991,20 +104168,20 @@ async function runMutation(options) {
   const tracked = git7(repo, ["ls-files", "-co", "--exclude-standard", "-z"]).stdout.split("\x00").filter(Boolean);
   const testFiles = tracked.filter((file) => TEST_FILE.test(file)).map((file) => {
     try {
-      return { file, text: readFileSync26(path65.join(repo, file), "utf8") };
+      return { file, text: readFileSync27(path66.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(path65.relative(repo, absolute));
+    const relative = toPosix(path66.relative(repo, absolute));
     if (!CODE_FILE.test(relative) || TEST_FILE.test(relative) || relative.endsWith(".d.ts"))
       continue;
-    if (NOT_SOURCE.test(relative) || !existsSync23(absolute))
+    if (NOT_SOURCE.test(relative) || !existsSync24(absolute))
       continue;
     try {
-      candidates.push(...mutantsFor(readFileSync26(absolute, "utf8"), relative, lines));
+      candidates.push(...mutantsFor(readFileSync27(absolute, "utf8"), relative, lines));
     } catch {}
   }
   const mutants = candidates.map((mutant, index) => ({ ...mutant, id: index + 1 }));
@@ -104012,9 +104189,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 = path65.relative(repo, options.cwd);
+  const cwdRelative = path66.relative(repo, options.cwd);
   const asArg = (file) => {
-    const relative = toPosix(path65.relative(cwdRelative, file));
+    const relative = toPosix(path66.relative(cwdRelative, file));
     return shellQuote(relative.startsWith(".") ? relative : `./${relative}`);
   };
   const commandFor = (tests) => options.command.replaceAll("{files}", () => tests.map(asArg).join(" "));
@@ -104050,7 +104227,7 @@ async function runMutation(options) {
     return finish3(options, 0, results, counts, started);
   removeStaleCopies();
   const { dir: copyDir, tree: copy } = copyWorkingTree(repo);
-  const copyCwd = path65.join(copy, cwdRelative);
+  const copyCwd = path66.join(copy, cwdRelative);
   let current = null;
   const restore = () => {
     if (current)
@@ -104085,7 +104262,7 @@ async function runMutation(options) {
         record({ ...mutant, status: "skipped", durationMs: 0, tests, reason: "budget" });
         continue;
       }
-      const original = readFileSync26(path65.join(copy, mutant.file), "utf8");
+      const original = readFileSync27(path66.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)) {
@@ -104142,8 +104319,8 @@ var NOT_SOURCE, FLIPS, isStringy = (node) => node.type === "StringLiteral" || no
     return error.code === "EPERM";
   }
 }, inside4 = (root, file) => {
-  const relative = path65.relative(root, file);
-  return relative === "" || !relative.startsWith("..") && !path65.isAbsolute(relative);
+  const relative = path66.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path66.isAbsolute(relative);
 }, active, killTree = (child) => {
   try {
     if (child.pid && process.platform !== "win32")
@@ -104191,8 +104368,8 @@ var exports_test_audit = {};
 __export(exports_test_audit, {
   run: () => run22
 });
-import { existsSync as existsSync24 } from "node:fs";
-import path66 from "node:path";
+import { existsSync as existsSync25 } from "node:fs";
+import path67 from "node:path";
 function parse8(argv) {
   const options = {
     paths: [],
@@ -104297,8 +104474,8 @@ async function run22(argv, io) {
     return emit(io, fail2("invalid_input", `${options}
 usage: ${USAGE14}`));
   const top = git7(io.cwd, ["rev-parse", "--show-toplevel"]);
-  const repo = top.ok ? path66.resolve(top.stdout.trim()) : null;
-  const display = (file) => toPosix(path66.relative(io.cwd, file) || file);
+  const repo = top.ok ? path67.resolve(top.stdout.trim()) : null;
+  const display = (file) => toPosix(path67.relative(io.cwd, file) || file);
   let base = null;
   let changed = null;
   if (options.diff || options.mutate) {
@@ -104315,7 +104492,7 @@ usage: ${USAGE14}`));
   }
   let files;
   if (options.diff && changed)
-    files = [...changed.keys()].filter((file) => TEST_FILE.test(toPosix(file)) && existsSync24(file)).toSorted();
+    files = [...changed.keys()].filter((file) => TEST_FILE.test(toPosix(file)) && existsSync25(file)).toSorted();
   else {
     const expanded = expandPaths(io.cwd, options.paths);
     if (expanded.missing.length > 0)
@@ -104436,8 +104613,8 @@ var exports_youtrack = {};
 __export(exports_youtrack, {
   run: () => run24
 });
-import { readFileSync as readFileSync27 } from "node:fs";
-import path67 from "node:path";
+import { readFileSync as readFileSync28 } from "node:fs";
+import path68 from "node:path";
 async function run24(argv, io) {
   const [sub, ...rest] = argv;
   if (sub !== "note" && sub !== "time" && sub !== "meeting")
@@ -104483,7 +104660,7 @@ async function run24(argv, io) {
     let markdown = flags.values.markdown ?? "";
     if (flags.values.file)
       try {
-        markdown = readFileSync27(path67.resolve(io.cwd, flags.values.file), "utf8");
+        markdown = readFileSync28(path68.resolve(io.cwd, flags.values.file), "utf8");
       } catch (error) {
         return usage3(io, `cannot read ${flags.values.file}: ${String(error)}`, USAGE16);
       }
@@ -104551,8 +104728,8 @@ var exports_changelog = {};
 __export(exports_changelog, {
   run: () => run25
 });
-import { readFileSync as readFileSync28 } from "node:fs";
-import path68 from "node:path";
+import { readFileSync as readFileSync29 } from "node:fs";
+import path69 from "node:path";
 async function run25(argv, io) {
   const [sub, ...rest] = argv;
   if (sub !== "apply")
@@ -104598,7 +104775,7 @@ async function run25(argv, io) {
   ]);
 }
 var USAGE17 = "workit changelog apply (--entries <JSON|@file|-> | --normalize-only) [--path CHANGELOG.md] [--preview]", readEntries = (raw, cwd) => {
-  const text = raw === "-" ? readFileSync28(0, "utf8") : raw.startsWith("@") ? readFileSync28(path68.resolve(cwd, raw.slice(1)), "utf8") : raw;
+  const text = raw === "-" ? readFileSync29(0, "utf8") : raw.startsWith("@") ? readFileSync29(path69.resolve(cwd, raw.slice(1)), "utf8") : raw;
   return JSON.parse(text);
 };
 var init_changelog2 = __esm(() => {
@@ -104695,7 +104872,7 @@ var init_handoff = __esm(() => {
 // packages/workit-cli/src/main.ts
 init_host_session();
 init_package();
-import path69 from "node:path";
+import path70 from "node:path";
 
 // packages/workit-cli/src/verbs/registry.ts
 var TASK_FAMILY_NAMES = [
@@ -104940,7 +105117,7 @@ var VERBS = [
     subcommands: [
       {
         name: "show",
-        usage: "workit models show [--role <role>] [--tier <mundane|standard|hard>] [--host <host>] [--json]",
+        usage: "workit models show [--role <role>] [--tier <mundane|standard|hard>] [--host <host>] [--report [--days <n>]] [--json]",
         summary: "Print the resolved model and effort per role for a host (default: the lead's host, else claude_code) and where each came from"
       }
     ],
@@ -105557,7 +105734,7 @@ var defaultIo = (json) => ({
 });
 async function main(argv, overrides = {}, options = {}) {
   const parsed = parseGlobals(argv);
-  const cwd = path69.resolve(overrides.cwd ?? process.cwd(), parsed.cwd ?? ".");
+  const cwd = path70.resolve(overrides.cwd ?? process.cwd(), parsed.cwd ?? ".");
   const io = { ...defaultIo(parsed.json), ...overrides, json: parsed.json, cwd };
   if (parsed.error)
     return emit(io, fail2("invalid_input", parsed.error));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brainervirus/workit-cli",
-  "version": "8.27.0",
+  "version": "8.28.1",
   "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.27.0",
+    "@brainervirus/workit-cursor": "^8.28.1",
     "@inkjs/ui": "2.0.0",
     "ink": "7.1.1",
     "react": "19.2.8"
   },
   "devDependencies": {
-    "@brainervirus/workit-core": "^8.27.0"
+    "@brainervirus/workit-core": "^8.28.1"
   },
   "engines": {
     "node": ">=24"