token-goat 2.9.28 → 2.9.30

package/dist/token-goat-chunk-P4QMM4WK.mjs

@@ -0,0 +1,295 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  ANTIGRAVITY_TOOL_NAME_KEY,
+  BODY_FIRST_TOOL_RESPONSE_KEYS,
+  OUTPUT_FIRST_TOOL_RESPONSE_KEYS,
+  VSCODE_TOOL_NAME_KEY,
+  antigravityNativeToolInput,
+  foldToolName,
+  replaceToolResponseField,
+  vscodeNativeToolInput
+} from "./token-goat-chunk-VPBBTSJR.mjs";
+import {
+  recordUnmappedTool
+} from "./token-goat-chunk-3Z5S4KGM.mjs";
+import {
+  registerReset
+} from "./token-goat-chunk-YZAAZU2S.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/hook_registry.ts
+init_define_import_meta_env();
+
+// src/bridges/vscode_hooks.ts
+init_define_import_meta_env();
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+function vscodeToolName(event) {
+  const name = event?.raw[VSCODE_TOOL_NAME_KEY];
+  return typeof name === "string" ? name : void 0;
+}
+var SHRINK_PREFIX = "token-goat-shrink-";
+var MATERIALIZED_MAX_AGE_MS = 60 * 60 * 1e3;
+var lastMaterializedSweepAtMs = 0;
+function pruneMaterialized() {
+  const now = Date.now();
+  if (now - lastMaterializedSweepAtMs < MATERIALIZED_MAX_AGE_MS) return;
+  lastMaterializedSweepAtMs = now;
+  try {
+    const dir = os.tmpdir();
+    for (const file of fs.readdirSync(dir)) {
+      if (!file.startsWith(SHRINK_PREFIX)) continue;
+      const full = path.join(dir, file);
+      try {
+        const st = fs.statSync(full);
+        if (st.isFile() && now - st.mtimeMs > MATERIALIZED_MAX_AGE_MS) fs.unlinkSync(full);
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function materializeShrunkImageFile(context) {
+  const idx = context.indexOf("data:image/");
+  if (idx === -1) return void 0;
+  const match = /^data:image\/([a-zA-Z0-9.+-]+);base64,([A-Za-z0-9+/=]+)$/.exec(context.slice(idx).trim());
+  if (!match) return void 0;
+  try {
+    pruneMaterialized();
+    const file = path.join(os.tmpdir(), `${SHRINK_PREFIX}${process.pid}-${Date.now()}-${crypto.randomUUID()}.${match[1]}`);
+    fs.writeFileSync(file, Buffer.from(match[2], "base64"), { mode: 384 });
+    return file;
+  } catch {
+    return void 0;
+  }
+}
+var NESTED_DECISION_EVENTS = /* @__PURE__ */ new Set(["stop", "subagent_stop"]);
+function serializeVscodeOutput(output, eventName, hookEventName, event) {
+  switch (output.hookType) {
+    case "deny":
+      if (eventName === "pre_tool_use") {
+        return JSON.stringify({
+          hookSpecificOutput: { hookEventName, permissionDecision: "deny", permissionDecisionReason: output.message }
+        });
+      }
+      if (NESTED_DECISION_EVENTS.has(eventName)) {
+        return JSON.stringify({ hookSpecificOutput: { hookEventName, decision: "block", reason: output.message } });
+      }
+      return JSON.stringify({ decision: "block", reason: output.message });
+    case "context": {
+      if (NESTED_DECISION_EVENTS.has(eventName)) return "{}";
+      if (eventName === "pre_compact" || eventName === "notification") return JSON.stringify({ systemMessage: output.context });
+      if (eventName === "pre_tool_use" && output.context.includes("data:image/")) return "{}";
+      return JSON.stringify({ hookSpecificOutput: { hookEventName, additionalContext: output.context } });
+    }
+    case "rewriteInput": {
+      const tool = vscodeToolName(event);
+      const updatedInput = tool === void 0 ? output.updatedInput : vscodeNativeToolInput(tool, output.updatedInput);
+      return JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", updatedInput } });
+    }
+    case "rewriteOutput":
+      return "{}";
+    case "pass":
+      return "{}";
+  }
+}
+
+// src/bridges/antigravity_hooks.ts
+init_define_import_meta_env();
+function antigravityToolName(event) {
+  const name = event?.raw[ANTIGRAVITY_TOOL_NAME_KEY];
+  return typeof name === "string" ? name : void 0;
+}
+function serializeAntigravityOutput(output, eventName, event) {
+  if (eventName === "pre_tool_use") {
+    switch (output.hookType) {
+      case "deny":
+        return JSON.stringify({ decision: "deny", reason: output.message });
+      case "context":
+        if (output.context.includes("data:image/")) return "{}";
+        return JSON.stringify({ reason: output.context });
+      case "rewriteInput": {
+        const tool = antigravityToolName(event);
+        const overwrite = tool === void 0 ? output.updatedInput : antigravityNativeToolInput(tool, output.updatedInput);
+        return JSON.stringify({ overwrite });
+      }
+      default:
+        return "{}";
+    }
+  }
+  if (eventName === "post_tool_use" && output.hookType === "rewriteOutput" && typeof event?.raw["result"] === "string") {
+    return JSON.stringify({ overwriteResult: output.updatedOutput });
+  }
+  return "{}";
+}
+
+// src/hook_registry.ts
+function sessionStateKey(event) {
+  return event.agentId !== void 0 ? `${event.sessionId}:agent:${event.agentId}` : event.sessionId;
+}
+var _handlers = /* @__PURE__ */ new Map();
+function registerHook(eventName, handler, opts) {
+  let list = _handlers.get(eventName);
+  if (list === void 0) {
+    list = [];
+    _handlers.set(eventName, list);
+  }
+  list.push({
+    handler,
+    toolName: opts?.toolName,
+    toolPattern: opts?.toolPattern,
+    advisory: opts?.advisory === true,
+    followsMatcher: opts?.followsMatcher === true
+  });
+}
+function toolMatcherFor(eventName) {
+  const list = _handlers.get(eventName);
+  if (list === void 0 || list.length === 0) return null;
+  const parts = [];
+  for (const { toolName, toolPattern, followsMatcher } of list) {
+    if (followsMatcher) continue;
+    if (toolName === void 0 && toolPattern === void 0) return null;
+    for (const part of [toolName === void 0 ? void 0 : `^${toolName}$`, toolPattern]) {
+      if (part !== void 0 && part !== "" && !parts.includes(part)) parts.push(part);
+    }
+  }
+  if (parts.length === 0) return null;
+  return parts.join("|");
+}
+function noteUnrecognizedTool(event, list) {
+  const toolName = event.toolName;
+  if (typeof toolName !== "string" || toolName === "") return;
+  const named = [];
+  for (const { toolName: want, toolPattern } of list) {
+    if (toolPattern !== void 0) {
+      let matches = false;
+      try {
+        matches = new RegExp(toolPattern).test(toolName);
+      } catch {
+      }
+      if (matches) return;
+    }
+    if (want === void 0) continue;
+    if (want === toolName) return;
+    named.push(want);
+  }
+  if (named.length === 0) return;
+  const folded = foldToolName(toolName);
+  const nearMiss = named.find((n) => foldToolName(n) === folded) ?? null;
+  recordUnmappedTool(toolName, event.eventName, nearMiss);
+}
+async function runHook(event) {
+  const list = _handlers.get(event.eventName);
+  if (list === void 0) return { hookType: "pass" };
+  noteUnrecognizedTool(event, list);
+  let advisoryResult;
+  let noticeResult;
+  for (const { handler, toolName, advisory } of list) {
+    if (toolName !== void 0 && toolName !== event.toolName) continue;
+    let result;
+    try {
+      result = await handler(event);
+    } catch {
+      continue;
+    }
+    if (result.hookType !== "pass") {
+      if (advisory) {
+        advisoryResult = result;
+        continue;
+      }
+      return result;
+    }
+    if (result.notice !== void 0) noticeResult ??= result;
+  }
+  return advisoryResult ?? noticeResult ?? { hookType: "pass" };
+}
+function clearHooks() {
+  _handlers.clear();
+}
+registerReset(clearHooks);
+var CLAUDE_CODE_EVENT_NAMES = {
+  pre_tool_use: "PreToolUse",
+  post_tool_use: "PostToolUse",
+  notification: "Notification",
+  stop: "Stop",
+  pre_compact: "PreCompact",
+  post_compact: "PostCompact",
+  user_prompt_submit: "UserPromptSubmit",
+  subagent_stop: "SubagentStop",
+  // Wired for Copilot CLI (`subagentStart`) and VS Code (`SubagentStart`) only; hooks_agent_spawn.ts's subagentStartHandler answers it with the spawn briefing as additionalContext, which both harnesses read.
+  subagent_start: "SubagentStart",
+  session_start: "SessionStart",
+  // Claude Code sends a failed tool call here rather than to PostToolUse, and its PostToolUseFailure output schema accepts hookSpecificOutput.additionalContext (captured and read from claude.exe 2.1.281); install.ts HOOK_EVENT_MAP registers it.
+  post_tool_use_failure: "PostToolUseFailure"
+};
+var EVENTS_WITHOUT_ADDITIONAL_CONTEXT = /* @__PURE__ */ new Set([
+  "notification",
+  "pre_compact"
+]);
+var EVENTS_WITH_RAW_STDOUT_CONTEXT = /* @__PURE__ */ new Set(["pre_compact"]);
+var BODY_FIRST_REWRITE_TOOLS = /* @__PURE__ */ new Set(["WebFetch", "Skill"]);
+function shapedUpdatedToolOutput(updatedOutput, harness, event) {
+  if (harness !== "claudecode") return updatedOutput;
+  const resp = event?.raw["tool_response"];
+  if (resp === null || resp === void 0 || typeof resp !== "object") return updatedOutput;
+  const keys = BODY_FIRST_REWRITE_TOOLS.has(event?.toolName ?? "") ? BODY_FIRST_TOOL_RESPONSE_KEYS : OUTPUT_FIRST_TOOL_RESPONSE_KEYS;
+  return replaceToolResponseField(resp, keys, updatedOutput) ?? updatedOutput;
+}
+function serializeOutput(output, eventName, harness, event) {
+  if (harness === "vscode") return serializeVscodeOutput(output, eventName, CLAUDE_CODE_EVENT_NAMES[eventName], event);
+  if (harness === "antigravity") return serializeAntigravityOutput(output, eventName, event);
+  switch (output.hookType) {
+    case "deny":
+      return JSON.stringify({ decision: "block", reason: output.message });
+    case "context":
+      if (EVENTS_WITH_RAW_STDOUT_CONTEXT.has(eventName) && harness === "claudecode") {
+        return output.context;
+      }
+      if (EVENTS_WITHOUT_ADDITIONAL_CONTEXT.has(eventName)) {
+        return JSON.stringify({ systemMessage: output.context });
+      }
+      return JSON.stringify({
+        ...noticeField(output.notice, harness),
+        hookSpecificOutput: {
+          hookEventName: CLAUDE_CODE_EVENT_NAMES[eventName],
+          additionalContext: output.context
+        }
+      });
+    case "rewriteInput":
+      return JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          permissionDecision: "allow",
+          updatedInput: output.updatedInput
+        }
+      });
+    case "rewriteOutput":
+      return JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "PostToolUse",
+          // A block array is emitted only when the handler built one, and only for Claude Code: every other harness token-goat bridges to reads this field as a plain string into a text block of its own, so handing it an array there is the same mistake in the other direction. See HookOutput's `updatedBlocks` for the capture that proves Claude Code takes the array.
+          updatedToolOutput: output.updatedBlocks !== void 0 && harness === "claudecode" ? output.updatedBlocks : shapedUpdatedToolOutput(output.updatedOutput, harness, event),
+          ...output.context !== void 0 ? { additionalContext: output.context } : {}
+        }
+      });
+    case "pass":
+      return JSON.stringify(noticeField(output.notice, harness));
+  }
+}
+function noticeField(notice, harness) {
+  return notice !== void 0 && harness === "claudecode" ? { systemMessage: notice } : {};
+}
+
+export {
+  materializeShrunkImageFile,
+  sessionStateKey,
+  registerHook,
+  toolMatcherFor,
+  runHook,
+  serializeOutput
+};

