@brainervirus/workit-codex 8.36.0 → 8.37.1

package/dist/launch-mcp.js

@@ -6621,14 +6621,14 @@ var require_dist = __commonJS(function(exports, module) {
 });
 
 // packages/workit-codex/scripts/launch-mcp.ts
-import { existsSync as existsSync11, realpathSync as realpathSync7, statSync as statSync3 } from "node:fs";
-import path26 from "node:path";
+import { existsSync as existsSync12, realpathSync as realpathSync8, statSync as statSync4 } from "node:fs";
+import path29 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // packages/workit-core/src/core.ts
 import { spawnSync as spawnSync14 } from "node:child_process";
 import { existsSync as existsSync8, realpathSync as realpathSync5 } from "node:fs";
-import path22 from "node:path";
+import path23 from "node:path";
 
 // packages/workit-core/src/core/task-contract.ts
 import { createHash, randomUUID } from "node:crypto";
@@ -19194,9 +19194,9 @@ var workerBlocksTransition = (transition, state) => transition === "pause" ? fal
 
 // packages/workit-core/src/core/task-evaluation.ts
 import { createHash as createHash10 } from "node:crypto";
-import * as fs13 from "node:fs";
+import * as fs14 from "node:fs";
 import { spawnSync as spawnSync10 } from "node:child_process";
-import path17 from "node:path";
+import path18 from "node:path";
 
 // packages/workit-core/src/check-config.ts
 import { spawnSync as spawnSync8 } from "node:child_process";
