@brainervirus/workit-opencode 8.16.0 → 8.17.0

package/dist/plugin.js

@@ -12398,6 +12398,17 @@ import fs9 from "node:fs";
 import path9 from "node:path";
 var SCRIPT_CHECKS = ["test", "lint", "typecheck", "check"];
 var CHECKS_FILE = "workit.checks.json";
+var checksConfigFile = (root) => path9.join(root, CHECKS_FILE);
+function repoHeavyCommands(root) {
+  try {
+    const value = JSON.parse(fs9.readFileSync(checksConfigFile(root), "utf8"));
+    const resources = isRecord(value) ? value.resources : undefined;
+    const list = isRecord(resources) ? resources.heavyCommands : undefined;
+    return Array.isArray(list) ? list.filter((item) => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
 var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var SHELL_META = /[|&;<>()$`\\*?[\]{}~!#]/u;
 function splitCommand(command) {
@@ -12510,7 +12521,7 @@ function detectedChecks(root) {
 var GATES = ["testing", "verification"];
 function loadCheckConfig(cwd) {
   const root = checkRoot(cwd);
-  const file = path9.join(root, CHECKS_FILE);
+  const file = checksConfigFile(root);
   const none = (error = null) => ({
     source: error ? CHECKS_FILE : "none",
     root,
@@ -13255,6 +13266,7 @@ var workspaceConfigSchema = object({
   autoApprove: union([boolean2(), array(nonBlank)]).optional(),
   defaultEndpoint: unknown().optional(),
   verification: _enum(["self", "independent"]).optional(),
+  delegation: unknown().optional(),
   trailers: boolean2().optional(),
   liveSessionGuard: boolean2().optional(),
   fanout: object({ tierModels: unknown().optional() }).passthrough().optional(),
@@ -17506,7 +17518,16 @@ function rawInvocations(command, dialect = "posix", depth = 0) {
   return found;
 }
 var RECENT = new Map;
-function walk2(command, dialect, depth) {
+function commandLines(command, dialect = "posix") {
+  const lines = [];
+  try {
+    walk2(command, dialect, 0, lines);
+  } catch (error) {
+    throw error instanceof ShellAnalysisError ? error : new ShellAnalysisError(error instanceof Error ? error.message : String(error));
+  }
+  return lines;
+}
+function walk2(command, dialect, depth, seen) {
   const found = [];
   let dir = null;
   const groups = [];
@@ -17517,7 +17538,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) => {
@@ -17529,11 +17551,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 ? os4.homedir() : joinDir(dir, target);
@@ -17624,6 +17652,51 @@ var LAUNCHERS = new Set([
   "command"
 ]);
 var WORKIT_BIN = /(?:^|[\\/])workit(?:\.exe)?$|^@brainervirus\/workit-cli$/;
+var WORKIT_PACKAGE = /^@brainervirus\/workit-cli(?:@\S*)?$/;
+var PACKAGE_RUNNERS = new Set(["npx", "bunx", "pnpx"]);
+function workitCheckTail(words) {
+  let at = 0;
+  if (PACKAGE_RUNNERS.has(commandName(words[0]))) {
+    at = words.findIndex((word, index) => index > 0 && !word.startsWith("-"));
+    if (at < 0 || !WORKIT_PACKAGE.test(words[at]))
+      return null;
+  } else if (!/^workit(?:\.exe|\.cmd)?$/.test(commandName(words[0])))
+    return null;
+  const args = words.slice(at + 1);
+  if (args[0] !== "check" && !(args[0] === "lock" && args[1] === "run"))
+    return null;
+  const split = args.indexOf("--");
+  const tail = split < 0 ? [] : args.slice(split + 1);
+  if (!tail.length)
+    return null;
+  return args.slice(0, split).includes("--shell") ? { script: tail.join(" ") } : { argv: tail };
+}
+function simpleCommand(command, dialect = "posix", depth = 0) {
+  let segments;
+  try {
+    segments = segmentsOf(command, dialect);
+  } catch {
+    return null;
+  }
+  if (segments.length !== 1)
+    return null;
+  const [segment] = segments;
+  if (segment.group || segment.pipe || segment.unanalyzable || segment.redirects.length || segment.subs?.length || segment.stdin?.length)
+    return null;
+  const { words } = stripPrefixes(segment.words);
+  const name = commandName(words[0]);
+  if (!name || depth >= MAX_DEPTH)
+    return null;
+  if (SHELLS.has(name)) {
+    const script = shellScript(words, undefined);
+    return script ? simpleCommand(script, "posix", depth + 1) : null;
+  }
+  if (name === "-c" || name === "--command")
+    return words[1] ? simpleCommand(words[1], "posix", depth + 1) : null;
+  if (EVALS.has(name) || POWERSHELLS.has(name) || ["xargs", "find", "parallel", "script", "cmd", "source", "."].includes(name))
+    return null;
+  return words;
+}
 function workitInvocations(command, dialect = "posix", depth = 0) {
   const found = [];
   for (const { words } of segmentsOf(command, dialect)) {
@@ -21971,17 +22044,816 @@ var shellPolicy = (cwd, command, dialect = "posix") => {
   }
   return policy && !policy.ok ? { kind: "deny", reason: `branch_policy_denied: ${policy.error}`, unblock: null } : { kind: "none" };
 };
-// packages/workit-core/src/hooks/write-gate.ts
-import { realpathSync as realpathSync6 } from "node:fs";
+// packages/workit-core/src/core/heavy-rules.ts
+import fs18 from "node:fs";
+import os6 from "node:os";
+import path26 from "node:path";
+var EMPTY = () => ({ deny: [], allow: [] });
+var readText2 = (file) => {
+  try {
+    return fs18.readFileSync(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+};
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function parseJsonc(text) {
+  let out = "";
+  for (let index = 0;index < text.length; index += 1) {
+    const char = text[index];
+    if (char === '"') {
+      const end = /"(?:[^"\\]|\\.)*"/y;
+      end.lastIndex = index;
+      const match = end.exec(text);
+      if (!match)
+        throw new Error("unterminated string");
+      out += match[0];
+      index += match[0].length - 1;
+    } else if (char === "/" && text[index + 1] === "/") {
+      while (index < text.length && text[index] !== `
+`)
+        index += 1;
+      out += `
+`;
+    } else if (char === "/" && text[index + 1] === "*") {
+      const close = text.indexOf("*/", index + 2);
+      if (close < 0)
+        throw new Error("unterminated comment");
+      index = close + 1;
+    } else
+      out += char;
+  }
+  return JSON.parse(out.replace(/,(\s*[}\]])/gu, "$1"));
+}
+function gitTop(cwd) {
+  for (let dir = path26.resolve(cwd);; dir = path26.dirname(dir)) {
+    if (fs18.existsSync(path26.join(dir, ".git")))
+      return dir;
+    if (path26.dirname(dir) === dir)
+      return null;
+  }
+}
+var projectDirs = (cwd) => {
+  const top = gitTop(cwd);
+  const dirs = [];
+  for (let dir = path26.resolve(cwd);; dir = path26.dirname(dir)) {
+    dirs.push(dir);
+    if (!top || dir === top || path26.dirname(dir) === dir)
+      return dirs;
+  }
+};
+var homeOf = (env) => env.HOME || os6.homedir();
+var CLAUDE_MANAGED = {
+  linux: "/etc/claude-code/managed-settings.json",
+  darwin: "/Library/Application Support/ClaudeCode/managed-settings.json",
+  win32: "C:\\Program Files\\ClaudeCode\\managed-settings.json"
+};
+function claudeSettingsFiles(cwd, env, platform = process.platform) {
+  const project = env.CLAUDE_PROJECT_DIR || gitTop(cwd) || cwd;
+  const user = env.CLAUDE_CONFIG_DIR || path26.join(homeOf(env), ".claude");
+  return [
+    ...CLAUDE_MANAGED[platform] ? [CLAUDE_MANAGED[platform]] : [],
+    path26.join(user, "settings.json"),
+    path26.join(project, ".claude", "settings.json"),
+    path26.join(project, ".claude", "settings.local.json")
+  ];
+}
+var bashPattern = (entry) => {
+  const match = /^Bash(?:\((.*)\))?$/su.exec(entry.trim());
+  return match ? match[1] ?? "" : null;
+};
+function claudeRules(cwd, env = process.env) {
+  const rules = EMPTY();
+  try {
+    for (const file of claudeSettingsFiles(cwd, env)) {
+      const text = readText2(file);
+      if (text === null)
+        continue;
+      const value = JSON.parse(text);
+      if (!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;
+}
+var OPENCODE_NAMES = ["opencode.json", "opencode.jsonc"];
+var opencodePermission = (permission, rules) => {
+  if (permission === undefined)
+    return true;
+  if (typeof permission === "string") {
+    (permission === "allow" ? rules.allow : rules.deny).push("");
+    return ["allow", "ask", "deny"].includes(permission);
+  }
+  if (!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;
+};
+var 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));
+};
+function opencodeRules(cwd, env = process.env) {
+  const rules = EMPTY();
+  try {
+    const config = env.XDG_CONFIG_HOME || path26.join(homeOf(env), ".config");
+    const files = [
+      ...OPENCODE_NAMES.map((name) => path26.join(config, "opencode", name)),
+      ...projectDirs(cwd).flatMap((dir) => OPENCODE_NAMES.flatMap((name) => [path26.join(dir, name), path26.join(dir, ".opencode", name)])),
+      ...env.OPENCODE_CONFIG ? [env.OPENCODE_CONFIG] : []
+    ];
+    for (const file of files) {
+      const text = readText2(file);
+      if (text !== null && !opencodeConfig(parseJsonc(text), rules))
+        return "unreadable";
+    }
+    if (env.OPENCODE_CONFIG_CONTENT && !opencodeConfig(parseJsonc(env.OPENCODE_CONFIG_CONTENT), rules))
+      return "unreadable";
+  } catch {
+    return "unreadable";
+  }
+  return rules;
+}
+var codexRule = (body) => {
+  const open = /\bpattern\s*=\s*\[/u.exec(body);
+  if (!open)
+    return null;
+  const words = [];
+  let index = open.index + open[0].length;
+  for (;; ) {
+    while (/[\s,]/u.test(body[index] ?? ""))
+      index += 1;
+    if (body[index] === "]")
+      break;
+    if (body[index] !== '"')
+      return null;
+    const literal = /"((?:[^"\\]|\\.)*)"/y;
+    literal.lastIndex = index;
+    const match = literal.exec(body);
+    if (!match)
+      return null;
+    words.push(JSON.parse(`"${match[1]}"`));
+    index = literal.lastIndex;
+  }
+  const decision = /\bdecision\s*=\s*"(\w+)"/u.exec(body)?.[1];
+  if (!words.length || !decision || !["allow", "prompt", "forbidden"].includes(decision))
+    return null;
+  return { pattern: words.join(" "), decision };
+};
+function codexRules(cwd, env = process.env) {
+  const rules = EMPTY();
+  try {
+    const home = env.CODEX_HOME || path26.join(homeOf(env), ".codex");
+    const top = gitTop(cwd) ?? cwd;
+    for (const dir of [path26.join(home, "rules"), path26.join(top, ".codex", "rules")]) {
+      let files;
+      try {
+        files = fs18.readdirSync(dir).filter((name) => name.endsWith(".rules"));
+      } catch (error) {
+        if (error.code === "ENOENT")
+          continue;
+        return "unreadable";
+      }
+      for (const name of files) {
+        const text = readText2(path26.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 [
+      path26.join(homeOf(env), ".cursor", "cli-config.json"),
+      path26.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;
+}
+var baseName = (word) => (word.split(/[\\/]/u).at(-1) ?? "").toLowerCase().replace(/\.(?:exe|cmd|bat)$/u, "");
+var firstToken = (pattern) => pattern.trim().split(/[:\s]/u)[0] ?? "";
+function names(pattern, words) {
+  const token = firstToken(pattern);
+  if (!token || token === "*" || token.includes("*"))
+    return true;
+  const wanted = baseName(token);
+  return words.some((word) => baseName(word) === wanted);
+}
+var literalPrefix = (pattern) => pattern.trim().replace(/(?::\*| \*|\*)$/u, "");
+var coversWrapper = (pattern) => {
+  const token = firstToken(pattern);
+  if (!token || token.includes("*"))
+    return true;
+  const words = literalPrefix(pattern).split(/\s+/u);
+  if (baseName(words[0]) !== "workit")
+    return false;
+  return ["check", "--heavy"].slice(0, words.length - 1).every((word, at) => {
+    const given = words[at + 1];
+    return given === word || word.startsWith(given);
+  });
+};
+var coversCommand = (pattern, command) => {
+  const prefix = literalPrefix(pattern);
+  if (!prefix)
+    return true;
+  return !prefix.includes("*") && command.trim().startsWith(prefix);
+};
+function wrapAllowed(read, words, command, options = {}) {
+  if (read === "unreadable")
+    return { ok: false, why: "named" };
+  if (read.deny.some((pattern) => names(pattern, words)))
+    return { ok: false, why: "named" };
+  if (!options.bypass && read.allow.some(coversWrapper) && !read.allow.some((pattern) => coversCommand(pattern, command)))
+    return { ok: false, why: "allowlisted" };
+  return { ok: true };
+}
+
+// packages/workit-core/src/core/heavy.ts
+import fs19 from "node:fs";
 import os7 from "node:os";
 import path27 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 path27.join(env.XDG_STATE_HOME, "workit");
+  const home = env.HOME || os7.homedir();
+  if (platform === "darwin")
+    return path27.join(home, "Library", "Application Support", "workit");
+  if (platform === "win32")
+    return path27.join(env.LOCALAPPDATA ?? path27.join(home, "AppData", "Local"), "workit");
+  return path27.join(home, ".local", "state", "workit");
+}
+var HEAVY_COMMANDS_FILE = "heavy-commands.json";
+var heavyCommandsFile = (env) => path27.join(stateDir(env), HEAVY_COMMANDS_FILE);
+var HEAVY_SCRIPT = /^(?:test|tests|t|tst|unit|integration|e2e|coverage|cov|lint|eslint|typecheck|type-check|types|tsc|check|verify|validate|build|compile|bundle|ci|sonar|cypress|playwright|jest|vitest|mocha|bench|benchmark|all)(?:$|[:_.-])/iu;
+var INFO_FLAGS = new Set(["--version", "-v", "-V", "--help", "-h", "help", "version"]);
+var WATCH_FLAG = /^(?:--watch(?:All)?(?:=.*)?|-w|--serve)$/u;
+var WATCH_SCRIPT = /(?:^|[:_.-])(?:watch|dev|serve|start|storybook)(?:$|[:_.-])/iu;
+var sub = (...names) => new Set(names);
+var TOOLS = {
+  jest: "any",
+  vitest: "any",
+  mocha: "any",
+  ava: "any",
+  tap: "any",
+  karma: "any",
+  jasmine: "any",
+  nyc: "any",
+  c8: "any",
+  tsc: "any",
+  "vue-tsc": "any",
+  "svelte-check": "any",
+  eslint: "any",
+  stylelint: "any",
+  tslint: "any",
+  webpack: "any",
+  "webpack-cli": "any",
+  rollup: "any",
+  parcel: "any",
+  tsup: "any",
+  vite: sub("build", "optimize"),
+  next: sub("build", "lint"),
+  nuxt: sub("build", "generate"),
+  nuxi: sub("build", "generate"),
+  astro: sub("build", "check"),
+  ng: sub("build", "b", "test", "t", "e2e", "lint"),
+  "react-scripts": sub("build", "test"),
+  playwright: sub("test", "install"),
+  cypress: sub("run"),
+  wdio: "any",
+  testcafe: "any",
+  turbo: "any",
+  lerna: sub("run", "exec", "bootstrap"),
+  "sonar-scanner": "any",
+  sonarless: sub("scan"),
+  "sonarless-mcp": sub("scan"),
+  go: sub("test", "build", "vet", "install", "generate"),
+  "golangci-lint": sub("run"),
+  gotestsum: "any",
+  staticcheck: "any",
+  cargo: sub("build", "b", "test", "t", "check", "c", "clippy", "bench", "nextest", "doc", "install", "tarpaulin", "llvm-cov"),
+  mvn: "any",
+  mvnw: "any",
+  gradle: "any",
+  gradlew: "any",
+  ant: "any",
+  sbt: "any",
+  bazel: sub("build", "test", "run", "coverage"),
+  bazelisk: sub("build", "test", "run", "coverage"),
+  buck2: sub("build", "test", "run"),
+  dotnet: sub("build", "test", "publish", "restore", "pack", "msbuild"),
+  msbuild: "any",
+  pytest: "any",
+  "py.test": "any",
+  tox: "any",
+  nox: "any",
+  mypy: "any",
+  pyright: "any",
+  pylint: "any",
+  coverage: sub("run"),
+  maturin: sub("build", "develop"),
+  pip: sub("install", "wheel"),
+  pip3: sub("install", "wheel"),
+  rspec: "any",
+  rails: sub("test", "assets:precompile"),
+  phpunit: "any",
+  pest: "any",
+  phpstan: "any",
+  psalm: "any",
+  composer: sub("install", "update", "require", "test"),
+  mix: sub("test", "compile", "deps.get", "dialyzer", "credo"),
+  swift: sub("build", "test"),
+  xcodebuild: "any",
+  flutter: sub("build", "test"),
+  dart: sub("test", "compile"),
+  pod: sub("install"),
+  cmake: sub("--build"),
+  ninja: "any",
+  meson: sub("compile", "test"),
+  ctest: "any",
+  scons: "any",
+  "docker-compose": sub("build"),
+  buildah: sub("bud", "build"),
+  earthly: "any"
+};
+var PM_VALUES = new Set([
+  "--prefix",
+  "-w",
+  "--workspace",
+  "-C",
+  "--dir",
+  "--filter",
+  "-F",
+  "--cwd",
+  "-p",
+  "--package",
+  "--cache",
+  "--registry"
+]);
+function positional2(words, from, values = PM_VALUES) {
+  let index = from;
+  while (index < words.length && words[index].startsWith("-")) {
+    if (words[index] === "--")
+      return index + 1;
+    index += values.has(words[index]) ? 2 : 1;
+  }
+  return index;
+}
+var baseName2 = (word) => (word?.split(/[\\/]/u).at(-1) ?? "").toLowerCase().replace(/\.(?:exe|cmd|bat|ps1)$/u, "");
+var WORKIT = /^(?:workit|@brainervirus\/workit-cli(?:@.*)?)$/u;
+var PYTHONS = /^(?:python[\d.]*|py)$/u;
+var NPM_INSTALL = new Set([
+  "ci",
+  "clean-install",
+  "cit",
+  "install-test",
+  "it",
+  "install",
+  "i",
+  "in",
+  "add",
+  "rebuild",
+  "update",
+  "up"
+]);
+var NPM_RUN = new Set(["run", "run-script", "rum", "urn"]);
+var NPM_TEST = new Set(["test", "t", "tst"]);
+var EXEC = new Set(["exec", "x", "dlx"]);
+function builtIn(words, depth = 0) {
+  if (depth > 6 || !words.length)
+    return null;
+  const name = baseName2(words[0]);
+  const label = () => words.slice(0, 3).join(" ");
+  const inner = (from) => builtIn(words.slice(from), depth + 1);
+  if (WORKIT.test(name))
+    return null;
+  if (INFO_FLAGS.has(words[1] ?? "") && words.length === 2)
+    return null;
+  if (words.some((word) => word === "--watch" || word.startsWith("--watch=") || word === "--watchAll"))
+    return null;
+  if (name === "npx" || name === "bunx" || name === "pnpx")
+    return inner(positional2(words, 1));
+  if (name === "corepack")
+    return inner(1);
+  if (name === "npm" || name === "pnpm" || name === "yarn" || name === "bun" || name === "deno") {
+    const at = positional2(words, 1);
+    const command = words[at];
+    if (command === undefined)
+      return name === "yarn" ? "yarn (install)" : null;
+    if (name === "deno") {
+      if (["test", "bench", "check", "compile", "lint"].includes(command))
+        return label();
+      if (command === "task" && HEAVY_SCRIPT.test(words[at + 1] ?? ""))
+        return label();
+      return null;
+    }
+    if (NPM_INSTALL.has(command) || NPM_TEST.has(command))
+      return label();
+    if (name === "bun" && command === "build")
+      return label();
+    if (EXEC.has(command))
+      return inner(positional2(words, at + 1));
+    if (name === "yarn" && command === "workspace")
+      return inner(at + 2);
+    if (name === "yarn" && command === "workspaces")
+      return words.slice(at + 1).some((word) => HEAVY_SCRIPT.test(word)) ? label() : null;
+    if (NPM_RUN.has(command)) {
+      const script = words[positional2(words, at + 1)];
+      if (script === undefined || WATCH_SCRIPT.test(script))
+        return null;
+      if (HEAVY_SCRIPT.test(script))
+        return label();
+      return name === "bun" ? inner(positional2(words, at + 1)) : null;
+    }
+    if (name === "npm")
+      return null;
+    if (WATCH_SCRIPT.test(command))
+      return null;
+    if (HEAVY_SCRIPT.test(command) && !/\.[cm]?[jt]sx?$/u.test(command))
+      return label();
+    return inner(at);
+  }
+  if (PYTHONS.test(name)) {
+    const at = words.indexOf("-m");
+    return at > 0 && words[at + 1] ? inner(at + 1) : null;
+  }
+  if (["uv", "poetry", "pdm", "pipenv", "hatch", "rye"].includes(name)) {
+    const at = positional2(words, 1);
+    const command = words[at];
+    if (command === "run")
+      return inner(positional2(words, at + 1));
+    if (command === "pip")
+      return inner(at);
+    return ["sync", "install", "build", "test", "add"].includes(command ?? "") ? label() : null;
+  }
+  if (name === "bundle") {
+    const command = words[positional2(words, 1)];
+    if (command === "exec")
+      return inner(positional2(words, 2));
+    return command === "install" || command === undefined ? label() : null;
+  }
+  if (name === "make" || name === "gmake") {
+    const targets = words.slice(1).filter((word) => !word.startsWith("-") && !word.includes("="));
+    if (targets.some((target) => WATCH_SCRIPT.test(target)))
+      return null;
+    return !targets.length || targets.some((target) => HEAVY_SCRIPT.test(target)) ? label() : null;
+  }
+  if (name === "rake") {
+    const targets = words.slice(1).filter((word) => !word.startsWith("-") && !word.includes("="));
+    return targets.some((target) => HEAVY_SCRIPT.test(target) || /^spec(?:$|:)/u.test(target)) ? label() : null;
+  }
+  if (name === "nx") {
+    const at = positional2(words, 1);
+    const command = words[at] ?? "";
+    if (["run-many", "affected"].includes(command))
+      return words.some((word) => /^(?:-t|--targets?)(?:=|$)/u.test(word)) && !words.some((word) => WATCH_SCRIPT.test(word.replace(/^--?targets?=/u, ""))) ? label() : null;
+    if (command === "run") {
+      const target = (words[at + 1] ?? "").split(":")[1] ?? "";
+      return HEAVY_SCRIPT.test(target) && !WATCH_SCRIPT.test(target) ? label() : null;
+    }
+    return HEAVY_SCRIPT.test(command) && !WATCH_SCRIPT.test(command) ? label() : null;
+  }
+  if (name === "docker" || name === "podman" || name === "nerdctl") {
+    const at = positional2(words, 1, new Set(["-H", "--host", "--context", "-c", "--config"]));
+    const command = words[at];
+    if (command === "build")
+      return label();
+    if (command === "buildx" || command === "image" || command === "builder")
+      return words[positional2(words, at + 1)] === "build" ? label() : null;
+    if (command === "compose") {
+      const at2 = positional2(words, at + 1, new Set(["-f", "--file", "-p"]));
+      const action = words[at2];
+      if (action === "build")
+        return label();
+      return action === "up" && words.slice(at2 + 1).includes("--build") ? label() : null;
+    }
+    return null;
+  }
+  const rule = TOOLS[name];
+  if (!rule)
+    return null;
+  if (words.slice(1).some((word) => WATCH_FLAG.test(word) || word === "watch" || word === "dev"))
+    return null;
+  if (rule === "any")
+    return label();
+  const command = words.slice(1).find((word) => !word.startsWith("-") && !word.startsWith("+") || rule.has(word));
+  return command !== undefined && rule.has(command) ? label() : null;
+}
+var globWord = (word) => new RegExp(`^${word.replace(/[.+?^${}()|[\]\\]/gu, "\\$&").replaceAll("*", ".*")}$`, "u");
+function parsePattern(pattern) {
+  const words = pattern.trim().split(/\s+/u).filter(Boolean);
+  return words.length ? words.map(globWord) : null;
+}
+var matches = (matchers, words) => matchers.length <= words.length && matchers.every((matcher, index) => index === 0 ? matcher.test(words[0]) || matcher.test(baseName2(words[0])) : matcher.test(words[index]));
+var readJson = (file) => {
+  try {
+    return JSON.parse(fs19.readFileSync(file, "utf8"));
+  } catch {
+    return;
+  }
+};
+var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var stringList = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+function machinePatterns(env) {
+  const value = readJson(heavyCommandsFile(env));
+  return isRecord5(value) ? stringList(value.patterns) : [];
+}
+function repoPatterns(cwd) {
+  return repoHeavyCommands(gitTop(cwd) ?? path27.resolve(cwd));
+}
+function heavyLines(lines, options) {
+  const found = [];
+  let patterns = null;
+  for (const line of lines) {
+    const reason = builtIn(line);
+    if (reason) {
+      found.push({ line, source: "catalog", reason });
+      continue;
+    }
+    patterns ??= (options.patterns ?? [
+      ...machinePatterns(options.env ?? process.env).map((pattern) => ({
+        pattern,
+        from: "machine"
+      })),
+      ...repoPatterns(options.cwd).map((pattern) => ({ pattern, from: "repo" }))
+    ]).flatMap((entry) => {
+      const matchers = parsePattern(entry.pattern);
+      return matchers ? [{ ...entry, matchers }] : [];
+    });
+    const hit = patterns.find((entry) => matches(entry.matchers, line));
+    if (hit)
+      found.push({
+        line,
+        source: { pattern: hit.pattern, from: hit.from },
+        reason: `${hit.from} pattern "${hit.pattern}"`
+      });
+  }
+  return found;
+}
+var linesOf = (command, dialect) => {
+  try {
+    return commandLines(command, dialect);
+  } catch {
+    return null;
+  }
+};
+var quoteWord = (word) => /^[\w@%+=:,./-]+$/u.test(word) ? word : `'${word.replaceAll("'", `'\\''`)}'`;
+var leaseCommand = (words) => `workit check --heavy -- ${words.map(quoteWord).join(" ")}`;
+function heavyPlan(command, options) {
+  const dialect = options.dialect ?? "posix";
+  if (dialect !== "posix" || !gitTop(options.cwd))
+    return { kind: "none" };
+  const lines = linesOf(command, dialect);
+  if (!lines)
+    return { kind: "none" };
+  const heavy = heavyLines(lines, options);
+  if (!heavy.length)
+    return { kind: "none" };
+  const simple = simpleCommand(command, dialect);
+  const single = simple && !WORKIT.test(baseName2(simple[0])) && heavyLines([simple], options)[0];
+  const judged = single ? [{ words: lines.flat(), text: command }] : heavy.map((match) => ({
+    words: match.line,
+    text: match.line.join(" ")
+  }));
+  if (options.rules !== null)
+    for (const { words, text } of judged) {
+      const verdict = wrapAllowed(options.rules, words, text, { bypass: options.bypass });
+      if (!verdict.ok)
+        return {
+          kind: "passthrough",
+          note: `workit: \`${command.trim()}\` is heavy but runs outside the heavy-check lease because a host permission rule names it (or \`workit\` is allowlisted); the host decides.`
+        };
+    }
+  if (single) {
+    const rewrite = leaseRewrite(command);
+    return rewrite ? { kind: "rewrite", command: rewrite, reason: single.reason } : { kind: "none" };
+  }
+  const parts = heavy.map((match) => leaseCommand(match.line));
+  return {
+    kind: "split",
+    reason: `heavy_command: \`${command.trim()}\` chains heavy work (${heavy.map((match) => match.reason).join("; ")}) with other commands, and a chain cannot run under the machine-wide heavy-check lease. Run each heavy part alone as \`workit check --heavy -- <segment>\` (here: ${parts.map((part) => `\`${part}\``).join("; ")}); run the other parts as their own commands.`,
+    unblock: parts[0] ?? null
+  };
+}
+function workitOnPath2(env = process.env) {
+  const names = process.platform === "win32" ? ["workit.exe", "workit.cmd", "workit"] : ["workit"];
+  for (const dir of (env.PATH ?? "").split(path27.delimiter))
+    for (const name of names) {
+      if (!dir)
+        continue;
+      try {
+        fs19.accessSync(path27.join(dir, name), fs19.constants.X_OK);
+        return true;
+      } catch {}
+    }
+  return false;
+}
+var ASSIGNMENTS = /^\s*((?:[A-Za-z_]\w*=(?:'[^']*'|"(?:[^"\\]|\\.)*"|[^\s'"])*\s+)*)/u;
+function leaseRewrite(command) {
+  const text = command.trim();
+  const prefix = ASSIGNMENTS.exec(text)?.[1] ?? "";
+  const rest = text.slice(prefix.length).trim();
+  if (!rest)
+    return null;
+  return `${prefix}workit check --heavy -- ${rest}`;
+}
+
+// packages/workit-core/src/core/heavy-words.ts
+import fs20 from "node:fs";
+import os8 from "node:os";
+import path28 from "node:path";
+var HEAVY_WORDS = new Set(("npm npx pnpm pnpx yarn bun bunx deno corepack make gmake docker podman nerdctl " + "python python3 py uv poetry pdm pipenv hatch rye bundle rake nx " + "jest vitest mocha ava tap karma jasmine nyc c8 tsc vue-tsc svelte-check eslint stylelint " + "tslint webpack webpack-cli rollup parcel tsup vite next nuxt nuxi astro ng react-scripts " + "playwright cypress wdio testcafe turbo lerna sonar-scanner sonarless sonarless-mcp go " + "golangci-lint gotestsum staticcheck cargo mvn mvnw gradle gradlew ant sbt bazel bazelisk " + "buck2 dotnet msbuild pytest py.test tox nox mypy pyright pylint coverage maturin pip pip3 " + "rspec rails phpunit pest phpstan psalm composer mix swift xcodebuild flutter dart pod cmake " + "ninja meson ctest scons docker-compose buildah earthly").split(" "));
+var wordsOf = (command) => command.split(/[\s;&|()<>`'"]+/u).map((word) => (word.split(/[\\/]/u).at(-1) ?? "").toLowerCase().replace(/\.(?:exe|cmd|bat)$/u, "")).filter(Boolean);
+var stateDir2 = (env) => {
+  if (env.WORKFLOW_TOOLKIT_STATE)
+    return env.WORKFLOW_TOOLKIT_STATE;
+  if (env.XDG_STATE_HOME)
+    return path28.join(env.XDG_STATE_HOME, "workit");
+  const home = env.HOME || os8.homedir();
+  if (process.platform === "darwin")
+    return path28.join(home, "Library", "Application Support", "workit");
+  if (process.platform === "win32")
+    return path28.join(env.LOCALAPPDATA ?? path28.join(home, "AppData", "Local"), "workit");
+  return path28.join(home, ".local", "state", "workit");
+};
+var readJson2 = (file) => {
+  try {
+    return JSON.parse(fs20.readFileSync(file, "utf8"));
+  } catch {
+    return;
+  }
+};
+var patternWords = (cwd, env) => {
+  const patterns = [];
+  const machine = readJson2(path28.join(stateDir2(env), "heavy-commands.json"));
+  if (Array.isArray(machine?.patterns))
+    patterns.push(...machine.patterns);
+  for (let dir = path28.resolve(cwd);; dir = path28.dirname(dir)) {
+    if (fs20.existsSync(path28.join(dir, ".git"))) {
+      patterns.push(...repoHeavyCommands(dir));
+      break;
+    }
+    if (path28.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;
+};
+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;
+  }
+}
+
+// packages/workit-core/src/hooks/heavy-gate.ts
+var rulesFor = (host, cwd, env) => {
+  switch (host) {
+    case "claude_code":
+      return claudeRules(cwd, env);
+    case "opencode":
+      return opencodeRules(cwd, env);
+    case "codex_cli":
+    case "codex_desktop":
+      return codexRules(cwd, env);
+    case "cursor":
+      return cursorRules(cwd, env);
+    case "pi":
+      return null;
+  }
+};
+function heavyGate(cwd, command, options) {
+  const env = options.env ?? process.env;
+  try {
+    if (env.WORKIT_HEAVY_GATE === "0" || !maybeHeavy(command, cwd, env) || !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" };
+  }
+}
+// packages/workit-core/src/hooks/write-gate.ts
+import { realpathSync as realpathSync6 } from "node:fs";
+import os10 from "node:os";
+import path30 from "node:path";
 
 // packages/workit-core/src/core/live-session.ts
 import { spawnSync as spawnSync17 } from "node:child_process";
 import { createHash as createHash14 } from "node:crypto";
-import fs18 from "node:fs";
-import os6 from "node:os";
-import path26 from "node:path";
+import fs21 from "node:fs";
+import os9 from "node:os";
+import path29 from "node:path";
 var LIVE_SESSION_TTL_MS = 15 * 60000;
 var HEARTBEAT_EVERY_MS = 30000;
 var liveProbe = {
@@ -22002,9 +22874,9 @@ var processAlive = (pid) => {
 var processInfo = (pid) => {
   try {
     if (liveProbe.platform === "linux") {
-      const stat = fs18.readFileSync(`/proc/${pid}/stat`, "utf8");
+      const stat = fs21.readFileSync(`/proc/${pid}/stat`, "utf8");
       const ppid = Number(stat.slice(stat.lastIndexOf(")") + 2).split(" ")[1]);
-      const command = fs18.readFileSync(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ");
+      const command = fs21.readFileSync(`/proc/${pid}/cmdline`, "utf8").replaceAll("\x00", " ");
       return Number.isInteger(ppid) ? { ppid, command: command.trim() } : null;
     }
     if (liveProbe.platform === "win32")
@@ -22055,35 +22927,35 @@ var liveOwner = (input, transport, env = process.env) => {
   };
 };
 var checkoutOf = (target) => {
-  let dir = path26.resolve(target);
-  while (!fs18.existsSync(dir) && path26.dirname(dir) !== dir)
-    dir = path26.dirname(dir);
-  if (fs18.existsSync(dir) && !fs18.statSync(dir).isDirectory())
-    dir = path26.dirname(dir);
-  const parts = dir.split(path26.sep);
+  let dir = path29.resolve(target);
+  while (!fs21.existsSync(dir) && path29.dirname(dir) !== dir)
+    dir = path29.dirname(dir);
+  if (fs21.existsSync(dir) && !fs21.statSync(dir).isDirectory())
+    dir = path29.dirname(dir);
+  const parts = dir.split(path29.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(path29.sep) || path29.sep;
   const location = resolveStore(dir);
   if (location instanceof Error || !location.shared || !location.top)
     return null;
   let top = location.top;
   try {
-    top = fs18.realpathSync.native(top);
+    top = fs21.realpathSync.native(top);
   } catch {}
   return top;
 };
-var markerFile2 = (top) => path26.join(resolveStateDir(), "live-sessions", `${createHash14("sha256").update(checkoutKey(top)).digest("hex").slice(0, 32)}.json`);
+var markerFile2 = (top) => path29.join(resolveStateDir(), "live-sessions", `${createHash14("sha256").update(checkoutKey(top)).digest("hex").slice(0, 32)}.json`);
 var checkoutKey = (top, platform = process.platform) => {
-  let key = path26.resolve(top);
+  let key = path29.resolve(top);
   try {
-    key = fs18.realpathSync.native(key);
+    key = fs21.realpathSync.native(key);
   } catch {}
   return platform === "win32" ? key.replaceAll("/", "\\").toLowerCase() : key;
 };
 var readMarker = (file) => {
   try {
-    const value = JSON.parse(fs18.readFileSync(file, "utf8"));
+    const value = JSON.parse(fs21.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 {
@@ -22106,7 +22978,7 @@ var isLive = (marker, deps) => {
   const age = ageOf2(marker, deps.now ?? new Date);
   if (age > (deps.ttlMs ?? LIVE_SESSION_TTL_MS))
     return false;
-  if (marker.machine !== (deps.machine ?? os6.hostname()) || marker.pid === null)
+  if (marker.machine !== (deps.machine ?? os9.hostname()) || marker.pid === null)
     return true;
   if (!(deps.alive ?? processAlive)(marker.pid))
     return false;
@@ -22135,7 +23007,7 @@ var liveConflict = (target, owner, deps = {}) => {
     const marker = readMarker(file);
     if (!marker || sameLead(marker, owner) || !isLive(marker, deps))
       return null;
-    if (sameOwner(marker, owner, deps.machine ?? os6.hostname()))
+    if (sameOwner(marker, owner, deps.machine ?? os9.hostname()))
       return null;
     return { marker, file, ageMs: ageOf2(marker, deps.now ?? new Date), checkout };
   } catch {
@@ -22149,7 +23021,7 @@ var claimLiveSession = (target, owner, deps = {}) => {
       return;
     const file = markerFile2(checkout);
     const now = deps.now ?? new Date;
-    const machine = deps.machine ?? os6.hostname();
+    const machine = deps.machine ?? os9.hostname();
     const current = readMarker(file);
     if (current) {
       const age = ageOf2(current, now);
@@ -22170,10 +23042,10 @@ var claimLiveSession = (target, owner, deps = {}) => {
       checkout,
       heartbeatAt: now.toISOString()
     };
-    fs18.mkdirSync(path26.dirname(file), { recursive: true });
+    fs21.mkdirSync(path29.dirname(file), { recursive: true });
     const temp = `${file}.${process.pid}.tmp`;
-    fs18.writeFileSync(temp, JSON.stringify(marker));
-    fs18.renameSync(temp, file);
+    fs21.writeFileSync(temp, JSON.stringify(marker));
+    fs21.renameSync(temp, file);
   } catch {}
 };
 
@@ -22182,27 +23054,42 @@ var NONE3 = { kind: "none" };
 var CASE_INSENSITIVE = process.platform === "darwin" || process.platform === "win32";
 var canonical2 = (file) => {
   let rest = "";
-  for (let dir = path27.resolve(file);; dir = path27.dirname(dir)) {
+  for (let dir = path30.resolve(file);; dir = path30.dirname(dir)) {
     try {
-      return path27.join(realpathSync6(dir), rest);
+      return path30.join(realpathSync6(dir), rest);
     } catch {
-      if (path27.dirname(dir) === dir)
-        return path27.resolve(file);
-      rest = rest ? path27.join(path27.basename(dir), rest) : path27.basename(dir);
+      if (path30.dirname(dir) === dir)
+        return path30.resolve(file);
+      rest = rest ? path30.join(path30.basename(dir), rest) : path30.basename(dir);
     }
   }
 };
 var 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 = path30.relative(fold(canonical2(root)), fold(canonical2(path30.resolve(cwd, file))));
+  if (relative.startsWith("..") || path30.isAbsolute(relative))
     return true;
-  const posix = relative.split(path27.sep).join("/");
+  const posix = relative.split(path30.sep).join("/");
   const segments = posix.split("/");
   return /\.mdx?$/i.test(posix) || segments[0] === "docs" || segments.includes("plans") || [...plans].some((plan) => fold(plan) === posix);
 };
 var PREFIXES2 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "xargs"]);
 var operands = (words) => words.filter((item) => !item.startsWith("-"));
+var SCRIPT_SHELLS = new Set(["sh", "bash", "zsh", "dash", "ksh"]);
+var wrappedScript = (input) => {
+  let words = input;
+  while (words.length && (PREFIXES2.has(words[0]) || /^\w+=/.test(words[0])))
+    words = words.slice(1);
+  const tail = workitCheckTail(words);
+  if (!tail)
+    return null;
+  if ("script" in tail)
+    return tail.script;
+  const [shell, flag, script] = tail.argv;
+  if (SCRIPT_SHELLS.has((shell.split(/[\\/]/).at(-1) ?? "").toLowerCase()) && /^-[a-z]*c$/.test(flag ?? ""))
+    return script ?? null;
+  return tail.argv.map(quoteWord2).join(" ");
+};
 var editsOf = (input) => {
   let words = input;
   while (words.length && (PREFIXES2.has(words[0]) || /^\w+=/.test(words[0])))
@@ -22279,10 +23166,18 @@ var editsOf = (input) => {
       return [];
   }
 };
-var shellWrites = (command) => {
+var shellWrites = (command, depth = 0) => {
   const targets = [];
   let unknown = false;
   for (const segment of segmentsOf(command)) {
+    const inner = depth < 4 ? wrappedScript(segment.words) : null;
+    if (inner !== null) {
+      const nested = shellWrites(inner, depth + 1);
+      if (nested.writes && nested.targets === null)
+        unknown = true;
+      else if (nested.targets)
+        targets.push(...nested.targets);
+    }
     targets.push(...segment.redirects.filter((item) => !/^\/dev\/(?:null|stdout|stderr|tty)$/.test(item)));
     const edits = editsOf(segment.words);
     if (edits === null)
@@ -22295,7 +23190,7 @@ var shellWrites = (command) => {
   return { writes: true, targets: unknown ? null : targets };
 };
 var cache2 = new Map;
-var planKeyOf = (root, plans) => [...plans].map((file) => fileSignature(path27.resolve(root, file)) ?? "-").join("\x00");
+var planKeyOf = (root, plans) => [...plans].map((file) => fileSignature(path30.resolve(root, file)) ?? "-").join("\x00");
 var gateFor = (cwd) => {
   const store = new TaskStore(cwd);
   const listed = store.listTaskIndex();
@@ -22374,7 +23269,7 @@ var gitMutationDirs = (cwd, command, dialect) => {
       return [];
     if (sub === "stash" && ["list", "show"].includes(rest[0] ?? ""))
       return [];
-    return [path27.resolve(cwd, invocation.dir ?? ".")];
+    return [path30.resolve(cwd, invocation.dir ?? ".")];
   });
 };
 var CD2 = new Set(["cd", "chdir", "set-location", "sl"]);
@@ -22384,15 +23279,15 @@ var cdInto = (dir, words) => {
   const target = words.slice(1).find((word) => !word.startsWith("-") || word === "-");
   if (dir === undefined || target === "-" || target && /^~|[$`*?]/.test(target))
     return;
-  return target === undefined ? os7.homedir() : path27.resolve(dir, target);
+  return target === undefined ? os10.homedir() : path30.resolve(dir, target);
 };
-var quoteWord = (word) => /^[\w@%+=:,./-]+$/.test(word) ? word : `'${word.replaceAll("'", "'\\''")}'`;
-var segmentTargets = (cwd, command, dialect) => {
+var quoteWord2 = (word) => /^[\w@%+=:,./-]+$/.test(word) ? word : `'${word.replaceAll("'", "'\\''")}'`;
+var segmentTargets = (cwd, command, dialect, depth = 0) => {
   const targets = [];
   let dir = cwd;
   let stack = [];
   const groups = [];
-  const at = (file) => path27.isAbsolute(file) ? file : dir === undefined ? null : path27.resolve(dir, file);
+  const at = (file) => path30.isAbsolute(file) ? file : dir === undefined ? null : path30.resolve(dir, file);
   for (const segment of segmentsOf(command, dialect)) {
     if (segment.group === "open") {
       groups.push({ dir, stack: [...stack] });
@@ -22420,6 +23315,9 @@ var segmentTargets = (cwd, command, dialect) => {
       dir = stack.length ? stack.pop() : undefined;
       continue;
     }
+    const inner = depth < 4 ? wrappedScript(words) : null;
+    if (inner !== null && dir !== undefined)
+      targets.push(...segmentTargets(dir, inner, "posix", depth + 1));
     for (const file of segment.redirects)
       if (!/^\/dev\/(?:null|stdout|stderr|tty)$/.test(file)) {
         const resolved = at(file);
@@ -22429,15 +23327,15 @@ var segmentTargets = (cwd, command, dialect) => {
     const edits = editsOf(segment.words);
     if (edits === null) {
       if (dir !== undefined)
-        targets.push(path27.join(dir, DIR_TARGET));
+        targets.push(path30.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(path27.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(path30.join(dir, DIR_TARGET));
   }
   return targets;
 };
@@ -22472,7 +23370,7 @@ var liveDeny = ({ marker, checkout, ageMs, file }) => {
 var guarded = (targets) => {
   const seen = new Set;
   return targets.filter((target) => {
-    const dir = path27.dirname(target);
+    const dir = path30.dirname(target);
     if (seen.has(dir))
       return false;
     seen.add(dir);
@@ -22493,7 +23391,7 @@ var claimAll = (owner, targets, deps) => {
   for (const target of guarded(targets))
     claimLiveSession(target, owner, deps);
 };
-var liveTargets = (cwd, paths) => paths?.length ? paths.map((file) => path27.resolve(cwd, file)) : [path27.join(cwd, DIR_TARGET)];
+var liveTargets = (cwd, paths) => paths?.length ? paths.map((file) => path30.resolve(cwd, file)) : [path30.join(cwd, DIR_TARGET)];
 function writeGate(cwd, paths, owner, deps) {
   if (!owner)
     return beforeWriteGate(cwd, paths);
@@ -22513,7 +23411,7 @@ function shellGate(cwd, command, owner, dialect = "posix", deps) {
     try {
       targets = [
         ...segmentTargets(cwd, command, dialect),
-        ...gitMutationDirs(cwd, command, dialect).map((dir) => path27.join(dir, DIR_TARGET))
+        ...gitMutationDirs(cwd, command, dialect).map((dir) => path30.join(dir, DIR_TARGET))
       ];
     } catch {
       targets = [];
@@ -22996,7 +23894,7 @@ var OPENCODE_DESCRIPTOR = {
     "compact.pre": { support: "native", native: 'session.hook("compaction")' },
     stop: { support: "partial", native: 'event("session.idle")' }
   },
-  shellPolicy: { deny: "native", channel: "effect", failClosed: false },
+  shellPolicy: { deny: "native", channel: "effect", failClosed: false, rewrite: "native" },
   context: {
     sessionStart: "none",
     perTurn: "native",
@@ -23045,11 +23943,11 @@ var OPENCODE_DESCRIPTOR = {
   ]
 };
 // packages/workit-opencode/src/shared/init-apply.ts
-import path32 from "node:path";
+import path35 from "node:path";
 
 // packages/workit-core/src/core/gitignore.ts
 import { existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "node:fs";
-import path28 from "node:path";
+import path31 from "node:path";
 var GITIGNORE_ENTRIES = [
   "# workit: SDD working state (never commit)",
   "docs/*/sdd/",
@@ -23069,7 +23967,7 @@ var GITIGNORE_ENTRIES = [
 var ensureProjectGitignore = (workspaceRoot, confirmed) => {
   if (!confirmed)
     return { ok: false, error: "confirmed: true required" };
-  const file = path28.join(workspaceRoot, ".gitignore");
+  const file = path31.join(workspaceRoot, ".gitignore");
   const existing = existsSync9(file) ? readFileSync6(file, "utf8") : "";
   const existingLines = new Set(existing.split(`
 `).map((l) => l.trim()).filter(Boolean));
@@ -23097,25 +23995,25 @@ var ensureProjectGitignore = (workspaceRoot, confirmed) => {
 
 // packages/workit-core/src/core/hygiene.ts
 import { existsSync as existsSync10, readFileSync as readFileSync7, readdirSync as readdirSync5, writeFileSync as writeFileSync5 } from "node:fs";
-import path29 from "node:path";
+import path32 from "node:path";
 var repoRoot3 = assetRoot();
-var templatesDir = () => path29.join(repoRoot3, "templates", "hygiene");
+var templatesDir = () => path32.join(repoRoot3, "templates", "hygiene");
 var packageJson = (root) => {
-  if (!existsSync10(path29.join(root, "package.json")))
+  if (!existsSync10(path32.join(root, "package.json")))
     return null;
   try {
-    return JSON.parse(readFileSync7(path29.join(root, "package.json"), "utf8"));
+    return JSON.parse(readFileSync7(path32.join(root, "package.json"), "utf8"));
   } catch {
     return null;
   }
 };
 var isOpenSource = (root) => {
-  if (existsSync10(path29.join(root, "LICENSE")))
+  if (existsSync10(path32.join(root, "LICENSE")))
     return true;
   const pkg = packageJson(root);
   if (pkg && !pkg.private)
     return true;
-  return path29.basename(root) === "workflow-toolkit";
+  return path32.basename(root) === "workflow-toolkit";
 };
 var licenseHolder = (root) => {
   const pkg = packageJson(root);
@@ -23138,13 +24036,13 @@ var planHygieneFiles = (root, opts = {}) => {
     files.push("LICENSE", "CONTRIBUTING.md");
   const planned = [];
   for (const file of files) {
-    if (existsSync10(path29.join(root, file)))
+    if (existsSync10(path32.join(root, file)))
       continue;
-    const tpl = path29.join(templatesDir(), file);
+    const tpl = path32.join(templatesDir(), file);
     if (!existsSync10(tpl))
       continue;
-    const content = readFileSync7(tpl, "utf8").replace(/<PROJECT>/g, path29.basename(root)).replace(/<YEAR>/g, String(new Date().getFullYear())).replace(/<HOLDER>\s*/g, licenseHolder(root));
-    planned.push({ path: path29.join(root, file), content });
+    const content = readFileSync7(tpl, "utf8").replace(/<PROJECT>/g, path32.basename(root)).replace(/<YEAR>/g, String(new Date().getFullYear())).replace(/<HOLDER>\s*/g, licenseHolder(root));
+    planned.push({ path: path32.join(root, file), content });
   }
   return planned;
 };
@@ -23154,19 +24052,19 @@ var ensureHygieneFiles = (root, opts) => {
   const created = [];
   for (const planned of planHygieneFiles(root, opts)) {
     writeFileSync5(planned.path, planned.content, "utf8");
-    created.push(path29.basename(planned.path));
+    created.push(path32.basename(planned.path));
   }
   return { ok: true, created };
 };
 
 // packages/workit-core/src/core/init.ts
-import fs19 from "node:fs";
-import path31 from "node:path";
+import fs22 from "node:fs";
+import path34 from "node:path";
 import { spawnSync as spawnSync19 } from "node:child_process";
 
 // packages/workit-core/src/core/workspace-branch-policy.ts
 import { mkdirSync as mkdirSync4, readFileSync as readFileSync8, renameSync as renameSync3, rmSync as rmSync2, writeFileSync as writeFileSync6 } from "node:fs";
-import path30 from "node:path";
+import path33 from "node:path";
 import { isDeepStrictEqual } from "node:util";
 var readFileSafe = (p) => {
   try {
@@ -23177,7 +24075,7 @@ var readFileSafe = (p) => {
 };
 function applyWorkspaceBranchPolicy(opts) {
   const { workspace_root, env = process.env } = opts;
-  const dir = path30.join(env.WORKFLOW_TOOLKIT_CONFIG ?? configDir());
+  const dir = path33.join(env.WORKFLOW_TOOLKIT_CONFIG ?? configDir());
   const {
     status,
     path: wsPath,
@@ -23189,7 +24087,7 @@ function applyWorkspaceBranchPolicy(opts) {
   if (status === "malformed" || status === "invalid")
     return { ok: false, error: workspacesError ?? `invalid workspaces.json: ${wsPath}` };
   const detection = detectBranchPolicy(workspace_root);
-  const name = String(env.WORKFLOW_BP_NAME ?? path30.basename(workspace_root));
+  const name = String(env.WORKFLOW_BP_NAME ?? path33.basename(workspace_root));
   const integration = env.WORKFLOW_BP_INTEGRATION ?? detection.integration;
   const policy = {
     preset: detection.preset,
@@ -23238,7 +24136,7 @@ function applyWorkspaceBranchPolicy(opts) {
       ok: false,
       error: `workspaces.json changed while applying the branch policy: ${wsPath}`
     };
-  mkdirSync4(path30.dirname(wsPath), { recursive: true });
+  mkdirSync4(path33.dirname(wsPath), { recursive: true });
   const tmp = `${wsPath}.${process.pid}.tmp`;
   try {
     writeFileSync6(tmp, JSON.stringify({ ...document, workspaces: next }, null, 2) + `
@@ -23271,9 +24169,9 @@ function applyWorkspaceBranchPolicy(opts) {
 
 // packages/workit-core/src/core/init.ts
 var TOKEN_PLACEHOLDER2 = "YOUR_TOKEN_HERE";
-var readJson = (p) => {
+var readJson3 = (p) => {
   try {
-    const parsed = JSON.parse(fs19.readFileSync(p, "utf8"));
+    const parsed = JSON.parse(fs22.readFileSync(p, "utf8"));
     return isConfigObject(parsed) ? parsed : null;
   } catch {
     return null;
@@ -23303,7 +24201,7 @@ var youtrackJsonContent = (dir) => {
   const meetingIssue = process.env.WORKFLOW_YT_MEETING_ISSUE;
   return {
     baseUrl: process.env.WORKFLOW_YT_BASE_URL ?? "https://youtrack.example.com",
-    tokenFile: process.env.WORKFLOW_YT_TOKEN_FILE ?? path31.join(dir, "youtrack.token"),
+    tokenFile: process.env.WORKFLOW_YT_TOKEN_FILE ?? path34.join(dir, "youtrack.token"),
     ...meetingIssue ? {
       meetingIssue,
       meetingIssues: { general: { issue: meetingIssue, label: "General meetings" } }
@@ -23333,19 +24231,19 @@ var vcsJsonContent = () => {
 };
 function initApplyData(action, env = process.env) {
   const dir = String(env.WORKFLOW_TOOLKIT_CONFIG ?? configDir());
-  fs19.mkdirSync(dir, { recursive: true });
+  fs22.mkdirSync(dir, { recursive: true });
   switch (action) {
     case "youtrack_json": {
-      const out = path31.join(dir, "youtrack.json");
-      fs19.writeFileSync(out, JSON.stringify(youtrackJsonContent(dir), null, 2) + `
+      const out = path34.join(dir, "youtrack.json");
+      fs22.writeFileSync(out, JSON.stringify(youtrackJsonContent(dir), null, 2) + `
 `, "utf8");
       return { action, ok: true, path: out };
     }
     case "youtrack_token_placeholder": {
-      const p = path31.join(dir, "youtrack.token");
+      const p = path34.join(dir, "youtrack.token");
       const preserved = writeFileExclusive(p, TOKEN_PLACEHOLDER2 + `
 `, 384) === "preserved";
-      const abs = path31.resolve(p);
+      const abs = path34.resolve(p);
       return {
         action,
         ok: true,
@@ -23357,19 +24255,19 @@ function initApplyData(action, env = process.env) {
       };
     }
     case "youtrack_scaffold": {
-      const jsonOut = path31.join(dir, "youtrack.json");
-      const tokenOut = path31.join(dir, "youtrack.token");
-      fs19.writeFileSync(jsonOut, JSON.stringify(youtrackJsonContent(dir), null, 2) + `
+      const jsonOut = path34.join(dir, "youtrack.json");
+      const tokenOut = path34.join(dir, "youtrack.token");
+      fs22.writeFileSync(jsonOut, JSON.stringify(youtrackJsonContent(dir), null, 2) + `
 `, "utf8");
       const preserved = writeFileExclusive(tokenOut, TOKEN_PLACEHOLDER2 + `
 `, 384) === "preserved";
-      const configPath = path31.resolve(jsonOut);
-      const tokenPath = path31.resolve(tokenOut);
+      const configPath = path34.resolve(jsonOut);
+      const tokenPath = path34.resolve(tokenOut);
       const prev = process.env.WORKFLOW_YOUTRACK_CONFIG;
       process.env.WORKFLOW_YOUTRACK_CONFIG = configPath;
       let tokenCreate = {};
       try {
-        const cfg = readJson(configPath) ?? {};
+        const cfg = readJson3(configPath) ?? {};
         const base = String(cfg.baseUrl ?? "").replace(/\/+$/, "");
         const meeting = String(cfg.meetingIssue ?? "");
         tokenCreate = youTrackTokenCreateUrl().data;
@@ -23416,14 +24314,14 @@ function initApplyData(action, env = process.env) {
       }
     }
     case "vcs_scaffold": {
-      const jsonOut = path31.join(dir, "vcs.json");
-      fs19.writeFileSync(jsonOut, JSON.stringify(vcsJsonContent(), null, 2) + `
+      const jsonOut = path34.join(dir, "vcs.json");
+      fs22.writeFileSync(jsonOut, JSON.stringify(vcsJsonContent(), null, 2) + `
 `, "utf8");
-      const configPath = path31.resolve(jsonOut);
+      const configPath = path34.resolve(jsonOut);
       const prev = process.env.WORKFLOW_VCS_CONFIG;
       process.env.WORKFLOW_VCS_CONFIG = configPath;
       try {
-        const cfg = readJson(configPath) ?? {};
+        const cfg = readJson3(configPath) ?? {};
         const rawProvider = cfg.provider;
         const provider = typeof rawProvider === "string" && rawProvider.trim() ? rawProvider : null;
         return {
@@ -23538,7 +24436,7 @@ var executeInitApply = (args, directory, runtime) => {
       protectedNames: args.branch_policy_protected
     }, current);
     writeConfig(next);
-    return output(ok({ action: "config", path: path32.join(configDir(), "config.json"), ...next }));
+    return output(ok({ action: "config", path: path35.join(configDir(), "config.json"), ...next }));
   }
   const env = Object.fromEntries(Object.entries({
     WORKFLOW_YT_BASE_URL: args.base_url,
@@ -23555,14 +24453,14 @@ var executeInitApply = (args, directory, runtime) => {
 
 // packages/workit-opencode/src/shared/session.ts
 import { realpathSync as realpathSync7 } from "node:fs";
-import path33 from "node:path";
+import path36 from "node:path";
 var sameWorkspace = (expected, observed) => {
   if (typeof observed !== "string" || !observed)
     return false;
   try {
     return realpathSync7(expected) === realpathSync7(observed);
   } catch {
-    return path33.resolve(expected) === path33.resolve(observed);
+    return path36.resolve(expected) === path36.resolve(observed);
   }
 };
 
@@ -23634,7 +24532,7 @@ var workitFamilyOf = (toolName) => {
 
 // packages/workit-opencode/src/tools/context.ts
 import { realpathSync as realpathSync8 } from "node:fs";
-import path34 from "node:path";
+import path37 from "node:path";
 var createContextTool = () => ({
   description: "Read Git, pull request, YouTrack, issue, changelog, release, or affected-file context.",
   execute: async (args, context) => {
@@ -23644,7 +24542,7 @@ var createContextTool = () => ({
     let root;
     try {
       const cwd = parsed.data.cwd;
-      root = realpathSync8(cwd ? path34.resolve(context.directory, cwd) : context.directory);
+      root = realpathSync8(cwd ? path37.resolve(context.directory, cwd) : context.directory);
     } catch {
       return JSON.stringify(failure2("invalid_input", "context target directory cannot be resolved"), null, 2);
     }
@@ -23675,19 +24573,19 @@ var workerCoordinatorFor = (task, worker) => {
 
 // packages/workit-core/src/fanout.ts
 import { createHash as createHash16 } from "node:crypto";
-import fs21 from "node:fs";
-import path37 from "node:path";
+import fs24 from "node:fs";
+import path40 from "node:path";
 
 // packages/workit-core/src/stack.ts
 import { spawnSync as spawnSync21 } from "node:child_process";
 import { createHash as createHash15, randomBytes as randomBytes4 } from "node:crypto";
-import fs20 from "node:fs";
-import path36 from "node:path";
+import fs23 from "node:fs";
+import path39 from "node:path";
 
 // packages/workit-core/src/git/ops.ts
 import { spawnSync as spawnSync20 } from "node:child_process";
 import { existsSync as existsSync11, readFileSync as readFileSync9 } from "node:fs";
-import path35 from "node:path";
+import path38 from "node:path";
 
 // packages/workit-core/src/forge/redact.ts
 var 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_.-]*`;
@@ -23731,18 +24629,18 @@ function operationInProgress(cwd) {
   if (!run.ok)
     return null;
   const found = run.stdout.split(`
-`).map((line) => path35.resolve(cwd, line.trim()));
+`).map((line) => path38.resolve(cwd, line.trim()));
   const conflicted = () => git5(cwd, ["ls-files", "-u"]).stdout.trim() !== "";
   for (const [index, [, operation]] of markers.entries()) {
     const marker = found[index];
     if (!marker || !existsSync11(marker))
       continue;
-    if (index === 1 && existsSync11(path35.join(marker, "applying")))
+    if (index === 1 && existsSync11(path38.join(marker, "applying")))
       return { operation: "am", commitAllowed: false, branch: null };
-    if (index === 0 && existsSync11(path35.join(marker, "amend")) && !conflicted()) {
+    if (index === 0 && existsSync11(path38.join(marker, "amend")) && !conflicted()) {
       let headName = "";
       try {
-        headName = readFileSync9(path35.join(marker, "head-name"), "utf8").trim();
+        headName = readFileSync9(path38.join(marker, "head-name"), "utf8").trim();
       } catch {}
       const branch = headName.startsWith("refs/heads/") ? headName.slice("refs/heads/".length) : null;
       return { operation, commitAllowed: branch !== null, branch };
@@ -23854,7 +24752,7 @@ function rebasingBranch2(dir) {
     if (!found.ok)
       continue;
     try {
-      return fs20.readFileSync(found.stdout.trim(), "utf8").trim();
+      return fs23.readFileSync(found.stdout.trim(), "utf8").trim();
     } catch {}
   }
   return null;
@@ -23862,14 +24760,14 @@ function rebasingBranch2(dir) {
 function rebaseInProgress(dir) {
   for (const name of ["rebase-merge", "rebase-apply"]) {
     const found = gitRun3(dir, ["rev-parse", "--path-format=absolute", "--git-path", name]);
-    if (found.ok && fs20.existsSync(found.stdout.trim()))
+    if (found.ok && fs23.existsSync(found.stdout.trim()))
       return true;
   }
   return false;
 }
 var scratchDir = (cwd) => {
   const dir = stacksDir(cwd);
-  return dir.ok ? path36.join(dir.data, "worktrees") : null;
+  return dir.ok ? path39.join(dir.data, "worktrees") : null;
 };
 function gitRestack(cwd, input) {
   const owner = worktreeOf(cwd, input.branch);
@@ -23878,8 +24776,8 @@ function gitRestack(cwd, input) {
     const scratch = scratchDir(cwd);
     if (!scratch)
       return { ok: false, conflict: false, worktree: cwd, error: "no store root" };
-    fs20.mkdirSync(scratch, { recursive: true });
-    dir = path36.join(scratch, `${input.branch.replace(/[^A-Za-z0-9._-]+/gu, "_").slice(0, 40)}-${randomBytes4(4).toString("hex")}`);
+    fs23.mkdirSync(scratch, { recursive: true });
+    dir = path39.join(scratch, `${input.branch.replace(/[^A-Za-z0-9._-]+/gu, "_").slice(0, 40)}-${randomBytes4(4).toString("hex")}`);
     const added = gitRun3(cwd, ["worktree", "add", "-q", dir, input.branch], GIT_TIMEOUTS.worktree);
     if (!added.ok)
       return { ok: false, conflict: false, worktree: cwd, error: firstLine(added) };
@@ -23923,13 +24821,14 @@ function stacksDir(cwd) {
   const root = storeRoot(cwd);
   if (!root.ok)
     return stackFail(root.code, root.error, root.unblock);
-  return { ok: true, data: path36.join(root.value.root, "stacks") };
+  return { ok: true, data: path39.join(root.value.root, "stacks") };
 }
 var HEARTBEAT_STALE_MS = 2 * 60000;
 
 // packages/workit-core/src/fanout.ts
 var FANOUT_VERSION = 1;
 var TIERS = ["mundane", "standard", "hard"];
+var REASONS = ["explore", "parallel", "backstop", "high-risk-verify"];
 var fanoutFail = (code, error, unblock, data) => ({
   ok: false,
   code,
@@ -23985,7 +24884,7 @@ function normalizePattern(raw) {
     return { error: "has unbalanced or nested braces" };
   return { pattern };
 }
-var isRecord5 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord7 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function findCycle(slices) {
   const byId = new Map(slices.map((slice) => [slice.id, slice]));
   const state = new Map;
@@ -24021,6 +24920,7 @@ function sliceHash(slice) {
     hash: _hash,
     hashSince: _since,
     tier: _tier,
+    reason: _reason,
     timebox: _timebox,
     context: _context,
     issues: _issues,
@@ -24032,10 +24932,10 @@ function fanoutsDir(cwd) {
   const root = storeRoot(cwd);
   if (!root.ok)
     return fanoutFail(root.code, root.error, root.unblock);
-  return { ok: true, data: path37.join(root.value.root, "fanouts") };
+  return { ok: true, data: path40.join(root.value.root, "fanouts") };
 }
 function parseStored(raw) {
-  if (!isRecord5(raw) || typeof raw.name !== "string" || typeof raw.trunk !== "string")
+  if (!isRecord7(raw) || typeof raw.name !== "string" || typeof raw.trunk !== "string")
     return null;
   if (!Array.isArray(raw.slices))
     return null;
@@ -24052,7 +24952,7 @@ function parseStored(raw) {
   });
   const slices = [];
   for (const item of raw.slices) {
-    if (!isRecord5(item) || typeof item.id !== "string" || typeof item.branch !== "string")
+    if (!isRecord7(item) || typeof item.id !== "string" || typeof item.branch !== "string")
       return null;
     slices.push({
       id: item.id,
@@ -24060,6 +24960,7 @@ function parseStored(raw) {
       base: text(item.base) || raw.trunk,
       worktree: text(item.worktree),
       tier: TIERS.includes(item.tier) ? item.tier : "standard",
+      reason: REASONS.includes(item.reason) ? item.reason : null,
       dependsOn: list(item.dependsOn),
       scope: globs(item.scope),
       owns: globs(item.owns),
@@ -24099,10 +25000,10 @@ function readFanout(cwd, name) {
   const dir = fanoutsDir(cwd);
   if (!dir.ok)
     return dir;
-  const file = path37.join(dir.data, stackFileName(name));
+  const file = path40.join(dir.data, stackFileName(name));
   let parsed = null;
   try {
-    parsed = parseStored(JSON.parse(fs21.readFileSync(file, "utf8")));
+    parsed = parseStored(JSON.parse(fs24.readFileSync(file, "utf8")));
   } catch (error) {
     if (error.code === "ENOENT")
       return { ok: true, data: null };
@@ -24116,7 +25017,7 @@ function listFanouts(cwd) {
     return dir;
   let names = [];
   try {
-    names = fs21.readdirSync(dir.data).filter((entry) => entry.endsWith(".json"));
+    names = fs24.readdirSync(dir.data).filter((entry) => entry.endsWith(".json"));
   } catch {
     return { ok: true, data: [] };
   }
@@ -24124,7 +25025,7 @@ function listFanouts(cwd) {
   for (const entry of names) {
     let parsed = null;
     try {
-      parsed = parseStored(JSON.parse(fs21.readFileSync(path37.join(dir.data, entry), "utf8")));
+      parsed = parseStored(JSON.parse(fs24.readFileSync(path40.join(dir.data, entry), "utf8")));
     } catch {
       parsed = null;
     }
@@ -24233,13 +25134,56 @@ var createV2Lifecycle = (deps) => {
   const unboundLaunch = (coordinator) => {
     const store = new TaskStore(root);
     const current = currentTaskId(store);
-    const base = current === null ? 'recovery_required: this branch has no Workit task yet; start it (workit_task start, or `workit task start "<objective>"`), then assign a worker on it with workit_worker before launching a native task' : "recovery_required: no assigned Workit worker is attributable to this coordinator on the current branch's task; assign one with workit_worker before launching a native task";
+    const base = current === null ? 'recovery_required: this branch has no Workit task yet; start it (workit_task start, or `workit task start "<objective>"`), then assign a worker on it with workit_worker before launching a native task' : "recovery_required: no assigned Workit worker is attributable to this coordinator on the current branch's task (worker assignments are branch-scoped: they follow the task of the branch checked out when the launch happens); assign one with workit_worker on this branch's task before launching a native task";
     const listed = store.listTasks();
     if (!listed.ok)
       return base;
     const stale = listed.data.flatMap((task) => task.status === "active" && task.id !== current ? task.workers.filter((worker) => (worker.data.state === "assigned" || worker.data.state === "running") && worker.provenance.session?.kind === "host" && worker.provenance.session.handle === coordinator).map((worker) => `workit_worker {"action":"cancel","taskId":"${task.id}","workerId":"${worker.id}","reason":"stale worker from another branch"}`) : []);
     return stale.length > 0 ? `${base}. Workers of this coordinator are still open on other tasks; cancel any that are stale: ${stale.join("; ")}` : base;
   };
+  const rebindStaleWorker = (coordinator, current, stale) => {
+    if (stale.length !== 1)
+      return false;
+    const { task: from, entry } = stale[0];
+    const store = new TaskStore(root);
+    const target = store.readTask(current);
+    if (!target.ok || target.data.status !== "active")
+      return false;
+    const core = new WorkitCore(store, {
+      root,
+      caller: { host: "opencode", actor: coordinator },
+      capabilities: [],
+      constraints: [],
+      now
+    });
+    const assigned = core.worker({
+      schemaVersion: 1,
+      action: "assign",
+      taskId: current,
+      assignment: entry.data.assignment
+    });
+    if (!assigned.ok)
+      return false;
+    const cancelled = core.worker({
+      schemaVersion: 1,
+      action: "cancel",
+      taskId: from.id,
+      workerId: entry.id,
+      reason: `rebound to task ${current} (worker ${assigned.data.id}) after a branch switch`
+    });
+    const latest = store.readTask(current);
+    if (cancelled.ok && latest.ok)
+      core.task({
+        schemaVersion: 1,
+        action: "progress",
+        taskId: current,
+        progress: {
+          ...latest.data.progress,
+          summary: `${latest.data.progress.summary} (worker ${assigned.data.id} rebound from task ${from.id} after a branch switch)`
+        }
+      });
+    return cancelled.ok;
+  };
   const prepareDispatch = (coordinator, callID) => {
     if (dispatches.has(coordinator))
       return "unsettled";
@@ -24253,7 +25197,16 @@ var createV2Lifecycle = (deps) => {
       return "unmanaged";
     const eligible = managed.flatMap((task) => task.workers.filter((entry) => entry.data.state === "assigned" && entry.data.session === null && entry.provenance.session?.kind === "host" && entry.provenance.session.host === "opencode" && entry.provenance.session.handle === coordinator).map((entry) => ({ task, entry })));
     const current = currentTaskId(store);
-    const next = oldest(eligible.filter((item) => item.task.id === current));
+    let next = oldest(eligible.filter((item) => item.task.id === current));
+    if (!next && current !== null) {
+      const stale = eligible.filter((item) => item.task.id !== current);
+      if (rebindStaleWorker(coordinator, current, stale)) {
+        const refreshed = store.readTask(current);
+        const rebound = refreshed.ok ? refreshed.data.workers.filter((entry) => entry.data.state === "assigned" && entry.data.session === null && entry.provenance.session?.kind === "host" && entry.provenance.session.handle === coordinator) : [];
+        if (refreshed.ok && rebound.length > 0)
+          next = oldest(rebound.map((entry) => ({ task: refreshed.data, entry })));
+      }
+    }
     if (!next)
       return "unbound";
     dispatches.set(coordinator, {
@@ -24703,6 +25656,11 @@ var evaluateShellPermission = (root, event, workdirs = new Map) => {
     const gated = shellGate(cwd, resource, owner);
     if (gated.kind === "deny")
       return deny(gated.reason);
+    if (event.effect === "allow") {
+      const plan = heavyGate(cwd, resource, { host: "opencode" });
+      if (plan.kind === "split")
+        return deny(plan.reason);
+    }
   }
 };
 
@@ -24726,7 +25684,7 @@ var childTaskMissing = (store, input) => {
 var childDenial = (identity) => `OpenCode child session has no validated Workit worker: as ${identity} it may only inspect the task summary (workit_task action "inspect") or record evidence or findings (workit_evidence/workit_finding action "record") on an existing task; for anything else the lead assigns it a worker with workit_worker before launching it`;
 
 // packages/workit-opencode/src/v2/shell.ts
-import path38 from "node:path";
+import path41 from "node:path";
 var commandOf = (input) => {
   if (input === null || typeof input !== "object")
     return null;
@@ -24735,12 +25693,28 @@ var commandOf = (input) => {
 };
 var hookInput = (root, sessionID, id, shell) => ({
   host: "opencode",
-  cwd: shell.workdir ? path38.resolve(root, shell.workdir) : root,
+  cwd: shell.workdir ? path41.resolve(root, shell.workdir) : root,
   session: { id: sessionID, agentId: null, agentType: null, parentId: null },
   permissionMode: null,
   transcriptPath: null,
   event: { kind: "shell.pre", command: shell.command, toolUseId: id }
 });
+var leaseRewrite2 = (input) => {
+  if (input.event.kind !== "shell.pre")
+    return null;
+  const { command } = input.event;
+  const plan = heavyGate(input.cwd, command, { host: "opencode" });
+  if (plan.kind !== "rewrite")
+    return null;
+  if (shellPolicy(input.cwd, command, "posix").kind === "deny")
+    return null;
+  if (rawGitPre(input, command, { nudge: false }).kind === "deny")
+    return null;
+  const owner = liveOwner({ host: "opencode", session: { id: input.session.id, parentId: null } }, "in-process-plugin");
+  if (shellGate(input.cwd, command, owner).kind === "deny")
+    return null;
+  return plan.command;
+};
 var observeShellBefore = (root, event, workdirs) => {
   try {
     if (event.tool !== "shell")
@@ -24749,6 +25723,12 @@ var observeShellBefore = (root, event, workdirs) => {
     if (!shell)
       return;
     const sessionID = String(event.sessionID);
+    const original = hookInput(root, sessionID, String(event.id), shell);
+    const heavy = leaseRewrite2(original);
+    if (heavy) {
+      event.input.command = heavy;
+      shell.command = heavy;
+    }
     const input = hookInput(root, sessionID, String(event.id), shell);
     workdirs.set(sessionID, input.cwd);
     if (workdirs.size > 256)
@@ -24920,37 +25900,37 @@ var createStopControl = (root, port) => {
 
 // packages/workit-opencode/src/v2/registry.ts
 import { existsSync as existsSync13, readFileSync as readFileSync10 } from "node:fs";
-import path40 from "node:path";
+import path43 from "node:path";
 
 // packages/workit-opencode/src/shared/assets.ts
 import { existsSync as existsSync12, realpathSync as realpathSync9 } from "node:fs";
-import path39 from "node:path";
+import path42 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 var moduleDir = () => {
   try {
-    return realpathSync9(path39.dirname(fileURLToPath2(import.meta.url)));
+    return realpathSync9(path42.dirname(fileURLToPath2(import.meta.url)));
   } catch {
-    return path39.dirname(fileURLToPath2(import.meta.url));
+    return path42.dirname(fileURLToPath2(import.meta.url));
   }
 };
 var packageRoot2 = () => {
   const dir = moduleDir();
   for (const candidate of [
-    path39.resolve(dir, ".."),
-    path39.resolve(dir, "..", ".."),
-    path39.resolve(dir, "..", "..", "..")
+    path42.resolve(dir, ".."),
+    path42.resolve(dir, "..", ".."),
+    path42.resolve(dir, "..", "..", "..")
   ]) {
-    if (existsSync12(path39.join(candidate, "package.json")))
+    if (existsSync12(path42.join(candidate, "package.json")))
       return candidate;
   }
-  return path39.resolve(dir, "..");
+  return path42.resolve(dir, "..");
 };
 var skillsRoot = () => {
   const root = packageRoot2();
-  const canonical = path39.resolve(root, "..", "workit-core", "skills");
-  if (existsSync12(path39.join(root, "src")) && existsSync12(canonical))
+  const canonical = path42.resolve(root, "..", "workit-core", "skills");
+  if (existsSync12(path42.join(root, "src")) && existsSync12(canonical))
     return canonical;
-  return path39.join(root, "assets", "skills");
+  return path42.join(root, "assets", "skills");
 };
 
 // packages/workit-opencode/src/v2/registry.ts
@@ -24977,11 +25957,11 @@ var registerSkills = async (ctx) => {
   if (!existsSync13(skillsDir))
     return new Set;
   const listed = await ctx.skill.list().catch(() => ({ data: [] }));
-  const own = (skill) => typeof skill.path === "string" && path40.resolve(skill.path).startsWith(skillsDir + path40.sep);
+  const own = (skill) => typeof skill.path === "string" && path43.resolve(skill.path).startsWith(skillsDir + path43.sep);
   const userSkills = new Set((listed?.data ?? []).filter((skill) => !own(skill)).map((skill) => skill.id));
   const packaged = new Map;
   for (const id of WORKIT_METHOD_SKILLS) {
-    const file = path40.join(skillsDir, id, "SKILL.md");
+    const file = path43.join(skillsDir, id, "SKILL.md");
     if (!userSkills.has(id) && existsSync13(file))
       packaged.set(id, file);
   }
@@ -25029,22 +26009,22 @@ var registerCommands = async (ctx, registeredSkills) => {
 
 // packages/workit-opencode/src/stale-sources.ts
 import { existsSync as existsSync14, readdirSync as readdirSync6 } from "node:fs";
-import path41 from "node:path";
+import path44 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 var typescriptFiles = (directory) => {
   if (!existsSync14(directory))
     return [];
   return readdirSync6(directory, { withFileTypes: true }).flatMap((entry) => {
-    const file = path41.join(directory, entry.name);
+    const file = path44.join(directory, entry.name);
     return entry.isDirectory() ? typescriptFiles(file) : entry.isFile() && file.endsWith(".ts") ? [file] : [];
   });
 };
 var pluginSourceFiles = [
   ...new Set([
     fileURLToPath3(import.meta.url),
-    ...typescriptFiles(path41.join(packageRoot2(), "src")),
-    path41.join(packageRoot2(), "..", "workit-core", "src", "core.ts"),
-    ...typescriptFiles(path41.join(packageRoot2(), "..", "workit-core", "src", "core"))
+    ...typescriptFiles(path44.join(packageRoot2(), "src")),
+    path44.join(packageRoot2(), "..", "workit-core", "src", "core.ts"),
+    ...typescriptFiles(path44.join(packageRoot2(), "..", "workit-core", "src", "core"))
   ])
 ].filter((file) => existsSync14(file)).toSorted();
 
@@ -25161,8 +26141,11 @@ var setup = async (ctx) => {
   const pendingShells = new Map;
   await ctx.tool.hook("execute.before", async (event) => {
     if (event.tool === "shell") {
-      noteShellCall(pendingShells, { sessionID: String(event.sessionID), input: event.input });
-      return observeShellBefore(root, event, shellWorkdirs);
+      observeShellBefore(root, event, shellWorkdirs);
+      return noteShellCall(pendingShells, {
+        sessionID: String(event.sessionID),
+        input: event.input
+      });
     }
     if (event.tool === "skill")
       return observeSkillLoad(root, event);