@humwick/runner 0.0.0-stage → 0.130.1

package/plugins/claude/hooks/gate-run-guard.provisioned.mjs

@@ -0,0 +1,914 @@
+// @bun
+// runner/plugins/claude/hooks/gate-run-guard.ts
+import { resolve as resolve4 } from "path";
+
+// sdk/src/gate-run-classify.ts
+var PACKAGE_MANAGERS = new Set(["bun", "bunx", "npm", "pnpm", "yarn"]);
+var SHELLS = new Set(["sh", "bash", "zsh", "dash", "ksh"]);
+var GATE_ENTRYPOINT_SCRIPTS = [
+  "scripts/test-shard.ts",
+  "scripts/test-affected.ts",
+  "scripts/delivery-gate.ts"
+];
+var GATE_ENTRYPOINT_SCRIPT_SET = new Set(GATE_ENTRYPOINT_SCRIPTS);
+function isTestScriptName(name, binary) {
+  if (name === "test" || name.startsWith("test:"))
+    return true;
+  if (binary !== "bun")
+    return false;
+  return GATE_ENTRYPOINT_SCRIPT_SET.has(name.startsWith("./") ? name.slice(2) : name);
+}
+function isTestRunCommand(args) {
+  const tokens = stripToCommandPosition(firstSegment(args));
+  if (tokens.length === 0)
+    return false;
+  const binary = (tokens[0] ?? "").split("/").pop()?.toLowerCase() ?? "";
+  if (!PACKAGE_MANAGERS.has(binary))
+    return false;
+  let index = 1;
+  index = skipBunFlags(tokens, index);
+  const verb = tokens[index];
+  if (!verb)
+    return false;
+  if (verb === "test")
+    return true;
+  if (verb !== "run")
+    return false;
+  index += 1;
+  index = skipBunFlags(tokens, index);
+  const script = tokens[index];
+  return script !== undefined && isTestScriptName(script, binary);
+}
+function skipBunFlags(tokens, index) {
+  while (index < tokens.length && tokens[index].startsWith("-")) {
+    const flag = tokens[index].split("=", 2)[0];
+    const takesOperand = flag === "--cwd" || flag === "--config";
+    const inline = tokens[index].includes("=");
+    index += 1;
+    if (takesOperand && !inline && index < tokens.length)
+      index += 1;
+  }
+  return index;
+}
+function lexCommandLine(value) {
+  const segments = [];
+  let words = [];
+  let word = "";
+  let hasWord = false;
+  let dropNextWord = false;
+  const endWord = () => {
+    if (!hasWord)
+      return;
+    if (dropNextWord)
+      dropNextWord = false;
+    else
+      words.push(word);
+    word = "";
+    hasWord = false;
+  };
+  const endSegment = () => {
+    endWord();
+    if (words.length > 0)
+      segments.push(words);
+    words = [];
+    dropNextWord = false;
+  };
+  let index = 0;
+  while (index < value.length) {
+    const char = value[index];
+    if (char === "\\" && index + 1 < value.length) {
+      word += value[index + 1];
+      hasWord = true;
+      index += 2;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      hasWord = true;
+      index += 1;
+      while (index < value.length && value[index] !== char) {
+        if (char === '"' && value[index] === "\\" && index + 1 < value.length) {
+          word += value[index + 1];
+          index += 2;
+          continue;
+        }
+        word += value[index];
+        index += 1;
+      }
+      index += 1;
+      continue;
+    }
+    if (char === " " || char === "\t" || char === `
+` || char === "\r") {
+      endWord();
+      index += 1;
+      continue;
+    }
+    if (char === "&" && value[index + 1] === "&" || char === "|" && value[index + 1] === "|") {
+      endSegment();
+      index += 2;
+      continue;
+    }
+    if (char === ";" || char === "|") {
+      endSegment();
+      index += 1;
+      continue;
+    }
+    if (char === "&" && value[index + 1] === ">") {
+      endWord();
+      index += 2;
+      if (value[index] === ">")
+        index += 1;
+      dropNextWord = true;
+      continue;
+    }
+    if (char === "&") {
+      endSegment();
+      index += 1;
+      continue;
+    }
+    if (char === ">" || char === "<") {
+      if (hasWord && /^\d+$/.test(word)) {
+        word = "";
+        hasWord = false;
+      } else
+        endWord();
+      index += 1;
+      if (value[index] === ">" || value[index] === "<")
+        index += 1;
+      if (value[index] === "&") {
+        index += 1;
+        while (index < value.length && /[\d-]/.test(value[index]))
+          index += 1;
+        continue;
+      }
+      dropNextWord = true;
+      continue;
+    }
+    word += char;
+    hasWord = true;
+    index += 1;
+  }
+  endSegment();
+  return segments;
+}
+function firstSegment(value) {
+  return lexCommandLine(value)[0] ?? [];
+}
+var ENV_ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/;
+var TRANSPARENT_PREFIXES = new Set(["env", "exec", "nice", "nohup", "time", "command", "stdbuf"]);
+var PREFIX_OPTIONS_WITH_OPERAND = {
+  env: new Set(["-u", "--unset", "-C", "--chdir", "-a", "--argv0", "--block-signal", "--default-signal"]),
+  nice: new Set(["-n", "--adjustment"]),
+  stdbuf: new Set(["-i", "-o", "-e"]),
+  exec: new Set(["-a"])
+};
+function prefixOperands(prefix) {
+  return PREFIX_OPTIONS_WITH_OPERAND[prefix];
+}
+function stripToCommandPosition(tokens) {
+  let index = 0;
+  while (index < tokens.length) {
+    const token = tokens[index];
+    if (ENV_ASSIGNMENT.test(token)) {
+      index += 1;
+      continue;
+    }
+    if (!TRANSPARENT_PREFIXES.has(token))
+      break;
+    const operands = prefixOperands(token);
+    index += 1;
+    while (index < tokens.length && tokens[index].startsWith("-")) {
+      const option = tokens[index];
+      index += 1;
+      const [flag, inlineValue] = option.split("=", 2);
+      if (inlineValue === undefined && operands?.has(flag) && index < tokens.length)
+        index += 1;
+    }
+  }
+  return tokens.slice(index);
+}
+function sameBinary(a, b) {
+  return a === b || (a.split("/").pop() ?? a) === (b.split("/").pop() ?? b);
+}
+function runsCommand(segment, configured) {
+  const candidate = stripToCommandPosition(segment);
+  const wanted = stripToCommandPosition(configured);
+  if (wanted.length === 0 || wanted.length > candidate.length)
+    return false;
+  if (!sameBinary(candidate[0], wanted[0]))
+    return false;
+  for (let offset = 1;offset < wanted.length; offset += 1) {
+    if (candidate[offset] !== wanted[offset])
+      return false;
+  }
+  return true;
+}
+function unwrapShellCommand(command) {
+  const tokens = stripToCommandPosition(firstSegment(command));
+  if (tokens.length < 3)
+    return;
+  const binary = (tokens[0] ?? "").split("/").pop()?.toLowerCase() ?? "";
+  if (!SHELLS.has(binary))
+    return;
+  let index = 1;
+  while (index < tokens.length && tokens[index].startsWith("-") && !/^-[a-z]*c$/.test(tokens[index]))
+    index += 1;
+  if (index >= tokens.length || !/^-[a-z]*c$/.test(tokens[index]))
+    return;
+  const inner = tokens.slice(index + 1).join(" ").trim();
+  return inner ? inner : undefined;
+}
+function unwrapGroupCommand(command) {
+  const trimmed = command.trim().replace(/;\s*$/, "").trim();
+  if (trimmed.startsWith("((") || trimmed.endsWith("))"))
+    return;
+  const open = trimmed[0];
+  const close = open === "(" ? ")" : open === "{" ? "}" : undefined;
+  if (!close || !trimmed.endsWith(close))
+    return;
+  const inner = trimmed.slice(1, -1).trim().replace(/;\s*$/, "").trim();
+  if (open === "{" && !/^\s/.test(trimmed.slice(1)))
+    return;
+  return inner ? inner : undefined;
+}
+var MAX_SHELL_UNWRAP_DEPTH = 2;
+function classifyGateRun(command, commands = {}) {
+  const configured = [];
+  if (commands.iterate)
+    configured.push({ category: "iterate", tokens: firstSegment(commands.iterate) });
+  if (commands.delivery)
+    configured.push({ category: "delivery", tokens: firstSegment(commands.delivery) });
+  for (const gate of commands.gates ?? []) {
+    if (gate)
+      configured.push({ category: "gate", tokens: firstSegment(gate) });
+  }
+  let candidate = command;
+  for (let depth = 0;depth <= MAX_SHELL_UNWRAP_DEPTH && candidate !== undefined; depth += 1) {
+    const segments = lexCommandLine(candidate);
+    for (const entry of configured) {
+      for (const segment of segments) {
+        if (runsCommand(segment, entry.tokens))
+          return entry.category;
+      }
+    }
+    for (const segment of segments) {
+      if (isTestRunCommand(stripToCommandPosition(segment).join(" ")))
+        return "heuristic";
+    }
+    candidate = unwrapShellCommand(candidate) ?? unwrapGroupCommand(candidate);
+  }
+  return null;
+}
+
+// sdk/src/land-gates.ts
+import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve3 } from "path";
+
+// sdk/src/types/guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// sdk/src/types/land-gates.ts
+var LAND_GATE_SCOPES = ["full", "partial"];
+
+// sdk/src/validation-core.ts
+import { isAbsolute, relative, resolve } from "path";
+
+class ValidationError extends Error {
+}
+function cleanString(value, field, opts = {}) {
+  if (value === undefined || value === null) {
+    if (opts.required)
+      throw new ValidationError(`${field} required`);
+    return;
+  }
+  if (typeof value !== "string")
+    throw new ValidationError(`${field} must be a string`);
+  if (opts.rejectControlBytes)
+    assertNoControlBytes(value, field);
+  const trimmed = value.trim();
+  if (opts.required && !trimmed)
+    throw new ValidationError(`${field} required`);
+  if (opts.max && trimmed.length > opts.max) {
+    throw new ValidationError(`${field} must be ${opts.max} characters or fewer`);
+  }
+  return trimmed || undefined;
+}
+function parseJson(raw, fallback) {
+  if (typeof raw !== "string" || !raw)
+    return fallback;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return fallback;
+  }
+}
+function isPathWithinBase(path, baseDir) {
+  if (!path || !baseDir)
+    return false;
+  const rel = relative(resolve(baseDir), resolve(path));
+  return rel === "" || !!rel && !rel.startsWith("..") && !isAbsolute(rel);
+}
+var CONTROL_BYTES = /[\x00-\x08\x0b-\x1f\x7f]/g;
+function stripControlBytes(text) {
+  return text.replace(CONTROL_BYTES, "");
+}
+function assertNoControlBytes(text, field) {
+  if (stripControlBytes(text) !== text)
+    throw new ValidationError(`${field} must not contain control bytes (only newline and tab are allowed)`);
+}
+
+// sdk/src/repo-config-file.ts
+import { dirname, resolve as resolve2 } from "path";
+import { readFileSync } from "fs";
+function absent(err) {
+  const code = err.code;
+  if (code === "ENOENT" || code === "ENOTDIR")
+    return;
+  throw err;
+}
+function* ancestors(startDir) {
+  for (let current = resolve2(startDir);; current = dirname(current)) {
+    yield current;
+    if (dirname(current) === current)
+      return;
+  }
+}
+function parsed(file, raw, repoRoot, clean) {
+  const value = parseJson(raw, null);
+  if (value === null)
+    throw new ValidationError(`${file}: invalid JSON`);
+  return { repoRoot, config: clean(value, repoRoot) };
+}
+function findRepoConfigFile(startDir, file, clean) {
+  for (const dir of ancestors(startDir)) {
+    let raw;
+    try {
+      raw = readFileSync(resolve2(dir, file), "utf8");
+    } catch (err) {
+      raw = absent(err);
+    }
+    if (raw !== undefined)
+      return parsed(file, raw, dir, clean);
+  }
+  return null;
+}
+
+// sdk/src/land-gates.ts
+var LAND_GATES_FILE = ".agent-relay/land-gates.json";
+var DEFAULT_LAND_GATE_TIMEOUT_MS = 5 * 60 * 1000;
+var LAND_GATE_TIMEOUT_MARGIN_MS = 5 * 60 * 1000;
+function cleanLandGate(value, index, worktreePath) {
+  if (!isRecord(value))
+    throw new ValidationError(`gates[${index}] must be an object`);
+  const name = cleanString(value.name, `gates[${index}].name`, { required: true, max: 120 });
+  if (!name)
+    throw new ValidationError(`gates[${index}].name required`);
+  const command = cleanString(value.command, `gates[${index}].command`, { required: true, max: 4096 });
+  if (!command)
+    throw new ValidationError(`gates[${index}].command required`);
+  let cwd;
+  if (value.cwd !== undefined && value.cwd !== null) {
+    const rawCwd = cleanString(value.cwd, `gates[${index}].cwd`, { max: 1000 });
+    if (rawCwd) {
+      if (worktreePath) {
+        const resolved = resolve3(worktreePath, rawCwd);
+        if (!isPathWithinBase(resolved, worktreePath)) {
+          throw new ValidationError(`gates[${index}].cwd must be within the worktree`);
+        }
+        cwd = relative2(worktreePath, resolved) || ".";
+      } else {
+        if (isAbsolute2(rawCwd))
+          throw new ValidationError(`gates[${index}].cwd must be a relative path when no worktreePath is provided`);
+        cwd = rawCwd;
+      }
+    }
+  }
+  if (value.timeoutMs !== undefined && value.timeoutMs !== null) {
+    if (typeof value.timeoutMs !== "number" || !Number.isSafeInteger(value.timeoutMs) || value.timeoutMs <= 0) {
+      throw new ValidationError(`gates[${index}].timeoutMs must be a positive integer`);
+    }
+  }
+  if (value.optional !== undefined && value.optional !== null) {
+    if (typeof value.optional !== "boolean") {
+      throw new ValidationError(`gates[${index}].optional must be a boolean`);
+    }
+  }
+  return {
+    name,
+    command,
+    ...cwd !== undefined ? { cwd } : {},
+    ...typeof value.timeoutMs === "number" ? { timeoutMs: value.timeoutMs } : {},
+    ...typeof value.optional === "boolean" ? { optional: value.optional } : {}
+  };
+}
+function cleanLandGatesConfig(value, worktreePath) {
+  if (!isRecord(value))
+    throw new ValidationError("land-gates config must be an object");
+  const { gates } = value;
+  if (!Array.isArray(gates))
+    throw new ValidationError("gates must be an array");
+  if (gates.length > 50)
+    throw new ValidationError("gates: at most 50 gates allowed");
+  return gates.map((g, i) => cleanLandGate(g, i, worktreePath));
+}
+function cleanLandGatesConfigFull(value, worktreePath) {
+  const gates = cleanLandGatesConfig(value, worktreePath);
+  const iterate = cleanString(value.iterate, "iterate", { max: 4096 });
+  const deliveryPolicy = cleanDeliveryGatePolicy(value);
+  const placement = cleanLandPlacement(value);
+  const requirements = cleanLandGateRequirements(value);
+  const cd = value.cd === true;
+  const scope = cleanLandGateScope(value);
+  return { gates, ...deliveryPolicy, ...iterate ? { iterate } : {}, ...cd ? { cd } : {}, ...placement ? { placement } : {}, ...requirements ? { requirements } : {}, ...scope };
+}
+function cleanDeliveryGatePolicy(value) {
+  if (!isRecord(value))
+    throw new ValidationError("land-gates config must be an object");
+  const delivery = cleanString(value.delivery, "delivery", { max: 4096 });
+  if (value.deliveryRequire !== undefined && value.deliveryRequire !== "captured") {
+    throw new ValidationError('deliveryRequire must be "captured" when present');
+  }
+  if (value.deliveryRequire && !delivery)
+    throw new ValidationError('deliveryRequire "captured" requires delivery command');
+  return { ...delivery ? { delivery } : {}, ...value.deliveryRequire ? { deliveryRequire: "captured" } : {} };
+}
+function cleanLandGateScope(value) {
+  const policy = value.mainFailurePolicy;
+  if (policy !== undefined && policy !== "stop" && policy !== "advisory") {
+    throw new ValidationError("mainFailurePolicy must be one of stop, advisory");
+  }
+  const scope = value.gateScope;
+  if (scope !== undefined && !LAND_GATE_SCOPES.includes(scope)) {
+    throw new ValidationError(`gateScope must be one of ${LAND_GATE_SCOPES.join(", ")}`);
+  }
+  let mainVerdict;
+  if (value.mainVerdict !== undefined) {
+    if (!isRecord(value.mainVerdict))
+      throw new ValidationError("mainVerdict must be an object");
+    const watch = cleanString(value.mainVerdict.watch, "mainVerdict.watch", { required: true, max: 64 });
+    if (!watch)
+      throw new ValidationError("mainVerdict.watch required");
+    mainVerdict = { watch };
+  }
+  if (scope === "partial" && !mainVerdict)
+    throw new ValidationError('gateScope "partial" requires mainVerdict.watch');
+  return { ...policy ? { mainFailurePolicy: policy } : {}, ...scope ? { gateScope: scope } : {}, ...mainVerdict ? { mainVerdict } : {} };
+}
+function cleanLandGateRequirements(value) {
+  if (!isRecord(value))
+    throw new ValidationError("land-gates config must be an object");
+  if (value.requirements === undefined)
+    return;
+  if (!isRecord(value.requirements))
+    throw new ValidationError("requirements must be an object");
+  const requirements = {};
+  for (const key of ["platforms", "capabilities"]) {
+    const items = value.requirements[key];
+    if (items === undefined)
+      continue;
+    if (!Array.isArray(items) || items.length === 0 || items.length > 50 || items.some((item) => typeof item !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9:_-]{0,119}$/.test(item))) {
+      throw new ValidationError(`requirements.${key} must be a nonempty array of capability names`);
+    }
+    requirements[key] = [...new Set(items)];
+  }
+  return requirements;
+}
+function cleanLandPlacement(value) {
+  if (!isRecord(value))
+    throw new ValidationError("land-gates config must be an object");
+  if (value.placement === undefined)
+    return;
+  if (!isRecord(value.placement))
+    throw new ValidationError("placement must be an object");
+  const platforms = value.placement.platforms;
+  if (platforms === undefined)
+    return {};
+  if (!Array.isArray(platforms) || !platforms.length || platforms.length > 20) {
+    throw new ValidationError("placement.platforms must be a nonempty array of at most 20 platforms");
+  }
+  return { platforms: [...new Set(platforms.map((item) => {
+    if (item !== "linux" && item !== "darwin" && item !== "win32") {
+      throw new ValidationError(`placement.platforms: unknown platform '${String(item)}'; expected linux, darwin, win32`);
+    }
+    return item;
+  }))] };
+}
+function resolveIterateCommand(config) {
+  if (config.iterate)
+    return config.iterate;
+  return config.gates.find((g) => g.name === "test")?.command;
+}
+function findRepoLandGatesConfig(startDir) {
+  return findRepoConfigFile(startDir, LAND_GATES_FILE, cleanLandGatesConfigFull);
+}
+var MERGE_NON_GATE_PHASE_OVERHEAD_MS = 21 * 60000;
+var DEFAULT_GATE_RUN_BUDGET_MS = 35 * 60000;
+var HEAVY_GATE_QUEUE_STALL_MS = 2 * 60 * 60000;
+var HEAVY_GATE_RUN_CAP_MS = 90 * 60000;
+var MERGE_TOTAL_SAFETY_MARGIN_MS = 10 * 60000;
+var HUB_MERGE_TTL_REPORT_HEADROOM_MS = 5 * 60000;
+function gateCommandsForCwd(cwd) {
+  try {
+    const found = findRepoLandGatesConfig(cwd);
+    if (!found)
+      return {};
+    return {
+      iterate: resolveIterateCommand(found.config),
+      delivery: found.config.delivery,
+      gates: found.config.gates.map((gate) => gate.command)
+    };
+  } catch {
+    return {};
+  }
+}
+
+// runner/plugins/claude/hooks/shell-trust.ts
+var SYNTAX = String.raw`<<|\\$|(^|\s)#|\$\(|` + "`" + String.raw`|\(\)|^\s*[{}]|\{\s*$`;
+var CONTROL_KEYWORDS = ["if", "then", "elif", "else", "fi", "for", "while", "until", "case", "esac", "select", "function"];
+var patterns = new Map;
+function unsurePattern(keywords) {
+  const key = keywords.join("|");
+  let pattern = patterns.get(key);
+  if (!pattern) {
+    pattern = new RegExp(`${SYNTAX}|(^|[\\s;&|(])(${key})\\b`, "m");
+    patterns.set(key, pattern);
+  }
+  return pattern;
+}
+var countOf = (line, char) => line.split(char).length - 1;
+function trustedFlatCommand(command, keywords = CONTROL_KEYWORDS) {
+  if (unsurePattern(keywords).test(command))
+    return null;
+  const lines = command.split(/\r?\n/);
+  if (lines.some((line) => countOf(line, "'") % 2 === 1 || countOf(line, '"') % 2 === 1))
+    return null;
+  return lines.filter((line) => line.trim()).join("; ");
+}
+
+// runner/plugins/claude/hooks/wait-loop-guard.ts
+var MIN_BARE_SLEEP_SECONDS = 30;
+var MIN_LOOP_SLEEP_SECONDS = 5;
+var MAX_UNWRAP_DEPTH = 2;
+var SETUP = new Set(["cd", "pushd", "export", "echo", "printf", "date", "true", ":"]);
+var BODY_FILLER = new Set(["echo", "printf", "date", "true", ":"]);
+var ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/;
+var DURATION = /^(\d+(?:\.\d+)?)([smhd]?)$/;
+var UNIT_SECONDS = { "": 1, s: 1, m: 60, h: 3600, d: 86400 };
+var UNSURE_OPERATORS = /\|\||</;
+var SHELL_BINARIES = new Set(["sh", "bash", "zsh", "dash", "ksh"]);
+var EXECUTING_FLAGS = /^-[leuxi]+$/;
+var EXECUTING_C_FLAGS = /^-[leuxi]*c$/;
+var READERS = new Set(["read", "mapfile", "readarray"]);
+var BACKGROUND_AMP = /(?<![&>])&(?![&>])/;
+var LOOP_KEYWORDS = CONTROL_KEYWORDS.filter((word) => word !== "while" && word !== "until");
+var STRUCTURE_WORDS = new Set([...CONTROL_KEYWORDS, "do", "done", "{", "}", "(", ")", "[["]);
+function sleepSeconds(words) {
+  if (words[0] !== "sleep" || words.length < 2)
+    return null;
+  let total = 0;
+  for (const arg of words.slice(1)) {
+    const match = DURATION.exec(arg);
+    if (!match)
+      return null;
+    total += Number(match[1]) * UNIT_SECONDS[match[2]];
+  }
+  return total;
+}
+var isSetup = (words) => SETUP.has(words[0]) || words.every((word) => ASSIGNMENT.test(word));
+var isPlainRest = (words) => !STRUCTURE_WORDS.has(words[0]);
+function isForegroundWait(segments) {
+  let i = 0;
+  while (i < segments.length && isSetup(segments[i]))
+    i += 1;
+  const head = segments[i];
+  if (!head)
+    return false;
+  let next;
+  if (head[0] === "sleep") {
+    const seconds = sleepSeconds(head);
+    if (seconds === null || seconds < MIN_BARE_SLEEP_SECONDS)
+      return false;
+    next = i + 1;
+  } else if (head[0] === "until" || head[0] === "while") {
+    const checkStart = head.slice(1);
+    const checkCommand = checkStart.find((word) => !ASSIGNMENT.test(word));
+    if (!checkCommand || READERS.has(checkCommand))
+      return false;
+    let j = i + 1;
+    while (j < segments.length && segments[j][0] !== "do") {
+      if (STRUCTURE_WORDS.has(segments[j][0]))
+        return false;
+      j += 1;
+    }
+    if (j >= segments.length)
+      return false;
+    let sleeps = false;
+    let first = true;
+    for (;j < segments.length; j += 1) {
+      const words = first ? segments[j].slice(1) : segments[j];
+      first = false;
+      if (words.length === 1 && words[0] === "done")
+        break;
+      if (words.length === 0)
+        continue;
+      const seconds = sleepSeconds(words);
+      if (seconds !== null) {
+        if (seconds === 0)
+          return false;
+        if (seconds >= MIN_LOOP_SLEEP_SECONDS)
+          sleeps = true;
+      } else if (!BODY_FILLER.has(words[0])) {
+        return false;
+      }
+    }
+    if (j >= segments.length || !sleeps)
+      return false;
+    next = j + 1;
+  } else {
+    return false;
+  }
+  return segments.slice(next).every(isPlainRest);
+}
+function executingShellScript(candidate) {
+  const segments = lexCommandLine(candidate);
+  const words = segments[0] ?? [];
+  if (!SHELL_BINARIES.has((words[0] ?? "").split("/").pop().toLowerCase()))
+    return;
+  let i = 1;
+  while (i < words.length && EXECUTING_FLAGS.test(words[i]))
+    i += 1;
+  if (words.length !== i + 2 || !EXECUTING_C_FLAGS.test(words[i]))
+    return;
+  return words[i + 1];
+}
+var TIMEOUT_PREFIX = /^\s*timeout\s+(?:-\S+\s+)*\S+\s+/;
+function waitLoopDenial(command) {
+  const flat = trustedFlatCommand(command, LOOP_KEYWORDS);
+  if (flat === null || BACKGROUND_AMP.test(flat) || UNSURE_OPERATORS.test(flat))
+    return null;
+  let candidate = flat;
+  for (let depth = 0;depth <= MAX_UNWRAP_DEPTH && candidate !== undefined; depth += 1) {
+    candidate = candidate.replace(TIMEOUT_PREFIX, "");
+    if (isForegroundWait(lexCommandLine(candidate))) {
+      return "Do not hold the turn on a foreground wait. Run it with the relay_run MCP tool (detach: true, waitMs: 0) as ONE poll loop with a deadline " + "(e.g. `end=$((SECONDS+1800)); until <check>; do [ $SECONDS -ge $end ] && exit 1; sleep 30; done`), then end your turn with no text; " + `Relay wakes you once when it finishes. Command: ${command}`;
+    }
+    candidate = executingShellScript(candidate) ?? unwrapGroupCommand(candidate);
+  }
+  return null;
+}
+
+// runner/plugins/claude/hooks/gate-run-guard.ts
+var MAX_COMMAND_CHARS = 64 * 1024;
+var MAX_UNWRAP_DEPTH2 = 2;
+var SETUP_COMMANDS = new Set(["cd", "pushd", "export", "set", "source", ".", "echo", "printf", "true"]);
+var ASSIGNMENT2 = /^[A-Za-z_][A-Za-z0-9_]*=/;
+var SHELL_BINARIES2 = new Set(["sh", "bash", "zsh", "dash", "ksh"]);
+var SHELL_NON_EXEC_LONG = new Set(["--help", "--version", "--dump-po-strings", "--dump-strings"]);
+var ENV_NON_EXEC_LONG = new Set(["--help", "--version"]);
+var shellQuote = (word) => /^[\w@%+=:,./-]+$/.test(word) ? word : `'${word.replaceAll("'", "'\\''")}'`;
+function normalizeGate(gate) {
+  if (!gate)
+    return gate;
+  const segments = lexCommandLine(gate).filter((words) => !SETUP_COMMANDS.has(words[0] ?? "") && !words.every((word) => ASSIGNMENT2.test(word)));
+  return segments[0]?.map(shellQuote).join(" ");
+}
+var repoRootOf = (dir) => findRepoLandGatesConfig(dir)?.repoRoot;
+function leavesProject(command, cwd) {
+  const home = repoRootOf(cwd);
+  let candidate = command;
+  for (let depth = 0;depth <= MAX_UNWRAP_DEPTH2 && candidate !== undefined; depth += 1) {
+    let dir = cwd;
+    for (const words of lexCommandLine(candidate)) {
+      if (words[0] !== "cd" && words[0] !== "pushd")
+        continue;
+      const target = words.slice(1).find((word) => !word.startsWith("-") || word === "-");
+      if (!target || target === "-" || /^~|\$|`/.test(target))
+        return true;
+      dir = resolve4(dir, target);
+      if (repoRootOf(dir) !== home)
+        return true;
+    }
+    candidate = unwrapShellCommand(candidate) ?? unwrapGroupCommand(candidate);
+  }
+  return false;
+}
+var baseBinary = (word) => (word.split("/").pop() ?? word).toLowerCase();
+function wrapperHasNonExecutingOption(candidate) {
+  const words = lexCommandLine(candidate)[0] ?? [];
+  let index = 0;
+  while (index < words.length && ASSIGNMENT2.test(words[index]))
+    index += 1;
+  const binary = baseBinary(words[index] ?? "");
+  if (SHELL_BINARIES2.has(binary)) {
+    for (let i = index + 1;i < words.length; i += 1) {
+      const flag = words[i];
+      if (!flag.startsWith("-") || flag === "--")
+        break;
+      if (flag.startsWith("--")) {
+        if (SHELL_NON_EXEC_LONG.has(flag.split("=", 2)[0]))
+          return true;
+        continue;
+      }
+      if (flag.includes("n"))
+        return true;
+      if (/^-[a-z]*c$/.test(flag))
+        break;
+    }
+    return false;
+  }
+  if (binary === "env") {
+    for (let i = index + 1;i < words.length; i += 1) {
+      const flag = words[i];
+      if (!flag.startsWith("-") || flag === "--")
+        break;
+      if (flag.startsWith("--") && ENV_NON_EXEC_LONG.has(flag.split("=", 2)[0]))
+        return true;
+    }
+  }
+  return false;
+}
+function shellHasExtraOperands(candidate) {
+  const match = /^\s*(?:\S+\/)?(sh|bash|zsh|dash|ksh)\s+([\s\S]*)$/i.exec(candidate);
+  if (!match)
+    return false;
+  let rest = match[2];
+  for (let guard = 0;guard < 16; guard += 1) {
+    rest = rest.replace(/^\s+/, "");
+    const flag = /^\S+/.exec(rest)?.[0];
+    if (!flag || !flag.startsWith("-"))
+      return false;
+    rest = rest.slice(flag.length);
+    if (/^-[a-z]*c$/.test(flag))
+      break;
+    if (!rest.trim())
+      return false;
+  }
+  rest = rest.replace(/^\s+/, "");
+  const quote = rest[0];
+  if (quote !== "'" && quote !== '"')
+    return false;
+  let i = 1;
+  while (i < rest.length && rest[i] !== quote)
+    i += 1;
+  if (i >= rest.length)
+    return false;
+  const after = rest.slice(i + 1).replace(/^\s+/, "");
+  if (!after)
+    return false;
+  return !/^(?:\d*\s*[><|;&#])/.test(after);
+}
+function layerHasShortCircuit(candidate) {
+  const parts = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  let pendingOp = null;
+  const push = () => {
+    parts.push({ text: current, op: pendingOp });
+    pendingOp = null;
+    current = "";
+  };
+  for (let i = 0;i < candidate.length; i += 1) {
+    const char = candidate[i];
+    if (inSingle) {
+      current += char;
+      if (char === "'")
+        inSingle = false;
+      continue;
+    }
+    if (inDouble) {
+      current += char;
+      if (char === "\\") {
+        i += 1;
+        if (i < candidate.length)
+          current += candidate[i];
+        continue;
+      }
+      if (char === '"')
+        inDouble = false;
+      continue;
+    }
+    if (char === "\\") {
+      current += char;
+      i += 1;
+      if (i < candidate.length)
+        current += candidate[i];
+      continue;
+    }
+    if (char === "'") {
+      inSingle = true;
+      current += char;
+      continue;
+    }
+    if (char === '"') {
+      inDouble = true;
+      current += char;
+      continue;
+    }
+    if (char === "&" && candidate[i + 1] === "&") {
+      push();
+      pendingOp = "&&";
+      i += 1;
+      continue;
+    }
+    if (char === "|" && candidate[i + 1] === "|") {
+      push();
+      pendingOp = "||";
+      i += 1;
+      continue;
+    }
+    current += char;
+  }
+  push();
+  const decidingBinary = (text) => {
+    const words = lexCommandLine(text).at(-1) ?? [];
+    return words.find((word) => !ASSIGNMENT2.test(word));
+  };
+  for (let j = 1;j < parts.length; j += 1) {
+    const prev = decidingBinary(parts[j - 1].text);
+    if (parts[j].op === "&&" && prev === "false")
+      return true;
+    if (parts[j].op === "||" && prev === "true")
+      return true;
+  }
+  return false;
+}
+function dropShellOptionOperands(command) {
+  const match = /^\s*(?:\S+\/)?(?:sh|bash|zsh|dash|ksh)\s+([\s\S]*)$/i.exec(command);
+  if (!match)
+    return command;
+  const regionStart = command.length - match[1].length;
+  let rest = match[1];
+  let kept = "";
+  for (let guard = 0;guard < 16; guard += 1) {
+    const trimmed = rest.replace(/^\s+/, "");
+    const word = /^\S+/.exec(trimmed)?.[0];
+    if (!word || word[0] === "'" || word[0] === '"')
+      return command;
+    if (/^[-+][oO]$/.test(word)) {
+      const operand = /^[^\s&|;#]+/.exec(trimmed.slice(word.length).replace(/^\s+/, ""))?.[0];
+      if (!operand || operand[0] === "'" || operand[0] === '"')
+        return command;
+      rest = trimmed.slice(word.length).replace(/^\s+/, "").slice(operand.length);
+      continue;
+    }
+    kept += rest.slice(0, rest.length - trimmed.length + word.length);
+    rest = trimmed.slice(word.length);
+    if (/^-[a-z]*c$/.test(word))
+      break;
+    if (!word.startsWith("-") && !word.startsWith("+"))
+      break;
+  }
+  return command.slice(0, regionStart) + kept + rest;
+}
+function failOpenForContrivedForm(flat) {
+  let candidate = flat;
+  for (let depth = 0;depth <= MAX_UNWRAP_DEPTH2 && candidate !== undefined; depth += 1) {
+    if (wrapperHasNonExecutingOption(candidate))
+      return true;
+    if (shellHasExtraOperands(candidate))
+      return true;
+    if (layerHasShortCircuit(candidate))
+      return true;
+    candidate = unwrapShellCommand(candidate) ?? unwrapGroupCommand(candidate);
+  }
+  return false;
+}
+function gateDenial(command, flat, cwd) {
+  const configured = gateCommandsForCwd(cwd);
+  const commands = {
+    iterate: normalizeGate(configured.iterate),
+    delivery: normalizeGate(configured.delivery),
+    gates: (configured.gates ?? []).map(normalizeGate).filter((gate) => Boolean(gate))
+  };
+  if (!commands.iterate && !commands.delivery && !commands.gates?.length)
+    return null;
+  const normalized = dropShellOptionOperands(flat);
+  if (failOpenForContrivedForm(normalized))
+    return null;
+  const category = classifyGateRun(normalized, commands);
+  if (!category || category === "heuristic")
+    return null;
+  if (leavesProject(normalized, cwd))
+    return null;
+  return `This is a project gate: run it with the relay_run MCP tool (waitMs: 0), then end your turn; Relay wakes you once when it finishes. Command: ${command}`;
+}
+function decide(payload) {
+  const input = payload;
+  if (input?.tool_name !== "Bash" && input?.tool_name !== "Monitor")
+    return null;
+  const command = input.tool_input?.command;
+  if (typeof command !== "string" || !command || command.length > MAX_COMMAND_CHARS)
+    return null;
+  const cwd = typeof input.cwd === "string" && input.cwd ? input.cwd : process.cwd();
+  const flat = trustedFlatCommand(command);
+  const gate = flat === null ? null : gateDenial(command, flat, cwd);
+  return gate ?? (input.tool_input?.run_in_background === true ? null : waitLoopDenial(command));
+}
+try {
+  const reason = decide(JSON.parse(await Bun.stdin.text()));
+  if (reason) {
+    console.log(JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: reason } }));
+  }
+} catch {}