@brainervirus/workit-codex 8.12.2 → 8.13.0

package/dist/{workit-hook-n81rx47z.js → workit-hook-sc45d7h1.js}

@@ -79,11 +79,11 @@ what and whether, the CLI does how and records what it observed.
 Native host allow/ask/deny, sandbox and org rules stay authoritative. Never
 switch paths to evade a denial, never claim enforcement a host cannot provide,
 and never fabricate an approval or verdict. A question answer is not
-host permission, and imported decisions or handoffs never grant authority.
+host permission, and imported decisions or handoffs grant no authority.
 
 Autonomy contract:
 - Continue to the requested endpoint (commit, push, PR, green CI, verified,
-  merged) without asking "continue?", running checks and repairs on the way.
+  merged) without asking "continue?", running checks and repairs.
   Stop only for a new consequential choice, a host denial, a conflicting edit
   or an unresolved blocker; report open gaps and uncertain workers.
 - No endpoint named: stop at a local commit on a policy-compliant branch and
@@ -93,7 +93,8 @@ Autonomy contract:
   never merging; \`merged\` also lands it with \`workit pr merge\`.
   Merge and release need a workspace grant only the user raises from their
   own terminal (a blocked verb names how); never edit workspaces.json or route
-  around a grant_required.
+  around grant_required. Release: \`workit release start <v>\`, commits,
+  \`finish\`; \`publish\` if asked.
 - Ask only for a product or preference choice, or for authority you lack, with
   your recommended answer. Facts are yours: read, run or prototype.
 - Label claims measured (run and seen this session), inferred, or guess.
@@ -108,22 +109,22 @@ Autonomy contract:
   reconcile every requested item and observe it (\`workit verify-delivery\`).
 
 CLI first: if a step has one right answer, use the \`workit\` verb instead of
-hand-running git, gh or glab (\`workit git|pr|ci|check\`; \`workit help\` lists
-the rest; lacking \`workit\`, \`npx -y @brainervirus/workit-cli\`).
+hand-running git, gh or glab (\`workit git|pr|ci|check|help\`;
+else \`npx -y @brainervirus/workit-cli\`).
 Add Co-Authored-By via \`workit git commit --trailer "K: v" -- <paths>\`, never
 an amend.
 The task families (task, policy, evidence, finding, decision, worker, state)
 are optional continuity for tracked work; each branch has one implicit task,
-and a solo edit needs no task. A decision
-records a user choice; it never authorizes an effect. Judge work once with
+and a solo edit needs no task. A decision records a user choice; it never
+authorizes an effect. Judge work once with
 \`workit policy assess --judge risk= behavior= product-choice= plan=\`.
-Across repositories, bind each item to its checkout, branch and endpoint,
-resolve competing targets before a mutation, and reconcile an uncertain
-external effect before retrying it.
+Across repositories, bind items to checkout, branch and endpoint, resolve
+competing targets before a mutation, and reconcile an uncertain
+external effect before a retry.
 
 Mid-task: never silently drop or resume an objective (workit-continue).
 
-Skills: load the skill, never act from memory of it (slash aliases /wk-<name>).
+Skills: load the skill, never act from memory (aliases /wk-<name>).
 - brainstorm, plan, spec, grill, should we: workit-shape
 - implement, build, add a feature: workit-implement
 - review, blast radius: workit-review
@@ -12524,6 +12525,15 @@ var repoBranchPreset = (workspaceRoot) => {
   const detected = detectBranchPolicy(workspaceRoot);
   return detected.developBranch || detected.allowed.length ? detected.preset : null;
 };
+var releaseTagPrefixOf = (workspaceRoot, policyPrefix) => {
+  if (typeof policyPrefix === "string")
+    return policyPrefix.trim();
+  const r = spawnSync5("git", ["config", "--get", "gitflow.prefix.versiontag"], {
+    cwd: workspaceRoot,
+    encoding: "utf8"
+  });
+  return r.status === 0 ? (r.stdout ?? "").trim() : "v";
+};
 
 // packages/workit-core/src/core/workspaces.ts
 var nonBlank = string2().refine((value) => value.trim().length > 0, "must not be blank");
@@ -18033,7 +18043,76 @@ var writeSessionMarker = (file, marker) => {
 };
 
 // packages/workit-core/src/hooks/shell-words.ts
-var closingQuote = (command, start, dialect) => {
+class ShellAnalysisError extends Error {
+}
+var MAX_NESTING = 64;
+var OPEN = "";
+var COMMA = "";
+var CLOSE = "";
+var MARKERS = /[\uE000-\uE002]/u;
+var literal2 = (word) => word.replaceAll(OPEN, "{").replaceAll(COMMA, ",").replaceAll(CLOSE, "}");
+var BRACE_LIMIT = 64;
+var BRACE_PENDING = 512;
+var BRACE_DEPTH = 16;
+var braceGroup = (word) => {
+  for (let start = 0;start < word.length; start++) {
+    if (word[start] !== OPEN)
+      continue;
+    let depth = 0;
+    let end = start;
+    const commas = [];
+    for (;end < word.length; end++) {
+      if (word[end] === OPEN)
+        depth++;
+      else if (word[end] === CLOSE && --depth === 0)
+        break;
+      else if (word[end] === COMMA && depth === 1)
+        commas.push(end);
+    }
+    if (end < word.length && commas.length)
+      return { start, end, commas };
+  }
+  return null;
+};
+var expandBraces = (word) => {
+  let depth = 0;
+  for (const char of word) {
+    if (char === OPEN && ++depth > BRACE_DEPTH)
+      return [literal2(word)];
+    if (char === CLOSE && depth > 0)
+      depth--;
+  }
+  const done = new Set;
+  const queue = [word];
+  const queued = new Set(queue);
+  for (let at = 0;at < queue.length; at++) {
+    const current = queue[at];
+    const group = braceGroup(current);
+    if (!group) {
+      const text = literal2(current);
+      if (text)
+        done.add(text);
+      if (done.size > BRACE_LIMIT)
+        return [literal2(word)];
+      continue;
+    }
+    const pre = current.slice(0, group.start);
+    const post = current.slice(group.end + 1);
+    let from = group.start + 1;
+    for (const comma of [...group.commas, group.end]) {
+      const next = pre + current.slice(from, comma) + post;
+      from = comma + 1;
+      if (queued.has(next))
+        continue;
+      queued.add(next);
+      queue.push(next);
+    }
+    if (queue.length - at > BRACE_PENDING)
+      return [literal2(word)];
+  }
+  return [...done];
+};
+var closingQuote = (command, start, dialect, nesting = 0) => {
   const quote = command[start];
   for (let index = start + 1;index < command.length; index++) {
     const char = command[index];
@@ -18050,51 +18129,265 @@ var closingQuote = (command, start, dialect) => {
       index++;
       continue;
     }
+    if (dialect === "posix" && char === "$" && command[index + 1] === "(") {
+      index = substitutionEnd(command, index + 1, nesting + 1);
+      continue;
+    }
+    if (dialect === "posix" && char === "`") {
+      index = backtickEnd(command, index);
+      continue;
+    }
     if (char === '"')
       return index;
   }
   return -1;
 };