package/dist/token-goat-chunk-PD5VKH46.mjs

@@ -0,0 +1,184 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  DownloadCooldownError,
+  DownloadFailedError,
+  activeDownloadCooldown,
+  clearDownloadFailure,
+  describeCause,
+  isExplicitDownload,
+  recordDownloadFailure
+} from "./token-goat-chunk-SMVRN2HU.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-7IN2MKDS.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/pinned_fetch.ts
+init_define_import_meta_env();
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pipeline } from "node:stream/promises";
+var ATTEMPTS = 3;
+var retryDelayMs = 250;
+function setPinnedRetryDelayForTesting(ms) {
+  retryDelayMs = ms ?? 250;
+}
+var DETERMINISTIC_CODE = /^(?:ENOTFOUND|EAI_NONAME|ERR_INVALID_URL|ERR_TLS_|ERR_SSL_|CERT_|DEPTH_ZERO_SELF_SIGNED_CERT$|SELF_SIGNED_CERT_IN_CHAIN$|UNABLE_TO_)/;
+function causeCodes(e) {
+  const codes = [];
+  let cursor = e;
+  for (let depth = 0; cursor !== null && typeof cursor === "object" && depth < 5; depth++) {
+    const code = cursor.code;
+    if (typeof code === "string") codes.push(code);
+    cursor = cursor.cause;
+  }
+  return codes;
+}
+function transient(e) {
+  if (e instanceof TypeError) return !causeCodes(e).some((code) => DETERMINISTIC_CODE.test(code)) && !/ENOTFOUND/.test(describeCause(e));
+  return e instanceof Error && (e.name === "TimeoutError" || e.name === "AbortError");
+}
+var HostFailure = class extends Error {
+  retry;
+  constructor(message, retry, cause) {
+    super(message, cause === void 0 ? void 0 : { cause });
+    this.retry = retry;
+  }
+};
+function failure(url, message, cause, startedAt) {
+  let at = Date.now();
+  try {
+    at = recordDownloadFailure(url, message, at, startedAt).at;
+  } catch {
+  }
+  return new DownloadFailedError(message, url, at, cause);
+}
+function forgetFailure(url) {
+  try {
+    clearDownloadFailure(url);
+  } catch {
+  }
+}
+async function fetchOk(url) {
+  let response;
+  try {
+    response = await fetch(url, { redirect: "follow" });
+  } catch (e) {
+    throw new HostFailure(`GET ${url} failed: ${describeCause(e)}`, transient(e), e);
+  }
+  if (response.ok) return response;
+  await response.body?.cancel().catch(() => void 0);
+  throw new HostFailure(`GET ${url} returned ${response.status} ${response.statusText}`, response.status >= 500 || response.status === 429);
+}
+async function* bodyChunks(url, body, expected) {
+  let received = 0;
+  try {
+    for await (const chunk of body) {
+      received += chunk.byteLength;
+      yield chunk;
+    }
+  } catch (e) {
+    throw new HostFailure(`GET ${url} broke off after ${received} of ${expected} bytes: ${describeCause(e)}`, transient(e), e);
+  }
+}
+function sha256Of(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = createHash("sha256");
+    const stream = fs.createReadStream(filePath);
+    stream.on("error", reject);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+  });
+}
+async function copyFromSharedCache(shared, file, target) {
+  const source = path.join(shared, file.name);
+  const temp = `${target}.${process.pid}.shared`;
+  try {
+    const info = fs.lstatSync(source, { throwIfNoEntry: false });
+    if (!info?.isFile() || info.size !== file.bytes) return false;
+    fs.copyFileSync(source, temp);
+    if (await sha256Of(temp) !== file.sha256) {
+      fs.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
+      fs.rmSync(source, { force: true, maxRetries: 20, retryDelay: 25 });
+      return false;
+    }
+    fs.renameSync(temp, target);
+    return true;
+  } catch {
+    try {
+      fs.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
+    } catch {
+    }
+    return false;
+  }
+}
+async function downloadPinned(url, file, target) {
+  if (loadConfig().network.offline) throw new Error(`Offline mode is on (network.offline): refusing to download ${url}`);
+  if (!isExplicitDownload()) {
+    const cooldown = activeDownloadCooldown(url);
+    if (cooldown) throw new DownloadCooldownError(url, cooldown);
+  }
+  const startedAt = Date.now();
+  for (let attempt = 1; ; attempt++) {
+    try {
+      await fetchAndPlace(url, file, target);
+      forgetFailure(url);
+      return;
+    } catch (e) {
+      if (!(e instanceof HostFailure)) throw e;
+      if (attempt < ATTEMPTS && e.retry) {
+        await new Promise((resolve) => setTimeout(resolve, retryDelayMs * attempt));
+        continue;
+      }
+      throw failure(url, e.message, e.cause, startedAt);
+    }
+  }
+}
+async function fetchAndPlace(url, file, target) {
+  const response = await fetchOk(url);
+  const body = response.body;
+  if (!body) throw new Error(`GET ${url} returned no body`);
+  const temp = `${target}.${process.pid}.partial`;
+  const hash = createHash("sha256");
+  let written = 0;
+  const out = fs.createWriteStream(temp);
+  try {
+    await pipeline(async function* () {
+      for await (const chunk of bodyChunks(url, body, file.bytes)) {
+        written += chunk.byteLength;
+        if (written > file.bytes) throw new Error(`${file.name} is longer than the pinned ${file.bytes} bytes`);
+        hash.update(chunk);
+        yield chunk;
+      }
+    }, out);
+    if (written !== file.bytes) {
+      throw new Error(`${file.name} is ${written} bytes, expected the pinned ${file.bytes}`);
+    }
+    const digest = hash.digest("hex");
+    if (digest !== file.sha256) {
+      throw new Error(`${file.name} has sha256 ${digest}, expected the pinned ${file.sha256}`);
+    }
+    fs.renameSync(temp, target);
+  } catch (e) {
+    await new Promise((resolve) => {
+      if (out.closed) resolve();
+      else out.once("close", () => resolve());
+    });
+    try {
+      fs.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
+    } catch {
+    }
+    throw e;
+  }
+}
+
+export {
+  setPinnedRetryDelayForTesting,
+  sha256Of,
+  copyFromSharedCache,
+  downloadPinned
+};

