@brainervirus/workit-cursor 8.15.1 → 8.17.0

package/dist/cursor-session-start.js

@@ -9711,6 +9711,7 @@ var init_workspaces = __esm(() => {
     autoApprove: union([boolean2(), array(nonBlank)]).optional(),
     defaultEndpoint: unknown().optional(),
     verification: _enum(["self", "independent"]).optional(),
+    delegation: unknown().optional(),
     trailers: boolean2().optional(),
     liveSessionGuard: boolean2().optional(),
     fanout: object({ tierModels: unknown().optional() }).passthrough().optional(),
@@ -15032,6 +15033,16 @@ var init_workers = __esm(() => {
 import { spawnSync as spawnSync9 } from "node:child_process";
 import fs12 from "node:fs";
 import path16 from "node:path";
+function repoHeavyCommands(root) {
+  try {
+    const value = JSON.parse(fs12.readFileSync(checksConfigFile(root), "utf8"));
+    const resources = isRecord3(value) ? value.resources : undefined;
+    const list = isRecord3(resources) ? resources.heavyCommands : undefined;
+    return Array.isArray(list) ? list.filter((item) => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
 function splitCommand(command) {
   const argv = [];
   let current = "";
@@ -15112,7 +15123,7 @@ function detectedChecks(root) {
 }
 function loadCheckConfig(cwd) {
   const root = checkRoot(cwd);
-  const file = path16.join(root, CHECKS_FILE);
+  const file = checksConfigFile(root);
   const none = (error = null) => ({
     source: error ? CHECKS_FILE : "none",
     root,
@@ -15196,7 +15207,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", isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), SHELL_META, git4 = (cwd, args) => {
+var SCRIPT_CHECKS, CHECKS_FILE = "workit.checks.json", checksConfigFile = (root) => path16.join(root, CHECKS_FILE), isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), SHELL_META, git4 = (cwd, args) => {
   const run = spawnSync9("git", args, {
     cwd,
     encoding: "utf8",
@@ -15648,6 +15659,42 @@ function evaluateClosure(requestedOutcome, view) {
     requirementIds: evaluations.map((item) => item.requirementId)
   });
 }
+function boundTaskSummary(summary) {
+  const rules = new Map((summary.policy?.requirements ?? []).map((item) => [item.id, item]));
+  const unmet = summary.requirements.filter((item) => item.status === "unsatisfied" || item.status === "unavailable");
+  const { progress, closure } = summary;
+  const next = progress.nextAction;
+  const open = unmet.slice(0, BRIEF_OPEN).map((item) => ({
+    dimension: rules.get(item.requirementId)?.dimension ?? "verification",
+    before: rules.get(item.requirementId)?.before ?? "close",
+    status: item.status
+  }));
+  const brief = {
+    id: summary.id,
+    revision: summary.revision,
+    workspaceRevision: summary.workspaceRevision,
+    updatedAt: summary.updatedAt,
+    objective: clip(summary.objective),
+    status: summary.status,
+    closure: closure && {
+      outcome: closure.outcome,
+      at: closure.at,
+      summary: clip(closure.summary)
+    },
+    progress: {
+      summary: clip(progress.summary),
+      nextAction: next && clip(next),
+      blockers: progress.blockers.slice(0, BRIEF_BLOCKERS).map((item) => ({
+        reason: clip(item.reason),
+        dependentAction: clip(item.dependentAction)
+      }))
+    },
+    requirements: { total: summary.requirements.length, unmet: unmet.length, open },
+    truncated: false
+  };
+  brief.truncated = JSON.stringify(brief).includes("…") || progress.blockers.length > BRIEF_BLOCKERS || unmet.length > BRIEF_OPEN;
+  return brief;
+}
 var digestBytes = (value) => createHash10("sha256").update(value).digest("hex"), inside = (root, candidate) => candidate === root || candidate.startsWith(`${root}${path17.sep}`), relative = (root, candidate) => path17.relative(root, candidate).split(path17.sep).join("/") || ".", canonicalPath = (value) => {
   if (typeof value !== "string" || !value)
     return null;
@@ -15867,7 +15914,15 @@ var digestBytes = (value) => createHash10("sha256").update(value).digest("hex"),
   if (dimension === "decisions")
     return "decision";
   return "worker report";
-}, observedGate = (requirement) => (requirement.dimension === "testing" || requirement.dimension === "verification") && requirement.before === "close";
+}, observedGate = (requirement) => (requirement.dimension === "testing" || requirement.dimension === "verification") && requirement.before === "close", BRIEF_TEXT = 250, BRIEF_BLOCKERS = 3, BRIEF_OPEN = 8, clip = (value) => {
+  const fits = (text) => Buffer.byteLength(JSON.stringify(text)) <= BRIEF_TEXT;
+  if (fits(value))
+    return value;
+  let length = Math.min(value.length, BRIEF_TEXT);
+  while (length > 0 && !fits(`${value.slice(0, length)}…`))
+    length -= 1;
+  return `${value.slice(0, length)}…`;
+};
 var init_task_evaluation = __esm(() => {
   init_task_contract();
   init_check_config();
@@ -16294,6 +16349,15 @@ class WorkitCore {
     if (!parsed.ok)
       return parsed;
     const input = parsed.data;
+    if (this.context.readOnlyChild) {
+      if (input.action !== "inspect")
+        return failure2("permission_denied", "child sessions can only inspect the task summary");
+      const task = this.store.readTask(input.taskId);
+      if (!task.ok)
+        return task;
+      const summary = this.summary(task.data);
+      return summary.ok ? { ...summary, data: boundTaskSummary(summary.data) } : summary;
+    }
     if ((this.context.workerId ?? null) !== null) {
       if (input.action !== "inspect" && input.action !== "list")
         return failure2("permission_denied", "helpers cannot control task lifecycle or scope");
@@ -18696,7 +18760,16 @@ function rawInvocations(command, dialect = "posix", depth = 0) {
     RECENT.delete(RECENT.keys().next().value);
   return found;
 }
-function walk2(command, dialect, depth) {
+function commandLines(command, dialect = "posix") {
+  const lines = [];
+  try {
+    walk2(command, dialect, 0, lines);
+  } catch (error) {
+    throw error instanceof ShellAnalysisError ? error : new ShellAnalysisError(error instanceof Error ? error.message : String(error));
+  }
+  return lines;
+}
+function walk2(command, dialect, depth, seen) {
   const found = [];
   let dir = null;
   const groups = [];
@@ -18707,7 +18780,8 @@ function walk2(command, dialect, depth) {
   const nested = (script, inner) => {
     if (!script || depth >= MAX_DEPTH)
       return;
-    for (const invocation of rawInvocations(script, inner, depth + 1))
+    const inside = seen ? walk2(script, inner, depth + 1, seen) : rawInvocations(script, inner, depth + 1);
+    for (const invocation of inside)
       found.push({ ...invocation, dir: rebase(dir, invocation.dir) });
   };
   const visit = (input, stdin, hops) => {
@@ -18719,11 +18793,17 @@ function walk2(command, dialect, depth) {
     const name = commandName(words[0]);
     if (!name)
       return;
+    seen?.push(words);
+    if (name === "-c" || name === "--command")
+      return nested(words[1], "posix");
     const runs = (lines) => {
       if (hops < MAX_DEPTH)
         for (const next of lines)
           visit(next, undefined, hops + 1);
     };
+    const wrapped = seen ? null : workitCheckTail(words);
+    if (wrapped)
+      return "script" in wrapped ? nested(wrapped.script, "posix") : runs([wrapped.argv]);
     if (CD.has(name)) {
       const target = cdTarget(words);
       dir = target === null ? os5.homedir() : joinDir(dir, target);
@@ -18800,6 +18880,49 @@ function walk2(command, dialect, depth) {
   }
   return found;
 }
+function workitCheckTail(words) {
+  let at = 0;
+  if (PACKAGE_RUNNERS.has(commandName(words[0]))) {
+    at = words.findIndex((word, index) => index > 0 && !word.startsWith("-"));
+    if (at < 0 || !WORKIT_PACKAGE.test(words[at]))
+      return null;
+  } else if (!/^workit(?:\.exe|\.cmd)?$/.test(commandName(words[0])))
+    return null;
+  const args = words.slice(at + 1);
+  if (args[0] !== "check" && !(args[0] === "lock" && args[1] === "run"))
+    return null;
+  const split = args.indexOf("--");
+  const tail = split < 0 ? [] : args.slice(split + 1);
+  if (!tail.length)
+    return null;
+  return args.slice(0, split).includes("--shell") ? { script: tail.join(" ") } : { argv: tail };
+}
+function simpleCommand(command, dialect = "posix", depth = 0) {
+  let segments;
+  try {
+    segments = segmentsOf(command, dialect);
+  } catch {
+    return null;
+  }
+  if (segments.length !== 1)
+    return null;
+  const [segment] = segments;
+  if (segment.group || segment.pipe || segment.unanalyzable || segment.redirects.length || segment.subs?.length || segment.stdin?.length)
+    return null;
+  const { words } = stripPrefixes(segment.words);
+  const name = commandName(words[0]);
+  if (!name || depth >= MAX_DEPTH)
+    return null;
+  if (SHELLS.has(name)) {
+    const script = shellScript(words, undefined);
+    return script ? simpleCommand(script, "posix", depth + 1) : null;
+  }
+  if (name === "-c" || name === "--command")
+    return words[1] ? simpleCommand(words[1], "posix", depth + 1) : null;
+  if (EVALS.has(name) || POWERSHELLS.has(name) || ["xargs", "find", "parallel", "script", "cmd", "source", "."].includes(name))
+    return null;
+  return words;
+}
 function workitInvocations(command, dialect = "posix", depth = 0) {
   const found = [];
   for (const { words } of segmentsOf(command, dialect)) {
@@ -19216,7 +19339,7 @@ var NONE2, SHELLS, POWERSHELLS, EVALS, WRAPPERS, WRAPPER_VALUES, KEYWORDS, DECLA
     ...Object.keys(env).length ? { env } : {},
     ...stdin === undefined ? {} : { stdin }
   };
-}, RECENT, LAUNCHERS, WORKIT_BIN, PUSH_VALUE_OPTIONS, CURRENT_BRANCH, pushDestination = (destination) => {
+}, RECENT, LAUNCHERS, WORKIT_BIN, WORKIT_PACKAGE, PACKAGE_RUNNERS, PUSH_VALUE_OPTIONS, CURRENT_BRANCH, pushDestination = (destination) => {
   if (destination === "HEAD" || destination === "@" || CURRENT_BRANCH.test(destination))
     return { name: null };
   if (destination.startsWith("refs/heads/"))
@@ -19908,6 +20031,8 @@ var init_raw_git = __esm(() => {
     "command"
   ]);
   WORKIT_BIN = /(?:^|[\\/])workit(?:\.exe)?$|^@brainervirus\/workit-cli$/;
+  WORKIT_PACKAGE = /^@brainervirus\/workit-cli(?:@\S*)?$/;
+  PACKAGE_RUNNERS = new Set(["npx", "bunx", "pnpx"]);
   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 = {
@@ -20147,12 +20272,808 @@ var init_policy = __esm(() => {
   init_shell_words();
 });
 
-// packages/workit-core/src/core/live-session.ts
-import { spawnSync as spawnSync13 } from "node:child_process";
-import { createHash as createHash15 } from "node:crypto";
+// packages/workit-core/src/core/heavy-rules.ts
 import fs17 from "node:fs";
 import os6 from "node:os";
 import path22 from "node:path";
+function parseJsonc(text) {
+  let out = "";
+  for (let index = 0;index < text.length; index += 1) {
+    const char = text[index];
+    if (char === '"') {
+      const end = /"(?:[^"\\]|\\.)*"/y;
+      end.lastIndex = index;
+      const match = end.exec(text);
+      if (!match)
+        throw new Error("unterminated string");
+      out += match[0];
+      index += match[0].length - 1;
+    } else if (char === "/" && text[index + 1] === "/") {
+      while (index < text.length && text[index] !== `
+`)
+        index += 1;
+      out += `
+`;
+    } else if (char === "/" && text[index + 1] === "*") {
+      const close = text.indexOf("*/", index + 2);
+      if (close < 0)
+        throw new Error("unterminated comment");
+      index = close + 1;
+    } else
+      out += char;
+  }
+  return JSON.parse(out.replace(/,(\s*[}\]])/gu, "$1"));
+}
+function gitTop(cwd) {
+  for (let dir = path22.resolve(cwd);; dir = path22.dirname(dir)) {
+    if (fs17.existsSync(path22.join(dir, ".git")))
+      return dir;
+    if (path22.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 || path22.join(homeOf(env), ".claude");
+  return [
+    ...CLAUDE_MANAGED[platform] ? [CLAUDE_MANAGED[platform]] : [],
+    path22.join(user, "settings.json"),
+    path22.join(project, ".claude", "settings.json"),
+    path22.join(project, ".claude", "settings.local.json")
+  ];
+}
+function claudeRules(cwd, env = process.env) {
+  const rules = EMPTY();
+  try {
+    for (const file of claudeSettingsFiles(cwd, env)) {
+      const text = readText2(file);
+      if (text === null)
+        continue;
+      const value = JSON.parse(text);
+      if (!isRecord4(value))
+        return "unreadable";
+      const permissions = value.permissions;
+      if (permissions === undefined)
+        continue;
+      if (!isRecord4(permissions))
+        return "unreadable";
+      for (const [key, bucket] of [
+        ["deny", rules.deny],
+        ["ask", rules.deny],
+        ["allow", rules.allow]
+      ]) {
+        const list = permissions[key];
+        if (list === undefined)
+          continue;
+        if (!Array.isArray(list))
+          return "unreadable";
+        for (const entry of list) {
+          if (typeof entry !== "string")
+            return "unreadable";
+          const pattern = bashPattern(entry);
+          if (pattern !== null)
+            bucket.push(pattern);
+        }
+      }
+    }
+  } catch {
+    return "unreadable";
+  }
+  return rules;
+}
+function opencodeRules(cwd, env = process.env) {
+  const rules = EMPTY();
+  try {
+    const config = env.XDG_CONFIG_HOME || path22.join(homeOf(env), ".config");
+    const files = [
+      ...OPENCODE_NAMES.map((name) => path22.join(config, "opencode", name)),
+      ...projectDirs(cwd).flatMap((dir) => OPENCODE_NAMES.flatMap((name) => [path22.join(dir, name), path22.join(dir, ".opencode", name)])),
+      ...env.OPENCODE_CONFIG ? [env.OPENCODE_CONFIG] : []
+    ];
+    for (const file of files) {
+      const text = readText2(file);
+      if (text !== null && !opencodeConfig(parseJsonc(text), rules))
+        return "unreadable";
+    }
+    if (env.OPENCODE_CONFIG_CONTENT && !opencodeConfig(parseJsonc(env.OPENCODE_CONFIG_CONTENT), rules))
+      return "unreadable";
+  } catch {
+    return "unreadable";
+  }
+  return rules;
+}
+function codexRules(cwd, env = process.env) {
+  const rules = EMPTY();
+  try {
+    const home = env.CODEX_HOME || path22.join(homeOf(env), ".codex");
+    const top = gitTop(cwd) ?? cwd;
+    for (const dir of [path22.join(home, "rules"), path22.join(top, ".codex", "rules")]) {
+      let files;
+      try {
+        files = fs17.readdirSync(dir).filter((name) => name.endsWith(".rules"));
+      } catch (error) {
+        if (error.code === "ENOENT")
+          continue;
+        return "unreadable";
+      }
+      for (const name of files) {
+        const text = readText2(path22.join(dir, name)) ?? "";
+        for (const part of text.split(/\bprefix_rule\s*\(/u).slice(1)) {
+          const rule = codexRule(part);
+          if (!rule)
+            return "unreadable";
+          (rule.decision === "allow" ? rules.allow : rules.deny).push(rule.pattern);
+        }
+      }
+    }
+  } catch {
+    return "unreadable";
+  }
+  return rules;
+}
+function cursorRules(cwd, env = process.env) {
+  const rules = EMPTY();
+  try {
+    const top = gitTop(cwd) ?? cwd;
+    for (const file of [
+      path22.join(homeOf(env), ".cursor", "cli-config.json"),
+      path22.join(top, ".cursor", "cli.json")
+    ]) {
+      const text = readText2(file);
+      if (text === null)
+        continue;
+      const value = JSON.parse(text);
+      if (!isRecord4(value))
+        return "unreadable";
+      if (value.permissions === undefined)
+        continue;
+      if (!isRecord4(value.permissions))
+        return "unreadable";
+      for (const [key, bucket] of [
+        ["deny", rules.deny],
+        ["allow", rules.allow]
+      ]) {
+        const list = value.permissions[key];
+        if (list === undefined)
+          continue;
+        if (!Array.isArray(list))
+          return "unreadable";
+        for (const entry of list) {
+          if (typeof entry !== "string")
+            return "unreadable";
+          const match = /^Shell(?:\((.*)\))?$/su.exec(entry.trim());
+          if (match)
+            bucket.push(match[1] ?? "");
+        }
+      }
+    }
+  } catch {
+    return "unreadable";
+  }
+  return rules;
+}
+function names(pattern, words) {
+  const token = firstToken(pattern);
+  if (!token || token === "*" || token.includes("*"))
+    return true;
+  const wanted = baseName(token);
+  return words.some((word) => baseName(word) === wanted);
+}
+function wrapAllowed(read, words, command, options = {}) {
+  if (read === "unreadable")
+    return { ok: false, why: "named" };
+  if (read.deny.some((pattern) => names(pattern, words)))
+    return { ok: false, why: "named" };
+  if (!options.bypass && read.allow.some(coversWrapper) && !read.allow.some((pattern) => coversCommand(pattern, command)))
+    return { ok: false, why: "allowlisted" };
+  return { ok: true };
+}
+var EMPTY = () => ({ deny: [], allow: [] }), readText2 = (file) => {
+  try {
+    return fs17.readFileSync(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+}, isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), projectDirs = (cwd) => {
+  const top = gitTop(cwd);
+  const dirs = [];
+  for (let dir = path22.resolve(cwd);; dir = path22.dirname(dir)) {
+    dirs.push(dir);
+    if (!top || dir === top || path22.dirname(dir) === dir)
+      return dirs;
+  }
+}, homeOf = (env) => env.HOME || os6.homedir(), CLAUDE_MANAGED, bashPattern = (entry) => {
+  const match = /^Bash(?:\((.*)\))?$/su.exec(entry.trim());
+  return match ? match[1] ?? "" : null;
+}, OPENCODE_NAMES, opencodePermission = (permission, rules) => {
+  if (permission === undefined)
+    return true;
+  if (typeof permission === "string") {
+    (permission === "allow" ? rules.allow : rules.deny).push("");
+    return ["allow", "ask", "deny"].includes(permission);
+  }
+  if (!isRecord4(permission))
+    return false;
+  for (const key of ["bash", "shell"]) {
+    const value = permission[key];
+    if (value === undefined)
+      continue;
+    if (typeof value === "string") {
+      if (!["allow", "ask", "deny"].includes(value))
+        return false;
+      (value === "allow" ? rules.allow : rules.deny).push("");
+      continue;
+    }
+    if (!isRecord4(value))
+      return false;
+    for (const [pattern, action] of Object.entries(value)) {
+      if (action !== "allow" && action !== "ask" && action !== "deny")
+        return false;
+      (action === "allow" ? rules.allow : rules.deny).push(pattern);
+    }
+  }
+  return true;
+}, opencodeConfig = (value, rules) => {
+  if (!isRecord4(value))
+    return false;
+  if (!opencodePermission(value.permission, rules))
+    return false;
+  if (value.agent === undefined)
+    return true;
+  if (!isRecord4(value.agent))
+    return false;
+  return Object.values(value.agent).every((agent) => isRecord4(agent) && opencodePermission(agent.permission, rules));
+}, codexRule = (body) => {
+  const open = /\bpattern\s*=\s*\[/u.exec(body);
+  if (!open)
+    return null;
+  const words = [];
+  let index = open.index + open[0].length;
+  for (;; ) {
+    while (/[\s,]/u.test(body[index] ?? ""))
+      index += 1;
+    if (body[index] === "]")
+      break;
+    if (body[index] !== '"')
+      return null;
+    const literal = /"((?:[^"\\]|\\.)*)"/y;
+    literal.lastIndex = index;
+    const match = literal.exec(body);
+    if (!match)
+      return null;
+    words.push(JSON.parse(`"${match[1]}"`));
+    index = literal.lastIndex;
+  }
+  const decision = /\bdecision\s*=\s*"(\w+)"/u.exec(body)?.[1];
+  if (!words.length || !decision || !["allow", "prompt", "forbidden"].includes(decision))
+    return null;
+  return { pattern: words.join(" "), decision };
+}, baseName = (word) => (word.split(/[\\/]/u).at(-1) ?? "").toLowerCase().replace(/\.(?:exe|cmd|bat)$/u, ""), firstToken = (pattern) => pattern.trim().split(/[:\s]/u)[0] ?? "", literalPrefix = (pattern) => pattern.trim().replace(/(?::\*| \*|\*)$/u, ""), coversWrapper = (pattern) => {
+  const token = firstToken(pattern);
+  if (!token || token.includes("*"))
+    return true;
+  const words = literalPrefix(pattern).split(/\s+/u);
+  if (baseName(words[0]) !== "workit")
+    return false;
+  return ["check", "--heavy"].slice(0, words.length - 1).every((word, at) => {
+    const given = words[at + 1];
+    return given === word || word.startsWith(given);
+  });
+}, coversCommand = (pattern, command) => {
+  const prefix = literalPrefix(pattern);
+  if (!prefix)
+    return true;
+  return !prefix.includes("*") && command.trim().startsWith(prefix);
+};
+var init_heavy_rules = __esm(() => {
+  CLAUDE_MANAGED = {
+    linux: "/etc/claude-code/managed-settings.json",
+    darwin: "/Library/Application Support/ClaudeCode/managed-settings.json",
+    win32: "C:\\Program Files\\ClaudeCode\\managed-settings.json"
+  };
+  OPENCODE_NAMES = ["opencode.json", "opencode.jsonc"];
+});
+
+// packages/workit-core/src/core/heavy.ts
+import fs18 from "node:fs";
+import os7 from "node:os";
+import path23 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 path23.join(env.XDG_STATE_HOME, "workit");
+  const home = env.HOME || os7.homedir();
+  if (platform === "darwin")
+    return path23.join(home, "Library", "Application Support", "workit");
+  if (platform === "win32")
+    return path23.join(env.LOCALAPPDATA ?? path23.join(home, "AppData", "Local"), "workit");
+  return path23.join(home, ".local", "state", "workit");
+}
+function positional2(words, from, values = PM_VALUES) {
+  let index = from;
+  while (index < words.length && words[index].startsWith("-")) {
+    if (words[index] === "--")
+      return index + 1;
+    index += values.has(words[index]) ? 2 : 1;
+  }
+  return index;
+}
+function builtIn(words, depth = 0) {
+  if (depth > 6 || !words.length)
+    return null;
+  const name = baseName2(words[0]);
+  const label = () => words.slice(0, 3).join(" ");
+  const inner = (from) => builtIn(words.slice(from), depth + 1);
+  if (WORKIT.test(name))
+    return null;
+  if (INFO_FLAGS.has(words[1] ?? "") && words.length === 2)
+    return null;
+  if (words.some((word) => word === "--watch" || word.startsWith("--watch=") || word === "--watchAll"))
+    return null;
+  if (name === "npx" || name === "bunx" || name === "pnpx")
+    return inner(positional2(words, 1));
+  if (name === "corepack")
+    return inner(1);
+  if (name === "npm" || name === "pnpm" || name === "yarn" || name === "bun" || name === "deno") {
+    const at = positional2(words, 1);
+    const command = words[at];
+    if (command === undefined)
+      return name === "yarn" ? "yarn (install)" : null;
+    if (name === "deno") {
+      if (["test", "bench", "check", "compile", "lint"].includes(command))
+        return label();
+      if (command === "task" && HEAVY_SCRIPT.test(words[at + 1] ?? ""))
+        return label();
+      return null;
+    }
+    if (NPM_INSTALL.has(command) || NPM_TEST.has(command))
+      return label();
+    if (name === "bun" && command === "build")
+      return label();
+    if (EXEC.has(command))
+      return inner(positional2(words, at + 1));
+    if (name === "yarn" && command === "workspace")
+      return inner(at + 2);
+    if (name === "yarn" && command === "workspaces")
+      return words.slice(at + 1).some((word) => HEAVY_SCRIPT.test(word)) ? label() : null;
+    if (NPM_RUN.has(command)) {
+      const script = words[positional2(words, at + 1)];
+      if (script === undefined || WATCH_SCRIPT.test(script))
+        return null;
+      if (HEAVY_SCRIPT.test(script))
+        return label();
+      return name === "bun" ? inner(positional2(words, at + 1)) : null;
+    }
+    if (name === "npm")
+      return null;
+    if (WATCH_SCRIPT.test(command))
+      return null;
+    if (HEAVY_SCRIPT.test(command) && !/\.[cm]?[jt]sx?$/u.test(command))
+      return label();
+    return inner(at);
+  }
+  if (PYTHONS.test(name)) {
+    const at = words.indexOf("-m");
+    return at > 0 && words[at + 1] ? inner(at + 1) : null;
+  }
+  if (["uv", "poetry", "pdm", "pipenv", "hatch", "rye"].includes(name)) {
+    const at = positional2(words, 1);
+    const command = words[at];
+    if (command === "run")
+      return inner(positional2(words, at + 1));
+    if (command === "pip")
+      return inner(at);
+    return ["sync", "install", "build", "test", "add"].includes(command ?? "") ? label() : null;
+  }
+  if (name === "bundle") {
+    const command = words[positional2(words, 1)];
+    if (command === "exec")
+      return inner(positional2(words, 2));
+    return command === "install" || command === undefined ? label() : null;
+  }
+  if (name === "make" || name === "gmake") {
+    const targets = words.slice(1).filter((word) => !word.startsWith("-") && !word.includes("="));
+    if (targets.some((target) => WATCH_SCRIPT.test(target)))
+      return null;
+    return !targets.length || targets.some((target) => HEAVY_SCRIPT.test(target)) ? label() : null;
+  }
+  if (name === "rake") {
+    const targets = words.slice(1).filter((word) => !word.startsWith("-") && !word.includes("="));
+    return targets.some((target) => HEAVY_SCRIPT.test(target) || /^spec(?:$|:)/u.test(target)) ? label() : null;
+  }
+  if (name === "nx") {
+    const at = positional2(words, 1);
+    const command = words[at] ?? "";
+    if (["run-many", "affected"].includes(command))
+      return words.some((word) => /^(?:-t|--targets?)(?:=|$)/u.test(word)) && !words.some((word) => WATCH_SCRIPT.test(word.replace(/^--?targets?=/u, ""))) ? label() : null;
+    if (command === "run") {
+      const target = (words[at + 1] ?? "").split(":")[1] ?? "";
+      return HEAVY_SCRIPT.test(target) && !WATCH_SCRIPT.test(target) ? label() : null;
+    }
+    return HEAVY_SCRIPT.test(command) && !WATCH_SCRIPT.test(command) ? label() : null;
+  }
+  if (name === "docker" || name === "podman" || name === "nerdctl") {
+    const at = positional2(words, 1, new Set(["-H", "--host", "--context", "-c", "--config"]));
+    const command = words[at];
+    if (command === "build")
+      return label();
+    if (command === "buildx" || command === "image" || command === "builder")
+      return words[positional2(words, at + 1)] === "build" ? label() : null;
+    if (command === "compose") {
+      const at2 = positional2(words, at + 1, new Set(["-f", "--file", "-p"]));
+      const action = words[at2];
+      if (action === "build")
+        return label();
+      return action === "up" && words.slice(at2 + 1).includes("--build") ? label() : null;
+    }
+    return null;
+  }
+  const rule = TOOLS[name];
+  if (!rule)
+    return null;
+  if (words.slice(1).some((word) => WATCH_FLAG.test(word) || word === "watch" || word === "dev"))
+    return null;
+  if (rule === "any")
+    return label();
+  const command = words.slice(1).find((word) => !word.startsWith("-") && !word.startsWith("+") || rule.has(word));
+  return command !== undefined && rule.has(command) ? label() : null;
+}
+function parsePattern(pattern) {
+  const words = pattern.trim().split(/\s+/u).filter(Boolean);
+  return words.length ? words.map(globWord) : null;
+}
+function machinePatterns(env) {
+  const value = readJson(heavyCommandsFile(env));
+  return isRecord5(value) ? stringList(value.patterns) : [];
+}
+function repoPatterns(cwd) {
+  return repoHeavyCommands(gitTop(cwd) ?? path23.resolve(cwd));
+}
+function heavyLines(lines, options) {
+  const found = [];
+  let patterns = null;
+  for (const line of lines) {
+    const reason = builtIn(line);
+    if (reason) {
+      found.push({ line, source: "catalog", reason });
+      continue;
+    }
+    patterns ??= (options.patterns ?? [
+      ...machinePatterns(options.env ?? process.env).map((pattern) => ({
+        pattern,
+        from: "machine"
+      })),
+      ...repoPatterns(options.cwd).map((pattern) => ({ pattern, from: "repo" }))
+    ]).flatMap((entry) => {
+      const matchers = parsePattern(entry.pattern);
+      return matchers ? [{ ...entry, matchers }] : [];
+    });
+    const hit = patterns.find((entry) => matches(entry.matchers, line));
+    if (hit)
+      found.push({
+        line,
+        source: { pattern: hit.pattern, from: hit.from },
+        reason: `${hit.from} pattern "${hit.pattern}"`
+      });
+  }
+  return found;
+}
+function heavyPlan(command, options) {
+  const dialect = options.dialect ?? "posix";
+  if (dialect !== "posix" || !gitTop(options.cwd))
+    return { kind: "none" };
+  const lines = linesOf(command, dialect);
+  if (!lines)
+    return { kind: "none" };
+  const heavy = heavyLines(lines, options);
+  if (!heavy.length)
+    return { kind: "none" };
+  const simple = simpleCommand(command, dialect);
+  const single = simple && !WORKIT.test(baseName2(simple[0])) && heavyLines([simple], options)[0];
+  const judged = single ? [{ words: lines.flat(), text: command }] : heavy.map((match) => ({
+    words: match.line,
+    text: match.line.join(" ")
+  }));
+  if (options.rules !== null)
+    for (const { words, text } of judged) {
+      const verdict = wrapAllowed(options.rules, words, text, { bypass: options.bypass });
+      if (!verdict.ok)
+        return {
+          kind: "passthrough",
+          note: `workit: \`${command.trim()}\` is heavy but runs outside the heavy-check lease because a host permission rule names it (or \`workit\` is allowlisted); the host decides.`
+        };
+    }
+  if (single) {
+    const rewrite = leaseRewrite(command);
+    return rewrite ? { kind: "rewrite", command: rewrite, reason: single.reason } : { kind: "none" };
+  }
+  const parts = heavy.map((match) => leaseCommand(match.line));
+  return {
+    kind: "split",
+    reason: `heavy_command: \`${command.trim()}\` chains heavy work (${heavy.map((match) => match.reason).join("; ")}) with other commands, and a chain cannot run under the machine-wide heavy-check lease. Run each heavy part alone as \`workit check --heavy -- <segment>\` (here: ${parts.map((part) => `\`${part}\``).join("; ")}); run the other parts as their own commands.`,
+    unblock: parts[0] ?? null
+  };
+}
+function workitOnPath2(env = process.env) {
+  const names = process.platform === "win32" ? ["workit.exe", "workit.cmd", "workit"] : ["workit"];
+  for (const dir of (env.PATH ?? "").split(path23.delimiter))
+    for (const name of names) {
+      if (!dir)
+        continue;
+      try {
+        fs18.accessSync(path23.join(dir, name), fs18.constants.X_OK);
+        return true;
+      } catch {}
+    }
+  return false;
+}
+function leaseRewrite(command) {
+  const text = command.trim();
+  const prefix = ASSIGNMENTS.exec(text)?.[1] ?? "";
+  const rest = text.slice(prefix.length).trim();
+  if (!rest)
+    return null;
+  return `${prefix}workit check --heavy -- ${rest}`;
+}
+var HEAVY_COMMANDS_FILE = "heavy-commands.json", heavyCommandsFile = (env) => path23.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(fs18.readFileSync(file, "utf8"));
+  } catch {
+    return;
+  }
+}, isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value), stringList = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [], linesOf = (command, dialect) => {
+  try {
+    return commandLines(command, dialect);
+  } catch {
+    return null;
+  }
+}, quoteWord = (word) => /^[\w@%+=:,./-]+$/u.test(word) ? word : `'${word.replaceAll("'", `'\\''`)}'`, leaseCommand = (words) => `workit check --heavy -- ${words.map(quoteWord).join(" ")}`, ASSIGNMENTS;
+var init_heavy = __esm(() => {
+  init_raw_git();
+  init_check_config();
+  init_heavy_rules();
+  HEAVY_SCRIPT = /^(?:test|tests|t|tst|unit|integration|e2e|coverage|cov|lint|eslint|typecheck|type-check|types|tsc|check|verify|validate|build|compile|bundle|ci|sonar|cypress|playwright|jest|vitest|mocha|bench|benchmark|all)(?:$|[:_.-])/iu;
+  INFO_FLAGS = new Set(["--version", "-v", "-V", "--help", "-h", "help", "version"]);
+  WATCH_FLAG = /^(?:--watch(?:All)?(?:=.*)?|-w|--serve)$/u;
+  WATCH_SCRIPT = /(?:^|[:_.-])(?:watch|dev|serve|start|storybook)(?:$|[:_.-])/iu;
+  TOOLS = {
+    jest: "any",
+    vitest: "any",
+    mocha: "any",
+    ava: "any",
+    tap: "any",
+    karma: "any",
+    jasmine: "any",
+    nyc: "any",
+    c8: "any",
+    tsc: "any",
+    "vue-tsc": "any",
+    "svelte-check": "any",
+    eslint: "any",
+    stylelint: "any",
+    tslint: "any",
+    webpack: "any",
+    "webpack-cli": "any",
+    rollup: "any",
+    parcel: "any",
+    tsup: "any",
+    vite: sub("build", "optimize"),
+    next: sub("build", "lint"),
+    nuxt: sub("build", "generate"),
+    nuxi: sub("build", "generate"),
+    astro: sub("build", "check"),
+    ng: sub("build", "b", "test", "t", "e2e", "lint"),
+    "react-scripts": sub("build", "test"),
+    playwright: sub("test", "install"),
+    cypress: sub("run"),
+    wdio: "any",
+    testcafe: "any",
+    turbo: "any",
+    lerna: sub("run", "exec", "bootstrap"),
+    "sonar-scanner": "any",
+    sonarless: sub("scan"),
+    "sonarless-mcp": sub("scan"),
+    go: sub("test", "build", "vet", "install", "generate"),
+    "golangci-lint": sub("run"),
+    gotestsum: "any",
+    staticcheck: "any",
+    cargo: sub("build", "b", "test", "t", "check", "c", "clippy", "bench", "nextest", "doc", "install", "tarpaulin", "llvm-cov"),
+    mvn: "any",
+    mvnw: "any",
+    gradle: "any",
+    gradlew: "any",
+    ant: "any",
+    sbt: "any",
+    bazel: sub("build", "test", "run", "coverage"),
+    bazelisk: sub("build", "test", "run", "coverage"),
+    buck2: sub("build", "test", "run"),
+    dotnet: sub("build", "test", "publish", "restore", "pack", "msbuild"),
+    msbuild: "any",
+    pytest: "any",
+    "py.test": "any",
+    tox: "any",
+    nox: "any",
+    mypy: "any",
+    pyright: "any",
+    pylint: "any",
+    coverage: sub("run"),
+    maturin: sub("build", "develop"),
+    pip: sub("install", "wheel"),
+    pip3: sub("install", "wheel"),
+    rspec: "any",
+    rails: sub("test", "assets:precompile"),
+    phpunit: "any",
+    pest: "any",
+    phpstan: "any",
+    psalm: "any",
+    composer: sub("install", "update", "require", "test"),
+    mix: sub("test", "compile", "deps.get", "dialyzer", "credo"),
+    swift: sub("build", "test"),
+    xcodebuild: "any",
+    flutter: sub("build", "test"),
+    dart: sub("test", "compile"),
+    pod: sub("install"),
+    cmake: sub("--build"),
+    ninja: "any",
+    meson: sub("compile", "test"),
+    ctest: "any",
+    scons: "any",
+    "docker-compose": sub("build"),
+    buildah: sub("bud", "build"),
+    earthly: "any"
+  };
+  PM_VALUES = new Set([
+    "--prefix",
+    "-w",
+    "--workspace",
+    "-C",
+    "--dir",
+    "--filter",
+    "-F",
+    "--cwd",
+    "-p",
+    "--package",
+    "--cache",
+    "--registry"
+  ]);
+  WORKIT = /^(?:workit|@brainervirus\/workit-cli(?:@.*)?)$/u;
+  PYTHONS = /^(?:python[\d.]*|py)$/u;
+  NPM_INSTALL = new Set([
+    "ci",
+    "clean-install",
+    "cit",
+    "install-test",
+    "it",
+    "install",
+    "i",
+    "in",
+    "add",
+    "rebuild",
+    "update",
+    "up"
+  ]);
+  NPM_RUN = new Set(["run", "run-script", "rum", "urn"]);
+  NPM_TEST = new Set(["test", "t", "tst"]);
+  EXEC = new Set(["exec", "x", "dlx"]);
+  ASSIGNMENTS = /^\s*((?:[A-Za-z_]\w*=(?:'[^']*'|"(?:[^"\\]|\\.)*"|[^\s'"])*\s+)*)/u;
+});
+
+// packages/workit-core/src/core/heavy-words.ts
+import fs19 from "node:fs";
+import os8 from "node:os";
+import path24 from "node:path";
+function maybeHeavy(command, cwd, env = process.env) {
+  try {
+    const words = wordsOf(command);
+    if (words.some((word) => HEAVY_WORDS.has(word) || /^python[\d.]*$/u.test(word)))
+      return true;
+    const extra = patternWords(cwd, env);
+    return extra === null || words.some((word) => extra.has(word));
+  } catch {
+    return true;
+  }
+}
+var HEAVY_WORDS, wordsOf = (command) => command.split(/[\s;&|()<>`'"]+/u).map((word) => (word.split(/[\\/]/u).at(-1) ?? "").toLowerCase().replace(/\.(?:exe|cmd|bat)$/u, "")).filter(Boolean), stateDir2 = (env) => {
+  if (env.WORKFLOW_TOOLKIT_STATE)
+    return env.WORKFLOW_TOOLKIT_STATE;
+  if (env.XDG_STATE_HOME)
+    return path24.join(env.XDG_STATE_HOME, "workit");
+  const home = env.HOME || os8.homedir();
+  if (process.platform === "darwin")
+    return path24.join(home, "Library", "Application Support", "workit");
+  if (process.platform === "win32")
+    return path24.join(env.LOCALAPPDATA ?? path24.join(home, "AppData", "Local"), "workit");
+  return path24.join(home, ".local", "state", "workit");
+}, readJson2 = (file) => {
+  try {
+    return JSON.parse(fs19.readFileSync(file, "utf8"));
+  } catch {
+    return;
+  }
+}, patternWords = (cwd, env) => {
+  const patterns = [];
+  const machine = readJson2(path24.join(stateDir2(env), "heavy-commands.json"));
+  if (Array.isArray(machine?.patterns))
+    patterns.push(...machine.patterns);
+  for (let dir = path24.resolve(cwd);; dir = path24.dirname(dir)) {
+    if (fs19.existsSync(path24.join(dir, ".git"))) {
+      patterns.push(...repoHeavyCommands(dir));
+      break;
+    }
+    if (path24.dirname(dir) === dir)
+      break;
+  }
+  const words = new Set;
+  for (const pattern of patterns) {
+    if (typeof pattern !== "string")
+      continue;
+    const first = wordsOf(pattern)[0];
+    if (!first || first.includes("*"))
+      return null;
+    words.add(first);
+  }
+  return words;
+};
+var init_heavy_words = __esm(() => {
+  init_check_config();
+  HEAVY_WORDS = new Set(("npm npx pnpm pnpx yarn bun bunx deno corepack make gmake docker podman nerdctl " + "python python3 py uv poetry pdm pipenv hatch rye bundle rake nx " + "jest vitest mocha ava tap karma jasmine nyc c8 tsc vue-tsc svelte-check eslint stylelint " + "tslint webpack webpack-cli rollup parcel tsup vite next nuxt nuxi astro ng react-scripts " + "playwright cypress wdio testcafe turbo lerna sonar-scanner sonarless sonarless-mcp go " + "golangci-lint gotestsum staticcheck cargo mvn mvnw gradle gradlew ant sbt bazel bazelisk " + "buck2 dotnet msbuild pytest py.test tox nox mypy pyright pylint coverage maturin pip pip3 " + "rspec rails phpunit pest phpstan psalm composer mix swift xcodebuild flutter dart pod cmake " + "ninja meson ctest scons docker-compose buildah earthly").split(" "));
+});
+
+// packages/workit-core/src/hooks/heavy-gate.ts
+function heavyGate(cwd, command, options) {
+  const env = options.env ?? process.env;
+  try {
+    if (env.WORKIT_HEAVY_GATE === "0" || !maybeHeavy(command, cwd, env) || !workitOnPath2(env))
+      return { kind: "none" };
+    return heavyPlan(command, {
+      cwd,
+      env,
+      dialect: options.dialect ?? "posix",
+      rules: rulesFor(options.host, cwd, env),
+      bypass: options.permissionMode === "bypassPermissions"
+    });
+  } catch {
+    return { kind: "none" };
+  }
+}
+var rulesFor = (host, cwd, env) => {
+  switch (host) {
+    case "claude_code":
+      return claudeRules(cwd, env);
+    case "opencode":
+      return opencodeRules(cwd, env);
+    case "codex_cli":
+    case "codex_desktop":
+      return codexRules(cwd, env);
+    case "cursor":
+      return cursorRules(cwd, env);
+    case "pi":
+      return null;
+  }
+}, rewriteNote = (plan) => `workit: this heavy command (${plan.reason}) runs under the machine-wide heavy-check lease as \`${plan.command}\`: it waits while another heavy check holds the lease (\`workit lock status\` shows who). Run heavy commands that way yourself; \`workit help lock\` explains the lease.`, heavyDenial = (original, plan) => ({
+  kind: "deny",
+  reason: `heavy_command: \`${original.trim()}\` is heavy (${plan.reason}) and must run under the machine-wide heavy-check lease, so parallel agents cannot exhaust this machine's memory and CPU. Run exactly: ${plan.command}`,
+  unblock: plan.command
+}), splitDenial = (plan) => ({
+  kind: "deny",
+  reason: plan.reason,
+  unblock: plan.unblock
+});
+var init_heavy_gate = __esm(() => {
+  init_heavy_rules();
+  init_heavy();
+  init_heavy_words();
+});
+
+// packages/workit-core/src/core/live-session.ts
+import { spawnSync as spawnSync13 } from "node:child_process";
+import { createHash as createHash15 } from "node:crypto";
+import fs20 from "node:fs";
+import os9 from "node:os";
+import path25 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);
@@ -20163,9 +21084,9 @@ var LIVE_SESSION_TTL_MS, HEARTBEAT_EVERY_MS = 30000, liveProbe, leadOf = (sessio
 }, processInfo = (pid) => {
   try {
     if (liveProbe.platform === "linux") {
-      const stat = fs17.readFileSync(`/proc/${pid}/stat`, "utf8");
+      const stat = fs20.readFileSync(`/proc/${pid}/stat`, "utf8");
       const ppid = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1]);
-      const command = fs17.readFileSync(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ");
+      const command = fs20.readFileSync(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ");
       return Number.isInteger(ppid) ? { ppid, command: command.trim() } : null;
     }
     if (liveProbe.platform === "win32")
@@ -20210,32 +21131,32 @@ var LIVE_SESSION_TTL_MS, HEARTBEAT_EVERY_MS = 30000, liveProbe, leadOf = (sessio
     pid: () => hostPid(transport)
   };
 }, checkoutOf = (target) => {
-  let dir = path22.resolve(target);
-  while (!fs17.existsSync(dir) && path22.dirname(dir) !== dir)
-    dir = path22.dirname(dir);
-  if (fs17.existsSync(dir) && !fs17.statSync(dir).isDirectory())
-    dir = path22.dirname(dir);
-  const parts = dir.split(path22.sep);
+  let dir = path25.resolve(target);
+  while (!fs20.existsSync(dir) && path25.dirname(dir) !== dir)
+    dir = path25.dirname(dir);
+  if (fs20.existsSync(dir) && !fs20.statSync(dir).isDirectory())
+    dir = path25.dirname(dir);
+  const parts = dir.split(path25.sep);
   const dotGit = parts.lastIndexOf(".git");
   if (dotGit > 0)
-    dir = parts.slice(0, dotGit).join(path22.sep) || path22.sep;
+    dir = parts.slice(0, dotGit).join(path25.sep) || path25.sep;
   const location = resolveStore(dir);
   if (location instanceof Error || !location.shared || !location.top)
     return null;
   let top = location.top;
   try {
-    top = fs17.realpathSync.native(top);
+    top = fs20.realpathSync.native(top);
   } catch {}
   return top;
-}, markerFile2 = (top) => path22.join(resolveStateDir(), "live-sessions", `${createHash15("sha256").update(checkoutKey(top)).digest("hex").slice(0, 32)}.json`), checkoutKey = (top, platform = process.platform) => {
-  let key = path22.resolve(top);
+}, markerFile2 = (top) => path25.join(resolveStateDir(), "live-sessions", `${createHash15("sha256").update(checkoutKey(top)).digest("hex").slice(0, 32)}.json`), checkoutKey = (top, platform = process.platform) => {
+  let key = path25.resolve(top);
   try {
-    key = fs17.realpathSync.native(key);
+    key = fs20.realpathSync.native(key);
   } catch {}
   return platform === "win32" ? key.replaceAll("/", "\\").toLowerCase() : key;
 }, readMarker = (file) => {
   try {
-    const value = JSON.parse(fs17.readFileSync(file, "utf8"));
+    const value = JSON.parse(fs20.readFileSync(file, "utf8"));
     if (value?.version !== 1 || typeof value.session !== "string" || typeof value.host !== "string" || typeof value.heartbeatAt !== "string" || Number.isNaN(Date.parse(value.heartbeatAt)))
       return null;
     return {
@@ -20256,7 +21177,7 @@ var LIVE_SESSION_TTL_MS, HEARTBEAT_EVERY_MS = 30000, liveProbe, leadOf = (sessio
   const age = ageOf2(marker, deps.now ?? new Date);
   if (age > (deps.ttlMs ?? LIVE_SESSION_TTL_MS))
     return false;
-  if (marker.machine !== (deps.machine ?? os6.hostname()) || marker.pid === null)
+  if (marker.machine !== (deps.machine ?? os9.hostname()) || marker.pid === null)
     return true;
   if (!(deps.alive ?? processAlive)(marker.pid))
     return false;
@@ -20282,7 +21203,7 @@ var LIVE_SESSION_TTL_MS, HEARTBEAT_EVERY_MS = 30000, liveProbe, leadOf = (sessio
     const marker = readMarker(file);
     if (!marker || sameLead(marker, owner) || !isLive(marker, deps))
       return null;
-    if (sameOwner(marker, owner, deps.machine ?? os6.hostname()))
+    if (sameOwner(marker, owner, deps.machine ?? os9.hostname()))
       return null;
     return { marker, file, ageMs: ageOf2(marker, deps.now ?? new Date), checkout };
   } catch {
@@ -20295,7 +21216,7 @@ var LIVE_SESSION_TTL_MS, HEARTBEAT_EVERY_MS = 30000, liveProbe, leadOf = (sessio
       return;
     const file = markerFile2(checkout);
     const now = deps.now ?? new Date;
-    const machine = deps.machine ?? os6.hostname();
+    const machine = deps.machine ?? os9.hostname();
     const current = readMarker(file);
     if (current) {
       const age = ageOf2(current, now);
@@ -20316,10 +21237,10 @@ var LIVE_SESSION_TTL_MS, HEARTBEAT_EVERY_MS = 30000, liveProbe, leadOf = (sessio
       checkout,
       heartbeatAt: now.toISOString()
     };
-    fs17.mkdirSync(path22.dirname(file), { recursive: true });
+    fs20.mkdirSync(path25.dirname(file), { recursive: true });
     const temp = `${file}.${process.pid}.tmp`;
-    fs17.writeFileSync(temp, JSON.stringify(marker));
-    fs17.renameSync(temp, file);
+    fs20.writeFileSync(temp, JSON.stringify(marker));
+    fs20.renameSync(temp, file);
   } catch {}
 };
 var init_live_session = __esm(() => {
@@ -20338,8 +21259,8 @@ var init_live_session = __esm(() => {
 
 // packages/workit-core/src/hooks/write-gate.ts
 import { realpathSync as realpathSync5 } from "node:fs";
-import os7 from "node:os";
-import path23 from "node:path";
+import os10 from "node:os";
+import path26 from "node:path";
 function writeGate(cwd, paths, owner, deps) {
   if (!owner)
     return beforeWriteGate(cwd, paths);
@@ -20359,7 +21280,7 @@ function shellGate(cwd, command, owner, dialect = "posix", deps) {
     try {
       targets = [
         ...segmentTargets(cwd, command, dialect),
-        ...gitMutationDirs(cwd, command, dialect).map((dir) => path23.join(dir, DIR_TARGET))
+        ...gitMutationDirs(cwd, command, dialect).map((dir) => path26.join(dir, DIR_TARGET))
       ];
     } catch {
       targets = [];
@@ -20397,24 +21318,37 @@ function beforeWriteGate(cwd, paths) {
 }
 var NONE3, CASE_INSENSITIVE, canonical2 = (file) => {
   let rest = "";
-  for (let dir = path23.resolve(file);; dir = path23.dirname(dir)) {
+  for (let dir = path26.resolve(file);; dir = path26.dirname(dir)) {
     try {
-      return path23.join(realpathSync5(dir), rest);
+      return path26.join(realpathSync5(dir), rest);
     } catch {
-      if (path23.dirname(dir) === dir)
-        return path23.resolve(file);
-      rest = rest ? path23.join(path23.basename(dir), rest) : path23.basename(dir);
+      if (path26.dirname(dir) === dir)
+        return path26.resolve(file);
+      rest = rest ? path26.join(path26.basename(dir), rest) : path26.basename(dir);
     }
   }
 }, exempt = (cwd, root, file, plans) => {
   const fold = (value) => CASE_INSENSITIVE ? value.toLowerCase() : value;
-  const relative = path23.relative(fold(canonical2(root)), fold(canonical2(path23.resolve(cwd, file))));
-  if (relative.startsWith("..") || path23.isAbsolute(relative))
+  const relative = path26.relative(fold(canonical2(root)), fold(canonical2(path26.resolve(cwd, file))));
+  if (relative.startsWith("..") || path26.isAbsolute(relative))
     return true;
-  const posix = relative.split(path23.sep).join("/");
+  const posix = relative.split(path26.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("-")), editsOf = (input) => {
+}, PREFIXES2, operands = (words) => words.filter((item) => !item.startsWith("-")), SCRIPT_SHELLS, wrappedScript = (input) => {
+  let words = input;
+  while (words.length && (PREFIXES2.has(words[0]) || /^\w+=/.test(words[0])))
+    words = words.slice(1);
+  const tail = workitCheckTail(words);
+  if (!tail)
+    return null;
+  if ("script" in tail)
+    return tail.script;
+  const [shell, flag, script] = tail.argv;
+  if (SCRIPT_SHELLS.has((shell.split(/[\\/]/).at(-1) ?? "").toLowerCase()) && /^-[a-z]*c$/.test(flag ?? ""))
+    return script ?? null;
+  return tail.argv.map(quoteWord2).join(" ");
+}, editsOf = (input) => {
   let words = input;
   while (words.length && (PREFIXES2.has(words[0]) || /^\w+=/.test(words[0])))
     words = words.slice(1);
@@ -20489,10 +21423,18 @@ var NONE3, CASE_INSENSITIVE, canonical2 = (file) => {
     default:
       return [];
   }
-}, shellWrites = (command) => {
+}, shellWrites = (command, depth = 0) => {
   const targets = [];
   let unknown = false;
   for (const segment of segmentsOf(command)) {
+    const inner = depth < 4 ? wrappedScript(segment.words) : null;
+    if (inner !== null) {
+      const nested = shellWrites(inner, depth + 1);
+      if (nested.writes && nested.targets === null)
+        unknown = true;
+      else if (nested.targets)
+        targets.push(...nested.targets);
+    }
     targets.push(...segment.redirects.filter((item) => !/^\/dev\/(?:null|stdout|stderr|tty)$/.test(item)));
     const edits = editsOf(segment.words);
     if (edits === null)
@@ -20503,7 +21445,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(path23.resolve(root, file)) ?? "-").join("\x00"), gateFor = (cwd) => {
+}, cache2, planKeyOf = (root, plans) => [...plans].map((file) => fileSignature(path26.resolve(root, file)) ?? "-").join("\x00"), gateFor = (cwd) => {
   const store = new TaskStore(cwd);
   const listed = store.listTaskIndex();
   if (!listed.ok)
@@ -20556,19 +21498,19 @@ var NONE3, CASE_INSENSITIVE, canonical2 = (file) => {
       return [];
     if (sub === "stash" && ["list", "show"].includes(rest[0] ?? ""))
       return [];
-    return [path23.resolve(cwd, invocation.dir ?? ".")];
+    return [path26.resolve(cwd, invocation.dir ?? ".")];
   });
 }, CD2, PUSHD2, POPD2, cdInto = (dir, words) => {
   const target = words.slice(1).find((word) => !word.startsWith("-") || word === "-");
   if (dir === undefined || target === "-" || target && /^~|[$`*?]/.test(target))
     return;
-  return target === undefined ? os7.homedir() : path23.resolve(dir, target);
-}, quoteWord = (word) => /^[\w@%+=:,./-]+$/.test(word) ? word : `'${word.replaceAll("'", "'\\''")}'`, segmentTargets = (cwd, command, dialect) => {
+  return target === undefined ? os10.homedir() : path26.resolve(dir, target);
+}, quoteWord2 = (word) => /^[\w@%+=:,./-]+$/.test(word) ? word : `'${word.replaceAll("'", "'\\''")}'`, segmentTargets = (cwd, command, dialect, depth = 0) => {
   const targets = [];
   let dir = cwd;
   let stack = [];
   const groups = [];
-  const at = (file) => path23.isAbsolute(file) ? file : dir === undefined ? null : path23.resolve(dir, file);
+  const at = (file) => path26.isAbsolute(file) ? file : dir === undefined ? null : path26.resolve(dir, file);
   for (const segment of segmentsOf(command, dialect)) {
     if (segment.group === "open") {
       groups.push({ dir, stack: [...stack] });
@@ -20596,6 +21538,9 @@ var NONE3, CASE_INSENSITIVE, canonical2 = (file) => {
       dir = stack.length ? stack.pop() : undefined;
       continue;
     }
+    const inner = depth < 4 ? wrappedScript(words) : null;
+    if (inner !== null && dir !== undefined)
+      targets.push(...segmentTargets(dir, inner, "posix", depth + 1));
     for (const file of segment.redirects)
       if (!/^\/dev\/(?:null|stdout|stderr|tty)$/.test(file)) {
         const resolved = at(file);
@@ -20605,15 +21550,15 @@ var NONE3, CASE_INSENSITIVE, canonical2 = (file) => {
     const edits = editsOf(segment.words);
     if (edits === null) {
       if (dir !== undefined)
-        targets.push(path23.join(dir, DIR_TARGET));
+        targets.push(path26.join(dir, DIR_TARGET));
     } else
       for (const file of edits) {
         const resolved = at(file);
         if (resolved)
           targets.push(resolved);
       }
-    if (dir !== undefined && workitInvocations(segment.words.map(quoteWord).join(" "), "posix").some((args) => args[0] === "git" && MUTATING_WORKIT_GIT.has(args[1] ?? "") && !inert(args.slice(2), "")))
-      targets.push(path23.join(dir, DIR_TARGET));
+    if (dir !== undefined && workitInvocations(segment.words.map(quoteWord2).join(" "), "posix").some((args) => args[0] === "git" && MUTATING_WORKIT_GIT.has(args[1] ?? "") && !inert(args.slice(2), "")))
+      targets.push(path26.join(dir, DIR_TARGET));
   }
   return targets;
 }, overridden = (command, dialect) => {
@@ -20636,7 +21581,7 @@ var NONE3, CASE_INSENSITIVE, canonical2 = (file) => {
 }, guarded = (targets) => {
   const seen = new Set;
   return targets.filter((target) => {
-    const dir = path23.dirname(target);
+    const dir = path26.dirname(target);
     if (seen.has(dir))
       return false;
     seen.add(dir);
@@ -20654,7 +21599,7 @@ 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) => path23.resolve(cwd, file)) : [path23.join(cwd, DIR_TARGET)], noteOverride = (cwd, owner, command) => {
+}, liveTargets = (cwd, paths) => paths?.length ? paths.map((file) => path26.resolve(cwd, file)) : [path26.join(cwd, DIR_TARGET)], noteOverride = (cwd, owner, command) => {
   try {
     if (!inWorkitWorkspace(cwd))
       return;
@@ -20678,6 +21623,7 @@ var init_write_gate = __esm(() => {
   NONE3 = { kind: "none" };
   CASE_INSENSITIVE = process.platform === "darwin" || process.platform === "win32";
   PREFIXES2 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "xargs"]);
+  SCRIPT_SHELLS = new Set(["sh", "bash", "zsh", "dash", "ksh"]);
   cache2 = new Map;
   MUTATING_GIT = new Set([
     "add",
@@ -21090,9 +22036,9 @@ 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 path24 from "node:path";
-var isRecord4 = (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) || !path24.isAbsolute(value) || !existsSync7(value))
+import path27 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) || !path27.isAbsolute(value) || !existsSync7(value))
     return null;
   try {
     return statSync2(value).isDirectory() ? realpathSync6(value) : null;
@@ -21118,7 +22064,7 @@ var isRecord4 = (value) => value !== null && typeof value === "object" && !Array
   const joined = argv.map(quoteArg).join(" ");
   return nonEmpty2(joined) ? joined : null;
 }, WRITE_TOOLS, isWriteTool = (name) => typeof name === "string" && WRITE_TOOLS.has(name.toLowerCase().replace(/[_-]/g, "")), PATH_KEYS, PATCH_HEADER, writePaths = (input) => {
-  if (!isRecord4(input))
+  if (!isRecord6(input))
     return [];
   const paths = PATH_KEYS.map((key) => input[key]).filter(nonEmpty2);
   for (const value of Object.values(input))
@@ -21200,10 +22146,32 @@ function handleHook(input, deps) {
       const gate = usable2(descriptor.events["write.pre"].support) ? shellGate(input.cwd, event.command, liveOwner(input, descriptor.transport), event.dialect) : NONE5;
       if (gate.kind === "deny")
         return gate;
+      const plan = heavyGate(input.cwd, event.command, {
+        host: input.host,
+        dialect: event.dialect,
+        permissionMode: input.permissionMode
+      });
+      if (plan.kind === "split" && canDeny)
+        return splitDenial(plan);
+      const rewrites = usable2(descriptor.shellPolicy.rewrite);
+      if (plan.kind === "rewrite" && !rewrites && canDeny)
+        return heavyDenial(event.command, plan);
+      const lease = plan.kind === "rewrite" && rewrites ? plan : null;
+      const aside = plan.kind === "passthrough" ? plan.note : null;
       noteRawCommit(input, event.command, postTool ? callKey(event.toolUseId, event.command) : NEXT_COMMAND);
+      const rewritten = (text) => lease ? {
+        kind: "rewrite",
+        command: lease.command,
+        input: event.toolInput ? { ...event.toolInput, command: lease.command } : null,
+        text
+      } : NONE5;
       if (descriptor.transport !== "hook-process")
-        return NONE5;
-      return withContextLine(canDeny ? rawGitPre(input, event.command) : NONE5, shipNudge(input, event.command));
+        return rewritten(null);
+      const nudged = withContextLine(withContextLine(canDeny ? rawGitPre(input, event.command) : NONE5, aside), shipNudge(input, event.command));
+      if (!lease)
+        return nudged;
+      return rewritten([rewriteNote(lease), nudged.kind === "context" ? nudged.text : null].filter(Boolean).join(`
+`));
     }
     case "shell.post":
       if (usable2(descriptor.events["shell.post"].support))
@@ -21289,6 +22257,7 @@ var init_handle = __esm(() => {
   init_branch();
   init_workspaces();
   init_host_session();
+  init_heavy_gate();
   init_policy();
   init_raw_git();
   init_skill_nudge();
@@ -21306,7 +22275,7 @@ var init_handle = __esm(() => {
 });
 
 // packages/workit-core/src/hooks/hosts/claude-code.ts
-var CLAUDE_CODE_DESCRIPTOR, EVENTS, SOURCES, SHELL_TOOLS, dialectOf2 = (value) => value.tool_name === "PowerShell" ? "powershell" : "posix", toolCommand = (value) => isRecord4(value.tool_input) ? commandText(value.tool_input.command) : null, eventOf = (name, value) => {
+var CLAUDE_CODE_DESCRIPTOR, EVENTS, SOURCES, SHELL_TOOLS, dialectOf2 = (value) => value.tool_name === "PowerShell" ? "powershell" : "posix", toolCommand = (value) => isRecord6(value.tool_input) ? commandText(value.tool_input.command) : null, eventOf = (name, value) => {
   const toolUseId = optionalText(value.tool_use_id);
   switch (name) {
     case "SessionStart":
@@ -21333,19 +22302,28 @@ var CLAUDE_CODE_DESCRIPTOR, EVENTS, SOURCES, SHELL_TOOLS, dialectOf2 = (value) =
             kind: "tool.pre",
             tool: value.tool_name,
             toolUseId,
-            skill: isRecord4(value.tool_input) ? optionalText(value.tool_input.skill) : null
+            skill: isRecord6(value.tool_input) ? optionalText(value.tool_input.skill) : null
           }
         };
       if (!SHELL_TOOLS.has(value.tool_name))
         return { ok: true, event: { kind: "tool.pre", tool: value.tool_name, toolUseId } };
       const command = toolCommand(value);
-      return command ? { ok: true, event: { kind: "shell.pre", command, toolUseId, dialect: dialectOf2(value) } } : { ok: false, error: `tool_input.command is required for ${value.tool_name}` };
+      return command ? {
+        ok: true,
+        event: {
+          kind: "shell.pre",
+          command,
+          toolUseId,
+          dialect: dialectOf2(value),
+          toolInput: value.tool_input
+        }
+      } : { ok: false, error: `tool_input.command is required for ${value.tool_name}` };
     }
     case "PostToolUse": {
       const command = toolCommand(value);
       if (!SHELL_TOOLS.has(String(value.tool_name)) || !command)
         return { ok: false, error: "only shell PostToolUse is mapped" };
-      const response = isRecord4(value.tool_response) ? value.tool_response : {};
+      const response = isRecord6(value.tool_response) ? value.tool_response : {};
       return {
         ok: true,
         event: {
@@ -21395,6 +22373,17 @@ var CLAUDE_CODE_DESCRIPTOR, EVENTS, SOURCES, SHELL_TOOLS, dialectOf2 = (value) =
       };
   }
 }, CONTEXT_EVENTS, render = (decision, native) => {
+  if (decision.kind === "rewrite" && native === "PreToolUse" && decision.input)
+    return {
+      json: {
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          updatedInput: decision.input,
+          ...decision.text ? { additionalContext: decision.text } : {}
+        }
+      },
+      exitCode: 0
+    };
   if (decision.kind === "deny" && native === "PreToolUse")
     return {
       json: {
@@ -21438,7 +22427,12 @@ var init_claude_code = __esm(() => {
       "compact.pre": { support: "none", native: null },
       stop: { support: "native", native: "Stop" }
     },
-    shellPolicy: { deny: "native", channel: "permissionDecision", failClosed: false },
+    shellPolicy: {
+      deny: "native",
+      channel: "permissionDecision",
+      failClosed: false,
+      rewrite: "native"
+    },
     context: {
       sessionStart: "native",
       perTurn: "native",
@@ -21529,14 +22523,14 @@ var init_claude_code = __esm(() => {
   claudeCodeAdapter = {
     descriptor: CLAUDE_CODE_DESCRIPTOR,
     parse(raw) {
-      const native = isRecord4(raw) && Object.hasOwn(EVENTS, String(raw.hook_event_name)) ? raw.hook_event_name : null;
+      const native = isRecord6(raw) && Object.hasOwn(EVENTS, String(raw.hook_event_name)) ? raw.hook_event_name : null;
       const fail = (error) => ({
         ok: false,
         error,
         native,
         event: native ? EVENTS[native] : null
       });
-      if (!isRecord4(raw) || !native)
+      if (!isRecord6(raw) || !native)
         return fail("hook_event_name is required");
       if (!nonEmpty2(raw.session_id))
         return fail("session_id is required");
@@ -21573,7 +22567,7 @@ function detectCodexSurface(env) {
   return env.CODEX_INTERNAL_ORIGINATOR_OVERRIDE === "Codex Desktop" || Boolean(env.CODEX_ELECTRON_RESOURCES_PATH) ? "codex_desktop" : "codex_cli";
 }
 var CODEX_DESCRIPTOR, EVENTS2, SHELL_TOOLS2, isShellTool = (name) => SHELL_TOOLS2.has(String(name).toLowerCase()), SOURCES2, parseCodexHookInput = (value) => {
-  if (!isRecord4(value) || !Object.hasOwn(EVENTS2, String(value.hook_event_name)))
+  if (!isRecord6(value) || !Object.hasOwn(EVENTS2, String(value.hook_event_name)))
     return { ok: false, error: "hook_event_name is required" };
   const event = value.hook_event_name;
   const cwd = existingDirectory(value.cwd);
@@ -21582,7 +22576,7 @@ var CODEX_DESCRIPTOR, EVENTS2, SHELL_TOOLS2, isShellTool = (name) => SHELL_TOOLS
   const toolEvent = event === "PreToolUse" || event === "PostToolUse";
   if (toolEvent && !nonEmpty2(value.tool_name))
     return { ok: false, error: "tool_name is required" };
-  const command = isRecord4(value.tool_input) ? commandText(value.tool_input.command) : null;
+  const command = isRecord6(value.tool_input) ? commandText(value.tool_input.command) : null;
   if (toolEvent && isShellTool(value.tool_name) && !command)
     return { ok: false, error: "tool_input.command is required for shell tools" };
   if (event === "SubagentStart" && !nonEmpty2(value.agent_id))
@@ -21708,7 +22702,12 @@ var init_codex = __esm(() => {
       "compact.pre": { support: "none", native: null },
       stop: { support: "native", native: "Stop" }
     },
-    shellPolicy: { deny: "native", channel: "permissionDecision", failClosed: false },
+    shellPolicy: {
+      deny: "native",
+      channel: "permissionDecision",
+      failClosed: false,
+      rewrite: "none"
+    },
     context: {
       sessionStart: "native",
       perTurn: "native",
@@ -21804,7 +22803,7 @@ var init_codex = __esm(() => {
       const host = detectCodexSurface(env);
       const parsed = parseCodexHookInput(raw);
       if (!parsed.ok) {
-        const native = isRecord4(raw) && Object.hasOwn(EVENTS2, String(raw.hook_event_name)) ? raw.hook_event_name : null;
+        const native = isRecord6(raw) && Object.hasOwn(EVENTS2, String(raw.hook_event_name)) ? raw.hook_event_name : null;
         return { ok: false, error: parsed.error, native, event: native ? EVENTS2[native] : null };
       }
       const input = parsed.data;
@@ -21832,10 +22831,10 @@ var init_codex = __esm(() => {
 });
 
 // packages/workit-core/src/hooks/hosts/cursor.ts
-import fs18 from "node:fs";
-import path25 from "node:path";
+import fs21 from "node:fs";
+import path28 from "node:path";
 var undocumented, none, CURSOR_DESCRIPTOR, EVENTS3, parseCursorHookInput = (value) => {
-  if (!isRecord4(value) || !Object.hasOwn(EVENTS3, String(value.hook_event_name)))
+  if (!isRecord6(value) || !Object.hasOwn(EVENTS3, String(value.hook_event_name)))
     return { ok: false, error: "hook_event_name is required" };
   const roots = value.workspace_roots;
   if (!Array.isArray(roots) || roots.length === 0 || !roots.every(nonEmpty2))
@@ -21914,17 +22913,17 @@ var undocumented, none, CURSOR_DESCRIPTOR, EVENTS3, parseCursorHookInput = (valu
       };
   }
 }, TRANSCRIPT_TAIL_BYTES, lastAssistantText = (file) => {
-  if (!file || !path25.isAbsolute(file))
+  if (!file || !path28.isAbsolute(file))
     return null;
   try {
-    const size = fs18.statSync(file).size;
+    const size = fs21.statSync(file).size;
     const start = Math.max(0, size - TRANSCRIPT_TAIL_BYTES);
     const buffer = Buffer.alloc(size - start);
-    const fd = fs18.openSync(file, "r");
+    const fd = fs21.openSync(file, "r");
     try {
-      fs18.readSync(fd, buffer, 0, buffer.length, start);
+      fs21.readSync(fd, buffer, 0, buffer.length, start);
     } finally {
-      fs18.closeSync(fd);
+      fs21.closeSync(fd);
     }
     const lines = buffer.toString("utf8").split(`
 `);
@@ -21935,14 +22934,14 @@ var undocumented, none, CURSOR_DESCRIPTOR, EVENTS3, parseCursorHookInput = (valu
       } catch {
         continue;
       }
-      if (!isRecord4(entry) || entry.role !== "assistant")
+      if (!isRecord6(entry) || entry.role !== "assistant")
         continue;
-      const content = isRecord4(entry.message) ? entry.message.content : entry.content;
+      const content = isRecord6(entry.message) ? entry.message.content : entry.content;
       if (typeof content === "string")
         return content;
       if (!Array.isArray(content))
         return null;
-      const text = content.filter((part) => isRecord4(part) && part.type === "text" && typeof part.text === "string").map((part) => part.text).join(`
+      const text = content.filter((part) => isRecord6(part) && part.type === "text" && typeof part.text === "string").map((part) => part.text).join(`
 `);
       return text || null;
     }
@@ -21950,7 +22949,7 @@ var undocumented, none, CURSOR_DESCRIPTOR, EVENTS3, parseCursorHookInput = (valu
   } catch {
     return null;
   }
-}, within = (root, dir) => dir === root || dir.startsWith(root.endsWith(path25.sep) ? root : `${root}${path25.sep}`), hookCwd = (input) => {
+}, within = (root, dir) => dir === root || dir.startsWith(root.endsWith(path28.sep) ? root : `${root}${path28.sep}`), hookCwd = (input) => {
   const cwd = existingDirectory(input.cwd);
   if (cwd && input.hook_event_name === "beforeShellExecution")
     return cwd;
@@ -22004,7 +23003,7 @@ var init_cursor = __esm(() => {
       "compact.pre": { support: "partial", native: "preCompact" },
       stop: { support: "native", native: "stop" }
     },
-    shellPolicy: { deny: "native", channel: "exit2+json", failClosed: false },
+    shellPolicy: { deny: "native", channel: "exit2+json", failClosed: false, rewrite: "none" },
     context: {
       sessionStart: "native",
       perTurn: "none",
@@ -22103,7 +23102,7 @@ var init_cursor = __esm(() => {
     parse(raw) {
       const parsed = parseCursorHookInput(raw);
       if (!parsed.ok) {
-        const native = isRecord4(raw) && Object.hasOwn(EVENTS3, String(raw.hook_event_name)) ? raw.hook_event_name : null;
+        const native = isRecord6(raw) && Object.hasOwn(EVENTS3, String(raw.hook_event_name)) ? raw.hook_event_name : null;
         return { ok: false, error: parsed.error, native, event: native ? EVENTS3[native] : null };
       }
       const input = parsed.data;
@@ -22175,6 +23174,7 @@ var init_pi = () => {};
 var init_hooks = __esm(async () => {
   init_context();
   init_policy();
+  init_heavy_gate();
   init_write_gate();
   init_live_session();
   init_stop();