@pushary/agent-hooks 1.9.30 → 1.9.31

package/dist/{chunk-JBVKA3UR.js → chunk-TDLEFGAM.js}

@@ -1750,6 +1750,428 @@ var powerShellCommandHasAVisibleConsequence = (command, judge) => {
   return powerShellReadingIsDestructive(reading, judge) || stages.some((stage) => stageHasAVisibleConsequence(stage, judge)) || reading.statements.some(listsRecursivelyIntoARemoval) || runsFetchedPowerShellCode(stages, judge) || runsADownloadedFile(stages, judge) || reading.posixCommands.some((words) => judge.commandShowsAConsequence(words));
 };
 
+// ../contracts/src/command-analysis/sql-text.ts
+var UNCERTAIN_SQL = { kind: "uncertain" };
+var STRING_PLACEHOLDER = "''";
+var TOKEN_GAP = " ";
+var STATEMENT_SEPARATOR2 = ";";
+var SINGLE_QUOTE = "'";
+var DOUBLE_QUOTE = '"';
+var BACKTICK = "`";
+var BACKSLASH = "\\";
+var DOLLAR = "$";
+var DASH_DASH = "--";
+var HASH = "#";
+var BLOCK_COMMENT_OPEN2 = "/*";
+var BLOCK_COMMENT_CLOSE2 = "*/";
+var NEWLINE2 = "\n";
+var CARRIAGE_RETURN2 = "\r";
+var TRIPLE_QUOTE_LENGTH = 3;
+var CLIENT_COMMAND_LENGTH = 2;
+var UNICODE_ESCAPE_PREFIX = /^[uU]&$/;
+var ESCAPE_STRING_PREFIX = /^[eE]$/;
+var EXECUTABLE_COMMENT_OPENER = /^\/\*M?!/;
+var ASCII_LETTER_OR_UNDERSCORE = /^[A-Za-z_]$/;
+var DECIMAL_DIGIT = /^[0-9]$/;
+var DECIMAL_DIGITS = /^[0-9]+$/;
+var ANY_WHITESPACE = /^\s$/;
+var STATEMENT_TERMINATOR_CLIENT_COMMAND = /^\\[gG]$/;
+var SQL_MODE_SETTING = /\bsql_mode\b/i;
+var FIRST_NON_ASCII = "\x80";
+var FIRST_NON_ASCII_CODE = 128;
+var LAST_ASCII_CONTROL_OR_SPACE = 32;
+var ASCII_DELETE = 127;
+var MYSQL_WHITESPACE = /* @__PURE__ */ new Set([" ", "	", "\n", "\v", "\f", "\r"]);
+var ESCAPE_STRING_SYNTAX = { backslashes: "escape", content: "hidden" };
+var isIdentifierStart = (character) => ASCII_LETTER_OR_UNDERSCORE.test(character) || character >= FIRST_NON_ASCII;
+var isDecimalDigit = (character) => DECIMAL_DIGIT.test(character);
+var isWordCharacter = (character) => isIdentifierStart(character) || isDecimalDigit(character);
+var isIdentifierPart = (character) => isWordCharacter(character) || character === DOLLAR;
+var isQuote = (character) => character === SINGLE_QUOTE || character === DOUBLE_QUOTE || character === BACKTICK;
+var isLineCommentTerminator = (character) => character === NEWLINE2 || character === CARRIAGE_RETURN2;
+var isControlOrSpace = (character) => {
+  const code = character.charCodeAt(0);
+  return code <= LAST_ASCII_CONTROL_OR_SPACE || code === ASCII_DELETE;
+};
+var followsNonAsciiText = (source, index) => source.charCodeAt(index - 1) >= FIRST_NON_ASCII_CODE;
+var mayBeAMultibyteTrailByte = (source, index, lexicon) => lexicon.clientCharsets === "may-be-multibyte" && followsNonAsciiText(source, index);
+var endOfRun = (source, start, belongs) => {
+  let index = start;
+  while (index < source.length && belongs(source.charAt(index))) index += 1;
+  return index;
+};
+var dollarQuoteDelimiterAt = (source, start) => {
+  if (source.charAt(start) !== DOLLAR) return void 0;
+  const tagStart = start + 1;
+  const tagEnd = isIdentifierStart(source.charAt(tagStart)) ? endOfRun(source, tagStart, isWordCharacter) : tagStart;
+  return source.charAt(tagEnd) === DOLLAR ? source.slice(start, tagEnd + 1) : void 0;
+};
+var doubledQuoteEnd = (source, from, quote, backslashBeforeTheQuote) => {
+  for (let index = from; index < source.length; index += 1) {
+    if (backslashBeforeTheQuote === "uncertain" && source[index] === BACKSLASH && source[index + 1] === quote) return "uncertain";
+    if (source[index] !== quote) continue;
+    if (source[index + 1] === quote) index += 1;
+    else return index + 1;
+  }
+  return "unterminated";
+};
+var escapedQuoteEnd = (source, from, closing, lexicon) => {
+  for (let index = from; index < source.length; ) {
+    if (source[index] === BACKSLASH) {
+      if (mayBeAMultibyteTrailByte(source, index, lexicon)) return "uncertain";
+      index += 2;
+    } else if (!source.startsWith(closing, index)) {
+      index += 1;
+    } else if (closing.length === 1 && source[index + 1] === closing) {
+      index += 2;
+    } else {
+      return index + closing.length;
+    }
+  }
+  return "unterminated";
+};
+var blockCommentEnd = (source, start, lexicon) => {
+  let depth = 0;
+  let index = start + BLOCK_COMMENT_OPEN2.length;
+  while (index < source.length) {
+    if (source.startsWith(BLOCK_COMMENT_OPEN2, index)) {
+      if (lexicon.nestedBlockComments === "uncertain") return "uncertain";
+      depth += 1;
+      index += BLOCK_COMMENT_OPEN2.length;
+    } else if (!source.startsWith(BLOCK_COMMENT_CLOSE2, index)) {
+      index += 1;
+    } else if (depth === 0) {
+      return index + BLOCK_COMMENT_CLOSE2.length;
+    } else {
+      depth -= 1;
+      index += BLOCK_COMMENT_CLOSE2.length;
+    }
+  }
+  return "uncertain";
+};
+var opensAnEscapeString = (source, start, lexicon) => lexicon.escapeStringPrefix === "backslash-escapes" && source.charAt(start) === SINGLE_QUOTE && ESCAPE_STRING_PREFIX.test(source.charAt(start - 1)) && !isIdentifierPart(source.charAt(start - 2));
+var quotedTextSyntaxOf = (quote, lexicon) => {
+  if (quote === SINGLE_QUOTE) return lexicon.singleQuotes;
+  if (quote === DOUBLE_QUOTE) return lexicon.doubleQuotes;
+  return lexicon.backticks;
+};
+var syntaxOfQuoteAt = (source, start, lexicon) => opensAnEscapeString(source, start, lexicon) ? ESCAPE_STRING_SYNTAX : quotedTextSyntaxOf(source.charAt(start), lexicon);
+var openerOfQuoteAt = (source, start, lexicon) => {
+  const triple = source.charAt(start).repeat(TRIPLE_QUOTE_LENGTH);
+  return lexicon.tripleQuotes === "quote" && source.startsWith(triple, start) ? triple : source.charAt(start);
+};
+var readsBackslashesLiterally = (syntax, reading) => syntax.backslashes === "escape-unless-the-sql-mode-disables-it" && reading.backslashMode === "literal";
+var quotedTextEnd = (source, start, opener, syntax, reading) => {
+  const from = start + opener.length;
+  if (opener.length > 1) return escapedQuoteEnd(source, from, opener, reading.lexicon);
+  const end = doubledQuoteEnd(source, from, opener, "uncertain");
+  if (end !== "uncertain" || syntax.backslashes === "uncertain-before-the-quote") return end;
+  return readsBackslashesLiterally(syntax, reading) ? doubledQuoteEnd(source, from, opener, "ordinary") : escapedQuoteEnd(source, from, opener, reading.lexicon);
+};
+var opensAUnicodeEscapedQuote = (source, start) => source.charAt(start) !== SINGLE_QUOTE && UNICODE_ESCAPE_PREFIX.test(source.slice(Math.max(0, start - 2), start));
+var swallowsABacktick = (source, start, end, lexicon) => {
+  if (source.charAt(start) !== BACKTICK) return false;
+  for (let index = start; index !== -1 && index < end; index = source.indexOf(BACKTICK, index + 1)) {
+    if (mayBeAMultibyteTrailByte(source, index, lexicon)) return true;
+  }
+  return false;
+};
+var unterminatedTextRunsToTheEnd = (reading) => reading.backslashMode === "literal";
+var quotedToken = (source, start, reading, inside) => {
+  if (opensAUnicodeEscapedQuote(source, start)) return "uncertain";
+  const syntax = syntaxOfQuoteAt(source, start, reading.lexicon);
+  const opener = openerOfQuoteAt(source, start, reading.lexicon);
+  const end = quotedTextEnd(source, start, opener, syntax, reading);
+  if (end === "uncertain") return "uncertain";
+  if (end === "unterminated") {
+    return unterminatedTextRunsToTheEnd(reading) ? { text: STRING_PLACEHOLDER, end: source.length, insideExecutableComment: inside } : "uncertain";
+  }
+  if (swallowsABacktick(source, start, end, reading.lexicon)) return "uncertain";
+  const quote = source.charAt(start);
+  const text = syntax.content === "hidden" ? STRING_PLACEHOLDER : source.slice(start + opener.length, end - opener.length).replaceAll(quote + quote, quote);
+  return { text, end, insideExecutableComment: inside };
+};
+var lineCommentEnd = (source, start, lexicon) => {
+  const terminator = endOfRun(source, start, (character) => !isLineCommentTerminator(character));
+  if (source.charAt(terminator) !== CARRIAGE_RETURN2) return terminator;
+  if (lexicon.carriageReturnInLineComment === "uncertain") return "uncertain";
+  if (lexicon.carriageReturnInLineComment === "ends-the-comment") return terminator;
+  const newline = source.indexOf(NEWLINE2, terminator);
+  return newline === -1 ? source.length : newline;
+};
+var lineCommentToken = (source, start, lexicon, inside) => {
+  if (inside) return "uncertain";
+  const end = lineCommentEnd(source, start, lexicon);
+  return end === "uncertain" ? "uncertain" : { text: TOKEN_GAP, end, insideExecutableComment: false };
+};
+var dashDashStartsAComment = (next, lexicon) => {
+  if (lexicon.dashDash === "comment" || next === "") return true;
+  if (lexicon.dashDash === "uncertain-before-text") return ANY_WHITESPACE.test(next) || "uncertain";
+  if (MYSQL_WHITESPACE.has(next)) return true;
+  return isControlOrSpace(next) ? "uncertain" : false;
+};
+var dashDashToken = (source, start, lexicon, inside) => {
+  const startsAComment = dashDashStartsAComment(source.charAt(start + DASH_DASH.length), lexicon);
+  if (startsAComment === "uncertain") return "uncertain";
+  return startsAComment ? lineCommentToken(source, start, lexicon, inside) : { text: source.charAt(start), end: start + 1, insideExecutableComment: inside };
+};
+var hashToken = (source, start, lexicon, inside) => {
+  if (lexicon.hash === "uncertain") return "uncertain";
+  if (lexicon.hash === "comment") return lineCommentToken(source, start, lexicon, inside);
+  return { text: HASH, end: start + 1, insideExecutableComment: inside };
+};
+var blockCommentToken = (source, start, lexicon, inside) => {
+  if (inside) return "uncertain";
+  const opener = EXECUTABLE_COMMENT_OPENER.exec(source.slice(start, start + 4))?.[0];
+  if (opener !== void 0 && lexicon.executableComments === "uncertain") return "uncertain";
+  if (opener !== void 0) {
+    return { text: TOKEN_GAP, end: endOfRun(source, start + opener.length, isDecimalDigit), insideExecutableComment: true };
+  }
+  const end = blockCommentEnd(source, start, lexicon);
+  return end === "uncertain" ? "uncertain" : { text: TOKEN_GAP, end, insideExecutableComment: false };
+};
+var dollarToken = (source, start, lexicon, inside) => {
+  const delimiter = dollarQuoteDelimiterAt(source, start);
+  if (delimiter === void 0) return { text: DOLLAR, end: start + 1, insideExecutableComment: inside };
+  if (lexicon.dollarQuotes === "uncertain") return "uncertain";
+  const close = source.indexOf(delimiter, start + delimiter.length);
+  return close === -1 ? "uncertain" : { text: delimiter + delimiter, end: close + delimiter.length, insideExecutableComment: inside };
+};
+var numberToken = (source, start, inside) => {
+  const end = endOfRun(source, start, isWordCharacter);
+  const text = source.slice(start, end);
+  if (!DECIMAL_DIGITS.test(text) && dollarQuoteDelimiterAt(source, end) !== void 0) return "uncertain";
+  return { text, end, insideExecutableComment: inside };
+};
+var identifierToken = (source, start, inside) => {
+  const end = endOfRun(source, start, isIdentifierPart);
+  return { text: source.slice(start, end), end, insideExecutableComment: inside };
+};
+var clientCommandToken = (source, start, inside) => {
+  const command = source.slice(start, start + CLIENT_COMMAND_LENGTH);
+  return STATEMENT_TERMINATOR_CLIENT_COMMAND.test(command) ? { text: STATEMENT_SEPARATOR2, end: start + CLIENT_COMMAND_LENGTH, insideExecutableComment: inside } : "uncertain";
+};
+var nextSqlToken = (source, start, reading, inside) => {
+  const { lexicon } = reading;
+  const character = source.charAt(start);
+  if (isQuote(character)) return quotedToken(source, start, reading, inside);
+  if (source.startsWith(DASH_DASH, start)) return dashDashToken(source, start, lexicon, inside);
+  if (character === HASH) return hashToken(source, start, lexicon, inside);
+  if (source.startsWith(BLOCK_COMMENT_OPEN2, start)) return blockCommentToken(source, start, lexicon, inside);
+  if (inside && source.startsWith(BLOCK_COMMENT_CLOSE2, start)) {
+    return { text: TOKEN_GAP, end: start + BLOCK_COMMENT_CLOSE2.length, insideExecutableComment: false };
+  }
+  if (character === BACKSLASH && lexicon.backslashOutsideLiterals === "client-command") return clientCommandToken(source, start, inside);
+  if (character === DOLLAR) return dollarToken(source, start, lexicon, inside);
+  if (isIdentifierStart(character)) return identifierToken(source, start, inside);
+  if (isDecimalDigit(character)) return numberToken(source, start, inside);
+  return { text: character, end: start + 1, insideExecutableComment: inside };
+};
+var readsABackslashTheSqlModeDecides = (source, start, end, lexicon) => isQuote(source.charAt(start)) && syntaxOfQuoteAt(source, start, lexicon).backslashes === "escape-unless-the-sql-mode-disables-it" && source.slice(start, end).includes(BACKSLASH);
+var sqlReadingOf = (source, reading) => {
+  const pieces = [];
+  let inside = false;
+  let backslashModeMatters = false;
+  for (let index = 0; index < source.length; ) {
+    const token = nextSqlToken(source, index, reading, inside);
+    if (token === "uncertain") return "uncertain";
+    backslashModeMatters ||= readsABackslashTheSqlModeDecides(source, index, token.end, reading.lexicon);
+    pieces.push(token.text);
+    inside = token.insideExecutableComment;
+    index = token.end;
+  }
+  return inside ? "uncertain" : { text: pieces.join(""), backslashModeMatters };
+};
+var sqlModeDecidesBackslashes = (lexicon) => [lexicon.singleQuotes, lexicon.doubleQuotes, lexicon.backticks].some((syntax) => syntax.backslashes === "escape-unless-the-sql-mode-disables-it");
+var backslashModesOf = (lexicon) => sqlModeDecidesBackslashes(lexicon) ? ["escape", "literal"] : ["escape"];
+var isReadingText = (result) => result !== "uncertain";
+var mayChangeTheBackslashMode = (readings) => readings.some((reading) => reading.backslashModeMatters) && readings.some((reading) => SQL_MODE_SETTING.test(reading.text));
+var sqlOutsideLiterals = (source, lexicon) => {
+  const results = backslashModesOf(lexicon).map((backslashMode) => sqlReadingOf(source, { lexicon, backslashMode }));
+  const readings = results.filter(isReadingText);
+  if (readings.length < results.length || mayChangeTheBackslashMode(readings)) return UNCERTAIN_SQL;
+  return { kind: "readable", texts: [...new Set(readings.map((reading) => reading.text))] };
+};
+
+// ../contracts/src/command-analysis/env-invocation.ts
+var GNU_ENV = {
+  shortOptions: { switches: /* @__PURE__ */ new Set(["i", "v", "0"]), withAValue: /* @__PURE__ */ new Set(["a", "C", "S", "u"]) },
+  longOptions: [
+    { name: "argv0", argument: "required", effect: "continues" },
+    { name: "ignore-environment", argument: "none", effect: "continues" },
+    { name: "null", argument: "none", effect: "continues" },
+    { name: "unset", argument: "required", effect: "continues" },
+    { name: "chdir", argument: "required", effect: "continues" },
+    { name: "default-signal", argument: "optional", effect: "continues" },
+    { name: "ignore-signal", argument: "optional", effect: "continues" },
+    { name: "block-signal", argument: "optional", effect: "continues" },
+    { name: "list-signal-handling", argument: "none", effect: "continues" },
+    { name: "debug", argument: "none", effect: "continues" },
+    { name: "split-string", argument: "required", effect: "splits" },
+    { name: "help", argument: "none", effect: "exits" },
+    { name: "version", argument: "none", effect: "exits" }
+  ]
+};
+var BSD_ENV = {
+  shortOptions: { switches: /* @__PURE__ */ new Set(["-", "i", "v", "0"]), withAValue: /* @__PURE__ */ new Set(["C", "L", "P", "S", "U", "u"]) },
+  longOptions: null
+};
+var ENV_FLAVORS = [GNU_ENV, BSD_ENV];
+var UNREADABLE = { kind: "unreadable" };
+var RUNS_NOTHING = { kind: "runs-nothing" };
+var EXITS = { kind: "exits" };
+var SPLIT_STRING_LETTER = "S";
+var END_OF_OPTIONS = "--";
+var LONE_DASH = "-";
+var OPTION_PREFIX = "-";
+var NO_CLUSTER = "";
+var LONG_OPTION_PREFIX = "--";
+var ASSIGNMENT_SEPARATOR = "=";
+var nextOption = (next) => ({ kind: "next", next });
+var finished = (reading) => ({ kind: "done", reading });
+var commandAfterOptions = (args, firstOperand) => {
+  let start = args[firstOperand]?.text === LONE_DASH ? firstOperand + 1 : firstOperand;
+  while (args[start]?.text.includes(ASSIGNMENT_SEPARATOR)) start += 1;
+  return { kind: "command", start };
+};
+var splitReading = (args, index, clusterBefore, attached) => {
+  const word = args[index];
+  const prefix = [...args.slice(0, index).map((arg) => arg.text), ...clusterBefore.length > 1 ? [clusterBefore] : []];
+  if (word !== void 0 && attached !== void 0) return { kind: "split", prefix, value: { ...word, text: attached }, rest: index + 1 };
+  return { kind: "split", prefix, value: args[index + 1], rest: index + 2 };
+};
+var requiredValueStep = (args, index) => index + 1 < args.length ? nextOption(index + 2) : finished(EXITS);
+var shortOptionStep = (args, index, text, options) => {
+  for (let position = 1; position < text.length; position += 1) {
+    const letter = text.charAt(position);
+    if (options.switches.has(letter)) continue;
+    if (!options.withAValue.has(letter)) return finished(EXITS);
+    const attached = text.slice(position + 1);
+    if (letter === SPLIT_STRING_LETTER) return finished(splitReading(args, index, text.slice(0, position), attached === "" ? void 0 : attached));
+    return attached === "" ? requiredValueStep(args, index) : nextOption(index + 1);
+  }
+  return nextOption(index + 1);
+};
+var gnuLongOptionAbbreviatedBy = (name, options) => {
+  const exact = options.find((option) => option.name === name);
+  if (exact !== void 0) return exact;
+  const candidates = options.filter((option) => option.name.startsWith(name));
+  return candidates.length === 1 ? candidates[0] : void 0;
+};
+var longOptionStep = (args, index, text, options) => {
+  const body = text.slice(LONG_OPTION_PREFIX.length);
+  const separator = body.indexOf(ASSIGNMENT_SEPARATOR);
+  const attached = separator === -1 ? void 0 : body.slice(separator + 1);
+  const option = gnuLongOptionAbbreviatedBy(separator === -1 ? body : body.slice(0, separator), options);
+  if (option === void 0) return finished(UNREADABLE);
+  if (option.effect === "exits" || option.argument === "none" && attached !== void 0) return finished(EXITS);
+  if (option.effect === "splits") return finished(splitReading(args, index, NO_CLUSTER, attached));
+  return option.argument === "required" && attached === void 0 ? requiredValueStep(args, index) : nextOption(index + 1);
+};
+var optionStep = (args, index, word, flavor) => {
+  if (word.expands) return finished(UNREADABLE);
+  if (flavor.longOptions !== null && word.text.startsWith(LONG_OPTION_PREFIX)) return longOptionStep(args, index, word.text, flavor.longOptions);
+  return shortOptionStep(args, index, word.text, flavor.shortOptions);
+};
+var flavorReadingOf = (args, flavor) => {
+  for (let index = 0; index < args.length; ) {
+    const word = args[index];
+    if (word === void 0) break;
+    if (word.text === END_OF_OPTIONS) return commandAfterOptions(args, index + 1);
+    if (word.text === LONE_DASH || !word.text.startsWith(OPTION_PREFIX)) return commandAfterOptions(args, index);
+    const step = optionStep(args, index, word, flavor);
+    if (step.kind === "done") return step.reading;
+    index = step.next;
+  }
+  return commandAfterOptions(args, args.length);
+};
+var runsSomething = (reading) => reading.kind === "command" || reading.kind === "split";
+var sameEnvReading = (left, right) => {
+  if (left.kind === "command" && right.kind === "command") return left.start === right.start;
+  if (left.kind !== "split" || right.kind !== "split") return false;
+  return left.rest === right.rest && left.prefix.length === right.prefix.length && left.prefix.every((text, position) => text === right.prefix[position]) && left.value?.text === right.value?.text && left.value?.expands === right.value?.expands;
+};
+var envReadingOf = (args) => {
+  const readings = ENV_FLAVORS.map((flavor) => flavorReadingOf(args, flavor));
+  if (readings.some((reading) => reading.kind === "unreadable")) return UNREADABLE;
+  const running = readings.filter(runsSomething);
+  const [first, ...others] = running;
+  if (first === void 0) return RUNS_NOTHING;
+  return others.every((other) => sameEnvReading(first, other)) ? first : { kind: "ambiguous", readings: running };
+};
+
+// ../contracts/src/command-analysis/shell-command-string.ts
+var NO_LETTERS = /* @__PURE__ */ new Set();
+var BASH_OPTIONS = {
+  lettersWithAValue: /* @__PURE__ */ new Set(["o", "O"]),
+  lettersThatEndOptions: NO_LETTERS,
+  leadingLongOptionsWithAValue: /* @__PURE__ */ new Set(["--rcfile", "--init-file", "-rcfile", "-init-file"])
+};
+var SHELL_OPTION_SYNTAX = /* @__PURE__ */ new Map([
+  ["sh", BASH_OPTIONS],
+  ["bash", BASH_OPTIONS],
+  ["zsh", { lettersWithAValue: /* @__PURE__ */ new Set(["o"]), lettersThatEndOptions: /* @__PURE__ */ new Set(["b"]), leadingLongOptionsWithAValue: NO_LETTERS }],
+  ["dash", { lettersWithAValue: /* @__PURE__ */ new Set(["o"]), lettersThatEndOptions: NO_LETTERS, leadingLongOptionsWithAValue: NO_LETTERS }],
+  ["ksh", { lettersWithAValue: /* @__PURE__ */ new Set(["o", "R"]), lettersThatEndOptions: NO_LETTERS, leadingLongOptionsWithAValue: NO_LETTERS }]
+]);
+var POSIX_SHELL_PROGRAMS = new Set(SHELL_OPTION_SYNTAX.keys());
+var ABSENT = { kind: "absent" };
+var UNREADABLE2 = { kind: "unreadable" };
+var COMMAND_STRING_LETTER = "c";
+var END_OF_OPTIONS2 = "--";
+var LONE_DASH2 = "-";
+var LONG_OPTION_PREFIX2 = "--";
+var SHORT_OPTION_CLUSTER = /^[-+][A-Za-z]*$/;
+var COMMAND_STRING_CLUSTER = /^[-+][A-Za-z]*c[A-Za-z]*$/;
+var clusterReadingOf = (cluster, syntax) => {
+  const letters = cluster.slice(1);
+  const valueLetter = [...letters].findIndex((letter) => syntax.lettersWithAValue.has(letter));
+  if (valueLetter !== -1 && valueLetter !== letters.length - 1) return null;
+  return {
+    runsACommandString: letters.includes(COMMAND_STRING_LETTER),
+    takesAValue: valueLetter !== -1,
+    endsOptions: [...letters].some((letter) => syntax.lettersThatEndOptions.has(letter))
+  };
+};
+var endsOptionParsing = (text) => text === END_OF_OPTIONS2 || text === LONE_DASH2;
+var isAnOperand = (text) => !text.startsWith("-") && !text.startsWith("+");
+var optionValueIsUnreadable = (value) => value === void 0 || value.expands;
+var shellCommandStringOf = (shell, args) => {
+  const syntax = SHELL_OPTION_SYNTAX.get(shell);
+  if (syntax === void 0 || !args.some((arg) => COMMAND_STRING_CLUSTER.test(arg.text))) return ABSENT;
+  let runsACommandString = false;
+  let seenAShortOption = false;
+  let index = 0;
+  while (index < args.length) {
+    const word = args[index];
+    if (word === void 0 || word.expands) return UNREADABLE2;
+    if (endsOptionParsing(word.text)) {
+      index += 1;
+      break;
+    }
+    if (isAnOperand(word.text)) break;
+    if (!seenAShortOption && syntax.leadingLongOptionsWithAValue.has(word.text)) {
+      if (optionValueIsUnreadable(args[index + 1])) return UNREADABLE2;
+      index += 2;
+      continue;
+    }
+    if (word.text.startsWith(LONG_OPTION_PREFIX2)) {
+      index += 1;
+      continue;
+    }
+    const cluster = SHORT_OPTION_CLUSTER.test(word.text) ? clusterReadingOf(word.text, syntax) : null;
+    if (cluster === null) return UNREADABLE2;
+    if (cluster.takesAValue && optionValueIsUnreadable(args[index + 1])) return UNREADABLE2;
+    seenAShortOption = true;
+    runsACommandString ||= cluster.runsACommandString;
+    index += cluster.takesAValue ? 2 : 1;
+    if (cluster.endsOptions) break;
+  }
+  if (!runsACommandString) return ABSENT;
+  const operand = args[index];
+  return operand === void 0 || operand.expands ? UNREADABLE2 : { kind: "readable", script: operand.text };
+};
+
 // ../contracts/src/degraded.ts
 var DEGRADED_PREFIX = "[degraded]";
 var degradedPayload = (subsystem, report) => ({
@@ -1762,37 +2184,6 @@ var degradedPayload = (subsystem, report) => ({
 });
 var degradedLine = (subsystem, report) => `${DEGRADED_PREFIX} ${JSON.stringify(degradedPayload(subsystem, report))}`;
 
-// ../contracts/src/setup-wire.ts
-var PAIR_TTL_SECONDS = 900;
-var computerOsOfPlatform = (platform) => {
-  switch (platform) {
-    case "darwin":
-      return "mac";
-    case "win32":
-      return "windows";
-    case "linux":
-      return "linux";
-    default:
-      return null;
-  }
-};
-var SETUP_AGENT_CHOICES = [
-  "claude_code",
-  "codex",
-  "gemini_cli",
-  "hermes",
-  "cursor",
-  "vscode",
-  "opencode",
-  "fx",
-  ...COMPATIBLE_AGENT_TYPES,
-  "custom"
-];
-var isComputerAgent = (agent) => agent !== "custom";
-var NO_PAIRING_COMPUTER = { computerName: null, os: null, agents: null };
-var SETUP_CONNECT_MODES = ["app", "browser", "web", "none"];
-var isSetupConnectMode = (value) => typeof value === "string" && SETUP_CONNECT_MODES.includes(value);
-
 // ../contracts/src/observability.ts
 var CLIENT_CONTEXT_HEADERS = {
   surface: "x-pushary-surface",
@@ -1840,6 +2231,37 @@ var AUTH_REJECTION_REASONS = [
   ...AGENT_SITE_REJECTION_REASONS
 ];
 
+// ../contracts/src/setup-wire.ts
+var PAIR_TTL_SECONDS = 900;
+var computerOsOfPlatform = (platform) => {
+  switch (platform) {
+    case "darwin":
+      return "mac";
+    case "win32":
+      return "windows";
+    case "linux":
+      return "linux";
+    default:
+      return null;
+  }
+};
+var SETUP_AGENT_CHOICES = [
+  "claude_code",
+  "codex",
+  "gemini_cli",
+  "hermes",
+  "cursor",
+  "vscode",
+  "opencode",
+  "fx",
+  ...COMPATIBLE_AGENT_TYPES,
+  "custom"
+];
+var isComputerAgent = (agent) => agent !== "custom";
+var NO_PAIRING_COMPUTER = { computerName: null, os: null, agents: null };
+var SETUP_CONNECT_MODES = ["app", "browser", "web", "none"];
+var isSetupConnectMode = (value) => typeof value === "string" && SETUP_CONNECT_MODES.includes(value);
+
 // ../contracts/src/declined-agents.ts
 var DECLINED_AGENTS_FILE = "declined-agents.json";
 var DECLINED_AGENTS_VERSION = 1;
@@ -2165,12 +2587,17 @@ var rankWholeOrSegments = (toolName, arg, intent, matches) => {
   const matched = toolName in POLICY_COMMAND_KEYS ? shellSegmentsMatch(arg, intent, matches) : matches(arg);
   return matched ? "prefix" : "none";
 };
+var argumentOpenIndex = (pattern) => pattern.endsWith(")") ? pattern.indexOf("(") : -1;
+var patternToolName = (pattern) => {
+  const open = argumentOpenIndex(pattern);
+  return open === -1 ? pattern : pattern.slice(0, open);
+};
 var matchToolPattern = (pattern, toolName, arg, intent = PATTERN_INTENT.grant) => {
-  const open = pattern.indexOf("(");
-  if (open === -1 || !pattern.endsWith(")")) {
+  const open = argumentOpenIndex(pattern);
+  if (open === -1) {
     return pattern === toolName ? "tool" : "none";
   }
-  if (pattern.slice(0, open) !== toolName || arg === void 0) return "none";
+  if (patternToolName(pattern) !== toolName || arg === void 0) return "none";
   const inner = pattern.slice(open + 1, -1);
   if (inner.endsWith(":*")) {
     const prefix = inner.slice(0, -2);
@@ -2453,7 +2880,7 @@ var uniqFileOperandCount = (args) => {
     if (optionsEnded || !isFlagToken(arg) || arg === STDIN_OPERAND) {
       operands += 1;
       optionsEnded = true;
-    } else if (arg === END_OF_OPTIONS) {
+    } else if (arg === END_OF_OPTIONS3) {
       optionsEnded = true;
     } else if (UNIQ_OPTIONS_WITH_A_SEPARATE_VALUE.includes(arg)) {
       index += 1;
@@ -2462,7 +2889,7 @@ var uniqFileOperandCount = (args) => {
   return operands;
 };
 var STDIN_OPERAND = "-";
-var LONG_OPTION_PREFIX = "--";
+var LONG_OPTION_PREFIX3 = "--";
 var OPTION_VALUE_SEPARATOR = "=";
 var longOptionName = (token) => token.split(OPTION_VALUE_SEPARATOR, 1)[0] ?? token;
 var abbreviatesALongOption = (token, longOptions) => {
@@ -2471,8 +2898,8 @@ var abbreviatesALongOption = (token, longOptions) => {
 };
 var clustersAShortOption = (token, shortOptions) => shortOptions.some((option) => token.slice(1).includes(option.slice(1)));
 var isRefusedOption = (token, options) => {
-  if (token === END_OF_OPTIONS || !isFlagToken(token)) return false;
-  return token.startsWith(LONG_OPTION_PREFIX) ? abbreviatesALongOption(token, options.long) : clustersAShortOption(token, options.short);
+  if (token === END_OF_OPTIONS3 || !isFlagToken(token)) return false;
+  return token.startsWith(LONG_OPTION_PREFIX3) ? abbreviatesALongOption(token, options.long) : clustersAShortOption(token, options.short);
 };
 var carriesNoRefusedOption = (args, options) => !args.some((arg) => isRefusedOption(arg, options));
 var SED_PRINT_ONLY_SCRIPT = /^(?:\d+|\$)(?:,(?:\d+|\$))?p$/;
@@ -2485,8 +2912,8 @@ var isReadOnlyDate = (args) => args.every((arg) => arg.startsWith(DATE_FORMAT_PR
 var PRINTF_TEXT_CONVERSION = /%(?:%|[-+ #0]*\d*(?:\.\d*)?[bcqs])/g;
 var PRINTF_CONVERSION_START = "%";
 var ARITHMETIC_SAFE_NUMBER = /^[-+]?(?:0[xX][0-9a-fA-F]+|\d+(?:\.\d+)?)$/;
-var printfAssignsNothing = (args) => args[0] === END_OF_OPTIONS || !isFlagToken(args[0] ?? "");
-var printfOperands = (args) => args[0] === END_OF_OPTIONS ? args.slice(1) : args;
+var printfAssignsNothing = (args) => args[0] === END_OF_OPTIONS3 || !isFlagToken(args[0] ?? "");
+var printfOperands = (args) => args[0] === END_OF_OPTIONS3 ? args.slice(1) : args;
 var convertsArgumentsOnlyAsText = (format) => !format.replace(PRINTF_TEXT_CONVERSION, "").includes(PRINTF_CONVERSION_START);
 var printfNeverEvaluatesAnArgument = ([format = "", ...values]) => convertsArgumentsOnlyAsText(format) || values.every((value) => ARITHMETIC_SAFE_NUMBER.test(value));
 var isOutputOnlyPrintf = (args) => printfAssignsNothing(args) && printfNeverEvaluatesAnArgument(printfOperands(args));
@@ -2758,7 +3185,7 @@ var SHELL_RESERVED_WORDS = /* @__PURE__ */ new Set([
   "]]"
 ]);
 var HARMLESS_GLOBAL_FLAGS = /* @__PURE__ */ new Set(["--no-pager", "--version", "-v", "-V", "--help", "-h"]);
-var END_OF_OPTIONS = "--";
+var END_OF_OPTIONS3 = "--";
 var SUBCOMMAND_DEPTH = 3;
 var SHELL_LINE_CONTINUATION = /\\\n/g;
 var invocationOf = (segment) => {
@@ -2770,13 +3197,13 @@ var argsAfterHarmlessGlobalFlags = (args) => {
   return firstMeaningful === -1 ? [] : args.slice(firstMeaningful);
 };
 var subcommandWordsOf = (args) => {
-  const endOfOptions = args.findIndex((arg) => arg.text === END_OF_OPTIONS);
+  const endOfOptions = args.findIndex((arg) => arg.text === END_OF_OPTIONS3);
   const options = endOfOptions === -1 ? args : args.slice(0, endOfOptions);
   return options.filter((arg) => !arg.text.startsWith("-")).slice(0, SUBCOMMAND_DEPTH);
 };
 var passesInlineCode = (arg) => {
   if (arg === INLINE_CODE_SUBCOMMAND || arg === STANDARD_INPUT_ARGUMENT || INLINE_CODE_LONG_FLAG.test(arg)) return true;
-  if (arg.startsWith(END_OF_OPTIONS)) return false;
+  if (arg.startsWith(END_OF_OPTIONS3)) return false;
   const cluster = SHORT_FLAG_CLUSTER.exec(arg)?.[1] ?? "";
   return [...cluster].some((letter) => INLINE_CODE_SHORT_FLAG_LETTERS.has(letter));
 };
@@ -2804,9 +3231,9 @@ var invocationTextWith = ({ program, args }, wordText) => {
 };
 var normalizedInvocation = (invocation) => invocationTextWith(invocation, (word) => word.text);
 var SHELL_METACHARACTER = /[\s;&|<>()$`\\"'*?[\]#~{}!]/;
-var SINGLE_QUOTE = "'";
+var SINGLE_QUOTE2 = "'";
 var ESCAPED_SINGLE_QUOTE = `'\\''`;
-var asOneShellWord = (text) => SHELL_METACHARACTER.test(text) ? `${SINGLE_QUOTE}${text.replaceAll(SINGLE_QUOTE, ESCAPED_SINGLE_QUOTE)}${SINGLE_QUOTE}` : text;
+var asOneShellWord = (text) => SHELL_METACHARACTER.test(text) ? `${SINGLE_QUOTE2}${text.replaceAll(SINGLE_QUOTE2, ESCAPED_SINGLE_QUOTE)}${SINGLE_QUOTE2}` : text;
 var quotedInvocation = (invocation) => invocationTextWith(invocation, (word) => asOneShellWord(word.text));
 var normalizedCommand = (command) => {
   const segments = readableCommandSegments(command);
@@ -2888,19 +3315,99 @@ var changesProduction = (invocation) => {
   const words = wordsOfInvocation(invocation);
   return words.some((word, index) => wordSelectsProduction(word, words[index - 1])) && (deployCliChangesSomething(words) || SCHEMA_CHANGE_WORD.test(normalizedInvocation(invocation)));
 };
-var MYSQL_SYNTAX = { inlineFlags: /* @__PURE__ */ new Set(["-e", "--execute"]), scriptFlags: /* @__PURE__ */ new Set(), positionalSql: false };
-var SQLITE_SYNTAX = { inlineFlags: /* @__PURE__ */ new Set(["-cmd"]), scriptFlags: /* @__PURE__ */ new Set(["-init"]), positionalSql: true };
+var STRING_WITH_DOUBLED_QUOTES = { backslashes: "uncertain-before-the-quote", content: "hidden" };
+var IDENTIFIER_WITH_DOUBLED_QUOTES = { backslashes: "uncertain-before-the-quote", content: "shown" };
+var MYSQL_STRING = { backslashes: "escape-unless-the-sql-mode-disables-it", content: "hidden" };
+var STRING_WITH_BACKSLASH_ESCAPES = { backslashes: "escape", content: "hidden" };
+var SHOWN_TEXT_WITH_BACKSLASH_ESCAPES = { backslashes: "escape", content: "shown" };
+var POSTGRES_LEXICON = {
+  singleQuotes: STRING_WITH_DOUBLED_QUOTES,
+  doubleQuotes: IDENTIFIER_WITH_DOUBLED_QUOTES,
+  backticks: IDENTIFIER_WITH_DOUBLED_QUOTES,
+  tripleQuotes: "absent",
+  escapeStringPrefix: "backslash-escapes",
+  dollarQuotes: "string",
+  dashDash: "comment",
+  carriageReturnInLineComment: "ends-the-comment",
+  hash: "text",
+  executableComments: "uncertain",
+  nestedBlockComments: "nest",
+  backslashOutsideLiterals: "text",
+  clientCharsets: "may-be-multibyte"
+};
+var MYSQL_LEXICON = {
+  singleQuotes: MYSQL_STRING,
+  doubleQuotes: STRING_WITH_DOUBLED_QUOTES,
+  backticks: IDENTIFIER_WITH_DOUBLED_QUOTES,
+  tripleQuotes: "absent",
+  escapeStringPrefix: "absent",
+  dollarQuotes: "uncertain",
+  dashDash: "comment-before-whitespace",
+  carriageReturnInLineComment: "stays-in-the-comment",
+  hash: "comment",
+  executableComments: "executed",
+  nestedBlockComments: "uncertain",
+  backslashOutsideLiterals: "client-command",
+  clientCharsets: "may-be-multibyte"
+};
+var SQLITE_LEXICON = {
+  singleQuotes: STRING_WITH_DOUBLED_QUOTES,
+  doubleQuotes: IDENTIFIER_WITH_DOUBLED_QUOTES,
+  backticks: IDENTIFIER_WITH_DOUBLED_QUOTES,
+  tripleQuotes: "absent",
+  escapeStringPrefix: "absent",
+  dollarQuotes: "uncertain",
+  dashDash: "comment",
+  carriageReturnInLineComment: "stays-in-the-comment",
+  hash: "text",
+  executableComments: "uncertain",
+  nestedBlockComments: "uncertain",
+  backslashOutsideLiterals: "text",
+  clientCharsets: "unicode"
+};
+var GOOGLE_SQL_LEXICON = {
+  singleQuotes: STRING_WITH_BACKSLASH_ESCAPES,
+  doubleQuotes: SHOWN_TEXT_WITH_BACKSLASH_ESCAPES,
+  backticks: SHOWN_TEXT_WITH_BACKSLASH_ESCAPES,
+  tripleQuotes: "quote",
+  escapeStringPrefix: "absent",
+  dollarQuotes: "uncertain",
+  dashDash: "comment",
+  carriageReturnInLineComment: "uncertain",
+  hash: "comment",
+  executableComments: "uncertain",
+  nestedBlockComments: "uncertain",
+  backslashOutsideLiterals: "text",
+  clientCharsets: "unicode"
+};
+var UNVERIFIED_SQL_LEXICON = {
+  singleQuotes: STRING_WITH_DOUBLED_QUOTES,
+  doubleQuotes: IDENTIFIER_WITH_DOUBLED_QUOTES,
+  backticks: IDENTIFIER_WITH_DOUBLED_QUOTES,
+  tripleQuotes: "absent",
+  escapeStringPrefix: "absent",
+  dollarQuotes: "uncertain",
+  dashDash: "uncertain-before-text",
+  carriageReturnInLineComment: "uncertain",
+  hash: "uncertain",
+  executableComments: "uncertain",
+  nestedBlockComments: "uncertain",
+  backslashOutsideLiterals: "text",
+  clientCharsets: "may-be-multibyte"
+};
+var MYSQL_SYNTAX = { inlineFlags: /* @__PURE__ */ new Set(["-e", "--execute"]), scriptFlags: /* @__PURE__ */ new Set(), positionalSql: false, lexicon: MYSQL_LEXICON };
+var SQLITE_SYNTAX = { inlineFlags: /* @__PURE__ */ new Set(["-cmd"]), scriptFlags: /* @__PURE__ */ new Set(["-init"]), positionalSql: true, lexicon: SQLITE_LEXICON };
 var SQL_CLIENT_SYNTAX = /* @__PURE__ */ new Map([
-  ["psql", { inlineFlags: /* @__PURE__ */ new Set(["-c", "--command"]), scriptFlags: /* @__PURE__ */ new Set(["-f", "--file"]), positionalSql: false }],
+  ["psql", { inlineFlags: /* @__PURE__ */ new Set(["-c", "--command"]), scriptFlags: /* @__PURE__ */ new Set(["-f", "--file"]), positionalSql: false, lexicon: POSTGRES_LEXICON }],
   ["mysql", MYSQL_SYNTAX],
   ["mariadb", MYSQL_SYNTAX],
   ["sqlite3", SQLITE_SYNTAX],
   ["sqlite", SQLITE_SYNTAX],
-  ["duckdb", { inlineFlags: /* @__PURE__ */ new Set(["-c", "-s", "-cmd"]), scriptFlags: /* @__PURE__ */ new Set(["-f", "-init"]), positionalSql: true }],
-  ["clickhouse-client", { inlineFlags: /* @__PURE__ */ new Set(["-q", "--query"]), scriptFlags: /* @__PURE__ */ new Set(["--queries-file"]), positionalSql: false }],
-  ["bq", { inlineFlags: /* @__PURE__ */ new Set(), scriptFlags: /* @__PURE__ */ new Set(), positionalSql: true }],
-  ["mongosh", { inlineFlags: /* @__PURE__ */ new Set(["--eval"]), scriptFlags: /* @__PURE__ */ new Set(["-f", "--file"]), positionalSql: false }],
-  ["mongo", { inlineFlags: /* @__PURE__ */ new Set(["--eval"]), scriptFlags: /* @__PURE__ */ new Set(), positionalSql: false }]
+  ["duckdb", { inlineFlags: /* @__PURE__ */ new Set(["-c", "-s", "-cmd"]), scriptFlags: /* @__PURE__ */ new Set(["-f", "-init"]), positionalSql: true, lexicon: UNVERIFIED_SQL_LEXICON }],
+  ["clickhouse-client", { inlineFlags: /* @__PURE__ */ new Set(["-q", "--query"]), scriptFlags: /* @__PURE__ */ new Set(["--queries-file"]), positionalSql: false, lexicon: UNVERIFIED_SQL_LEXICON }],
+  ["bq", { inlineFlags: /* @__PURE__ */ new Set(), scriptFlags: /* @__PURE__ */ new Set(), positionalSql: true, lexicon: GOOGLE_SQL_LEXICON }],
+  ["mongosh", { inlineFlags: /* @__PURE__ */ new Set(["--eval"]), scriptFlags: /* @__PURE__ */ new Set(["-f", "--file"]), positionalSql: false, lexicon: UNVERIFIED_SQL_LEXICON }],
+  ["mongo", { inlineFlags: /* @__PURE__ */ new Set(["--eval"]), scriptFlags: /* @__PURE__ */ new Set(), positionalSql: false, lexicon: UNVERIFIED_SQL_LEXICON }]
 ]);
 var SQL_WRITE_STATEMENT = new RegExp([
   String.raw`\b(?:insert|update|delete|merge|upsert|alter|create|drop|truncate|grant|revoke|copy|vacuum|reindex|rename|attach|detach)\b`,
@@ -2909,21 +3416,26 @@ var SQL_WRITE_STATEMENT = new RegExp([
   String.raw`\binto\s+(?:out|dump)file\b`,
   String.raw`\bset\s+(?:global|persist)\b`,
   String.raw`\bkill\s+(?:query|connection|\d)`,
-  String.raw`\bcall\s+[\w.]+\s*\(`,
-  String.raw`\bdo\s+(?:\$\w*\$|')`,
+  String.raw`\bcall\b`,
+  String.raw`\bexecute\s+immediate\b`,
+  String.raw`\bprepare\s+\S+\s+from\b`,
+  String.raw`\bselect\b[^;]*\binto\b(?!\s*@)`,
+  String.raw`(?:^|;)\s*lock\b`,
+  String.raw`(?:^|;)\s*do\b`,
   String.raw`\bpg_terminate_backend\b`,
   String.raw`\bsetval\b`,
   String.raw`\bpragma\s+writable_schema\b`,
   String.raw`\.(?:insert|update|delete|replace|remove|drop|rename|create|bulkwrite|findoneand)\w*\s*\(`
 ].join("|"), "i");
 var SQL_READ_PHRASE = /\bshow\s+create\b/gi;
-var SQL_STRING_LITERAL = /'(?:[^']|'')*'/g;
-var EMPTY_SQL_STRING = "''";
-var SQL_COMMENT = /--[^\n]*|\/\*[\s\S]*?\*\//g;
-var writesThroughSql = (sql) => {
-  const statement = sql.replace(SQL_COMMENT, " ").replace(SQL_STRING_LITERAL, EMPTY_SQL_STRING).replace(SQL_READ_PHRASE, "");
+var sqlTextWrites = (text) => {
+  const statement = text.replace(SQL_READ_PHRASE, "");
   return SQL_WRITE_STATEMENT.test(statement) || SQL_CLIENT_FILE_COMMAND.test(statement);
 };
+var writesThroughSql = (sql, lexicon) => {
+  const parsed = sqlOutsideLiterals(sql, lexicon);
+  return parsed.kind === "uncertain" || parsed.texts.some(sqlTextWrites);
+};
 var SQL_CLIENT_FILE_COMMAND = new RegExp([
   String.raw`(?:^|[\s;=])\\(?:i|ir|include|include_relative|o|out|w|write|gexec|!|\.)(?=\s|$)`,
   String.raw`(?:^|[\s;=])\\g\s*\|`,
@@ -2931,6 +3443,7 @@ var SQL_CLIENT_FILE_COMMAND = new RegExp([
   String.raw`(?:^|[;=])\s*(?:system|source)\s`
 ].join("|"), "i");
 var SHORT_FLAG_CLUSTER_ONLY = /^-([A-Za-z0-9]+)$/;
+var LEADING_OPTION_DASHES = /^-+/;
 var NO_SQL = { script: false, sql: null, hidden: false };
 var shortFlagOf = (flags, text) => [...flags].find((flag) => /^-[A-Za-z]$/.test(flag) && text.startsWith(flag) && text.length > flag.length && !text.startsWith("--"));
 var sqlArgumentAt = (args, index, syntax) => {
@@ -2950,7 +3463,7 @@ var sqlArgumentAt = (args, index, syntax) => {
   const last = cluster ? `-${cluster.slice(-1)}` : "";
   if (cluster && cluster.length > 1 && syntax.scriptFlags.has(last)) return { script: true, sql: null, hidden: false };
   if (cluster && cluster.length > 1 && syntax.inlineFlags.has(last)) return valueOf(next);
-  return { script: false, sql: arg.text, hidden: false };
+  return { script: false, sql: arg.text.replace(LEADING_OPTION_DASHES, ""), hidden: false };
 };
 var namesALongFlagValue = (text, flags) => [...flags].some((flag) => flag.startsWith("--") && text.startsWith(`${flag}${FLAG_VALUE_SEPARATOR}`));
 var positionalSqlIsHidden = (args, syntax) => syntax.positionalSql && args.filter((arg) => !arg.text.startsWith("-")).slice(1).some((arg) => arg.expands);
@@ -2960,7 +3473,7 @@ var sqlClientChangesData = (invocation) => {
   if (syntax === void 0) return false;
   return positionalSqlIsHidden(invocation.args, syntax) || invocation.args.some((_, index) => {
     const { script, sql, hidden } = sqlArgumentAt(invocation.args, index, syntax);
-    return script || hidden || sql !== null && writesThroughSql(sql);
+    return script || hidden || sql !== null && writesThroughSql(sql, syntax.lexicon);
   });
 };
 var PULL_REQUEST_CLIS = /* @__PURE__ */ new Set(["gh", "glab"]);
@@ -3102,10 +3615,24 @@ var GITHUB_READ_COMMANDS = /* @__PURE__ */ new Map([
 var GITHUB_OPTIONS_WITH_VALUES = /* @__PURE__ */ new Set(["-R", "--repo", "--hostname"]);
 var GITHUB_API_SUBCOMMAND = "api";
 var GITHUB_GRAPHQL_ENDPOINT = "graphql";
-var HTTP_METHOD_FLAGS = /* @__PURE__ */ new Set(["-X", "--method"]);
-var HTTP_METHOD_ATTACHED = /^(?:-X|--method=)(.+)$/;
+var HTTP_METHOD_OPTIONS = /* @__PURE__ */ new Set(["-X", "--method"]);
 var HTTP_READ_METHODS = /* @__PURE__ */ new Set(["GET", "HEAD"]);
-var GITHUB_API_BODY_FLAG = /^(?:-[fF]|--(?:field|raw-field|input)(?:=|$))/;
+var GITHUB_API_BODY_OPTIONS = /* @__PURE__ */ new Set(["-f", "-F", "--field", "--raw-field", "--input"]);
+var GITHUB_API_SHORT_SWITCHES = /* @__PURE__ */ new Set(["i", "h"]);
+var GITHUB_API_SHORT_OPTIONS_WITH_A_VALUE = /* @__PURE__ */ new Set(["X", "F", "f", "H", "p", "t", "q"]);
+var GITHUB_API_LONG_OPTIONS_WITH_A_VALUE = /* @__PURE__ */ new Set([
+  "--method",
+  "--field",
+  "--raw-field",
+  "--header",
+  "--preview",
+  "--input",
+  "--template",
+  "--jq",
+  "--cache",
+  "--hostname"
+]);
+var PFLAG_ATTACHED_VALUE_PREFIX = /^=/;
 var GITHUB_API_FILE_FIELD = /=@|^--input(?:=|$)/;
 var GRAPHQL_MUTATION = /\bmutation\b/i;
 var STRIPE_READ_COMMANDS = /* @__PURE__ */ new Set([
@@ -3154,29 +3681,63 @@ var S3_URL_PREFIX = "s3://";
 var TWILIO_TOPIC_SEPARATOR = ":";
 var TWILIO_READ_ACTIONS = /* @__PURE__ */ new Set(["list", "fetch"]);
 var positionalWordsOf = (args, optionsWithValues) => {
-  const endOfOptions = args.findIndex((arg) => arg.text === END_OF_OPTIONS);
+  const endOfOptions = args.findIndex((arg) => arg.text === END_OF_OPTIONS3);
   const options = endOfOptions === -1 ? args : args.slice(0, endOfOptions);
   const operands = endOfOptions === -1 ? [] : args.slice(endOfOptions + 1);
   const positional = options.filter((arg, index) => !arg.text.startsWith("-") && !optionsWithValues.has(options[index - 1]?.text ?? ""));
   return [...positional, ...operands];
 };
-var httpMethodOf = (args) => {
-  for (const [index, arg] of args.entries()) {
-    const attached = HTTP_METHOD_ATTACHED.exec(arg.text);
-    if (attached) return arg.expands ? null : attached[1];
-    if (HTTP_METHOD_FLAGS.has(arg.text)) {
-      const value = args[index + 1];
-      return value === void 0 || value.expands ? null : value.text;
+var NO_CLI_OPTION = [];
+var githubApiLongOptionAt = (args, index, arg) => {
+  const separator = arg.text.indexOf(FLAG_VALUE_SEPARATOR);
+  if (separator !== -1) {
+    return { options: [{ name: arg.text.slice(0, separator), value: { ...arg, text: arg.text.slice(separator + 1) } }], next: index + 1 };
+  }
+  if (!GITHUB_API_LONG_OPTIONS_WITH_A_VALUE.has(arg.text)) return { options: [{ name: arg.text, value: void 0 }], next: index + 1 };
+  return { options: [{ name: arg.text, value: args[index + 1] }], next: index + 2 };
+};
+var githubApiShortOptionsAt = (args, index, arg) => {
+  const options = [];
+  for (let position = 1; position < arg.text.length; position += 1) {
+    const letter = arg.text.charAt(position);
+    const name = `-${letter}`;
+    if (GITHUB_API_SHORT_SWITCHES.has(letter)) {
+      options.push({ name, value: void 0 });
+      continue;
     }
+    if (!GITHUB_API_SHORT_OPTIONS_WITH_A_VALUE.has(letter)) return null;
+    const attached = arg.text.slice(position + 1);
+    if (attached === "") return { options: [...options, { name, value: args[index + 1] }], next: index + 2 };
+    return { options: [...options, { name, value: { ...arg, text: attached.replace(PFLAG_ATTACHED_VALUE_PREFIX, "") } }], next: index + 1 };
   }
-  return void 0;
+  return { options, next: index + 1 };
+};
+var githubApiOptionsAt = (args, index, arg) => {
+  if (LONG_OPTION.test(arg.text)) return githubApiLongOptionAt(args, index, arg);
+  if (FLAG.test(arg.text) && arg.text !== STANDARD_INPUT_ARGUMENT) return githubApiShortOptionsAt(args, index, arg);
+  return { options: NO_CLI_OPTION, next: index + 1 };
+};
+var githubApiOptionsOf = (args) => {
+  const options = [];
+  for (let index = 0; index < args.length; ) {
+    const arg = args[index];
+    if (arg === void 0 || arg.text === END_OF_OPTIONS3) break;
+    const parsed = githubApiOptionsAt(args, index, arg);
+    if (parsed === null) return null;
+    options.push(...parsed.options);
+    index = parsed.next;
+  }
+  return options;
 };
+var requestMethodCanWrite = (method) => method === void 0 || method.expands || !HTTP_READ_METHODS.has(method.text.toUpperCase());
 var graphqlRequestCanWrite = (args) => args.some((arg) => arg.expands || GRAPHQL_MUTATION.test(arg.text) || GITHUB_API_FILE_FIELD.test(arg.text));
 var githubApiRequestWrites = (args) => {
-  const method = httpMethodOf(args);
-  if (method !== void 0) return method === null || !HTTP_READ_METHODS.has(method.toUpperCase());
+  const options = githubApiOptionsOf(args);
+  if (options === null) return true;
+  const method = options.filter((option) => HTTP_METHOD_OPTIONS.has(option.name)).at(-1);
+  if (method !== void 0) return requestMethodCanWrite(method.value);
   if (args.some((arg) => arg.text === GITHUB_GRAPHQL_ENDPOINT)) return graphqlRequestCanWrite(args);
-  return args.some((arg) => GITHUB_API_BODY_FLAG.test(arg.text));
+  return options.some((option) => GITHUB_API_BODY_OPTIONS.has(option.name));
 };
 var githubCommandOnlyReads = (noun, verb) => {
   if (noun === void 0 || GITHUB_COMMANDS_THAT_ONLY_READ.has(noun.text)) return true;
@@ -3360,8 +3921,9 @@ var findRunnerEnd = (args, from) => {
 };
 var wrapperSyntax = (optionsWithAValue = [], operandsBeforeTheCommand = 0) => ({ optionsWithAValue: new Set(optionsWithAValue), operandsBeforeTheCommand });
 var ENVIRONMENT_ASSIGNMENTS = wrapperSyntax();
+var ENV = "env";
+var ENV_SPLIT_STRING_ESCAPE = /[\\$]/;
 var WRAPPER_SYNTAX = /* @__PURE__ */ new Map([
-  ["env", wrapperSyntax(["-u", "--unset", "-C", "--chdir", "-S", "--split-string", "-P"])],
   ["xargs", wrapperSyntax([
     "-I",
     "-J",
@@ -3423,22 +3985,39 @@ var WRAPPER_SYNTAX = /* @__PURE__ */ new Map([
   ["pnpx", wrapperSyntax()],
   ["uvx", wrapperSyntax(["--from", "--with", "-p", "--python"])]
 ]);
-var SHELLS = /* @__PURE__ */ new Set(["sh", "bash", "zsh", "dash", "ksh"]);
-var SCRIPT_FLAG_CLUSTER = /^-[A-Za-z]*c$/;
 var EVAL = "eval";
 var MAX_CONSEQUENCE_DEPTH = 4;
+var shortValueOptionPosition = (text, options) => {
+  if (!text.startsWith("-") || text.startsWith("--")) return -1;
+  for (let index = 1; index < text.length; index += 1) {
+    if (options.has(`-${text[index]}`)) return index;
+  }
+  return -1;
+};
+var wrapperOptionConsumesNextWord = (text, options) => {
+  if (options.has(text)) return true;
+  const position = shortValueOptionPosition(text, options);
+  return position !== -1 && position === text.length - 1;
+};
 var commandStartAfterWrapper = (words, syntax) => {
   let index = 0;
   while (index < words.length) {
     const text = words[index]?.text ?? "";
-    if (text === END_OF_OPTIONS) return index + 1 + syntax.operandsBeforeTheCommand;
+    if (text === END_OF_OPTIONS3) return index + 1 + syntax.operandsBeforeTheCommand;
     if (!SHELL_ENV_ASSIGNMENT.test(text) && (!FLAG.test(text) || text === STANDARD_INPUT_ARGUMENT)) break;
-    index += syntax.optionsWithAValue.has(text) ? 2 : 1;
+    index += wrapperOptionConsumesNextWord(text, syntax.optionsWithAValue) ? 2 : 1;
   }
   return index + syntax.operandsBeforeTheCommand;
 };
+var envWrappedInvocation = (args) => {
+  const reading = envReadingOf(args);
+  if (reading.kind !== "command") return null;
+  const command = args[reading.start];
+  return command === void 0 ? null : { program: command, args: args.slice(reading.start + 1) };
+};
 var wrappedInvocation = ({ program, args }) => {
   if (program === void 0) return null;
+  if (basenameOf(program.text) === ENV) return envWrappedInvocation(args);
   const assigns = SHELL_ENV_ASSIGNMENT.test(program.text);
   const syntax = assigns ? ENVIRONMENT_ASSIGNMENTS : WRAPPER_SYNTAX.get(basenameOf(program.text));
   if (syntax === void 0) return null;
@@ -3447,17 +4026,29 @@ var wrappedInvocation = ({ program, args }) => {
   const command = words[start];
   return command === void 0 ? null : { program: command, args: words.slice(start + 1) };
 };
-var innermostInvocation = (invocation, depth = 0) => {
-  const wrapped = depth < MAX_CONSEQUENCE_DEPTH ? wrappedInvocation(invocation) : null;
-  return wrapped === null ? invocation : innermostInvocation(wrapped, depth + 1);
+var innermostInvocation = (invocation) => {
+  let current = invocation;
+  let wrapped = wrappedInvocation(current);
+  while (wrapped !== null) {
+    current = wrapped;
+    wrapped = wrappedInvocation(current);
+  }
+  return current;
+};
+var envSplitScriptOf = ({ prefix, value, rest }, args) => {
+  if (value === void 0 || value.expands || ENV_SPLIT_STRING_ESCAPE.test(value.text)) return null;
+  return [ENV, ...prefix.map(asOneShellWord), value.text, ...args.slice(rest).map((arg) => asOneShellWord(arg.text))].join(" ");
 };
 var shellScriptOf = ({ program, args }) => {
   if (program === void 0) return null;
-  if (basenameOf(program.text) === EVAL) return args.some((arg) => arg.expands) ? null : args.map((arg) => arg.text).join(" ");
-  if (!SHELLS.has(basenameOf(program.text))) return null;
-  const flag = args.findIndex((arg) => SCRIPT_FLAG_CLUSTER.test(arg.text));
-  const script = flag === -1 ? void 0 : args[flag + 1];
-  return script === void 0 || script.expands ? null : script.text;
+  const name = basenameOf(program.text);
+  if (name === ENV) {
+    const reading = envReadingOf(args);
+    return reading.kind === "split" ? envSplitScriptOf(reading, args) : null;
+  }
+  if (name === EVAL) return args.some((arg) => arg.expands) ? null : args.map((arg) => arg.text).join(" ");
+  const commandString = shellCommandStringOf(name, args);
+  return commandString.kind === "readable" ? commandString.script : null;
 };
 var FLAG = /^-/;
 var FLAG_WITH_ATTACHED_VALUE = /^-[^=]*=/;
@@ -3485,18 +4076,19 @@ var honoursPreviewFlags = ({ program, args }) => {
 var onlyPreviews = (invocation) => invocation.program !== void 0 && honoursPreviewFlags(invocation) && invocation.args.some((arg) => !arg.expands && PREVIEW_FLAG.test(arg.text));
 var changesWhatIsDeployed = (toolName, invocation, normalized) => !onlyPreviews(invocation) && (changesProduction(invocation) || mergesAPullRequest(invocation) || isCoveredByPolicy(DEPLOY_AND_SCHEMA_COMMAND_PATTERNS, toolName, normalized));
 var invocationHasAVisibleConsequence = (toolName, invocation, depth) => {
-  if (invocation.program === void 0 || depth > MAX_CONSEQUENCE_DEPTH) return false;
+  if (depth > MAX_CONSEQUENCE_DEPTH) return true;
+  if (invocation.program === void 0) return false;
   const normalized = quotedInvocation(invocation);
-  const wrapped = wrappedInvocation(invocation);
+  const innermost = innermostInvocation(invocation);
   const script = shellScriptOf(invocation);
-  return classifyDecisionRisk(toolName, normalized) === "destructive" || changesWhatIsDeployed(toolName, invocation, normalized) || writesASecretFile(invocation) || losesDataVisibly(toolName, invocation, normalized, depth) || subcommandDestroysVisibly(invocation) || sqlClientChangesData(invocation) || wrapped !== null && invocationHasAVisibleConsequence(toolName, wrapped, depth + 1) || script !== null && commandHasAVisibleConsequenceAt(toolName, script, depth + 1) || readingsPastGlobalFlags(invocation).some((reading) => invocationHasAVisibleConsequence(toolName, reading, depth + 1));
+  return classifyDecisionRisk(toolName, normalized) === "destructive" || changesWhatIsDeployed(toolName, invocation, normalized) || writesASecretFile(invocation) || losesDataVisibly(toolName, invocation, normalized, depth) || subcommandDestroysVisibly(invocation) || sqlClientChangesData(invocation) || innermost !== invocation && invocationHasAVisibleConsequence(toolName, innermost, depth) || script === null && passesAnInlineScript(invocation) || script !== null && commandHasAVisibleConsequenceAt(toolName, script, depth + 1) || readingsPastGlobalFlags(invocation).some((reading) => invocationHasAVisibleConsequence(toolName, reading, depth + 1));
 };
 var RUNS_FETCHED_CODE = /(?:\$\(|`|<\()\s*(?:curl|wget)\b/;
 var FETCHING_PROGRAMS = /* @__PURE__ */ new Set(["curl", "wget"]);
 var READS_ITS_SCRIPT_FROM_STANDARD_INPUT = /^-[A-Za-z]*s[A-Za-z]*$/;
 var interpreterNameOf = (program) => basenameOf(program.text).replace(/\d+(?:\.\d+)*$/, "");
-var runsScripts = (program) => SHELLS.has(basenameOf(program.text)) || INLINE_CODE_INTERPRETERS.has(interpreterNameOf(program));
-var runsWhatItReads = ({ program, args }) => program !== void 0 && runsScripts(program) && (args.length === 0 || args.every((arg) => arg.text.startsWith("-")) || args.some((arg) => arg.text === STANDARD_INPUT_ARGUMENT) || SHELLS.has(basenameOf(program.text)) && args.some((arg) => READS_ITS_SCRIPT_FROM_STANDARD_INPUT.test(arg.text)));
+var runsScripts = (program) => POSIX_SHELL_PROGRAMS.has(basenameOf(program.text)) || INLINE_CODE_INTERPRETERS.has(interpreterNameOf(program));
+var runsWhatItReads = ({ program, args }) => program !== void 0 && runsScripts(program) && (args.length === 0 || args.every((arg) => arg.text.startsWith("-")) || args.some((arg) => arg.text === STANDARD_INPUT_ARGUMENT) || POSIX_SHELL_PROGRAMS.has(basenameOf(program.text)) && args.some((arg) => READS_ITS_SCRIPT_FROM_STANDARD_INPUT.test(arg.text)));
 var fetches = (invocation) => FETCHING_PROGRAMS.has(basenameOf(innermostInvocation(invocation).program?.text ?? ""));
 var URL_QUERY_OR_FRAGMENT2 = /[?#].*$/;
 var SOURCES_A_SCRIPT = /* @__PURE__ */ new Set(["source", "."]);
@@ -3611,7 +4203,7 @@ var roughSegmentsOf = (command) => {
 };
 var roughSegmentHasAVisibleConsequence = (toolName, segment, fetchesCode, depth) => {
   const innermost = innermostInvocation(segment.invocation);
-  const runsAHeredocScript = innermost.program !== void 0 && SHELLS.has(basenameOf(innermost.program.text));
+  const runsAHeredocScript = innermost.program !== void 0 && POSIX_SHELL_PROGRAMS.has(basenameOf(innermost.program.text));
   return invocationHasAVisibleConsequence(toolName, segment.invocation, depth) || sqlClientSyntaxOf(innermost) !== void 0 && (segment.readsInput || segment.feedsASubstitution) || segment.readsAPipe && fetchesCode && runsWhatItReads(innermost) || runsAHeredocScript && segment.heredocs.some((body) => commandHasAVisibleConsequenceAt(toolName, body, depth + 1));
 };
 var roughReadingHasAVisibleConsequence = (toolName, command, depth) => {
@@ -3701,14 +4293,28 @@ var canonicalInvocationText = (invocation) => invocationTextWith(invocation, (wo
 var spellingsOfAnInvocation = (invocation, innermost) => [invocation, innermost, ...gitReadingsPastGlobalOptions(innermost), ...readingsPastGlobalFlags(innermost)].flatMap((reading) => [verbatimInvocationText(reading), canonicalInvocationText(reading)]);
 var NO_INLINE_SCRIPT = { kind: "none" };
 var HIDDEN_INLINE_SCRIPT = { kind: "hidden" };
+var ENV_READINGS_THAT_NAME_THEIR_OUTCOME = /* @__PURE__ */ new Set(["command", "runs-nothing"]);
+var envPassesItsCommandIndirectly = (reading) => !ENV_READINGS_THAT_NAME_THEIR_OUTCOME.has(reading.kind);
 var passesAnInlineScript = ({ program, args }) => {
   const name = basenameOf(program?.text ?? "");
-  return name === EVAL || SHELLS.has(name) && args.some((arg) => SCRIPT_FLAG_CLUSTER.test(arg.text));
-};
-var shellReadsItsScript = (invocation) => SHELLS.has(basenameOf(invocation.program?.text ?? "")) && runsWhatItReads(invocation);
+  return name === EVAL || shellCommandStringOf(name, args).kind !== "absent" || name === ENV && envPassesItsCommandIndirectly(envReadingOf(args));
+};
+var envCommandScriptOf = (start, args) => args[start]?.expands ? null : args.slice(start).map((word) => asOneShellWord(word.text)).join(" ");
+var envCandidateScriptOf = (reading, args) => reading.kind === "split" ? envSplitScriptOf(reading, args) : envCommandScriptOf(reading.start, args);
+var isAScript = (script) => script !== null;
+var envCandidateScriptsOf = ({ program, args }) => {
+  if (basenameOf(program?.text ?? "") !== ENV) return NO_INLINE_SCRIPT;
+  const reading = envReadingOf(args);
+  if (reading.kind !== "ambiguous") return NO_INLINE_SCRIPT;
+  const scripts = reading.readings.map((candidate) => envCandidateScriptOf(candidate, args));
+  return scripts.every(isAScript) ? { kind: "readable", scripts } : HIDDEN_INLINE_SCRIPT;
+};
+var shellReadsItsScript = (invocation) => POSIX_SHELL_PROGRAMS.has(basenameOf(invocation.program?.text ?? "")) && runsWhatItReads(invocation);
 var inlineScriptsOf = (invocation, heredocs) => {
   const script = shellScriptOf(invocation);
   if (script !== null) return { kind: "readable", scripts: [script] };
+  const envCandidates = envCandidateScriptsOf(invocation);
+  if (envCandidates.kind !== "none") return envCandidates;
   if (passesAnInlineScript(invocation)) return HIDDEN_INLINE_SCRIPT;
   if (!shellReadsItsScript(invocation)) return NO_INLINE_SCRIPT;
   return heredocs.length > 0 ? { kind: "readable", scripts: heredocs } : HIDDEN_INLINE_SCRIPT;
@@ -5190,6 +5796,8 @@ export {
   MAX_HOOK_ACTIVATION_EVIDENCE_ROWS,
   isHookActivationReport,
   hookActivationResult,
+  CLIENT_REPORT_PATH,
+  clientContextHeaders,
   PAIR_TTL_SECONDS,
   computerOsOfPlatform,
   SETUP_AGENT_CHOICES,
@@ -5197,8 +5805,6 @@ export {
   NO_PAIRING_COMPUTER,
   SETUP_CONNECT_MODES,
   isSetupConnectMode,
-  CLIENT_REPORT_PATH,
-  clientContextHeaders,
   DECLINED_AGENTS_FILE,
   parseDeclinedAgents,
   serializeDeclinedAgents,