package/dist/token-goat-chunk-PEPTHRFF.mjs

@@ -0,0 +1,129 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  DELIVERS_CONTENT_RE
+} from "./token-goat-chunk-MNWKPRAL.mjs";
+import {
+  splitShellSegments,
+  stripLeadingAssignments
+} from "./token-goat-chunk-APGZXSPS.mjs";
+import {
+  safeSlice
+} from "./token-goat-chunk-GOLEOXZP.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/tool_error_class.ts
+init_define_import_meta_env();
+var UNKNOWN_REASON = "unclassified";
+var DENIAL_KIND_REASONS = {
+  "permission-rule": "hook_deny",
+  // 73 in the census: the user declined an approval prompt.
+  "user-rejected": "user_rejected",
+  // 1 in the census; kept because it is an enumerated harness value, not a text guess.
+  "automode-blocked": "auto_mode_blocked"
+};
+var TG_DENY_RE = /\[tg\]|token-goat/;
+var CONTENT_DELIVERED_REASON = "tg_content_delivered";
+function tgDenyReason(text) {
+  return DELIVERS_CONTENT_RE.test(text) ? CONTENT_DELIVERED_REASON : "tg_deny";
+}
+var HOOK_DENY_TEXT_RE = /^PreToolUse:\S+ hook error: /;
+var TEST_OR_BUILD_COMMAND_RE = /^(?:npm\s+(?:test|run\s+(?:test|build|lint|typecheck))|npx\s+(?:vitest|tsc|eslint|jest|playwright)|vitest|jest|pytest|tsc|eslint|cargo\s+(?:test|build|check|clippy)|go\s+(?:test|build|vet)|make|gradle|mvn|dotnet\s+(?:test|build)|ruff|mypy|python3?\s+-m\s+(?:pytest|unittest))\b/;
+var SEARCH_COMMAND_RE = /^(?:grep|egrep|fgrep|rg|findstr)\b/;
+function runsCommand(command, head) {
+  return splitShellSegments(command).some((segment) => head.test(stripLeadingAssignments(segment)));
+}
+var EXPECTED_PATTERNS = [
+  // 176: the Bash tool's own timeout, reported as SIGTERM's 143 plus this line.
+  { reason: "command_timeout", tools: ["Bash"], re: /^Exit code \d+\s+Command timed out after / },
+  // 289: exit 1 with no output from a search command, which is how grep and rg report zero hits.
+  { reason: "search_no_match", tools: ["Bash"], re: /^Exit code 1\s*$/, command: SEARCH_COMMAND_RE },
+  // 252: a test, build, lint or typecheck run reporting failures, which is the tool doing its job.
+  { reason: "test_or_build_failed", tools: ["Bash"], re: /^Exit code \d+/, command: TEST_OR_BUILD_COMMAND_RE },
+  // 302: an unbalanced quote or bracket in the command itself.
+  { reason: "shell_syntax_error", tools: ["Bash"], re: /unexpected EOF while looking for matching|syntax error near unexpected token/ },
+  // 29: a binary missing from PATH.
+  { reason: "command_not_found", tools: ["Bash"], re: /command not found/ },
+  // 272: the harness refusing a bare or leading `sleep` and pointing at Monitor instead.
+  { reason: "sleep_blocked", tools: ["Bash"], re: /^Blocked: (?:sleep \d+ followed by|standalone sleep)/ },
+  // 114: old_string absent from the file.
+  { reason: "edit_string_not_found", tools: ["Edit", "MultiEdit"], re: /^String to replace not found in file/ },
+  // 37: old_string present more than once with replace_all false.
+  { reason: "edit_multiple_matches", tools: ["Edit", "MultiEdit"], re: /^Found \d+ matches of the string to replace/ },
+  // 37: the harness's read-before-write guard.
+  { reason: "file_not_read_yet", tools: ["Edit", "MultiEdit", "Write"], re: /^File has not been read yet/ },
+  // 16: the file changed on disk after the last read.
+  { reason: "file_modified_since_read", tools: ["Edit", "MultiEdit", "Write"], re: /^File has been modified since read/ },
+  // 643 (578 Bash, 53 Read, 11 Grep, 1 Edit): a path that does not exist, in each tool's own wording.
+  { reason: "path_not_found", re: /No such file or directory|^File does not exist\.|^Path does not exist:/ },
+  // 1,171: an interpreter raising: a Python traceback header, the `Node.js vN.N.N` line Node prints under every uncaught error, or a named error line (`SyntaxError: ...`). After path_not_found, so a missing file stays a missing file whichever language reported it.
+  { reason: "script_exception", tools: ["Bash"], re: /^(?:Traceback \(most recent call last\):|Node\.js v\d+\.\d+\.\d+\b|[A-Z]\w*(?:Error|Exception)(?: \[\w+\])?: )/m },
+  // 14: a Read over the harness's size ceiling.
+  { reason: "file_too_large", tools: ["Read"], re: /^File content \([^)]*\) exceeds maximum allowed/ },
+  // 85: arguments the tool's schema rejected before it ran.
+  { reason: "input_validation", re: /^InputValidationError/ },
+  // 68: a StructuredOutput call that did not match the requested schema.
+  { reason: "schema_mismatch", tools: ["StructuredOutput"], re: /^Output does not match required schema/ },
+  // 35: the harness's concurrent-subagent ceiling.
+  { reason: "subagent_limit", tools: ["Agent", "Task"], re: /^Concurrent subagent limit reached/ },
+  // 37: a tool disabled for this session or a misspelled tool name.
+  { reason: "tool_unavailable", re: /^Error: No such tool available/ }
+];
+var EXPECTED_REASONS = [
+  "interrupted",
+  "tg_deny",
+  CONTENT_DELIVERED_REASON,
+  ...new Set(Object.values(DENIAL_KIND_REASONS)),
+  ...EXPECTED_PATTERNS.map((p) => p.reason)
+];
+var TOOL_USE_ERROR_OPEN = "<tool_use_error>";
+var TOOL_USE_ERROR_CLOSE = "</tool_use_error>";
+function unwrapToolError(errorText) {
+  let text = errorText.trim();
+  if (text.startsWith(TOOL_USE_ERROR_OPEN)) text = text.slice(TOOL_USE_ERROR_OPEN.length);
+  if (text.endsWith(TOOL_USE_ERROR_CLOSE)) text = text.slice(0, text.length - TOOL_USE_ERROR_CLOSE.length);
+  return text.trim();
+}
+function expected(reason) {
+  return { kind: "expected", reason };
+}
+function classifyToolError(tool, errorText, flags = {}) {
+  if (flags.isInterrupt === true) return expected("interrupted");
+  const text = unwrapToolError(errorText);
+  const denial = flags.denialKind;
+  if (denial !== void 0 && denial !== "") {
+    const reason = DENIAL_KIND_REASONS[denial] ?? "hook_deny";
+    return expected(reason === "hook_deny" && TG_DENY_RE.test(text) ? tgDenyReason(text) : reason);
+  }
+  if (HOOK_DENY_TEXT_RE.test(text)) return expected(TG_DENY_RE.test(text) ? tgDenyReason(text) : "hook_deny");
+  for (const p of EXPECTED_PATTERNS) {
+    if (p.tools !== void 0 && (tool === void 0 || !p.tools.includes(tool))) continue;
+    if (!p.re.test(text)) continue;
+    if (p.command !== void 0 && (flags.command === void 0 || !runsCommand(flags.command, p.command))) continue;
+    return expected(p.reason);
+  }
+  return { kind: "unknown", reason: UNKNOWN_REASON };
+}
+var ERROR_PREFIX_CHARS = 60;
+var EXIT_CODE_HEADER_RE = /^Exit code (\d+)\s*/;
+function errorPrefix(errorText) {
+  let text = unwrapToolError(errorText);
+  let lead = "";
+  const exit = EXIT_CODE_HEADER_RE.exec(text);
+  if (exit !== null) {
+    lead = `exit ${exit[1] ?? ""}: `;
+    text = text.slice(exit[0].length);
+  }
+  const line = text.split("\n").find((l) => l.trim() !== "") ?? "";
+  const masked = line.trim().replace(/\b[A-Za-z]:[\\/]\S*|~?\/[\w.~-]+(?:\/[\w.~-]*)+/g, "<path>").replace(/'[^'\n]*'|"[^"\n]*"|`[^`\n]*`/g, "<q>").replace(/\d+/g, "N");
+  return safeSlice(`${lead}${masked === "" ? "(empty)" : masked}`, ERROR_PREFIX_CHARS);
+}
+
+export {
+  CONTENT_DELIVERED_REASON,
+  SEARCH_COMMAND_RE,
+  classifyToolError,
+  errorPrefix
+};