@poetic-ai/poetic 1.42.0

package/dist/chunk-LO23NABI.js

@@ -0,0 +1,3063 @@
+import {
+  resolveExecutionBoundary
+} from "./chunk-7R2WLDOS.js";
+import {
+  describeVerificationCommand,
+  detectExitZeroVerifyFailure,
+  detectZeroCollectedTests,
+  resolveVerificationExitCode
+} from "./chunk-2QLYTVYX.js";
+
+// src/core/verification/verify-commands.ts
+import { execa } from "execa";
+var VERIFY_GLOBAL_BUDGET_EXIT_CODE = 124;
+var VERIFY_COMMAND_REJECTED_EXIT_CODE = 126;
+var VERIFY_COMMAND_PROCESS_FAILURE_EXIT_CODE = 1;
+var VERIFY_COMMAND_MAX_BUFFER_BYTES = 128 * 1024 * 1024;
+var VERIFY_COMMAND_RETAINED_TAIL_BYTES = 256 * 1024;
+function boundTailBytes(output, maxBytes) {
+  if (output.length <= maxBytes) return output;
+  return output.slice(output.length - maxBytes);
+}
+var ALLOWED_VERIFY_EXECUTABLES = /* @__PURE__ */ new Set([
+  "ava",
+  "biome",
+  "black",
+  "bundle",
+  "bun",
+  "cargo",
+  "clang-tidy",
+  "cmake",
+  "composer",
+  "ctest",
+  "dart",
+  "dbt",
+  "detekt",
+  "dotnet",
+  "echo",
+  "eslint",
+  "env",
+  "flutter",
+  "git",
+  "go",
+  "golangci-lint",
+  "govulncheck",
+  "gradle",
+  "gradlew",
+  "grep",
+  "hadolint",
+  "jest",
+  "just",
+  "ktlint",
+  "kubeconform",
+  "make",
+  "meson",
+  "mocha",
+  "mvn",
+  "mvnw",
+  "mypy",
+  "node",
+  "npm",
+  "npx",
+  "pnpm",
+  "poetic",
+  "powershell",
+  "powershell.exe",
+  "prettier",
+  "printf",
+  "pwsh",
+  "pwsh.exe",
+  "pytest",
+  "py",
+  "php",
+  "phpstan",
+  "phpunit",
+  "pip-audit",
+  "psalm",
+  "python",
+  "python3",
+  "R",
+  "rake",
+  "rspec",
+  "ruff",
+  "ruby",
+  "rubocop",
+  "shellcheck",
+  "sqlfluff",
+  "staticcheck",
+  "swift",
+  "swiftlint",
+  "tap",
+  "task",
+  "terraform",
+  "test",
+  "tflint",
+  "tsc",
+  "turbo",
+  "vitest",
+  "vue-tsc",
+  "yarn"
+]);
+var REJECTED_VERIFY_EXECUTABLES = /* @__PURE__ */ new Set([
+  "bash",
+  "dash",
+  "fish",
+  "ksh",
+  "osascript",
+  "powershell",
+  "powershell.exe",
+  "pwsh",
+  "pwsh.exe",
+  "sh",
+  "zsh"
+]);
+function compactOutputSnippet(value, maxChars = 160) {
+  const normalized = String(value ?? "").replace(/\s+/g, " ").trim();
+  if (!normalized) return void 0;
+  return normalized.length <= maxChars ? normalized : `${normalized.slice(0, maxChars - 1)}...`;
+}
+function summarizeVerifyCommandRun(results, totalCommands) {
+  const passedCount = results.filter((result) => result.exitCode === 0).length;
+  const failedResult = results.find((result) => result.exitCode !== 0);
+  const failedCount = failedResult ? 1 : 0;
+  const skippedCount = Math.max(0, totalCommands - results.length);
+  if (!failedResult) {
+    return `Verify passed: ${passedCount} passed, 0 failed, ${skippedCount} skipped.`;
+  }
+  const outputSnippet = compactOutputSnippet(
+    failedResult.stderrTail || failedResult.stdoutTail || failedResult.outputTail
+  );
+  return `Verify failed: ${passedCount} passed, ${failedCount} failed, ${skippedCount} skipped. Failed command: ${failedResult.command} (exit ${failedResult.exitCode})` + (outputSnippet ? `. Output: ${outputSnippet}` : ".");
+}
+function validationSurfaceToCommands(surface) {
+  return surface.commands;
+}
+function mergeValidationSurfaces(surfaces) {
+  const seen = /* @__PURE__ */ new Set();
+  const commands = [];
+  for (const surface of surfaces) {
+    for (const cmd of surface.commands) {
+      if (!seen.has(cmd)) {
+        seen.add(cmd);
+        commands.push(cmd);
+      }
+    }
+  }
+  return commands;
+}
+function formatOutputTail(content, maxLines = 80) {
+  const lines = String(content ?? "").split(/\r?\n/);
+  const tail = lines.slice(-maxLines).join("\n").trim();
+  return tail.length > 0 ? tail : "(no output)";
+}
+function errorMessage(value) {
+  if (value instanceof Error) return value.message;
+  if (typeof value === "string" && value.trim()) return value.trim();
+  return void 0;
+}
+function resolveProcessExitCode(command, result) {
+  if (result.isCanceled) {
+    return VERIFY_GLOBAL_BUDGET_EXIT_CODE;
+  }
+  return resolveVerificationExitCode(command, result, {
+    failureExitCode: VERIFY_COMMAND_PROCESS_FAILURE_EXIT_CODE
+  }).exitCode;
+}
+function describeMissingProcessExitCode(result) {
+  if (typeof result.exitCode === "number") return void 0;
+  const reasons = [];
+  if (result.timedOut) reasons.push("timed out");
+  if (result.isCanceled) reasons.push("canceled");
+  if (result.signal) reasons.push(`signal ${result.signal}`);
+  if (result.killed) reasons.push("killed");
+  if (result.failed) reasons.push("failed");
+  const message = errorMessage(result.error);
+  if (message) reasons.push(message);
+  return "[verify] Process ended without a numeric exit code" + (reasons.length > 0 ? ` (${reasons.join(", ")})` : "") + ". Treating as failure.";
+}
+function detectTestRunnerFailureSummary(command, output) {
+  const failure = detectExitZeroVerifyFailure(command, output)?.message;
+  if (failure) return failure;
+  if (detectZeroCollectedTests(command, output)) {
+    return "Test command exited 0 but collected/ran zero tests; no verification evidence.";
+  }
+  return void 0;
+}
+function hasShellControlOperators(command) {
+  return /(?:\|\||&&|[|;<>])/.test(command);
+}
+function isBaselineComparableTypeScriptCompilerCommand(command) {
+  const parsed = parseVerifyCommand(command);
+  if (!Array.isArray(parsed) || parsed.length !== 1) return false;
+  const argv = parsed[0]?.argv ?? [];
+  const executable = getExecutableName(argv[0] ?? "").replace(/\.(?:cmd|exe|ps1)$/i, "");
+  let targetIndex = 0;
+  if (executable === "npx" || executable === "pnpx" || executable === "bunx") {
+    targetIndex = 1;
+    while (argv[targetIndex] === "--no-install" || argv[targetIndex] === "--offline") {
+      targetIndex += 1;
+    }
+  }
+  const target = argv[targetIndex] ?? "";
+  const targetName = getExecutableName(target).replace(/\.(?:cmd|exe|ps1)$/i, "");
+  if (targetName !== "tsc" && targetName !== "vue-tsc") return false;
+  const args = argv.slice(targetIndex + 1);
+  return args.some(
+    (arg) => arg === "--noEmit" || arg === "-p" || arg.startsWith("-p=") || arg === "--project" || arg.startsWith("--project=") || arg === "-b" || arg === "--build" || /(?:^|[/\\])tsconfig[^/\\]*\.json$/i.test(arg)
+  );
+}
+function makeSignatureNewCount(signatures, count) {
+  return (baselineOutput, currentOutput) => {
+    const currentCount = count(currentOutput);
+    if (currentCount === 0) return 0;
+    const baselineSigs = signatures(baselineOutput);
+    const currentSigs = signatures(currentOutput);
+    if (baselineSigs.size === 0 || currentSigs.size === 0) {
+      const delta = currentCount - count(baselineOutput);
+      return delta > 0 ? delta : 1;
+    }
+    let newCount = 0;
+    for (const sig of currentSigs) {
+      if (!baselineSigs.has(sig)) newCount++;
+    }
+    return newCount;
+  };
+}
+function extractRustErrorSignatures(output) {
+  const signatures = /* @__PURE__ */ new Set();
+  const lines = output.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i] ?? "";
+    const m = /^error(\[E\d+\])?:\s*(.*)$/.exec(line.trim());
+    if (!m) continue;
+    if (/could not compile .*due to \d+ previous error/i.test(line)) continue;
+    const code = m[1] ?? "";
+    const msg = (m[2] ?? "").trim().slice(0, 120);
+    const next = (lines[i + 1] ?? "").trim();
+    const loc = /^-->\s+(.+)$/.exec(next)?.[1] ?? "";
+    signatures.add(`${loc} - error${code}: ${msg}`);
+  }
+  return signatures;
+}
+function countRustErrorsFromOutput(output) {
+  const summaryMatches = [...output.matchAll(/due to (\d+) previous errors?/gi)];
+  const lastSummary = summaryMatches.at(-1);
+  if (lastSummary?.[1]) {
+    const parsed = Number.parseInt(lastSummary[1], 10);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  const errorLines = output.split(/\r?\n/).filter(
+    (line) => /^error(\[E\d+\])?:/.test(line.trim()) && !/could not compile .*due to \d+ previous error/i.test(line)
+  );
+  return errorLines.length > 0 ? errorLines.length : 1;
+}
+var GO_ERROR_LINE_RE = /^(.+?\.go):(\d+)(?::(\d+))?:\s+(.*)$/;
+function extractGoErrorSignatures(output) {
+  const signatures = /* @__PURE__ */ new Set();
+  for (const line of output.split(/\r?\n/)) {
+    const m = GO_ERROR_LINE_RE.exec(line.trim());
+    if (!m) continue;
+    const msg = (m[4] ?? "").trim().slice(0, 120);
+    signatures.add(`${m[1]}:${m[2]} - ${msg}`);
+  }
+  return signatures;
+}
+function countGoErrorsFromOutput(output) {
+  const matches = output.split(/\r?\n/).filter((line) => GO_ERROR_LINE_RE.test(line.trim()));
+  return matches.length > 0 ? matches.length : 1;
+}
+var MYPY_ERROR_LINE_RE = /^(.+?\.py):(\d+)(?::\d+)?:\s+error:\s*(.*)$/;
+function extractPythonErrorSignatures(output) {
+  const signatures = /* @__PURE__ */ new Set();
+  for (const line of output.split(/\r?\n/)) {
+    const m = MYPY_ERROR_LINE_RE.exec(line.trim());
+    if (!m) continue;
+    const msg = (m[3] ?? "").trim().slice(0, 120);
+    signatures.add(`${m[1]}:${m[2]} - error: ${msg}`);
+  }
+  return signatures;
+}
+function countPythonErrorsFromOutput(output) {
+  const summaryMatches = [...output.matchAll(/\bFound\s+(\d+)\s+errors?\b/gi)];
+  const lastSummary = summaryMatches.at(-1);
+  if (lastSummary?.[1]) {
+    const parsed = Number.parseInt(lastSummary[1], 10);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  const matches = output.split(/\r?\n/).filter((line) => MYPY_ERROR_LINE_RE.test(line.trim()));
+  return matches.length > 0 ? matches.length : 1;
+}
+function isSimpleSingleVerifyCommand(command) {
+  const parsed = parseVerifyCommand(command);
+  if (!Array.isArray(parsed) || parsed.length !== 1) return void 0;
+  return parsed[0]?.argv ?? [];
+}
+function matchesCargoErrorCommand(command) {
+  const argv = isSimpleSingleVerifyCommand(command);
+  if (!argv) return false;
+  const executable = getExecutableName(argv[0] ?? "");
+  if (executable !== "cargo") return false;
+  const verb = argv[1] ?? "";
+  return verb === "check" || verb === "build" || verb === "clippy";
+}
+function matchesGoErrorCommand(command) {
+  const argv = isSimpleSingleVerifyCommand(command);
+  if (!argv) return false;
+  const executable = getExecutableName(argv[0] ?? "");
+  if (executable !== "go") return false;
+  const verb = argv[1] ?? "";
+  return verb === "build" || verb === "vet";
+}
+function matchesMypyErrorCommand(command) {
+  const argv = isSimpleSingleVerifyCommand(command);
+  if (!argv) return false;
+  const executable = getExecutableName(argv[0] ?? "");
+  if (executable === "mypy") return true;
+  if (executable === "python" || executable === "python3" || executable === "py") {
+    return argv[1] === "-m" && argv[2] === "mypy";
+  }
+  return false;
+}
+var BASELINE_ERROR_PARSERS = {
+  node: {
+    matches: isBaselineComparableTypeScriptCompilerCommand,
+    signatures: extractTypeScriptErrorSignatures,
+    count: countTypeScriptErrorsFromOutput,
+    newCount: computeNewErrorCount
+  },
+  rust: {
+    matches: matchesCargoErrorCommand,
+    signatures: extractRustErrorSignatures,
+    count: countRustErrorsFromOutput,
+    newCount: makeSignatureNewCount(extractRustErrorSignatures, countRustErrorsFromOutput)
+  },
+  go: {
+    matches: matchesGoErrorCommand,
+    signatures: extractGoErrorSignatures,
+    count: countGoErrorsFromOutput,
+    newCount: makeSignatureNewCount(extractGoErrorSignatures, countGoErrorsFromOutput)
+  },
+  python: {
+    matches: matchesMypyErrorCommand,
+    signatures: extractPythonErrorSignatures,
+    count: countPythonErrorsFromOutput,
+    newCount: makeSignatureNewCount(extractPythonErrorSignatures, countPythonErrorsFromOutput)
+  }
+};
+function resolveBaselineErrorParser(command) {
+  const trimmed = command.trim();
+  if (trimmed.length === 0 || hasShellControlOperators(trimmed)) {
+    return void 0;
+  }
+  const language = describeVerificationCommand(trimmed).language;
+  const byLanguage = language !== "unknown" ? BASELINE_ERROR_PARSERS[language] : void 0;
+  if (byLanguage?.matches(trimmed)) {
+    return byLanguage;
+  }
+  for (const parser of Object.values(BASELINE_ERROR_PARSERS)) {
+    if (parser?.matches(trimmed)) {
+      return parser;
+    }
+  }
+  return void 0;
+}
+function isBaselineComparableTypeScriptCommand(command) {
+  return resolveBaselineErrorParser(command) !== void 0;
+}
+function countTypeScriptErrorsFromOutput(output) {
+  const summaryMatches = [...output.matchAll(/\bFound\s+(\d+)\s+errors?/gi)];
+  const lastSummary = summaryMatches.at(-1);
+  if (lastSummary?.[1]) {
+    const parsed = Number.parseInt(lastSummary[1], 10);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  const tsErrorMatches = output.match(/error TS\d+:/g);
+  if (tsErrorMatches && tsErrorMatches.length > 0) {
+    return tsErrorMatches.length;
+  }
+  return 1;
+}
+function extractTypeScriptErrorSignatures(output) {
+  const signatures = /* @__PURE__ */ new Set();
+  const lineRe = /^(.+?)\((\d+),\d+\):\s+error\s+(TS\d+):\s*(.*)$/gm;
+  for (const m of output.matchAll(lineRe)) {
+    const msg = (m[4] ?? "").trim().slice(0, 120);
+    signatures.add(`${m[1]}:${m[2]} - error ${m[3]}: ${msg}`);
+  }
+  return signatures;
+}
+function computeNewErrorCount(baselineOutput, currentOutput) {
+  const baselineSigs = extractTypeScriptErrorSignatures(baselineOutput);
+  const currentSigs = extractTypeScriptErrorSignatures(currentOutput);
+  const baselineCount = countTypeScriptErrorsFromOutput(baselineOutput);
+  const currentCount = countTypeScriptErrorsFromOutput(currentOutput);
+  if (currentCount === 0) {
+    return 0;
+  }
+  if (baselineSigs.size === 0 || currentSigs.size === 0) {
+    const countDelta = currentCount - baselineCount;
+    if (countDelta > 0) {
+      return countDelta;
+    }
+    return 1;
+  }
+  let newCount = 0;
+  for (const sig of currentSigs) {
+    if (!baselineSigs.has(sig)) {
+      newCount++;
+    }
+  }
+  return newCount;
+}
+function buildSanitizedEnv() {
+  const sensitivePattern = /(?:^|_)(?:API[_-]?KEY|AUTH|CONNECTION[_-]?STRING|CREDENTIALS?|DSN|KEY|OAUTH|PASS(?:WORD)?|PRIVATE[_-]?KEY|SECRET|SESSION|TOKEN)(?:_|$)/i;
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (sensitivePattern.test(key) || isCredentialedUrlEnv(key, value)) continue;
+    env[key] = value;
+  }
+  return env;
+}
+function isCredentialedUrlEnv(key, value) {
+  if (!/(?:^|_)URL(?:_|$)/i.test(key) || !value) return false;
+  try {
+    const parsed = new URL(value);
+    return parsed.username.length > 0 || parsed.password.length > 0;
+  } catch {
+    return /^[a-z][a-z0-9+.-]*:\/\/[^/?#\s@]+@/i.test(value);
+  }
+}
+function splitVerifyCommandSequence(command) {
+  const trimmed = command.trim();
+  if (trimmed.length === 0) {
+    return { error: "Empty verify command rejected." };
+  }
+  if (/[`]/.test(trimmed) || /\$\(/.test(trimmed)) {
+    return {
+      error: "Verify command rejected: command substitution is not allowed."
+    };
+  }
+  const segments = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  let escaped = false;
+  for (let i = 0; i < trimmed.length; i++) {
+    const ch = trimmed.charAt(i);
+    const next = trimmed.charAt(i + 1);
+    if (escaped) {
+      current += ch;
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\") {
+      current += ch;
+      escaped = true;
+      continue;
+    }
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle;
+      current += ch;
+      continue;
+    }
+    if (ch === '"' && !inSingle) {
+      inDouble = !inDouble;
+      current += ch;
+      continue;
+    }
+    if (!inSingle && !inDouble) {
+      if (ch === "|" || ch === "<" || ch === ">") {
+        return {
+          error: "Verify command rejected: pipes and redirection are not allowed."
+        };
+      }
+      if (ch === "&") {
+        if (next === "&") {
+          const part = current.trim();
+          if (!part) return { error: "Verify command rejected: empty command segment." };
+          segments.push(part, "&&");
+          current = "";
+          i++;
+          continue;
+        }
+        return {
+          error: "Verify command rejected: background execution is not allowed."
+        };
+      }
+      if (ch === ";") {
+        return {
+          error: "Verify command rejected: command separators are not allowed. Use && so failed verify steps cannot be hidden by later commands."
+        };
+      }
+    }
+    current += ch;
+  }
+  if (inSingle || inDouble) {
+    return { error: "Verify command rejected: unterminated quote." };
+  }
+  const finalPart = current.trim();
+  if (!finalPart) {
+    return { error: "Verify command rejected: empty command segment." };
+  }
+  segments.push(finalPart);
+  return segments;
+}
+function parseArgv(segment) {
+  const args = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  let escaped = false;
+  for (let i = 0; i < segment.length; i++) {
+    const ch = segment.charAt(i);
+    if (escaped) {
+      current += ch;
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (ch === "'" && !inDouble) {
+      inSingle = !inSingle;
+      continue;
+    }
+    if (ch === '"' && !inSingle) {
+      inDouble = !inDouble;
+      continue;
+    }
+    if (/\s/.test(ch) && !inSingle && !inDouble) {
+      if (current.length > 0) {
+        args.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += ch;
+  }
+  if (escaped) {
+    current += "\\";
+  }
+  if (inSingle || inDouble) {
+    return { error: "Verify command rejected: unterminated quote." };
+  }
+  if (current.length > 0) {
+    args.push(current);
+  }
+  if (args.length === 0) {
+    return { error: "Verify command rejected: empty command segment." };
+  }
+  return args;
+}
+function getExecutableName(executable) {
+  return executable.split(/[\\/]/).pop() ?? executable;
+}
+var ALLOWED_PATH_QUALIFIED_EXECUTABLES = /* @__PURE__ */ new Set(["./gradlew", "./mvnw"]);
+function validateVerifyArgv(argv, wrapperDepth = 0) {
+  const rawExecutable = argv[0] ?? "";
+  const executableName = getExecutableName(rawExecutable);
+  if (!executableName) {
+    return "Verify command rejected: empty executable.";
+  }
+  if ((rawExecutable.includes("/") || rawExecutable.includes("\\")) && !ALLOWED_PATH_QUALIFIED_EXECUTABLES.has(rawExecutable)) {
+    return `Verify command rejected: path-qualified executable "${rawExecutable}" is not allowed. Use a bare command name (e.g. "git", "npm") resolved from PATH.`;
+  }
+  if (isPowerShellExecutable(executableName)) {
+    const powershellError = validatePowerShellToolArgv(executableName, argv);
+    if (powershellError) return powershellError;
+  } else if (REJECTED_VERIFY_EXECUTABLES.has(executableName)) {
+    return `Verify command rejected: shell executable "${executableName}" is not allowed.`;
+  }
+  if (!ALLOWED_VERIFY_EXECUTABLES.has(executableName)) {
+    return `Verify command rejected: executable "${executableName}" is not in the verify allowlist.`;
+  }
+  const envError = validateEnvArgv(executableName, argv);
+  if (envError) {
+    return envError;
+  }
+  if (executableName === "env") {
+    return void 0;
+  }
+  const inlineExecutionFlags = executableName === "node" ? /* @__PURE__ */ new Set(["-e", "--eval", "--import"]) : /* @__PURE__ */ new Set(["-e", "-c"]);
+  if ((executableName === "node" || executableName === "python" || executableName === "python3" || executableName === "py") && argv.some((arg) => inlineExecutionFlags.has(normalizeFlagName(arg) ?? arg))) {
+    return `Verify command rejected: inline ${executableName} execution is not allowed. Use a repository script/file or a simple allowlisted command such as grep -Fqx instead.`;
+  }
+  const nodeError = validateNodeToolArgv(executableName, argv, wrapperDepth);
+  if (nodeError) {
+    return nodeError;
+  }
+  const simpleReadToolError = validateSimpleReadToolArgv(executableName, argv);
+  if (simpleReadToolError) {
+    return simpleReadToolError;
+  }
+  const directLintToolError = validateDirectLintToolArgv(executableName, argv);
+  if (directLintToolError) {
+    return directLintToolError;
+  }
+  const expandedLintToolError = validateExpandedLintToolArgv(executableName, argv);
+  if (expandedLintToolError) {
+    return expandedLintToolError;
+  }
+  const packageManagerError = validatePackageManagerArgv(executableName, argv);
+  if (packageManagerError) {
+    return packageManagerError;
+  }
+  const auditToolError = validateAuditToolArgv(executableName, argv);
+  if (auditToolError) {
+    return auditToolError;
+  }
+  const poeticError = validatePoeticArgv(executableName, argv);
+  if (poeticError) {
+    return poeticError;
+  }
+  const gitError = validateGitArgv(executableName, argv);
+  if (gitError) {
+    return gitError;
+  }
+  const pythonToolError = validatePythonToolArgv(executableName, argv);
+  if (pythonToolError) {
+    return pythonToolError;
+  }
+  const rubyToolError = validateRubyToolArgv(executableName, argv);
+  if (rubyToolError) {
+    return rubyToolError;
+  }
+  const phpToolError = validatePhpToolArgv(executableName, argv);
+  if (phpToolError) {
+    return phpToolError;
+  }
+  const expandedToolchainError = validateExpandedProjectToolArgv(executableName, argv);
+  if (expandedToolchainError) {
+    return expandedToolchainError;
+  }
+  const typescriptToolError = validateTypescriptToolArgv(executableName, argv);
+  if (typescriptToolError) {
+    return typescriptToolError;
+  }
+  const jsToolchainError = validateJavaScriptToolchainArgv(executableName, argv);
+  if (jsToolchainError) {
+    return jsToolchainError;
+  }
+  const buildToolError = validateBuildToolArgv(executableName, argv);
+  if (buildToolError) {
+    return buildToolError;
+  }
+  const iacToolError = validateIacToolArgv(executableName, argv);
+  if (iacToolError) {
+    return iacToolError;
+  }
+  const runnerToolError = validateRunnerToolArgv(executableName, argv);
+  if (runnerToolError) {
+    return runnerToolError;
+  }
+  return void 0;
+}
+function validateExpandedProjectToolArgv(executableName, argv) {
+  const args = argv.slice(1).filter((arg) => arg.length > 0);
+  const reject = (detail) => `Verify command rejected: ${detail}. Extended project verify tools may only run conventional read-only build, lint, or test commands.`;
+  const rejectUnknownFlag = (tool, token) => reject(`${tool} option "${token}" is not allowlisted`);
+  const allowOnlyPathSafePositionals = (tool, tokens, options = {}) => {
+    const noValueFlags = options.noValueFlags ?? /* @__PURE__ */ new Set();
+    const valueFlags = options.valueFlags ?? /* @__PURE__ */ new Set();
+    const pathValueFlags = options.pathValueFlags ?? /* @__PURE__ */ new Set();
+    for (let i = 0; i < tokens.length; i += 1) {
+      const token = tokens[i] ?? "";
+      if (!token.startsWith("-")) {
+        if (options.allowPositionals === false) {
+          return reject(`${tool} positional "${token}" is not allowlisted`);
+        }
+        if (isEscapingPathValue(token)) {
+          return reject(`${tool} operand "${token}" points outside the repository`);
+        }
+        continue;
+      }
+      const name = normalizeFlagName(token) ?? token;
+      if (noValueFlags.has(name) && !token.includes("=")) continue;
+      if (valueFlags.has(name)) {
+        const value = token.includes("=") ? token.slice(token.indexOf("=") + 1) : tokens[i + 1];
+        if (!value || !token.includes("=") && value.startsWith("-")) {
+          return reject(`option "${token}" requires a value`);
+        }
+        if (pathValueFlags.has(name) && isEscapingPathValue(value)) {
+          return reject(`option "${token}" points outside the repository`);
+        }
+        if (!token.includes("=")) i += 1;
+        continue;
+      }
+      return rejectUnknownFlag(tool, token);
+    }
+    return void 0;
+  };
+  if (executableName === "cmake") {
+    if (args[0] !== "--build") return reject('"cmake" must use "--build"');
+    const safeTargets = /* @__PURE__ */ new Set(["all", "build", "check", "test", "verify"]);
+    const target = args[1] ?? "";
+    if (!target || target.startsWith("-")) {
+      if (target !== "--preset")
+        return reject('"cmake --build" requires a build directory or --preset');
+    } else if (isEscapingPathValue(target)) {
+      return reject(`cmake build directory "${target}" points outside the repository`);
+    }
+    for (let i = 1; i < args.length; i += 1) {
+      const token = args[i] ?? "";
+      if (!token.startsWith("-")) continue;
+      if (["--preset", "--config", "-j", "--parallel"].includes(token)) {
+        const value = args[i + 1];
+        if (!value || value.startsWith("-")) return reject(`option "${token}" requires a value`);
+        i += 1;
+        continue;
+      }
+      if (token === "--target") {
+        const value = args[i + 1];
+        if (!value || value.startsWith("-")) return reject('option "--target" requires a value');
+        if (!safeTargets.has(value)) {
+          return reject(`cmake target "${value}" is not allowlisted`);
+        }
+        i += 1;
+        continue;
+      }
+      if (token.startsWith("--preset=") || token.startsWith("--config=")) continue;
+      if (token.startsWith("--target=")) {
+        const value = token.slice(token.indexOf("=") + 1);
+        if (!safeTargets.has(value)) return reject(`cmake target "${value}" is not allowlisted`);
+        continue;
+      }
+      if (token === "--verbose" || token === "-v") continue;
+      return reject(`cmake option "${token}" is not allowlisted`);
+    }
+    return void 0;
+  }
+  if (executableName === "ctest") {
+    for (let i = 0; i < args.length; i += 1) {
+      const token = args[i] ?? "";
+      if (!token.startsWith("-")) return reject(`ctest positional "${token}" is not allowlisted`);
+      if (token === "--preset" || token === "--test-dir" || token === "-C" || token === "-R") {
+        const value = args[i + 1];
+        if (!value || value.startsWith("-")) return reject(`option "${token}" requires a value`);
+        if ((token === "--test-dir" || token === "-R") && isEscapingPathValue(value)) {
+          return reject(`option "${token}" points outside the repository`);
+        }
+        i += 1;
+        continue;
+      }
+      if (token.startsWith("--preset=") || token.startsWith("-C=") || token.startsWith("-R=")) {
+        continue;
+      }
+      if (token.startsWith("--test-dir=")) {
+        const value = token.slice(token.indexOf("=") + 1);
+        if (isEscapingPathValue(value))
+          return reject(`option "${token}" points outside the repository`);
+        continue;
+      }
+      if (token === "--output-on-failure" || token === "--no-tests=error") continue;
+      return reject(`ctest option "${token}" is not allowlisted`);
+    }
+    return void 0;
+  }
+  if (executableName === "meson") {
+    const subcommand = args[0] ?? "";
+    if (subcommand !== "compile" && subcommand !== "test") {
+      return reject(`"meson ${subcommand}" is not an allowlisted verify command`);
+    }
+    for (let i = 1; i < args.length; i += 1) {
+      const token = args[i] ?? "";
+      if (token === "-C") {
+        const value = args[i + 1];
+        if (!value || value.startsWith("-")) return reject("meson -C requires a build directory");
+        if (isEscapingPathValue(value))
+          return reject(`meson build directory "${value}" points outside the repository`);
+        i += 1;
+        continue;
+      }
+      if (token.startsWith("-C")) {
+        const value = token.slice(2);
+        if (!value || isEscapingPathValue(value)) {
+          return reject(`meson build directory "${value}" points outside the repository`);
+        }
+        continue;
+      }
+      if (token === "--verbose") continue;
+      return reject(`meson option "${token}" is not allowlisted`);
+    }
+    return void 0;
+  }
+  if (executableName === "swift") {
+    const subcommand = args[0] ?? "";
+    if (subcommand !== "build" && subcommand !== "test") {
+      return reject(`"swift ${subcommand}" is not an allowlisted verify command`);
+    }
+    return allowOnlyPathSafePositionals("swift", args.slice(1), {
+      noValueFlags: /* @__PURE__ */ new Set(["--verbose", "-v"]),
+      valueFlags: /* @__PURE__ */ new Set(["--package-path", "-c", "--configuration"]),
+      pathValueFlags: /* @__PURE__ */ new Set(["--package-path"]),
+      allowPositionals: false
+    });
+  }
+  if (executableName === "dart" || executableName === "flutter") {
+    const subcommand = args[0] ?? "";
+    if (subcommand !== "analyze" && subcommand !== "test") {
+      return reject(`"${executableName} ${subcommand}" is not an allowlisted verify command`);
+    }
+    return allowOnlyPathSafePositionals(executableName, args.slice(1), {
+      noValueFlags: /* @__PURE__ */ new Set(["--coverage", "--no-pub", "--machine"]),
+      valueFlags: /* @__PURE__ */ new Set(["--name", "--plain-name", "--concurrency", "--reporter"]),
+      pathValueFlags: /* @__PURE__ */ new Set([]),
+      allowPositionals: true
+    });
+  }
+  if (executableName === "shellcheck") {
+    for (let i = 0; i < args.length; i += 1) {
+      const token = args[i] ?? "";
+      const name = normalizeFlagName(token) ?? token;
+      if (name !== "-P" && name !== "--source-path") continue;
+      const value = token.includes("=") ? token.slice(token.indexOf("=") + 1) : args[i + 1];
+      const sourcePath = value?.startsWith("SOURCE=") ? value.slice("SOURCE=".length) : value;
+      if (sourcePath && isEscapingPathValue(sourcePath)) {
+        return reject(`option "${token}" points outside the repository`);
+      }
+      if (!token.includes("=")) i += 1;
+    }
+    return allowOnlyPathSafePositionals("shellcheck", args, {
+      noValueFlags: /* @__PURE__ */ new Set([]),
+      valueFlags: /* @__PURE__ */ new Set(["-P", "--source-path", "-S", "--severity"]),
+      pathValueFlags: /* @__PURE__ */ new Set(["-P", "--source-path"]),
+      allowPositionals: true
+    });
+  }
+  if (executableName === "R") {
+    if (args[0] !== "CMD" || args[1] !== "check" || args.length !== 3 || args[2] !== ".") {
+      return reject('"R" is only allowlisted as "R CMD check ."');
+    }
+    return void 0;
+  }
+  if (executableName === "dbt") {
+    const subcommand = args[0] ?? "";
+    if (subcommand !== "compile" && subcommand !== "test") {
+      return reject(`"dbt ${subcommand}" is not an allowlisted verify command`);
+    }
+    return allowOnlyPathSafePositionals("dbt", args.slice(1), {
+      noValueFlags: /* @__PURE__ */ new Set(["--no-version-check"]),
+      valueFlags: /* @__PURE__ */ new Set(["--select", "--exclude", "--profiles-dir", "--project-dir"]),
+      pathValueFlags: /* @__PURE__ */ new Set(["--profiles-dir", "--project-dir"]),
+      allowPositionals: false
+    });
+  }
+  if (executableName === "sqlfluff") {
+    if (args[0] !== "lint") {
+      return reject('"sqlfluff" must use the lint subcommand');
+    }
+    return allowOnlyPathSafePositionals("sqlfluff", args.slice(1), {
+      noValueFlags: /* @__PURE__ */ new Set([]),
+      valueFlags: /* @__PURE__ */ new Set(["--dialect"]),
+      pathValueFlags: /* @__PURE__ */ new Set([]),
+      allowPositionals: true
+    });
+  }
+  return void 0;
+}
+function validateEnvArgv(executableName, argv) {
+  if (executableName !== "env") return void 0;
+  const args = argv.slice(1).filter((arg) => arg.length > 0);
+  const reject = (detail) => `Verify command rejected: ${detail}. The env wrapper is only allowlisted for repo-relative PYTHONPATH on otherwise safe commands.`;
+  if (args.length === 0) return reject('"env" requires a PYTHONPATH assignment and command');
+  let index = 0;
+  let sawPythonPath = false;
+  for (; index < args.length; index += 1) {
+    const token = args[index] ?? "";
+    if (token.startsWith("-")) {
+      return reject(`env option "${token}" is not allowlisted`);
+    }
+    const assignmentIndex = token.indexOf("=");
+    if (assignmentIndex < 0) break;
+    const name = token.slice(0, assignmentIndex);
+    const value = token.slice(assignmentIndex + 1);
+    if (name !== "PYTHONPATH") {
+      return reject(`env assignment "${name}" is not allowlisted`);
+    }
+    if (!value) {
+      return reject("PYTHONPATH must not be empty");
+    }
+    for (const entry of value.split(":")) {
+      if (!entry) return reject("PYTHONPATH entries must not be empty");
+      if (isEscapingPathValue(entry)) {
+        return reject(`PYTHONPATH entry "${entry}" points outside the repository`);
+      }
+    }
+    sawPythonPath = true;
+  }
+  if (!sawPythonPath) {
+    return reject('"env" requires a PYTHONPATH assignment');
+  }
+  const nestedArgv = args.slice(index);
+  const nestedExecutable = getExecutableName(nestedArgv[0] ?? "");
+  if (!nestedExecutable) {
+    return reject('"env" requires a command after PYTHONPATH');
+  }
+  if (nestedExecutable === "env") {
+    return reject("nested env wrappers are not allowlisted");
+  }
+  return validateVerifyArgv(nestedArgv);
+}
+function validatePowerShellToolArgv(executableName, argv) {
+  if (!isPowerShellExecutable(executableName)) {
+    return void 0;
+  }
+  const args = argv.slice(1).filter((arg) => arg.length > 0);
+  const reject = (detail) => `Verify command rejected: ${detail}. PowerShell verify steps are only allowlisted for Pester test execution (Invoke-Pester).`;
+  const ALLOWED_POWERSHELL_CMDLETS = /* @__PURE__ */ new Set(["invoke-pester"]);
+  const normalized = args.map((arg) => arg.toLowerCase());
+  if (!normalized.includes("-noprofile")) {
+    return reject(`"${executableName}" must include -NoProfile`);
+  }
+  const commandIndex = normalized.findIndex((arg) => arg === "-command" || arg === "-c");
+  if (commandIndex < 0) {
+    return reject(`"${executableName}" must use -Command Invoke-Pester`);
+  }
+  const command = args[commandIndex + 1];
+  if (!command || command.startsWith("-")) {
+    return reject("-Command requires Invoke-Pester");
+  }
+  const cmdletName = command.toLowerCase();
+  if (!ALLOWED_POWERSHELL_CMDLETS.has(cmdletName)) {
+    return reject(`"${command}" is not an allowlisted PowerShell verify command`);
+  }
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index] ?? "";
+    const lower = token.toLowerCase();
+    if (index === commandIndex) {
+      index += 1;
+      continue;
+    }
+    if (lower === "-noprofile" || lower === "-noninteractive") continue;
+    if (lower === "-ci" || lower === "-enableexit") continue;
+    return reject(`option "${token}" is not allowlisted`);
+  }
+  return void 0;
+}
+function isPowerShellExecutable(executableName) {
+  return executableName === "pwsh" || executableName === "pwsh.exe" || executableName === "powershell" || executableName === "powershell.exe";
+}
+function isVacuousVerifyArgv(argv) {
+  const executableName = getExecutableName(argv[0] ?? "");
+  return executableName === "echo" || executableName === "printf";
+}
+function isAllowedVerifyCommand(command) {
+  const parsed = parseVerifyCommand(command);
+  if (!Array.isArray(parsed)) return false;
+  return parsed.every((segment) => validateVerifyArgv(segment.argv) === void 0);
+}
+function validatePoeticArgv(executableName, argv) {
+  if (executableName !== "poetic") return void 0;
+  const args = argv.slice(1).filter((arg) => arg.length > 0);
+  const firstPositional = args.find((arg) => !arg.startsWith("-"));
+  if (firstPositional === "internal") {
+    return validatePoeticInternalArgv(args);
+  }
+  const reject = (detail) => `Verify command rejected: ${detail}. Use "poetic assert exact-line <path> --content-base64 <value>" for Poetic-managed verify assertions.`;
+  const contentFlagIndex = args.indexOf("--content-base64");
+  const contentValue = contentFlagIndex >= 0 ? args[contentFlagIndex + 1] : void 0;
+  const positionals = [];
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === void 0) continue;
+    if (arg === "--content-base64") {
+      index++;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      return reject(`unexpected option "${arg}"`);
+    }
+    positionals.push(arg);
+  }
+  if (positionals.length === 0) {
+    return reject('bare "poetic" is not an allowlisted verify command');
+  }
+  if (positionals[0] !== "assert") {
+    return reject(`"poetic ${positionals[0]}" is not an allowlisted verify command`);
+  }
+  if (positionals[1] !== "exact-line") {
+    return reject(`"poetic assert ${positionals[1] ?? ""}" is not an allowlisted verify assertion`);
+  }
+  if (!args.includes("--content-base64")) {
+    return reject('"poetic assert exact-line" must use --content-base64');
+  }
+  if (!contentValue || contentValue.startsWith("-")) {
+    return reject('"poetic assert exact-line" must include a --content-base64 value');
+  }
+  if (positionals.length !== 3) {
+    return reject('"poetic assert exact-line" must include exactly one path');
+  }
+  if (isEscapingPathValue(positionals[2] ?? "")) {
+    return reject(
+      `"poetic assert exact-line" path "${positionals[2]}" points outside the repository`
+    );
+  }
+  return void 0;
+}
+var POETIC_INTERNAL_SUBCOMMANDS = /* @__PURE__ */ new Map([
+  ["review-gate", /* @__PURE__ */ new Set(["--findings", "--threshold", "--mode", "--annotation-out"])],
+  ["findings-schema", /* @__PURE__ */ new Set(["--findings"])]
+]);
+function validatePoeticInternalArgv(args) {
+  const reject = (detail) => `Verify command rejected: ${detail}. Use "poetic internal review-gate --findings <path> [--threshold high|medium|low] [--mode advisory|blocking] [--annotation-out <path>]" or "poetic internal findings-schema --findings <path>".`;
+  const positionals = [];
+  const valueFlags = /* @__PURE__ */ new Set(["--findings", "--threshold", "--mode", "--annotation-out"]);
+  const pathValueFlags = /* @__PURE__ */ new Set(["--findings", "--annotation-out"]);
+  const enumFlagValues = {
+    "--threshold": /* @__PURE__ */ new Set(["high", "medium", "low"]),
+    "--mode": /* @__PURE__ */ new Set(["advisory", "blocking"])
+  };
+  const seen = /* @__PURE__ */ new Set();
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+    if (arg === void 0) continue;
+    if (!arg.startsWith("-")) {
+      positionals.push(arg);
+      continue;
+    }
+    const name = arg.includes("=") ? arg.slice(0, arg.indexOf("=")) : arg;
+    if (!valueFlags.has(name)) {
+      return reject(`unexpected option "${arg}"`);
+    }
+    const value = arg.includes("=") ? arg.slice(arg.indexOf("=") + 1) : args[++index];
+    if (value === void 0 || value.startsWith("-")) {
+      return reject(`option "${name}" requires a value`);
+    }
+    if (seen.has(name)) {
+      return reject(`option "${name}" specified more than once`);
+    }
+    seen.add(name);
+    if (pathValueFlags.has(name) && isEscapingPathValue(value)) {
+      return reject(`option "${name}" path "${value}" points outside the repository`);
+    }
+    const allowedValues = enumFlagValues[name];
+    if (allowedValues && !allowedValues.has(value)) {
+      return reject(`option "${name}" value "${value}" is not allowlisted`);
+    }
+  }
+  if (positionals[0] !== "internal") {
+    return reject('expected "poetic internal <subcommand>"');
+  }
+  const subcommand = positionals[1] ?? "";
+  const permittedFlags = POETIC_INTERNAL_SUBCOMMANDS.get(subcommand);
+  if (!permittedFlags) {
+    return reject(`"poetic internal ${subcommand}" is not an allowlisted verify command`);
+  }
+  if (positionals.length !== 2) {
+    return reject(`"poetic internal ${subcommand}" does not accept positional arguments`);
+  }
+  for (const flag of seen) {
+    if (!permittedFlags.has(flag)) {
+      return reject(`option "${flag}" is not valid for "poetic internal ${subcommand}"`);
+    }
+  }
+  if (!seen.has("--findings")) {
+    return reject(`"poetic internal ${subcommand}" requires --findings <path>`);
+  }
+  return void 0;
+}
+var MAX_NODE_WRAPPER_DEPTH = 4;
+var NODE_HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h", "help"]);
+function isReadOnlyPoeticHelpArgv(args) {
+  if (args.length === 0) {
+    return false;
+  }
+  if (args.every((arg) => NODE_HELP_FLAGS.has(arg))) {
+    return true;
+  }
+  const positionals = args.filter((arg) => !arg.startsWith("-"));
+  const flags = args.filter((arg) => arg.startsWith("-"));
+  if (positionals.length === 1 && flags.length >= 1 && flags.every((flag) => NODE_HELP_FLAGS.has(flag))) {
+    return true;
+  }
+  return positionals.length === 2 && positionals[1] === "help" && flags.length === 0;
+}
+function validateNodeToolArgv(executableName, argv, wrapperDepth = 0) {
+  if (executableName !== "node") return void 0;
+  const args = argv.slice(1).filter((arg) => arg.length > 0);
+  const reject = (detail) => `Verify command rejected: ${detail}. Node verify steps must use package scripts or allowlisted local tools, not arbitrary script execution.`;
+  if (args.length === 1 && (args[0] === "--version" || args[0] === "-v")) {
+    return void 0;
+  }
+  const nodeTarget = (args[0] ?? "").replace(/\\/g, "/");
+  if (nodeTarget === "scripts/assert-node-runtime.mjs") {
+    const expectedArgs = ["--root", ".", "--native", "off"];
+    if (args.length !== expectedArgs.length + 1 || !expectedArgs.every((arg, index) => args[index + 1] === arg)) {
+      return reject(
+        '"node scripts/assert-node-runtime.mjs" is only allowlisted with "--root . --native off"'
+      );
+    }
+    return void 0;
+  }
+  if (wrapperDepth >= MAX_NODE_WRAPPER_DEPTH) {
+    return reject("nested node wrapper depth exceeded");
+  }
+  if (nodeTarget === "scripts/dynamic-node-options.mjs") {
+    const nested = args.slice(1);
+    if (nested.length === 0) {
+      return reject('"node scripts/dynamic-node-options.mjs" requires a nested command');
+    }
+    return validateVerifyArgv(nested, wrapperDepth + 1);
+  }
+  if (nodeTarget === "scripts/verify-command-output.mjs") {
+    const separatorIndex = args.indexOf("--");
+    if (separatorIndex <= 1 || separatorIndex === args.length - 1) {
+      return reject(
+        '"node scripts/verify-command-output.mjs" requires <expected> -- <command> [args...]'
+      );
+    }
+    return validateVerifyArgv(args.slice(separatorIndex + 1), wrapperDepth + 1);
+  }
+  if (nodeTarget === "scripts/verify-file-content.mjs") {
+    return void 0;
+  }
+  if (nodeTarget === "dist/entry.js") {
+    const nested = args.slice(1);
+    if (isReadOnlyPoeticHelpArgv(nested)) {
+      return void 0;
+    }
+    return validatePoeticArgv("poetic", ["poetic", ...nested]);
+  }
+  if (args[0] !== "--check" && args[0] !== "-c") {
+    return reject('"node" is only allowlisted for syntax checks via "node --check <file>"');
+  }
+  const target = args[1] ?? "";
+  if (!target || target.startsWith("-")) {
+    return reject('"node --check" requires a file path');
+  }
+  if (args.length > 2) {
+    return reject('"node --check" accepts exactly one file path');
+  }
+  if (isEscapingPathValue(target)) {
+    return reject(`"node --check ${target}" points outside the repository`);
+  }
+  return void 0;
+}
+function validateSimpleReadToolArgv(executableName, argv) {
+  if (executableName !== "grep" && executableName !== "test") {
+    return void 0;
+  }
+  const args = argv.slice(1).filter((arg) => arg.length > 0);
+  const reject = (detail) => `Verify command rejected: ${detail}. Read-only verify tools may not inspect paths outside the repository.`;
+  if (executableName === "grep") {
+    const patternFileError = validatePathValueFlags(args, /* @__PURE__ */ new Set(["-f", "--file"]), reject);
+    if (patternFileError) return patternFileError;
+  }
+  return validateRepoRelativePositionals(args, reject, executableName);
+}
+var LINT_TOOL_PATH_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "-c",
+  "--config",
+  "--config-path",
+  "--resolve-plugins-relative-to",
+  "--rulesdir"
+]);
+function validateDirectLintToolArgv(executableName, argv) {
+  if (executableName !== "prettier" && executableName !== "eslint" && executableName !== "biome") {
+    return void 0;
+  }
+  const args = argv.slice(1).filter((arg) => arg.length > 0);
+  const reject = (detail) => `Verify command rejected: ${detail}. Verify lint/format tools may only run read-only checks.`;
+  const pathFlagError = validatePathValueFlags(args, LINT_TOOL_PATH_VALUE_FLAGS, reject);
+  if (pathFlagError) return pathFlagError;
+  if (executableName === "prettier" && args.some((arg) => arg === "--write" || arg.startsWith("--write="))) {
+    return reject('"prettier --write" can rewrite files');
+  }
+  if (executableName === "prettier" && !args.some((arg) => arg === "--check" || arg === "--list-different")) {
+    return reject('"prettier" must include --check or --list-different');
+  }
+  if (executableName === "eslint" && args.some((arg) => arg === "--fix" || arg.startsWith("--fix="))) {
+    return reject('"eslint --fix" can rewrite files');
+  }
+  if (executableName === "biome") {
+    if (args.some(
+      (arg) => arg === "--write" || arg.startsWith("--write=") || arg === "--fix" || arg.startsWith("--fix=") || arg === "--apply" || arg.startsWith("--apply=") || arg === "--apply-unsafe" || arg.startsWith("--apply-unsafe=")
+    )) {
+      return reject('"biome --write/--fix/--apply" can rewrite files');
+    }
+    if (args[0] === "format") {
+      return reject('"biome format" can rewrite files; use "biome check" for verify steps');
+    }
+  }
+  return validateRepoRelativePositionals(args, reject, executableName);
+}
+var EXPANDED_LINT_TOOL_POLICIES = {
+  "golangci-lint": {
+    writeFlags: ["--fix"],
+    noValueFlags: /* @__PURE__ */ new Set([
+      "-v",
+      "--verbose",
+      "--tests",
+      "--allow-parallel-runners",
+      "--new",
+      "--sort-results"
+    ]),
+    valueFlags: /* @__PURE__ */ new Set([
+      "--timeout",
+      "--build-tags",
+      "--go",
+      "--concurrency",
+      "-j",
+      "--issues-exit-code",
+      "--new-from-rev"
+    ]),
+    // `--out-format` is NOT opaque: golangci-lint >=1.51 accepts
+    // `--out-format <format>:<path>` (and comma-joined `format:path` forms)
+    // which WRITES the report to that path — an out-of-repo write bypass. Its
+    // value must be a comma-separated list of BARE format names only; any
+    // segment carrying a `:` or path separator is rejected.
+    bareFormatValueFlags: /* @__PURE__ */ new Set(["--out-format"]),
+    pathValueFlags: /* @__PURE__ */ new Set(["-c", "--config", "--path-prefix"]),
+    allowedSubcommands: /* @__PURE__ */ new Set(["run"]),
+    allowPositionals: true
+  },
+  staticcheck: {
+    writeFlags: [],
+    // staticcheck uses Go-style single-dash flags; `-tests` is a bool switch.
+    noValueFlags: /* @__PURE__ */ new Set(["-tests", "-version"]),
+    valueFlags: /* @__PURE__ */ new Set(["-checks", "-tags", "-f", "-go"]),
+    pathValueFlags: /* @__PURE__ */ new Set([]),
+    allowBareInvocation: true,
+    allowPositionals: true
+  },
+  ktlint: {
+    writeFlags: ["-F", "--format"],
+    noValueFlags: /* @__PURE__ */ new Set(["--relative", "-v", "--version"]),
+    valueFlags: /* @__PURE__ */ new Set(["--log-level"]),
+    pathValueFlags: /* @__PURE__ */ new Set(["--editorconfig"]),
+    allowBareInvocation: true,
+    allowPositionals: true
+  },
+  detekt: {
+    writeFlags: ["--auto-correct", "-ac", "--create-baseline", "--report", "-r"],
+    noValueFlags: /* @__PURE__ */ new Set(["--parallel", "--build-upon-default-config", "--all-rules"]),
+    valueFlags: /* @__PURE__ */ new Set(["--includes", "--excludes", "--jvm-target"]),
+    pathValueFlags: /* @__PURE__ */ new Set(["--config", "-c", "--baseline", "-b", "--input", "-i"]),
+    allowBareInvocation: true,
+    // detekt takes its inputs via -i/--input, not positionals.
+    allowPositionals: false
+  },
+  swiftlint: {
+    writeFlags: ["--fix", "--autocorrect", "--output", "-o"],
+    noValueFlags: /* @__PURE__ */ new Set(["--strict", "--lenient", "--quiet", "--no-cache"]),
+    valueFlags: /* @__PURE__ */ new Set(["--reporter"]),
+    pathValueFlags: /* @__PURE__ */ new Set(["--config"]),
+    allowedSubcommands: /* @__PURE__ */ new Set(["lint", "analyze"]),
+    allowBareInvocation: true,
+    allowPositionals: true
+  },
+  "clang-tidy": {
+    writeFlags: [
+      "-fix",
+      "--fix",
+      "-fix-errors",
+      "--fix-errors",
+      "-fix-notes",
+      "--fix-notes",
+      "-export-fixes",
+      "--export-fixes",
+      "-store-check-profile",
+      "--store-check-profile"
+    ],
+    noValueFlags: /* @__PURE__ */ new Set(["-quiet", "--quiet", "-list-checks", "--list-checks"]),
+    valueFlags: /* @__PURE__ */ new Set([
+      "-checks",
+      "--checks",
+      "-header-filter",
+      "--header-filter",
+      "-warnings-as-errors",
+      "--warnings-as-errors"
+    ]),
+    pathValueFlags: /* @__PURE__ */ new Set(["-p", "--config-file", "-config-file"]),
+    allowBareInvocation: true,
+    allowPositionals: true
+  }
+};
+function validateExpandedLintToolArgv(executableName, argv) {
+  const policy = EXPANDED_LINT_TOOL_POLICIES[executableName];
+  if (policy === void 0) return void 0;
+  const args = argv.slice(1).filter((arg) => arg.length > 0);
+  const reject = (detail) => `Verify command rejected: ${detail}. Verify lint tools may only run read-only checks.`;
+  for (const arg of args) {
+    if (policy.writeFlags.some((flag) => arg === flag || arg.startsWith(`${flag}=`))) {
+      return reject(`"${executableName} ${arg}" can rewrite or write files`);
+    }
+  }
+  const firstPositional = args.find((arg) => !arg.startsWith("-"));
+  if (policy.allowedSubcommands) {
+    if (firstPositional === void 0) {
+      if (!policy.allowBareInvocation) {
+        return reject(
+          `bare "${executableName}" is not allowlisted; use an explicit read-only subcommand (${[...policy.allowedSubcommands].sort().join(", ")})`
+        );
+      }
+    } else if (!policy.allowedSubcommands.has(firstPositional) && !policy.allowPositionals) {
+      return reject(
+        `"${executableName} ${firstPositional}" is not an allowlisted read-only subcommand`
+      );
+    } else if (!policy.allowedSubcommands.has(firstPositional)) {
+      if (!/[./\\]/.test(firstPositional)) {
+        return reject(
+          `"${executableName} ${firstPositional}" is not an allowlisted read-only subcommand`
+        );
+      }
+    }
+  }
+  let sawSubcommand = false;
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i] ?? "";
+    if (!token.startsWith("-")) {
+      const isAllowedSubcommand = !sawSubcommand && policy.allowedSubcommands?.has(token) === true;
+      if (isAllowedSubcommand) {
+        sawSubcommand = true;
+        continue;
+      }
+      if (!policy.allowPositionals) {
+        return reject(`${executableName} positional "${token}" is not allowlisted`);
+      }
+      if (isEscapingPathValue(token)) {
+        return reject(`${executableName} operand "${token}" points outside the repository`);
+      }
+      continue;
+    }
+    const name = normalizeFlagName(token) ?? token;
+    if (policy.noValueFlags.has(name) && !token.includes("=")) {
+      continue;
+    }
+    if (policy.bareFormatValueFlags?.has(name)) {
+      const value = token.includes("=") ? token.slice(token.indexOf("=") + 1) : args[i + 1];
+      if (value === void 0 || !token.includes("=") && value.startsWith("-")) {
+        return reject(`${executableName} option "${token}" requires a value`);
+      }
+      for (const segment of value.split(",")) {
+        if (!/^[A-Za-z0-9-]+$/.test(segment)) {
+          return reject(
+            `${executableName} option "${token}" value "${segment}" is not a bare format name; the "format:path" form can write a report outside the repository`
+          );
+        }
+      }
+      if (!token.includes("=")) i += 1;
+      continue;
+    }
+    if (policy.valueFlags.has(name) || policy.pathValueFlags.has(name)) {
+      const value = token.includes("=") ? token.slice(token.indexOf("=") + 1) : args[i + 1];
+      if (value === void 0 || !token.includes("=") && value.startsWith("-")) {
+        return reject(`${executableName} option "${token}" requires a value`);
+      }
+      if (policy.pathValueFlags.has(name) && isEscapingPathValue(value)) {
+        return reject(`${executableName} option "${token}" points outside the repository`);
+      }
+      if (!token.includes("=")) i += 1;
+      continue;
+    }
+    return reject(`${executableName} option "${token}" is not allowlisted`);
+  }
+  return void 0;
+}
+function validateTypescriptToolArgv(executableName, argv) {
+  if (executableName !== "tsc" && executableName !== "vue-tsc") return void 0;
+  const args = argv.slice(1).filter((arg) => arg.length > 0);
+  const reject = (detail) => `Verify command rejected: ${detail}. TypeScript verify tools may not point project/config paths outside the repository.`;
+  let buildMode = false;
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i] ?? "";
+    if (token === "-p" || token === "--project" || token === "--tsBuildInfoFile") {
+      const value = args[i + 1];
+      if (value !== void 0 && isEscapingPathValue(value)) {
+        return reject(`option "${token}" points outside the repository`);
+      }
+      i += 1;
+      continue;
+    }
+    if (token.startsWith("--project=") || token.startsWith("--tsBuildInfoFile=") || token.startsWith("-p=")) {
+      const value = token.slice(token.indexOf("=") + 1);
+      if (isEscapingPathValue(value))
+        return reject(`option "${token}" points outside the repository`);
+      continue;
+    }
+    if (token.startsWith("-p") && token.length > 2) {
+      const value = token.slice(2);
+      if (isEscapingPathValue(value))
+        return reject(`option "${token}" points outside the repository`);
+      continue;
+    }
+    if (token === "-b" || token === "--build") {
+      buildMode = true;
+      continue;
+    }
+    if (token.startsWith("--build=")) {
+      const value = token.slice(token.indexOf("=") + 1);
+      if (isEscapingPathValue(value))
+        return reject(`option "${token}" points outside the repository`);
+      buildMode = true;
+      continue;
+    }
+    if (token.startsWith("-b") && token.length > 2) {
+      const value = token.slice(2);
+      if (isEscapingPathValue(value))
+        return reject(`option "${token}" points outside the repository`);
+      buildMode = true;
+      continue;
+    }
+    if (buildMode && !token.startsWith("-") && isEscapingPathValue(token)) {
+      return reject(`build project "${token}" points outside the repository`);
+    }
+  }
+  return void 0;
+}
+function validateRepoRelativePositionals(args, reject, toolLabel) {
+  for (const arg of args) {
+    if (arg.startsWith("-")) continue;
+    if (isEscapingPathValue(arg)) {
+      return reject(`${toolLabel} operand "${arg}" points outside the repository`);
+    }
+  }
+  return void 0;
+}
+var JAVASCRIPT_TOOLCHAIN_PATH_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "-c",
+  "--cache-dir",
+  "--cacheDir",
+  "--config",
+  "--coverageDirectory",
+  "--file",
+  "--outputFile",
+  "--package",
+  // mocha/ava/tap preload + reporter module flags: a module path outside the
+  // repo would load and execute out-of-repo code, so their values are
+  // repo-escape-checked (bare reporter NAMES like "spec" are unaffected).
+  "-r",
+  "--require",
+  "-R",
+  "--reporter",
+  "--test-reporter",
+  "--testResultsProcessor"
+]);
+var JS_TEST_RUNNER_SNAPSHOT_UPDATE_FLAGS = {
+  jest: ["-u", "--update", "--updateSnapshot", "--update-snapshot"],
+  vitest: ["-u", "--update", "--updateSnapshot", "--update-snapshot"],
+  ava: ["-u", "--update-snapshots"],
+  tap: ["--snapshot"],
+  mocha: []
+};
+var JS_TEST_RUNNER_PASSTHROUGH_FLAGS = {
+  jest: [],
+  vitest: [],
+  mocha: ["-n", "--node-option", "-O", "--reporter-option", "--reporter-options"],
+  ava: ["--node-arguments"],
+  tap: ["--node-arg", "--nyc-arg", "--output-file", "-o"]
+};
+var JS_TEST_RUNNER_EXIT_SUPPRESSING_FLAGS = {
+  jest: [],
+  vitest: [],
+  mocha: ["--pass-on-failing-test-suite", "--dry-run"],
+  ava: ["--dry-run"],
+  tap: []
+};
+var JAVASCRIPT_TOOLCHAIN_EXECUTABLES = /* @__PURE__ */ new Set([
+  "jest",
+  "vitest",
+  "turbo",
+  "mocha",
+  "ava",
+  "tap"
+]);
+function validateJavaScriptToolchainArgv(executableName, argv) {
+  if (!JAVASCRIPT_TOOLCHAIN_EXECUTABLES.has(executableName)) {
+    return void 0;
+  }
+  const args = argv.slice(1).filter((arg) => arg.length > 0);
+  const reject = (detail) => `Verify command rejected: ${detail}. JavaScript verify tools may not point project/config paths outside the repository.`;
+  const pathFlagError = validatePathValueFlags(args, JAVASCRIPT_TOOLCHAIN_PATH_VALUE_FLAGS, reject);
+  if (pathFlagError) return pathFlagError;
+  const snapshotUpdateFlags = JS_TEST_RUNNER_SNAPSHOT_UPDATE_FLAGS[executableName];
+  if (snapshotUpdateFlags && args.some((arg) => snapshotUpdateFlags.some((flag) => tokenMatchesFlag(arg, flag)))) {
+    return reject(`"${executableName}" snapshot update options can rewrite files`);
+  }
+  const passthroughFlags = JS_TEST_RUNNER_PASSTHROUGH_FLAGS[executableName];
+  if (passthroughFlags) {
+    for (const arg of args) {
+      if (passthroughFlags.some((flag) => tokenMatchesFlag(arg, flag))) {
+        return reject(
+          `"${executableName} ${arg}" can pass options to the node process or write output files`
+        );
+      }
+    }
+  }
+  const exitSuppressingFlags = JS_TEST_RUNNER_EXIT_SUPPRESSING_FLAGS[executableName];
+  if (exitSuppressingFlags) {
+    for (const arg of args) {
+      if (exitSuppressingFlags.some((flag) => tokenMatchesFlag(arg, flag))) {
+        return reject(
+          `"${executableName} ${arg}" suppresses the failing exit code or skips test execution`
+        );
+      }
+    }
+  }
+  if (executableName === "mocha" && args[0] === "init") {
+    return reject('"mocha init" writes scaffolding files');
+  }
+  if (executableName === "tap") {
+    for (const arg of args) {
+      if (!arg.startsWith("-") && !/[./\\]/.test(arg)) {
+        return reject(
+          `"tap ${arg}" is not a test file path; tap subcommands are not allowlisted verify commands`
+        );
+      }
+    }
+  }
+  if (executableName === "turbo") {
+    const subcommand = args[0] ?? "";
+    if (subcommand !== "run") {
+      return reject('"turbo" must use the run subcommand');
+    }
+    const allowedTasks = /* @__PURE__ */ new Set(["build", "check", "lint", "test", "typecheck", "verify"]);
+    const tasks = args.slice(1).filter((arg) => !arg.startsWith("-"));
+    if (tasks.length === 0) return reject('"turbo run" requires an allowlisted task');
+    for (const task of tasks) {
+      if (!allowedTasks.has(task) && !/^(?:build|check|lint|test|typecheck|verify):/.test(task)) {
+        return reject(`turbo task "${task}" is not allowlisted`);
+      }
+    }
+  }
+  return validateRepoRelativePositionals(args, reject, executableName);
+}
+function isExactPythonCoverageUnittestDiscoverArgv(moduleArgs) {
+  return moduleArgs.length === 4 && moduleArgs[0] === "run" && moduleArgs[1] === "-m" && moduleArgs[2] === "unittest" && moduleArgs[3] === "discover";
+}
+function validatePythonToolArgv(executableName, argv) {
+  const reject = (detail) => `Verify command rejected: ${detail}. Python verify tools may only run read-only checks.`;
+  if (executableName === "python" || executableName === "python3" || executableName === "py") {
+    const args2 = argv.slice(1).filter((arg) => arg.length > 0);
+    if (args2[0] !== "-m") {
+      return reject(`"${executableName}" must use "-m" with an allowlisted verify module`);
+    }
+    const moduleName = args2[1] ?? "";
+    if (moduleName === "pytest" || moduleName === "unittest")
+      return validatePythonToolArgv(moduleName, [moduleName, ...args2.slice(2)]);
+    if (moduleName === "black" || moduleName === "ruff" || moduleName === "mypy") {
+      return validatePythonToolArgv(moduleName, [moduleName, ...args2.slice(2)]);
+    }
+    if (moduleName === "coverage") {
+      const coverageArgs = args2.slice(2);
+      if (isExactPythonCoverageUnittestDiscoverArgv(coverageArgs)) {
+        return void 0;
+      }
+      return reject(
+        `"${executableName} -m coverage" only allows the exact form "run -m unittest discover"`
+      );
+    }
+    return reject(`"${executableName} -m ${moduleName}" is not an allowlisted verify module`);
+  }
+  if (executableName !== "black" && executableName !== "ruff" && executableName !== "mypy" && executableName !== "pytest" && executableName !== "unittest") {
+    return void 0;
+  }
+  const args = argv.slice(1).filter((arg) => arg.length > 0);
+  const pathFlags = new Set(
+    executableName === "pytest" || executableName === "unittest" ? ["-c", "--rootdir", "--confcutdir"] : executableName === "black" || executableName === "ruff" ? ["--config"] : ["--config-file", "--cache-dir"]
+  );
+  const pathFlagError = validatePathValueFlags(args, pathFlags, reject);
+  if (pathFlagError) return pathFlagError;
+  if (executableName === "pytest" || executableName === "unittest") {
+    return validateRepoRelativePositionals(args, reject, executableName);
+  }
+  if (executableName === "black") {
+    if (!args.includes("--check")) {
+      return reject('"black" must include --check');
+    }
+    return validateRepoRelativePositionals(args, reject, "black");
+  }
+  if (executableName === "ruff") {
+    if (!args.includes("check")) {
+      return reject('"ruff" must use the check subcommand');
+    }
+    for (const arg of args) {
+      if (arg === "--fix" || arg === "--unsafe-fixes" || arg.startsWith("--fix=") || arg.startsWith("--unsafe-fixes=")) {
+        return reject(`"${arg}" can rewrite files`);
+      }
+      if (arg === "--exit-zero" || arg.startsWith("--exit-zero=")) {
+        return reject(`"${arg}" makes ruff findings non-blocking`);
+      }
+    }
+    return validateRepoRelativePositionals(args, reject, "ruff");
+  }
+  if (args.some((arg) => arg === "--install-types" || arg.startsWith("--install-types="))) {
+    return reject('"mypy --install-types" can install packages');
+  }
+  return validateRepoRelativePositionals(args, reject, "mypy");
+}
+function validateRubyToolArgv(executableName, argv) {
+  if (!["bundle", "rake", "rspec", "rubocop", "ruby"].includes(executableName)) {
+    return void 0;
+  }
+  const args = argv.slice(1).filter((arg) => arg.length > 0);
+  const reject = (detail) => `Verify command rejected: ${detail}. Ruby verify tools may only run conventional test or read-only lint commands.`;
+  if (executableName === "bundle") {
+    if (args[0] !== "exec") return reject('"bundle" must use "bundle exec"');
+    const nested = args.slice(1);
+    if (nested.length === 0) return reject('"bundle exec" requires a tool name');
+    const nestedCommand = nested[0] ?? "";
+    const nestedExecutable = getExecutableName(nestedCommand);
+    if (nestedExecutable !== nestedCommand) {
+      return reject(`"bundle exec ${nestedCommand}" must name an allowlisted tool, not a path`);
+    }
+    if (!["rake", "rspec", "rubocop"].includes(nestedExecutable)) {
+      return reject(`"bundle exec ${nestedExecutable}" is not an allowlisted Ruby verify tool`);
+    }
+    return validateRubyToolArgv(nestedExecutable, nested);
+  }
+  if (executableName === "rake") {
+    const pathFlagError = validatePathValueFlags(args, /* @__PURE__ */ new Set(["-f", "--rakefile"]), reject);
+    if (pathFlagError) return pathFlagError;
+    const targets = args.filter((arg) => !arg.startsWith("-"));
+    if (targets.length === 0) return reject('bare "rake" can run arbitrary default tasks');
+    for (const target of targets) {
+      if (target !== "test" && target !== "spec") {
+        return reject(`"rake ${target}" is not an allowlisted test target`);
+      }
+    }
+    return void 0;
+  }
+  if (executableName === "rubocop") {
+    const pathFlagError = validatePathValueFlags(
+      args,
+      /* @__PURE__ */ new Set(["-c", "--config", "-r", "--require"]),
+      reject
+    );
+    if (pathFlagError) return pathFlagError;
+    for (const arg of args) {
+      if (arg === "-a" || arg === "-A" || arg === "--auto-correct" || arg === "--autocorrect") {
+        return reject(`"rubocop ${arg}" can rewrite files`);
+      }
+    }
+    return validateRepoRelativePositionals(args, reject, "rubocop");
+  }
+  if (executableName === "rspec") {
+    const pathFlagError = validatePathValueFlags(
+      args,
+      /* @__PURE__ */ new Set(["-O", "--options", "-r", "--require"]),
+      reject
+    );
+    if (pathFlagError) return pathFlagError;
+    return validateRepoRelativePositionals(args, reject, "rspec");
+  }
+  if (executableName === "ruby") {
+    if (args.some((arg) => arg === "-e")) {
+      return reject('"ruby -e" inline execution is not allowed');
+    }
+    if (args[0] !== "-c" || args.length < 2) {
+      return reject('"ruby" is only allowlisted for syntax checks via "ruby -c <file>"');
+    }
+    if (isEscapingPathValue(args[1] ?? "")) {
+      return reject(`"ruby -c ${args[1]}" points outside the repository`);
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function validatePhpToolArgv(executableName, argv) {
+  if (!["composer", "php", "phpunit", "phpstan", "psalm"].includes(executableName)) {
+    return void 0;
+  }
+  const args = argv.slice(1).filter((arg) => arg.length > 0);
+  const reject = (detail) => `Verify command rejected: ${detail}. PHP verify tools may only run project scripts or local analyzer/test binaries.`;
+  if (executableName === "composer") {
+    const pathFlagError = validatePathValueFlags(args, /* @__PURE__ */ new Set(["-d", "--working-dir"]), reject);
+    if (pathFlagError) return pathFlagError;
+    const blocked = /* @__PURE__ */ new Set(["install", "update", "require", "remove", "create-project"]);
+    if (args.some((arg) => blocked.has(arg))) {
+      return reject('"composer" install/update commands are not allowlisted verify commands');
+    }
+    const command = args.find((arg) => !arg.startsWith("-"));
+    if (command === "test") {
+      const commandIndex = args.indexOf(command);
+      return validateRepoRelativePositionals(args.slice(commandIndex + 1), reject, "composer test");
+    }
+    if (command === "run" || command === "run-script") {
+      const scriptIndex = args.indexOf(command) + 1;
+      const scriptName = args[scriptIndex] ?? "";
+      if (/^(?:test|tests|phpunit|lint|analyse|analyze|static-analysis|typecheck|check)$/.test(
+        scriptName
+      )) {
+        return validateRepoRelativePositionals(
+          args.slice(scriptIndex + 1),
+          reject,
+          `composer ${command} ${scriptName}`
+        );
+      }
+      return reject(
+        `"composer ${command} ${scriptName}" is not an allowlisted verification script`
+      );
+    }
+    if (command !== "exec") {
+      return reject(`"composer ${command ?? ""}" is not an allowlisted verify command`);
+    }
+    const dashDash = args.indexOf("--");
+    const executableIndex = dashDash >= 0 ? dashDash + 1 : args.indexOf("exec") + 1;
+    const nestedCommand = args[executableIndex] ?? "";
+    const nestedExecutable = getExecutableName(nestedCommand);
+    if (nestedExecutable !== nestedCommand) {
+      return reject(`"composer exec ${nestedCommand}" must name an allowlisted tool, not a path`);
+    }
+    if (!["phpunit", "phpstan", "psalm", "php-cs-fixer"].includes(nestedExecutable)) {
+      return reject(`"composer exec ${nestedExecutable}" is not an allowlisted PHP verify tool`);
+    }
+    if (nestedExecutable === "php-cs-fixer") {
+      const nestedArgs = args.slice(executableIndex + 1);
+      const pathFlagError2 = validatePathValueFlags(nestedArgs, /* @__PURE__ */ new Set(["--config"]), reject);
+      if (pathFlagError2) return pathFlagError2;
+      if (!nestedArgs.includes("fix") || !nestedArgs.includes("--dry-run")) {
+        return reject('"composer exec php-cs-fixer" must run "fix --dry-run"');
+      }
+      return validateRepoRelativePositionals(nestedArgs, reject, "php-cs-fixer");
+    }
+    return validatePhpToolArgv(nestedExecutable, [
+      nestedExecutable,
+      ...args.slice(executableIndex + 1)
+    ]);
+  }
+  if (executableName === "php") {
+    return reject('"php" may not execute arbitrary scripts directly');
+  }
+  if (executableName === "phpunit" || executableName === "phpstan" || executableName === "psalm") {
+    const pathFlags = executableName === "phpunit" ? /* @__PURE__ */ new Set(["-c", "--configuration", "--bootstrap"]) : executableName === "phpstan" ? /* @__PURE__ */ new Set(["-c", "--configuration", "--configuration-file", "--autoload-file"]) : /* @__PURE__ */ new Set(["-c", "--config", "--config-file"]);
+    const pathFlagError = validatePathValueFlags(args, pathFlags, reject);
+    if (pathFlagError) return pathFlagError;
+    return validateRepoRelativePositionals(args, reject, executableName);
+  }
+  return void 0;
+}
+var GIT_READONLY_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "cat-file",
+  "describe",
+  "diff",
+  "grep",
+  "log",
+  "ls-files",
+  "ls-tree",
+  "rev-parse",
+  "show",
+  "status"
+]);
+var GIT_PROGRAM_EXECUTING_OPTIONS = /* @__PURE__ */ new Set([
+  "-c",
+  "-O",
+  "-p",
+  "--config-env",
+  "--exec",
+  "--exec-path",
+  "--ext-diff",
+  "--filters",
+  "--open-files-in-pager",
+  "--output",
+  "--paginate",
+  "--textconv"
+]);
+var GIT_SUBCOMMAND_PROGRAM_OPTIONS = /* @__PURE__ */ new Set([
+  "-O",
+  "--config-env",
+  "--exec",
+  "--exec-path",
+  "--ext-diff",
+  "--filters",
+  // `--help` runs `git help <cmd>`, which spawns the configured man viewer/pager
+  // (an external program). Bare `-h` just prints usage to stderr and is left
+  // alone (it also collides with `git grep -h`, a legitimate read-only flag).
+  "--help",
+  "--open-files-in-pager",
+  "--output",
+  "--textconv"
+]);
+var GIT_EXTERNAL_PATH_OPTIONS = /* @__PURE__ */ new Set(["--pathspec-from-file"]);
+var GIT_GREP_EXTERNAL_PATTERN_OPTIONS = /* @__PURE__ */ new Set(["-f", "--file"]);
+var GIT_DIFF_REJECTED_OPTIONS = /* @__PURE__ */ new Set(["--no-index"]);
+var GIT_REPO_REDIRECT_FLAGS = /* @__PURE__ */ new Set(["-C", "--git-dir", "--namespace", "--work-tree"]);
+function validateGitArgv(executableName, argv) {
+  if (executableName !== "git") return void 0;
+  const args = argv.slice(1).filter((arg) => arg.length > 0);
+  const reject = (detail) => `Verify command rejected: ${detail}. Verify "git" commands may only read state (diff, status, log, show, rev-parse, ls-files, ls-tree, cat-file, grep, describe).`;
+  const index = 0;
+  while (index < args.length) {
+    const token = args[index];
+    if (token === void 0) break;
+    if (!token.startsWith("-")) break;
+    const name = normalizeFlagName(token) ?? token;
+    if (GIT_PROGRAM_EXECUTING_OPTIONS.has(name)) {
+      return reject(`option "${token}" can execute an external program`);
+    }
+    if (GIT_REPO_REDIRECT_FLAGS.has(name)) {
+      return reject(
+        `option "${token}" retargets the git repository, which can load foreign config`
+      );
+    }
+    return reject(`global option "${token}" is not allowed before a verify git subcommand`);
+  }
+  const subcommand = args[index];
+  if (subcommand === void 0) {
+    return reject('bare "git" is not an allowlisted verify command');
+  }
+  if (!GIT_READONLY_SUBCOMMANDS.has(subcommand)) {
+    return reject(`"git ${subcommand}" is not a read-only git subcommand`);
+  }
+  for (const token of args.slice(index + 1)) {
+    if (tokenMatchesAnyFlag(token, GIT_SUBCOMMAND_PROGRAM_OPTIONS)) {
+      return reject(`option "${token}" can execute an external program`);
+    }
+    if (tokenMatchesAnyFlag(token, GIT_EXTERNAL_PATH_OPTIONS)) {
+      return reject(`option "${token}" can read pathspecs from an external file`);
+    }
+    if (subcommand === "grep" && tokenMatchesAnyFlag(token, GIT_GREP_EXTERNAL_PATTERN_OPTIONS)) {
+      return reject(`option "${token}" can read patterns from an external file`);
+    }
+    if (subcommand === "diff" && tokenMatchesAnyFlag(token, GIT_DIFF_REJECTED_OPTIONS)) {
+      return reject(`"git diff ${token}" can compare arbitrary paths outside the repository`);
+    }
+  }
+  return validateGitPathspecArgs(subcommand, args.slice(index + 1), reject);
+}
+function isEscapingGitPathspecValue(value) {
+  let pathspec = value;
+  if (pathspec.startsWith(":(")) {
+    const closingParen = pathspec.indexOf(")");
+    if (closingParen >= 0) {
+      pathspec = pathspec.slice(closingParen + 1);
+    }
+  } else if (pathspec.startsWith(":/") || pathspec.startsWith(":!") || pathspec.startsWith(":^")) {
+    pathspec = pathspec.slice(2);
+  }
+  const objectPathSeparator = pathspec.lastIndexOf(":");
+  if (objectPathSeparator > 0) {
+    const objectPath = pathspec.slice(objectPathSeparator + 1);
+    if (objectPath.length > 0 && isEscapingPathValue(objectPath)) return true;
+  }
+  return isEscapingPathValue(pathspec);
+}
+function validateGitPathspecArgs(subcommand, args, reject) {
+  const pathspecSubcommands = /* @__PURE__ */ new Set([
+    "cat-file",
+    "diff",
+    "grep",
+    "log",
+    "ls-files",
+    "ls-tree",
+    "show",
+    "status"
+  ]);
+  if (!pathspecSubcommands.has(subcommand)) return void 0;
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i] ?? "";
+    if (token === "--") {
+      for (const pathspec of args.slice(i + 1)) {
+        if (isEscapingGitPathspecValue(pathspec)) {
+          return reject(`pathspec "${pathspec}" points outside the repository`);
+        }
+      }
+      return void 0;
+    }
+    if (token.startsWith("-")) continue;
+    if (isEscapingGitPathspecValue(token)) {
+      return reject(`pathspec "${token}" points outside the repository`);
+    }
+  }
+  return void 0;
+}
+var BUILD_TOOL_ALLOWED_GOALS = {
+  cargo: /* @__PURE__ */ new Set([
+    "audit",
+    "build",
+    "check",
+    "test",
+    "clippy",
+    "fmt",
+    "bench",
+    "doc",
+    "tree",
+    "nextest"
+  ]),
+  dotnet: /* @__PURE__ */ new Set(["build", "test", "format"]),
+  go: /* @__PURE__ */ new Set(["build", "test", "vet"]),
+  gradle: /* @__PURE__ */ new Set(["build", "check", "test", "assemble", "lint", "verify"]),
+  gradlew: /* @__PURE__ */ new Set(["build", "check", "test", "assemble", "lint", "verify"]),
+  make: /* @__PURE__ */ new Set(["build", "test", "check", "lint", "verify", "all", "ci"]),
+  mvn: /* @__PURE__ */ new Set(["compile", "test", "verify", "validate", "test-compile"]),
+  mvnw: /* @__PURE__ */ new Set(["compile", "test", "verify", "validate", "test-compile"])
+};
+var BUILD_TOOL_SAFE_VALUE_FLAGS = {
+  cargo: /* @__PURE__ */ new Set([
+    "-p",
+    "--package",
+    "--features",
+    "--target",
+    "--profile",
+    "-j",
+    "--jobs",
+    "--manifest-path",
+    "--target-dir"
+  ]),
+  dotnet: /* @__PURE__ */ new Set(["-c", "--configuration", "-f", "--framework", "-v", "--verbosity"]),
+  go: /* @__PURE__ */ new Set(["-p", "-tags", "-timeout", "-run", "-count", "-parallel"]),
+  gradle: /* @__PURE__ */ new Set(["-p", "--project-dir", "--console", "--max-workers", "--warning-mode"]),
+  gradlew: /* @__PURE__ */ new Set(["-p", "--project-dir", "--console", "--max-workers", "--warning-mode"]),
+  make: /* @__PURE__ */ new Set(["-C", "--directory", "-l", "--load-average"]),
+  mvn: /* @__PURE__ */ new Set(["-pl", "--projects", "-P", "--activate-profiles", "-T", "--threads"]),
+  mvnw: /* @__PURE__ */ new Set(["-pl", "--projects", "-P", "--activate-profiles", "-T", "--threads"])
+};
+var BUILD_TOOL_PATH_VALUE_FLAGS = {
+  cargo: /* @__PURE__ */ new Set(["--manifest-path", "--target-dir"]),
+  dotnet: /* @__PURE__ */ new Set([]),
+  go: /* @__PURE__ */ new Set([]),
+  // `-p` is Gradle's short form of `--project-dir` (a path), so it must be
+  // path-validated like the long form — not treated as a plain value flag.
+  gradle: /* @__PURE__ */ new Set(["-p", "--project-dir"]),
+  gradlew: /* @__PURE__ */ new Set(["-p", "--project-dir"]),
+  make: /* @__PURE__ */ new Set(["-C", "--directory"]),
+  mvn: /* @__PURE__ */ new Set([]),
+  mvnw: /* @__PURE__ */ new Set([])
+};
+var BUILD_TOOL_SAFE_NOVALUE_FLAGS = {
+  cargo: /* @__PURE__ */ new Set([
+    "--release",
+    "--all-features",
+    "--no-default-features",
+    "--workspace",
+    "--all",
+    "--locked",
+    "--frozen",
+    "--offline",
+    "--check",
+    "-v",
+    "--verbose",
+    "-q",
+    "--quiet",
+    "--all-targets",
+    "--lib",
+    "--bins",
+    "--tests",
+    "--doc",
+    "--no-fail-fast"
+  ]),
+  dotnet: /* @__PURE__ */ new Set([
+    "--no-restore",
+    "--no-build",
+    "--verify-no-changes",
+    "--include-generated",
+    "--nologo"
+  ]),
+  go: /* @__PURE__ */ new Set(["-race", "-cover", "-v", "-short", "-json", "-buildvcs", "-vet"]),
+  // NOTE: dry-run flags (gradle/make `--dry-run`, make `-n`) are intentionally
+  // EXCLUDED. They make the tool print actions without running them, so a verify
+  // step would report success without actually verifying — a green gate that
+  // proves nothing. Reject them so an untrusted verify command cannot pass hollow.
+  gradle: /* @__PURE__ */ new Set([
+    "--stacktrace",
+    "--info",
+    "--debug",
+    "-q",
+    "--quiet",
+    "--offline",
+    "--no-daemon"
+  ]),
+  gradlew: /* @__PURE__ */ new Set([
+    "--stacktrace",
+    "--info",
+    "--debug",
+    "-q",
+    "--quiet",
+    "--offline",
+    "--no-daemon"
+  ]),
+  // `-j`/`--jobs`: no-value here (make's jobs arg is optional). `-jN` attached is
+  // handled in the validator; `-j N` separated would leave `N` as a positional
+  // (rejected) which is acceptably conservative for untrusted input. `-n`/
+  // `--dry-run` are excluded (see note above).
+  make: /* @__PURE__ */ new Set([
+    "-j",
+    "--jobs",
+    "-k",
+    "--keep-going",
+    "-s",
+    "--silent",
+    "-w",
+    "-B",
+    "--always-make",
+    "-i"
+  ]),
+  mvn: /* @__PURE__ */ new Set([
+    "-o",
+    "--offline",
+    "-q",
+    "--quiet",
+    "-B",
+    "--batch-mode",
+    "-e",
+    "--errors",
+    "-V",
+    "--show-version"
+  ]),
+  mvnw: /* @__PURE__ */ new Set([
+    "-o",
+    "--offline",
+    "-q",
+    "--quiet",
+    "-B",
+    "--batch-mode",
+    "-e",
+    "--errors",
+    "-V",
+    "--show-version"
+  ])
+};
+function isEscapingPathValue(value) {
+  if (value.length === 0) return false;
+  if (value.startsWith("/") || value.startsWith("\\")) return true;
+  if (/^[A-Za-z]:[\\/]/.test(value)) return true;
+  if (value.startsWith("~")) return true;
+  const normalized = value.replace(/\\/g, "/");
+  return normalized.split("/").some((seg) => seg === "..");
+}
+function validatePathValueFlags(args, pathFlags, reject) {
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i] ?? "";
+    if (!token.startsWith("-")) continue;
+    const name = normalizeFlagName(token) ?? token;
+    if (pathFlags.has(name)) {
+      const value = token.includes("=") ? token.slice(token.indexOf("=") + 1) : args[i + 1];
+      if (value !== void 0 && isEscapingPathValue(value)) {
+        return reject(`option "${token}" points outside the repository`);
+      }
+      if (!token.includes("=")) i += 1;
+      continue;
+    }
+    const shortMatch = /^(-[A-Za-z])(.+)$/.exec(token);
+    if (shortMatch) {
+      const shortFlag = shortMatch[1] ?? "";
+      const attachedValue = shortMatch[2] ?? "";
+      if (pathFlags.has(shortFlag) && isEscapingPathValue(attachedValue)) {
+        return reject(`option "${token}" points outside the repository`);
+      }
+    }
+  }
+  return void 0;
+}
+function cargoGoalAllowed(goal, args) {
+  if (goal === "fmt") {
+    return args.includes("--check");
+  }
+  return true;
+}
+function tokenMatchesFlag(token, flag) {
+  if (token === flag) return true;
+  if (token.startsWith(`${flag}=`)) return true;
+  if (/^-[A-Za-z]$/.test(flag) && token.startsWith(flag) && token.length > flag.length) {
+    return true;
+  }
+  return false;
+}
+function tokenMatchesAnyFlag(token, flags) {
+  for (const flag of flags) {
+    if (tokenMatchesFlag(token, flag)) return true;
+  }
+  return false;
+}
+function resolveBuildGoal(executableName, goal) {
+  if (!goal.includes(":")) return { value: goal };
+  if (executableName === "gradle" || executableName === "gradlew") {
+    const last = goal.split(":").filter(Boolean).pop();
+    return last ? { value: last } : { reject: goal };
+  }
+  if (executableName === "mvn" || executableName === "mvnw") {
+    return { reject: goal };
+  }
+  return { value: goal };
+}
+function validateBuildToolArgv(executableName, argv) {
+  const allowed = BUILD_TOOL_ALLOWED_GOALS[executableName];
+  if (!allowed) return void 0;
+  const valueFlags = BUILD_TOOL_SAFE_VALUE_FLAGS[executableName] ?? /* @__PURE__ */ new Set();
+  const pathFlags = BUILD_TOOL_PATH_VALUE_FLAGS[executableName] ?? /* @__PURE__ */ new Set();
+  const noValueFlags = BUILD_TOOL_SAFE_NOVALUE_FLAGS[executableName] ?? /* @__PURE__ */ new Set();
+  const args = argv.slice(1).filter((arg) => arg.length > 0);
+  const reject = (detail) => `Verify command rejected: ${detail}. Build-tool verify steps may only run a read-only build/test/check goal (${[...allowed].sort().join(", ")}).`;
+  const goals = [];
+  for (let i = 0; i < args.length; i++) {
+    const token = args[i];
+    if (token === void 0) continue;
+    if (executableName === "cargo" && token === "--") {
+      const remaining = args.slice(i + 1);
+      if (goals[0] === "clippy" && remaining.length === 2 && remaining[0] === "-D" && remaining[1] === "warnings") {
+        break;
+      }
+      return reject(`cargo passthrough "${remaining.join(" ")}" is not allowlisted`);
+    }
+    if (token.startsWith("-")) {
+      const name = normalizeFlagName(token) ?? token;
+      const hasInlineValue = token.includes("=");
+      if (valueFlags.has(name)) {
+        let value;
+        if (hasInlineValue) {
+          value = token.slice(token.indexOf("=") + 1);
+        } else {
+          value = args[i + 1];
+          i += 1;
+        }
+        if (pathFlags.has(name) && value !== void 0 && isEscapingPathValue(value)) {
+          return reject(`option "${token}" points outside the repository`);
+        }
+        continue;
+      }
+      const shortMatch = /^(-[A-Za-z])(.+)$/.exec(token);
+      if (shortMatch) {
+        const shortFlag = shortMatch[1] ?? "";
+        const attachedValue = shortMatch[2] ?? "";
+        if (valueFlags.has(shortFlag)) {
+          if (pathFlags.has(shortFlag) && isEscapingPathValue(attachedValue)) {
+            return reject(`option "${token}" points outside the repository`);
+          }
+          continue;
+        }
+        if (noValueFlags.has(shortFlag) && /^[0-9]+$/.test(attachedValue)) {
+          continue;
+        }
+      }
+      if (noValueFlags.has(name) && !hasInlineValue) {
+        continue;
+      }
+      return reject(`option "${token}" is not an allowlisted read-only build-tool flag`);
+    }
+    goals.push(token);
+  }
+  if (goals.length === 0) {
+    return reject(
+      `bare "${executableName}" runs its default target which can execute arbitrary code`
+    );
+  }
+  const resolvedFirst = resolveBuildGoal(executableName, goals[0] ?? "");
+  if ("reject" in resolvedFirst) {
+    return reject(
+      `"${executableName} ${resolvedFirst.reject}" is not an allowlisted read-only goal`
+    );
+  }
+  const firstGoal = resolvedFirst.value;
+  if (!allowed.has(firstGoal)) {
+    return reject(`"${executableName} ${goals[0]}" is not an allowlisted read-only goal`);
+  }
+  if (executableName === "cargo" && !cargoGoalAllowed(firstGoal, args)) {
+    return reject(`"cargo ${firstGoal}" mutates files unless run with --check`);
+  }
+  if (executableName === "cargo" && firstGoal === "nextest") {
+    if (goals.length !== 2 || goals[1] !== "run") {
+      return reject('"cargo nextest" is only allowed with the read-only "run" subcommand');
+    }
+    return void 0;
+  }
+  if (executableName === "dotnet" && firstGoal === "format" && !args.includes("--verify-no-changes")) {
+    return reject('"dotnet format" mutates files unless run with --verify-no-changes');
+  }
+  if (executableName === "go") {
+    for (const pkg of goals.slice(1)) {
+      if (isEscapingPathValue(pkg)) {
+        return reject(`go package "${pkg}" points outside the repository`);
+      }
+    }
+  } else {
+    for (const goal of goals.slice(1)) {
+      const resolved = resolveBuildGoal(executableName, goal);
+      if ("reject" in resolved || !allowed.has(resolved.value)) {
+        return reject(`"${executableName} ... ${goal}" is not an allowlisted read-only goal`);
+      }
+    }
+  }
+  return void 0;
+}
+var RUNNER_TOOL_ALLOWED_TASKS = /* @__PURE__ */ new Set(["test", "lint", "build", "check", "verify"]);
+function validateRunnerToolArgv(executableName, argv) {
+  if (executableName !== "just" && executableName !== "task") return void 0;
+  const args = argv.slice(1).filter((arg) => arg.length > 0);
+  const reject = (detail) => `Verify command rejected: ${detail}. Task-runner verify steps may only run a single canonical safe task name (${[...RUNNER_TOOL_ALLOWED_TASKS].sort().join(", ")}); recipe bodies and arbitrary task names are never trusted.`;
+  if (args.length === 0) {
+    return reject(
+      `bare "${executableName}" runs its default recipe which can execute arbitrary code`
+    );
+  }
+  if (args.length > 1) {
+    return reject(`"${executableName}" verify steps accept exactly one canonical task name`);
+  }
+  const task = args[0] ?? "";
+  if (task.startsWith("-")) {
+    return reject(`"${executableName}" option "${task}" is not allowlisted`);
+  }
+  if (!RUNNER_TOOL_ALLOWED_TASKS.has(task)) {
+    return reject(`"${executableName} ${task}" is not an allowlisted canonical task name`);
+  }
+  return void 0;
+}
+function validateIacToolArgv(executableName, argv) {
+  if (executableName !== "hadolint" && executableName !== "terraform" && executableName !== "tflint" && executableName !== "kubeconform") {
+    return void 0;
+  }
+  const args = argv.slice(1).filter((arg) => arg.length > 0);
+  const reject = (detail) => `Verify command rejected: ${detail}. IaC verify tools may only run static, offline checks (hadolint, terraform fmt -check, tflint, kubeconform).`;
+  if (executableName === "terraform") {
+    const subcommand = args[0] ?? "";
+    if (subcommand !== "fmt") {
+      return reject(
+        `"terraform ${subcommand || "(none)"}" is not allowlisted; only "terraform fmt -check"`
+      );
+    }
+    if (!args.includes("-check")) {
+      return reject('"terraform fmt" must include -check so it cannot rewrite files');
+    }
+    const SAFE_FMT_FLAGS = /* @__PURE__ */ new Set(["-check", "-recursive", "-diff", "-no-color"]);
+    for (let i = 1; i < args.length; i += 1) {
+      const token = args[i] ?? "";
+      if (token.startsWith("-")) {
+        if (!SAFE_FMT_FLAGS.has(token)) {
+          return reject(`"terraform fmt" option "${token}" is not allowlisted`);
+        }
+        continue;
+      }
+      if (isEscapingPathValue(token)) {
+        return reject(`"terraform fmt" operand "${token}" points outside the repository`);
+      }
+    }
+    return void 0;
+  }
+  const IAC_FLAG_POLICIES = {
+    // hadolint: static Dockerfile linter. Allow config (path), format (value),
+    // and the no-color switch, plus Dockerfile positionals. Reject the rest.
+    // `--no-fail` is deliberately NOT allowed: it forces a zero exit even when
+    // violations are found, which would make the lint gate hollow (always green).
+    hadolint: {
+      noValueFlags: /* @__PURE__ */ new Set(["--no-color"]),
+      valueFlags: /* @__PURE__ */ new Set(["-f", "--format"]),
+      pathValueFlags: /* @__PURE__ */ new Set(["-c", "--config"])
+    },
+    // tflint: static Terraform linter. Allow format (value), chdir/config (path),
+    // and the `--recursive` switch so nested Terraform modules (infra/, envs/prod/)
+    // are linted — plain `tflint` lints only the repo root and would skip child
+    // modules. `--recursive` is static/offline-safe: it is local directory
+    // traversal only and does NOT download plugins (unlike `--init`, still
+    // REJECTED). Unknown flags rejected.
+    tflint: {
+      noValueFlags: /* @__PURE__ */ new Set(["--recursive"]),
+      valueFlags: /* @__PURE__ */ new Set(["-f", "--format"]),
+      pathValueFlags: /* @__PURE__ */ new Set(["--chdir", "-c", "--config"])
+    },
+    // kubeconform: offline schema validator. Allow summary/strict switches,
+    // output (value) and -n (value). `-schema-location`/`--schema-location` is a
+    // PATH value flag (repo-relative, non-URL — escaping/URL values rejected
+    // below). Unknown flags rejected. NOTE: kubeconform's DEFAULT schema location
+    // fetches schemas over the network, so a kubeconform command is only admitted
+    // when it pins an explicit offline `-schema-location` (enforced below before
+    // the per-flag loop).
+    kubeconform: {
+      noValueFlags: /* @__PURE__ */ new Set(["-summary", "-strict"]),
+      valueFlags: /* @__PURE__ */ new Set(["-output", "-n"]),
+      pathValueFlags: /* @__PURE__ */ new Set(["-schema-location", "--schema-location"])
+    }
+  };
+  const policy = IAC_FLAG_POLICIES[executableName];
+  if (policy === void 0) {
+    return reject(`"${executableName}" has no static-flag policy`);
+  }
+  if (executableName === "kubeconform") {
+    let schemaLocationCount = 0;
+    for (let i = 0; i < args.length; i += 1) {
+      const token = args[i] ?? "";
+      if (!token.startsWith("-")) continue;
+      const name = normalizeFlagName(token) ?? token;
+      if (name !== "-schema-location" && name !== "--schema-location") continue;
+      const value = token.includes("=") ? token.slice(token.indexOf("=") + 1) : args[i + 1];
+      if (value === void 0 || !token.includes("=") && value.startsWith("-")) {
+        continue;
+      }
+      if (value === "") {
+        return reject("kubeconform -schema-location requires a non-empty repo-relative value");
+      }
+      schemaLocationCount += 1;
+      if (value.includes("://") || isEscapingPathValue(value)) {
+        return reject(
+          `kubeconform -schema-location value "${value}" is not an offline, repo-relative schema source`
+        );
+      }
+      if (value.toLowerCase() === "default") {
+        return reject('kubeconform -schema-location "default" fetches schemas over the network');
+      }
+    }
+    if (schemaLocationCount === 0) {
+      return reject(
+        'kubeconform requires an explicit repo-relative -schema-location (default location, including the literal value "default", fetches schemas over the network)'
+      );
+    }
+  }
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i] ?? "";
+    if (!token.startsWith("-")) {
+      if (token.includes("://")) {
+        return reject(`${executableName} operand "${token}" looks like a URL (not offline)`);
+      }
+      if (isEscapingPathValue(token)) {
+        return reject(`${executableName} operand "${token}" points outside the repository`);
+      }
+      continue;
+    }
+    const name = normalizeFlagName(token) ?? token;
+    if (policy.noValueFlags.has(name)) {
+      if (token.includes("=")) {
+        return reject(`${executableName} switch "${token}" does not take a value`);
+      }
+      continue;
+    }
+    if (policy.valueFlags.has(name) || policy.pathValueFlags.has(name)) {
+      const value = token.includes("=") ? token.slice(token.indexOf("=") + 1) : args[i + 1];
+      if (value === void 0 || !token.includes("=") && value.startsWith("-")) {
+        return reject(`${executableName} option "${token}" requires a value`);
+      }
+      if (value.includes("://")) {
+        return reject(`${executableName} option "${token}" value "${value}" looks like a URL`);
+      }
+      if (policy.pathValueFlags.has(name) && isEscapingPathValue(value)) {
+        return reject(`${executableName} option "${token}" points outside the repository`);
+      }
+      if (!token.includes("=")) i += 1;
+      continue;
+    }
+    return reject(`${executableName} option "${token}" is not allowlisted`);
+  }
+  return void 0;
+}
+var NPX_RUNNABLE_BINARY_ALLOWLIST = /* @__PURE__ */ new Set([
+  "ava",
+  "biome",
+  "eslint",
+  "jest",
+  "mocha",
+  "prettier",
+  "tap",
+  "tsc",
+  "turbo",
+  "vitest",
+  "vue-tsc"
+]);
+var PACKAGE_MANAGER_VERIFY_SCRIPTS = /^(?:test|tests|test[:_-][A-Za-z0-9:_-]+|lint|lint[:_-][A-Za-z0-9:_-]+|typecheck|typecheck[:_-][A-Za-z0-9:_-]+|type-check|type-check[:_-][A-Za-z0-9:_-]+|build|build[:_-][A-Za-z0-9:_-]+|coverage|coverage[:_-][A-Za-z0-9:_-]+|test:coverage|check|check[:_-][A-Za-z0-9:_-]+|verify|verify[:_-][A-Za-z0-9:_-]+|validate|validate[:_-][A-Za-z0-9:_-]+|integration|integration[:_-][A-Za-z0-9:_-]+|e2e|e2e[:_-][A-Za-z0-9:_-]+|smoke|smoke[:_-][A-Za-z0-9:_-]+|release:gate|format:check|check:format|fmt:check)$/;
+var NPM_ALLOWED_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "run",
+  "run-script",
+  "rum",
+  // npm alias for run-script
+  "urn",
+  // npm alias for run-script
+  "test",
+  "t",
+  "tst",
+  "ls",
+  "list"
+]);
+var PACKAGE_MANAGER_BLOCKED_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "add",
+  "ci",
+  "create",
+  "dedupe",
+  "dlx",
+  "exec",
+  "i",
+  "import",
+  "init",
+  "install",
+  "link",
+  "rebuild",
+  "up",
+  "update",
+  "upgrade",
+  "x"
+]);
+var PACKAGE_MANAGER_VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "-C",
+  "-F",
+  "-w",
+  "--cache",
+  "--cache-folder",
+  "--cwd",
+  "--dir",
+  "--filter",
+  "--globalconfig",
+  "--include-workspace-root",
+  "--loglevel",
+  "--modules-dir",
+  "--mutex",
+  "--network-timeout",
+  "--prefix",
+  "--registry",
+  "--store-dir",
+  "--tag",
+  "--use-node-version",
+  "--userconfig",
+  "--workspace",
+  "--workspace-root",
+  "--audit-level",
+  "--omit",
+  "--severity"
+]);
+var PACKAGE_MANAGER_PATH_VALUE_FLAGS = /* @__PURE__ */ new Set(["-C", "--cwd", "--dir", "--prefix"]);
+function extractPackageManagerPositionals(args) {
+  const positionals = [];
+  let pending = "none";
+  for (const token of args) {
+    if (token.startsWith("-")) {
+      const name = normalizeFlagName(token);
+      const bare = !token.includes("=");
+      if (bare && name && PACKAGE_MANAGER_VALUE_FLAGS.has(name)) {
+        pending = "known";
+      } else if (bare) {
+        pending = "unknown";
+      } else {
+        pending = "none";
+      }
+      continue;
+    }
+    if (pending === "known") {
+      pending = "none";
+      continue;
+    }
+    positionals.push({ value: token, definite: pending !== "unknown" });
+    pending = "none";
+  }
+  return positionals;
+}
+function normalizeFlagName(token) {
+  if (!token.startsWith("-")) return void 0;
+  const eq = token.indexOf("=");
+  return eq >= 0 ? token.slice(0, eq) : token;
+}
+function validateNpmAuditArgv(args, scanned, reject) {
+  const auditPosition = scanned.findIndex((p) => p.value === "audit" && p.definite);
+  if (auditPosition < 0) return void 0;
+  const extraPositional = scanned.find((_p, index) => index !== auditPosition);
+  if (extraPositional) {
+    return reject(`"npm audit ${extraPositional.value}" is not an allowlisted audit command`);
+  }
+  if (args.includes("--")) {
+    return reject('"npm audit" does not allow passthrough arguments');
+  }
+  const valueFlags = /* @__PURE__ */ new Set(["--audit-level", "--omit"]);
+  const noValueFlags = /* @__PURE__ */ new Set(["--json"]);
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i] ?? "";
+    if (token === "audit") continue;
+    if (!token.startsWith("-")) continue;
+    const name = normalizeFlagName(token) ?? token;
+    if (noValueFlags.has(name) && !token.includes("=")) {
+      continue;
+    }
+    if (valueFlags.has(name)) {
+      const value = token.includes("=") ? token.slice(token.indexOf("=") + 1) : args[i + 1];
+      if (!value || !token.includes("=") && value.startsWith("-")) {
+        return reject(`option "${token}" requires a value`);
+      }
+      if (!token.includes("=")) i += 1;
+      continue;
+    }
+    return reject(`"npm audit" option "${token}" is not allowlisted`);
+  }
+  return void 0;
+}
+function validatePackageManagerAuditArgv(executableName, args, scanned, reject) {
+  const definite = scanned.filter((p) => p.definite).map((p) => p.value);
+  const expected = executableName === "yarn" ? ["npm", "audit"] : executableName === "pnpm" ? ["audit"] : ["audit"];
+  const matched = expected.every((value, index) => definite[index] === value);
+  if (!matched) return { matched: false };
+  const extra = definite.slice(expected.length)[0];
+  if (extra) {
+    return {
+      matched: true,
+      error: reject(
+        `"${executableName} ${expected.join(" ")} ${extra}" is not an allowlisted audit command`
+      )
+    };
+  }
+  if (args.includes("--")) {
+    return {
+      matched: true,
+      error: reject(
+        `"${executableName} ${expected.join(" ")}" does not allow passthrough arguments`
+      )
+    };
+  }
+  const valueFlags = executableName === "pnpm" ? /* @__PURE__ */ new Set(["--audit-level"]) : executableName === "yarn" ? /* @__PURE__ */ new Set(["--severity"]) : /* @__PURE__ */ new Set();
+  const noValueFlags = executableName === "pnpm" ? /* @__PURE__ */ new Set(["--prod", "--json"]) : executableName === "yarn" ? /* @__PURE__ */ new Set(["--recursive", "--json"]) : /* @__PURE__ */ new Set(["--production", "--json"]);
+  const commandTokens = new Set(expected);
+  for (let i = 0; i < args.length; i += 1) {
+    const token = args[i] ?? "";
+    if (commandTokens.has(token)) continue;
+    if (!token.startsWith("-")) continue;
+    const name = normalizeFlagName(token) ?? token;
+    if (noValueFlags.has(name) && !token.includes("=")) {
+      continue;
+    }
+    if (valueFlags.has(name)) {
+      const value = token.includes("=") ? token.slice(token.indexOf("=") + 1) : args[i + 1];
+      if (!value || !token.includes("=") && value.startsWith("-")) {
+        return { matched: true, error: reject(`option "${token}" requires a value`) };
+      }
+      if (!token.includes("=")) i += 1;
+      continue;
+    }
+    return {
+      matched: true,
+      error: reject(
+        `"${executableName} ${expected.join(" ")}" option "${token}" is not allowlisted`
+      )
+    };
+  }
+  return { matched: true };
+}
+function validateAuditToolArgv(executableName, argv) {
+  const args = argv.slice(1).filter((arg) => arg.length > 0);
+  const reject = (detail) => `Verify command rejected: ${detail}. Audit verify tools may only run read-only vulnerability checks.`;
+  if (executableName === "pip-audit") {
+    const valueFlags = /* @__PURE__ */ new Set([
+      "-r",
+      "--requirement",
+      "--cache-dir",
+      "--index-url",
+      "--extra-index-url",
+      "--format",
+      "--progress-spinner",
+      "--timeout",
+      "--vulnerability-service",
+      "--ignore-vuln"
+    ]);
+    const pathValueFlags = /* @__PURE__ */ new Set(["-r", "--requirement", "--cache-dir"]);
+    const noValueFlags = /* @__PURE__ */ new Set([
+      "--strict",
+      "--desc",
+      "--aliases",
+      "--disable-pip",
+      "--no-deps",
+      "--skip-editable"
+    ]);
+    for (let i = 0; i < args.length; i += 1) {
+      const token = args[i] ?? "";
+      if (!token.startsWith("-")) {
+        return reject(`pip-audit positional "${token}" is not allowlisted`);
+      }
+      const name = normalizeFlagName(token) ?? token;
+      if (name === "--fix" || name === "--require-hashes" || name === "-o" || name === "--output") {
+        return reject(`pip-audit option "${name}" can mutate or write files`);
+      }
+      if (noValueFlags.has(name) && !token.includes("=")) continue;
+      if (valueFlags.has(name)) {
+        const value = token.includes("=") ? token.slice(token.indexOf("=") + 1) : args[i + 1];
+        if (!value || !token.includes("=") && value.startsWith("-")) {
+          return reject(`option "${token}" requires a value`);
+        }
+        if (pathValueFlags.has(name) && isEscapingPathValue(value)) {
+          return reject(`option "${token}" points outside the repository`);
+        }
+        if (!token.includes("=")) i += 1;
+        continue;
+      }
+      return reject(`pip-audit option "${token}" is not allowlisted`);
+    }
+    return void 0;
+  }
+  if (executableName === "govulncheck") {
+    const valueFlags = /* @__PURE__ */ new Set(["-C", "-db", "-format", "-mode", "-scan", "-show", "-tags"]);
+    const pathValueFlags = /* @__PURE__ */ new Set(["-C"]);
+    const noValueFlags = /* @__PURE__ */ new Set(["-json", "-test", "-version", "-v"]);
+    for (let i = 0; i < args.length; i += 1) {
+      const token = args[i] ?? "";
+      if (!token.startsWith("-")) {
+        if (isEscapingPathValue(token)) {
+          return reject(`govulncheck package "${token}" points outside the repository`);
+        }
+        continue;
+      }
+      const name = normalizeFlagName(token) ?? token;
+      const shortMatch = /^(-[A-Za-z])(.+)$/.exec(token);
+      if (shortMatch && valueFlags.has(shortMatch[1] ?? "")) {
+        const value = shortMatch[2] ?? "";
+        if (pathValueFlags.has(shortMatch[1] ?? "") && isEscapingPathValue(value)) {
+          return reject(`option "${token}" points outside the repository`);
+        }
+        continue;
+      }
+      if (noValueFlags.has(name) && !token.includes("=")) continue;
+      if (valueFlags.has(name)) {
+        const value = token.includes("=") ? token.slice(token.indexOf("=") + 1) : args[i + 1];
+        if (!value || !token.includes("=") && value.startsWith("-")) {
+          return reject(`option "${token}" requires a value`);
+        }
+        if (pathValueFlags.has(name) && isEscapingPathValue(value)) {
+          return reject(`option "${token}" points outside the repository`);
+        }
+        if (!token.includes("=")) i += 1;
+        continue;
+      }
+      return reject(`govulncheck option "${token}" is not allowlisted`);
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function validatePackageManagerArgv(executableName, argv) {
+  const args = argv.slice(1).filter((arg) => arg.length > 0);
+  const reject = (detail) => `Verify command rejected: ${detail}. Use a repository script (e.g. "npm run <script>") or an allowlisted locally-installed binary instead.`;
+  if (executableName === "npx" || executableName === "pnpx" || executableName === "bunx") {
+    const downloadFlags = /* @__PURE__ */ new Set(["-p", "--package", "--packages", "-y", "--yes", "-c", "--call"]);
+    const firstNonFlagIndex = args.findIndex((arg) => !arg.startsWith("-"));
+    for (const token of firstNonFlagIndex >= 0 ? args.slice(0, firstNonFlagIndex) : args) {
+      const flag = normalizeFlagName(token);
+      if (flag && downloadFlags.has(flag)) {
+        return reject(`"${executableName} ${flag}" can fetch and execute a remote package`);
+      }
+    }
+    const firstNonFlag = firstNonFlagIndex >= 0 ? args[firstNonFlagIndex] : void 0;
+    if (!firstNonFlag) {
+      return reject(`"${executableName}" requires an explicit allowlisted binary`);
+    }
+    if (firstNonFlag.startsWith("@")) {
+      return reject(
+        `"${executableName} ${firstNonFlag}" is not an allowlisted local binary and may fetch a remote package`
+      );
+    }
+    const binaryName = getExecutableName(firstNonFlag);
+    if (binaryName !== firstNonFlag) {
+      return reject(
+        `"${executableName} ${firstNonFlag}" must name an allowlisted binary, not a path`
+      );
+    }
+    if (!NPX_RUNNABLE_BINARY_ALLOWLIST.has(binaryName)) {
+      return reject(
+        `"${executableName} ${firstNonFlag}" is not an allowlisted local binary and may fetch a remote package`
+      );
+    }
+    const hasLocalOnlyFlag = args.slice(0, firstNonFlagIndex).some((arg) => arg === "--no-install" || arg === "--offline");
+    if (!hasLocalOnlyFlag) {
+      return reject(
+        `"${executableName} ${firstNonFlag}" must use --no-install or --offline so verify cannot fetch a remote package`
+      );
+    }
+    const nestedArgs = args.slice(firstNonFlagIndex + 1);
+    if ((binaryName === "prettier" || binaryName === "biome") && nestedArgs.some((arg) => arg === "--write" || arg.startsWith("--write="))) {
+      return reject(`"${executableName} ${binaryName} --write" can rewrite files`);
+    }
+    if (binaryName === "eslint" && nestedArgs.some((arg) => arg === "--fix" || arg.startsWith("--fix="))) {
+      return reject(`"${executableName} eslint --fix" can rewrite files`);
+    }
+    if (binaryName === "biome" && nestedArgs.some((arg) => arg === "--fix" || arg.startsWith("--fix="))) {
+      return reject(`"${executableName} biome --fix" can rewrite files`);
+    }
+    if (binaryName === "biome" && nestedArgs[0] === "format") {
+      return reject(
+        `"${executableName} biome format" can rewrite files; use "biome check" for verify steps`
+      );
+    }
+    const nestedLintToolError = validateDirectLintToolArgv(binaryName, [binaryName, ...nestedArgs]);
+    if (nestedLintToolError) return nestedLintToolError;
+    const nestedToolError = validateTypescriptToolArgv(binaryName, args.slice(firstNonFlagIndex));
+    if (nestedToolError) return nestedToolError;
+    const nestedJsToolchainError = validateJavaScriptToolchainArgv(
+      binaryName,
+      args.slice(firstNonFlagIndex)
+    );
+    if (nestedJsToolchainError) return nestedJsToolchainError;
+    return void 0;
+  }
+  if (executableName === "npm" || executableName === "pnpm" || executableName === "yarn" || executableName === "bun") {
+    const pathFlagError = validatePathValueFlags(args, PACKAGE_MANAGER_PATH_VALUE_FLAGS, reject);
+    if (pathFlagError) return pathFlagError;
+    const dashDash = args.indexOf("--");
+    const beforeDashDash = dashDash >= 0 ? args.slice(0, dashDash) : args;
+    const afterDashDash = dashDash >= 0 ? args.slice(dashDash + 1) : [];
+    const positionalsBefore = extractPackageManagerPositionals(beforeDashDash);
+    const positionalsAfter = extractPackageManagerPositionals(afterDashDash);
+    const hasDefiniteCommandBefore = positionalsBefore.some((p) => p.definite);
+    const scanned = hasDefiniteCommandBefore ? positionalsBefore : [...positionalsBefore, ...positionalsAfter];
+    for (const { value } of scanned) {
+      if (PACKAGE_MANAGER_BLOCKED_SUBCOMMANDS.has(value)) {
+        return reject(
+          `"${executableName} ${value}" can install, update, or execute remote packages`
+        );
+      }
+    }
+    if (scanned.length === 0) {
+      return reject(`bare "${executableName}" performs an implicit install`);
+    }
+    if (executableName === "npm") {
+      const npmAuditError = validateNpmAuditArgv(args, scanned, reject);
+      if (npmAuditError !== void 0) {
+        return npmAuditError;
+      }
+      if (scanned.some((p) => p.value === "audit" && p.definite)) {
+        return void 0;
+      }
+      const hasSafeVerb = scanned.some((p) => NPM_ALLOWED_SUBCOMMANDS.has(p.value));
+      if (!hasSafeVerb) {
+        return reject(
+          `"npm ${scanned[0]?.value}" is not an allowlisted script command (use "npm run <script>" or "npm test")`
+        );
+      }
+      const verbIndex = scanned.findIndex((p) => NPM_ALLOWED_SUBCOMMANDS.has(p.value));
+      const verb = scanned[verbIndex]?.value;
+      const script = scanned[verbIndex + 1]?.value;
+      if (verb && verb !== "test" && verb !== "t" && verb !== "tst") {
+        if (!script || !PACKAGE_MANAGER_VERIFY_SCRIPTS.test(script)) {
+          return reject(`"npm ${verb} ${script ?? ""}" is not an allowlisted verification script`);
+        }
+      }
+    }
+    if (executableName === "pnpm" || executableName === "yarn" || executableName === "bun") {
+      const auditResult = validatePackageManagerAuditArgv(executableName, args, scanned, reject);
+      if (auditResult.error !== void 0) {
+        return auditResult.error;
+      }
+      if (auditResult.matched) {
+        return void 0;
+      }
+      const firstCommandIndex = scanned.findIndex((p) => p.definite);
+      const firstCommand = scanned[firstCommandIndex]?.value;
+      if (firstCommand !== "run" && firstCommand !== "test") {
+        return reject(
+          `"${executableName} ${firstCommand ?? ""}" is not an allowlisted explicit verify command (use "${executableName} run <script>" or "${executableName} test")`
+        );
+      }
+      if (firstCommand === "run") {
+        const script = scanned[firstCommandIndex + 1]?.value;
+        if (!script || !PACKAGE_MANAGER_VERIFY_SCRIPTS.test(script)) {
+          return reject(
+            `"${executableName} run ${script ?? ""}" is not an allowlisted verification script`
+          );
+        }
+      }
+    }
+    return void 0;
+  }
+  return void 0;
+}
+function parseVerifyCommand(command) {
+  const sequence = splitVerifyCommandSequence(command);
+  if (!Array.isArray(sequence)) {
+    return sequence;
+  }
+  const parsed = [];
+  let nextOperator = "always";
+  for (const segment of sequence) {
+    if (segment === ";") {
+      nextOperator = "always";
+      continue;
+    }
+    if (segment === "&&") {
+      nextOperator = "and";
+      continue;
+    }
+    let negate = false;
+    let segmentBody = segment;
+    if (segmentBody.startsWith("!")) {
+      negate = true;
+      segmentBody = segmentBody.slice(1).trim();
+      if (!segmentBody) {
+        return {
+          error: "Verify command rejected: empty command segment after shell negation."
+        };
+      }
+    }
+    const argv = parseArgv(segmentBody);
+    if (!Array.isArray(argv)) {
+      return argv;
+    }
+    if (negate && getExecutableName(argv[0] ?? "") !== "grep") {
+      return {
+        error: "Verify command rejected: shell negation is only allowed for grep absence checks."
+      };
+    }
+    const validationError = validateVerifyArgv(argv);
+    if (validationError) {
+      return { error: validationError };
+    }
+    parsed.push({
+      operator: nextOperator,
+      argv,
+      ...negate ? { negate: true } : {}
+    });
+    nextOperator = "always";
+  }
+  if (parsed.length === 0) {
+    return { error: "Empty verify command rejected." };
+  }
+  if (parsed.every((segment) => isVacuousVerifyArgv(segment.argv))) {
+    return {
+      error: "Verify command rejected: no-op commands do not verify the project."
+    };
+  }
+  return parsed;
+}
+function checkVerifyCommandSafety(command) {
+  const parsed = parseVerifyCommand(command);
+  if (Array.isArray(parsed)) {
+    return { safe: true };
+  }
+  return { safe: false, error: parsed.error };
+}
+function containsUnsafeVerifyShellSyntax(command) {
+  const parsed = parseVerifyCommand(command);
+  if (Array.isArray(parsed)) return false;
+  const msg = parsed.error.toLowerCase();
+  return msg.includes("pipe") || msg.includes("redirection") || msg.includes("command substitution") || msg.includes("background execution");
+}
+async function executeVerifyCommand(cwd, command, timeoutMs, signal) {
+  const parsed = parseVerifyCommand(command);
+  if (!Array.isArray(parsed)) {
+    return {
+      exitCode: VERIFY_COMMAND_REJECTED_EXIT_CODE,
+      stdout: "",
+      stderr: parsed.error,
+      combined: parsed.error
+    };
+  }
+  const stdoutChunks = [];
+  const stderrChunks = [];
+  const combinedChunks = [];
+  let exitCode = 0;
+  let anyOverflow = false;
+  try {
+    for (const part of parsed) {
+      if (part.operator === "and" && exitCode !== 0) {
+        break;
+      }
+      const [executable, ...args] = part.argv;
+      const result = await execa(executable, args, {
+        cwd,
+        stdio: "pipe",
+        all: true,
+        reject: false,
+        timeout: timeoutMs,
+        cancelSignal: signal,
+        env: buildSanitizedEnv(),
+        extendEnv: false,
+        shell: false,
+        maxBuffer: VERIFY_COMMAND_MAX_BUFFER_BYTES
+      });
+      const overflowed = result.isMaxBuffer === true;
+      if (overflowed) anyOverflow = true;
+      const hasNumericExitCode = !overflowed && typeof result.exitCode === "number";
+      exitCode = overflowed ? VERIFY_COMMAND_PROCESS_FAILURE_EXIT_CODE : resolveProcessExitCode(command, result);
+      if (part.negate && hasNumericExitCode) {
+        if (exitCode >= 2) {
+          exitCode = VERIFY_COMMAND_PROCESS_FAILURE_EXIT_CODE;
+        } else {
+          exitCode = exitCode === 0 ? 1 : 0;
+        }
+      }
+      const stdout = boundTailBytes(
+        String(result.stdout ?? ""),
+        VERIFY_COMMAND_RETAINED_TAIL_BYTES
+      );
+      const stderr = boundTailBytes(
+        String(result.stderr ?? ""),
+        VERIFY_COMMAND_RETAINED_TAIL_BYTES
+      );
+      const missingExitCodeDiagnostic = describeMissingProcessExitCode(result);
+      const maxBufferDiagnostic = overflowed ? `[verify] Output exceeded the ${VERIFY_COMMAND_MAX_BUFFER_BYTES}-byte capture buffer; the command was terminated and treated as a failure (its exit code is not trustworthy).` : void 0;
+      const combined = [
+        boundTailBytes(
+          String(result.all ?? [stdout, stderr].filter(Boolean).join("\n")),
+          VERIFY_COMMAND_RETAINED_TAIL_BYTES
+        ),
+        maxBufferDiagnostic,
+        missingExitCodeDiagnostic
+      ].filter(Boolean).join("\n");
+      if (stdout) stdoutChunks.push(stdout);
+      if (stderr || missingExitCodeDiagnostic) {
+        stderrChunks.push([stderr, missingExitCodeDiagnostic].filter(Boolean).join("\n"));
+      }
+      if (combined) combinedChunks.push(combined);
+    }
+    if (anyOverflow && exitCode === 0) {
+      exitCode = VERIFY_COMMAND_PROCESS_FAILURE_EXIT_CODE;
+    }
+    return {
+      exitCode,
+      stdout: stdoutChunks.join("\n"),
+      stderr: stderrChunks.join("\n"),
+      combined: combinedChunks.join("\n"),
+      overflowed: anyOverflow
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      exitCode: 124,
+      stdout: "",
+      stderr: "",
+      combined: `${message}`.trim()
+    };
+  }
+}
+async function runVerifyCommands(options) {
+  const verifyCommands = [];
+  const maxOutputLines = options.maxOutputLines ?? 80;
+  const combinedOutputChunks = [];
+  const stdoutChunks = [];
+  const stderrChunks = [];
+  const commandProvenance = options.commandProvenance ?? "workflow-config";
+  const globalDeadline = Date.now() + resolveExecutionBoundary("short-command").hardCeilingMs * 3;
+  let globalBudgetExhausted = false;
+  if (options.commands.length === 0) {
+    const message = "Empty verify command list rejected.";
+    const result = {
+      command: "<empty verify commands>",
+      exitCode: VERIFY_COMMAND_REJECTED_EXIT_CODE,
+      durationMs: 0,
+      provenance: commandProvenance,
+      outputTail: message,
+      stdoutTail: "(no output)",
+      stderrTail: message
+    };
+    return {
+      passed: false,
+      results: [result],
+      combinedOutput: message,
+      stdoutOutput: "",
+      stderrOutput: message
+    };
+  }
+  for (const command of options.commands) {
+    if (Date.now() > globalDeadline) {
+      const remaining = options.commands.length - verifyCommands.length;
+      const message = `[verify] Global budget exhausted; skipping ${remaining} remaining command(s).`;
+      console.warn(message);
+      verifyCommands.push({
+        command: "<global verify budget>",
+        exitCode: VERIFY_GLOBAL_BUDGET_EXIT_CODE,
+        durationMs: 0,
+        provenance: commandProvenance,
+        outputTail: message,
+        stdoutTail: "(no output)",
+        stderrTail: message
+      });
+      combinedOutputChunks.push(message);
+      stderrChunks.push(message);
+      globalBudgetExhausted = true;
+      break;
+    }
+    const commandStartTime = Date.now();
+    const VERIFY_COMMAND_DEFAULT_TIMEOUT_MS = resolveExecutionBoundary("short-command").hardCeilingMs;
+    const envTimeoutMsRaw = Number(process.env.POETIC_VERIFY_COMMAND_TIMEOUT_MS);
+    const envTimeoutMs = Number.isFinite(envTimeoutMsRaw) && envTimeoutMsRaw > 0 ? envTimeoutMsRaw : VERIFY_COMMAND_DEFAULT_TIMEOUT_MS;
+    const timeoutMs = options.timeoutMs ?? envTimeoutMs;
+    if (options.signal?.aborted) {
+      const message = "Verify command aborted before execution.";
+      verifyCommands.push({
+        command,
+        exitCode: 124,
+        durationMs: 0,
+        provenance: commandProvenance,
+        outputTail: message,
+        stdoutTail: "(no output)",
+        stderrTail: message
+      });
+      combinedOutputChunks.push(message);
+      stderrChunks.push(message);
+      globalBudgetExhausted = true;
+      break;
+    }
+    const currentExecution = await executeVerifyCommand(
+      options.cwd,
+      command,
+      timeoutMs,
+      options.signal
+    );
+    const durationMs = Date.now() - commandStartTime;
+    const stdout = currentExecution.stdout;
+    let stderr = currentExecution.stderr;
+    let combined = currentExecution.combined;
+    let exitCode = currentExecution.exitCode;
+    let baselineErrorCount;
+    let currentErrorCount;
+    let newErrorCount;
+    const baselineParser = resolveBaselineErrorParser(command);
+    if (exitCode !== 0 && !currentExecution.overflowed && options.baselineCwd && baselineParser) {
+      const baselineExecution = await executeVerifyCommand(
+        options.baselineCwd,
+        command,
+        timeoutMs,
+        options.signal
+      );
+      if (baselineExecution.exitCode !== 0 && !baselineExecution.overflowed) {
+        baselineErrorCount = baselineParser.count(baselineExecution.combined);
+        currentErrorCount = baselineParser.count(combined);
+        newErrorCount = baselineParser.newCount(baselineExecution.combined, combined);
+        if (newErrorCount === 0 && currentErrorCount <= baselineErrorCount) {
+          exitCode = 0;
+          const baselineNote = `Baseline errors: ${baselineErrorCount}; current: ${currentErrorCount}; new: 0. Treating verify as pass because no new errors were introduced.`;
+          combined = [combined.trim(), baselineNote].filter(Boolean).join("\n");
+          stderr = [stderr.trim(), baselineNote].filter(Boolean).join("\n");
+        }
+      }
+    }
+    if (exitCode === 0) {
+      const failureSummary = detectTestRunnerFailureSummary(command, combined);
+      if (failureSummary) {
+        exitCode = 1;
+        combined = [combined.trim(), `[verify] ${failureSummary}`].filter(Boolean).join("\n");
+        stderr = [stderr.trim(), `[verify] ${failureSummary}`].filter(Boolean).join("\n");
+      }
+    }
+    const outputTail = formatOutputTail(combined, maxOutputLines);
+    const stdoutTail = formatOutputTail(stdout, maxOutputLines);
+    const stderrTail = formatOutputTail(stderr, maxOutputLines);
+    combinedOutputChunks.push(`$ ${command}
+${combined}`.trim());
+    stdoutChunks.push(`$ ${command}
+${stdout}`.trim());
+    stderrChunks.push(`$ ${command}
+${stderr}`.trim());
+    verifyCommands.push({
+      command,
+      exitCode,
+      durationMs,
+      provenance: commandProvenance,
+      outputTail,
+      stdoutTail,
+      stderrTail,
+      baselineErrorCount,
+      currentErrorCount,
+      newErrorCount
+    });
+    if (exitCode !== 0) {
+      return {
+        passed: false,
+        results: verifyCommands,
+        combinedOutput: combinedOutputChunks.filter(Boolean).join("\n\n"),
+        stdoutOutput: stdoutChunks.filter(Boolean).join("\n\n"),
+        stderrOutput: stderrChunks.filter(Boolean).join("\n\n")
+      };
+    }
+  }
+  return {
+    passed: !globalBudgetExhausted,
+    results: verifyCommands,
+    combinedOutput: combinedOutputChunks.filter(Boolean).join("\n\n"),
+    stdoutOutput: stdoutChunks.filter(Boolean).join("\n\n"),
+    stderrOutput: stderrChunks.filter(Boolean).join("\n\n")
+  };
+}
+
+export {
+  boundTailBytes,
+  summarizeVerifyCommandRun,
+  validationSurfaceToCommands,
+  mergeValidationSurfaces,
+  resolveBaselineErrorParser,
+  isBaselineComparableTypeScriptCommand,
+  extractTypeScriptErrorSignatures,
+  computeNewErrorCount,
+  buildSanitizedEnv,
+  isAllowedVerifyCommand,
+  parseVerifyCommand,
+  checkVerifyCommandSafety,
+  containsUnsafeVerifyShellSyntax,
+  runVerifyCommands
+};
+//# sourceMappingURL=chunk-LO23NABI.js.map