@brainervirus/workit-cli 8.20.0 → 8.21.0

package/dist/index.js

@@ -65,7 +65,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@brainervirus/workit-cli",
-    version: "8.20.0",
+    version: "8.21.0",
     private: false,
     description: "Workit CLI — setup wizard, doctor, and task control for agentic coding workflows",
     keywords: [
@@ -103,13 +103,13 @@ var init_package = __esm(() => {
     },
     dependencies: {
       "@babel/parser": "7.29.9",
-      "@brainervirus/workit-cursor": "^8.20.0",
+      "@brainervirus/workit-cursor": "^8.21.0",
       "@inkjs/ui": "2.0.0",
       ink: "7.1.1",
       react: "19.2.8"
     },
     devDependencies: {
-      "@brainervirus/workit-core": "^8.20.0"
+      "@brainervirus/workit-core": "^8.21.0"
     },
     engines: {
       node: ">=24"
@@ -15262,11 +15262,23 @@ var init_workers = __esm(() => {
   UNCERTAIN_WORKER_STATES = ["dispatching", "running", "cancelling", "unknown"];
 });
 
+// packages/workit-core/src/hooks/standing-signal.ts
+import fs12 from "node:fs";
+import path16 from "node:path";
+var standingRevFile = (store) => path16.join(store, "standing", "rev"), bumpStandingRev = (store, rev) => {
+  try {
+    fs12.mkdirSync(path16.join(store, "standing"), { recursive: true });
+    fs12.writeFileSync(standingRevFile(store), `${rev}
+`);
+  } catch {}
+};
+var init_standing_signal = () => {};
+
 // packages/workit-core/src/ledger.ts
 import { spawnSync as spawnSync9 } from "node:child_process";
 import { createHash as createHash10, randomBytes as randomBytes3 } from "node:crypto";
-import fs12 from "node:fs";
-import path16 from "node:path";
+import fs13 from "node:fs";
+import path17 from "node:path";
 function resolveCommit(cwd, ref) {
   if (!safeRef(ref))
     return null;
@@ -15332,14 +15344,14 @@ function diffHash(cwd, base, head) {
   return `sha256:${hash.digest("hex")}`;
 }
 function storeRoot(cwd) {
-  const location = resolveStore(path16.resolve(cwd));
+  const location = resolveStore(path17.resolve(cwd));
   if (location instanceof Error)
     return err("unavailable", location.message.replace(/; fix the repository.*$/u, ""), "fix the repository (git status should work here) or run from a non-git directory");
   return { ok: true, value: { root: location.dir, shared: location.shared } };
 }
 function ledgerPath(cwd) {
   const root = storeRoot(cwd);
-  return root.ok ? { ok: true, value: path16.join(root.value.root, "ledger", "ledger.jsonl") } : root;
+  return root.ok ? { ok: true, value: path17.join(root.value.root, "ledger", "ledger.jsonl") } : root;
 }
 function actorFromEnv(env) {
   const value = (key) => {
@@ -15377,15 +15389,15 @@ function withLedgerLock(file, fn, waitMs = hostAwareLockTimeout(LOCK_WAIT_MS)) {
 }
 function appendLine(file, build, options) {
   const write = () => {
-    const fd = fs12.openSync(file, "a+", 384);
+    const fd = fs13.openSync(file, "a+", 384);
     try {
       if (process.platform !== "win32")
         tighten(fd);
-      const size = fs12.fstatSync(fd).size;
+      const size = fs13.fstatSync(fd).size;
       let fence = "";
       if (size > 0) {
         const last = Buffer.alloc(1);
-        fs12.readSync(fd, last, 0, 1, size - 1);
+        fs13.readSync(fd, last, 0, 1, size - 1);
         if (last[0] !== 10)
           fence = `
 `;
@@ -15394,17 +15406,17 @@ function appendLine(file, build, options) {
       if (!line.ok)
         return line;
       const bytes = Buffer.from(fence + line.value);
-      const written = fs12.writeSync(fd, bytes);
+      const written = fs13.writeSync(fd, bytes);
       if (written !== bytes.length)
         return err("unavailable", `short write to ${file}: ${written} of ${bytes.length} bytes; the row is torn and will be skipped`);
       return { ok: true, value: undefined };
     } finally {
-      fs12.closeSync(fd);
+      fs13.closeSync(fd);
     }
   };
   try {
-    fs12.mkdirSync(path16.dirname(file), { recursive: true });
-    if (!options.forceLock && !onNetworkFs(path16.dirname(file)))
+    fs13.mkdirSync(path17.dirname(file), { recursive: true });
+    if (!options.forceLock && !onNetworkFs(path17.dirname(file)))
       return write();
     const locked = withLedgerLock(file, write);
     return locked ?? err("busy", `ledger lock ${file}.lock is held`, "retry; remove the .lock directory if no workit process is running");
@@ -15461,8 +15473,8 @@ function readLedger(cwd, options = {}) {
   let text = "";
   let stat = null;
   try {
-    stat = fs12.statSync(file.value);
-    text = fs12.readFileSync(file.value, "utf8");
+    stat = fs13.statSync(file.value);
+    text = fs13.readFileSync(file.value, "utf8");
   } catch (error) {
     if (error.code === "ENOENT")
       return {
@@ -15594,7 +15606,7 @@ function ledgerTampering(cwd) {
   if (!file.ok)
     return [];
   try {
-    const stat = fs12.statSync(file.value);
+    const stat = fs13.statSync(file.value);
     const cached = tamperCache.get(file.value);
     if (cached && cached.size === stat.size && cached.stamp === fileStamp(stat))
       return cached.breaks;
@@ -16011,8 +16023,14 @@ function leadOnly(context, lead) {
     return { ok: true, value: undefined };
   return err("blocked", lead !== null ? `session ${session ?? "(none)"} is not the fanout's lead (${lead}): standing orders come from the lead` : `session ${session} is a worker or verifier: standing orders come from the lead`, lead !== null ? `the lead in a new session? workit fanout plan <plan.json> --take-lead from this session; a worker or verifier reports the order to the lead instead` : "a worker or verifier reports the order to the lead instead");
 }
+function signalStanding(cwd, result) {
+  const root = result.ok ? storeRoot(cwd) : null;
+  if (result.ok && root?.ok && root.value.shared)
+    bumpStandingRev(root.value.root, result.value.id);
+  return result;
+}
 function recordStanding(context, input) {
-  const what = required2(input.what, "<order>");
+  const what = input.stop ? { ok: true, value: stopOrderText(input.what?.trim() || null) } : required2(input.what, "<order>");
   if (!what.ok)
     return what;
   if (/\p{Cc}/u.test(what.value))
@@ -16023,12 +16041,14 @@ function recordStanding(context, input) {
   const link = checkSupersede(context, "standing");
   if (!link.ok)
     return link;
-  return appendRow(context.cwd, {
+  const recorded = appendRow(context.cwd, {
     ...common(context, noteKey(context)),
     type: "standing",
     fanout: input.fanout,
-    what: what.value
+    what: what.value,
+    ...input.stop ? { stop: true } : {}
   }, { now: context.now });
+  return signalStanding(context.cwd, recorded);
 }
 function clearStanding(context, input) {
   const lead = leadOnly(context, input.lead);
@@ -16041,12 +16061,31 @@ function clearStanding(context, input) {
     if (!activeStanding(ledger.value.rows, input.fanout, input.leads ?? null).some((row) => row.id === input.target))
       return err("not_found", `no standing order ${input.target} in force for fanout ${input.fanout}`, `workit ledger standing list --fanout ${input.fanout}`);
   }
-  return appendRow(context.cwd, {
+  return signalStanding(context.cwd, appendRow(context.cwd, {
     ...common(context, noteKey(context)),
     type: "standing.cleared",
     fanout: input.fanout,
     target: input.target
-  }, { now: context.now });
+  }, { now: context.now }));
+}
+function liftStop(context, input) {
+  const lead = leadOnly(context, input.lead);
+  if (!lead.ok)
+    return lead;
+  const ledger = readLedger(context.cwd);
+  if (!ledger.ok)
+    return ledger;
+  const stops = activeStanding(ledger.value.rows, input.fanout, input.leads ?? null).filter((row) => row.stop === true);
+  if (!stops.length)
+    return err("not_found", `no stop line in force for fanout ${input.fanout}`, `workit ledger standing list --fanout ${input.fanout}`);
+  const cleared = [];
+  for (const stop of stops) {
+    const row = clearStanding(context, { ...input, target: stop.id });
+    if (!row.ok)
+      return row;
+    cleared.push(row.value);
+  }
+  return { ok: true, value: cleared };
 }
 function dirtyElsewhere(cwd, branch, head) {
   if (headSha(cwd) === head)
@@ -16202,17 +16241,17 @@ function summarizeRow(row) {
   };
 }
 function stackPosition(root, branch) {
-  const dir = path16.join(root, "stacks");
+  const dir = path17.join(root, "stacks");
   let names = [];
   try {
-    names = fs12.readdirSync(dir).filter((name) => name.endsWith(".json"));
+    names = fs13.readdirSync(dir).filter((name) => name.endsWith(".json"));
   } catch {
     return null;
   }
   for (const name of names.toSorted()) {
     let parsed;
     try {
-      parsed = JSON.parse(fs12.readFileSync(path16.join(dir, name), "utf8"));
+      parsed = JSON.parse(fs13.readFileSync(path17.join(dir, name), "utf8"));
     } catch {
       continue;
     }
@@ -16351,20 +16390,20 @@ var LEDGER_VERSION = 1, MAX_LINE_BYTES = 4096, VERDICT_RESULTS, PASSING, FAILING
   if (process.platform !== "linux")
     return false;
   try {
-    return isNetworkFsType(fs12.statfsSync(dir).type);
+    return isNetworkFsType(fs13.statfsSync(dir).type);
   } catch {
     return false;
   }
 }, LOCK_WAIT_MS = 5000, LOCK_STALE_MS = 30000, LOCK_OWNER = "owner", lockToken = (lock) => {
   try {
-    return fs12.readFileSync(path16.join(lock, LOCK_OWNER), "utf8");
+    return fs13.readFileSync(path17.join(lock, LOCK_OWNER), "utf8");
   } catch {
     return null;
   }
 }, lockAgeMs = (lock) => {
-  for (const target of [path16.join(lock, LOCK_OWNER), lock]) {
+  for (const target of [path17.join(lock, LOCK_OWNER), lock]) {
     try {
-      return Date.now() - fs12.statSync(target).mtimeMs;
+      return Date.now() - fs13.statSync(target).mtimeMs;
     } catch {}
   }
   return null;
@@ -16372,7 +16411,7 @@ var LEDGER_VERSION = 1, MAX_LINE_BYTES = 4096, VERDICT_RESULTS, PASSING, FAILING
 ${body}`), TAIL_BYTES, lastLine = (fd, size) => {
   for (let span = Math.min(size, TAIL_BYTES);span > 0; span = Math.min(size, span * 2)) {
     const buffer = Buffer.alloc(span);
-    fs12.readSync(fd, buffer, 0, span, size - span);
+    fs13.readSync(fd, buffer, 0, span, size - span);
     const end = buffer.lastIndexOf(10);
     if (end < 0) {
       if (span === size)
@@ -16402,8 +16441,8 @@ ${body}`), TAIL_BYTES, lastLine = (fd, size) => {
   return null;
 }, tighten = (fd) => {
   try {
-    if ((fs12.fstatSync(fd).mode & 63) !== 0)
-      fs12.fchmodSync(fd, 384);
+    if ((fs13.fstatSync(fd).mode & 63) !== 0)
+      fs13.fchmodSync(fd, 384);
   } catch {}
 }, sealed = (row, id, at, previous) => {
   const { prevHash: _prev, rowHash: _row, ...fields } = row;
@@ -16465,7 +16504,7 @@ ${body}`), TAIL_BYTES, lastLine = (fd, size) => {
 }, required2 = (value, flag) => {
   const text = value?.trim();
   return text ? { ok: true, value: text } : err("invalid_input", `${flag} is required`);
-}, fromLead = (row, leads) => leads === null || row.actor.session !== null && leads.includes(row.actor.session), isDelegateSession = (session) => session !== null && (/-w-[a-z0-9._-]+(?:\+try\d)?$/u.test(session) || /-v\d+$/u.test(session) || session.includes(":")), OBSERVED_ONLY, MAX_DIRTY_PATHS = 10, dirtyState = (cwd) => {
+}, fromLead = (row, leads) => leads === null || row.actor.session !== null && leads.includes(row.actor.session), isDelegateSession = (session) => session !== null && (/-w-[a-z0-9._-]+(?:\+try\d)?$/u.test(session) || /-v\d+$/u.test(session) || session.includes(":")), stopOrderText = (note) => `STOP: start nothing new, stop every process you started (dev servers, browsers, watchers), commit only finished work, and report to the lead now${note ? ` (${note})` : ""}`, OBSERVED_ONLY, MAX_DIRTY_PATHS = 10, dirtyState = (cwd) => {
   const run = gitRun2(cwd, ["status", "--porcelain=v1", "-z", "--untracked-files=normal"], GIT_TIMEOUTS.worktree);
   if (!run.ok)
     return { dirty: false, files: 0, paths: [] };
@@ -16502,6 +16541,7 @@ var init_ledger = __esm(() => {
   init_vcs_config();
   init_rev();
   init_host_session();
+  init_standing_signal();
   init_paths();
   VERDICT_RESULTS = [
     "verified",
@@ -16536,14 +16576,14 @@ var init_ledger = __esm(() => {
   ledgerLock = {
     acquire(lock) {
       try {
-        fs12.mkdirSync(lock);
+        fs13.mkdirSync(lock);
       } catch (error) {
         if (error.code === "EEXIST")
           return null;
         throw error;
       }
       const token = `${process.pid}-${randomBytes3(8).toString("hex")}`;
-      fs12.writeFileSync(path16.join(lock, LOCK_OWNER), token);
+      fs13.writeFileSync(path17.join(lock, LOCK_OWNER), token);
       return token;
     },
     release(lock, token) {
@@ -16551,35 +16591,35 @@ var init_ledger = __esm(() => {
         return false;
       const tomb = `${lock}.release-${randomBytes3(6).toString("hex")}`;
       try {
-        fs12.renameSync(lock, tomb);
+        fs13.renameSync(lock, tomb);
       } catch {
         return false;
       }
       if (lockToken(tomb) !== token) {
         try {
-          fs12.renameSync(tomb, lock);
+          fs13.renameSync(tomb, lock);
         } catch {}
         return false;
       }
-      fs12.rmSync(tomb, { recursive: true, force: true });
+      fs13.rmSync(tomb, { recursive: true, force: true });
       return true;
     },
     token: lockToken,
     reap(lock, observed) {
       const tomb = `${lock}.reap-${randomBytes3(6).toString("hex")}`;
       try {
-        fs12.renameSync(lock, tomb);
+        fs13.renameSync(lock, tomb);
       } catch {
         return false;
       }
       if (lockToken(tomb) === observed) {
-        fs12.rmSync(tomb, { recursive: true, force: true });
+        fs13.rmSync(tomb, { recursive: true, force: true });
         return true;
       }
       try {
-        fs12.renameSync(tomb, lock);
+        fs13.renameSync(tomb, lock);
       } catch {
-        fs12.rmSync(tomb, { recursive: true, force: true });
+        fs13.rmSync(tomb, { recursive: true, force: true });
       }
       return false;
     }
@@ -16613,7 +16653,7 @@ var init_ledger = __esm(() => {
 
 // packages/workit-core/src/core/policy/derive.ts
 import { existsSync as existsSync4 } from "node:fs";
-import path17 from "node:path";
+import path18 from "node:path";
 function deriveRequirements(judgment, scope, constraints, verification = "self") {
   const out = [];
   const base = { scope, dependentAction: null };
@@ -16754,7 +16794,7 @@ var RULES, derived2 = (spec) => ({
     decisionIds: []
   };
 }, planRecorded = (task, root) => {
-  const cited = (latestJudgment(task)?.refs ?? []).find((ref) => ref.kind === "external" || ref.kind === "file" && existsSync4(path17.resolve(root, ref.path)));
+  const cited = (latestJudgment(task)?.refs ?? []).find((ref) => ref.kind === "external" || ref.kind === "file" && existsSync4(path18.resolve(root, ref.path)));
   if (cited)
     return {
       met: true,
@@ -16801,13 +16841,13 @@ var init_derive = __esm(() => {
 
 // packages/workit-core/src/core/task-evaluation.ts
 import { createHash as createHash11 } from "node:crypto";
-import * as fs13 from "node:fs";
+import * as fs14 from "node:fs";
 import { spawnSync as spawnSync10 } from "node:child_process";
-import path18 from "node:path";
+import path19 from "node:path";
 function captureCandidate(root, scope, environment = []) {
   let checkout;
   try {
-    checkout = fs13.realpathSync(root);
+    checkout = fs14.realpathSync(root);
   } catch {
     return failure2("invalid_input", "candidate root does not exist");
   }
@@ -16825,11 +16865,11 @@ function captureCandidate(root, scope, environment = []) {
     if (item === ".git" || item === ".workit")
       continue;
     names.add(item);
-    if (!fs13.existsSync(target))
+    if (!fs14.existsSync(target))
       continue;
     let stat;
     try {
-      stat = fs13.lstatSync(target);
+      stat = fs14.lstatSync(target);
     } catch {
       uncertain = true;
       continue;
@@ -16845,17 +16885,17 @@ function captureCandidate(root, scope, environment = []) {
   for (const item of [...names].toSorted()) {
     if (!scopeMatches(item, normalizedScope))
       continue;
-    const target = path18.join(checkout, item);
+    const target = path19.join(checkout, item);
     try {
-      const stat = fs13.lstatSync(target);
+      const stat = fs14.lstatSync(target);
       if (stat.isSymbolicLink()) {
-        const link = fs13.readlinkSync(target);
+        const link = fs14.readlinkSync(target);
         files.push({ path: item, kind: "symlink", digest: digestBytes(link), executable: null });
       } else if (stat.isFile()) {
         files.push({
           path: item,
           kind: "file",
-          digest: digestBytes(fs13.readFileSync(target)),
+          digest: digestBytes(fs14.readFileSync(target)),
           executable: (stat.mode & 73) !== 0
         });
       } else if (!stat.isDirectory()) {
@@ -17254,12 +17294,12 @@ function boundTaskSummary(summary) {
   brief.truncated = JSON.stringify(brief).includes("…") || progress.blockers.length > BRIEF_BLOCKERS || unmet.length > BRIEF_OPEN;
   return brief;
 }
-var digestBytes = (value) => createHash11("sha256").update(value).digest("hex"), inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path18.sep}`), relative = (root, candidate) => path18.relative(root, candidate).split(path18.sep).join("/") || ".", canonicalPath = (value) => {
+var digestBytes = (value) => createHash11("sha256").update(value).digest("hex"), inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path19.sep}`), relative = (root, candidate) => path19.relative(root, candidate).split(path19.sep).join("/") || ".", canonicalPath = (value) => {
   if (typeof value !== "string" || !value)
     return null;
   if (value.includes("\\") || value.split("/").includes(".."))
     return null;
-  const normalized = path18.posix.normalize(value);
+  const normalized = path19.posix.normalize(value);
   if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
     return null;
   return normalized === "." ? "." : normalized.replace(/\/$/, "");
@@ -17301,20 +17341,20 @@ var digestBytes = (value) => createHash11("sha256").update(value).digest("hex"),
       git: !/not a git repository/i.test(stderr)
     };
   }
-  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path18.sep).join("/")) : [];
+  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path19.sep).join("/")) : [];
   const stagedDeleted = spawnSync10("git", ["diff", "--cached", "--name-only", "--diff-filter=D", "-z"], { cwd: root, encoding: "buffer" });
   if (stagedDeleted.status !== 0) {
     const stderr = stagedDeleted.stderr?.toString("utf8") ?? "";
     if (!/not a git repository/i.test(stderr))
       return { paths, uncertain: true, git: true };
   } else if (stagedDeleted.stdout) {
-    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path18.sep).join("/")));
+    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path19.sep).join("/")));
   }
   return { paths: [...new Set(paths)], uncertain: false, git: true };
 }, walk = (root, directory, output) => {
   let names;
   try {
-    names = fs13.readdirSync(directory);
+    names = fs14.readdirSync(directory);
   } catch {
     return true;
   }
@@ -17322,10 +17362,10 @@ var digestBytes = (value) => createHash11("sha256").update(value).digest("hex"),
   for (const name of names) {
     if (name === ".git" || name === ".workit")
       continue;
-    const target = path18.join(directory, name);
+    const target = path19.join(directory, name);
     let stat;
     try {
-      stat = fs13.lstatSync(target);
+      stat = fs14.lstatSync(target);
     } catch {
       uncertain = true;
       continue;
@@ -17339,14 +17379,14 @@ var digestBytes = (value) => createHash11("sha256").update(value).digest("hex"),
 }, scopeRoots = (root, scope) => {
   const roots = [];
   for (const item of scope.paths.length ? scope.paths : ["."]) {
-    const target = path18.resolve(root, item);
+    const target = path19.resolve(root, item);
     if (!inside(root, target))
       return failure2("invalid_input", `candidate scope escapes checkout: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} is outside the checkout` }] });
     let ancestor = target;
-    while (!fs13.existsSync(ancestor) && ancestor !== root)
-      ancestor = path18.dirname(ancestor);
+    while (!fs14.existsSync(ancestor) && ancestor !== root)
+      ancestor = path19.dirname(ancestor);
     try {
-      if (!inside(root, fs13.realpathSync(ancestor)))
+      if (!inside(root, fs14.realpathSync(ancestor)))
         return failure2("invalid_input", `candidate scope escapes checkout through a symlink: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} resolves outside the checkout` }] });
     } catch {
       return failure2("invalid_input", `candidate scope cannot be inspected: ${item}`);
@@ -17399,7 +17439,7 @@ var digestBytes = (value) => createHash11("sha256").update(value).digest("hex"),
 }, findingVerificationPasses = (findingCandidateId, evidence) => evidence.status === "passed" && (evidence.kind === "check" || evidence.kind === "review") && ((findingCandidateId ?? null) === null || evidence.candidateId != null), verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
   let root;
   try {
-    root = fs13.realpathSync(checkoutRoot);
+    root = fs14.realpathSync(checkoutRoot);
   } catch {
     return failure2("permission_denied", "checkout root is unavailable");
   }
@@ -17408,23 +17448,23 @@ var digestBytes = (value) => createHash11("sha256").update(value).digest("hex"),
       continue;
     if (!reference.digest)
       return failure2("invalid_input", "document references require a byte digest");
-    const target = path18.resolve(root, reference.path);
-    if (target !== root && !target.startsWith(`${root}${path18.sep}`))
+    const target = path19.resolve(root, reference.path);
+    if (target !== root && !target.startsWith(`${root}${path19.sep}`))
       return failure2("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
         fields: [
           { path: "contentRefs.path", reason: `${reference.path} is outside the checkout` }
         ]
       });
     try {
-      const below = path18.relative(root, target);
+      const below = path19.relative(root, target);
       let current = root;
-      for (const segment of below.split(path18.sep)) {
+      for (const segment of below.split(path19.sep)) {
         if (!segment)
           continue;
-        current = path18.join(current, segment);
-        const stat = fs13.lstatSync(current);
-        const real = fs13.realpathSync(current);
-        if (real !== root && !real.startsWith(`${root}${path18.sep}`))
+        current = path19.join(current, segment);
+        const stat = fs14.lstatSync(current);
+        const real = fs14.realpathSync(current);
+        if (real !== root && !real.startsWith(`${root}${path19.sep}`))
           return failure2("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
             fields: [
               {
@@ -17440,7 +17480,7 @@ var digestBytes = (value) => createHash11("sha256").update(value).digest("hex"),
         if (current !== target && !stat.isDirectory())
           return failure2("invalid_input", "document reference ancestor is not a directory");
       }
-      if (digestBytes(fs13.readFileSync(target)) !== reference.digest)
+      if (digestBytes(fs14.readFileSync(target)) !== reference.digest)
         return failure2("permission_denied", "decision document bytes have changed");
     } catch {
       return failure2("invalid_input", "decision document is unavailable");
@@ -18089,7 +18129,7 @@ var init_shell_words = __esm(() => {
 
 // packages/workit-core/src/hooks/raw-git.ts
 import os4 from "node:os";
-import path19 from "node:path";
+import path20 from "node:path";
 function rawInvocations(command, dialect = "posix", depth = 0) {
   if (depth > 0)
     return walk2(command, dialect, depth);
@@ -18271,12 +18311,12 @@ function simpleCommand(command, dialect = "posix", depth = 0) {
     return null;
   return words;
 }
-var SHELLS, POWERSHELLS, EVALS, WRAPPERS, WRAPPER_VALUES, KEYWORDS, DECLARATIONS, SCRIPT_FLAG, CD, PUSHD, POPD, GIT_VALUE_OPTIONS, GIT_CONFIG_OPTIONS, GIT_CONFIG_ENV, ASSIGNMENT, MAX_DEPTH = 4, MAX_EXPANSIONS = 16, isAbsolute = (value) => path19.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\"), HERE, joinDir = (base, raw) => {
+var SHELLS, POWERSHELLS, EVALS, WRAPPERS, WRAPPER_VALUES, KEYWORDS, DECLARATIONS, SCRIPT_FLAG, CD, PUSHD, POPD, GIT_VALUE_OPTIONS, GIT_CONFIG_OPTIONS, GIT_CONFIG_ENV, ASSIGNMENT, MAX_DEPTH = 4, MAX_EXPANSIONS = 16, isAbsolute = (value) => path20.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\"), HERE, joinDir = (base, raw) => {
   const next = raw.replace(HERE, ".");
   if (base === undefined || /[$`*?]/.test(next) || next === "-")
     return;
-  const expanded = next === "~" || next.startsWith("~/") ? path19.join(os4.homedir(), next.slice(1)) : next;
-  return base === null || isAbsolute(expanded) ? expanded : path19.join(base, expanded);
+  const expanded = next === "~" || next.startsWith("~/") ? path20.join(os4.homedir(), next.slice(1)) : next;
+  return base === null || isAbsolute(expanded) ? expanded : path20.join(base, expanded);
 }, rebase = (base, inner) => inner === null ? base : inner === undefined ? undefined : joinDir(base, inner), cdTarget = (words) => {
   const args = words.slice(1);
   const flag = args.findIndex((word) => /^-(?:literal)?path$/i.test(word));
@@ -18795,7 +18835,7 @@ import {
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync3
 } from "node:fs";
-import path20 from "node:path";
+import path21 from "node:path";
 function writeFileExclusive(file, content, mode) {
   try {
     writeFileSync3(file, content, { encoding: "utf8", flag: "wx", mode });
@@ -18807,9 +18847,9 @@ function writeFileExclusive(file, content, mode) {
   }
 }
 function writeFileAtomic(file, content, mode) {
-  const absolute = path20.resolve(file);
-  let parent = path20.dirname(absolute);
-  const root = path20.parse(parent).root;
+  const absolute = path21.resolve(file);
+  let parent = path21.dirname(absolute);
+  const root = path21.parse(parent).root;
   for (;; ) {
     try {
       if (lstatSync3(parent).isSymbolicLink())
@@ -18818,12 +18858,12 @@ function writeFileAtomic(file, content, mode) {
       if (error.code !== "ENOENT")
         throw error;
     }
-    const next = path20.dirname(parent);
+    const next = path21.dirname(parent);
     if (parent === root || next === parent)
       break;
     parent = next;
   }
-  const directory = path20.dirname(absolute);
+  const directory = path21.dirname(absolute);
   mkdirSync4(directory, { recursive: true });
   let existing = null;
   try {
@@ -18863,7 +18903,7 @@ var init_safe_write = () => {};
 // packages/workit-core/src/autonomy.ts
 import { copyFileSync as copyFileSync3, existsSync as existsSync6 } from "node:fs";
 import os5 from "node:os";
-import path21 from "node:path";
+import path22 from "node:path";
 function endpointOf(entry) {
   const raw = entry?.defaultEndpoint;
   if (raw === undefined)
@@ -19106,9 +19146,9 @@ var accountHome = () => {
   } catch {
     return os5.homedir();
   }
-}, grantsHome, grantsDir = () => path21.join(grantsHome.resolve(), ".config", "workit"), grantsOverride = () => {
-  const configured = path21.resolve(resolveConfigDir());
-  return configured === path21.resolve(grantsDir()) ? null : `the config directory is redirected to ${configured} (WORKFLOW_TOOLKIT_CONFIG, WORKFLOW_TOOLKIT_CONFIG_DIR or XDG_CONFIG_HOME); grants are read only from ${path21.join(grantsDir(), "workspaces.json")}, so the D4 defaults apply`;
+}, grantsHome, grantsDir = () => path22.join(grantsHome.resolve(), ".config", "workit"), grantsOverride = () => {
+  const configured = path22.resolve(resolveConfigDir());
+  return configured === path22.resolve(grantsDir()) ? null : `the config directory is redirected to ${configured} (WORKFLOW_TOOLKIT_CONFIG, WORKFLOW_TOOLKIT_CONFIG_DIR or XDG_CONFIG_HOME); grants are read only from ${path22.join(grantsDir(), "workspaces.json")}, so the D4 defaults apply`;
 }, GRANT_KINDS, DEFAULT_GRANTS, DEFAULT_ENDPOINTS, DEFAULT_ENDPOINT = "commit", isDefaultEndpoint = (value) => typeof value === "string" && DEFAULT_ENDPOINTS.includes(value), raisesEndpoint = (current, next) => DEFAULT_ENDPOINTS.indexOf(next) > DEFAULT_ENDPOINTS.indexOf(current), DEFAULT_VERIFICATION = "self", verificationOf = (entry) => entry?.verification === "independent" ? "independent" : "self", isGrantKind = (value) => typeof value === "string" && GRANT_KINDS.includes(value), isGrantValue = (value) => value === true || value === false || value === "verified", normalized = (kind, value) => value === "verified" && kind !== "merge" ? true : value, fromAutoApprove = (value) => {
   if (value === true)
     return { push: true, pr: true, merge: "verified" };
@@ -20842,12 +20882,12 @@ var init_pr_body = __esm(() => {
 });
 
 // packages/workit-core/src/core/pr-create.ts
-import path22 from "node:path";
+import path23 from "node:path";
 import { spawnSync as spawnSync11 } from "node:child_process";
 import { pathToFileURL } from "node:url";
 var safePushUrl = (remote) => {
   const raw = remote.trim();
-  if (path22.isAbsolute(raw))
+  if (path23.isAbsolute(raw))
     return pathToFileURL(raw).href;
   if (!raw.includes("://")) {
     const scp = /^(?:([^@\s]+)@)?([^:]+):(.+)$/u.exec(raw);
@@ -20907,16 +20947,16 @@ var init_scripts = __esm(() => {
 });
 
 // packages/workit-core/src/core/youtrack.ts
-import fs14 from "node:fs";
-import path23 from "node:path";
+import fs15 from "node:fs";
+import path24 from "node:path";
 function readYouTrackConfig(required) {
   const cfgPath = youTrackConfigPath();
-  if (!fs14.existsSync(cfgPath)) {
+  if (!fs15.existsSync(cfgPath)) {
     return required ? { error: "ERROR: missing youtrack.json", path: cfgPath } : { config: {}, path: cfgPath };
   }
   let parsed;
   try {
-    parsed = JSON.parse(fs14.readFileSync(cfgPath, "utf8"));
+    parsed = JSON.parse(fs15.readFileSync(cfgPath, "utf8"));
   } catch {
     return { error: `${cfgPath} is not valid JSON`, path: cfgPath };
   }
@@ -20932,22 +20972,22 @@ function youTrackConfigLoad() {
   }
   const cfgPath = loaded.path;
   const tokenFile = String(loaded.config.tokenFile ?? "");
-  const tokenPath = tokenFile ? path23.isAbsolute(tokenFile) ? path23.resolve(tokenFile) : path23.resolve(process.cwd(), tokenFile) : "";
-  if (!tokenPath || !fs14.existsSync(tokenPath)) {
+  const tokenPath = tokenFile ? path24.isAbsolute(tokenFile) ? path24.resolve(tokenFile) : path24.resolve(process.cwd(), tokenFile) : "";
+  if (!tokenPath || !fs15.existsSync(tokenPath)) {
     return { error: "missing youtrack.token" };
   }
   if (!youTrackTokenModeOk(tokenPath)) {
     return { error: "youtrack.token mode must be 0600" };
   }
-  const token = fs14.readFileSync(tokenPath, "utf8").trim();
+  const token = fs15.readFileSync(tokenPath, "utf8").trim();
   if (!token || token === TOKEN_PLACEHOLDER || token.startsWith(TOKEN_PLACEHOLDER)) {
     return { error: "token file still placeholder — edit locally, then /wk-status" };
   }
   const redacted = { ...loaded.config };
   delete redacted.tokenFile;
   redacted.tokenPresent = true;
-  redacted.configPath = path23.resolve(cfgPath);
-  redacted.tokenPath = path23.resolve(tokenPath);
+  redacted.configPath = path24.resolve(cfgPath);
+  redacted.tokenPath = path24.resolve(tokenPath);
   return { data: redacted };
 }
 function tzParts(date, tz) {
@@ -20976,10 +21016,10 @@ function youTrackParseDuration(text) {
 function youTrackWorkDateMs(dateRaw) {
   const cfgPath = youTrackConfigPath();
   let effective = effectiveWorkTimezone(null);
-  if (fs14.existsSync(cfgPath)) {
+  if (fs15.existsSync(cfgPath)) {
     let parsed;
     try {
-      parsed = JSON.parse(fs14.readFileSync(cfgPath, "utf8"));
+      parsed = JSON.parse(fs15.readFileSync(cfgPath, "utf8"));
     } catch {
       return { error: `${cfgPath} is not valid JSON` };
     }
@@ -21119,9 +21159,9 @@ function resolveYouTrackFromPaths(spec_path, plan_path, workspace_root) {
     } catch {
       continue;
     }
-    if (!fs14.existsSync(full))
+    if (!fs15.existsSync(full))
       continue;
-    const text = fs14.readFileSync(full, "utf8");
+    const text = fs15.readFileSync(full, "utf8");
     const m = text.match(/^\*\*YouTrack:\*\*\s*`?([A-Z]+-\d+)`?/m);
     if (m)
       return m[1];
@@ -21270,18 +21310,18 @@ async function postUpdate({
   }
   return { ok: true, issueId, postedComment: true };
 }
-var ISSUE_RE, TOKEN_PLACEHOLDER = "YOUR_TOKEN_HERE", youTrackConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path23.join(configDir(), "youtrack.json"), youTrackReadOnlyConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path23.join(resolveConfigDir(), "youtrack.json"), youTrackTokenModeOk = (p) => {
+var ISSUE_RE, TOKEN_PLACEHOLDER = "YOUR_TOKEN_HERE", youTrackConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path24.join(configDir(), "youtrack.json"), youTrackReadOnlyConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path24.join(resolveConfigDir(), "youtrack.json"), youTrackTokenModeOk = (p) => {
   if (process.platform === "win32")
     return true;
-  const mode = fs14.statSync(p).mode & 511;
+  const mode = fs15.statSync(p).mode & 511;
   return mode === 384;
 }, readYouTrackContextConfig = () => {
   const cfgPath = youTrackReadOnlyConfigPath();
-  if (!fs14.existsSync(cfgPath))
+  if (!fs15.existsSync(cfgPath))
     return { data: {} };
   let parsed;
   try {
-    parsed = JSON.parse(fs14.readFileSync(cfgPath, "utf8"));
+    parsed = JSON.parse(fs15.readFileSync(cfgPath, "utf8"));
   } catch {
     return { error: "YouTrack configuration is unavailable" };
   }
@@ -21312,12 +21352,12 @@ var ISSUE_RE, TOKEN_PLACEHOLDER = "YOUR_TOKEN_HERE", youTrackConfigPath = () =>
   if ("error" in loaded)
     return loaded;
   const tokenFile = String(loaded.config.tokenFile ?? "");
-  const tokenPath = tokenFile ? path23.isAbsolute(tokenFile) ? path23.resolve(tokenFile) : path23.resolve(process.cwd(), tokenFile) : "";
-  if (!tokenPath || !fs14.existsSync(tokenPath))
+  const tokenPath = tokenFile ? path24.isAbsolute(tokenFile) ? path24.resolve(tokenFile) : path24.resolve(process.cwd(), tokenFile) : "";
+  if (!tokenPath || !fs15.existsSync(tokenPath))
     return { error: "missing youtrack.token" };
   if (!youTrackTokenModeOk(tokenPath))
     return { error: "youtrack.token mode must be 0600" };
-  const token = fs14.readFileSync(tokenPath, "utf8").trim();
+  const token = fs15.readFileSync(tokenPath, "utf8").trim();
   if (!token)
     return { error: "empty token file" };
   if (token === TOKEN_PLACEHOLDER || token.startsWith(TOKEN_PLACEHOLDER)) {
@@ -21417,18 +21457,18 @@ var init_context_read = __esm(() => {
 
 // packages/workit-core/src/core.ts
 import { existsSync as existsSync7, realpathSync as realpathSync5 } from "node:fs";
-import path24 from "node:path";
+import path25 from "node:path";
 function resolveInside(root, candidate) {
   const base = realpathSync5(root);
-  const target = path24.resolve(base, candidate);
-  if (target !== base && !target.startsWith(base + path24.sep)) {
+  const target = path25.resolve(base, candidate);
+  if (target !== base && !target.startsWith(base + path25.sep)) {
     throw new Error("path must stay inside repository root");
   }
   let ancestor = target;
   while (!existsSync7(ancestor))
-    ancestor = path24.dirname(ancestor);
+    ancestor = path25.dirname(ancestor);
   const canonicalAncestor = realpathSync5(ancestor);
-  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path24.sep)) {
+  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path25.sep)) {
     throw new Error("path must stay inside repository root");
   }
   return target;
@@ -21454,7 +21494,7 @@ var init_core3 = __esm(() => {
 
 // packages/workit-cli/src/task.ts
 import { readFileSync as readFileSync7 } from "node:fs";
-import path25 from "node:path";
+import path26 from "node:path";
 async function readInput(input) {
   if (typeof input === "string")
     return input;
@@ -21781,7 +21821,7 @@ var TASK_FAMILIES, workspaceRootFor = (deps = {}) => {
     return explicit;
   const cwd = deps.cwd ?? process.cwd();
   const top = checkRoot(cwd);
-  return sameDirectoryIdentity(top, path25.resolve(cwd)) ? cwd : top;
+  return sameDirectoryIdentity(top, path26.resolve(cwd)) ? cwd : top;
 }, TASK_ACTIONS, outOf = (deps) => deps.out ?? process.stdout, errOf = (deps) => deps.err ?? process.stderr, write = (stream, value) => stream.write(value.endsWith(`
 `) ? value : `${value}
 `), jsonResult = (stream, result) => write(stream, JSON.stringify(result)), usage = (message) => failure2("invalid_input", message), parseUsage = (message, json) => ({
@@ -25834,7 +25874,7 @@ var init_wrap_ansi = __esm(() => {
 // node_modules/terminal-size/index.js
 import process3 from "node:process";
 import { execFileSync as execFileSync2 } from "node:child_process";
-import fs15 from "node:fs";
+import fs16 from "node:fs";
 import tty from "node:tty";
 function terminalSize() {
   const { env, stdout, stderr } = process3;
@@ -25882,7 +25922,7 @@ var defaultColumns = 80, defaultRows = 24, exec2 = (command, arguments_, { shell
     return true;
   }
   try {
-    const statContents = fs15.readFileSync("/proc/self/stat", "utf8");
+    const statContents = fs16.readFileSync("/proc/self/stat", "utf8");
     const closingParenthesisIndex = statContents.lastIndexOf(") ");
     if (closingParenthesisIndex === -1) {
       return false;
@@ -25902,8 +25942,8 @@ var defaultColumns = 80, defaultRows = 24, exec2 = (command, arguments_, { shell
   }
 }, devTty = () => {
   try {
-    const flags = process3.platform === "darwin" ? fs15.constants.O_EVTONLY | fs15.constants.O_NONBLOCK : fs15.constants.O_NONBLOCK;
-    const { columns, rows } = tty.WriteStream(fs15.openSync("/dev/tty", flags));
+    const flags = process3.platform === "darwin" ? fs16.constants.O_EVTONLY | fs16.constants.O_NONBLOCK : fs16.constants.O_NONBLOCK;
+    const { columns, rows } = tty.WriteStream(fs16.openSync("/dev/tty", flags));
     return { columns, rows };
   } catch {}
 }, tput = () => {
@@ -61016,7 +61056,7 @@ var init_Text = __esm(() => {
 });
 
 // node_modules/ink/build/components/ErrorOverview.js
-import * as fs16 from "node:fs";
+import * as fs17 from "node:fs";
 import { cwd } from "node:process";
 function ErrorOverview({ error }) {
   const stack = error.stack ? error.stack.split(`
@@ -61026,8 +61066,8 @@ function ErrorOverview({ error }) {
   let excerpt;
   let lineWidth = 0;
   const stackLineCounts = new Map;
-  if (filePath && origin?.line && fs16.existsSync(filePath)) {
-    const sourceCode = fs16.readFileSync(filePath, "utf8");
+  if (filePath && origin?.line && fs17.existsSync(filePath)) {
+    const sourceCode = fs17.readFileSync(filePath, "utf8");
     excerpt = dist_default3(sourceCode, origin.line);
     if (excerpt) {
       for (const { line } of excerpt) {
@@ -64692,8 +64732,8 @@ var init_gitignore = __esm(() => {
 });
 
 // packages/workit-core/src/core/changelog.ts
-import fs17 from "node:fs";
-import path26 from "node:path";
+import fs18 from "node:fs";
+import path27 from "node:path";
 import { createHash as createHash13 } from "node:crypto";
 function normalizeBullet(text) {
   text = text.trim();
@@ -64853,8 +64893,8 @@ function applyChangelog(target, entries, normalizeOnly) {
   const rendered = renderChangelog(source.text, entries, normalizeOnly);
   if ("error" in rendered)
     return { error: rendered.error };
-  fs17.mkdirSync(path26.dirname(target), { recursive: true });
-  fs17.writeFileSync(target, rendered.text, "utf8");
+  fs18.mkdirSync(path27.dirname(target), { recursive: true });
+  fs18.writeFileSync(target, rendered.text, "utf8");
   return { ...rendered.result, path: target };
 }
 function renderChangelog(source, entries, normalizeOnly) {
@@ -64982,12 +65022,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 `, digestBytes2 = (value) => createHash13("sha256").update(value).digest("hex"), readChangelogSource = (target) => {
-  if (!fs17.existsSync(target)) {
+  if (!fs18.existsSync(target)) {
     const bytes = Buffer.from(SKELETON, "utf8");
     return { exists: false, bytes, text: SKELETON };
   }
   try {
-    const bytes = fs17.readFileSync(target);
+    const bytes = fs18.readFileSync(target);
     const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
     return { exists: true, bytes, text };
   } catch {
@@ -64995,17 +65035,17 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   }
 }, changelogTarget = (workspaceRoot, changelogPath) => {
   try {
-    const cwd = fs17.realpathSync(resolveWorkspaceRoot(workspaceRoot));
-    const target = path26.resolve(cwd, changelogPath || "CHANGELOG.md");
-    if (target !== cwd && !target.startsWith(cwd + path26.sep))
+    const cwd = fs18.realpathSync(resolveWorkspaceRoot(workspaceRoot));
+    const target = path27.resolve(cwd, changelogPath || "CHANGELOG.md");
+    if (target !== cwd && !target.startsWith(cwd + path27.sep))
       return { error: "changelog path must be inside workspace_root" };
     let ancestor = target;
-    while (!fs17.existsSync(ancestor))
-      ancestor = path26.dirname(ancestor);
-    const canonicalAncestor = fs17.realpathSync(ancestor);
-    if (canonicalAncestor !== cwd && !canonicalAncestor.startsWith(cwd + path26.sep))
+    while (!fs18.existsSync(ancestor))
+      ancestor = path27.dirname(ancestor);
+    const canonicalAncestor = fs18.realpathSync(ancestor);
+    if (canonicalAncestor !== cwd && !canonicalAncestor.startsWith(cwd + path27.sep))
       return { error: "changelog path must be inside workspace_root" };
-    return { cwd, target: fs17.existsSync(target) ? fs17.realpathSync(target) : target };
+    return { cwd, target: fs18.existsSync(target) ? fs18.realpathSync(target) : target };
   } catch {
     return { error: "changelog path must be inside workspace_root" };
   }
@@ -65023,22 +65063,22 @@ var init_changelog = __esm(() => {
 // packages/workit-core/src/core/hygiene.ts
 import { spawnSync as spawnSync12 } from "node:child_process";
 import { existsSync as existsSync9, readFileSync as readFileSync9, readdirSync as readdirSync5, writeFileSync as writeFileSync4 } from "node:fs";
-import path27 from "node:path";
-var repoRoot2, templatesDir = () => path27.join(repoRoot2, "templates", "hygiene"), packageJson = (root) => {
-  if (!existsSync9(path27.join(root, "package.json")))
+import path28 from "node:path";
+var repoRoot2, templatesDir = () => path28.join(repoRoot2, "templates", "hygiene"), packageJson = (root) => {
+  if (!existsSync9(path28.join(root, "package.json")))
     return null;
   try {
-    return JSON.parse(readFileSync9(path27.join(root, "package.json"), "utf8"));
+    return JSON.parse(readFileSync9(path28.join(root, "package.json"), "utf8"));
   } catch {
     return null;
   }
 }, isOpenSource = (root) => {
-  if (existsSync9(path27.join(root, "LICENSE")))
+  if (existsSync9(path28.join(root, "LICENSE")))
     return true;
   const pkg = packageJson(root);
   if (pkg && !pkg.private)
     return true;
-  return path27.basename(root) === "workflow-toolkit";
+  return path28.basename(root) === "workflow-toolkit";
 }, licenseHolder = (root) => {
   const pkg = packageJson(root);
   if (pkg) {
@@ -65053,14 +65093,14 @@ var repoRoot2, templatesDir = () => path27.join(repoRoot2, "templates", "hygiene
   }
   return "";
 }, projectTarget = (dir) => {
-  const start = path27.resolve(dir);
+  const start = path28.resolve(dir);
   const top = spawnSync12("git", ["rev-parse", "--show-toplevel"], { cwd: start, encoding: "utf8" });
   const root = top.status === 0 ? (top.stdout ?? "").trim() : "";
   if (root)
-    return { ok: true, root: path27.resolve(root) };
+    return { ok: true, root: path28.resolve(root) };
   let children = [];
   try {
-    children = readdirSync5(start, { withFileTypes: true }).filter((entry) => entry.isDirectory() && existsSync9(path27.join(start, entry.name, ".git"))).map((entry) => path27.join(start, entry.name)).toSorted();
+    children = readdirSync5(start, { withFileTypes: true }).filter((entry) => entry.isDirectory() && existsSync9(path28.join(start, entry.name, ".git"))).map((entry) => path28.join(start, entry.name)).toSorted();
   } catch {
     children = [];
   }
@@ -65076,13 +65116,13 @@ var repoRoot2, templatesDir = () => path27.join(repoRoot2, "templates", "hygiene
     files.push("LICENSE", "CONTRIBUTING.md");
   const planned = [];
   for (const file of files) {
-    if (existsSync9(path27.join(root, file)))
+    if (existsSync9(path28.join(root, file)))
       continue;
-    const tpl = path27.join(templatesDir(), file);
+    const tpl = path28.join(templatesDir(), file);
     if (!existsSync9(tpl))
       continue;
-    const content = readFileSync9(tpl, "utf8").replace(/<PROJECT>/g, path27.basename(root)).replace(/<YEAR>/g, String(new Date().getFullYear())).replace(/<HOLDER>\s*/g, licenseHolder(root));
-    planned.push({ path: path27.join(root, file), content });
+    const content = readFileSync9(tpl, "utf8").replace(/<PROJECT>/g, path28.basename(root)).replace(/<YEAR>/g, String(new Date().getFullYear())).replace(/<HOLDER>\s*/g, licenseHolder(root));
+    planned.push({ path: path28.join(root, file), content });
   }
   return planned;
 };
@@ -65094,9 +65134,9 @@ var init_hygiene = __esm(() => {
 
 // packages/workit-cli/src/admin/setup-state.ts
 import { existsSync as existsSync10, readFileSync as readFileSync10 } from "node:fs";
-import path28 from "node:path";
+import path29 from "node:path";
 var classifySetupFile = (dir, name) => {
-  const file = path28.join(dir, name);
+  const file = path29.join(dir, name);
   let raw;
   try {
     raw = readFileSync10(file, "utf8");
@@ -65134,7 +65174,7 @@ var init_setup_state = __esm(() => {
 });
 
 // packages/workit-cli/src/admin/registration.ts
-import path29 from "node:path";
+import path30 from "node:path";
 function isWorkitPlugin(value) {
   const s = String(value).replaceAll("\\", "/");
   const url = s.startsWith("file://") || s.startsWith("git+file://");
@@ -65167,11 +65207,11 @@ function mergeCursorEnabledPlugins(enabled) {
 }
 function mergeCursorPluginDirs(pluginDirs, pluginDir) {
   const strip = (p) => {
-    const j = path29.join(p);
-    return path29.dirname(j) === j ? j : j.replace(/[\\/]+$/, "");
+    const j = path30.join(p);
+    return path30.dirname(j) === j ? j : j.replace(/[\\/]+$/, "");
   };
   const normalized = strip(pluginDir);
-  const legacy = strip(path29.join(path29.dirname(pluginDir), "workflow-toolkit"));
+  const legacy = strip(path30.join(path30.dirname(pluginDir), "workflow-toolkit"));
   const prev = Array.isArray(pluginDirs) ? pluginDirs.map(String) : [];
   const kept = prev.filter((d) => strip(d) !== legacy);
   const exists = kept.some((d) => strip(d) === normalized);
@@ -65259,7 +65299,7 @@ function cursorMcpServerEntry(_packageDir) {
 function cursorHooksEntry(pluginDir) {
   return { command: `${cursorHookLauncher(pluginDir)} workit-cursor-session-start`, args: [] };
 }
-var OPENCODE_NPM_PIN = "@brainervirus/workit-opencode", isRecord4 = (v) => v !== null && typeof v === "object" && !Array.isArray(v), named = (s, name) => s === name || s.startsWith(`${name}@`), CURSOR_RUNTIME_PACKAGE = "@brainervirus/workit-cursor@latest", cursorHookLauncher = (pluginDir) => pluginDir ? `node "${shellQuotedPath(path29.join(pluginDir, "hooks", "launch.mjs"))}"` : 'node "${CURSOR_PLUGIN_ROOT}/hooks/launch.mjs"', shellQuotedPath = (file) => path29.sep === "\\" ? file : file.replace(/([$`"\\])/g, "\\$1"), CURSOR_HOOK_RUN_COMMAND, CURSOR_PRETOOLUSE_MATCHER = "Write|Edit|Delete|Shell|Remove|ApplyPatch|Apply_Patch|Patch|Rename|Mkdir|Mv|Cp|Touch", CURSOR_HOOK_EVENTS, canonicalHookEntry = (event, pluginDir) => {
+var OPENCODE_NPM_PIN = "@brainervirus/workit-opencode", isRecord4 = (v) => v !== null && typeof v === "object" && !Array.isArray(v), named = (s, name) => s === name || s.startsWith(`${name}@`), CURSOR_RUNTIME_PACKAGE = "@brainervirus/workit-cursor@latest", cursorHookLauncher = (pluginDir) => pluginDir ? `node "${shellQuotedPath(path30.join(pluginDir, "hooks", "launch.mjs"))}"` : 'node "${CURSOR_PLUGIN_ROOT}/hooks/launch.mjs"', shellQuotedPath = (file) => path30.sep === "\\" ? file : file.replace(/([$`"\\])/g, "\\$1"), CURSOR_HOOK_RUN_COMMAND, CURSOR_PRETOOLUSE_MATCHER = "Write|Edit|Delete|Shell|Remove|ApplyPatch|Apply_Patch|Patch|Rename|Mkdir|Mv|Cp|Touch", CURSOR_HOOK_EVENTS, canonicalHookEntry = (event, pluginDir) => {
   const command = `${cursorHookLauncher(pluginDir)} workit-cursor-hook`;
   if (event === "preToolUse")
     return { command, matcher: CURSOR_PRETOOLUSE_MATCHER, failClosed: false };
@@ -65294,8 +65334,8 @@ var init_support_matrix = __esm(() => {
 
 // packages/workit-core/src/core/heavy-scope.ts
 import { spawnSync as spawnSync13 } from "node:child_process";
-import fs18 from "node:fs";
-import path30 from "node:path";
+import fs19 from "node:fs";
+import path31 from "node:path";
 function scopeSupport(env, platform = process.platform, read = readText2) {
   if (platform !== "linux")
     return { ok: false, reason: `no systemd scopes on ${platform}` };
@@ -65303,7 +65343,7 @@ function scopeSupport(env, platform = process.platform, read = readText2) {
     return { ok: false, reason: "systemd-run is not on PATH" };
   const uid = process.getuid?.() ?? 0;
   const runtime = env.XDG_RUNTIME_DIR || `/run/user/${uid}`;
-  if (!fs18.existsSync(path30.join(runtime, "systemd", "private")))
+  if (!fs19.existsSync(path31.join(runtime, "systemd", "private")))
     return { ok: false, reason: "no user systemd manager is running" };
   const controllers = read(`/sys/fs/cgroup/user.slice/user-${uid}.slice/user@${uid}.service/cgroup.controllers`);
   if (controllers === null)
@@ -65366,13 +65406,13 @@ function probeScope(env = process.env) {
 }
 var readText2 = (file) => {
   try {
-    return fs18.readFileSync(file, "utf8");
+    return fs19.readFileSync(file, "utf8");
   } catch {
     return null;
   }
-}, onPath = (command, env) => (env.PATH ?? "").split(path30.delimiter).filter(Boolean).some((dir) => {
+}, onPath = (command, env) => (env.PATH ?? "").split(path31.delimiter).filter(Boolean).some((dir) => {
   try {
-    fs18.accessSync(path30.join(dir, command), fs18.constants.X_OK);
+    fs19.accessSync(path31.join(dir, command), fs19.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -65392,7 +65432,7 @@ import {
   statSync as statSync2
 } from "node:fs";
 import os8 from "node:os";
-import path31 from "node:path";
+import path32 from "node:path";
 function hostCommand(name, args, options = {}) {
   const executable = findHostExecutable(name, options);
   if (!executable)
@@ -65409,11 +65449,11 @@ function hostCommand(name, args, options = {}) {
   return { command: executable, args, cwd: options.cwd, purpose: `${name} CLI` };
 }
 function resolveWindowsShimEntry(contents, shim, exists = existsSync11) {
-  const root = path31.win32.dirname(shim);
+  const root = path32.win32.dirname(shim);
   const matches = contents.matchAll(/(["']?)([^\r\n"']*node_modules[\\/][^\r\n"']+?\.js)\1/gi);
   for (const match of matches) {
     const raw = match[2].replace(/%~?dp0%?/gi, root);
-    const candidate = path31.win32.isAbsolute(raw) ? raw : path31.win32.resolve(root, raw);
+    const candidate = path32.win32.isAbsolute(raw) ? raw : path32.win32.resolve(root, raw);
     if (exists(candidate))
       return candidate;
   }
@@ -65423,22 +65463,22 @@ function findHostExecutable(name, options = {}) {
   const env = options.env ?? process.env;
   const home = options.home ?? env.HOME ?? os8.homedir();
   const suffixes = process.platform === "win32" ? ["", ".exe", ".cmd", ".bat"] : [""];
-  const dirs = (env.PATH ?? "").split(path31.delimiter).filter(Boolean);
-  dirs.push(path31.join(home, ".local", "bin"), path31.join(home, ".asdf", "shims"));
+  const dirs = (env.PATH ?? "").split(path32.delimiter).filter(Boolean);
+  dirs.push(path32.join(home, ".local", "bin"), path32.join(home, ".asdf", "shims"));
   for (const [base, tail] of [
-    [path31.join(home, ".local", "share", "fnm", "node-versions"), path31.join("installation", "bin")],
-    [path31.join(home, ".nvm", "versions", "node"), "bin"]
+    [path32.join(home, ".local", "share", "fnm", "node-versions"), path32.join("installation", "bin")],
+    [path32.join(home, ".nvm", "versions", "node"), "bin"]
   ]) {
     try {
       for (const entry of readdirSync6(base, { withFileTypes: true })) {
         if (entry.isDirectory())
-          dirs.push(path31.join(base, entry.name, tail));
+          dirs.push(path32.join(base, entry.name, tail));
       }
     } catch {}
   }
   for (const dir of dirs) {
     for (const suffix of suffixes) {
-      const candidate = path31.join(dir, `${name}${suffix}`);
+      const candidate = path32.join(dir, `${name}${suffix}`);
       try {
         if (statSync2(candidate).isFile()) {
           if (process.platform === "win32")
@@ -65453,7 +65493,7 @@ function findHostExecutable(name, options = {}) {
 }
 function installedHostApp(host, home, env = process.env, platform = process.platform, exists = existsSync11) {
   const candidates = [];
-  const pathApi = platform === "win32" ? path31.win32 : path31;
+  const pathApi = platform === "win32" ? path32.win32 : path32;
   if (platform === "darwin") {
     const app = host === "cursor" ? "Cursor.app" : host === "codex" ? "Codex.app" : host === "opencode" ? "OpenCode.app" : "";
     if (app)
@@ -65558,8 +65598,8 @@ function planHostInstall(host, options = {}) {
     const npmCli = npm ? findNpmCli(npm) : null;
     if (!npmCli)
       throw new Error("npm CLI could not be resolved; install Node.js 24+ and npm, then retry");
-    const stage = path31.join(home, ".cursor", "plugins", "local", ".workit-package-bootstrap");
-    const target = options.targetDir ?? path31.join(home, ".cursor", "plugins", "local", "workit");
+    const stage = path32.join(home, ".cursor", "plugins", "local", ".workit-package-bootstrap");
+    const target = options.targetDir ?? path32.join(home, ".cursor", "plugins", "local", "workit");
     return [
       nodePrerequisite({ home, cwd, env }),
       {
@@ -65575,7 +65615,7 @@ function planHostInstall(host, options = {}) {
         ],
         cwd,
         purpose: upgrading ? "Download the current Workit Cursor adapter for the managed local plugin directory" : "Download the Workit Cursor adapter package for the managed local plugin directory",
-        packageRoot: path31.join(stage, "node_modules", "@brainervirus", "workit-cursor"),
+        packageRoot: path32.join(stage, "node_modules", "@brainervirus", "workit-cursor"),
         packageTarget: target
       }
     ];
@@ -65657,10 +65697,10 @@ function runHostCommand(step, context = {}) {
     env: (() => {
       const home = context.home ?? context.env?.HOME ?? os8.homedir();
       const env = { ...process.env, ...context.env, HOME: home };
-      env.CODEX_HOME = context.env?.CODEX_HOME ?? path31.join(home, ".codex");
-      env.PI_CODING_AGENT_DIR = context.env?.PI_CODING_AGENT_DIR ?? path31.join(home, ".pi", "agent");
-      env.CLAUDE_CONFIG_DIR = context.env?.CLAUDE_CONFIG_DIR ?? path31.join(home, ".claude");
-      env.XDG_CONFIG_HOME = context.env?.XDG_CONFIG_HOME ?? path31.join(home, ".config");
+      env.CODEX_HOME = context.env?.CODEX_HOME ?? path32.join(home, ".codex");
+      env.PI_CODING_AGENT_DIR = context.env?.PI_CODING_AGENT_DIR ?? path32.join(home, ".pi", "agent");
+      env.CLAUDE_CONFIG_DIR = context.env?.CLAUDE_CONFIG_DIR ?? path32.join(home, ".claude");
+      env.XDG_CONFIG_HOME = context.env?.XDG_CONFIG_HOME ?? path32.join(home, ".config");
       return env;
     })(),
     encoding: "utf8",
@@ -65695,7 +65735,7 @@ var resolveWindowsShimScript = (shim) => {
     purpose: "Check the Node.js 24+ package runtime requirement"
   };
 }, isPiWorkitInstalled = (home, env = process.env) => {
-  const settings = path31.join(env.PI_CODING_AGENT_DIR ?? path31.join(home, ".pi", "agent"), "settings.json");
+  const settings = path32.join(env.PI_CODING_AGENT_DIR ?? path32.join(home, ".pi", "agent"), "settings.json");
   try {
     const document2 = JSON.parse(readFileSync11(settings, "utf8"));
     return (document2.packages ?? []).some((entry) => {
@@ -65708,7 +65748,7 @@ var resolveWindowsShimScript = (shim) => {
   }
 }, OPENCODE_PLUGIN_SCOPE = "@brainervirus", OPENCODE_PLUGIN_NAME = "workit-opencode", packageVersionAt = (root, name) => {
   try {
-    const pkg = JSON.parse(readFileSync11(path31.join(root, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync11(path32.join(root, "package.json"), "utf8"));
     return pkg.name === name && typeof pkg.version === "string" ? pkg.version : null;
   } catch {
     return null;
@@ -65722,17 +65762,17 @@ var resolveWindowsShimScript = (shim) => {
       return d;
   }
   return 0;
-}, openCodeCacheDir = (home, env = process.env) => path31.join(env.XDG_CACHE_HOME || path31.join(home, ".cache"), "opencode"), subdirs = (dir) => {
+}, openCodeCacheDir = (home, env = process.env) => path32.join(env.XDG_CACHE_HOME || path32.join(home, ".cache"), "opencode"), subdirs = (dir) => {
   try {
-    return readdirSync6(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path31.join(dir, entry.name));
+    return readdirSync6(dir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => path32.join(dir, entry.name));
   } catch {
     return [];
   }
 }, openCodeInstalledPlugin = (home, env = process.env) => {
   const name = `${OPENCODE_PLUGIN_SCOPE}/${OPENCODE_PLUGIN_NAME}`;
   const cache = openCodeCacheDir(home, env);
-  const specDirs = (layout) => subdirs(path31.join(cache, layout, OPENCODE_PLUGIN_SCOPE)).filter((dir) => path31.basename(dir) === `${OPENCODE_PLUGIN_NAME}@latest`);
-  const installs = [...specDirs("npm").flatMap(subdirs), ...specDirs("packages")].map((dir) => path31.join(dir, "node_modules", OPENCODE_PLUGIN_SCOPE, OPENCODE_PLUGIN_NAME));
+  const specDirs = (layout) => subdirs(path32.join(cache, layout, OPENCODE_PLUGIN_SCOPE)).filter((dir) => path32.basename(dir) === `${OPENCODE_PLUGIN_NAME}@latest`);
+  const installs = [...specDirs("npm").flatMap(subdirs), ...specDirs("packages")].map((dir) => path32.join(dir, "node_modules", OPENCODE_PLUGIN_SCOPE, OPENCODE_PLUGIN_NAME));
   let best = null;
   for (const root of installs) {
     const version = packageVersionAt(root, name);
@@ -65742,8 +65782,8 @@ var resolveWindowsShimScript = (shim) => {
   return best;
 }, isCanonicalCodexPackage = (root) => {
   for (const file of [
-    path31.join(root, ".codex-plugin", "plugin.json"),
-    path31.join(root, "package.json")
+    path32.join(root, ".codex-plugin", "plugin.json"),
+    path32.join(root, "package.json")
   ]) {
     try {
       const manifest = JSON.parse(readFileSync11(file, "utf8"));
@@ -65754,47 +65794,47 @@ var resolveWindowsShimScript = (shim) => {
   }
   return false;
 }, isCodexWorkitInstalled = (home, env = process.env) => {
-  const codexHome = env.CODEX_HOME ?? path31.join(home, ".codex");
+  const codexHome = env.CODEX_HOME ?? path32.join(home, ".codex");
   const isPackageOrVersionDirectory = (root) => {
     if (isCanonicalCodexPackage(root))
       return true;
     try {
-      return readdirSync6(root, { withFileTypes: true }).some((entry) => entry.isDirectory() && isCanonicalCodexPackage(path31.join(root, entry.name)));
+      return readdirSync6(root, { withFileTypes: true }).some((entry) => entry.isDirectory() && isCanonicalCodexPackage(path32.join(root, entry.name)));
     } catch {
       return false;
     }
   };
-  if (isPackageOrVersionDirectory(path31.join(codexHome, "plugins", "workit")))
+  if (isPackageOrVersionDirectory(path32.join(codexHome, "plugins", "workit")))
     return true;
-  const root = path31.join(codexHome, "plugins", "cache");
+  const root = path32.join(codexHome, "plugins", "cache");
   try {
     for (const marketplace of readdirSync6(root, { withFileTypes: true })) {
       if (!marketplace.isDirectory())
         continue;
-      if (isPackageOrVersionDirectory(path31.join(root, marketplace.name, "workit")))
+      if (isPackageOrVersionDirectory(path32.join(root, marketplace.name, "workit")))
         return true;
     }
   } catch {
     return false;
   }
   return false;
-}, claudeConfigDir = (home, env = process.env) => env.CLAUDE_CONFIG_DIR ?? path31.join(home, ".claude"), CLAUDE_SCOPES, appliesTo = (install, cwd) => {
+}, claudeConfigDir = (home, env = process.env) => env.CLAUDE_CONFIG_DIR ?? path32.join(home, ".claude"), CLAUDE_SCOPES, appliesTo = (install, cwd) => {
   if (install.scope === "user")
     return true;
   if (cwd === null || install.projectPath === null)
     return false;
-  const relative = path31.relative(path31.resolve(install.projectPath), path31.resolve(cwd));
-  return relative === "" || !relative.startsWith("..") && !path31.isAbsolute(relative);
+  const relative = path32.relative(path32.resolve(install.projectPath), path32.resolve(cwd));
+  return relative === "" || !relative.startsWith("..") && !path32.isAbsolute(relative);
 }, isCanonicalClaudePlugin = (root) => {
   try {
-    const manifest = JSON.parse(readFileSync11(path31.join(root, ".claude-plugin", "plugin.json"), "utf8"));
+    const manifest = JSON.parse(readFileSync11(path32.join(root, ".claude-plugin", "plugin.json"), "utf8"));
     const repository = typeof manifest.repository === "string" ? manifest.repository : manifest.repository?.url;
     return manifest.name === "workit" && repository?.replace(/\.git$/, "").toLowerCase() === "https://github.com/brainervirus/workit";
   } catch {
     return false;
   }
 }, claudeWorkitInstalls = (home, env = process.env, cwd = process.cwd()) => {
-  const file = path31.join(claudeConfigDir(home, env), "plugins", "installed_plugins.json");
+  const file = path32.join(claudeConfigDir(home, env), "plugins", "installed_plugins.json");
   let registry;
   try {
     registry = JSON.parse(readFileSync11(file, "utf8"));
@@ -65829,14 +65869,14 @@ var resolveWindowsShimScript = (shim) => {
 }, isClaudeWorkitInstalled = (home, env = process.env, cwd = process.cwd()) => claudeWorkitInstalls(home, env, cwd).length > 0, findNpmCli = (npm) => {
   try {
     const resolved = realpathSync6(npm);
-    if (path31.basename(resolved) === "npm-cli.js")
+    if (path32.basename(resolved) === "npm-cli.js")
       return resolved;
   } catch {}
-  const dir = path31.dirname(npm);
+  const dir = path32.dirname(npm);
   const candidates = [
-    path31.join(dir, "node_modules", "npm", "bin", "npm-cli.js"),
-    path31.join(dir, "..", "node_modules", "npm", "bin", "npm-cli.js"),
-    path31.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")
+    path32.join(dir, "node_modules", "npm", "bin", "npm-cli.js"),
+    path32.join(dir, "..", "node_modules", "npm", "bin", "npm-cli.js"),
+    path32.join(dir, "..", "lib", "node_modules", "npm", "bin", "npm-cli.js")
   ];
   return candidates.find((candidate) => existsSync11(candidate)) ?? null;
 };
@@ -65847,21 +65887,21 @@ var init_host_install = __esm(() => {
 
 // packages/workit-core/src/core/skill-manifests.ts
 import { cpSync as cpSync3, existsSync as existsSync12, readFileSync as readFileSync12, readdirSync as readdirSync7, statSync as statSync3, writeFileSync as writeFileSync5 } from "node:fs";
-import path32 from "node:path";
-var WORKIT_METHOD_SKILLS, skillManifestNames = (root) => existsSync12(root) ? readdirSync7(root).filter((name) => existsSync12(path32.join(root, name, "SKILL.md"))).toSorted() : [], validateSkillManifests = (root, expected, label) => {
+import path33 from "node:path";
+var WORKIT_METHOD_SKILLS, skillManifestNames = (root) => existsSync12(root) ? readdirSync7(root).filter((name) => existsSync12(path33.join(root, name, "SKILL.md"))).toSorted() : [], validateSkillManifests = (root, expected, label) => {
   const actual = skillManifestNames(root);
   const missing = expected.filter((name) => !actual.includes(name));
   const extra = actual.filter((name) => !expected.includes(name));
   return missing.length === 0 && extra.length === 0 ? null : `${label} mismatch at ${root} (missing: ${missing.join(", ") || "none"}; extra: ${extra.join(", ") || "none"})`;
 }, validateCursorSkills = (pluginDir, expected = WORKIT_METHOD_SKILLS) => {
-  const workit = validateSkillManifests(path32.join(pluginDir, "skills"), expected, "Cursor Workit skills");
+  const workit = validateSkillManifests(path33.join(pluginDir, "skills"), expected, "Cursor Workit skills");
   if (workit)
     return workit;
-  const pending = [path32.join(pluginDir, "skills")];
+  const pending = [path33.join(pluginDir, "skills")];
   while (pending.length > 0) {
     const dir = pending.pop();
     for (const entry of readdirSync7(dir, { withFileTypes: true })) {
-      const file = path32.join(dir, entry.name);
+      const file = path33.join(dir, entry.name);
       if (entry.isDirectory())
         pending.push(file);
       else if ((statSync3(file).mode & 73) !== 0 || readFileSync12(file).subarray(0, 2).toString("latin1") === "#!") {
@@ -65903,7 +65943,7 @@ import {
   statSync as statSync4,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import path33 from "node:path";
+import path34 from "node:path";
 function inspectSessionHook(cwd, env = process.env) {
   const none = { hooksDir: null, hookPath: null, helperPath: null, helperCurrent: false };
   if (!existsSync13(cwd))
@@ -65915,8 +65955,8 @@ function inspectSessionHook(cwd, env = process.env) {
   const [commonDir, hooksDir] = paths.out.split(/\r?\n/);
   if (!paths.ok || !commonDir || !hooksDir)
     return { state: "not_git", ...none };
-  const hookPath = path33.join(hooksDir, SESSION_HOOK_NAME);
-  const helperPath = path33.join(commonDir, ...HELPER);
+  const hookPath = path34.join(hooksDir, SESSION_HOOK_NAME);
+  const helperPath = path34.join(commonDir, ...HELPER);
   const helperCurrent = readText3(helperPath) === SESSION_TRAILER_SCRIPT;
   const leftover = leftoverOf(hooksDir);
   const base = { hooksDir, hookPath, helperPath, helperCurrent, ...leftover ? { leftover } : {} };
@@ -65955,7 +65995,7 @@ function inspectSessionHook(cwd, env = process.env) {
     return blocked(`${hookPath} belongs to ${owner === "other" ? "another hook" : owner}; Workit never replaces it`, owner, text);
   }
   if (!inside2(hooksDir, commonDir)) {
-    const rel = path33.relative(top.out, hookPath).split(path33.sep).join("/");
+    const rel = path34.relative(top.out, hookPath).split(path34.sep).join("/");
     if (!run2(top.out, ["check-ignore", "-q", "--", rel], env).ok)
       return blocked(`${hooksDir} is in the working tree and not ignored; the hook would show up as a new file`, "other");
   }
@@ -66096,8 +66136,8 @@ exit 0
   });
   return { ok: r.status === 0, out: (r.stdout ?? "").trim() };
 }, inside2 = (child, parent) => {
-  const rel = path33.relative(path33.resolve(parent), path33.resolve(child));
-  return rel === "" || !rel.startsWith("..") && !path33.isAbsolute(rel);
+  const rel = path34.relative(path34.resolve(parent), path34.resolve(child));
+  return rel === "" || !rel.startsWith("..") && !path34.isAbsolute(rel);
 }, readText3 = (file) => {
   try {
     return readFileSync13(file, "utf8");
@@ -66111,7 +66151,7 @@ exit 0
   } catch {
     return false;
   }
-}, LEFTHOOK_CONFIGS, lefthookConfig = (top) => LEFTHOOK_CONFIGS.map((name) => path33.join(top, name)).find((file) => existsSync13(file)) ?? null, isComment = (line) => /^\s*#/.test(line), COMMAND_SH, DIRECT_CALL, VAR_CALL, runsHelperText = (text) => {
+}, LEFTHOOK_CONFIGS, lefthookConfig = (top) => LEFTHOOK_CONFIGS.map((name) => path34.join(top, name)).find((file) => existsSync13(file)) ?? null, isComment = (line) => /^\s*#/.test(line), COMMAND_SH, DIRECT_CALL, VAR_CALL, runsHelperText = (text) => {
   const lines = text.split(/\r?\n/).filter((line) => !isComment(line));
   const assigned = lines.some((line) => /(?:^|[\s;])h=/.test(line) && line.includes(HELPER_REF));
   return lines.some((line) => DIRECT_CALL.test(line) || assigned && VAR_CALL.test(line));
@@ -66156,14 +66196,14 @@ exit 0
 }, manualInPlace = (input, target) => {
   if (input.owner === "lefthook")
     return LEFTHOOK_YAML.some((name) => {
-      const text = readText3(path33.join(input.top, name));
+      const text = readText3(path34.join(input.top, name));
       return text !== null && lefthookRunsHelper(text);
     });
   const text = readText3(target);
   if (text === null || !runsHelperText(text))
     return false;
   return input.owner === "husky" && target !== input.hookPath || isExecutable(target);
-}, isHuskyV9 = (text, hooksDir) => /\$\(dirname (?:-- )?"\$0"\)\/h"/.test(text) && existsSync13(path33.join(hooksDir, "h")), ownerOf = (text, hooksDir, top) => {
+}, isHuskyV9 = (text, hooksDir) => /\$\(dirname (?:-- )?"\$0"\)\/h"/.test(text) && existsSync13(path34.join(hooksDir, "h")), ownerOf = (text, hooksDir, top) => {
   if (text.includes("husky.sh") || isHuskyV9(text, hooksDir))
     return "husky";
   if (/lefthook/i.test(text) || lefthookConfig(top))
@@ -66171,9 +66211,9 @@ exit 0
   return "other";
 }, manualTargetOf = ({ owner, text, hooksDir, hookPath, top }) => {
   if (owner === "husky" && isHuskyV9(text, hooksDir))
-    return path33.join(path33.dirname(hooksDir), SESSION_HOOK_NAME);
+    return path34.join(path34.dirname(hooksDir), SESSION_HOOK_NAME);
   if (owner === "lefthook")
-    return lefthookConfig(top) ?? path33.join(top, "lefthook.yml");
+    return lefthookConfig(top) ?? path34.join(top, "lefthook.yml");
   return hookPath;
 }, manualFor = (input) => {
   const { owner, displaced } = input;
@@ -66192,8 +66232,8 @@ exit 0
 `);
   return `add this line to ${target} (a new file needs \`#!/bin/sh\` as its first line and \`chmod +x\`)${stale}: ${manualTrailerLine()}`;
 }, leftoverOf = (hooksDir) => {
-  const chained = path33.join(hooksDir, LEGACY_CHAINED);
-  const commitMsg = path33.join(hooksDir, "commit-msg");
+  const chained = path34.join(hooksDir, LEGACY_CHAINED);
+  const commitMsg = path34.join(hooksDir, "commit-msg");
   const oldOurs = readText3(commitMsg)?.includes(SESSION_HOOK_MARKER) ?? false;
   if (exists(chained))
     return oldOurs ? `${chained} was left by an earlier Workit build: move it back to ${commitMsg} (replacing Workit's old hook there)` : `${chained} was left by an earlier Workit build and nothing runs it: if it is your original commit-msg hook, move it back to ${commitMsg}; otherwise delete it`;
@@ -66201,7 +66241,7 @@ exit 0
     return `${commitMsg} is a hook from an earlier Workit build; delete it (the trailer now comes from ${SESSION_HOOK_NAME})`;
   return;
 }, writeExecutable = (file, content) => {
-  mkdirSync5(path33.dirname(file), { recursive: true });
+  mkdirSync5(path34.dirname(file), { recursive: true });
   const staged = `${file}.workit-new`;
   try {
     writeFileSync6(staged, content, { mode: 493 });
@@ -66264,13 +66304,13 @@ import {
   writeFileSync as writeFileSync7
 } from "node:fs";
 import os9 from "node:os";
-import path34 from "node:path";
+import path35 from "node:path";
 var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
-  let dir = path34.resolve(cwd);
+  let dir = path35.resolve(cwd);
   while (true) {
-    if (existsSync14(path34.join(dir, "packages", "workit-core", "package.json")))
+    if (existsSync14(path35.join(dir, "packages", "workit-core", "package.json")))
       return dir;
-    const parent = path34.dirname(dir);
+    const parent = path35.dirname(dir);
     if (parent === dir)
       return null;
     dir = parent;
@@ -66278,8 +66318,8 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
 }, resolve = (options) => {
   const env = options.env ?? process.env;
   const home = options.home ?? env.HOME ?? os9.homedir();
-  const configDir = options.configDir ?? env.WORKFLOW_TOOLKIT_CONFIG ?? env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path34.join(home, ".config", "workit");
-  const stateDir = options.stateDir ?? env.WORKFLOW_TOOLKIT_STATE ?? path34.join(home, ".local", "state", "workit");
+  const configDir = options.configDir ?? env.WORKFLOW_TOOLKIT_CONFIG ?? env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path35.join(home, ".config", "workit");
+  const stateDir = options.stateDir ?? env.WORKFLOW_TOOLKIT_STATE ?? path35.join(home, ".local", "state", "workit");
   const cwd = options.cwd ?? process.cwd();
   const dev = options.dev?.trim() || env.WORKFLOW_TOOLKIT_DEV?.trim() || findDevFromCwd(cwd);
   return {
@@ -66290,11 +66330,11 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     cwd,
     workspaceRoot: options.workspaceRoot ?? env.WORKFLOW_WORKSPACE_ROOT ?? cwd,
     dev,
-    opencodeConfig: options.opencodeConfig ?? path34.join(home, ".config", "opencode", "opencode.json"),
+    opencodeConfig: options.opencodeConfig ?? path35.join(home, ".config", "opencode", "opencode.json"),
     opencodePackageCacheDir: options.opencodePackageCacheDir ?? null,
-    cursorSettings: options.cursorSettings ?? path34.join(home, ".cursor", "settings.json"),
-    cursorMcp: options.cursorMcp ?? path34.join(home, ".cursor", "mcp.json"),
-    cursorPluginDir: options.cursorPluginDir ?? path34.join(home, ".cursor", "plugins", "local", "workit"),
+    cursorSettings: options.cursorSettings ?? path35.join(home, ".cursor", "settings.json"),
+    cursorMcp: options.cursorMcp ?? path35.join(home, ".cursor", "mcp.json"),
+    cursorPluginDir: options.cursorPluginDir ?? path35.join(home, ".cursor", "plugins", "local", "workit"),
     cursorHeartbeatDir: options.stateDir ?? (env.WORKFLOW_TOOLKIT_STATE || resolveStateDir()),
     hookStateDir: options.stateDir ?? (env.WORKFLOW_TOOLKIT_STATE || resolveStateDir()),
     codexHome: options.codexHome,
@@ -66323,12 +66363,12 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     ...new Set(entries.filter((entry) => typeof entry === "string" && isWorkitPlugin(entry)))
   ];
 }, commandOnPath = (name, env) => findOnPath(process.platform === "win32" ? [name, `${name}.exe`] : [name], env) !== null, pathextNames = (name, env) => process.platform === "win32" ? (env.PATHEXT ?? process.env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean).map((ext) => `${name}${ext.toLowerCase()}`) : [name], findOnPath = (names, env) => {
-  const dirs = (env.PATH ?? process.env.PATH ?? "").split(path34.delimiter);
+  const dirs = (env.PATH ?? process.env.PATH ?? "").split(path35.delimiter);
   for (const dir of dirs) {
     if (!dir)
       continue;
     for (const candidateName of names) {
-      const candidate = path34.join(dir, candidateName);
+      const candidate = path35.join(dir, candidateName);
       try {
         const st = statSync5(candidate);
         if (process.platform !== "win32" && (st.mode & 73) === 0)
@@ -66357,7 +66397,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   if (env.BUN && existsSync14(env.BUN))
     return env.BUN;
   for (const candidate of [
-    path34.join(env.HOME || os9.homedir(), ".bun/bin/bun"),
+    path35.join(env.HOME || os9.homedir(), ".bun/bin/bun"),
     "/usr/local/bin/bun",
     "/usr/bin/bun"
   ]) {
@@ -66412,7 +66452,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
       detail: "installed package, not a dev checkout — version parity applies to checkouts only"
     };
   }
-  const corePkg = readJson(path34.join(res.dev, "packages/workit-core/package.json"));
+  const corePkg = readJson(path35.join(res.dev, "packages/workit-core/package.json"));
   if (!corePkg) {
     return {
       id: "versions",
@@ -66422,7 +66462,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   }
   const refs = new Set;
   for (const name of ["workit-opencode", "workit-cursor", "workit-cli"]) {
-    const pkg = readJson(path34.join(res.dev, "packages", name, "package.json"));
+    const pkg = readJson(path35.join(res.dev, "packages", name, "package.json"));
     const dep = pkg?.dependencies?.["@brainervirus/workit-core"] ?? pkg?.devDependencies?.["@brainervirus/workit-core"];
     if (typeof dep === "string")
       refs.add(dep);
@@ -66438,7 +66478,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   if (refs.size > 1) {
     problems.push(`adapters pin different core versions: ${[...refs].join(", ")}`);
   }
-  const opencodePkg = readJson(path34.join(res.dev, "packages/workit-opencode/package.json"));
+  const opencodePkg = readJson(path35.join(res.dev, "packages/workit-opencode/package.json"));
   const sdk = opencodePkg?.dependencies?.["@opencode/plugin"] ?? opencodePkg?.devDependencies?.["@opencode/plugin"];
   const sdkVersion = typeof sdk === "string" ? (sdk.match(/^\d+(?:\.\d+){0,2}/) ?? [])[0] : null;
   if (sdkVersion && !semverAtLeast(sdkVersion, SUPPORT_MATRIX.opencode.minimum)) {
@@ -66465,14 +66505,14 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
       status: "pass",
       detail: "opencode CLI not on PATH — skipping version check"
     };
-  const scratch = mkdtempSync(path34.join(os9.tmpdir(), "workit-doctor-opencode-"));
+  const scratch = mkdtempSync(path35.join(os9.tmpdir(), "workit-doctor-opencode-"));
   let raw;
   try {
     raw = versionOf("opencode", {
       ...res.env,
-      XDG_DATA_HOME: path34.join(scratch, "data"),
-      XDG_STATE_HOME: path34.join(scratch, "state"),
-      XDG_CACHE_HOME: path34.join(scratch, "cache")
+      XDG_DATA_HOME: path35.join(scratch, "data"),
+      XDG_STATE_HOME: path35.join(scratch, "state"),
+      XDG_CACHE_HOME: path35.join(scratch, "cache")
     }, 5000);
   } finally {
     rmSync3(scratch, { recursive: true, force: true });
@@ -66574,19 +66614,19 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     current[unquote(pair[1])] = value === "true" ? true : value === "false" ? false : unquote(value);
   }
   return tables;
-}, codexHomeOf = (res) => res.codexHome ?? (res.env.CODEX_HOME || path34.join(res.home, ".codex")), codexWorkitInstalls = (res) => {
+}, codexHomeOf = (res) => res.codexHome ?? (res.env.CODEX_HOME || path35.join(res.home, ".codex")), codexWorkitInstalls = (res) => {
   const codexHome = codexHomeOf(res);
-  const configFile = path34.join(codexHome, "config.toml");
+  const configFile = path35.join(codexHome, "config.toml");
   const installs = [];
   for (const [key, table] of readTomlTables(configFile)) {
     const [kind, id, ...rest] = key.split("\x00");
     if (kind !== "plugins" || rest.length > 0 || !id?.startsWith("workit@") || table.enabled === false)
       continue;
     const marketplace = id.slice("workit@".length);
-    const dir = path34.join(codexHome, "plugins", "cache", marketplace, "workit");
+    const dir = path35.join(codexHome, "plugins", "cache", marketplace, "workit");
     let versions = [];
     try {
-      versions = readdirSync8(dir).filter((v) => existsSync14(path34.join(dir, v, ".codex-plugin")));
+      versions = readdirSync8(dir).filter((v) => existsSync14(path35.join(dir, v, ".codex-plugin")));
     } catch {
       versions = [];
     }
@@ -66594,7 +66634,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     installs.push({
       id,
       marketplace,
-      root: version ? path34.join(dir, version) : null,
+      root: version ? path35.join(dir, version) : null,
       version,
       configFile
     });
@@ -66616,7 +66656,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   };
   return `sha256:${createHash14("sha256").update(JSON.stringify(body)).digest("hex")}`;
 }, codexHookTrust = (install, tables) => {
-  const hooks = install.root ? readJson(path34.join(install.root, "hooks", "hooks.json"))?.hooks : null;
+  const hooks = install.root ? readJson(path35.join(install.root, "hooks", "hooks.json"))?.hooks : null;
   if (!hooks || typeof hooks !== "object")
     return null;
   const result = [];
@@ -66689,25 +66729,25 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
       status: "pass",
       detail: "no Workit Codex plugin enabled — skipping"
     };
-  const agentsDir = path34.join(codexHomeOf(res), "agents");
+  const agentsDir = path35.join(codexHomeOf(res), "agents");
   const problems = [];
   const fixes = [];
   const installed = [];
   for (const install of installs) {
-    const source = install.root ? path34.join(install.root, "agents") : null;
+    const source = install.root ? path35.join(install.root, "agents") : null;
     const files = source && existsSync14(source) ? readdirSync8(source).filter((f) => f.endsWith(".toml")).toSorted() : [];
     if (files.length === 0) {
       problems.push(`${install.id} ${install.version ?? "?"} bundles no agents`);
       fixes.push(`codex plugin remove ${install.id} && codex plugin add ${install.id}`);
       continue;
     }
-    const install_fix = `node ${JSON.stringify(path34.join(install.root, "dist", "launch-mcp.js"))} --install-agents, then start a new Codex session`;
-    const pluginVersion = readJson(path34.join(install.root, "package.json"))?.version;
+    const install_fix = `node ${JSON.stringify(path35.join(install.root, "dist", "launch-mcp.js"))} --install-agents, then start a new Codex session`;
+    const pluginVersion = readJson(path35.join(install.root, "package.json"))?.version;
     const version = typeof pluginVersion === "string" ? pluginVersion.match(SEMVER)?.[0] ?? null : null;
     let stale = false;
     for (const file of files) {
-      const dest = path34.join(agentsDir, file);
-      const want = stampCodexAgent(readFileSync14(path34.join(source, file), "utf8"), version);
+      const dest = path35.join(agentsDir, file);
+      const want = stampCodexAgent(readFileSync14(path35.join(source, file), "utf8"), version);
       let link = false;
       try {
         link = lstatSync5(dest).isSymbolicLink();
@@ -66760,7 +66800,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   const env = res.env.PI_CODING_AGENT_DIR;
   if (env)
     return env === "~" ? res.home : env.replace(/^~(?=\/|\\)/, res.home);
-  return path34.join(res.home, ".pi", "agent");
+  return path35.join(res.home, ".pi", "agent");
 }, npmSpecName = (spec) => {
   const at = spec.indexOf("@", spec.startsWith("@") ? 1 : 0);
   return at > 0 ? { name: spec.slice(0, at), pinned: true } : { name: spec, pinned: false };
@@ -66768,10 +66808,10 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   const scopes = [
     {
       scope: "project",
-      settingsFile: path34.join(res.cwd, ".pi", "settings.json"),
-      base: path34.join(res.cwd, ".pi")
+      settingsFile: path35.join(res.cwd, ".pi", "settings.json"),
+      base: path35.join(res.cwd, ".pi")
     },
-    { scope: "user", settingsFile: path34.join(agentDir, "settings.json"), base: agentDir }
+    { scope: "user", settingsFile: path35.join(agentDir, "settings.json"), base: agentDir }
   ];
   for (const { scope, settingsFile, base } of scopes) {
     const packages = readJson(settingsFile)?.packages;
@@ -66786,13 +66826,13 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
         const spec = npmSpecName(source.slice(4).trim());
         if (spec.name !== PI_PACKAGE)
           continue;
-        const root = path34.join(base, "npm", "node_modules", ...PI_PACKAGE.split("/"));
+        const root = path35.join(base, "npm", "node_modules", ...PI_PACKAGE.split("/"));
         return { scope, settingsFile, source, filter, root, npm: { pinned: spec.pinned } };
       }
       if (/^(git:|https?:|ssh:|git@)/.test(source))
         continue;
-      const local = path34.resolve(base, source.replace(/^~(?=\/|\\)/, res.home));
-      if (readJson(path34.join(local, "package.json"))?.name === PI_PACKAGE)
+      const local = path35.resolve(base, source.replace(/^~(?=\/|\\)/, res.home));
+      if (readJson(path35.join(local, "package.json"))?.name === PI_PACKAGE)
         return { scope, settingsFile, source, filter, root: local, npm: null };
     }
   }
@@ -66803,7 +66843,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   const list = patterns.filter((p) => typeof p === "string");
   if (list.length === 0)
     return false;
-  const name = path34.posix.basename(file);
+  const name = path35.posix.basename(file);
   const matches = (p) => {
     const re = globToRegExp3(p);
     return re.test(file) || re.test(name);
@@ -66828,12 +66868,12 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     return {
       id: "pi_extension",
       status: "warn",
-      detail: `Workit Pi extension missing: no ${PI_PACKAGE} entry in ${path34.join(agentDir, "settings.json")} or ${path34.join(res.cwd, ".pi", "settings.json")}`,
+      detail: `Workit Pi extension missing: no ${PI_PACKAGE} entry in ${path35.join(agentDir, "settings.json")} or ${path35.join(res.cwd, ".pi", "settings.json")}`,
       fix: installCmd("user")
     };
   const where = `${entry.source} (${entry.scope}, ${entry.settingsFile})`;
   const rebuild = `cd ${JSON.stringify(entry.root)} && bun run build`;
-  const pkg = readJson(path34.join(entry.root, "package.json"));
+  const pkg = readJson(path35.join(entry.root, "package.json"));
   if (!pkg)
     return {
       id: "pi_extension",
@@ -66842,7 +66882,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
       fix: entry.npm ? installCmd(entry.scope, entry.source) : `restore ${entry.root}, then ${rebuild}`
     };
   const declared = Array.isArray(pkg.pi?.extensions) ? pkg.pi.extensions.some((e) => typeof e === "string" && e.replace(/^\.\//, "") === PI_EXTENSION) : false;
-  if (!declared || !existsSync14(path34.join(entry.root, PI_EXTENSION)))
+  if (!declared || !existsSync14(path35.join(entry.root, PI_EXTENSION)))
     return {
       id: "pi_extension",
       status: "warn",
@@ -66895,21 +66935,21 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     detail: `Workit Pi extension ${version ?? "?"} from ${where} loads ${PI_EXTENSION}`
   };
 }, assetPathsFor = (host, dev) => {
-  const pkg = path34.join(dev, "packages", `workit-${host}`);
+  const pkg = path35.join(dev, "packages", `workit-${host}`);
   switch (host) {
     case "opencode": {
-      const packaged = path34.join(pkg, "assets", "skills");
-      const root = existsSync14(packaged) ? packaged : path34.join(dev, "packages", "workit-core", "skills");
-      return WORKIT_METHOD_SKILLS.map((skill) => path34.join(root, skill, "SKILL.md"));
+      const packaged = path35.join(pkg, "assets", "skills");
+      const root = existsSync14(packaged) ? packaged : path35.join(dev, "packages", "workit-core", "skills");
+      return WORKIT_METHOD_SKILLS.map((skill) => path35.join(root, skill, "SKILL.md"));
     }
     case "cursor":
       return [
-        path34.join(pkg, "assets", "templates", "workit-contract.md"),
-        path34.join(pkg, "mcp.json"),
-        path34.join(pkg, ".cursor-plugin")
+        path35.join(pkg, "assets", "templates", "workit-contract.md"),
+        path35.join(pkg, "mcp.json"),
+        path35.join(pkg, ".cursor-plugin")
       ];
     case "cli":
-      return [path34.join(pkg, "assets", "templates", "spec-template.md")];
+      return [path35.join(pkg, "assets", "templates", "spec-template.md")];
   }
 }, hostsFor = (host) => host === "cli" ? ["opencode", "cursor", "cli"] : [host], checkAssets = (res) => {
   const dev = res.dev;
@@ -66940,17 +66980,17 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     fix: "Reinstall or rebuild the workit package (missing assets under packages/workit-<host>)"
   };
 }, launcherSlotsFor = (host, dev) => {
-  const pkg = path34.join(dev, "packages", `workit-${host}`);
+  const pkg = path35.join(dev, "packages", `workit-${host}`);
   switch (host) {
     case "opencode":
-      return [[path34.join(pkg, "src", "plugin.ts"), path34.join(pkg, "dist", "plugin.js")]];
+      return [[path35.join(pkg, "src", "plugin.ts"), path35.join(pkg, "dist", "plugin.js")]];
     case "cursor":
       return [
-        [path34.join(pkg, "dist", "mcp-server.js")],
-        [path34.join(pkg, "dist", "cursor-session-start.js")]
+        [path35.join(pkg, "dist", "mcp-server.js")],
+        [path35.join(pkg, "dist", "cursor-session-start.js")]
       ];
     case "cli":
-      return [[path34.join(pkg, "src", "index.tsx"), path34.join(pkg, "dist", "index.js")]];
+      return [[path35.join(pkg, "src", "index.tsx"), path35.join(pkg, "dist", "index.js")]];
   }
 }, validNodeEntry = (entry, runtime, env) => {
   try {
@@ -66977,7 +67017,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   if (typeof command !== "string" || !Array.isArray(args) || typeof args[0] !== "string") {
     return "invalid";
   }
-  const executable = path34.basename(command).toLowerCase();
+  const executable = path35.basename(command).toLowerCase();
   const canonical = cursorMcpServerEntry("").args;
   if (executable === "npx" || executable === "npx.exe" || executable === "npx.cmd") {
     if (args.length !== canonical.length || args.some((a, i) => a !== canonical[i]))
@@ -66989,10 +67029,10 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   return {
     kind: "node",
     runtime: command,
-    entry: path34.isAbsolute(args[0]) ? args[0] : path34.resolve(path34.dirname(res.cursorMcp), args[0])
+    entry: path35.isAbsolute(args[0]) ? args[0] : path35.resolve(path35.dirname(res.cursorMcp), args[0])
   };
 }, canonicalCursorHook, isCanonicalCursorHook = (command, res) => command === canonicalCursorHook || command === cursorHooksEntry(res.cursorPluginDir).command, registeredCursorHook = (res) => {
-  const hooksFile = path34.join(res.cursorPluginDir, "hooks", "hooks-cursor.json");
+  const hooksFile = path35.join(res.cursorPluginDir, "hooks", "hooks-cursor.json");
   if (!existsSync14(hooksFile))
     return "invalid";
   const config = readJson(hooksFile);
@@ -67010,9 +67050,9 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   if (!m)
     return false;
   const entry = m[1].trim();
-  if (!path34.isAbsolute(entry))
+  if (!path35.isAbsolute(entry))
     return false;
-  if (path34.resolve(entry) !== path34.resolve(path34.join(res.cursorPluginDir, "dist", "cursor-session-start.js"))) {
+  if (path35.resolve(entry) !== path35.resolve(path35.join(res.cursorPluginDir, "dist", "cursor-session-start.js"))) {
     return false;
   }
   return validNodeEntry(entry, "node", res.env);
@@ -67021,7 +67061,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   const hosts = hostsFor(res.host);
   const registered = hosts.includes("cursor") ? registeredCursorLauncher(res) : null;
   const runtime = registered && registered !== "invalid" && registered.kind === "node" ? registered.runtime : "node";
-  const missing = hosts.includes("cursor") ? ["dist/mcp-server.js", "dist/cursor-session-start.js"].map((rel) => path34.join(res.cursorPluginDir, rel)).filter((p) => !validNodeEntry(p, runtime, res.env)).map((p) => `cursor: ${p}`) : [];
+  const missing = hosts.includes("cursor") ? ["dist/mcp-server.js", "dist/cursor-session-start.js"].map((rel) => path35.join(res.cursorPluginDir, rel)).filter((p) => !validNodeEntry(p, runtime, res.env)).map((p) => `cursor: ${p}`) : [];
   if (hosts.includes("cursor")) {
     if (registered === "invalid") {
       missing.push(`cursor: canonical workit MCP launcher in ${res.cursorMcp}`);
@@ -67030,9 +67070,9 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     }
     const hook = registeredCursorHook(res);
     if (hook === "invalid") {
-      missing.push(`cursor: canonical session-start hook in ${path34.join(res.cursorPluginDir, "hooks", "hooks-cursor.json")}`);
+      missing.push(`cursor: canonical session-start hook in ${path35.join(res.cursorPluginDir, "hooks", "hooks-cursor.json")}`);
     } else if (hook !== null && !isCanonicalCursorHook(hook, res) && !validLocalDistHook(hook, res)) {
-      missing.push(`cursor: canonical session-start hook in ${path34.join(res.cursorPluginDir, "hooks", "hooks-cursor.json")} (registered ${hook})`);
+      missing.push(`cursor: canonical session-start hook in ${path35.join(res.cursorPluginDir, "hooks", "hooks-cursor.json")} (registered ${hook})`);
     }
   }
   if (dev) {
@@ -67067,7 +67107,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
       status: "pass",
       detail: "no Cursor plugin install — hook launcher not inspected"
     };
-  const launcher = path34.join(res.cursorPluginDir, "hooks", "launch.mjs");
+  const launcher = path35.join(res.cursorPluginDir, "hooks", "launch.mjs");
   if (!existsSync14(launcher))
     return {
       id: "cursor_hook",
@@ -67075,7 +67115,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
       detail: `cursor hook launcher mode: missing — ${launcher} is absent (an install from before the pinned launcher)`,
       fix: CURSOR_HOOK_FIX
     };
-  const hooksFile = path34.join(res.cursorPluginDir, "hooks", "hooks-cursor.json");
+  const hooksFile = path35.join(res.cursorPluginDir, "hooks", "hooks-cursor.json");
   const registered = readJson(hooksFile);
   const sessionCommand = registered?.hooks?.sessionStart?.[0]?.command;
   const offLauncher = [
@@ -67142,10 +67182,10 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     return null;
   }
 }, silentCursorHooks = (res) => {
-  const session = mtimeMs(path34.join(res.cursorHeartbeatDir, "cursor-session-last-start"));
+  const session = mtimeMs(path35.join(res.cursorHeartbeatDir, "cursor-session-last-start"));
   if (session === null || Date.now() - session < SILENT_HOOK_GRACE_MS)
     return null;
-  const hook = mtimeMs(path34.join(res.cursorHeartbeatDir, "cursor-hook-last-run"));
+  const hook = mtimeMs(path35.join(res.cursorHeartbeatDir, "cursor-hook-last-run"));
   if (hook !== null && hook >= session)
     return null;
   return `Cursor started the Workit MCP server at ${new Date(session).toISOString()} but no Workit hook has run since${hook === null ? " (none ever)" : ""} — if the agent ran in that window, Cursor is not running the plugin hooks and Workit enforcement is off`;
@@ -67241,7 +67281,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   }
   return { id: "stale_pin", status: "pass", detail: "opencode pin resolves" };
 }, pluginMcpSelectors = (res) => {
-  const p = path34.join(res.cursorPluginDir, "mcp.json");
+  const p = path35.join(res.cursorPluginDir, "mcp.json");
   if (!existsSync14(p))
     return null;
   const cfg = readJson(p);
@@ -67275,19 +67315,19 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     return null;
   }
 }, installedPluginVersion = (res) => {
-  const pkg = readJson(path34.join(res.cursorPluginDir, "package.json"));
+  const pkg = readJson(path35.join(res.cursorPluginDir, "package.json"));
   return typeof pkg?.version === "string" && pkg.version ? pkg.version : null;
 }, installedOpenCodeCache = (res) => {
   if (res.opencodePackageCacheDir !== null) {
-    const pkg = readJson(path34.join(res.opencodePackageCacheDir, "node_modules", "@brainervirus", "workit-opencode", "package.json"));
+    const pkg = readJson(path35.join(res.opencodePackageCacheDir, "node_modules", "@brainervirus", "workit-opencode", "package.json"));
     return typeof pkg?.version === "string" && pkg.version ? { version: pkg.version, dir: res.opencodePackageCacheDir } : null;
   }
   const found = openCodeInstalledPlugin(res.home, res.env);
   if (!found)
     return null;
-  let dir = path34.dirname(path34.dirname(path34.dirname(found.root)));
-  if (path34.basename(dir) !== "workit-opencode@latest")
-    dir = path34.dirname(dir);
+  let dir = path35.dirname(path35.dirname(path35.dirname(found.root)));
+  if (path35.basename(dir) !== "workit-opencode@latest")
+    dir = path35.dirname(dir);
   return { version: found.version, dir };
 }, checkOpenCodePackageCache = (res) => {
   if (!existsSync14(res.opencodeConfig)) {
@@ -67391,7 +67431,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
       fix: "Re-run install-cursor-plugin.sh — it rewrites the workit MCP entry to the canonical @latest selector"
     };
   }
-  const hooksFile = path34.join(res.cursorPluginDir, "hooks", "hooks-cursor.json");
+  const hooksFile = path35.join(res.cursorPluginDir, "hooks", "hooks-cursor.json");
   const hookCmd = readJson(hooksFile)?.hooks?.sessionStart?.[0]?.command ?? null;
   const canonicalHook = canonicalCursorHook;
   const staleHook = hookCmd !== null && !isCanonicalCursorHook(hookCmd, res) && !hookCmd.startsWith("node ") && hookCmd.includes("@brainervirus/workit-cursor@");
@@ -67413,7 +67453,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     };
   }
   const installed = installedPluginVersion(res);
-  const source = res.dev ? readJson(path34.join(res.dev, "packages/workit-cursor/package.json"))?.version ?? null : readJson(path34.join(packageRoot(), "package.json"))?.version ?? null;
+  const source = res.dev ? readJson(path35.join(res.dev, "packages/workit-cursor/package.json"))?.version ?? null : readJson(path35.join(packageRoot(), "package.json"))?.version ?? null;
   const localDist = mcpSelectors === null && hookCmd !== null && !isCanonicalCursorHook(hookCmd, res) && hookCmd.startsWith("node ");
   if (localDist && installed !== null && source !== null && !semverAtLeast(installed, source)) {
     return {
@@ -67425,7 +67465,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   }
   if (localDist && installed !== null && source !== null && res.dev) {
     const entry = /^node\s+(.+)$/.exec((hookCmd ?? "").trim())?.[1]?.trim() ?? "";
-    const sourceBundle = entry && path34.isAbsolute(entry) ? path34.join(res.dev, "packages", "workit-cursor", "dist", path34.basename(entry)) : "";
+    const sourceBundle = entry && path35.isAbsolute(entry) ? path35.join(res.dev, "packages", "workit-cursor", "dist", path35.basename(entry)) : "";
     if (entry && sourceBundle) {
       const installedHash = bundleHashOfFile(entry);
       const sourceHash = bundleHashOfFile(sourceBundle);
@@ -67433,7 +67473,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
         return {
           id: "stale_install",
           status: "fail",
-          detail: `stale_install: installed workit-cursor ${installed} runs different bytes than the current runtime build (${path34.basename(entry)} hash mismatch)`,
+          detail: `stale_install: installed workit-cursor ${installed} runs different bytes than the current runtime build (${path35.basename(entry)} hash mismatch)`,
           fix: "Re-run install-cursor-plugin.sh — it refreshes the plugin directory with the current build"
         };
       }
@@ -67533,7 +67573,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
 }, checkMalformedConfig = (res) => {
   const files = [];
   for (const name of ["config.json", "youtrack.json", "vcs.json", "workspaces.json"]) {
-    const p = path34.join(res.configDir, name);
+    const p = path35.join(res.configDir, name);
     if (existsSync14(p))
       files.push(p);
   }
@@ -67731,11 +67771,11 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   }
 }, checkCredentialMetadata = (res) => {
   const tokenPaths = [];
-  const youtrackJson = readJson(path34.join(res.configDir, "youtrack.json"));
+  const youtrackJson = readJson(path35.join(res.configDir, "youtrack.json"));
   if (youtrackJson) {
-    tokenPaths.push(typeof youtrackJson.tokenFile === "string" ? youtrackJson.tokenFile : path34.join(res.configDir, "youtrack.token"));
-  } else if (existsSync14(path34.join(res.configDir, "youtrack.token"))) {
-    tokenPaths.push(path34.join(res.configDir, "youtrack.token"));
+    tokenPaths.push(typeof youtrackJson.tokenFile === "string" ? youtrackJson.tokenFile : path35.join(res.configDir, "youtrack.token"));
+  } else if (existsSync14(path35.join(res.configDir, "youtrack.token"))) {
+    tokenPaths.push(path35.join(res.configDir, "youtrack.token"));
   }
   if (tokenPaths.length === 0) {
     return {
@@ -67746,7 +67786,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   }
   const problems = [];
   for (const raw of tokenPaths) {
-    const p = path34.isAbsolute(raw) ? raw : path34.resolve(res.configDir, raw);
+    const p = path35.isAbsolute(raw) ? raw : path35.resolve(res.configDir, raw);
     if (!existsSync14(p)) {
       problems.push(`${p} is missing`);
       continue;
@@ -67862,7 +67902,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   const remoteHost = githubHostFromRemote(probes.origin(res.cwd) ?? "");
   if (!remoteHost)
     return { id: "github_identity", status: "pass", detail: "no GitHub remote configured" };
-  const vcsJson = readJson(res.env.WORKFLOW_VCS_CONFIG ?? path34.join(res.configDir, "vcs.json"));
+  const vcsJson = readJson(res.env.WORKFLOW_VCS_CONFIG ?? path35.join(res.configDir, "vcs.json"));
   const workspace = workspaceProviderForIdentity(res.cwd, res.configDir, res.env);
   if (workspace.error)
     return {
@@ -67890,7 +67930,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   const remoteHost = githubHostFromRemote(probes.origin(res.cwd) ?? "");
   if (!remoteHost)
     return { id: "gitlab_identity", status: "pass", detail: "no GitLab remote configured" };
-  const vcsJson = readJson(res.env.WORKFLOW_VCS_CONFIG ?? path34.join(res.configDir, "vcs.json"));
+  const vcsJson = readJson(res.env.WORKFLOW_VCS_CONFIG ?? path35.join(res.configDir, "vcs.json"));
   const workspace = workspaceProviderForIdentity(res.cwd, res.configDir, res.env);
   if (workspace.error)
     return {
@@ -67916,8 +67956,8 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     { surface: "SSH", login: probes.sshLogin(remoteHost) }
   ]);
 }, checkLogWritable = (res) => {
-  const logsDir = path34.join(res.stateDir, "logs");
-  const probe = path34.join(logsDir, "doctor-probe.tmp");
+  const logsDir = path35.join(res.stateDir, "logs");
+  const probe = path35.join(logsDir, "doctor-probe.tmp");
   try {
     mkdirSync6(logsDir, { recursive: true, mode: 448 });
     writeFileSync7(probe, `{"probe":true}
@@ -67995,7 +68035,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   const counts = { skip: 0, late: 0 };
   let text = "";
   try {
-    text = readFileSync14(path34.join(stateDir, HOOK_SKIPS_FILE), "utf8");
+    text = readFileSync14(path35.join(stateDir, HOOK_SKIPS_FILE), "utf8");
   } catch {
     return counts;
   }
@@ -68013,7 +68053,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   }
   return counts;
 }, checkHookDeadline = (res) => {
-  const file = path34.join(res.hookStateDir, HOOK_SKIPS_FILE);
+  const file = path35.join(res.hookStateDir, HOOK_SKIPS_FILE);
   const { skip, late } = countHookSkips(res.hookStateDir, Date.now() - DAY_MS);
   const lateText = late > 0 ? `; ${late} answered past it in full` : "";
   if (skip > 0)
@@ -68036,8 +68076,8 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   };
 }, checkChecksConfig = (res) => {
   const root = checkRoot(res.cwd);
-  const current = existsSync14(path34.join(root, CHECKS_FILE));
-  const legacy = existsSync14(path34.join(root, LEGACY_CHECKS_FILE));
+  const current = existsSync14(path35.join(root, CHECKS_FILE));
+  const legacy = existsSync14(path35.join(root, LEGACY_CHECKS_FILE));
   if (!legacy)
     return {
       id: "checks_config",
@@ -68052,8 +68092,8 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
   };
 }, fixChecksConfig = (options = {}) => {
   const root = checkRoot(resolve(options).cwd);
-  const from = path34.join(root, LEGACY_CHECKS_FILE);
-  const to = path34.join(root, CHECKS_FILE);
+  const from = path35.join(root, LEGACY_CHECKS_FILE);
+  const to = path35.join(root, CHECKS_FILE);
   if (!existsSync14(from))
     return { action: "none", detail: `no ${LEGACY_CHECKS_FILE} at ${root}` };
   if (existsSync14(to))
@@ -68101,7 +68141,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
 }, HOOK_ISSUED_MARKER = "workit-issued-sessions/3", hookRecordsIssued = (root) => {
   let files;
   try {
-    files = readdirSync8(path34.join(root, "dist")).filter((f) => f.endsWith(".js"));
+    files = readdirSync8(path35.join(root, "dist")).filter((f) => f.endsWith(".js"));
   } catch {
     return null;
   }
@@ -68109,7 +68149,7 @@ var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE", findDevFromCwd = (cwd) => {
     return null;
   return files.some((file) => {
     try {
-      return readFileSync14(path34.join(root, "dist", file), "utf8").includes(HOOK_ISSUED_MARKER);
+      return readFileSync14(path35.join(root, "dist", file), "utf8").includes(HOOK_ISSUED_MARKER);
     } catch {
       return false;
     }
@@ -68325,7 +68365,7 @@ import {
 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import os10 from "node:os";
-import path35 from "node:path";
+import path36 from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
 function parseList(raw) {
   return raw.split(",").map((s) => s.trim()).filter(Boolean);
@@ -68370,7 +68410,7 @@ function buildSetupPreview(values, opts = {}) {
     const current = readConfigFromDir(state.configDir);
     mutations.push({
       type: "merge-json",
-      path: path35.join(state.configDir, "config.json"),
+      path: path36.join(state.configDir, "config.json"),
       value: {
         locale: values.locale,
         localeOptions: current.localeOptions,
@@ -68396,17 +68436,17 @@ function buildSetupPreview(values, opts = {}) {
       if (blocked.length === 0) {
         mutations.push({
           type: "update-workspaces",
-          path: path35.join(state.configDir, "workspaces.json"),
+          path: path36.join(state.configDir, "workspaces.json"),
           entries: values.workspaces,
           expectedRevision: diskWorkspaceResult.revision
         });
       }
     }
     if (values.baseUrl.trim()) {
-      const ytPath = path35.join(state.configDir, "youtrack.json");
+      const ytPath = path36.join(state.configDir, "youtrack.json");
       const ytExisting = readConfigRecord(ytPath);
       const ytConfigured = configuredTokenPath(ytExisting, "tokenFile");
-      const tokenPath = resolveTokenPath(ytConfigured, path35.join(state.configDir, "youtrack.token"), values.tokenPaths?.youtrack);
+      const tokenPath = resolveTokenPath(ytConfigured, path36.join(state.configDir, "youtrack.token"), values.tokenPaths?.youtrack);
       const draft = youtrackDraft(values, tokenPath);
       if (ytConfigured !== null && tokenPath !== ytConfigured) {
         delete draft.tokenFile;
@@ -68434,7 +68474,7 @@ function buildSetupPreview(values, opts = {}) {
         });
     }
     if (values.vcsProvider !== "skip") {
-      const vcsPath = path35.join(state.configDir, "vcs.json");
+      const vcsPath = path36.join(state.configDir, "vcs.json");
       mutations.push({
         type: "merge-json",
         path: vcsPath,
@@ -68463,7 +68503,7 @@ function buildSetupPreview(values, opts = {}) {
             mutations.push({
               type: "install-host",
               platform: "cursor",
-              path: path35.join(paths.home, ".cursor", "plugins", "local", ".workit-package-bootstrap"),
+              path: path36.join(paths.home, ".cursor", "plugins", "local", ".workit-package-bootstrap"),
               commands
             });
           }
@@ -68476,7 +68516,7 @@ function buildSetupPreview(values, opts = {}) {
             mutations.push({
               type: "install-host",
               platform,
-              path: platform === "claude-code" ? claudeInstallRecord(paths.home, env) : platform === "codex" ? path35.join(env.CODEX_HOME ?? path35.join(paths.home, ".codex"), "plugins", "cache", "workflow-toolkit", "workit") : path35.join(env.PI_CODING_AGENT_DIR ?? path35.join(paths.home, ".pi", "agent"), "settings.json"),
+              path: platform === "claude-code" ? claudeInstallRecord(paths.home, env) : platform === "codex" ? path36.join(env.CODEX_HOME ?? path36.join(paths.home, ".codex"), "plugins", "cache", "workflow-toolkit", "workit") : path36.join(env.PI_CODING_AGENT_DIR ?? path36.join(paths.home, ".pi", "agent"), "settings.json"),
               commands
             });
           }
@@ -68488,7 +68528,7 @@ function buildSetupPreview(values, opts = {}) {
       projectRefused = target.refused;
     if (target?.ok) {
       const root = target.root;
-      const gitignorePath = path35.join(root, ".gitignore");
+      const gitignorePath = path36.join(root, ".gitignore");
       const existing = existsSync15(gitignorePath) ? readFileSync15(gitignorePath, "utf8") : "";
       const existingLines = new Set(existing.split(`
 `).map((l) => l.trim()).filter(Boolean));
@@ -68526,7 +68566,7 @@ function deepMerge(base, patch) {
   return out;
 }
 function applyMutation(m) {
-  const dir = path35.dirname(m.path);
+  const dir = path36.dirname(m.path);
   switch (m.type) {
     case "create-file": {
       mkdirSync7(dir, { recursive: true });
@@ -68675,7 +68715,7 @@ function applyMutation(m) {
           detail: "already configured"
         };
       }
-      mkdirSync7(path35.dirname(m.path), { recursive: true });
+      mkdirSync7(path36.dirname(m.path), { recursive: true });
       writeFileSync8(m.path, JSON.stringify(merged, null, 2) + `
 `, "utf8");
       return existing.kind === "record" ? { platform: "core", file: m.path, status: "Configured" } : { platform: "core", file: m.path, status: "Installed" };
@@ -68684,11 +68724,11 @@ function applyMutation(m) {
 }
 function adapterRoot(platform, res, preferInstalledAdapter = false) {
   const candidates = [];
-  const stagedCursor = path35.join(res.home, ".cursor", "plugins", "local", ".workit-package-bootstrap", "node_modules", "@brainervirus", "workit-cursor");
+  const stagedCursor = path36.join(res.home, ".cursor", "plugins", "local", ".workit-package-bootstrap", "node_modules", "@brainervirus", "workit-cursor");
   if (platform === "cursor" && preferInstalledAdapter)
     candidates.push(stagedCursor);
   if (res.dev) {
-    candidates.push(path35.join(res.dev, "packages", `workit-${platform}`));
+    candidates.push(path36.join(res.dev, "packages", `workit-${platform}`));
   } else {
     candidates.push(...nodeResolvedAdapters(platform));
     if (platform === "cursor")
@@ -68698,10 +68738,10 @@ function adapterRoot(platform, res, preferInstalledAdapter = false) {
       if (cached)
         candidates.push(cached.root);
     }
-    let dir = path35.resolve(res.cwd);
+    let dir = path36.resolve(res.cwd);
     while (true) {
-      candidates.push(path35.join(dir, "packages", `workit-${platform}`));
-      const parent = path35.dirname(dir);
+      candidates.push(path36.join(dir, "packages", `workit-${platform}`));
+      const parent = path36.dirname(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -68723,7 +68763,7 @@ function applyOpenCode(root, res) {
       detail: "workit-opencode package has no loadable plugin entry (src/plugin.ts or dist/plugin.js)"
     };
   }
-  mkdirSync7(path35.dirname(res.opencodeConfig), { recursive: true });
+  mkdirSync7(path36.dirname(res.opencodeConfig), { recursive: true });
   const existing = readExisting(res.opencodeConfig);
   if (existing.kind === "malformed") {
     return {
@@ -68768,31 +68808,31 @@ function applyOpenCode(root, res) {
 }
 function copyPluginDir(src, dest) {
   const realSrc = realpathSync7(src);
-  const marker = path35.join(dest, ".workit-root");
+  const marker = path36.join(dest, ".workit-root");
   const destIsLink = existsSync15(dest) && lstatSync6(dest).isSymbolicLink();
   const synced = !destIsLink && readFileSafe(marker)?.trim() === realSrc && samePluginContent(realSrc, dest, dest);
   if (synced)
     return "Skipped";
   const hadDir = existsSync15(dest);
   const rules = preservedCursorRules(realSrc, dest);
-  const parent = path35.dirname(dest);
+  const parent = path36.dirname(dest);
   mkdirSync7(parent, { recursive: true });
-  const swap = mkdtempSync2(path35.join(parent, `.${path35.basename(dest)}.swap-`));
-  const stage = path35.join(swap, "stage");
-  const backup = path35.join(swap, "backup");
+  const swap = mkdtempSync2(path36.join(parent, `.${path36.basename(dest)}.swap-`));
+  const stage = path36.join(swap, "stage");
+  const backup = path36.join(swap, "backup");
   try {
     cpSync4(realSrc, stage, {
       recursive: true,
-      filter: (entry) => !path35.relative(realSrc, entry).split(path35.sep).includes("node_modules")
+      filter: (entry) => !path36.relative(realSrc, entry).split(path36.sep).includes("node_modules")
     });
-    const stagedHooks = path35.join(stage, CURSOR_HOOKS_FILE);
+    const stagedHooks = path36.join(stage, CURSOR_HOOKS_FILE);
     if (existsSync15(stagedHooks))
       writeFileSync8(stagedHooks, localizedCursorHooks(readFileSync15(stagedHooks), dest));
     for (const [name, content] of rules) {
-      mkdirSync7(path35.join(stage, "rules"), { recursive: true });
-      writeFileSync8(path35.join(stage, "rules", name), content);
+      mkdirSync7(path36.join(stage, "rules"), { recursive: true });
+      writeFileSync8(path36.join(stage, "rules", name), content);
     }
-    writeFileSync8(path35.join(stage, ".workit-root"), realSrc + `
+    writeFileSync8(path36.join(stage, ".workit-root"), realSrc + `
 `, "utf8");
     if (!samePluginContent(realSrc, stage, dest))
       throw new Error("staged adapter content is incomplete");
@@ -68815,7 +68855,7 @@ function copyPluginDir(src, dest) {
   return hadDir ? "Configured" : "Installed";
 }
 function applyCursorSettings(root, res) {
-  mkdirSync7(path35.dirname(res.cursorSettings), { recursive: true });
+  mkdirSync7(path36.dirname(res.cursorSettings), { recursive: true });
   const settingsExisting = readExisting(res.cursorSettings);
   if (settingsExisting.kind === "malformed") {
     return {
@@ -68843,7 +68883,7 @@ function applyCursorSettings(root, res) {
   };
 }
 function applyCursorMcp(root, res) {
-  mkdirSync7(path35.dirname(res.cursorMcp), { recursive: true });
+  mkdirSync7(path36.dirname(res.cursorMcp), { recursive: true });
   const mcpExisting = readExisting(res.cursorMcp);
   if (mcpExisting.kind === "malformed") {
     return {
@@ -68949,7 +68989,7 @@ function applySetupPreview(preview, options = {}) {
   let cursorCopyOk = false;
   for (const mutation of preview.mutations) {
     if (mutation.type === "install-host") {
-      const expectedPath = mutation.platform === "cursor" ? path35.join(res.home, ".cursor", "plugins", "local", ".workit-package-bootstrap") : mutation.platform === "codex" ? path35.join(res.env.CODEX_HOME ?? path35.join(res.home, ".codex"), "plugins", "cache", "workflow-toolkit", "workit") : mutation.platform === "pi" ? path35.join(res.env.PI_CODING_AGENT_DIR ?? path35.join(res.home, ".pi", "agent"), "settings.json") : mutation.platform === "claude-code" ? claudeInstallRecord(res.home, res.env) : "";
+      const expectedPath = mutation.platform === "cursor" ? path36.join(res.home, ".cursor", "plugins", "local", ".workit-package-bootstrap") : mutation.platform === "codex" ? path36.join(res.env.CODEX_HOME ?? path36.join(res.home, ".codex"), "plugins", "cache", "workflow-toolkit", "workit") : mutation.platform === "pi" ? path36.join(res.env.PI_CODING_AGENT_DIR ?? path36.join(res.home, ".pi", "agent"), "settings.json") : mutation.platform === "claude-code" ? claudeInstallRecord(res.home, res.env) : "";
       if (mutation.path !== expectedPath) {
         entries.push({
           platform: mutation.platform,
@@ -69061,7 +69101,7 @@ function applySetupPreview(preview, options = {}) {
   if (preview.projectRefused) {
     entries.push({
       platform: "core",
-      file: path35.resolve(res.cwd),
+      file: path36.resolve(res.cwd),
       status: "Skipped",
       detail: preview.projectRefused
     });
@@ -69147,7 +69187,7 @@ var TOKEN_PLACEHOLDER3 = "YOUR_TOKEN_HERE", YT_OVERRIDES, VCS_OVERRIDES, SETUP_O
   } catch {
     return null;
   }
-}, claudeInstallRecord = (home, env) => path35.join(claudeConfigDir(home, env), "plugins", "installed_plugins.json"), resolveSetupPaths = (options, resolvedConfigDir) => {
+}, claudeInstallRecord = (home, env) => path36.join(claudeConfigDir(home, env), "plugins", "installed_plugins.json"), resolveSetupPaths = (options, resolvedConfigDir) => {
   const env = options.env ?? process.env;
   const home = options.home ?? env.HOME ?? os10.homedir();
   return {
@@ -69155,10 +69195,10 @@ var TOKEN_PLACEHOLDER3 = "YOUR_TOKEN_HERE", YT_OVERRIDES, VCS_OVERRIDES, SETUP_O
     configDir: resolvedConfigDir,
     cwd: options.cwd ?? process.cwd(),
     env,
-    opencodeConfig: options.opencodeConfig ?? path35.join(home, ".config", "opencode", "opencode.json"),
-    cursorSettings: options.cursorSettings ?? path35.join(home, ".cursor", "settings.json"),
-    cursorMcp: options.cursorMcp ?? path35.join(home, ".cursor", "mcp.json"),
-    cursorPluginDir: options.cursorPluginDir ?? path35.join(home, ".cursor", "plugins", "local", "workit")
+    opencodeConfig: options.opencodeConfig ?? path36.join(home, ".config", "opencode", "opencode.json"),
+    cursorSettings: options.cursorSettings ?? path36.join(home, ".cursor", "settings.json"),
+    cursorMcp: options.cursorMcp ?? path36.join(home, ".cursor", "mcp.json"),
+    cursorPluginDir: options.cursorPluginDir ?? path36.join(home, ".cursor", "plugins", "local", "workit")
   };
 }, isRecord5 = (v) => v !== null && typeof v === "object" && !Array.isArray(v), readExisting = (p) => {
   let raw;
@@ -69195,15 +69235,15 @@ var TOKEN_PLACEHOLDER3 = "YOUR_TOKEN_HERE", YT_OVERRIDES, VCS_OVERRIDES, SETUP_O
   }
 }, isAdapter = (root, platform) => {
   try {
-    const pkg = JSON.parse(readFileSync15(path35.join(root, "package.json"), "utf8"));
+    const pkg = JSON.parse(readFileSync15(path36.join(root, "package.json"), "utf8"));
     return pkg.name === `@brainervirus/workit-${platform}`;
   } catch {
     return false;
   }
 }, nodeResolvedAdapters = (platform) => {
   const name = `@brainervirus/workit-${platform}`;
-  const require2 = createRequire2(path35.join(packageRoot(), "package.json"));
-  return (require2.resolve.paths(name) ?? []).map((dir) => path35.join(dir, name));
+  const require2 = createRequire2(path36.join(packageRoot(), "package.json"));
+  return (require2.resolve.paths(name) ?? []).map((dir) => path36.join(dir, name));
 }, realRoot = (root) => {
   try {
     return realpathSync7(root);
@@ -69219,7 +69259,7 @@ var TOKEN_PLACEHOLDER3 = "YOUR_TOKEN_HERE", YT_OVERRIDES, VCS_OVERRIDES, SETUP_O
   if (!isDevOpenCodeAdapterRoot(root, opts.dev))
     return OPENCODE_NPM_PIN;
   for (const rel of ["src/plugin.ts", "dist/plugin.js"]) {
-    const entry = path35.join(root, rel);
+    const entry = path36.join(root, rel);
     if (existsSync15(entry))
       return `file://${entry}`;
   }
@@ -69237,9 +69277,9 @@ var TOKEN_PLACEHOLDER3 = "YOUR_TOKEN_HERE", YT_OVERRIDES, VCS_OVERRIDES, SETUP_O
     for (const entry of readdirSync9(src, { withFileTypes: true })) {
       if (entry.name === "node_modules")
         continue;
-      const source = path35.join(src, entry.name);
-      const installed = path35.join(dest, entry.name);
-      const rel = path35.join(relative, entry.name);
+      const source = path36.join(src, entry.name);
+      const installed = path36.join(dest, entry.name);
+      const rel = path36.join(relative, entry.name);
       if (entry.isDirectory()) {
         if (!statSync6(installed).isDirectory() || !samePluginContent(source, installed, pluginDir, rel))
           return false;
@@ -69250,9 +69290,9 @@ var TOKEN_PLACEHOLDER3 = "YOUR_TOKEN_HERE", YT_OVERRIDES, VCS_OVERRIDES, SETUP_O
       }
     }
     for (const entry of readdirSync9(dest, { withFileTypes: true })) {
-      if (existsSync15(path35.join(src, entry.name)))
+      if (existsSync15(path36.join(src, entry.name)))
         continue;
-      const rel = path35.join(relative, entry.name);
+      const rel = path36.join(relative, entry.name);
       if (rel === ".workit-root")
         continue;
       if (relative === "rules" && entry.isFile() && entry.name.endsWith(".mdc"))
@@ -69265,32 +69305,32 @@ var TOKEN_PLACEHOLDER3 = "YOUR_TOKEN_HERE", YT_OVERRIDES, VCS_OVERRIDES, SETUP_O
   }
 }, preservedCursorRules = (src, dest) => {
   const preserved = new Map;
-  const sourceRules = path35.join(src, "rules");
-  const installedRules = path35.join(dest, "rules");
+  const sourceRules = path36.join(src, "rules");
+  const installedRules = path36.join(dest, "rules");
   try {
     for (const entry of readdirSync9(installedRules, { withFileTypes: true })) {
       if (!entry.isFile() || !entry.name.endsWith(".mdc"))
         continue;
-      if (existsSync15(path35.join(sourceRules, entry.name)))
+      if (existsSync15(path36.join(sourceRules, entry.name)))
         continue;
-      preserved.set(entry.name, readFileSync15(path35.join(installedRules, entry.name)));
+      preserved.set(entry.name, readFileSync15(path36.join(installedRules, entry.name)));
     }
   } catch {}
   return preserved;
 }, removeLegacyCursorDir = (res) => {
-  const legacy = path35.join(res.home, ".cursor", "plugins", "local", "workflow-toolkit");
+  const legacy = path36.join(res.home, ".cursor", "plugins", "local", "workflow-toolkit");
   if (legacy === res.cursorPluginDir || !existsSync15(legacy))
     return;
-  const legacyRules = path35.join(legacy, "rules");
+  const legacyRules = path36.join(legacy, "rules");
   if (existsSync15(legacyRules)) {
     try {
-      mkdirSync7(path35.join(res.cursorPluginDir, "rules"), { recursive: true });
+      mkdirSync7(path36.join(res.cursorPluginDir, "rules"), { recursive: true });
       for (const entry of readdirSync9(legacyRules, { withFileTypes: true })) {
         if (!entry.isFile() || !entry.name.endsWith(".mdc"))
           continue;
-        const target = path35.join(res.cursorPluginDir, "rules", entry.name);
+        const target = path36.join(res.cursorPluginDir, "rules", entry.name);
         if (!existsSync15(target))
-          copyFileSync4(path35.join(legacyRules, entry.name), target);
+          copyFileSync4(path36.join(legacyRules, entry.name), target);
       }
     } catch {}
   }
@@ -69324,16 +69364,16 @@ var init_setup = __esm(() => {
     { envKey: "WORKFLOW_GITHUB_HOST", affects: "vcs.json github.host" }
   ];
   SETUP_OVERRIDES = [...YT_OVERRIDES, ...VCS_OVERRIDES];
-  CURSOR_HOOKS_FILE = path35.join("hooks", "hooks-cursor.json");
+  CURSOR_HOOKS_FILE = path36.join("hooks", "hooks-cursor.json");
 });
 
 // packages/workit-core/src/core/workspace-branch-policy.ts
 import { mkdirSync as mkdirSync8, readFileSync as readFileSync16, renameSync as renameSync6, rmSync as rmSync5, writeFileSync as writeFileSync9 } from "node:fs";
-import path36 from "node:path";
+import path37 from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual3 } from "node:util";
 function applyWorkspaceBranchPolicy(opts) {
   const { workspace_root, env = process.env } = opts;
-  const dir = path36.join(env.WORKFLOW_TOOLKIT_CONFIG ?? configDir());
+  const dir = path37.join(env.WORKFLOW_TOOLKIT_CONFIG ?? configDir());
   const {
     status,
     path: wsPath,
@@ -69345,7 +69385,7 @@ function applyWorkspaceBranchPolicy(opts) {
   if (status === "malformed" || status === "invalid")
     return { ok: false, error: workspacesError ?? `invalid workspaces.json: ${wsPath}` };
   const detection = detectBranchPolicy(workspace_root);
-  const name = String(env.WORKFLOW_BP_NAME ?? path36.basename(workspace_root));
+  const name = String(env.WORKFLOW_BP_NAME ?? path37.basename(workspace_root));
   const integration = env.WORKFLOW_BP_INTEGRATION ?? detection.integration;
   const policy = {
     preset: detection.preset,
@@ -69394,7 +69434,7 @@ function applyWorkspaceBranchPolicy(opts) {
       ok: false,
       error: `workspaces.json changed while applying the branch policy: ${wsPath}`
     };
-  mkdirSync8(path36.dirname(wsPath), { recursive: true });
+  mkdirSync8(path37.dirname(wsPath), { recursive: true });
   const tmp = `${wsPath}.${process.pid}.tmp`;
   try {
     writeFileSync9(tmp, JSON.stringify({ ...document2, workspaces: next }, null, 2) + `
@@ -69679,7 +69719,7 @@ var init_logic = __esm(() => {
 
 // packages/workit-cli/src/wizard-state.ts
 import { existsSync as existsSync16, statSync as statSync7 } from "node:fs";
-import path37 from "node:path";
+import path38 from "node:path";
 import { isDeepStrictEqual as isDeepStrictEqual4 } from "node:util";
 function resolveBasePath(values, env = process.env) {
   return env.WORKFLOW_WORKSPACE_ROOT?.trim() || values.basePath.trim();
@@ -70206,8 +70246,8 @@ var NEXT, PREV, skipsCustomBranch = (screen, preset) => (screen === "branchAllow
   const p = value.trim();
   if (!p)
     return "workspace root path is required";
-  return !path37.isAbsolute(p) || !isDirectory(p) ? `invalid workspace root "${p}" — enter an existing absolute directory` : null;
-}, skipsBranchPolicy = (screen, basePath) => (screen === "branchPolicy" || screen === "branchPolicyDevelop") && !existsSync16(path37.join(basePath, ".git")), decodeBranchPreset = (value, fallback) => value === "gitflow" || value === "github-flow" || value === "trunk-based" || value === "custom" ? value : fallback, decodeVcsProvider = (value, fallback) => value === "gitlab" || value === "github" || value === "skip" ? value : fallback, decodeIssueTracker = (value, fallback) => value === "youtrack" || value === "github" || value === "gitlab" || value === "none" ? value : fallback, GITHUB_ISSUES, withGithubIssues = (draft, tracker) => tracker === "github" ? { ...draft, issues: { ...GITHUB_ISSUES } } : draft;
+  return !path38.isAbsolute(p) || !isDirectory(p) ? `invalid workspace root "${p}" — enter an existing absolute directory` : null;
+}, skipsBranchPolicy = (screen, basePath) => (screen === "branchPolicy" || screen === "branchPolicyDevelop") && !existsSync16(path38.join(basePath, ".git")), decodeBranchPreset = (value, fallback) => value === "gitflow" || value === "github-flow" || value === "trunk-based" || value === "custom" ? value : fallback, decodeVcsProvider = (value, fallback) => value === "gitlab" || value === "github" || value === "skip" ? value : fallback, decodeIssueTracker = (value, fallback) => value === "youtrack" || value === "github" || value === "gitlab" || value === "none" ? value : fallback, GITHUB_ISSUES, withGithubIssues = (draft, tracker) => tracker === "github" ? { ...draft, issues: { ...GITHUB_ISSUES } } : draft;
 var init_wizard_state = __esm(() => {
   init_config();
   init_workspaces();
@@ -70268,7 +70308,7 @@ var init_wizard_state = __esm(() => {
 // packages/workit-cli/src/admin/uninstall.ts
 import { existsSync as existsSync17, readFileSync as readFileSync17, realpathSync as realpathSync8, rmSync as rmSync6, writeFileSync as writeFileSync10 } from "node:fs";
 import os11 from "node:os";
-import path38 from "node:path";
+import path39 from "node:path";
 function cleanCursorSettings(settings, pluginDir) {
   const next = { ...settings };
   let changed = false;
@@ -70443,8 +70483,8 @@ function applyUninstall(plan, paths = {}) {
         status = outcome.status;
         detail = outcome.detail;
       } else if (action.kind === "remove-dir") {
-        const resolved = path38.resolve(action.path);
-        const allowed = canonicalRemoveDirAllowed(resolved, res) || resolved === path38.resolve(res.codexPluginDir) && path38.basename(resolved) === "workit" && path38.basename(path38.dirname(resolved)) === "plugins";
+        const resolved = path39.resolve(action.path);
+        const allowed = canonicalRemoveDirAllowed(resolved, res) || resolved === path39.resolve(res.codexPluginDir) && path39.basename(resolved) === "workit" && path39.basename(path39.dirname(resolved)) === "plugins";
         if (!allowed) {
           status = "failed";
           detail = `refusing to remove non-canonical plugin directory: ${resolved}`;
@@ -70479,12 +70519,12 @@ function applyUninstall(plan, paths = {}) {
 var resolveUninstallPaths = (options = {}) => {
   const home = options.home ?? options.env?.HOME ?? os11.homedir();
   return {
-    opencodeConfig: options.opencodeConfig ?? path38.join(home, ".config", "opencode", "opencode.json"),
-    cursorSettings: options.cursorSettings ?? path38.join(home, ".cursor", "settings.json"),
-    cursorMcp: options.cursorMcp ?? path38.join(home, ".cursor", "mcp.json"),
-    cursorPluginDir: options.cursorPluginDir ?? path38.join(home, ".cursor", "plugins", "local", "workit"),
-    codexPluginDir: path38.join(home, ".codex", "plugins", "workit"),
-    piConfig: path38.join(home, ".pi", "config.json")
+    opencodeConfig: options.opencodeConfig ?? path39.join(home, ".config", "opencode", "opencode.json"),
+    cursorSettings: options.cursorSettings ?? path39.join(home, ".cursor", "settings.json"),
+    cursorMcp: options.cursorMcp ?? path39.join(home, ".cursor", "mcp.json"),
+    cursorPluginDir: options.cursorPluginDir ?? path39.join(home, ".cursor", "plugins", "local", "workit"),
+    codexPluginDir: path39.join(home, ".codex", "plugins", "workit"),
+    piConfig: path39.join(home, ".pi", "config.json")
   };
 }, isRecord6 = (v) => v !== null && typeof v === "object" && !Array.isArray(v), readJsonRecord = (file) => {
   let raw;
@@ -70502,8 +70542,8 @@ var resolveUninstallPaths = (options = {}) => {
     return { kind: "malformed", error: `${file} is not valid JSON` };
   }
 }, stripTrailingSep = (p) => {
-  const j = path38.join(p);
-  return path38.dirname(j) === j ? j : j.replace(/[\\/]+$/, "");
+  const j = path39.join(p);
+  return path39.dirname(j) === j ? j : j.replace(/[\\/]+$/, "");
 }, CURSOR_LEGACY_IDENTITIES, jsonCleanerFor = (target, res) => {
   if (target === res.opencodeConfig)
     return cleanOpenCodeConfig;
@@ -70515,8 +70555,8 @@ var resolveUninstallPaths = (options = {}) => {
     return cleanPiConfig;
   return null;
 }, canonicalRemoveDirAllowed = (actionPath, res) => {
-  const expected = path38.resolve(res.cursorPluginDir);
-  if (!(actionPath === expected && path38.basename(expected) === "workit" && path38.basename(path38.dirname(expected)) === "local" && path38.basename(path38.dirname(path38.dirname(expected))) === "plugins")) {
+  const expected = path39.resolve(res.cursorPluginDir);
+  if (!(actionPath === expected && path39.basename(expected) === "workit" && path39.basename(path39.dirname(expected)) === "local" && path39.basename(path39.dirname(path39.dirname(expected))) === "plugins")) {
     return false;
   }
   try {
@@ -70568,7 +70608,7 @@ var resolveUninstallPaths = (options = {}) => {
     };
   const home = paths.home ?? paths.env?.HOME ?? os11.homedir();
   const env = paths.env ?? process.env;
-  const recorded = claudeWorkitInstalls(home, env, action.cwd).some((install) => install.id === id && install.scope === scope && (install.projectPath === null ? action.cwd === null : path38.resolve(install.projectPath) === path38.resolve(action.cwd ?? "")));
+  const recorded = claudeWorkitInstalls(home, env, action.cwd).some((install) => install.id === id && install.scope === scope && (install.projectPath === null ? action.cwd === null : path39.resolve(install.projectPath) === path39.resolve(action.cwd ?? "")));
   if (!recorded)
     return { status: "skipped", detail: `${id} (${scope} scope) is no longer installed` };
   const executable = findHostExecutable("claude", { home, env });
@@ -73124,7 +73164,7 @@ import {
   cpSync as cpSync5,
   lstatSync as lstatSync7
 } from "node:fs";
-import path39 from "node:path";
+import path40 from "node:path";
 import os13 from "node:os";
 import { createHash as createHash15 } from "node:crypto";
 function previewUpgrade(hosts = HOSTS2, deps = {}) {
@@ -73148,9 +73188,9 @@ function previewUpgrade(hosts = HOSTS2, deps = {}) {
   for (const file of [
     paths.opencodeConfig,
     paths.opencodeConfig + "c",
-    path39.join(home, ".cursor/settings.json"),
-    path39.join(home, ".cursor/mcp.json"),
-    path39.join(home, ".cursor/plugins/local/workit/package.json"),
+    path40.join(home, ".cursor/settings.json"),
+    path40.join(home, ".cursor/mcp.json"),
+    path40.join(home, ".cursor/plugins/local/workit/package.json"),
     paths.codexConfig,
     paths.piSettings
   ])
@@ -73165,16 +73205,16 @@ function previewUpgrade(hosts = HOSTS2, deps = {}) {
       });
     const installedSources = sources(paths, run, hosts);
     if (installedSources.some((source) => source.host === "opencode")) {
-      const scratch = mkdtempSync3(path39.join(os13.tmpdir(), "workit-upgrade-opencode-"));
+      const scratch = mkdtempSync3(path40.join(os13.tmpdir(), "workit-upgrade-opencode-"));
       let probe;
       try {
         probe = runner({
           ...deps,
           env: {
             ...deps.env,
-            XDG_DATA_HOME: path39.join(scratch, "data"),
-            XDG_STATE_HOME: path39.join(scratch, "state"),
-            XDG_CACHE_HOME: path39.join(scratch, "cache")
+            XDG_DATA_HOME: path40.join(scratch, "data"),
+            XDG_STATE_HOME: path40.join(scratch, "state"),
+            XDG_CACHE_HOME: path40.join(scratch, "cache")
           }
         })("opencode", ["--version"]);
       } finally {
@@ -73220,7 +73260,7 @@ function previewUpgrade(hosts = HOSTS2, deps = {}) {
         env: deps.env,
         cwd: home,
         packageVersion: latest.stdout.trim(),
-        targetDir: path39.join(home, ".cursor/plugins/local/workit")
+        targetDir: path40.join(home, ".cursor/plugins/local/workit")
       });
       plan.entries.push({
         host: source.host,
@@ -73250,11 +73290,11 @@ function applyUpgrade(plan, deps = {}) {
       ok: false,
       error: "Stop the selected running hosts before upgrading their loaded plugins"
     };
-  const backup = path39.join(home, ".local/state/workit/upgrades", new Date().toISOString().replaceAll(":", "-"));
+  const backup = path40.join(home, ".local/state/workit/upgrades", new Date().toISOString().replaceAll(":", "-"));
   mkdirSync9(backup, { recursive: true, mode: 448 });
   for (const file of Object.keys(plan.configDigests))
     if (existsSync18(file)) {
-      const target = path39.join(backup, createHash15("sha256").update(file).digest("hex").slice(0, 12) + "-" + path39.basename(file));
+      const target = path40.join(backup, createHash15("sha256").update(file).digest("hex").slice(0, 12) + "-" + path40.basename(file));
       copyFileSync5(file, target);
       chmodSync2(target, 384);
     }
@@ -73271,9 +73311,9 @@ function applyUpgrade(plan, deps = {}) {
 `, 384);
   }
   const run = runner(deps);
-  const cursorRoot = path39.join(home, ".cursor/plugins/local/workit");
+  const cursorRoot = path40.join(home, ".cursor/plugins/local/workit");
   if (plan.entries.some((entry) => entry.host === "cursor") && existsSync18(cursorRoot))
-    cpSync5(cursorRoot, path39.join(backup, "cursor-package"), { recursive: true });
+    cpSync5(cursorRoot, path40.join(backup, "cursor-package"), { recursive: true });
   for (const entry of plan.entries) {
     if (entry.host === "opencode")
       return {
@@ -73293,7 +73333,7 @@ function applyUpgrade(plan, deps = {}) {
           {
             type: "install-host",
             platform: "cursor",
-            path: path39.join(home, ".cursor/plugins/local/.workit-package-bootstrap"),
+            path: path40.join(home, ".cursor/plugins/local/.workit-package-bootstrap"),
             commands: entry.commands.map((command) => ({
               ...command,
               purpose: command.purpose ?? "Upgrade Cursor"
@@ -73302,7 +73342,7 @@ function applyUpgrade(plan, deps = {}) {
           {
             type: "install-adapter",
             platform: "cursor",
-            path: path39.join(home, ".cursor/plugins/local/workit")
+            path: path40.join(home, ".cursor/plugins/local/workit")
           }
         ]
       };
@@ -73316,7 +73356,7 @@ function applyUpgrade(plan, deps = {}) {
           return { exitCode: outcome.status ?? 1, stdout: outcome.stdout, stderr: "" };
         }
       });
-      const pkg = object2(path39.join(home, ".cursor/plugins/local/workit/package.json"));
+      const pkg = object2(path40.join(home, ".cursor/plugins/local/workit/package.json"));
       if (!result.ok || pkg?.version !== entry.latest)
         return {
           ok: false,
@@ -73350,15 +73390,15 @@ function applyUpgrade(plan, deps = {}) {
     const currentRoot = run("npm", ["root", "--global"]);
     if (currentRoot.status !== 0 || currentRoot.stdout.trim() !== plan.cli.root)
       return { ok: false, backup, error: "Global npm location changed; preview again" };
-    const cliBackup = path39.join(backup, "cli-package");
-    cpSync5(path39.join(plan.cli.root, "@brainervirus/workit-cli"), cliBackup, { recursive: true });
+    const cliBackup = path40.join(backup, "cli-package");
+    cpSync5(path40.join(plan.cli.root, "@brainervirus/workit-cli"), cliBackup, { recursive: true });
     if (run("npm", ["install", "--global", `@brainervirus/workit-cli@${plan.cli.latest}`]).status !== 0)
       return {
         ok: false,
         backup,
-        error: `CLI update failed; preserved package at ${cliBackup}; use npm to repair or run node ${path39.join(cliBackup, "dist/index.js")}`
+        error: `CLI update failed; preserved package at ${cliBackup}; use npm to repair or run node ${path40.join(cliBackup, "dist/index.js")}`
       };
-    const installed = object2(path39.join(plan.cli.root, "@brainervirus/workit-cli/package.json"));
+    const installed = object2(path40.join(plan.cli.root, "@brainervirus/workit-cli/package.json"));
     if (installed?.name !== "@brainervirus/workit-cli" || installed.version !== plan.cli.latest)
       return {
         ok: false,
@@ -73383,12 +73423,12 @@ async function runUpgradeCommand(argv, deps = {}) {
   if (flags.has("--cli")) {
     const run = runner(deps);
     const root = run("npm", ["root", "--global"]);
-    if (root.status !== 0 || !path39.isAbsolute(root.stdout.trim())) {
+    if (root.status !== 0 || !path40.isAbsolute(root.stdout.trim())) {
       plan.blocked.push("Global npm location could not be verified");
     } else {
-      const packageFile = path39.join(root.stdout.trim(), "@brainervirus/workit-cli/package.json");
+      const packageFile = path40.join(root.stdout.trim(), "@brainervirus/workit-cli/package.json");
       const pkg = object2(packageFile);
-      if (pkg?.name !== "@brainervirus/workit-cli" || lstatSync7(path39.dirname(packageFile)).isSymbolicLink()) {
+      if (pkg?.name !== "@brainervirus/workit-cli" || lstatSync7(path40.dirname(packageFile)).isSymbolicLink()) {
         plan.skipped.push({
           host: "cli",
           reason: "No managed global CLI install (local links preserved); use npx @brainervirus/workit-cli@latest"
@@ -73479,23 +73519,23 @@ var HOSTS2, upgradePaths = (deps) => {
     ...process.env,
     ...deps.home || deps.env?.HOME ? {
       HOME: home,
-      CODEX_HOME: path39.join(home, ".codex"),
-      PI_CODING_AGENT_DIR: path39.join(home, ".pi/agent"),
-      XDG_CONFIG_HOME: path39.join(home, ".config"),
+      CODEX_HOME: path40.join(home, ".codex"),
+      PI_CODING_AGENT_DIR: path40.join(home, ".pi/agent"),
+      XDG_CONFIG_HOME: path40.join(home, ".config"),
       WORKFLOW_TOOLKIT_CONFIG: undefined,
       WORKFLOW_TOOLKIT_CONFIG_DIR: undefined
     } : {},
     ...deps.env,
     HOME: home
   };
-  const xdg = env.XDG_CONFIG_HOME || path39.join(home, ".config");
+  const xdg = env.XDG_CONFIG_HOME || path40.join(home, ".config");
   return {
     home,
     env,
-    configDir: env.WORKFLOW_TOOLKIT_CONFIG ?? env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path39.join(xdg, "workit"),
-    opencodeConfig: path39.join(xdg, "opencode/opencode.json"),
-    piSettings: path39.join(env.PI_CODING_AGENT_DIR ?? path39.join(home, ".pi/agent"), "settings.json"),
-    codexConfig: path39.join(env.CODEX_HOME ?? path39.join(home, ".codex"), "config.toml")
+    configDir: env.WORKFLOW_TOOLKIT_CONFIG ?? env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path40.join(xdg, "workit"),
+    opencodeConfig: path40.join(xdg, "opencode/opencode.json"),
+    piSettings: path40.join(env.PI_CODING_AGENT_DIR ?? path40.join(home, ".pi/agent"), "settings.json"),
+    codexConfig: path40.join(env.CODEX_HOME ?? path40.join(home, ".codex"), "config.toml")
   };
 }, object2 = (file) => {
   if (!existsSync18(file))
@@ -73535,9 +73575,9 @@ var HOSTS2, upgradePaths = (deps) => {
   for (const pin of plugins)
     if (typeof pin === "string" && isWorkitPlugin(pin))
       result.push(classify("opencode", pin));
-  const cursor = hosts.includes("cursor") ? object2(path39.join(home, ".cursor/plugins/local/workit/package.json")) : null;
+  const cursor = hosts.includes("cursor") ? object2(path40.join(home, ".cursor/plugins/local/workit/package.json")) : null;
   if (cursor?.name === "@brainervirus/workit-cursor") {
-    const mcp = object2(path39.join(home, ".cursor/mcp.json"));
+    const mcp = object2(path40.join(home, ".cursor/mcp.json"));
     const args = mcp?.mcpServers?.workit?.args ?? [];
     const selector = args.find((arg) => typeof arg === "string" && arg.startsWith("--package="));
     result.push(classify("cursor", typeof selector === "string" ? selector.slice(10) : "local"));
@@ -73550,7 +73590,7 @@ var HOSTS2, upgradePaths = (deps) => {
     if (typeof source !== "string")
       continue;
     const npm = /^(?:npm:)?@brainervirus\/workit-pi(?:@[^/]+)?$/.test(source);
-    const local = path39.isAbsolute(source) && source.replaceAll("\\", "/").endsWith("/packages/workit-pi") && object2(path39.join(source, "package.json"))?.name === "@brainervirus/workit-pi";
+    const local = path40.isAbsolute(source) && source.replaceAll("\\", "/").endsWith("/packages/workit-pi") && object2(path40.join(source, "package.json"))?.name === "@brainervirus/workit-pi";
     if (npm || local)
       result.push(classify("pi", source));
   }
@@ -73597,9 +73637,9 @@ var HOSTS2, upgradePaths = (deps) => {
 }, piInstalledVersion = (listing, selector) => {
   const lines = listing.split(/\r?\n/).map((line) => line.trim());
   const index = lines.indexOf(selector);
-  if (index < 0 || !lines[index + 1] || !path39.isAbsolute(lines[index + 1]))
+  if (index < 0 || !lines[index + 1] || !path40.isAbsolute(lines[index + 1]))
     return;
-  const pkg = object2(path39.join(lines[index + 1], "package.json"));
+  const pkg = object2(path40.join(lines[index + 1], "package.json"));
   return pkg?.name === "@brainervirus/workit-pi" ? pkg.version : undefined;
 }, versionAtLeast = (installed, latest) => {
   if (!/^\d+\.\d+\.\d+$/.test(installed))
@@ -73651,8 +73691,8 @@ var init_launch = __esm(() => {
 
 // packages/workit-core/src/knowledge.ts
 import { spawnSync as spawnSync18 } from "node:child_process";
-import fs19 from "node:fs";
-import path40 from "node:path";
+import fs20 from "node:fs";
+import path41 from "node:path";
 function lintKnowledge(root) {
   const seen = new Set;
   const unreadable = [];
@@ -73756,17 +73796,17 @@ 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 = path40.join(root, file);
+  const full = path41.join(root, file);
   try {
-    fs19.lstatSync(full);
+    fs20.lstatSync(full);
   } catch {
     return null;
   }
   try {
-    if (!fs19.statSync(full).isFile())
+    if (!fs20.statSync(full).isFile())
       return null;
-    const text = fs19.readFileSync(full, "utf8");
-    return { file, text, lines: text.split(/\r?\n/), real: fs19.realpathSync(full) };
+    const text = fs20.readFileSync(full, "utf8");
+    return { file, text, lines: text.split(/\r?\n/), real: fs20.realpathSync(full) };
   } catch {
     return "unreadable";
   }
@@ -73783,7 +73823,7 @@ var AGENTS_BYTE_BUDGET, STEERING_FILES, NEED_BASED_FILES, STANDARDS_FILE = "CODI
   return new Set(run.stdout.split("\x00").filter(Boolean).map((file) => file.split("/")[0]));
 }, exists2 = (target) => {
   try {
-    fs19.statSync(target);
+    fs20.statSync(target);
     return true;
   } catch {
     return false;
@@ -73797,7 +73837,7 @@ var AGENTS_BYTE_BUDGET, STEERING_FILES, NEED_BASED_FILES, STANDARDS_FILE = "CODI
   }
 }, brokenLinks = (root, doc, tracked) => {
   const findings = [];
-  const base = path40.dirname(path40.join(root, doc.file));
+  const base = path41.dirname(path41.join(root, doc.file));
   const missing = (target, line, how) => findings.push({
     rule: "broken-link",
     file: doc.file,
@@ -73816,7 +73856,7 @@ var AGENTS_BYTE_BUDGET, STEERING_FILES, NEED_BASED_FILES, STANDARDS_FILE = "CODI
       const local = localTarget(target);
       if (!local)
         continue;
-      const resolved = local.startsWith("/") ? path40.join(root, local) : path40.resolve(base, local);
+      const resolved = local.startsWith("/") ? path41.join(root, local) : path41.resolve(base, local);
       if (!exists2(resolved))
         missing(target, index + 1, "link");
     }
@@ -73826,9 +73866,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(path40.join(root, first))))
+      if (!relative && !(tracked ? tracked.has(first) : exists2(path41.join(root, first))))
         continue;
-      const resolved = relative ? path40.resolve(base, candidate) : path40.join(root, candidate);
+      const resolved = relative ? path41.resolve(base, candidate) : path41.join(root, candidate);
       if (!exists2(resolved))
         missing(span, index + 1, "pointer");
     }
@@ -74190,9 +74230,9 @@ var init_redact = __esm(() => {
 // packages/workit-core/src/checks.ts
 import { spawn, spawnSync as spawnSync19 } from "node:child_process";
 import { createHash as createHash16 } from "node:crypto";
-import fs20 from "node:fs";
+import fs21 from "node:fs";
 import os14 from "node:os";
-import path41 from "node:path";
+import path42 from "node:path";
 import { StringDecoder } from "node:string_decoder";
 function tailLines(text, lines = TAIL_LINES) {
   const all = text.replace(/\r\n?/gu, `
@@ -74312,10 +74352,10 @@ 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 = path41.win32;
+  const win = path42.win32;
   const isFile = options.isFile ?? ((file) => {
     try {
-      return fs20.statSync(file).isFile();
+      return fs21.statSync(file).isFile();
     } catch {
       return false;
     }
@@ -74474,13 +74514,13 @@ function runCheckCommand(argv, options) {
 function storeLog(storeRoot, log) {
   const digest = logDigest(log);
   const ref = `blobs/logs/${digest.slice("sha256:".length)}.log`;
-  const file = path41.join(storeRoot, ref);
+  const file = path42.join(storeRoot, ref);
   try {
-    if (!fs20.existsSync(file)) {
-      fs20.mkdirSync(path41.dirname(file), { recursive: true });
+    if (!fs21.existsSync(file)) {
+      fs21.mkdirSync(path42.dirname(file), { recursive: true });
       const temp = `${file}.${process.pid}.${Date.now()}.tmp`;
-      fs20.writeFileSync(temp, log, { mode: 384 });
-      fs20.renameSync(temp, file);
+      fs21.writeFileSync(temp, log, { mode: 384 });
+      fs21.renameSync(temp, file);
     }
     return { digest, ref };
   } catch {
@@ -74490,17 +74530,17 @@ function storeLog(storeRoot, log) {
 function pruneCheckLogs(storeRoot, options = {}) {
   const limits = { ...LOG_RETENTION, ...options.retention };
   const now = options.now ?? Date.now();
-  const dir = path41.join(storeRoot, "blobs", "logs");
+  const dir = path42.join(storeRoot, "blobs", "logs");
   const report = { removed: 0, removedBytes: 0, kept: 0 };
   let names;
   try {
-    names = fs20.readdirSync(dir);
+    names = fs21.readdirSync(dir);
   } catch {
     return report;
   }
   const files = names.flatMap((name) => {
     try {
-      const stat = fs20.statSync(path41.join(dir, name));
+      const stat = fs21.statSync(path42.join(dir, name));
       return stat.isFile() ? [{ name, size: stat.size, mtimeMs: stat.mtimeMs }] : [];
     } catch {
       return [];
@@ -74519,7 +74559,7 @@ function pruneCheckLogs(storeRoot, options = {}) {
       continue;
     if (!options.dryRun)
       try {
-        fs20.rmSync(path41.join(dir, file.name), { force: true });
+        fs21.rmSync(path42.join(dir, file.name), { force: true });
       } catch {
         continue;
       }
@@ -74769,13 +74809,13 @@ var init_grant = __esm(() => {
 });
 
 // packages/workit-core/src/core/heavy-rules.ts
-import fs21 from "node:fs";
-import path42 from "node:path";
+import fs22 from "node:fs";
+import path43 from "node:path";
 function gitTop(cwd) {
-  for (let dir = path42.resolve(cwd);; dir = path42.dirname(dir)) {
-    if (fs21.existsSync(path42.join(dir, ".git")))
+  for (let dir = path43.resolve(cwd);; dir = path43.dirname(dir)) {
+    if (fs22.existsSync(path43.join(dir, ".git")))
       return dir;
-    if (path42.dirname(dir) === dir)
+    if (path43.dirname(dir) === dir)
       return null;
   }
 }
@@ -74815,20 +74855,20 @@ var baseName = (word) => (word.split(/[\\/]/u).at(-1) ?? "").toLowerCase().repla
 var init_heavy_rules = () => {};
 
 // packages/workit-core/src/core/heavy.ts
-import fs22 from "node:fs";
+import fs23 from "node:fs";
 import os15 from "node:os";
-import path43 from "node:path";
+import path44 from "node:path";
 function stateDir(env, platform = process.platform) {
   if (env.WORKFLOW_TOOLKIT_STATE)
     return env.WORKFLOW_TOOLKIT_STATE;
   if (env.XDG_STATE_HOME)
-    return path43.join(env.XDG_STATE_HOME, "workit");
+    return path44.join(env.XDG_STATE_HOME, "workit");
   const home = env.HOME || os15.homedir();
   if (platform === "darwin")
-    return path43.join(home, "Library", "Application Support", "workit");
+    return path44.join(home, "Library", "Application Support", "workit");
   if (platform === "win32")
-    return path43.join(env.LOCALAPPDATA ?? path43.join(home, "AppData", "Local"), "workit");
-  return path43.join(home, ".local", "state", "workit");
+    return path44.join(env.LOCALAPPDATA ?? path44.join(home, "AppData", "Local"), "workit");
+  return path44.join(home, ".local", "state", "workit");
 }
 function positional(words, from, values = PM_VALUES) {
   let index = from;
@@ -74968,7 +75008,7 @@ function machinePatterns(env) {
   return isRecord7(value) ? stringList(value.patterns) : [];
 }
 function repoPatterns(cwd) {
-  return repoHeavyCommands(gitTop(cwd) ?? path43.resolve(cwd));
+  return repoHeavyCommands(gitTop(cwd) ?? path44.resolve(cwd));
 }
 function heavyLines(lines, options) {
   const found = [];
@@ -75047,9 +75087,9 @@ function leaseRewrite(command) {
     return null;
   return `${prefix}workit check --heavy -- ${rest}`;
 }
-var HEAVY_COMMANDS_FILE = "heavy-commands.json", heavyCommandsFile = (env) => path43.join(stateDir(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) => path44.join(stateDir(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(fs22.readFileSync(file, "utf8"));
+    return JSON.parse(fs23.readFileSync(file, "utf8"));
   } catch {
     return;
   }
@@ -75192,9 +75232,9 @@ var init_heavy = __esm(() => {
 
 // packages/workit-core/src/core/resources.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
-import fs23 from "node:fs";
+import fs24 from "node:fs";
 import os16 from "node:os";
-import path44 from "node:path";
+import path45 from "node:path";
 function memoryValue(value, host) {
   const text = typeof value === "number" ? String(value) : typeof value === "string" ? value : "";
   const percent = PERCENT.exec(text.trim());
@@ -75347,27 +75387,27 @@ function staleReason(lease, probe = {}) {
 function reclaim(file, stale) {
   const guard = `${file}.reclaim`;
   try {
-    fs23.mkdirSync(guard);
+    fs24.mkdirSync(guard);
   } catch {
     try {
-      if (Date.now() - fs23.statSync(guard).mtimeMs > GUARD_TTL_MS)
-        fs23.rmSync(guard, { force: true, recursive: true });
+      if (Date.now() - fs24.statSync(guard).mtimeMs > GUARD_TTL_MS)
+        fs24.rmSync(guard, { force: true, recursive: true });
     } catch {}
     return false;
   }
   try {
     let ageMs = 0;
     try {
-      ageMs = Date.now() - fs23.statSync(file).mtimeMs;
+      ageMs = Date.now() - fs24.statSync(file).mtimeMs;
     } catch {
       return true;
     }
     if (!stale(parseLease(readText4(file)), ageMs))
       return false;
-    fs23.rmSync(file, { force: true });
+    fs24.rmSync(file, { force: true });
     return true;
   } finally {
-    fs23.rmSync(guard, { force: true, recursive: true });
+    fs24.rmSync(guard, { force: true, recursive: true });
   }
 }
 function tryOnce(options, record, reclaimed) {
@@ -75375,14 +75415,14 @@ function tryOnce(options, record, reclaimed) {
   const text = `${JSON.stringify(record)}
 `;
   for (let slot = 0;slot < options.slots; slot += 1) {
-    const file = path44.join(options.dir, `slot-${slot}.json`);
+    const file = path45.join(options.dir, `slot-${slot}.json`);
     for (let attempt = 0;attempt < 2; attempt += 1) {
       try {
-        const fd = fs23.openSync(file, "wx", 384);
+        const fd = fs24.openSync(file, "wx", 384);
         try {
-          fs23.writeSync(fd, text);
+          fs24.writeSync(fd, text);
         } finally {
-          fs23.closeSync(fd);
+          fs24.closeSync(fd);
         }
         return { slot, file };
       } catch (error) {
@@ -75409,7 +75449,7 @@ function tryOnce(options, record, reclaimed) {
 }
 function removeOwn(file, id) {
   if (parseLease(readText4(file))?.id === id)
-    fs23.rmSync(file, { force: true });
+    fs24.rmSync(file, { force: true });
 }
 async function acquireLease(options) {
   const pid = options.pid ?? process.pid;
@@ -75429,7 +75469,7 @@ async function acquireLease(options) {
     scope: null
   };
   try {
-    fs23.mkdirSync(options.dir, { recursive: true, mode: 448 });
+    fs24.mkdirSync(options.dir, { recursive: true, mode: 448 });
   } catch (error) {
     return { ok: false, reason: "unavailable", error: error.message };
   }
@@ -75483,9 +75523,9 @@ function updateLease(lease, patch) {
     if (parseLease(readText4(lease.file))?.id !== lease.record.id)
       return;
     const temp = `${lease.file}.${process.pid}.tmp`;
-    fs23.writeFileSync(temp, `${JSON.stringify(lease.record)}
+    fs24.writeFileSync(temp, `${JSON.stringify(lease.record)}
 `, { mode: 384 });
-    fs23.renameSync(temp, lease.file);
+    fs24.renameSync(temp, lease.file);
   } catch {}
 }
 function heldLease(dir, id, options = {}) {
@@ -75493,14 +75533,14 @@ function heldLease(dir, id, options = {}) {
     return null;
   let names;
   try {
-    names = fs23.readdirSync(dir);
+    names = fs24.readdirSync(dir);
   } catch {
     return null;
   }
   for (const name of names) {
     if (!/^slot-\d+\.json$/u.test(name))
       continue;
-    const lease = parseLease(readText4(path44.join(dir, name)));
+    const lease = parseLease(readText4(path45.join(dir, name)));
     if (lease?.id === id && !staleReason(lease, options.probe) && (options.ancestor ?? isAncestor)(lease.pid))
       return lease;
   }
@@ -75555,10 +75595,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 = path44.join(stateDir(env), "notices");
+  const dir = path45.join(stateDir(env), "notices");
   try {
-    fs23.mkdirSync(dir, { recursive: true, mode: 448 });
-    fs23.writeFileSync(path44.join(dir, `${key}-${id}`), `${new Date(now).toISOString()}
+    fs24.mkdirSync(dir, { recursive: true, mode: 448 });
+    fs24.writeFileSync(path45.join(dir, `${key}-${id}`), `${new Date(now).toISOString()}
 `, {
       flag: "wx",
       mode: 384
@@ -75567,10 +75607,10 @@ function firstNotice(env, session, key, now = Date.now()) {
     return error.code !== "EEXIST";
   }
   try {
-    for (const name of fs23.readdirSync(dir)) {
-      const file = path44.join(dir, name);
-      if (now - fs23.statSync(file).mtimeMs > NOTICE_TTL_MS)
-        fs23.rmSync(file, { force: true });
+    for (const name of fs24.readdirSync(dir)) {
+      const file = path45.join(dir, name);
+      if (now - fs24.statSync(file).mtimeMs > NOTICE_TTL_MS)
+        fs24.rmSync(file, { force: true });
     }
   } catch {}
   return true;
@@ -75578,7 +75618,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(readText4(path44.join(dir, `slot-${slot}.json`)));
+    const lease = parseLease(readText4(path45.join(dir, `slot-${slot}.json`)));
     states.push({
       slot,
       holder: lease ? holderOf(lease) : null,
@@ -75590,9 +75630,9 @@ function leaseSlots(dir, slots, probe = {}) {
 var DEFAULT_HEAVY_CHECKS, DEFAULT_SLOTS = 1, DEFAULT_WAIT_S = 600, DEFAULT_MEMORY_SHARE = 0.4, DEFAULT_CPU_SHARE = 0.7, MAX_SLOTS = 64, UNREADABLE_TTL_MS = 30000, GUARD_TTL_MS = 30000, hostShape = () => ({
   totalMemBytes: os16.totalmem(),
   cpus: Math.max(1, os16.availableParallelism?.() ?? os16.cpus().length)
-}), isRecord8 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), SIZE, PERCENT, UNITS, leaseDir = (env) => path44.join(stateDir(env), "leases"), readText4 = (file) => {
+}), isRecord8 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), SIZE, PERCENT, UNITS, leaseDir = (env) => path45.join(stateDir(env), "leases"), readText4 = (file) => {
   try {
-    return fs23.readFileSync(file, "utf8");
+    return fs24.readFileSync(file, "utf8");
   } catch {
     return null;
   }
@@ -75643,7 +75683,7 @@ __export(exports_check, {
   workspaceResources: () => workspaceResources
 });
 import os17 from "node:os";
-import path45 from "node:path";
+import path46 from "node:path";
 function parse5(argv) {
   const split = argv.indexOf("--");
   const head = split >= 0 ? argv.slice(0, split) : [...argv];
@@ -75822,7 +75862,7 @@ function hostToolWaitCapMs(env) {
 }
 async function workspaceResources(io) {
   const env = io.env;
-  const dir = env.WORKFLOW_TOOLKIT_CONFIG ?? env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path45.join(env.XDG_CONFIG_HOME || path45.join(env.HOME || os17.homedir(), ".config"), "workit");
+  const dir = env.WORKFLOW_TOOLKIT_CONFIG ?? env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path46.join(env.XDG_CONFIG_HOME || path46.join(env.HOME || os17.homedir(), ".config"), "workit");
   try {
     await Promise.resolve().then(() => init_workspaces());
     const workspace = resolveWorkspaceFrom(io.cwd, dir, env.WORKFLOW_WORKSPACE_NAME?.trim() || undefined);
@@ -75941,7 +75981,7 @@ async function run10(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(path45.relative(top, runCwd));
+  const relCwd = posix(path46.relative(top, runCwd));
   const configured = !options.shell && matchesNamedCheck(config, name, command, relCwd);
   const actor = actorFromEnv(io.env);
   const branchKey = codeKey(io.cwd, { base: options.base });
@@ -76107,7 +76147,7 @@ async function run10(argv, io) {
     return recordError.code === "busy" ? 4 : recordError.code === "invalid_input" ? 2 : 5;
   return 0;
 }
-var USAGE3 = 'workit check <name> [--no-lease --reason "<why>"] | workit check [--name <n>] [--shell] [--heavy] [--wait <s>] [--timeout <s>] [--task <id>] [--json] -- <cmd…>', MAX_UNVERIFIED_RUN_MS, RECORD_TAIL_LINES = 20, RECORD_TAIL_CHARS = 200, posix = (value) => value.split(path45.sep).join("/") || ".", ENGINE_CODES2, FINGERPRINT_VARS, HOST_TOOL_WAIT_CAP_MS = 1e5;
+var USAGE3 = 'workit check <name> [--no-lease --reason "<why>"] | workit check [--name <n>] [--shell] [--heavy] [--wait <s>] [--timeout <s>] [--task <id>] [--json] -- <cmd…>', MAX_UNVERIFIED_RUN_MS, RECORD_TAIL_LINES = 20, RECORD_TAIL_CHARS = 200, posix = (value) => value.split(path46.sep).join("/") || ".", ENGINE_CODES2, FINGERPRINT_VARS, HOST_TOOL_WAIT_CAP_MS = 1e5;
 var init_check = __esm(() => {
   init_check_config();
   init_checks3();
@@ -76132,8 +76172,8 @@ var exports_lock = {};
 __export(exports_lock, {
   run: () => run11
 });
-import fs24 from "node:fs";
-import path46 from "node:path";
+import fs25 from "node:fs";
+import path47 from "node:path";
 async function settingsFor(io) {
   const workspace = await workspaceResources(io);
   const config = loadCheckConfig(io.cwd);
@@ -76205,7 +76245,7 @@ async function runHeavy(args, io) {
 }
 function readPatterns(file) {
   try {
-    const value = JSON.parse(fs24.readFileSync(file, "utf8"));
+    const value = JSON.parse(fs25.readFileSync(file, "utf8"));
     if (value && typeof value === "object" && !Array.isArray(value)) {
       const record = value;
       const patterns = Array.isArray(record.patterns) ? record.patterns.filter((item) => typeof item === "string") : [];
@@ -76215,11 +76255,11 @@ function readPatterns(file) {
   return { patterns: [] };
 }
 function writePatterns(file, value) {
-  fs24.mkdirSync(path46.dirname(file), { recursive: true, mode: 448 });
+  fs25.mkdirSync(path47.dirname(file), { recursive: true, mode: 448 });
   const temp = `${file}.${process.pid}.tmp`;
-  fs24.writeFileSync(temp, `${JSON.stringify(value, null, 2)}
+  fs25.writeFileSync(temp, `${JSON.stringify(value, null, 2)}
 `, { mode: 384 });
-  fs24.renameSync(temp, file);
+  fs25.renameSync(temp, file);
 }
 async function heavy(args, io) {
   const [action, ...rest] = args.filter((arg) => arg !== "--json");
@@ -76406,7 +76446,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 existsSync19, readFileSync as readFileSync19 } from "node:fs";
-import path47 from "node:path";
+import path48 from "node:path";
 function operationInProgress(cwd) {
   const markers = [
     ["rebase-merge", "rebase"],
@@ -76419,18 +76459,18 @@ function operationInProgress(cwd) {
   if (!run.ok)
     return null;
   const found = run.stdout.split(`
-`).map((line) => path47.resolve(cwd, line.trim()));
+`).map((line) => path48.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 || !existsSync19(marker))
       continue;
-    if (index === 1 && existsSync19(path47.join(marker, "applying")))
+    if (index === 1 && existsSync19(path48.join(marker, "applying")))
       return { operation: "am", commitAllowed: false, branch: null };
-    if (index === 0 && existsSync19(path47.join(marker, "amend")) && !conflicted()) {
+    if (index === 0 && existsSync19(path48.join(marker, "amend")) && !conflicted()) {
       let headName = "";
       try {
-        headName = readFileSync19(path47.join(marker, "head-name"), "utf8").trim();
+        headName = readFileSync19(path48.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 };
@@ -76758,7 +76798,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) => existsSync19(path47.resolve(cwd, value)) || [...tracked].some((file) => file === value || file.startsWith(`${value}/`)));
+    const addable = paths.filter((value) => existsSync19(path48.resolve(cwd, value)) || [...tracked].some((file) => file === value || file.startsWith(`${value}/`)));
     if (addable.length) {
       const added = git5(cwd, ["add", "-A", "--", ...addable]);
       if (!added.ok)
@@ -77284,11 +77324,11 @@ var init_ops = __esm(() => {
 });
 
 // packages/workit-core/src/forge/reruns.ts
-import fs25 from "node:fs";
-import path48 from "node:path";
+import fs26 from "node:fs";
+import path49 from "node:path";
 function rerunLogPath(cwd) {
   const common = gitCommonDir(cwd);
-  return common ? path48.join(common, "workit", "ci-reruns.jsonl") : null;
+  return common ? path49.join(common, "workit", "ci-reruns.jsonl") : null;
 }
 function rerunCounts(cwd, key) {
   const counts = new Map;
@@ -77297,7 +77337,7 @@ function rerunCounts(cwd, key) {
     return counts;
   let text;
   try {
-    text = fs25.readFileSync(file, "utf8");
+    text = fs26.readFileSync(file, "utf8");
   } catch {
     return counts;
   }
@@ -77323,8 +77363,8 @@ function recordReruns(cwd, rows) {
   if (!file)
     return false;
   try {
-    fs25.mkdirSync(path48.dirname(file), { recursive: true });
-    fs25.appendFileSync(file, rows.map((row) => `${JSON.stringify(row)}
+    fs26.mkdirSync(path49.dirname(file), { recursive: true });
+    fs26.appendFileSync(file, rows.map((row) => `${JSON.stringify(row)}
 `).join(""));
     return true;
   } catch {
@@ -77336,18 +77376,18 @@ function withRerunLock(cwd, fn) {
   if (!file)
     return fn();
   const lock = `${file.slice(0, -".jsonl".length)}.lock`;
-  fs25.mkdirSync(path48.dirname(lock), { recursive: true });
+  fs26.mkdirSync(path49.dirname(lock), { recursive: true });
   const until = Date.now() + LOCK_WAIT_MS2;
   for (;; ) {
     try {
-      fs25.closeSync(fs25.openSync(lock, "wx"));
+      fs26.closeSync(fs26.openSync(lock, "wx"));
       break;
     } catch (error) {
       if (error.code !== "EEXIST")
         throw error;
       try {
-        if (Date.now() - fs25.statSync(lock).mtimeMs > LOCK_STALE_MS2) {
-          fs25.rmSync(lock, { force: true });
+        if (Date.now() - fs26.statSync(lock).mtimeMs > LOCK_STALE_MS2) {
+          fs26.rmSync(lock, { force: true });
           continue;
         }
       } catch {
@@ -77361,7 +77401,7 @@ function withRerunLock(cwd, fn) {
   try {
     return fn();
   } finally {
-    fs25.rmSync(lock, { force: true });
+    fs26.rmSync(lock, { force: true });
   }
 }
 var isRow = (value) => {
@@ -78228,8 +78268,8 @@ var init_pr_ops = __esm(() => {
 // packages/workit-core/src/stack.ts
 import { spawnSync as spawnSync22 } from "node:child_process";
 import { createHash as createHash17, randomBytes as randomBytes4 } from "node:crypto";
-import fs26 from "node:fs";
-import path49 from "node:path";
+import fs27 from "node:fs";
+import path50 from "node:path";
 function worktreeOf(cwd, branch) {
   const list = gitRun3(cwd, ["worktree", "list", "--porcelain"]);
   if (!list.ok)
@@ -78252,7 +78292,7 @@ function rebasingBranch2(dir) {
     if (!found.ok)
       continue;
     try {
-      return fs26.readFileSync(found.stdout.trim(), "utf8").trim();
+      return fs27.readFileSync(found.stdout.trim(), "utf8").trim();
     } catch {}
   }
   return null;
@@ -78260,7 +78300,7 @@ function rebasingBranch2(dir) {
 function rebaseInProgress(dir) {
   for (const name of ["rebase-merge", "rebase-apply"]) {
     const found = gitRun3(dir, ["rev-parse", "--path-format=absolute", "--git-path", name]);
-    if (found.ok && fs26.existsSync(found.stdout.trim()))
+    if (found.ok && fs27.existsSync(found.stdout.trim()))
       return true;
   }
   return false;
@@ -78272,8 +78312,8 @@ function gitRestack(cwd, input) {
     const scratch = scratchDir(cwd);
     if (!scratch)
       return { ok: false, conflict: false, worktree: cwd, error: "no store root" };
-    fs26.mkdirSync(scratch, { recursive: true });
-    dir = path49.join(scratch, `${input.branch.replace(/[^A-Za-z0-9._-]+/gu, "_").slice(0, 40)}-${randomBytes4(4).toString("hex")}`);
+    fs27.mkdirSync(scratch, { recursive: true });
+    dir = path50.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) };
@@ -78311,10 +78351,10 @@ function gitRestack(cwd, input) {
 }
 function pruneScratch(cwd) {
   const scratch = scratchDir(cwd);
-  if (!scratch || !fs26.existsSync(scratch))
+  if (!scratch || !fs27.existsSync(scratch))
     return;
-  for (const name of fs26.readdirSync(scratch)) {
-    const dir = path49.join(scratch, name);
+  for (const name of fs27.readdirSync(scratch)) {
+    const dir = path50.join(scratch, name);
     if (!rebaseInProgress(dir) && !trackedDirt(dir))
       gitRun3(cwd, ["worktree", "remove", "--force", dir]);
   }
@@ -78324,7 +78364,7 @@ function stacksDir(cwd) {
   const root = storeRoot(cwd);
   if (!root.ok)
     return stackFail(root.code, root.error, root.unblock);
-  return { ok: true, data: path49.join(root.value.root, "stacks") };
+  return { ok: true, data: path50.join(root.value.root, "stacks") };
 }
 function parseStack(raw) {
   if (!isRecord10(raw) || !Array.isArray(raw.branches))
@@ -78376,10 +78416,10 @@ function readStack(cwd, name) {
   const dir = stacksDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path49.join(dir.data, fileFor(name));
+  const file = path50.join(dir.data, fileFor(name));
   let text;
   try {
-    text = fs26.readFileSync(file, "utf8");
+    text = fs27.readFileSync(file, "utf8");
   } catch (error) {
     if (error.code === "ENOENT")
       return { ok: true, data: null };
@@ -78397,17 +78437,17 @@ function writeStack(cwd, stack, now = new Date) {
   const dir = stacksDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path49.join(dir.data, fileFor(stack.name));
+  const file = path50.join(dir.data, fileFor(stack.name));
   const temp = `${file}.${process.pid}.tmp`;
   try {
-    fs26.mkdirSync(dir.data, { recursive: true });
+    fs27.mkdirSync(dir.data, { recursive: true });
     stack.updatedAt = now.toISOString();
-    fs26.writeFileSync(temp, `${JSON.stringify(stack, null, 2)}
+    fs27.writeFileSync(temp, `${JSON.stringify(stack, null, 2)}
 `);
-    fs26.renameSync(temp, file);
+    fs27.renameSync(temp, file);
     return { ok: true, data: undefined };
   } catch (error) {
-    fs26.rmSync(temp, { force: true });
+    fs27.rmSync(temp, { force: true });
     return stackFail("unavailable", `cannot write ${file}: ${error.message}`);
   }
 }
@@ -78417,7 +78457,7 @@ function listStacks(cwd) {
     return dir;
   let names = [];
   try {
-    names = fs26.readdirSync(dir.data).filter((name) => name.endsWith(".json"));
+    names = fs27.readdirSync(dir.data).filter((name) => name.endsWith(".json"));
   } catch {
     return { ok: true, data: [] };
   }
@@ -78425,7 +78465,7 @@ function listStacks(cwd) {
   for (const name of names) {
     let parsed = null;
     try {
-      parsed = parseStack(JSON.parse(fs26.readFileSync(path49.join(dir.data, name), "utf8")));
+      parsed = parseStack(JSON.parse(fs27.readFileSync(path50.join(dir.data, name), "utf8")));
     } catch {
       parsed = null;
     }
@@ -78472,7 +78512,7 @@ function stackLockStale(raw, age) {
 }
 function takeLock(lock) {
   try {
-    fs26.mkdirSync(lock);
+    fs27.mkdirSync(lock);
   } catch (error) {
     if (error.code === "EEXIST")
       return null;
@@ -78484,24 +78524,24 @@ function takeLock(lock) {
     host: localLockHost(),
     nonce: randomBytes4(8).toString("hex")
   };
-  fs26.writeFileSync(path49.join(lock, OWNER), JSON.stringify(owner));
+  fs27.writeFileSync(path50.join(lock, OWNER), JSON.stringify(owner));
   return owner;
 }
 function reapLock(lock, observed) {
   const tomb = `${lock}.reap-${randomBytes4(6).toString("hex")}`;
   try {
-    fs26.renameSync(lock, tomb);
+    fs27.renameSync(lock, tomb);
   } catch {
     return false;
   }
   if (readOwner(tomb).raw === observed) {
-    fs26.rmSync(tomb, { recursive: true, force: true });
+    fs27.rmSync(tomb, { recursive: true, force: true });
     return true;
   }
   try {
-    fs26.renameSync(tomb, lock);
+    fs27.renameSync(tomb, lock);
   } catch {
-    fs26.rmSync(tomb, { recursive: true, force: true });
+    fs27.rmSync(tomb, { recursive: true, force: true });
   }
   return false;
 }
@@ -78511,8 +78551,8 @@ function releaseLock(lock, owner) {
     return;
   const tomb = `${lock}.release-${randomBytes4(6).toString("hex")}`;
   try {
-    fs26.renameSync(lock, tomb);
-    fs26.rmSync(tomb, { recursive: true, force: true });
+    fs27.renameSync(lock, tomb);
+    fs27.rmSync(tomb, { recursive: true, force: true });
   } catch {}
 }
 async function withStackLock(cwd, name, fn, waitMs = LOCK_WAIT_MS3) {
@@ -78521,9 +78561,9 @@ 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 = path49.join(dir.data, `${fileFor(name)}.lock`);
+  const lock = path50.join(dir.data, `${fileFor(name)}.lock`);
   try {
-    fs26.mkdirSync(dir.data, { recursive: true });
+    fs27.mkdirSync(dir.data, { recursive: true });
   } catch (error) {
     return stackFail("unavailable", `cannot create ${dir.data}: ${error.message}`);
   }
@@ -78551,7 +78591,7 @@ async function withStackLock(cwd, name, fn, waitMs = LOCK_WAIT_MS3) {
   const touch = () => {
     try {
       const now = new Date;
-      fs26.utimesSync(path49.join(lock, OWNER), now, now);
+      fs27.utimesSync(path50.join(lock, OWNER), now, now);
     } catch {}
   };
   const beat = setInterval(touch, HEARTBEAT_MS);
@@ -79391,7 +79431,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 ? path49.join(dir.data, "worktrees") : null;
+  return dir.ok ? path50.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) => {
@@ -79406,14 +79446,14 @@ ${run.stdout}`.split(`
 }, isRecord10 = (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 = fs26.readFileSync(path49.join(lock, OWNER), "utf8");
+    raw = fs27.readFileSync(path50.join(lock, OWNER), "utf8");
   } catch {
     raw = null;
   }
   let age = null;
-  for (const target of [path49.join(lock, OWNER), lock])
+  for (const target of [path50.join(lock, OWNER), lock])
     try {
-      age = Date.now() - fs26.statSync(target).mtimeMs;
+      age = Date.now() - fs27.statSync(target).mtimeMs;
       break;
     } catch {}
   return { raw, age };
@@ -79446,8 +79486,8 @@ var init_stack = __esm(() => {
 // packages/workit-core/src/fanout.ts
 import { spawnSync as spawnSync23 } from "node:child_process";
 import { createHash as createHash18 } from "node:crypto";
-import fs27 from "node:fs";
-import path50 from "node:path";
+import fs28 from "node:fs";
+import path51 from "node:path";
 function expandBraces2(pattern, limit = 64) {
   for (let index = 0;index < pattern.length; index += 1) {
     if (pattern[index] === "\\") {
@@ -79693,7 +79733,7 @@ function parsePlan(raw, defaults, name) {
       id,
       branch,
       base: optional("base") ?? "",
-      worktree: path50.resolve(defaults.root, optional("worktree") ?? path50.join(defaults.worktreeRoot, id)),
+      worktree: path51.resolve(defaults.root, optional("worktree") ?? path51.join(defaults.worktreeRoot, id)),
       tier,
       reason,
       dependsOn: [...new Set(dependsOn ?? [])],
@@ -79924,11 +79964,11 @@ function defaultTrunk(cwd) {
 }
 function mainCheckout(cwd) {
   const common = gitCommonDir(cwd);
-  return common && path50.basename(common) === ".git" ? path50.dirname(common) : path50.resolve(cwd);
+  return common && path51.basename(common) === ".git" ? path51.dirname(common) : path51.resolve(cwd);
 }
 function worktreeRoot(cwd) {
   const main = mainCheckout(cwd);
-  return path50.join(path50.dirname(main), `${path50.basename(main)}-wt`);
+  return path51.join(path51.dirname(main), `${path51.basename(main)}-wt`);
 }
 function sliceHash(slice) {
   const {
@@ -79948,7 +79988,7 @@ function fanoutsDir(cwd) {
   const root = storeRoot(cwd);
   if (!root.ok)
     return fanoutFail(root.code, root.error, root.unblock);
-  return { ok: true, data: path50.join(root.value.root, "fanouts") };
+  return { ok: true, data: path51.join(root.value.root, "fanouts") };
 }
 function parseStored(raw) {
   if (!isRecord11(raw) || typeof raw.name !== "string" || typeof raw.trunk !== "string")
@@ -80016,10 +80056,10 @@ function readFanout(cwd, name) {
   const dir = fanoutsDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path50.join(dir.data, stackFileName(name));
+  const file = path51.join(dir.data, stackFileName(name));
   let parsed = null;
   try {
-    parsed = parseStored(JSON.parse(fs27.readFileSync(file, "utf8")));
+    parsed = parseStored(JSON.parse(fs28.readFileSync(file, "utf8")));
   } catch (error) {
     if (error.code === "ENOENT")
       return { ok: true, data: null };
@@ -80033,7 +80073,7 @@ function listFanouts(cwd) {
     return dir;
   let names = [];
   try {
-    names = fs27.readdirSync(dir.data).filter((entry) => entry.endsWith(".json"));
+    names = fs28.readdirSync(dir.data).filter((entry) => entry.endsWith(".json"));
   } catch {
     return { ok: true, data: [] };
   }
@@ -80041,7 +80081,7 @@ function listFanouts(cwd) {
   for (const entry of names) {
     let parsed = null;
     try {
-      parsed = parseStored(JSON.parse(fs27.readFileSync(path50.join(dir.data, entry), "utf8")));
+      parsed = parseStored(JSON.parse(fs28.readFileSync(path51.join(dir.data, entry), "utf8")));
     } catch {
       parsed = null;
     }
@@ -80080,16 +80120,16 @@ function writeFanout(cwd, plan) {
   const dir = fanoutsDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path50.join(dir.data, stackFileName(plan.name));
+  const file = path51.join(dir.data, stackFileName(plan.name));
   const temp = `${file}.${process.pid}.tmp`;
   try {
-    fs27.mkdirSync(dir.data, { recursive: true });
-    fs27.writeFileSync(temp, `${JSON.stringify(plan, null, 2)}
+    fs28.mkdirSync(dir.data, { recursive: true });
+    fs28.writeFileSync(temp, `${JSON.stringify(plan, null, 2)}
 `);
-    fs27.renameSync(temp, file);
+    fs28.renameSync(temp, file);
     return { ok: true, data: file };
   } catch (error) {
-    fs27.rmSync(temp, { force: true });
+    fs28.rmSync(temp, { force: true });
     return fanoutFail("unavailable", `cannot write ${file}: ${error.message}`);
   }
 }
@@ -80286,16 +80326,16 @@ var init_fanout = __esm(() => {
 
 // packages/workit-core/src/forge/exec.ts
 import { spawnSync as spawnSync24 } from "node:child_process";
-import fs28 from "node:fs";
-import path51 from "node:path";
+import fs29 from "node:fs";
+import path52 from "node:path";
 function findExecutable(bin, env) {
-  const dirs = (env.PATH ?? env.Path ?? "").split(path51.delimiter).filter(Boolean);
+  const dirs = (env.PATH ?? env.Path ?? "").split(path52.delimiter).filter(Boolean);
   const exts = process.platform === "win32" ? [".exe"] : [""];
   for (const dir of dirs)
     for (const ext of exts) {
-      const candidate = path51.join(dir, `${bin}${ext}`);
+      const candidate = path52.join(dir, `${bin}${ext}`);
       try {
-        const stat = fs28.statSync(candidate);
+        const stat = fs29.statSync(candidate);
         if (stat.isFile())
           return candidate;
       } catch {}
@@ -81767,7 +81807,7 @@ var init_pr_edit = __esm(() => {
 });
 
 // packages/workit-core/src/forge/resolve.ts
-import fs29 from "node:fs";
+import fs30 from "node:fs";
 function memo4(scope, key, compute, now = Date.now) {
   let entries = memoScopes.get(scope.owner);
   if (!entries)
@@ -81813,14 +81853,14 @@ function resolveCredential(workspace, derived, run, scope) {
     if (process.platform !== "win32") {
       let mode = 0;
       try {
-        mode = fs29.statSync(tokenFile.trim()).mode;
+        mode = fs30.statSync(tokenFile.trim()).mode;
       } catch {}
       if ((mode & 63) !== 0)
         return failure3("blocked", `workspace ${workspace?.name ?? "?"} vcs.tokenFile is readable by group or other (mode ${(mode & 511).toString(8).padStart(4, "0")})`, `chmod 600 ${tokenFile.trim()}`);
     }
     let token = "";
     try {
-      token = fs29.readFileSync(tokenFile.trim(), "utf8").trim();
+      token = fs30.readFileSync(tokenFile.trim(), "utf8").trim();
     } catch {
       return failure3("blocked", `workspace ${workspace?.name ?? "?"} vcs.tokenFile cannot be read`, "fix vcs.tokenFile in ~/.config/workit/workspaces.json");
     }
@@ -82193,11 +82233,11 @@ __export(exports_pr, {
   run: () => run12
 });
 import { readFileSync as readFileSync21 } from "node:fs";
-import path52 from "node:path";
+import path53 from "node:path";
 function readBodyFile(io, file) {
   try {
     return {
-      body: file === "-" ? forgeDeps.readStdin() : readFileSync21(path52.resolve(io.cwd, file), "utf8")
+      body: file === "-" ? forgeDeps.readStdin() : readFileSync21(path53.resolve(io.cwd, file), "utf8")
     };
   } catch {
     return `cannot read --body-file ${file}`;
@@ -82871,7 +82911,7 @@ __export(exports_git, {
   run: () => run14
 });
 import { readFileSync as readFileSync22 } from "node:fs";
-import path53 from "node:path";
+import path54 from "node:path";
 function kindHint(cwd, kind) {
   let kinds = [...BRANCH_KINDS];
   try {
@@ -82975,7 +83015,7 @@ function commitMessage(parsed, io) {
 
 `);
   try {
-    return file === "-" ? readFileSync22(0, "utf8") : readFileSync22(path53.resolve(io.cwd, file), "utf8");
+    return file === "-" ? readFileSync22(0, "utf8") : readFileSync22(path54.resolve(io.cwd, file), "utf8");
   } catch (error) {
     return {
       error: `cannot read -F ${file}: ${error instanceof Error ? error.message : String(error)}`
@@ -84381,8 +84421,8 @@ var init_stack2 = __esm(() => {
 
 // packages/workit-core/src/fanout-worktree.ts
 import { randomBytes as randomBytes5 } from "node:crypto";
-import fs30 from "node:fs";
-import path54 from "node:path";
+import fs31 from "node:fs";
+import path55 from "node:path";
 function rowSample(lines) {
   const out = [];
   let bytes = 0;
@@ -84442,7 +84482,7 @@ function adminDir(worktree) {
   const file = dir.stdout.trim();
   let token = null;
   try {
-    token = fs30.readFileSync(path54.join(file, TOKEN_FILE), "utf8").trim() || null;
+    token = fs31.readFileSync(path55.join(file, TOKEN_FILE), "utf8").trim() || null;
   } catch {
     token = null;
   }
@@ -84450,7 +84490,7 @@ function adminDir(worktree) {
     const stat = worktreeDeps.stat(file);
     return {
       path: file,
-      id: path54.basename(file),
+      id: path55.basename(file),
       ino: stat.ino.toString(),
       token,
       birthMs: stat.birthtimeNs > 0n ? Number(stat.birthtimeMs) : null,
@@ -84466,7 +84506,7 @@ function markAdminDir(worktree) {
     return null;
   const token = randomBytes5(16).toString("hex");
   try {
-    fs30.writeFileSync(path54.join(admin.path, TOKEN_FILE), `${token}
+    fs31.writeFileSync(path55.join(admin.path, TOKEN_FILE), `${token}
 `);
   } catch {
     return null;
@@ -84481,25 +84521,25 @@ function excludeScratch(cwd) {
   const common = gitCommonDir(cwd);
   if (!common)
     return;
-  const file = path54.join(common, "info", "exclude");
+  const file = path55.join(common, "info", "exclude");
   let text = "";
   try {
-    text = fs30.readFileSync(file, "utf8");
+    text = fs31.readFileSync(file, "utf8");
   } catch {
     text = "";
   }
   if (text.split(/\r?\n/u).includes(EXCLUDE_LINE))
     return;
-  fs30.mkdirSync(path54.dirname(file), { recursive: true });
-  fs30.appendFileSync(file, `${text && !text.endsWith(`
+  fs31.mkdirSync(path55.dirname(file), { recursive: true });
+  fs31.appendFileSync(file, `${text && !text.endsWith(`
 `) ? `
 ` : ""}# workit fanout: per-worker scratch dirs
 ${EXCLUDE_LINE}
 `);
 }
 function ensureScratch(worktree) {
-  const scratch = path54.join(worktree, SCRATCH_DIR);
-  fs30.mkdirSync(scratch, { recursive: true });
+  const scratch = path55.join(worktree, SCRATCH_DIR);
+  fs31.mkdirSync(scratch, { recursive: true });
   return scratch;
 }
 function createSliceWorktree(cwd, plan, input) {
@@ -84543,8 +84583,8 @@ function createSliceWorktree(cwd, plan, input) {
     return fanoutFail("blocked", `${slice.branch} is checked out at ${elsewhere.path}: never two live workers on one branch`, `stop that worker, then workit fanout worktree release ${slice.id} (or git worktree remove ${elsewhere.path})`);
   let dirExisted = false;
   try {
-    const stat = fs30.statSync(target);
-    if (!stat.isDirectory() || fs30.readdirSync(target).length > 0)
+    const stat = fs31.statSync(target);
+    if (!stat.isDirectory() || fs31.readdirSync(target).length > 0)
       return fanoutFail("blocked", `${target} exists and is ${stat.isDirectory() ? "not empty" : "not a directory"} (not a worktree of this repository)`, `move it away, or set slice ${slice.id}'s worktree to another path`);
     dirExisted = true;
   } catch (error) {
@@ -84626,7 +84666,7 @@ function releaseSliceWorktree(cwd, plan, input) {
     notes: []
   };
   if (index < 0) {
-    if (fs30.existsSync(target))
+    if (fs31.existsSync(target))
       return fanoutFail("blocked", `${target} is not a worktree of this repository; nothing was removed`, "remove it yourself once you know what it holds");
     out.notes.push(`no worktree at ${target}; nothing to release`);
     return { ok: true, data: out };
@@ -84688,7 +84728,7 @@ function releaseSliceWorktree(cwd, plan, input) {
 `)[0]}`, entry.locked ? `git worktree unlock ${entry.path}, then release again` : undefined, { ...out });
   out.removed = true;
   if (made.dirExisted === true)
-    fs30.mkdirSync(entry.path, { recursive: true });
+    fs31.mkdirSync(entry.path, { recursive: true });
   if (out.unpushed)
     out.notes.push(`${slice.branch} is kept with ${out.unpushed} commit(s) not on the remote`);
   return { ok: true, data: out };
@@ -84716,32 +84756,32 @@ function unpushedCount(cwd, branch) {
   return count.ok ? Number(count.stdout.trim()) : null;
 }
 function removeScratch(worktree) {
-  const scratch = path54.join(worktree, SCRATCH_DIR);
+  const scratch = path55.join(worktree, SCRATCH_DIR);
   let stat;
   try {
-    stat = fs30.lstatSync(scratch);
+    stat = fs31.lstatSync(scratch);
   } catch {
     return;
   }
   if (stat.isSymbolicLink() || !stat.isDirectory())
-    fs30.unlinkSync(scratch);
+    fs31.unlinkSync(scratch);
   else
-    fs30.rmSync(scratch, { recursive: true, force: true, maxRetries: 2 });
+    fs31.rmSync(scratch, { recursive: true, force: true, maxRetries: 2 });
 }
 var SLOW, SCRATCH_DIR = ".workit-scratch", EXCLUDE_LINE, DIRTY_ROW_BYTES = 2000, canonical2 = (target) => {
   try {
-    return fs30.realpathSync.native(target);
+    return fs31.realpathSync.native(target);
   } catch {
-    return path54.resolve(target);
+    return path55.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 = path54.relative(canonical2(parent), canonical2(child));
-  return relative === "" || !relative.startsWith("..") && !path54.isAbsolute(relative);
-}, slicePath = (cwd, slice) => path54.isAbsolute(slice.worktree) ? slice.worktree : path54.resolve(mainCheckout(cwd), slice.worktree), CLOCK_SLACK_MS = 2000, TOKEN_FILE = "workit-fanout-token", worktreeDeps, worktreeFailed = (stderr) => fanoutFail("failed", `git worktree add failed: ${stderr.trim().split(`
+  const relative = path55.relative(canonical2(parent), canonical2(child));
+  return relative === "" || !relative.startsWith("..") && !path55.isAbsolute(relative);
+}, slicePath = (cwd, slice) => path55.isAbsolute(slice.worktree) ? slice.worktree : path55.resolve(mainCheckout(cwd), slice.worktree), CLOCK_SLACK_MS = 2000, TOKEN_FILE = "workit-fanout-token", worktreeDeps, worktreeFailed = (stderr) => fanoutFail("failed", `git worktree add failed: ${stderr.trim().split(`
 `)[0] || "unknown error"}`);
 var init_fanout_worktree = __esm(() => {
   init_ops();
@@ -84751,7 +84791,7 @@ var init_fanout_worktree = __esm(() => {
   SLOW = GIT_TIMEOUTS.worktree;
   EXCLUDE_LINE = `/${SCRATCH_DIR}/`;
   worktreeDeps = {
-    stat: (file) => fs30.statSync(file, { bigint: true })
+    stat: (file) => fs31.statSync(file, { bigint: true })
   };
 });
 
@@ -85565,8 +85605,8 @@ var exports_fanout = {};
 __export(exports_fanout, {
   run: () => run18
 });
-import fs31 from "node:fs";
-import path55 from "node:path";
+import fs32 from "node:fs";
+import path56 from "node:path";
 function forgeFor(io, offline) {
   if (offline)
     return { forge: null, error: "--offline" };
@@ -85627,10 +85667,10 @@ 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 = path55.resolve(io.cwd, flags.positionals[0]);
+  const file = path56.resolve(io.cwd, flags.positionals[0]);
   let raw;
   try {
-    raw = JSON.parse(fs31.readFileSync(file, "utf8"));
+    raw = JSON.parse(fs32.readFileSync(file, "utf8"));
   } catch (error) {
     return usage3(io, `cannot read ${file} as JSON: ${error.message}`, PLAN_USAGE2);
   }
@@ -86046,6 +86086,10 @@ async function standing(io, values, args) {
   const [action, ...rest] = args;
   if (action !== "add" && action !== "list" && action !== "clear")
     return emit(io, fail2("invalid_input", action ? `unknown standing action "${action}"` : "missing add, list or clear", { unblock: STANDING_USAGE }));
+  if ((values.stop || values.clear) && action !== "add")
+    return usage4(io, `--stop and --clear go with standing add, not standing ${action}`);
+  if (values.stop && values.clear)
+    return usage4(io, "pass --stop or --clear, not both");
   const target = standingFanout(io, values);
   if (target instanceof Error)
     return emit(io, fail2("invalid_input", target.message, { unblock: STANDING_USAGE }));
@@ -86080,13 +86124,18 @@ async function standing(io, values, args) {
     return emit(io, fail2("not_found", `no fanout plan named ${fanout}`, {
       unblock: "workit fanout plan <plan.json> first, or name an existing plan with --fanout"
     }));
+  if (action === "add" && values.clear) {
+    if (rest.length)
+      return usage4(io, `unexpected argument: ${rest[0]}`);
+    return fromResult(io, liftStop(context, { fanout, lead, leads }), (rows) => `lifted the stop line for fanout ${fanout} (cleared ${rows.map((row) => row.target).join(", ")}); running workers are told on their next tool call`);
+  }
   if (action === "add")
-    return fromResult(io, recordStanding(context, { fanout, lead, what: rest.join(" ") }), (row) => `recorded standing order ${row.id} for fanout ${fanout}`);
+    return fromResult(io, recordStanding(context, { fanout, lead, what: rest.join(" "), stop: values.stop === true }), (row) => row.stop ? `recorded stop line ${row.id} for fanout ${fanout}; running workers stop and report on their next tool call` : `recorded standing order ${row.id} for fanout ${fanout}; running workers get it on their next tool call`);
   if (rest.length > 1)
     return usage4(io, `unexpected argument: ${rest[1]}`);
   return fromResult(io, clearStanding(context, { fanout, lead, leads, target: rest[0] ?? null }), (row) => row.target ? `cleared standing order ${row.target} for fanout ${fanout}` : `cleared every standing order for fanout ${fanout}`);
 }
-var USAGE11 = "workit ledger decision|ruling|verdict|standing|list|check ... (workit help ledger for the grammar)", STANDING_USAGE = 'workit ledger standing add "<order>" | list | clear [<id>]  [--fanout <name>] [--json]', OPTIONS, SESSION_SAFE2, ROLE_SAFE, actorFor = (io, values) => {
+var USAGE11 = "workit ledger decision|ruling|verdict|standing|list|check ... (workit help ledger for the grammar)", STANDING_USAGE = 'workit ledger standing add "<order>" | add --stop ["<note>"] | add --clear | list | clear [<id>]  [--fanout <name>] [--json]', OPTIONS, SESSION_SAFE2, ROLE_SAFE, actorFor = (io, values) => {
   const actor = actorFromEnv(io.env);
   if (values.session !== undefined && values.as !== undefined)
     return new Error("pass --session or --as, not both");
@@ -86183,6 +86232,8 @@ var init_ledger2 = __esm(() => {
     token: { type: "string" },
     as: { type: "string" },
     fanout: { type: "string" },
+    stop: { type: "boolean" },
+    clear: { type: "boolean" },
     json: { type: "boolean" }
   };
   SESSION_SAFE2 = /^[A-Za-z0-9_.:@/+-]{1,128}$/;
@@ -101150,7 +101201,7 @@ var init_ast = __esm(() => {
 
 // packages/workit-cli/src/test-audit/rules.ts
 import { builtinModules } from "node:module";
-import path56 from "node:path";
+import path57 from "node:path";
 function testCallee(call) {
   let callee = call.callee;
   if (callee.type === "CallExpression")
@@ -101643,12 +101694,12 @@ function checkConstantsOnly(ctx, emit) {
 }
 function checkOverMocking(ctx, emit) {
   const { program } = ctx.parsed;
-  const unit = path56.basename(ctx.file).replace(/\.(?:[cm]?[jt]sx?)$/, "").replace(/\.(?:test|spec)$/, "");
+  const unit = path57.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 = path56.basename(spec.replace(/\/index(?:\.[cm]?[jt]sx?)?$/, "")).replace(/\.(?:[cm]?[jt]sx?)$/, "");
+    const base = path57.basename(spec.replace(/\/index(?:\.[cm]?[jt]sx?)?$/, "")).replace(/\.(?:[cm]?[jt]sx?)$/, "");
     if (base === unit)
       emit({
         rule: "over-mocking",
@@ -102038,7 +102089,7 @@ var init_rules = __esm(() => {
 // packages/workit-cli/src/test-audit/audit.ts
 import { spawnSync as spawnSync28 } from "node:child_process";
 import { existsSync as existsSync20, readdirSync as readdirSync10, readFileSync as readFileSync23, statSync as statSync8 } from "node:fs";
-import path57 from "node:path";
+import path58 from "node:path";
 function git7(cwd, args) {
   const run = spawnSync28("git", ["-c", "core.quotepath=off", ...args], {
     cwd,
@@ -102051,7 +102102,7 @@ function walkTests(dir, out) {
   for (const entry of readdirSync10(dir, { withFileTypes: true })) {
     if (entry.name.startsWith(".") && entry.name !== "." && entry.isDirectory())
       continue;
-    const full = path57.join(dir, entry.name);
+    const full = path58.join(dir, entry.name);
     if (entry.isDirectory()) {
       if (!SKIP_DIRS.has(entry.name))
         walkTests(full, out);
@@ -102063,7 +102114,7 @@ function expandPaths(cwd, inputs) {
   const files = [];
   const missing = [];
   for (const input of inputs.length > 0 ? inputs : ["."]) {
-    const full = path57.resolve(cwd, input);
+    const full = path58.resolve(cwd, input);
     if (!existsSync20(full))
       missing.push(input);
     else if (statSync8(full).isDirectory())
@@ -102100,11 +102151,11 @@ function changedLines(cwd, base) {
       for (let offset = 0;offset < count; offset += 1)
         lines.add(start + offset);
     }
-    changed.set(path57.join(root, file), lines);
+    changed.set(path58.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(path57.join(root, file), "all");
+    changed.set(path58.join(root, file), "all");
   return changed;
 }
 function auditFiles(files, display) {
@@ -102166,7 +102217,7 @@ function auditFiles(files, display) {
     durationMs: Math.round(performance.now() - started)
   };
 }
-var TEST_FILE, CODE_FILE, SKIP_DIRS, toPosix = (file) => file.split(path57.sep).join("/"), SEVERITY_ORDER, ruleIds;
+var TEST_FILE, CODE_FILE, SKIP_DIRS, toPosix = (file) => file.split(path58.sep).join("/"), SEVERITY_ORDER, ruleIds;
 var init_audit = __esm(() => {
   init_ast();
   init_rules();
@@ -102196,7 +102247,7 @@ import {
   copyFileSync as copyFileSync6
 } from "node:fs";
 import os18 from "node:os";
-import path58 from "node:path";
+import path59 from "node:path";
 function mutantsFor(source, file, lines) {
   const parsed = parseSource(source, file);
   const out = [];
@@ -102269,7 +102320,7 @@ function relatedTests(source, testFiles) {
     for (const match of text.matchAll(SPECIFIER)) {
       const spec = match[1];
       if (spec.startsWith(".")) {
-        if (stripExt(path58.posix.join(path58.posix.dirname(file), spec)) === target)
+        if (stripExt(path59.posix.join(path59.posix.dirname(file), spec)) === target)
           return true;
       } else if (spec.includes("/") && stripExt(spec).split("/").slice(-2).join("/") === tail)
         return true;
@@ -102289,12 +102340,12 @@ function removeStaleCopies(tmp = os18.tmpdir()) {
   for (const name of names) {
     if (!name.startsWith(TEMP_PREFIX))
       continue;
-    const dir = path58.join(tmp, name);
+    const dir = path59.join(tmp, name);
     try {
       const stat = lstatSync8(dir);
       if (!stat.isDirectory() || uid !== undefined && stat.uid !== uid)
         continue;
-      const pid = Number(readFileSync24(path58.join(dir, PID_FILE), "utf8"));
+      const pid = Number(readFileSync24(path59.join(dir, PID_FILE), "utf8"));
       if (Number.isInteger(pid) && pid > 0 && alive(pid))
         continue;
     } catch (error) {
@@ -102311,8 +102362,8 @@ function removeStaleCopies(tmp = os18.tmpdir()) {
 function linkNodeModules(origin, target, repo, copy) {
   mkdirSync10(target, { recursive: true });
   for (const entry of readdirSync11(origin, { withFileTypes: true })) {
-    const from = path58.join(origin, entry.name);
-    const to = path58.join(target, entry.name);
+    const from = path59.join(origin, entry.name);
+    const to = path59.join(target, entry.name);
     if (entry.name.startsWith("@") && entry.isDirectory()) {
       linkNodeModules(from, to, repo, copy);
       continue;
@@ -102328,9 +102379,9 @@ function linkNodeModules(origin, target, repo, copy) {
       } catch {
         continue;
       }
-      const relative = path58.relative(repo, real);
-      if (!relative.startsWith("..") && !path58.isAbsolute(relative) && !relative.split(path58.sep).includes("node_modules")) {
-        symlinkSync(path58.join(copy, relative), to, "junction");
+      const relative = path59.relative(repo, real);
+      if (!relative.startsWith("..") && !path59.isAbsolute(relative) && !relative.split(path59.sep).includes("node_modules")) {
+        symlinkSync(path59.join(copy, relative), to, "junction");
         continue;
       }
     }
@@ -102346,7 +102397,7 @@ function copySymlink(repo, tree, from, to) {
   }
   const realRepo = realpathSync9(repo);
   if (real && inside4(realRepo, real)) {
-    symlinkSync(path58.relative(path58.dirname(to), path58.join(tree, path58.relative(realRepo, real))), to);
+    symlinkSync(path59.relative(path59.dirname(to), path59.join(tree, path59.relative(realRepo, real))), to);
     return;
   }
   if (real && statSync9(real).isFile())
@@ -102355,10 +102406,10 @@ function copySymlink(repo, tree, from, to) {
     symlinkSync(readlinkSync3(from), to);
 }
 function writeInside(copy, file, content) {
-  const target = path58.join(copy, file);
+  const target = path59.join(copy, file);
   try {
     const stat = lstatSync8(target);
-    if (!stat.isFile() || !inside4(realpathSync9(copy), realpathSync9(path58.dirname(target))))
+    if (!stat.isFile() || !inside4(realpathSync9(copy), realpathSync9(path59.dirname(target))))
       return false;
   } catch {
     return false;
@@ -102369,9 +102420,9 @@ function writeInside(copy, file, content) {
   return true;
 }
 function copyWorkingTree(repo) {
-  const dir = mkdtempSync4(path58.join(os18.tmpdir(), TEMP_PREFIX));
-  writeFileSync11(path58.join(dir, PID_FILE), String(process.pid));
-  const tree = path58.join(dir, "tree");
+  const dir = mkdtempSync4(path59.join(os18.tmpdir(), TEMP_PREFIX));
+  writeFileSync11(path59.join(dir, PID_FILE), String(process.pid));
+  const tree = path59.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();
@@ -102388,29 +102439,29 @@ function copyWorkingTree(repo) {
   for (const relative of listed) {
     if (!relative)
       continue;
-    const from = path58.join(repo, relative);
+    const from = path59.join(repo, relative);
     let stat;
     try {
       stat = lstatSync8(from);
     } catch {
       continue;
     }
-    const to = path58.join(tree, relative);
-    mkdirSync10(path58.dirname(to), { recursive: true });
+    const to = path59.join(tree, relative);
+    mkdirSync10(path59.dirname(to), { recursive: true });
     if (stat.isSymbolicLink())
       copySymlink(repo, tree, from, to);
     else if (stat.isFile())
       copyFileSync6(from, to);
-    let parent = path58.dirname(relative);
+    let parent = path59.dirname(relative);
     while (parent !== "." && !dirs.has(parent)) {
       dirs.add(parent);
-      parent = path58.dirname(parent);
+      parent = path59.dirname(parent);
     }
   }
   for (const parent of dirs) {
-    const modules = path58.join(repo, parent, "node_modules");
-    if (existsSync21(modules) && !existsSync21(path58.join(tree, parent, "node_modules")))
-      linkNodeModules(modules, path58.join(tree, parent, "node_modules"), repo, tree);
+    const modules = path59.join(repo, parent, "node_modules");
+    if (existsSync21(modules) && !existsSync21(path59.join(tree, parent, "node_modules")))
+      linkNodeModules(modules, path59.join(tree, parent, "node_modules"), repo, tree);
   }
   return { dir, tree };
 }
@@ -102449,14 +102500,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: readFileSync24(path58.join(repo, file), "utf8") };
+      return { file, text: readFileSync24(path59.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(path58.relative(repo, absolute));
+    const relative = toPosix(path59.relative(repo, absolute));
     if (!CODE_FILE.test(relative) || TEST_FILE.test(relative) || relative.endsWith(".d.ts"))
       continue;
     if (NOT_SOURCE.test(relative) || !existsSync21(absolute))
@@ -102470,9 +102521,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 = path58.relative(repo, options.cwd);
+  const cwdRelative = path59.relative(repo, options.cwd);
   const asArg = (file) => {
-    const relative = toPosix(path58.relative(cwdRelative, file));
+    const relative = toPosix(path59.relative(cwdRelative, file));
     return shellQuote(relative.startsWith(".") ? relative : `./${relative}`);
   };
   const commandFor = (tests) => options.command.replaceAll("{files}", () => tests.map(asArg).join(" "));
@@ -102507,7 +102558,7 @@ async function runMutation(options) {
     return finish3(options, 0, results, counts, started);
   removeStaleCopies();
   const { dir: copyDir, tree: copy } = copyWorkingTree(repo);
-  const copyCwd = path58.join(copy, cwdRelative);
+  const copyCwd = path59.join(copy, cwdRelative);
   let current = null;
   const restore = () => {
     if (current)
@@ -102542,7 +102593,7 @@ async function runMutation(options) {
         record({ ...mutant, status: "skipped", durationMs: 0, tests, reason: "budget" });
         continue;
       }
-      const original = readFileSync24(path58.join(copy, mutant.file), "utf8");
+      const original = readFileSync24(path59.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)) {
@@ -102599,8 +102650,8 @@ var NOT_SOURCE, FLIPS, isStringy = (node) => node.type === "StringLiteral" || no
     return error.code === "EPERM";
   }
 }, inside4 = (root, file) => {
-  const relative = path58.relative(root, file);
-  return relative === "" || !relative.startsWith("..") && !path58.isAbsolute(relative);
+  const relative = path59.relative(root, file);
+  return relative === "" || !relative.startsWith("..") && !path59.isAbsolute(relative);
 }, active, killTree = (child) => {
   try {
     if (child.pid && process.platform !== "win32")
@@ -102649,7 +102700,7 @@ __export(exports_test_audit, {
   run: () => run20
 });
 import { existsSync as existsSync22 } from "node:fs";
-import path59 from "node:path";
+import path60 from "node:path";
 function parse7(argv) {
   const options = {
     paths: [],
@@ -102753,8 +102804,8 @@ async function run20(argv, io) {
     return emit(io, fail2("invalid_input", `${options}
 usage: ${USAGE12}`));
   const top = git7(io.cwd, ["rev-parse", "--show-toplevel"]);
-  const repo = top.ok ? path59.resolve(top.stdout.trim()) : null;
-  const display = (file) => toPosix(path59.relative(io.cwd, file) || file);
+  const repo = top.ok ? path60.resolve(top.stdout.trim()) : null;
+  const display = (file) => toPosix(path60.relative(io.cwd, file) || file);
   let base = null;
   let changed = null;
   if (options.diff || options.mutate) {
@@ -102893,7 +102944,7 @@ __export(exports_youtrack, {
   run: () => run22
 });
 import { readFileSync as readFileSync25 } from "node:fs";
-import path60 from "node:path";
+import path61 from "node:path";
 async function run22(argv, io) {
   const [sub, ...rest] = argv;
   if (sub !== "note" && sub !== "time" && sub !== "meeting")
@@ -102939,7 +102990,7 @@ async function run22(argv, io) {
     let markdown = flags.values.markdown ?? "";
     if (flags.values.file)
       try {
-        markdown = readFileSync25(path60.resolve(io.cwd, flags.values.file), "utf8");
+        markdown = readFileSync25(path61.resolve(io.cwd, flags.values.file), "utf8");
       } catch (error) {
         return usage3(io, `cannot read ${flags.values.file}: ${String(error)}`, USAGE14);
       }
@@ -103008,7 +103059,7 @@ __export(exports_changelog, {
   run: () => run23
 });
 import { readFileSync as readFileSync26 } from "node:fs";
-import path61 from "node:path";
+import path62 from "node:path";
 async function run23(argv, io) {
   const [sub, ...rest] = argv;
   if (sub !== "apply")
@@ -103054,7 +103105,7 @@ async function run23(argv, io) {
   ]);
 }
 var USAGE15 = "workit changelog apply (--entries <JSON|@file|-> | --normalize-only) [--path CHANGELOG.md] [--preview]", readEntries = (raw, cwd) => {
-  const text = raw === "-" ? readFileSync26(0, "utf8") : raw.startsWith("@") ? readFileSync26(path61.resolve(cwd, raw.slice(1)), "utf8") : raw;
+  const text = raw === "-" ? readFileSync26(0, "utf8") : raw.startsWith("@") ? readFileSync26(path62.resolve(cwd, raw.slice(1)), "utf8") : raw;
   return JSON.parse(text);
 };
 var init_changelog2 = __esm(() => {
@@ -103150,7 +103201,7 @@ var init_handoff = __esm(() => {
 
 // packages/workit-cli/src/main.ts
 init_package();
-import path62 from "node:path";
+import path63 from "node:path";
 
 // packages/workit-cli/src/verbs/registry.ts
 var TASK_FAMILY_NAMES = [
@@ -103648,8 +103699,8 @@ var VERBS = [
       {
         name: "standing",
         flagAliases: { name: "fanout" },
-        usage: `workit ledger standing add "<order>" | standing list | standing clear [<id>]  [--fanout <name>] [--supersedes <id>] [--session <id> [--token <t>] | --as <role>]`,
-        summary: "The lead's standing orders for a fanout's workers"
+        usage: `workit ledger standing add "<order>" | standing add --stop ["<note>"] | standing add --clear | standing list | standing clear [<id>]  [--fanout <name>] [--supersedes <id>] [--session <id> [--token <t>] | --as <role>]`,
+        summary: "The lead's standing orders for a fanout's workers; running workers get each change on their next tool call, and --stop tells them to stop and report"
       },
       {
         name: "add",
@@ -103979,7 +104030,7 @@ var defaultIo = (json) => ({
 });
 async function main(argv, overrides = {}, options = {}) {
   const parsed = parseGlobals(argv);
-  const cwd = path62.resolve(overrides.cwd ?? process.cwd(), parsed.cwd ?? ".");
+  const cwd = path63.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));