token-goat 2.9.29 → 2.9.31

package/dist/token-goat-chunk-65N4RHP4.mjs

@@ -0,0 +1,33 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/windows_powershell.ts
+init_define_import_meta_env();
+
+// src/windows_system32.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as path from "node:path";
+var DEFAULT_WINDOWS_DIR = "C:\\Windows";
+function windowsSystem32Exe(...rel) {
+  const missing = path.join(DEFAULT_WINDOWS_DIR, "System32", ...rel);
+  for (const root of [process.env["SystemRoot"], process.env["windir"], DEFAULT_WINDOWS_DIR]) {
+    if (root === void 0 || !path.win32.isAbsolute(root)) continue;
+    const exe = path.join(root, "System32", ...rel);
+    if (fs.existsSync(exe)) return exe;
+  }
+  return missing;
+}
+
+// src/windows_powershell.ts
+function windowsPowerShellPath() {
+  return windowsSystem32Exe("WindowsPowerShell", "v1.0", "powershell.exe");
+}
+
+export {
+  windowsSystem32Exe,
+  windowsPowerShellPath
+};

package/dist/{token-goat-chunk-6AK46ZT7.mjs → token-goat-chunk-6DG6HWP3.mjs}

@@ -3,6 +3,12 @@ const require = __cjsRequire(import.meta.url);
 import {
   external_exports
 } from "./token-goat-chunk-3U6ZYVX5.mjs";
+import {
+  answeringMcpToolCall
+} from "./token-goat-chunk-KGEFFSHD.mjs";
+import {
+  displaySafeText
+} from "./token-goat-chunk-FNFBKLRD.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -91,6 +97,10 @@ var McpServer = class {
     }
   }
   async handleMessage(message) {
+    if (message === null || typeof message !== "object" || Array.isArray(message)) {
+      await this.sendError(void 0, JSONRPC_INVALID_REQUEST, "Invalid Request: a JSON-RPC message must be a JSON object");
+      return;
+    }
     if (!isRequest(message)) return;
     const { id, method } = message;
     const params = message.params ?? {};
@@ -109,7 +119,7 @@ var McpServer = class {
           await this.send({ jsonrpc: "2.0", id, result: await this.callTool(params) });
           return;
         default:
-          await this.sendError(id, JSONRPC_METHOD_NOT_FOUND, `Method not found: ${method}`);
+          await this.sendError(id, JSONRPC_METHOD_NOT_FOUND, `Method not found: ${displaySafeText(method)}`);
           return;
       }
     } catch (err) {
@@ -117,7 +127,7 @@ var McpServer = class {
     }
   }
   async sendError(id, code, message) {
-    await this.send({ jsonrpc: "2.0", id, error: { code, message } });
+    await this.send(id === void 0 ? { jsonrpc: "2.0", error: { code, message } } : { jsonrpc: "2.0", id, error: { code, message } });
   }
   initializeResult(params) {
     const requested = params["protocolVersion"];
@@ -153,7 +163,7 @@ var McpServer = class {
       );
     }
     try {
-      return await handler(parsed.data);
+      return await answeringMcpToolCall(() => handler(parsed.data), new Set(this.tools.keys()));
     } catch (err) {
       return errorText(err instanceof Error ? err.message : String(err));
     }

package/dist/token-goat-chunk-6ENQSNRZ.mjs

