@brainervirus/workit-cursor 8.22.3 → 8.24.0

package/dist/cursor-session-start.js

@@ -6981,6 +6981,110 @@ function resolveRef(cwd, ref) {
     return null;
   return line(git(cwd, ["rev-parse", "--verify", "-q", `${ref}^{commit}`]));
 }
+function diffNumstat(cwd, fork, head) {
+  const range = laneRange(fork, head);
+  if (!range)
+    return null;
+  const run = git(cwd, [...LANE_DIFF, "--numstat", "-z", ...range, "--"]);
+  if (!run.ok)
+    return null;
+  const out = [];
+  for (const record of run.stdout.split("\x00")) {
+    const match = /^(-|\d+)\t(-|\d+)\t(.+)$/su.exec(record.replace(/^\n/u, ""));
+    if (!match)
+      continue;
+    const binary = match[1] === "-";
+    out.push({
+      path: match[3],
+      added: binary ? 0 : Number(match[1]),
+      deleted: binary ? 0 : Number(match[2]),
+      binary
+    });
+  }
+  return out;
+}
+function diffRaw(cwd, fork, head) {
+  const range = laneRange(fork, head);
+  if (!range)
+    return null;
+  const run = git(cwd, [...LANE_DIFF, "--raw", "-z", "--no-abbrev", ...range, "--"]);
+  if (!run.ok)
+    return null;
+  const fields = run.stdout.split("\x00");
+  const out = [];
+  for (let index = 0;index + 1 < fields.length; index += 2) {
+    const meta = /^:(\d{6}) (\d{6}) ([0-9a-f]+) ([0-9a-f]+) [A-Z]\d*$/u.exec(fields[index].replace(/^\n/u, ""));
+    if (!meta)
+      return null;
+    out.push({
+      path: fields[index + 1],
+      oldMode: meta[1],
+      newMode: meta[2],
+      oldBlob: meta[3],
+      newBlob: meta[4]
+    });
+  }
+  return out;
+}
+function readBlobs(cwd, ids) {
+  const out = new Map;
+  const wanted = [...new Set(ids)].filter((id) => /^[0-9a-f]{40,64}$/u.test(id));
+  if (!wanted.length)
+    return out;
+  const run = spawnSync("git", ["cat-file", "--batch"], {
+    cwd,
+    input: `${wanted.join(`
+`)}
+`,
+    maxBuffer: MAX_BUFFER,
+    timeout: GIT_TIMEOUTS.local,
+    killSignal: "SIGKILL",
+    windowsHide: true
+  });
+  if (run.status !== 0 || !run.stdout)
+    return null;
+  const bytes = run.stdout;
+  let at = 0;
+  for (const id of wanted) {
+    const end = bytes.indexOf(10, at);
+    if (end < 0)
+      return null;
+    const header = bytes.subarray(at, end).toString("utf8").split(" ");
+    at = end + 1;
+    if (header[1] === "missing")
+      continue;
+    const size = Number(header[2]);
+    if (header[0] !== id || !Number.isSafeInteger(size))
+      return null;
+    out.set(id, bytes.subarray(at, at + size));
+    at += size + 1;
+  }
+  return out;
+}
+function treeFilesNamed(cwd, rev, name) {
+  if (!safeArg(rev))
+    return null;
+  const run = git(cwd, ["ls-tree", "-r", "-z", "--full-tree", rev]);
+  if (!run.ok)
+    return null;
+  const out = new Map;
+  for (const record of run.stdout.split("\x00")) {
+    const match = /^\d{6} blob ([0-9a-f]+)\t(.+)$/su.exec(record);
+    if (match && (match[2] === name || match[2].endsWith(`/${name}`)))
+      out.set(match[2], match[1]);
+  }
+  return out;
+}
+function fileAt(cwd, rev, file) {
+  if (!safeArg(rev))
+    return null;
+  const run = git(cwd, ["cat-file", "blob", `${rev}:${file}`]);
+  return run.ok ? run.stdout : null;
+}
+function untrackedFiles(cwd) {
+  const run = git(cwd, ["ls-files", "-z", "--others", "--exclude-standard"]);
+  return run.ok ? run.stdout.split("\x00").filter(Boolean) : [];
+}
 function currentBranch(cwd) {
   return line(git(cwd, ["symbolic-ref", "--short", "-q", "HEAD"]));
 }
@@ -7027,11 +7131,24 @@ var MAX_BUFFER, GIT_TIMEOUTS, git = (cwd, args, options = {}) => {
   const { atimeNs, mtimeNs } = fs.statSync(from, { bigint: true });
   const seconds = (ns) => (Number(ns / 1000n) - 1) / 1e6;
   fs.utimesSync(to, seconds(atimeNs), seconds(mtimeNs));
+}, LANE_DIFF, laneRange = (fork, head) => {
+  if (!safeArg(fork) || head !== null && !safeArg(head))
+    return null;
+  return head === null ? [fork] : [fork, head];
 }, config2 = (cwd, key) => line(git(cwd, ["config", "--get", key]));
 var init_rev = __esm(() => {
   MAX_BUFFER = 256 * 1024 * 1024;
   GIT_TIMEOUTS = { local: 20000, worktree: 120000, network: 15000 };
   MAX_UNTRACKED_BYTES = 5 * 1024 * 1024;
+  LANE_DIFF = [
+    "-c",
+    "core.quotePath=false",
+    "diff",
+    "--no-color",
+    "--no-ext-diff",
+    "--no-textconv",
+    "--no-renames"
+  ];
 });
 
 // packages/workit-core/src/store/paths.ts
@@ -8094,7 +8211,7 @@ var init_workspaces = __esm(() => {
     }).passthrough().optional(),
     autoApprove: union([boolean2(), array(nonBlank)]).optional(),
     defaultEndpoint: unknown().optional(),
-    verification: _enum(["self", "independent"]).optional(),
+    verification: _enum(["proportional", "self", "independent"]).optional(),
     delegation: unknown().optional(),
     trailers: boolean2().optional(),
     liveSessionGuard: boolean2().optional(),
@@ -9787,7 +9904,8 @@ function checkVerdicts(cwd, branch, ledgerRows) {
     verdict: failing?.verdict ?? null,
     reasons: failing ? ["failing_verdict"] : !newestCurrent ? ["no_verdict"] : newestCurrent.reasons.length ? newestCurrent.reasons : ["type_check_only"]
   };
-  const selfEntry = failing ? undefined : verdicts.findLast((entry) => entry.current && !entry.independent && !untrusted(entry.reasons) && STRONG_RESULTS.has(String(entry.verdict.result)));
+  const latestSelf = failing ? undefined : verdicts.findLast((entry) => entry.current && !entry.independent && !untrusted(entry.reasons) && (STRONG_RESULTS.has(String(entry.verdict.result)) || FAILING.has(String(entry.verdict.result))));
+  const selfEntry = latestSelf && STRONG_RESULTS.has(String(latestSelf.verdict.result)) ? latestSelf : undefined;
   return {
     branch,
     head,
@@ -10068,12 +10186,709 @@ var init_ledger = __esm(() => {
   ]);
 });
 
