@kaynooo/guard-tools 0.4.1 → 0.5.0

package/dist/cli.js

@@ -2,10 +2,10 @@
 // @bun
 
 // src/cli.ts
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
 import { homedir } from "os";
 import { dirname } from "path";
-import process6 from "process";
+import process7 from "process";
 
 // ../kit/src/args.ts
 import process3 from "process";
@@ -504,8 +504,103 @@ async function readInput(path, { noStdin = "nothing is piped on stdin" } = {}) {
     fail(`no file ${path}`);
   return file.text();
 }
-// ../kit/src/cli.ts
+// ../kit/src/process.ts
+import { constants } from "os";
 import process4 from "process";
+var KILL_GRACE_MS = 2000;
+function exitCodeOf(code, signal) {
+  if (code !== null)
+    return code;
+  if (typeof signal === "number")
+    return 128 + signal;
+  return signal === null ? 129 : 128 + constants.signals[signal];
+}
+async function runCommand(argv, { cwd, env, stdin = "ignore", timeoutMs, signal, maxBytes = Infinity, onChunk, onStart } = {}) {
+  const chunks = [];
+  const grouped = timeoutMs !== undefined || signal !== undefined || onStart !== undefined || onChunk !== undefined;
+  const proc = Bun.spawn(argv, { ...cwd === undefined ? {} : { cwd }, ...env === undefined ? {} : { env }, stdin, stdout: "pipe", stderr: "pipe", ...grouped ? { detached: true } : {} });
+  const state = { kept: 0, truncated: false, timedOut: false, failure: undefined, done: false };
+  const timers = [];
+  const killGroup = (killing) => {
+    if (state.done)
+      return;
+    try {
+      if (grouped)
+        process4.kill(-proc.pid, killing);
+      else
+        proc.kill(killing);
+    } catch {}
+  };
+  const stop = () => {
+    killGroup("SIGTERM");
+    timers.push(setTimeout(killGroup, KILL_GRACE_MS, "SIGKILL"));
+  };
+  const onAbort = () => stop();
+  if (timeoutMs !== undefined) {
+    timers.push(setTimeout(() => {
+      state.timedOut = true;
+      stop();
+    }, timeoutMs));
+  }
+  if (signal?.aborted === true)
+    onAbort();
+  else
+    signal?.addEventListener("abort", onAbort, { once: true });
+  onStart?.({ kill: (killing) => killGroup(killing) });
+  const drain = async (stream, name) => {
+    for await (const data of stream) {
+      if (state.failure !== undefined)
+        continue;
+      try {
+        onChunk?.({ stream: name, data });
+      } catch (error) {
+        state.failure = error;
+        stop();
+        continue;
+      }
+      if (state.kept + data.length > maxBytes) {
+        state.truncated = true;
+        continue;
+      }
+      state.kept += data.length;
+      chunks.push({ stream: name, data });
+    }
+  };
+  try {
+    await Promise.all([drain(proc.stdout, "stdout"), drain(proc.stderr, "stderr")]);
+    await proc.exited;
+  } finally {
+    state.done = true;
+    for (const timer of timers)
+      clearTimeout(timer);
+    signal?.removeEventListener("abort", onAbort);
+  }
+  if (state.failure !== undefined)
+    throw state.failure;
+  const joined = () => Buffer.concat(chunks.map(({ data }) => data));
+  let output;
+  let text;
+  return {
+    code: exitCodeOf(proc.exitCode, proc.signalCode),
+    chunks,
+    timedOut: state.timedOut,
+    truncated: state.truncated,
+    get output() {
+      return output ??= joined();
+    },
+    get text() {
+      return text ??= (output ??= joined()).toString();
+    }
+  };
+}
+
+// ../kit/src/progress.ts
+var ESC = String.fromCharCode(27);
+var ESCAPE_CODE = new RegExp(`${ESC}(?:\\[[\\x30-\\x3F]*[\\x20-\\x2F]*[\\x40-\\x7E]|\\][^\\u0007${ESC}]*(?:\\u0007|${ESC}\\\\))`, "y");
+var RESET_STYLE = `${ESC}[0m`;
+var CLOSE_LINK = `${ESC}]8;;${ESC}\\`;
+// ../kit/src/cli.ts
+import process5 from "process";
 var LEVEL_OPTIONS = {
   ...OUTPUT_OPTIONS,
   help: { type: "boolean", short: "h", description: "show this help" }
@@ -581,8 +676,8 @@ async function help({ path, header, summary: lazySummary, commands, defaultComma
 `);
 }
 function printError(prefix, message, hint, cause) {
-  const colors = paint(process4.stderr);
-  const styled = takesControlCodes(process4.stderr);
+  const colors = paint(process5.stderr);
+  const styled = takesControlCodes(process5.stderr);
   const head = styled ? `${colors.red.bold("error")} ${colors.dim(`${prefix}:`)}` : `error: ${prefix}:`;
   const under = (label, text, tint) => text === undefined ? "" : `
   ${styled ? tint(label) : `${label}:`} ${text}`;
@@ -615,11 +710,11 @@ async function dispatch(level, typed, { version, redact }) {
   }
   const [name, ...args] = argv;
   if (name === undefined && level.path.length > 1) {
-    console.error(await help(await expand(level, [...level.path.slice(1), ...argv]), process4.stderr));
+    console.error(await help(await expand(level, [...level.path.slice(1), ...argv]), process5.stderr));
     return 2;
   }
   if (name === undefined || name === "help" || name === "--help" || name === "-h") {
-    console.log(await help(await expand(level, [...level.path.slice(1), ...argv]), process4.stdout));
+    console.log(await help(await expand(level, [...level.path.slice(1), ...argv]), process5.stdout));
     return 0;
   }
   if (level.path.length === 1 && (name === "--version" || name === "-v")) {
@@ -692,49 +787,80 @@ async function printCandidates(found) {
     console.log(line);
   return 0;
 }
-async function runCli(cli, argv = process4.argv.slice(2)) {
+async function runCli(cli, argv = process5.argv.slice(2)) {
   if (argv[0] === COMPLETE)
     return printCandidates(candidates(scopeOf(cli.commands, cli.extraCommands, cli.aliases), cli.defaultCommand, argv.slice(1)));
   return dispatch({ path: [cli.name], header: (colors, about) => `${colors.bold(cli.name)} ${colors.dim(cli.version)}  ${about}`, summary: cli.about, ...scopeOf(cli.commands, cli.extraCommands, cli.aliases), defaultCommand: cli.defaultCommand, examples: cli.examples, replaces: cli.replaces }, argv, { version: cli.version, redact: cli.redact });
 }
-// ../kit/src/process.ts
-import { constants } from "os";
-async function collect(stream, name, chunks) {
-  for await (const data of stream)
-    chunks.push({ stream: name, data });
-}
-function exitCodeOf(code, signal) {
-  if (code !== null)
-    return code;
-  if (typeof signal === "number")
-    return 128 + signal;
-  return signal === null ? 129 : 128 + constants.signals[signal];
-}
-async function runCommand(argv, { cwd, env, stdin = "ignore" } = {}) {
-  const chunks = [];
-  const proc = Bun.spawn(argv, { ...cwd === undefined ? {} : { cwd }, ...env === undefined ? {} : { env }, stdin, stdout: "pipe", stderr: "pipe" });
-  await Promise.all([collect(proc.stdout, "stdout", chunks), collect(proc.stderr, "stderr", chunks)]);
-  await proc.exited;
-  const output = Buffer.concat(chunks.map(({ data }) => data));
-  return { code: exitCodeOf(proc.exitCode, proc.signalCode), chunks, output, text: output.toString() };
-}
+// ../kit/src/logs.ts
+var DAY_MS = 24 * 60 * 60 * 1000;
+// ../kit/src/secrets.ts
+var SECRET_WORDS = new Set(["key", "pass", "pwd", "auth", "salt", "cookie", "session", "jwt", "ssn", "iban", "card", "cvv", "otp"]);
 // package.json
-var version = "0.4.1";
+var version = "0.5.0";
 
 // ../kit/src/shell.ts
 var SEPARATORS = new Set([`
 `, ";", "|"]);
 var PLAIN_BREAKERS = new Set(["<", ">", "(", ")", "&", "|"]);
+var GLOB_CHARS = new Set(["*", "?", "["]);
+var COMMENT_PREFIXES = new Set([";", "&", "|", "(", ")"]);
 var WHITESPACE = /\s/;
 var ASSIGNMENT = /^\w+=/;
 var TRAILING_SLASHES = /\/+$/;
+var TRAILING_CR = /\r$/;
 var LEADING_TILDE = /^~(?=\/|$)/;
 var LEADING_TABS = /^\t+/;
 var OPENERS = /^[({]+/;
 var CLOSERS = /[)}]+$/;
+var CASE_LABEL = /^\(?[^\s()]*\)$/;
+var REDIRECT_ONLY = /^\d*(?:<|>|>>|<&|>&|&>|>\||<>)$/;
+var REDIRECT_START = /^\d*[<>]|^&>/;
+var SAFE_WORD = /^[\w@%+=:,./-]+$/;
+var LEADING_HEX = /^[\da-f]*/i;
 var DOUBLE_QUOTED_ESCAPES = new Set(["$", "`", '"', "\\"]);
 var HEREDOC = /^<<(-?)[ \t]*(?:'([^']*)'|"([^"]*)"|([^\s;&|<>()-][^\s;&|<>()]*))/;
-var WRAPPERS = new Set(["command", "env", "sudo", "exec", "nohup", "time"]);
+var ANSI_QUOTE = "$'";
+var ANSI_ESCAPES = { n: `
+`, t: "\t", r: "\r", a: "\x07", b: "\b", f: "\f", v: "\v", e: "\x1B", E: "\x1B", "\\": "\\", "'": "'", '"': '"', "?": "?" };
+var ANSI_DIGITS = { x: 2, u: 4, U: 8 };
+var OCTAL = /^[0-7]{1,3}/;
+var KEYWORDS = new Set(["then", "do", "else", "if", "elif", "while", "until", "!", "{", "}"]);
+var MAX_DEPTH = 8;
+var MAX_BRACES = 256;
+var SHELLS = new Set(["sh", "bash", "zsh", "dash", "ash", "ksh"]);
+var COMMAND_STRING_PROGRAMS = new Set([...SHELLS, "su", "runuser"]);
+var SHELL_VALUE_OPTIONS = new Set(["-o", "-O", "--rcfile", "--init-file"]);
+var PRINTERS = new Set(["echo", "printf"]);
+var FIND_EXEC = new Set(["-exec", "-execdir", "-ok", "-okdir"]);
+function wrapper(short = "", long = [], operands = 0) {
+  return { short, long, operands };
+}
+var WRAPPERS = new Map([
+  ["command", wrapper()],
+  ["builtin", wrapper()],
+  ["nohup", wrapper()],
+  ["setsid", wrapper()],
+  ["busybox", wrapper()],
+  ["exec", wrapper("a")],
+  ["time", wrapper("fo", ["--format", "--output"])],
+  ["env", wrapper("uCS", ["--unset", "--chdir", "--split-string", "--argv0"])],
+  ["sudo", wrapper("ughpCTrtUDR", ["--user", "--group", "--host", "--prompt", "--close-from", "--command-timeout", "--role", "--type", "--other-user", "--chdir", "--chroot"])],
+  ["doas", wrapper("uC")],
+  ["timeout", wrapper("sk", ["--signal", "--kill-after"], 1)],
+  ["nice", wrapper("n", ["--adjustment"])],
+  ["ionice", wrapper("cnpPu", ["--class", "--classdata", "--pid", "--pgid", "--uid"])],
+  ["stdbuf", wrapper("ioe", ["--input", "--output", "--error"])],
+  ["chroot", wrapper("", ["--userspec", "--groups"], 1)],
+  ["xargs", wrapper("IndsEaPL", ["--max-args", "--max-procs", "--max-chars", "--delimiter", "--arg-file", "--eof", "--max-lines", "--process-slot-var"])]
+]);
+function closerOf(quote) {
+  return quote === ANSI_QUOTE ? "'" : quote;
+}
+function startsComment(command, i) {
+  const before = command[i - 1] ?? "";
+  return i === 0 || WHITESPACE.test(before) || COMMENT_PREFIXES.has(before);
+}
 function separatorWidth(command, i) {
   const pair = command.slice(i, i + 2);
   if (pair === "&&" || pair === "||")
@@ -751,7 +877,7 @@ function heredocEnd(command, newline, words) {
       const next = command.indexOf(`
 `, lineStart);
       const lineEnd = next === -1 ? command.length : next;
-      const line = command.slice(lineStart, lineEnd);
+      const line = command.slice(lineStart, lineEnd).replace(TRAILING_CR, "");
       lineStart = lineEnd + 1;
       if ((stripsTabs ? line.replace(LEADING_TABS, "") : line) === word)
         break;
@@ -773,6 +899,7 @@ function withoutRanges(command, start, end, ranges) {
 function splitCommand(command) {
   const bounds = [];
   const bodies = [];
+  const comments = [];
   let heredocs = [];
   let start = 0;
   let quote = null;
@@ -783,14 +910,27 @@ function splitCommand(command) {
       continue;
     }
     if (quote !== null) {
-      if (char === quote)
+      if (char === closerOf(quote))
         quote = null;
       continue;
     }
+    if (char === "$" && command[i + 1] === "'") {
+      quote = ANSI_QUOTE;
+      i++;
+      continue;
+    }
     if (char === "'" || char === '"') {
       quote = char;
       continue;
     }
+    if (char === "#" && startsComment(command, i)) {
+      const newline = command.indexOf(`
+`, i);
+      const end = newline === -1 ? command.length : newline;
+      comments.push([i, end]);
+      i = end - 1;
+      continue;
+    }
     const heredoc = char === "<" && command[i + 1] === "<" && command[i + 2] !== "<" ? HEREDOC.exec(command.slice(i)) : null;
     if (heredoc) {
       heredocs.push({ word: heredoc[2] ?? heredoc[3] ?? heredoc[4] ?? "", stripsTabs: heredoc[1] === "-", isQuoted: heredoc[4] === undefined });
@@ -813,32 +953,78 @@ function splitCommand(command) {
     start = i + 1;
   }
   bounds.push([start, command.length, ""]);
-  const ranges = bodies.map(([from, to]) => [from, to]);
-  return bounds.map(([from, to, separator]) => ({
-    text: command.slice(from, to),
-    start: from,
-    end: to,
-    command: withoutRanges(command, from, to, ranges),
-    separator,
-    expanded: bodies.filter(([body, , expands]) => expands && body >= from && body < to).map(([body, bodyEnd]) => command.slice(body, bodyEnd)).join("")
-  }));
+  const ranges = [...bodies, ...comments].map(([from, to]) => [from, to]).sort(([a], [b]) => a - b);
+  return bounds.map(([from, to, separator]) => {
+    const inside = bodies.filter(([body]) => body >= from && body < to);
+    return {
+      text: command.slice(from, to),
+      start: from,
+      end: to,
+      command: withoutRanges(command, from, to, ranges),
+      separator,
+      expanded: inside.filter(([, , expands]) => expands).map(([body, bodyEnd]) => command.slice(body, bodyEnd)).join(""),
+      heredocs: inside.map(([body, bodyEnd]) => command.slice(body, bodyEnd))
+    };
+  });
 }
 function isPlain(text) {
   let quote = null;
   for (let i = 0;i < text.length; i++) {
     const char = text[i] ?? "";
     const isSubstitution = char === "`" || char === "$" && text[i + 1] === "(";
+    if (quote === null && char === "$" && text[i + 1] === "'") {
+      quote = ANSI_QUOTE;
+      i++;
+      continue;
+    }
     if (char === "\\" && quote !== "'")
       i++;
-    else if (quote !== null && char === quote)
+    else if (quote !== null && char === closerOf(quote))
       quote = null;
     else if (quote === null && (char === '"' || char === "'"))
       quote = char;
-    else if (quote !== "'" && (isSubstitution || quote === null && PLAIN_BREAKERS.has(char)))
+    else if (quote !== "'" && quote !== ANSI_QUOTE && (isSubstitution || quote === null && PLAIN_BREAKERS.has(char)))
       return false;
   }
   return quote === null;
 }
+function unmatchedClosers(text) {
+  let depth = 0;
+  let unmatched = 0;
+  let quote = null;
+  for (let i = 0;i < text.length; i++) {
+    const char = text[i] ?? "";
+    if (quote === null && char === "$" && text[i + 1] === "'") {
+      quote = ANSI_QUOTE;
+      i++;
+      continue;
+    }
+    if (char === "\\" && quote !== "'")
+      i++;
+    else if (quote !== null && char === closerOf(quote))
+      quote = null;
+    else if (quote === null && (char === '"' || char === "'"))
+      quote = char;
+    else if (quote === null && char === "(")
+      depth++;
+    else if (quote === null && char === ")" && depth > 0)
+      depth--;
+    else if (quote === null && char === ")")
+      unmatched++;
+  }
+  return unmatched;
+}
+function withoutSubshell(text) {
+  let result = text.trim();
+  let closers = unmatchedClosers(result);
+  while (result.startsWith("("))
+    result = result.slice(1).trimStart();
+  while (closers > 0 && result.endsWith(")")) {
+    result = result.slice(0, -1).trimEnd();
+    closers--;
+  }
+  return result;
+}
 function closingParen(text, open) {
   let depth = 0;
   let quote = null;
@@ -847,8 +1033,11 @@ function closingParen(text, open) {
     if (char === "\\" && quote !== "'") {
       i++;
     } else if (quote !== null) {
-      if (char === quote)
+      if (char === closerOf(quote))
         quote = null;
+    } else if (char === "$" && text[i + 1] === "'") {
+      quote = ANSI_QUOTE;
+      i++;
     } else if (char === "'" || char === '"') {
       quote = char;
     } else if (char === "(") {
@@ -873,12 +1062,18 @@ function bodies(text, isQuoting) {
   let quote = null;
   for (let i = 0;i < text.length; i++) {
     const char = text[i] ?? "";
+    const next = text[i + 1];
     if (quote === "'") {
       if (char === "'")
         quote = null;
+    } else if (quote === ANSI_QUOTE) {
+      if (char === "\\")
+        i++;
+      else if (char === "'")
+        quote = null;
     } else if (char === "\\") {
       i++;
-    } else if (char === "$" && text[i + 1] === "(") {
+    } else if (char === "$" && next === "(" || isQuoting && quote === null && (char === "<" || char === ">") && next === "(") {
       const end = closingParen(text, i + 1);
       found.push(text.slice(i + 2, end));
       i = end;
@@ -888,6 +1083,9 @@ function bodies(text, isQuoting) {
       i = end;
     } else if (isQuoting && char === '"') {
       quote = quote === null ? char : null;
+    } else if (isQuoting && char === "$" && next === "'" && quote === null) {
+      quote = ANSI_QUOTE;
+      i++;
     } else if (isQuoting && char === "'" && quote === null) {
       quote = char;
     }
@@ -897,11 +1095,26 @@ function bodies(text, isQuoting) {
 function substitutions(command) {
   return splitCommand(command).flatMap((piece) => [...bodies(piece.command, true), ...bodies(piece.expanded, false)]);
 }
+function ansiEscape(text, at) {
+  const letter = text[at + 1] ?? "";
+  const simple = ANSI_ESCAPES[letter];
+  if (simple !== undefined)
+    return [simple, at + 1];
+  const hex = LEADING_HEX.exec(text.slice(at + 2, at + 2 + (ANSI_DIGITS[letter] ?? 0)))?.[0] ?? "";
+  if (hex !== "")
+    return [String.fromCodePoint(Number.parseInt(hex, 16)), at + 1 + hex.length];
+  const octal = OCTAL.exec(text.slice(at + 1))?.[0];
+  if (octal !== undefined)
+    return [String.fromCodePoint(Number.parseInt(octal, 8)), at + octal.length];
+  return [`\\${letter}`, at + 1];
+}
 function words(text) {
   const found = [];
   let current = "";
   let isStarted = false;
   let isProse = false;
+  let hasGlob = false;
+  let hasBrace = false;
   let quote = null;
   for (let i = 0;i < text.length; i++) {
     const char = text[i] ?? "";
@@ -911,40 +1124,79 @@ function words(text) {
       i++;
     if (quote === null && (isContinuation || WHITESPACE.test(char))) {
       if (isStarted)
-        found.push({ text: current, isProse });
+        found.push({ text: current, isProse, hasGlob, hasBrace });
       current = "";
       isStarted = false;
       isProse = false;
+      hasGlob = false;
+      hasBrace = false;
       continue;
     }
     if (isContinuation)
       continue;
     isStarted = true;
-    if (char === "\\" && quote === '"' && !DOUBLE_QUOTED_ESCAPES.has(text[i + 1] ?? ""))
+    if (char === "\\" && quote === ANSI_QUOTE) {
+      const [decoded, last] = ansiEscape(text, i);
+      current += decoded;
+      i = last;
+    } else if (char === "\\" && quote === '"' && !DOUBLE_QUOTED_ESCAPES.has(text[i + 1] ?? "")) {
       current += char;
-    else if (char === "\\" && quote !== "'")
+    } else if (char === "\\" && quote !== "'") {
       current += text[++i] ?? "";
-    else if (quote !== null && char === quote)
+    } else if (quote !== null && char === closerOf(quote)) {
       quote = null;
-    else if (quote === null && (char === '"' || char === "'"))
+    } else if (quote === null && char === "$" && text[i + 1] === "'") {
+      quote = ANSI_QUOTE;
+      i++;
+    } else if (quote === null && (char === '"' || char === "'")) {
       quote = char;
-    else
+    } else {
       current += char;
+      hasGlob ||= quote === null && GLOB_CHARS.has(char);
+      hasBrace ||= quote === null && char === "{";
+    }
     isProse ||= quote !== null && WHITESPACE.test(char);
   }
   if (isStarted)
-    found.push({ text: current, isProse });
+    found.push({ text: current, isProse, hasGlob, hasBrace });
   return found;
 }
 function tokenize(text) {
   return words(text).map((word) => word.text);
 }
+function skipOptions(tokens, spec) {
+  const take = (name, attached) => {
+    const value = attached === "" ? tokens.shift() ?? "" : attached;
+    if (name === "S" || name === "--split-string")
+      tokens.unshift(...tokenize(value));
+  };
+  while (tokens[0] !== undefined && tokens[0].startsWith("-") && tokens[0] !== "-") {
+    const option = tokens.shift() ?? "";
+    if (option === "--")
+      break;
+    if (option.startsWith("--")) {
+      const [name = "", ...value] = option.split("=");
+      if (spec.long.includes(name))
+        take(name, value.join("="));
+      continue;
+    }
+    for (const [index, letter] of [...option.slice(1)].entries()) {
+      if (!spec.short.includes(letter))
+        continue;
+      take(letter, option.slice(index + 2));
+      break;
+    }
+  }
+  for (let operand = 0;operand < spec.operands; operand++)
+    tokens.shift();
+}
 function parseCommand(text) {
   const tokens = tokenize(text);
   const assignments = [];
   let isWrapped = false;
   for (;; ) {
     const first = tokens[0] ?? "";
+    const spec = WRAPPERS.get(first.split("/").pop() ?? "");
     if (OPENERS.test(first)) {
       isWrapped = true;
       const rest = first.replace(OPENERS, "");
@@ -954,11 +1206,20 @@ function parseCommand(text) {
         tokens[0] = rest;
     } else if (ASSIGNMENT.test(first)) {
       assignments.push(tokens.shift() ?? "");
-    } else if (WRAPPERS.has(first)) {
+    } else if (KEYWORDS.has(first)) {
       isWrapped = true;
       tokens.shift();
-      while (tokens[0]?.startsWith("-"))
-        tokens.shift();
+    } else if (first === "case") {
+      isWrapped = true;
+      const at = tokens.indexOf("in");
+      tokens.splice(0, at === -1 ? tokens.length : at + 1);
+    } else if (tokens.length > 1 && CASE_LABEL.test(first)) {
+      isWrapped = true;
+      tokens.shift();
+    } else if (spec !== undefined) {
+      isWrapped = true;
+      tokens.shift();
+      skipOptions(tokens, spec);
     } else {
       break;
     }
@@ -972,6 +1233,131 @@ function parseCommand(text) {
   const [program = "", ...args] = tokens;
   return { program: program.split("/").pop() ?? "", args, assignments, isWrapped };
 }
+function quoted(word) {
+  return SAFE_WORD.test(word) || word === "{}" ? word : `'${word.replaceAll("'", "'\\''")}'`;
+}
+function commandStrings(tokens) {
+  const found = [];
+  for (const [i, token] of tokens.entries()) {
+    const name = token.split("/").pop() ?? "";
+    if (!COMMAND_STRING_PROGRAMS.has(name))
+      continue;
+    const isUser = name === "su" || name === "runuser";
+    let isValue = false;
+    for (let j = i + 1;j < tokens.length; j++) {
+      const option = tokens[j] ?? "";
+      if (isValue) {
+        isValue = false;
+        continue;
+      }
+      if (SHELL_VALUE_OPTIONS.has(option)) {
+        isValue = true;
+        continue;
+      }
+      if (option.startsWith("--command=")) {
+        found.push(option.slice("--command=".length));
+        break;
+      }
+      if (option === "--command" || !option.startsWith("--") && option.startsWith("-") && option.slice(1).includes("c")) {
+        found.push(tokens[j + 1] ?? "");
+        break;
+      }
+      if (!option.startsWith("-") && !isUser)
+        break;
+    }
+  }
+  return found;
+}
+function redirections(args) {
+  const operands = [];
+  const hereStrings = [];
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i] ?? "";
+    if (arg.startsWith("<<<"))
+      hereStrings.push(arg.length > 3 ? arg.slice(3) : args[++i] ?? "");
+    else if (REDIRECT_ONLY.test(arg))
+      i++;
+    else if (!REDIRECT_START.test(arg))
+      operands.push(arg);
+  }
+  return { operands, hereStrings };
+}
+function findExecs(args) {
+  const found = [];
+  for (const [i, arg] of args.entries()) {
+    if (!FIND_EXEC.has(arg))
+      continue;
+    const rest = args.slice(i + 1);
+    const end = rest.findIndex((word) => word === ";" || word === "+");
+    found.push((end === -1 ? rest : rest.slice(0, end)).map(quoted).join(" "));
+  }
+  return found;
+}
+function nestedCommands(piece, previous) {
+  const tokens = tokenize(piece.command);
+  const { program, args } = parseCommand(piece.command);
+  const found = commandStrings(tokens);
+  if (program === "eval")
+    found.push(args.join(" "));
+  if (program === "find")
+    found.push(...findExecs(args));
+  if (!SHELLS.has(program))
+    return found;
+  const { operands, hereStrings } = redirections(args);
+  if (operands.length > 0)
+    return found;
+  found.push(...piece.heredocs, ...hereStrings);
+  if (previous?.separator === "|") {
+    const before = parseCommand(previous.command);
+    if (PRINTERS.has(before.program))
+      found.push(...before.args, before.args.join(" "));
+  }
+  return found;
+}
+function commandsRun(command, depth = 0) {
+  const found = [command];
+  if (depth >= MAX_DEPTH)
+    return found;
+  const pieces = splitCommand(command);
+  for (const [index, piece] of pieces.entries()) {
+    const inner = withoutSubshell(piece.command);
+    const nested = [...bodies(piece.command, true), ...bodies(piece.expanded, false), ...nestedCommands(piece, pieces[index - 1])];
+    if (inner !== piece.command.trim())
+      nested.push(inner);
+    for (const each of nested)
+      found.push(...commandsRun(each, depth + 1));
+  }
+  return found;
+}
+function expandBraces(word) {
+  const open = word.indexOf("{");
+  if (open === -1)
+    return [word];
+  const alternatives = [];
+  let depth = 0;
+  let cut = open;
+  for (let i = open;i < word.length; i++) {
+    const char = word[i];
+    if (char === "{") {
+      depth++;
+    } else if (char === "," && depth === 1) {
+      alternatives.push(word.slice(cut + 1, i));
+      cut = i;
+    } else if (char === "}" && --depth === 0) {
+      if (alternatives.length === 0)
+        break;
+      alternatives.push(word.slice(cut + 1, i));
+      const prefix = word.slice(0, open);
+      const suffix = word.slice(i + 1);
+      return alternatives.flatMap((alternative) => expandBraces(prefix + alternative + suffix)).slice(0, MAX_BRACES + 1);
+    }
+  }
+  return expandBraces(word.slice(open + 1)).map((rest) => `${word.slice(0, open + 1)}${rest}`);
+}
+function braceExpand(word) {
+  const found = expandBraces(word);
+  return found.length > MAX_BRACES ? [word] : found;
+}
 function replacePieces(command, replacements) {
   let result = command;
   for (const [piece, text] of [...replacements].sort(([a], [b]) => b.start - a.start)) {
@@ -1005,10 +1391,14 @@ var LOCK_KIND = /^(?:update|share|no|key)$/;
 var DIGITS = /\d/;
 var COMMAND_ENDS = ";";
 var UNCLOSED = "unclosed";
+var NUL = "\x00";
+var UNICODE_IDENTIFIER = 'U&"';
+var UNICODE_PREFIX = /u&$/i;
+var LINE_END = /[\r\n]/;
 var PRIVILEGED_SET = new Set(["role", "session", "transaction"]);
 var READ_STARTS = new Set(["select", "with", "values", "table", "show", "explain"]);
 var WRITE_WORDS = new Set(["insert", "update", "delete", "merge", "truncate", "drop", "alter", "create", "grant", "revoke", "into", "call", "vacuum", "lock", "refresh", "reindex", "cluster", "do"]);
-var SIDE_EFFECT_FUNCTIONS = /^(?:nextval|setval|set_config|pg_terminate_backend|pg_cancel_backend|pg_reload_conf|pg_rotate_logfile|pg_switch_wal|pg_create_restore_point|pg_advisory_lock\w*|pg_advisory_xact_lock\w*|pg_try_advisory\w*|pg_notify|lo_\w+|dblink\w*|pg_read_file|pg_read_binary_file|pg_ls_dir|query_to_xml\w*|pg_logical_\w+|pg_replication_\w+|pg_drop_replication_slot|pg_stat_reset\w*|pg_promote|pg_file_\w+)$/;
+var SIDE_EFFECT_FUNCTIONS = /^(?:nextval|setval|set_config|pg_terminate_backend|pg_cancel_backend|pg_reload_conf|pg_rotate_logfile|pg_switch_wal|pg_create_restore_point|pg_advisory_lock\w*|pg_advisory_xact_lock\w*|pg_try_advisory\w*|pg_notify|lo_\w+|dblink\w*|pg_read_file|pg_read_binary_file|pg_ls_\w+|pg_stat_file|pg_sleep\w*|pg_export_snapshot|pg_backup_start|pg_backup_stop|pg_start_backup|pg_stop_backup|txid_current|pg_current_xact_id|pg_current_logfile|pg_wal_replay_\w+|\w+_to_xml\w*|pg_logical_\w+|pg_replication_\w+|pg_drop_replication_slot|pg_stat_reset\w*|pg_promote|pg_file_\w+)$/;
 function tokenize2(sql) {
   const tokens = [];
   let at = 0;
@@ -1017,21 +1407,29 @@ function tokenize2(sql) {
     const next = sql.charAt(at + 1);
     if (SPACE.test(char)) {
       at++;
+    } else if (char === NUL) {
+      tokens.push({ kind: "punct", text: NUL });
+      at++;
     } else if (char === "-" && next === "-") {
-      const end = sql.indexOf(`
-`, at);
-      at = end === -1 ? sql.length : end + 1;
+      const end = sql.slice(at).search(LINE_END);
+      at = end === -1 ? sql.length : at + end + 1;
     } else if (char === "/" && next === "*" && sql.charAt(at + 2) === "!") {
       at += 3;
       while (DIGITS.test(sql.charAt(at)))
         at++;
     } else if (char === "/" && next === "*") {
       at = skipComment(sql, at);
-    } else if (char === "'" || char === '"' || char === "`") {
-      const backslashes = char === "'" && ESCAPE_PREFIX.test(sql.charAt(at - 1)) && !WORD_PART.test(sql.charAt(at - 2));
+    } else if (char === "'") {
+      const backslashes = ESCAPE_PREFIX.test(sql.charAt(at - 1)) && !WORD_PART.test(sql.charAt(at - 2));
       const end = skipQuoted(sql, at, char, backslashes);
       at = end ?? sql.length;
       tokens.push({ kind: "punct", text: end === undefined ? UNCLOSED : char });
+    } else if (char === '"' || char === "`") {
+      const end = skipQuoted(sql, at, char, false);
+      if (char === '"' && UNICODE_PREFIX.test(sql.slice(Math.max(0, at - 2), at)) && !WORD_PART.test(sql.charAt(at - 3)))
+        tokens.push({ kind: "punct", text: UNICODE_IDENTIFIER });
+      tokens.push(end === undefined ? { kind: "punct", text: UNCLOSED } : { kind: "quoted", text: sql.slice(at + 1, end - 1).replaceAll(char + char, char) });
+      at = end ?? sql.length;
     } else if (char === "$" && DOLLAR_TAG.test(sql.slice(at))) {
       const tag = DOLLAR_TAG.exec(sql.slice(at))?.[0] ?? "$$";
       const end = sql.indexOf(tag, at + tag.length);
@@ -1116,6 +1514,12 @@ function statementWrites(statement) {
   for (const [index, token] of statement.entries()) {
     if (isPunct(token, UNCLOSED))
       reasons.push("has a quote that never closes");
+    else if (isPunct(token, NUL))
+      reasons.push("contains a NUL byte");
+    else if (isPunct(token, UNICODE_IDENTIFIER))
+      reasons.push("uses a U& escaped identifier");
+    if (token.kind === "quoted" && SIDE_EFFECT_FUNCTIONS.test(token.text))
+      reasons.push(`calls ${token.text}`);
     if (token.kind !== "word")
       continue;
     if (SIDE_EFFECT_FUNCTIONS.test(token.text)) {
@@ -1148,23 +1552,104 @@ function writes(sql) {
 var SQL_CLIENTS = new Set(["psql", "mysql", "mariadb", "pgcli", "mycli", "sqlite3"]);
 var WRITING_TOOLS = new Set(["dropdb", "createdb", "pg_restore"]);
 var CONSOLE_PROGRAMS = new Set(["php", "docker", "symfony", "console", "artisan"]);
-var STATEMENT_OPTIONS = new Set(["-c", "--command", "-e", "--execute"]);
-var FILE_OPTIONS = new Set(["-f", "--file", "<"]);
-var PRINTERS = new Set(["echo", "printf"]);
+var VALUE_SHORTS = { psql: "cdfhLopPRTUvF", pgcli: "dhUpW", mysql: "eDhPSuTA", mariadb: "eDhPSuTA", mycli: "eDhPSuTA", sqlite3: "" };
+var STATEMENT_SHORTS = { psql: "c", pgcli: "c", mysql: "e", mariadb: "e", mycli: "e", sqlite3: "" };
+var FILE_SHORTS = { psql: "f", pgcli: "", mysql: "", mariadb: "", mycli: "", sqlite3: "" };
+var IS_MYSQL = new Set(["mysql", "mariadb", "mycli"]);
+var DATABASE_SHORTS = new Set(["d", "D"]);
+var STATEMENT_LONGS = new Set(["--command", "--execute"]);
+var DATABASE_LONGS = new Set(["--dbname", "--database"]);
+var VALUE_LONGS = new Set(["--host", "--port", "--username", "--user", "--output", "--set", "--variable", "--field-separator", "--record-separator", "--pset", "--log-file", "--socket"]);
+var PRINTERS2 = new Set(["echo", "printf"]);
 var LIST_OPTIONS = new Set(["-l", "--list"]);
+var REDIRECT_ONLY2 = /^\d*(?:>|>>|>&|&>|>\||<&|<>)$/;
+var REDIRECT_START2 = /^\d*>|^&>/;
+var URL_DATABASE = /^[a-z][a-z\d+.-]*:\/\/[^/]*\/([^?#]*)/i;
 var WRITING_CONSOLE = /^(?:doctrine:(?:migrations:(?:migrate|execute|rollup)|schema:(?:update|create|drop)|database:(?:create|drop)|fixtures:load)|migrate(?::\w+)?|db:(?:seed|wipe))$/;
 var TEST_SCOPED = /(?:^|[^a-z])test/i;
 var SHOT_STACK = /\.worktrees\/[^/\s]+\/shot(?:\/|$)|--shot(?:-|$)/;
+var DEVICE_PATH = /^\/(?:dev|proc|sys)\//;
+var STDIN_PATHS = new Set(["-", "/dev/stdin"]);
 var SQL_WRITE = "Statements that write (INSERT, UPDATE, DELETE, DDL, migrations, fixtures) are handed over: list the exact command for the user to run. Only a clearly test-only database runs them directly.";
+var SQL_UNREADABLE = "A file this SQL client is fed cannot be read here (missing, a device, or too large), so what it runs is unknown. Hand over the exact command for the user to run.";
 function hasWrite(statement) {
   return writes(statement).length > 0;
 }
 function programOf(word) {
   return word.split("/").pop() ?? "";
 }
-function isTestScoped(words) {
-  const client = words.findIndex((word) => SQL_CLIENTS.has(programOf(word)));
-  return words.some((word, i) => (TEST_SCOPED.test(word) || SHOT_STACK.test(word)) && (i <= client || client === -1 || !STATEMENT_OPTIONS.has(words[i - 1] ?? "") && !FILE_OPTIONS.has(words[i - 1] ?? "")));
+function databaseOf(operand) {
+  return URL_DATABASE.exec(operand)?.[1] ?? operand;
+}
+function clientInput(name, args) {
+  const input = { statements: [], files: [], databases: [], operands: [] };
+  const valueShorts = VALUE_SHORTS[name] ?? "";
+  let isOperands = false;
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i] ?? "";
+    if (isOperands) {
+      input.operands.push(arg);
+    } else if (arg === "--") {
+      isOperands = true;
+    } else if (arg.startsWith("<<<")) {
+      input.statements.push(arg.length > 3 ? arg.slice(3) : args[++i] ?? "");
+    } else if (arg.startsWith("<<")) {
+      continue;
+    } else if (arg === "<") {
+      input.files.push(args[++i] ?? "");
+    } else if (arg.startsWith("<")) {
+      input.files.push(arg.slice(1));
+    } else if (REDIRECT_ONLY2.test(arg)) {
+      i++;
+    } else if (REDIRECT_START2.test(arg)) {
+      continue;
+    } else if (arg.startsWith("--")) {
+      const [option = "", ...rest] = arg.split("=");
+      const attached = rest.length > 0 ? rest.join("=") : undefined;
+      const value = attached ?? args[i + 1] ?? "";
+      if (STATEMENT_LONGS.has(option))
+        input.statements.push(value);
+      else if (option === "--file")
+        input.files.push(value);
+      else if (DATABASE_LONGS.has(option))
+        input.databases.push(databaseOf(value));
+      if (attached === undefined && (STATEMENT_LONGS.has(option) || option === "--file" || DATABASE_LONGS.has(option) || VALUE_LONGS.has(option)))
+        i++;
+    } else if (arg === "-cmd" && name === "sqlite3") {
+      input.statements.push(args[++i] ?? "");
+    } else if (arg.startsWith("-p") && IS_MYSQL.has(name)) {
+      continue;
+    } else if (arg.startsWith("-") && arg.length > 1) {
+      for (const [index, letter] of [...arg.slice(1)].entries()) {
+        if (!valueShorts.includes(letter))
+          continue;
+        const attached = arg.slice(index + 2);
+        const value = attached === "" ? args[++i] ?? "" : attached;
+        if (STATEMENT_SHORTS[name]?.includes(letter) === true)
+          input.statements.push(value);
+        else if (FILE_SHORTS[name]?.includes(letter) === true)
+          input.files.push(value);
+        else if (DATABASE_SHORTS.has(letter))
+          input.databases.push(databaseOf(value));
+        break;
+      }
+    } else {
+      input.operands.push(arg);
+    }
+  }
+  if (name === "sqlite3")
+    input.statements.push(...input.operands.slice(1));
+  else if (input.operands[0] !== undefined)
+    input.databases.push(databaseOf(input.operands[0]));
+  return input;
+}
+function isTestScoped(words, client, input) {
+  if (client === -1)
+    return words.some((word) => TEST_SCOPED.test(word) || SHOT_STACK.test(word));
+  return words.slice(0, client).some((word) => TEST_SCOPED.test(word) || SHOT_STACK.test(word)) || (input?.databases ?? []).some((name) => TEST_SCOPED.test(name));
+}
+async function fileText(path, read) {
+  return DEVICE_PATH.test(path) ? null : read(path);
 }
 async function sqlViolation(command, read) {
   const pieces = splitCommand(command);
@@ -1174,23 +1659,27 @@ async function sqlViolation(command, read) {
     const { program, args } = parseCommand(piece.command);
     if (program === "cd")
       inShotStack = SHOT_STACK.test(args[0] ?? "");
-    if (inShotStack || isTestScoped(words))
+    const client = words.findIndex((word) => SQL_CLIENTS.has(programOf(word)));
+    const input = client === -1 ? null : clientInput(programOf(words[client] ?? ""), words.slice(client + 1));
+    if (inShotStack || isTestScoped(words, client, input))
       continue;
     if (WRITING_TOOLS.has(program) && !words.some((word) => LIST_OPTIONS.has(word)))
       return SQL_WRITE;
     if (CONSOLE_PROGRAMS.has(program) && words.some((word) => WRITING_CONSOLE.test(word)))
       return SQL_WRITE;
-    const client = words.findIndex((word) => SQL_CLIENTS.has(programOf(word)));
-    if (client === -1)
+    if (input === null)
       continue;
-    const files = words.filter((_, i) => i > client && FILE_OPTIONS.has(words[i - 1] ?? ""));
     const before = index === 0 ? null : parseCommand(pieces[index - 1]?.command ?? "");
+    const isPiped = pieces[index - 1]?.separator === "|";
+    const paths = input.files.filter((path) => !STDIN_PATHS.has(path));
+    const texts = await Promise.all([...paths, ...isPiped && before?.program === "cat" ? before.args.filter((arg) => !arg.startsWith("-")) : []].map(async (path) => fileText(path, read)));
+    if (texts.includes(null))
+      return SQL_UNREADABLE;
     const statements = [
-      ...words.filter((_, i) => i > client && STATEMENT_OPTIONS.has(words[i - 1] ?? "")),
-      piece.text === piece.command ? "" : piece.text.slice(piece.text.indexOf(`
-`)),
-      before !== null && PRINTERS.has(before.program) ? before.args.join(" ") : "",
-      ...(await Promise.all(files.map(read))).map((text) => text ?? "")
+      ...input.statements,
+      ...piece.heredocs,
+      isPiped && before !== null && PRINTERS2.has(before.program) ? before.args.join(" ") : "",
+      ...texts.map((text) => text ?? "")
     ];
     if (statements.some(hasWrite))
       return SQL_WRITE;
@@ -1199,17 +1688,49 @@ async function sqlViolation(command, read) {
 }
 
 // ../env/src/files.ts
-var ENV_FILE = /^\.env(?:\..+)?$/;
+var ENV_FILE = /^(?:\.env(?:\..+)?|.+\.env|\.envrc)$/;
 var TEMPLATE = /\.(?:example|sample|template|dist|defaults)$/;
+var SKIPPED = new Set(["node_modules", ".git", "vendor"]);
 
 // ../env/src/guard.ts
 var REDIRECT = /^\d*[<>]+&?/;
+var ENVRC = ".envrc";
+var PROC_ENVIRON = /^\/proc\/[^/]+\/environ$/;
+var ENV_NAME_IN_CODE = /(?:^|[^\w.-])(\.env(?:\.[\w.-]*\w)?|\.envrc)(?![\w-])/g;
+var PYTHON_ENVIRON = /\bos\.environ\b(?!\s*(?:\[|\.get\b))/;
+var VARIABLE = /\$(?:(\w+)|\{(\w+)\})/;
+var ASSIGNMENT2 = /^\w+=/;
+var SHORT_FLAGS = /^-[a-z]+$/i;
+var OPENER = /^[({]+/;
+var ENV_SAMPLES = [".env", ".env.local", ".env.production", ".envrc"];
+var MAX_VARIANTS = 64;
+var INTERPRETERS = new Set(["bun", "deno", "node", "python", "python3", "ruby", "perl", "php", "lua", "awk", "gawk"]);
+var CODE_OPTIONS = new Set(["-e", "-c", "-p", "-E", "-pe", "-r", "--eval", "--print", "--command"]);
+var GREPS = new Set(["grep", "egrep", "fgrep"]);
+var GREP_VALUE_OPTIONS = new Set(["-e", "-f", "-m", "-A", "-B", "-C", "-d", "-D", "--regexp", "--file", "--max-count", "--include", "--exclude", "--exclude-dir", "--exclude-from", "--context", "--after-context", "--before-context", "--label", "--binary-files", "--directories", "--devices"]);
+var RG_VALUE_OPTIONS = new Set(["-e", "-f", "-g", "-t", "-T", "-m", "-A", "-B", "-C", "-j", "-d", "--regexp", "--file", "--glob", "--iglob", "--type", "--type-not", "--max-count", "--context", "--after-context", "--before-context", "--threads", "--max-depth", "--max-filesize"]);
+var PATTERN_OPTIONS = new Set(["-e", "-f", "--regexp", "--file"]);
+var HIDDEN_FLAGS = /^(?:-u{2,}|--hidden|-\.)$/i;
+var REGEX_SPECIALS = /[.+^${}()|\\[\]]/g;
+var NEGATED_CLASS = /^!/;
+var GLOB_CHAR = /[*?[]/;
+var HAS_R = /r/i;
+var DUMP_FLAGS = /^-[a-z]*[px]/;
+var DECLARERS = new Set(["export", "declare", "local", "readonly", "typeset"]);
+var WHOLE_TREE_OPERAND = /^(?:(?:\.\.?\/?)+|~\/?|\$HOME\/?|\/)$/;
+var GIT_PATCHES = new Set(["diff", "log", "show", "whatchanged", "format-patch", "grep"]);
+var GIT_NO_PATCH = new Set(["--stat", "--numstat", "--shortstat", "--name-only", "--name-status", "--summary", "-s", "--no-patch", "--check", "--quiet"]);
+var GIT_VALUE_OPTIONS = new Set(["-C", "-c", "--git-dir", "--work-tree", "--namespace", "--exec-path"]);
+var GIT_PATCH_FLAGS = new Set(["-p", "-u", "--patch", "-c", "--cc", "--patch-with-stat", "--patch-with-raw"]);
+var GIT_EXCLUDE = /^:(?:!|\^|\(exclude\))/;
+var EXCLUDES_ENV = /^(?:--exclude(?:-dir)?=.*env|(?:--glob=|--iglob=|-g)?!.*env)/;
+var EXCLUDE_OPTIONS = new Set(["--exclude", "--exclude-dir", "-g", "--glob", "--iglob"]);
 var ENV_DUMP = /(?:console\.\w+|JSON\.stringify|Object\.(?:entries|keys|values)|print)\(\s*process\.env\s*[,)]/;
 var HARMLESS = new Set(["ev", "redact", "ls", "stat", "test", "[", "[[", "touch"]);
 var GIT_HARMLESS = new Set(["check-ignore", "ls-files", "status"]);
 var ENV_PRINTERS = new Set(["env", "printenv"]);
 var DOCKER = new Set(["docker", "docker-compose"]);
-var SHELLS = new Set(["sh", "bash", "zsh", "ash"]);
+var SHELLS2 = new Set(["sh", "bash", "zsh", "ash"]);
 var DOCKER_VALUE_OPTIONS = new Set(["-f", "--file", "-p", "--project-name", "--profile", "--env-file", "--project-directory", "--ansi", "--progress", "--parallel", "-H", "--host", "-c", "--context", "--config", "-l", "--log-level"]);
 var EXEC_VALUE_OPTIONS = new Set(["-e", "--env", "--env-file", "-u", "--user", "-w", "--workdir", "--index", "--detach-keys"]);
 var CONFIG_LISTS = new Set(["--services", "--volumes", "--profiles", "--images", "--networks", "--hash", "-q", "--quiet"]);
@@ -1218,13 +1739,79 @@ var WHOLE_FORMAT = /Env|\{\{\s*json\s+\.\s*\}\}|^json$/;
 var USE_EV = '.env files hold secrets that must never reach the transcript, so they are not read, edited or printed directly. Use `ev` instead: `ev list`, `ev get KEY` (masked), `ev grep <regex>` for the keys matching it, `ev show <rev>:<file>` for one at a git revision, `printf %s "$value" | ev set KEY [file]` (`--empty` for an empty value), `ev unset KEY`, `ev cp KEY --from .env --to .env.local`, `ev mv KEY --from .env --to .env.local`, `ev diff a b`, `ev missing`; and pipe output that may carry a secret through `redact`, as `docker compose exec <svc> printenv | redact` or `docker compose config | redact`. If `ev` is missing: `bun install -g @kaynooo/env-tools`.';
 function isEnvFile(path) {
   const name = path.slice(Math.max(path.lastIndexOf("/"), path.lastIndexOf(":")) + 1);
-  return (ENV_FILE.test(name) || name === ".env*") && !TEMPLATE.test(name);
+  return (ENV_FILE.test(name) || name === ".env*" || name === ENVRC) && !TEMPLATE.test(name);
+}
+function globRegex(glob) {
+  let source = "";
+  for (let i = 0;i < glob.length; i++) {
+    const char = glob[i] ?? "";
+    const close = char === "[" ? glob.indexOf("]", i + 2) : -1;
+    if (char === "*") {
+      source += ".*";
+    } else if (char === "?") {
+      source += ".";
+    } else if (close === -1) {
+      source += char.replace(REGEX_SPECIALS, String.raw`\$&`);
+    } else {
+      source += `[${glob.slice(i + 1, close).replace(NEGATED_CLASS, "^")}]`;
+      i = close;
+    }
+  }
+  return new RegExp(`^${source}$`);
 }
-function namesEnvFile(word, previous) {
-  if (previous === "--env-file" || word.startsWith("--env-file="))
+function globReachesEnv(path) {
+  const name = path.slice(path.lastIndexOf("/") + 1);
+  if (!name.startsWith(".") || !GLOB_CHAR.test(name))
     return false;
+  const regex = globRegex(name);
+  return ENV_SAMPLES.some((sample) => regex.test(sample));
+}
+function reachesEnvFile(path) {
+  return braceExpand(path).some((each) => isEnvFile(each) || globReachesEnv(each));
+}
+function targetOf(word) {
   const bare = word.replace(REDIRECT, "");
-  return isEnvFile(bare.includes("=") ? bare.slice(bare.indexOf("=") + 1) : bare);
+  return bare.includes("=") ? bare.slice(bare.indexOf("=") + 1) : bare;
+}
+function namesEnvFile(word, previous, isGlob) {
+  if (previous === "--env-file" || word.startsWith("--env-file=") || word.startsWith("--exclude") || EXCLUDE_OPTIONS.has(previous ?? ""))
+    return false;
+  const path = targetOf(word);
+  return isEnvFile(path) || PROC_ENVIRON.test(path) || isGlob && globReachesEnv(path);
+}
+function variablesOf(command) {
+  const variables = new Map;
+  const add = (assignment) => {
+    const at = assignment.indexOf("=");
+    const name = assignment.slice(0, at);
+    variables.set(name, [...variables.get(name) ?? [], assignment.slice(at + 1)]);
+  };
+  for (const piece of splitCommand(command)) {
+    const { program, args, assignments } = parseCommand(piece.command);
+    const tokens = tokenize(piece.command);
+    const declared = DECLARERS.has(program) ? args.filter((arg) => ASSIGNMENT2.test(arg)) : [];
+    for (const assignment of [...assignments, ...declared])
+      add(assignment);
+    if (tokens[0] === "for" && tokens[2] === "in" && tokens[1] !== undefined)
+      variables.set(tokens[1], [...variables.get(tokens[1]) ?? [], ...tokens.slice(3)]);
+  }
+  return variables;
+}
+function variantsOf(word, variables) {
+  let found = [word.text];
+  for (let round = 0;round < 4 && found.some((each) => VARIABLE.test(each)); round++) {
+    found = found.flatMap((each) => {
+      const match = VARIABLE.exec(each);
+      const values = variables.get(match?.[1] ?? match?.[2] ?? "");
+      if (match === null || values === undefined)
+        return [each.replace(VARIABLE, "")];
+      return values.map((value) => each.slice(0, match.index) + value + each.slice(match.index + match[0].length));
+    }).slice(0, MAX_VARIANTS);
+  }
+  return found.flatMap((each) => word.hasBrace ? braceExpand(each) : [each]);
+}
+function codeReadsEnv(found) {
+  return found.some((word, i) => (word.isProse || CODE_OPTIONS.has(found[i - 1]?.text ?? "")) && (PYTHON_ENVIRON.test(word.text) || [...word.text.matchAll(ENV_NAME_IN_CODE)].some((match) => isEnvFile(match[1] ?? ""))));
 }
 function firstOperand(words, valueOptions) {
   for (let i = 0;i < words.length; i++) {
@@ -1237,7 +1824,7 @@ function firstOperand(words, valueOptions) {
   return words.length;
 }
 function printsEnv([program = "", ...args]) {
-  if (SHELLS.has(program) && args[0] === "-c")
+  if (SHELLS2.has(program) && args[0] === "-c")
     return splitCommand(args[1] ?? "").some((piece) => ENV_PRINTERS.has(tokenize(piece.command)[0] ?? ""));
   return ENV_PRINTERS.has(program);
 }
@@ -1259,24 +1846,79 @@ function dumpsContainerEnv(program, args) {
   const format = after.find((_, i) => FORMAT_OPTIONS.has(after[i - 1] ?? "")) ?? after.find((word) => word.startsWith("--format="))?.slice("--format=".length);
   return format === undefined || WHOLE_FORMAT.test(format);
 }
-function readsEnv(piece) {
+function readsEnv(piece, variables) {
   const { program, args } = parseCommand(piece.command);
   const found = words(piece.command);
   if (program === "" || HARMLESS.has(program) || program === "git" && GIT_HARMLESS.has(args[0] ?? ""))
     return false;
-  return found.some((word, index) => !word.isProse && namesEnvFile(word.text, found[index - 1]?.text));
+  if (INTERPRETERS.has(program) && codeReadsEnv(found))
+    return true;
+  const isExclusion = (word) => program === "git" && GIT_EXCLUDE.test(word.text);
+  return found.some((word, index) => !word.isProse && !isExclusion(word) && variantsOf(word, variables).some((variant) => namesEnvFile(variant, found[index - 1]?.text, word.hasGlob)));
 }
-function touchesEnv(command) {
+function operandsOf(args, valueOptions) {
+  const operands = [];
+  let hasPattern = false;
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i] ?? "";
+    if (PATTERN_OPTIONS.has(arg) || arg.startsWith("--regexp=") || arg.startsWith("--file="))
+      hasPattern = true;
+    if (valueOptions.has(arg))
+      i++;
+    else if (!arg.startsWith("-"))
+      operands.push(arg);
+  }
+  return hasPattern ? operands : operands.slice(1);
+}
+function searchesEnv(program, args) {
+  const isGrep = GREPS.has(program);
+  if (!isGrep && program !== "rg" && program !== "ag")
+    return false;
+  const isRecursive = args.some((arg) => SHORT_FLAGS.test(arg) && HAS_R.test(arg) || arg === "--recursive" || arg === "--dereference-recursive");
+  const isHidden = args.some((arg) => HIDDEN_FLAGS.test(arg) || program === "ag" && (arg === "-u" || arg === "--unrestricted"));
+  const isLimited = args.some((arg, i) => arg.startsWith("--include") || EXCLUDES_ENV.test(arg) || EXCLUDE_OPTIONS.has(args[i - 1] ?? "") && arg.includes("env"));
+  if (isLimited || (isGrep ? !isRecursive : !isHidden))
+    return false;
+  const operands = operandsOf(args, isGrep ? GREP_VALUE_OPTIONS : RG_VALUE_OPTIONS);
+  return operands.length === 0 || operands.some((operand) => WHOLE_TREE_OPERAND.test(operand));
+}
+function dumpsEnvironment(program, args, tokens) {
+  const isBare = args.every((arg) => arg.startsWith("-"));
+  if (program === "printenv" || program === "export")
+    return isBare;
+  if (program === "declare" || program === "typeset")
+    return isBare && args.some((arg) => DUMP_FLAGS.test(arg));
+  if (program === "set")
+    return args.length === 0;
+  return program === "" && tokens.some((token) => token.replace(OPENER, "") === "env");
+}
+function printsTrackedEnv(program, args) {
+  if (program !== "git")
+    return false;
+  const at = args.findIndex((arg, i) => !arg.startsWith("-") && !GIT_VALUE_OPTIONS.has(args[i - 1] ?? ""));
+  const name = args[at] ?? "";
+  const rest = args.slice(at + 1);
+  if (!GIT_PATCHES.has(name) || rest.some((arg) => GIT_EXCLUDE.test(arg)))
+    return false;
+  if (name === "grep")
+    return true;
+  if (name === "log" || name === "whatchanged")
+    return rest.some((arg) => GIT_PATCH_FLAGS.has(arg));
+  return !rest.some((arg) => GIT_NO_PATCH.has(arg));
+}
+function touchesEnv(command, options = {}) {
   if (ENV_DUMP.test(command))
     return true;
-  if (substitutions(command).some(touchesEnv))
+  if (substitutions(command).some((each) => touchesEnv(each, options)))
     return true;
   const pieces = splitCommand(command);
+  const variables = variablesOf(command);
   return pieces.some((piece, index) => {
-    if (readsEnv(piece))
-      return true;
     const { program, args } = parseCommand(piece.command);
-    if (!dumpsContainerEnv(program, args))
+    if (readsEnv(piece, variables) || searchesEnv(program, args))
+      return true;
+    const isDump = dumpsContainerEnv(program, args) || dumpsEnvironment(program, args, tokenize(piece.command)) || options.hasTrackedEnv === true && printsTrackedEnv(program, args);
+    if (!isDump)
       return false;
     for (let at = index;pieces[at]?.separator === "|"; at++) {
       if (parseCommand(pieces[at + 1]?.command ?? "").program === "redact")
@@ -1287,17 +1929,19 @@ function touchesEnv(command) {
 }
 
 // ../git/src/message.ts
-var CONVENTIONAL = /^[a-z]+(?:\([^()\n]+\))?!?: \S/;
+var CONVENTIONAL = /^(?:feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(?:\([^()\n]+\))?!?: \S/;
+var MAX_TITLE = 100;
 var GIT_MADE = /^(?:Merge |Revert "|fixup! |squash! |amend! )/;
 var TICKET = /^(?:[\w.-]+\/[\w.-]+)?#\d+ - /;
 var BREAKING = /^BREAKING[ -]CHANGE: /;
 var BREAKING_TITLE = /^[a-z]+(?:\([^()\n]+\))?!: /;
-var TRAILER = /^(?:co-authored-by|signed-off-by|reviewed-by|acked-by|tested-by|reported-by|suggested-by|helped-by|change-id):|^\W*generated with\b/i;
+var TRAILER = /^(?:co-authored-by|signed-off-by|reviewed-by|acked-by|tested-by|reported-by|suggested-by|helped-by|change-id):|^\W*generated with \W*claude/i;
 var BULLET = /^\s*(?:[-*+]|\d+[.)])\s/;
 var SENTENCE_END = /[.!?:;)\]`'"]$/;
 var LOWER_START = /^\p{Ll}/u;
 var RULE = 'The rule: a `type(scope): title` line, `!` after the scope for a breaking change, type and scope taken from the repository\'s history; then optionally a blank line and one or two lines on what changed, never a bullet list or a hard-wrapped sentence; then a blank line and one line per ticket, its title copied verbatim, `#<n> - <title>` (`owner/repo#<n> - <title>` for another repository). The message ends there: no Co-Authored-By, Signed-off-by or "Generated with" trailer. Only a breaking change gives full details.';
 var TITLE = `The title is no Conventional Commit. ${RULE}`;
+var TITLE_TOO_LONG = `The title runs past ${MAX_TITLE} characters: shorten it and move the detail to the body. ${RULE}`;
 var TITLE_LINE = `The title takes one line and a blank line follows it. ${RULE}`;
 var TRAILERS = `No trailers, ever: no Co-Authored-By, Signed-off-by or "Generated with" line, no --signoff or --trailer. ${RULE}`;
 var BULLETS = `The body names what changed in a line or two, never a bullet list narrating the diff. ${RULE}`;
@@ -1323,20 +1967,26 @@ function commitMessageViolation(message) {
     return TITLE;
   if (second !== undefined && second !== "")
     return TITLE_LINE;
-  if (BREAKING_TITLE.test(title) || body.some((line) => BREAKING.test(line)))
+  if (!GIT_MADE.test(title) && title.length > MAX_TITLE)
+    return TITLE_TOO_LONG;
+  if (BREAKING_TITLE.test(title))
     return null;
-  const descriptions = body.filter(isDescription);
+  const footer = body.findIndex((line) => BREAKING.test(line));
+  const described = footer === -1 ? body : body.slice(0, footer);
+  const descriptions = described.filter(isDescription);
   if (descriptions.some((line) => BULLET.test(line)))
     return BULLETS;
   if (descriptions.length > 2)
     return TOO_LONG;
-  const isWrapped = body.some((line, i) => isDescription(line) && isDescription(body[i + 1]) && !SENTENCE_END.test(line) && LOWER_START.test(body[i + 1] ?? ""));
+  const isWrapped = described.some((line, i) => isDescription(line) && isDescription(described[i + 1]) && !SENTENCE_END.test(line) && LOWER_START.test(described[i + 1] ?? ""));
   return isWrapped ? WRAPPED : null;
 }
 
 // ../out/src/wrap.ts
-var ASSIGNMENT2 = /^\w+=/;
-var EXCLUDED = /(?:^|\s)(?:--json|--help|--version|-h)(?:\s|$)/;
+var ASSIGNMENT3 = /^\w+=/;
+var EXCLUDED = /(?:^|\s)(?:--json|--help|--version|-h|--watch(?:-?all|=\S*)?|--watchAll)(?:\s|$)/;
+var SHORT_WATCH = /(?:^|\s)(?:\S*\/)?(?:tsc|tsgo|vue-tsc|vitest|jest)\s(?:.*\s)?-w(?:\s|$)/;
+var LONG_RUNNING = /^(?:dev|watch|serve|start|up|run|preview|storybook)(?:[:-]\S*)?$/;
 var BUN_SCRIPT = /^(?:build|check|lint|typecheck|types|test|ci|verify|compile)(?::|$)/;
 var BUN_TOOLS = new Set(["tsc", "tsgo", "eslint", "keslint", "vitest", "jest", "prettier", "playwright", "biome", "vue-tsc"]);
 var BUN_SUBCOMMANDS = new Set(["install", "i", "add", "remove", "rm", "update", "test", "check", "lint", "build"]);
@@ -1372,9 +2022,9 @@ var RULES = {
   "php-cs-fixer": always,
   rector: always,
   php: (args) => listed(afterOptions(args, PHP_VALUE_OPTIONS)),
-  make: always,
+  make: ([first]) => first === undefined || !LONG_RUNNING.test(first),
   check: always,
-  just: ([first]) => first !== undefined && !first.startsWith("-"),
+  just: ([first]) => first !== undefined && !first.startsWith("-") && !LONG_RUNNING.test(first),
   composer: ([sub]) => sub === "install" || sub === "update" || sub === "require",
   pip: ([sub]) => sub === "install",
   cargo: ([sub]) => ["build", "test", "check", "clippy"].includes(sub ?? ""),
@@ -1432,14 +2082,14 @@ function withoutFilters(command) {
   return rest;
 }
 function listed(words) {
-  const start = words.findIndex((word) => !ASSIGNMENT2.test(word));
+  const start = words.findIndex((word) => !ASSIGNMENT3.test(word));
   const path = words[start];
   if (path === undefined)
     return false;
   return RULES[path.slice(path.lastIndexOf("/") + 1)]?.(words.slice(start + 1)) ?? false;
 }
 function listedSegment(segment) {
-  return !EXCLUDED.test(segment) && listed(tokenize(segment));
+  return !EXCLUDED.test(segment) && !SHORT_WATCH.test(segment) && listed(tokenize(segment));
 }
 function isCd(segment) {
   return segment === "cd" || segment.startsWith("cd ");
@@ -1450,14 +2100,14 @@ function shouldWrap(command) {
     return false;
   return segments.every((segment) => isCd(segment) || listedSegment(segment));
 }
-function quoted(value) {
+function quoted2(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
 function wrap(command) {
   const trimmed = withoutFilters(command.trim());
-  if (scan(trimmed).segments.length <= 1 && !ASSIGNMENT2.test(trimmed))
+  if (scan(trimmed).segments.length <= 1 && !ASSIGNMENT3.test(trimmed))
     return `out -- ${trimmed}`;
-  return `out -- sh -c ${quoted(trimmed)}`;
+  return `out -- sh -c ${quoted2(trimmed)}`;
 }
 
 // ../pkg/src/added.ts
@@ -1466,10 +2116,18 @@ var BARE_REDIRECT = /^\d*(?:[<>]|>>)$/;
 var ADDS = {
   bun: new Set(["add", "a", "install", "i"]),
   npm: new Set(["install", "i", "add", "in", "isntall"]),
-  pnpm: new Set(["add"]),
+  pnpm: new Set(["add", "i", "install"]),
   yarn: new Set(["add"])
 };
-var VALUE_FLAGS = new Set(["--cwd", "--filter", "-F", "--workspace", "--registry", "--prefix", "-C", "--dir", "--config", "--cache-dir"]);
+var RUNS = {
+  bun: new Set(["x"]),
+  npm: new Set(["exec", "x"]),
+  pnpm: new Set(["dlx"]),
+  yarn: new Set(["dlx"])
+};
+var RUNNERS = new Set(["bunx", "npx"]);
+var PACKAGE_FLAGS = new Set(["-p", "--package"]);
+var VALUE_FLAGS = new Set(["--cwd", "--filter", "-F", "--workspace", "--registry", "--prefix", "-C", "--dir", "--config", "--cache-dir", "--loglevel", "--tag", "--save-prefix", "--userconfig", "--omit", "--include", "--fetch-timeout", "--fetch-retries", "--install-strategy", "--cache", ...PACKAGE_FLAGS]);
 var NOT_REGISTRY = /^(?:[./~]|file:|link:|portal:|workspace:|git[+:]|github:|gitlab:|bitbucket:|https?:)|\.tgz$|^[\w.-]+\/[\w.-]+(?:#.*)?$/;
 var NPM_ALIAS = /^(?:@[^/]+\/)?[^@]+@npm:(.+)$/;
 var PUBLISH = /\b(?:ft|cli\.ts)\s+release\b|\b(?:bun|npm|pnpm|yarn)\s+publish\b|\bjust\s+(?:patch|minor|major)\b/;
@@ -1479,16 +2137,38 @@ function addedPackages(command) {
     published ||= PUBLISH.test(piece.command);
     const { program, args } = parseCommand(piece.command);
     const [sub = "", ...rest] = args;
-    if (published || !ADDS[program]?.has(sub))
+    if (published)
+      return [];
+    if (RUNNERS.has(program))
+      return runnerPackages(args);
+    if (RUNS[program]?.has(sub))
+      return runnerPackages(rest);
+    if (!ADDS[program]?.has(sub))
       return [];
-    return rest.flatMap((word, index) => {
-      const previous = rest[index - 1] ?? "";
-      if (word.startsWith("-") || REDIRECT2.test(word) || VALUE_FLAGS.has(previous) || BARE_REDIRECT.test(previous) || NOT_REGISTRY.test(word))
-        return [];
-      return [NPM_ALIAS.exec(word)?.[1] ?? word];
-    });
+    return rest.flatMap((word, index) => isSkipped(word, rest[index - 1] ?? "") ? [] : registryName(word));
   });
 }
+function isSkipped(word, previous) {
+  return word.startsWith("-") || REDIRECT2.test(word) || VALUE_FLAGS.has(previous) || BARE_REDIRECT.test(previous);
+}
+function registryName(word) {
+  return NOT_REGISTRY.test(word) ? [] : [NPM_ALIAS.exec(word)?.[1] ?? word];
+}
+function runnerPackages(words) {
+  const named = [];
+  for (const [index, word] of words.entries()) {
+    const previous = words[index - 1] ?? "";
+    if (PACKAGE_FLAGS.has(previous))
+      named.push(word);
+    else if (word.startsWith("--package="))
+      named.push(word.slice("--package=".length));
+    else if (!isSkipped(word, previous) && named.length === 0)
+      return registryName(word);
+    else if (!isSkipped(word, previous))
+      break;
+  }
+  return named.flatMap(registryName);
+}
 
 // ../pkg/src/pin.ts
 var LOCKFILES = [
@@ -1617,11 +2297,16 @@ var COMMIT_VALUE_LONGS = new Set(["--message", "--file", "--reuse-message", "--r
 var SHORT_CLUSTER = /^-[A-Z]+$/i;
 var STAGES_ALL = /[Au]/;
 var ALL_TAGS = new Set(["--tags", "--follow-tags"]);
+var TOP_MAGIC = /^:(?:\/|\([^)]*\))/;
+var RISKY_CONFIG = /^(?:alias\.|core\.(?:sshcommand|hookspath|pager|editor|fsmonitor|askpass|gitproxy)|credential\.|diff\.external|sequence\.editor|pager\.|filter\.|gpg\..*program)/i;
+var RISKY_ENV = /^GIT_(?:CONFIG_(?:COUNT|PARAMETERS)|EXTERNAL_DIFF|ASKPASS|PROXY_COMMAND|PAGER)=/;
+var READS_CONFIG = new Set(["--get", "--get-all", "--get-regexp", "--list", "-l", "--unset", "--unset-all", "--show-origin", "--show-scope"]);
 var STAGE_BY_PATH = `Stage by path: the tree carries unrelated work and peer sessions edit it live. ${USE_GC}`;
 var STASH = "Never `git stash`: a pop with nothing saved applies someone else's old stash. To prove a test fails without your change, `proof --keep <test> -- <cmd>` runs it at HEAD in a temporary worktree and again here; `base -- <cmd>` runs any command at HEAD (`--ref <rev>` another commit), the working tree untouched. To set edits aside before a cherry-pick, a rebase or a checkout, commit them with `gc` first, or do the other work in `git worktree add`.";
 var ADD_ALL = `\`git add\` over the whole tree is refused. ${STAGE_BY_PATH}`;
 var COMMIT_ALL = `\`git commit -a\` stages the whole tree and is refused. ${STAGE_BY_PATH}`;
 var PUSH = "`git push` runs only when the user asked for a push in their latest prompt: say the commit is ready and let them ask.";
+var CONFIG_OVERRIDE = "Never set git config that runs a program or defines a command (`-c alias.*`, `--config-env`, `core.sshCommand`, `core.hooksPath`, `core.pager`, credential helpers, `git config alias.*`): it sidesteps every rule here. Run the git command itself.";
 var TAGS_APART = "A tag goes out with its branch in one `git push --atomic origin <branch> <tag>`, never a separate `git push --tags`.";
 function subcommandOf(args) {
   for (let i = 0;i < args.length; i++) {
@@ -1633,6 +2318,35 @@ function subcommandOf(args) {
   }
   return { name: "", rest: [] };
 }
+function overridesConfig(args) {
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i] ?? "";
+    if (arg === "--config-env" || arg.startsWith("--config-env="))
+      return true;
+    if (arg === "-c" && RISKY_CONFIG.test(args[i + 1] ?? ""))
+      return true;
+    if (GLOBAL_VALUE_OPTIONS.has(arg))
+      i++;
+    else if (!arg.startsWith("-"))
+      return false;
+  }
+  return false;
+}
+function isWholeTree(arg) {
+  if (WHOLE_TREE.has(arg))
+    return true;
+  if (arg.startsWith("-"))
+    return SHORT_CLUSTER.test(arg) && STAGES_ALL.test(arg);
+  const parts = [];
+  for (const part of arg.replace(TOP_MAGIC, "").split("/")) {
+    if (part === ".." && parts.length > 0 && parts.at(-1) !== "..")
+      parts.pop();
+    else if (part !== "" && part !== ".")
+      parts.push(part);
+  }
+  const path = parts.join("/");
+  return path === "" || path === ".." || WHOLE_TREE.has(path);
+}
 function commitsAll(args) {
   for (let i = 0;i < args.length; i++) {
     const arg = args[i] ?? "";
@@ -1660,13 +2374,19 @@ function commitsAll(args) {
 }
 function gitViolation(command, isPushAsked = false) {
   for (const piece of splitCommand(command)) {
-    const { program, args } = parseCommand(piece.command);
+    const { program, args, assignments } = parseCommand(piece.command);
+    if (assignments.some((assignment) => RISKY_ENV.test(assignment)))
+      return CONFIG_OVERRIDE;
     if (program !== "git")
       continue;
+    if (overridesConfig(args))
+      return CONFIG_OVERRIDE;
     const { name, rest } = subcommandOf(args);
+    if (name === "config" && rest.length > 1 && rest.some((arg) => RISKY_CONFIG.test(arg)) && !rest.some((arg) => READS_CONFIG.has(arg)))
+      return CONFIG_OVERRIDE;
     if (name === "stash" && !READ_ONLY_STASH.has(rest[0] ?? ""))
       return STASH;
-    if (name === "add" && rest.some((arg) => WHOLE_TREE.has(arg) || SHORT_CLUSTER.test(arg) && STAGES_ALL.test(arg)))
+    if (name === "add" && rest.some(isWholeTree))
       return ADD_ALL;
     if (name === "commit" && commitsAll(rest))
       return COMMIT_ALL;
@@ -1767,19 +2487,63 @@ function inlineMessage(parts) {
 }
 
 // src/remote.ts
-var SHELL_PROGRAMS = new Set(["ssh", "scp", "sftp", "mosh", "autossh"]);
+var SHELL_PROGRAMS = new Set(["ssh", "scp", "sftp", "mosh", "mosh-client", "autossh"]);
+var SOCKET_PROGRAMS = new Set(["nc", "ncat", "netcat", "telnet", "socat"]);
+var URL_PROGRAMS = new Set(["git", "docker", "docker-compose"]);
+var DECLARERS2 = new Set(["export", "declare", "typeset"]);
 var RSYNC_REMOTE = /^(?:[\w.-]+@)?[\w.-]{2,}:/;
 var SSH_URL = /^ssh:\/\//;
+var SSH_URL_WORD = /^(?:[\w-]+=)?ssh:\/\//;
+var LOOPBACK = /(?:^|[:=@[])(?:localhost|127(?:\.\d+){3}|::1)(?:[:\]/]|$)/;
+var LISTENS = /^-[A-KM-Z]*L[A-Z]*$/i;
+var DOCKER_VALUE_OPTIONS2 = new Set(["-c", "--context", "-H", "--host", "-l", "--log-level", "--config", "--tlscacert", "--tlscert", "--tlskey"]);
+var CONTEXT_CHANGES = new Set(["use", "create", "update", "import"]);
+var KUBECTL_SERVER = /^(?:--server(?:=|$)|-s$)/;
+var REMOTE_VARIABLE = /^GIT_SSH(?:_COMMAND)?=/;
 var REMOTE = "Remote servers are off limits (no SSH, no deploys, no remote commands). Hand the user the exact command to run themselves.";
+function dockerContext(args) {
+  let context = null;
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i] ?? "";
+    if (arg.startsWith("--context="))
+      context = arg.slice("--context=".length);
+    else if (arg === "-c" || arg === "--context")
+      context = args[++i] ?? null;
+    else if (DOCKER_VALUE_OPTIONS2.has(arg))
+      i++;
+    else if (!arg.startsWith("-"))
+      return { context, name: arg, rest: args.slice(i + 1) };
+  }
+  return { context, name: "", rest: [] };
+}
+function isDockerRemote(args, assignments) {
+  const { context, name, rest } = dockerContext(args);
+  const fromEnv = assignments.find((assignment) => assignment.startsWith("DOCKER_CONTEXT="))?.slice("DOCKER_CONTEXT=".length);
+  if ([context, fromEnv].some((each) => each !== null && each !== undefined && each !== "default"))
+    return true;
+  return name === "context" && CONTEXT_CHANGES.has(rest[0] ?? "");
+}
+function isSocketRemote(args) {
+  return !args.some((arg) => LISTENS.test(arg) || LOOPBACK.test(arg));
+}
 function isRemote(text) {
   const { program, args, assignments } = parseCommand(text);
+  const declared = DECLARERS2.has(program) ? args : [];
   if (SHELL_PROGRAMS.has(program))
     return true;
+  if (SOCKET_PROGRAMS.has(program))
+    return isSocketRemote(args);
   if (program === "rsync")
     return args.some((arg) => !arg.startsWith("-") && RSYNC_REMOTE.test(arg));
-  if (assignments.some((assignment) => assignment.startsWith("DOCKER_HOST=") && SSH_URL.test(assignment.slice("DOCKER_HOST=".length))))
+  if (program === "kubectl")
+    return args.some((arg) => KUBECTL_SERVER.test(arg));
+  if ([...assignments, ...declared].some((assignment) => REMOTE_VARIABLE.test(assignment)))
+    return true;
+  if ([...assignments, ...declared].some((assignment) => assignment.startsWith("DOCKER_HOST=") && SSH_URL.test(assignment.slice("DOCKER_HOST=".length))))
     return true;
-  return program === "docker" && tokenize(text).some((word) => SSH_URL.test(word));
+  if (program === "docker" && isDockerRemote(args, assignments))
+    return true;
+  return URL_PROGRAMS.has(program) && tokenize(text).some((word) => SSH_URL_WORD.test(word));
 }
 function remoteViolation(command) {
   return splitCommand(command).some((piece) => isRemote(piece.command)) ? REMOTE : null;
@@ -2110,6 +2874,7 @@ function replaceViolation(command) {
 }
 
 // src/check.ts
+var UNREADABLE_MESSAGE = "The commit message cannot be read here (a variable, a substitution, a missing file or no heredoc on stdin), so it cannot be checked. Write it literally with `-m` or a `$(cat <<'EOF' ... EOF)` heredoc.";
 function absolute(path, cwd) {
   return path.startsWith("/") ? path : `${cwd}/${path}`;
 }
@@ -2125,6 +2890,8 @@ function commitViolation(command, { cwd, read }) {
       message = inlineMessage(source.parts);
     else if (file !== "-")
       message = read(absolute(file, cwd));
+    if (message === null && (source.parts.length > 0 || file !== null))
+      return UNREADABLE_MESSAGE;
     const violation = message === null ? null : commitMessageViolation(message);
     if (violation !== null)
       return violation;
@@ -2140,9 +2907,6 @@ function pinnedManagers(start, exists) {
       return null;
   }
 }
-function commandsRun(command) {
-  return [command, ...substitutions(command).flatMap(commandsRun)];
-}
 function mismatches(command, { cwd, home, exists }) {
   return installRequests(command, cwd, home).flatMap((request) => {
     const mismatch = mismatchFor(request, pinnedManagers(request.dir, exists));
@@ -2158,13 +2922,22 @@ async function checkCommand(command, context) {
   };
   const run = commandsRun(command);
   const first = (messages) => messages.find((message) => message !== null) ?? null;
-  add("remote", first(run.map(remoteViolation)));
-  add("git", first(run.map((each) => gitViolation(each, context.isPushAsked))));
-  const commit = commitViolation(command, context);
+  const guarded = async (rule, check) => {
+    try {
+      return await check();
+    } catch (error) {
+      context.onError?.(rule, error, command);
+      return `The ${rule} rule crashed on this command (${error instanceof Error ? error.message : String(error)}), so it is refused. Simplify the command or run it yourself.`;
+    }
+  };
+  const readSql = async (path) => Promise.resolve(context.read(absolute(path, context.cwd)));
+  add("remote", await guarded("remote", () => first(run.map(remoteViolation))));
+  add("git", await guarded("git", () => first(run.map((each) => gitViolation(each, context.isPushAsked)))));
+  const commit = await guarded("commit", () => first(run.map((each) => commitViolation(each, context))));
   add("commit", commit === null ? null : `${commit} ${USE_GC}`);
-  add("sql", first(await Promise.all(run.map(async (each) => sqlViolation(each, async (path) => Promise.resolve(context.read(absolute(path, context.cwd))))))));
-  add("env", touchesEnv(command) ? USE_EV : null);
-  add("edit", context.canSub ? first(run.map(replaceViolation)) : null);
+  add("sql", await guarded("sql", async () => first(await Promise.all(run.map(async (each) => sqlViolation(each, readSql))))));
+  add("env", await guarded("env", () => run.some((each) => touchesEnv(each, { hasTrackedEnv: context.hasTrackedEnv === true })) ? USE_EV : null));
+  add("edit", context.canSub ? await guarded("edit", () => first(run.map(replaceViolation))) : null);
   const found = mismatches(command, context);
   const refused = found.find((mismatch) => mismatch.rewrite === null || !context.canRewrite);
   const rewrite = refused?.rewrite ?? null;
@@ -2177,10 +2950,10 @@ async function checkCommand(command, context) {
   }
   if (context.canRewrite && context.canWrap && shouldWrap(rewritten))
     rewritten = wrap(rewritten);
-  return { violations, command: violations.length > 0 ? command : rewritten, notes: violations.length > 0 ? [] : notes, packages: addedPackages(command) };
+  return { violations, command: violations.length > 0 ? command : rewritten, notes: violations.length > 0 ? [] : notes, packages: [...new Set(run.flatMap(addedPackages))] };
 }
 function checkPath(path) {
-  return isEnvFile(path) ? { rule: "env", message: USE_EV } : null;
+  return reachesEnvFile(path) ? { rule: "env", message: USE_EV } : null;
 }
 
 // src/bins.ts
@@ -2189,7 +2962,7 @@ var BINS = {
   fix: "`fix`: runs the repo's fixers and formatters (its fix, lint:fix and format scripts, just fmt, go fmt, cargo fmt, ruff) and lists the files they changed.",
   errs: "`errs [log]`, `errs -- <cmd>`: turns tsc, tsgo, eslint, bun check and bun test output into one `file:line:col: message (rule)` line per error, counting the lines it did not recognise (`--json`); use it instead of reading raw type, lint or test logs.",
   db: '`db "<sql>"`: one read-only statement against the Postgres in DATABASE_URL (`-e KEY` for another) or, without one, the compose project\'s running Postgres service (`-s <service>`, `-d <database>`), credentials never shown, a write printed for the user to run; `db tables`, `db describe <table>`, `db dbs`.',
-  ev: "`ev`: .env files read and edited with values masked (`ev list`, `ev get KEY`, `ev grep <regex>`, `ev show <rev>:<file>`, `ev set`, `ev diff`, `ev missing`); `ev audit [dir]` finds env files others can read or git tracks, and compose files writing secrets out.",
+  ev: "`ev`: .env files read and edited with values masked (`ev list`, `ev get KEY`, `ev grep <regex>`, `ev show <rev>:<file>`, `ev set`, `ev diff`, `ev missing`); `ev audit [dir]` finds env files others can read or git tracks, and compose files writing secrets out; `ev pins [dir]` lists the env vars reaching outside that the tests of an app leave unpinned.",
   redact: "`redact`: masks secrets in piped output, `<cmd> | redact`.",
   pkg: "`pkg <name>[@version]`: checks an npm package before it is added: whether the name exists or is a near miss of a popular one, the newest version at least two weeks old, licence, install scripts; `bun add`, `npm install`, `pnpm add` and `yarn add` run it first and are refused on what it flags. `pkg bump <@scope/lib> [version]` waits until the registry serves a release, then `bun add --exact`s it in every consumer under ~/Workspace (`--dry-run`), `pkg consumers <name>` lists them; use it instead of a `bun info` and sleep loop and a `bun add` per repo.",
   stack: "`stack port <name>`: the port a service name always hashes to, for every host port a compose file publishes; `stack audit [dir]` cross-checks release.config.ts against its compose files.",
@@ -2219,9 +2992,21 @@ ${lines.join(`
 
 // src/hook.ts
 var EVENTS = ["pre-tool-use", "user-prompt-submit", "session-start"];
-var PUSH_WORDS = /\b(?:push|pousse)/i;
+var PUSH_WORD = /\b(?:push|pousser?|poussez)\b/i;
+var PUSH_NOUN = /\bpush[\s-]+(?:notifications?|messages?|tokens?|events?|services?|apis?|subscriptions?|workers?|servers?)\b/gi;
+var NOT_A_REQUEST = /\b(?:don'?t|do not|never|not|no|without|avoid|stop|can'?t|cannot|won'?t|shouldn'?t|did|didn'?t|does|doesn'?t|already|ne|pas|jamais|sans|surtout)\b/i;
+var CLAUSE_BREAKS = /[.!?;,\n]+/;
 var SESSION_ID = /^[\w-]+$/;
-var FILE_TOOLS = new Set(["Read", "Edit", "Write"]);
+var FILE_TOOLS = new Map([["Read", "file_path"], ["Edit", "file_path"], ["MultiEdit", "file_path"], ["Write", "file_path"], ["NotebookEdit", "notebook_path"], ["Grep", "path"], ["Glob", "path"]]);
+var GIT_WORD = /\bgit\b/;
+var GIT_PRINT_WORD = /\b(?:diff|log|show|whatchanged|format-patch|grep)\b/;
+var TRACKED_ENV = [":(glob)**/.env", ":(glob)**/.env.*", ":(glob)**/.envrc"];
+function asksForPush(prompt) {
+  return prompt.split(CLAUSE_BREAKS).some((clause) => {
+    const asked = clause.replace(PUSH_NOUN, "");
+    return PUSH_WORD.test(asked) && !NOT_A_REQUEST.test(asked);
+  });
+}
 function pushFile(sessionId, { stateDir }) {
   return sessionId !== undefined && SESSION_ID.test(sessionId) ? `${stateDir}/push-asked/${sessionId}` : null;
 }
@@ -2243,25 +3028,36 @@ async function bashCall(command, input, machine) {
     canWrap: false,
     canSub: machine.has("sub"),
     read: machine.read,
-    exists: machine.exists
+    exists: machine.exists,
+    hasTrackedEnv: GIT_WORD.test(command) && GIT_PRINT_WORD.test(command) && await hasTrackedEnv(cwd, machine),
+    onError: (rule, error, each) => machine.log?.(`${new Date().toISOString()} ${rule} crashed: ${error instanceof Error ? error.stack ?? error.message : String(error)}
+  command: ${each}
+`)
   });
   if (verdict.violations.length > 0 || verdict.packages.length === 0 || !machine.has("pkg"))
     return deny(verdict.violations);
   const checked = await machine.run(["pkg", "check", ...verdict.packages], cwd);
-  return checked.code === 1 ? deny([{ rule: "pkg", message: `pkg refused what this adds, so it was not run:
-${checked.text.trim()}` }]) : null;
+  if (checked.code === 0)
+    return null;
+  const message = checked.code === 1 ? "pkg refused what this adds, so it was not run" : `pkg check failed (exit ${checked.code}), so what this adds was not checked and it was not run`;
+  return deny([{ rule: "pkg", message: `${message}:
+${checked.text.trim()}` }]);
+}
+async function hasTrackedEnv(cwd, machine) {
+  const listed = await machine.run(["git", "ls-files", "-z", "--", ...TRACKED_ENV], cwd);
+  return listed.code === 0 && listed.text.split("\x00").some(isEnvFile);
 }
 function preToolUse(input, machine) {
   const { tool_name: tool, tool_input: given = {} } = input;
   if (tool === "Bash" && typeof given.command === "string")
     return bashCall(given.command, input, machine);
-  if (tool !== undefined && FILE_TOOLS.has(tool) && typeof given.file_path === "string")
-    return deny([checkPath(given.file_path)].filter((each) => each !== null));
-  return null;
+  const field = tool === undefined ? undefined : FILE_TOOLS.get(tool);
+  const paths = [field === undefined ? undefined : given[field], tool === "Grep" ? given.glob : undefined];
+  return deny(paths.flatMap((path) => typeof path === "string" ? [checkPath(path)] : []).filter((each) => each !== null));
 }
 function userPromptSubmit(input, machine) {
   const file = pushFile(input.session_id, machine);
-  if (file !== null && PUSH_WORDS.test(input.prompt ?? ""))
+  if (file !== null && asksForPush(input.prompt ?? ""))
     machine.write(file, "");
   else if (file !== null)
     machine.remove(file);
@@ -2302,13 +3098,15 @@ var pathOptions = {
 var hookUsage = `guard hook <${EVENTS.join("|")}>
 
 Answers a Claude Code hook: reads the event JSON on stdin and prints the reply JSON, nothing when the call goes ahead untouched.
-pre-tool-use refuses a Bash call breaking a rule, an install pkg refuses, and a Read, Edit or Write of an env file; user-prompt-submit remembers whether the prompt asked for a push; session-start lists the installed agent-tools bins.
+pre-tool-use refuses a Bash call breaking a rule, an install pkg refuses (or fails to check), and a file tool (Read, Edit, MultiEdit, Write, NotebookEdit, Grep, Glob) reaching an env file; user-prompt-submit remembers whether the prompt asked for a push; session-start lists the installed agent-tools bins.
 A failure exits 1, which Claude Code reports without blocking the call.
 
 Exits 0 when it answered, 1 on a failure or an unknown event (never 2, which would block the call).`;
+var MAX_READ = 1e6;
 function readText(path) {
   try {
-    return readFileSync(path, "utf8");
+    const stats = statSync(path, { throwIfNoEntry: false });
+    return stats?.isFile() === true && stats.size <= MAX_READ ? readFileSync(path, "utf8") : null;
   } catch {
     return null;
   }
@@ -2327,7 +3125,7 @@ ${checkUsage}`);
   const given = positionals[0] ?? "-";
   const command = given === "-" ? await readInput("-", { noStdin: "give the command, or pipe it on stdin" }) : given;
   const context = {
-    cwd: values.cwd ?? process6.cwd(),
+    cwd: values.cwd ?? process7.cwd(),
     home: homedir(),
     isPushAsked: values["push-asked"] === true,
     canRewrite: true,
@@ -2361,9 +3159,10 @@ ${pathUsage}`);
 }
 function machine() {
   const home = homedir();
+  const stateDir = `${process7.env.XDG_STATE_HOME ?? `${home}/.local/state`}/guard`;
   return {
     home,
-    stateDir: `${process6.env.XDG_STATE_HOME ?? `${home}/.local/state`}/guard`,
+    stateDir,
     has: (bin) => Bun.which(bin) !== null,
     run: async (argv, cwd) => runCommand(argv, { cwd }),
     read: readText,
@@ -2372,7 +3171,13 @@ function machine() {
       mkdirSync(dirname(path), { recursive: true });
       writeFileSync(path, text);
     },
-    remove: (path) => rmSync(path, { force: true })
+    remove: (path) => rmSync(path, { force: true }),
+    log: (text) => {
+      try {
+        mkdirSync(stateDir, { recursive: true });
+        appendFileSync(`${stateDir}/errors.log`, text);
+      } catch {}
+    }
   };
 }
 async function hookCommand(args) {
@@ -2387,7 +3192,7 @@ ${hookUsage}`, 1);
     console.log(JSON.stringify(reply));
   return 0;
 }
-process6.exitCode = await runCli({
+process7.exitCode = await runCli({
   name: "guard",
   version,
   about: "the safety rules a Claude Code Bash call is held to, each refusal naming the route",