@brainervirus/workit-codex 8.16.0 → 8.17.1

package/dist/{workit-hook-71xrmyzh.js → workit-hook-5g0b5ywj.js}

@@ -1,4 +1,13 @@
 #!/usr/bin/env node
+import {
+  CHECKS_FILE,
+  repoHeavyCommands,
+  loadCheckConfig,
+  matchesNamedCheck,
+  gateCheckNames,
+  checkCommand,
+  maybeHeavy
+} from "./workit-hook-rbb0m9zp.js";
 // packages/workit-core/src/hooks/descriptor.ts
 var support = (descriptor, axis) => {
   if (axis.startsWith("event:"))
@@ -25,8 +34,8 @@ var capabilitiesFor = (descriptor, observed = {}) => descriptor.capabilities.map
 });
 // packages/workit-core/src/hooks/context.ts
 import { createHash as createHash11 } from "node:crypto";
-import fs14 from "node:fs";
-import path18 from "node:path";
+import fs13 from "node:fs";
+import path17 from "node:path";
 
 // packages/workit-core/src/core/methods.ts
 var METHODS = {
@@ -8804,225 +8813,20 @@ function requirementId(input) {
 
 // packages/workit-core/src/core/task-evaluation.ts
 import { createHash as createHash10 } from "node:crypto";
-import * as fs13 from "node:fs";
-import { spawnSync as spawnSync10 } from "node:child_process";
-import path16 from "node:path";
-
-// packages/workit-core/src/check-config.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-import fs2 from "node:fs";
-import path2 from "node:path";
-var SCRIPT_CHECKS = ["test", "lint", "typecheck", "check"];
-var CHECKS_FILE = "workit.checks.json";
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var SHELL_META = /[|&;<>()$`\\*?[\]{}~!#]/u;
-function splitCommand(command) {
-  const argv = [];
-  let current = "";
-  let quote = null;
-  let started = false;
-  for (const char of command) {
-    if (quote) {
-      if (char === quote)
-        quote = null;
-      else
-        current += char;
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      quote = char;
-      started = true;
-      continue;
-    }
-    if (/\s/u.test(char)) {
-      if (started)
-        argv.push(current);
-      current = "";
-      started = false;
-      continue;
-    }
-    if (SHELL_META.test(char))
-      return new Error(`"${command}" uses shell syntax (${char}); configure an argv array instead`);
-    current += char;
-    started = true;
-  }
-  if (quote)
-    return new Error(`"${command}" has an unterminated quote`);
-  if (started)
-    argv.push(current);
-  return argv.length ? argv : new Error("empty command");
-}
-var git = (cwd, args) => {
-  const run = spawnSync2("git", args, {
-    cwd,
-    encoding: "utf8",
-    timeout: 20000,
-    killSignal: "SIGKILL",
-    windowsHide: true
-  });
-  const value = run.status === 0 ? (run.stdout ?? "").trim() : "";
-  return value || null;
-};
-function checkRoot(cwd) {
-  return path2.resolve(git(cwd, ["rev-parse", "--show-toplevel"]) ?? cwd);
-}
-var packageManager = (root) => {
-  const has = (file) => fs2.existsSync(path2.join(root, file));
-  if (has("bun.lock") || has("bun.lockb"))
-    return "bun";
-  if (has("pnpm-lock.yaml"))
-    return "pnpm";
-  if (has("yarn.lock"))
-    return "yarn";
-  return "npm";
-};
-var scriptCheck = (pm, name) => {
-  const argv = [pm, "run", name];
-  const accepts = [argv];
-  if (pm === "pnpm" || pm === "yarn" || pm === "npm" && name === "test")
-    accepts.push([pm, name]);
-  return { name, argv, accepts };
-};
-var CHECK_NAME = /^[a-z0-9][a-z0-9:._-]{0,63}$/u;
-function detectedChecks(root) {
-  const read = (file) => {
-    try {
-      return fs2.readFileSync(path2.join(root, file), "utf8");
-    } catch {
-      return null;
-    }
-  };
-  const checks = [];
-  const add = (check) => {
-    if (!checks.some((item) => item.name === check.name))
-      checks.push(check);
-  };
-  const manifestText = read("package.json");
-  if (manifestText !== null) {
-    let manifest = null;
-    try {
-      manifest = JSON.parse(manifestText);
-    } catch {}
-    const scripts = isRecord(manifest) && isRecord(manifest.scripts) ? manifest.scripts : {};
-    const pm = packageManager(root);
-    for (const name of SCRIPT_CHECKS) {
-      const script = scripts[name];
-      if (typeof script === "string" && script.trim() !== "")
-        add(scriptCheck(pm, name));
-    }
-  }
-  const plain = (name, argv) => ({ name, argv, accepts: [argv] });
-  if (read("go.mod") !== null)
-    add(plain("test", ["go", "test", "./..."]));
-  if (read("Cargo.toml") !== null)
-    add(plain("test", ["cargo", "test"]));
-  if (read("pytest.ini") !== null || /\bpytest\b/u.test(read("pyproject.toml") ?? ""))
-    add(plain("test", ["pytest"]));
-  const makefile = read("Makefile") ?? read("makefile") ?? read("GNUmakefile");
-  if (makefile !== null && /^test\s*:(?!=)/mu.test(makefile))
-    add(plain("test", ["make", "test"]));
-  return checks;
-}
-var GATES = ["testing", "verification"];
-function loadCheckConfig(cwd) {
-  const root = checkRoot(cwd);
-  const file = path2.join(root, CHECKS_FILE);
-  const none = (error = null) => ({
-    source: error ? CHECKS_FILE : "none",
-    root,
-    checks: [],
-    gates: {},
-    error
-  });
-  let text = null;
-  try {
-    text = fs2.readFileSync(file, "utf8");
-  } catch (error) {
-    if (error.code !== "ENOENT")
-      return none(`cannot read ${CHECKS_FILE}: ${error.message}`);
-  }
-  if (text === null) {
-    const checks = detectedChecks(root);
-    return checks.length ? { source: "defaults", root, checks, gates: {}, error: null } : none();
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    return none(`${CHECKS_FILE} is not valid JSON`);
-  }
-  if (!isRecord(parsed) || !isRecord(parsed.checks))
-    return none(`${CHECKS_FILE} must be {"checks":{"<name>":"<command>"|["argv",…]}}`);
-  const checks = [];
-  for (const [name, value] of Object.entries(parsed.checks)) {
-    if (!CHECK_NAME.test(name))
-      return none(`${CHECKS_FILE}: check name "${name}" must match ${CHECK_NAME.source}`);
-    const argv = typeof value === "string" ? splitCommand(value) : Array.isArray(value) && value.length > 0 && value.every((item) => typeof item === "string" && item.length > 0) ? value : new Error("expected a command string or a non-empty argv array");
-    if (argv instanceof Error)
-      return none(`${CHECKS_FILE}: check "${name}": ${argv.message}`);
-    checks.push({ name, argv, accepts: [argv] });
-  }
-  const gates = {};
-  if (parsed.gates !== undefined) {
-    if (!isRecord(parsed.gates))
-      return none(`${CHECKS_FILE}: gates must be {"testing":"<name>"|["<name>",…]}`);
-    for (const [gate, value] of Object.entries(parsed.gates)) {
-      if (!GATES.includes(gate))
-        return none(`${CHECKS_FILE}: unknown gate "${gate}" (use ${GATES.join(" or ")})`);
-      const names = typeof value === "string" ? [value] : value;
-      if (!Array.isArray(names) || names.length === 0 || !names.every((name) => typeof name === "string" && checks.some((c) => c.name === name)))
-        return none(`${CHECKS_FILE}: gates.${gate} must name configured checks`);
-      gates[gate] = names;
-    }
-  }
-  return { source: CHECKS_FILE, root, checks, gates, error: null, resources: parsed.resources };
-}
-var sameArgv = (left, right) => left.length === right.length && left.every((item, index) => item === right[index]);
-function matchesNamedCheck(config, name, argv, cwd) {
-  if (config.error || name === null || cwd !== ".")
-    return false;
-  const check = config.checks.find((item) => item.name === name);
-  return Boolean(check?.accepts.some((accepted) => sameArgv(accepted, argv)));
-}
-function gateCheckNames(config, dimension) {
-  const explicit = config.gates[dimension];
-  if (explicit)
-    return explicit;
-  const names = config.checks.map((check) => check.name);
-  if (dimension === "testing")
-    return names.includes("test") ? ["test"] : [];
-  return names;
-}
-var workitOnPath;
-function workitAvailable(env = process.env) {
-  if (workitOnPath !== undefined)
-    return workitOnPath;
-  const windows = process.platform === "win32";
-  const exts = windows ? (env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean) : [""];
-  const dirs = (env.PATH ?? env.Path ?? "").split(path2.delimiter).filter(Boolean);
-  workitOnPath = dirs.some((dir) => exts.some((ext) => {
-    try {
-      return fs2.statSync(path2.join(dir, `workit${ext}`)).isFile();
-    } catch {
-      return false;
-    }
-  }));
-  return workitOnPath;
-}
-function checkCommand(args, version, onPath = workitAvailable()) {
-  return onPath ? `workit check ${args}` : `npx -y @brainervirus/workit-cli@${version} check ${args}`;
-}
+import * as fs12 from "node:fs";
+import { spawnSync as spawnSync9 } from "node:child_process";
+import path15 from "node:path";
 
 // packages/workit-core/src/git/rev.ts
-import { spawnSync as spawnSync3 } from "node:child_process";
+import { spawnSync as spawnSync2 } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
-import fs3 from "node:fs";
+import fs2 from "node:fs";
 import os from "node:os";
-import path3 from "node:path";
+import path2 from "node:path";
 var MAX_BUFFER = 256 * 1024 * 1024;
 var GIT_TIMEOUTS = { local: 20000, worktree: 120000, network: 15000 };
-var git2 = (cwd, args, options = {}) => {
-  const result = spawnSync3("git", args, {
+var git = (cwd, args, options = {}) => {
+  const result = spawnSync2("git", args, {
     cwd,
     encoding: "utf8",
     env: options.env ?? process.env,
@@ -9048,30 +8852,30 @@ var line = (run) => {
 };
 var safeArg = (value) => value.length > 0 && !value.startsWith("-");
 function headSha(cwd) {
-  return line(git2(cwd, ["rev-parse", "--verify", "-q", "HEAD^{commit}"]));
+  return line(git(cwd, ["rev-parse", "--verify", "-q", "HEAD^{commit}"]));
 }
-var emptyTree = (cwd) => line(git2(cwd, ["mktree"], { input: "" }));
+var emptyTree = (cwd) => line(git(cwd, ["mktree"], { input: "" }));
 var MAX_UNTRACKED_BYTES = 5 * 1024 * 1024;
 var seedIndex = (from, to) => {
-  fs3.copyFileSync(from, to);
-  const { atimeNs, mtimeNs } = fs3.statSync(from, { bigint: true });
+  fs2.copyFileSync(from, to);
+  const { atimeNs, mtimeNs } = fs2.statSync(from, { bigint: true });
   const seconds = (ns) => (Number(ns / 1000n) - 1) / 1e6;
-  fs3.utimesSync(to, seconds(atimeNs), seconds(mtimeNs));
+  fs2.utimesSync(to, seconds(atimeNs), seconds(mtimeNs));
 };
 function worktreeTree(cwd, options = {}) {
-  const top = line(git2(cwd, ["rev-parse", "--show-toplevel"]));
-  const indexPath = line(git2(cwd, ["rev-parse", "--path-format=absolute", "--git-path", "index"]));
+  const top = line(git(cwd, ["rev-parse", "--show-toplevel"]));
+  const indexPath = line(git(cwd, ["rev-parse", "--path-format=absolute", "--git-path", "index"]));
   if (!top || !indexPath)
     return null;
   const cap = options.maxUntrackedBytes ?? MAX_UNTRACKED_BYTES;
   const timeoutMs = options.timeoutMs ?? GIT_TIMEOUTS.worktree;
-  const scratch = fs3.mkdtempSync(path3.join(os.tmpdir(), "workit-tree-"));
+  const scratch = fs2.mkdtempSync(path2.join(os.tmpdir(), "workit-tree-"));
   try {
-    const tempIndex = path3.join(scratch, "index");
-    if (fs3.existsSync(indexPath))
+    const tempIndex = path2.join(scratch, "index");
+    if (fs2.existsSync(indexPath))
       seedIndex(indexPath, tempIndex);
     const env = { ...process.env, GIT_INDEX_FILE: tempIndex };
-    const untracked = git2(top, ["ls-files", "--others", "--exclude-standard", "-z"], {
+    const untracked = git(top, ["ls-files", "--others", "--exclude-standard", "-z"], {
       env,
       timeoutMs
     });
@@ -9080,34 +8884,34 @@ function worktreeTree(cwd, options = {}) {
     const skipped = [];
     for (const file of untracked.stdout.split("\x00").filter(Boolean)) {
       try {
-        const stat = fs3.statSync(path3.join(top, file));
+        const stat = fs2.statSync(path2.join(top, file));
         if (stat.isFile() && stat.size > cap)
           skipped.push({ path: file, size: stat.size, mtimeMs: Math.trunc(stat.mtimeMs) });
       } catch {}
     }
     skipped.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
-    const added = skipped.length ? git2(top, ["add", "-A", "--pathspec-from-file=-", "--pathspec-file-nul"], {
+    const added = skipped.length ? git(top, ["add", "-A", "--pathspec-from-file=-", "--pathspec-file-nul"], {
       env,
       timeoutMs,
       input: [".", ...skipped.map((file) => `:(exclude,literal)${file.path}`)].join("\x00")
-    }) : git2(top, ["add", "-A"], { env, timeoutMs });
+    }) : git(top, ["add", "-A"], { env, timeoutMs });
     if (!added.ok)
       return null;
-    const tree = line(git2(top, ["write-tree"], { env, timeoutMs }));
+    const tree = line(git(top, ["write-tree"], { env, timeoutMs }));
     if (!tree)
       return null;
-    const base = line(git2(top, ["rev-parse", "--verify", "-q", "HEAD^{tree}"])) ?? emptyTree(top);
+    const base = line(git(top, ["rev-parse", "--verify", "-q", "HEAD^{tree}"])) ?? emptyTree(top);
     const key = skipped.length ? `sha256:${createHash3("sha256").update(JSON.stringify({ tree, skipped })).digest("hex")}` : tree;
     return { tree, key, dirty: tree !== base || skipped.length > 0, skipped };
   } finally {
-    fs3.rmSync(scratch, { recursive: true, force: true });
+    fs2.rmSync(scratch, { recursive: true, force: true });
   }
 }
 function worktreeSignal(cwd, options = {}) {
-  const top = line(git2(cwd, ["rev-parse", "--show-toplevel"]));
+  const top = line(git(cwd, ["rev-parse", "--show-toplevel"]));
   if (!top)
     return null;
-  const status = git2(top, [
+  const status = git(top, [
     "status",
     "--porcelain=v1",
     "-z",
@@ -9126,10 +8930,10 @@ function worktreeSignal(cwd, options = {}) {
     if (entry.length < 4)
       continue;
     const file = entry.slice(3);
-    const absolute = path3.join(top, file);
+    const absolute = path2.join(top, file);
     let stat = "-";
     try {
-      const info = fs3.lstatSync(absolute, { bigint: true });
+      const info = fs2.lstatSync(absolute, { bigint: true });
       stat = `${info.mode.toString(8)}:${info.size}:${info.mtimeNs}`;
       if (info.isDirectory())
         stat += `:${headSha(absolute) ?? "-"}`;
@@ -9141,12 +8945,12 @@ function worktreeSignal(cwd, options = {}) {
 function mergeBase(cwd, a, b) {
   if (!safeArg(a) || !safeArg(b))
     return null;
-  return line(git2(cwd, ["merge-base", a, b]));
+  return line(git(cwd, ["merge-base", a, b]));
 }
 function patchId(cwd, base, head) {
   if (!safeArg(base) || !safeArg(head))
     return null;
-  const diff = git2(cwd, [
+  const diff = git(cwd, [
     "diff",
     "-U3",
     "--diff-algorithm=myers",
@@ -9163,20 +8967,20 @@ function patchId(cwd, base, head) {
   ]);
   if (!diff.ok || !diff.stdout.trim())
     return null;
-  const id = git2(cwd, ["patch-id", "--stable"], { input: diff.stdout });
+  const id = git(cwd, ["patch-id", "--stable"], { input: diff.stdout });
   return line(id)?.split(/\s+/u)[0] ?? null;
 }
 function remoteNames(cwd) {
-  return (git2(cwd, ["remote"]).stdout ?? "").split(/\r?\n/u).map((value) => value.trim()).filter(Boolean);
+  return (git(cwd, ["remote"]).stdout ?? "").split(/\r?\n/u).map((value) => value.trim()).filter(Boolean);
 }
 function resolveRef(cwd, ref) {
   if (!safeArg(ref))
     return null;
-  return line(git2(cwd, ["rev-parse", "--verify", "-q", `${ref}^{commit}`]));
+  return line(git(cwd, ["rev-parse", "--verify", "-q", `${ref}^{commit}`]));
 }
-var config2 = (cwd, key) => line(git2(cwd, ["config", "--get", key]));
+var config2 = (cwd, key) => line(git(cwd, ["config", "--get", key]));
 function currentBranch(cwd) {
-  return line(git2(cwd, ["symbolic-ref", "--short", "-q", "HEAD"]));
+  return line(git(cwd, ["symbolic-ref", "--short", "-q", "HEAD"]));
 }
 function pushRemoteName(cwd, branch) {
   const name = branch ?? currentBranch(cwd);
@@ -9196,8 +9000,8 @@ function pushRemoteName(cwd, branch) {
 
 // packages/workit-core/src/core/task-store.ts
 import { createHash as createHash6, randomUUID as randomUUID3 } from "node:crypto";
-import * as fs10 from "node:fs";
-import path10 from "node:path";
+import * as fs9 from "node:fs";
+import path9 from "node:path";
 
 // node_modules/@openclaw/fs-safe/dist/errors.js
 var OPERATIONAL_CODES = new Set([
@@ -9248,10 +9052,10 @@ function sameFileIdentity(left, right, platform = process.platform) {
 // node_modules/@openclaw/fs-safe/dist/sidecar-lock-reclaim.js
 import { randomBytes } from "node:crypto";
 import fsSync from "node:fs";
-import path4 from "node:path";
+import path3 from "node:path";
 
 // node_modules/@openclaw/fs-safe/dist/bounded-read.js
-import fs4 from "node:fs";
+import fs3 from "node:fs";
 
 // node_modules/@openclaw/fs-safe/dist/byte-budget.js
 function normalizeMaxBytes(value, options = {}) {
@@ -9288,7 +9092,7 @@ function readFileDescriptorBoundedSync(fd, maxBytes) {
   let total = 0;
   while (true) {
     const length = nextReadLength(total, maxBytes, scratch.length);
-    const bytesRead = fs4.readSync(fd, scratch, 0, length, null);
+    const bytesRead = fs3.readSync(fd, scratch, 0, length, null);
     if (bytesRead === 0) {
       return Buffer.concat(chunks, total);
     }
@@ -9297,9 +9101,9 @@ function readFileDescriptorBoundedSync(fd, maxBytes) {
 }
 
 // node_modules/@openclaw/fs-safe/dist/read-open-flags.js
-import fs5 from "node:fs";
+import fs4 from "node:fs";
 function resolveReadOpenFlags(options) {
-  const constants = options?.constants ?? fs5.constants;
+  const constants = options?.constants ?? fs4.constants;
   const noFollow = process.platform !== "win32" && options?.followSymlinks !== true && typeof constants.O_NOFOLLOW === "number" ? constants.O_NOFOLLOW : 0;
   const nonBlocking = process.platform !== "win32" && typeof constants.O_NONBLOCK === "number" ? constants.O_NONBLOCK : 0;
   return constants.O_RDONLY | noFollow | nonBlocking;
@@ -9338,13 +9142,13 @@ ${ownershipToken}
   return { raw, ownershipToken };
 }
 function relativeSidecarLockPath(lockRoot, lockPath) {
-  const resolved = path4.resolve(lockPath);
-  const lexicalRelative = path4.relative(lockRoot.rootDir, resolved);
-  const relative = lexicalRelative !== ".." && !lexicalRelative.startsWith(`..${path4.sep}`) && !path4.isAbsolute(lexicalRelative) ? lexicalRelative : path4.relative(lockRoot.rootReal, resolved);
-  if (!relative || relative === ".." || relative.startsWith(`..${path4.sep}`) || path4.isAbsolute(relative)) {
+  const resolved = path3.resolve(lockPath);
+  const lexicalRelative = path3.relative(lockRoot.rootDir, resolved);
+  const relative = lexicalRelative !== ".." && !lexicalRelative.startsWith(`..${path3.sep}`) && !path3.isAbsolute(lexicalRelative) ? lexicalRelative : path3.relative(lockRoot.rootReal, resolved);
+  if (!relative || relative === ".." || relative.startsWith(`..${path3.sep}`) || path3.isAbsolute(relative)) {
     throw new FsSafeError("outside-workspace", "sidecar lock path is outside lockRoot");
   }
-  return relative.split(path4.sep).join(path4.posix.sep);
+  return relative.split(path3.sep).join(path3.posix.sep);
 }
 function parseSidecarLockPayload(raw, parser) {
   if (parser) {
@@ -9490,8 +9294,8 @@ function getFsSafeLockConfig() {
 }
 
 // node_modules/@openclaw/fs-safe/dist/file-lock-sync.js
-import fs6 from "node:fs";
-import path5 from "node:path";
+import fs5 from "node:fs";
+import path4 from "node:path";
 
 // node_modules/@openclaw/fs-safe/dist/timing.js
 function sleepSync(ms) {
@@ -9521,7 +9325,7 @@ function releaseAllSyncHeldLocks() {
     }
     try {
       if (held.fd !== undefined)
-        fs6.closeSync(held.fd);
+        fs5.closeSync(held.fd);
     } catch {}
     try {
       removeSidecarLockIfUnchangedSync(held.lockPath, held.snapshot);
@@ -9556,7 +9360,7 @@ function releaseSyncHeldLock(held) {
   if (held.fd !== undefined) {
     const fd = held.fd;
     held.fd = undefined;
-    fs6.closeSync(fd);
+    fs5.closeSync(fd);
   }
   removeSidecarLockIfUnchangedSync(held.lockPath, held.snapshot);
   heldLocks.delete(held.normalizedTargetPath);
@@ -9579,29 +9383,29 @@ function createSyncHeldLockHandle(held) {
   };
 }
 function canonicalLockParentSync(parent) {
-  return process.platform === "win32" ? fs6.realpathSync.native(parent) : fs6.realpathSync(parent);
+  return process.platform === "win32" ? fs5.realpathSync.native(parent) : fs5.realpathSync(parent);
 }
 function normalizeTargetPath(targetPath) {
-  const resolved = path5.resolve(targetPath);
-  fs6.mkdirSync(path5.dirname(resolved), { recursive: true });
+  const resolved = path4.resolve(targetPath);
+  fs5.mkdirSync(path4.dirname(resolved), { recursive: true });
   try {
-    return path5.join(canonicalLockParentSync(path5.dirname(resolved)), path5.basename(resolved));
+    return path4.join(canonicalLockParentSync(path4.dirname(resolved)), path4.basename(resolved));
   } catch {
     return resolved;
   }
 }
 function boundedLockPath(lockPath, lockRoot) {
-  const resolved = path5.resolve(lockPath);
+  const resolved = path4.resolve(lockPath);
   if (!lockRoot)
     return resolved;
   relativeSidecarLockPath(lockRoot, resolved);
-  const parent = path5.dirname(resolved);
+  const parent = path4.dirname(resolved);
   const parentReal = canonicalLockParentSync(parent);
-  const parentRelative = path5.relative(lockRoot.rootReal, parentReal);
-  if (parentRelative === ".." || parentRelative.startsWith(`..${path5.sep}`) || path5.isAbsolute(parentRelative)) {
+  const parentRelative = path4.relative(lockRoot.rootReal, parentReal);
+  if (parentRelative === ".." || parentRelative.startsWith(`..${path4.sep}`) || path4.isAbsolute(parentRelative)) {
     throw new FsSafeError("outside-workspace", "sidecar lock parent is outside lockRoot");
   }
-  return path5.join(parentReal, path5.basename(resolved));
+  return path4.join(parentReal, path4.basename(resolved));
 }
 function defaultShouldReclaim(snapshot, staleMs, nowMs) {
   const createdAtMs = sidecarLockPayloadCreatedAtMs(snapshot.payload);
@@ -9611,7 +9415,7 @@ function defaultShouldReclaim(snapshot, staleMs, nowMs) {
 }
 function reclaimGuardExists(reclaimGuardPath) {
   try {
-    fs6.lstatSync(reclaimGuardPath);
+    fs5.lstatSync(reclaimGuardPath);
     return true;
   } catch (error) {
     if (error.code === "ENOENT")
@@ -9675,19 +9479,19 @@ function acquireFileLockSync(targetPath, options) {
     const { raw, ownershipToken } = serializeSidecarLockPayload(payload);
     let lockFileCreateDenied = false;
     try {
-      const noFollow = process.platform !== "win32" && typeof fs6.constants.O_NOFOLLOW === "number" ? fs6.constants.O_NOFOLLOW : 0;
+      const noFollow = process.platform !== "win32" && typeof fs5.constants.O_NOFOLLOW === "number" ? fs5.constants.O_NOFOLLOW : 0;
       try {
-        fd = fs6.openSync(lockPath, fs6.constants.O_WRONLY | fs6.constants.O_CREAT | fs6.constants.O_EXCL | noFollow, 384);
+        fd = fs5.openSync(lockPath, fs5.constants.O_WRONLY | fs5.constants.O_CREAT | fs5.constants.O_EXCL | noFollow, 384);
       } catch (error) {
         lockFileCreateDenied = isTransientLockFileDenial(error, lockPath);
         throw error;
       }
-      fs6.writeFileSync(fd, raw, "utf8");
-      fs6.fsyncSync(fd);
+      fs5.writeFileSync(fd, raw, "utf8");
+      fs5.fsyncSync(fd);
       const snapshot = {
         raw,
         payload,
-        stat: fs6.fstatSync(fd),
+        stat: fs5.fstatSync(fd),
         ownershipToken
       };
       const createdHeld = {
@@ -9722,8 +9526,8 @@ function acquireFileLockSync(targetPath, options) {
       return returnedHandle;
     } catch (error) {
       if (fd !== undefined) {
-        const failed = { payload: null, stat: fs6.fstatSync(fd) };
-        fs6.closeSync(fd);
+        const failed = { payload: null, stat: fs5.fstatSync(fd) };
+        fs5.closeSync(fd);
         fd = undefined;
         removeSidecarLockIfUnchangedSync(lockPath, failed);
       }
@@ -9772,7 +9576,7 @@ function acquireFileLockSync(targetPath, options) {
         })) {
           let ownsReclaimGuard = false;
           try {
-            fs6.mkdirSync(reclaimGuardPath);
+            fs5.mkdirSync(reclaimGuardPath);
             ownsReclaimGuard = true;
             if (removeSidecarLockIfUnchangedSync(lockPath, snapshot))
               continue;
@@ -9785,7 +9589,7 @@ function acquireFileLockSync(targetPath, options) {
           } finally {
             if (ownsReclaimGuard) {
               try {
-                fs6.rmdirSync(reclaimGuardPath);
+                fs5.rmdirSync(reclaimGuardPath);
               } catch {}
             }
           }
@@ -9802,12 +9606,12 @@ function acquireFileLockSync(targetPath, options) {
 }
 // packages/workit-core/src/host-session.ts
 import { createHash as createHash4, randomBytes as randomBytes2, timingSafeEqual } from "node:crypto";
-import fs7 from "node:fs";
-import path7 from "node:path";
+import fs6 from "node:fs";
+import path6 from "node:path";
 
 // packages/workit-core/src/core/logger.ts
 import os2 from "node:os";
-import path6 from "node:path";
+import path5 from "node:path";
 var SENSITIVE_WORDS = new Set([
   "token",
   "secret",
@@ -9852,14 +9656,14 @@ var resolveStateDir = () => {
     return override;
   const home = os2.homedir();
   if (process.env.XDG_STATE_HOME)
-    return path6.join(process.env.XDG_STATE_HOME, "workit");
+    return path5.join(process.env.XDG_STATE_HOME, "workit");
   switch (os2.platform()) {
     case "darwin":
-      return path6.join(home, "Library", "Application Support", "workit");
+      return path5.join(home, "Library", "Application Support", "workit");
     case "win32":
-      return path6.join(process.env.LOCALAPPDATA ?? path6.join(home, "AppData", "Local"), "workit");
+      return path5.join(process.env.LOCALAPPDATA ?? path5.join(home, "AppData", "Local"), "workit");
     default:
-      return path6.join(process.env.HOME ?? home, ".local", "state", "workit");
+      return path5.join(process.env.HOME ?? home, ".local", "state", "workit");
   }
 };
 var homePattern = new RegExp(`${escapeRegExp(os2.homedir())}(?=[/\\\\]|$)|\\$HOME(?=[/\\\\]|$)`, "g");
@@ -9895,8 +9699,8 @@ function hostSessionFromEnv(env) {
 var ISSUED_PER_LEAD = 64;
 var ISSUED_SESSIONS_MARKER = "workit-issued-sessions/3";
 var hash = (value) => createHash4("sha256").update(value).digest("hex").slice(0, 32);
-var userIssuedRoot = () => path7.join(resolveStateDir(), "issued");
-var userTokenRoot = () => path7.join(resolveStateDir(), "issued-tokens");
+var userIssuedRoot = () => path6.join(resolveStateDir(), "issued");
+var userTokenRoot = () => path6.join(resolveStateDir(), "issued-tokens");
 function migrateRepoIssued(cwd) {
   if (cwd === undefined)
     return;
@@ -9905,27 +9709,27 @@ function migrateRepoIssued(cwd) {
     const location = resolveStore(cwd);
     if (location instanceof Error)
       return;
-    old = path7.join(location.dir, "hooks", "issued");
-    if (!fs7.existsSync(old))
+    old = path6.join(location.dir, "hooks", "issued");
+    if (!fs6.existsSync(old))
       return;
   } catch {
     return;
   }
   for (const lead of safeList(old)) {
     try {
-      const from = path7.join(old, lead);
-      if (!fs7.statSync(from).isDirectory())
+      const from = path6.join(old, lead);
+      if (!fs6.statSync(from).isDirectory())
         continue;
-      const to = path7.join(userIssuedRoot(), lead);
-      fs7.mkdirSync(to, { recursive: true, mode: 448 });
-      for (const id of fs7.readdirSync(from)) {
+      const to = path6.join(userIssuedRoot(), lead);
+      fs6.mkdirSync(to, { recursive: true, mode: 448 });
+      for (const id of fs6.readdirSync(from)) {
         try {
-          fs7.copyFileSync(path7.join(from, id), path7.join(to, id), fs7.constants.COPYFILE_EXCL);
+          fs6.copyFileSync(path6.join(from, id), path6.join(to, id), fs6.constants.COPYFILE_EXCL);
         } catch (error) {
           if (error.code !== "EEXIST")
             throw error;
         }
-        fs7.rmSync(path7.join(from, id), { force: true });
+        fs6.rmSync(path6.join(from, id), { force: true });
       }
       removeIfEmpty(from);
     } catch {}
@@ -9934,14 +9738,14 @@ function migrateRepoIssued(cwd) {
 }
 var safeList = (dir) => {
   try {
-    return fs7.readdirSync(dir);
+    return fs6.readdirSync(dir);
   } catch {
     return [];
   }
 };
 var removeIfEmpty = (dir) => {
   try {
-    fs7.rmdirSync(dir);
+    fs6.rmdirSync(dir);
   } catch {}
 };
 var tokenHash = (token) => createHash4("sha256").update(token).digest("hex");
@@ -9950,13 +9754,13 @@ function recordIssuedSession(cwd, lead, issued) {
   try {
     migrateRepoIssued(cwd);
     const own = hash(issued);
-    const tokens = path7.join(userTokenRoot(), hash(lead));
-    fs7.mkdirSync(tokens, { recursive: true, mode: 448 });
-    fs7.writeFileSync(path7.join(tokens, own), `${tokenHash(token)}
+    const tokens = path6.join(userTokenRoot(), hash(lead));
+    fs6.mkdirSync(tokens, { recursive: true, mode: 448 });
+    fs6.writeFileSync(path6.join(tokens, own), `${tokenHash(token)}
 `, { mode: 384, flag: "wx" });
-    const dir = path7.join(userIssuedRoot(), hash(lead));
-    fs7.mkdirSync(dir, { recursive: true, mode: 448 });
-    fs7.writeFileSync(path7.join(dir, own), `${ISSUED_SESSIONS_MARKER}
+    const dir = path6.join(userIssuedRoot(), hash(lead));
+    fs6.mkdirSync(dir, { recursive: true, mode: 448 });
+    fs6.writeFileSync(path6.join(dir, own), `${ISSUED_SESSIONS_MARKER}
 `, { mode: 384 });
     pruneIssued(dir, own, tokens);
     return token;
@@ -9966,13 +9770,13 @@ function recordIssuedSession(cwd, lead, issued) {
 }
 function pruneIssued(dir, own, tokens) {
   try {
-    const entries = fs7.readdirSync(dir);
+    const entries = fs6.readdirSync(dir);
     if (entries.length <= ISSUED_PER_LEAD)
       return;
-    const byAge = entries.filter((name) => name !== own).map((name) => ({ name, at: fs7.statSync(path7.join(dir, name)).mtimeMs })).toSorted((a, b) => a.at - b.at);
+    const byAge = entries.filter((name) => name !== own).map((name) => ({ name, at: fs6.statSync(path6.join(dir, name)).mtimeMs })).toSorted((a, b) => a.at - b.at);
     for (const { name } of byAge.slice(0, entries.length - ISSUED_PER_LEAD)) {
-      fs7.rmSync(path7.join(dir, name), { force: true });
-      fs7.rmSync(path7.join(tokens, name), { force: true });
+      fs6.rmSync(path6.join(dir, name), { force: true });
+      fs6.rmSync(path6.join(tokens, name), { force: true });
     }
   } catch {}
 }
@@ -9982,7 +9786,7 @@ var issuedRecord = (cwd, claimed) => {
     return null;
   migrateRepoIssued(cwd);
   try {
-    return fs7.readFileSync(path7.join(userIssuedRoot(), hash(claimed.slice(0, cut)), hash(claimed)), "utf8");
+    return fs6.readFileSync(path6.join(userIssuedRoot(), hash(claimed.slice(0, cut)), hash(claimed)), "utf8");
   } catch {
     return null;
   }
@@ -9992,9 +9796,9 @@ var issuedToken = (claimed) => {
   const cut = claimed.lastIndexOf(":");
   if (cut <= 0)
     return { stored: null, leadBound: false };
-  const dir = path7.join(userTokenRoot(), hash(claimed.slice(0, cut)));
+  const dir = path6.join(userTokenRoot(), hash(claimed.slice(0, cut)));
   try {
-    const text = fs7.readFileSync(path7.join(dir, hash(claimed)), "utf8");
+    const text = fs6.readFileSync(path6.join(dir, hash(claimed)), "utf8");
     return { stored: TOKEN_HASH.exec(text)?.[1] ?? null, leadBound: true };
   } catch {
     return { stored: null, leadBound: safeList(dir).length > 0 };
@@ -10013,21 +9817,21 @@ var OWN_CHILD_SHELL = new Set(["opencode", "pi"]);
 
 // packages/workit-core/src/core/package-root.ts
 import { existsSync } from "node:fs";
-import path8 from "node:path";
+import path7 from "node:path";
 import { fileURLToPath } from "node:url";
 var packageRoot = () => {
-  let dir = path8.dirname(fileURLToPath(import.meta.url));
+  let dir = path7.dirname(fileURLToPath(import.meta.url));
   while (true) {
-    const parent = path8.dirname(dir);
-    if (existsSync(path8.join(dir, "package.json")) || parent === dir)
+    const parent = path7.dirname(dir);
+    if (existsSync(path7.join(dir, "package.json")) || parent === dir)
       return dir;
     dir = parent;
   }
 };
 
 // packages/workit-core/src/core/store-lock.ts
-import { spawnSync as spawnSync4 } from "node:child_process";
-import fs8 from "node:fs";
+import { spawnSync as spawnSync3 } from "node:child_process";
+import fs7 from "node:fs";
 import { hostname } from "node:os";
 var metadataLockSchema = object({
   pid: number2().int().nonnegative().safe(),
@@ -10071,14 +9875,14 @@ var parseProcStatStart = (stat) => {
 var processStartOf = (pid) => {
   if (process.platform === "linux") {
     try {
-      return parseProcStatStart(fs8.readFileSync(`/proc/${pid}/stat`, "utf8"));
+      return parseProcStatStart(fs7.readFileSync(`/proc/${pid}/stat`, "utf8"));
     } catch {
       return null;
     }
   }
   if (process.platform === "darwin" || process.platform === "freebsd") {
     try {
-      const run = spawnSync4("ps", ["-o", "lstart=", "-p", String(pid)], {
+      const run = spawnSync3("ps", ["-o", "lstart=", "-p", String(pid)], {
         encoding: "utf8",
         timeout: 1000
       });
@@ -10092,7 +9896,7 @@ var processStartOf = (pid) => {
 };
 var readTrimmed = (file) => {
   try {
-    return fs8.readFileSync(file, "utf8").trim() || null;
+    return fs7.readFileSync(file, "utf8").trim() || null;
   } catch {
     return null;
   }
@@ -10103,7 +9907,7 @@ var localLockHost = () => {
     return cachedLockHost;
   let pidns = null;
   try {
-    pidns = /\[(\d+)\]/.exec(fs8.readlinkSync("/proc/self/ns/pid"))?.[1] ?? null;
+    pidns = /\[(\d+)\]/.exec(fs7.readlinkSync("/proc/self/ns/pid"))?.[1] ?? null;
   } catch {}
   const boot = readTrimmed("/proc/sys/kernel/random/boot_id");
   cachedLockHost = pidns || boot ? `${hostname()}#${pidns ?? "?"}:${boot ?? "?"}` : hostname();
@@ -10149,7 +9953,7 @@ var classifyLockOwner = (payload, ageMs, localHost = localLockHost(), options =
 };
 var ageOf = (file, nowMs) => {
   try {
-    return nowMs - fs8.lstatSync(file).mtimeMs;
+    return nowMs - fs7.lstatSync(file).mtimeMs;
   } catch {
     return null;
   }
@@ -10160,7 +9964,7 @@ var clearAbandonedReclaimGuard = (lockPath, nowMs = Date.now()) => {
   if (age === null || age <= RECLAIM_GUARD_TTL_MS)
     return false;
   try {
-    fs8.rmdirSync(guard);
+    fs7.rmdirSync(guard);
     return true;
   } catch {
     return false;
@@ -10169,8 +9973,8 @@ var clearAbandonedReclaimGuard = (lockPath, nowMs = Date.now()) => {
 
 // packages/workit-core/src/store/event-log.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import fs9 from "node:fs";
-import path9 from "node:path";
+import fs8 from "node:fs";
+import path8 from "node:path";
 var EVENT_VERSION = 1;
 
 class LogDamage extends Error {
@@ -10199,7 +10003,7 @@ var parseEvent = (line, file, offset) => {
 function readLog(file, from = 0, expectSeq = null) {
   let fd;
   try {
-    fd = fs9.openSync(file, "r");
+    fd = fs8.openSync(file, "r");
   } catch (error) {
     if (error.code === "ENOENT")
       return null;
@@ -10208,13 +10012,13 @@ function readLog(file, from = 0, expectSeq = null) {
   let bytes;
   let size;
   try {
-    size = fs9.fstatSync(fd).size;
+    size = fs8.fstatSync(fd).size;
     if (from > size)
       throw new LogDamage(`${file}: shorter than its snapshot`);
     bytes = Buffer.alloc(size - from);
     let read = 0;
     while (read < bytes.length) {
-      const got = fs9.readSync(fd, bytes, read, bytes.length - read, from + read);
+      const got = fs8.readSync(fd, bytes, read, bytes.length - read, from + read);
       if (got === 0)
         break;
       read += got;
@@ -10222,7 +10026,7 @@ function readLog(file, from = 0, expectSeq = null) {
     bytes = bytes.subarray(0, read);
     size = from + read;
   } finally {
-    fs9.closeSync(fd);
+    fs8.closeSync(fd);
   }
   const events = [];
   let start = 0;
@@ -10247,11 +10051,11 @@ function readLog(file, from = 0, expectSeq = null) {
 }
 var fsyncDirectory = (dir) => {
   try {
-    const fd = fs9.openSync(dir, "r");
+    const fd = fs8.openSync(dir, "r");
     try {
-      fs9.fsyncSync(fd);
+      fs8.fsyncSync(fd);
     } finally {
-      fs9.closeSync(fd);
+      fs8.closeSync(fd);
     }
   } catch (error) {
     if (process.platform !== "win32")
@@ -10261,46 +10065,46 @@ var fsyncDirectory = (dir) => {
 function appendEvent(file, event, validEnd) {
   const line = Buffer.from(`${JSON.stringify(event)}
 `, "utf8");
-  const created = !fs9.existsSync(file);
-  if (!created && fs9.statSync(file).size !== validEnd) {
-    const cut = fs9.openSync(file, "r+");
+  const created = !fs8.existsSync(file);
+  if (!created && fs8.statSync(file).size !== validEnd) {
+    const cut = fs8.openSync(file, "r+");
     try {
-      fs9.ftruncateSync(cut, validEnd);
-      fs9.fsyncSync(cut);
+      fs8.ftruncateSync(cut, validEnd);
+      fs8.fsyncSync(cut);
     } finally {
-      fs9.closeSync(cut);
+      fs8.closeSync(cut);
     }
   }
-  const fd = fs9.openSync(file, "a", 384);
+  const fd = fs8.openSync(file, "a", 384);
   try {
     let written = 0;
     while (written < line.length)
-      written += fs9.writeSync(fd, line, written, line.length - written);
-    fs9.fsyncSync(fd);
+      written += fs8.writeSync(fd, line, written, line.length - written);
+    fs8.fsyncSync(fd);
   } finally {
-    fs9.closeSync(fd);
+    fs8.closeSync(fd);
   }
   if (created)
-    fsyncDirectory(path9.dirname(file));
+    fsyncDirectory(path8.dirname(file));
   return validEnd;
 }
 function replaceFile(file, bytes, durable) {
   const temporary = `${file}.${process.pid}.${randomUUID2()}.tmp`;
   try {
-    const fd = fs9.openSync(temporary, "wx", 384);
+    const fd = fs8.openSync(temporary, "wx", 384);
     try {
-      fs9.writeSync(fd, bytes);
+      fs8.writeSync(fd, bytes);
       if (durable)
-        fs9.fsyncSync(fd);
+        fs8.fsyncSync(fd);
     } finally {
-      fs9.closeSync(fd);
+      fs8.closeSync(fd);
     }
     renameWithRetry(temporary, file);
     if (durable)
-      fsyncDirectory(path9.dirname(file));
+      fsyncDirectory(path8.dirname(file));
   } catch (error) {
     try {
-      fs9.unlinkSync(temporary);
+      fs8.unlinkSync(temporary);
     } catch {}
     throw error;
   }
@@ -10325,7 +10129,7 @@ var retryTransient = (run) => {
     }
   }
 };
-var renameWithRetry = (from, to) => retryTransient(() => fs9.renameSync(from, to));
+var renameWithRetry = (from, to) => retryTransient(() => fs8.renameSync(from, to));
 
 // packages/workit-core/src/store/patch.ts
 var isPlainObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
@@ -10622,7 +10426,7 @@ var indexEntry = (task, key, legacy, file) => {
 };
 var fileSignature = (file) => {
   try {
-    const stat = fs10.statSync(file, { bigint: true });
+    const stat = fs9.statSync(file, { bigint: true });
     return `${stat.dev}:${stat.ino}:${stat.size}:${stat.mtimeNs}:${stat.ctimeNs}`;
   } catch {
     return null;
@@ -10640,7 +10444,7 @@ var cachedRuntimeVersion = null;
 var runtimeVersion = () => {
   if (cachedRuntimeVersion === null) {
     try {
-      const pkg = JSON.parse(fs10.readFileSync(path10.join(packageRoot(), "package.json"), "utf8"));
+      const pkg = JSON.parse(fs9.readFileSync(path9.join(packageRoot(), "package.json"), "utf8"));
       cachedRuntimeVersion = typeof pkg.version === "string" && pkg.version ? pkg.version : "0.0.0";
     } catch {
       cachedRuntimeVersion = "0.0.0";
@@ -10666,14 +10470,14 @@ var isNewerVersion = (candidate, current) => {
 var validId = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(value);
 var readText = (file) => {
   try {
-    return fs10.readFileSync(file, "utf8");
+    return fs9.readFileSync(file, "utf8");
   } catch {
     return "";
   }
 };
 var REFLOG_LINE = /^[0-9a-f]+ ([0-9a-f]+) .* (\d+) [+-]\d{4}\t(.*)$/u;
 var branchStart = (location, branch, aliases) => {
-  const first = readText(path10.join(path10.dirname(location.dir), "logs", "refs", "heads", branch)).split(`
+  const first = readText(path9.join(path9.dirname(location.dir), "logs", "refs", "heads", branch)).split(`
 `, 1)[0];
   const created = REFLOG_LINE.exec(first);
   const start = created && /^branch: Created from (\S+)$/u.exec(created[3])?.[1];
@@ -10683,7 +10487,7 @@ var branchStart = (location, branch, aliases) => {
     return start;
   if (!location.git)
     return null;
-  for (const line of readText(path10.join(location.git.gitDir, "logs", "HEAD")).split(`
+  for (const line of readText(path9.join(location.git.gitDir, "logs", "HEAD")).split(`
 `)) {
     const entry = REFLOG_LINE.exec(line);
     const moved = entry && /^checkout: moving from (\S+) to (\S+)$/u.exec(entry[3]);
@@ -10693,23 +10497,23 @@ var branchStart = (location, branch, aliases) => {
   }
   return null;
 };
-var refExists = (common, ref) => fs10.existsSync(path10.join(common, ref)) || readText(path10.join(common, "packed-refs")).includes(` ${ref}
+var refExists = (common, ref) => fs9.existsSync(path9.join(common, ref)) || readText(path9.join(common, "packed-refs")).includes(` ${ref}
 `);
 var origins = new Map;
 var sameDirectoryIdentity = (left, right) => {
-  if (!path10.isAbsolute(left) || !path10.isAbsolute(right))
+  if (!path9.isAbsolute(left) || !path9.isAbsolute(right))
     return false;
-  const normalizedLeft = path10.resolve(left);
-  const normalizedRight = path10.resolve(right);
+  const normalizedLeft = path9.resolve(left);
+  const normalizedRight = path9.resolve(right);
   try {
-    const a = fs10.statSync(normalizedLeft, { bigint: true });
-    const b = fs10.statSync(normalizedRight, { bigint: true });
+    const a = fs9.statSync(normalizedLeft, { bigint: true });
+    const b = fs9.statSync(normalizedRight, { bigint: true });
     if (!a.isDirectory() || !b.isDirectory())
       return false;
     if (process.platform === "win32" ? normalizedLeft.toLowerCase() === normalizedRight.toLowerCase() : normalizedLeft === normalizedRight)
       return true;
-    const canonicalLeft = fs10.realpathSync(normalizedLeft);
-    const canonicalRight = fs10.realpathSync(normalizedRight);
+    const canonicalLeft = fs9.realpathSync(normalizedLeft);
+    const canonicalRight = fs9.realpathSync(normalizedRight);
     if (process.platform === "win32" ? canonicalLeft.toLowerCase() === canonicalRight.toLowerCase() : canonicalLeft === canonicalRight)
       return true;
     return a.dev === b.dev && a.ino !== 0n && a.ino === b.ino;
@@ -10746,8 +10550,8 @@ class TaskStore {
   migrationChecked = false;
   compactDue = new Set;
   constructor(root, options = {}) {
-    const resolved = path10.resolve(root);
-    this.origin = fs10.existsSync(resolved) ? fs10.realpathSync(resolved) : resolved;
+    const resolved = path9.resolve(root);
+    this.origin = fs9.existsSync(resolved) ? fs9.realpathSync(resolved) : resolved;
     this.located = resolveStore(this.origin);
     this.root = checkoutRootOf(this.origin, this.located);
     this.lockTimeoutMs = options.lockTimeoutMs ?? defaultLockTimeout();
@@ -10755,7 +10559,7 @@ class TaskStore {
     this.migrateOnRead = options.migrateOnRead;
   }
   location() {
-    if (this.located !== undefined && !(this.located instanceof Error) && !this.located.shared && fs10.existsSync(path10.join(this.root, ".git"))) {
+    if (this.located !== undefined && !(this.located instanceof Error) && !this.located.shared && fs9.existsSync(path9.join(this.root, ".git"))) {
       this.located = undefined;
       this.migrationChecked = false;
     }
@@ -10819,7 +10623,7 @@ class TaskStore {
     const tasksDir = this.paths().tasks;
     let names;
     try {
-      names = fs10.existsSync(tasksDir) ? fs10.readdirSync(tasksDir).filter((name) => validId(name)) : [];
+      names = fs9.existsSync(tasksDir) ? fs9.readdirSync(tasksDir).filter((name) => validId(name)) : [];
     } catch (error) {
       return failure2("storage_error", `unable to list tasks: ${String(error)}`, {
         path: tasksDir
@@ -10860,7 +10664,7 @@ class TaskStore {
     const file = this.paths().workspace;
     let bytes;
     try {
-      bytes = retryTransient(() => fs10.readFileSync(file, "utf8"));
+      bytes = retryTransient(() => fs9.readFileSync(file, "utf8"));
     } catch (error) {
       if (error.code === "ENOENT")
         return success(null, null, null);
@@ -10911,7 +10715,7 @@ class TaskStore {
         const moved = this.bindLocked(again.data.id, key, input.now);
         return moved.ok ? success(moved.data.revision, null, { task: moved.data, created: false, key }) : moved;
       }
-      const label = key.kind === "branch" ? `branch ${key.branch}` : key.kind === "detached" ? "a detached HEAD" : path10.basename(this.root) || this.root;
+      const label = key.kind === "branch" ? `branch ${key.branch}` : key.kind === "detached" ? "a detached HEAD" : path9.basename(this.root) || this.root;
       const intent = {
         objective: input.objective?.trim() || `Work on ${label}`,
         scope: { description: `the checkout (${label})`, paths: ["."], exclusions: [] },
@@ -10977,14 +10781,14 @@ class TaskStore {
     const branch = key.ok ? key.data.branch : null;
     if (!branch || !location.ok)
       return success(null, null, null);
-    const common = path10.dirname(location.data.dir);
-    const heads = path10.join(common, "logs", "refs", "heads");
-    const headLog = location.data.git ? path10.join(location.data.git.gitDir, "logs", "HEAD") : "";
+    const common = path9.dirname(location.data.dir);
+    const heads = path9.join(common, "logs", "refs", "heads");
+    const headLog = location.data.git ? path9.join(location.data.git.gitDir, "logs", "HEAD") : "";
     const signatures = [
-      path10.join(heads, branch),
+      path9.join(heads, branch),
       headLog,
       heads,
-      path10.join(common, "packed-refs")
+      path9.join(common, "packed-refs")
     ].map((file) => fileSignature(file) ?? "-");
     const slot = `${location.data.dir}\x00${headLog}\x00${branch}`;
     let resolved = origins.get(slot);
@@ -10996,7 +10800,7 @@ class TaskStore {
           aliases.push(rename.from);
       const start = branchStart(location.data, branch, aliases);
       const slash = start?.indexOf("/") ?? -1;
-      const remote = slash > 0 && !refExists(common, `refs/heads/${start}`) && (refExists(common, `refs/remotes/${start}`) || readText(path10.join(common, "config")).includes(`[remote "${start.slice(0, slash)}"]`));
+      const remote = slash > 0 && !refExists(common, `refs/heads/${start}`) && (refExists(common, `refs/remotes/${start}`) || readText(path9.join(common, "config")).includes(`[remote "${start.slice(0, slash)}"]`));
       const name = start && (remote ? start.slice(slash + 1) : start);
       resolved = {
         signature: signatures.join("|"),
@@ -11234,13 +11038,13 @@ class TaskStore {
     if (!ready.ok)
       return ready;
     const dirs = this.paths();
-    const recovery = path10.join(this.root, ".workit", "recovery");
-    if (fs10.existsSync(recovery)) {
+    const recovery = path9.join(this.root, ".workit", "recovery");
+    if (fs9.existsSync(recovery)) {
       let files = 0;
       let bytes = 0;
       try {
-        for (const name of fs10.readdirSync(recovery)) {
-          const stat = fs10.lstatSync(path10.join(recovery, name));
+        for (const name of fs9.readdirSync(recovery)) {
+          const stat = fs9.lstatSync(path9.join(recovery, name));
           if (!stat.isFile())
             continue;
           files += 1;
@@ -11249,17 +11053,17 @@ class TaskStore {
       } catch {}
       const remove = options.pruneRecovery === true && !dryRun;
       if (remove)
-        fs10.rmSync(recovery, { recursive: true, force: true });
+        fs9.rmSync(recovery, { recursive: true, force: true });
       report.legacyRecovery = { path: recovery, files, bytes, removed: remove };
     }
-    if (!fs10.existsSync(dirs.tasks))
+    if (!fs9.existsSync(dirs.tasks))
       return success(null, null, report);
-    const names = fs10.readdirSync(dirs.tasks).filter((name) => validId(name));
+    const names = fs9.readdirSync(dirs.tasks).filter((name) => validId(name));
     for (const name of names) {
       const file = this.eventsPath(name);
       let size = 0;
       try {
-        size = fs10.statSync(file).size;
+        size = fs9.statSync(file).size;
       } catch {
         continue;
       }
@@ -11287,16 +11091,16 @@ class TaskStore {
       const references = new Set;
       for (const name of names)
         try {
-          for (const match of fs10.readFileSync(this.eventsPath(name), "utf8").matchAll(/"\$blob":"([0-9a-f]{64})"/g))
+          for (const match of fs9.readFileSync(this.eventsPath(name), "utf8").matchAll(/"\$blob":"([0-9a-f]{64})"/g))
             references.add(match[1]);
         } catch {}
-      if (fs10.existsSync(dirs.blobs))
-        for (const name of fs10.readdirSync(dirs.blobs)) {
+      if (fs9.existsSync(dirs.blobs))
+        for (const name of fs9.readdirSync(dirs.blobs)) {
           const digest = name.replace(/\.json$/, "");
-          const file = path10.join(dirs.blobs, name);
+          const file = path9.join(dirs.blobs, name);
           let stat;
           try {
-            stat = fs10.lstatSync(file);
+            stat = fs9.lstatSync(file);
           } catch {
             continue;
           }
@@ -11307,11 +11111,11 @@ class TaskStore {
           report.blobs.removed += 1;
           report.blobs.removedBytes += stat.size;
           if (!dryRun)
-            fs10.rmSync(file, { force: true });
+            fs9.rmSync(file, { force: true });
         }
       return success(null, null, null);
     };
-    const swept = dryRun ? sweep() : this.withLock(path10.join(dirs.dir, "gc.lock"), sweep);
+    const swept = dryRun ? sweep() : this.withLock(path9.join(dirs.dir, "gc.lock"), sweep);
     if (!swept.ok)
       return swept;
     const temporaryDirs = [
@@ -11319,17 +11123,17 @@ class TaskStore {
       dirs.tasks,
       dirs.blobs,
       dirs.checkout,
-      ...names.map((name) => path10.join(dirs.tasks, name))
+      ...names.map((name) => path9.join(dirs.tasks, name))
     ];
     for (const directory of temporaryDirs) {
-      if (!fs10.existsSync(directory))
+      if (!fs9.existsSync(directory))
         continue;
-      for (const name of fs10.readdirSync(directory)) {
+      for (const name of fs9.readdirSync(directory)) {
         if (!name.endsWith(".tmp") && !name.endsWith(".probe"))
           continue;
-        const file = path10.join(directory, name);
+        const file = path9.join(directory, name);
         try {
-          const stat = fs10.lstatSync(file);
+          const stat = fs9.lstatSync(file);
           if (!stat.isFile() || nowMs - stat.mtimeMs <= STALE_TEMPORARY_MS)
             continue;
         } catch {
@@ -11337,37 +11141,37 @@ class TaskStore {
         }
         report.temporary.removed += 1;
         if (!dryRun)
-          fs10.rmSync(file, { force: true });
+          fs9.rmSync(file, { force: true });
       }
     }
     return success(null, null, report);
   }
   paths() {
     const location = this.location();
-    const dir = location.ok ? location.data.dir : path10.join(this.root, ".workit");
-    const checkout = path10.join(dir, "checkouts", checkoutSlug(this.root));
+    const dir = location.ok ? location.data.dir : path9.join(this.root, ".workit");
+    const checkout = path9.join(dir, "checkouts", checkoutSlug(this.root));
     return {
       dir,
       shared: location.ok ? location.data.shared : false,
-      marker: path10.join(dir, "store.json"),
+      marker: path9.join(dir, "store.json"),
       checkout,
-      workspace: path10.join(checkout, "workspace.json"),
-      checkoutLock: path10.join(checkout, "metadata.lock"),
-      tasks: path10.join(dir, "tasks"),
-      index: path10.join(dir, "task-index.json"),
-      blobs: path10.join(dir, "blobs", "candidates"),
-      legacy: path10.join(dir, "legacy", checkoutSlug(this.root), "v2"),
-      v2: path10.join(this.root, ".workit")
+      workspace: path9.join(checkout, "workspace.json"),
+      checkoutLock: path9.join(checkout, "metadata.lock"),
+      tasks: path9.join(dir, "tasks"),
+      index: path9.join(dir, "task-index.json"),
+      blobs: path9.join(dir, "blobs", "candidates"),
+      legacy: path9.join(dir, "legacy", checkoutSlug(this.root), "v2"),
+      v2: path9.join(this.root, ".workit")
     };
   }
   eventsPath(taskId) {
-    return path10.join(this.paths().tasks, taskId, "events.jsonl");
+    return path9.join(this.paths().tasks, taskId, "events.jsonl");
   }
   snapshotPath(taskId) {
-    return path10.join(this.paths().tasks, taskId, "snapshot.json");
+    return path9.join(this.paths().tasks, taskId, "snapshot.json");
   }
   taskLockPath(taskId) {
-    return path10.join(this.paths().tasks, taskId, "lock");
+    return path9.join(this.paths().tasks, taskId, "lock");
   }
   ready(write = false) {
     const location = this.location();
@@ -11377,7 +11181,7 @@ class TaskStore {
       return success(null, null, null);
     const dirs = this.paths();
     try {
-      const marker = JSON.parse(fs10.readFileSync(dirs.marker, "utf8"));
+      const marker = JSON.parse(fs9.readFileSync(dirs.marker, "utf8"));
       if (typeof marker.version === "number" && marker.version > STORE_FORMAT)
         return failure2("recovery_required", `the workit store at ${dirs.dir} has format ${marker.version}; upgrade Workit to use it`, { path: dirs.marker });
     } catch {}
@@ -11406,21 +11210,21 @@ class TaskStore {
     return {
       read: (digest) => {
         try {
-          return JSON.parse(fs10.readFileSync(path10.join(dir, `${digest}.json`), "utf8"));
+          return JSON.parse(fs9.readFileSync(path9.join(dir, `${digest}.json`), "utf8"));
         } catch (error) {
           throw new LogDamage(`stored candidate ${digest} is missing or unreadable: ${String(error)}`);
         }
       },
       write: (digest, value) => {
-        const file = path10.join(dir, `${digest}.json`);
-        if (fs10.existsSync(file)) {
+        const file = path9.join(dir, `${digest}.json`);
+        if (fs9.existsSync(file)) {
           const stamp = new Date;
           try {
-            fs10.utimesSync(file, stamp, stamp);
+            fs9.utimesSync(file, stamp, stamp);
             return;
           } catch {}
         }
-        fs10.mkdirSync(dir, { recursive: true });
+        fs9.mkdirSync(dir, { recursive: true });
         replaceFile(file, JSON.stringify(value), true);
       }
     };
@@ -11502,7 +11306,7 @@ class TaskStore {
   }
   readSnapshot(taskId) {
     try {
-      const value = JSON.parse(fs10.readFileSync(this.snapshotPath(taskId), "utf8"));
+      const value = JSON.parse(fs9.readFileSync(this.snapshotPath(taskId), "utf8"));
       if (!isObject4(value) || value.v !== 1 || value.task !== taskId || typeof value.seq !== "number" || typeof value.lastId !== "string" || typeof value.lastStart !== "number" || typeof value.end !== "number" || !isObject4(value.record))
         return null;
       return value;
@@ -11604,8 +11408,8 @@ class TaskStore {
     }
   }
   openTask(record, type, key, legacy = null) {
-    const dir = path10.join(this.paths().tasks, record.id);
-    fs10.mkdirSync(dir, { recursive: true });
+    const dir = path9.join(this.paths().tasks, record.id);
+    fs9.mkdirSync(dir, { recursive: true });
     const blobs = this.blobStore();
     const bound = key ? { ...key, boundAt: key.boundAt ?? new Date().toISOString() } : null;
     const event = this.event(record.id, 1, type, {
@@ -11657,11 +11461,11 @@ class TaskStore {
         } catch {}
         if (!latest || latest.events[0]?.id !== last.id)
           return failure2("busy", "the task log changed during compaction; retry", { taskId });
-        const appended = fs10.readFileSync(file).subarray(log.end, latest.end);
+        const appended = fs9.readFileSync(file).subarray(log.end, latest.end);
         const bytes = Buffer.concat([Buffer.from(prefix, "utf8"), appended]);
         replaceFile(file, bytes.toString("utf8"), true);
         try {
-          fs10.rmSync(this.snapshotPath(taskId), { force: true });
+          fs9.rmSync(this.snapshotPath(taskId), { force: true });
         } catch {}
         const reloaded = this.load(taskId);
         if (reloaded.ok && reloaded.data)
@@ -11674,7 +11478,7 @@ class TaskStore {
   }
   countEvents(file) {
     try {
-      const bytes = fs10.readFileSync(file);
+      const bytes = fs9.readFileSync(file);
       let count = 0;
       for (let index = bytes.indexOf(10);index >= 0; index = bytes.indexOf(10, index + 1))
         count += 1;
@@ -11697,7 +11501,7 @@ class TaskStore {
   }
   withKeyLock(key, operation) {
     const digest = createHash6("sha256").update(key).digest("hex").slice(0, 32);
-    return this.withLock(path10.join(this.paths().dir, "keys", `${digest}.lock`), operation);
+    return this.withLock(path9.join(this.paths().dir, "keys", `${digest}.lock`), operation);
   }
   bindLocked(taskId, key, timestamp) {
     const current = this.readWorkspace();
@@ -11838,7 +11642,7 @@ class TaskStore {
   writeWorkspace(record) {
     const file = this.paths().workspace;
     try {
-      fs10.mkdirSync(path10.dirname(file), { recursive: true });
+      fs9.mkdirSync(path9.dirname(file), { recursive: true });
       replaceFile(file, `${canonicalJson(record)}
 `, true);
       return success(null, null, null);
@@ -11848,7 +11652,7 @@ class TaskStore {
   }
   readIndex() {
     try {
-      const value = JSON.parse(fs10.readFileSync(this.paths().index, "utf8"));
+      const value = JSON.parse(fs9.readFileSync(this.paths().index, "utf8"));
       if (!isObject4(value) || value.version !== INDEX_VERSION || !isObject4(value.tasks))
         return {};
       const tasks = {};
@@ -11862,7 +11666,7 @@ class TaskStore {
   }
   writeIndex(entries) {
     try {
-      fs10.mkdirSync(this.paths().tasks, { recursive: true });
+      fs9.mkdirSync(this.paths().tasks, { recursive: true });
       replaceFile(this.paths().index, JSON.stringify({
         version: INDEX_VERSION,
         tasks: Object.fromEntries(entries.map((entry) => [entry.id, entry]))
@@ -11916,23 +11720,23 @@ class TaskStore {
     return failure2("revision_conflict", "workspace revision does not match; omit expectedWorkspaceRevision to use the current record", { expectedWorkspaceRevision: expected, actualWorkspaceRevision: actual });
   }
   v2Dirs() {
-    return [...new Set([this.root, this.origin])].map((dir) => path10.join(dir, ".workit"));
+    return [...new Set([this.root, this.origin])].map((dir) => path9.join(dir, ".workit"));
   }
   pendingMigrations() {
     return this.v2Dirs().filter((dir) => {
-      const raw = this.readV2Workspace(path10.join(dir, "workspace.json"));
+      const raw = this.readV2Workspace(path9.join(dir, "workspace.json"));
       return raw !== null && raw !== TOMBSTONE;
     });
   }
   migrateV2(v2) {
     const dirs = this.paths();
-    const v2Workspace = path10.join(v2, "workspace.json");
-    const v2Tasks = path10.join(v2, "tasks");
-    const legacy = path10.join(dirs.dir, "legacy", checkoutSlug(path10.dirname(v2)), "v2");
+    const v2Workspace = path9.join(v2, "workspace.json");
+    const v2Tasks = path9.join(v2, "tasks");
+    const legacy = path9.join(dirs.dir, "legacy", checkoutSlug(path9.dirname(v2)), "v2");
     const raw = this.readV2Workspace(v2Workspace);
     if (raw === null || raw === TOMBSTONE)
       return success(null, null, null);
-    return this.withLock(dirs.checkoutLock, () => this.withLock(path10.join(v2, "metadata.lock"), () => {
+    return this.withLock(dirs.checkoutLock, () => this.withLock(path9.join(v2, "metadata.lock"), () => {
       const workspace = this.readV2Workspace(v2Workspace);
       if (workspace === null || workspace === TOMBSTONE)
         return success(null, null, null);
@@ -11941,7 +11745,7 @@ class TaskStore {
         return failure2("recovery_required", `cannot migrate the 2.x store at ${v2}: ${parsedWorkspace.error}; move it aside to start fresh`, { path: v2Workspace });
       let files = [];
       try {
-        files = fs10.readdirSync(v2Tasks).filter((name) => name.endsWith(".json") && validId(name.slice(0, -5))).filter((name) => !this.isStub(path10.join(v2Tasks, name)));
+        files = fs9.readdirSync(v2Tasks).filter((name) => name.endsWith(".json") && validId(name.slice(0, -5))).filter((name) => !this.isStub(path9.join(v2Tasks, name)));
       } catch {}
       const current = this.readWorkspace();
       if (!current.ok)
@@ -11959,22 +11763,22 @@ class TaskStore {
       let skipped = 0;
       const done = new Map;
       try {
-        fs10.mkdirSync(path10.join(legacy, "tasks"), { recursive: true });
+        fs9.mkdirSync(path9.join(legacy, "tasks"), { recursive: true });
         for (const name of ["workspace.json", "index.json"])
-          if (fs10.existsSync(path10.join(v2, name)))
-            fs10.copyFileSync(path10.join(v2, name), path10.join(legacy, name));
+          if (fs9.existsSync(path9.join(v2, name)))
+            fs9.copyFileSync(path9.join(v2, name), path9.join(legacy, name));
         for (const name of files) {
           const id = name.slice(0, -5);
-          const file = path10.join(v2Tasks, name);
-          const bytes = fs10.readFileSync(file, "utf8");
+          const file = path9.join(v2Tasks, name);
+          const bytes = fs9.readFileSync(file, "utf8");
           const digest = sha256(bytes);
-          fs10.writeFileSync(path10.join(legacy, "tasks", name), bytes);
+          fs9.writeFileSync(path9.join(legacy, "tasks", name), bytes);
           const parsed = this.parseRecord(bytes, taskRecordSchema, "2.x task");
           if (!parsed.ok || parsed.data.id !== id)
             return failure2("recovery_required", `cannot migrate 2.x task ${id}: ${parsed.ok ? "file name and record ID differ" : parsed.error}; move ${file} aside to continue`, { path: file });
           const record = { ...parsed.data, workspaceId: target.id };
-          const origin = { path: path10.join(legacy, "tasks", name), digest };
-          if (!fs10.existsSync(this.eventsPath(id))) {
+          const origin = { path: path9.join(legacy, "tasks", name), digest };
+          if (!fs9.existsSync(this.eventsPath(id))) {
             this.openTask(record, "migrated.from_v2", null, origin);
             migrated += 1;
           } else {
@@ -12009,8 +11813,8 @@ class TaskStore {
       try {
         let complete = true;
         for (const [name, digest] of done) {
-          const file = path10.join(v2Tasks, name);
-          if (sha256(fs10.readFileSync(file, "utf8")) !== digest) {
+          const file = path9.join(v2Tasks, name);
+          if (sha256(fs9.readFileSync(file, "utf8")) !== digest) {
             complete = false;
             continue;
           }
@@ -12020,7 +11824,7 @@ class TaskStore {
           return failure2("busy", `the 2.x store at ${v2} changed during migration; retry`, {
             path: v2
           });
-        fs10.rmSync(path10.join(v2, "index.json"), { force: true });
+        fs9.rmSync(path9.join(v2, "index.json"), { force: true });
         this.writeTombstone(v2, target.id);
       } catch (error) {
         return failure2("storage_error", `cannot finish the 2.x migration: ${String(error)}`, {
@@ -12040,45 +11844,45 @@ class TaskStore {
   }
   adoptLocalStore() {
     const dirs = this.paths();
-    const marker = path10.join(dirs.v2, "store.json");
-    if (!dirs.shared || !fs10.existsSync(marker))
+    const marker = path9.join(dirs.v2, "store.json");
+    if (!dirs.shared || !fs9.existsSync(marker))
       return success(null, null, null);
     return this.withLock(dirs.checkoutLock, () => {
-      if (!fs10.existsSync(marker))
+      if (!fs9.existsSync(marker))
         return success(null, null, null);
       let tasks = 0;
       try {
         const merge = (from, to) => {
-          if (!fs10.existsSync(to)) {
-            fs10.mkdirSync(path10.dirname(to), { recursive: true });
+          if (!fs9.existsSync(to)) {
+            fs9.mkdirSync(path9.dirname(to), { recursive: true });
             try {
-              fs10.renameSync(from, to);
+              fs9.renameSync(from, to);
             } catch {
-              fs10.cpSync(from, to, { recursive: true, errorOnExist: true, force: false });
-              fs10.rmSync(from, { recursive: true, force: true });
+              fs9.cpSync(from, to, { recursive: true, errorOnExist: true, force: false });
+              fs9.rmSync(from, { recursive: true, force: true });
             }
             return;
           }
-          if (fs10.lstatSync(from).isDirectory() && fs10.lstatSync(to).isDirectory())
-            for (const name of fs10.readdirSync(from))
-              merge(path10.join(from, name), path10.join(to, name));
+          if (fs9.lstatSync(from).isDirectory() && fs9.lstatSync(to).isDirectory())
+            for (const name of fs9.readdirSync(from))
+              merge(path9.join(from, name), path9.join(to, name));
         };
         for (const sub of ["tasks", "checkouts", "blobs", "legacy"]) {
-          const from = path10.join(dirs.v2, sub);
-          if (!fs10.existsSync(from))
+          const from = path9.join(dirs.v2, sub);
+          if (!fs9.existsSync(from))
             continue;
           if (sub === "tasks") {
-            for (const name of fs10.readdirSync(from))
-              if (validId(name) && !fs10.existsSync(path10.join(dirs.dir, sub, name)))
+            for (const name of fs9.readdirSync(from))
+              if (validId(name) && !fs9.existsSync(path9.join(dirs.dir, sub, name)))
                 tasks += 1;
           }
-          merge(from, path10.join(dirs.dir, sub));
+          merge(from, path9.join(dirs.dir, sub));
         }
-        const ledger = path10.join(dirs.v2, "ledger");
-        if (fs10.existsSync(ledger) && !fs10.existsSync(path10.join(dirs.dir, "ledger")))
-          merge(ledger, path10.join(dirs.dir, "ledger"));
-        fs10.rmSync(path10.join(dirs.v2, "task-index.json"), { force: true });
-        fs10.renameSync(marker, path10.join(dirs.v2, "store.moved.json"));
+        const ledger = path9.join(dirs.v2, "ledger");
+        if (fs9.existsSync(ledger) && !fs9.existsSync(path9.join(dirs.dir, "ledger")))
+          merge(ledger, path9.join(dirs.dir, "ledger"));
+        fs9.rmSync(path9.join(dirs.v2, "task-index.json"), { force: true });
+        fs9.renameSync(marker, path9.join(dirs.v2, "store.moved.json"));
       } catch (error) {
         return failure2("storage_error", `cannot move ${dirs.v2} into ${dirs.dir}: ${String(error)}`, {
           path: dirs.v2
@@ -12098,7 +11902,7 @@ class TaskStore {
   readV2Workspace(file) {
     let bytes;
     try {
-      bytes = fs10.readFileSync(file, "utf8");
+      bytes = fs9.readFileSync(file, "utf8");
     } catch {
       return null;
     }
@@ -12116,7 +11920,7 @@ class TaskStore {
       schemaVersion: SCHEMA_VERSION,
       id: workspaceId ?? newId(),
       revision: newRevision(),
-      root: path10.dirname(v2),
+      root: path9.dirname(v2),
       runtime: { createdWith: version, updatedWith: version },
       writer: null,
       store: {
@@ -12127,12 +11931,12 @@ class TaskStore {
       },
       critical: ["store"]
     };
-    fs10.mkdirSync(v2, { recursive: true });
-    const ignore = path10.join(v2, ".gitignore");
-    if (!fs10.existsSync(ignore))
-      fs10.writeFileSync(ignore, `*
+    fs9.mkdirSync(v2, { recursive: true });
+    const ignore = path9.join(v2, ".gitignore");
+    if (!fs9.existsSync(ignore))
+      fs9.writeFileSync(ignore, `*
 `);
-    replaceFile(path10.join(v2, "workspace.json"), `${JSON.stringify(marker, null, 2)}
+    replaceFile(path9.join(v2, "workspace.json"), `${JSON.stringify(marker, null, 2)}
 `, true);
   }
   stubFor(taskId) {
@@ -12148,7 +11952,7 @@ class TaskStore {
   }
   isStub(file) {
     try {
-      const value = JSON.parse(fs10.readFileSync(file, "utf8"));
+      const value = JSON.parse(fs9.readFileSync(file, "utf8"));
       return isObject4(value) && isObject4(value.store) && value.store.format === "workit-store";
     } catch {
       return false;
@@ -12156,32 +11960,32 @@ class TaskStore {
   }
   writeTombstoneIfMissing() {
     try {
-      const v2 = path10.join(this.root, ".workit");
-      if (fs10.existsSync(path10.join(v2, "workspace.json")))
+      const v2 = path9.join(this.root, ".workit");
+      if (fs9.existsSync(path9.join(v2, "workspace.json")))
         return;
       let id = null;
       try {
-        id = JSON.parse(fs10.readFileSync(this.paths().workspace, "utf8")).id ?? null;
+        id = JSON.parse(fs9.readFileSync(this.paths().workspace, "utf8")).id ?? null;
       } catch {}
       this.writeTombstone(v2, id);
     } catch {}
   }
   initializeStorage() {
     const dirs = this.paths();
-    retryTransient(() => fs10.mkdirSync(dirs.checkout, { recursive: true }));
-    retryTransient(() => fs10.mkdirSync(dirs.tasks, { recursive: true }));
-    if (!fs10.existsSync(dirs.marker))
+    retryTransient(() => fs9.mkdirSync(dirs.checkout, { recursive: true }));
+    retryTransient(() => fs9.mkdirSync(dirs.tasks, { recursive: true }));
+    if (!fs9.existsSync(dirs.marker))
       replaceFile(dirs.marker, `${JSON.stringify({ format: "workit-store", version: STORE_FORMAT, createdWith: runtimeVersion() })}
 `, false);
     if (!dirs.shared) {
-      const ignore = path10.join(dirs.dir, ".gitignore");
+      const ignore = path9.join(dirs.dir, ".gitignore");
       let current = null;
       try {
-        current = fs10.readFileSync(ignore, "utf8");
+        current = fs9.readFileSync(ignore, "utf8");
       } catch {}
       if (current !== `*
 `)
-        retryTransient(() => fs10.writeFileSync(ignore, `*
+        retryTransient(() => fs9.writeFileSync(ignore, `*
 `));
     }
     this.writeTombstoneIfMissing();
@@ -12197,7 +12001,7 @@ class TaskStore {
       shouldReclaim: ({ payload, nowMs }) => {
         let ageMs = null;
         try {
-          ageMs = nowMs - fs10.lstatSync(lockPath).mtimeMs;
+          ageMs = nowMs - fs9.lstatSync(lockPath).mtimeMs;
         } catch {}
         return classifyLockOwner(payload, ageMs, localLockHost(), TASK_STORE_LOCK).state === "stale";
       },
@@ -12234,7 +12038,7 @@ class TaskStore {
   withLock(lockPath, operation) {
     try {
       this.initializeStorage();
-      fs10.mkdirSync(path10.dirname(lockPath), { recursive: true });
+      fs9.mkdirSync(path9.dirname(lockPath), { recursive: true });
     } catch (error) {
       return failure2("storage_error", `unable to initialize store: ${String(error)}`, {
         path: this.paths().dir
@@ -12274,18 +12078,18 @@ class TaskStore {
   lockDirWritable(lockPath) {
     const probe = `${lockPath}.${process.pid}.${randomUUID3()}.probe`;
     try {
-      fs10.closeSync(fs10.openSync(probe, "wx", 384));
+      fs9.closeSync(fs9.openSync(probe, "wx", 384));
     } catch {
       return false;
     }
     try {
-      fs10.rmSync(probe, { force: true });
+      fs9.rmSync(probe, { force: true });
     } catch {}
     return true;
   }
   lockHolderPresent(lockPath) {
     try {
-      fs10.lstatSync(lockPath);
+      fs9.lstatSync(lockPath);
       return true;
     } catch (error) {
       return error?.code !== "ENOENT";
@@ -12297,12 +12101,12 @@ class TaskStore {
     if (isTransientWindowsError(error) && !this.lockHolderPresent(lockPath) && !this.lockDirWritable(lockPath))
       return failure2("storage_error", `cannot create the workit lock (${code}); no other Workit call holds it`, {
         path: lockPath,
-        guidance: `Check permissions and the read-only attribute on ${path10.dirname(lockPath)}.`
+        guidance: `Check permissions and the read-only attribute on ${path9.dirname(lockPath)}.`
       });
     if (code === "EEXIST" || code === "file_lock_timeout" || code === "file_lock_stale" || isTransientWindowsError(error)) {
       let lock = null;
       try {
-        lock = parseMetadataLockOrNull(fs10.readFileSync(lockPath, "utf8"));
+        lock = parseMetadataLockOrNull(fs9.readFileSync(lockPath, "utf8"));
       } catch {}
       return failure2("busy", `workit lock is held by another Workit call${lock ? ` (pid ${lock.pid} on ${lock.host})` : ""}; retry shortly`, {
         outcome: "not_started",
@@ -12317,18 +12121,18 @@ class TaskStore {
 
 // packages/workit-core/src/core/policy/derive.ts
 import { existsSync as existsSync4 } from "node:fs";
-import path15 from "node:path";
+import path14 from "node:path";
 
 // packages/workit-core/src/ledger.ts
-import { spawnSync as spawnSync9 } from "node:child_process";
+import { spawnSync as spawnSync8 } from "node:child_process";
 import { createHash as createHash9, randomBytes as randomBytes3 } from "node:crypto";
-import fs12 from "node:fs";
-import path14 from "node:path";
-
-// packages/workit-core/src/core/vcs-config.ts
 import fs11 from "node:fs";
 import path13 from "node:path";
-import { spawnSync as spawnSync8 } from "node:child_process";
+
+// packages/workit-core/src/core/vcs-config.ts
+import fs10 from "node:fs";
+import path12 from "node:path";
+import { spawnSync as spawnSync7 } from "node:child_process";
 
 // packages/workit-core/src/core/config.ts
 import {
@@ -12341,7 +12145,7 @@ import {
   writeFileSync as writeFileSync2
 } from "node:fs";
 import os3 from "node:os";
-import path11 from "node:path";
+import path10 from "node:path";
 
 // packages/workit-core/src/core/boundary.ts
 var EVENT = {
@@ -12385,7 +12189,7 @@ var mergePreset = (preset, input = {}, current = {
     protected: preset === "custom" ? input.protectedNames ?? current.branchPolicy.protected : [...defs.protected]
   };
 };
-var resolveConfigDir = () => process.env.WORKFLOW_TOOLKIT_CONFIG ?? process.env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path11.join(process.env.XDG_CONFIG_HOME || path11.join(os3.homedir(), ".config"), "workit");
+var resolveConfigDir = () => process.env.WORKFLOW_TOOLKIT_CONFIG ?? process.env.WORKFLOW_TOOLKIT_CONFIG_DIR ?? path10.join(process.env.XDG_CONFIG_HOME || path10.join(os3.homedir(), ".config"), "workit");
 var migratedDir = null;
 var migrationFailed = false;
 var ensureConfigDir = (dir = resolveConfigDir()) => {
@@ -12395,7 +12199,7 @@ var ensureConfigDir = (dir = resolveConfigDir()) => {
     migratedDir = dir;
     return dir;
   }
-  const legacy = path11.join(process.env.XDG_CONFIG_HOME || path11.join(os3.homedir(), ".config"), "workflow-toolkit");
+  const legacy = path10.join(process.env.XDG_CONFIG_HOME || path10.join(os3.homedir(), ".config"), "workflow-toolkit");
   if (!existsSync3(legacy)) {
     migratedDir = dir;
     return dir;
@@ -12408,8 +12212,8 @@ var ensureConfigDir = (dir = resolveConfigDir()) => {
   mkdirSync2(dir, { recursive: true });
   diagnosticLogger?.info(EVENT.migration, { from: legacy, to: dir });
   for (const entry of readdirSync2(legacy, { withFileTypes: true })) {
-    const src = path11.join(legacy, entry.name);
-    const dest = path11.join(dir, entry.name);
+    const src = path10.join(legacy, entry.name);
+    const dest = path10.join(dir, entry.name);
     if (existsSync3(dest))
       continue;
     try {
@@ -12481,7 +12285,7 @@ var parseConfigResult = (raw, file) => {
   return { status: "valid", path: file, config };
 };
 var readConfigTyped = (dir) => {
-  const file = path11.join(dir ?? configDir(), "config.json");
+  const file = path10.join(dir ?? configDir(), "config.json");
   return parseConfigResult(readSafe(file), file);
 };
 var readConfig = () => {
@@ -12490,7 +12294,7 @@ var readConfig = () => {
     throw new Error(result.error);
   return result.config ?? DEFAULTS;
 };
-var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path11.join(configDir(), "vcs.json");
+var vcsConfigPath = () => process.env.WORKFLOW_VCS_CONFIG ?? path10.join(configDir(), "vcs.json");
 var branchGlobPattern = (glob) => new RegExp(`^${glob.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*")}$`, "i");
 var resolveBranchPolicy = (config, workspace, repoPreset) => {
   const wp = workspace?.branchPolicy ?? {};
@@ -12531,13 +12335,13 @@ var resolveCommitPolicy = (config, workspace) => {
 };
 
 // packages/workit-core/src/core/workspaces.ts
-import { spawnSync as spawnSync6 } from "node:child_process";
+import { spawnSync as spawnSync5 } from "node:child_process";
 import { createHash as createHash7 } from "node:crypto";
 import { readFileSync as readFileSync3, realpathSync as realpathSync2 } from "node:fs";
-import path12 from "node:path";
+import path11 from "node:path";
 
 // packages/workit-core/src/core/branch-policy.ts
-import { spawnSync as spawnSync5 } from "node:child_process";
+import { spawnSync as spawnSync4 } from "node:child_process";
 var PREFIXES = {
   feature: "feature/*",
   bugfix: "bugfix/*",
@@ -12545,7 +12349,7 @@ var PREFIXES = {
   hotfix: "hotfix/*"
 };
 var branchNames = (workspaceRoot) => {
-  const r = spawnSync5("git", ["for-each-ref", "--format=%(refname)", "refs/heads", "refs/remotes/origin"], { cwd: workspaceRoot, encoding: "utf8" });
+  const r = spawnSync4("git", ["for-each-ref", "--format=%(refname)", "refs/heads", "refs/remotes/origin"], { cwd: workspaceRoot, encoding: "utf8" });
   if (r.status !== 0)
     return new Set;
   return new Set((r.stdout ?? "").split(`
@@ -12604,7 +12408,7 @@ var repoBranchPreset = (workspaceRoot) => {
 var releaseTagPrefixOf = (workspaceRoot, policyPrefix) => {
   if (typeof policyPrefix === "string")
     return policyPrefix.trim();
-  const r = spawnSync5("git", ["config", "--get", "gitflow.prefix.versiontag"], {
+  const r = spawnSync4("git", ["config", "--get", "gitflow.prefix.versiontag"], {
     cwd: workspaceRoot,
     encoding: "utf8"
   });
@@ -12669,7 +12473,7 @@ var releaseTrackSchema = object({
       context.addIssue({ code: "custom", path: [field], message: "entries must be unique" });
     }
   }
-  if (track.versionSource?.kind === "package-json" && (path12.posix.isAbsolute(track.versionSource.path.replaceAll("\\", "/")) || /^[A-Za-z]:\//u.test(track.versionSource.path.replaceAll("\\", "/")) || track.versionSource.path.replaceAll("\\", "/").split("/").includes(".."))) {
+  if (track.versionSource?.kind === "package-json" && (path11.posix.isAbsolute(track.versionSource.path.replaceAll("\\", "/")) || /^[A-Za-z]:\//u.test(track.versionSource.path.replaceAll("\\", "/")) || track.versionSource.path.replaceAll("\\", "/").split("/").includes(".."))) {
     context.addIssue({
       code: "custom",
       path: ["versionSource", "path"],
@@ -12689,6 +12493,7 @@ var workspaceConfigSchema = object({
   autoApprove: union([boolean2(), array(nonBlank)]).optional(),
   defaultEndpoint: unknown().optional(),
   verification: _enum(["self", "independent"]).optional(),
+  delegation: unknown().optional(),
   trailers: boolean2().optional(),
   liveSessionGuard: boolean2().optional(),
   fanout: object({ tierModels: unknown().optional() }).passthrough().optional(),
@@ -12769,7 +12574,7 @@ var validateWorkspacesDocument = (parsed, file) => {
   };
 };
 var readWorkspacesResult = (dir = configDir()) => {
-  const file = path12.join(dir, "workspaces.json");
+  const file = path11.join(dir, "workspaces.json");
   let raw;
   try {
     raw = readFileSync3(file, "utf8");
@@ -12868,7 +12673,7 @@ var mainCheckoutOf = (cwd) => {
   for (const name of ["GIT_DIR", "GIT_WORK_TREE", "GIT_COMMON_DIR", "GIT_INDEX_FILE"])
     delete env[name];
   const git = (args) => {
-    const run = spawnSync6("git", args, {
+    const run = spawnSync5("git", args, {
       cwd,
       env,
       encoding: "utf8",
@@ -12880,9 +12685,9 @@ var mainCheckoutOf = (cwd) => {
   let main = null;
   const dirs = git(["rev-parse", "--path-format=absolute", "--git-dir", "--git-common-dir"]);
   const [gitDir, common] = (dirs ?? "").trim().split(/\r?\n/u);
-  if (gitDir && common && path12.resolve(gitDir) !== path12.resolve(common)) {
+  if (gitDir && common && path11.resolve(gitDir) !== path11.resolve(common)) {
     const listed = /^worktree (.+)$/mu.exec(git(["worktree", "list", "--porcelain"]) ?? "")?.[1];
-    main = listed?.trim() || (path12.basename(common) === ".git" ? path12.dirname(common) : common);
+    main = listed?.trim() || (path11.basename(common) === ".git" ? path11.dirname(common) : common);
   }
   mainCheckouts.set(cwd, main);
   return main;
@@ -12973,7 +12778,7 @@ var runtimeWorkspaceIndexSchema = object({
   workspaces: array(object({ name: nonBlank, glob: nonBlank }).passthrough()).optional()
 }).passthrough();
 var matchRuntimeWorkspace = (cwd, dir = configDir()) => {
-  const file = path12.join(dir, "workspaces.json");
+  const file = path11.join(dir, "workspaces.json");
   let raw;
   try {
     raw = readFileSync3(file, "utf8");
@@ -13082,7 +12887,7 @@ function workspaceDefaultTarget(cwd, globalDefault) {
 
 // packages/workit-core/src/core/release-tracks.ts
 import { createHash as createHash8 } from "node:crypto";
-import { spawnSync as spawnSync7 } from "node:child_process";
+import { spawnSync as spawnSync6 } from "node:child_process";
 class ReleaseTrackError extends Error {
 }
 var KNOWN_FIELDS = new Set([
@@ -13101,7 +12906,7 @@ var KNOWN_FIELDS = new Set([
 var BRANCH_FIELDS = ["productionBranch", "integrationBranch", "baseBranch", "pullRequestTarget"];
 var PLACEHOLDER = /\{[^}]*\}/gu;
 var HAS_PLACEHOLDER = /\{[^}]*\}/u;
-var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var branchName = (value) => typeof value === "string" && value.trim() && !value.trim().startsWith("-") ? value.trim() : null;
 var namedBranches = (entry) => [
   ...BRANCH_FIELDS.map((field) => branchName(entry[field])),
@@ -13112,7 +12917,7 @@ function readReleaseTracks(raw) {
   const out = { tracks: [], issues: [], error: null, protectedBranches: [] };
   if (raw === undefined || raw === null)
     return out;
-  if (!isRecord2(raw)) {
+  if (!isRecord(raw)) {
     out.issues.push("releaseTracks is not an object; ignored");
     return out;
   }
@@ -13120,7 +12925,7 @@ function readReleaseTracks(raw) {
   const protectedNames = new Set;
   for (const [name, entry] of Object.entries(raw).toSorted(([a], [b]) => a < b ? -1 : 1)) {
     const label = `release track ${JSON.stringify(name)}`;
-    if (!isRecord2(entry)) {
+    if (!isRecord(entry)) {
       out.issues.push(`${label} is not an object; ignored`);
       continue;
     }
@@ -13171,7 +12976,7 @@ function readReleaseTracks(raw) {
     }
     const naming = {};
     if (entry.naming !== undefined) {
-      if (!isRecord2(entry.naming))
+      if (!isRecord(entry.naming))
         problem("naming", "not an object; ignored");
       else
         for (const kind of ["feature", "release", "hotfix"]) {
@@ -13366,8 +13171,8 @@ function resolveReleaseTrack(input) {
   const newest = forks.filter((fork) => !forks.some((other) => descends(fork.sha, other.sha)));
   return fallback(`${branch} has the same or unrelated fork points with ${[...new Set(newest.map((fork) => `${fork.ref} (${fork.track.name === IMPLICIT ? "workspace default" : fork.track.name})`))].join(" and ")}`);
 }
-var git3 = (cwd, args) => {
-  const run = spawnSync7("git", args, {
+var git2 = (cwd, args) => {
+  const run = spawnSync6("git", args, {
     cwd,
     encoding: "utf8",
     timeout: 20000,
@@ -13378,7 +13183,7 @@ var git3 = (cwd, args) => {
 };
 var recordedBaseKey = (branch) => `branch.${branch}.workitBase`;
 var escapeRegExp2 = (text) => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
-var reflog = (cwd, ref) => (git3(cwd, ["log", "-g", "--date=unix", "--format=%H%x09%gd%x09%gs", ref, "--"]) ?? "").split(`
+var reflog = (cwd, ref) => (git2(cwd, ["log", "-g", "--date=unix", "--format=%H%x09%gd%x09%gs", ref, "--"]) ?? "").split(`
 `).map((line) => {
   const [sha = "", selector = "", ...subject] = line.split("\t");
   return {
@@ -13396,9 +13201,9 @@ function gitTrackProbe(cwd) {
   };
   return {
     remotes: () => remotes ??= remoteNames(cwd),
-    recordedBase: (branch) => git3(cwd, ["config", "--get", recordedBaseKey(branch)]) || null,
+    recordedBase: (branch) => git2(cwd, ["config", "--get", recordedBaseKey(branch)]) || null,
     createdFrom: (branch) => {
-      const log = git3(cwd, ["reflog", "show", "--format=%gs", `refs/heads/${branch}`, "--"]);
+      const log = git2(cwd, ["reflog", "show", "--format=%gs", `refs/heads/${branch}`, "--"]);
       const oldest = log?.split(`
 `).findLast(Boolean) ?? "";
       const match = /^branch: Created from (\S+)$/u.exec(oldest);
@@ -13417,7 +13222,7 @@ function gitTrackProbe(cwd) {
       const base = tip(trackBranch);
       return base && resolveRef(cwd, `refs/heads/${branch}`) ? mergeBase(cwd, base, `refs/heads/${branch}`) : null;
     },
-    isAncestor: (ancestor, descendant) => git3(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]) !== null
+    isAncestor: (ancestor, descendant) => git2(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]) !== null
   };
 }
 function workspaceReleaseTracks(cwd) {
@@ -13444,15 +13249,15 @@ function resolveTrackFor(cwd, options) {
   };
   let key = null;
   if (!options.probe) {
-    const refs = git3(cwd, [
+    const refs = git2(cwd, [
       "for-each-ref",
       "--format=%(refname) %(objectname)",
       "refs/heads",
       "refs/remotes"
     ]) ?? "";
-    const head = git3(cwd, ["reflog", "show", "-n", "1", "--format=%H %gs", "HEAD", "--"]) ?? "";
+    const head = git2(cwd, ["reflog", "show", "-n", "1", "--format=%H %gs", "HEAD", "--"]) ?? "";
     const own = branch ? [
-      git3(cwd, [
+      git2(cwd, [
         "log",
         "-g",
         "-n",
@@ -13462,7 +13267,7 @@ function resolveTrackFor(cwd, options) {
         `refs/heads/${branch}`,
         "--"
       ]) ?? "",
-      git3(cwd, ["config", "--get", recordedBaseKey(branch)]) ?? ""
+      git2(cwd, ["config", "--get", recordedBaseKey(branch)]) ?? ""
     ] : [];
     key = createHash8("sha256").update(JSON.stringify({ cwd, input, refs, head, own })).digest("hex");
     const hit = memo2.get(key);
@@ -13479,10 +13284,10 @@ function resolveTrackFor(cwd, options) {
 }
 
 // packages/workit-core/src/core/vcs-config.ts
-var workspacesPath = () => path13.join(configDir(), "workspaces.json");
+var workspacesPath = () => path12.join(configDir(), "workspaces.json");
 var vcsCwd = (cwd) => cwd ?? process.env.WORKFLOW_WORKSPACE_ROOT ?? process.cwd();
 var remoteProvider = (cwd) => {
-  const r = spawnSync8("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
+  const r = spawnSync7("git", ["remote", "get-url", "origin"], { cwd, encoding: "utf8" });
   if (r.status !== 0)
     return null;
   const url = (r.stdout ?? "").trim();
@@ -13496,7 +13301,7 @@ var readVcsConfig = () => {
   const file = vcsConfigPath();
   let raw;
   try {
-    raw = fs11.readFileSync(file, "utf8");
+    raw = fs10.readFileSync(file, "utf8");
   } catch {
     return { status: "missing", path: file, config: {} };
   }
@@ -13621,7 +13426,7 @@ function vcsConfig(mode, cwd, options = {}) {
   const prov = cfg[provider] ?? {};
   const out = {
     ok: true,
-    configPath: path13.resolve(cfgPath),
+    configPath: path12.resolve(cfgPath),
     provider,
     defaultTargetBranch: workspaceDefault,
     pr: cfg.pr ?? {},
@@ -13662,7 +13467,7 @@ var err = (code, error, unblock) => ({
   ...unblock ? { unblock } : {}
 });
 var gitRun2 = (cwd, args, timeoutMs = GIT_TIMEOUTS.local) => {
-  const run = spawnSync9("git", args, {
+  const run = spawnSync8("git", args, {
     cwd,
     encoding: "utf8",
     timeout: timeoutMs,
@@ -13683,7 +13488,7 @@ var gitRun2 = (cwd, args, timeoutMs = GIT_TIMEOUTS.local) => {
     stderr: run.error ? String(run.error.message) : run.stderr ?? ""
   };
 };
-var git4 = (cwd, args) => {
+var git3 = (cwd, args) => {
   const run = gitRun2(cwd, args);
   const value = run.ok ? run.stdout.trim() : "";
   return value ? value : null;
@@ -13692,7 +13497,7 @@ var safeRef = (value) => value.length > 0 && !value.startsWith("-");
 function resolveCommit(cwd, ref) {
   if (!safeRef(ref))
     return null;
-  return git4(cwd, ["rev-parse", "--verify", "-q", `${ref}^{commit}`]);
+  return git3(cwd, ["rev-parse", "--verify", "-q", `${ref}^{commit}`]);
 }
 function branchHead(cwd, branch) {
   if (!safeRef(branch))
@@ -13717,7 +13522,7 @@ function defaultBase(cwd) {
       if (resolveCommit(cwd, candidate))
         return candidate;
   }
-  const originHead = git4(cwd, ["symbolic-ref", "-q", "--short", "refs/remotes/origin/HEAD"]);
+  const originHead = git3(cwd, ["symbolic-ref", "-q", "--short", "refs/remotes/origin/HEAD"]);
   if (originHead && resolveCommit(cwd, originHead))
     return originHead;
   for (const candidate of [
@@ -13765,14 +13570,14 @@ function diffHash(cwd, base, head) {
   return `sha256:${hash.digest("hex")}`;
 }
 function storeRoot(cwd) {
-  const location = resolveStore(path14.resolve(cwd));
+  const location = resolveStore(path13.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: path14.join(root.value.root, "ledger", "ledger.jsonl") } : root;
+  return root.ok ? { ok: true, value: path13.join(root.value.root, "ledger", "ledger.jsonl") } : root;
 }
 var newId2 = () => `${Date.now().toString(36)}-${randomBytes3(6).toString("hex")}`;
 var NETWORK_FS_TYPES = new Set([
@@ -13792,7 +13597,7 @@ var onNetworkFs = (dir) => {
   if (process.platform !== "linux")
     return false;
   try {
-    return isNetworkFsType(fs12.statfsSync(dir).type);
+    return isNetworkFsType(fs11.statfsSync(dir).type);
   } catch {
     return false;
   }
@@ -13802,15 +13607,15 @@ var LOCK_STALE_MS = 30000;
 var LOCK_OWNER = "owner";
 var lockToken = (lock) => {
   try {
-    return fs12.readFileSync(path14.join(lock, LOCK_OWNER), "utf8");
+    return fs11.readFileSync(path13.join(lock, LOCK_OWNER), "utf8");
   } catch {
     return null;
   }
 };
 var lockAgeMs = (lock) => {
-  for (const target of [path14.join(lock, LOCK_OWNER), lock]) {
+  for (const target of [path13.join(lock, LOCK_OWNER), lock]) {
     try {
-      return Date.now() - fs12.statSync(target).mtimeMs;
+      return Date.now() - fs11.statSync(target).mtimeMs;
     } catch {}
   }
   return null;
@@ -13818,14 +13623,14 @@ var lockAgeMs = (lock) => {
 var ledgerLock = {
   acquire(lock) {
     try {
-      fs12.mkdirSync(lock);
+      fs11.mkdirSync(lock);
     } catch (error) {
       if (error.code === "EEXIST")
         return null;
       throw error;
     }
     const token = `${process.pid}-${randomBytes3(8).toString("hex")}`;
-    fs12.writeFileSync(path14.join(lock, LOCK_OWNER), token);
+    fs11.writeFileSync(path13.join(lock, LOCK_OWNER), token);
     return token;
   },
   release(lock, token) {
@@ -13833,35 +13638,35 @@ var ledgerLock = {
       return false;
     const tomb = `${lock}.release-${randomBytes3(6).toString("hex")}`;
     try {
-      fs12.renameSync(lock, tomb);
+      fs11.renameSync(lock, tomb);
     } catch {
       return false;
     }
     if (lockToken(tomb) !== token) {
       try {
-        fs12.renameSync(tomb, lock);
+        fs11.renameSync(tomb, lock);
       } catch {}
       return false;
     }
-    fs12.rmSync(tomb, { recursive: true, force: true });
+    fs11.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);
+      fs11.renameSync(lock, tomb);
     } catch {
       return false;
     }
     if (lockToken(tomb) === observed) {
-      fs12.rmSync(tomb, { recursive: true, force: true });
+      fs11.rmSync(tomb, { recursive: true, force: true });
       return true;
     }
     try {
-      fs12.renameSync(tomb, lock);
+      fs11.renameSync(tomb, lock);
     } catch {
-      fs12.rmSync(tomb, { recursive: true, force: true });
+      fs11.rmSync(tomb, { recursive: true, force: true });
     }
     return false;
   }
@@ -13895,7 +13700,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);
+    fs11.readSync(fd, buffer, 0, span, size - span);
     const end = buffer.lastIndexOf(10);
     if (end < 0) {
       if (span === size)
@@ -13926,21 +13731,21 @@ var lastLine = (fd, size) => {
 };
 var tighten = (fd) => {
   try {
-    if ((fs12.fstatSync(fd).mode & 63) !== 0)
-      fs12.fchmodSync(fd, 384);
+    if ((fs11.fstatSync(fd).mode & 63) !== 0)
+      fs11.fchmodSync(fd, 384);
   } catch {}
 };
 function appendLine(file, build, options) {
   const write = () => {
-    const fd = fs12.openSync(file, "a+", 384);
+    const fd = fs11.openSync(file, "a+", 384);
     try {
       if (process.platform !== "win32")
         tighten(fd);
-      const size = fs12.fstatSync(fd).size;
+      const size = fs11.fstatSync(fd).size;
       let fence = "";
       if (size > 0) {
         const last = Buffer.alloc(1);
-        fs12.readSync(fd, last, 0, 1, size - 1);
+        fs11.readSync(fd, last, 0, 1, size - 1);
         if (last[0] !== 10)
           fence = `
 `;
@@ -13949,17 +13754,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 = fs11.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);
+      fs11.closeSync(fd);
     }
   };
   try {
-    fs12.mkdirSync(path14.dirname(file), { recursive: true });
-    if (!options.forceLock && !onNetworkFs(path14.dirname(file)))
+    fs11.mkdirSync(path13.dirname(file), { recursive: true });
+    if (!options.forceLock && !onNetworkFs(path13.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");
@@ -14002,10 +13807,10 @@ function appendObserved(cwd, row, options = {}) {
 function appendHookObserved(cwd, row) {
   return appendRaw(cwd, { ...row, observer: "host_hook" }, {});
 }
-var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var str = (value) => typeof value === "string" ? value : null;
 var normalizeActor = (value) => {
-  const actor = isRecord3(value) ? value : {};
+  const actor = isRecord2(value) ? value : {};
   return {
     host: str(actor.host) ?? "unknown",
     session: str(actor.session),
@@ -14032,8 +13837,8 @@ function readLedger(cwd, options = {}) {
   let text = "";
   let stat = null;
   try {
-    stat = fs12.statSync(file.value);
-    text = fs12.readFileSync(file.value, "utf8");
+    stat = fs11.statSync(file.value);
+    text = fs11.readFileSync(file.value, "utf8");
   } catch (error) {
     if (error.code === "ENOENT")
       return {
@@ -14068,7 +13873,7 @@ function readLedger(cwd, options = {}) {
       skipped += 1;
       continue;
     }
-    if (!isRecord3(parsed) || !str(parsed.id) || !str(parsed.type) || !str(parsed.at)) {
+    if (!isRecord2(parsed) || !str(parsed.id) || !str(parsed.type) || !str(parsed.at)) {
       skipped += 1;
       continue;
     }
@@ -14168,7 +13973,7 @@ function ledgerTampering(cwd) {
   if (!file.ok)
     return [];
   try {
-    const stat = fs12.statSync(file.value);
+    const stat = fs11.statSync(file.value);
     const cached = tamperCache.get(file.value);
     if (cached && cached.size === stat.size && cached.stamp === fileStamp(stat))
       return cached.breaks;
@@ -14195,7 +14000,7 @@ var isLiveVerdict = (row, retired) => row.type === "verdict" && typeof row.resul
 function trailerSessions(cwd, base, head) {
   if (!base || !head || !safeRef(base) || !safeRef(head))
     return [];
-  const out = git4(cwd, [
+  const out = git3(cwd, [
     "log",
     "--format=%(trailers:key=Workit-Session,valueonly,separator=%x00)",
     `${base}..${head}`
@@ -14207,7 +14012,7 @@ function branchScope(cwd, branch) {
   const renamedAt = new Map;
   let since = Number.NEGATIVE_INFINITY;
   if (safeRef(branch)) {
-    const log = git4(cwd, [
+    const log = git3(cwd, [
       "log",
       "-g",
       "--date=unix",
@@ -14647,7 +14452,7 @@ var productDecision = (task, ledger) => {
   };
 };
 var planRecorded = (task, root) => {
-  const cited = (latestJudgment(task)?.refs ?? []).find((ref) => ref.kind === "external" || ref.kind === "file" && existsSync4(path15.resolve(root, ref.path)));
+  const cited = (latestJudgment(task)?.refs ?? []).find((ref) => ref.kind === "external" || ref.kind === "file" && existsSync4(path14.resolve(root, ref.path)));
   if (cited)
     return {
       met: true,
@@ -14707,14 +14512,14 @@ function writeBlockers(task, root) {
 
 // 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}${path16.sep}`);
-var relative = (root, candidate) => path16.relative(root, candidate).split(path16.sep).join("/") || ".";
+var inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path15.sep}`);
+var relative = (root, candidate) => path15.relative(root, candidate).split(path15.sep).join("/") || ".";
 var canonicalPath = (value) => {
   if (typeof value !== "string" || !value)
     return null;
   if (value.includes("\\") || value.split("/").includes(".."))
     return null;
-  const normalized = path16.posix.normalize(value);
+  const normalized = path15.posix.normalize(value);
   if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
     return null;
   return normalized === "." ? "." : normalized.replace(/\/$/, "");
@@ -14750,7 +14555,7 @@ var compareCodeUnits2 = (left, right) => {
   return left.length - right.length;
 };
 var gitPaths = (root) => {
-  const result = spawnSync10("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+  const result = spawnSync9("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
     cwd: root,
     encoding: "buffer"
   });
@@ -14762,21 +14567,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(path16.sep).join("/")) : [];
-  const stagedDeleted = spawnSync10("git", ["diff", "--cached", "--name-only", "--diff-filter=D", "-z"], { cwd: root, encoding: "buffer" });
+  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path15.sep).join("/")) : [];
+  const stagedDeleted = spawnSync9("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(path16.sep).join("/")));
+    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path15.sep).join("/")));
   }
   return { paths: [...new Set(paths)], uncertain: false, git: true };
 };
 var walk = (root, directory, output) => {
   let names;
   try {
-    names = fs13.readdirSync(directory);
+    names = fs12.readdirSync(directory);
   } catch {
     return true;
   }
@@ -14784,10 +14589,10 @@ var walk = (root, directory, output) => {
   for (const name of names) {
     if (name === ".git" || name === ".workit")
       continue;
-    const target = path16.join(directory, name);
+    const target = path15.join(directory, name);
     let stat;
     try {
-      stat = fs13.lstatSync(target);
+      stat = fs12.lstatSync(target);
     } catch {
       uncertain = true;
       continue;
@@ -14802,14 +14607,14 @@ var walk = (root, directory, output) => {
 var scopeRoots = (root, scope) => {
   const roots = [];
   for (const item of scope.paths.length ? scope.paths : ["."]) {
-    const target = path16.resolve(root, item);
+    const target = path15.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 = path16.dirname(ancestor);
+    while (!fs12.existsSync(ancestor) && ancestor !== root)
+      ancestor = path15.dirname(ancestor);
     try {
-      if (!inside(root, fs13.realpathSync(ancestor)))
+      if (!inside(root, fs12.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}`);
@@ -14821,7 +14626,7 @@ var scopeRoots = (root, scope) => {
 function captureCandidate(root, scope, environment = []) {
   let checkout;
   try {
-    checkout = fs13.realpathSync(root);
+    checkout = fs12.realpathSync(root);
   } catch {
     return failure2("invalid_input", "candidate root does not exist");
   }
@@ -14839,11 +14644,11 @@ function captureCandidate(root, scope, environment = []) {
     if (item === ".git" || item === ".workit")
       continue;
     names.add(item);
-    if (!fs13.existsSync(target))
+    if (!fs12.existsSync(target))
       continue;
     let stat;
     try {
-      stat = fs13.lstatSync(target);
+      stat = fs12.lstatSync(target);
     } catch {
       uncertain = true;
       continue;
@@ -14859,17 +14664,17 @@ function captureCandidate(root, scope, environment = []) {
   for (const item of [...names].toSorted()) {
     if (!scopeMatches(item, normalizedScope))
       continue;
-    const target = path16.join(checkout, item);
+    const target = path15.join(checkout, item);
     try {
-      const stat = fs13.lstatSync(target);
+      const stat = fs12.lstatSync(target);
       if (stat.isSymbolicLink()) {
-        const link = fs13.readlinkSync(target);
+        const link = fs12.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(fs12.readFileSync(target)),
           executable: (stat.mode & 73) !== 0
         });
       } else if (!stat.isDirectory()) {
@@ -14894,7 +14699,7 @@ function captureCandidate(root, scope, environment = []) {
   const values = supplied.toSorted((left, right) => compareCodeUnits2(left.name, right.name)).map(({ name, value }) => ({ name, value, refs: [] }));
   if (values.some(({ value }) => value === null))
     completeness = "uncertain";
-  const headResult = spawnSync10("git", ["rev-parse", "HEAD"], { cwd: checkout, encoding: "utf8" });
+  const headResult = spawnSync9("git", ["rev-parse", "HEAD"], { cwd: checkout, encoding: "utf8" });
   if (headResult.status !== 0 && !/not a git repository/i.test(headResult.stderr ?? ""))
     completeness = "uncertain";
   const head = headResult.status === 0 ? headResult.stdout.trim() : null;
@@ -15034,7 +14839,7 @@ var findingVerificationPasses = (findingCandidateId, evidence) => evidence.statu
 var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
   let root;
   try {
-    root = fs13.realpathSync(checkoutRoot);
+    root = fs12.realpathSync(checkoutRoot);
   } catch {
     return failure2("permission_denied", "checkout root is unavailable");
   }
@@ -15043,23 +14848,23 @@ var verifyDecisionContentAtRoot = (checkoutRoot, binding) => {
       continue;
     if (!reference.digest)
       return failure2("invalid_input", "document references require a byte digest");
-    const target = path16.resolve(root, reference.path);
-    if (target !== root && !target.startsWith(`${root}${path16.sep}`))
+    const target = path15.resolve(root, reference.path);
+    if (target !== root && !target.startsWith(`${root}${path15.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 = path16.relative(root, target);
+      const below = path15.relative(root, target);
       let current = root;
-      for (const segment of below.split(path16.sep)) {
+      for (const segment of below.split(path15.sep)) {
         if (!segment)
           continue;
-        current = path16.join(current, segment);
-        const stat = fs13.lstatSync(current);
-        const real = fs13.realpathSync(current);
-        if (real !== root && !real.startsWith(`${root}${path16.sep}`))
+        current = path15.join(current, segment);
+        const stat = fs12.lstatSync(current);
+        const real = fs12.realpathSync(current);
+        if (real !== root && !real.startsWith(`${root}${path15.sep}`))
           return failure2("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
             fields: [
               {
@@ -15075,7 +14880,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(fs12.readFileSync(target)) !== reference.digest)
         return failure2("permission_denied", "decision document bytes have changed");
     } catch {
       return failure2("invalid_input", "decision document is unavailable");
@@ -15980,7 +15785,7 @@ var judgeInputSummary = (raw) => {
 
 // packages/workit-core/src/autonomy.ts
 import os4 from "node:os";
-import path17 from "node:path";
+import path16 from "node:path";
 var accountHome = () => {
   try {
     return os4.userInfo().homedir;
@@ -15989,10 +15794,10 @@ var accountHome = () => {
   }
 };
 var grantsHome = { resolve: accountHome };
-var grantsDir = () => path17.join(grantsHome.resolve(), ".config", "workit");
+var grantsDir = () => path16.join(grantsHome.resolve(), ".config", "workit");
 var grantsOverride = () => {
-  const configured = path17.resolve(resolveConfigDir());
-  return configured === path17.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 ${path17.join(grantsDir(), "workspaces.json")}, so the D4 defaults apply`;
+  const configured = path16.resolve(resolveConfigDir());
+  return configured === path16.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 ${path16.join(grantsDir(), "workspaces.json")}, so the D4 defaults apply`;
 };
 var GRANT_KINDS = ["push", "pr", "merge", "release", "rerun"];
 var DEFAULT_GRANTS = Object.freeze({
@@ -18005,7 +17810,7 @@ function entryCompactContext(store, entry, session, context) {
     return null;
   const freshness = { mode: "signal", current: () => recentSignal(store.root) };
   const observed = task?.data.evidence.some(isObservedCheck) ?? false;
-  const files = (task?.data.decisions ?? []).flatMap((decision) => decision.data.binding.contentRefs.flatMap((ref) => ref.kind === "file" ? [path18.resolve(store.root, ref.path)] : []));
+  const files = (task?.data.decisions ?? []).flatMap((decision) => decision.data.binding.contentRefs.flatMap((ref) => ref.kind === "file" ? [path17.resolve(store.root, ref.path)] : []));
   const observedFiles = filesKey(files);
   const compact = new WorkitCore(store, context).compactContext(entry?.id ?? null, freshness, origin && { origin: origin.origin, taskId: origin.entry.id });
   if (!compact.ok || !compact.data)
@@ -18083,32 +17888,32 @@ var turnMarker = (input) => {
     if (location instanceof Error)
       return null;
     const session = [input.host, input.session.id, input.session.agentId ?? ""].join("\x00");
-    return path18.join(location.dir, "hooks", `turn-${digestOf(session).slice(0, 32)}.json`);
+    return path17.join(location.dir, "hooks", `turn-${digestOf(session).slice(0, 32)}.json`);
   } catch {
     return null;
   }
 };
 var writeTurnDigest = (file, digest) => {
   try {
-    fs14.mkdirSync(path18.dirname(file), { recursive: true });
-    fs14.writeFileSync(file, `${JSON.stringify({ digest })}
+    fs13.mkdirSync(path17.dirname(file), { recursive: true });
+    fs13.writeFileSync(file, `${JSON.stringify({ digest })}
 `);
   } catch {}
 };
 var clearTurnDigest = (file) => {
   try {
-    fs14.rmSync(file, { force: true });
+    fs13.rmSync(file, { force: true });
   } catch {}
 };
 var pruneTurnDigests = (dir, now) => {
   try {
-    for (const name of fs14.readdirSync(dir)) {
+    for (const name of fs13.readdirSync(dir)) {
       if (!name.startsWith("turn-"))
         continue;
-      const file = path18.join(dir, name);
+      const file = path17.join(dir, name);
       try {
-        if (now - fs14.statSync(file).mtimeMs > TURN_TTL_MS)
-          fs14.rmSync(file, { force: true });
+        if (now - fs13.statSync(file).mtimeMs > TURN_TTL_MS)
+          fs13.rmSync(file, { force: true });
       } catch {}
     }
   } catch {}
@@ -18124,7 +17929,7 @@ var changedTurnContext = (input, text) => {
     return text;
   const digest = digestOf(text);
   try {
-    const previous = JSON.parse(fs14.readFileSync(file, "utf8"));
+    const previous = JSON.parse(fs13.readFileSync(file, "utf8"));
     if (previous.digest === digest)
       return null;
   } catch {}
@@ -18135,23 +17940,23 @@ var seedTurnContext = (input, descriptor, text = turnContextText(input, descript
   const file = turnMarker(input);
   if (!file)
     return;
-  pruneTurnDigests(path18.dirname(file), Date.now());
+  pruneTurnDigests(path17.dirname(file), Date.now());
   if (text)
     writeTurnDigest(file, digestOf(text));
   else
     clearTurnDigest(file);
 };
 // packages/workit-core/src/core/route-intent.ts
-import { spawnSync as spawnSync12 } from "node:child_process";
+import { spawnSync as spawnSync11 } from "node:child_process";
 import { existsSync as existsSync6 } from "node:fs";
-import path21 from "node:path";
+import path20 from "node:path";
 
 // packages/workit-core/src/hooks/raw-git.ts
-import { spawnSync as spawnSync11 } from "node:child_process";
+import { spawnSync as spawnSync10 } from "node:child_process";
 import { createHash as createHash14 } from "node:crypto";
-import fs16 from "node:fs";
+import fs15 from "node:fs";
 import os5 from "node:os";
-import path20 from "node:path";
+import path19 from "node:path";
 
 // packages/workit-core/src/core/branch.ts
 import { createHash as createHash12 } from "node:crypto";
@@ -18363,8 +18168,8 @@ var globOf = (pattern) => pattern.source.replace(/^\^|\$$/gu, "").replaceAll(".*
 
 // packages/workit-core/src/hooks/session-marker.ts
 import { createHash as createHash13 } from "node:crypto";
-import fs15 from "node:fs";
-import path19 from "node:path";
+import fs14 from "node:fs";
+import path18 from "node:path";
 var sessionMarkerFile = (input, session, store) => {
   let dir = store;
   if (dir === undefined) {
@@ -18374,12 +18179,12 @@ var sessionMarkerFile = (input, session, store) => {
     dir = location.dir;
   }
   const name = createHash13("sha256").update(`${input.host}\x00${session}`).digest("hex").slice(0, 32);
-  return path19.join(dir, "hooks", `skills-${name}.json`);
+  return path18.join(dir, "hooks", `skills-${name}.json`);
 };
 var list2 = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 var readSessionMarker = (file) => {
   try {
-    const value = JSON.parse(fs15.readFileSync(file, "utf8"));
+    const value = JSON.parse(fs14.readFileSync(file, "utf8"));
     return { nudged: list2(value.nudged), loaded: list2(value.loaded), raw: list2(value.raw) };
   } catch {
     return { nudged: [], loaded: [], raw: [] };
@@ -18387,8 +18192,8 @@ var readSessionMarker = (file) => {
 };
 var writeSessionMarker = (file, marker) => {
   try {
-    fs15.mkdirSync(path19.dirname(file), { recursive: true });
-    fs15.writeFileSync(file, JSON.stringify(marker));
+    fs14.mkdirSync(path18.dirname(file), { recursive: true });
+    fs14.writeFileSync(file, JSON.stringify(marker));
   } catch {}
 };
 
@@ -18885,14 +18690,14 @@ var GIT_CONFIG_ENV = /^GIT_(?:CONFIG\w*|DIR|COMMON_DIR|WORK_TREE)$/;
 var ASSIGNMENT = /^([A-Za-z_]\w*)=([\s\S]*)$/;
 var MAX_DEPTH = 4;
 var MAX_EXPANSIONS = 16;
-var isAbsolute = (value) => path20.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
+var isAbsolute = (value) => path19.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
 var HERE = /^(?:\$PWD|\$\{PWD\}|\$\(\s*pwd\s*\)|`pwd`|\$\(\s*git\s+rev-parse\s+--show-toplevel\s*\))(?=$|[\\/])/;
 var joinDir = (base, raw) => {
   const next = raw.replace(HERE, ".");
   if (base === undefined || /[$`*?]/.test(next) || next === "-")
     return;
-  const expanded = next === "~" || next.startsWith("~/") ? path20.join(os5.homedir(), next.slice(1)) : next;
-  return base === null || isAbsolute(expanded) ? expanded : path20.join(base, expanded);
+  const expanded = next === "~" || next.startsWith("~/") ? path19.join(os5.homedir(), next.slice(1)) : next;
+  return base === null || isAbsolute(expanded) ? expanded : path19.join(base, expanded);
 };
 var rebase = (base, inner) => inner === null ? base : inner === undefined ? undefined : joinDir(base, inner);
 var cdTarget = (words) => {
@@ -19230,7 +19035,16 @@ function rawInvocations(command, dialect = "posix", depth = 0) {
   return found;
 }
 var RECENT = new Map;
-function walk2(command, dialect, depth) {
+function commandLines(command, dialect = "posix") {
+  const lines = [];
+  try {
+    walk2(command, dialect, 0, lines);
+  } catch (error) {
+    throw error instanceof ShellAnalysisError ? error : new ShellAnalysisError(error instanceof Error ? error.message : String(error));
+  }
+  return lines;
+}
+function walk2(command, dialect, depth, seen) {
   const found = [];
   let dir = null;
   const groups = [];
@@ -19241,7 +19055,8 @@ function walk2(command, dialect, depth) {
   const nested = (script, inner) => {
     if (!script || depth >= MAX_DEPTH)
       return;
-    for (const invocation of rawInvocations(script, inner, depth + 1))
+    const inside = seen ? walk2(script, inner, depth + 1, seen) : rawInvocations(script, inner, depth + 1);
+    for (const invocation of inside)
       found.push({ ...invocation, dir: rebase(dir, invocation.dir) });
   };
   const visit = (input, stdin, hops) => {
@@ -19253,11 +19068,17 @@ function walk2(command, dialect, depth) {
     const name = commandName(words[0]);
     if (!name)
       return;
+    seen?.push(words);
+    if (name === "-c" || name === "--command")
+      return nested(words[1], "posix");
     const runs = (lines) => {
       if (hops < MAX_DEPTH)
         for (const next of lines)
           visit(next, undefined, hops + 1);
     };
+    const wrapped = seen ? null : workitCheckTail(words);
+    if (wrapped)
+      return "script" in wrapped ? nested(wrapped.script, "posix") : runs([wrapped.argv]);
     if (CD.has(name)) {
       const target = cdTarget(words);
       dir = target === null ? os5.homedir() : joinDir(dir, target);
@@ -19348,6 +19169,51 @@ var LAUNCHERS = new Set([
   "command"
 ]);
 var WORKIT_BIN = /(?:^|[\\/])workit(?:\.exe)?$|^@brainervirus\/workit-cli$/;
+var WORKIT_PACKAGE = /^@brainervirus\/workit-cli(?:@\S*)?$/;
+var PACKAGE_RUNNERS = new Set(["npx", "bunx", "pnpx"]);
+function workitCheckTail(words) {
+  let at = 0;
+  if (PACKAGE_RUNNERS.has(commandName(words[0]))) {
+    at = words.findIndex((word, index) => index > 0 && !word.startsWith("-"));
+    if (at < 0 || !WORKIT_PACKAGE.test(words[at]))
+      return null;
+  } else if (!/^workit(?:\.exe|\.cmd)?$/.test(commandName(words[0])))
+    return null;
+  const args = words.slice(at + 1);
+  if (args[0] !== "check" && !(args[0] === "lock" && args[1] === "run"))
+    return null;
+  const split = args.indexOf("--");
+  const tail = split < 0 ? [] : args.slice(split + 1);
+  if (!tail.length)
+    return null;
+  return args.slice(0, split).includes("--shell") ? { script: tail.join(" ") } : { argv: tail };
+}
+function simpleCommand(command, dialect = "posix", depth = 0) {
+  let segments;
+  try {
+    segments = segmentsOf(command, dialect);
+  } catch {
+    return null;
+  }
+  if (segments.length !== 1)
+    return null;
+  const [segment] = segments;
+  if (segment.group || segment.pipe || segment.unanalyzable || segment.redirects.length || segment.subs?.length || segment.stdin?.length)
+    return null;
+  const { words } = stripPrefixes(segment.words);
+  const name = commandName(words[0]);
+  if (!name || depth >= MAX_DEPTH)
+    return null;
+  if (SHELLS.has(name)) {
+    const script = shellScript(words, undefined);
+    return script ? simpleCommand(script, "posix", depth + 1) : null;
+  }
+  if (name === "-c" || name === "--command")
+    return words[1] ? simpleCommand(words[1], "posix", depth + 1) : null;
+  if (EVALS.has(name) || POWERSHELLS.has(name) || ["xargs", "find", "parallel", "script", "cmd", "source", "."].includes(name))
+    return null;
+  return words;
+}
 function workitInvocations(command, dialect = "posix", depth = 0) {
   const found = [];
   for (const { words } of segmentsOf(command, dialect)) {
@@ -19643,7 +19509,7 @@ var repoAt = (dir) => {
   return { location, dir, branch: resolveTaskKey(dir, location).branch };
 };
 var isWorkitWorkspace = (repo) => {
-  if (fs16.existsSync(repo.location.dir))
+  if (fs15.existsSync(repo.location.dir))
     return true;
   try {
     return resolveRuntimeWorkspaceVcs(repo.location.top ?? repo.dir) !== null;
@@ -19664,17 +19530,17 @@ var headSha2 = (repo) => {
   if (!git || git.reftable)
     return null;
   try {
-    const head = fs16.readFileSync(path20.join(git.gitDir, "HEAD"), "utf8").trim();
+    const head = fs15.readFileSync(path19.join(git.gitDir, "HEAD"), "utf8").trim();
     if (/^[0-9a-f]{40,64}$/.test(head))
       return head;
     const ref = /^ref: (refs\/.+)$/.exec(head)?.[1];
     if (!ref)
       return null;
-    const common = path20.dirname(repo.location.dir);
+    const common = path19.dirname(repo.location.dir);
     try {
-      return fs16.readFileSync(path20.join(common, ref), "utf8").trim() || null;
+      return fs15.readFileSync(path19.join(common, ref), "utf8").trim() || null;
     } catch {}
-    const packed = fs16.readFileSync(path20.join(common, "packed-refs"), "utf8");
+    const packed = fs15.readFileSync(path19.join(common, "packed-refs"), "utf8");
     return new RegExp(`^([0-9a-f]{40,64}) ${ref.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`, "m").exec(packed)?.[1] ?? null;
   } catch {
     return null;
@@ -19686,7 +19552,7 @@ var gitConfig = (dir, invocation, cache) => {
   if (cached)
     return cached;
   const config = new Map;
-  const listed = spawnSync11("git", [...invocation.config ?? [], "config", "-z", "--list"], {
+  const listed = spawnSync10("git", [...invocation.config ?? [], "config", "-z", "--list"], {
     cwd: dir,
     encoding: "utf8",
     timeout: 3000,
@@ -19762,8 +19628,8 @@ var expandGitAliases = (root, invocation, cache = new Map, depth = 0) => {
   const sub = invocation.args[0];
   if (invocation.tool !== "git" || invocation.dir === undefined || !sub || sub.startsWith("-") || GIT_COMMANDS.has(sub) || depth >= MAX_DEPTH)
     return [invocation];
-  const dir = path20.resolve(root, invocation.dir ?? ".");
-  if (!fs16.existsSync(dir))
+  const dir = path19.resolve(root, invocation.dir ?? ".");
+  if (!fs15.existsSync(dir))
     return [invocation];
   const config = gitConfig(dir, invocation, cache);
   const alias = configValue(config, `alias.${sub.toLowerCase()}`);
@@ -19785,11 +19651,11 @@ var expandGitAliases = (root, invocation, cache = new Map, depth = 0) => {
 var normalizedUrl = (url, dir) => {
   const trimmed = url.trim();
   if (/^file:\/\//i.test(trimmed))
-    return path20.resolve(dir, trimmed.slice(7)).replace(/\/+$/, "").replace(/\.git$/, "");
+    return path19.resolve(dir, trimmed.slice(7)).replace(/\/+$/, "").replace(/\.git$/, "");
   const scheme = /^[a-z][a-z0-9+.-]*:\/\//i.exec(trimmed);
   const scp = !scheme && /^(?:[^@/\\]+@)?[^/\\:]{2,}:/.test(trimmed);
   if (!scheme && !scp)
-    return path20.resolve(dir, trimmed).replace(/\/+$/, "").replace(/\.git$/, "");
+    return path19.resolve(dir, trimmed).replace(/\/+$/, "").replace(/\.git$/, "");
   const value = scheme ? trimmed.slice(scheme[0].length).replace(/^[^@/]*@/, "").replace(/^([^/:]+):\d+(?=\/)/, "$1") : trimmed.replace(/^[^@/]*@/, "").replace(":", "/");
   return value.toLowerCase().replace(/\/{2,}/g, "/").replace(/^www\./, "").replace(/\/+$/, "").replace(/\.git$/, "");
 };
@@ -19850,7 +19716,7 @@ var refusal = (action, branch, dir) => {
 };
 var refFacts = (repo, remote) => {
   const facts = { heads: new Set, tags: new Set, remoteHeads: new Set };
-  const listed = spawnSync11("git", ["for-each-ref", "--format=%(refname)", "refs/heads", "refs/tags", `refs/remotes/${remote}`], { cwd: repo.dir, encoding: "utf8", timeout: 5000 });
+  const listed = spawnSync10("git", ["for-each-ref", "--format=%(refname)", "refs/heads", "refs/tags", `refs/remotes/${remote}`], { cwd: repo.dir, encoding: "utf8", timeout: 5000 });
   const remotePrefix = `refs/remotes/${remote}/`;
   for (const ref of (listed.stdout ?? "").split(`
 `)) {
@@ -19867,7 +19733,7 @@ var globBranches = (repo, glob) => {
   const source = glob.source.startsWith("refs/") ? glob.source : `refs/heads/${glob.source}`;
   const [sourcePrefix, sourceSuffix = ""] = source.split("*");
   const [destinationPrefix, destinationSuffix = ""] = glob.destination.split("*");
-  const listed = spawnSync11("git", [
+  const listed = spawnSync10("git", [
     "for-each-ref",
     "--format=%(refname)",
     sourcePrefix.slice(0, sourcePrefix.lastIndexOf("/") + 1)
@@ -19944,7 +19810,7 @@ var tagRefusal = (action, facts, dir) => {
   return `workit: raw ${quote(`git push${action.allTags ? " --tags" : ""}`)} of ${tags.length ? `tag ${tags.join(", ")}` : "tags"} bypasses the release grant. Push a release tag with ${quote(`workit git push --release ${named}`)} (${shape} tags whose commit the production branch already has; a tag never moves), under the ${quote("release")} grant (if refused, ask the user to run ${quote("workit grant set <workspace> release=true")}).`;
 };
 var remoteHeads = (repo, remote) => {
-  const listed = spawnSync11("git", ["ls-remote", "--heads", remote], {
+  const listed = spawnSync10("git", ["ls-remote", "--heads", remote], {
     cwd: repo.dir,
     encoding: "utf8",
     timeout: 3000,
@@ -20013,7 +19879,7 @@ var actionsIn = (cwd, command, dialect, cache = new Map) => {
   const out = [];
   const repos = new Map;
   const repoFor = (relative) => {
-    const dir = path20.resolve(cwd, relative ?? ".");
+    const dir = path19.resolve(cwd, relative ?? ".");
     if (!repos.has(dir)) {
       const repo = repoAt(dir);
       repos.set(dir, repo && isWorkitWorkspace(repo) ? repo : null);
@@ -20099,7 +19965,7 @@ var analysisDenial = (error) => ({
 });
 var NEXT_COMMAND = "next";
 var MARKER_TTL_SECONDS = 3600;
-var markerFile = (repo, session, key) => path20.join(repo.location.dir, "hooks", `commit-${createHash14("sha256").update(`${session}\x00${key}`).digest("hex").slice(0, 32)}.json`);
+var markerFile = (repo, session, key) => path19.join(repo.location.dir, "hooks", `commit-${createHash14("sha256").update(`${session}\x00${key}`).digest("hex").slice(0, 32)}.json`);
 var callKey = (toolUseId, command) => toolUseId ?? `cmd:${createHash14("sha256").update(command).digest("hex")}`;
 function noteRawCommit(input, command, key) {
   try {
@@ -20110,14 +19976,14 @@ function noteRawCommit(input, command, key) {
       if (action.kind !== "commit")
         continue;
       const file = markerFile(repo, input.session.id, key);
-      fs16.mkdirSync(path20.dirname(file), { recursive: true });
-      fs16.writeFileSync(file, `${JSON.stringify({ head: headSha2(repo), at })}
+      fs15.mkdirSync(path19.dirname(file), { recursive: true });
+      fs15.writeFileSync(file, `${JSON.stringify({ head: headSha2(repo), at })}
 `);
     }
   } catch {}
 }
 var headCommit = (dir) => {
-  const run = spawnSync11("git", [
+  const run = spawnSync10("git", [
     "log",
     "-1",
     "--format=%H%x1f%ct%x1f%s%x1f%(trailers:key=Workit-Session,valueonly,separator=%x2c)"
@@ -20134,11 +20000,11 @@ var headCommit = (dir) => {
 var settle2 = (input, repo, file) => {
   let marker;
   try {
-    marker = JSON.parse(fs16.readFileSync(file, "utf8"));
+    marker = JSON.parse(fs15.readFileSync(file, "utf8"));
   } catch {
     return;
   }
-  fs16.rmSync(file, { force: true });
+  fs15.rmSync(file, { force: true });
   const session = input.session.id;
   const now = Date.now() / 1000;
   if (typeof marker.at !== "number" || now - marker.at > MARKER_TTL_SECONDS)
@@ -20187,7 +20053,7 @@ function settlePendingCommit(input) {
     if (!repo)
       return;
     const file = markerFile(repo, input.session.id, NEXT_COMMAND);
-    if (fs16.existsSync(file))
+    if (fs15.existsSync(file))
       settle2(input, repo, file);
   } catch {}
 }
@@ -20331,7 +20197,7 @@ var targetsOf = (invocations) => invocations.flatMap((invocation) => invocation.
   branch,
   dir: invocation.dir
 })) : []);
-var localBranchExists = (dir, branch) => spawnSync12("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], {
+var localBranchExists = (dir, branch) => spawnSync11("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], {
   cwd: dir,
   stdio: "ignore",
   timeout: 5000
@@ -20341,7 +20207,7 @@ var judgedDir = (root, dir) => {
     return null;
   if (dir === null)
     return root;
-  const resolved = path21.resolve(root, dir);
+  const resolved = path20.resolve(root, dir);
   return existsSync6(resolved) && inWorkitWorkspace(resolved) ? resolved : null;
 };
 var shellBranchPolicyViolation = (root, command, dialect = "posix") => {
@@ -20375,22 +20241,771 @@ var shellPolicy = (cwd, command, dialect = "posix") => {
   }
   return policy && !policy.ok ? { kind: "deny", reason: `branch_policy_denied: ${policy.error}`, unblock: null } : { kind: "none" };
 };
+// packages/workit-core/src/core/heavy-rules.ts
+import fs16 from "node:fs";
+import os6 from "node:os";
+import path21 from "node:path";
+var EMPTY = () => ({ deny: [], allow: [] });
+var readText2 = (file) => {
+  try {
+    return fs16.readFileSync(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+};
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function parseJsonc(text) {
+  let out = "";
+  for (let index = 0;index < text.length; index += 1) {
+    const char = text[index];
+    if (char === '"') {
+      const end = /"(?:[^"\\]|\\.)*"/y;
+      end.lastIndex = index;
+      const match = end.exec(text);
+      if (!match)
+        throw new Error("unterminated string");
+      out += match[0];
+      index += match[0].length - 1;
+    } else if (char === "/" && text[index + 1] === "/") {
+      while (index < text.length && text[index] !== `
+`)
+        index += 1;
+      out += `
+`;
+    } else if (char === "/" && text[index + 1] === "*") {
+      const close = text.indexOf("*/", index + 2);
+      if (close < 0)
+        throw new Error("unterminated comment");
+      index = close + 1;
+    } else
+      out += char;
+  }
+  return JSON.parse(out.replace(/,(\s*[}\]])/gu, "$1"));
+}
+function gitTop(cwd) {
+  for (let dir = path21.resolve(cwd);; dir = path21.dirname(dir)) {
+    if (fs16.existsSync(path21.join(dir, ".git")))
+      return dir;
+    if (path21.dirname(dir) === dir)
+      return null;
+  }
+}
+var projectDirs = (cwd) => {
+  const top = gitTop(cwd);
+  const dirs = [];
+  for (let dir = path21.resolve(cwd);; dir = path21.dirname(dir)) {
+    dirs.push(dir);
+    if (!top || dir === top || path21.dirname(dir) === dir)
+      return dirs;
+  }
+};
+var homeOf = (env) => env.HOME || os6.homedir();
+var CLAUDE_MANAGED = {
+  linux: "/etc/claude-code/managed-settings.json",
+  darwin: "/Library/Application Support/ClaudeCode/managed-settings.json",
+  win32: "C:\\Program Files\\ClaudeCode\\managed-settings.json"
+};
+function claudeSettingsFiles(cwd, env, platform = process.platform) {
+  const project = env.CLAUDE_PROJECT_DIR || gitTop(cwd) || cwd;
+  const user = env.CLAUDE_CONFIG_DIR || path21.join(homeOf(env), ".claude");
+  return [
+    ...CLAUDE_MANAGED[platform] ? [CLAUDE_MANAGED[platform]] : [],
+    path21.join(user, "settings.json"),
+    path21.join(project, ".claude", "settings.json"),
+    path21.join(project, ".claude", "settings.local.json")
+  ];
+}
+var bashPattern = (entry) => {
+  const match = /^Bash(?:\((.*)\))?$/su.exec(entry.trim());
+  return match ? match[1] ?? "" : null;
+};
+function claudeRules(cwd, env = process.env) {
+  const rules = EMPTY();
+  try {
+    for (const file of claudeSettingsFiles(cwd, env)) {
+      const text = readText2(file);
+      if (text === null)
+        continue;
+      const value = JSON.parse(text);
+      if (!isRecord3(value))
+        return "unreadable";
+      const permissions = value.permissions;
+      if (permissions === undefined)
+        continue;
+      if (!isRecord3(permissions))
+        return "unreadable";
+      for (const [key, bucket] of [
+        ["deny", rules.deny],
+        ["ask", rules.deny],
+        ["allow", rules.allow]
+      ]) {
+        const list = permissions[key];
+        if (list === undefined)
+          continue;
+        if (!Array.isArray(list))
+          return "unreadable";
+        for (const entry of list) {
+          if (typeof entry !== "string")
+            return "unreadable";
+          const pattern = bashPattern(entry);
+          if (pattern !== null)
+            bucket.push(pattern);
+        }
+      }
+    }
+  } catch {
+    return "unreadable";
+  }
+  return rules;
+}
+var OPENCODE_NAMES = ["opencode.json", "opencode.jsonc"];
+var opencodePermission = (permission, rules) => {
+  if (permission === undefined)
+    return true;
+  if (typeof permission === "string") {
+    (permission === "allow" ? rules.allow : rules.deny).push("");
+    return ["allow", "ask", "deny"].includes(permission);
+  }
+  if (!isRecord3(permission))
+    return false;
+  for (const key of ["bash", "shell"]) {
+    const value = permission[key];
+    if (value === undefined)
+      continue;
+    if (typeof value === "string") {
+      if (!["allow", "ask", "deny"].includes(value))
+        return false;
+      (value === "allow" ? rules.allow : rules.deny).push("");
+      continue;
+    }
+    if (!isRecord3(value))
+      return false;
+    for (const [pattern, action] of Object.entries(value)) {
+      if (action !== "allow" && action !== "ask" && action !== "deny")
+        return false;
+      (action === "allow" ? rules.allow : rules.deny).push(pattern);
+    }
+  }
+  return true;
+};
+var opencodeConfig = (value, rules) => {
+  if (!isRecord3(value))
+    return false;
+  if (!opencodePermission(value.permission, rules))
+    return false;
+  if (value.agent === undefined)
+    return true;
+  if (!isRecord3(value.agent))
+    return false;
+  return Object.values(value.agent).every((agent) => isRecord3(agent) && opencodePermission(agent.permission, rules));
+};
+function opencodeRules(cwd, env = process.env) {
+  const rules = EMPTY();
+  try {
+    const config = env.XDG_CONFIG_HOME || path21.join(homeOf(env), ".config");
+    const files = [
+      ...OPENCODE_NAMES.map((name) => path21.join(config, "opencode", name)),
+      ...projectDirs(cwd).flatMap((dir) => OPENCODE_NAMES.flatMap((name) => [path21.join(dir, name), path21.join(dir, ".opencode", name)])),
+      ...env.OPENCODE_CONFIG ? [env.OPENCODE_CONFIG] : []
+    ];
+    for (const file of files) {
+      const text = readText2(file);
+      if (text !== null && !opencodeConfig(parseJsonc(text), rules))
+        return "unreadable";
+    }
+    if (env.OPENCODE_CONFIG_CONTENT && !opencodeConfig(parseJsonc(env.OPENCODE_CONFIG_CONTENT), rules))
+      return "unreadable";
+  } catch {
+    return "unreadable";
+  }
+  return rules;
+}
+var codexRule = (body) => {
+  const open = /\bpattern\s*=\s*\[/u.exec(body);
+  if (!open)
+    return null;
+  const words = [];
+  let index = open.index + open[0].length;
+  for (;; ) {
+    while (/[\s,]/u.test(body[index] ?? ""))
+      index += 1;
+    if (body[index] === "]")
+      break;
+    if (body[index] !== '"')
+      return null;
+    const literal = /"((?:[^"\\]|\\.)*)"/y;
+    literal.lastIndex = index;
+    const match = literal.exec(body);
+    if (!match)
+      return null;
+    words.push(JSON.parse(`"${match[1]}"`));
+    index = literal.lastIndex;
+  }
+  const decision = /\bdecision\s*=\s*"(\w+)"/u.exec(body)?.[1];
+  if (!words.length || !decision || !["allow", "prompt", "forbidden"].includes(decision))
+    return null;
+  return { pattern: words.join(" "), decision };
+};
+function codexRules(cwd, env = process.env) {
+  const rules = EMPTY();
+  try {
+    const home = env.CODEX_HOME || path21.join(homeOf(env), ".codex");
+    const top = gitTop(cwd) ?? cwd;
+    for (const dir of [path21.join(home, "rules"), path21.join(top, ".codex", "rules")]) {
+      let files;
+      try {
+        files = fs16.readdirSync(dir).filter((name) => name.endsWith(".rules"));
+      } catch (error) {
+        if (error.code === "ENOENT")
+          continue;
+        return "unreadable";
+      }
+      for (const name of files) {
+        const text = readText2(path21.join(dir, name)) ?? "";
+        for (const part of text.split(/\bprefix_rule\s*\(/u).slice(1)) {
+          const rule = codexRule(part);
+          if (!rule)
+            return "unreadable";
+          (rule.decision === "allow" ? rules.allow : rules.deny).push(rule.pattern);
+        }
+      }
+    }
+  } catch {
+    return "unreadable";
+  }
+  return rules;
+}
+function cursorRules(cwd, env = process.env) {
+  const rules = EMPTY();
+  try {
+    const top = gitTop(cwd) ?? cwd;
+    for (const file of [
+      path21.join(homeOf(env), ".cursor", "cli-config.json"),
+      path21.join(top, ".cursor", "cli.json")
+    ]) {
+      const text = readText2(file);
+      if (text === null)
+        continue;
+      const value = JSON.parse(text);
+      if (!isRecord3(value))
+        return "unreadable";
+      if (value.permissions === undefined)
+        continue;
+      if (!isRecord3(value.permissions))
+        return "unreadable";
+      for (const [key, bucket] of [
+        ["deny", rules.deny],
+        ["allow", rules.allow]
+      ]) {
+        const list = value.permissions[key];
+        if (list === undefined)
+          continue;
+        if (!Array.isArray(list))
+          return "unreadable";
+        for (const entry of list) {
+          if (typeof entry !== "string")
+            return "unreadable";
+          const match = /^Shell(?:\((.*)\))?$/su.exec(entry.trim());
+          if (match)
+            bucket.push(match[1] ?? "");
+        }
+      }
+    }
+  } catch {
+    return "unreadable";
+  }
+  return rules;
+}
+var baseName = (word) => (word.split(/[\\/]/u).at(-1) ?? "").toLowerCase().replace(/\.(?:exe|cmd|bat)$/u, "");
+var firstToken = (pattern) => pattern.trim().split(/[:\s]/u)[0] ?? "";
+function names(pattern, words) {
+  const token = firstToken(pattern);
+  if (!token || token === "*" || token.includes("*"))
+    return true;
+  const wanted = baseName(token);
+  return words.some((word) => baseName(word) === wanted);
+}
+var literalPrefix = (pattern) => pattern.trim().replace(/(?::\*| \*|\*)$/u, "");
+var coversWrapper = (pattern) => {
+  const token = firstToken(pattern);
+  if (!token || token.includes("*"))
+    return true;
+  const words = literalPrefix(pattern).split(/\s+/u);
+  if (baseName(words[0]) !== "workit")
+    return false;
+  return ["check", "--heavy"].slice(0, words.length - 1).every((word, at) => {
+    const given = words[at + 1];
+    return given === word || word.startsWith(given);
+  });
+};
+var coversCommand = (pattern, command) => {
+  const prefix = literalPrefix(pattern);
+  if (!prefix)
+    return true;
+  return !prefix.includes("*") && command.trim().startsWith(prefix);
+};
+function wrapAllowed(read, words, command, options = {}) {
+  if (read === "unreadable")
+    return { ok: false, why: "named" };
+  if (read.deny.some((pattern) => names(pattern, words)))
+    return { ok: false, why: "named" };
+  if (!options.bypass && read.allow.some(coversWrapper) && !read.allow.some((pattern) => coversCommand(pattern, command)))
+    return { ok: false, why: "allowlisted" };
+  return { ok: true };
+}
+
+// packages/workit-core/src/core/heavy.ts
+import fs17 from "node:fs";
+import os7 from "node:os";
+import path22 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 path22.join(env.XDG_STATE_HOME, "workit");
+  const home = env.HOME || os7.homedir();
+  if (platform === "darwin")
+    return path22.join(home, "Library", "Application Support", "workit");
+  if (platform === "win32")
+    return path22.join(env.LOCALAPPDATA ?? path22.join(home, "AppData", "Local"), "workit");
+  return path22.join(home, ".local", "state", "workit");
+}
+var HEAVY_COMMANDS_FILE = "heavy-commands.json";
+var heavyCommandsFile = (env) => path22.join(stateDir(env), HEAVY_COMMANDS_FILE);
+var HEAVY_SCRIPT = /^(?:test|tests|t|tst|unit|integration|e2e|coverage|cov|lint|eslint|typecheck|type-check|types|tsc|check|verify|validate|build|compile|bundle|ci|sonar|cypress|playwright|jest|vitest|mocha|bench|benchmark|all)(?:$|[:_.-])/iu;
+var INFO_FLAGS = new Set(["--version", "-v", "-V", "--help", "-h", "help", "version"]);
+var WATCH_FLAG = /^(?:--watch(?:All)?(?:=.*)?|-w|--serve)$/u;
+var WATCH_SCRIPT = /(?:^|[:_.-])(?:watch|dev|serve|start|storybook)(?:$|[:_.-])/iu;
+var sub = (...names) => new Set(names);
+var TOOLS = {
+  jest: "any",
+  vitest: "any",
+  mocha: "any",
+  ava: "any",
+  tap: "any",
+  karma: "any",
+  jasmine: "any",
+  nyc: "any",
+  c8: "any",
+  tsc: "any",
+  "vue-tsc": "any",
+  "svelte-check": "any",
+  eslint: "any",
+  stylelint: "any",
+  tslint: "any",
+  webpack: "any",
+  "webpack-cli": "any",
+  rollup: "any",
+  parcel: "any",
+  tsup: "any",
+  vite: sub("build", "optimize"),
+  next: sub("build", "lint"),
+  nuxt: sub("build", "generate"),
+  nuxi: sub("build", "generate"),
+  astro: sub("build", "check"),
+  ng: sub("build", "b", "test", "t", "e2e", "lint"),
+  "react-scripts": sub("build", "test"),
+  playwright: sub("test", "install"),
+  cypress: sub("run"),
+  wdio: "any",
+  testcafe: "any",
+  turbo: "any",
+  lerna: sub("run", "exec", "bootstrap"),
+  "sonar-scanner": "any",
+  sonarless: sub("scan"),
+  "sonarless-mcp": sub("scan"),
+  go: sub("test", "build", "vet", "install", "generate"),
+  "golangci-lint": sub("run"),
+  gotestsum: "any",
+  staticcheck: "any",
+  cargo: sub("build", "b", "test", "t", "check", "c", "clippy", "bench", "nextest", "doc", "install", "tarpaulin", "llvm-cov"),
+  mvn: "any",
+  mvnw: "any",
+  gradle: "any",
+  gradlew: "any",
+  ant: "any",
+  sbt: "any",
+  bazel: sub("build", "test", "run", "coverage"),
+  bazelisk: sub("build", "test", "run", "coverage"),
+  buck2: sub("build", "test", "run"),
+  dotnet: sub("build", "test", "publish", "restore", "pack", "msbuild"),
+  msbuild: "any",
+  pytest: "any",
+  "py.test": "any",
+  tox: "any",
+  nox: "any",
+  mypy: "any",
+  pyright: "any",
+  pylint: "any",
+  coverage: sub("run"),
+  maturin: sub("build", "develop"),
+  pip: sub("install", "wheel"),
+  pip3: sub("install", "wheel"),
+  rspec: "any",
+  rails: sub("test", "assets:precompile"),
+  phpunit: "any",
+  pest: "any",
+  phpstan: "any",
+  psalm: "any",
+  composer: sub("install", "update", "require", "test"),
+  mix: sub("test", "compile", "deps.get", "dialyzer", "credo"),
+  swift: sub("build", "test"),
+  xcodebuild: "any",
+  flutter: sub("build", "test"),
+  dart: sub("test", "compile"),
+  pod: sub("install"),
+  cmake: sub("--build"),
+  ninja: "any",
+  meson: sub("compile", "test"),
+  ctest: "any",
+  scons: "any",
+  "docker-compose": sub("build"),
+  buildah: sub("bud", "build"),
+  earthly: "any"
+};
+var PM_VALUES = new Set([
+  "--prefix",
+  "-w",
+  "--workspace",
+  "-C",
+  "--dir",
+  "--filter",
+  "-F",
+  "--cwd",
+  "-p",
+  "--package",
+  "--cache",
+  "--registry"
+]);
+function positional2(words, from, values = PM_VALUES) {
+  let index = from;
+  while (index < words.length && words[index].startsWith("-")) {
+    if (words[index] === "--")
+      return index + 1;
+    index += values.has(words[index]) ? 2 : 1;
+  }
+  return index;
+}
+var baseName2 = (word) => (word?.split(/[\\/]/u).at(-1) ?? "").toLowerCase().replace(/\.(?:exe|cmd|bat|ps1)$/u, "");
+var WORKIT = /^(?:workit|@brainervirus\/workit-cli(?:@.*)?)$/u;
+var PYTHONS = /^(?:python[\d.]*|py)$/u;
+var NPM_INSTALL = new Set([
+  "ci",
+  "clean-install",
+  "cit",
+  "install-test",
+  "it",
+  "install",
+  "i",
+  "in",
+  "add",
+  "rebuild",
+  "update",
+  "up"
+]);
+var NPM_RUN = new Set(["run", "run-script", "rum", "urn"]);
+var NPM_TEST = new Set(["test", "t", "tst"]);
+var EXEC = new Set(["exec", "x", "dlx"]);
+function builtIn(words, depth = 0) {
+  if (depth > 6 || !words.length)
+    return null;
+  const name = baseName2(words[0]);
+  const label = () => words.slice(0, 3).join(" ");
+  const inner = (from) => builtIn(words.slice(from), depth + 1);
+  if (WORKIT.test(name))
+    return null;
+  if (INFO_FLAGS.has(words[1] ?? "") && words.length === 2)
+    return null;
+  if (words.some((word) => word === "--watch" || word.startsWith("--watch=") || word === "--watchAll"))
+    return null;
+  if (name === "npx" || name === "bunx" || name === "pnpx")
+    return inner(positional2(words, 1));
+  if (name === "corepack")
+    return inner(1);
+  if (name === "npm" || name === "pnpm" || name === "yarn" || name === "bun" || name === "deno") {
+    const at = positional2(words, 1);
+    const command = words[at];
+    if (command === undefined)
+      return name === "yarn" ? "yarn (install)" : null;
+    if (name === "deno") {
+      if (["test", "bench", "check", "compile", "lint"].includes(command))
+        return label();
+      if (command === "task" && HEAVY_SCRIPT.test(words[at + 1] ?? ""))
+        return label();
+      return null;
+    }
+    if (NPM_INSTALL.has(command) || NPM_TEST.has(command))
+      return label();
+    if (name === "bun" && command === "build")
+      return label();
+    if (EXEC.has(command))
+      return inner(positional2(words, at + 1));
+    if (name === "yarn" && command === "workspace")
+      return inner(at + 2);
+    if (name === "yarn" && command === "workspaces")
+      return words.slice(at + 1).some((word) => HEAVY_SCRIPT.test(word)) ? label() : null;
+    if (NPM_RUN.has(command)) {
+      const script = words[positional2(words, at + 1)];
+      if (script === undefined || WATCH_SCRIPT.test(script))
+        return null;
+      if (HEAVY_SCRIPT.test(script))
+        return label();
+      return name === "bun" ? inner(positional2(words, at + 1)) : null;
+    }
+    if (name === "npm")
+      return null;
+    if (WATCH_SCRIPT.test(command))
+      return null;
+    if (HEAVY_SCRIPT.test(command) && !/\.[cm]?[jt]sx?$/u.test(command))
+      return label();
+    return inner(at);
+  }
+  if (PYTHONS.test(name)) {
+    const at = words.indexOf("-m");
+    return at > 0 && words[at + 1] ? inner(at + 1) : null;
+  }
+  if (["uv", "poetry", "pdm", "pipenv", "hatch", "rye"].includes(name)) {
+    const at = positional2(words, 1);
+    const command = words[at];
+    if (command === "run")
+      return inner(positional2(words, at + 1));
+    if (command === "pip")
+      return inner(at);
+    return ["sync", "install", "build", "test", "add"].includes(command ?? "") ? label() : null;
+  }
+  if (name === "bundle") {
+    const command = words[positional2(words, 1)];
+    if (command === "exec")
+      return inner(positional2(words, 2));
+    return command === "install" || command === undefined ? label() : null;
+  }
+  if (name === "make" || name === "gmake") {
+    const targets = words.slice(1).filter((word) => !word.startsWith("-") && !word.includes("="));
+    if (targets.some((target) => WATCH_SCRIPT.test(target)))
+      return null;
+    return !targets.length || targets.some((target) => HEAVY_SCRIPT.test(target)) ? label() : null;
+  }
+  if (name === "rake") {
+    const targets = words.slice(1).filter((word) => !word.startsWith("-") && !word.includes("="));
+    return targets.some((target) => HEAVY_SCRIPT.test(target) || /^spec(?:$|:)/u.test(target)) ? label() : null;
+  }
+  if (name === "nx") {
+    const at = positional2(words, 1);
+    const command = words[at] ?? "";
+    if (["run-many", "affected"].includes(command))
+      return words.some((word) => /^(?:-t|--targets?)(?:=|$)/u.test(word)) && !words.some((word) => WATCH_SCRIPT.test(word.replace(/^--?targets?=/u, ""))) ? label() : null;
+    if (command === "run") {
+      const target = (words[at + 1] ?? "").split(":")[1] ?? "";
+      return HEAVY_SCRIPT.test(target) && !WATCH_SCRIPT.test(target) ? label() : null;
+    }
+    return HEAVY_SCRIPT.test(command) && !WATCH_SCRIPT.test(command) ? label() : null;
+  }
+  if (name === "docker" || name === "podman" || name === "nerdctl") {
+    const at = positional2(words, 1, new Set(["-H", "--host", "--context", "-c", "--config"]));
+    const command = words[at];
+    if (command === "build")
+      return label();
+    if (command === "buildx" || command === "image" || command === "builder")
+      return words[positional2(words, at + 1)] === "build" ? label() : null;
+    if (command === "compose") {
+      const at2 = positional2(words, at + 1, new Set(["-f", "--file", "-p"]));
+      const action = words[at2];
+      if (action === "build")
+        return label();
+      return action === "up" && words.slice(at2 + 1).includes("--build") ? label() : null;
+    }
+    return null;
+  }
+  const rule = TOOLS[name];
+  if (!rule)
+    return null;
+  if (words.slice(1).some((word) => WATCH_FLAG.test(word) || word === "watch" || word === "dev"))
+    return null;
+  if (rule === "any")
+    return label();
+  const command = words.slice(1).find((word) => !word.startsWith("-") && !word.startsWith("+") || rule.has(word));
+  return command !== undefined && rule.has(command) ? label() : null;
+}
+var globWord = (word) => new RegExp(`^${word.replace(/[.+?^${}()|[\]\\]/gu, "\\$&").replaceAll("*", ".*")}$`, "u");
+function parsePattern(pattern) {
+  const words = pattern.trim().split(/\s+/u).filter(Boolean);
+  return words.length ? words.map(globWord) : null;
+}
+var matches = (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]));
+var readJson = (file) => {
+  try {
+    return JSON.parse(fs17.readFileSync(file, "utf8"));
+  } catch {
+    return;
+  }
+};
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var stringList = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+function machinePatterns(env) {
+  const value = readJson(heavyCommandsFile(env));
+  return isRecord4(value) ? stringList(value.patterns) : [];
+}
+function repoPatterns(cwd) {
+  return repoHeavyCommands(gitTop(cwd) ?? path22.resolve(cwd));
+}
+function heavyLines(lines, options) {
+  const found = [];
+  let patterns = null;
+  for (const line of lines) {
+    const reason = builtIn(line);
+    if (reason) {
+      found.push({ line, source: "catalog", reason });
+      continue;
+    }
+    patterns ??= (options.patterns ?? [
+      ...machinePatterns(options.env ?? process.env).map((pattern) => ({
+        pattern,
+        from: "machine"
+      })),
+      ...repoPatterns(options.cwd).map((pattern) => ({ pattern, from: "repo" }))
+    ]).flatMap((entry) => {
+      const matchers = parsePattern(entry.pattern);
+      return matchers ? [{ ...entry, matchers }] : [];
+    });
+    const hit = patterns.find((entry) => matches(entry.matchers, line));
+    if (hit)
+      found.push({
+        line,
+        source: { pattern: hit.pattern, from: hit.from },
+        reason: `${hit.from} pattern "${hit.pattern}"`
+      });
+  }
+  return found;
+}
+var linesOf = (command, dialect) => {
+  try {
+    return commandLines(command, dialect);
+  } catch {
+    return null;
+  }
+};
+var quoteWord = (word) => /^[\w@%+=:,./-]+$/u.test(word) ? word : `'${word.replaceAll("'", `'\\''`)}'`;
+var leaseCommand = (words) => `workit check --heavy -- ${words.map(quoteWord).join(" ")}`;
+function heavyPlan(command, options) {
+  const dialect = options.dialect ?? "posix";
+  if (dialect !== "posix" || !gitTop(options.cwd))
+    return { kind: "none" };
+  const lines = linesOf(command, dialect);
+  if (!lines)
+    return { kind: "none" };
+  const heavy = heavyLines(lines, options);
+  if (!heavy.length)
+    return { kind: "none" };
+  const simple = simpleCommand(command, dialect);
+  const single = simple && !WORKIT.test(baseName2(simple[0])) && heavyLines([simple], options)[0];
+  const judged = single ? [{ words: lines.flat(), text: command }] : heavy.map((match) => ({
+    words: match.line,
+    text: match.line.join(" ")
+  }));
+  if (options.rules !== null)
+    for (const { words, text } of judged) {
+      const verdict = wrapAllowed(options.rules, words, text, { bypass: options.bypass });
+      if (!verdict.ok)
+        return {
+          kind: "passthrough",
+          note: `workit: \`${command.trim()}\` is heavy but runs outside the heavy-check lease because a host permission rule names it (or \`workit\` is allowlisted); the host decides.`
+        };
+    }
+  if (single) {
+    const rewrite = leaseRewrite(command);
+    return rewrite ? { kind: "rewrite", command: rewrite, reason: single.reason } : { kind: "none" };
+  }
+  const parts = heavy.map((match) => leaseCommand(match.line));
+  return {
+    kind: "split",
+    reason: `heavy_command: \`${command.trim()}\` chains heavy work (${heavy.map((match) => match.reason).join("; ")}) with other commands, and a chain cannot run under the machine-wide heavy-check lease. Run each heavy part alone as \`workit check --heavy -- <segment>\` (here: ${parts.map((part) => `\`${part}\``).join("; ")}); run the other parts as their own commands.`,
+    unblock: parts[0] ?? null
+  };
+}
+function workitOnPath(env = process.env) {
+  const names = process.platform === "win32" ? ["workit.exe", "workit.cmd", "workit"] : ["workit"];
+  for (const dir of (env.PATH ?? "").split(path22.delimiter))
+    for (const name of names) {
+      if (!dir)
+        continue;
+      try {
+        fs17.accessSync(path22.join(dir, name), fs17.constants.X_OK);
+        return true;
+      } catch {}
+    }
+  return false;
+}
+var ASSIGNMENTS = /^\s*((?:[A-Za-z_]\w*=(?:'[^']*'|"(?:[^"\\]|\\.)*"|[^\s'"])*\s+)*)/u;
+function leaseRewrite(command) {
+  const text = command.trim();
+  const prefix = ASSIGNMENTS.exec(text)?.[1] ?? "";
+  const rest = text.slice(prefix.length).trim();
+  if (!rest)
+    return null;
+  return `${prefix}workit check --heavy -- ${rest}`;
+}
+
+// packages/workit-core/src/hooks/heavy-gate.ts
+var rulesFor = (host, cwd, env) => {
+  switch (host) {
+    case "claude_code":
+      return claudeRules(cwd, env);
+    case "opencode":
+      return opencodeRules(cwd, env);
+    case "codex_cli":
+    case "codex_desktop":
+      return codexRules(cwd, env);
+    case "cursor":
+      return cursorRules(cwd, env);
+    case "pi":
+      return null;
+  }
+};
+function heavyGate(cwd, command, options) {
+  const env = options.env ?? process.env;
+  try {
+    if (env.WORKIT_HEAVY_GATE === "0" || !maybeHeavy(command, cwd, env) || !workitOnPath(env))
+      return { kind: "none" };
+    return heavyPlan(command, {
+      cwd,
+      env,
+      dialect: options.dialect ?? "posix",
+      rules: rulesFor(options.host, cwd, env),
+      bypass: options.permissionMode === "bypassPermissions"
+    });
+  } catch {
+    return { kind: "none" };
+  }
+}
+var rewriteNote = (plan) => `workit: this heavy command (${plan.reason}) runs under the machine-wide heavy-check lease as \`${plan.command}\`: it waits while another heavy check holds the lease (\`workit lock status\` shows who). Run heavy commands that way yourself; \`workit help lock\` explains the lease.`;
+var heavyDenial = (original, plan) => ({
+  kind: "deny",
+  reason: `heavy_command: \`${original.trim()}\` is heavy (${plan.reason}) and must run under the machine-wide heavy-check lease, so parallel agents cannot exhaust this machine's memory and CPU. Run exactly: ${plan.command}`,
+  unblock: plan.command
+});
+var splitDenial = (plan) => ({
+  kind: "deny",
+  reason: plan.reason,
+  unblock: plan.unblock
+});
 // packages/workit-core/src/hooks/write-gate.ts
 import { realpathSync as realpathSync5 } from "node:fs";
-import os7 from "node:os";
-import path23 from "node:path";
+import os9 from "node:os";
+import path24 from "node:path";
 
 // packages/workit-core/src/core/live-session.ts
-import { spawnSync as spawnSync13 } from "node:child_process";
+import { spawnSync as spawnSync12 } from "node:child_process";
 import { createHash as createHash15 } from "node:crypto";
-import fs17 from "node:fs";
-import os6 from "node:os";
-import path22 from "node:path";
+import fs18 from "node:fs";
+import os8 from "node:os";
+import path23 from "node:path";
 var LIVE_SESSION_TTL_MS = 15 * 60000;
 var HEARTBEAT_EVERY_MS = 30000;
 var liveProbe = {
   platform: process.platform,
-  run: (args) => spawnSync13("ps", args, { encoding: "utf8", timeout: 2000 }).stdout ?? "",
+  run: (args) => spawnSync12("ps", args, { encoding: "utf8", timeout: 2000 }).stdout ?? "",
   start: (pid) => processStartOf(pid)
 };
 var leadOf = (session) => session.split(":")[0].replace(/-w-.*$/su, "") || session;
@@ -20406,9 +21021,9 @@ var processAlive = (pid) => {
 var processInfo = (pid) => {
   try {
     if (liveProbe.platform === "linux") {
-      const stat = fs17.readFileSync(`/proc/${pid}/stat`, "utf8");
+      const stat = fs18.readFileSync(`/proc/${pid}/stat`, "utf8");
       const ppid = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1]);
-      const command = fs17.readFileSync(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ");
+      const command = fs18.readFileSync(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ");
       return Number.isInteger(ppid) ? { ppid, command: command.trim() } : null;
     }
     if (liveProbe.platform === "win32")
@@ -20459,35 +21074,35 @@ var liveOwner = (input, transport, env = process.env) => {
   };
 };
 var checkoutOf = (target) => {
-  let dir = path22.resolve(target);
-  while (!fs17.existsSync(dir) && path22.dirname(dir) !== dir)
-    dir = path22.dirname(dir);
-  if (fs17.existsSync(dir) && !fs17.statSync(dir).isDirectory())
-    dir = path22.dirname(dir);
-  const parts = dir.split(path22.sep);
+  let dir = path23.resolve(target);
+  while (!fs18.existsSync(dir) && path23.dirname(dir) !== dir)
+    dir = path23.dirname(dir);
+  if (fs18.existsSync(dir) && !fs18.statSync(dir).isDirectory())
+    dir = path23.dirname(dir);
+  const parts = dir.split(path23.sep);
   const dotGit = parts.lastIndexOf(".git");
   if (dotGit > 0)
-    dir = parts.slice(0, dotGit).join(path22.sep) || path22.sep;
+    dir = parts.slice(0, dotGit).join(path23.sep) || path23.sep;
   const location = resolveStore(dir);
   if (location instanceof Error || !location.shared || !location.top)
     return null;
   let top = location.top;
   try {
-    top = fs17.realpathSync.native(top);
+    top = fs18.realpathSync.native(top);
   } catch {}
   return top;
 };
-var markerFile2 = (top) => path22.join(resolveStateDir(), "live-sessions", `${createHash15("sha256").update(checkoutKey(top)).digest("hex").slice(0, 32)}.json`);
+var markerFile2 = (top) => path23.join(resolveStateDir(), "live-sessions", `${createHash15("sha256").update(checkoutKey(top)).digest("hex").slice(0, 32)}.json`);
 var checkoutKey = (top, platform = process.platform) => {
-  let key = path22.resolve(top);
+  let key = path23.resolve(top);
   try {
-    key = fs17.realpathSync.native(key);
+    key = fs18.realpathSync.native(key);
   } catch {}
   return platform === "win32" ? key.replaceAll("/", "\\").toLowerCase() : key;
 };
 var readMarker = (file) => {
   try {
-    const value = JSON.parse(fs17.readFileSync(file, "utf8"));
+    const value = JSON.parse(fs18.readFileSync(file, "utf8"));
     if (value?.version !== 1 || typeof value.session !== "string" || typeof value.host !== "string" || typeof value.heartbeatAt !== "string" || Number.isNaN(Date.parse(value.heartbeatAt)))
       return null;
     return {
@@ -20510,7 +21125,7 @@ var isLive = (marker, deps) => {
   const age = ageOf2(marker, deps.now ?? new Date);
   if (age > (deps.ttlMs ?? LIVE_SESSION_TTL_MS))
     return false;
-  if (marker.machine !== (deps.machine ?? os6.hostname()) || marker.pid === null)
+  if (marker.machine !== (deps.machine ?? os8.hostname()) || marker.pid === null)
     return true;
   if (!(deps.alive ?? processAlive)(marker.pid))
     return false;
@@ -20539,7 +21154,7 @@ var liveConflict = (target, owner, deps = {}) => {
     const marker = readMarker(file);
     if (!marker || sameLead(marker, owner) || !isLive(marker, deps))
       return null;
-    if (sameOwner(marker, owner, deps.machine ?? os6.hostname()))
+    if (sameOwner(marker, owner, deps.machine ?? os8.hostname()))
       return null;
     return { marker, file, ageMs: ageOf2(marker, deps.now ?? new Date), checkout };
   } catch {
@@ -20553,7 +21168,7 @@ var claimLiveSession = (target, owner, deps = {}) => {
       return;
     const file = markerFile2(checkout);
     const now = deps.now ?? new Date;
-    const machine = deps.machine ?? os6.hostname();
+    const machine = deps.machine ?? os8.hostname();
     const current = readMarker(file);
     if (current) {
       const age = ageOf2(current, now);
@@ -20574,10 +21189,10 @@ var claimLiveSession = (target, owner, deps = {}) => {
       checkout,
       heartbeatAt: now.toISOString()
     };
-    fs17.mkdirSync(path22.dirname(file), { recursive: true });
+    fs18.mkdirSync(path23.dirname(file), { recursive: true });
     const temp = `${file}.${process.pid}.tmp`;
-    fs17.writeFileSync(temp, JSON.stringify(marker));
-    fs17.renameSync(temp, file);
+    fs18.writeFileSync(temp, JSON.stringify(marker));
+    fs18.renameSync(temp, file);
   } catch {}
 };
 
@@ -20586,27 +21201,42 @@ var NONE3 = { kind: "none" };
 var CASE_INSENSITIVE = process.platform === "darwin" || process.platform === "win32";
 var canonical2 = (file) => {
   let rest = "";
-  for (let dir = path23.resolve(file);; dir = path23.dirname(dir)) {
+  for (let dir = path24.resolve(file);; dir = path24.dirname(dir)) {
     try {
-      return path23.join(realpathSync5(dir), rest);
+      return path24.join(realpathSync5(dir), rest);
     } catch {
-      if (path23.dirname(dir) === dir)
-        return path23.resolve(file);
-      rest = rest ? path23.join(path23.basename(dir), rest) : path23.basename(dir);
+      if (path24.dirname(dir) === dir)
+        return path24.resolve(file);
+      rest = rest ? path24.join(path24.basename(dir), rest) : path24.basename(dir);
     }
   }
 };
 var exempt = (cwd, root, file, plans) => {
   const fold = (value) => CASE_INSENSITIVE ? value.toLowerCase() : value;
-  const relative = path23.relative(fold(canonical2(root)), fold(canonical2(path23.resolve(cwd, file))));
-  if (relative.startsWith("..") || path23.isAbsolute(relative))
+  const relative = path24.relative(fold(canonical2(root)), fold(canonical2(path24.resolve(cwd, file))));
+  if (relative.startsWith("..") || path24.isAbsolute(relative))
     return true;
-  const posix = relative.split(path23.sep).join("/");
+  const posix = relative.split(path24.sep).join("/");
   const segments = posix.split("/");
   return /\.mdx?$/i.test(posix) || segments[0] === "docs" || segments.includes("plans") || [...plans].some((plan) => fold(plan) === posix);
 };
 var PREFIXES2 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "xargs"]);
 var operands = (words) => words.filter((item) => !item.startsWith("-"));
+var SCRIPT_SHELLS = new Set(["sh", "bash", "zsh", "dash", "ksh"]);
+var wrappedScript = (input) => {
+  let words = input;
+  while (words.length && (PREFIXES2.has(words[0]) || /^\w+=/.test(words[0])))
+    words = words.slice(1);
+  const tail = workitCheckTail(words);
+  if (!tail)
+    return null;
+  if ("script" in tail)
+    return tail.script;
+  const [shell, flag, script] = tail.argv;
+  if (SCRIPT_SHELLS.has((shell.split(/[\\/]/).at(-1) ?? "").toLowerCase()) && /^-[a-z]*c$/.test(flag ?? ""))
+    return script ?? null;
+  return tail.argv.map(quoteWord2).join(" ");
+};
 var editsOf = (input) => {
   let words = input;
   while (words.length && (PREFIXES2.has(words[0]) || /^\w+=/.test(words[0])))
@@ -20683,10 +21313,18 @@ var editsOf = (input) => {
       return [];
   }
 };
-var shellWrites = (command) => {
+var shellWrites = (command, depth = 0) => {
   const targets = [];
   let unknown = false;
   for (const segment of segmentsOf(command)) {
+    const inner = depth < 4 ? wrappedScript(segment.words) : null;
+    if (inner !== null) {
+      const nested = shellWrites(inner, depth + 1);
+      if (nested.writes && nested.targets === null)
+        unknown = true;
+      else if (nested.targets)
+        targets.push(...nested.targets);
+    }
     targets.push(...segment.redirects.filter((item) => !/^\/dev\/(?:null|stdout|stderr|tty)$/.test(item)));
     const edits = editsOf(segment.words);
     if (edits === null)
@@ -20699,7 +21337,7 @@ var shellWrites = (command) => {
   return { writes: true, targets: unknown ? null : targets };
 };
 var cache2 = new Map;
-var planKeyOf = (root, plans) => [...plans].map((file) => fileSignature(path23.resolve(root, file)) ?? "-").join("\x00");
+var planKeyOf = (root, plans) => [...plans].map((file) => fileSignature(path24.resolve(root, file)) ?? "-").join("\x00");
 var gateFor = (cwd) => {
   const store = new TaskStore(cwd);
   const listed = store.listTaskIndex();
@@ -20778,7 +21416,7 @@ var gitMutationDirs = (cwd, command, dialect) => {
       return [];
     if (sub === "stash" && ["list", "show"].includes(rest[0] ?? ""))
       return [];
-    return [path23.resolve(cwd, invocation.dir ?? ".")];
+    return [path24.resolve(cwd, invocation.dir ?? ".")];
   });
 };
 var CD2 = new Set(["cd", "chdir", "set-location", "sl"]);
@@ -20788,15 +21426,15 @@ var cdInto = (dir, words) => {
   const target = words.slice(1).find((word) => !word.startsWith("-") || word === "-");
   if (dir === undefined || target === "-" || target && /^~|[$`*?]/.test(target))
     return;
-  return target === undefined ? os7.homedir() : path23.resolve(dir, target);
+  return target === undefined ? os9.homedir() : path24.resolve(dir, target);
 };
-var quoteWord = (word) => /^[\w@%+=:,./-]+$/.test(word) ? word : `'${word.replaceAll("'", "'\\''")}'`;
-var segmentTargets = (cwd, command, dialect) => {
+var quoteWord2 = (word) => /^[\w@%+=:,./-]+$/.test(word) ? word : `'${word.replaceAll("'", "'\\''")}'`;
+var segmentTargets = (cwd, command, dialect, depth = 0) => {
   const targets = [];
   let dir = cwd;
   let stack = [];
   const groups = [];
-  const at = (file) => path23.isAbsolute(file) ? file : dir === undefined ? null : path23.resolve(dir, file);
+  const at = (file) => path24.isAbsolute(file) ? file : dir === undefined ? null : path24.resolve(dir, file);
   for (const segment of segmentsOf(command, dialect)) {
     if (segment.group === "open") {
       groups.push({ dir, stack: [...stack] });
@@ -20824,6 +21462,9 @@ var segmentTargets = (cwd, command, dialect) => {
       dir = stack.length ? stack.pop() : undefined;
       continue;
     }
+    const inner = depth < 4 ? wrappedScript(words) : null;
+    if (inner !== null && dir !== undefined)
+      targets.push(...segmentTargets(dir, inner, "posix", depth + 1));
     for (const file of segment.redirects)
       if (!/^\/dev\/(?:null|stdout|stderr|tty)$/.test(file)) {
         const resolved = at(file);
@@ -20833,15 +21474,15 @@ var segmentTargets = (cwd, command, dialect) => {
     const edits = editsOf(segment.words);
     if (edits === null) {
       if (dir !== undefined)
-        targets.push(path23.join(dir, DIR_TARGET));
+        targets.push(path24.join(dir, DIR_TARGET));
     } else
       for (const file of edits) {
         const resolved = at(file);
         if (resolved)
           targets.push(resolved);
       }
-    if (dir !== undefined && workitInvocations(segment.words.map(quoteWord).join(" "), "posix").some((args) => args[0] === "git" && MUTATING_WORKIT_GIT.has(args[1] ?? "") && !inert(args.slice(2), "")))
-      targets.push(path23.join(dir, DIR_TARGET));
+    if (dir !== undefined && workitInvocations(segment.words.map(quoteWord2).join(" "), "posix").some((args) => args[0] === "git" && MUTATING_WORKIT_GIT.has(args[1] ?? "") && !inert(args.slice(2), "")))
+      targets.push(path24.join(dir, DIR_TARGET));
   }
   return targets;
 };
@@ -20876,7 +21517,7 @@ var liveDeny = ({ marker, checkout, ageMs, file }) => {
 var guarded = (targets) => {
   const seen = new Set;
   return targets.filter((target) => {
-    const dir = path23.dirname(target);
+    const dir = path24.dirname(target);
     if (seen.has(dir))
       return false;
     seen.add(dir);
@@ -20897,7 +21538,7 @@ var claimAll = (owner, targets, deps) => {
   for (const target of guarded(targets))
     claimLiveSession(target, owner, deps);
 };
-var liveTargets = (cwd, paths) => paths?.length ? paths.map((file) => path23.resolve(cwd, file)) : [path23.join(cwd, DIR_TARGET)];
+var liveTargets = (cwd, paths) => paths?.length ? paths.map((file) => path24.resolve(cwd, file)) : [path24.join(cwd, DIR_TARGET)];
 function writeGate(cwd, paths, owner, deps) {
   if (!owner)
     return beforeWriteGate(cwd, paths);
@@ -20917,7 +21558,7 @@ function shellGate(cwd, command, owner, dialect = "posix", deps) {
     try {
       targets = [
         ...segmentTargets(cwd, command, dialect),
-        ...gitMutationDirs(cwd, command, dialect).map((dir) => path23.join(dir, DIR_TARGET))
+        ...gitMutationDirs(cwd, command, dialect).map((dir) => path24.join(dir, DIR_TARGET))
       ];
     } catch {
       targets = [];
@@ -20966,7 +21607,7 @@ function beforeWriteGate(cwd, paths) {
   }
 }
 // packages/workit-core/src/hooks/stop.ts
-import { spawnSync as spawnSync14 } from "node:child_process";
+import { spawnSync as spawnSync13 } from "node:child_process";
 var NONE4 = { kind: "none" };
 var QUESTION = /[?？؟](?=[\s*_`"')\]>]*(?:\s|$))|¿/;
 var OFFER = /\b(?:let me know|want me to|should I|shall I|would you like|do you want|if you(?:'d| would) like|may I|can I go ahead)\b/i;
@@ -20987,7 +21628,7 @@ var asksUser = (message) => {
 };
 var short = (sha) => (sha ?? "?").slice(0, 12);
 var gitList = (cwd, args) => {
-  const run = spawnSync14("git", args, {
+  const run = spawnSync13("git", args, {
     cwd,
     encoding: "utf8",
     timeout: 3000,
@@ -21351,12 +21992,12 @@ ${line}` };
 };
 // packages/workit-core/src/hooks/hosts/fields.ts
 import { existsSync as existsSync7, realpathSync as realpathSync6, statSync as statSync2 } from "node:fs";
-import path24 from "node:path";
-var isRecord4 = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+import path25 from "node:path";
+var isRecord5 = (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) || !path24.isAbsolute(value) || !existsSync7(value))
+  if (!nonEmpty2(value) || !path25.isAbsolute(value) || !existsSync7(value))
     return null;
   try {
     return statSync2(value).isDirectory() ? realpathSync6(value) : null;
@@ -21409,7 +22050,7 @@ var isWriteTool = (name) => typeof name === "string" && WRITE_TOOLS.has(name.toL
 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))
+  if (!isRecord5(input))
     return [];
   const paths = PATH_KEYS.map((key) => input[key]).filter(nonEmpty2);
   for (const value of Object.values(input))
@@ -21504,10 +22145,32 @@ function handleHook(input, deps) {
       const gate = usable2(descriptor.events["write.pre"].support) ? shellGate(input.cwd, event.command, liveOwner(input, descriptor.transport), event.dialect) : NONE5;
       if (gate.kind === "deny")
         return gate;
+      const plan = heavyGate(input.cwd, event.command, {
+        host: input.host,
+        dialect: event.dialect,
+        permissionMode: input.permissionMode
+      });
+      if (plan.kind === "split" && canDeny)
+        return splitDenial(plan);
+      const rewrites = usable2(descriptor.shellPolicy.rewrite);
+      if (plan.kind === "rewrite" && !rewrites && canDeny)
+        return heavyDenial(event.command, plan);
+      const lease = plan.kind === "rewrite" && rewrites ? plan : null;
+      const aside = plan.kind === "passthrough" ? plan.note : null;
       noteRawCommit(input, event.command, postTool ? callKey(event.toolUseId, event.command) : NEXT_COMMAND);
+      const rewritten = (text) => lease ? {
+        kind: "rewrite",
+        command: lease.command,
+        input: event.toolInput ? { ...event.toolInput, command: lease.command } : null,
+        text
+      } : NONE5;
       if (descriptor.transport !== "hook-process")
-        return NONE5;
-      return withContextLine(canDeny ? rawGitPre(input, event.command) : NONE5, shipNudge(input, event.command));
+        return rewritten(null);
+      const nudged = withContextLine(withContextLine(canDeny ? rawGitPre(input, event.command) : NONE5, aside), shipNudge(input, event.command));
+      if (!lease)
+        return nudged;
+      return rewritten([rewriteNote(lease), nudged.kind === "context" ? nudged.text : null].filter(Boolean).join(`
+`));
     }
     case "shell.post":
       if (usable2(descriptor.events["shell.post"].support))
@@ -21565,6 +22228,112 @@ var dispatchHook = (adapter, raw, env = process.env) => {
     };
   }
 };
+// packages/workit-core/src/hooks/deadline.ts
+import { appendFileSync, mkdirSync as mkdirSync3 } from "node:fs";
+import path26 from "node:path";
+var HOOK_SKIP_TEXT = "workit context skipped: host under load";
+var HOOK_DEADLINE_MS = 8000;
+var HOST_DEADLINES = {
+  claude_code: { "": 8000, SessionStart: 16000, Stop: 16000 },
+  codex_cli: { "": 45000, Stop: 16000 },
+  codex_desktop: { "": 45000, Stop: 16000 },
+  cursor: { "": 45000 }
+};
+var HOOK_SKIPS_FILE = "hook-skips.jsonl";
+var override = (env) => {
+  const value = Number(env.WORKIT_HOOK_DEADLINE_MS);
+  return Number.isFinite(value) && value > 0 ? value : null;
+};
+var hookDeadlineMs = (env, host = "", native) => {
+  const row = HOST_DEADLINES[host];
+  return override(env) ?? (row ? native === undefined ? Math.min(...Object.values(row)) : row[native] ?? row[""] : HOOK_DEADLINE_MS);
+};
+var skipsFile = (stateDir) => path26.join(stateDir, HOOK_SKIPS_FILE);
+var recordHookSkip = (skip, stateDir = resolveStateDir()) => {
+  try {
+    mkdirSync3(stateDir, { recursive: true });
+    appendFileSync(skipsFile(stateDir), `${JSON.stringify(skip)}
+`);
+  } catch {}
+};
+var QUIET = new Set([
+  "stop",
+  "subagent.stop",
+  "shell.post",
+  "compact.pre",
+  "prompt.submit",
+  null
+]);
+var skipDecision = (event) => QUIET.has(event) ? { kind: "none" } : { kind: "context", text: HOOK_SKIP_TEXT };
+var TIMED_OUT = Symbol("timed out");
+var within = async (work, ms) => {
+  let timer;
+  const expired = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(TIMED_OUT), Math.max(0, ms));
+    timer.unref?.();
+  });
+  try {
+    return await Promise.race([work, expired]);
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var isTimedOut = (value) => value === TIMED_OUT;
+var PROCESS_START = performance.timeOrigin;
+var hookBudget = (env, options = {}, host = "") => {
+  const now = options.now ?? Date.now;
+  return {
+    now,
+    record: options.record ?? ((skip) => recordHookSkip(skip)),
+    startedAt: options.startedAt ?? now(),
+    deadlineMs: options.deadlineMs ?? hookDeadlineMs(env, host),
+    host: options.deadlineMs === undefined ? host : null
+  };
+};
+var readWithin = async (stdin, budget) => {
+  const read = (async () => {
+    let text = "";
+    for await (const chunk of stdin)
+      text += String(chunk);
+    return text;
+  })();
+  const text = await within(read, budget.startedAt + budget.deadlineMs - budget.now());
+  return isTimedOut(text) ? null : text;
+};
+var note = (adapter, raw, env, budget, outcome, stage) => {
+  const parsed = raw === undefined ? null : adapter.parse(raw, env);
+  const event = parsed ? parsed.ok ? parsed.input.event.kind : parsed.event : null;
+  budget.record({
+    at: new Date(budget.now()).toISOString(),
+    host: adapter.descriptor.host,
+    event,
+    outcome,
+    stage,
+    elapsedMs: Math.round(budget.now() - budget.startedAt)
+  });
+  return { native: parsed?.native ?? null, event };
+};
+var skippedHook = (adapter, raw, env, budget, stage) => {
+  const { native, event } = note(adapter, raw, env, budget, "skip", stage);
+  return {
+    ...adapter.render(skipDecision(event), native),
+    error: `${HOOK_SKIP_TEXT} (past the ${budget.deadlineMs} ms hook deadline)`,
+    skipped: true
+  };
+};
+var dispatchWithin = async (adapter, raw, env, budget, dispatch = dispatchHook) => {
+  const native = raw?.hook_event_name;
+  if (budget.host !== null && typeof native === "string")
+    budget.deadlineMs = hookDeadlineMs(env, budget.host, native);
+  const remaining = () => budget.startedAt + budget.deadlineMs - budget.now();
+  const result = remaining() > 0 ? await within(Promise.resolve().then(() => dispatch(adapter, raw, env)), remaining()) : TIMED_OUT;
+  if (isTimedOut(result))
+    return skippedHook(adapter, raw, env, budget, "dispatch");
+  if (remaining() < 0)
+    note(adapter, raw, env, budget, "late", "done");
+  return { ...result, skipped: false };
+};
+
 // packages/workit-core/src/hooks/hosts/claude-code.ts
 var CLAUDE_CODE_DESCRIPTOR = {
   host: "claude_code",
@@ -21585,7 +22354,12 @@ var CLAUDE_CODE_DESCRIPTOR = {
     "compact.pre": { support: "none", native: null },
     stop: { support: "native", native: "Stop" }
   },
-  shellPolicy: { deny: "native", channel: "permissionDecision", failClosed: false },
+  shellPolicy: {
+    deny: "native",
+    channel: "permissionDecision",
+    failClosed: false,
+    rewrite: "native"
+  },
   context: {
     sessionStart: "native",
     perTurn: "native",
@@ -21667,7 +22441,7 @@ var EVENTS = {
 var SOURCES = new Set(["startup", "resume", "clear", "compact", "fork"]);
 var SHELL_TOOLS = new Set(["Bash", "PowerShell"]);
 var dialectOf2 = (value) => value.tool_name === "PowerShell" ? "powershell" : "posix";
-var toolCommand = (value) => isRecord4(value.tool_input) ? commandText(value.tool_input.command) : null;
+var toolCommand = (value) => isRecord5(value.tool_input) ? commandText(value.tool_input.command) : null;
 var eventOf = (name, value) => {
   const toolUseId = optionalText(value.tool_use_id);
   switch (name) {
@@ -21695,19 +22469,28 @@ var eventOf = (name, value) => {
             kind: "tool.pre",
             tool: value.tool_name,
             toolUseId,
-            skill: isRecord4(value.tool_input) ? optionalText(value.tool_input.skill) : null
+            skill: isRecord5(value.tool_input) ? optionalText(value.tool_input.skill) : null
           }
         };
       if (!SHELL_TOOLS.has(value.tool_name))
         return { ok: true, event: { kind: "tool.pre", tool: value.tool_name, toolUseId } };
       const command = toolCommand(value);
-      return command ? { ok: true, event: { kind: "shell.pre", command, toolUseId, dialect: dialectOf2(value) } } : { ok: false, error: `tool_input.command is required for ${value.tool_name}` };
+      return command ? {
+        ok: true,
+        event: {
+          kind: "shell.pre",
+          command,
+          toolUseId,
+          dialect: dialectOf2(value),
+          toolInput: value.tool_input
+        }
+      } : { ok: false, error: `tool_input.command is required for ${value.tool_name}` };
     }
     case "PostToolUse": {
       const command = toolCommand(value);
       if (!SHELL_TOOLS.has(String(value.tool_name)) || !command)
         return { ok: false, error: "only shell PostToolUse is mapped" };
-      const response = isRecord4(value.tool_response) ? value.tool_response : {};
+      const response = isRecord5(value.tool_response) ? value.tool_response : {};
       return {
         ok: true,
         event: {
@@ -21765,6 +22548,17 @@ var CONTEXT_EVENTS = new Set([
   "PostToolUse"
 ]);
 var render = (decision, native) => {
+  if (decision.kind === "rewrite" && native === "PreToolUse" && decision.input)
+    return {
+      json: {
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          updatedInput: decision.input,
+          ...decision.text ? { additionalContext: decision.text } : {}
+        }
+      },
+      exitCode: 0
+    };
   if (decision.kind === "deny" && native === "PreToolUse")
     return {
       json: {
@@ -21790,14 +22584,14 @@ var render = (decision, native) => {
 var claudeCodeAdapter = {
   descriptor: CLAUDE_CODE_DESCRIPTOR,
   parse(raw) {
-    const native = isRecord4(raw) && Object.hasOwn(EVENTS, String(raw.hook_event_name)) ? raw.hook_event_name : null;
+    const native = isRecord5(raw) && Object.hasOwn(EVENTS, String(raw.hook_event_name)) ? raw.hook_event_name : null;
     const fail = (error) => ({
       ok: false,
       error,
       native,
       event: native ? EVENTS[native] : null
     });
-    if (!isRecord4(raw) || !native)
+    if (!isRecord5(raw) || !native)
       return fail("hook_event_name is required");
     if (!nonEmpty2(raw.session_id))
       return fail("session_id is required");
@@ -21851,7 +22645,12 @@ var CODEX_DESCRIPTOR = {
     "compact.pre": { support: "none", native: null },
     stop: { support: "native", native: "Stop" }
   },
-  shellPolicy: { deny: "native", channel: "permissionDecision", failClosed: false },
+  shellPolicy: {
+    deny: "native",
+    channel: "permissionDecision",
+    failClosed: false,
+    rewrite: "none"
+  },
   context: {
     sessionStart: "native",
     perTurn: "native",
@@ -21943,7 +22742,7 @@ 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(EVENTS2, String(value.hook_event_name)))
+  if (!isRecord5(value) || !Object.hasOwn(EVENTS2, 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);
@@ -21952,7 +22751,7 @@ var parseCodexHookInput = (value) => {
   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;
+  const command = isRecord5(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))
@@ -22066,7 +22865,7 @@ var codexAdapter = {
     const host = detectCodexSurface(env);
     const parsed = parseCodexHookInput(raw);
     if (!parsed.ok) {
-      const native = isRecord4(raw) && Object.hasOwn(EVENTS2, String(raw.hook_event_name)) ? raw.hook_event_name : null;
+      const native = isRecord5(raw) && Object.hasOwn(EVENTS2, String(raw.hook_event_name)) ? raw.hook_event_name : null;
       return { ok: false, error: parsed.error, native, event: native ? EVENTS2[native] : null };
     }
     const input = parsed.data;
@@ -22093,8 +22892,8 @@ var codexAdapter = {
 };
 
 // packages/workit-core/src/hooks/hosts/cursor.ts
-import fs18 from "node:fs";
-import path25 from "node:path";
+import fs19 from "node:fs";
+import path27 from "node:path";
 var undocumented = { support: "undocumented", native: null };
 var none = { support: "none", native: null };
 var CURSOR_DESCRIPTOR = {
@@ -22116,7 +22915,7 @@ var CURSOR_DESCRIPTOR = {
     "compact.pre": { support: "partial", native: "preCompact" },
     stop: { support: "native", native: "stop" }
   },
-  shellPolicy: { deny: "native", channel: "exit2+json", failClosed: false },
+  shellPolicy: { deny: "native", channel: "exit2+json", failClosed: false, rewrite: "none" },
   context: {
     sessionStart: "native",
     perTurn: "none",
@@ -22209,7 +23008,7 @@ var EVENTS3 = {
   stop: "stop"
 };
 var parseCursorHookInput = (value) => {
-  if (!isRecord4(value) || !Object.hasOwn(EVENTS3, String(value.hook_event_name)))
+  if (!isRecord5(value) || !Object.hasOwn(EVENTS3, String(value.hook_event_name)))
     return { ok: false, error: "hook_event_name is required" };
   const roots = value.workspace_roots;
   if (!Array.isArray(roots) || roots.length === 0 || !roots.every(nonEmpty2))
@@ -22291,17 +23090,17 @@ var protocolEvent2 = (input) => {
 };
 var TRANSCRIPT_TAIL_BYTES = 256 * 1024;
 var lastAssistantText = (file) => {
-  if (!file || !path25.isAbsolute(file))
+  if (!file || !path27.isAbsolute(file))
     return null;
   try {
-    const size = fs18.statSync(file).size;
+    const size = fs19.statSync(file).size;
     const start = Math.max(0, size - TRANSCRIPT_TAIL_BYTES);
     const buffer = Buffer.alloc(size - start);
-    const fd = fs18.openSync(file, "r");
+    const fd = fs19.openSync(file, "r");
     try {
-      fs18.readSync(fd, buffer, 0, buffer.length, start);
+      fs19.readSync(fd, buffer, 0, buffer.length, start);
     } finally {
-      fs18.closeSync(fd);
+      fs19.closeSync(fd);
     }
     const lines = buffer.toString("utf8").split(`
 `);
@@ -22312,14 +23111,14 @@ var lastAssistantText = (file) => {
       } catch {
         continue;
       }
-      if (!isRecord4(entry) || entry.role !== "assistant")
+      if (!isRecord5(entry) || entry.role !== "assistant")
         continue;
-      const content = isRecord4(entry.message) ? entry.message.content : entry.content;
+      const content = isRecord5(entry.message) ? entry.message.content : entry.content;
       if (typeof content === "string")
         return content;
       if (!Array.isArray(content))
         return null;
-      const text = content.filter((part) => isRecord4(part) && part.type === "text" && typeof part.text === "string").map((part) => part.text).join(`
+      const text = content.filter((part) => isRecord5(part) && part.type === "text" && typeof part.text === "string").map((part) => part.text).join(`
 `);
       return text || null;
     }
@@ -22328,7 +23127,7 @@ var lastAssistantText = (file) => {
     return null;
   }
 };
-var within = (root, dir) => dir === root || dir.startsWith(root.endsWith(path25.sep) ? root : `${root}${path25.sep}`);
+var within2 = (root, dir) => dir === root || dir.startsWith(root.endsWith(path27.sep) ? root : `${root}${path27.sep}`);
 var hookCwd = (input) => {
   const cwd = existingDirectory(input.cwd);
   if (cwd && input.hook_event_name === "beforeShellExecution")
@@ -22337,7 +23136,7 @@ var hookCwd = (input) => {
 };
 var cursorWorkspaceRoot = (input) => {
   const cwd = existingDirectory(input.cwd);
-  return cwd && input.workspace_roots.find((root) => within(root, cwd)) || input.workspace_roots[0];
+  return cwd && input.workspace_roots.find((root) => within2(root, cwd)) || input.workspace_roots[0];
 };
 var cursorDeny = (reason) => ({
   permission: "deny",
@@ -22369,7 +23168,7 @@ var cursorAdapter = {
   parse(raw) {
     const parsed = parseCursorHookInput(raw);
     if (!parsed.ok) {
-      const native = isRecord4(raw) && Object.hasOwn(EVENTS3, String(raw.hook_event_name)) ? raw.hook_event_name : null;
+      const native = isRecord5(raw) && Object.hasOwn(EVENTS3, String(raw.hook_event_name)) ? raw.hook_event_name : null;
       return { ok: false, error: parsed.error, native, event: native ? EVENTS3[native] : null };
     }
     const input = parsed.data;
@@ -22402,19 +23201,21 @@ var HOOK_ADAPTERS = {
   codex_desktop: codexAdapter,
   cursor: cursorAdapter
 };
-async function runHookProcess(host, stdin, stdout, stderr = process.stderr, env = process.env) {
+async function runHookProcess(host, stdin, stdout, stderr = process.stderr, env = process.env, deadline = {}) {
   const adapter = typeof host === "string" ? HOOK_ADAPTERS[host] : host;
-  let text = "";
-  for await (const chunk of stdin)
-    text += String(chunk);
+  const budget = hookBudget(env, deadline, adapter.descriptor.host);
+  const text = await readWithin(stdin, budget);
   let raw;
   try {
-    raw = JSON.parse(text || "{}");
+    raw = text === null ? undefined : JSON.parse(text || "{}");
   } catch {
     raw = undefined;
   }
-  const result = dispatchHook(adapter, raw, env);
-  if (raw === undefined || result.error)
+  const result = text === null ? skippedHook(adapter, undefined, env, budget, "input") : await dispatchWithin(adapter, raw, env, budget, deadline.dispatch);
+  if (result.skipped)
+    stderr.write(`[workit] ${result.error}
+`);
+  else if (raw === undefined || result.error)
     stderr.write(`[workit] hook input rejected: ${raw === undefined ? "invalid JSON hook input" : result.error}
 `);
   stdout.write(`${JSON.stringify(result.json)}
@@ -22431,7 +23232,7 @@ function warnOnSurfaceFallback(env = process.env) {
 }
 var runCodexHook = async (stdin = process.stdin) => {
   warnOnSurfaceFallback();
-  process.exitCode = await runHookProcess(detectCodexSurface(process.env), stdin, process.stdout);
+  process.exitCode = await runHookProcess(detectCodexSurface(process.env), stdin, process.stdout, process.stderr, process.env, { startedAt: PROCESS_START });
 };
 if (false)
   ;