+var backtickEnd = (command, start) => {
+  for (let index = start + 1;index < command.length; index++) {
+    if (command[index] === "\\")
+      index++;
+    else if (command[index] === "`")
+      return index;
+  }
+  return command.length;
+};
+var heredocDelimiter = (command, start) => {
+  let index = start;
+  if (command[index] === "-")
+    index++;
+  while (command[index] === " " || command[index] === "\t")
+    index++;
+  let delimiter = "";
+  for (;index < command.length && !/[\s;&|<>()]/.test(command[index]); index++) {
+    const char = command[index];
+    if (char === "'" || char === '"') {
+      const end = command.indexOf(char, index + 1);
+      if (end < 0)
+        break;
+      delimiter += command.slice(index + 1, end);
+      index = end;
+    } else if (char === "\\")
+      delimiter += command[++index] ?? "";
+    else
+      delimiter += char;
+  }
+  return { delimiter, end: index - 1 };
+};
+var skipHeredocs = (command, newline, delimiters) => {
+  let index = newline;
+  while (delimiters.length) {
+    const delimiter = delimiters.shift();
+    for (;; ) {
+      const lineEnd = command.indexOf(`
+`, index + 1);
+      const line = command.slice(index + 1, lineEnd < 0 ? undefined : lineEnd);
+      index = lineEnd < 0 ? command.length : lineEnd;
+      if (line.trim() === delimiter || lineEnd < 0)
+        break;
+    }
+  }
+  return index;
+};
+var substitutionEnd = (command, start, nesting = 0) => {
+  if (nesting > MAX_NESTING)
+    throw new ShellAnalysisError("substitutions nest too deep");
+  let depth = 0;
+  let wordStart = true;
+  const heredocs = [];
+  for (let index = start;index < command.length; index++) {
+    const char = command[index];
+    const atWordStart = wordStart;
+    wordStart = /[\s;&|()]/.test(char);
+    if (char === "\\")
+      index++;
+    else if (char === `
+` && heredocs.length) {
+      index = skipHeredocs(command, index, heredocs);
+      wordStart = true;
+    } else if (char === "'" || char === '"') {
+      const end = closingQuote(command, index, "posix", nesting);
+      if (end < 0)
+        return command.length;
+      index = end;
+    } else if (char === "`")
+      index = backtickEnd(command, index);
+    else if (char === "#" && atWordStart) {
+      const newline = command.indexOf(`
+`, index);
+      index = newline < 0 ? command.length : newline - 1;
+    } else if (char === "<" && command[index + 1] === "<" && command[index + 2] !== "<") {
+      const { delimiter, end } = heredocDelimiter(command, index + 2);
+      if (delimiter)
+        heredocs.push(delimiter);
+      index = end;
+    } else if (char === "<" && command[index + 1] === "<")
+      index += 2;
+    else if (char === "$" && command[index + 1] === "(")
+      index = substitutionEnd(command, index + 1, nesting + 1);
+    else if (char === "(")
+      depth++;
+    else if (char === ")" && --depth === 0)
+      return index;
+  }
+  return command.length;
+};
 var unquote = (body, quote, dialect) => {
   if (quote === "'")
     return dialect === "powershell" ? body.replaceAll("''", "'") : body;
-  return dialect === "posix" ? body.replace(/\\(["\\$`])/g, "$1") : body.replace(/`(.)/g, "$1");
+  return dialect === "posix" ? body.replace(/\\\n/g, "").replace(/\\(["\\$`])/g, "$1") : body.replace(/`(.)/g, "$1");
+};
+var C_ESCAPES = {
+  n: `
+`,
+  t: "\t",
+  r: "\r",
+  a: "\x07",
+  b: "\b",
+  e: "\x1B",
+  E: "\x1B",
+  f: "\f",
+  v: "\v"
+};
+var ansiC = (command, start) => {
+  let text = "";
+  let index = start + 1;
+  for (;index < command.length && command[index] !== "'"; index++) {
+    const char = command[index];
+    if (char !== "\\" || index + 1 >= command.length) {
+      text += char;
+      continue;
+    }
+    const rest = command.slice(++index);
+    const hex = /^x([0-9a-fA-F]{1,2})/.exec(rest);
+    const octal = /^[0-7]{1,3}/.exec(rest);
+    if (hex) {
+      text += String.fromCharCode(Number.parseInt(hex[1], 16));
+      index += hex[0].length - 1;
+    } else if (octal) {
+      text += String.fromCharCode(Number.parseInt(octal[0], 8));
+      index += octal[0].length - 1;
+    } else
+      text += C_ESCAPES[rest[0]] ?? rest[0];
+  }
+  return { text, end: index };
+};
+var substitutions = (body) => {
+  const found = [];
+  for (let index = 0;index < body.length; index++) {
+    const char = body[index];
+    if (char === "\\")
+      index++;
+    else if (char === "`") {
+      const end = backtickEnd(body, index);
+      found.push(body.slice(index + 1, end).replace(/\\(.)/g, "$1"));
+      index = end;
+    } else if (char === "$" && body[index + 1] === "(") {
+      const end = substitutionEnd(body, index + 1);
+      found.push(body.slice(index + 2, end));
+      index = end;
+    }
+  }
+  return found;
+};
+var PLAIN_POSIX = /[^\s'"\\`$(){},<>|;&#]+/uy;
+var PLAIN_POWERSHELL = /[^\s'"`(){}<>|;&#]+/uy;
+var arithmeticEnd = (command, start) => {
+  const end = substitutionEnd(command, start);
+  return command[end - 1] === ")" && end > start + 2 ? end : 0;
 };
 var segmentsOf = (command, dialect = "posix") => {
+  try {
+    return tokenize(command, dialect);
+  } catch (error) {
+    const why = error instanceof ShellAnalysisError ? error.message : String(error);
+    return [{ words: [], redirects: [], unanalyzable: why }];
+  }
+};
+var tokenize = (command, dialect) => {
+  const posix = dialect === "posix";
   const segments = [];
   let current = { words: [], redirects: [] };
   let word = "";
   let inWord = false;
   let pending = null;
   const heredocs = [];
-  const escape = dialect === "posix" ? "\\" : "`";
+  const escape = posix ? "\\" : "`";
   const flushWord = () => {
     if (!inWord)
       return;
+    const text = MARKERS.test(word) ? literal2(word) : word;
     if (pending === "redirect") {
-      if (!word.startsWith("&"))
-        current.redirects.push(word);
+      if (!text.startsWith("&"))
+        current.redirects.push(text);
     } else if (pending === "heredoc")
-      heredocs.push(word.replace(/^-/, ""));
+      heredocs.push({ delimiter: text.replace(/^-/, ""), owner: current });
+    else if (pending === "herestring")
+      (current.stdin ??= []).push(text);
     else if (pending !== "input")
-      current.words.push(word);
+      current.words.push(...MARKERS.test(word) ? expandBraces(word) : [word]);
     pending = null;
     word = "";
     inWord = false;
   };
   const flushSegment = () => {
     flushWord();
-    if (current.words.length || current.redirects.length)
+    if (current.words.length || current.redirects.length || current.stdin || current.subs)
       segments.push(current);
     current = { words: [], redirects: [] };
   };
+  const group = (kind) => {
+    flushSegment();
+    pending = null;
+    segments.push({ words: [], redirects: [], group: kind });
+  };
+  const substitution = (inner, text) => {
+    (current.subs ??= []).push(inner);
+    word += text;
+    inWord = true;
+  };
+  const plain = posix ? PLAIN_POSIX : PLAIN_POWERSHELL;
   for (let index = 0;index < command.length; index++) {
+    plain.lastIndex = index;
+    const run = plain.exec(command);
+    if (run) {
+      word += run[0];
+      inWord = true;
+      index += run[0].length - 1;
+      continue;
+    }
     const char = command[index];
-    if (char === "'" || char === '"') {
+    const next = command[index + 1];
+    if (char === escape && (next === `
+` || next === "\r" && command[index + 2] === `
+`))
+      index += next === "\r" ? 2 : 1;
+    else if (char === "#" && !inWord) {
+      const newline = command.indexOf(`
+`, index);
+      index = (newline < 0 ? command.length : newline) - 1;
+    } else if (!posix && char === "<" && next === "#") {
+      const end = command.indexOf("#>", index + 2);
+      index = end < 0 ? command.length : end + 1;
+    } else if (posix && char === "$" && next === "'") {
+      const { text, end } = ansiC(command, index + 1);
+      word += text;
+      inWord = true;
+      index = end;
+    } else if (posix && char === "$" && next === '"')
+      continue;
+    else if (char === "'" || char === '"') {
       const end = closingQuote(command, index, dialect);
-      word += unquote(command.slice(index + 1, end < 0 ? undefined : end), char, dialect);
+      const body = command.slice(index + 1, end < 0 ? undefined : end);
+      if (posix && char === '"' && /\$\(|`/.test(body))
+        (current.subs ??= []).push(...substitutions(body));
+      word += unquote(body, char, dialect);
       inWord = true;
       index = end < 0 ? command.length : end;
+    } else if (posix && char === "`") {
+      const end = backtickEnd(command, index);
+      const inner = command.slice(index + 1, end);
+      substitution(inner.replace(/\\(.)/g, "$1"), `\`${inner}\``);
+      index = end;
     } else if (char === escape && index + 1 < command.length) {
       word += command[++index];
       inWord = true;
@@ -18102,26 +18395,56 @@ var segmentsOf = (command, dialect = "posix") => {
 `) {
       flushSegment();
       while (heredocs.length) {
-        const delimiter = heredocs.shift();
+        const { delimiter, owner } = heredocs.shift();
         const lines = command.slice(index + 1).split(`
 `);
         const at = lines.findIndex((line) => line.trim() === delimiter);
-        const skipped = (at < 0 ? lines : lines.slice(0, at + 1)).join(`
+        (owner.stdin ??= []).push((at < 0 ? lines : lines.slice(0, at)).join(`
+`));
+        index += (at < 0 ? lines : lines.slice(0, at + 1)).join(`
 `).length + 1;
-        index += skipped;
       }
     } else if (/\s/.test(char))
       flushWord();
-    else if (char === "(" || char === ")") {
+    else if (posix && char === "(" && inWord && word.endsWith("$")) {
+      const end = substitutionEnd(command, index);
+      const inner = command.slice(index + 1, end);
+      substitution(inner, `(${inner})`);
+      index = end;
+    } else if (posix && char === "(" && (pending === "input" || pending === "redirect")) {
+      const sign = pending === "input" ? "<" : ">";
+      pending = null;
+      const end = substitutionEnd(command, index);
+      const inner = command.slice(index + 1, end);
+      substitution(inner, `${sign}(${inner})`);
+      index = end;
+    } else if (posix && char === "(" && next === "(" && !inWord && arithmeticEnd(command, index)) {
+      flushSegment();
+      index = arithmeticEnd(command, index);
+    } else if (char === "(" || char === ")") {
       if (char === "(" && inWord && word.endsWith("$")) {
         word = word.slice(0, -1);
         inWord = word !== "";
       }
+      group(char === "(" ? "open" : "close");
+    } else if (!posix && (char === "{" || char === "}")) {
+      if (char === "{" && inWord && word.endsWith("@")) {
+        word += char;
+        continue;
+      }
       flushSegment();
-      segments.push({ words: [], redirects: [], group: char === "(" ? "open" : "close" });
     } else if (";&|".includes(char)) {
-      if (char === "&" && command[index + 1] === ">")
+      if (char === "&" && next === ">")
         continue;
+      if (char === "|" && next === "|")
+        index++;
+      else if (char === "|") {
+        flushWord();
+        if (current.words.length)
+          current.pipe = true;
+        if (next === "&")
+          index++;
+      }
       flushSegment();
     } else if (char === ">") {
       if (inWord && /^\d$/.test(word)) {
@@ -18137,16 +18460,24 @@ var segmentsOf = (command, dialect = "posix") => {
         inWord = true;
       }
       pending = "redirect";
-    } else if (char === "<" && dialect === "posix") {
+    } else if (char === "<" && posix) {
       flushWord();
-      if (command[index + 1] === "<") {
+      if (next === "<" && command[index + 2] === "<") {
+        index += 2;
+        pending = "herestring";
+      } else if (next === "<") {
         index++;
-        if (command[index + 1] === "<")
-          index++;
         pending = "heredoc";
       } else
         pending = "input";
-    } else {
+    } else if (posix && char === "{" && !word.endsWith("$")) {
+      word += OPEN;
+      inWord = true;
+    } else if (posix && char === "," && word.includes(OPEN))
+      word += COMMA;
+    else if (posix && char === "}" && word.includes(OPEN))
+      word += CLOSE;
+    else {
       word += char;
       inWord = true;
     }
@@ -18157,8 +18488,35 @@ var segmentsOf = (command, dialect = "posix") => {
 
 // packages/workit-core/src/hooks/raw-git.ts
 var NONE2 = { kind: "none" };
-var SHELLS = new Set(["sh", "bash", "zsh", "dash", "ksh"]);
-var PREFIXES2 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "nice", "&"]);
+var SHELLS = new Set(["sh", "bash", "zsh", "dash", "ksh", "ash", "mksh", "yash", "fish"]);
+var POWERSHELLS = new Set(["pwsh", "powershell"]);
+var EVALS = new Set(["eval", "iex", "invoke-expression"]);
+var WRAPPERS = {
+  sudo: { values: "-u -g -h -p -C -D -R -T -r -t -U --user --group --host --prompt --chdir" },
+  doas: { values: "-u -C" },
+  command: { values: "" },
+  builtin: { values: "" },
+  env: { values: "-u -C --unset --chdir" },
+  nohup: { values: "" },
+  setsid: { values: "" },
+  time: { values: "-f -o --format --output" },
+  exec: { values: "-a" },
+  nice: { values: "-n --adjustment" },
+  ionice: { values: "-c -n -p --class --classdata" },
+  stdbuf: { values: "-i -o -e --input --output --error" },
+  chronic: { values: "" },
+  unbuffer: { values: "" },
+  wsl: { values: "-d -u --cd --distribution --user" },
+  timeout: { values: "-s -k --signal --kill-after", operands: 1 },
+  flock: { values: "-w -E --timeout --conflict-exit-code", operands: 1 },
+  coproc: { values: "" },
+  taskset: { values: "", operands: 1 },
+  watch: { values: "-n -d --interval --differences -q --equexit" },
+  "&": { values: "" }
+};
+var WRAPPER_VALUES = new Map(Object.entries(WRAPPERS).map(([name, wrapper]) => [name, new Set(wrapper.values.split(" "))]));
+var KEYWORDS = new Set(["if", "then", "else", "elif", "while", "until", "do", "!", "{"]);
+var DECLARATIONS = new Set(["export", "local", "declare", "readonly", "typeset"]);
 var SCRIPT_FLAG = /^-[a-zA-Z]*c[a-zA-Z]*$/;
 var CD = new Set(["cd", "chdir", "set-location", "sl"]);
 var PUSHD = new Set(["pushd", "push-location"]);
@@ -18172,13 +18530,21 @@ var GIT_VALUE_OPTIONS = new Set([
   "--config-env",
   "--super-prefix"
 ]);
+var GIT_CONFIG_OPTIONS = new Set(["-c", "--config-env", "--git-dir"]);
+var GIT_CONFIG_ENV = /^GIT_(?:CONFIG\w*|DIR|COMMON_DIR|WORK_TREE)$/;
+var ASSIGNMENT = /^([A-Za-z_]\w*)=([\s\S]*)$/;
+var MAX_DEPTH = 4;
+var MAX_EXPANSIONS = 16;
 var isAbsolute = (value) => path20.isAbsolute(value) || /^[A-Za-z]:[\\/]/.test(value) || value.startsWith("\\\\");
-var joinDir = (base, next) => {
+var HERE = /^(?:\$PWD|\$\{PWD\}|\$\(\s*pwd\s*\)|`pwd`|\$\(\s*git\s+rev-parse\s+--show-toplevel\s*\))(?=$|[\\/])/;
+var joinDir = (base, raw) => {
+  const next = raw.replace(HERE, ".");
   if (base === undefined || /[$`*?]/.test(next) || next === "-")
     return;
   const expanded = next === "~" || next.startsWith("~/") ? path20.join(os5.homedir(), next.slice(1)) : next;
   return base === null || isAbsolute(expanded) ? expanded : path20.join(base, expanded);
 };
+var rebase = (base, inner) => inner === null ? base : inner === undefined ? undefined : joinDir(base, inner);
 var cdTarget = (words) => {
   const args = words.slice(1);
   const flag = args.findIndex((word) => /^-(?:literal)?path$/i.test(word));
@@ -18188,88 +18554,433 @@ var cdTarget = (words) => {
 };
 var stripPrefixes = (input) => {
   let words = input;
+  const env = {};
   for (;; ) {
     const first = words[0];
     if (first === undefined)
-      return words;
-    if (/^\w+=/.test(first))
+      return { words, env };
+    const assignment = ASSIGNMENT.exec(first);
+    if (assignment) {
+      if (GIT_CONFIG_ENV.test(assignment[1]))
+        env[assignment[1]] = assignment[2];
       words = words.slice(1);
-    else if (PREFIXES2.has(first)) {
+    } else if (KEYWORDS.has(first))
       words = words.slice(1);
-      while (words[0]?.startsWith("-"))
-        words = words.slice(words[0] === "-u" ? 2 : 1);
-    } else if (first === "timeout") {
+    else if (first === "function")
+      words = words.slice(2);
+    else if (Object.hasOwn(WRAPPERS, commandName(first))) {
+      const name = commandName(first);
+      const values = WRAPPER_VALUES.get(name);
       words = words.slice(1);
-      while (words[0]?.startsWith("-"))
+      const takesValue = (option) => values.has(option) || /^-[a-zA-Z]{2,}$/.test(option) && values.has(`-${option.at(-1)}`);
+      while (words[0]?.startsWith("-") && words[0] !== "--")
+        words = words.slice(takesValue(words[0]) ? 2 : 1);
+      if (words[0] === "--")
         words = words.slice(1);
-      words = words.slice(1);
+      words = words.slice(WRAPPERS[name].operands ?? 0);
     } else
-      return words;
+      return { words, env };
   }
 };
 var commandName = (word) => (word?.split(/[\\/]/).at(-1) ?? "").toLowerCase().replace(/\.exe$/, "");
+var VARIABLE = /\$(?:\{(\w+)\}|(\w+))/g;
+var expandWord = (word, vars) => {
+  if (!word.includes("$"))
+    return [word];
+  let results = [""];
+  let last = 0;
+  for (const match of word.matchAll(VARIABLE)) {
+    const values = vars.get(match[1] ?? match[2]) ?? [match[0]];
+    const before = word.slice(last, match.index);
+    results = results.flatMap((result) => values.map((value) => result + before + value)).slice(0, MAX_EXPANSIONS);
+    last = match.index + match[0].length;
+  }
+  return results.map((result) => result + word.slice(last));
+};
+var substitute = (words, vars) => {
+  if (vars.size === 0)
+    return [words];
+  let lines = [[]];
+  for (const word of words) {
+    const values = expandWord(word, vars);
+    lines = lines.flatMap((line) => values.map((value) => [...line, value])).slice(0, MAX_EXPANSIONS);
+  }
+  return lines;
+};
+var assignments = (words, vars) => {
+  if (words[0] === "for" && words[2] === "in" && /^\w+$/.test(words[1] ?? "")) {
+    const values = words.slice(3).flatMap((word) => expandWord(word, vars));
+    return [[words[1], values.slice(0, MAX_EXPANSIONS)]];
+  }
+  let rest = words;
+  if (DECLARATIONS.has(rest[0] ?? "")) {
+    rest = rest.slice(1);
+    while (rest[0]?.startsWith("-"))
+      rest = rest.slice(1);
+  }
+  if (rest.length === 0 || !rest.every((word) => ASSIGNMENT.test(word)))
+    return null;
+  return rest.map((word) => {
+    const [, name, value] = ASSIGNMENT.exec(word);
+    return [name, expandWord(value, vars)];
+  });
+};
+var literalOutput = (segment) => {
+  if (!segment?.pipe)
+    return;
+  const { words } = stripPrefixes(segment.words);
+  const name = commandName(words[0]);
+  if (name === "echo") {
+    let args = words.slice(1);
+    while (/^-[neE]+$/.test(args[0] ?? ""))
+      args = args.slice(1);
+    return args.join(" ");
+  }
+  if (name === "printf") {
+    const [format = "", ...args] = words.slice(1);
+    return (args.length ? args.join(`
+`) : format).replace(/\\n/g, `
+`);
+  }
+  if (name === "cat" && words.length === 1 && segment.stdin)
+    return segment.stdin.join(`
+`);
+  return;
+};
+var stdinOf = (segment, previous) => segment.stdin ? segment.stdin.join(`
+`) : literalOutput(previous);
+var XARGS_VALUES = new Set(["-n", "-L", "-l", "-P", "-d", "-E", "-e", "-s", "-a", "--arg-file", "--delimiter"].concat([
+  "--max-args",
+  "--max-lines",
+  "--max-procs",
+  "--eof",
+  "--max-chars",
+  "--process-slot-var"
+]));
+var xargsCommands = (words, input) => {
+  let replace = null;
+  let index = 1;
+  for (;index < words.length; index++) {
+    const word = words[index];
+    if (word === "--") {
+      index++;
+      break;
+    }
+    if (!word.startsWith("-"))
+      break;
+    if (word === "-I")
+      replace = words[++index] ?? "{}";
+    else if (word === "--replace" || word === "-i")
+      replace = "{}";
+    else if (word.startsWith("--replace="))
+      replace = word.slice("--replace=".length);
+    else if (/^-[Ii]./.test(word))
+      replace = word.slice(2);
+    else if (XARGS_VALUES.has(word))
+      index++;
+  }
+  const command = words.slice(index);
+  if (command.length === 0)
+    return [];
+  if (input === undefined)
+    return [command];
+  if (replace === null)
+    return [[...command, ...input.split(/\s+/).filter(Boolean)]];
+  const token = replace;
+  return input.split(`
+`).map((line) => line.trim()).filter(Boolean).slice(0, MAX_EXPANSIONS).map((line) => command.map((word) => word.replaceAll(token, line)));
+};
+var findCommands = (words) => {
+  const found = [];
+  for (let index = 1;index < words.length; index++) {
+    if (!/^-(?:exec|execdir|ok|okdir)$/.test(words[index]))
+      continue;
+    const end = words.findIndex((word, at) => at > index && (word === ";" || word === "+"));
+    found.push(words.slice(index + 1, end < 0 ? undefined : end));
+    if (end < 0)
+      break;
+    index = end;
+  }
+  return found;
+};
+var POWERSHELL_VALUES = /^-(?:f|file|ex|executionpolicy|wd|workingdirectory|config|configurationname|o|outputformat|if|inputformat|inp|w|windowstyle|settingsfile|custompipename|psconsolefile)$/;
+var powershellScript = (words, stdin) => {
+  for (let index = 1;index < words.length; index++) {
+    const word = words[index];
+    if (!/^[-/]/.test(word))
+      return null;
+    const flag = word.replace(/^[-/]+/, "").toLowerCase();
+    if (!flag)
+      return null;
+    if (flag === "e" || flag === "ec" || flag.length >= 2 && "encodedcommand".startsWith(flag)) {
+      try {
+        return Buffer.from(words[index + 1] ?? "", "base64").toString("utf16le");
+      } catch {
+        return null;
+      }
+    }
+    if (flag === "cwa" || flag.length >= 8 && "commandwithargs".startsWith(flag))
+      return words[index + 1] ?? null;
+    if ("command".startsWith(flag))
+      return words[index + 1] === "-" ? stdin ?? null : words.slice(index + 1).join(" ");
+    if (POWERSHELL_VALUES.test(`-${flag}`)) {
+      if (flag === "f" || flag === "file")
+        return null;
+      index++;
+    }
+  }
+  return null;
+};
+var cmdScript = (words) => {
+  const at = words.findIndex((word, index) => index > 0 && /^\/[ck]$/i.test(word));
+  if (at > 0)
+    return words.slice(at + 1).join(" ");
+  const attached = words.find((word, index) => index > 0 && /^\/[ck]./i.test(word));
+  return attached ? [attached.slice(2), ...words.slice(words.indexOf(attached) + 1)].join(" ") : null;
+};
+var processSubstitutionText = (word) => {
+  const inner = /^<\(([\s\S]*)\)$/.exec(word ?? "")?.[1];
+  if (inner === undefined)
+    return;
+  const segments = segmentsOf(inner);
+  return segments.length === 1 ? literalOutput({ ...segments[0], pipe: true }) : undefined;
+};
+var shellScript = (words, stdin) => {
+  const flag = words.findIndex((word, index) => index > 0 && SCRIPT_FLAG.test(word));
+  if (flag > 0)
+    return words[flag + 1] === "--" ? words[flag + 2] : words[flag + 1];
+  const operand = words.slice(1).find((word) => !word.startsWith("-"));
+  if (operand !== undefined)
+    return processSubstitutionText(operand);
+  return stdin;
+};
+var scriptCommand = (words) => {
+  for (let index = 1;index < words.length; index++) {
+    const word = words[index];
+    if (word === "--command" || /^-[a-zA-Z]*c$/.test(word))
+      return words[index + 1];
+    if (word.startsWith("--command="))
+      return word.slice("--command=".length);
+  }
+  return;
+};
+var PARALLEL_VALUES = new Set(["-j", "--jobs", "-N", "-n", "-S", "--sshlogin", "-P", "--delay"]);
+var parallelCommands = (words) => {
+  let index = 1;
+  while (index < words.length && words[index].startsWith("-"))
+    index += PARALLEL_VALUES.has(words[index]) ? 2 : 1;
+  const separator = words.indexOf(":::", index);
+  const command = words.slice(index, separator < 0 ? undefined : separator);
+  if (separator < 0)
+    return command.length ? [command] : [];
+  return words.slice(separator + 1).filter((arg) => !arg.startsWith(":::")).slice(0, MAX_EXPANSIONS).map((arg) => command.some((word) => word.includes("{}")) ? command.map((word) => word.replaceAll("{}", arg)) : [...command, arg]);
+};
+var START_PROCESS_VALUES = /^-(?:workingdirectory|wd|redirectstandard\w*|verb|windowstyle|credential|environment)$/i;
+var startProcessCommand = (words) => {
+  let file;
+  let args;
+  const positionals = [];
+  for (let index = 1;index < words.length; index++) {
+    const word = words[index];
+    const flag = word.startsWith("-") ? word.slice(1).toLowerCase() : null;
+    if (flag === null)
+      positionals.push(word);
+    else if (flag && "filepath".startsWith(flag))
+      file = words[++index];
+    else if (flag && (flag === "args" || "argumentlist".startsWith(flag)))
+      args = words[++index];
+    else if (START_PROCESS_VALUES.test(word))
+      index++;
+  }
+  file ??= positionals.shift();
+  args ??= positionals.shift();
+  if (!file)
+    return null;
+  return [file, ...(args ?? "").split(/[\s,]+/).filter(Boolean)];
+};
+var splitString = (line) => {
+  if (commandName(line[0]) !== "env")
+    return null;
+  for (let index = 1;index < line.length; index++) {
+    const word = line[index];
+    if (word === "-S" || word === "--split-string")
+      return line.slice(index + 1).join(" ");
+    if (word.startsWith("--split-string="))
+      return line.slice(index).join(" ").slice(15);
+    if (/^-S./.test(word))
+      return [word.slice(2), ...line.slice(index + 1)].join(" ");
+    if (!word.startsWith("-") && !ASSIGNMENT.test(word))
+      return null;
+  }
+  return null;
+};
+var CONFIG_READS = /^(?:--get\S*|-l|--list|--unset\S*|--remove-section|--rename-section|-e|--edit|--show-\S+|--name-only)$/;
+var configSetBy = (args) => {
+  const positionals = args.filter((arg, index) => index > 0 && !arg.startsWith("-"));
+  if (args[0] === "remote" && (positionals[0] === "add" || positionals[0] === "set-url")) {
+    const [, name, url] = positionals;
+    const key = args.includes("--push") ? "pushurl" : "url";
+    return name && url ? ["-c", `remote.${name}.${key}=${url}`] : [];
+  }
+  if (args[0] !== "config" || args.some((arg) => CONFIG_READS.test(arg)))
+    return [];
+  const [key, value] = positionals[0] === "set" ? positionals.slice(1) : positionals;
+  return key?.includes(".") && value !== undefined && positionals.length <= 3 ? ["-c", `${key}=${value}`] : [];
+};
+var gitInvocation = (words, dir, env = {}, stdin, inherited = []) => {
+  let here = dir;
+  const config = [...inherited];
+  let gitDir = env.GIT_DIR;
+  let index = 0;
+  for (;index < words.length; index++) {
+    const word = words[index];
+    if (word === "-C")
+      here = words[index + 1] ? joinDir(here, words[++index]) : here;
+    else if (GIT_CONFIG_OPTIONS.has(word)) {
+      if (word === "--git-dir")
+        gitDir = words[index + 1];
+      if (words[index + 1] !== undefined)
+        config.push(word, words[++index]);
+    } else if (/^--(?:config-env|git-dir)=/.test(word)) {
+      if (word.startsWith("--git-dir="))
+        gitDir = word.slice("--git-dir=".length);
+      config.push(word);
+    } else if (GIT_VALUE_OPTIONS.has(word))
+      index++;
+    else if (!word.startsWith("-"))
+      break;
+  }
+  if (gitDir)
+    here = joinDir(here, gitDir.replace(/(?:^|[\\/]+)\.git[\\/]*$/, "") || ".");
+  return {
+    tool: "git",
+    dir: here,
+    args: words.slice(index),
+    ...config.length ? { config } : {},
+    ...Object.keys(env).length ? { env } : {},
+    ...stdin === undefined ? {} : { stdin }
+  };
+};
 function rawInvocations(command, dialect = "posix", depth = 0) {
+  if (depth > 0)
+    return walk2(command, dialect, depth);
+  const key = `${dialect}\x00${command}`;
+  const cached = RECENT.get(key);
+  if (cached)
+    return cached;
+  let found;
+  try {
+    found = walk2(command, dialect, depth);
+  } catch (error) {
+    throw error instanceof ShellAnalysisError ? error : new ShellAnalysisError(error instanceof Error ? error.message : String(error));
+  }
+  RECENT.set(key, found);
+  if (RECENT.size > 8)
+    RECENT.delete(RECENT.keys().next().value);
+  return found;
+}
+var RECENT = new Map;
+function walk2(command, dialect, depth) {
   const found = [];
   let dir = null;
   const groups = [];
   let stack = [];
-  for (const segment of segmentsOf(command, dialect)) {
-    if (segment.group === "open") {
-      groups.push({ dir, stack: [...stack] });
-      continue;
-    }
-    if (segment.group === "close") {
-      const saved = groups.pop();
-      if (saved)
-        ({ dir, stack } = saved);
-      continue;
-    }
-    const words = stripPrefixes(segment.words);
+  const vars = new Map;
+  const exported = {};
+  const sessionConfig = [];
+  const nested = (script, inner) => {
+    if (!script || depth >= MAX_DEPTH)
+      return;
+    for (const invocation of rawInvocations(script, inner, depth + 1))
+      found.push({ ...invocation, dir: rebase(dir, invocation.dir) });
+  };
+  const visit = (input, stdin, hops) => {
+    const line = /^\$[\w:]+$/.test(input[0] ?? "") && input[1] === "=" ? input.slice(2) : input;
+    const split = splitString(line);
+    if (split !== null)
+      return nested(split, "posix");
+    const { words, env } = stripPrefixes(line);
     const name = commandName(words[0]);
+    if (!name)
+      return;
+    const runs = (lines) => {
+      if (hops < MAX_DEPTH)
+        for (const next of lines)
+          visit(next, undefined, hops + 1);
+    };
     if (CD.has(name)) {
       const target = cdTarget(words);
       dir = target === null ? os5.homedir() : joinDir(dir, target);
-      continue;
-    }
-    if (PUSHD.has(name)) {
+    } else if (PUSHD.has(name)) {
       const target = cdTarget(words);
       stack.push(dir);
       dir = target === null || target === "-" ? undefined : joinDir(dir, target);
-      continue;
-    }
-    if (POPD.has(name)) {
+    } else if (POPD.has(name))
       dir = stack.length ? stack.pop() : undefined;
-      continue;
+    else if (EVALS.has(name)) {
+      const args = /^-c(?:o(?:m(?:m(?:a(?:n(?:d)?)?)?)?)?)?$/i.test(words[1] ?? "") ? words.slice(2) : words.slice(1);
+      nested(args.join(" "), dialect);
+    } else if (SHELLS.has(name))
+      nested(shellScript(words, stdin), "posix");
+    else if ((name === "source" || name === ".") && dialect === "posix")
+      nested(processSubstitutionText(words[1]), "posix");
+    else if (name === "trap" && dialect === "posix" && !/^-[lp]$/.test(words[1] ?? ""))
+      nested(words[1], "posix");
+    else if (name === "script")
+      nested(scriptCommand(words), "posix");
+    else if (name === "parallel")
+      runs(parallelCommands(words));
+    else if (dialect === "powershell" && /^(?:start-process|saps|start)$/.test(name)) {
+      const started = startProcessCommand(words);
+      if (started)
+        runs([started]);
+    } else if (POWERSHELLS.has(name))
+      nested(powershellScript(words, stdin), "powershell");
+    else if (name === "cmd")
+      nested(cmdScript(words), "powershell");
+    else if (name === "xargs" || name === "find")
+      runs(name === "xargs" ? xargsCommands(words, stdin) : findCommands(words));
+    else if (name === "gh" || name === "glab")
+      found.push({
+        tool: name,
+        dir,
+        args: words.slice(1),
+        ...stdin === undefined ? {} : { stdin }
+      });
+    else if (name === "git") {
+      const invocation = gitInvocation(words.slice(1), dir, { ...exported, ...env }, stdin, sessionConfig);
+      found.push(invocation);
+      sessionConfig.push(...configSetBy(invocation.args));
     }
-    if (SHELLS.has(name) && depth < 3) {
-      const flag = words.findIndex((word, index) => index > 0 && SCRIPT_FLAG.test(word));
-      const script = flag > 0 ? words[flag + 1] : undefined;
-      if (script)
-        for (const inner of rawInvocations(script, "posix", depth + 1))
-          found.push({
-            ...inner,
-            dir: inner.dir === null ? dir : inner.dir === undefined ? undefined : joinDir(dir, inner.dir)
-          });
+  };
+  const segments = segmentsOf(command, dialect);
+  for (const [index, segment] of segments.entries()) {
+    if (segment.group === "open") {
+      groups.push({ dir, stack: [...stack] });
       continue;
     }
-    if (name === "gh" || name === "glab") {
-      found.push({ tool: name, dir, args: words.slice(1) });
+    if (segment.group === "close") {
+      const saved = groups.pop();
+      if (saved)
+        ({ dir, stack } = saved);
       continue;
     }
-    if (name !== "git")
+    if (segment.unanalyzable)
+      throw new ShellAnalysisError(segment.unanalyzable);
+    for (const sub of segment.subs ?? [])
+      nested(sub, "posix");
+    const set = assignments(segment.words, vars);
+    if (set) {
+      for (const [name, values] of set) {
+        vars.set(name, values);
+        if (segment.words[0] === "export" && GIT_CONFIG_ENV.test(name) && values[0] !== undefined)
+          exported[name] = values[0];
+      }
       continue;
-    let here = dir;
-    let index = 1;
-    for (;index < words.length; index++) {
-      const word = words[index];
-      if (word === "-C")
-        here = words[index + 1] ? joinDir(here, words[++index]) : here;
-      else if (GIT_VALUE_OPTIONS.has(word))
-        index++;
-      else if (!word.startsWith("-"))
-        break;
     }
-    found.push({ tool: "git", dir: here, args: words.slice(index) });
+    const stdin = stdinOf(segment, segments[index - 1]);
+    for (const line of substitute(segment.words, vars))
+      visit(line, stdin, 0);
   }
   return found;
 }
@@ -18305,6 +19016,55 @@ function workitInvocations(command, dialect = "posix", depth = 0) {
   return found;
 }
 var PUSH_VALUE_OPTIONS = new Set(["-o", "--push-option", "--receive-pack", "--exec", "--repo"]);
+var CURRENT_BRANCH = /^\$\(\s*git\s+(?:branch\s+--show-current|rev-parse\s+--abbrev-ref\s+HEAD|symbolic-ref\s+--short\s+HEAD)\s*\)$/;
+var pushDestination = (destination) => {
+  if (destination === "HEAD" || destination === "@" || CURRENT_BRANCH.test(destination))
+    return { name: null };
+  if (destination.startsWith("refs/heads/"))
+    return { name: destination.slice(11) };
+  if (destination.startsWith("refs/tags/"))
+    return { name: undefined, tag: destination.slice(10) };
+  if (destination.startsWith("refs/"))
+    return { name: undefined };
+  return { name: destination };
+};
+var pushRefspecs = (specs) => {
+  let force = false;
+  let matching = false;
+  const targets = [];
+  const tags = [];
+  const deleted = [];
+  const globs = [];
+  for (const raw of specs) {
+    if (raw.startsWith("+"))
+      force = true;
+    const spec = raw.replace(/^\+/, "");
+    if (spec.startsWith("^"))
+      continue;
+    if (spec === ":") {
+      matching = true;
+      continue;
+    }
+    const colon = spec.indexOf(":");
+    const source = colon >= 0 ? spec.slice(0, colon) : spec;
+    const destination = colon >= 0 ? spec.slice(colon + 1) : spec;
+    if (!destination)
+      continue;
+    if (destination.includes("*")) {
+      globs.push({ source, destination });
+      continue;
+    }
+    const { name, tag } = pushDestination(destination);
+    if (tag !== undefined)
+      tags.push(tag);
+    if (name === undefined)
+      continue;
+    targets.push(name);
+    if (colon === 0 && name !== null)
+      deleted.push(name);
+  }
+  return { force, matching, targets, tags, deleted, globs };
+};
 var pushAction = (args) => {
   let force = false;
   let lease = false;
@@ -18314,6 +19074,7 @@ var pushAction = (args) => {
   let allBranches = false;
   let mirror = false;
   let remote = null;
+  let dryRun = false;
   const positionals = [];
   for (let index = 1;index < args.length; index++) {
     const arg = args[index];
@@ -18321,9 +19082,11 @@ var pushAction = (args) => {
       positionals.push(...args.slice(index + 1));
       break;
     }
-    if (arg === "--dry-run" || /^-[a-zA-Z]*n[a-zA-Z]*$/.test(arg))
-      return null;
-    if (arg === "--repo")
+    if (/^--dr(?:y(?:-(?:r(?:un?)?)?)?)?$/.test(arg) || /^-[a-zA-Z]*n[a-zA-Z]*$/.test(arg))
+      dryRun = true;
+    else if (/^--no-dr(?:y(?:-(?:r(?:un?)?)?)?)?$/.test(arg))
+      dryRun = false;
+    else if (arg === "--repo")
       remote = args[++index] ?? null;
     else if (arg.startsWith("--repo="))
       remote = arg.slice("--repo=".length);
@@ -18344,41 +19107,28 @@ var pushAction = (args) => {
     else if (!arg.startsWith("-"))
       positionals.push(arg);
   }
+  if (dryRun)
+    return null;
   const specs = remote === null ? positionals.slice(1) : positionals;
   remote ??= positionals[0] ?? null;
-  const targets = [];
-  const tags = [];
-  const deleted = [];
-  for (const raw of specs) {
-    if (raw.startsWith("+"))
-      force = true;
-    const spec = raw.replace(/^\+/, "");
-    const colon = spec.indexOf(":");
-    const destination = colon >= 0 ? spec.slice(colon + 1) : spec;
-    if (!destination)
-      continue;
-    const name = destination === "HEAD" ? null : destination.startsWith("refs/heads/") ? destination.slice(11) : destination.startsWith("refs/") ? undefined : destination;
-    if (destination.startsWith("refs/tags/"))
-      tags.push(destination.slice(10));
-    if (name === undefined)
-      continue;
-    targets.push(name);
-    if (colon === 0 && name !== null)
-      deleted.push(name);
-  }
-  if (specs.length === 0 && !wholesale)
-    targets.push(null);
+  const parsed = pushRefspecs(specs);
+  const implicit = specs.length === 0 && !wholesale;
+  if (implicit)
+    parsed.targets.push(null);
   return {
     kind: "push",
-    targets,
-    blindForce: force && !lease,
+    targets: parsed.targets,
+    blindForce: (force || parsed.force) && !lease,
     remote,
-    ...tags.length ? { tags } : {},
+    ...parsed.tags.length ? { tags: parsed.tags } : {},
     ...allTags ? { allTags: true } : {},
     ...deletes ? { deletes: true } : {},
-    ...deleted.length ? { deleted } : {},
+    ...parsed.deleted.length ? { deleted: parsed.deleted } : {},
     ...allBranches ? { allBranches: true } : {},
-    ...mirror ? { mirror: true } : {}
+    ...mirror ? { mirror: true } : {},
+    ...implicit ? { implicit: true } : {},
+    ...parsed.globs.length ? { globs: parsed.globs } : {},
+    ...parsed.matching ? { matching: true } : {}
   };
 };
 var VALUE_OPTIONS = {
@@ -18424,22 +19174,110 @@ var asksHelp = (invocation) => {
   }
   return false;
 };
+var API_VALUES = new Set(["--method", "--header", "--raw-field", "--field", "--jq", "--template", "--input"].concat([
+  "--hostname",
+  "--preview",
+  "--cache",
+  "--output"
+]));
+var API_SHORT_VALUES = "XHfFqtp";
+var API_FIELDS = new Set(["-f", "-F", "--raw-field", "--field"]);
+var API_MERGE = {
+  gh: /(?:^|\/)(?:pulls\/[^/?#]+\/merge|merges)\/?(?:[?#]|$)/i,
+  glab: /(?:^|\/)merge_requests\/[^/?#]+\/merge\/?(?:[?#]|$)/i
+};
+var GRAPHQL_MERGE = /\b(?:mergePullRequest|enablePullRequestAutoMerge|mergeBranch|mergeRequestAccept)\b/;
+var apiMerges = (tool, args, stdin) => {
+  const request = { method: null, body: false };
+  let endpoint = null;
+  const values = [];
+  const take = (name, value) => {
+    if (name === "-X" || name === "--method")
+      request.method = value.toUpperCase();
+    if (API_FIELDS.has(name) || name === "--input")
+      request.body = true;
+    values.push(value);
+    const fromStdin = name === "--input" ? value === "-" : /^(?:[^=]*=)?@-$/.test(value);
+    if (fromStdin && stdin !== undefined)
+      values.push(stdin);
+  };
+  for (let index = 1;index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--") {
+      endpoint ??= args[index + 1] ?? null;
+      break;
+    }
+    if (arg.startsWith("--")) {
+      const eq = arg.indexOf("=");
+      const name = eq > 0 ? arg.slice(0, eq) : arg;
+      if (API_VALUES.has(name))
+        take(name, eq > 0 ? arg.slice(eq + 1) : args[++index] ?? "");
+    } else if (arg.startsWith("-") && arg.length > 1) {
+      for (let at = 1;at < arg.length; at++) {
+        if (!API_SHORT_VALUES.includes(arg[at]))
+          continue;
+        take(`-${arg[at]}`, at + 1 < arg.length ? arg.slice(at + 1) : args[++index] ?? "");
+        break;
+      }
+    } else
+      endpoint ??= arg;
+  }
+  if (!endpoint)
+    return false;
+  endpoint = endpoint.replace(/(?<!:)\/{2,}/g, "/");
+  if (/(?:^|\/)graphql\/?$/i.test(endpoint))
+    return values.some((value) => GRAPHQL_MERGE.test(value));
+  const verb = request.method ?? (request.body ? "POST" : "GET");
+  return verb !== "GET" && verb !== "HEAD" && API_MERGE[tool].test(endpoint);
+};
+var subtreePush = (args) => {
+  const positionals = [];
+  for (let index = 2;index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "-P" || arg === "--prefix" || arg === "-m" || arg === "--message")
+      index++;
+    else if (!arg.startsWith("-"))
+      positionals.push(arg);
+  }
+  const [remote, branch] = positionals;
+  return remote && branch ? pushAction(["push", remote, `HEAD:refs/heads/${branch}`]) : null;
+};
 function rawAction(invocation) {
   const args = invocation.args;
+  if (invocation.tool !== "git" && args[0] === "api")
+    return apiMerges(invocation.tool, args, invocation.stdin) ? { kind: "merge", forge: invocation.tool, via: "api" } : null;
   if (asksHelp(invocation))
     return null;
-  const [first, second] = args;
+  const [first] = args;
   if (invocation.tool === "git") {
+    const second = args[1];
     if (first === "commit")
       return args.includes("--dry-run") ? null : { kind: "commit", amend: args.includes("--amend") };
     if (first === "push")
       return pushAction(args);
+    if (first === "send-pack")
+      return pushAction([
+        "push",
+        ...args.slice(1).filter((arg) => arg !== "--stdin"),
+        ...args.includes("--stdin") ? (invocation.stdin ?? "").split(/\s+/).filter(Boolean) : []
+      ]);
+    if (first === "subtree" && second === "push")
+      return subtreePush(args);
     return null;
   }
   const forge = invocation.tool;
   const noun = forge === "gh" ? "pr" : "mr";
   if (first !== noun)
     return null;
+  const values = VALUE_OPTIONS[forge];
+  let second;
+  for (let index = 1;index < args.length && second === undefined; index++) {
+    const arg = args[index];
+    if (values.has(arg))
+      index++;
+    else if (!arg.startsWith("-"))
+      second = arg;
+  }
   if (second === "merge")
     return { kind: "merge", forge };
   if (second === "create")
@@ -18471,16 +19309,6 @@ var guardedBranch = (dir, branch) => {
     return false;
   }
 };
-var toPushRemote = (repo, remote) => {
-  if (remote === null)
-    return true;
-  try {
-    const pushRemote = pushRemoteName(repo.dir, repo.branch);
-    return pushRemote === null || pushRemote === remote;
-  } catch {
-    return false;
-  }
-};
 var headSha2 = (repo) => {
   const git = repo.location.git;
   if (!git || git.reftable)
@@ -18502,13 +19330,172 @@ var headSha2 = (repo) => {
     return null;
   }
 };
+var gitConfig = (dir, invocation, cache) => {
+  const key = JSON.stringify([dir, invocation.config ?? [], invocation.env ?? {}]);
+  const cached = cache.get(key);
+  if (cached)
+    return cached;
+  const config = new Map;
+  const listed = spawnSync11("git", [...invocation.config ?? [], "config", "-z", "--list"], {
+    cwd: dir,
+    encoding: "utf8",
+    timeout: 3000,
+    windowsHide: true,
+    env: { ...process.env, ...invocation.env, GIT_TERMINAL_PROMPT: "0", GIT_OPTIONAL_LOCKS: "0" }
+  });
+  for (const entry of (listed.status === 0 ? listed.stdout : "").split("\x00")) {
+    if (!entry)
+      continue;
+    const newline = entry.indexOf(`
+`);
+    const name = newline < 0 ? entry : entry.slice(0, newline);
+    config.set(name, [
+      ...config.get(name) ?? [],
+      newline < 0 ? "true" : entry.slice(newline + 1)
+    ]);
+  }
+  cache.set(key, config);
+  return config;
+};
+var configValue = (config, key) => config.get(key)?.at(-1);
+var GIT_COMMANDS = new Set(("add am annotate apply archive bisect blame branch bugreport bundle cat-file check-attr " + "check-ignore check-mailmap check-ref-format checkout checkout-index cherry cherry-pick " + "citool clean clone column commit commit-graph commit-tree config count-objects credential " + "daemon describe diagnose diff diff-files diff-index diff-tree difftool fast-export " + "fast-import fetch fetch-pack filter-branch fmt-merge-msg for-each-ref for-each-repo " + "format-patch fsck gc get-tar-commit-id grep gui hash-object help hook index-pack init " + "instaweb interpret-trailers lfs log ls-files ls-remote ls-tree mailinfo mailsplit " + "maintenance merge merge-base merge-file merge-index merge-tree mergetool mktag mktree " + "multi-pack-index mv name-rev notes pack-objects pack-refs patch-id prune pull push " + "range-diff read-tree rebase reflog remote repack replace request-pull rerere reset " + "restore rev-list rev-parse revert rm send-email shortlog show show-branch show-ref " + "sparse-checkout stage stash status stripspace submodule subtree switch symbolic-ref tag " + "update-index update-ref var verify-commit verify-pack verify-tag version whatchanged " + "worktree write-tree").split(" "));
+var JUDGED_COMMANDS = [
+  "push",
+  "commit",
+  "switch",
+  "checkout",
+  "branch",
+  "worktree",
+  "stash",
+  "update-ref",
+  "symbolic-ref",
+  "fetch",
+  "pull",
+  "subtree"
+];
+var editDistance2 = (a, b) => {
+  let before = [];
+  let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
+  for (let i = 1;i <= a.length; i++) {
+    const row = [i];
+    for (let j = 1;j <= b.length; j++) {
+      row[j] = Math.min(previous[j] + 1, row[j - 1] + 1, previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+      if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1])
+        row[j] = Math.min(row[j], before[j - 2] + 1);
+    }
+    [before, previous] = [previous, row];
+  }
+  return previous[b.length];
+};
+var autocorrected = (name, config) => {
+  const setting = (configValue(config, "help.autocorrect") ?? "0").toLowerCase();
+  if (setting !== "immediate" && !/^-?[1-9]\d*$/.test(setting))
+    return null;
+  let best = null;
+  let bestDistance = 3;
+  let tie = false;
+  for (const command of JUDGED_COMMANDS) {
+    const distance = editDistance2(name, command);
+    if (distance < bestDistance)
+      [best, bestDistance, tie] = [command, distance, false];
+    else if (distance === bestDistance)
+      tie = true;
+  }
+  return tie ? null : best;
+};
+var shellQuote = (word) => `'${word.replaceAll("'", "'\\''")}'`;
+var positional = (script, args) => {
+  const word = (arg) => /^[\w./@+:=-]+$/.test(arg) ? arg : shellQuote(arg);
+  return script.replace(/\$\{?([1-9])\}?/g, (_, n) => word(args[Number(n) - 1] ?? "")).replace(/\$\{?[@*]\}?/g, args.map(word).join(" "));
+};
+var expandGitAliases = (root, invocation, cache = new Map, depth = 0) => {
+  const sub = invocation.args[0];
+  if (invocation.tool !== "git" || invocation.dir === undefined || !sub || sub.startsWith("-") || GIT_COMMANDS.has(sub) || depth >= MAX_DEPTH)
+    return [invocation];
+  const dir = path20.resolve(root, invocation.dir ?? ".");
+  if (!fs16.existsSync(dir))
+    return [invocation];
+  const config = gitConfig(dir, invocation, cache);
+  const alias = configValue(config, `alias.${sub.toLowerCase()}`);
+  if (alias === undefined) {
+    const corrected = autocorrected(sub, config);
+    return corrected ? [{ ...invocation, args: [corrected, ...invocation.args.slice(1)] }] : [invocation];
+  }
+  const rest = invocation.args.slice(1);
+  const expanded = alias.startsWith("!") ? rawInvocations([positional(alias.slice(1), rest), ...rest.map(shellQuote)].join(" ")).map((inner) => ({
+    ...inner,
+    dir: rebase(invocation.dir, inner.dir),
+    ...inner.tool === "git" && (invocation.config || inner.config) ? { config: [...invocation.config ?? [], ...inner.config ?? []] } : {},
+    ...inner.tool === "git" && (invocation.env || inner.env) ? { env: { ...invocation.env, ...inner.env } } : {}
+  })) : [
+    gitInvocation([...segmentsOf(alias)[0]?.words ?? [], ...rest], invocation.dir, invocation.env, invocation.stdin, invocation.config)
+  ];
+  return expanded.flatMap((inner) => expandGitAliases(root, inner, cache, depth + 1));
+};
+var normalizedUrl = (url, dir) => {
+  const trimmed = url.trim();
+  if (/^file:\/\//i.test(trimmed))
+    return path20.resolve(dir, trimmed.slice(7)).replace(/\/+$/, "").replace(/\.git$/, "");
+  const scheme = /^[a-z][a-z0-9+.-]*:\/\//i.exec(trimmed);
+  const scp = !scheme && /^(?:[^@/\\]+@)?[^/\\:]{2,}:/.test(trimmed);
+  if (!scheme && !scp)
+    return path20.resolve(dir, trimmed).replace(/\/+$/, "").replace(/\.git$/, "");
+  const value = scheme ? trimmed.slice(scheme[0].length).replace(/^[^@/]*@/, "").replace(/^([^/:]+):\d+(?=\/)/, "$1") : trimmed.replace(/^[^@/]*@/, "").replace(":", "/");
+  return value.toLowerCase().replace(/\/{2,}/g, "/").replace(/^www\./, "").replace(/\/+$/, "").replace(/\.git$/, "");
+};
+var rewrittenUrl = (url, config) => {
+  for (const kind of ["pushinsteadof", "insteadof"]) {
+    let best = null;
+    for (const [key, prefixes] of config) {
+      if (!key.startsWith("url.") || !key.endsWith(`.${kind}`))
+        continue;
+      const base = key.slice(4, -(kind.length + 1));
+      for (const prefix of prefixes)
+        if (url.startsWith(prefix) && prefix.length > (best?.prefix.length ?? -1))
+          best = { base, prefix };
+    }
+    if (best)
+      return best.base + url.slice(best.prefix.length);
+  }
+  return url;
+};
+var pushUrl = (config, remote, dir) => {
+  const configured = configValue(config, `remote.${remote}.pushurl`) ?? configValue(config, `remote.${remote}.url`);
+  return normalizedUrl(rewrittenUrl(configured ?? remote, config), dir);
+};
+var pushRemoteOf = (config, branch) => {
+  const remotes = new Set;
+  for (const key of config.keys()) {
+    const name = /^remote\.(.+)\.url$/.exec(key)?.[1];
+    if (name)
+      remotes.add(name);
+  }
+  for (const candidate of [
+    branch ? configValue(config, `branch.${branch}.pushremote`) : undefined,
+    configValue(config, "remote.pushdefault"),
+    branch ? configValue(config, `branch.${branch}.remote`) : undefined
+  ])
+    if (candidate && candidate !== "." && remotes.has(candidate))
+      return candidate;
+  if (remotes.has("origin"))
+    return "origin";
+  return remotes.size === 1 ? [...remotes][0] : null;
+};
+var toPushRemote = (repo, remote, config) => {
+  if (remote === null || /[$`]/.test(remote))
+    return true;
+  const pushRemote = pushRemoteOf(config, repo.branch);
+  if (pushRemote === null || pushRemote === remote)
+    return true;
+  return pushUrl(config, remote, repo.dir) === pushUrl(config, pushRemote, repo.dir);
+};
 var quote = (text) => `\`${text}\``;
 var refusal = (action, branch, dir) => {
   if (action.kind === "merge")
-    return `workit: raw ${quote(action.forge === "gh" ? "gh pr merge" : "glab mr merge")} bypasses the merge grant and the verdict gate. Run ${quote("workit pr merge")} instead (it checks both; ${quote("workit help pr")}).`;
+    return `workit: raw ${quote(action.via === "api" ? `${action.forge} api` : action.forge === "gh" ? "gh pr merge" : "glab mr merge")}${action.via === "api" ? " merge" : ""} bypasses the merge grant and the verdict gate. Run ${quote("workit pr merge")} instead (it checks both; ${quote("workit help pr")}).`;
   const plainPush = action.kind === "push" && !action.blindForce && !action.deletes;
   if (dir && branch && plainPush && releaseBranch(dir, branch))
-    return `workit: raw ${quote("git push")} onto ${branch}, a protected release branch, bypasses workit's protected-branch check. To finish a release or hotfix, push it with ${quote(`workit git push --release ${branch} [--release v<version>]`)}: it pushes ${branch} (fast-forward only) and the release tag, verifies the remote and records it, under the ${quote("release")} grant (if refused, ask the user to run ${quote("workit grant set <workspace> release=true")}). Feature work goes through ${quote("workit git push")} and ${quote("workit pr merge")}.`;
+    return `workit: raw ${quote("git push")} onto ${branch}, a protected release branch, bypasses workit's protected-branch check. To finish a release or hotfix, push it with ${quote(`workit git push --release ${branch} [--release ${releaseTagPrefixOf(dir)}<version>]`)}: it pushes ${branch} (fast-forward only) and the release tag, verifies the remote and records it, under the ${quote("release")} grant (if refused, ask the user to run ${quote("workit grant set <workspace> release=true")}). Feature work goes through ${quote("workit git push")} and ${quote("workit pr merge")}.`;
   return `workit: raw ${quote("git push")}${action.kind === "push" && action.blindForce ? " --force" : ""} onto ${branch}, a protected branch or the default target, bypasses workit's protected-branch check. Push your feature branch with ${quote("workit git push")} (${quote("workit git push --force-with-lease")} to rewrite it) and land it with ${quote("workit pr merge")}.`;
 };
 var refFacts = (repo, remote) => {
@@ -18526,35 +19513,112 @@ var refFacts = (repo, remote) => {
   }
   return facts;
 };
+var globBranches = (repo, glob) => {
+  const source = glob.source.startsWith("refs/") ? glob.source : `refs/heads/${glob.source}`;
+  const [sourcePrefix, sourceSuffix = ""] = source.split("*");
+  const [destinationPrefix, destinationSuffix = ""] = glob.destination.split("*");
+  const listed = spawnSync11("git", [
+    "for-each-ref",
+    "--format=%(refname)",
+    sourcePrefix.slice(0, sourcePrefix.lastIndexOf("/") + 1)
+  ], { cwd: repo.dir, encoding: "utf8", timeout: 5000, windowsHide: true });
+  const names = [];
+  for (const ref of (listed.stdout ?? "").split(`
+`)) {
+    if (!ref.startsWith(sourcePrefix) || !ref.endsWith(sourceSuffix))
+      continue;
+    const middle = ref.slice(sourcePrefix.length, ref.length - sourceSuffix.length);
+    const { name } = pushDestination(destinationPrefix + middle + destinationSuffix);
+    if (name)
+      names.push(name);
+  }
+  return names;
+};
+var pushedBranches = (action, repo, config, facts, remote) => {
+  const targets = action.implicit ? [] : [...action.targets];
+  const globs = [...action.globs ?? []];
+  let matching = action.matching === true;
+  const configured = action.implicit ? config.get(`remote.${remote}.push`) : undefined;
+  if (configured?.length) {
+    const parsed = pushRefspecs(configured);
+    targets.push(...parsed.targets);
+    globs.push(...parsed.globs);
+    matching ||= parsed.matching;
+  } else if (action.implicit) {
+    const mode = (configValue(config, "push.default") ?? "simple").toLowerCase();
+    const merge = repo.branch ? configValue(config, `branch.${repo.branch}.merge`) : undefined;
+    if (mode === "matching")
+      matching = true;
+    else if ((mode === "upstream" || mode === "tracking") && merge?.startsWith("refs/heads/"))
+      targets.push(merge.slice(11));
+    else if (mode !== "nothing")
+      targets.push(null);
+  }
+  if (action.allBranches)
+    targets.push(...facts.heads);
+  if (matching) {
+    for (const head of facts.heads)
+      if (facts.remoteHeads.has(head))
+        targets.push(head);
+  }
+  for (const glob of globs)
+    targets.push(...globBranches(repo, glob));
+  return targets;
+};
+var literalReadings = (name) => {
+  if (!/[$`]/.test(name))
+    return [name];
+  const withDefaults = name.replace(/\$\{\w+:?[-=]([^}$`]*)\}/g, "$1").replace(/\$\{\w+\}|\$\w+/g, "");
+  return /[$`]/.test(withDefaults) || !withDefaults ? [] : [withDefaults];
+};
+var guardedTarget = (dir, target) => {
+  for (const branch of literalReadings(target)) {
+    if (guardedBranch(dir, branch))
+      return branch;
+    const bare = branch.startsWith("heads/") ? branch.slice(6) : null;
+    if (bare && guardedBranch(dir, bare))
+      return bare;
+  }
+  return null;
+};
 var isTag = (facts, name) => facts.tags.has(name) && !facts.heads.has(name);
-var tagRefusal = (action, facts) => {
+var tagRefusal = (action, facts, dir) => {
   const tags = [
     ...action.tags ?? [],
     ...action.targets.filter((name) => name !== null && isTag(facts, name))
   ];
   if (!tags.length && !action.allTags)
     return null;
-  const named = tags.length ? tags.join(" --release ") : "v<version>";
-  return `workit: raw ${quote(`git push${action.allTags ? " --tags" : ""}`)} of ${tags.length ? `tag ${tags.join(", ")}` : "tags"} bypasses the release grant. Push a release tag with ${quote(`workit git push --release ${named}`)} (v<version> tags whose commit the production branch already has; a tag never moves), under the ${quote("release")} grant (if refused, ask the user to run ${quote("workit grant set <workspace> release=true")}).`;
+  const shape = `${releaseTagPrefixOf(dir)}<version>`;
+  const named = tags.length ? tags.join(" --release ") : shape;
+  return `workit: raw ${quote(`git push${action.allTags ? " --tags" : ""}`)} of ${tags.length ? `tag ${tags.join(", ")}` : "tags"} bypasses the release grant. Push a release tag with ${quote(`workit git push --release ${named}`)} (${shape} tags whose commit the production branch already has; a tag never moves), under the ${quote("release")} grant (if refused, ask the user to run ${quote("workit grant set <workspace> release=true")}).`;
 };
-var remoteHas = (repo, remote, branch) => {
-  const listed = spawnSync11("git", ["ls-remote", "--heads", remote, `refs/heads/${branch}`], {
+var remoteHeads = (repo, remote) => {
+  const listed = spawnSync11("git", ["ls-remote", "--heads", remote], {
     cwd: repo.dir,
     encoding: "utf8",
     timeout: 3000,
+    windowsHide: true,
     env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
   });
-  return listed.status !== 0 || (listed.stdout ?? "").trim() !== "";
+  if (listed.status !== 0)
+    return null;
+  return new Set((listed.stdout ?? "").split(`
+`).map((line) => line.split("\t")[1] ?? "").filter((ref) => ref.startsWith("refs/heads/")).map((ref) => ref.slice(11)));
 };
 var offPolicyPush = (action, repo, facts, remote) => {
   const names = action.allBranches ? [...facts.heads] : action.targets.map((target) => target ?? repo.branch);
+  let listed;
+  const remoteHas = (branch) => (listed === undefined ? listed = remoteHeads(repo, remote) : listed)?.has(branch) ?? true;
   for (const branch of names) {
-    if (!branch || action.deleted?.includes(branch) || isTag(facts, branch))
+    if (!branch || /[$`]/.test(branch))
+      continue;
+    if (action.deleted?.includes(branch) || isTag(facts, branch))
       continue;
     if (facts.remoteHeads.has(branch))
       continue;
     const check = validateBranchNameFor(repo.dir, branch);
-    if (check.ok || check.rule !== "allowed_pattern" || remoteHas(repo, remote, branch))
+    if (check.ok || check.rule !== "allowed_pattern" || remoteHas(branch))
       continue;
     return `workit: raw ${quote("git push")} onto ${branch}: ${check.error}`;
   }
@@ -18576,23 +19640,50 @@ var nudgeFor = (action, host, session) => {
       return null;
   }
 };
-var actionsIn = (cwd, command, dialect) => {
+var pushRefusal = (action, repo, config) => {
+  if (!toPushRemote(repo, action.remote, config))
+    return null;
+  if (action.mirror)
+    return `workit: raw ${quote("git push --mirror")} rewrites and deletes every remote ref, protected branches and tags included. Push one branch with ${quote("workit git push")}.`;
+  const remote = action.remote ?? pushRemoteOf(config, repo.branch) ?? "origin";
+  const facts = refFacts(repo, remote);
+  const targets = pushedBranches(action, repo, config, facts, remote);
+  const pushed = { ...action, targets };
+  const offPolicy = action.allBranches ? offPolicyPush(pushed, repo, facts, remote) : null;
+  if (offPolicy)
+    return offPolicy;
+  for (const target of targets) {
+    const guarded = guardedTarget(repo.dir, target ?? repo.branch ?? "");
+    if (guarded)
+      return refusal(action, guarded, repo.dir);
+  }
+  return tagRefusal(pushed, facts, repo.dir) ?? (action.deletes ? null : offPolicyPush(pushed, repo, facts, remote));
+};
+var actionsIn = (cwd, command, dialect, cache = new Map) => {
   const out = [];
   const repos = new Map;
-  for (const invocation of rawInvocations(command, dialect)) {
-    if (invocation.dir === undefined)
-      continue;
-    const action = rawAction(invocation);
-    if (!action)
-      continue;
-    const dir = path20.resolve(cwd, invocation.dir ?? ".");
+  const repoFor = (relative) => {
+    const dir = path20.resolve(cwd, relative ?? ".");
     if (!repos.has(dir)) {
       const repo = repoAt(dir);
       repos.set(dir, repo && isWorkitWorkspace(repo) ? repo : null);
     }
-    const repo = repos.get(dir);
-    if (repo)
-      out.push({ action, repo });
+    return repos.get(dir) ?? null;
+  };
+  for (const raw of rawInvocations(command, dialect)) {
+    if (raw.dir === undefined)
+      continue;
+    const known = raw.tool !== "git" || GIT_COMMANDS.has(raw.args[0] ?? "");
+    if (!known && !repoFor(raw.dir))
+      continue;
+    for (const invocation of known ? [raw] : expandGitAliases(cwd, raw, cache)) {
+      if (invocation.dir === undefined)
+        continue;
+      const action = rawAction(invocation);
+      const repo = action ? repoFor(invocation.dir) : null;
+      if (action && repo)
+        out.push({ action, repo, invocation });
+    }
   }
   return out;
 };
@@ -18621,31 +19712,18 @@ var unseenNudges = (input, nudges, store) => {
 };
 function rawGitPre(input, command, options = {}) {
   try {
-    if (!mentionsRawTool(command))
-      return NONE2;
     const dialect = dialectOf(input);
     const nudges = new Map;
     let store = null;
-    for (const { action, repo } of actionsIn(input.cwd, command, dialect)) {
+    const cache = new Map;
+    for (const { action, repo, invocation } of actionsIn(input.cwd, command, dialect, cache)) {
       store ??= repo.location.dir;
       if (action.kind === "merge")
         return deny(refusal(action, null));
-      if (action.kind === "push" && toPushRemote(repo, action.remote)) {
-        if (action.mirror)
-          return deny(`workit: raw ${quote("git push --mirror")} rewrites and deletes every remote ref, protected branches and tags included. Push one branch with ${quote("workit git push")}.`);
-        for (const target of action.targets) {
-          const branch = target ?? repo.branch;
-          if (branch && guardedBranch(repo.dir, branch))
-            return deny(refusal(action, branch, repo.dir));
-        }
-        const remote = action.remote ?? pushRemoteName(repo.dir, repo.branch) ?? "origin";
-        const facts = refFacts(repo, remote);
-        const tagDeny = tagRefusal(action, facts);
-        if (tagDeny)
-          return deny(tagDeny);
-        const nameDeny = action.deletes ? null : offPolicyPush(action, repo, facts, remote);
-        if (nameDeny)
-          return deny(nameDeny);
+      if (action.kind === "push") {
+        const refused = pushRefusal(action, repo, gitConfig(repo.dir, invocation, cache));
+        if (refused)
+          return deny(refused);
       }
       const nudge = nudgeFor(action, input.host, input.session.id);
       if (nudge && !nudges.has(nudgeKind(action)))
@@ -18658,11 +19736,17 @@ function rawGitPre(input, command, options = {}) {
     const shown = unseenNudges(input, nudges, store);
     return shown.length ? { kind: "context", text: shown.join(`
 `) } : NONE2;
-  } catch {
-    return NONE2;
+  } catch (error) {
+    return error instanceof ShellAnalysisError ? analysisDenial(error) : NONE2;
   }
 }
 var deny = (reason) => ({ kind: "deny", reason, unblock: null });
+var SPLIT_IT = "Split it into simpler commands (no deeply nested substitutions or huge brace lists) and run them one at a time.";
+var analysisDenial = (error) => ({
+  kind: "deny",
+  reason: `workit: the shell hook could not analyze this command (${error.message}), so it does not run. ${SPLIT_IT}`,
+  unblock: SPLIT_IT
+});
 var NEXT_COMMAND = "next";
 var MARKER_TTL_SECONDS = 3600;
 var markerFile = (repo, session, key) => path20.join(repo.location.dir, "hooks", `commit-${createHash14("sha256").update(`${session}\x00${key}`).digest("hex").slice(0, 32)}.json`);
@@ -18763,20 +19847,28 @@ var UNKNOWABLE = /[$`*?[\]{}~]/u;
 var SWITCH_CREATE = new Set(["-c", "--create", "-C", "--force-create", "--orphan"]);
 var CHECKOUT_CREATE = new Set(["-b", "-B", "--orphan"]);
 var WORKTREE_CREATE = new Set(["-b", "-B"]);
+var SUBTREE_CREATE = new Set(["-b", "--branch"]);
 var BRANCH_NO_CREATE = new Set(["-d", "-D", "--delete", "-l", "--list", "-a", "--all", "-r", "--remotes", "--show-current"].concat(["-v", "-vv", "--verbose", "--contains", "--no-contains", "--merged", "--no-merged"]).concat(["--points-at", "--sort", "--format", "--column", "--no-column", "-u"]).concat(["--set-upstream-to", "--unset-upstream", "--edit-description", "-i", "--ignore-case"]));
 var BRANCH_RENAME = new Set(["-m", "-M", "--move", "-c", "-C", "--copy"]);
+var longOption = (name, flags) => flags.has(name) || name.length >= 3 && [...flags].some((flag) => flag.startsWith("--") && flag.startsWith(name));
+var shortsOf = (flags) => [...flags].filter((flag) => /^-[^-]$/u.test(flag)).join("").replaceAll("-", "");
 var flagValue = (args, flags) => {
+  const shorts = shortsOf(flags);
   for (let index = 1;index < args.length; index++) {
     const arg = args[index];
     if (arg === "--")
       return null;
-    if (flags.has(arg))
-      return args[index + 1] ?? null;
-    const eq = arg.indexOf("=");
-    if (arg.startsWith("--") && eq > 0 && flags.has(arg.slice(0, eq)))
-      return arg.slice(eq + 1);
-    if (!arg.startsWith("--") && arg.length > 2 && flags.has(arg.slice(0, 2)))
-      return arg.slice(2);
+    if (arg.startsWith("--")) {
+      const eq = arg.indexOf("=");
+      if (!longOption(eq > 0 ? arg.slice(0, eq) : arg, flags))
+        continue;
+      return eq > 0 ? arg.slice(eq + 1) : args[index + 1] ?? null;
+    }
+    if (!arg.startsWith("-") || arg.length < 2)
+      continue;
+    for (let at = 1;at < arg.length; at++)
+      if (shorts.includes(arg[at]))
+        return at + 1 < arg.length ? arg.slice(at + 1) : args[index + 1] ?? null;
   }
   return null;
 };
@@ -18809,62 +19901,128 @@ var branchCommandTarget = (args) => {
       positionals.push(...args.slice(index + 1));
       break;
     }
-    const flag = arg.split("=", 1)[0];
-    if (BRANCH_NO_CREATE.has(flag))
-      return null;
-    if (BRANCH_RENAME.has(flag))
-      rename = true;
-    else if (!arg.startsWith("-"))
+    if (arg.startsWith("--")) {
+      const flag = arg.split("=", 1)[0];
+      if (longOption(flag, BRANCH_NO_CREATE))
+        return null;
+      if (longOption(flag, BRANCH_RENAME))
+        rename = true;
+    } else if (arg.startsWith("-") && arg.length > 1) {
+      const shorts = arg.slice(1).split("");
+      if (shorts.some((short) => BRANCH_NO_CREATE.has(`-${short}`)))
+        return null;
+      if (shorts.some((short) => BRANCH_RENAME.has(`-${short}`)))
+        rename = true;
+    } else
       positionals.push(arg);
   }
   if (positionals.length < 1 || positionals.length > 2)
     return null;
   return rename ? positionals.at(-1) ?? null : positionals[0];
 };
-var gitBranchCreation = (args) => {
-  const [sub, second] = args;
-  const target = sub === "switch" ? flagValue(args, SWITCH_CREATE) : sub === "checkout" ? flagValue(args, CHECKOUT_CREATE) : sub === "branch" ? branchCommandTarget(args) : sub === "worktree" && second === "add" ? worktreeTarget(args.slice(1)) : null;
-  return target && !target.startsWith("-") && !UNKNOWABLE.test(target) ? target : null;
+var positionalsOf = (args, skip, values = new Set) => {
+  const found = [];
+  for (let index = skip;index < args.length; index++) {
+    const arg = args[index];
+    if (arg === "--")
+      return [...found, ...args.slice(index + 1)];
+    if (values.has(arg))
+      index++;
+    else if (!arg.startsWith("-") || arg === "-")
+      found.push(arg);
+  }
+  return found;
 };
-var shellBranchTargets = (command, dialect = "posix") => {
-  if (!/\bgit\b/u.test(command))
+var localHead = (ref) => ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : null;
+var updateRefTargets = (args, stdin) => {
+  if (args.some((arg) => arg === "-d" || arg === "--delete"))
     return [];
-  const found = [];
-  for (const invocation of rawInvocations(command, dialect)) {
-    if (invocation.tool !== "git")
+  if (args.includes("--stdin"))
+    return (stdin ?? "").split(/[\n\0]/u).map((line) => /^\s*(?:create|update)\s+(\S+)/u.exec(line)?.[1] ?? "").map(localHead).filter((name) => name !== null);
+  const [ref] = positionalsOf(args, 1, new Set(["-m"]));
+  const name = ref ? localHead(ref) : null;
+  return name ? [name] : [];
+};
+var symbolicRefTarget = (args) => {
+  if (args.some((arg) => arg === "-d" || arg === "--delete"))
+    return null;
+  const [, ref] = positionalsOf(args, 1, new Set(["-m"]));
+  return ref ? localHead(ref) : null;
+};
+var FETCH_VALUES = new Set(["--depth", "--deepen", "--shallow-since", "--shallow-exclude", "--refmap", "-j", "--jobs"].concat(["--upload-pack", "-o", "--server-option", "--negotiation-tip", "--filter"]).concat(["--recurse-submodules-default", "--submodule-prefix", "-s", "--strategy", "-X"]).concat(["--strategy-option"]));
+var fetchTargets = (args, stdin) => {
+  if (args.includes("--all") || args.includes("--multiple"))
+    return [];
+  const specs = args.includes("--stdin") ? (stdin ?? "").split(/\s+/u).filter(Boolean) : positionalsOf(args, 1, FETCH_VALUES).slice(1);
+  const names = [];
+  for (const raw of specs) {
+    const colon = raw.indexOf(":");
+    const destination = colon >= 0 ? raw.slice(colon + 1) : "";
+    if (!destination || destination.includes("*"))
       continue;
-    const branch = gitBranchCreation(invocation.args);
-    if (branch)
-      found.push({ branch, dir: invocation.dir });
+    const name = destination.startsWith("refs/") ? localHead(destination) : destination;
+    if (name)
+      names.push(name);
   }
-  return found;
+  return names;
+};
+var localPushTargets = (args) => {
+  const action = pushAction(args);
+  if (action?.kind !== "push" || action.remote !== "." || action.deletes)
+    return [];
+  return action.targets.filter((name) => name !== null);
+};
+var gitBranchCreations = (args, stdin) => {
+  const [sub, second] = args;
+  const targets = sub === "switch" ? [flagValue(args, SWITCH_CREATE)] : sub === "checkout" ? [flagValue(args, CHECKOUT_CREATE)] : sub === "branch" ? [branchCommandTarget(args)] : sub === "worktree" && second === "add" ? [worktreeTarget(args.slice(1))] : sub === "stash" && second === "branch" ? positionalsOf(args, 2).slice(0, 1) : sub === "update-ref" ? updateRefTargets(args, stdin) : sub === "symbolic-ref" ? [symbolicRefTarget(args)] : sub === "fetch" || sub === "pull" ? fetchTargets(args, stdin) : sub === "push" ? localPushTargets(args) : sub === "subtree" && second === "split" ? [flagValue(args.slice(1), SUBTREE_CREATE)] : [];
+  return targets.filter((target) => target !== null && target !== "" && !target.startsWith("-") && !UNKNOWABLE.test(target));
 };
+var targetsOf = (invocations) => invocations.flatMap((invocation) => invocation.tool === "git" ? gitBranchCreations(invocation.args, invocation.stdin).map((branch) => ({
+  branch,
+  dir: invocation.dir
+})) : []);
 var localBranchExists = (dir, branch) => spawnSync12("git", ["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], {
   cwd: dir,
   stdio: "ignore",
   timeout: 5000
 }).status === 0;
+var judgedDir = (root, dir) => {
+  if (dir === undefined)
+    return null;
+  if (dir === null)
+    return root;
+  const resolved = path21.resolve(root, dir);
+  return existsSync6(resolved) && inWorkitWorkspace(resolved) ? resolved : null;
+};
 var shellBranchPolicyViolation = (root, command, dialect = "posix") => {
   let judged = false;
-  for (const target of shellBranchTargets(command, dialect)) {
-    if (target.dir === undefined)
-      continue;
-    const dir = target.dir === null ? root : path21.resolve(root, target.dir);
-    if (target.dir !== null && (!existsSync6(dir) || !inWorkitWorkspace(dir)))
+  const cache = new Map;
+  for (const raw of rawInvocations(command, dialect)) {
+    if (raw.tool !== "git" || judgedDir(root, raw.dir) === null)
       continue;
-    if (localBranchExists(dir, target.branch))
-      continue;
-    judged = true;
-    const check = validateBranchNameFor(dir, target.branch);
-    if (!check.ok)
-      return check;
+    for (const target of targetsOf(expandGitAliases(root, raw, cache))) {
+      const dir = judgedDir(root, target.dir);
+      if (dir === null || localBranchExists(dir, target.branch))
+        continue;
+      judged = true;
+      const check = validateBranchNameFor(dir, target.branch);
+      if (!check.ok)
+        return check;
+    }
   }
   return judged ? { ok: true } : null;
 };
 
 // packages/workit-core/src/hooks/policy.ts
 var shellPolicy = (cwd, command, dialect = "posix") => {
-  const policy = shellBranchPolicyViolation(cwd, command, dialect);
+  let policy;
+  try {
+    policy = shellBranchPolicyViolation(cwd, command, dialect);
+  } catch (error) {
+    if (error instanceof ShellAnalysisError)
+      return analysisDenial(error);
+    throw error;
+  }
   return policy && !policy.ok ? { kind: "deny", reason: `branch_policy_denied: ${policy.error}`, unblock: null } : { kind: "none" };
 };
 // packages/workit-core/src/hooks/write-gate.ts
@@ -18893,11 +20051,11 @@ var exempt = (cwd, root, file, plans) => {
   const segments = posix.split("/");
   return /\.mdx?$/i.test(posix) || segments[0] === "docs" || segments.includes("plans") || [...plans].some((plan) => fold(plan) === posix);
 };
-var PREFIXES3 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "xargs"]);
+var PREFIXES2 = new Set(["sudo", "command", "env", "nohup", "time", "exec", "xargs"]);
 var operands = (words) => words.filter((item) => !item.startsWith("-"));
 var editsOf = (input) => {
   let words = input;
-  while (words.length && (PREFIXES3.has(words[0]) || /^\w+=/.test(words[0])))
+  while (words.length && (PREFIXES2.has(words[0]) || /^\w+=/.test(words[0])))
     words = words.slice(1);
   const [verb, ...args] = words;
   const name = (verb?.split(/[\\/]/).at(-1) ?? "").toLowerCase();
@@ -20194,7 +21352,7 @@ var CURSOR_DESCRIPTOR = {
     "compact.pre": { support: "partial", native: "preCompact" },
     stop: { support: "native", native: "stop" }
   },
-  shellPolicy: { deny: "native", channel: "exit2+json", failClosed: true },
+  shellPolicy: { deny: "native", channel: "exit2+json", failClosed: false },
   context: {
     sessionStart: "native",
     perTurn: "none",