-// packages/workit-core/src/core/policy/derive.ts
-import { existsSync as existsSync2 } from "node:fs";
+// packages/workit-core/src/forge/pr-body.ts
+var init_pr_body = __esm(() => {
+  init_vcs_config();
+});
+
+// packages/workit-core/src/core/pr-create.ts
+var init_pr_create = __esm(() => {
+  init_vcs_config();
+  init_vcs_config();
+  init_branch();
+  init_pr_body();
+});
+
+// packages/workit-core/src/forge/redact.ts
+var KEY, ASSIGNMENT, QUOTED_ASSIGNMENT, ANSI;
+var init_redact = __esm(() => {
+  KEY = String.raw`[A-Za-z0-9_.-]*?(?:token|secret|password|passwd|pwd|api[_-]?key|access[_-]?key|account[_-]?key|private[_-]?key|client[_-]?secret|credentials?|authorization|cookie|signature)[A-Za-z0-9_.-]*`;
+  ASSIGNMENT = new RegExp(String.raw`(?<![A-Za-z0-9])(["']?${KEY}["']?\s*[:=]\s*["']?)((?:bearer|basic|token|digest)\s+)?([^\s"',;&]+)`, "giu");
+  QUOTED_ASSIGNMENT = new RegExp(String.raw`(?<![A-Za-z0-9])(["']?${KEY}["']?\s*[:=]\s*)(["'])([^"'\n]*[^\s"'][^"'\n]*)\2`, "giu");
+  ANSI = new RegExp(String.raw`\u001b\[[0-9;?]*[ -/]*[@-~]|\u001b\][^\u0007]*\u0007`, "gu");
+});
+// packages/workit-core/src/git/ops.ts
+var COMMIT_TIMEOUT_MS;
+var init_ops = __esm(() => {
+  init_branch();
+  init_branch_policy();
+  init_commit_flavors();
+  init_pr_create();
+  init_release_tracks();
+  init_vcs_config();
+  init_workspaces();
+  init_redact();
+  init_host_session();
+  init_ledger();
+  init_rev();
+  COMMIT_TIMEOUT_MS = 10 * 60000;
+});
+
+// packages/workit-core/src/core/policy/attributes.ts
+function patternRegex(dir, pattern) {
+  if (!pattern || pattern.endsWith("/") || pattern.startsWith('"') || pattern.startsWith("!"))
+    return null;
+  const anchored = pattern.includes("/");
+  const body = pattern.replace(/^\//u, "");
+  let source = "";
+  for (let index = 0;index < body.length; index += 1) {
+    const char = body[index];
+    if (char === "*" && body[index + 1] === "*") {
+      const slash = body[index + 2] === "/";
+      source += slash ? "(?:.*/)?" : ".*";
+      index += slash ? 2 : 1;
+    } else if (char === "*")
+      source += "[^/]*";
+    else if (char === "?")
+      source += "[^/]";
+    else if (char === "[") {
+      const end = body.indexOf("]", index + 2);
+      if (end < 0)
+        return null;
+      const set = body.slice(index + 1, end).replace(/^!/u, "^").replace(/\\/gu, "\\\\");
+      source += `[${set}]`;
+      index = end;
+    } else if (char === "\\" && index + 1 < body.length) {
+      source += body[index + 1].replace(/[.*+?^${}()|[\]\\/]/gu, "\\$&");
+      index += 1;
+    } else
+      source += char.replace(/[.*+?^${}()|[\]\\/]/gu, "\\$&");
+  }
+  const prefix = dir ? `${dir.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}/` : "";
+  try {
+    return new RegExp(anchored ? `^${prefix}${source}$` : `^${prefix}(?:.*/)?${source}$`, "u");
+  } catch {
+    return null;
+  }
+}
+function rulesOf(dir, text) {
+  const out = [];
+  for (const raw of text.split(`
+`)) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#") || line.startsWith("[attr]"))
+      continue;
+    const [pattern, ...attributes] = line.split(/\s+/u);
+    let generated = null;
+    for (const attribute of attributes) {
+      if (attribute === "linguist-generated" || attribute === "linguist-generated=true")
+        generated = true;
+      else if (attribute === "-linguist-generated" || attribute === "!linguist-generated" || attribute.startsWith("linguist-generated="))
+        generated = false;
+    }
+    if (generated === null)
+      continue;
+    const regex = patternRegex(dir, pattern);
+    if (regex)
+      out.push({ regex, generated });
+  }
+  return out;
+}
+function generatedByAttributes(files, paths) {
+  const rules = [...files].map(([file, text]) => {
+    const dir = file.includes("/") ? file.slice(0, file.lastIndexOf("/")) : "";
+    return {
+      depth: dir ? dir.split("/").length : 0,
+      rules: rulesOf(dir, text)
+    };
+  }).toSorted((left, right) => left.depth - right.depth).flatMap((entry) => entry.rules);
+  const out = new Set;
+  for (const file of paths) {
+    const last = rules.findLast((rule) => rule.regex.test(file));
+    if (last?.generated)
+      out.add(file);
+  }
+  return out;
+}
+
+// packages/workit-core/src/core/policy/substance.ts
+function substanceOf(file, text) {
+  const syntax = syntaxOf(file);
+  if (!syntax)
+    return plainSubstance(text);
+  const markup = syntax.block.some(([open]) => open === "<!--");
+  if (markup && (/<(?:script|style)\b|<!\[CDATA\[|<\?/iu.test(text) || /[^>\s][ \t]*<!--/u.test(text)))
+    return plainSubstance(text);
+  return lex(syntax, text);
+}
+function plainSubstance(text) {
+  return text.split(`
+`).map((line) => line.replace(/[ \t\r\f\v]+$/u, "")).filter(Boolean).join(`
+`);
+}
+function lex(syntax, text) {
+  const collapse = !syntax.indented;
+  let out = "";
+  let lineStart = 0;
+  let kept = 0;
+  let pendingSpace = false;
+  const frames = [{ kind: "code", braces: 0 }];
+  let index = 0;
+  if (text.startsWith("#!")) {
+    const end = text.indexOf(`
+`);
+    out = end < 0 ? text : text.slice(0, end);
+    kept = out.length;
+    index = end < 0 ? text.length : end;
+  }
+  const emitCode = (chunk) => {
+    if (collapse && pendingSpace && out.length > lineStart) {
+      const before = out[out.length - 1];
+      if (!NO_SPACE_AFTER.includes(before) && !NO_SPACE_BEFORE.includes(chunk[0]))
+        out += " ";
+    }
+    pendingSpace = false;
+    out += chunk;
+  };
+  const emitVerbatim = (chunk) => {
+    emitCode(chunk);
+    kept = out.length;
+  };
+  const newline = () => {
+    if (!collapse) {
+      let end = out.length;
+      while (end > Math.max(lineStart, kept) && SPACE.test(out[end - 1]))
+        end -= 1;
+      out = out.slice(0, end);
+    }
+    pendingSpace = false;
+    if (out.length > lineStart) {
+      out += `
+`;
+      lineStart = out.length;
+    }
+  };
+  const regexAllowed = () => {
+    let end = out.length;
+    while (end > 0 && /\s/u.test(out[end - 1]))
+      end -= 1;
+    if (end === 0 || REGEX_AFTER.includes(out[end - 1]))
+      return true;
+    let start = end;
+    while (start > 0 && WORD.test(out[start - 1]))
+      start -= 1;
+    return REGEX_KEYWORDS.has(out.slice(start, end));
+  };
+  const scanString = (quote, escapes, multiline) => {
+    const prefix = text.slice(Math.max(0, index - 2), index).match(/[a-z]*$/iu)?.[0] ?? "";
+    const fstring = syntax.fstring === true && /f/iu.test(prefix);
+    let end = index + quote.length;
+    while (end < text.length) {
+      const char = text[end];
+      if (escapes && char === "\\") {
+        end += 2;
+        continue;
+      }
+      if (text.startsWith(quote, end)) {
+        if (fstring && unbalanced(text.slice(index + quote.length, end)))
+          return false;
+        emitVerbatim(text.slice(index, end + quote.length));
+        index = end + quote.length;
+        return true;
+      }
+      if (char === `
+` && !multiline)
+        return false;
+      end += 1;
+    }
+    return false;
+  };
+  while (index < text.length) {
+    const frame = frames[frames.length - 1];
+    const char = text[index];
+    if (frame.kind === "template") {
+      if (char === "\\") {
+        emitVerbatim(text.slice(index, index + 2));
+        index += 2;
+      } else if (char === "`") {
+        emitVerbatim(char);
+        frames.pop();
+        index += 1;
+      } else if (text.startsWith("${", index)) {
+        emitVerbatim("${");
+        frames.push({ kind: "code", braces: 0 });
+        index += 2;
+      } else {
+        out += char;
+        kept = out.length;
+        index += 1;
+      }
+      continue;
+    }
+    if (char === `
+`) {
+      newline();
+      index += 1;
+      continue;
+    }
+    if (SPACE.test(char)) {
+      if (collapse)
+        pendingSpace = true;
+      else
+        out += char;
+      index += 1;
+      continue;
+    }
+    const lineOpener = syntax.line.find((opener) => text.startsWith(opener, index));
+    if (lineOpener) {
+      const end = text.indexOf(`
+`, index);
+      const comment = text.slice(index, end < 0 ? text.length : end);
+      if (DIRECTIVE.test(comment.slice(lineOpener.length)))
+        emitVerbatim(comment);
+      else
+        pendingSpace = true;
+      index = end < 0 ? text.length : end;
+      continue;
+    }
+    const block = syntax.block.find(([open]) => text.startsWith(open, index));
+    if (block) {
+      const end = text.indexOf(block[1], index + block[0].length);
+      if (end < 0)
+        return null;
+      const comment = text.slice(index, end + block[1].length);
+      if (DIRECTIVE.test(comment.slice(block[0].length, -block[1].length)))
+        emitVerbatim(comment);
+      else
+        pendingSpace = true;
+      if (comment.includes(`
+`))
+        newline();
+      index = end + block[1].length;
+      continue;
+    }
+    if (syntax.triple && (char === '"' || char === "'") && text.startsWith(char.repeat(3), index)) {
+      if (!scanString(char.repeat(3), !syntax.literal?.includes(char), true))
+        return null;
+      continue;
+    }
+    if (syntax.quotes.includes(char)) {
+      if (!scanString(char, true, Boolean(syntax.multiline)))
+        return null;
+      continue;
+    }
+    if (syntax.literal?.includes(char)) {
+      if (!scanString(char, false, false))
+        return null;
+      continue;
+    }
+    if (syntax.rawBacktick && char === "`") {
+      if (!scanString("`", false, true))
+        return null;
+      continue;
+    }
+    if (syntax.js && char === "`") {
+      emitVerbatim(char);
+      frames.push({ kind: "template" });
+      index += 1;
+      continue;
+    }
+    if (syntax.cssUrl && /^url\(\s*[^"')\s]/iu.test(text.slice(index, index + 64)))
+      return null;
+    if (syntax.js && char === "/" && !regexAllowed() && out.trimEnd().endsWith(")")) {
+      const lineEnd = text.indexOf(`
+`, index);
+      if (text.slice(index + 1, lineEnd < 0 ? text.length : lineEnd).includes("/"))
+        return null;
+    }
+    if (syntax.js && char === "/" && regexAllowed()) {
+      let end = index + 1;
+      let inClass = false;
+      while (end < text.length && (inClass || text[end] !== "/")) {
+        if (text[end] === `
+`)
+          return null;
+        if (text[end] === "\\")
+          end += 1;
+        else if (text[end] === "[")
+          inClass = true;
+        else if (text[end] === "]")
+          inClass = false;
+        end += 1;
+      }
+      if (end >= text.length)
+        return null;
+      emitVerbatim(text.slice(index, end + 1));
+      index = end + 1;
+      continue;
+    }
+    if (frames.length > 1 && frame.kind === "code") {
+      if (char === "{")
+        frame.braces += 1;
+      else if (char === "}") {
+        if (frame.braces === 0) {
+          emitVerbatim(char);
+          frames.pop();
+          index += 1;
+          continue;
+        }
+        frame.braces -= 1;
+      }
+    }
+    emitCode(char);
+    index += 1;
+  }
+  if (frames.length !== 1)
+    return null;
+  newline();
+  return out;
+}
+function unbalanced(body) {
+  let depth = 0;
+  for (const part of body.replaceAll("{{", "").replaceAll("}}", "")) {
+    if (part === "{")
+      depth += 1;
+    else if (part === "}")
+      depth = Math.max(0, depth - 1);
+  }
+  return depth > 0;
+}
+function hasOpaqueLineBreak(text) {
+  return /\r(?!\n)|[\u2028\u2029]/u.test(text);
+}
+function textOf(bytes) {
+  if (bytes.includes(0))
+    return null;
+  try {
+    return decoder.decode(bytes);
+  } catch {
+    return null;
+  }
+}
+function cosmeticChange(file, before, after) {
+  const left = textOf(before);
+  const right = textOf(after);
+  if (left === null || right === null)
+    return false;
+  if (hasOpaqueLineBreak(left) || hasOpaqueLineBreak(right))
+    return false;
+  const a = substanceOf(file, left);
+  return a !== null && a === substanceOf(file, right);
+}
+var SLASH_BLOCK, C_LIKE, SYNTAXES, DIRECTIVE, extensionOf = (file) => {
+  const name = file.slice(file.lastIndexOf("/") + 1);
+  const dot = name.lastIndexOf(".");
+  return dot > 0 ? name.slice(dot + 1).toLowerCase() : "";
+}, CI_PATH, syntaxOf = (file) => CI_PATH.test(file) ? null : SYNTAXES[extensionOf(file)] ?? null, SPACE, WORD, NO_SPACE_AFTER = "([{,;", NO_SPACE_BEFORE = ")]},;", REGEX_AFTER = "(,=:[!&|?{};+-*%<>~^", REGEX_KEYWORDS, decoder;
+var init_substance = __esm(() => {
+  SLASH_BLOCK = [["/*", "*/"]];
+  C_LIKE = { line: ["//"], block: SLASH_BLOCK, quotes: `"'` };
+  SYNTAXES = Object.fromEntries([
+    ...["ts", "mts", "cts", "js", "mjs", "cjs"].map((ext) => [ext, { ...C_LIKE, js: true }]),
+    ...["java", "kt", "kts", "scala", "swift", "dart", "groovy"].map((ext) => [
+      ext,
+      { ...C_LIKE, triple: true }
+    ]),
+    ["go", { ...C_LIKE, rawBacktick: true }],
+    ...["css", "scss", "less"].map((ext) => [
+      ext,
+      { line: [], block: SLASH_BLOCK, quotes: `"'`, cssUrl: true }
+    ]),
+    ...["py", "pyi"].map((ext) => [
+      ext,
+      { line: ["#"], block: [], quotes: `"'`, triple: true, indented: true, fstring: true }
+    ]),
+    ["toml", { line: ["#"], block: [], quotes: `"`, literal: "'", triple: true }],
+    ...["html", "htm", "xml", "svg", "xhtml"].map((ext) => [
+      ext,
+      { line: [], block: [["<!--", "-->"]], quotes: "", indented: true }
+    ])
+  ]);
+  DIRECTIVE = /@ts-|eslint|prettier|biome|oxlint|istanbul|\bc8\b|\bv8\b|@jsx|@flow|@vite|webpack|__PURE__|__NO_SIDE_EFFECTS__|source(?:Mapping)?URL|^\/\s*<|go:|\+build|nolint|noqa|type:|pyright|mypy|pylint|pragma|coding[:=]|fmt:|NOSONAR|@license|@preserve|@refresh|environment|language=|cython|ruff|isort|deno-|@vitest|@jest|swiftlint|ktlint|checkstyle|suppress|nullable|#(?:end)?region/iu;
+  CI_PATH = /^\.github\/|(?:^|\/)(?:\.gitlab-ci\.ya?ml|Jenkinsfile|azure-pipelines\.ya?ml|\.pre-commit-config\.ya?ml|\.circleci\/.*)$/u;
+  SPACE = /[ \t\r\f\v]/u;
+  WORD = /[\w$]/u;
+  REGEX_KEYWORDS = new Set([
+    "return",
+    "typeof",
+    "instanceof",
+    "case",
+    "do",
+    "else",
+    "in",
+    "of",
+    "new",
+    "delete",
+    "void",
+    "throw",
+    "yield",
+    "await"
+  ]);
+  decoder = new TextDecoder("utf-8", { fatal: true });
+});
+
+// packages/workit-core/src/core/policy/lane.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
 import path10 from "node:path";
+function kindOf(file) {
+  if (file.binary)
+    return "behavior";
+  if (file.generated)
+    return "generated";
+  if (LOCKFILES.has(basename(file.path)))
+    return "lockfile";
+  if (isDoc(file.path))
+    return "doc";
+  if (file.cosmetic)
+    return "cosmetic";
+  return TEST_PATH.test(file.path) ? "test" : "behavior";
+}
+function globMatch(pattern, file) {
+  let regex = globCache.get(pattern);
+  if (!regex) {
+    let source = "";
+    for (let index = 0;index < pattern.length; index += 1) {
+      const char = pattern[index];
+      if (char === "*" && pattern[index + 1] === "*") {
+        source += pattern[index + 2] === "/" ? "(?:[^/]*/)*" : ".*";
+        index += pattern[index + 2] === "/" ? 2 : 1;
+      } else if (char === "*")
+        source += "[^/]*";
+      else if (char === "?")
+        source += "[^/]";
+      else
+        source += char.replace(/[.+^${}()|[\]\\]/gu, "\\$&");
+    }
+    regex = new RegExp(`^${source}$`, "u");
+    globCache.set(pattern, regex);
+  }
+  return regex.test(file) || file.startsWith(`${pattern.replace(/\/$/u, "")}/`);
+}
+function isRiskPath(file, extra = []) {
+  if (extra.some((pattern) => globMatch(pattern, file)))
+    return true;
+  if (RISK_FILES.has(file) || RISK_NAMES.has(basename(file)))
+    return true;
+  if (TEST_PATH.test(file) || isDoc(file))
+    return false;
+  return file.split("/").map((segment, index, all) => index === all.length - 1 ? segment.replace(/\.[^.]+$/u, "") : segment).some((segment) => segment.toLowerCase().split(/[-_.]/u).some((token) => RISK_TOKENS.has(token)));
+}
+function computeLane(input) {
+  const riskFiles = input.files.filter((file) => isRiskPath(file.path, input.riskPaths)).map((file) => file.path);
+  const risky = new Set(riskFiles);
+  const kinds = input.files.map((file) => ({
+    file,
+    kind: risky.has(file.path) ? "behavior" : kindOf(file)
+  }));
+  const behavior = kinds.filter((entry) => entry.kind === "behavior" || entry.kind === "test" || entry.kind === "lockfile");
+  const lines = behavior.filter((entry) => entry.kind !== "lockfile").reduce((sum, entry) => sum + entry.file.added + entry.file.deleted, 0);
+  const opaque = behavior.filter((entry) => entry.kind === "lockfile" || entry.file.binary);
+  const result = (lane, reasons) => ({
+    lane,
+    reasons,
+    lines,
+    files: behavior.length,
+    riskFiles
+  });
+  const { selfMaxLines, selfMaxFiles, fullMinLines } = LANE_THRESHOLDS;
+  if (input.riskTier === "high")
+    return result("full", ["the task judgment records high risk"]);
+  if (riskFiles.length)
+    return result("full", [
+      `touches a risk path: ${riskFiles.slice(0, 3).join(", ")}${riskFiles.length > 3 ? ", …" : ""}`
+    ]);
+  if (!behavior.length)
+    return result("none", [
+      input.files.length ? "only docs, comments, formatting or generated copies changed" : "no changes"
+    ]);
+  if (lines >= fullMinLines)
+    return result("full", [`large diff: ${lines} lines (≥ ${fullMinLines})`]);
+  if (lines > selfMaxLines)
+    return result("focused", [`${lines} lines changed (> ${selfMaxLines})`]);
+  if (behavior.length > selfMaxFiles)
+    return result("focused", [`${behavior.length} behavior files changed (> ${selfMaxFiles})`]);
+  if (opaque.length)
+    return result("focused", [
+      `a lockfile or binary changed: ${opaque.slice(0, 3).map((entry) => entry.file.path).join(", ")}${opaque.length > 3 ? ", …" : ""}`
+    ]);
+  return result("self", [
+    `small change: ${lines} line${lines === 1 ? "" : "s"} in ${behavior.length} file${behavior.length === 1 ? "" : "s"}, no risk path`
+  ]);
+}
+function untrackedStat(cwd, file) {
+  try {
+    const bytes = readFileSync3(path10.join(cwd, file));
+    if (bytes.includes(0))
+      return { path: file, added: 0, deleted: 0, binary: true };
+    const text = bytes.toString("utf8");
+    if (hasOpaqueLineBreak(text))
+      return { path: file, added: 0, deleted: 0, binary: true };
+    const lines = text.split(`
+`).length - (text.endsWith(`
+`) ? 1 : 0);
+    return { path: file, added: lines, deleted: 0 };
+  } catch {
+    return { path: file, added: 0, deleted: 0, binary: true };
+  }
+}
+function cosmeticFiles(cwd, fork, head) {
+  const raw = diffRaw(cwd, fork, head);
+  if (!raw)
+    return null;
+  const candidates = raw.filter((entry) => REGULAR.has(entry.oldMode) && entry.oldMode === entry.newMode && !ABSENT.test(entry.oldBlob) && (head === null || !ABSENT.test(entry.newBlob)));
+  const blobs = readBlobs(cwd, candidates.flatMap((entry) => [entry.oldBlob, entry.newBlob]));
+  if (!blobs)
+    return null;
+  const out = new Set;
+  const opaque = new Set;
+  for (const entry of candidates) {
+    const before = blobs.get(entry.oldBlob);
+    let after = blobs.get(entry.newBlob);
+    if (!after && head === null && ABSENT.test(entry.newBlob))
+      try {
+        after = readFileSync3(path10.join(cwd, entry.path));
+      } catch {
+        after = undefined;
+      }
+    if (before && after && cosmeticChange(entry.path, before, after))
+      out.add(entry.path);
+    else if ([before, after].some((bytes) => bytes && hasOpaqueLineBreak(bytes.toString("utf8"))))
+      opaque.add(entry.path);
+  }
+  return { cosmetic: out, opaque };
+}
+function generatedAt(cwd, fork, paths) {
+  const files = treeFilesNamed(cwd, fork, ".gitattributes");
+  const blobs = files?.size ? readBlobs(cwd, [...files.values()]) : null;
+  if (!files || !blobs)
+    return new Set;
+  const texts = new Map;
+  for (const [file, id] of files) {
+    const bytes = blobs.get(id);
+    if (bytes)
+      texts.set(file, bytes.toString("utf8"));
+  }
+  return generatedByAttributes(texts, paths);
+}
+function laneFiles(cwd, fork, head) {
+  const stats = diffNumstat(cwd, fork, head);
+  const cosmetic = stats ? cosmeticFiles(cwd, fork, head) : null;
+  if (!stats || !cosmetic)
+    return null;
+  const files = [
+    ...stats.map((entry) => ({
+      ...entry,
+      ...cosmetic.opaque.has(entry.path) ? { binary: true } : {},
+      cosmetic: !entry.binary && cosmetic.cosmetic.has(entry.path)
+    })),
+    ...head === null ? untrackedFiles(cwd).map((file) => untrackedStat(cwd, file)) : []
+  ];
+  const generated = generatedAt(cwd, fork, files.map((entry) => entry.path));
+  return files.map((entry) => ({
+    ...entry,
+    generated: generated.has(entry.path)
+  }));
+}
+function branchLane(cwd, options) {
+  const candidates = options.base ? [`origin/${options.base}`, options.base] : [];
+  const base = candidates.find((ref) => resolveRef(cwd, ref) !== null) ?? defaultBase(cwd) ?? null;
+  const head = options.workingTree ? null : options.head;
+  const fork = base && (options.workingTree || options.head) ? forkOf(cwd, base, head) : null;
+  const files = fork ? laneFiles(cwd, fork, head) : null;
+  const riskTier = options.judgment?.riskTier ?? null;
+  if (!fork || !files) {
+    const high = riskTier === "high";
+    return {
+      lane: high ? "full" : "focused",
+      reasons: [
+        `the diff of ${options.head?.slice(0, 12) ?? "(no head)"} against ${base ?? "(no base)"} cannot be read`,
+        ...high ? ["the task judgment records high risk"] : []
+      ],
+      lines: 0,
+      files: 0,
+      riskFiles: [],
+      base,
+      head: options.head
+    };
+  }
+  const repoRisk = parseRiskPaths(fileAt(cwd, fork, RISK_PATHS_FILE) ?? "");
+  return {
+    ...computeLane({
+      files,
+      riskTier,
+      riskPaths: [...repoRisk, ...options.riskPaths ?? []]
+    }),
+    base,
+    head: options.head
+  };
+}
+var LANE_THRESHOLDS, RISK_TOKENS, RISK_FILES, RISK_NAMES, RISK_PATHS_FILE = ".workit/risk-paths", LOCKFILES, DOC_EXT, DOC_NAMES, INSTRUCTIONS, TEST_PATH, basename = (file) => file.slice(file.lastIndexOf("/") + 1), isDoc = (file) => !INSTRUCTIONS.test(file) && (DOC_EXT.test(file) || DOC_NAMES.test(basename(file))), globCache, parseRiskPaths = (text) => text.split(`
+`).map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).map((line) => line.replace(/^\//u, "")), REGULAR, ABSENT, forkOf = (cwd, base, head) => mergeBase(cwd, base, head ?? "HEAD"), laneNeed = (lane) => lane === "none" ? "none" : lane === "self" ? "self" : "non-author";
+var init_lane = __esm(() => {
+  init_rev();
+  init_ops();
+  init_ledger();
+  init_substance();
+  LANE_THRESHOLDS = {
+    selfMaxLines: 100,
+    selfMaxFiles: 5,
+    fullMinLines: 500
+  };
+  RISK_TOKENS = new Set([
+    "auth",
+    "authn",
+    "authz",
+    "oauth",
+    "security",
+    "permission",
+    "permissions",
+    "secret",
+    "secrets",
+    "crypto",
+    "gate",
+    "gates",
+    "policy",
+    "policies",
+    "hook",
+    "hooks",
+    "husky",
+    "lefthook",
+    "release",
+    "releases",
+    "migration",
+    "migrations",
+    "migrate",
+    "workflows"
+  ]);
+  RISK_FILES = new Set([
+    ".gitlab-ci.yml",
+    "Jenkinsfile",
+    "azure-pipelines.yml",
+    ".pre-commit-config.yaml",
+    ".workit/risk-paths"
+  ]);
+  RISK_NAMES = new Set([".gitattributes"]);
+  LOCKFILES = new Set([
+    "bun.lock",
+    "bun.lockb",
+    "package-lock.json",
+    "npm-shrinkwrap.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "Cargo.lock",
+    "go.sum",
+    "poetry.lock",
+    "uv.lock",
+    "Pipfile.lock",
+    "Gemfile.lock",
+    "composer.lock"
+  ]);
+  DOC_EXT = /\.(?:md|mdx|markdown|rst|adoc|txt)$/iu;
+  DOC_NAMES = /^(?:license|licence|notice|authors|changelog|changes|contributors)$/iu;
+  INSTRUCTIONS = /(?:^|\/)(?:AGENTS|CLAUDE|GEMINI|SKILL)\.md$|(?:^|\/)(?:skills|agents|commands|rules|prompts)\/[^/]+/iu;
+  TEST_PATH = /(?:^|\/)(?:test|tests|__tests__|spec|specs|fixtures)\/|\.(?:test|spec)\.[^/]+$/iu;
+  globCache = new Map;
+  REGULAR = new Set(["100644", "100755"]);
+  ABSENT = /^0+$/u;
+});
+
+// packages/workit-core/src/core/policy/derive.ts
+import { existsSync as existsSync3 } from "node:fs";
+import path11 from "node:path";
 function deriveRequirements(judgment, scope, constraints, verification = "self") {
   const out = [];
   const base = { scope, dependentAction: null };
+  const proportional = verification === "proportional";
   if (judgment.behaviorChange)
     out.push(derived2({
       ...base,
@@ -10084,7 +10899,17 @@ function deriveRequirements(judgment, scope, constraints, verification = "self")
       before: "close",
       acceptanceAllowed: false
     }));
-  if (judgment.behaviorChange && judgment.riskTier === "normal")
+  if (proportional && judgment.riskTier === "normal")
+    out.push(derived2({
+      ...base,
+      ruleId: RULES.lane,
+      dimension: "review",
+      reason: "The review lane computed from the diff decides the verdict: none needs none, self the author's own (shown as self-reviewed), focused and full a non-author one.",
+      satisfaction: "Read the lane in `workit policy assess` or `workit pr status`; record what it asks: `workit ledger verdict tests-verified --self --how <what you ran>` for self, or hand focused and full to a verifier.",
+      before: "close",
+      acceptanceAllowed: false
+    }));
+  if (!proportional && judgment.behaviorChange && judgment.riskTier === "normal")
     out.push(verification === "independent" ? derived2({
       ...base,
       ruleId: RULES.nonAuthor,
@@ -10163,7 +10988,9 @@ function derivedRuleStatus(task, requirement, root, ledger) {
     case RULES.self:
     case RULES.nonAuthor:
     case RULES.verified:
-      return verdict(requirement, root, ledger);
+      return verdict(requirement.ruleId, root, ledger);
+    case RULES.lane:
+      return laneVerdict(task, root, ledger);
     default:
       return null;
   }
@@ -10222,7 +11049,7 @@ var RULES, derived2 = (spec) => ({
     decisionIds: []
   };
 }, planRecorded = (task, root) => {
-  const cited = (latestJudgment(task)?.refs ?? []).find((ref) => ref.kind === "external" || ref.kind === "file" && existsSync2(path10.resolve(root, ref.path)));
+  const cited = (latestJudgment(task)?.refs ?? []).find((ref) => ref.kind === "external" || ref.kind === "file" && existsSync3(path11.resolve(root, ref.path)));
   if (cited)
     return {
       met: true,
@@ -10235,14 +11062,28 @@ var RULES, derived2 = (spec) => ({
     reason: "no plan recorded: write it (docs/ and Markdown writes stay allowed), then `workit policy assess --ref <path>`",
     decisionIds: []
   };
-}, verdict = (requirement, root, ledger) => {
+}, workingLane = (task, root) => branchLane(root, { head: null, workingTree: true, judgment: latestJudgment(task) }), laneVerdict = (task, root, ledger) => {
+  if (!ledger.branch() && latestJudgment(task)?.behaviorChange === false)
+    return {
+      met: true,
+      reason: "no branch to read a lane from, and the judgment records no behavior change",
+      decisionIds: []
+    };
+  const lane = workingLane(task, root);
+  const label = `lane ${lane.lane} (${lane.reasons.join("; ")})`;
+  const need = laneNeed(lane.lane);
+  if (need === "none")
+    return { met: true, reason: `${label}: no verdict needed`, decisionIds: [] };
+  const status = verdict(need === "self" ? RULES.self : RULES.nonAuthor, root, ledger);
+  return { ...status, reason: `${label}: ${status.reason}` };
+}, verdict = (ruleId, root, ledger) => {
   const branch = ledger.branch();
   if (!branch)
     return { met: false, reason: "no branch is checked out to hold a verdict", decisionIds: [] };
   const check = checkVerdicts(root, branch, ledger.rows());
   const failing = check.accepted.reasons.includes("failing_verdict");
   const strong = (entry) => STRONG_RESULTS.has(String(entry.verdict.result));
-  const met = !failing && (requirement.ruleId === RULES.verified ? check.verdicts.find((entry) => entry.accepted && entry.kind === "live" && String(entry.verdict.result) === "verified") : requirement.ruleId === RULES.nonAuthor ? check.verdicts.find((entry) => entry.accepted && strong(entry)) : check.verdicts.find((entry) => entry.current && strong(entry)));
+  const met = !failing && (ruleId === RULES.verified ? check.verdicts.find((entry) => entry.accepted && entry.kind === "live" && String(entry.verdict.result) === "verified") : ruleId === RULES.nonAuthor ? check.verdicts.find((entry) => entry.accepted && strong(entry)) : check.verdicts.find((entry) => entry.current && strong(entry)));
   if (met)
     return {
       met: true,
@@ -10250,18 +11091,20 @@ var RULES, derived2 = (spec) => ({
       decisionIds: []
     };
   const why = failing ? "a current independent verdict fails" : check.verdicts.some((entry) => entry.current && entry.verdict.result === "type-check-only") ? "type-check-only does not prove a behavior change" : (check.accepted.reasons.join(", ") || "no_verdict").replace(/_/g, " ");
-  const unblock = requirement.ruleId === RULES.self ? "record your own verdict after an observed `workit check test`: `workit ledger verdict tests-verified --self --how <what you ran>` (shown as self-reviewed), or have a verifier record one" : `an independent session records \`workit ledger verdict verified${requirement.ruleId === RULES.verified ? " --kind live" : ""} --how <what it exercised>\``;
+  const unblock = ruleId === RULES.self ? "record your own verdict after an observed `workit check test`: `workit ledger verdict tests-verified --self --how <what you ran>` (shown as self-reviewed), or have a verifier record one" : `an independent session records \`workit ledger verdict verified${ruleId === RULES.verified ? " --kind live" : ""} --how <what it exercised>\``;
   return { met: false, reason: `${why}: ${unblock}`, decisionIds: [] };
 };
 var init_derive = __esm(() => {
   init_rev();
   init_ledger();
+  init_lane();
   init_task_contract();
   RULES = {
     test: "check:test",
     self: "verdict:self",
     nonAuthor: "verdict:non-author",
     verified: "verdict:verified",
+    lane: "verdict:lane",
     product: "decision:product",
     plan: "plan"
   };
@@ -10819,7 +11662,7 @@ var init_safe_write = () => {};
 
 // packages/workit-core/src/autonomy.ts
 import os4 from "node:os";
-import path11 from "node:path";
+import path12 from "node:path";
 function endpointOf(entry) {
   const raw = entry?.defaultEndpoint;
   if (raw === undefined)
@@ -10916,10 +11759,13 @@ var accountHome = () => {
   } catch {
     return os4.homedir();
   }
-}, grantsHome, grantsDir = () => path11.join(grantsHome.resolve(), ".config", "workit"), grantsOverride = () => {
-  const configured = path11.resolve(resolveConfigDir());
-  return configured === path11.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 ${path11.join(grantsDir(), "workspaces.json")}, so the D4 defaults apply`;
-}, GRANT_KINDS, DEFAULT_GRANTS, DEFAULT_ENDPOINTS, DEFAULT_ENDPOINT = "commit", isDefaultEndpoint = (value) => typeof value === "string" && DEFAULT_ENDPOINTS.includes(value), DEFAULT_VERIFICATION = "self", verificationOf = (entry) => entry?.verification === "independent" ? "independent" : "self", isGrantValue = (value) => value === true || value === false || value === "verified", normalized = (kind, value) => value === "verified" && kind !== "merge" ? true : value, fromAutoApprove = (value) => {
+}, grantsHome, grantsDir = () => path12.join(grantsHome.resolve(), ".config", "workit"), grantsOverride = () => {
+  const configured = path12.resolve(resolveConfigDir());
+  return configured === path12.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 ${path12.join(grantsDir(), "workspaces.json")}, so the D4 defaults apply`;
+}, GRANT_KINDS, DEFAULT_GRANTS, DEFAULT_ENDPOINTS, DEFAULT_ENDPOINT = "commit", isDefaultEndpoint = (value) => typeof value === "string" && DEFAULT_ENDPOINTS.includes(value), VERIFICATION_MODES, DEFAULT_VERIFICATION = "proportional", verificationOf = (entry) => {
+  const value = entry?.verification;
+  return VERIFICATION_MODES.includes(value) ? value : DEFAULT_VERIFICATION;
+}, isGrantValue = (value) => value === true || value === false || value === "verified", normalized = (kind, value) => value === "verified" && kind !== "merge" ? true : value, fromAutoApprove = (value) => {
   if (value === true)
     return { push: true, pr: true, merge: "verified" };
   if (!Array.isArray(value))
@@ -10946,6 +11792,11 @@ var init_autonomy = __esm(() => {
     rerun: true
   });
   DEFAULT_ENDPOINTS = ["commit", "pr", "green", "merged"];
+  VERIFICATION_MODES = [
+    "proportional",
+    "self",
+    "independent"
+  ];
 });
 
 // node_modules/@openclaw/fs-safe/dist/errors.js
@@ -11058,7 +11909,7 @@ var init_read_open_flags = () => {};
 // node_modules/@openclaw/fs-safe/dist/sidecar-lock-reclaim.js
 import { randomBytes as randomBytes3 } from "node:crypto";
 import fsSync from "node:fs";
-import path12 from "node:path";
+import path13 from "node:path";
 function parseSidecarLockSnapshot(snapshot, parser) {
   return snapshot && { ...snapshot, payload: parseSidecarLockPayload(snapshot.raw, parser) };
 }
@@ -11086,13 +11937,13 @@ ${ownershipToken}
   return { raw, ownershipToken };
 }
 function relativeSidecarLockPath(lockRoot, lockPath) {
-  const resolved = path12.resolve(lockPath);
-  const lexicalRelative = path12.relative(lockRoot.rootDir, resolved);
-  const relative = lexicalRelative !== ".." && !lexicalRelative.startsWith(`..${path12.sep}`) && !path12.isAbsolute(lexicalRelative) ? lexicalRelative : path12.relative(lockRoot.rootReal, resolved);
-  if (!relative || relative === ".." || relative.startsWith(`..${path12.sep}`) || path12.isAbsolute(relative)) {
+  const resolved = path13.resolve(lockPath);
+  const lexicalRelative = path13.relative(lockRoot.rootDir, resolved);
+  const relative = lexicalRelative !== ".." && !lexicalRelative.startsWith(`..${path13.sep}`) && !path13.isAbsolute(lexicalRelative) ? lexicalRelative : path13.relative(lockRoot.rootReal, resolved);
+  if (!relative || relative === ".." || relative.startsWith(`..${path13.sep}`) || path13.isAbsolute(relative)) {
     throw new FsSafeError("outside-workspace", "sidecar lock path is outside lockRoot");
   }
-  return relative.split(path12.sep).join(path12.posix.sep);
+  return relative.split(path13.sep).join(path13.posix.sep);
 }
 function parseSidecarLockPayload(raw, parser) {
   if (parser) {
@@ -11262,7 +12113,7 @@ function sleepSync(ms) {
 
 // node_modules/@openclaw/fs-safe/dist/file-lock-sync.js
 import fs10 from "node:fs";
-import path13 from "node:path";
+import path14 from "node:path";
 function getSyncHeldLocks() {
   const globalWithState = globalThis;
   if (!globalWithState[SYNC_HELD_LOCKS_KEY]) {
@@ -11340,26 +12191,26 @@ function canonicalLockParentSync(parent) {
   return process.platform === "win32" ? fs10.realpathSync.native(parent) : fs10.realpathSync(parent);
 }
 function normalizeTargetPath(targetPath) {
-  const resolved = path13.resolve(targetPath);
-  fs10.mkdirSync(path13.dirname(resolved), { recursive: true });
+  const resolved = path14.resolve(targetPath);
+  fs10.mkdirSync(path14.dirname(resolved), { recursive: true });
   try {
-    return path13.join(canonicalLockParentSync(path13.dirname(resolved)), path13.basename(resolved));
+    return path14.join(canonicalLockParentSync(path14.dirname(resolved)), path14.basename(resolved));
   } catch {
     return resolved;
   }
 }
 function boundedLockPath(lockPath, lockRoot) {
-  const resolved = path13.resolve(lockPath);
+  const resolved = path14.resolve(lockPath);
   if (!lockRoot)
     return resolved;
   relativeSidecarLockPath(lockRoot, resolved);
-  const parent = path13.dirname(resolved);
+  const parent = path14.dirname(resolved);
   const parentReal = canonicalLockParentSync(parent);
-  const parentRelative = path13.relative(lockRoot.rootReal, parentReal);
-  if (parentRelative === ".." || parentRelative.startsWith(`..${path13.sep}`) || path13.isAbsolute(parentRelative)) {
+  const parentRelative = path14.relative(lockRoot.rootReal, parentReal);
+  if (parentRelative === ".." || parentRelative.startsWith(`..${path14.sep}`) || path14.isAbsolute(parentRelative)) {
     throw new FsSafeError("outside-workspace", "sidecar lock parent is outside lockRoot");
   }
-  return path13.join(parentReal, path13.basename(resolved));
+  return path14.join(parentReal, path14.basename(resolved));
 }
 function defaultShouldReclaim(snapshot, staleMs, nowMs) {
   const createdAtMs = sidecarLockPayloadCreatedAtMs(snapshot.payload);
@@ -11575,14 +12426,14 @@ var init_file_lock = __esm(() => {
 });
 
 // packages/workit-core/src/core/package-root.ts
-import { existsSync as existsSync3 } from "node:fs";
-import path14 from "node:path";
+import { existsSync as existsSync4 } from "node:fs";
+import path15 from "node:path";
 import { fileURLToPath } from "node:url";
 var packageRoot = () => {
-  let dir = path14.dirname(fileURLToPath(import.meta.url));
+  let dir = path15.dirname(fileURLToPath(import.meta.url));
   while (true) {
-    const parent = path14.dirname(dir);
-    if (existsSync3(path14.join(dir, "package.json")) || parent === dir)
+    const parent = path15.dirname(dir);
+    if (existsSync4(path15.join(dir, "package.json")) || parent === dir)
       return dir;
     dir = parent;
   }
@@ -11592,7 +12443,7 @@ var init_package_root = () => {};
 // packages/workit-core/src/store/event-log.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
 import fs11 from "node:fs";
-import path15 from "node:path";
+import path16 from "node:path";
 function readLog(file, from = 0, expectSeq = null) {
   let fd;
   try {
@@ -11665,7 +12516,7 @@ function appendEvent(file, event, validEnd) {
     fs11.closeSync(fd);
   }
   if (created)
-    fsyncDirectory(path15.dirname(file));
+    fsyncDirectory(path16.dirname(file));
   return validEnd;
 }
 function replaceFile(file, bytes, durable) {
@@ -11681,7 +12532,7 @@ function replaceFile(file, bytes, durable) {
     }
     renameWithRetry(temporary, file);
     if (durable)
-      fsyncDirectory(path15.dirname(file));
+      fsyncDirectory(path16.dirname(file));
   } catch (error) {
     try {
       fs11.unlinkSync(temporary);
@@ -11991,7 +12842,7 @@ var init_notes = __esm(() => {
 // packages/workit-core/src/core/task-store.ts
 import { createHash as createHash11, randomUUID as randomUUID3 } from "node:crypto";
 import * as fs12 from "node:fs";
-import path16 from "node:path";
+import path17 from "node:path";
 
 class TaskStore {
   root;
@@ -12003,7 +12854,7 @@ class TaskStore {
   migrationChecked = false;
   compactDue = new Set;
   constructor(root, options = {}) {
-    const resolved = path16.resolve(root);
+    const resolved = path17.resolve(root);
     this.origin = fs12.existsSync(resolved) ? fs12.realpathSync(resolved) : resolved;
     this.located = resolveStore(this.origin);
     this.root = checkoutRootOf(this.origin, this.located);
@@ -12012,7 +12863,7 @@ class TaskStore {
     this.migrateOnRead = options.migrateOnRead;
   }
   location() {
-    if (this.located !== undefined && !(this.located instanceof Error) && !this.located.shared && fs12.existsSync(path16.join(this.root, ".git"))) {
+    if (this.located !== undefined && !(this.located instanceof Error) && !this.located.shared && fs12.existsSync(path17.join(this.root, ".git"))) {
       this.located = undefined;
       this.migrationChecked = false;
     }
@@ -12168,7 +13019,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" : path16.basename(this.root) || this.root;
+      const label = key.kind === "branch" ? `branch ${key.branch}` : key.kind === "detached" ? "a detached HEAD" : path17.basename(this.root) || this.root;
       const intent = {
         objective: input.objective?.trim() || `Work on ${label}`,
         scope: { description: `the checkout (${label})`, paths: ["."], exclusions: [] },
@@ -12234,14 +13085,14 @@ class TaskStore {
     const branch = key.ok ? key.data.branch : null;
     if (!branch || !location.ok)
       return success(null, null, null);
-    const common = path16.dirname(location.data.dir);
-    const heads = path16.join(common, "logs", "refs", "heads");
-    const headLog = location.data.git ? path16.join(location.data.git.gitDir, "logs", "HEAD") : "";
+    const common = path17.dirname(location.data.dir);
+    const heads = path17.join(common, "logs", "refs", "heads");
+    const headLog = location.data.git ? path17.join(location.data.git.gitDir, "logs", "HEAD") : "";
     const signatures = [
-      path16.join(heads, branch),
+      path17.join(heads, branch),
       headLog,
       heads,
-      path16.join(common, "packed-refs")
+      path17.join(common, "packed-refs")
     ].map((file) => fileSignature(file) ?? "-");
     const slot = `${location.data.dir}\x00${headLog}\x00${branch}`;
     let resolved = origins.get(slot);
@@ -12253,7 +13104,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(path16.join(common, "config")).includes(`[remote "${start.slice(0, slash)}"]`));
+      const remote = slash > 0 && !refExists(common, `refs/heads/${start}`) && (refExists(common, `refs/remotes/${start}`) || readText(path17.join(common, "config")).includes(`[remote "${start.slice(0, slash)}"]`));
       const name = start && (remote ? start.slice(slash + 1) : start);
       resolved = {
         signature: signatures.join("|"),
@@ -12491,13 +13342,13 @@ class TaskStore {
     if (!ready.ok)
       return ready;
     const dirs = this.paths();
-    const recovery = path16.join(this.root, ".workit", "recovery");
+    const recovery = path17.join(this.root, ".workit", "recovery");
     if (fs12.existsSync(recovery)) {
       let files = 0;
       let bytes = 0;
       try {
         for (const name of fs12.readdirSync(recovery)) {
-          const stat = fs12.lstatSync(path16.join(recovery, name));
+          const stat = fs12.lstatSync(path17.join(recovery, name));
           if (!stat.isFile())
             continue;
           files += 1;
@@ -12550,7 +13401,7 @@ class TaskStore {
       if (fs12.existsSync(dirs.blobs))
         for (const name of fs12.readdirSync(dirs.blobs)) {
           const digest = name.replace(/\.json$/, "");
-          const file = path16.join(dirs.blobs, name);
+          const file = path17.join(dirs.blobs, name);
           let stat;
           try {
             stat = fs12.lstatSync(file);
@@ -12568,7 +13419,7 @@ class TaskStore {
         }
       return success(null, null, null);
     };
-    const swept = dryRun ? sweep() : this.withLock(path16.join(dirs.dir, "gc.lock"), sweep);
+    const swept = dryRun ? sweep() : this.withLock(path17.join(dirs.dir, "gc.lock"), sweep);
     if (!swept.ok)
       return swept;
     const temporaryDirs = [
@@ -12576,7 +13427,7 @@ class TaskStore {
       dirs.tasks,
       dirs.blobs,
       dirs.checkout,
-      ...names.map((name) => path16.join(dirs.tasks, name))
+      ...names.map((name) => path17.join(dirs.tasks, name))
     ];
     for (const directory of temporaryDirs) {
       if (!fs12.existsSync(directory))
@@ -12584,7 +13435,7 @@ class TaskStore {
       for (const name of fs12.readdirSync(directory)) {
         if (!name.endsWith(".tmp") && !name.endsWith(".probe"))
           continue;
-        const file = path16.join(directory, name);
+        const file = path17.join(directory, name);
         try {
           const stat = fs12.lstatSync(file);
           if (!stat.isFile() || nowMs - stat.mtimeMs <= STALE_TEMPORARY_MS)
@@ -12601,30 +13452,30 @@ class TaskStore {
   }
   paths() {
     const location = this.location();
-    const dir = location.ok ? location.data.dir : path16.join(this.root, ".workit");
-    const checkout = path16.join(dir, "checkouts", checkoutSlug(this.root));
+    const dir = location.ok ? location.data.dir : path17.join(this.root, ".workit");
+    const checkout = path17.join(dir, "checkouts", checkoutSlug(this.root));
     return {
       dir,
       shared: location.ok ? location.data.shared : false,
-      marker: path16.join(dir, "store.json"),
+      marker: path17.join(dir, "store.json"),
       checkout,
-      workspace: path16.join(checkout, "workspace.json"),
-      checkoutLock: path16.join(checkout, "metadata.lock"),
-      tasks: path16.join(dir, "tasks"),
-      index: path16.join(dir, "task-index.json"),
-      blobs: path16.join(dir, "blobs", "candidates"),
-      legacy: path16.join(dir, "legacy", checkoutSlug(this.root), "v2"),
-      v2: path16.join(this.root, ".workit")
+      workspace: path17.join(checkout, "workspace.json"),
+      checkoutLock: path17.join(checkout, "metadata.lock"),
+      tasks: path17.join(dir, "tasks"),
+      index: path17.join(dir, "task-index.json"),
+      blobs: path17.join(dir, "blobs", "candidates"),
+      legacy: path17.join(dir, "legacy", checkoutSlug(this.root), "v2"),
+      v2: path17.join(this.root, ".workit")
     };
   }
   eventsPath(taskId) {
-    return path16.join(this.paths().tasks, taskId, "events.jsonl");
+    return path17.join(this.paths().tasks, taskId, "events.jsonl");
   }
   snapshotPath(taskId) {
-    return path16.join(this.paths().tasks, taskId, "snapshot.json");
+    return path17.join(this.paths().tasks, taskId, "snapshot.json");
   }
   taskLockPath(taskId) {
-    return path16.join(this.paths().tasks, taskId, "lock");
+    return path17.join(this.paths().tasks, taskId, "lock");
   }
   ready(write = false) {
     const location = this.location();
@@ -12663,13 +13514,13 @@ class TaskStore {
     return {
       read: (digest) => {
         try {
-          return JSON.parse(fs12.readFileSync(path16.join(dir, `${digest}.json`), "utf8"));
+          return JSON.parse(fs12.readFileSync(path17.join(dir, `${digest}.json`), "utf8"));
         } catch (error) {
           throw new LogDamage(`stored candidate ${digest} is missing or unreadable: ${String(error)}`);
         }
       },
       write: (digest, value) => {
-        const file = path16.join(dir, `${digest}.json`);
+        const file = path17.join(dir, `${digest}.json`);
         if (fs12.existsSync(file)) {
           const stamp = new Date;
           try {
@@ -12861,7 +13712,7 @@ class TaskStore {
     }
   }
   openTask(record, type, key, legacy = null) {
-    const dir = path16.join(this.paths().tasks, record.id);
+    const dir = path17.join(this.paths().tasks, record.id);
     fs12.mkdirSync(dir, { recursive: true });
     const blobs = this.blobStore();
     const bound = key ? { ...key, boundAt: key.boundAt ?? new Date().toISOString() } : null;
@@ -12954,7 +13805,7 @@ class TaskStore {
   }
   withKeyLock(key, operation) {
     const digest = createHash11("sha256").update(key).digest("hex").slice(0, 32);
-    return this.withLock(path16.join(this.paths().dir, "keys", `${digest}.lock`), operation);
+    return this.withLock(path17.join(this.paths().dir, "keys", `${digest}.lock`), operation);
   }
   bindLocked(taskId, key, timestamp) {
     const current = this.readWorkspace();
@@ -13095,7 +13946,7 @@ class TaskStore {
   writeWorkspace(record) {
     const file = this.paths().workspace;
     try {
-      fs12.mkdirSync(path16.dirname(file), { recursive: true });
+      fs12.mkdirSync(path17.dirname(file), { recursive: true });
       replaceFile(file, `${canonicalJson(record)}
 `, true);
       return success(null, null, null);
@@ -13173,23 +14024,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) => path16.join(dir, ".workit"));
+    return [...new Set([this.root, this.origin])].map((dir) => path17.join(dir, ".workit"));
   }
   pendingMigrations() {
     return this.v2Dirs().filter((dir) => {
-      const raw = this.readV2Workspace(path16.join(dir, "workspace.json"));
+      const raw = this.readV2Workspace(path17.join(dir, "workspace.json"));
       return raw !== null && raw !== TOMBSTONE;
     });
   }
   migrateV2(v2) {
     const dirs = this.paths();
-    const v2Workspace = path16.join(v2, "workspace.json");
-    const v2Tasks = path16.join(v2, "tasks");
-    const legacy = path16.join(dirs.dir, "legacy", checkoutSlug(path16.dirname(v2)), "v2");
+    const v2Workspace = path17.join(v2, "workspace.json");
+    const v2Tasks = path17.join(v2, "tasks");
+    const legacy = path17.join(dirs.dir, "legacy", checkoutSlug(path17.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(path16.join(v2, "metadata.lock"), () => {
+    return this.withLock(dirs.checkoutLock, () => this.withLock(path17.join(v2, "metadata.lock"), () => {
       const workspace = this.readV2Workspace(v2Workspace);
       if (workspace === null || workspace === TOMBSTONE)
         return success(null, null, null);
@@ -13198,7 +14049,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 = fs12.readdirSync(v2Tasks).filter((name) => name.endsWith(".json") && validId(name.slice(0, -5))).filter((name) => !this.isStub(path16.join(v2Tasks, name)));
+        files = fs12.readdirSync(v2Tasks).filter((name) => name.endsWith(".json") && validId(name.slice(0, -5))).filter((name) => !this.isStub(path17.join(v2Tasks, name)));
       } catch {}
       const current = this.readWorkspace();
       if (!current.ok)
@@ -13216,21 +14067,21 @@ class TaskStore {
       let skipped = 0;
       const done = new Map;
       try {
-        fs12.mkdirSync(path16.join(legacy, "tasks"), { recursive: true });
+        fs12.mkdirSync(path17.join(legacy, "tasks"), { recursive: true });
         for (const name of ["workspace.json", "index.json"])
-          if (fs12.existsSync(path16.join(v2, name)))
-            fs12.copyFileSync(path16.join(v2, name), path16.join(legacy, name));
+          if (fs12.existsSync(path17.join(v2, name)))
+            fs12.copyFileSync(path17.join(v2, name), path17.join(legacy, name));
         for (const name of files) {
           const id = name.slice(0, -5);
-          const file = path16.join(v2Tasks, name);
+          const file = path17.join(v2Tasks, name);
           const bytes = fs12.readFileSync(file, "utf8");
           const digest = sha256(bytes);
-          fs12.writeFileSync(path16.join(legacy, "tasks", name), bytes);
+          fs12.writeFileSync(path17.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: path16.join(legacy, "tasks", name), digest };
+          const origin = { path: path17.join(legacy, "tasks", name), digest };
           if (!fs12.existsSync(this.eventsPath(id))) {
             this.openTask(record, "migrated.from_v2", null, origin);
             migrated += 1;
@@ -13266,7 +14117,7 @@ class TaskStore {
       try {
         let complete = true;
         for (const [name, digest] of done) {
-          const file = path16.join(v2Tasks, name);
+          const file = path17.join(v2Tasks, name);
           if (sha256(fs12.readFileSync(file, "utf8")) !== digest) {
             complete = false;
             continue;
@@ -13277,7 +14128,7 @@ class TaskStore {
           return failure2("busy", `the 2.x store at ${v2} changed during migration; retry`, {
             path: v2
           });
-        fs12.rmSync(path16.join(v2, "index.json"), { force: true });
+        fs12.rmSync(path17.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)}`, {
@@ -13297,7 +14148,7 @@ class TaskStore {
   }
   adoptLocalStore() {
     const dirs = this.paths();
-    const marker = path16.join(dirs.v2, "store.json");
+    const marker = path17.join(dirs.v2, "store.json");
     if (!dirs.shared || !fs12.existsSync(marker))
       return success(null, null, null);
     return this.withLock(dirs.checkoutLock, () => {
@@ -13307,7 +14158,7 @@ class TaskStore {
       try {
         const merge = (from, to) => {
           if (!fs12.existsSync(to)) {
-            fs12.mkdirSync(path16.dirname(to), { recursive: true });
+            fs12.mkdirSync(path17.dirname(to), { recursive: true });
             try {
               fs12.renameSync(from, to);
             } catch {
@@ -13318,24 +14169,24 @@ class TaskStore {
           }
           if (fs12.lstatSync(from).isDirectory() && fs12.lstatSync(to).isDirectory())
             for (const name of fs12.readdirSync(from))
-              merge(path16.join(from, name), path16.join(to, name));
+              merge(path17.join(from, name), path17.join(to, name));
         };
         for (const sub of ["tasks", "checkouts", "blobs", "legacy"]) {
-          const from = path16.join(dirs.v2, sub);
+          const from = path17.join(dirs.v2, sub);
           if (!fs12.existsSync(from))
             continue;
           if (sub === "tasks") {
             for (const name of fs12.readdirSync(from))
-              if (validId(name) && !fs12.existsSync(path16.join(dirs.dir, sub, name)))
+              if (validId(name) && !fs12.existsSync(path17.join(dirs.dir, sub, name)))
                 tasks += 1;
           }
-          merge(from, path16.join(dirs.dir, sub));
+          merge(from, path17.join(dirs.dir, sub));
         }
-        const ledger = path16.join(dirs.v2, "ledger");
-        if (fs12.existsSync(ledger) && !fs12.existsSync(path16.join(dirs.dir, "ledger")))
-          merge(ledger, path16.join(dirs.dir, "ledger"));
-        fs12.rmSync(path16.join(dirs.v2, "task-index.json"), { force: true });
-        fs12.renameSync(marker, path16.join(dirs.v2, "store.moved.json"));
+        const ledger = path17.join(dirs.v2, "ledger");
+        if (fs12.existsSync(ledger) && !fs12.existsSync(path17.join(dirs.dir, "ledger")))
+          merge(ledger, path17.join(dirs.dir, "ledger"));
+        fs12.rmSync(path17.join(dirs.v2, "task-index.json"), { force: true });
+        fs12.renameSync(marker, path17.join(dirs.v2, "store.moved.json"));
       } catch (error) {
         return failure2("storage_error", `cannot move ${dirs.v2} into ${dirs.dir}: ${String(error)}`, {
           path: dirs.v2
@@ -13373,7 +14224,7 @@ class TaskStore {
       schemaVersion: SCHEMA_VERSION,
       id: workspaceId ?? newId(),
       revision: newRevision(),
-      root: path16.dirname(v2),
+      root: path17.dirname(v2),
       runtime: { createdWith: version, updatedWith: version },
       writer: null,
       store: {
@@ -13385,11 +14236,11 @@ class TaskStore {
       critical: ["store"]
     };
     fs12.mkdirSync(v2, { recursive: true });
-    const ignore = path16.join(v2, ".gitignore");
+    const ignore = path17.join(v2, ".gitignore");
     if (!fs12.existsSync(ignore))
       fs12.writeFileSync(ignore, `*
 `);
-    replaceFile(path16.join(v2, "workspace.json"), `${JSON.stringify(marker, null, 2)}
+    replaceFile(path17.join(v2, "workspace.json"), `${JSON.stringify(marker, null, 2)}
 `, true);
   }
   stubFor(taskId) {
@@ -13413,8 +14264,8 @@ class TaskStore {
   }
   writeTombstoneIfMissing() {
     try {
-      const v2 = path16.join(this.root, ".workit");
-      if (fs12.existsSync(path16.join(v2, "workspace.json")))
+      const v2 = path17.join(this.root, ".workit");
+      if (fs12.existsSync(path17.join(v2, "workspace.json")))
         return;
       let id = null;
       try {
@@ -13431,7 +14282,7 @@ class TaskStore {
       replaceFile(dirs.marker, `${JSON.stringify({ format: "workit-store", version: STORE_FORMAT, createdWith: runtimeVersion() })}
 `, false);
     if (!dirs.shared) {
-      const ignore = path16.join(dirs.dir, ".gitignore");
+      const ignore = path17.join(dirs.dir, ".gitignore");
       let current = null;
       try {
         current = fs12.readFileSync(ignore, "utf8");
@@ -13491,7 +14342,7 @@ class TaskStore {
   withLock(lockPath, operation) {
     try {
       this.initializeStorage();
-      fs12.mkdirSync(path16.dirname(lockPath), { recursive: true });
+      fs12.mkdirSync(path17.dirname(lockPath), { recursive: true });
     } catch (error) {
       return failure2("storage_error", `unable to initialize store: ${String(error)}`, {
         path: this.paths().dir
@@ -13554,7 +14405,7 @@ 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 ${path16.dirname(lockPath)}.`
+        guidance: `Check permissions and the read-only attribute on ${path17.dirname(lockPath)}.`
       });
     if (code === "EEXIST" || code === "file_lock_timeout" || code === "file_lock_stale" || isTransientWindowsError(error)) {
       let lock = null;
@@ -13612,7 +14463,7 @@ var MIGRATION_PENDING = "workit migration pending", STORE_FORMAT = 3, STORE_MIN_
 }, now = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z"), oldestFirst = (left, right) => left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id), cachedRuntimeVersion = null, runtimeVersion = () => {
   if (cachedRuntimeVersion === null) {
     try {
-      const pkg = JSON.parse(fs12.readFileSync(path16.join(packageRoot(), "package.json"), "utf8"));
+      const pkg = JSON.parse(fs12.readFileSync(path17.join(packageRoot(), "package.json"), "utf8"));
       cachedRuntimeVersion = typeof pkg.version === "string" && pkg.version ? pkg.version : "0.0.0";
     } catch {
       cachedRuntimeVersion = "0.0.0";
@@ -13639,7 +14490,7 @@ var MIGRATION_PENDING = "workit migration pending", STORE_FORMAT = 3, STORE_MIN_
     return "";
   }
 }, REFLOG_LINE, branchStart = (location, branch, aliases) => {
-  const first = readText(path16.join(path16.dirname(location.dir), "logs", "refs", "heads", branch)).split(`
+  const first = readText(path17.join(path17.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];
@@ -13649,7 +14500,7 @@ var MIGRATION_PENDING = "workit migration pending", STORE_FORMAT = 3, STORE_MIN_
     return start;
   if (!location.git)
     return null;
-  for (const line of readText(path16.join(location.git.gitDir, "logs", "HEAD")).split(`
+  for (const line of readText(path17.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]);
@@ -13658,12 +14509,12 @@ var MIGRATION_PENDING = "workit migration pending", STORE_FORMAT = 3, STORE_MIN_
       return moved[1];
   }
   return null;
-}, refExists = (common, ref) => fs12.existsSync(path16.join(common, ref)) || readText(path16.join(common, "packed-refs")).includes(` ${ref}
+}, refExists = (common, ref) => fs12.existsSync(path17.join(common, ref)) || readText(path17.join(common, "packed-refs")).includes(` ${ref}
 `), origins, sameDirectoryIdentity = (left, right) => {
-  if (!path16.isAbsolute(left) || !path16.isAbsolute(right))
+  if (!path17.isAbsolute(left) || !path17.isAbsolute(right))
     return false;
-  const normalizedLeft = path16.resolve(left);
-  const normalizedRight = path16.resolve(right);
+  const normalizedLeft = path17.resolve(left);
+  const normalizedRight = path17.resolve(right);
   try {
     const a = fs12.statSync(normalizedLeft, { bigint: true });
     const b = fs12.statSync(normalizedRight, { bigint: true });
@@ -13721,10 +14572,10 @@ var init_workers = __esm(() => {
 // packages/workit-core/src/check-config.ts
 import { spawnSync as spawnSync9 } from "node:child_process";
 import fs13 from "node:fs";
-import path17 from "node:path";
+import path18 from "node:path";
 function checksConfigFile(root) {
-  const current = path17.join(root, CHECKS_FILE);
-  const legacy = path17.join(root, LEGACY_CHECKS_FILE);
+  const current = path18.join(root, CHECKS_FILE);
+  const legacy = path18.join(root, LEGACY_CHECKS_FILE);
   return !fs13.existsSync(current) && fs13.existsSync(legacy) ? legacy : current;
 }
 function repoHeavyCommands(root) {
@@ -13774,12 +14625,12 @@ function splitCommand(command) {
   return argv.length ? argv : new Error("empty command");
 }
 function checkRoot(cwd) {
-  return path17.resolve(git4(cwd, ["rev-parse", "--show-toplevel"]) ?? cwd);
+  return path18.resolve(git5(cwd, ["rev-parse", "--show-toplevel"]) ?? cwd);
 }
 function detectedChecks(root) {
   const read = (file) => {
     try {
-      return fs13.readFileSync(path17.join(root, file), "utf8");
+      return fs13.readFileSync(path18.join(root, file), "utf8");
     } catch {
       return null;
     }
@@ -13818,7 +14669,7 @@ function detectedChecks(root) {
 function loadCheckConfig(cwd) {
   const root = checkRoot(cwd);
   const file = checksConfigFile(root);
-  const legacy = path17.basename(file) === LEGACY_CHECKS_FILE;
+  const legacy = path18.basename(file) === LEGACY_CHECKS_FILE;
   const label = legacy ? LEGACY_CHECKS_FILE : CHECKS_FILE;
   const note = legacy ? {
     note: `${LEGACY_CHECKS_FILE} is deprecated; move it to ${CHECKS_FILE} (workit doctor --fix)`
@@ -13894,10 +14745,10 @@ function workitAvailable(env = process.env) {
     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(path17.delimiter).filter(Boolean);
+  const dirs = (env.PATH ?? env.Path ?? "").split(path18.delimiter).filter(Boolean);
   workitOnPath = dirs.some((dir) => exts.some((ext) => {
     try {
-      return fs13.statSync(path17.join(dir, `workit${ext}`)).isFile();
+      return fs13.statSync(path18.join(dir, `workit${ext}`)).isFile();
     } catch {
       return false;
     }
@@ -13907,7 +14758,7 @@ function workitAvailable(env = process.env) {
 function checkCommand(args, version, onPath = workitAvailable()) {
   return onPath ? `workit check ${args}` : `npx -y @brainervirus/workit-cli@${version} check ${args}`;
 }
-var SCRIPT_CHECKS, CHECKS_FILE = ".workit/checks.json", LEGACY_CHECKS_FILE = "workit.checks.json", isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), SHELL_META, git4 = (cwd, args) => {
+var SCRIPT_CHECKS, CHECKS_FILE = ".workit/checks.json", LEGACY_CHECKS_FILE = "workit.checks.json", isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), SHELL_META, git5 = (cwd, args) => {
   const run = spawnSync9("git", args, {
     cwd,
     encoding: "utf8",
@@ -13918,7 +14769,7 @@ var SCRIPT_CHECKS, CHECKS_FILE = ".workit/checks.json", LEGACY_CHECKS_FILE = "wo
   const value = run.status === 0 ? (run.stdout ?? "").trim() : "";
   return value || null;
 }, packageManager = (root) => {
-  const has = (file) => fs13.existsSync(path17.join(root, file));
+  const has = (file) => fs13.existsSync(path18.join(root, file));
   if (has("bun.lock") || has("bun.lockb"))
     return "bun";
   if (has("pnpm-lock.yaml"))
@@ -13944,7 +14795,7 @@ var init_check_config = __esm(() => {
 import { createHash as createHash12 } from "node:crypto";
 import * as fs14 from "node:fs";
 import { spawnSync as spawnSync10 } from "node:child_process";
-import path18 from "node:path";
+import path19 from "node:path";
 function captureCandidate(root, scope, environment = []) {
   let checkout;
   try {
@@ -13986,7 +14837,7 @@ function captureCandidate(root, scope, environment = []) {
   for (const item of [...names].toSorted()) {
     if (!scopeMatches(item, normalizedScope))
       continue;
-    const target = path18.join(checkout, item);
+    const target = path19.join(checkout, item);
     try {
       const stat = fs14.lstatSync(target);
       if (stat.isSymbolicLink()) {
@@ -14395,12 +15246,12 @@ function boundTaskSummary(summary) {
   brief.truncated = JSON.stringify(brief).includes("…") || progress.blockers.length > BRIEF_BLOCKERS || unmet.length > BRIEF_OPEN;
   return brief;
 }
-var digestBytes = (value) => createHash12("sha256").update(value).digest("hex"), inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path18.sep}`), relative = (root, candidate) => path18.relative(root, candidate).split(path18.sep).join("/") || ".", canonicalPath = (value) => {
+var digestBytes = (value) => createHash12("sha256").update(value).digest("hex"), inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path19.sep}`), relative = (root, candidate) => path19.relative(root, candidate).split(path19.sep).join("/") || ".", canonicalPath = (value) => {
   if (typeof value !== "string" || !value)
     return null;
   if (value.includes("\\") || value.split("/").includes(".."))
     return null;
-  const normalized = path18.posix.normalize(value);
+  const normalized = path19.posix.normalize(value);
   if (normalized === ".." || normalized.startsWith("../") || normalized.startsWith("/"))
     return null;
   return normalized === "." ? "." : normalized.replace(/\/$/, "");
@@ -14442,14 +15293,14 @@ var digestBytes = (value) => createHash12("sha256").update(value).digest("hex"),
       git: !/not a git repository/i.test(stderr)
     };
   }
-  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path18.sep).join("/")) : [];
+  const paths = result.stdout ? result.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path19.sep).join("/")) : [];
   const stagedDeleted = spawnSync10("git", ["diff", "--cached", "--name-only", "--diff-filter=D", "-z"], { cwd: root, encoding: "buffer" });
   if (stagedDeleted.status !== 0) {
     const stderr = stagedDeleted.stderr?.toString("utf8") ?? "";
     if (!/not a git repository/i.test(stderr))
       return { paths, uncertain: true, git: true };
   } else if (stagedDeleted.stdout) {
-    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path18.sep).join("/")));
+    paths.push(...stagedDeleted.stdout.toString("utf8").split("\x00").filter(Boolean).map((item) => item.split(path19.sep).join("/")));
   }
   return { paths: [...new Set(paths)], uncertain: false, git: true };
 }, walk = (root, directory, output) => {
@@ -14463,7 +15314,7 @@ var digestBytes = (value) => createHash12("sha256").update(value).digest("hex"),
   for (const name of names) {
     if (name === ".git" || name === ".workit")
       continue;
-    const target = path18.join(directory, name);
+    const target = path19.join(directory, name);
     let stat;
     try {
       stat = fs14.lstatSync(target);
@@ -14480,12 +15331,12 @@ var digestBytes = (value) => createHash12("sha256").update(value).digest("hex"),
 }, scopeRoots = (root, scope) => {
   const roots = [];
   for (const item of scope.paths.length ? scope.paths : ["."]) {
-    const target = path18.resolve(root, item);
+    const target = path19.resolve(root, item);
     if (!inside(root, target))
       return failure2("invalid_input", `candidate scope escapes checkout: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} is outside the checkout` }] });
     let ancestor = target;
     while (!fs14.existsSync(ancestor) && ancestor !== root)
-      ancestor = path18.dirname(ancestor);
+      ancestor = path19.dirname(ancestor);
     try {
       if (!inside(root, fs14.realpathSync(ancestor)))
         return failure2("invalid_input", `candidate scope escapes checkout through a symlink: ${item} — keep one task per repository and coordinate a separate linked task in the other checkout`, { fields: [{ path: "scope.paths", reason: `${item} resolves outside the checkout` }] });
@@ -14549,23 +15400,23 @@ var digestBytes = (value) => createHash12("sha256").update(value).digest("hex"),
       continue;
     if (!reference.digest)
       return failure2("invalid_input", "document references require a byte digest");
-    const target = path18.resolve(root, reference.path);
-    if (target !== root && !target.startsWith(`${root}${path18.sep}`))
+    const target = path19.resolve(root, reference.path);
+    if (target !== root && !target.startsWith(`${root}${path19.sep}`))
       return failure2("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
         fields: [
           { path: "contentRefs.path", reason: `${reference.path} is outside the checkout` }
         ]
       });
     try {
-      const below = path18.relative(root, target);
+      const below = path19.relative(root, target);
       let current = root;
-      for (const segment of below.split(path18.sep)) {
+      for (const segment of below.split(path19.sep)) {
         if (!segment)
           continue;
-        current = path18.join(current, segment);
+        current = path19.join(current, segment);
         const stat = fs14.lstatSync(current);
         const real = fs14.realpathSync(current);
-        if (real !== root && !real.startsWith(`${root}${path18.sep}`))
+        if (real !== root && !real.startsWith(`${root}${path19.sep}`))
           return failure2("invalid_input", "document reference escapes checkout; cite it as an external file:// reference instead", {
             fields: [
               {
@@ -14693,9 +15544,9 @@ Autonomy contract:
   Prose is a note: only a configured check the CLI ran (\`workit check <name>\`)
   satisfies a gate; an ad-hoc \`workit check -- <cmd>\` never does.
 - Author is not verifier: your own verdict is \`--self\`, shown as
-  self-reviewed, never verified. High risk, \`verification: independent\` and
-  merge need a verifier with its own host-derived session (a subagent's
-  \`<lead>:<child>\`); never hand-mint one (\`<lead>-v1\`).
+  self-reviewed, never verified. High risk, a focused or full lane and
+  merge under \`verification: self|independent\` need a verifier with its
+  own host-derived session (a subagent's \`<lead>:<child>\`); never hand-mint one (\`<lead>-v1\`).
 - A local-commit endpoint does not imply PR readiness, and a local commit alone
   is not evidence of a requested remote push. Before reporting delivery,
   reconcile every requested item and observe it (\`workit verify-delivery\`).
@@ -16566,7 +17417,7 @@ var support = (descriptor, axis) => {
 // packages/workit-core/src/hooks/context.ts
 import { createHash as createHash13 } from "node:crypto";
 import fs15 from "node:fs";
-import path19 from "node:path";
+import path20 from "node:path";
 function sessionCompactContext(store, session, context, selection = "session-bound") {
   const listed = store.listTaskIndex();
   if (!listed.ok)
@@ -16601,7 +17452,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" ? [path19.resolve(store.root, ref.path)] : []));
+  const files = (task?.data.decisions ?? []).flatMap((decision) => decision.data.binding.contentRefs.flatMap((ref) => ref.kind === "file" ? [path20.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)
@@ -16707,13 +17558,13 @@ ${options.addendum}` : ""}
     if (location instanceof Error)
       return null;
     const session = [input.host, input.session.id, input.session.agentId ?? ""].join("\x00");
-    return path19.join(location.dir, "hooks", `turn-${digestOf(session).slice(0, 32)}.json`);
+    return path20.join(location.dir, "hooks", `turn-${digestOf(session).slice(0, 32)}.json`);
   } catch {
     return null;
   }
 }, writeTurnDigest = (file, digest) => {
   try {
-    fs15.mkdirSync(path19.dirname(file), { recursive: true });
+    fs15.mkdirSync(path20.dirname(file), { recursive: true });
     fs15.writeFileSync(file, `${JSON.stringify({ digest })}
 `);
   } catch {}
@@ -16726,7 +17577,7 @@ ${options.addendum}` : ""}
     for (const name of fs15.readdirSync(dir)) {
       if (!name.startsWith("turn-"))
         continue;
-      const file = path19.join(dir, name);
+      const file = path20.join(dir, name);
       try {
         if (now - fs15.statSync(file).mtimeMs > TURN_TTL_MS)
           fs15.rmSync(file, { force: true });
@@ -16754,7 +17605,7 @@ ${options.addendum}` : ""}
   const file = turnMarker(input);
   if (!file)
     return;
-  pruneTurnDigests(path19.dirname(file), Date.now());
+  pruneTurnDigests(path20.dirname(file), Date.now());
   if (text)
     writeTurnDigest(file, digestOf(text));
   else
@@ -16776,7 +17627,7 @@ var init_context = __esm(() => {
 // packages/workit-core/src/hooks/session-marker.ts
 import { createHash as createHash14 } from "node:crypto";
 import fs16 from "node:fs";
-import path20 from "node:path";
+import path21 from "node:path";
 var sessionMarkerFile = (input, session, store) => {
   let dir = store;
   if (dir === undefined) {
@@ -16786,7 +17637,7 @@ var sessionMarkerFile = (input, session, store) => {
     dir = location.dir;
   }
   const name = createHash14("sha256").update(`${input.host}\x00${session}`).digest("hex").slice(0, 32);
-  return path20.join(dir, "hooks", `skills-${name}.json`);
+  return path21.join(dir, "hooks", `skills-${name}.json`);
 }, list2 = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [], EMPTY, readRaw = (file) => {
   try {
     return fs16.readFileSync(file, "utf8");
@@ -16807,7 +17658,7 @@ var sessionMarkerFile = (input, session, store) => {
     return { ...EMPTY };
   }
 }, readSessionMarker = (file) => parseMarker(readRaw(file)), writeAtomic = (file, marker) => {
-  fs16.mkdirSync(path20.dirname(file), { recursive: true });
+  fs16.mkdirSync(path21.dirname(file), { recursive: true });
   const temp = `${file}.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     fs16.writeFileSync(temp, JSON.stringify(marker));
@@ -17277,7 +18128,7 @@ import { spawnSync as spawnSync11 } from "node:child_process";
 import { createHash as createHash15 } from "node:crypto";
 import fs17 from "node:fs";
 import os5 from "node:os";
-import path21 from "node:path";
+import path22 from "node:path";
 function rawInvocations(command, dialect = "posix", depth = 0) {
   if (depth > 0)
     return walk2(command, dialect, depth);
@@ -17476,6 +18327,23 @@ function workitInvocations(command, dialect = "posix", depth = 0) {
   }
   return found;
 }
+function skipWorkitGlobals(args) {
+  let cwd = null;
+  let at = 0;
+  for (;at < args.length; at++) {
+    const match = WORKIT_GLOBAL.exec(args[at]);
+    if (match?.[1] === "=") {
+      if (args[at].startsWith("--cwd="))
+        cwd = args[at].slice(6);
+    } else if (match && args[at + 1] !== undefined) {
+      if (args[at] === "--cwd")
+        cwd = args[at + 1];
+      at++;
+    } else if (args[at] !== "--json")
+      break;
+  }
+  return { rest: args.slice(at), cwd };
+}
 function rawAction(invocation) {
   const args = invocation.args;
   if (invocation.tool !== "git" && args[0] === "api")
@@ -17559,7 +18427,7 @@ function noteRawCommit(input, command, key) {
       if (action.kind !== "commit")
         continue;
       const file = markerFile(repo, input.session.id, key);
-      fs17.mkdirSync(path21.dirname(file), { recursive: true });
+      fs17.mkdirSync(path22.dirname(file), { recursive: true });
       fs17.writeFileSync(file, `${JSON.stringify({ head: headSha2(repo), at })}
 `);
     }
@@ -17586,12 +18454,12 @@ function settlePendingCommit(input) {
       settle2(input, repo, file);
   } catch {}
 }
-var NONE2, SHELLS, POWERSHELLS, EVALS, WRAPPERS, WRAPPER_VALUES, KEYWORDS, DECLARATIONS, SCRIPT_FLAG, CD, PUSHD, POPD, GIT_VALUE_OPTIONS, GIT_CONFIG_OPTIONS, GIT_CONFIG_ENV, ASSIGNMENT, MAX_DEPTH = 4, MAX_EXPANSIONS = 16, isAbsolute = (value) => path21.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\"), HERE, joinDir = (base, raw) => {
+var NONE2, SHELLS, POWERSHELLS, EVALS, WRAPPERS, WRAPPER_VALUES, KEYWORDS, DECLARATIONS, SCRIPT_FLAG, CD, PUSHD, POPD, GIT_VALUE_OPTIONS, GIT_CONFIG_OPTIONS, GIT_CONFIG_ENV, ASSIGNMENT2, MAX_DEPTH = 4, MAX_EXPANSIONS = 16, isAbsolute = (value) => path22.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\"), HERE, joinDir = (base, raw) => {
   const next = raw.replace(HERE, ".");
   if (base === undefined || /[$`*?]/.test(next) || next === "-")
     return;
-  const expanded = next === "~" || next.startsWith("~/") ? path21.join(os5.homedir(), next.slice(1)) : next;
-  return base === null || isAbsolute(expanded) ? expanded : path21.join(base, expanded);
+  const expanded = next === "~" || next.startsWith("~/") ? path22.join(os5.homedir(), next.slice(1)) : next;
+  return base === null || isAbsolute(expanded) ? expanded : path22.join(base, expanded);
 }, rebase = (base, inner) => inner === null ? base : inner === undefined ? undefined : joinDir(base, inner), cdTarget = (words) => {
   const args = words.slice(1);
   const flag = args.findIndex((word) => /^-(?:literal)?path$/i.test(word));
@@ -17605,7 +18473,7 @@ var NONE2, SHELLS, POWERSHELLS, EVALS, WRAPPERS, WRAPPER_VALUES, KEYWORDS, DECLA
     const first = words[0];
     if (first === undefined)
       return { words, env };
-    const assignment = ASSIGNMENT.exec(first);
+    const assignment = ASSIGNMENT2.exec(first);
     if (assignment) {
       if (GIT_CONFIG_ENV.test(assignment[1]))
         env[assignment[1]] = assignment[2];
@@ -17659,10 +18527,10 @@ var NONE2, SHELLS, POWERSHELLS, EVALS, WRAPPERS, WRAPPER_VALUES, KEYWORDS, DECLA
     while (rest[0]?.startsWith("-"))
       rest = rest.slice(1);
   }
-  if (rest.length === 0 || !rest.every((word) => ASSIGNMENT.test(word)))
+  if (rest.length === 0 || !rest.every((word) => ASSIGNMENT2.test(word)))
     return null;
   return rest.map((word) => {
-    const [, name, value] = ASSIGNMENT.exec(word);
+    const [, name, value] = ASSIGNMENT2.exec(word);
     return [name, expandWord(value, vars)];
   });
 }, literalOutput = (segment) => {
@@ -17827,7 +18695,7 @@ var NONE2, SHELLS, POWERSHELLS, EVALS, WRAPPERS, WRAPPER_VALUES, KEYWORDS, DECLA
       return line.slice(index).join(" ").slice(15);
     if (/^-S./.test(word))
       return [word.slice(2), ...line.slice(index + 1)].join(" ");
-    if (!word.startsWith("-") && !ASSIGNMENT.test(word))
+    if (!word.startsWith("-") && !ASSIGNMENT2.test(word))
       return null;
   }
   return null;
@@ -17875,7 +18743,7 @@ var NONE2, SHELLS, POWERSHELLS, EVALS, WRAPPERS, WRAPPER_VALUES, KEYWORDS, DECLA
     ...Object.keys(env).length ? { env } : {},
     ...stdin === undefined ? {} : { stdin }
   };
-}, RECENT, LAUNCHERS, WORKIT_BIN, WORKIT_PACKAGE, PACKAGE_RUNNERS, PUSH_VALUE_OPTIONS, CURRENT_BRANCH, pushDestination = (destination) => {
+}, RECENT, LAUNCHERS, WORKIT_BIN, WORKIT_PACKAGE, PACKAGE_RUNNERS, WORKIT_GLOBAL, PUSH_VALUE_OPTIONS, CURRENT_BRANCH, pushDestination = (destination) => {
   if (destination === "HEAD" || destination === "@" || CURRENT_BRANCH.test(destination))
     return { name: null };
   if (destination.startsWith("refs/heads/"))
@@ -18079,17 +18947,17 @@ var NONE2, SHELLS, POWERSHELLS, EVALS, WRAPPERS, WRAPPER_VALUES, KEYWORDS, DECLA
   if (!git || git.reftable)
     return null;
   try {
-    const head = fs17.readFileSync(path21.join(git.gitDir, "HEAD"), "utf8").trim();
+    const head = fs17.readFileSync(path22.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 = path21.dirname(repo.location.dir);
+    const common = path22.dirname(repo.location.dir);
     try {
-      return fs17.readFileSync(path21.join(common, ref), "utf8").trim() || null;
+      return fs17.readFileSync(path22.join(common, ref), "utf8").trim() || null;
     } catch {}
-    const packed = fs17.readFileSync(path21.join(common, "packed-refs"), "utf8");
+    const packed = fs17.readFileSync(path22.join(common, "packed-refs"), "utf8");
     return new RegExp(`^([0-9a-f]{40,64}) ${ref.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`, "m").exec(packed)?.[1] ?? null;
   } catch {
     return null;
@@ -18155,7 +19023,7 @@ var NONE2, SHELLS, POWERSHELLS, EVALS, WRAPPERS, WRAPPER_VALUES, KEYWORDS, DECLA
   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 = path21.resolve(root, invocation.dir ?? ".");
+  const dir = path22.resolve(root, invocation.dir ?? ".");
   if (!fs17.existsSync(dir))
     return [invocation];
   const config = gitConfig(dir, invocation, cache);
@@ -18177,11 +19045,11 @@ var NONE2, SHELLS, POWERSHELLS, EVALS, WRAPPERS, WRAPPER_VALUES, KEYWORDS, DECLA
 }, normalizedUrl = (url, dir) => {
   const trimmed = url.trim();
   if (/^file:\/\//i.test(trimmed))
-    return path21.resolve(dir, trimmed.slice(7)).replace(/\/+$/, "").replace(/\.git$/, "");
+    return path22.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 path21.resolve(dir, trimmed).replace(/\/+$/, "").replace(/\.git$/, "");
+    return path22.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$/, "");
 }, rewrittenUrl = (url, config) => {
@@ -18199,7 +19067,7 @@ var NONE2, SHELLS, POWERSHELLS, EVALS, WRAPPERS, WRAPPER_VALUES, KEYWORDS, DECLA
       return best.base + url.slice(best.prefix.length);
   }
   return url;
-}, pushUrl = (config, remote, dir) => {
+}, pushUrl2 = (config, remote, dir) => {
   const configured = configValue(config, `remote.${remote}.pushurl`) ?? configValue(config, `remote.${remote}.url`);
   return normalizedUrl(rewrittenUrl(configured ?? remote, config), dir);
 }, pushRemoteOf = (config, branch) => {
@@ -18225,7 +19093,7 @@ var NONE2, SHELLS, POWERSHELLS, EVALS, WRAPPERS, WRAPPER_VALUES, KEYWORDS, DECLA
   const pushRemote = pushRemoteOf(config, repo.branch);
   if (pushRemote === null || pushRemote === remote)
     return true;
-  return pushUrl(config, remote, repo.dir) === pushUrl(config, pushRemote, repo.dir);
+  return pushUrl2(config, remote, repo.dir) === pushUrl2(config, pushRemote, repo.dir);
 }, quote = (text) => `\`${text}\``, refusal = (action, branch, dir) => {
   if (action.kind === "merge")
     return `workit: raw ${quote(action.via === "api" ? `${action.forge} api` : action.forge === "gh" ? "gh pr merge" : "glab mr merge")}${action.via === "api" ? " merge" : ""} bypasses the merge grant and the verdict gate. Run ${quote("workit pr merge")} instead (it checks both; ${quote("workit help pr")}).`;
@@ -18387,7 +19255,7 @@ var NONE2, SHELLS, POWERSHELLS, EVALS, WRAPPERS, WRAPPER_VALUES, KEYWORDS, DECLA
   const out = [];
   const repos = new Map;
   const repoFor = (relative) => {
-    const dir = path21.resolve(cwd, relative ?? ".");
+    const dir = path22.resolve(cwd, relative ?? ".");
     if (!repos.has(dir)) {
       const repo = repoAt(dir);
       repos.set(dir, repo && isWorkitWorkspace(repo) ? repo : null);
@@ -18431,7 +19299,7 @@ var NONE2, SHELLS, POWERSHELLS, EVALS, WRAPPERS, WRAPPER_VALUES, KEYWORDS, DECLA
   kind: "deny",
   reason: `workit: the shell hook could not analyze this command (${error.message}), so it does not run. ${SPLIT_IT}`,
   unblock: SPLIT_IT
-}), NEXT_COMMAND = "next", MARKER_TTL_SECONDS = 3600, markerFile = (repo, session, key) => path21.join(repo.location.dir, "hooks", `commit-${createHash15("sha256").update(`${session}\x00${key}`).digest("hex").slice(0, 32)}.json`), callKey = (toolUseId, command) => toolUseId ?? `cmd:${createHash15("sha256").update(command).digest("hex")}`, headCommit = (dir) => {
+}), NEXT_COMMAND = "next", MARKER_TTL_SECONDS = 3600, markerFile = (repo, session, key) => path22.join(repo.location.dir, "hooks", `commit-${createHash15("sha256").update(`${session}\x00${key}`).digest("hex").slice(0, 32)}.json`), callKey = (toolUseId, command) => toolUseId ?? `cmd:${createHash15("sha256").update(command).digest("hex")}`, headCommit = (dir) => {
   const run = spawnSync11("git", [
     "log",
     "-1",
@@ -18537,7 +19405,7 @@ var init_raw_git = __esm(() => {
   ]);
   GIT_CONFIG_OPTIONS = new Set(["-c", "--config-env", "--git-dir"]);
   GIT_CONFIG_ENV = /^GIT_(?:CONFIG\w*|DIR|COMMON_DIR|WORK_TREE)$/;
-  ASSIGNMENT = /^([A-Za-z_]\w*)=([\s\S]*)$/;
+  ASSIGNMENT2 = /^([A-Za-z_]\w*)=([\s\S]*)$/;
   HERE = /^(?:\$PWD|\$\{PWD\}|\$\(\s*pwd\s*\)|`pwd`|\$\(\s*git\s+rev-parse\s+--show-toplevel\s*\))(?=$|[\\/])/;
   VARIABLE = /\$(?:\{(\w+)\}|(\w+))/g;
   XARGS_VALUES = new Set(["-n", "-L", "-l", "-P", "-d", "-E", "-e", "-s", "-a", "--arg-file", "--delimiter"].concat([
@@ -18569,6 +19437,7 @@ var init_raw_git = __esm(() => {
   WORKIT_BIN = /(?:^|[\\/])workit(?:\.exe)?$|^@brainervirus\/workit-cli$/;
   WORKIT_PACKAGE = /^@brainervirus\/workit-cli(?:@\S*)?$/;
   PACKAGE_RUNNERS = new Set(["npx", "bunx", "pnpx"]);
+  WORKIT_GLOBAL = /^--(?:cwd|session|token|as)(=|$)/;
   PUSH_VALUE_OPTIONS = new Set(["-o", "--push-option", "--receive-pack", "--exec", "--repo"]);
   CURRENT_BRANCH = /^\$\(\s*git\s+(?:branch\s+--show-current|rev-parse\s+--abbrev-ref\s+HEAD|symbolic-ref\s+--short\s+HEAD)\s*\)$/;
   VALUE_OPTIONS = {
@@ -18629,8 +19498,8 @@ var init_raw_git = __esm(() => {
 
 // packages/workit-core/src/core/route-intent.ts
 import { spawnSync as spawnSync12 } from "node:child_process";
-import { existsSync as existsSync6 } from "node:fs";
-import path22 from "node:path";
+import { existsSync as existsSync7 } from "node:fs";
+import path23 from "node:path";
 var UNKNOWABLE, SWITCH_CREATE, CHECKOUT_CREATE, WORKTREE_CREATE, SUBTREE_CREATE, BRANCH_NO_CREATE, BRANCH_RENAME, longOption = (name, flags) => flags.has(name) || name.length >= 3 && [...flags].some((flag) => flag.startsWith("--") && flag.startsWith(name)), shortsOf = (flags) => [...flags].filter((flag) => /^-[^-]$/u.test(flag)).join("").replaceAll("-", ""), flagValue = (args, flags) => {
   const shorts = shortsOf(flags);
   for (let index = 1;index < args.length; index++) {
@@ -18756,8 +19625,8 @@ var UNKNOWABLE, SWITCH_CREATE, CHECKOUT_CREATE, WORKTREE_CREATE, SUBTREE_CREATE,
     return null;
   if (dir === null)
     return root;
-  const resolved = path22.resolve(root, dir);
-  return existsSync6(resolved) && inWorkitWorkspace(resolved) ? resolved : null;
+  const resolved = path23.resolve(root, dir);
+  return existsSync7(resolved) && inWorkitWorkspace(resolved) ? resolved : null;
 }, shellBranchPolicyViolation = (root, command, dialect = "posix") => {
   let judged = false;
   const cache = new Map;
@@ -18811,7 +19680,7 @@ var init_policy = __esm(() => {
 // packages/workit-core/src/core/heavy-rules.ts
 import fs18 from "node:fs";
 import os6 from "node:os";
-import path23 from "node:path";
+import path24 from "node:path";
 function parseJsonc(text) {
   let out = "";
   for (let index = 0;index < text.length; index += 1) {
@@ -18841,21 +19710,21 @@ function parseJsonc(text) {
   return JSON.parse(out.replace(/,(\s*[}\]])/gu, "$1"));
 }
 function gitTop(cwd) {
-  for (let dir = path23.resolve(cwd);; dir = path23.dirname(dir)) {
-    if (fs18.existsSync(path23.join(dir, ".git")))
+  for (let dir = path24.resolve(cwd);; dir = path24.dirname(dir)) {
+    if (fs18.existsSync(path24.join(dir, ".git")))
       return dir;
-    if (path23.dirname(dir) === dir)
+    if (path24.dirname(dir) === dir)
       return null;
   }
 }
 function claudeSettingsFiles(cwd, env, platform = process.platform) {
   const project = env.CLAUDE_PROJECT_DIR || gitTop(cwd) || cwd;
-  const user = env.CLAUDE_CONFIG_DIR || path23.join(homeOf(env), ".claude");
+  const user = env.CLAUDE_CONFIG_DIR || path24.join(homeOf(env), ".claude");
   return [
     ...CLAUDE_MANAGED[platform] ? [CLAUDE_MANAGED[platform]] : [],
-    path23.join(user, "settings.json"),
-    path23.join(project, ".claude", "settings.json"),
-    path23.join(project, ".claude", "settings.local.json")
+    path24.join(user, "settings.json"),
+    path24.join(project, ".claude", "settings.json"),
+    path24.join(project, ".claude", "settings.local.json")
   ];
 }
 function claudeRules(cwd, env = process.env) {
@@ -18900,10 +19769,10 @@ function claudeRules(cwd, env = process.env) {
 function opencodeRules(cwd, env = process.env) {
   const rules = EMPTY2();
   try {
-    const config = env.XDG_CONFIG_HOME || path23.join(homeOf(env), ".config");
+    const config = env.XDG_CONFIG_HOME || path24.join(homeOf(env), ".config");
     const files = [
-      ...OPENCODE_NAMES.map((name) => path23.join(config, "opencode", name)),
-      ...projectDirs(cwd).flatMap((dir) => OPENCODE_NAMES.flatMap((name) => [path23.join(dir, name), path23.join(dir, ".opencode", name)])),
+      ...OPENCODE_NAMES.map((name) => path24.join(config, "opencode", name)),
+      ...projectDirs(cwd).flatMap((dir) => OPENCODE_NAMES.flatMap((name) => [path24.join(dir, name), path24.join(dir, ".opencode", name)])),
       ...env.OPENCODE_CONFIG ? [env.OPENCODE_CONFIG] : []
     ];
     for (const file of files) {
@@ -18921,9 +19790,9 @@ function opencodeRules(cwd, env = process.env) {
 function codexRules(cwd, env = process.env) {
   const rules = EMPTY2();
   try {
-    const home = env.CODEX_HOME || path23.join(homeOf(env), ".codex");
+    const home = env.CODEX_HOME || path24.join(homeOf(env), ".codex");
     const top = gitTop(cwd) ?? cwd;
-    for (const dir of [path23.join(home, "rules"), path23.join(top, ".codex", "rules")]) {
+    for (const dir of [path24.join(home, "rules"), path24.join(top, ".codex", "rules")]) {
       let files;
       try {
         files = fs18.readdirSync(dir).filter((name) => name.endsWith(".rules"));
@@ -18933,7 +19802,7 @@ function codexRules(cwd, env = process.env) {
         return "unreadable";
       }
       for (const name of files) {
-        const text = readText2(path23.join(dir, name)) ?? "";
+        const text = readText2(path24.join(dir, name)) ?? "";
         for (const part of text.split(/\bprefix_rule\s*\(/u).slice(1)) {
           const rule = codexRule(part);
           if (!rule)
@@ -18952,8 +19821,8 @@ function cursorRules(cwd, env = process.env) {
   try {
     const top = gitTop(cwd) ?? cwd;
     for (const file of [
-      path23.join(homeOf(env), ".cursor", "cli-config.json"),
-      path23.join(top, ".cursor", "cli.json")
+      path24.join(homeOf(env), ".cursor", "cli-config.json"),
+      path24.join(top, ".cursor", "cli.json")
     ]) {
       const text = readText2(file);
       if (text === null)
@@ -19015,9 +19884,9 @@ var EMPTY2 = () => ({ deny: [], allow: [] }), readText2 = (file) => {
 }, isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), projectDirs = (cwd) => {
   const top = gitTop(cwd);
   const dirs = [];
-  for (let dir = path23.resolve(cwd);; dir = path23.dirname(dir)) {
+  for (let dir = path24.resolve(cwd);; dir = path24.dirname(dir)) {
     dirs.push(dir);
-    if (!top || dir === top || path23.dirname(dir) === dir)
+    if (!top || dir === top || path24.dirname(dir) === dir)
       return dirs;
   }
 }, homeOf = (env) => env.HOME || os6.homedir(), CLAUDE_MANAGED, bashPattern = (entry) => {
@@ -19115,18 +19984,18 @@ var init_heavy_rules = __esm(() => {
 // packages/workit-core/src/core/heavy.ts
 import fs19 from "node:fs";
 import os7 from "node:os";
-import path24 from "node:path";
+import path25 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 path24.join(env.XDG_STATE_HOME, "workit");
+    return path25.join(env.XDG_STATE_HOME, "workit");
   const home = env.HOME || os7.homedir();
   if (platform === "darwin")
-    return path24.join(home, "Library", "Application Support", "workit");
+    return path25.join(home, "Library", "Application Support", "workit");
   if (platform === "win32")
-    return path24.join(env.LOCALAPPDATA ?? path24.join(home, "AppData", "Local"), "workit");
-  return path24.join(home, ".local", "state", "workit");
+    return path25.join(env.LOCALAPPDATA ?? path25.join(home, "AppData", "Local"), "workit");
+  return path25.join(home, ".local", "state", "workit");
 }
 function positional2(words, from, values = PM_VALUES) {
   let index = from;
@@ -19266,7 +20135,7 @@ function machinePatterns(env) {
   return isRecord5(value) ? stringList(value.patterns) : [];
 }
 function repoPatterns(cwd) {
-  return repoHeavyCommands(gitTop(cwd) ?? path24.resolve(cwd));
+  return repoHeavyCommands(gitTop(cwd) ?? path25.resolve(cwd));
 }
 function heavyLines(lines, options) {
   const found = [];
@@ -19335,12 +20204,12 @@ function heavyPlan(command, options) {
 }
 function workitOnPath2(env = process.env) {
   const names = process.platform === "win32" ? ["workit.exe", "workit.cmd", "workit"] : ["workit"];
-  for (const dir of (env.PATH ?? "").split(path24.delimiter))
+  for (const dir of (env.PATH ?? "").split(path25.delimiter))
     for (const name of names) {
       if (!dir)
         continue;
       try {
-        fs19.accessSync(path24.join(dir, name), fs19.constants.X_OK);
+        fs19.accessSync(path25.join(dir, name), fs19.constants.X_OK);
         return true;
       } catch {}
     }
@@ -19354,7 +20223,7 @@ function leaseRewrite(command) {
     return null;
   return `${prefix}workit check --heavy -- ${rest}`;
 }
-var HEAVY_COMMANDS_FILE = "heavy-commands.json", heavyCommandsFile = (env) => path24.join(stateDir(env), HEAVY_COMMANDS_FILE), HEAVY_SCRIPT, INFO_FLAGS, WATCH_FLAG, WATCH_SCRIPT, sub = (...names) => new Set(names), TOOLS, PM_VALUES, baseName2 = (word) => (word?.split(/[\\/]/u).at(-1) ?? "").toLowerCase().replace(/\.(?:exe|cmd|bat|ps1)$/u, ""), WORKIT, PYTHONS, NPM_INSTALL, NPM_RUN, NPM_TEST, EXEC, globWord = (word) => new RegExp(`^${word.replace(/[.+?^${}()|[\]\\]/gu, "\\$&").replaceAll("*", ".*")}$`, "u"), 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])), readJson = (file) => {
+var HEAVY_COMMANDS_FILE = "heavy-commands.json", heavyCommandsFile = (env) => path25.join(stateDir(env), HEAVY_COMMANDS_FILE), HEAVY_SCRIPT, INFO_FLAGS, WATCH_FLAG, WATCH_SCRIPT, sub = (...names) => new Set(names), TOOLS, PM_VALUES, baseName2 = (word) => (word?.split(/[\\/]/u).at(-1) ?? "").toLowerCase().replace(/\.(?:exe|cmd|bat|ps1)$/u, ""), WORKIT, PYTHONS, NPM_INSTALL, NPM_RUN, NPM_TEST, EXEC, globWord = (word) => new RegExp(`^${word.replace(/[.+?^${}()|[\]\\]/gu, "\\$&").replaceAll("*", ".*")}$`, "u"), 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])), readJson = (file) => {
   try {
     return JSON.parse(fs19.readFileSync(file, "utf8"));
   } catch {
@@ -19500,7 +20369,7 @@ var init_heavy = __esm(() => {
 // packages/workit-core/src/core/heavy-words.ts
 import fs20 from "node:fs";
 import os8 from "node:os";
-import path25 from "node:path";
+import path26 from "node:path";
 function maybeHeavy(command, cwd, env = process.env) {
   try {
     const words = wordsOf(command);
@@ -19516,13 +20385,13 @@ var HEAVY_WORDS, wordsOf = (command) => command.split(/[\s;&|()<>`'"]+/u).map((w
   if (env.WORKFLOW_TOOLKIT_STATE)
     return env.WORKFLOW_TOOLKIT_STATE;
   if (env.XDG_STATE_HOME)
-    return path25.join(env.XDG_STATE_HOME, "workit");
+    return path26.join(env.XDG_STATE_HOME, "workit");
   const home = env.HOME || os8.homedir();
   if (process.platform === "darwin")
-    return path25.join(home, "Library", "Application Support", "workit");
+    return path26.join(home, "Library", "Application Support", "workit");
   if (process.platform === "win32")
-    return path25.join(env.LOCALAPPDATA ?? path25.join(home, "AppData", "Local"), "workit");
-  return path25.join(home, ".local", "state", "workit");
+    return path26.join(env.LOCALAPPDATA ?? path26.join(home, "AppData", "Local"), "workit");
+  return path26.join(home, ".local", "state", "workit");
 }, readJson2 = (file) => {
   try {
     return JSON.parse(fs20.readFileSync(file, "utf8"));
@@ -19531,15 +20400,15 @@ var HEAVY_WORDS, wordsOf = (command) => command.split(/[\s;&|()<>`'"]+/u).map((w
   }
 }, patternWords = (cwd, env) => {
   const patterns = [];
-  const machine = readJson2(path25.join(stateDir2(env), "heavy-commands.json"));
+  const machine = readJson2(path26.join(stateDir2(env), "heavy-commands.json"));
   if (Array.isArray(machine?.patterns))
     patterns.push(...machine.patterns);
-  for (let dir = path25.resolve(cwd);; dir = path25.dirname(dir)) {
-    if (fs20.existsSync(path25.join(dir, ".git"))) {
+  for (let dir = path26.resolve(cwd);; dir = path26.dirname(dir)) {
+    if (fs20.existsSync(path26.join(dir, ".git"))) {
       patterns.push(...repoHeavyCommands(dir));
       break;
     }
-    if (path25.dirname(dir) === dir)
+    if (path26.dirname(dir) === dir)
       break;
   }
   const words = new Set;
@@ -19609,7 +20478,7 @@ import { spawnSync as spawnSync13 } from "node:child_process";
 import { createHash as createHash16 } from "node:crypto";
 import fs21 from "node:fs";
 import os9 from "node:os";
-import path26 from "node:path";
+import path27 from "node:path";
 var LIVE_SESSION_TTL_MS, HEARTBEAT_EVERY_MS = 30000, liveProbe, leadOf = (session) => session.split(":")[0].replace(/-w-.*$/su, "") || session, familyOf = (host) => host.replace(/_(?:cli|desktop)$/u, ""), processAlive = (pid) => {
   try {
     process.kill(pid, 0);
@@ -19667,15 +20536,15 @@ var LIVE_SESSION_TTL_MS, HEARTBEAT_EVERY_MS = 30000, liveProbe, leadOf = (sessio
     pid: () => hostPid(transport)
   };
 }, checkoutOf = (target) => {
-  let dir = path26.resolve(target);
-  while (!fs21.existsSync(dir) && path26.dirname(dir) !== dir)
-    dir = path26.dirname(dir);
+  let dir = path27.resolve(target);
+  while (!fs21.existsSync(dir) && path27.dirname(dir) !== dir)
+    dir = path27.dirname(dir);
   if (fs21.existsSync(dir) && !fs21.statSync(dir).isDirectory())
-    dir = path26.dirname(dir);
-  const parts = dir.split(path26.sep);
+    dir = path27.dirname(dir);
+  const parts = dir.split(path27.sep);
   const dotGit = parts.lastIndexOf(".git");
   if (dotGit > 0)
-    dir = parts.slice(0, dotGit).join(path26.sep) || path26.sep;
+    dir = parts.slice(0, dotGit).join(path27.sep) || path27.sep;
   const location = resolveStore(dir);
   if (location instanceof Error || !location.shared || !location.top)
     return null;
@@ -19684,8 +20553,8 @@ var LIVE_SESSION_TTL_MS, HEARTBEAT_EVERY_MS = 30000, liveProbe, leadOf = (sessio
     top = fs21.realpathSync.native(top);
   } catch {}
   return top;
-}, markerFile2 = (top) => path26.join(resolveStateDir(), "live-sessions", `${createHash16("sha256").update(checkoutKey(top)).digest("hex").slice(0, 32)}.json`), checkoutKey = (top, platform = process.platform) => {
-  let key = path26.resolve(top);
+}, markerFile2 = (top) => path27.join(resolveStateDir(), "live-sessions", `${createHash16("sha256").update(checkoutKey(top)).digest("hex").slice(0, 32)}.json`), checkoutKey = (top, platform = process.platform) => {
+  let key = path27.resolve(top);
   try {
     key = fs21.realpathSync.native(key);
   } catch {}
@@ -19773,7 +20642,7 @@ var LIVE_SESSION_TTL_MS, HEARTBEAT_EVERY_MS = 30000, liveProbe, leadOf = (sessio
       checkout,
       heartbeatAt: now.toISOString()
     };
-    fs21.mkdirSync(path26.dirname(file), { recursive: true });
+    fs21.mkdirSync(path27.dirname(file), { recursive: true });
     const temp = `${file}.${process.pid}.tmp`;
     fs21.writeFileSync(temp, JSON.stringify(marker));
     fs21.renameSync(temp, file);
@@ -19794,9 +20663,9 @@ var init_live_session = __esm(() => {
 });
 
 // packages/workit-core/src/hooks/write-gate.ts
-import { realpathSync as realpathSync5 } from "node:fs";
+import { existsSync as existsSync8, realpathSync as realpathSync5 } from "node:fs";
 import os10 from "node:os";
-import path27 from "node:path";
+import path28 from "node:path";
 function writeGate(cwd, paths, owner, deps) {
   const forged = paths?.length ? issuedTarget(cwd, paths) : null;
   if (forged)
@@ -19820,16 +20689,8 @@ function shellGate(cwd, command, owner, dialect = "posix", deps) {
   } catch {}
   const writes = shellWrites(command);
   let targets = [];
-  if (owner) {
-    try {
-      targets = [
-        ...segmentTargets(cwd, command, dialect),
-        ...gitMutationDirs(cwd, command, dialect).map((dir) => path27.join(dir, DIR_TARGET))
-      ];
-    } catch {
-      targets = [];
-    }
-  }
+  if (owner)
+    targets = shellMutationTargets(cwd, command, dialect);
   if (owner && targets.length) {
     const live = liveGate(owner, targets, deps);
     if (live.kind !== "none") {
@@ -19862,21 +20723,21 @@ function beforeWriteGate(cwd, paths) {
 }
 var NONE3, CASE_INSENSITIVE, canonical2 = (file) => {
   let rest = "";
-  for (let dir = path27.resolve(file);; dir = path27.dirname(dir)) {
+  for (let dir = path28.resolve(file);; dir = path28.dirname(dir)) {
     try {
-      return path27.join(realpathSync5.native(dir), rest);
+      return path28.join(realpathSync5.native(dir), rest);
     } catch {
-      if (path27.dirname(dir) === dir)
-        return path27.resolve(file);
-      rest = rest ? path27.join(path27.basename(dir), rest) : path27.basename(dir);
+      if (path28.dirname(dir) === dir)
+        return path28.resolve(file);
+      rest = rest ? path28.join(path28.basename(dir), rest) : path28.basename(dir);
     }
   }
 }, exempt = (cwd, root, file, plans) => {
   const fold = (value) => CASE_INSENSITIVE ? value.toLowerCase() : value;
-  const relative = path27.relative(fold(canonical2(root)), fold(canonical2(path27.resolve(cwd, file))));
-  if (relative.startsWith("..") || path27.isAbsolute(relative))
+  const relative = path28.relative(fold(canonical2(root)), fold(canonical2(path28.resolve(cwd, file))));
+  if (relative.startsWith("..") || path28.isAbsolute(relative))
     return true;
-  const posix = relative.split(path27.sep).join("/");
+  const posix = relative.split(path28.sep).join("/");
   const segments = posix.split("/");
   return /\.mdx?$/i.test(posix) || segments[0] === "docs" || segments.includes("plans") || [...plans].some((plan) => fold(plan) === posix);
 }, PREFIXES2, operands = (words) => words.filter((item) => !item.startsWith("-")), SCRIPT_SHELLS, wrappedScript = (input) => {
@@ -19888,9 +20749,9 @@ var NONE3, CASE_INSENSITIVE, canonical2 = (file) => {
     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;
+  const script = shellScript2(tail.argv);
+  if (SCRIPT_SHELLS.has((tail.argv[0]?.split(/[\\/]/).at(-1) ?? "").toLowerCase()) && script)
+    return script;
   return tail.argv.map(quoteWord2).join(" ");
 }, editsOf = (input) => {
   let words = input;
@@ -19967,6 +20828,89 @@ var NONE3, CASE_INSENSITIVE, canonical2 = (file) => {
     default:
       return [];
   }
+}, shellScript2 = (words) => {
+  if (!SCRIPT_SHELLS.has((words[0]?.split(/[\\/]/).at(-1) ?? "").toLowerCase()))
+    return null;
+  for (let index = 1;index < words.length; index++) {
+    const word = words[index];
+    if (/^-[a-z]*c$/.test(word))
+      return words[index + 1] ?? null;
+    if (/^[-+][oO]$/.test(word))
+      index++;
+    else if (!/^[-+]/.test(word))
+      return null;
+  }
+  return null;
+}, XARGS_VALUE, runsWriter = (words) => {
+  const filled = [...words.filter((word) => word !== "{}" && word !== ";" && word !== "+"), "x"];
+  const edits = editsOf(filled);
+  return edits === null || edits.length > 0 || opaqueWrites(filled) !== null;
+}, opaqueWrites = (input) => {
+  let words = input;
+  while (words.length && (PREFIXES2.has(words[0]) || /^\w+=/.test(words[0]))) {
+    if (words[0] === "xargs") {
+      let at = 1;
+      while (words[at]?.startsWith("-"))
+        at += XARGS_VALUE.test(words[at]) ? 2 : 1;
+      return runsWriter(words.slice(at)) ? ["."] : null;
+    }
+    words = words.slice(1);
+  }
+  const [verb, ...args] = words;
+  const name = (verb?.split(/[\\/]/).at(-1) ?? "").toLowerCase();
+  const files = operands(args);
+  const has = (pattern) => args.some((arg) => pattern.test(arg));
+  const listed = (named) => named.length ? named : ["."];
+  if (name === "unlink" || name === "shred")
+    return listed(files);
+  if (/^(?:chmod|chown|chgrp|chattr)$/.test(name))
+    return listed(has(/^--reference/) ? files : files.slice(1));
+  if (name === "rsync") {
+    const dest = files.at(-1);
+    const remote = /^[\w.@-]*:/.test(dest ?? "") && !/^[A-Za-z]:[\\/]/.test(dest ?? "");
+    return dest === undefined ? ["."] : remote ? [] : [dest];
+  }
+  if (name === "find") {
+    const exec = args.findIndex((arg) => /^-(?:exec|execdir|ok|okdir)$/.test(arg));
+    const writes = has(/^-(?:delete|fprint\w*|fls)$/) || exec >= 0 && runsWriter(args.slice(exec + 1));
+    const end = args.findIndex((arg) => /^[-(!]/.test(arg));
+    return writes ? listed(end < 0 ? args : args.slice(0, end)) : null;
+  }
+  if (/^g?awk$/.test(name)) {
+    if (!has(/^-i|^--include/))
+      return null;
+    const named = [];
+    let program = !has(/^-f$|^--file/);
+    for (let index = 0;index < args.length; index++)
+      if (/^(?:-[ifvF]|--(?:include|file|assign|field-separator))$/.test(args[index]))
+        index++;
+      else if (args[index].startsWith("-"))
+        continue;
+      else if (program)
+        program = false;
+      else
+        named.push(args[index]);
+    return listed(named);
+  }
+  if (name === "perl")
+    return has(/^-[a-zA-Z]*[eE]/) ? ["."] : null;
+  if (/^(?:python[\d.]*|node|bun|deno|ruby|php)$/.test(name))
+    return has(/^-[a-zA-Z]*[ce]$|^--eval$|^-p$/) ? ["."] : null;
+  return shellScript2(words) === null ? null : ["."];
+}, linkSources = (args, at) => {
+  const names = operands([...args]);
+  const into = args.indexOf("-t");
+  const dest = into >= 0 ? args[into + 1] : names.length > 1 ? names.at(-1) : ".";
+  const sources = names.filter((name, index) => into >= 0 ? name !== dest : index < names.length - 1 || names.length === 1);
+  const target = dest === undefined ? null : at(dest);
+  const symbolic = args.some((arg) => /^-[a-zA-Z]*s|^--symbolic$/.test(arg));
+  const base = target === null ? null : into >= 0 || sources.length > 1 || existsSync8(target) || /[\\/]$/.test(dest ?? "") ? target : path28.dirname(target);
+  return sources.flatMap((source) => {
+    if (symbolic && base !== null && !path28.isAbsolute(homeExpanded(source)))
+      return [path28.resolve(base, source)];
+    const resolved = at(source);
+    return resolved ? [resolved] : [];
+  });
 }, shellWrites = (command, depth = 0) => {
   const targets = [];
   let unknown = false;
@@ -19989,7 +20933,7 @@ var NONE3, CASE_INSENSITIVE, canonical2 = (file) => {
   if (!unknown && targets.length === 0)
     return { writes: false, targets: null };
   return { writes: true, targets: unknown ? null : targets };
-}, cache2, planKeyOf = (root, plans) => [...plans].map((file) => fileSignature(path27.resolve(root, file)) ?? "-").join("\x00"), gateFor = (cwd) => {
+}, cache2, planKeyOf = (root, plans) => [...plans].map((file) => fileSignature(path28.resolve(root, file)) ?? "-").join("\x00"), gateFor = (cwd) => {
   const store = new TaskStore(cwd);
   const listed = store.listTaskIndex();
   if (!listed.ok)
@@ -20042,25 +20986,28 @@ var NONE3, CASE_INSENSITIVE, canonical2 = (file) => {
       return [];
     if (sub === "stash" && ["list", "show"].includes(rest[0] ?? ""))
       return [];
-    return [path27.resolve(cwd, invocation.dir ?? ".")];
+    return [path28.resolve(cwd, invocation.dir ?? ".")];
   });
-}, CD2, PUSHD2, POPD2, cdInto = (dir, words) => {
+}, CD2, PUSHD2, POPD2, UNKNOWN_DIR, cdInto = (dir, words, strict = false) => {
+  const lost = strict ? UNKNOWN_DIR : undefined;
   const named = words.slice(1).find((word) => !word.startsWith("-") || word === "-");
   const target = named === undefined ? undefined : homeExpanded(named);
-  if (dir === undefined || target === "-" || target && /^~|[$`*?]/.test(target))
-    return;
-  return target === undefined ? os10.homedir() : path27.resolve(dir, target);
+  if (target === "-" || target && /^~|[$`*?]/.test(target))
+    return lost;
+  if (dir === undefined)
+    return lost;
+  return target === undefined ? os10.homedir() : path28.resolve(dir, target);
 }, quoteWord2 = (word) => /^[\w@%+=:,./-]+$/.test(word) ? word : `'${word.replaceAll("'", "'\\''")}'`, homeExpanded = (file) => {
   const match = /^(?:~|\$HOME|\$\{HOME\})(?=\/|$)/.exec(file);
   return match ? (process.env.HOME || os10.homedir()) + file.slice(match[0].length) : file;
-}, segmentTargets = (cwd, command, dialect, depth = 0) => {
+}, segmentTargets = (cwd, command, dialect, depth = 0, strict = false) => {
   const targets = [];
   let dir = cwd;
   let stack = [];
   const groups = [];
   const at = (file) => {
     const home = homeExpanded(file);
-    return path27.isAbsolute(home) ? home : dir === undefined ? null : path27.resolve(dir, home);
+    return path28.isAbsolute(home) ? home : dir === undefined ? null : path28.resolve(dir, home);
   };
   for (const segment of segmentsOf(command, dialect)) {
     if (segment.group === "open") {
@@ -20077,21 +21024,35 @@ var NONE3, CASE_INSENSITIVE, canonical2 = (file) => {
     const words = lead < 0 ? [] : segment.words.slice(lead);
     const name = (words[0]?.split(/[\\/]/).at(-1) ?? "").toLowerCase();
     if (CD2.has(name)) {
-      dir = cdInto(dir, words);
+      dir = cdInto(dir, words, strict);
       continue;
     }
     if (PUSHD2.has(name)) {
       stack.push(dir);
-      dir = cdInto(dir, words);
+      dir = cdInto(dir, words, strict);
       continue;
     }
     if (POPD2.has(name)) {
-      dir = stack.length ? stack.pop() : undefined;
+      dir = stack.length ? stack.pop() : strict ? UNKNOWN_DIR : undefined;
       continue;
     }
-    const inner = depth < 4 ? wrappedScript(words) : null;
+    const inner = depth < 4 ? wrappedScript(words) ?? (strict ? shellScript2(words) : null) : null;
     if (inner !== null && dir !== undefined)
-      targets.push(...segmentTargets(dir, inner, "posix", depth + 1));
+      targets.push(...segmentTargets(dir, inner, "posix", depth + 1, strict));
+    if (strict && dir !== undefined) {
+      const runIn = dir;
+      for (const sub of depth < 4 ? segment.subs ?? [] : [])
+        targets.push(...segmentTargets(runIn, sub, dialect, depth + 1, true));
+      const opaque = segment.unanalyzable ? ["."] : inner === null ? opaqueWrites(words) : null;
+      for (const file of opaque ?? []) {
+        const resolved = at(file);
+        if (resolved)
+          targets.push(file === "." ? path28.join(resolved, DIR_TARGET) : resolved);
+      }
+      const ln = words.findIndex((word) => /^ln$/i.test(word.split(/[\\/]/).at(-1) ?? ""));
+      if (ln >= 0 && words.slice(0, ln).every((word) => PREFIXES2.has(word)))
+        targets.push(...linkSources(words.slice(ln + 1), at));
+    }
     for (const file of segment.redirects)
       if (!/^\/dev\/(?:null|stdout|stderr|tty)$/.test(file)) {
         const resolved = at(file);
@@ -20101,17 +21062,33 @@ var NONE3, CASE_INSENSITIVE, canonical2 = (file) => {
     const edits = editsOf(segment.words);
     if (edits === null) {
       if (dir !== undefined)
-        targets.push(path27.join(dir, DIR_TARGET));
+        targets.push(path28.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(quoteWord2).join(" "), "posix").some((args) => args[0] === "git" && MUTATING_WORKIT_GIT.has(args[1] ?? "") && !inert(args.slice(2), "")))
-      targets.push(path27.join(dir, DIR_TARGET));
+    if (dir !== undefined)
+      for (const invocation of workitInvocations(segment.words.map(quoteWord2).join(" "), "posix")) {
+        const { at: runsIn, args } = workitCwd(dir, invocation);
+        if (args[0] === "git" && MUTATING_WORKIT_GIT.has(args[1] ?? "") && !inert(args.slice(2), ""))
+          targets.push(path28.join(runsIn, DIR_TARGET));
+      }
   }
   return targets;
+}, workitCwd = (dir, args) => {
+  const { rest, cwd } = skipWorkitGlobals(args);
+  return { at: cwd === null ? dir : path28.resolve(dir, homeExpanded(cwd)), args: rest };
+}, shellMutationTargets = (cwd, command, dialect = "posix", strict = false) => {
+  try {
+    return [
+      ...segmentTargets(cwd, command, dialect, 0, strict),
+      ...gitMutationDirs(cwd, command, dialect).map((dir) => path28.join(dir, DIR_TARGET))
+    ];
+  } catch {
+    return [];
+  }
 }, overridden = (command, dialect) => {
   const segments = segmentsOf(command, dialect);
   if (segments.length !== 1 || segments[0].group || segments[0].subs?.length)
@@ -20132,7 +21109,7 @@ var NONE3, CASE_INSENSITIVE, canonical2 = (file) => {
 }, guarded = (targets) => {
   const seen = new Set;
   return targets.filter((target) => {
-    const dir = path27.dirname(target);
+    const dir = path28.dirname(target);
     if (seen.has(dir))
       return false;
     seen.add(dir);
@@ -20150,13 +21127,13 @@ var NONE3, CASE_INSENSITIVE, canonical2 = (file) => {
 }, claimAll = (owner, targets, deps) => {
   for (const target of guarded(targets))
     claimLiveSession(target, owner, deps);
-}, liveTargets = (cwd, paths) => paths?.length ? paths.map((file) => path27.resolve(cwd, file)) : [path27.join(cwd, DIR_TARGET)], issuedTarget = (cwd, targets) => {
+}, liveTargets = (cwd, paths) => paths?.length ? paths.map((file) => path28.resolve(cwd, file)) : [path28.join(cwd, DIR_TARGET)], issuedTarget = (cwd, targets) => {
   const state = resolveStateDir();
   const found = targets.find((target) => underIssued(state, cwd, homeExpanded(target), process.platform, canonical2));
   return found ?? null;
 }, underIssued = (state, cwd, target, platform = process.platform, real = (file) => file) => {
   const win = platform === "win32";
-  const p = win ? path27.win32 : path27.posix;
+  const p = win ? path28.win32 : path28.posix;
   const fold = (value) => win || platform === "darwin" ? value.toLowerCase() : value;
   const named = win ? target.replace(/^\/([a-zA-Z])(?=\/|$)/, "$1:") : target;
   const relative = p.relative(fold(real(p.resolve(state))), fold(real(p.resolve(cwd, named))));
@@ -20199,8 +21176,9 @@ var init_write_gate = __esm(() => {
   init_shell_words();
   NONE3 = { kind: "none" };
   CASE_INSENSITIVE = process.platform === "darwin" || process.platform === "win32";
-  PREFIXES2 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "xargs"]);
+  PREFIXES2 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "xargs", "busybox"]);
   SCRIPT_SHELLS = new Set(["sh", "bash", "zsh", "dash", "ksh"]);
+  XARGS_VALUE = /^-[IinLPdsEa]$/;
   cache2 = new Map;
   MUTATING_GIT = new Set([
     "add",
@@ -20226,6 +21204,7 @@ var init_write_gate = __esm(() => {
   CD2 = new Set(["cd", "chdir", "set-location", "sl"]);
   PUSHD2 = new Set(["pushd", "push-location"]);
   POPD2 = new Set(["popd", "pop-location"]);
+  UNKNOWN_DIR = path28.resolve(path28.parse(process.cwd()).root, ".workit-unknown-dir");
   HOST_LABELS = {
     claude_code: "Claude Code",
     opencode: "OpenCode",
@@ -20236,6 +21215,26 @@ var init_write_gate = __esm(() => {
   };
 });
 
+// packages/workit-core/src/core/policy/current-judgment.ts
+function currentJudgment(cwd) {
+  try {
+    const store = new TaskStore(cwd);
+    const listed = store.listTaskIndex();
+    const key = store.currentKey();
+    if (!listed.ok || !key.ok)
+      return null;
+    const entry = listed.data.filter((item) => item.key === key.data.key && item.status !== "closed").toSorted((left, right) => right.updatedAt.localeCompare(left.updatedAt))[0];
+    const task = entry ? store.readTask(entry.id) : null;
+    return task?.ok === true ? latestJudgment(task.data) : null;
+  } catch {
+    return null;
+  }
+}
+var init_current_judgment = __esm(() => {
+  init_task_store();
+  init_derive();
+});
+
 // packages/workit-core/src/hooks/stop.ts
 import { spawnSync as spawnSync14 } from "node:child_process";
 function stopObligation(input, descriptor) {
@@ -20274,7 +21273,7 @@ function stopObligation(input, descriptor) {
     }
     if (!delivered || endpoint !== "green" && endpoint !== "merged")
       return null;
-    const left = unverified(input.cwd, branch, all, descriptor, autonomy.verification);
+    const left = unverified(input.cwd, branch, all, descriptor, autonomy.verification, head);
     return left ? { ...left, head } : null;
   } catch {
     return null;
@@ -20377,28 +21376,31 @@ var NONE4, QUESTION, OFFER, YES_NO, LIST_ITEM, asksUser = (message) => {
     kind: "checks",
     reason: `PR #${pr}'s checks were last seen ${state} at ${short(head)}, and this workspace's endpoint is \`${endpoint}\`: run \`workit ci wait --pr ${pr}\`${state === "failing" ? " after fixing the failures `workit pr status` lists (then push)" : ""}.`
   };
-}, taskJudgment = (cwd) => {
-  try {
-    const store = new TaskStore(cwd);
-    const listed = store.listTaskIndex();
-    const key = store.currentKey();
-    if (!listed.ok || !key.ok)
-      return null;
-    const entry = listed.data.filter((item) => item.key === key.data.key && item.status !== "closed").toSorted((left, right) => right.updatedAt.localeCompare(left.updatedAt))[0];
-    const task = entry ? store.readTask(entry.id) : null;
-    return task?.ok === true ? latestJudgment(task.data) : null;
-  } catch {
-    return null;
-  }
-}, unverified = (cwd, branch, all, descriptor, verification) => {
+}, prBase = (rows) => {
+  const seen = rows.findLast((row) => (row.type === "pr.status" || row.type === "pr.created") && row.observer === "workit_cli" && typeof row.base === "string");
+  return typeof seen?.base === "string" ? seen.base : null;
+}, unverified = (cwd, branch, all, descriptor, verification, head) => {
   const check = checkVerdicts(cwd, branch, all);
   if (check.accepted.accepted || check.accepted.reasons.includes("failing_verdict"))
     return null;
-  const judgment = taskJudgment(cwd);
+  const judgment = currentJudgment(cwd);
   const high = judgment?.riskTier === "high";
-  if (judgment && !judgment.behaviorChange && !high)
-    return null;
-  const independent = verification === "independent" || high;
+  let independent;
+  if (verification === "proportional") {
+    const lane = branchLane(cwd, {
+      base: prBase(all.filter((row) => row.branch === branch)),
+      head,
+      judgment
+    });
+    const need = laneNeed(lane.lane);
+    if (need === "none")
+      return null;
+    independent = need === "non-author";
+  } else {
+    if (judgment && !judgment.behaviorChange && !high)
+      return null;
+    independent = verification === "independent" || high;
+  }
   if (!independent && check.review === "self-reviewed")
     return null;
   const has = check.review === "self-reviewed" ? "only a self verdict" : "no current verdict";
@@ -20411,8 +21413,8 @@ var NONE4, QUESTION, OFFER, YES_NO, LIST_ITEM, asksUser = (message) => {
 };
 var init_stop = __esm(() => {
   init_autonomy();
-  init_derive();
-  init_task_store();
+  init_current_judgment();
+  init_lane();
   init_rev();
   init_ledger();
   init_raw_git();
@@ -20653,10 +21655,10 @@ var init_skill_nudge = __esm(() => {
 });
 
 // packages/workit-core/src/hooks/hosts/fields.ts
-import { existsSync as existsSync7, realpathSync as realpathSync6, statSync as statSync2 } from "node:fs";
-import path28 from "node:path";
+import { existsSync as existsSync9, realpathSync as realpathSync6, statSync as statSync2 } from "node:fs";
+import path29 from "node:path";
 var isRecord6 = (value) => value !== null && typeof value === "object" && !Array.isArray(value), nonEmpty2 = (value) => typeof value === "string" && value.trim() !== "", optionalText = (value) => typeof value === "string" ? value : null, existingDirectory = (value) => {
-  if (!nonEmpty2(value) || !path28.isAbsolute(value) || !existsSync7(value))
+  if (!nonEmpty2(value) || !path29.isAbsolute(value) || !existsSync9(value))
     return null;
   try {
     return statSync2(value).isDirectory() ? realpathSync6(value) : null;
@@ -20722,9 +21724,9 @@ var init_fields = __esm(() => {
 
 // packages/workit-core/src/hooks/standing.ts
 import fs22 from "node:fs";
-import path29 from "node:path";
+import path30 from "node:path";
 var readPlans = (store) => {
-  const dir = path29.join(store, "fanouts");
+  const dir = path30.join(store, "fanouts");
   let names;
   try {
     names = fs22.readdirSync(dir).filter((name) => name.endsWith(".json"));
@@ -20734,7 +21736,7 @@ var readPlans = (store) => {
   const plans = [];
   for (const name of names) {
     try {
-      const raw = JSON.parse(fs22.readFileSync(path29.join(dir, name), "utf8"));
+      const raw = JSON.parse(fs22.readFileSync(path30.join(dir, name), "utf8"));
       if (typeof raw.name !== "string" || !Array.isArray(raw.slices))
         continue;
       const texts = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string" && item !== "") : [];
@@ -20857,6 +21859,252 @@ var init_cwd_normalize = __esm(() => {
   FILTERS = new Set(["tail", "head", "grep"]);
 });
 
+// packages/workit-core/src/hooks/worktree-confine.ts
+import { createHash as createHash17 } from "node:crypto";
+import fs23 from "node:fs";
+import path31 from "node:path";
+function confineImplementer(input, targets) {
+  try {
+    if (!input.session.agentId || hostIsolated(input.cwd, input.session.agentId))
+      return NONE5;
+    if (targets.some((target) => within(path31.resolve(target), UNKNOWN_DIR)))
+      return unknownDirDeny(input, boundWorktree(input));
+    const bindings = canonical3(bindingDir());
+    const judged = targets.map((named) => ({ named, real: canonical3(named) })).filter(({ real }) => within(real, bindings) || checkoutOf2(real) !== null);
+    if (judged.length === 0)
+      return NONE5;
+    let worktree = boundWorktree(input);
+    if (!worktree) {
+      for (const { real } of judged) {
+        worktree = within(real, bindings) ? null : workitWorktreeOf(real);
+        if (worktree)
+          break;
+      }
+      if (!worktree)
+        return unboundDeny(input, judged[0].named);
+      bind(input, worktree);
+    }
+    const root = canonical3(worktree);
+    const outside = judged.find(({ real }) => !within(real, root) || within(real, bindings));
+    return outside ? outsideDeny(input, worktree, outside.named) : NONE5;
+  } catch {
+    return NONE5;
+  }
+}
+function confineImplementerShell(input, command, dialect = "posix") {
+  try {
+    if (!input.session.agentId || hostIsolated(input.cwd, input.session.agentId))
+      return NONE5;
+    if (rawInvocations(command, dialect).some((invocation) => invocation.tool === "git" && leadOwnedGit(invocation.args)) || workitInvocations(command, dialect).some(leadOwnedWorkit))
+      return leadOwnedDeny(input, command);
+  } catch {}
+  return confineImplementer(input, shellMutationTargets(input.cwd, command, dialect, true));
+}
+var FANOUT_TOKEN_FILE = "workit-fanout-token", NONE5, CASE_INSENSITIVE2, canonical3 = (file) => {
+  let rest = "";
+  for (let dir = path31.resolve(file);; dir = path31.dirname(dir)) {
+    try {
+      return path31.join(fs23.realpathSync.native(dir), rest);
+    } catch {
+      if (path31.dirname(dir) === dir)
+        return path31.resolve(file);
+      rest = rest ? path31.join(path31.basename(dir), rest) : path31.basename(dir);
+    }
+  }
+}, within = (child, parent) => {
+  const fold = (value) => CASE_INSENSITIVE2 ? value.toLowerCase() : value;
+  const relative = path31.relative(fold(parent), fold(child));
+  return relative === "" || !relative.startsWith("..") && !path31.isAbsolute(relative);
+}, checkoutOf2 = (file) => {
+  for (let dir = canonical3(file);; dir = path31.dirname(dir)) {
+    const dotGit = path31.join(dir, ".git");
+    if (fs23.existsSync(dotGit)) {
+      if (!fs23.statSync(dotGit).isFile())
+        return { root: dir, workit: false };
+      const admin = /^gitdir:\s*(.+)$/mu.exec(fs23.readFileSync(dotGit, "utf8"))?.[1]?.trim();
+      return {
+        root: dir,
+        workit: Boolean(admin) && fs23.existsSync(path31.join(path31.resolve(dir, admin), FANOUT_TOKEN_FILE))
+      };
+    }
+    if (path31.dirname(dir) === dir)
+      return null;
+  }
+}, workitWorktreeOf = (file) => {
+  try {
+    const checkout = checkoutOf2(file);
+    return checkout?.workit ? checkout.root : null;
+  } catch {
+    return null;
+  }
+}, bindingDir = () => path31.join(resolveStateDir(), "worktree-bind"), bindingFile = (session, agentId) => path31.join(bindingDir(), `${createHash17("sha256").update(`${session}\x00${agentId}`).digest("hex").slice(0, 32)}.json`), readBinding = (file) => {
+  try {
+    const value = JSON.parse(fs23.readFileSync(file, "utf8"));
+    return typeof value.worktree === "string" ? value : null;
+  } catch {
+    return null;
+  }
+}, boundWorktree = (input) => {
+  const agentId = input.session.agentId;
+  if (!agentId)
+    return null;
+  const binding = readBinding(bindingFile(input.session.id, agentId));
+  return binding && workitWorktreeOf(binding.worktree) === binding.worktree ? binding.worktree : null;
+}, bind = (input, worktree) => {
+  const agentId = input.session.agentId;
+  const file = bindingFile(input.session.id, agentId);
+  const binding = {
+    worktree,
+    session: input.session.id,
+    agentId,
+    at: new Date().toISOString()
+  };
+  fs23.mkdirSync(path31.dirname(file), { recursive: true });
+  fs23.writeFileSync(file, JSON.stringify(binding));
+  try {
+    if (inWorkitWorkspace(input.cwd))
+      appendHookObserved(input.cwd, {
+        type: "worktree.bound",
+        actor: { host: input.host, session: input.session.id, agentId },
+        agentType: input.session.agentType,
+        worktree
+      });
+  } catch {}
+}, hostIsolated = (cwd, agentId) => {
+  try {
+    if (agentId === null)
+      return false;
+    const checkout = checkoutOf2(cwd);
+    if (!checkout)
+      return false;
+    const dotGit = path31.join(checkout.root, ".git");
+    if (!fs23.statSync(dotGit).isFile())
+      return false;
+    const admin = /^gitdir:\s*(.+)$/mu.exec(fs23.readFileSync(dotGit, "utf8"))?.[1]?.trim();
+    if (!admin)
+      return false;
+    const adminDir = path31.resolve(checkout.root, admin);
+    const back = fs23.readFileSync(path31.join(adminDir, "gitdir"), "utf8").trim();
+    if (path31.relative(canonical3(path31.resolve(adminDir, back)), canonical3(dotGit)) !== "")
+      return false;
+    const common = path31.join(adminDir, "commondir");
+    const gitDir = fs23.existsSync(common) ? path31.resolve(adminDir, fs23.readFileSync(common, "utf8").trim()) : adminDir;
+    const expected = path31.join(path31.dirname(canonical3(gitDir)), ".claude", "worktrees", `agent-${agentId}`);
+    return path31.relative(canonical3(expected), checkout.root) === "";
+  } catch {
+    return false;
+  }
+}, shown = (target) => path31.basename(target) === ".workit-live-target" ? path31.dirname(target) : target, unboundDeny = (input, target) => {
+  const unblock = "Work only in the worktree your brief names, which the lead made with `workit fanout worktree create <slice>`: edit files under it and run one verb per call against it (`workit --cwd <worktree> git commit -m … -- <paths>`, `workit --cwd <worktree> check <name>`). If your brief names no worktree, stop and report that to the lead.";
+  return {
+    kind: "deny",
+    reason: `workit worktree confinement: implementer ${input.session.agentId} is not working in a Workit worktree yet, and ${shown(target)} is outside every worktree \`workit fanout worktree create\` made, so it would change the lead's checkout. ${unblock}`,
+    unblock
+  };
+}, outsideDeny = (input, worktree, target) => {
+  const unblock = `Edit only under ${worktree} and run git there, one verb per call: \`workit --cwd ${worktree} git commit -m … -- <paths>\`, \`workit --cwd ${worktree} check <name>\` (or \`git -C ${worktree} …\`); a command whose writes Workit cannot see is judged by the directory it runs in. Anything outside it is a follow-up for your report.`;
+  return {
+    kind: "deny",
+    reason: `workit worktree confinement: implementer ${input.session.agentId} is bound to the worktree ${worktree}, and ${shown(target)} is outside it. ${unblock}`,
+    unblock
+  };
+}, unknownDirDeny = (input, worktree) => {
+  const wt = worktree ?? "<worktree>";
+  const unblock = `Workit cannot resolve \`cd -\`, \`cd "$X"\` or \`popd\`: write by absolute path, \`git -C ${wt}\` or \`workit --cwd ${wt}\`.`;
+  return {
+    kind: "deny",
+    reason: `workit worktree confinement: implementer ${input.session.agentId} writes after an unknown directory change. ${unblock}`,
+    unblock
+  };
+}, MUTATING_REMOTE, CONFIG_READ, CONFIG_WRITE, CONFIG_VALUE, leadOwnedGit = (args) => {
+  const [sub = "", ...rest] = args;
+  if (rest.some((arg) => arg === "--help" || arg === "-h"))
+    return false;
+  const names = rest.filter((arg) => !arg.startsWith("-"));
+  const flag = (pattern) => rest.some((arg) => pattern.test(arg));
+  switch (sub) {
+    case "worktree":
+      return names[0] !== undefined && names[0] !== "list";
+    case "update-ref":
+      return true;
+    case "symbolic-ref":
+      return names.length > 1 || flag(/^(?:-d|--delete)$/);
+    case "branch":
+      return flag(/^-[a-zA-Z]*[dDfmMcC]|^--(?:delete|force|move|copy)$/);
+    case "tag":
+      return flag(/^-[a-zA-Z]*[df]|^--(?:delete|force)$/);
+    case "push": {
+      if (flag(/^(?:-d|--delete|--mirror|--prune)$/))
+        return true;
+      const refspecs = names.slice(1);
+      return refspecs.some((name) => name.includes(":") || name.startsWith("+")) || refspecs.length > 0 && flag(/^-[a-zA-Z]*f|^--force/);
+    }
+    case "replace":
+    case "filter-branch":
+    case "gc":
+    case "prune":
+    case "repack":
+    case "sparse-checkout":
+      return true;
+    case "notes":
+    case "reflog":
+    case "submodule":
+      return !/^(?:list|show|status|exists)$/.test(names[0] ?? "list");
+    case "stash":
+      return names[0] === "drop" || names[0] === "clear";
+    case "remote":
+      return MUTATING_REMOTE.has(names[0] ?? "");
+    case "config": {
+      if (rest.some((arg) => CONFIG_READ.test(arg)))
+        return false;
+      if (rest.some((arg) => CONFIG_WRITE.test(arg)))
+        return true;
+      let operands = 0;
+      for (let index = 0;index < rest.length; index++)
+        if (CONFIG_VALUE.test(rest[index]))
+          index++;
+        else if (!rest[index].startsWith("-"))
+          operands++;
+      return operands > 1;
+    }
+    default:
+      return false;
+  }
+}, leadOwnedWorkit = (args) => !args.includes("--help") && args.some((_, start) => {
+  if (start > 0 && !/(?:^|[\\/])workit(?:\.exe|\.cmd)?$/.test(args[start - 1]))
+    return false;
+  const [verb, sub] = skipWorkitGlobals(args.slice(start)).rest;
+  return verb === "fanout" && /^(?:plan|worktree)$/.test(sub ?? "");
+}), leadOwnedDeny = (input, command) => {
+  const unblock = "Worktrees, branches other than your own, refs, tags, remotes, git config, the shared stash and the fan-out plan belong to the lead: report what you need changed as a follow-up instead.";
+  return {
+    kind: "deny",
+    reason: `workit worktree confinement: implementer ${input.session.agentId} may not run \`${command.slice(0, 160)}\`. ${unblock}`,
+    unblock
+  };
+};
+var init_worktree_confine = __esm(() => {
+  init_logger();
+  init_ledger();
+  init_raw_git();
+  init_write_gate();
+  NONE5 = { kind: "none" };
+  CASE_INSENSITIVE2 = process.platform === "darwin" || process.platform === "win32";
+  MUTATING_REMOTE = new Set([
+    "add",
+    "remove",
+    "rm",
+    "rename",
+    "set-url",
+    "set-head",
+    "set-branches",
+    "prune"
+  ]);
+  CONFIG_READ = /^(?:--get(?:-all|-regexp|-urlmatch)?|--list|-l|get|list)$/;
+  CONFIG_WRITE = /^(?:--(?:unset(?:-all)?|add|replace-all|rename-section|remove-section|edit)|-e|set|unset|rename-section|remove-section|edit)$/;
+  CONFIG_VALUE = /^(?:--file|-f|--blob|--type|--default|--comment)$/;
+});
+
 // packages/workit-core/src/hooks/handle.ts
 function handleHook(input, deps) {
   const decision = decide(input, deps);
@@ -20874,7 +22122,7 @@ function decide(input, deps) {
   switch (event.kind) {
     case "session.start": {
       if (!usable2(descriptor.context.sessionStart))
-        return NONE5;
+        return NONE6;
       const key = input.session.id ? `${input.host}\x00${input.session.id}` : null;
       const offer = event.source === "startup" && (key === null || !offered.has(key));
       if (offer && key !== null)
@@ -20889,26 +22137,31 @@ function decide(input, deps) {
     }
     case "context.turn": {
       if (!usable2(descriptor.context.perTurn))
-        return NONE5;
+        return NONE6;
       const current = turnContextText(input, descriptor);
       const text = resendsOnChange(descriptor) ? changedTurnContext(input, current) : current;
-      return withContextLine(text ? { kind: "context", text } : NONE5, promptNudge(input, event.prompt));
+      return withContextLine(text ? { kind: "context", text } : NONE6, promptNudge(input, event.prompt));
     }
     case "shell.pre": {
       const skillRead = skillReadIn(event.command, event.dialect);
       if (skillRead)
         recordSkillLoad(input, skillRead, "read");
       const canDeny = usable2(descriptor.shellPolicy.deny);
-      const policy = canDeny ? shellPolicy(input.cwd, event.command, event.dialect) : NONE5;
+      const policy = canDeny ? shellPolicy(input.cwd, event.command, event.dialect) : NONE6;
       if (policy.kind !== "none")
         return policy;
       const postTool = usable2(descriptor.events["shell.post"].support);
       if (!postTool)
         settlePendingCommit(input);
-      const raw = canDeny ? rawGitPre(input, event.command, { nudge: false }) : NONE5;
+      const raw = canDeny ? rawGitPre(input, event.command, { nudge: false }) : NONE6;
       if (raw.kind === "deny")
         return raw;
-      const gate = usable2(descriptor.events["write.pre"].support) ? shellGate(input.cwd, event.command, liveOwner(input, descriptor.transport), event.dialect) : NONE5;
+      if (canDeny && implementerAgent(input, descriptor)) {
+        const confined = confineImplementerShell(input, event.command, event.dialect);
+        if (confined.kind === "deny")
+          return confined;
+      }
+      const gate = usable2(descriptor.events["write.pre"].support) ? shellGate(input.cwd, event.command, liveOwner(input, descriptor.transport), event.dialect) : NONE6;
       if (gate.kind === "deny")
         return gate;
       const plan = heavyGate(input.cwd, event.command, {
@@ -20931,10 +22184,10 @@ function decide(input, deps) {
         command: rewrittenTo,
         input: event.toolInput ? { ...event.toolInput, command: rewrittenTo } : null,
         text
-      } : NONE5;
+      } : NONE6;
       if (descriptor.transport !== "hook-process")
         return rewritten(null);
-      const nudged = withContextLine(withContextLine(canDeny ? rawGitPre(input, event.command) : NONE5, aside), shipNudge(input, event.command));
+      const nudged = withContextLine(withContextLine(canDeny ? rawGitPre(input, event.command) : NONE6, aside), shipNudge(input, event.command));
       if (!lease)
         return cwdCommand && nudged.kind !== "deny" ? rewritten(nudged.kind === "context" ? nudged.text : null) : nudged;
       return rewritten([rewriteNote(lease), nudged.kind === "context" ? nudged.text : null].filter(Boolean).join(`
@@ -20943,9 +22196,17 @@ function decide(input, deps) {
     case "shell.post":
       if (usable2(descriptor.events["shell.post"].support))
         rawGitPost(input, event.command, callKey(event.toolUseId, event.command));
-      return NONE5;
-    case "write.pre":
-      return usable2(descriptor.events["write.pre"].support) ? writeGate(input.cwd, event.paths, liveOwner(input, descriptor.transport)) : NONE5;
+      return NONE6;
+    case "write.pre": {
+      if (!usable2(descriptor.events["write.pre"].support))
+        return NONE6;
+      if (implementerAgent(input, descriptor)) {
+        const confined = confineImplementer(input, liveTargets(input.cwd, event.paths));
+        if (confined.kind === "deny")
+          return confined;
+      }
+      return writeGate(input.cwd, event.paths, liveOwner(input, descriptor.transport));
+    }
     case "subagent.start":
       if (workitRole(descriptor, event.agentType) === "judge")
         trackJudge(input, event.agentId, true);
@@ -20962,25 +22223,25 @@ function decide(input, deps) {
     case "tool.pre":
       if (event.skill)
         recordSkillLoad(input, event.skill, "tool");
-      return NONE5;
+      return NONE6;
     case "stop":
-      return usable2(descriptor.events.stop.support) ? stopDecision(input, descriptor) : NONE5;
+      return usable2(descriptor.events.stop.support) ? stopDecision(input, descriptor) : NONE6;
     case "subagent.stop":
       trackJudge(input, event.agentId, false);
-      return NONE5;
+      return NONE6;
     case "prompt.submit":
-      return NONE5;
+      return NONE6;
   }
 }
-var usable2 = (value) => value === "native" || value === "partial", NONE5, resendsOnChange = (descriptor) => descriptor.context.turnResend === "on-change" && usable2(descriptor.context.perTurn), offered, ROLES, workitRole = (descriptor, agentType) => {
+var usable2 = (value) => value === "native" || value === "partial", NONE6, resendsOnChange = (descriptor) => descriptor.context.turnResend === "on-change" && usable2(descriptor.context.perTurn), offered, ROLES, workitRole = (descriptor, agentType) => {
   const prefix = descriptor.subagents.agentPrefix;
   const name = agentType.startsWith(prefix) ? agentType.slice(prefix.length) : "";
   return Object.hasOwn(ROLES, name) ? ROLES[name] : null;
-}, subagentSession = (session, agentId) => [session, agentId].filter((part) => Boolean(part)).join(":").replace(/[^A-Za-z0-9_.:@/+-]/g, "-").slice(0, 128), CLAUDE_WORKTREE, isolatedGit = (cwd) => `Run git as plain, separate commands inside your worktree (\`git switch -c <branch> <base>\`, ${workspaceTrailers(cwd).enabled ? '`git commit --trailer "Workit-Session=<your session>"`, `git push`; `workit doctor --fix` can install a prepare-commit-msg hook that adds the trailer' : "`git commit` (this workspace sets trailers: false: add no Workit-Session trailer), `git push`"}; add Co-Authored-By with \`git commit --trailer\` in the same commit, never by amending), never \`workit git …\`: Claude Code's worktree isolation refuses a command that wraps git and cannot be turned off (https://code.claude.com/docs/en/worktrees#how-claude-code-enforces-isolation). Never dodge that check by renaming or re-wrapping git. Use workit for the non-git verbs (\`workit check\`, \`workit ledger\`, \`workit pr\`).`, subagentStartText = (input, descriptor, event) => {
+}, implementerAgent = (input, descriptor) => Boolean(input.session.agentId) && input.session.agentType !== null && workitRole(descriptor, input.session.agentType) === "implementer", subagentSession = (session, agentId) => [session, agentId].filter((part) => Boolean(part)).join(":").replace(/[^A-Za-z0-9_.:@/+-]/g, "-").slice(0, 128), CLAUDE_WORKTREE, isolatedGit = (cwd) => `Run git as plain, separate commands inside your worktree (\`git switch -c <branch> <base>\`, ${workspaceTrailers(cwd).enabled ? '`git commit --trailer "Workit-Session=<your session>"`, `git push`; `workit doctor --fix` can install a prepare-commit-msg hook that adds the trailer' : "`git commit` (this workspace sets trailers: false: add no Workit-Session trailer), `git push`"}; add Co-Authored-By with \`git commit --trailer\` in the same commit, never by amending), never \`workit git …\`: Claude Code's worktree isolation refuses a command that wraps git and cannot be turned off (https://code.claude.com/docs/en/worktrees#how-claude-code-enforces-isolation). Never dodge that check by renaming or re-wrapping git. Use workit for the non-git verbs (\`workit check\`, \`workit ledger\`, \`workit pr\`).`, subagentStartText = (input, descriptor, event) => {
   const session = input.session.id ?? null;
   const role = workitRole(descriptor, event.agentType);
   const who = `${descriptor.label} subagent ${event.agentId} (${event.agentType})`;
-  const isolated = descriptor.subagents.worktreeIsolation === "native" && (role === "implementer" || CLAUDE_WORKTREE.test(input.cwd));
+  const isolated = descriptor.subagents.worktreeIsolation === "native" && (role === "implementer" ? hostIsolated(input.cwd, event.agentId) : CLAUDE_WORKTREE.test(input.cwd));
   const guide = role === "implementer" ? branchGuidance(input.cwd) : null;
   if (role === "implementer" && isolated)
     return `Workit observed ${who} working in its own git worktree: it may edit and commit there, within its brief's scope. ${isolatedGit(input.cwd)} Plain git is expected here, and the branch name is still policy-checked: a raw \`git switch -c\`, \`git checkout -b\`, \`git branch\` or \`git worktree add -b\` onto a protected or non-compliant name is denied, so use a policy-compliant branch.${guide ? ` ${guide}` : " (e.g. feature/<slug>)"} Never record a verdict on your own work. Never push, open a PR, or merge unless the brief asks for it.`;
@@ -20988,7 +22249,7 @@ var usable2 = (value) => value === "native" || value === "partial", NONE5, resen
     return `${isolatedGit(input.cwd)}
 ${subagentStartText({ ...input, cwd: "" }, descriptor, event)}`;
   if (role === "implementer")
-    return `Workit observed ${who} as an implementer: it edits and commits only in its own git worktree (the lead makes one with \`workit fanout worktree create <slice>\`), never in the lead's checkout, within its brief's scope. Before the first commit, switch to a policy-compliant branch with \`workit git branch <branch> --base <base>\` (or \`--kind <kind> --slug <slug>\`, which picks the base); branch policy hooks still deny protected or non-compliant branches, raw git included.${guide ? ` ${guide}` : " (e.g. feature/<slug>)"} Never record a verdict on your own work. Never push, open a PR, or merge unless the brief asks for it.`;
+    return `Workit observed ${who} as an implementer: it edits and commits only in its own git worktree, the one its brief names (the lead makes it with \`workit fanout worktree create <slice>\` before spawning), never in the lead's checkout, within its brief's scope. Workit binds it to the first Workit worktree it changes: from then on an edit or a mutating git command outside that worktree is denied, and before then so is one outside every Workit worktree. Run Workit against the worktree one verb per call, never \`cd … &&\` chains or \`$VAR\` paths: \`workit --cwd <worktree> git commit -m "<message>" -- <paths>\`, \`workit --cwd <worktree> check <name>\`. The worktree is on the brief's branch once the lead made it; otherwise switch with \`workit --cwd <worktree> git branch <branch> --base <base>\` (or \`--kind <kind> --slug <slug>\`, which picks the base); branch policy hooks still deny protected or non-compliant branches, raw git included.${guide ? ` ${guide}` : " (e.g. feature/<slug>)"} Never record a verdict on your own work. Never push, open a PR, or merge unless the brief asks for it.`;
   const readOnly = `Workit observed ${who} as read-only/agent-guided.`;
   if (role !== "judge" || !event.agentId)
     return readOnly;
@@ -21003,10 +22264,10 @@ ${subagentStartText({ ...input, cwd: "" }, descriptor, event)}`;
   return `${readOnly} Its own Workit session is ${own}, so the ledger tells its verdicts apart from the author's. Record the verdict with exactly this command (pick the result${pick}, name the candidate branch if it differs, say what you ran): \`${line}\`.${token ? " The token is this subagent's alone: never write it into a report, a file or a commit. --token needs a workit CLI at least as new as this plugin; if the CLI answers that --token is an unknown option, update the workit CLI (workit upgrade --cli) and record again." : ""}`;
 }, PRE_TOOL, failureDecision = (descriptor, event, error) => {
   if (event === "shell.pre" || event === "tool.pre" || event === "write.pre")
-    return descriptor.shellPolicy.failClosed ? { kind: "deny", reason: error, unblock: null } : NONE5;
+    return descriptor.shellPolicy.failClosed ? { kind: "deny", reason: error, unblock: null } : NONE6;
   if (event === "session.start" || event === "subagent.start")
     return { kind: "context", text: `[workit diagnostic: ${error}]` };
-  return NONE5;
+  return NONE6;
 }, dispatchHook = (adapter, raw, env = process.env) => {
   const parsed = adapter.parse(raw, env);
   if (!parsed.ok)
@@ -21044,7 +22305,8 @@ var init_handle = __esm(() => {
   init_stop();
   init_live_session();
   init_write_gate();
-  NONE5 = { kind: "none" };
+  init_worktree_confine();
+  NONE6 = { kind: "none" };
   offered = new Set;
   ROLES = {
     implementer: "implementer",
@@ -21057,20 +22319,20 @@ var init_handle = __esm(() => {
 
 // packages/workit-core/src/hooks/deadline.ts
 import { appendFileSync, mkdirSync as mkdirSync3 } from "node:fs";
-import path30 from "node:path";
+import path32 from "node:path";
 var HOOK_SKIP_TEXT = "workit context skipped: host under load", HOOK_DEADLINE_MS = 8000, HOST_DEADLINES, HOOK_SKIPS_FILE = "hook-skips.jsonl", override = (env) => {
   const value = Number(env.WORKIT_HOOK_DEADLINE_MS);
   return Number.isFinite(value) && value > 0 ? value : null;
 }, 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);
-}, skipsFile = (stateDir) => path30.join(stateDir, HOOK_SKIPS_FILE), recordHookSkip = (skip, stateDir = resolveStateDir()) => {
+}, skipsFile = (stateDir) => path32.join(stateDir, HOOK_SKIPS_FILE), recordHookSkip = (skip, stateDir = resolveStateDir()) => {
   try {
     mkdirSync3(stateDir, { recursive: true });
     appendFileSync(skipsFile(stateDir), `${JSON.stringify(skip)}
 `);
   } catch {}
-}, QUIET, skipDecision = (event) => QUIET.has(event) ? { kind: "none" } : { kind: "context", text: HOOK_SKIP_TEXT }, TIMED_OUT, within = async (work, ms) => {
+}, QUIET, skipDecision = (event) => QUIET.has(event) ? { kind: "none" } : { kind: "context", text: HOOK_SKIP_TEXT }, TIMED_OUT, within2 = async (work, ms) => {
   let timer;
   const expired = new Promise((resolve) => {
     timer = setTimeout(() => resolve(TIMED_OUT), Math.max(0, ms));
@@ -21097,7 +22359,7 @@ var HOOK_SKIP_TEXT = "workit context skipped: host under load", HOOK_DEADLINE_MS
       text += String(chunk);
     return text;
   })();
-  const text = await within(read, budget.startedAt + budget.deadlineMs - budget.now());
+  const text = await within2(read, budget.startedAt + budget.deadlineMs - budget.now());
   return isTimedOut(text) ? null : text;
 }, note = (adapter, raw, env, budget, outcome, stage) => {
   const parsed = raw === undefined ? null : adapter.parse(raw, env);
@@ -21123,7 +22385,7 @@ var HOOK_SKIP_TEXT = "workit context skipped: host under load", HOOK_DEADLINE_MS
   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;
+  const result = remaining() > 0 ? await within2(Promise.resolve().then(() => dispatch(adapter, raw, env)), remaining()) : TIMED_OUT;
   if (isTimedOut(result))
     return skippedHook(adapter, raw, env, budget, "dispatch");
   if (remaining() < 0)
@@ -21708,8 +22970,8 @@ var init_codex = __esm(() => {
 });
 
 // packages/workit-core/src/hooks/hosts/cursor.ts
-import fs23 from "node:fs";
-import path31 from "node:path";
+import fs24 from "node:fs";
+import path33 from "node:path";
 var undocumented, none, CURSOR_DESCRIPTOR, EVENTS3, parseCursorHookInput = (value) => {
   if (!isRecord6(value) || !Object.hasOwn(EVENTS3, String(value.hook_event_name)))
     return { ok: false, error: "hook_event_name is required" };
@@ -21790,17 +23052,17 @@ var undocumented, none, CURSOR_DESCRIPTOR, EVENTS3, parseCursorHookInput = (valu
       };
   }
 }, TRANSCRIPT_TAIL_BYTES, lastAssistantText = (file) => {
-  if (!file || !path31.isAbsolute(file))
+  if (!file || !path33.isAbsolute(file))
     return null;
   try {
-    const size = fs23.statSync(file).size;
+    const size = fs24.statSync(file).size;
     const start = Math.max(0, size - TRANSCRIPT_TAIL_BYTES);
     const buffer = Buffer.alloc(size - start);
-    const fd = fs23.openSync(file, "r");
+    const fd = fs24.openSync(file, "r");
     try {
-      fs23.readSync(fd, buffer, 0, buffer.length, start);
+      fs24.readSync(fd, buffer, 0, buffer.length, start);
     } finally {
-      fs23.closeSync(fd);
+      fs24.closeSync(fd);
     }
     const lines = buffer.toString("utf8").split(`
 `);
@@ -21826,14 +23088,14 @@ var undocumented, none, CURSOR_DESCRIPTOR, EVENTS3, parseCursorHookInput = (valu
   } catch {
     return null;
   }
-}, within2 = (root, dir) => dir === root || dir.startsWith(root.endsWith(path31.sep) ? root : `${root}${path31.sep}`), hookCwd = (input) => {
+}, within3 = (root, dir) => dir === root || dir.startsWith(root.endsWith(path33.sep) ? root : `${root}${path33.sep}`), hookCwd = (input) => {
   const cwd = existingDirectory(input.cwd);
   if (cwd && input.hook_event_name === "beforeShellExecution")
     return cwd;
   return cursorWorkspaceRoot(input);
 }, cursorWorkspaceRoot = (input) => {
   const cwd = existingDirectory(input.cwd);
-  return cwd && input.workspace_roots.find((root) => within2(root, cwd)) || input.workspace_roots[0];
+  return cwd && input.workspace_roots.find((root) => within3(root, cwd)) || input.workspace_roots[0];
 }, cursorDeny = (reason) => ({
   permission: "deny",
   user_message: "Workit blocked this action",