@@ -0,0 +1,573 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  diagnoseSqlFailure
+} from "./token-goat-chunk-PX5PQWTY.mjs";
+import {
+  SEARCH_COMMAND_RE,
+  classifyToolError
+} from "./token-goat-chunk-JVFSHVFJ.mjs";
+import {
+  PIPELINE_PASSTHROUGH_HEADS,
+  extractCommand,
+  pureFileReadPath,
+  stripCommandPrefix,
+  unwrapCompressCommand
+} from "./token-goat-chunk-ODBT2USM.mjs";
+import {
+  splitShellSegments,
+  stripLeadingAssignments
+} from "./token-goat-chunk-DGS2LVNA.mjs";
+import {
+  applyHintTracking,
+  settleSelfScoredHints,
+  uncorrelatedHint
+} from "./token-goat-chunk-4SMRO4TO.mjs";
+import {
+  sessionSidecarPath
+} from "./token-goat-chunk-WBA5SKT4.mjs";
+import {
+  registerHook,
+  sessionStateKey
+} from "./token-goat-chunk-C75NA7PL.mjs";
+import {
+  OUTPUT_FIRST_TOOL_RESPONSE_KEYS,
+  contextOutput,
+  estimateResultCount,
+  extractToolResponseField,
+  getFilePath,
+  getToolInput,
+  getToolName,
+  passOutput,
+  resolveEventPath,
+  structuredResultCount
+} from "./token-goat-chunk-76FGDLRO.mjs";
+import {
+  recordStat
+} from "./token-goat-chunk-U4WHMG6Y.mjs";
+import {
+  buildLineIndex,
+  offsetToLine
+} from "./token-goat-chunk-OUKDTVNU.mjs";
+import {
+  redactSecrets
+} from "./token-goat-chunk-T5P5ACNQ.mjs";
+import {
+  ensureDirSync
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  displaySafeText,
+  hostPathOfIndexKey,
+  normalizePath
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/hooks_tool_failure.ts
+init_define_import_meta_env();
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync as readFileSync2, statSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, relative } from "node:path";
+
+// src/call_streak.ts
+init_define_import_meta_env();
+import { readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+var SERIAL_GAP_MS = 1e3;
+var SERIAL_READS_BEFORE_HINT = 3;
+var ZERO_HIT_SEARCHES_BEFORE_BRAKE = 3;
+var MAX_BATCH_HINTS_PER_SESSION = 2;
+var MAX_SEARCH_BRAKES_PER_SESSION = 2;
+var STREAK_SUFFIX = ".call-streak";
+var TG_SEARCH_RE = /^(?:token-goat|tg)\s+(?:answer|semantic|symbol|refs|locate)\b/;
+var TG_MEANING_SEARCH_RE = /^(?:token-goat|tg)\s+(?:answer|semantic)\b/;
+var TG_READ_RE = /^(?:token-goat|tg)\s+(?:read|section|outline|skeleton|brief)\b/;
+var WRITE_REDIRECT_RE = /\d?>>?(?!\s*(?:&\d|\/dev\/null\b))/;
+function freshState() {
+  return { promptId: "", lastReadPostAt: 0, inFlight: false, serialRun: 0, batchShownInRun: false, batchShown: 0, batchVerdict: "none", zeroHits: 0, brakeShownInRun: false, brakeShown: 0, brakeVerdict: false };
+}
+function readState(target) {
+  const state = freshState();
+  try {
+    const parsed = JSON.parse(readFileSync(target, "utf8"));
+    if (parsed === null || typeof parsed !== "object") return state;
+    const p = parsed;
+    for (const key of Object.keys(state)) {
+      if (typeof p[key] === typeof state[key]) state[key] = p[key];
+    }
+    if (!["none", "next_turn", "second_call"].includes(state.batchVerdict)) state.batchVerdict = "none";
+  } catch {
+  }
+  return state;
+}
+function writeState(target, state) {
+  try {
+    ensureDirSync(dirname(target));
+    writeFileSync(target, JSON.stringify(state), "utf8");
+  } catch {
+  }
+}
+var MUTATING = { readOnly: false, search: false, meaningSearch: false };
+function isPassThroughStage(stage) {
+  const head = (stage.split(/\s/, 1)[0] ?? "").replace(/^.*[/\\]/, "");
+  return head !== "tee" && PIPELINE_PASSTHROUGH_HEADS.has(head);
+}
+function bashCallKind(event) {
+  const raw = extractCommand(event);
+  if (raw === void 0) return MUTATING;
+  const cmd = stripCommandPrefix(unwrapCompressCommand(raw) ?? raw);
+  const stages = splitShellSegments(cmd).map((s) => stripLeadingAssignments(s.trim())).filter((s) => s !== "");
+  if (stages.length === 0 || stages.some((s) => WRITE_REDIRECT_RE.test(s))) return MUTATING;
+  const searches = stages.filter((s) => SEARCH_COMMAND_RE.test(s) || TG_SEARCH_RE.test(s));
+  const readOnly = pureFileReadPath(cmd) !== null || stages.every((s) => SEARCH_COMMAND_RE.test(s) || TG_SEARCH_RE.test(s) || TG_READ_RE.test(s) || isPassThroughStage(s));
+  if (!readOnly) return MUTATING;
+  return { readOnly, search: searches.length > 0, meaningSearch: TG_MEANING_SEARCH_RE.test(stages[0] ?? "") };
+}
+function callKind(event) {
+  switch (event.toolName) {
+    case "Read":
+      return { readOnly: true, search: false, meaningSearch: false };
+    case "Grep":
+    case "Glob":
+      return { readOnly: true, search: true, meaningSearch: false };
+    case "Bash":
+      return bashCallKind(event);
+    default:
+      return MUTATING;
+  }
+}
+function searchResultCount(event) {
+  const structured = structuredResultCount(event.raw);
+  if (structured !== null) return structured;
+  const text = extractToolResponseField(event.raw, OUTPUT_FIRST_TOOL_RESPONSE_KEYS);
+  if (event.toolName === "Bash") return text.trim() === "" ? 0 : 1;
+  return text === "" ? null : estimateResultCount(text);
+}
+function batchHintText(run) {
+  return `[token-goat] ${run} reads/searches in a row each waited a full turn. Issue independent reads and searches together in one message.`;
+}
+function searchBrakeText(misses) {
+  return `[token-goat] ${misses} searches in a row found nothing. Search by meaning instead of guessing literals: \`token-goat answer "<question>"\` or \`token-goat semantic "<description>"\`.`;
+}
+function trackedLine(event, category, text) {
+  const out = applyHintTracking(event, contextOutput(text, [sessionStateKey(event)]), uncorrelatedHint(category));
+  if (out.hookType !== "context") return null;
+  recordStat("session_hint", 0, 0);
+  return out.context;
+}
+function breakStreaks(event, state) {
+  if (state.batchVerdict === "second_call") {
+    settleSelfScoredHints("read_batch", event, false);
+    state.batchVerdict = "none";
+  }
+  Object.assign(state, { lastReadPostAt: 0, inFlight: false, serialRun: 0, batchShownInRun: false, zeroHits: 0, brakeShownInRun: false });
+}
+function onReadOnlyPre(event, state, kind, now, canSpeak) {
+  const serial = !state.inFlight && (state.lastReadPostAt === 0 || now - state.lastReadPostAt > SERIAL_GAP_MS);
+  state.inFlight = true;
+  if (state.batchVerdict === "second_call") {
+    settleSelfScoredHints("read_batch", event, !serial);
+    state.batchVerdict = "none";
+  } else if (state.batchVerdict === "next_turn" && serial) {
+    state.batchVerdict = "second_call";
+  }
+  if (state.brakeVerdict && kind.search && serial) {
+    settleSelfScoredHints("search_brake", event, kind.meaningSearch);
+    state.brakeVerdict = false;
+  }
+  if (!serial) {
+    state.serialRun = 0;
+    state.batchShownInRun = false;
+    return null;
+  }
+  state.serialRun += 1;
+  if (state.serialRun < SERIAL_READS_BEFORE_HINT || state.batchShownInRun || state.batchShown >= MAX_BATCH_HINTS_PER_SESSION || !canSpeak) return null;
+  state.batchShownInRun = true;
+  const line = trackedLine(event, "read_batch", batchHintText(state.serialRun));
+  if (line === null) return null;
+  state.batchShown += 1;
+  state.batchVerdict = "next_turn";
+  return line;
+}
+function onSearchMiss(event, state, canSpeak) {
+  state.zeroHits += 1;
+  if (state.zeroHits < ZERO_HIT_SEARCHES_BEFORE_BRAKE || state.brakeShownInRun || state.brakeShown >= MAX_SEARCH_BRAKES_PER_SESSION || !canSpeak) return null;
+  state.brakeShownInRun = true;
+  const line = trackedLine(event, "search_brake", searchBrakeText(state.zeroHits));
+  if (line === null) return null;
+  state.brakeShown += 1;
+  state.brakeVerdict = true;
+  return line;
+}
+function onReadOnlyPost(event, state, kind, now, canSpeak) {
+  state.inFlight = false;
+  state.lastReadPostAt = now;
+  if (!kind.search) return null;
+  const count = searchResultCount(event);
+  if (count === null) return null;
+  if (count === 0) return onSearchMiss(event, state, canSpeak);
+  state.zeroHits = 0;
+  state.brakeShownInRun = false;
+  return null;
+}
+function withStreakState(event, update) {
+  if (!event.sessionId) return null;
+  const target = sessionSidecarPath(sessionStateKey(event), STREAK_SUFFIX);
+  if (target === null) return null;
+  const state = readState(target);
+  const before = JSON.stringify(state);
+  const promptId = event.raw["prompt_id"];
+  if (typeof promptId === "string" && promptId !== state.promptId) {
+    breakStreaks(event, state);
+    if (state.batchVerdict !== "none") settleSelfScoredHints("read_batch", event, null);
+    if (state.brakeVerdict) settleSelfScoredHints("search_brake", event, null);
+    state.batchVerdict = "none";
+    state.brakeVerdict = false;
+    state.promptId = promptId;
+  }
+  const line = update(state);
+  if (JSON.stringify(state) !== before) writeState(target, state);
+  return line;
+}
+function applyCallStreak(event, output, now) {
+  if (event.eventName !== "pre_tool_use" && event.eventName !== "post_tool_use") return output;
+  if (output.hookType === "deny") return output;
+  try {
+    const canSpeak = output.hookType === "pass" || output.hookType === "context";
+    const kind = callKind(event);
+    const line = withStreakState(event, (state) => {
+      if (!kind.readOnly) {
+        breakStreaks(event, state);
+        return null;
+      }
+      return event.eventName === "pre_tool_use" ? onReadOnlyPre(event, state, kind, now, canSpeak) : onReadOnlyPost(event, state, kind, now, canSpeak);
+    });
+    if (line === null) return output;
+    return output.hookType === "context" ? { ...output, context: `${output.context}
+${line}` } : contextOutput(line);
+  } catch {
+    return output;
+  }
+}
+function callStreakAfterFailure(event, reason) {
+  try {
+    const kind = callKind(event);
+    const line = withStreakState(event, (state) => {
+      if (!kind.readOnly) {
+        breakStreaks(event, state);
+        return null;
+      }
+      state.inFlight = false;
+      state.lastReadPostAt = Date.now();
+      return reason === "search_no_match" ? onSearchMiss(event, state, true) : null;
+    });
+    return line === null ? null : contextOutput(line);
+  } catch {
+    return null;
+  }
+}
+
+// src/hooks_verification.ts
+init_define_import_meta_env();
+var VERIFICATION_WORD = /test|jest|lint|check|build|compile|verify|tsc|ruff|clippy|mypy|pyright|\bvet\b/i;
+function mayBeVerificationCommand(command) {
+  return VERIFICATION_WORD.test(command);
+}
+registerHook("stop", async (event) => (await import("./token-goat-chunk-OS5EM5PP.mjs")).stopHandler(event), { advisory: true });
+async function noteFailedVerificationHandler(event) {
+  const executed = getToolInput(event)["command"];
+  const command = typeof executed === "string" ? unwrapCompressCommand(executed) ?? executed : null;
+  if (getToolName(event)?.toLowerCase() === "bash" && command !== null && mayBeVerificationCommand(command)) {
+    const [failure, verification] = await Promise.all([import("./token-goat-chunk-XZSUHBVS.mjs"), import("./token-goat-chunk-QFNQXSDT.mjs")]);
+    const errorText = failure.extractFailureText(event.raw);
+    if (errorText !== "") verification.noteFailedVerificationRun(command, errorText, event.raw["is_interrupt"] === true);
+  }
+  return passOutput();
+}
+
+// src/hooks_tool_failure.ts
+var FAILURE_SUFFIX = ".tool-failures";
+var MAX_TRACKED_FAILURES = 64;
+var SIGNATURE_ERROR_CHARS = 200;
+var LEDGER_VERSION = 2;
+function failureSignature(toolName, errorText) {
+  const tool = toolName === void 0 || toolName === "" ? "unknown" : toolName;
+  const normalized = errorText.replace(/\s+/g, " ").trim().slice(0, SIGNATURE_ERROR_CHARS);
+  return `${tool} :: ${normalized}`;
+}
+function extractFailureText(raw) {
+  for (const key of ["error", "errorMessage", "tool_error", "toolError", "message", "reason"]) {
+    const value = raw[key];
+    if (typeof value === "string" && value.trim() !== "") return value;
+  }
+  const response = raw["tool_response"] ?? raw["toolResponse"];
+  if (typeof response === "string" && response.trim() !== "") return response;
+  if (response !== null && typeof response === "object") {
+    const nested = response["error"];
+    if (typeof nested === "string" && nested.trim() !== "") return nested;
+  }
+  return "";
+}
+function ledgerPath(sessionId) {
+  return sessionSidecarPath(sessionId, FAILURE_SUFFIX);
+}
+function readLedger(target) {
+  try {
+    const parsed = JSON.parse(readFileSync2(target, "utf8"));
+    if (parsed !== null && typeof parsed === "object") {
+      if (parsed.version !== LEDGER_VERSION) return { seen: {}, order: [] };
+      const seen = parsed.seen;
+      const order = parsed.order;
+      if (seen !== null && typeof seen === "object" && Array.isArray(order)) {
+        return { seen, order: order.filter((k) => typeof k === "string") };
+      }
+    }
+  } catch {
+  }
+  return { seen: {}, order: [] };
+}
+function writeLedger(target, ledger) {
+  try {
+    ensureDirSync(dirname2(target));
+    writeFileSync2(target, JSON.stringify({ version: LEDGER_VERSION, ...ledger }), "utf8");
+  } catch {
+  }
+}
+var REPEAT_NOTICE_EXEMPT = /* @__PURE__ */ new Set([
+  // Refusals and stops. Claude Code never delivers a refused call to this event (a PreToolUse deny fired no PostToolUseFailure in a 2.1.281 capture), so these guard the other harnesses that route failures here.
+  "interrupted",
+  // the payload's is_interrupt flag; the census has 0 rows because an interrupt never surfaces as an is_error result
+  "tg_deny",
+  // 2,762 rows, 283 repeats, 13 with the same input: the deny names the command to run instead
+  "tg_content_delivered",
+  // a deny whose text is the content (a Skill's compact slice or heading tree, a served Read sidecar): the call did its job, so there is nothing to retry
+  "hook_deny",
+  // 5 rows: another hook's refusal, with its own instruction
+  "user_rejected",
+  // 73 rows, 21 repeats, 1 with the same input
+  "auto_mode_blocked",
+  // 1 row
+  // Generic wording: a repeat was a different call that failed the same way.
+  "search_no_match",
+  // 99 repeats, 0 with the same input: every empty grep prints the same bare `Exit code 1`
+  "command_timeout",
+  // 41 repeats, 0 with the same input
+  "subagent_limit",
+  // 27 repeats, 1 with the same input; the harness's own text already says not to retry
+  "input_validation"
+  // 23 repeats, 0 with the same input
+]);
+function repeatFailureNotice(toolName) {
+  const tool = toolName === void 0 || toolName === "" ? "This tool" : displaySafeText(toolName);
+  return `[token-goat] ${tool} just failed with the same error as an earlier call this session. Retrying it unchanged will fail the same way -- change the arguments, the tool, or the approach.`;
+}
+var nearMissLib;
+async function loadNearMiss() {
+  try {
+    nearMissLib ??= await import("./token-goat-chunk-5IMLKSOP.mjs");
+  } catch {
+  }
+}
+var MAX_EDIT_DIAGNOSE_BYTES = 10 * 1024 * 1024;
+function editOldStrings(event) {
+  const input = event.toolInput;
+  const out = [];
+  for (const key of ["old_string", "old_str", "target", "TargetContent"]) {
+    const value = input[key];
+    if (typeof value === "string" && value !== "") {
+      out.push(value);
+      break;
+    }
+  }
+  const edits = input["edits"];
+  if (Array.isArray(edits)) {
+    for (const entry of edits) {
+      const value = entry !== null && typeof entry === "object" ? entry["old_string"] : void 0;
+      if (typeof value === "string" && value !== "") out.push(value);
+    }
+  }
+  return out;
+}
+function diagnoseEditFailure(event, errorText) {
+  const toolName = getToolName(event);
+  if (!toolName || !/^(edit|multiedit|str_replace_editor)$/i.test(toolName)) {
+    return null;
+  }
+  const isMultiple = /multiple matches|not unique|found \d+ matches|matches \d+ times|more than one match/i.test(errorText);
+  const isNotFound = /no match|not found|could not find|zero matches|string to replace.*not found/i.test(errorText);
+  if (!isMultiple && !isNotFound) {
+    return null;
+  }
+  const fallbackPath = ["path", "TargetFile"].map((key) => event.toolInput[key]).find((value) => typeof value === "string" && value !== "");
+  const filePath = getFilePath(event) ?? (fallbackPath === void 0 ? void 0 : resolveEventPath(event, fallbackPath));
+  if (!filePath) return null;
+  const oldStrings = editOldStrings(event);
+  if (oldStrings.length === 0) return null;
+  const absPath = hostPathOfIndexKey(normalizePath(filePath));
+  if (!existsSync(absPath)) return null;
+  try {
+    const stat = statSync(absPath);
+    if (stat.size > MAX_EDIT_DIAGNOSE_BYTES) return null;
+    const fileContent = readFileSync2(absPath, "utf8");
+    const oldString = oldStrings.length === 1 ? oldStrings[0] : oldStrings.find((candidate) => isNotFound ? !fileContent.includes(candidate) : fileContent.indexOf(candidate) !== fileContent.lastIndexOf(candidate));
+    if (oldString === void 0) return null;
+    const relDisplay = displaySafeText(relative(process.cwd(), absPath).replace(/\\/g, "/") || absPath);
+    if (isMultiple) {
+      const matchLines = [];
+      const lineIndex = buildLineIndex(fileContent);
+      let pos = 0;
+      while (pos < fileContent.length) {
+        const idx = fileContent.indexOf(oldString, pos);
+        if (idx === -1) break;
+        matchLines.push(offsetToLine(lineIndex, idx));
+        pos = idx + Math.max(1, oldString.length);
+      }
+      if (matchLines.length > 1) {
+        const lineList = matchLines.slice(0, 5).join(", ");
+        const overflow = matchLines.length > 5 ? ` (+${matchLines.length - 5} more)` : "";
+        return `[token-goat] Edit failed: string matched ${matchLines.length} times in ${relDisplay} on lines ${lineList}${overflow}. Include 2-3 lines of surrounding context to make old_str unique.`;
+      }
+    }
+    if (isNotFound) {
+      const normOld = oldString.replace(/\r\n/g, "\n");
+      const normFile = fileContent.replace(/\r\n/g, "\n");
+      if (normFile.includes(normOld)) {
+        return `[token-goat] Edit failed: string not found in ${relDisplay}, but matches with normalized line endings. Check CRLF vs LF line endings or whitespace.`;
+      }
+      const nearMiss = nearMissLib?.findNearMiss(fileContent, oldString) ?? null;
+      const nearAdvice = nearMiss === null ? null : nearMissLib?.describeNearMiss(fileContent, relDisplay, nearMiss) ?? null;
+      if (nearAdvice !== null) return nearAdvice;
+      const firstLine = oldString.split(/\r?\n/)[0]?.trim() ?? "";
+      if (firstLine.length >= 10) {
+        const fileLines = fileContent.split("\n");
+        const similarLines = [];
+        for (let i = 0; i < fileLines.length; i++) {
+          const lineText = fileLines[i];
+          if (lineText !== void 0 && lineText.includes(firstLine)) {
+            similarLines.push(i + 1);
+            if (similarLines.length >= 3) break;
+          }
+        }
+        if (similarLines.length > 0) {
+          return `[token-goat] Edit failed: string not found in ${relDisplay}. A similar line was found on line ${similarLines.join(", ")} \u2014 view that range to copy exact text.`;
+        }
+      }
+      return `[token-goat] Edit failed: string not found in ${relDisplay}. View the target lines to copy the exact current content and indentation.`;
+    }
+  } catch {
+  }
+  return null;
+}
+function editAdviceOutput(event, text) {
+  const out = contextOutput(text);
+  return nearMissLib?.isNearMissAdvice(text) === true ? applyHintTracking(event, out, uncorrelatedHint("edit_near_miss")) : out;
+}
+var RECOVERY_SKIPPED = /* @__PURE__ */ new Set(["shell_syntax_error", "sleep_blocked"]);
+function newSlot() {
+  return { lines: [], recovery: null, pathMiss: null };
+}
+function withExtraLines(base, lines) {
+  if (lines.length === 0) return base;
+  const extra = lines.join("\n");
+  if (base.hookType === "context") return contextOutput([base.context, extra].join("\n"), base.correlators);
+  return base.hookType === "pass" ? contextOutput(extra) : base;
+}
+function postToolUseFailureHandler(event) {
+  return adviseOnFailure(event, newSlot());
+}
+async function postToolUseFailureWithExtras(event) {
+  const slot = newSlot();
+  const toolName = getToolName(event);
+  if (toolName !== void 0 && /^(edit|multiedit|str_replace_editor)$/i.test(toolName)) await loadNearMiss();
+  const base = adviseOnFailure(event, slot);
+  try {
+    if (slot.recovery !== null) {
+      const { recoveryAfterFailure } = await import("./token-goat-chunk-FDSREWLX.mjs");
+      const recovery = recoveryAfterFailure(event, { command: slot.recovery.command, errorText: slot.recovery.errorText });
+      if (recovery !== null) slot.lines.push(recovery);
+    }
+    if (slot.pathMiss !== null) {
+      const { pathMissAfterFailure } = await import("./token-goat-chunk-3EZRNKTK.mjs");
+      const pathMiss = pathMissAfterFailure(event, slot.pathMiss);
+      if (pathMiss !== null) slot.lines.push(pathMiss);
+    }
+  } catch {
+  }
+  return withExtraLines(base, slot.lines);
+}
+function adviseOnFailure(event, slot) {
+  try {
+    const errorText = extractFailureText(event.raw);
+    if (errorText === "") return passOutput();
+    const toolName = getToolName(event);
+    const executed = getToolInput(event)["command"];
+    const command = typeof executed === "string" ? unwrapCompressCommand(executed) ?? executed : executed;
+    const verdict = classifyToolError(toolName, errorText, { isInterrupt: event.raw["is_interrupt"] === true, ...typeof command === "string" ? { command } : {} });
+    recordStat("tool_failure", 0, 0, void 0, `tool=${(toolName ?? "unknown").replace(/\s+/g, "_")} class=${verdict.kind} reason=${verdict.reason}`);
+    const streakLine = callStreakAfterFailure(event, verdict.reason);
+    if (toolName === "Bash" && typeof command === "string" && event.raw["is_interrupt"] !== true && !REPEAT_NOTICE_EXEMPT.has(verdict.reason) && !RECOVERY_SKIPPED.has(verdict.reason)) {
+      slot.recovery = { toolName, errorText, command };
+    }
+    if (verdict.reason === "path_not_found" && event.raw["is_interrupt"] !== true) {
+      slot.pathMiss = { toolName, errorText };
+    }
+    if (REPEAT_NOTICE_EXEMPT.has(verdict.reason)) return streakLine ?? passOutput();
+    if (!event.sessionId) return passOutput();
+    const target = ledgerPath(event.sessionId);
+    if (target === null) return passOutput();
+    const signature = createHash("sha256").update(failureSignature(toolName, redactSecrets(errorText).text)).digest("hex");
+    const ledger = readLedger(target);
+    const priorState = ledger.seen[signature];
+    const editDiagnostic = diagnoseEditFailure(event, errorText);
+    const sqlDiagnostic = diagnoseSqlFailure(event, errorText);
+    if (priorState === void 0) {
+      ledger.seen[signature] = false;
+      ledger.order.push(signature);
+      while (ledger.order.length > MAX_TRACKED_FAILURES) {
+        const evicted = ledger.order.shift();
+        if (evicted !== void 0) delete ledger.seen[evicted];
+      }
+      writeLedger(target, ledger);
+      if (editDiagnostic !== null) {
+        ledger.seen[signature] = true;
+        writeLedger(target, ledger);
+        return editAdviceOutput(event, editDiagnostic);
+      }
+      if (sqlDiagnostic !== null) {
+        ledger.seen[signature] = true;
+        writeLedger(target, ledger);
+        return contextOutput(sqlDiagnostic);
+      }
+      return passOutput();
+    }
+    if (priorState) return passOutput();
+    ledger.seen[signature] = true;
+    writeLedger(target, ledger);
+    if (editDiagnostic !== null) {
+      return editAdviceOutput(event, editDiagnostic);
+    }
+    if (sqlDiagnostic !== null) {
+      return contextOutput(sqlDiagnostic);
+    }
+    return contextOutput(repeatFailureNotice(toolName));
+  } catch {
+    return passOutput();
+  }
+}
+registerHook("post_tool_use_failure", noteFailedVerificationHandler, { advisory: true });
+registerHook("post_tool_use_failure", postToolUseFailureWithExtras);
+
+export {
+  applyCallStreak,
+  MAX_TRACKED_FAILURES,
+  failureSignature,
+  extractFailureText,
+  REPEAT_NOTICE_EXEMPT,
+  repeatFailureNotice,
+  loadNearMiss,
+  diagnoseEditFailure,
+  postToolUseFailureHandler,
+  postToolUseFailureWithExtras,
+  mayBeVerificationCommand
+};