@@ -19430,13 +19430,13 @@ function checkCommand(args, version, onPath = workitAvailable()) {
 
 // packages/workit-core/src/core/policy/derive.ts
 import { existsSync as existsSync5 } from "node:fs";
-import path16 from "node:path";
+import path17 from "node:path";
 
 // packages/workit-core/src/ledger.ts
 import { spawnSync as spawnSync9 } from "node:child_process";
 import { createHash as createHash9, randomBytes as randomBytes3 } from "node:crypto";
-import fs12 from "node:fs";
-import path15 from "node:path";
+import fs13 from "node:fs";
+import path16 from "node:path";
 
 // packages/workit-core/src/core/policy/lane.ts
 import { existsSync as existsSync4, readFileSync as readFileSync4 } from "node:fs";
@@ -20179,6 +20179,34 @@ function verdictDrift(cwd, input) {
   return stale(lane.reasons[0] ?? `lane ${lane.lane}`, paths, lane.lane === "self");
 }
 
+// packages/workit-core/src/hooks/standing-signal.ts
+import fs12 from "node:fs";
+import path15 from "node:path";
+var gitStoreDir = (cwd) => {
+  try {
+    for (let dir = path15.resolve(cwd);; dir = path15.dirname(dir)) {
+      const dotGit = path15.join(dir, ".git");
+      if (fs12.existsSync(dotGit)) {
+        let gitDir = dotGit;
+        if (fs12.statSync(dotGit).isFile()) {
+          const target = /^gitdir:\s*(.+)$/mu.exec(fs12.readFileSync(dotGit, "utf8"))?.[1]?.trim();
+          if (!target)
+            return null;
+          gitDir = path15.resolve(dir, target);
+          const common = path15.join(gitDir, "commondir");
+          if (fs12.existsSync(common))
+            gitDir = path15.resolve(gitDir, fs12.readFileSync(common, "utf8").trim());
+        }
+        return path15.join(gitDir, "workit");
+      }
+      if (path15.dirname(dir) === dir)
+        return null;
+    }
+  } catch {
+    return null;
+  }
+};
+
 // packages/workit-core/src/ledger.ts
 var LEDGER_VERSION = 1;
 var MAX_LINE_BYTES = 4096;
@@ -20280,14 +20308,14 @@ function cleanRebase(cwd, range) {
   return Boolean(tree) && tree === git4(cwd, ["rev-parse", "--verify", "-q", `${range.to}^{tree}`]);
 }
 function storeRoot(cwd) {
-  const location = resolveStore(path15.resolve(cwd));
+  const location = resolveStore(path16.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: path15.join(root.value.root, "ledger", "ledger.jsonl") } : root;
+  return root.ok ? { ok: true, value: path16.join(root.value.root, "ledger", "ledger.jsonl") } : root;
 }
 var newId2 = () => `${Date.now().toString(36)}-${randomBytes3(6).toString("hex")}`;
 var NETWORK_FS_TYPES = new Set([
@@ -20307,7 +20335,7 @@ var onNetworkFs = (dir) => {
   if (process.platform !== "linux")
     return false;
   try {
-    return isNetworkFsType(fs12.statfsSync(dir).type);
+    return isNetworkFsType(fs13.statfsSync(dir).type);
   } catch {
     return false;
   }
@@ -20317,15 +20345,15 @@ var LOCK_STALE_MS = 30000;
 var LOCK_OWNER = "owner";
 var lockToken = (lock) => {
   try {
-    return fs12.readFileSync(path15.join(lock, LOCK_OWNER), "utf8");
+    return fs13.readFileSync(path16.join(lock, LOCK_OWNER), "utf8");
   } catch {
     return null;
   }
 };
 var lockAgeMs = (lock) => {
-  for (const target of [path15.join(lock, LOCK_OWNER), lock]) {
+  for (const target of [path16.join(lock, LOCK_OWNER), lock]) {
     try {
-      return Date.now() - fs12.statSync(target).mtimeMs;
+      return Date.now() - fs13.statSync(target).mtimeMs;
     } catch {}
   }
   return null;
@@ -20333,14 +20361,14 @@ var lockAgeMs = (lock) => {
 var 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(path15.join(lock, LOCK_OWNER), token);
+    fs13.writeFileSync(path16.join(lock, LOCK_OWNER), token);
     return token;
   },
   release(lock, token) {
@@ -20348,35 +20376,35 @@ var ledgerLock = {
       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;
   }
@@ -20410,7 +20438,7 @@ var TAIL_BYTES = 64 * 1024;
 var 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)
@@ -20441,21 +20469,21 @@ var lastLine = (fd, size) => {
 };
 var 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 {}
 };
 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 = `
 `;
@@ -20464,17 +20492,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(path15.dirname(file), { recursive: true });
-    if (!options.forceLock && !onNetworkFs(path15.dirname(file)))
+    fs13.mkdirSync(path16.dirname(file), { recursive: true });
+    if (!options.forceLock && !onNetworkFs(path16.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");
@@ -20544,8 +20572,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 {
@@ -20685,7 +20713,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;
@@ -21267,7 +21295,7 @@ var productDecision = (task, ledger) => {
   };
 };
 var planRecorded = (task, root) => {
-  const cited = (latestJudgment(task)?.refs ?? []).find((ref) => ref.kind === "external" || ref.kind === "file" && existsSync5(path16.resolve(root, ref.path)));
+  const cited = (latestJudgment(task)?.refs ?? []).find((ref) => ref.kind === "external" || ref.kind === "file" && existsSync5(path17.resolve(root, ref.path)));
   if (cited)
     return {
       met: true,
@@ -21334,14 +21362,14 @@ function derivedRuleStatus(task, requirement, root, ledger) {
 
 // packages/workit-core/src/core/task-evaluation.ts
 var digestBytes = (value) => createHash10("sha256").update(value).digest("hex");
-var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path17.sep}`);
-var relative = (root, candidate) => path17.relative(root, candidate).split(path17.sep).join("/") || ".";
+var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path18.sep}`);
+var relative = (root, candidate) => path18.relative(root, candidate).split(path18.sep).join("/") || ".";
 var canonicalPath = (value) => {
   if (typeof value !== "string" || !value)
     return null;
   if (value.includes("\\") || value.split("/").includes(".."))
     return null;
-  const normalized = path17.posix.normalize(value);
+  const normalized = path18.posix.normalize(value);
   if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
     return null;
   return normalized === "." ? "." : normalized.replace(/\/$/, "");
@@ -21389,21 +21417,21 @@ var gitPaths = (root) => {
       git: !/not a git repository/i.test(stderr)
     };
   }
-  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path17.sep).join("/")) : [];
+  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path18.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(path17.sep).join("/")));
+    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path18.sep).join("/")));
   }
   return { paths: [...new Set(paths)], uncertain: false, git: true };
 };
 var walk = (root, directory, output) => {
   let names;
   try {
-    names = fs13.readdirSync(directory);
+    names = fs14.readdirSync(directory);
   } catch {
     return true;
   }
@@ -21411,10 +21439,10 @@ var walk = (root, directory, output) => {
   for (const name of names) {
     if (name === ".git" || name === ".workit")
       continue;
-    const target = path17.join(directory, name);
+    const target = path18.join(directory, name);
     let stat;
     try {
-      stat = fs13.lstatSync(target);
+      stat = fs14.lstatSync(target);
     } catch {
       uncertain = true;
       continue;
@@ -21429,14 +21457,14 @@ var walk = (root, directory, output) => {
 var scopeRoots = (root, scope) => {
   const roots = [];
   for (const item of scope.paths.length ? scope.paths : ["."]) {
-    const target = path17.resolve(root, item);
+    const target = path18.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 = path17.dirname(ancestor);
+    while (!fs14.existsSync(ancestor) && ancestor !== root)
+      ancestor = path18.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}`);
@@ -21448,7 +21476,7 @@ var scopeRoots = (root, scope) => {
 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");
   }
@@ -21466,11 +21494,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;
@@ -21486,17 +21514,17 @@ function captureCandidate(root, scope, environment = []) {
   for (const item of [...names].toSorted()) {
     if (!scopeMatches(item, normalizedScope))
       continue;
-    const target = path17.join(checkout, item);
+    const target = path18.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()) {
@@ -21661,7 +21689,7 @@ var findingVerificationPasses = (findingCandidateId, evidence) => evidence.statu
 var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
   let root;
   try {
-    root = fs13.realpathSync(checkoutRoot);
+    root = fs14.realpathSync(checkoutRoot);
   } catch {
     return failure2("permission_denied", "checkout root is unavailable");
   }
@@ -21670,23 +21698,23 @@ var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
       continue;
     if (!reference.digest)
       return failure2("invalid_input", "document references require a byte digest");
-    const target = path17.resolve(root, reference.path);
-    if (target !== root && !target.startsWith(`${root}${path17.sep}`))
+    const target = path18.resolve(root, reference.path);
+    if (target !== root && !target.startsWith(`${root}${path18.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 = path17.relative(root, target);
+      const below = path18.relative(root, target);
       let current = root;
-      for (const segment of below.split(path17.sep)) {
+      for (const segment of below.split(path18.sep)) {
         if (!segment)
           continue;
-        current = path17.join(current, segment);
-        const stat = fs13.lstatSync(current);
-        const real = fs13.realpathSync(current);
-        if (real !== root && !real.startsWith(`${root}${path17.sep}`))
+        current = path18.join(current, segment);
+        const stat = fs14.lstatSync(current);
+        const real = fs14.realpathSync(current);
+        if (real !== root && !real.startsWith(`${root}${path18.sep}`))
           return failure2("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
             fields: [
               {
@@ -21702,7 +21730,7 @@ var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
         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");
@@ -22546,7 +22574,7 @@ var judgeInputSummary = (raw) => {
 
 // packages/workit-core/src/autonomy.ts
 import os4 from "node:os";
-import path18 from "node:path";
+import path19 from "node:path";
 var accountHome = () => {
   try {
     return os4.userInfo().homedir;
@@ -22555,10 +22583,10 @@ var accountHome = () => {
   }
 };
 var grantsHome = { resolve: accountHome };
-var grantsDir = () => path18.join(grantsHome.resolve(), ".config", "workit");
+var grantsDir = () => path19.join(grantsHome.resolve(), ".config", "workit");
 var grantsOverride = () => {
-  const configured = path18.resolve(resolveConfigDir());
-  return configured === path18.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 ${path18.join(grantsDir(), "workspaces.json")}, so the D4 defaults apply`;
+  const configured = path19.resolve(resolveConfigDir());
+  return configured === path19.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 ${path19.join(grantsDir(), "workspaces.json")}, so the D4 defaults apply`;
 };
 var GRANT_KINDS = ["push", "pr", "merge", "release", "rerun"];
 var DEFAULT_GRANTS = Object.freeze({
@@ -24369,7 +24397,7 @@ class WorkitCore {
 // packages/workit-core/src/core/repo-context.ts
 import { spawnSync as spawnSync11 } from "node:child_process";
 import { existsSync as existsSync7, readFileSync as readFileSync6, readdirSync as readdirSync4 } from "node:fs";
-import path19 from "node:path";
+import path20 from "node:path";
 var isSafeContextRange = (value) => value.length <= 4096 && (() => {
   try {
     gitRevisionParts(value);
@@ -24503,7 +24531,7 @@ var findPrTemplate = (cwd) => {
   ]) {
     const parts = rel.split("/");
     const base = parts[parts.length - 1];
-    const dir = parts.length > 1 ? path19.join(cwd, ...parts.slice(0, -1)) : cwd;
+    const dir = parts.length > 1 ? path20.join(cwd, ...parts.slice(0, -1)) : cwd;
     const actual = probeCaseInsensitive(dir, base);
     if (actual)
       return [...parts.slice(0, -1), actual].join("/");
@@ -24534,7 +24562,7 @@ var diffStatForRange = (cwd, range) => {
   return runGit(cwd, ["diff", "--stat", "--"]).stdout;
 };
 var packageScripts = (cwd, keys) => {
-  const pkgPath = path19.join(cwd, "package.json");
+  const pkgPath = path20.join(cwd, "package.json");
   if (!existsSync7(pkgPath))
     return [];
   try {
@@ -24560,9 +24588,9 @@ var documentationFiles = (cwd) => {
       if (entry.isDirectory()) {
         if (excluded.has(entry.name))
           continue;
-        walk(path19.join(dir, entry.name), depth + 1);
+        walk(path20.join(dir, entry.name), depth + 1);
       } else if (entry.isFile() && (entry.name === "README.md" || entry.name.endsWith(".md"))) {
-        matches.push("./" + path19.relative(cwd, path19.join(dir, entry.name)).replaceAll("\\", "/"));
+        matches.push("./" + path20.relative(cwd, path20.join(dir, entry.name)).replaceAll("\\", "/"));
       }
     }
   };
@@ -24578,7 +24606,7 @@ var readTrimmed2 = (file, maxLines) => {
 `);
 };
 function prReadyContext(root, range) {
-  const cwd = path19.resolve(repoRoot(root));
+  const cwd = path20.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   let stdout = "";
@@ -24636,7 +24664,7 @@ ${status.stderr}` : "");
     stdout += `template_path: ${template}
 
 `;
-    stdout += readTrimmed2(path19.join(cwd, template), 220);
+    stdout += readTrimmed2(path20.join(cwd, template), 220);
   } else {
     stdout += `template_path: none
 
@@ -24646,7 +24674,7 @@ ${status.stderr}` : "");
   stdout += `
 `;
   stdout += printSection("Recent Validation Signals");
-  if (existsSync7(path19.join(cwd, "package.json"))) {
+  if (existsSync7(path20.join(cwd, "package.json"))) {
     stdout += `package.json detected. Common scripts:
 `;
     const found = packageScripts(cwd, ["lint", "format:check", "test", "build"]);
@@ -24655,7 +24683,7 @@ ${status.stderr}` : "");
 `) + `
 `;
   }
-  if (existsSync7(path19.join(cwd, "Cargo.toml")) || existsSync7(path19.join(cwd, "src-tauri/Cargo.toml"))) {
+  if (existsSync7(path20.join(cwd, "Cargo.toml")) || existsSync7(path20.join(cwd, "src-tauri/Cargo.toml"))) {
     stdout += `Rust project detected.
 `;
   }
@@ -24688,7 +24716,7 @@ var CHANGELOG_RULES = `- Use an [Unreleased] section.
 - Apply with the host-native editor, preserving the repository changelog conventions.
 - If Unreleased already has duplicate category headings, normalize_only first.`;
 function changelogContext(root, range) {
-  const cwd = path19.resolve(repoRoot(root));
+  const cwd = path20.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   const resolvedRange = rangeArgOrDefault(range, cwd);
@@ -24706,7 +24734,7 @@ function changelogContext(root, range) {
   stdout += CHANGELOG_RULES + `
 `;
   stdout += printSection("Existing CHANGELOG.md");
-  const changelogPath = path19.join(cwd, "CHANGELOG.md");
+  const changelogPath = path20.join(cwd, "CHANGELOG.md");
   if (existsSync7(changelogPath)) {
     stdout += readTrimmed2(changelogPath, 260) + `
 `;
@@ -24726,7 +24754,7 @@ function changelogContext(root, range) {
   return { stdout, stderr: "", exitCode: 0, cwd };
 }
 function docsRefreshContext(root, range) {
-  const cwd = path19.resolve(repoRoot(root));
+  const cwd = path20.resolve(repoRoot(root));
   if (range !== undefined && !isResolvableContextRange(cwd, range))
     return invalidRange(cwd);
   const resolvedRange = rangeArgOrDefault(range, cwd);
@@ -24748,7 +24776,7 @@ function docsRefreshContext(root, range) {
 `) + `
 `;
   stdout += printSection("README Preview");
-  const readme = path19.join(cwd, "README.md");
+  const readme = path20.join(cwd, "README.md");
   if (existsSync7(readme)) {
     stdout += readTrimmed2(readme, 220) + `
 `;
@@ -24757,7 +24785,7 @@ function docsRefreshContext(root, range) {
 `;
   }
   stdout += printSection("Package Scripts");
-  const pkgPath = path19.join(cwd, "package.json");
+  const pkgPath = path20.join(cwd, "package.json");
   if (existsSync7(pkgPath)) {
     try {
       const pkg = JSON.parse(readFileSync6(pkgPath, "utf8"));
@@ -24771,7 +24799,7 @@ function docsRefreshContext(root, range) {
   return { stdout, stderr: "", exitCode: 0, cwd };
 }
 function releaseNotesContext(root, rangeOrTag) {
-  const cwd = path19.resolve(repoRoot(root));
+  const cwd = path20.resolve(repoRoot(root));
   if (!rangeOrTag) {
     return { stdout: "", stderr: `ERROR: release tag or range required
 `, exitCode: 1, cwd };
@@ -24809,7 +24837,7 @@ function releaseNotesContext(root, rangeOrTag) {
 `;
   stdout += printSection("Existing Release Files");
   for (const rel of ["CHANGELOG.md", "RELEASE_NOTES.md", ".github/releases.md"]) {
-    if (existsSync7(path19.join(cwd, rel)))
+    if (existsSync7(path20.join(cwd, rel)))
       stdout += rel + `
 `;
   }
@@ -24840,8 +24868,8 @@ function releaseNotesContext(root, rangeOrTag) {
 import { spawnSync as spawnSync13 } from "node:child_process";
 
 // packages/workit-core/src/core/pr-create.ts
-import fs14 from "node:fs";
-import path20 from "node:path";
+import fs15 from "node:fs";
+import path21 from "node:path";
 import { spawnSync as spawnSync12 } from "node:child_process";
 // packages/workit-core/src/forge/pr-body.ts
 function parseGhIssue(value) {
@@ -24852,13 +24880,13 @@ function parseGhIssue(value) {
 // packages/workit-core/src/core/pr-create.ts
 function whichOnPath(tool) {
   const names = process.platform === "win32" ? [tool, `${tool}.exe`, `${tool}.cmd`] : [tool];
-  for (const dir of (process.env.PATH ?? "").split(path20.delimiter)) {
+  for (const dir of (process.env.PATH ?? "").split(path21.delimiter)) {
     if (!dir)
       continue;
     for (const name of names) {
-      const candidate = path20.join(dir, name);
+      const candidate = path21.join(dir, name);
       try {
-        fs14.accessSync(candidate, fs14.constants.X_OK);
+        fs15.accessSync(candidate, fs15.constants.X_OK);
         return candidate;
       } catch {}
     }
@@ -24976,8 +25004,8 @@ var fetchGitLabIssueBody = async (ref, root, deps = {}) => {
 };
 
 // packages/workit-core/src/core/youtrack.ts
-import fs15 from "node:fs";
-import path21 from "node:path";
+import fs16 from "node:fs";
+import path22 from "node:path";
 
 // packages/workit-core/src/core/templates.ts
 var repoRoot2 = assetRoot();
@@ -24990,22 +25018,22 @@ var resolveWorkspaceRoot = (explicit) => explicit || process.cwd();
 // packages/workit-core/src/core/youtrack.ts
 var ISSUE_RE = /^[A-Z]+-\d+$/;
 var TOKEN_PLACEHOLDER = "YOUR_TOKEN_HERE";
-var youTrackConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path21.join(configDir(), "youtrack.json");
-var youTrackReadOnlyConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path21.join(resolveConfigDir(), "youtrack.json");
+var youTrackConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path22.join(configDir(), "youtrack.json");
+var youTrackReadOnlyConfigPath = () => process.env.WORKFLOW_YOUTRACK_CONFIG ?? path22.join(resolveConfigDir(), "youtrack.json");
 var youTrackTokenModeOk = (p) => {
   if (process.platform === "win32")
     return true;
-  const mode = fs15.statSync(p).mode & 511;
+  const mode = fs16.statSync(p).mode & 511;
   return mode === 384;
 };
 function readYouTrackConfig(required) {
   const cfgPath = youTrackConfigPath();
-  if (!fs15.existsSync(cfgPath)) {
+  if (!fs16.existsSync(cfgPath)) {
     return required ? { error: "ERROR: missing youtrack.json", path: cfgPath } : { config: {}, path: cfgPath };
   }
   let parsed;
   try {
-    parsed = JSON.parse(fs15.readFileSync(cfgPath, "utf8"));
+    parsed = JSON.parse(fs16.readFileSync(cfgPath, "utf8"));
   } catch {
     return { error: `${cfgPath} is not valid JSON`, path: cfgPath };
   }
@@ -25016,11 +25044,11 @@ function readYouTrackConfig(required) {
 }
 var readYouTrackContextConfig = () => {
   const cfgPath = youTrackReadOnlyConfigPath();
-  if (!fs15.existsSync(cfgPath))
+  if (!fs16.existsSync(cfgPath))
     return { data: {} };
   let parsed;
   try {
-    parsed = JSON.parse(fs15.readFileSync(cfgPath, "utf8"));
+    parsed = JSON.parse(fs16.readFileSync(cfgPath, "utf8"));
   } catch {
     return { error: "YouTrack configuration is unavailable" };
   }
@@ -25059,12 +25087,12 @@ var youTrackToken = () => {
   if ("error" in loaded)
     return loaded;
   const tokenFile = String(loaded.config.tokenFile ?? "");
-  const tokenPath = tokenFile ? path21.isAbsolute(tokenFile) ? path21.resolve(tokenFile) : path21.resolve(process.cwd(), tokenFile) : "";
-  if (!tokenPath || !fs15.existsSync(tokenPath))
+  const tokenPath = tokenFile ? path22.isAbsolute(tokenFile) ? path22.resolve(tokenFile) : path22.resolve(process.cwd(), tokenFile) : "";
+  if (!tokenPath || !fs16.existsSync(tokenPath))
     return { error: "missing youtrack.token" };
   if (!youTrackTokenModeOk(tokenPath))
     return { error: "youtrack.token mode must be 0600" };
-  const token = fs15.readFileSync(tokenPath, "utf8").trim();
+  const token = fs16.readFileSync(tokenPath, "utf8").trim();
   if (!token)
     return { error: "empty token file" };
   if (token === TOKEN_PLACEHOLDER || token.startsWith(TOKEN_PLACEHOLDER)) {
@@ -25129,9 +25157,9 @@ function resolveYouTrackFromPaths(spec_path, plan_path, workspace_root) {
     } catch {
       continue;
     }
-    if (!fs15.existsSync(full))
+    if (!fs16.existsSync(full))
       continue;
-    const text = fs15.readFileSync(full, "utf8");
+    const text = fs16.readFileSync(full, "utf8");
     const m = text.match(/^\*\*YouTrack:\*\*\s*`?([A-Z]+-\d+)`?/m);
     if (m)
       return m[1];
@@ -25401,15 +25429,15 @@ function resolveGitRevision(root, value) {
 }
 function resolveInside(root, candidate) {
   const base = realpathSync5(root);
-  const target = path22.resolve(base, candidate);
-  if (target !== base && !target.startsWith(base + path22.sep)) {
+  const target = path23.resolve(base, candidate);
+  if (target !== base && !target.startsWith(base + path23.sep)) {
     throw new Error("path must stay inside repository root");
   }
   let ancestor = target;
   while (!existsSync8(ancestor))
-    ancestor = path22.dirname(ancestor);
+    ancestor = path23.dirname(ancestor);
   const canonicalAncestor = realpathSync5(ancestor);
-  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path22.sep)) {
+  if (canonicalAncestor !== base && !canonicalAncestor.startsWith(base + path23.sep)) {
     throw new Error("path must stay inside repository root");
   }
   return target;
@@ -25441,7 +25469,7 @@ var SUPPORT_MATRIX = {
 
 // packages/workit-mcp/src/server.ts
 import { existsSync as existsSync9, readFileSync as readFileSync7, realpathSync as realpathSync6 } from "node:fs";
-import path23 from "node:path";
+import path24 from "node:path";
 // node_modules/@modelcontextprotocol/sdk/dist/esm/server/zod-compat.js
 function isZ4Schema(s) {
   const schema = s;
@@ -27889,13 +27917,13 @@ var rootVariants = (workspaceRoot) => {
   if (!workspaceRoot)
     return [];
   const roots = new Set;
-  for (const candidate of [workspaceRoot, path23.resolve(workspaceRoot)]) {
-    if (path23.isAbsolute(candidate) && candidate !== path23.parse(candidate).root)
+  for (const candidate of [workspaceRoot, path24.resolve(workspaceRoot)]) {
+    if (path24.isAbsolute(candidate) && candidate !== path24.parse(candidate).root)
       roots.add(candidate);
   }
   try {
     const canonical = realpathSync6(workspaceRoot);
-    if (canonical !== path23.parse(canonical).root)
+    if (canonical !== path24.parse(canonical).root)
       roots.add(canonical);
   } catch {}
   return [...roots].toSorted((left, right) => right.length - left.length);
@@ -27977,11 +28005,11 @@ var thrownResult = (tool, error, workspaceRoot) => {
 };
 function createMcpServer(host, contextProvider) {
   assertMcpHost(host);
-  const here = path23.dirname(fileURLToPath2(import.meta.url));
+  const here = path24.dirname(fileURLToPath2(import.meta.url));
   const sourceMarker = markSourcesLoaded([
-    path23.join(here, "server.ts"),
-    path23.join(here, "..", "..", "workit-core", "src", "core", "task-contract.ts"),
-    path23.join(here, "..", "..", "workit-core", "src", "core", "task-engine.ts")
+    path24.join(here, "server.ts"),
+    path24.join(here, "..", "..", "workit-core", "src", "core", "task-contract.ts"),
+    path24.join(here, "..", "..", "workit-core", "src", "core", "task-engine.ts")
   ].filter((file) => existsSync9(file)));
   let staleWarned = false;
   const failures = new Map;
@@ -28320,7 +28348,7 @@ var EXEC = new Set(["exec", "x", "dlx"]);
 // packages/workit-core/src/core/heavy-words.ts
 var HEAVY_WORDS = new Set(("npm npx pnpm pnpx yarn bun bunx deno corepack make gmake docker podman nerdctl " + "python python3 py uv poetry pdm pipenv hatch rye bundle rake nx " + "jest vitest mocha ava tap karma jasmine nyc c8 tsc vue-tsc svelte-check eslint stylelint " + "tslint webpack webpack-cli rollup parcel tsup vite next nuxt nuxi astro ng react-scripts " + "playwright cypress wdio testcafe turbo lerna sonar-scanner sonarless sonarless-mcp go " + "golangci-lint gotestsum staticcheck cargo mvn mvnw gradle gradlew ant sbt bazel bazelisk " + "buck2 dotnet msbuild pytest py.test tox nox mypy pyright pylint coverage maturin pip pip3 " + "rspec rails phpunit pest phpstan psalm composer mix swift xcodebuild flutter dart pod cmake " + "ninja meson ctest scons docker-compose buildah earthly").split(" "));
 // packages/workit-core/src/hooks/write-gate.ts
-import path24 from "node:path";
+import path25 from "node:path";
 
 // packages/workit-core/src/core/live-session.ts
 import { spawnSync as spawnSync15 } from "node:child_process";
@@ -28361,7 +28389,7 @@ var MUTATING_WORKIT_GIT = new Set(["commit", "branch"]);
 var CD2 = new Set(["cd", "chdir", "set-location", "sl"]);
 var PUSHD2 = new Set(["pushd", "push-location"]);
 var POPD2 = new Set(["popd", "pop-location"]);
-var UNKNOWN_DIR = path24.resolve(path24.parse(process.cwd()).root, ".workit-unknown-dir");
+var UNKNOWN_DIR = path25.resolve(path25.parse(process.cwd()).root, ".workit-unknown-dir");
 // packages/workit-core/src/core/skill-manifests.ts
 if (false) {}
 
@@ -28381,7 +28409,42 @@ var READERS = new Set([
   "type"
 ]);
 // packages/workit-core/src/hooks/hosts/fields.ts
+import { existsSync as existsSync10, realpathSync as realpathSync7, statSync as statSync3 } from "node:fs";
+import path26 from "node:path";
+var isRecord4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+var nonEmpty2 = (value) => typeof value === "string" && value.trim() !== "";
+var optionalText = (value) => typeof value === "string" ? value : null;
+var existingDirectory = (value) => {
+  if (!nonEmpty2(value) || !path26.isAbsolute(value) || !existsSync10(value))
+    return null;
+  try {
+    return statSync3(value).isDirectory() ? realpathSync7(value) : null;
+  } catch {
+    return null;
+  }
+};
 var SHELLS2 = new Set(["sh", "bash", "zsh", "dash", "pwsh", "powershell", "cmd"]);
+var SCRIPT_FLAG = /^(?:-\w*c|-command|\/c)$/i;
+var quoteArg = (arg) => /^[\w@%+=:,./-]+$/.test(arg) ? arg : JSON.stringify(arg);
+var commandText = (value) => {
+  if (nonEmpty2(value))
+    return value;
+  if (!Array.isArray(value) || value.length === 0)
+    return null;
+  const argv = value;
+  if (!argv.every((arg) => typeof arg === "string"))
+    return null;
+  const shell = argv[0].split(/[\\/]/).at(-1)?.replace(/\.exe$/i, "").toLowerCase() ?? "";
+  if (SHELLS2.has(shell))
+    for (let index = 1;index < argv.length - 1; index++) {
+      if (SCRIPT_FLAG.test(argv[index]))
+        return nonEmpty2(argv[index + 1]) ? argv[index + 1] : null;
+      if (!/^[-/]/.test(argv[index]))
+        break;
+    }
+  const joined = argv.map(quoteArg).join(" ");
+  return nonEmpty2(joined) ? joined : null;
+};
 var WRITE_TOOLS = new Set([
   "write",
   "edit",
@@ -28401,6 +28464,23 @@ var WRITE_TOOLS = new Set([
   "editfile",
   "writefile"
 ]);
+var isWriteTool = (name) => typeof name === "string" && WRITE_TOOLS.has(name.toLowerCase().replace(/[_-]/g, ""));
+var PATH_KEYS = ["file_path", "filePath", "notebook_path", "path", "target_file", "file"];
+var PATCH_HEADER = /^[ \t]*\*\*\* (?:(?:Add|Update|Delete) File|Move to): (.+)$/gm;
+var writePaths = (input) => {
+  if (!isRecord4(input))
+    return [];
+  const paths = PATH_KEYS.map((key) => input[key]).filter(nonEmpty2);
+  for (const value of Object.values(input))
+    if (typeof value === "string")
+      for (const match of value.matchAll(PATCH_HEADER))
+        paths.push(match[1].trim());
+  return [...new Set(paths)];
+};
+var writeTargets = (input) => {
+  const paths = writePaths(input);
+  return paths.length > 0 ? paths : null;
+};
 // packages/workit-core/src/hooks/standing.ts
 var sinceStart = new Map;
 // packages/workit-core/src/hooks/cwd-normalize.ts
@@ -28647,8 +28727,168 @@ var CODEX_DESCRIPTOR = {
   ]
 };
 var codexDescriptor = (host) => ({ ...CODEX_DESCRIPTOR, host });
+var EVENTS = {
+  SessionStart: "session.start",
+  UserPromptSubmit: "context.turn",
+  PreToolUse: "shell.pre",
+  PostToolUse: "shell.post",
+  SubagentStart: "subagent.start",
+  SubagentStop: "subagent.stop",
+  Stop: "stop"
+};
 var SHELL_TOOLS2 = new Set(["bash", "unified-exec"]);
+var isShellTool = (name) => SHELL_TOOLS2.has(String(name).toLowerCase());
 var SOURCES2 = new Set(["startup", "resume", "clear", "compact", "fork"]);
+var parseCodexHookInput = (value) => {
+  if (!isRecord4(value) || !Object.hasOwn(EVENTS, String(value.hook_event_name)))
+    return { ok: false, error: "hook_event_name is required" };
+  const event = value.hook_event_name;
+  const cwd = existingDirectory(value.cwd);
+  if (!cwd)
+    return { ok: false, error: "cwd must be an existing absolute directory" };
+  const toolEvent = event === "PreToolUse" || event === "PostToolUse";
+  if (toolEvent && !nonEmpty2(value.tool_name))
+    return { ok: false, error: "tool_name is required" };
+  const command = isRecord4(value.tool_input) ? commandText(value.tool_input.command) : null;
+  if (toolEvent && isShellTool(value.tool_name) && !command)
+    return { ok: false, error: "tool_input.command is required for shell tools" };
+  if (event === "SubagentStart" && !nonEmpty2(value.agent_id))
+    return { ok: false, error: "agent_id is required" };
+  return {
+    ok: true,
+    data: {
+      hook_event_name: event,
+      session_id: nonEmpty2(value.session_id) ? value.session_id : "",
+      model: optionalText(value.model),
+      permission_mode: optionalText(value.permission_mode),
+      transcript_path: optionalText(value.transcript_path),
+      cwd,
+      ...event === "SessionStart" ? { source: SOURCES2.has(String(value.source)) ? value.source : "resume" } : {},
+      ...nonEmpty2(value.turn_id) ? { turn_id: value.turn_id } : {},
+      ...event === "UserPromptSubmit" ? { prompt: optionalText(value.prompt) } : {},
+      ...nonEmpty2(value.tool_name) ? { tool_name: value.tool_name } : {},
+      ...toolEvent ? { tool_input: value.tool_input } : {},
+      ...event === "PostToolUse" && typeof value.tool_response === "string" ? { tool_response: value.tool_response } : {},
+      ...command ? { command } : {},
+      ...nonEmpty2(value.tool_use_id) ? { tool_use_id: value.tool_use_id } : {},
+      ...nonEmpty2(value.agent_id) ? { agent_id: value.agent_id } : {},
+      ...nonEmpty2(value.agent_type) ? { agent_type: value.agent_type } : {},
+      ...event === "Stop" ? {
+        last_assistant_message: optionalText(value.last_assistant_message),
+        stop_hook_active: value.stop_hook_active === true
+      } : {},
+      ...event === "SubagentStop" ? {
+        agent_transcript_path: optionalText(value.agent_transcript_path),
+        last_assistant_message: optionalText(value.last_assistant_message),
+        stop_hook_active: value.stop_hook_active === true
+      } : {}
+    }
+  };
+};
+var protocolEvent = (input) => {
+  switch (input.hook_event_name) {
+    case "SessionStart":
+      return { kind: "session.start", source: input.source };
+    case "UserPromptSubmit":
+      return { kind: "context.turn", prompt: input.prompt ?? null };
+    case "PreToolUse": {
+      const toolUseId = input.tool_use_id ?? null;
+      if (isShellTool(input.tool_name))
+        return { kind: "shell.pre", command: input.command ?? "", toolUseId };
+      if (isWriteTool(input.tool_name))
+        return {
+          kind: "write.pre",
+          tool: input.tool_name,
+          paths: writeTargets(input.tool_input),
+          toolUseId
+        };
+      return { kind: "tool.pre", tool: input.tool_name, toolUseId };
+    }
+    case "PostToolUse": {
+      const toolUseId = input.tool_use_id ?? null;
+      return isShellTool(input.tool_name) ? {
+        kind: "shell.post",
+        command: input.command ?? "",
+        stdout: input.tool_response ?? "",
+        exitCode: null,
+        toolUseId
+      } : { kind: "tool.pre", tool: input.tool_name, toolUseId };
+    }
+    case "SubagentStart":
+      return {
+        kind: "subagent.start",
+        agentId: input.agent_id,
+        agentType: input.agent_type ?? "unknown",
+        task: null
+      };
+    case "SubagentStop":
+      return {
+        kind: "subagent.stop",
+        agentId: input.agent_id ?? null,
+        agentType: input.agent_type ?? null,
+        lastMessage: input.last_assistant_message ?? null,
+        stopHookActive: input.stop_hook_active ?? false
+      };
+    case "Stop":
+      return {
+        kind: "stop",
+        lastMessage: input.last_assistant_message ?? null,
+        stopHookActive: input.stop_hook_active ?? false
+      };
+  }
+};
+var output = (event, extra = {}) => ({
+  hookSpecificOutput: { hookEventName: event, ...extra }
+});
+var render = (decision, native) => {
+  if (native === "Stop" && decision.kind === "continue")
+    return { json: { decision: "block", reason: decision.reason }, exitCode: 0 };
+  if (native === "SubagentStop" || native === "Stop" || native === null)
+    return { json: {}, exitCode: 0 };
+  if (decision.kind === "deny")
+    return {
+      json: output(native, {
+        permissionDecision: "deny",
+        permissionDecisionReason: decision.reason
+      }),
+      exitCode: 0
+    };
+  if (decision.kind === "context")
+    return { json: output(native, { additionalContext: decision.text }), exitCode: 0 };
+  return { json: output(native), exitCode: 0 };
+};
+var codexAdapter = {
+  descriptor: CODEX_DESCRIPTOR,
+  parse(raw, env) {
+    const host = detectCodexSurface(env);
+    const parsed = parseCodexHookInput(raw);
+    if (!parsed.ok) {
+      const native = isRecord4(raw) && Object.hasOwn(EVENTS, String(raw.hook_event_name)) ? raw.hook_event_name : null;
+      return { ok: false, error: parsed.error, native, event: native ? EVENTS[native] : null };
+    }
+    const input = parsed.data;
+    return {
+      ok: true,
+      native: input.hook_event_name,
+      input: {
+        host,
+        cwd: input.cwd,
+        session: {
+          id: input.session_id,
+          agentId: input.agent_id ?? null,
+          agentType: input.agent_type ?? null,
+          parentId: null
+        },
+        permissionMode: input.permission_mode,
+        transcriptPath: input.transcript_path,
+        model: input.model,
+        event: protocolEvent(input)
+      }
+    };
+  },
+  render,
+  addendum: (input) => `<workit-codex-mutations>Codex MCP is read-only: unattested callers cannot mutate. Run workit verbs with the workit CLI on the shell (node_modules/.bin/workit, or npx -y @brainervirus/workit-cli): check, git branch|commit|push, pr, ci, stack, ledger, handoff; task-family mutations take --json${input.session.id ? ` --actor ${input.session.id}` : ""}. workit acts as this thread (CODEX_THREAD_ID${input.session.id ? `=${input.session.id}` : ""}) unless WORKIT_SESSION_ID is set. A verifier or reviewer records workit ledger verdict under its own session, never the author's: a workit-verifier or workit-reviewer agent uses the --session its SubagentStart context names; any other passes --as verifier (an id derived from its own thread). A hand-minted id such as <lead>-v1 is refused as forged_session. Merge and release need a workspace grant (workit grant show); a question answer is not host permission.</workit-codex-mutations>`
+};
 
 // packages/workit-core/src/hooks/hosts/cursor.ts
 var TRANSCRIPT_TAIL_BYTES = 256 * 1024;
@@ -28656,6 +28896,112 @@ var BLOCKING2 = new Set(["preToolUse", "beforeShellExecution", "subagentStart"])
 
 // packages/workit-core/src/hooks/run.ts
 if (false) {}
+// packages/workit-core/src/hooks/budget-signal.ts
+import { createHash as createHash12 } from "node:crypto";
+import fs17 from "node:fs";
+import path27 from "node:path";
+var hash2 = (text) => createHash12("sha256").update(text).digest("hex").slice(0, 32);
+var budgetDir = (store) => path27.join(store, "budget");
+var agentBase = (store, session, agentId) => path27.join(budgetDir(store), hash2(`${session}\x00${agentId ?? ""}`));
+var spawnsFile = (store, session) => path27.join(budgetDir(store), `spawns-${hash2(session)}.jsonl`);
+var spawnBudget = (prompt) => {
+  const found = /^TIMEBOX:[^\n]*?\b(\d+)\s+tool calls\b/mu.exec(prompt);
+  const n = found ? Number(found[1]) : NaN;
+  return Number.isInteger(n) && n > 0 ? n : null;
+};
+var noteSpawnBudget = (cwd, session, type, prompt) => {
+  try {
+    const store = session ? gitStoreDir(cwd) : null;
+    if (!store)
+      return;
+    fs17.mkdirSync(budgetDir(store), { recursive: true });
+    fs17.appendFileSync(spawnsFile(store, session), `${JSON.stringify({ type: type ?? "", n: spawnBudget(prompt) })}
+`);
+  } catch {}
+};
+var readBudget = (file) => {
+  try {
+    const { limit, told } = JSON.parse(fs17.readFileSync(file, "utf8"));
+    return typeof limit === "number" && limit > 0 ? { limit, told: Number(told) || 0 } : null;
+  } catch {
+    return null;
+  }
+};
+var claimSpawnBudget = (cwd, session, agentId, agentType) => {
+  try {
+    const store = session ? gitStoreDir(cwd) : null;
+    if (!store)
+      return null;
+    const file = spawnsFile(store, session);
+    const entries = fs17.readFileSync(file, "utf8").split(`
+`).filter(Boolean).map((line) => JSON.parse(line));
+    const at = entries.findIndex((entry) => entry.type === (agentType ?? ""));
+    if (at < 0)
+      return null;
+    const [{ n }] = entries.splice(at, 1);
+    fs17.writeFileSync(file, entries.map((entry) => `${JSON.stringify(entry)}
+`).join(""));
+    if (typeof n !== "number" || n <= 0)
+      return null;
+    startBudget(store, session, agentId, n);
+    return n;
+  } catch {
+    return null;
+  }
+};
+var startBudget = (store, session, agentId, n) => {
+  const dir = budgetDir(store);
+  fs17.mkdirSync(dir, { recursive: true });
+  const cutoff = Date.now() - 604800000;
+  for (const name of fs17.readdirSync(dir))
+    try {
+      if (fs17.statSync(path27.join(dir, name)).mtimeMs < cutoff)
+        fs17.rmSync(path27.join(dir, name));
+    } catch {}
+  const base = agentBase(store, session, agentId);
+  fs17.writeFileSync(`${base}.json`, JSON.stringify({ limit: n, told: 0 }));
+  fs17.rmSync(`${base}.calls`, { force: true });
+};
+var lineFor = (calls) => `Tool-call budget reached (${calls}): commit your work, write your report, stop.`;
+var reachedOf = (cwd, session, agentId) => {
+  const store = session ? gitStoreDir(cwd) : null;
+  const base = store && agentBase(store, session, agentId);
+  const budget = base && readBudget(`${base}.json`);
+  if (!budget)
+    return null;
+  return { base, budget, reached: Math.floor(fs17.statSync(`${base}.calls`).size / budget.limit) };
+};
+var dropBudget = (cwd, session, agentId) => {
+  const store = session ? gitStoreDir(cwd) : null;
+  if (store)
+    for (const ext of [".json", ".calls"])
+      fs17.rmSync(agentBase(store, session, agentId) + ext, { force: true });
+};
+var budgetLine = (cwd, session, agentId) => {
+  try {
+    const at = reachedOf(cwd, session, agentId);
+    if (!at || at.reached <= at.budget.told)
+      return null;
+    fs17.writeFileSync(`${at.base}.json`, JSON.stringify({ ...at.budget, told: at.reached }));
+    return lineFor(at.budget.limit * at.reached);
+  } catch {
+    return null;
+  }
+};
+var CODEX_GATED = new Set(["bash", "unifiedexec", "shell", "applypatch", "edit", "write"]);
+var budgetHooks = {
+  line: (input) => budgetLine(input.cwd, input.session.id ?? "", input.session.agentId),
+  start: (input, agentId, agentType) => void claimSpawnBudget(input.cwd, input.session.id ?? "", agentId, agentType),
+  spawn: (input, spawn) => {
+    if (!input.session.agentId)
+      noteSpawnBudget(input.cwd, input.session.id ?? "", String(spawn.subagent_type || "general-purpose"), String(spawn.prompt ?? ""));
+  },
+  stop: (input, agentId) => {
+    try {
+      dropBudget(input.cwd, input.session.id ?? "", agentId);
+    } catch {}
+  }
+};
 // packages/workit-codex/hooks/workit-hook.ts
 var codexCapabilities = (host, availability = {}) => capabilitiesFor(codexDescriptor(host), {
   "session.start": availability.sessionStart,
@@ -28663,12 +29009,13 @@ var codexCapabilities = (host, availability = {}) => capabilitiesFor(codexDescri
   "subagent.start": availability.subagentStart,
   "subagent.stop": availability.subagentStop
 });
+var adapter = { ...codexAdapter, budget: budgetHooks };
 if (false)
   ;
 
 // packages/workit-codex/scripts/agents.ts
 import {
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   lstatSync as lstatSync3,
   mkdirSync as mkdirSync3,
   readdirSync as readdirSync5,
@@ -28678,18 +29025,18 @@ import {
   writeFileSync as writeFileSync3
 } from "node:fs";
 import os5 from "node:os";
-import path25 from "node:path";
+import path28 from "node:path";
 var CODEX_AGENT_ROLES = ["verifier", "reviewer", "implementer"];
 var CODEX_AGENT_MARKER = "# Generated by Workit";
 var codexAgentName = (role) => `workit-${role}`;
 var codexAgentFile = (role) => `${codexAgentName(role)}.toml`;
 var tomlString = (value) => JSON.stringify(value);
 var codexHomeOfInstall = (pluginRoot) => {
-  const parts = path25.resolve(pluginRoot).split(path25.sep);
+  const parts = path28.resolve(pluginRoot).split(path28.sep);
   const cache = parts.length - 4;
-  return cache >= 2 && parts[cache] === "cache" && parts[cache - 1] === "plugins" ? parts.slice(0, cache - 1).join(path25.sep) || path25.sep : null;
+  return cache >= 2 && parts[cache] === "cache" && parts[cache - 1] === "plugins" ? parts.slice(0, cache - 1).join(path28.sep) || path28.sep : null;
 };
-var codexHomeFor = (pluginRoot, env) => codexHomeOfInstall(pluginRoot) ?? (env.CODEX_HOME || path25.join(env.HOME || os5.homedir(), ".codex"));
+var codexHomeFor = (pluginRoot, env) => codexHomeOfInstall(pluginRoot) ?? (env.CODEX_HOME || path28.join(env.HOME || os5.homedir(), ".codex"));
 var withRoleModel = (content, file, models) => {
   const role = CODEX_AGENT_ROLES.find((candidate) => codexAgentFile(candidate) === file);
   const chosen = role ? models[role] : undefined;
@@ -28712,7 +29059,7 @@ var versionAtLeast = (version, min) => {
 };
 var pluginVersion = (pluginRoot) => {
   try {
-    const version = JSON.parse(readFileSync8(path25.join(pluginRoot, "package.json"), "utf8")).version;
+    const version = JSON.parse(readFileSync8(path28.join(pluginRoot, "package.json"), "utf8")).version;
     return typeof version === "string" && /^\d+\.\d+\.\d+/.test(version) ? version.match(/^\d+\.\d+\.\d+/)[0] : null;
   } catch {
     return null;
@@ -28726,15 +29073,15 @@ var lstatOrNull = (file) => {
   }
 };
 var installCodexAgents = (pluginRoot, codexHome, models = {}) => {
-  const source = path25.join(pluginRoot, "agents");
-  if (!existsSync10(source))
+  const source = path28.join(pluginRoot, "agents");
+  if (!existsSync11(source))
     return [];
   const version = pluginVersion(pluginRoot);
-  const target = path25.join(codexHome, "agents");
+  const target = path28.join(codexHome, "agents");
   const results = [];
   for (const file of readdirSync5(source).filter((name) => name.endsWith(".toml")).toSorted()) {
-    const content = withRoleModel(stampCodexAgent(readFileSync8(path25.join(source, file), "utf8"), version), file, models);
-    const dest = path25.join(target, file);
+    const content = withRoleModel(stampCodexAgent(readFileSync8(path28.join(source, file), "utf8"), version), file, models);
+    const dest = path28.join(target, file);
     const stat = lstatOrNull(dest);
     if (stat?.isSymbolicLink()) {
       results.push({ file: dest, action: "skipped-symlink" });
@@ -28770,7 +29117,7 @@ var installCodexAgents = (pluginRoot, codexHome, models = {}) => {
       results.push({ file: dest, action: "kept-newer-version" });
       continue;
     }
-    const temp = path25.join(target, `.${file}.${process.pid}.${Date.now()}.tmp`);
+    const temp = path28.join(target, `.${file}.${process.pid}.${Date.now()}.tmp`);
     writeFileSync3(temp, content, { flag: "wx" });
     try {
       renameSync2(temp, dest);
@@ -28792,14 +29139,14 @@ var codexQualification = (host) => host === "codex_cli" ? { surface: host, cli:
 var resolveCodexWorkspaceRoot = (pluginRoot, env) => {
   const explicit = env.WORKFLOW_WORKSPACE_ROOT;
   const inherited = env.PWD;
-  const candidate = explicit ?? (inherited && path26.resolve(inherited) !== path26.resolve(pluginRoot) ? inherited : undefined);
-  if (!candidate || !path26.isAbsolute(candidate) || !existsSync11(candidate))
+  const candidate = explicit ?? (inherited && path29.resolve(inherited) !== path29.resolve(pluginRoot) ? inherited : undefined);
+  if (!candidate || !path29.isAbsolute(candidate) || !existsSync12(candidate))
     return null;
   try {
-    if (!statSync3(candidate).isDirectory())
+    if (!statSync4(candidate).isDirectory())
       return null;
-    const canonical = realpathSync7(candidate);
-    if (canonical === realpathSync7(pluginRoot)) {
+    const canonical = realpathSync8(candidate);
+    if (canonical === realpathSync8(pluginRoot)) {
       if (!explicit)
         return null;
       const workspace = new TaskStore(canonical).readWorkspace();
@@ -28832,7 +29179,7 @@ var codexContextProvider = (host = detectCodexSurface(process.env), root) => ({
     };
   }
 });
-var pluginRoot = () => path26.resolve(path26.dirname(fileURLToPath3(import.meta.url)), "..");
+var pluginRoot = () => path29.resolve(path29.dirname(fileURLToPath3(import.meta.url)), "..");
 var codexRoleModels = (cwd) => {
   const out = {};
   for (const role of ["verifier", "reviewer"]) {