token-goat 2.9.29 → 2.9.31

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

@@ -0,0 +1,3957 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  findVerifiedFileEvidence,
+  readEvidenceFileText
+} from "./token-goat-chunk-NOSS5VWY.mjs";
+import {
+  getContextPressure,
+  loadSessionCache,
+  readAllSessionManifests
+} from "./token-goat-chunk-NMD42SFQ.mjs";
+import {
+  contentHash,
+  getCompactAnySessionSync,
+  isCompactStale
+} from "./token-goat-chunk-SAMFDIS2.mjs";
+import {
+  applyHintTracking,
+  classifyReadHint,
+  logSuppressedDetection,
+  meetsSavingsFloor
+} from "./token-goat-chunk-4SMRO4TO.mjs";
+import {
+  DELIVERS_CONTENT_RE
+} from "./token-goat-chunk-MNWKPRAL.mjs";
+import {
+  enqueueDirtyPathSafe
+} from "./token-goat-chunk-CIMQ2BB3.mjs";
+import {
+  claudeConfigDir
+} from "./token-goat-chunk-BPGCUMR7.mjs";
+import {
+  getBashOutput
+} from "./token-goat-chunk-KQBLRPBN.mjs";
+import {
+  DEFAULT_MAX_AGE_MS,
+  isGeneratedFile,
+  isInBuildDir,
+  isLockFile,
+  isManifestFile
+} from "./token-goat-chunk-4ZBFWLXF.mjs";
+import {
+  materializeShrunkImageFile,
+  registerHook,
+  sessionStateKey
+} from "./token-goat-chunk-C75NA7PL.mjs";
+import {
+  commandPathIsTouchable,
+  preToolPathDeclined,
+  vscodePathAllowed
+} from "./token-goat-chunk-P6VGNTQT.mjs";
+import {
+  OUTPUT_FIRST_TOOL_RESPONSE_KEYS,
+  VSCODE_TOOL_NAME_KEY,
+  contextOutput,
+  denyOutput,
+  extractToolResponseField,
+  getCwd,
+  getFilePath,
+  passOutput,
+  resolveEventPath,
+  resolveToolResponseFieldPath
+} from "./token-goat-chunk-76FGDLRO.mjs";
+import {
+  clearReadRangeIfChanged,
+  dropFileLineRangesIfChanged,
+  epochReadCounts,
+  evaluateRangeEvasion,
+  getCompactedAt,
+  getFileLineRanges,
+  getFileServedOutputs,
+  getReadRangeDenials,
+  getRecentReadRanges,
+  getSessionFileEntry,
+  getSessionFiles,
+  getSessionId,
+  getTranscriptPath,
+  lockReadRange,
+  markHintShown,
+  rangeLockMessage,
+  recordFileLineRange,
+  recordFileRead,
+  recordLargeFileHintPending,
+  recordRecentReadRange,
+  resetFileLineRanges,
+  takePendingLargeFileHint,
+  unrecordRefusedRead,
+  wasFileFullyReadThisSession,
+  wasFileReadThisSession,
+  wasFileTruncatedThisSession,
+  wasHintShown
+} from "./token-goat-chunk-GL3ETKSC.mjs";
+import {
+  extractShellBannerHeading
+} from "./token-goat-chunk-OXFMP75N.mjs";
+import {
+  MARKDOWN_SIZE_THRESHOLD,
+  eachUnfencedLine,
+  extractChangelogVersionHint,
+  extractMarkdownHeadings,
+  formatHeadingTreeParts,
+  getWellKnownSections,
+  ipynbToVirtualSource,
+  isImagePath,
+  normalizeSourceText
+} from "./token-goat-chunk-NISNMD7T.mjs";
+import {
+  ATX_DOT_BREAK_RE,
+  matchAtxHeading
+} from "./token-goat-chunk-EVMZJ27Z.mjs";
+import {
+  commonGitDir,
+  getFileEntry,
+  querySymbols
+} from "./token-goat-chunk-IK2DRMFX.mjs";
+import {
+  applyExifOrientation,
+  calculateFitInside,
+  decodeBmp,
+  decodeGif,
+  decodeJpeg,
+  decodePng,
+  encodeJpeg,
+  encodePng,
+  probeBufferMeta,
+  resizeRgba
+} from "./token-goat-chunk-5Y6ZYL6U.mjs";
+import {
+  recordStat,
+  savedTokensFromBytes
+} from "./token-goat-chunk-U4WHMG6Y.mjs";
+import {
+  detectLanguage,
+  filePathSpellingsClause,
+  fileRowByIndexKey,
+  languageHasFlag,
+  withProbeIndex
+} from "./token-goat-chunk-GVB2MUST.mjs";
+import {
+  findHtmlHeadingMatches
+} from "./token-goat-chunk-OUKDTVNU.mjs";
+import {
+  parse
+} from "./token-goat-chunk-3BTK54F3.mjs";
+import {
+  windowsSystem32Exe
+} from "./token-goat-chunk-65N4RHP4.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import {
+  detectHarness
+} from "./token-goat-chunk-QYHO5CPH.mjs";
+import {
+  findProject,
+  fingerprintContent,
+  fingerprintFile,
+  makeProjectAt,
+  shortFingerprint
+} from "./token-goat-chunk-4GBVPH3D.mjs";
+import {
+  IDENTICAL_READ_MIN_BODY_BYTES,
+  PER_FILE_COUNTERFACTUAL_CEILING,
+  atomicWriteBytes,
+  atomicWriteText,
+  containsLineRun,
+  countNoun,
+  decodeSource,
+  ensureDirSync,
+  isSequentialPagingChain,
+  isWithinQuietHours,
+  runGit,
+  sanitizeIdForFilename,
+  statSize,
+  toKB
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  configGetCommand,
+  docNavigation,
+  fencedCommand,
+  fileSubject,
+  grepLinesHint,
+  leadWithCommand,
+  nameSubject,
+  quotedArg,
+  quotedArgs,
+  sentenceStart,
+  stripUnsafeSuggestions
+} from "./token-goat-chunk-GGGG7RWB.mjs";
+import {
+  foldPath,
+  foldPathForContainment,
+  isInsideRoot,
+  isNodeModulesPath
+} from "./token-goat-chunk-AM5V6GSX.mjs";
+import {
+  TOOL_RESULTS_ID_CHARS,
+  displaySafePath,
+  displaySafeText,
+  fenceUntrustedFileContent,
+  hostPathOfIndexKey,
+  isUncOrDevicePath,
+  normalizePath,
+  resolveIndexPath
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  dataDir,
+  tokenGoatHome
+} from "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/indexed_source.ts
+init_define_import_meta_env();
+function indexedSourceText(filePath, raw) {
+  const text = normalizeSourceText(raw);
+  return isVirtualIndexedPath(filePath) ? normalizeSourceText(ipynbToVirtualSource(text).content) : text;
+}
+function isVirtualIndexedPath(filePath) {
+  return filePath.toLowerCase().endsWith(".ipynb");
+}
+function virtualIndexedScopeNote(displayPath, consequence) {
+  return `[${displayPath} is a notebook: its indexed line numbers address the flattened cell source, not the JSON in the file, so ${consequence}.]`;
+}
+var NOTEBOOK_CELL_LINES_SUFFIX = " (notebook cell lines)";
+function formatSymbolLocation(displayPath, lineStart, lineEnd) {
+  const range = lineEnd === void 0 ? `${lineStart}` : `${lineStart}-${lineEnd}`;
+  const suffix = isVirtualIndexedPath(displayPath) ? NOTEBOOK_CELL_LINES_SUFFIX : "";
+  return `${displayPath}:${range}${suffix}`;
+}
+
+// src/rewrite_permission.ts
+init_define_import_meta_env();
+import { execFile, spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+function agentTypeOf(raw) {
+  const agentType = raw["agent_type"];
+  return typeof agentType === "string" ? agentType : void 0;
+}
+var KNOWN_MODES = /* @__PURE__ */ new Set(["default", "plan", "acceptEdits", "auto", "dontAsk", "bypassPermissions"]);
+var READ_ONLY_PLAIN = /* @__PURE__ */ new Set(["ls", "cat", "echo", "pwd", "head", "tail", "grep", "wc", "which", "diff", "stat", "du"]);
+var READ_ONLY_FIRST_WORDS = /* @__PURE__ */ new Set([...READ_ONLY_PLAIN, "find", "git", "cd"]);
+var GIT_READ_SUBCOMMANDS = /* @__PURE__ */ new Set(["status", "diff", "log", "show"]);
+var GIT_READ_FLAG = /^(?:-s|--short|-b|--branch|--porcelain(?:=v[12])?|--stat|--shortstat|--numstat|--name-only|--name-status|--cached|--staged|-p|--patch|--no-patch|--oneline|--graph|--decorate|--all|--no-color|--summary|-n\d*|-\d+|--max-count=\d+|--format=\S*|--pretty=\S*|--)$/;
+var FIND_WRITE_FLAGS = /* @__PURE__ */ new Set(["-exec", "-execdir", "-ok", "-okdir", "-delete", "-fprint", "-fprint0", "-fprintf", "-fls"]);
+var UNPROVABLE_FIRST_WORDS = /* @__PURE__ */ new Set(["timeout", "time", "nice", "nohup", "stdbuf", "command", "builtin", "noglob", "xargs", "watch", "setsid", "ionice", "flock", "env", "sudo", "doas", "exec", "eval", "source", ".", "sh", "bash", "zsh", "dash", "ksh", "fish", "pwsh", "powershell", "cmd", "cmd.exe", "nocorrect"]);
+var PROTECTED_PATH_FRAGMENTS = [".git", ".config/git", ".vscode", ".idea", ".husky", ".cargo", ".devcontainer", ".yarn", ".mvn", ".claude", ".bashrc", ".zshrc", ".profile", ".envrc", ".npmrc", ".pnp.", "bunfig.toml", ".bazelrc", ".pre-commit-config.yaml", "lefthook.yml", ".mcp.json"];
+var RM_WORD = /(?:^|[^a-z0-9_.-])(?:rm|rmdir)(?:[^a-z0-9_-]|$)/;
+function namesRmOrProtectedPath(text) {
+  const lowered = text.toLowerCase();
+  return RM_WORD.test(lowered) || PROTECTED_PATH_FRAGMENTS.some((p) => lowered.includes(p));
+}
+var INTERPRETER_WORDS = /* @__PURE__ */ new Set(["python", "python3", "py", "node", "deno", "bun", "perl", "ruby", "php", "lua", "awk", "gawk", "busybox", "ssh"]);
+function isSimpleCommand(command) {
+  const words = simpleWords(command);
+  return words !== null && !words.some((w) => /[{}[\]*?~!#|;&<>()^]/.test(w)) && !words.some((w, i) => {
+    const base = (w.split("/").pop() ?? w).toLowerCase().replace(/\.exe$/, "");
+    return (base !== "." || i === 0) && (UNPROVABLE_FIRST_WORDS.has(base) || INTERPRETER_WORDS.has(base));
+  });
+}
+var FILE_RULE_TOOLS = ["read", "edit", "write", "multiedit", "notebookedit"];
+var BASH_COMMAND_CEILING = 1e4;
+function normalizedMode(mode) {
+  if (mode === void 0 || mode === null || mode === "") return "default";
+  return typeof mode === "string" && KNOWN_MODES.has(mode) ? mode : null;
+}
+function parseRule(raw, trustedAllow) {
+  if (typeof raw !== "string") return { raw: String(raw), tool: void 0, content: void 0, trustedAllow: false };
+  const m = /^([A-Za-z0-9_*.-]+)(?:\(([\s\S]*)\))?$/.exec(raw.trim());
+  if (m === null) return { raw, tool: void 0, content: void 0, trustedAllow: false };
+  return { raw, tool: m[1], content: m[2], trustedAllow };
+}
+function wildcardMatches(pattern, text) {
+  let p = 0;
+  let t = 0;
+  let star = -1;
+  let resume = 0;
+  while (t < text.length) {
+    if (p < pattern.length && pattern[p] !== "*" && pattern[p] === text[t]) {
+      p++;
+      t++;
+    } else if (p < pattern.length && pattern[p] === "*") {
+      star = p++;
+      resume = t;
+    } else if (star >= 0) {
+      p = star + 1;
+      t = ++resume;
+    } else {
+      return false;
+    }
+  }
+  while (p < pattern.length && pattern[p] === "*") p++;
+  return p === pattern.length;
+}
+function ruleToolIs(rule, names) {
+  if (rule.tool === void 0) return false;
+  const tool = rule.tool.toLowerCase();
+  return names.some((n) => wildcardMatches(tool, n));
+}
+function haystacks(parts) {
+  const base = parts.join("\n").toLowerCase().replace(/["']/g, "");
+  return [base.split("\\").join("/"), base.split("\\").join("")];
+}
+function realSpellings(p, cwd) {
+  const abs = path.resolve(cwd, p);
+  if (isUncOrDevicePath(p) || isUncOrDevicePath(abs)) return [];
+  let existing = abs;
+  for (let depth = 0; depth < 64; depth++) {
+    try {
+      const real = path.join(fs.realpathSync.native(existing), path.relative(existing, abs));
+      const same = process.platform === "win32" ? real.toLowerCase() === abs.toLowerCase() : real === abs;
+      return same ? [] : [real];
+    } catch {
+    }
+    const parent = path.dirname(existing);
+    if (parent === existing) break;
+    existing = parent;
+  }
+  return [];
+}
+function shellPathWords(command) {
+  return command.split(/[\s;&|<>()=,'"`]+/).filter((w) => w !== "" && !w.startsWith("-")).slice(0, 64);
+}
+function isWordChar(ch) {
+  return ch !== void 0 && /[a-z0-9]/.test(ch);
+}
+function containsPiece(text, piece) {
+  let at = text.indexOf(piece.text);
+  while (at >= 0) {
+    if ((piece.openLeft || !isWordChar(text[at - 1])) && (piece.openRight || !isWordChar(text[at + piece.text.length]))) return true;
+    at = text.indexOf(piece.text, at + 1);
+  }
+  return false;
+}
+function bashRuleMayMatch(rule, hays) {
+  if (rule.content === void 0) return true;
+  const pieces = [];
+  for (const token of rule.content.replace(/:\*\s*$/, " ").split(/\s+/)) {
+    const bits = token.split("*");
+    bits.forEach((bit, i) => {
+      const text = bit.replace(/["'\\]/g, "").toLowerCase();
+      if (text !== "") pieces.push({ text, openLeft: i > 0, openRight: i < bits.length - 1 });
+    });
+  }
+  if (pieces.length === 0) return true;
+  return pieces.every((p) => hays.some((h) => containsPiece(h, p)));
+}
+function pathRuleMayMatch(rule, hays) {
+  const content = rule.content;
+  if (content === void 0) return true;
+  if (/[{}[\]\\]/.test(content)) return true;
+  const segments = content.replace(/^(?:\/\/|~\/|\.\/|\/)/, "").split("/");
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const pieces = (segments[i] ?? "").split(/[*?]+/).filter((p) => p !== "").map((p) => p.toLowerCase());
+    if (pieces.length > 0) return pieces.every((p) => hays.some((h) => h.includes(p)));
+  }
+  return true;
+}
+function bashGlobMatches(content, command) {
+  if (!content.endsWith(":*") && !content.endsWith(" *")) return wildcardMatches(content, command);
+  const prefix = content.slice(0, -2);
+  return wildcardMatches(prefix, command) || wildcardMatches(`${prefix} *`, command) || wildcardMatches(`${prefix}	*`, command);
+}
+function simpleWords(command) {
+  const words = [];
+  let current = "";
+  let inWord = false;
+  for (let i = 0; i < command.length; i++) {
+    const ch = command[i];
+    if (ch === " " || ch === "	") {
+      if (inWord) words.push(current);
+      current = "";
+      inWord = false;
+      continue;
+    }
+    inWord = true;
+    if (ch === "'" || ch === '"') {
+      const close = command.indexOf(ch, i + 1);
+      if (close < 0) return null;
+      const quoted = command.slice(i + 1, close);
+      if (ch === '"' && /[$`\\!]/.test(quoted)) return null;
+      current += quoted;
+      i = close;
+      continue;
+    }
+    if (!/[A-Za-z0-9_./:=@%+,-]/.test(ch)) return null;
+    current += ch;
+  }
+  if (inWord) words.push(current);
+  return words.length > 0 ? words : null;
+}
+function provenAllowed(snapshot, command) {
+  if (command.length > BASH_COMMAND_CEILING) return false;
+  const words = simpleWords(command);
+  if (words === null) return false;
+  const first = words[0];
+  if (first.includes("=") || UNPROVABLE_FIRST_WORDS.has(first)) return false;
+  if (first === "find" && words.some((w) => FIND_WRITE_FLAGS.has(w))) return false;
+  if (READ_ONLY_PLAIN.has(first)) return true;
+  if (first === "git" && GIT_READ_SUBCOMMANDS.has(words[1] ?? "") && words.slice(2).every((w) => !w.startsWith("-") || GIT_READ_FLAG.test(w))) return true;
+  return snapshot.allow.some((r) => r.trustedAllow && r.tool === "Bash" && (r.content === void 0 || bashGlobMatches(r.content, command)));
+}
+function allSubcommandsReadOnly(command) {
+  const parts = command.split(/&&|\|\||[;|\n]/).map((p) => p.trim()).filter((p) => p !== "");
+  if (parts.length === 0) return false;
+  return parts.every((p) => {
+    const first = /^\S+/.exec(p.replace(/^(?:[A-Za-z_][A-Za-z0-9_]*=\S*\s+)*/, ""))?.[0] ?? "";
+    return READ_ONLY_FIRST_WORDS.has(first.replace(/["']/g, ""));
+  });
+}
+function decideShell(snapshot, req, mode) {
+  if (snapshot.blockReadsOutside) return "skip";
+  const original = req.original.trim();
+  const lowered = original.toLowerCase();
+  if (RM_WORD.test(lowered)) return "skip";
+  if (PROTECTED_PATH_FRAGMENTS.some((p) => lowered.includes(p))) return "skip";
+  const linked = shellPathWords(original).flatMap((w) => realSpellings(w, req.cwd).map((real) => ({ real, lexical: path.resolve(req.cwd, w) })));
+  if (linked.some(({ real, lexical }) => PROTECTED_PATH_FRAGMENTS.some((p) => haystacks([real])[0]?.includes(p) === true && haystacks([lexical])[0]?.includes(p) !== true))) return "skip";
+  const hays = haystacks([req.cwd, original, req.rewritten]);
+  const realHays = haystacks(linked.map(({ real }) => real));
+  const expands = /[$`\\]/.test(original);
+  const pathExpands = /[$`~*?[]/.test(original);
+  for (const rule of [...snapshot.deny, ...snapshot.ask]) {
+    if (rule.tool === void 0) return "skip";
+    if (ruleToolIs(rule, ["bash"])) {
+      if (expands || bashRuleMayMatch(rule, hays)) return "skip";
+    } else if (ruleToolIs(rule, FILE_RULE_TOOLS)) {
+      if (pathExpands || pathRuleMayMatch(rule, hays) || linked.length > 0 && pathRuleMayMatch(rule, realHays)) return "skip";
+    }
+  }
+  if (mode === "bypassPermissions") return "rewrite";
+  if (mode !== "plan" && provenAllowed(snapshot, original)) return "approve";
+  if (mode === "dontAsk") return "skip";
+  const allowHays = req.kind === "shell-wrap" ? hays : haystacks([original]);
+  for (const rule of snapshot.allow) {
+    if (!ruleToolIs(rule, ["bash"])) continue;
+    if (req.kind === "shell-wrap" && rule.content !== void 0 && !rule.content.includes("*") && rule.content === req.rewritten) continue;
+    if (bashRuleMayMatch(rule, allowHays)) return "skip";
+  }
+  if (allSubcommandsReadOnly(original)) return "skip";
+  return "rewrite";
+}
+function readRuleMayCover(snapshot, hays) {
+  for (const rule of [...snapshot.deny, ...snapshot.ask]) {
+    if (rule.tool === void 0) return true;
+    if (ruleToolIs(rule, ["read"]) && pathRuleMayMatch(rule, hays)) return true;
+  }
+  return false;
+}
+function decideRead(snapshot, req) {
+  if (snapshot.blockReadsOutside) return "skip";
+  if (readRuleMayCover(snapshot, haystacks([req.original, req.rewritten, ...realSpellings(req.original, req.cwd), ...realSpellings(req.rewritten, req.cwd)]))) return "skip";
+  if (req.harness !== "claudecode") return "rewrite";
+  return req.insideCwd === true ? "approve" : "skip";
+}
+function decideAgent(snapshot) {
+  for (const rule of [...snapshot.deny, ...snapshot.ask]) {
+    if (rule.tool === void 0) return "skip";
+    if (ruleToolIs(rule, ["agent", "task"]) && rule.content !== void 0 && /[:*]/.test(rule.content)) return "skip";
+  }
+  return "rewrite";
+}
+function isOtherHostEntry(entrypoint) {
+  return entrypoint !== void 0 && entrypoint !== "" && !/^(sdk-)?cli$/.test(entrypoint);
+}
+var unseenRules;
+var primeAhead = false;
+function decideRewrite(snapshot, req, hidden = (r, filesOnly) => unseenRules?.hidden(r.cwd, r.agentType, filesOnly) ?? true, lineRules = () => unseenRules?.lineRules() ?? !isOtherHostEntry(process.env["CLAUDE_CODE_ENTRYPOINT"])) {
+  if (snapshot === null) return "skip";
+  const mode = req.harness === "claudecode" ? normalizedMode(req.mode) : "default";
+  if (mode === null || mode === "auto") return "skip";
+  let verdict;
+  switch (req.kind) {
+    case "shell-wrap":
+    case "shell-query":
+      verdict = decideShell(snapshot, req, mode);
+      break;
+    case "read":
+      verdict = decideRead(snapshot, req);
+      break;
+    case "agent":
+      verdict = decideAgent(snapshot);
+  }
+  if (verdict === "skip") return verdict;
+  if (mode !== "bypassPermissions") return verdict === "approve" && (req.harness === "claudecode" && lineRules(req) || snapshot.permissionHooks || hidden(req, true)) ? "skip" : verdict;
+  return snapshot.permissionHooks || hidden(req, false) ? "skip" : "approve";
+}
+function asObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function snapshotFromDocs(docs) {
+  const allow = [];
+  const deny = [];
+  const ask = [];
+  let blockReadsOutside = false;
+  const managedGroups = new Set(docs.filter((d) => d.role === "managed").map((d) => d.managedGroup ?? "managed"));
+  const managedOnly = docs.some((d) => d.role === "managed" && d.json["allowManagedPermissionRulesOnly"] !== void 0 && d.json["allowManagedPermissionRulesOnly"] !== false);
+  let permissionHooks = false;
+  for (const doc of docs) {
+    if (asObject(doc.json["hooks"])?.["PermissionRequest"] !== void 0) permissionHooks = true;
+    const permissions = doc.json["permissions"];
+    if (permissions === void 0) continue;
+    const perms = asObject(permissions);
+    if (perms === null) throw new Error("permissions is not an object");
+    const block = perms["blockReadsOutsideWorkingDirectories"];
+    if (block !== void 0 && block !== false) blockReadsOutside = true;
+    let trusted;
+    switch (doc.role) {
+      case "managed":
+        trusted = managedGroups.size === 1;
+        break;
+      case "user":
+        trusted = !managedOnly;
+        break;
+      case "local":
+        trusted = !managedOnly && doc.localTrusted === true;
+        break;
+      default:
+        trusted = false;
+    }
+    for (const [key, list] of [["allow", allow], ["deny", deny], ["ask", ask]]) {
+      const entries = perms[key];
+      if (entries === void 0) continue;
+      if (!Array.isArray(entries)) throw new Error(`permissions.${key} is not an array`);
+      if (key === "allow" && doc.role === "ancestor") continue;
+      for (const entry of entries) list.push(parseRule(entry, key === "allow" && trusted));
+    }
+  }
+  return { allow, deny, ask, blockReadsOutside, permissionHooks };
+}
+var SOURCE_FILTER_SLOT = /* @__PURE__ */ Symbol.for("token-goat.permission-source-filter");
+function sourceAllowed(source) {
+  const filter = globalThis[SOURCE_FILTER_SLOT];
+  return typeof filter !== "function" || filter(source) === true;
+}
+function readIfExists(file, list) {
+  if (!sourceAllowed(file)) return void 0;
+  try {
+    return list === true ? fs.readdirSync(file) : fs.readFileSync(file, "utf8");
+  } catch (err) {
+    const code = err.code;
+    if (code === "ENOENT" || code === "ENOTDIR") return void 0;
+    throw err;
+  }
+}
+function readSettingsFile(file) {
+  const text = readIfExists(file);
+  if (text === void 0) return void 0;
+  const json = asObject(JSON.parse(text));
+  if (json === null) throw new Error(`${file} is not a JSON object`);
+  return json;
+}
+var REG_ABSENT = "ERROR: The system was unable to find the specified registry key or value.";
+var REG_SENTINEL = "HKLM\\SOFTWARE\\TokenGoatNoSuchKey";
+var REG_OPTS = { encoding: "utf8", windowsHide: true, timeout: 5e3 };
+var regArgs = (key) => ["query", key, "/v", "Settings"];
+var regQuery = (key) => spawnSync(windowsSystem32Exe("reg.exe"), regArgs(key), REG_OPTS);
+function regQueryAsync(key) {
+  return new Promise((resolve3) => {
+    execFile(windowsSystem32Exe("reg.exe"), regArgs(key), REG_OPTS, (err, stdout, stderr) => {
+      const status = err === null ? 0 : typeof err.code === "number" && err.killed !== true ? err.code : null;
+      resolve3({ status, stdout, stderr });
+    });
+  });
+}
+var sentinelMessage = (res) => res.status === 1 ? res.stderr.trim() : "";
+function registrySettings(key, res, missing) {
+  if (res.status === 1) {
+    if (res.stderr.trim() === REG_ABSENT) return void 0;
+    const none = missing();
+    if (none !== "" && res.stderr.trim() === none) return void 0;
+  }
+  const json = res.status === 0 && !res.stdout.includes("\uFFFD") ? asObject(JSON.parse(/^\s*Settings\s+REG_(?:EXPAND_)?SZ\s(.*)$/m.exec(res.stdout)?.[1]?.trim() ?? "null")) : null;
+  if (json === null) throw new Error(`unreadable ${key}`);
+  return json;
+}
+function readRegistrySettings(keys) {
+  let missing;
+  return keys.map((key) => registrySettings(key, regQuery(key), () => missing ??= sentinelMessage(regQuery(REG_SENTINEL))));
+}
+async function readRegistrySettingsAsync(keys) {
+  const answers = await Promise.all(keys.map(regQueryAsync));
+  const needsSentinel = answers.some((res) => res.status === 1 && res.stderr.trim() !== REG_ABSENT);
+  const missing = needsSentinel ? sentinelMessage(await regQueryAsync(REG_SENTINEL)) : "";
+  return keys.map((key, i) => registrySettings(key, answers[i], () => missing));
+}
+var policyKeys = () => ["HKLM", "HKCU"].map((h) => `${h}\\SOFTWARE\\Policies\\ClaudeCode`).filter((k) => sourceAllowed(`registry:${k}`));
+function managedFileDocs(dir, group, out) {
+  const main = readSettingsFile(path.join(dir, "managed-settings.json"));
+  if (main !== void 0) out.push({ role: "managed", json: main, managedGroup: group });
+  const names = readIfExists(path.join(dir, "managed-settings.d"), true) ?? [];
+  for (const name of names.filter((n) => n.endsWith(".json") && !n.startsWith(".")).sort()) {
+    const json = readSettingsFile(path.join(dir, "managed-settings.d", name));
+    if (json !== void 0) out.push({ role: "managed", json, managedGroup: group });
+  }
+}
+function managedDirs() {
+  if (process.platform === "darwin") return ["/Library/Application Support/ClaudeCode"];
+  if (process.platform !== "win32") return ["/etc/claude-code"];
+  const dirs = /* @__PURE__ */ new Map();
+  for (const base of [process.env["ProgramFiles"], "C:\\Program Files"]) {
+    if (base !== void 0 && base !== "") dirs.set(path.join(base, "ClaudeCode").toLowerCase(), path.join(base, "ClaudeCode"));
+  }
+  return [...dirs.values()];
+}
+function managedDocs(registry) {
+  const out = [];
+  for (const dir of managedDirs()) managedFileDocs(dir, "file", out);
+  if (process.platform === "win32") {
+    const keys = registry?.keys ?? policyKeys();
+    const values = registry?.values ?? readRegistrySettings(keys);
+    values.forEach((json, i) => {
+      if (json !== void 0) out.push({ role: "managed", json, managedGroup: keys[i].slice(0, 4).toLowerCase() });
+    });
+  } else if (process.platform === "darwin") {
+    for (const plist of ["/Library/Managed Preferences/com.anthropic.claudecode.plist", path.join("/Library/Managed Preferences", os.userInfo().username, "com.anthropic.claudecode.plist")]) {
+      if (!sourceAllowed(plist) || !fs.existsSync(plist)) continue;
+      const res = spawnSync("plutil", ["-convert", "json", "-o", "-", plist], { encoding: "utf8", timeout: 5e3 });
+      if (res.error !== void 0 || res.status !== 0) throw new Error(`unreadable ${plist}`);
+      const json = asObject(JSON.parse(res.stdout));
+      if (json === null) throw new Error(`${plist} is not a dictionary`);
+      out.push({ role: "managed", json, managedGroup: "plist" });
+    }
+  }
+  const remote = readSettingsFile(path.join(claudeConfigDir(), "remote-settings.json"));
+  if (remote !== void 0 && Object.keys(remote).length > 0) out.push({ role: "managed", json: remote, managedGroup: "remote" });
+  return out;
+}
+var MANAGED_CACHE_MS = 3e4;
+var MANAGED_REFRESH_MS = 2e4;
+var MANAGED_IDLE_MS = 3e5;
+var managedCache;
+var managedRefresh;
+var managedGeneration = 0;
+var managedUsedAt = 0;
+function primeManagedPolicyAhead() {
+  if (process.platform !== "win32" || managedRefresh !== void 0) return;
+  managedUsedAt = Date.now();
+  const refresh = () => {
+    if (Date.now() - managedUsedAt > MANAGED_IDLE_MS) return;
+    const generation = managedGeneration;
+    const at = Date.now();
+    const keys = policyKeys();
+    readRegistrySettingsAsync(keys).then((values) => {
+      if (generation !== managedGeneration || managedCache !== void 0 && managedCache.at > at) return;
+      managedCache = { at, docs: managedDocs({ keys, values }) };
+    }).catch(() => void 0);
+  };
+  managedRefresh = setInterval(refresh, MANAGED_REFRESH_MS);
+  managedRefresh.unref();
+  refresh();
+}
+function localFileTrusted(file) {
+  try {
+    if (fs.lstatSync(path.dirname(file)).isSymbolicLink()) return false;
+  } catch {
+    return false;
+  }
+  const res = runGit(["ls-files", "--error-unmatch", path.basename(file)], { cwd: path.dirname(file), timeoutMs: 5e3 });
+  return res.exitCode === 1;
+}
+function samePath(a, b) {
+  return foldPathForContainment(a) === foldPathForContainment(b);
+}
+function gitMainRoot(dir) {
+  for (const d of selfAndAncestors(dir)) {
+    if (!fs.existsSync(path.join(d, ".git"))) continue;
+    const common = commonGitDir(d);
+    return common !== null && path.basename(common) === ".git" ? path.dirname(common) : d;
+  }
+  return void 0;
+}
+function selfAndAncestors(dir) {
+  const out = [];
+  let d = dir;
+  for (let depth = 0; depth < 64; depth++) {
+    out.push(d);
+    const parent = path.dirname(d);
+    if (parent === d) break;
+    d = parent;
+  }
+  return out;
+}
+function loadPermissionSnapshot(cwd, projectDir = process.env["CLAUDE_PROJECT_DIR"]) {
+  try {
+    const here = path.resolve(cwd);
+    const project = projectDir !== void 0 && path.isAbsolute(projectDir) ? path.resolve(projectDir) : void 0;
+    if (project !== void 0 && !isInsideRoot(here, project)) return null;
+    const start = project ?? here;
+    const mainRoot = gitMainRoot(start);
+    const localDir = samePath(here, start) && (process.platform === "win32" || mainRoot === void 0 || samePath(mainRoot, start)) ? start : void 0;
+    const now = Date.now();
+    managedUsedAt = now;
+    if (managedCache === void 0 || now - managedCache.at > MANAGED_CACHE_MS) managedCache = { at: now, docs: managedDocs() };
+    const docs = [...managedCache.docs];
+    const user = readSettingsFile(path.join(claudeConfigDir(), "settings.json"));
+    if (user !== void 0) docs.push({ role: "user", json: user });
+    const userLocal = readSettingsFile(path.join(claudeConfigDir(), "settings.local.json"));
+    if (userLocal !== void 0) docs.push({ role: "ancestor", json: userLocal });
+    const seen = /* @__PURE__ */ new Set();
+    for (const dir of [here, start, ...mainRoot === void 0 ? [] : [mainRoot]].flatMap(selfAndAncestors)) {
+      const key = process.platform === "win32" ? dir.toLowerCase() : dir;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const projectSettings = readSettingsFile(path.join(dir, ".claude", "settings.json"));
+      if (projectSettings !== void 0) docs.push({ role: samePath(dir, start) ? "project" : "ancestor", json: projectSettings });
+      const localFile = path.join(dir, ".claude", "settings.local.json");
+      const local = readSettingsFile(localFile);
+      if (local !== void 0) {
+        const perms = asObject(local["permissions"]);
+        const hasAllow = Array.isArray(perms?.["allow"]) && perms["allow"].length > 0;
+        docs.push(localDir !== void 0 && samePath(dir, localDir) ? { role: "local", json: local, localTrusted: hasAllow && localFileTrusted(localFile) } : { role: "ancestor", json: local });
+      }
+    }
+    return snapshotFromDocs(docs);
+  } catch {
+    return null;
+  }
+}
+var codexDecide;
+async function loadCodexRules() {
+  if (codexDecide !== void 0) return;
+  const { decideCodex } = await import("./token-goat-chunk-B3PEKBYG.mjs");
+  const helpers = { containsPiece, haystacks, readIfExists, selfAndAncestors, sourceAllowed };
+  codexDecide = (req) => decideCodex(req, helpers);
+}
+async function loadHiddenRuleCheck() {
+  unseenRules ??= (await import("./token-goat-chunk-CSJ5L3NL.mjs")).hiddenRules({ configDir: claudeConfigDir, managedDirs, runGit, selfAndAncestors, sourceAllowed });
+  if (primeAhead) await unseenRules.prime(process.env);
+}
+function primeHiddenRulesAhead() {
+  primeAhead = true;
+}
+function loadingHiddenRuleCheck(handler) {
+  return (event) => {
+    if (unseenRules !== void 0 && !primeAhead || event.raw["permission_mode"] === "auto") return handler(event);
+    const harness = detectHarness();
+    if (harness !== "claudecode" && harness !== "vscode") return handler(event);
+    return loadHiddenRuleCheck().then(() => handler(event), () => handler(event));
+  };
+}
+var UNSEEN_SHELL_RULES = /* @__PURE__ */ new Set(["copilot_cli", "opencode", "grok"]);
+function permissionNeutralRewrite(updatedInput, req) {
+  if (UNSEEN_SHELL_RULES.has(req.harness) && (req.kind === "shell-wrap" || req.kind === "shell-query")) return null;
+  const codexShell = req.harness === "codex" && (req.kind === "shell-wrap" || req.kind === "shell-query");
+  const verdict = req.harness === "claudecode" || req.harness === "vscode" ? decideRewrite(loadPermissionSnapshot(req.cwd), req) : codexShell ? codexDecide?.(req) ?? "skip" : "rewrite";
+  if (verdict === "skip") return null;
+  return { hookType: "rewriteInput", updatedInput, approve: verdict === "approve" };
+}
+function readHintCrossesRule(harness, cwd, paths, command = "", declined) {
+  if (harness !== "claudecode" && harness !== "vscode") return false;
+  const snapshot = loadPermissionSnapshot(cwd);
+  if (snapshot === null || snapshot.blockReadsOutside) return true;
+  if (/[$`~*?[]/.test(command) && [...snapshot.deny, ...snapshot.ask].some((rule) => rule.tool === void 0 || ruleToolIs(rule, ["read"]))) return true;
+  return readRuleMayCover(snapshot, haystacks([command, ...paths.map((p) => path.resolve(cwd, p)), ...paths.filter((p) => declined?.(p) !== true).flatMap((p) => realSpellings(p, cwd))]));
+}
+
+// src/hints/file_type_handler.ts
+init_define_import_meta_env();
+var LARGE_SYMBOL_LINE_THRESHOLD = 200;
+var FILE_TYPE_THRESHOLDS = {
+  pdf: 0,
+  // always intercept (any size)
+  html: 5e4,
+  txt: 2e4,
+  log: 1e4,
+  svg: 8e3,
+  xml: 2e4,
+  dtsx: 2e4,
+  ampkg: 2e4,
+  xaml: 2e4,
+  csv: 1e4,
+  tsv: 1e4,
+  json: 2e4,
+  yaml: 2e4,
+  jsonl: 2e4,
+  transcript: 1e4,
+  office: 0,
+  // always block (.docx etc)
+  sqlite: 0,
+  // always block (.db, .sqlite, etc)
+  parquet: 0,
+  // always block (.parquet)
+  generic: 1e5
+  // catch-all for unrecognized large files
+};
+function formatBytes(n) {
+  if (n < 1024) return `${n} B`;
+  if (n < 1048576) return `${(n / 1024).toFixed(1)} KB`;
+  if (n < 1073741824) return `${(n / 1048576).toFixed(1)} MB`;
+  if (n < 1099511627776) return `${(n / 1073741824).toFixed(1)} GB`;
+  return `${(n / 1099511627776).toFixed(1)} TB`;
+}
+function previewUnavailable(content, effectiveLength) {
+  return content.length === 0 && effectiveLength > 0;
+}
+function BYTE_RANGE_ADVICE(filePath) {
+  return `This file is mostly one long line (e.g. base64 or minified content) \u2014 offset/limit line-windowing won't shrink a read here. Sample raw bytes instead, e.g.: dd if=${quotedArg(filePath)} bs=1 skip=<N> count=<M> status=none`;
+}
+function handlePdf(filePath, contentLength) {
+  const [quoted, range] = quotedArgs(filePath, "<range>");
+  return {
+    shouldBlock: true,
+    message: [
+      `PDF file (${formatBytes(contentLength)}) \u2014 Read cannot return PDF content; this is not retryable with different Read parameters.`,
+      `Inspect first: token-goat pdf-meta ${quoted} and token-goat pdf-outline ${quoted}`,
+      `Then extract relevant pages: token-goat pdf-extract ${quoted} --pages ${range}`
+    ].join("\n")
+  };
+}
+function handleHtml(filePath, content, contentLengthHint) {
+  const length = contentLengthHint ?? content.length;
+  if (length < FILE_TYPE_THRESHOLDS.html) return { shouldBlock: false, message: "" };
+  if (previewUnavailable(content, length)) {
+    return {
+      shouldBlock: true,
+      message: `Large HTML file (${formatBytes(length)}) \u2014 too large to preview (exceeds the in-hook scan cap). Use token-goat section to extract a section by heading, or convert to text: pandoc ${quotedArg(displaySafePath(filePath))} -t plain`
+    };
+  }
+  const title = content.match(/<title[^>]*>([^<]*)<\/title>/i)?.[1]?.trim();
+  const headings = findHtmlHeadingMatches(content).slice(0, 20).map(({ level, heading }) => {
+    if (!heading) return "";
+    return `${"  ".repeat(level - 1)}h${level}: ${heading}`;
+  }).filter(Boolean);
+  const isMinified = !content.includes("\n") || content.length > 5e4 && content.split("\n").length < 10;
+  if (isMinified) {
+    return {
+      shouldBlock: true,
+      message: `HTML file appears minified (${formatBytes(length)}). Consider fetching the source or converting with: pandoc ${quotedArg(displaySafePath(filePath))} -t plain`
+    };
+  }
+  return {
+    shouldBlock: true,
+    message: [
+      // Title and headings are verbatim file bytes spliced into a message the harness attributes to token-goat, so they are fenced as untrusted data.
+      `Large HTML file (${formatBytes(length)}).`,
+      title || headings.length > 0 ? fenceUntrustedFileContent(
+        [title ? `Title: ${title}` : "", headings.length > 0 ? `Headings:
+${headings.join("\n")}` : ""].filter(Boolean).join("\n")
+      ) : "",
+      `Use token-goat section to extract a section by heading, or convert to text: pandoc ${quotedArg(displaySafePath(filePath))} -t plain`
+    ].filter(Boolean).join("\n")
+  };
+}
+function handleTxt(filePath, content, contentLengthHint) {
+  const length = contentLengthHint ?? content.length;
+  const isLog = /\.(log|out|err|trace)$/i.test(filePath) || /[\\/]logs[\\/]/.test(filePath);
+  const threshold = isLog ? FILE_TYPE_THRESHOLDS.log : FILE_TYPE_THRESHOLDS.txt;
+  if (length < threshold) return { shouldBlock: false, message: "" };
+  const [quotedLog, errorPattern] = quotedArgs(filePath, "error|ERROR");
+  const recall = isLog ? `Log file \u2014 use Read with offset/limit params, or: token-goat bash-output --file ${quotedLog} --tail 100 --grep ${errorPattern}` : "Use Read with offset and limit params to sample specific line ranges.";
+  if (previewUnavailable(content, length)) {
+    return {
+      shouldBlock: true,
+      message: `Large text file (${formatBytes(length)}) \u2014 too large to preview (exceeds the in-hook scan cap).
+${recall}`
+    };
+  }
+  const contentSniff = content.slice(0, 1e3);
+  if (/^\s*<!DOCTYPE\s+html|^\s*<html[\s>]/i.test(contentSniff)) {
+    const htmlResult = handleHtml(filePath, content, contentLengthHint);
+    if (htmlResult.shouldBlock) return htmlResult;
+  }
+  const lines = content.split("\n");
+  if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
+  const preview = [
+    "--- first 5 lines ---",
+    ...lines.slice(0, 5),
+    `... (${lines.length.toLocaleString()} lines total) ...`,
+    "--- last 5 lines ---",
+    ...lines.slice(-5)
+  ].join("\n");
+  return {
+    shouldBlock: true,
+    // The preview is verbatim file bytes, so it is fenced as untrusted data.
+    message: `Large text file (${formatBytes(length)}, ${lines.length.toLocaleString()} lines).
+${fenceUntrustedFileContent(preview)}
+
+${recall}`
+  };
+}
+function handleSvg(filePath, content, contentLengthHint) {
+  const length = contentLengthHint ?? content.length;
+  if (length < FILE_TYPE_THRESHOLDS.svg) return { shouldBlock: false, message: "" };
+  if (previewUnavailable(content, length)) {
+    return {
+      shouldBlock: true,
+      message: [
+        `Large SVG file (${formatBytes(length)}) \u2014 too large to preview (exceeds the in-hook scan cap).`,
+        `Inspect structure: token-goat xml-outline ${quotedArg(filePath)}`,
+        `Query layers/elements: token-goat xml-query ${quotedArgs(filePath, "//g[@id]").join(" ")}`
+      ].join("\n")
+    };
+  }
+  const titleMatch = content.match(/<title[^>]*>([^<]*)<\/title>/i);
+  const title = titleMatch ? titleMatch[1]?.trim() : "";
+  const groupIds = [];
+  const idRegex = /<g[^>]*\bid=["']([^"']+)["']/gi;
+  let match;
+  while ((match = idRegex.exec(content)) !== null && groupIds.length < 10) {
+    if (match[1]) groupIds.push(match[1]);
+  }
+  const preview = [
+    title ? `Title: ${title}` : "",
+    groupIds.length > 0 ? `Layer/Group IDs: ${groupIds.join(", ")}` : ""
+  ].filter(Boolean).join("\n");
+  const [labelPattern, labelGlob] = quotedArgs("<text>", filePath);
+  return {
+    shouldBlock: true,
+    message: [
+      `Large SVG/diagram file (${formatBytes(length)}) \u2014 raw coordinate paths flood context.`,
+      preview ? fenceUntrustedFileContent(preview) : "",
+      `Inspect structure: token-goat xml-outline ${quotedArg(filePath)}`,
+      `Query elements: token-goat xml-query ${quotedArgs(filePath, "//g[@id]").join(" ")}`,
+      `Search text labels: token-goat grep ${labelPattern} --glob ${labelGlob}`
+    ].filter(Boolean).join("\n")
+  };
+}
+function handleXml(filePath, content, contentLengthHint) {
+  const length = contentLengthHint ?? content.length;
+  const ext = filePath.split(".").pop()?.toLowerCase() ?? "xml";
+  const threshold = ext === "dtsx" || ext === "ampkg" || ext === "xaml" ? FILE_TYPE_THRESHOLDS[ext] : FILE_TYPE_THRESHOLDS.xml;
+  if (length < threshold) return { shouldBlock: false, message: "" };
+  const typeLabel = ext === "dtsx" ? "SSIS package XML (.dtsx)" : ext === "ampkg" ? "workflow package XML (.ampkg)" : ext === "xaml" ? "XAML (.xaml)" : "XML";
+  if (previewUnavailable(content, length)) {
+    return {
+      shouldBlock: true,
+      message: [
+        `Large ${typeLabel} file (${formatBytes(length)}) \u2014 too large to preview (exceeds the in-hook scan cap).`,
+        `Inspect structure: token-goat xml-outline ${quotedArg(filePath)}`,
+        `Query nodes: token-goat xml-query ${quotedArgs(filePath, "<selector>").join(" ")}`
+      ].join("\n")
+    };
+  }
+  return {
+    shouldBlock: true,
+    message: [
+      `Large ${typeLabel} file (${formatBytes(length)}).`,
+      `Inspect hierarchy: token-goat xml-outline ${quotedArg(filePath)}`,
+      `Query specific elements: token-goat xml-query ${quotedArgs(filePath, "<selector>").join(" ")}`
+    ].join("\n")
+  };
+}
+function handleOfficeBinary(filePath) {
+  const filename = filePath.split(/[\\/]/).pop() || "";
+  const parts = filename.split(".");
+  const lastPart = parts[parts.length - 1];
+  const ext = parts.length > 1 && lastPart ? lastPart.toLowerCase() : "bin";
+  return {
+    shouldBlock: true,
+    message: [
+      `Binary Office file (.${ext}) \u2014 cannot be read as text.`,
+      `Extract content first: pandoc ${quotedArg(displaySafePath(filePath))} -t plain -o ${quotedArg(displaySafePath(filePath + ".txt"))}`,
+      `Then read the extracted .txt file.`
+    ].join("\n")
+  };
+}
+function handleXlsx(filePath) {
+  const [quoted, sheet] = quotedArgs(filePath, "<name>");
+  return {
+    shouldBlock: true,
+    message: [
+      `Excel file \u2014 Read cannot return spreadsheet content; this is not retryable with different Read parameters.`,
+      `List sheets: token-goat xlsx-sheets ${quoted}`,
+      `Then preview a sheet: ${fencedCommand(`token-goat xlsx-head ${quoted} --sheet ${sheet}`)}, or filter rows: ${fencedCommand(`token-goat xlsx-query ${quoted} --sheet ${sheet} --where col=value`)}`
+    ].join("\n")
+  };
+}
+function handlePptx(filePath) {
+  const [quoted, slide] = quotedArgs(filePath, "<n>");
+  return {
+    shouldBlock: true,
+    message: [
+      `PowerPoint file \u2014 Read cannot return slide content; this is not retryable with different Read parameters.`,
+      `List slides: token-goat pptx-outline ${quoted}`,
+      `Then read one slide: token-goat pptx-slide ${quoted} --slide ${slide}`
+    ].join("\n")
+  };
+}
+function handleDocx(filePath) {
+  return {
+    shouldBlock: true,
+    message: [
+      `Word file \u2014 Read cannot return document content; this is not retryable with different Read parameters.`,
+      `See headings: token-goat docx-outline ${quotedArg(filePath)}`,
+      `Extract tables: token-goat docx-tables ${quotedArg(filePath)}`,
+      `Read full text: token-goat docx-text ${quotedArg(filePath)}`
+    ].join("\n")
+  };
+}
+function handleCsv(filePath, content, contentLengthHint) {
+  const threshold = filePath.toLowerCase().endsWith(".tsv") ? FILE_TYPE_THRESHOLDS.tsv : FILE_TYPE_THRESHOLDS.csv;
+  const length = contentLengthHint ?? content.length;
+  if (length < threshold) return { shouldBlock: false, message: "" };
+  if (previewUnavailable(content, length)) {
+    return {
+      shouldBlock: true,
+      message: [
+        `Large CSV file (${formatBytes(length)}) \u2014 too large to preview (exceeds the in-hook scan cap).`,
+        `Use token-goat csv-query ${quotedArg(filePath)} --columns "a,b,c" --where col=value --head N to query narrow slices.`
+      ].join("\n")
+    };
+  }
+  const lines = content.split("\n").filter((l) => l.trim());
+  const headers = lines[0] ?? "";
+  const sampleRows = lines.slice(1, 4);
+  const sep = filePath.toLowerCase().endsWith(".tsv") ? "	" : ",";
+  let colCount;
+  try {
+    colCount = parse(headers, { delimiter: sep })[0]?.length ?? headers.split(sep).length;
+  } catch {
+    colCount = headers.split(sep).length;
+  }
+  return {
+    shouldBlock: true,
+    message: [
+      `Large CSV file (${formatBytes(length)}, ~${lines.length.toLocaleString()} rows, ${colCount} columns).`,
+      // Header row and sample rows are verbatim file bytes, so they are fenced as untrusted data.
+      fenceUntrustedFileContent(`Columns: ${headers}
+Sample rows:
+${sampleRows.join("\n")}`),
+      `Use token-goat csv-query ${quotedArg(filePath)} --columns "a,b,c" --where col=value --head N to query narrow slices.`
+    ].join("\n")
+  };
+}
+function handleTranscript(filePath, content, contentLengthHint) {
+  const length = contentLengthHint ?? content.length;
+  if (length < FILE_TYPE_THRESHOLDS.transcript) return { shouldBlock: false, message: "" };
+  const [quoted, speaker] = quotedArgs(filePath, "Name");
+  if (previewUnavailable(content, length)) {
+    return {
+      shouldBlock: true,
+      message: [
+        `Transcript file (${formatBytes(length)}) \u2014 too large to preview (exceeds the in-hook scan cap).`,
+        `See structure: token-goat transcript-outline ${quotedArg(filePath)}`,
+        `Slice by speaker/time/pattern: token-goat transcript ${quoted} --speaker ${speaker} --from 00:05:00 --to 00:10:00 --grep pattern`
+      ].join("\n")
+    };
+  }
+  const speakerMatches = [...content.matchAll(/^<v(?:\.\w+)?\s+([^>]+)>/gm)].map((m) => m[1]?.trim() ?? "");
+  const speakers = [...new Set(speakerMatches)].slice(0, 10);
+  const cueCount = (content.match(/-->/g) ?? []).length;
+  return {
+    shouldBlock: true,
+    message: [
+      // Speaker names are verbatim file bytes, so they are fenced as untrusted data.
+      `Transcript file (${formatBytes(length)}, ~${cueCount} cues).`,
+      speakers.length > 0 ? fenceUntrustedFileContent(`Speakers: ${speakers.join(", ")}`) : "",
+      `See structure: token-goat transcript-outline ${quotedArg(filePath)}`,
+      `Slice by speaker/time/pattern: token-goat transcript ${quoted} --speaker ${speaker} --from 00:05:00 --to 00:10:00 --grep pattern`
+    ].filter(Boolean).join("\n")
+  };
+}
+function handleSqlite(filePath) {
+  return {
+    shouldBlock: true,
+    message: [
+      `SQLite database \u2014 Read cannot return binary database content; this is not retryable with different Read parameters.`,
+      `See tables: token-goat sqlite-tables ${quotedArg(filePath)}`,
+      `See schema: token-goat sqlite-schema ${quotedArg(filePath)}`,
+      `Query data: token-goat sqlite-query ${quotedArgs(filePath, "SELECT ... FROM ... LIMIT 20").join(" ")}`
+    ].join("\n")
+  };
+}
+function sqlLiteralPath(p) {
+  const path7 = /^[A-Za-z]:[\\/]/.test(p) ? p.replaceAll("\\", "/") : p;
+  return displaySafePath(path7) === path7 && !/['"$`\\\u2018-\u201E]/.test(path7) ? path7 : "<file>";
+}
+function handleParquet(filePath) {
+  return {
+    shouldBlock: true,
+    message: [
+      `Parquet file \u2014 Read cannot return binary columnar content; this is not retryable with different Read parameters.`,
+      `Query with DuckDB: duckdb -c "SELECT * FROM read_parquet('${sqlLiteralPath(filePath)}') LIMIT 10"`
+    ].join("\n")
+  };
+}
+function handleJson(filePath, content, contentLengthHint) {
+  const length = contentLengthHint ?? content.length;
+  if (length < FILE_TYPE_THRESHOLDS.json) return { shouldBlock: false, message: "" };
+  const [quoted, query] = quotedArgs(filePath, "<path>");
+  const isSpill = /(?:^|[/\\])content\.json$/i.test(filePath) || /[/\\](?:tmp|temp)[/\\]/i.test(filePath);
+  const spillHeader = isSpill ? `This file appears to be an oversized tool output spill (${formatBytes(length)}). Do not read it whole with Read/read_file.` : `Large JSON file (${formatBytes(length)}).`;
+  if (previewUnavailable(content, length)) {
+    return {
+      shouldBlock: true,
+      message: [
+        isSpill ? `This file appears to be an oversized tool output spill (${formatBytes(length)}) \u2014 too large to preview (exceeds the in-hook scan cap).` : `Large JSON file (${formatBytes(length)}) \u2014 too large to preview (exceeds the in-hook scan cap).`,
+        `See structure: token-goat json-outline ${quotedArg(filePath)}`,
+        `Query subtree: token-goat json-query ${quoted} ${query}`,
+        isSpill ? `Slice spill: token-goat mcp-output --file ${quoted} --json-query ${query}` : ""
+      ].filter(Boolean).join("\n")
+    };
+  }
+  let summary = "";
+  try {
+    const parsed = JSON.parse(content);
+    if (Array.isArray(parsed)) {
+      summary = `JSON array (${parsed.length} items)`;
+      if (parsed.length > 0 && typeof parsed[0] === "object" && parsed[0] !== null) {
+        const itemKeys = Object.keys(parsed[0]).slice(0, 10);
+        summary += `, item keys: ${itemKeys.join(", ")}${Object.keys(parsed[0]).length > 10 ? "..." : ""}`;
+      }
+    } else if (typeof parsed === "object" && parsed !== null) {
+      const keys = Object.keys(parsed).slice(0, 15);
+      summary = `Top-level keys (${Object.keys(parsed).length}): ${keys.join(", ")}${Object.keys(parsed).length > 15 ? "..." : ""}`;
+    }
+  } catch {
+  }
+  return {
+    shouldBlock: true,
+    message: [
+      spillHeader,
+      summary ? fenceUntrustedFileContent(summary) : "",
+      `See structure: token-goat json-outline ${quotedArg(filePath)}`,
+      `Query subtree: token-goat json-query ${quoted} ${query}`,
+      isSpill ? `Slice spill: token-goat mcp-output --file ${quoted} --json-query ${query}` : ""
+    ].filter(Boolean).join("\n")
+  };
+}
+function handleYaml(filePath, content, contentLengthHint) {
+  const length = contentLengthHint ?? content.length;
+  if (length < FILE_TYPE_THRESHOLDS.yaml) return { shouldBlock: false, message: "" };
+  return {
+    shouldBlock: true,
+    message: [
+      `Large YAML file (${formatBytes(length)}).`,
+      `See structure: token-goat yaml-outline ${quotedArg(filePath)}`,
+      `Query subtree: token-goat yaml-query ${quotedArgs(filePath, "<path>").join(" ")}`
+    ].join("\n")
+  };
+}
+function handleJsonl(filePath, content, contentLengthHint) {
+  const length = contentLengthHint ?? content.length;
+  if (length < FILE_TYPE_THRESHOLDS.jsonl) return { shouldBlock: false, message: "" };
+  if (previewUnavailable(content, length)) {
+    return {
+      shouldBlock: true,
+      message: `Large JSON Lines file (${formatBytes(length)}) \u2014 too large to preview (exceeds the in-hook scan cap). Slice records with Read using offset and limit (each line is a single JSON record).`
+    };
+  }
+  const lines = content.split(/\r?\n/).filter((l) => l.trim().length > 0);
+  let schema = "";
+  if (lines.length > 0) {
+    try {
+      const firstObj = JSON.parse(lines[0]);
+      if (typeof firstObj === "object" && firstObj !== null && !Array.isArray(firstObj)) {
+        const keys = Object.keys(firstObj).slice(0, 15);
+        schema = `Record keys: ${keys.join(", ")}${Object.keys(firstObj).length > 15 ? "..." : ""}`;
+      }
+    } catch {
+    }
+  }
+  return {
+    shouldBlock: true,
+    message: [
+      `Large JSON Lines file (${formatBytes(length)}, ~${lines.length} records).`,
+      schema ? fenceUntrustedFileContent(schema) : "",
+      `Slice records with Read using offset and limit (each line is a single JSON record), e.g. offset=1, limit=5.`
+    ].filter(Boolean).join("\n")
+  };
+}
+function handleGenericLarge(filePath, contentLength) {
+  if (contentLength < FILE_TYPE_THRESHOLDS.generic) return { shouldBlock: false, message: "" };
+  return {
+    shouldBlock: true,
+    message: `Large file (${formatBytes(contentLength)}). Use Read with offset and limit parameters to read specific line ranges rather than loading the entire file.`
+  };
+}
+function dispatchFileTypeHandler(filePath, content, contentLengthHint) {
+  const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+  if (["md", "mdx", "markdown", "rst"].includes(ext)) return null;
+  const effectiveLength = contentLengthHint ?? content.length;
+  if (ext === "pdf") return handlePdf(filePath, effectiveLength);
+  if (ext === "svg") return handleSvg(filePath, content, effectiveLength);
+  if (["xml", "dtsx", "ampkg", "xaml"].includes(ext)) return handleXml(filePath, content, effectiveLength);
+  if (["html", "htm", "xhtml"].includes(ext)) return handleHtml(filePath, content, effectiveLength);
+  if (["txt", "log", "out", "err", "trace"].includes(ext)) return handleTxt(filePath, content, effectiveLength);
+  if (ext === "xlsx") return handleXlsx(filePath);
+  if (ext === "pptx") return handlePptx(filePath);
+  if (ext === "docx") return handleDocx(filePath);
+  if (["odt", "ods", "ott", "odp"].includes(ext)) return handleOfficeBinary(filePath);
+  if (["sqlite", "db", "sqlite3", "db3"].includes(ext)) return handleSqlite(filePath);
+  if (ext === "parquet") return handleParquet(filePath);
+  if (ext === "csv" || ext === "tsv") return handleCsv(filePath, content, effectiveLength);
+  if (ext === "vtt" || ext === "srt") return handleTranscript(filePath, content, effectiveLength);
+  if (ext === "json") return handleJson(filePath, content, effectiveLength);
+  if (["yaml", "yml"].includes(ext)) return handleYaml(filePath, content, effectiveLength);
+  if (ext === "jsonl") return handleJsonl(filePath, content, effectiveLength);
+  return handleGenericLarge(filePath, effectiveLength);
+}
+
+// src/image_shrink.ts
+init_define_import_meta_env();
+import { createHash } from "node:crypto";
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+var DEFAULT_MAX_DIMENSION = 1568;
+var VISION_PATCH_PX = 28;
+var VISION_TIER_LIMITS = {
+  standard: { maxEdge: 1568, maxTokens: 1568 },
+  high: { maxEdge: 2576, maxTokens: 4784 }
+};
+function countImagePatches(width, height) {
+  return Math.ceil(width / VISION_PATCH_PX) * Math.ceil(height / VISION_PATCH_PX);
+}
+function roundTiesToEven(value) {
+  const floor = Math.floor(value);
+  if (value - floor !== 0.5) return Math.round(value);
+  return floor % 2 === 0 ? floor : floor + 1;
+}
+function fitsVisionLimits(width, height, maxEdge, maxTokens) {
+  return Math.ceil(width / VISION_PATCH_PX) * VISION_PATCH_PX <= maxEdge && Math.ceil(height / VISION_PATCH_PX) * VISION_PATCH_PX <= maxEdge && countImagePatches(width, height) <= maxTokens;
+}
+function resizedForVision(width, height, maxEdge, maxTokens) {
+  if (fitsVisionLimits(width, height, maxEdge, maxTokens)) return [width, height];
+  if (height > width) {
+    const [resizedH, resizedW] = resizedForVision(height, width, maxEdge, maxTokens);
+    return [resizedW, resizedH];
+  }
+  const aspectRatio = width / height;
+  let lo = 1;
+  let hi = width;
+  while (lo + 1 < hi) {
+    const mid = Math.floor((lo + hi) / 2);
+    if (fitsVisionLimits(mid, Math.max(roundTiesToEven(mid / aspectRatio), 1), maxEdge, maxTokens)) lo = mid;
+    else hi = mid;
+  }
+  return [lo, Math.max(roundTiesToEven(lo / aspectRatio), 1)];
+}
+function visionTokens(width, height, tier) {
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width < 1 || height < 1) return 0;
+  const limits = VISION_TIER_LIMITS[tier];
+  const [w, h] = resizedForVision(Math.floor(width), Math.floor(height), limits.maxEdge, limits.maxTokens);
+  return countImagePatches(w, h);
+}
+function visionTokensSaved(fromWidth, fromHeight, toWidth, toHeight, tier) {
+  return Math.max(0, visionTokens(fromWidth, fromHeight, tier) - visionTokens(toWidth, toHeight, tier));
+}
+function visionTierMaxTokens(tier) {
+  return VISION_TIER_LIMITS[tier].maxTokens;
+}
+function visionTokensSavedByText(width, height, emittedBytes, tier) {
+  const imageSide = width === null || height === null ? visionTierMaxTokens(tier) : visionTokens(width, height, tier);
+  return Math.max(0, imageSide - savedTokensFromBytes(emittedBytes));
+}
+var DEFAULT_SIZE_THRESHOLD_BYTES = 512 * 1024;
+var SINGLE_FRAME_DECODERS = /* @__PURE__ */ new Map([
+  ["png", (input) => decodePng(input)],
+  ["jpeg", (input) => decodeJpeg(input)],
+  ["bmp", (input) => decodeBmp(input)],
+  // The still-image path wants frame 0 and nothing else. Decoding the whole animation to index into it costs a full canvas per frame for frames that are then dropped, and a file can declare far more of them than it contains pixels.
+  ["gif", (input) => {
+    const decoded = decodeGif(input, { maxFrames: 1 });
+    const frame = decoded.frames[0];
+    return frame === void 0 ? null : { data: frame.data, width: frame.width, height: frame.height };
+  }]
+]);
+function canShrinkFormat(format) {
+  return format != null && SINGLE_FRAME_DECODERS.has(format);
+}
+function decoderRefusal(input, format) {
+  const decode = SINGLE_FRAME_DECODERS.get(format ?? "");
+  if (decode === void 0) return null;
+  try {
+    decode(input);
+    return null;
+  } catch (e) {
+    return e instanceof Error ? e.message : String(e);
+  }
+}
+function formatShrinkSummary(result, subject) {
+  const saved = result.originalBytes - result.shrunkBytes;
+  const pct = Math.round(saved / result.originalBytes * 100);
+  const summary = `token-goat shrank ${subject}: ${toKB(result.originalBytes)}kb -> ${toKB(result.shrunkBytes)}kb (${pct}% smaller, ${result.width}x${result.height} ${result.format}).`;
+  const dataUrl = `data:image/${result.format};base64,${result.data.toString("base64")}`;
+  return { summary, dataUrl };
+}
+var ImageDecodeError = class extends Error {
+};
+async function probeAnyMeta(input) {
+  const meta = probeBufferMeta(input);
+  if (meta !== null || input.length < 16 || input.toString("latin1", 4, 8) !== "ftyp") return meta;
+  const { probeIsoBmffMeta } = await import("./token-goat-chunk-UA5V6P3P.mjs");
+  const isoBmff = probeIsoBmffMeta(input);
+  return isoBmff === null ? null : { ...isoBmff, pages: 1 };
+}
+async function probeImageMeta(input) {
+  const meta = await probeAnyMeta(input);
+  if (meta === null) {
+    throw new ImageDecodeError("image could not be decoded");
+  }
+  const cfg = loadConfig().image_shrink;
+  const limitInputPixels = cfg.max_image_pixels > 0 ? cfg.max_image_pixels : false;
+  if (limitInputPixels !== false && meta.width * meta.height > limitInputPixels) {
+    throw new ImageDecodeError(`Input image exceeds pixel limit ${limitInputPixels}`);
+  }
+  return {
+    width: meta.width,
+    height: meta.height,
+    format: meta.format,
+    pages: meta.pages,
+    ...meta.orientation === void 0 ? {} : { orientation: meta.orientation }
+  };
+}
+async function exceedsConfiguredPixelLimit(input) {
+  const meta = await probeAnyMeta(input);
+  if (meta === null) return false;
+  const cfg = loadConfig().image_shrink;
+  const limitInputPixels = cfg.max_image_pixels > 0 ? cfg.max_image_pixels : false;
+  return limitInputPixels !== false && meta.width * meta.height > limitInputPixels;
+}
+async function imageQualifiesForShrink(input) {
+  try {
+    const meta = await probeImageMeta(input);
+    if (meta === null) return false;
+    if (!canShrinkFormat(meta.format)) return false;
+    if (input.length >= DEFAULT_SIZE_THRESHOLD_BYTES) return true;
+    return Math.max(meta.width, meta.height) > DEFAULT_MAX_DIMENSION;
+  } catch {
+    return false;
+  }
+}
+async function shrinkImage(input, opts) {
+  const cfg = loadConfig().image_shrink;
+  const maxDimension = opts?.maxDimension ?? DEFAULT_MAX_DIMENSION;
+  const quality = opts?.quality ?? cfg.jpeg_quality;
+  const sizeThreshold = opts?.sizeThresholdBytes ?? DEFAULT_SIZE_THRESHOLD_BYTES;
+  const originalBytes = input.length;
+  if (originalBytes < sizeThreshold) return null;
+  let inputMeta;
+  try {
+    inputMeta = await probeImageMeta(input);
+  } catch {
+    return null;
+  }
+  if (!inputMeta || inputMeta.width <= 0 || inputMeta.height <= 0) return null;
+  try {
+    const isAnimated = (inputMeta.pages ?? 1) > 1;
+    const { width: targetW, height: targetH } = calculateFitInside(inputMeta.width, inputMeta.height, maxDimension);
+    if (isAnimated && inputMeta.format === "gif") {
+      const decodedGif = decodeGif(input);
+      const { encodeAnimatedGifDelta } = await import("./token-goat-chunk-ZFOBKUWH.mjs");
+      const data2 = encodeAnimatedGifDelta(decodedGif, targetW, targetH);
+      if (data2.length >= originalBytes) return null;
+      return {
+        data: data2,
+        originalBytes,
+        shrunkBytes: data2.length,
+        originalWidth: inputMeta.width,
+        originalHeight: inputMeta.height,
+        width: targetW,
+        height: targetH,
+        format: "gif"
+      };
+    }
+    const decode = SINGLE_FRAME_DECODERS.get(inputMeta.format ?? "");
+    if (!decode) return null;
+    const decoded = decode(input);
+    if (decoded === null) return null;
+    const oriented = applyExifOrientation(decoded.data, decoded.width, decoded.height, inputMeta.orientation);
+    const dstRgba = resizeRgba(oriented.data, oriented.width, oriented.height, targetW, targetH);
+    const jpegBuf = encodeJpeg(targetW, targetH, dstRgba, quality);
+    const pngBuf = encodePng(targetW, targetH, dstRgba);
+    let data = jpegBuf;
+    let format = "jpeg";
+    if (pngBuf.length < jpegBuf.length) {
+      data = pngBuf;
+      format = "png";
+    }
+    if (data.length >= originalBytes) return null;
+    return {
+      data,
+      originalBytes,
+      shrunkBytes: data.length,
+      originalWidth: inputMeta.width,
+      originalHeight: inputMeta.height,
+      width: targetW,
+      height: targetH,
+      format
+    };
+  } catch {
+    return null;
+  }
+}
+function statInfo(absPath) {
+  try {
+    const st = fs2.statSync(absPath);
+    return st.isFile() ? { size: st.size, mtimeMs: st.mtimeMs } : null;
+  } catch {
+    return null;
+  }
+}
+function imageShrinkCacheDir() {
+  return path2.join(tokenGoatHome(), "image_shrink_cache");
+}
+var SHRINK_ENGINE_REVISION = 3;
+function shrinkCacheKeyForRevision(revision, originalPath, size, mtimeMs, quality) {
+  return createHash("sha256").update(`r${revision}:${originalPath}:${size}:${mtimeMs}:${quality}`).digest("hex").slice(0, 16);
+}
+function shrinkCacheKey(originalPath, size, mtimeMs, quality) {
+  return shrinkCacheKeyForRevision(SHRINK_ENGINE_REVISION, originalPath, size, mtimeMs, quality);
+}
+var SHRINK_CACHE_EXTENSION = /* @__PURE__ */ new Map([
+  ["jpeg", ".jpg"],
+  ["png", ".png"],
+  ["gif", ".gif"]
+]);
+var SHRINK_CACHE_FORMAT = /* @__PURE__ */ new Map([
+  [".jpg", "jpeg"],
+  [".png", "png"],
+  [".gif", "gif"],
+  [".webp", "webp"]
+]);
+function findCachedShrink(originalPath, size, mtimeMs, quality) {
+  const prefix = `token-goat-shrink-${shrinkCacheKey(originalPath, size, mtimeMs, quality)}-`;
+  const dir = imageShrinkCacheDir();
+  let entries;
+  try {
+    entries = fs2.readdirSync(dir);
+  } catch {
+    return null;
+  }
+  for (const file of entries) {
+    if (!file.startsWith(prefix)) continue;
+    const m = /^(\d+)x(\d+)(\.webp|\.jpg|\.png|\.gif)$/.exec(file.slice(prefix.length));
+    if (m === null) continue;
+    const format = SHRINK_CACHE_FORMAT.get(m[3] ?? "");
+    if (format === void 0) continue;
+    return {
+      filePath: path2.join(dir, file),
+      format,
+      originalWidth: Number(m[1]),
+      originalHeight: Number(m[2])
+    };
+  }
+  return null;
+}
+function writeCachedShrink(originalPath, result, mtimeMs, quality) {
+  try {
+    const dir = imageShrinkCacheDir();
+    ensureDirSync(dir);
+    const key = shrinkCacheKey(originalPath, result.originalBytes, mtimeMs, quality);
+    const ext = SHRINK_CACHE_EXTENSION.get(result.format);
+    if (ext === void 0) return;
+    atomicWriteBytes(path2.join(dir, `token-goat-shrink-${key}-${result.originalWidth}x${result.originalHeight}${ext}`), result.data);
+  } catch {
+  }
+}
+var SHRINK_CACHE_PRUNE_THROTTLE_MS = 6e4;
+var lastShrinkCachePruneAtMs = 0;
+function pruneShrinkCache() {
+  const now = Date.now();
+  if (now - lastShrinkCachePruneAtMs < SHRINK_CACHE_PRUNE_THROTTLE_MS) return;
+  lastShrinkCachePruneAtMs = now;
+  try {
+    const dir = imageShrinkCacheDir();
+    if (!fs2.existsSync(dir)) return;
+    const cutoff = now - DEFAULT_MAX_AGE_MS;
+    for (const file of fs2.readdirSync(dir)) {
+      if (!file.startsWith("token-goat-shrink-")) continue;
+      const full = path2.join(dir, file);
+      try {
+        const st = fs2.statSync(full);
+        if (st.mtimeMs < cutoff) fs2.unlinkSync(full);
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+var HOST_MATERIALIZED_HARNESSES = /* @__PURE__ */ new Set(["copilot_cli", "pi", "openclaw"]);
+var PATH_REWRITE_HARNESSES = /* @__PURE__ */ new Set(["vscode", "claudecode"]);
+async function finalizeShrinkResult(result, filePath, event) {
+  const basename5 = displaySafePath(path2.basename(filePath));
+  const harness = detectHarness();
+  if (PATH_REWRITE_HARNESSES.has(harness)) {
+    const file = materializeShrunkImageFile(formatShrinkSummary(result, basename5).dataUrl);
+    if (file === void 0) return passOutput();
+    const cwd = getCwd(event) ?? process.cwd();
+    const rewrite = permissionNeutralRewrite({ ...event.toolInput, file_path: file }, { kind: "read", harness, mode: event.raw["permission_mode"], cwd, original: filePath, rewritten: file, insideCwd: vscodePathAllowed(filePath, cwd), agentType: agentTypeOf(event.raw) });
+    if (rewrite === null) {
+      try {
+        fs2.unlinkSync(file);
+      } catch {
+      }
+      return passOutput();
+    }
+    if (deliveryReplacesRead(harness, rewrite)) recordSavedShrink(result, basename5);
+    recordFileRead(filePath);
+    return rewrite;
+  }
+  const { summary, dataUrl } = formatShrinkSummary(result, basename5);
+  recordFileRead(filePath);
+  return contextOutput(`${summary}
+${dataUrl}`);
+}
+function deliveryReplacesRead(harness, output) {
+  return output.hookType === "rewriteInput" && PATH_REWRITE_HARNESSES.has(harness);
+}
+function shrinkCanReplaceRead(harness) {
+  return PATH_REWRITE_HARNESSES.has(harness) || HOST_MATERIALIZED_HARNESSES.has(harness) || harness === "generic";
+}
+function recordSavedShrink(result, basename5) {
+  const tier = loadConfig().image_shrink.vision_tier;
+  recordStat("image_shrink", result.originalBytes - result.shrunkBytes, visionTokensSaved(result.originalWidth, result.originalHeight, result.width, result.height, tier), void 0, basename5);
+}
+async function preReadImageHandler(event) {
+  if (loadConfig().image_shrink.enabled === false) return passOutput();
+  const vscodeTool = event.raw[VSCODE_TOOL_NAME_KEY];
+  if (vscodeTool !== void 0 && vscodeTool !== "view_image") return passOutput();
+  const filePath = getFilePath(event);
+  if (filePath === void 0) return passOutput();
+  if (!isImagePath(filePath)) return passOutput();
+  if (preToolPathDeclined(event, filePath)) return passOutput();
+  const harness = detectHarness();
+  if ((harness === "claudecode" || harness === "copilot_cli") && !vscodePathAllowed(filePath, getCwd(event))) return passOutput();
+  if (!shrinkCanReplaceRead(harness)) return passOutput();
+  pruneShrinkCache();
+  const stat = statInfo(filePath);
+  if (stat === null) return passOutput();
+  const quality = loadConfig().image_shrink.jpeg_quality;
+  const cached = findCachedShrink(filePath, stat.size, stat.mtimeMs, quality);
+  if (cached !== null) {
+    let cachedData;
+    try {
+      cachedData = fs2.readFileSync(cached.filePath);
+    } catch {
+      cachedData = null;
+    }
+    let meta = null;
+    if (cachedData !== null) {
+      try {
+        meta = await probeImageMeta(cachedData);
+      } catch {
+        meta = null;
+      }
+    }
+    if (cachedData !== null && meta !== null) {
+      const result2 = {
+        data: cachedData,
+        originalBytes: stat.size,
+        shrunkBytes: cachedData.length,
+        originalWidth: cached.originalWidth,
+        originalHeight: cached.originalHeight,
+        width: meta.width,
+        height: meta.height,
+        format: cached.format
+      };
+      return finalizeShrinkResult(result2, filePath, event);
+    }
+    try {
+      fs2.unlinkSync(cached.filePath);
+    } catch {
+    }
+  }
+  let input;
+  try {
+    input = fs2.readFileSync(filePath);
+  } catch {
+    return passOutput();
+  }
+  if (!await imageQualifiesForShrink(input)) {
+    if (await exceedsConfiguredPixelLimit(input)) recordStat("image_shrink_over_pixel_limit");
+    return passOutput();
+  }
+  const result = await shrinkImage(input, { quality, sizeThresholdBytes: 0 });
+  if (result === null) {
+    recordStat("image_shrink_skipped");
+    return passOutput();
+  }
+  writeCachedShrink(filePath, result, stat.mtimeMs, quality);
+  return finalizeShrinkResult(result, filePath, event);
+}
+registerHook("pre_tool_use", loadingHiddenRuleCheck(preReadImageHandler), { toolName: "Read" });
+
+// src/hooks_read.ts
+init_define_import_meta_env();
+import * as fs8 from "node:fs";
+import * as path6 from "node:path";
+
+// src/hint_target.ts
+init_define_import_meta_env();
+import { openSync, readSync, closeSync, statSync as statSync2 } from "node:fs";
+
+// src/index_freshness.ts
+init_define_import_meta_env();
+function indexMatchesDisk(resolved) {
+  const entry = getFileEntry(resolved);
+  if (entry === null) return false;
+  if (entry.sha === "") return false;
+  const diskSha = fingerprintFile(hostPathOfIndexKey(resolved));
+  return diskSha !== null && diskSha === entry.sha;
+}
+
+// src/hint_target.ts
+var HINT_PLACEHOLDERS = { section: "SectionHeading", symbol: "SymbolName", key: "KEY_NAME", table: "table_name" };
+var HINT_TARGET_SCAN_BYTES = 32 * 1024;
+var HINT_TARGET_INDEX_ROWS = 500;
+var HINT_TARGET_CANDIDATES = 20;
+var MAX_HINT_NAME_CHARS = 120;
+var DECLARATION_WORDS = /^(?:def|class|function|async|export|default|interface|type|const|enum)$/;
+var SECTION_PATH_RE = /\.(?:md|mdx|markdown|rst|txt|html?|toml|ini|cfg|conf)$/i;
+var TABLE_HEADER_PATH_RE = /\.(?:toml|ini|cfg|conf)$/i;
+var KEY_PATH_RE = /\.(?:jsonc?|ya?ml|properties|env)$/i;
+var ENV_BASENAME_RE = /(?:^|[\\/])\.env(?:\.[\w.-]+)?$/i;
+var SLICE_KINDS = {
+  section: /* @__PURE__ */ new Set(["heading", "section"]),
+  key: /* @__PURE__ */ new Set(["property", "key", "env_key"]),
+  table: /* @__PURE__ */ new Set(["sql_table", "sql_type", "sql_view"])
+};
+var JSON_FIRST_KEY_RE = /^\s*\{\s*"((?:[^"\\\r\n]|\\.)*)"\s*:/;
+var YAML_KEY_RE = /^([A-Za-z_][\w.-]*)[ \t]*:/gm;
+var ENV_KEY_RE = /^(?:export[ \t]+)?([A-Za-z_][\w.-]*)[ \t]*[=:]/gm;
+var TABLE_HEADER_RE = /^[ \t]*\[([^[\]\r\n]+)\]/gm;
+var SQL_CREATE_RE = /\bCREATE\s+(?:(?:OR\s+REPLACE|TEMP|TEMPORARY|UNLOGGED)\s+)*(?:TABLE|TYPE|VIEW)\s+(?:IF\s+NOT\s+EXISTS\s+)?(?:"([^"\r\n]+)"|`([^`\r\n]+)`|\[([^\]\r\n]+)\]|([\w.]+))/gi;
+var HEADING_LEVEL_RE = /^\s*(#{1,6})\s/;
+var SETEXT_DASH_RE = /\n[ \t]*-{3,}[ \t]*$/;
+var SETEXT_UNDERLINE_RE = /\n[ \t]*([=-])\1*[ \t]*$/;
+function headingLevel(body) {
+  const atx = HEADING_LEVEL_RE.exec(body)?.[1]?.length;
+  if (atx !== void 0) return atx;
+  const underline = SETEXT_UNDERLINE_RE.exec(body)?.[1];
+  return underline === "=" ? 1 : underline === "-" ? 2 : 0;
+}
+function sliceForPath(filePath) {
+  if (/\.sql$/i.test(filePath)) return "table";
+  if (KEY_PATH_RE.test(filePath) || ENV_BASENAME_RE.test(filePath)) return "key";
+  if (SECTION_PATH_RE.test(filePath)) return "section";
+  return "symbol";
+}
+function escapeHintName(name) {
+  const trimmed = name.trim();
+  if (trimmed === "" || displaySafeText(trimmed) !== trimmed) return "";
+  const probe = "token-goat read " + quotedArg(trimmed);
+  return stripUnsafeSuggestions(probe) === probe ? trimmed : "";
+}
+function quotable(raw, slice) {
+  const name = raw.trim();
+  if (name === "" || name.length > MAX_HINT_NAME_CHARS || name.includes("\\") || name.includes("::")) return null;
+  if (slice === "key" && name.includes('"')) return null;
+  return escapeHintName(name) === "" ? null : name;
+}
+function continuesName(text, i, step) {
+  const ch = text[i];
+  if (ch === void 0) return false;
+  if (/\w/.test(ch)) return true;
+  return (ch === "-" || ch === "$") && /\w/.test(text[i + step] ?? "");
+}
+function namedIn(text, name) {
+  for (let at = text.indexOf(name); at !== -1; at = text.indexOf(name, at + 1)) {
+    if (!continuesName(text, at - 1, -1) && !continuesName(text, at + name.length, 1)) return true;
+  }
+  return false;
+}
+function pickForPattern(candidates, pattern, slice) {
+  const section = slice === "section";
+  const held = Array.from(new Set(candidates.flatMap((c) => quotable(c.name, slice) ?? [])));
+  const text = pattern.replace(/\\[A-Za-z]/g, " ");
+  if (!section) {
+    const heldSet = new Set(held);
+    const pair = Array.from(text.matchAll(/([A-Za-z_$][\w$]*)\.([A-Za-z_$][\w$]*)/g)).find((m) => heldSet.has(m[1]) && heldSet.has(m[2]));
+    if (pair !== void 0) return pair[1] + "." + pair[2];
+  }
+  const counts = /* @__PURE__ */ new Map();
+  for (const c of candidates) counts.set(c.name.trim(), (counts.get(c.name.trim()) ?? 0) + 1);
+  const named = held.filter((name) => (section || !DECLARATION_WORDS.test(name)) && (!section || counts.get(name) === 1) && namedIn(text, name));
+  return named.sort((a, b) => b.length - a.length)[0] ?? null;
+}
+function pick(candidates, slice) {
+  const usable = candidates.flatMap((c) => {
+    const name = quotable(c.name, slice);
+    return name === null ? [] : [{ name, level: c.level }];
+  });
+  if (slice !== "section") return usable[0]?.name ?? null;
+  const counts = /* @__PURE__ */ new Map();
+  for (const c of candidates) counts.set(c.name.trim(), (counts.get(c.name.trim()) ?? 0) + 1);
+  const unique = usable.filter((c) => counts.get(c.name) === 1);
+  const first = unique[0];
+  if (first === void 0) return null;
+  const top = Math.min(...unique.map((c) => c.level));
+  const loneTitle = first.level === top && unique.filter((c) => c.level === top).length === 1;
+  return loneTitle && unique.length > 1 ? unique[1].name : first.name;
+}
+function scanText(text, filePath, slice) {
+  const head = text.length > HINT_TARGET_SCAN_BYTES ? text.slice(0, text.lastIndexOf("\n", HINT_TARGET_SCAN_BYTES)) : text;
+  const all = (re) => Array.from(head.matchAll(re), (m) => ({ name: m.slice(1).find((g) => g !== void 0) ?? "", level: 0 })).slice(0, HINT_TARGET_CANDIDATES);
+  switch (slice) {
+    case "section": {
+      if (TABLE_HEADER_PATH_RE.test(filePath)) return all(TABLE_HEADER_RE);
+      const metaEnd = frontMatterEnd(head);
+      return extractMarkdownHeadings(head).filter((h) => h.lineNumber > metaEnd).map((h) => ({ name: h.text, level: h.level }));
+    }
+    case "table":
+      return all(SQL_CREATE_RE);
+    case "key": {
+      if (/\.jsonc?$/i.test(filePath)) {
+        const first = JSON_FIRST_KEY_RE.exec(head)?.[1];
+        return first === void 0 ? [] : [{ name: first, level: 0 }];
+      }
+      return all(/\.ya?ml$/i.test(filePath) ? YAML_KEY_RE : ENV_KEY_RE);
+    }
+    case "symbol":
+      return extractQuickSymbolSamples(head, filePath, HINT_TARGET_CANDIDATES).map((name) => ({ name, level: 0 }));
+  }
+}
+function frontMatterEnd(text) {
+  if (!/^---\r?\n/.test(text)) return 0;
+  const close = text.split(/\r?\n/).findIndex((line, i) => i > 0 && /^(?:---|\.\.\.)\s*$/.test(line));
+  return close === -1 ? 0 : close + 1;
+}
+function readHead(onDisk) {
+  const fd = openSync(onDisk, "r");
+  try {
+    const buf = Buffer.alloc(HINT_TARGET_SCAN_BYTES);
+    const n = readSync(fd, buf, 0, buf.length, 0);
+    const text = buf.subarray(0, n).toString("utf8");
+    return n < buf.length ? text : text.slice(0, text.lastIndexOf("\n") + 1);
+  } finally {
+    closeSync(fd);
+  }
+}
+function indexedCandidates(resolved, onDisk, slice) {
+  if (!indexMatchesDisk(resolved)) return null;
+  const kinds = slice === "symbol" ? null : SLICE_KINDS[slice];
+  const rows = querySymbols({ filePath: resolved, limit: HINT_TARGET_INDEX_ROWS }).filter((s) => kinds === null || kinds.has(s.kind));
+  const metaEnd = slice === "section" && rows.some((s) => SETEXT_DASH_RE.test(s.body)) ? frontMatterEnd(readHead(onDisk)) : 0;
+  return rows.filter((s) => s.lineStart > metaEnd).map((s) => ({ name: s.name, level: s.kind === "heading" ? headingLevel(s.body) : 0 }));
+}
+var MORE_HEADINGS_LINE_RE = /^ {2}\.\.\. \(\d+ more headings\)$/;
+function headingTreeParts(headings, filePath, content) {
+  const parts = formatHeadingTreeParts(headings, filePath);
+  const total = extractMarkdownHeadings(content, Number.MAX_SAFE_INTEGER).length;
+  if (total <= headings.length) return parts;
+  const guidance = parts.guidance.replace(`Large markdown file (${headings.length} headings)`, () => `Large markdown file (showing the first ${headings.length} of ${total} headings)`);
+  const lines = parts.sectionsList.split("\n");
+  const kept = lines.filter((l) => !MORE_HEADINGS_LINE_RE.test(l));
+  return { guidance, sectionsList: [...kept, `  ... (${countNoun(total - kept.length, "more heading")})`].join("\n") };
+}
+function hintTargetFromNames(names, slice) {
+  const found = pick(names.filter((name) => name === name.trim()).map((name) => ({ name, level: 0 })), slice);
+  return found === null ? { name: HINT_PLACEHOLDERS[slice], real: false, slice } : { name: found, real: true, slice };
+}
+function hintTarget(filePath, slice, source = {}) {
+  const found = (() => {
+    try {
+      if (source.headings !== void 0 && slice === "section") {
+        const metaEnd = frontMatterEnd(source.content ?? "");
+        const name = pick(source.headings.filter((h) => h.lineNumber > metaEnd).map((h) => ({ name: h.text, level: h.level })), slice);
+        if (name !== null) return name;
+      }
+      if (source.content !== void 0) return pick(scanText(source.content, filePath, slice), slice);
+      if (source.cwd !== void 0 && !commandPathIsTouchable(filePath, source.event)) return null;
+      const resolved = source.cwd !== void 0 ? resolveIndexPath(filePath, source.cwd) : filePath;
+      const onDisk = hostPathOfIndexKey(resolved);
+      if (!statSync2(onDisk).isFile()) return null;
+      const indexed = indexedCandidates(resolved, onDisk, slice);
+      const byPattern = (c) => source.pattern === void 0 || slice !== "symbol" && slice !== "section" ? null : pickForPattern(c, source.pattern, slice);
+      const fromIndex = indexed === null ? null : byPattern(indexed) ?? pick(indexed, slice);
+      if (fromIndex !== null) return fromIndex;
+      const scanned = scanText(readHead(onDisk), resolved, slice);
+      return byPattern(scanned) ?? pick(scanned, slice);
+    } catch {
+      return null;
+    }
+  })();
+  return found === null ? { name: source.placeholder ?? HINT_PLACEHOLDERS[slice], real: false, slice } : { name: found, real: true, slice };
+}
+function sliceCommand(shownPath, target) {
+  switch (target.slice) {
+    case "section":
+      return "token-goat section " + quotedArg(shownPath + "::" + target.name);
+    case "key": {
+      const format = structuredFormat(shownPath);
+      if (format === null) return configGetCommand(shownPath, target.name);
+      if (/^[\w-]+$/.test(target.name)) return "token-goat " + format + "-query " + quotedArgs(shownPath, target.name).join(" ");
+      if (!target.name.includes("'")) return "token-goat " + format + "-query " + quotedArgs(shownPath, "['" + target.name + "']").join(" ");
+      return "token-goat " + format + "-outline " + quotedArg(shownPath);
+    }
+    case "symbol":
+    case "table":
+      return "token-goat read " + quotedArg(shownPath + "::" + target.name);
+  }
+}
+var NO_HEADING_RANGE_LINES = 80;
+function sectionOrRangeCommand(shownPath, heading) {
+  return heading.real ? sliceCommand(shownPath, heading) : "token-goat read " + quotedArg(shownPath + "::1-" + NO_HEADING_RANGE_LINES);
+}
+var JSON_LOCK_BASENAMES = /* @__PURE__ */ new Set(["package-lock.json", "pipfile.lock", "composer.lock", "package.resolved"]);
+var YAML_LOCK_BASENAMES = /* @__PURE__ */ new Set(["pnpm-lock.yaml", "pubspec.lock"]);
+function structuredFormat(shownPath) {
+  const base = (shownPath.split("/").pop() ?? "").toLowerCase();
+  if (JSON_LOCK_BASENAMES.has(base) || /\.jsonc?$/.test(base)) return "json";
+  if (YAML_LOCK_BASENAMES.has(base) || /\.ya?ml$/.test(base)) return "yaml";
+  return null;
+}
+function fileQueryHint(shownPath, reason = "", grepSubject = "pattern") {
+  const format = structuredFormat(shownPath);
+  if (format !== null) {
+    return leadWithCommand("token-goat " + format + "-outline " + quotedArg(shownPath), "to list the top-level keys, then `token-goat " + format + "-query " + quotedArgs(shownPath, "<key>").join(" ") + "` to read one value", reason);
+  }
+  if (/\.(toml|ini|cfg)$/i.test(shownPath)) return leadWithCommand(configGetCommand(shownPath, "<key>"), "to read one value", reason);
+  if (/\.(xml|csproj)$/i.test(shownPath)) return leadWithCommand("token-goat xml-outline " + quotedArg(shownPath), "to see the element structure, then `token-goat xml-query " + quotedArgs(shownPath, "<path>").join(" ") + "` to read one element", reason);
+  return grepLinesHint("<" + grepSubject + ">", shownPath, reason);
+}
+var LED_COMMAND_RE = /`(token-goat [^`\r\n]+)`/;
+function sharpenRepeatedDeny(event, output) {
+  if (output.hookType !== "deny" || !event.sessionId || DELIVERS_CONTENT_RE.test(output.message)) return output;
+  const key = "deny-repeat:" + sessionStateKey(event) + ":" + (event.toolName ?? "") + ":" + getCompactedAt() + ":" + shortFingerprint(output.message) + ":" + shortFingerprint(JSON.stringify(event.toolInput));
+  if (!wasHintShown(key)) {
+    markHintShown(key);
+    return output;
+  }
+  const command = LED_COMMAND_RE.exec(output.message)?.[1];
+  const lead = command === void 0 ? "" : "Run `" + command + "` instead. ";
+  return { hookType: "deny", message: "[tg] " + lead + "Repeat refusal of this exact call; the earlier refusal this session has the full reason." };
+}
+
+// src/hooks_read_slice.ts
+init_define_import_meta_env();
+import * as fs4 from "node:fs";
+
+// src/snapshots.ts
+init_define_import_meta_env();
+import * as fs3 from "node:fs";
+import * as path3 from "node:path";
+var MAX_SNAPSHOTS_PER_SESSION = 150;
+var MAX_SNAPSHOT_BYTES = 256 * 1024;
+var SNAPSHOT_TRUNCATE_BYTES = 50 * 1024;
+var KIND_READ = "read";
+var KIND_PREDICTIVE = "predictive";
+var VALID_KINDS = /* @__PURE__ */ new Set([KIND_READ, KIND_PREDICTIVE]);
+function sessionDir(sessionId) {
+  if (!sessionId) return null;
+  const safe = sanitizeIdForFilename(sessionId, 64, "anon");
+  const base = path3.join(tokenGoatHome(), "session_snapshots");
+  const candidate = path3.join(base, safe);
+  try {
+    const rel = path3.relative(base, candidate);
+    if (rel.startsWith("..")) return null;
+  } catch {
+    return null;
+  }
+  return candidate;
+}
+function pathKey(filePath) {
+  return fingerprintContent(foldPath(normalizePath(filePath))).slice(0, 32);
+}
+function snapshot_path(sessionId, filePath) {
+  const d = sessionDir(sessionId);
+  if (!d) return null;
+  return path3.join(d, `${pathKey(filePath)}.bin`);
+}
+function kindSidecarPath(snapshotPath) {
+  return snapshotPath + ".kind";
+}
+function readSnapshotKind(sidecarPath) {
+  try {
+    if (!fs3.existsSync(sidecarPath)) return null;
+    const raw = fs3.readFileSync(sidecarPath, "utf8").trim();
+    return VALID_KINDS.has(raw) ? raw : null;
+  } catch {
+    return null;
+  }
+}
+function writeSnapshotKind(sidecarPath, kind) {
+  try {
+    const safeKind = VALID_KINDS.has(kind) ? kind : KIND_READ;
+    const dir = path3.dirname(sidecarPath);
+    if (!fs3.existsSync(dir)) {
+      ensureDirSync(dir);
+    }
+    fs3.writeFileSync(sidecarPath, safeKind, "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function evictOldest(d, maxCount) {
+  try {
+    const entries = [];
+    const files = fs3.readdirSync(d);
+    for (const file of files) {
+      const fullPath = path3.join(d, file);
+      if (!file.endsWith(".bin")) continue;
+      try {
+        const stat = fs3.statSync(fullPath);
+        entries.push([fullPath, stat.mtimeMs]);
+      } catch {
+        continue;
+      }
+    }
+    if (entries.length <= maxCount) return 0;
+    entries.sort((a, b) => a[1] - b[1]);
+    let removed = 0;
+    const over = entries.length - maxCount;
+    for (const [p] of entries.slice(0, over)) {
+      try {
+        fs3.unlinkSync(p);
+        removed++;
+        try {
+          fs3.unlinkSync(kindSidecarPath(p));
+        } catch {
+        }
+      } catch {
+        continue;
+      }
+    }
+    return removed;
+  } catch {
+    return 0;
+  }
+}
+function store(sessionId, filePath, content, opts = {}) {
+  const kind = opts.kind ?? KIND_READ;
+  const origLen = content.length;
+  if (origLen > MAX_SNAPSHOT_BYTES) {
+    return null;
+  }
+  let stored = content;
+  if (origLen > SNAPSHOT_TRUNCATE_BYTES) {
+    const marker = Buffer.from(`
+<snapshot truncated at ${origLen} bytes>
+`);
+    stored = Buffer.concat([content.slice(0, SNAPSHOT_TRUNCATE_BYTES), marker]);
+  }
+  const p = snapshot_path(sessionId, filePath);
+  if (!p) return null;
+  const sha = fingerprintContent(stored);
+  try {
+    const isNewEntry = !fs3.existsSync(p);
+    if (!isNewEntry) {
+      try {
+        const existing = fs3.readFileSync(p);
+        if (Buffer.from(existing).equals(stored)) {
+          const sidecar2 = kindSidecarPath(p);
+          if (readSnapshotKind(sidecar2) !== kind) writeSnapshotKind(sidecar2, kind);
+          return {
+            path: p,
+            content_sha: sha,
+            size_bytes: stored.length
+          };
+        }
+      } catch {
+      }
+    }
+    const dir = path3.dirname(p);
+    if (!fs3.existsSync(dir)) {
+      ensureDirSync(dir);
+    }
+    if (isNewEntry) {
+      evictOldest(dir, MAX_SNAPSHOTS_PER_SESSION - 1);
+    }
+    atomicWriteBytes(p, stored);
+    const sidecar = kindSidecarPath(p);
+    writeSnapshotKind(sidecar, kind);
+    return {
+      path: p,
+      content_sha: sha,
+      size_bytes: stored.length
+    };
+  } catch {
+    return null;
+  }
+}
+function load(sessionId, filePath, opts = {}) {
+  const p = snapshot_path(sessionId, filePath);
+  if (!p || !fs3.existsSync(p)) return null;
+  try {
+    const stat = fs3.statSync(p);
+    if (stat.size > MAX_SNAPSHOT_BYTES) {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+  try {
+    const data = fs3.readFileSync(p);
+    if (opts.expected_sha) {
+      const actualSha = fingerprintContent(data);
+      if (actualSha.toLowerCase() !== opts.expected_sha.toLowerCase()) {
+        return null;
+      }
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+function removeEligibleSnapshotFile(fullPath, file, cutoff) {
+  const stat = fs3.lstatSync(fullPath);
+  if ((stat.mode & 61440) === 40960) return false;
+  if (cutoff !== void 0 && stat.mtimeMs >= cutoff) return false;
+  fs3.unlinkSync(fullPath);
+  return file.endsWith(".bin");
+}
+function cleanup_stale(maxAgeHours = 24) {
+  const base = path3.join(tokenGoatHome(), "session_snapshots");
+  if (!fs3.existsSync(base)) return 0;
+  const cutoff = Date.now() - maxAgeHours * 3600 * 1e3;
+  let removed = 0;
+  try {
+    const sessionDirs = fs3.readdirSync(base);
+    for (const sessionDir2 of sessionDirs) {
+      const sessionPath = path3.join(base, sessionDir2);
+      try {
+        const stat = fs3.statSync(sessionPath);
+        if (!stat.isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      try {
+        const files = fs3.readdirSync(sessionPath);
+        for (const file of files) {
+          const fullPath = path3.join(sessionPath, file);
+          try {
+            if (removeEligibleSnapshotFile(fullPath, file, cutoff)) removed++;
+          } catch {
+            continue;
+          }
+        }
+        try {
+          fs3.rmdirSync(sessionPath);
+        } catch {
+        }
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return removed;
+  }
+  return removed;
+}
+
+// src/hooks_read_slice.ts
+function readIntToolInput(event, key) {
+  const val = event.toolInput[key];
+  const n = typeof val === "number" ? val : typeof val === "string" && val.trim() !== "" ? Number(val) : NaN;
+  return Number.isFinite(n) ? n : void 0;
+}
+var OFFSET_ONLY_EXTRA_LINES = 100;
+function requestedSliceSpan(window) {
+  if (window.offset === void 0) return void 0;
+  return { start: window.offset, end: window.limit !== void 0 ? window.offset + window.limit - 1 : window.offset + OFFSET_ONLY_EXTRA_LINES };
+}
+function rawTextReadHarness(event) {
+  const harness = event.raw["_tg_harness"];
+  return harness === "gemini" || harness === "qwen" || harness === "grok" ? harness : null;
+}
+function readRequestedSliceWindow(event) {
+  const rawOffset = readIntToolInput(event, "offset");
+  const rawLimit = readIntToolInput(event, "limit");
+  if (rawOffset !== void 0 || rawLimit !== void 0) {
+    const harness = rawTextReadHarness(event);
+    const zeroBased = harness === "qwen" || harness === "gemini";
+    const offset = rawOffset === void 0 ? 1 : zeroBased ? rawOffset >= 0 ? Math.floor(rawOffset) + 1 : 1 : rawOffset >= 1 ? Math.floor(rawOffset) : 1;
+    const limit = rawLimit !== void 0 && rawLimit > 0 ? Math.floor(rawLimit) : void 0;
+    const isExplicitSlice = offset > 1 || limit !== void 0 && limit > 0;
+    return {
+      offset,
+      limit,
+      isExplicitSlice
+    };
+  }
+  const rawRange = event.toolInput["view_range"] ?? event.toolInput["lines"] ?? event.toolInput["range"];
+  if (Array.isArray(rawRange) && rawRange.length >= 1) {
+    const rawStart = Number(rawRange[0]);
+    const startVal = Number.isFinite(rawStart) && rawStart >= 1 ? Math.floor(rawStart) : 1;
+    if (rawRange.length >= 2) {
+      const rawEnd = Number(rawRange[1]);
+      if (rawEnd === -1) {
+        return { offset: startVal, isExplicitSlice: startVal > 1 };
+      }
+      if (Number.isFinite(rawEnd) && rawEnd >= startVal) {
+        const lineCount = Math.floor(rawEnd - startVal + 1);
+        return { offset: startVal, limit: lineCount, isExplicitSlice: true };
+      }
+    }
+    return { offset: startVal, isExplicitSlice: startVal > 1 };
+  }
+  const startLine = readIntToolInput(event, "start_line") ?? readIntToolInput(event, "startLine") ?? readIntToolInput(event, "start");
+  const endLine = readIntToolInput(event, "end_line") ?? readIntToolInput(event, "endLine") ?? readIntToolInput(event, "end");
+  if (startLine !== void 0 || endLine !== void 0) {
+    const effectiveStart = startLine !== void 0 && startLine >= 1 ? Math.floor(startLine) : 1;
+    const effectiveLimit = endLine !== void 0 && endLine >= effectiveStart ? Math.floor(endLine - effectiveStart + 1) : void 0;
+    const isExplicitSlice = effectiveStart > 1 || effectiveLimit !== void 0 && effectiveLimit > 0;
+    return { offset: effectiveStart, limit: effectiveLimit, isExplicitSlice };
+  }
+  return { isExplicitSlice: false };
+}
+function readStartLine(event) {
+  if (rawTextReadHarness(event) !== null) {
+    const shown = splitRawReadHeader(readResponseText(event))?.shown;
+    return shown?.start ?? readRequestedSliceWindow(event).offset ?? 1;
+  }
+  const resp = event.raw["tool_response"];
+  const file = resp?.["file"];
+  const start = file?.["startLine"];
+  return typeof start === "number" && Number.isSafeInteger(start) && start >= 1 ? start : 1;
+}
+var HARNESS_TRUNCATION_NOTICE_RE = /^[ \t]*\[Truncated: PARTIAL view/m;
+function harnessNumbersReadContent(event) {
+  const resp = event.raw["tool_response"];
+  if (resp === null || typeof resp !== "object") return false;
+  const fieldPath = resolveToolResponseFieldPath(resp, OUTPUT_FIRST_TOOL_RESPONSE_KEYS);
+  return fieldPath !== null && fieldPath.length === 2 && fieldPath[0] === "file" && fieldPath[1] === "content";
+}
+function numberedRenderBytes(text, startLine) {
+  let bytes = Buffer.byteLength(text, "utf-8");
+  const lines = text.split("\n").length;
+  for (let n = startLine; n < startLine + lines; n++) bytes += String(n).length + 1;
+  return bytes;
+}
+function readResponseText(event) {
+  return extractToolResponseField(event.raw, OUTPUT_FIRST_TOOL_RESPONSE_KEYS);
+}
+var GEMINI_TRUNCATION_OPENER = "IMPORTANT: The file content has been truncated.";
+var GEMINI_STATUS_RE = /^Status: Showing lines (\d+)-(\d+) of (\d+) total lines\.$/;
+var GEMINI_CONTENT_MARKER = "--- FILE CONTENT (truncated) ---";
+var QWEN_STATUS_RE = /^Showing lines (\d+)-(\d+) of (at least )?(\d+) total lines\.$/;
+var LINE_CUT_MARKER_RE = /\.\.\. \[truncated\]$/m;
+function splitRawReadHeader(respText) {
+  const lines = respText.split("\n");
+  const opener = lines[0] === "" ? 1 : 0;
+  if (lines[opener] === GEMINI_TRUNCATION_OPENER) {
+    const marker = lines.indexOf(GEMINI_CONTENT_MARKER, opener + 1);
+    if (marker === -1 || marker > opener + 6) return null;
+    const status2 = lines.slice(opener + 1, marker).map((l) => GEMINI_STATUS_RE.exec(l)).find((m) => m !== null);
+    if (status2 === void 0 || status2 === null) return null;
+    const shown2 = { start: Number(status2[1]), end: Number(status2[2]), total: Number(status2[3]), atLeast: false };
+    return { header: lines.slice(0, marker + 1), body: lines.slice(marker + 1).join("\n"), shown: shown2 };
+  }
+  const status = QWEN_STATUS_RE.exec(lines[0] ?? "");
+  if (status === null) return null;
+  const shown = { start: Number(status[1]), end: Number(status[2]), total: Number(status[4]), atLeast: status[3] !== void 0 };
+  const width = lines[1] === "" && lines[2] === "---" && lines[3] === "" ? 4 : lines[1] === "---" ? 2 : 0;
+  if (width === 0) return null;
+  return { header: lines.slice(0, width), body: lines.slice(width).join("\n"), shown };
+}
+function rawReadCutShort(event, split) {
+  const { shown } = split;
+  if (shown.atLeast) return true;
+  const window = readRequestedSliceWindow(event);
+  const reqStart = window.offset ?? 1;
+  const reqEnd = window.limit !== void 0 ? Math.min(reqStart + window.limit - 1, shown.total) : shown.total;
+  if (shown.start !== reqStart || shown.end < reqEnd) return true;
+  return LINE_CUT_MARKER_RE.test(split.body);
+}
+function isTruncatedReadDelivery(event, respText) {
+  const harness = rawTextReadHarness(event);
+  if (harness === "gemini" || harness === "qwen") {
+    const split = splitRawReadHeader(respText);
+    return split !== null && rawReadCutShort(event, split);
+  }
+  const resp = event.raw["tool_response"];
+  const file = resp?.["file"];
+  if (file?.["truncatedByTokenCap"] === true) return true;
+  return HARNESS_TRUNCATION_NOTICE_RE.test(respText);
+}
+var SLICE_ESTIMATE_SCAN_CAP_BYTES = 2 * 1024 * 1024;
+var NEAR_SINGLE_LINE_SCAN_THRESHOLD = 20;
+function scanRequestedSlice(absPath, offset, limit) {
+  const windowEnd = offset + limit;
+  let fd;
+  try {
+    fd = fs4.openSync(hostPathOfIndexKey(absPath), "r");
+  } catch {
+    return null;
+  }
+  try {
+    const buf = Buffer.alloc(64 * 1024);
+    let lineNumber = 1;
+    let sliceBytes = 0;
+    let totalScanned = 0;
+    let afterCr = false;
+    for (; ; ) {
+      if (totalScanned >= SLICE_ESTIMATE_SCAN_CAP_BYTES) {
+        const nearSingleLine = lineNumber < NEAR_SINGLE_LINE_SCAN_THRESHOLD;
+        return { bytes: sliceBytes, trustworthy: nearSingleLine, nearSingleLine };
+      }
+      const bytesRead = fs4.readSync(fd, buf, 0, buf.length, null);
+      if (bytesRead === 0) {
+        const spansWholeFile = offset <= 1 && lineNumber <= windowEnd;
+        return {
+          bytes: sliceBytes,
+          trustworthy: true,
+          nearSingleLine: lineNumber < NEAR_SINGLE_LINE_SCAN_THRESHOLD && totalScanned > 2e3,
+          spansWholeFile
+        };
+      }
+      totalScanned += bytesRead;
+      for (let i = 0; i < bytesRead; i++) {
+        if (lineNumber >= offset && lineNumber < windowEnd) sliceBytes++;
+        const byte = buf[i];
+        if (byte === 10 && afterCr) {
+          afterCr = false;
+          continue;
+        }
+        afterCr = byte === 13;
+        if (byte === 10 || byte === 13) {
+          lineNumber++;
+          if (lineNumber >= windowEnd) return { bytes: sliceBytes, trustworthy: true, nearSingleLine: false };
+        }
+      }
+    }
+  } finally {
+    try {
+      fs4.closeSync(fd);
+    } catch {
+    }
+  }
+}
+function estimateRequestedSlice(event, absPath) {
+  const window = readRequestedSliceWindow(event);
+  if (window.limit === void 0 || window.limit <= 0) return { kind: "unbounded" };
+  const effectiveOffset = window.offset !== void 0 && window.offset >= 1 ? window.offset : 1;
+  const scan = scanRequestedSlice(absPath, effectiveOffset, window.limit);
+  if (scan === null) return { kind: "unbounded" };
+  if (scan.nearSingleLine) return { kind: "nearSingleLine" };
+  if (scan.trustworthy) return { kind: "bytes", bytes: scan.bytes, spansWholeFile: scan.spansWholeFile === true };
+  return { kind: "unbounded" };
+}
+function isSmallSlice(slice, thresholdBytes, fileSize) {
+  if (slice.kind !== "bytes") return false;
+  if (slice.bytes >= thresholdBytes) return false;
+  if (slice.bytes > SLICE_ESTIMATE_SCAN_CAP_BYTES) return false;
+  if (slice.spansWholeFile === true) return false;
+  if (fileSize !== void 0 && fileSize > 0 && slice.bytes >= fileSize) return false;
+  return true;
+}
+function isUnseenWindow(window, servedRanges, fullReads) {
+  if (!window.isExplicitSlice || fullReads !== 0 || window.offset === void 0 || window.limit === void 0) return false;
+  const start = window.offset;
+  const end = window.offset + window.limit - 1;
+  return !servedRanges.some(([s, e]) => s <= end && e >= start);
+}
+function describeSliceAdvice(slice, rawAbsPath) {
+  const absPath = displaySafePath(rawAbsPath);
+  if (slice.kind === "nearSingleLine") {
+    return BYTE_RANGE_ADVICE(absPath);
+  }
+  if (slice.kind === "bytes") {
+    return `The requested offset/limit range is still ~${toKB(slice.bytes)}KB \u2014 narrow the range further (a smaller limit) rather than reading the whole file.`;
+  }
+  return "Use Read with offset/limit to sample specific sections.";
+}
+function buildLineDiffDetailed(oldContent, newContent, label) {
+  const oldLines = oldContent.split("\n");
+  const newLines = newContent.split("\n");
+  let prefix = 0;
+  while (prefix < oldLines.length && prefix < newLines.length && oldLines[prefix] === newLines[prefix]) {
+    prefix++;
+  }
+  let oldSuffix = oldLines.length;
+  let newSuffix = newLines.length;
+  while (oldSuffix > prefix && newSuffix > prefix && oldLines[oldSuffix - 1] === newLines[newSuffix - 1]) {
+    oldSuffix--;
+    newSuffix--;
+  }
+  if (prefix === oldLines.length && prefix === newLines.length) return { text: "", truncated: false };
+  const changedOld = oldLines.slice(prefix, oldSuffix);
+  const changedNew = newLines.slice(prefix, newSuffix);
+  const MAX_LINES = 50;
+  const removedLines = changedOld.map((l) => `-${l}`);
+  const addedLines = changedNew.map((l) => `+${l}`);
+  const allChanges = [...removedLines, ...addedLines];
+  const shownRemoved = Math.min(removedLines.length, MAX_LINES);
+  const shownAdded = Math.max(0, Math.min(addedLines.length, MAX_LINES - shownRemoved));
+  const out = [
+    `--- ${label} (prev)`,
+    `+++ ${label} (current)`,
+    `@@ -${prefix + 1},${shownRemoved} +${prefix + 1},${shownAdded} @@`
+  ];
+  const truncated = allChanges.length > MAX_LINES;
+  if (!truncated) {
+    out.push(...allChanges);
+  } else {
+    out.push(...allChanges.slice(0, MAX_LINES));
+    out.push(`... (${countNoun(allChanges.length - MAX_LINES, "more changed line")})`);
+  }
+  return { text: out.join("\n"), truncated };
+}
+function buildLineDiff(oldContent, newContent, label) {
+  return buildLineDiffDetailed(oldContent, newContent, label).text;
+}
+function loadSnapshotDiff(sessionId, normalized, basename5) {
+  const oldSnap = load(sessionId, normalized);
+  if (oldSnap === null) return { kind: "none" };
+  try {
+    const onDisk = hostPathOfIndexKey(normalized);
+    const sz = statSize(onDisk);
+    if (sz === null || sz > 256 * 1024) return { kind: "none" };
+    const currentContent = fs4.readFileSync(onDisk, "utf8");
+    const TRUNC_MARKER = "\n<snapshot truncated at ";
+    const oldRaw = oldSnap.toString("utf8");
+    const truncIdx = oldRaw.indexOf(TRUNC_MARKER);
+    if (truncIdx >= 0) return { kind: "none" };
+    const oldContent = oldRaw;
+    if (oldContent === currentContent) return { kind: "unchanged", currentContent };
+    const { text: diff, truncated } = buildLineDiffDetailed(oldContent, currentContent, basename5);
+    if (diff === "") return { kind: "none" };
+    if (truncated) return { kind: "none" };
+    const savedBytes = Math.max(0, currentContent.length - diff.length);
+    return { kind: "diff", diff, savedBytes, currentContent };
+  } catch {
+    return { kind: "none" };
+  }
+}
+function countTextLines(content) {
+  if (content.length === 0) return 0;
+  const parts = content.split(/\r\n|\r|\n/);
+  if (parts[parts.length - 1] === "") parts.pop();
+  return parts.length;
+}
+function estimateTruncatedLineCount(normalized) {
+  try {
+    const onDisk = hostPathOfIndexKey(normalized);
+    const sz = statSize(onDisk);
+    if (sz !== null && sz <= SLICE_ESTIMATE_SCAN_CAP_BYTES) {
+      return countTextLines(fs4.readFileSync(onDisk, "utf8"));
+    }
+  } catch {
+  }
+  return Infinity;
+}
+function editAnywayHint(rawPath) {
+  const [quoted, b64, oldFile, newFile] = quotedArgs(displaySafePath(rawPath), "<base64>", "<oldfile>", "<newfile>");
+  return "To edit it anyway, use `token-goat replace " + quoted + " --old-b64 " + b64 + " --new-b64 " + b64 + "` (preferred \u2014 no temp files needed) or `--old-from " + oldFile + " --new-from " + newFile + "` for a snippet edit, or `token-goat write-file " + quoted + " --b64 " + b64 + "` (or `--from " + newFile + "`) to rewrite the whole file \u2014 Read/Edit's own precondition can't be satisfied after this deny.";
+}
+function truncatedReadDenyMessage(rawPath) {
+  const normalized = displaySafePath(rawPath);
+  const reason = "File was truncated on last read (>33K tokens).";
+  const skeleton = "token-goat skeleton " + quotedArg(normalized);
+  const target = hintTarget(rawPath, sliceForPath(rawPath));
+  return target.real ? leadWithCommand(sliceCommand(normalized, target), "for one part, or " + fencedCommand(skeleton) + " for structure", reason) : leadWithCommand(skeleton, "for structure, or " + fencedCommand("token-goat read " + quotedArg(normalized + "::SymbolName")) + " for one function", reason);
+}
+function readWindowFromDisk(event, normalized) {
+  const onDisk = hostPathOfIndexKey(normalized);
+  const size = statSize(onDisk);
+  if (size === null || size > SLICE_ESTIMATE_SCAN_CAP_BYTES) return null;
+  const text = decodeSource(fs4.readFileSync(onDisk));
+  const window = readRequestedSliceWindow(event);
+  const start = window.offset !== void 0 && window.offset >= 1 ? window.offset : 1;
+  const limit = window.limit;
+  if (start === 1 && (limit === void 0 || limit <= 0)) return text;
+  const lines = text.split("\n");
+  const from = start - 1;
+  return (limit === void 0 || limit <= 0 ? lines.slice(from) : lines.slice(from, from + limit)).join("\n");
+}
+var READ_NUMBERED_ROW_RE = /^\s*(\d+)[\t→](.*)$/;
+function parseReadDelivery(event, respText) {
+  const firstLine = readStartLine(event);
+  const harness = rawTextReadHarness(event);
+  if (harness === "gemini" || harness === "qwen") {
+    const split = splitRawReadHeader(respText);
+    if (split === null) return plainReadResult(respText, firstLine);
+    const parsed = plainReadResult(split.body, firstLine);
+    return parsed === null ? null : { ...parsed, header: split.header };
+  }
+  if (harness === "grok") return wholeNumberedReadResult(respText, firstLine) ?? plainReadResult(respText, firstLine);
+  return harnessNumbersReadContent(event) ? plainReadResult(respText, firstLine) : parseNumberedReadResult(respText, firstLine);
+}
+function wholeNumberedReadResult(respText, firstLine) {
+  const lines = respText.split("\n");
+  const body = lines[lines.length - 1] === "" ? lines.slice(0, -1) : lines;
+  if (body.length === 0) return null;
+  const rows = [];
+  for (const [idx, line] of body.entries()) {
+    const m = READ_NUMBERED_ROW_RE.exec(line);
+    if (m === null || Number(m[1]) !== firstLine + idx) return null;
+    rows.push({ no: firstLine + idx, text: m[2] ?? "", raw: line });
+  }
+  return { header: [], rows, trailer: body.length < lines.length ? [""] : [] };
+}
+function plainReadResult(respText, firstLine) {
+  if (respText === "") return null;
+  return { header: [], rows: respText.split("\n").map((text, idx) => ({ no: firstLine + idx, text, raw: text })), trailer: [] };
+}
+function parseNumberedReadResult(respText, firstLine) {
+  const lines = respText.split("\n");
+  const header = [];
+  const rows = [];
+  const trailer = [];
+  let i = 0;
+  for (; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const m = READ_NUMBERED_ROW_RE.exec(line);
+    if (m === null || !Number.isSafeInteger(Number(m[1]))) {
+      header.push(line);
+      continue;
+    }
+    rows.push({ no: Number(m[1]), text: m[2] ?? "", raw: line });
+    i++;
+    break;
+  }
+  for (; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    const m = READ_NUMBERED_ROW_RE.exec(line);
+    const prev = rows[rows.length - 1];
+    if (m === null || prev === void 0 || Number(m[1]) !== prev.no + 1) break;
+    rows.push({ no: prev.no + 1, text: m[2] ?? "", raw: line });
+  }
+  for (; i < lines.length; i++) trailer.push(lines[i] ?? "");
+  if (rows.length > 0) return { header, rows, trailer };
+  return plainReadResult(respText, firstLine);
+}
+function rereadIdentity(sessionId, normalized, prior) {
+  const onDisk = hostPathOfIndexKey(normalized);
+  let current;
+  try {
+    current = fs4.statSync(onDisk);
+  } catch {
+    return { identity: "unknown", basis: "none" };
+  }
+  const snap = load(sessionId, normalized);
+  if (snap !== null && !snap.includes("\n<snapshot truncated at ") && current.size <= 256 * 1024) {
+    try {
+      return { identity: snap.equals(fs4.readFileSync(onDisk)) ? "identical" : "changed", basis: "snapshot" };
+    } catch {
+    }
+  }
+  if (prior === void 0 || prior.sizeBytes <= 0) return { identity: "unknown", basis: "none" };
+  const changed = current.size !== prior.sizeBytes || current.mtimeMs > (prior.lastFullReadAt ?? prior.lastReadAt);
+  return { identity: changed ? "changed" : "identical", basis: "stat" };
+}
+
+// src/hooks_read_policy.ts
+init_define_import_meta_env();
+
+// src/read_navigation_evidence.ts
+init_define_import_meta_env();
+import * as fs5 from "node:fs";
+var PROBE_ROWS = 60;
+var KEPT_PER_KIND = 8;
+function indexedCopyIsStale(filePath, row) {
+  try {
+    const onDisk = hostPathOfIndexKey(filePath);
+    if (fs5.statSync(onDisk).mtimeMs / 1e3 === row.mtime) return false;
+    if (!row.sha || fingerprintFile(onDisk) !== row.sha) return true;
+    enqueueDirtyPathSafe(onDisk);
+    return false;
+  } catch {
+    return true;
+  }
+}
+function getReadNavigationEvidence(filePath, dbPath) {
+  return withProbeIndex((db) => {
+    const fileRow = fileRowByIndexKey(db, filePath, "path, mtime, sha");
+    if (!fileRow) return null;
+    const isStale = indexedCopyIsStale(filePath, fileRow);
+    const spellings = filePathSpellingsClause("file_path", fileRow.path);
+    const rows = db.prepare(
+      `SELECT name, kind, line_start, line_end, COUNT(*) OVER () AS total, SUM(CASE WHEN kind = 'heading' THEN 1 ELSE 0 END) OVER () AS headings FROM symbols WHERE ${spellings.clause} ORDER BY line_start ASC, rowid LIMIT ${PROBE_ROWS}`
+    ).all(...spellings.params);
+    const first = rows[0];
+    if (first === void 0) return null;
+    const headingCount = Number(first.headings ?? 0);
+    const topSymbols = [];
+    const topHeadings = [];
+    for (const r of rows) {
+      const item = { name: r.name, kind: r.kind, lineStart: r.line_start, lineEnd: r.line_end };
+      const kept = r.kind === "heading" ? topHeadings : topSymbols;
+      if (kept.length < KEPT_PER_KIND) kept.push(item);
+    }
+    return {
+      filePath: fileRow.path,
+      symbolCount: Math.max(0, first.total - headingCount),
+      headingCount,
+      topSymbols,
+      topHeadings,
+      indexedMtime: fileRow.mtime ?? 0,
+      isStale
+    };
+  }, dbPath);
+}
+
+// src/hooks_read_policy.ts
+function formatKb(bytes) {
+  return (bytes / 1024).toFixed(1);
+}
+function meetsFirstReadSymbolThreshold(policy, thresholdBytes, size) {
+  return policy !== "off" && thresholdBytes > 0 && size >= thresholdBytes;
+}
+function buildReadPolicyContext(args) {
+  const { event, normalizedPath, hints } = args;
+  const window = args.window ?? readRequestedSliceWindow(event);
+  const slice = args.slice ?? (window.isExplicitSlice ? estimateRequestedSlice(event, normalizedPath) : { kind: "unbounded" });
+  return {
+    event,
+    normalizedPath,
+    shownPath: args.shownPath,
+    fileSize: args.fileSize,
+    window,
+    slice,
+    quiet: isWithinQuietHours(hints.quiet_hours),
+    firstReadSymbolBytes: hints.first_read_symbol_bytes,
+    firstReadSymbolPolicy: hints.first_read_symbol_policy
+  };
+}
+function evaluateFirstReadSymbolPolicy(ctx) {
+  const {
+    event,
+    normalizedPath,
+    shownPath,
+    fileSize,
+    firstReadSymbolBytes,
+    firstReadSymbolPolicy
+  } = ctx;
+  if (!meetsFirstReadSymbolThreshold(firstReadSymbolPolicy, firstReadSymbolBytes, fileSize)) return { action: "allow" };
+  if (event.toolName === "Grep") return { action: "allow" };
+  if (firstReadSymbolPolicy === "warn" && ctx.quiet) return { action: "allow" };
+  if (ctx.window.isExplicitSlice && isSmallSlice(ctx.slice, firstReadSymbolBytes, ctx.fileSize)) return { action: "allow" };
+  const evidence = ctx.navigationEvidence !== void 0 ? ctx.navigationEvidence : getReadNavigationEvidence(normalizedPath);
+  if (!evidence || evidence.isStale) return { action: "allow" };
+  if (evidence.symbolCount + evidence.headingCount === 0) return { action: "allow" };
+  const safeShown = displaySafePath(shownPath);
+  const surgicalCommands = [];
+  if (evidence.symbolCount > 0 && evidence.topSymbols.length > 0) {
+    const target = hintTargetFromNames(evidence.topSymbols.map((s) => s.name), "symbol");
+    if (target.real) {
+      surgicalCommands.push("token-goat read " + quotedArg(`${safeShown}::${target.name}`));
+    }
+  } else if (evidence.headingCount > 0 && evidence.topHeadings.length > 0) {
+    const target = hintTargetFromNames(evidence.topHeadings.map((h) => h.name), "section");
+    if (target.real) {
+      surgicalCommands.push("token-goat section " + quotedArg(`${safeShown}::${target.name}`));
+    }
+  }
+  const outlineCommand = "token-goat outline " + quotedArg(safeShown);
+  const skeletonCommand = "token-goat skeleton " + quotedArg(safeShown);
+  const primaryCommand = surgicalCommands[0] ?? outlineCommand;
+  const kb = formatKb(fileSize);
+  const symbolDetails = evidence.symbolCount > 0 ? `${countNoun(evidence.symbolCount, "indexed symbol")}` : `${countNoun(evidence.headingCount, "indexed heading")}`;
+  const sliceAdvice = ctx.window.isExplicitSlice && ctx.slice.kind === "nearSingleLine" ? ". " + describeSliceAdvice(ctx.slice, normalizedPath) : ", or re-read with offset/limit for a specific line slice.";
+  if (firstReadSymbolPolicy === "deny") {
+    const message2 = leadWithCommand(
+      primaryCommand,
+      "to read surgically",
+      `This file is large (${kb}KB with ${symbolDetails}). Whole-file first read denied by first_read_symbol_policy. Use ${fencedCommand(outlineCommand)} or ${fencedCommand(skeletonCommand)} to map structure${sliceAdvice}`
+    ) + "\n" + editAnywayHint(normalizedPath);
+    return { action: "deny", message: message2 };
+  }
+  const message = leadWithCommand(
+    primaryCommand,
+    "to read surgically",
+    `This file is ${kb}KB with ${symbolDetails}; prefer surgical reads or ${fencedCommand(outlineCommand)} over reading the whole file.`
+  );
+  return { action: "warn", message };
+}
+
+// src/hints.ts
+init_define_import_meta_env();
+var HINT_PRIORITY_MEDIUM = 3;
+function buildPackageManifestHint(options) {
+  try {
+    const fname = _sanitizeHintPath(options.file_path.split(/[/\\]/).pop() ?? "");
+    const basenameLower = fname.toLowerCase();
+    if (basenameLower === "package.json") {
+      const text = `\`${fname}\` is a package manifest. Run \`token-goat json-query ${quotedArgs(options.shown, "dependencies").join(" ")}\` or \`token-goat json-query ${quotedArgs(options.shown, "devDependencies").join(" ")}\` for focused reads, or \`token-goat json-outline ${quotedArg(options.shown)}\` for every top-level key.`;
+      return {
+        text,
+        hint_priority: HINT_PRIORITY_MEDIUM
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function _sanitizeHintPath(path7) {
+  if (typeof path7 !== "string") {
+    return "???";
+  }
+  return path7.replace(/[\x00]/g, "").slice(0, 200);
+}
+
+// src/doc_compact.ts
+init_define_import_meta_env();
+import * as fs6 from "fs";
+import * as path4 from "path";
+var defaultSentencesPerSection = 2;
+var headerPrefix = "<!-- token-goat doc-compact source-hash:";
+var headerRegex = /^<!-- token-goat doc-compact source-hash:(\S+) source:(.+?) -->\r?$/;
+var compactSubdir = "doc_compacts";
+function sourceHash(filePath) {
+  try {
+    return fingerprintContent(fs6.readFileSync(filePath));
+  } catch {
+    return "";
+  }
+}
+function _compactSlug(absPathStr) {
+  const h = fingerprintContent(foldPath(absPathStr)).slice(0, 12);
+  const ext = path4.extname(absPathStr);
+  const stem = path4.basename(absPathStr, ext);
+  const safeStem = sanitizeIdForFilename(stem, 32);
+  return `${h}_${safeStem}`;
+}
+function compactPathFor(sourcePath) {
+  const abs = resolveIndexPath(sourcePath);
+  return path4.join(dataDir(), compactSubdir, `${_compactSlug(abs)}.md`);
+}
+function readCompactHeader(compactPath) {
+  try {
+    const text = fs6.readFileSync(compactPath, "utf-8");
+    const firstLine = text.split("\n")[0] || "";
+    const m = firstLine.match(headerRegex);
+    if (!m || !m[1] || !m[2]) return null;
+    return [m[1], m[2]];
+  } catch {
+    return null;
+  }
+}
+function isCompactFresh(compactPath, sourcePath) {
+  const header = readCompactHeader(compactPath);
+  if (!header) return false;
+  const [storedHash] = header;
+  if (storedHash === "STALE") return false;
+  const currentHash = sourceHash(sourcePath);
+  return !!currentHash && currentHash === storedHash;
+}
+function markCompactStale(compactPath) {
+  try {
+    if (!fs6.existsSync(compactPath)) return false;
+    const text = fs6.readFileSync(compactPath, "utf-8");
+    const lines = text.split("\n");
+    if (!lines[0]) return false;
+    const m = lines[0].match(headerRegex);
+    if (!m || m[1] === "STALE") return false;
+    const oldHash = m[1];
+    lines[0] = lines[0].replace(`source-hash:${oldHash}`, "source-hash:STALE");
+    atomicWriteText(compactPath, lines.join("\n"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readCompactBody(compactPath) {
+  try {
+    const text = fs6.readFileSync(compactPath, "utf-8");
+    const lines = text.split("\n");
+    if (lines.length < 2) return null;
+    const body = lines.slice(1).join("\n").trimStart();
+    return body.trim() ? body : null;
+  } catch {
+    return null;
+  }
+}
+function writeCompact(compactPath, sourcePath, compactBody, sourceRel) {
+  const srcPath = path4.resolve(sourcePath);
+  const sha = sourceHash(srcPath);
+  const displayRel = sourceRel || path4.basename(srcPath);
+  const header = `${headerPrefix}${sha} source:${displayRel} -->
+`;
+  const fullText = header + compactBody.trimStart();
+  const dir = path4.dirname(compactPath);
+  if (!fs6.existsSync(dir)) {
+    ensureDirSync(dir);
+  }
+  atomicWriteText(compactPath, fullText);
+}
+function buildExtractiveCompact(text, maxSentences) {
+  const max = maxSentences ?? defaultSentencesPerSection;
+  const lines = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n").split("\n");
+  const out = [];
+  let i = 0;
+  const n = lines.length;
+  if (lines[0]?.trim() === "---") {
+    let j = 1;
+    while (j < n && lines[j]?.trim() !== "---") {
+      j++;
+    }
+    if (j < n) {
+      i = j + 1;
+    }
+  }
+  let inCodeBlock = false;
+  let codeBlockLines = 0;
+  let currentHeading = null;
+  let sentencesEmitted = 0;
+  let fence = null;
+  while (i < n) {
+    const line = lines[i];
+    const stripped = line.trim();
+    const fm = /^\s*(`{3,}|~{3,})(.*)$/.exec(line);
+    if (fm !== null && fm[1] !== void 0) {
+      const run = fm[1];
+      const ch = run[0] ?? "";
+      if (fence === null) {
+        fence = { ch, len: run.length };
+        inCodeBlock = true;
+        codeBlockLines = 0;
+        if (currentHeading && sentencesEmitted < max) {
+          out.push(line);
+          codeBlockLines++;
+        }
+        i++;
+        continue;
+      } else if (ch === fence.ch && run.length >= fence.len && (fm[2] ?? "").trim() === "") {
+        fence = null;
+        inCodeBlock = false;
+        if (currentHeading && codeBlockLines > 0) {
+          out.push(line);
+          codeBlockLines++;
+        }
+        i++;
+        continue;
+      }
+    }
+    if (inCodeBlock) {
+      if (codeBlockLines < 10 && currentHeading && sentencesEmitted < max) {
+        out.push(line);
+        codeBlockLines++;
+      }
+      i++;
+      continue;
+    }
+    const headingMatch = stripped.match(/^(#{1,6})\s+(.*)/);
+    if (headingMatch) {
+      currentHeading = stripped;
+      sentencesEmitted = 0;
+      out.push("");
+      out.push(line);
+      i++;
+      continue;
+    }
+    if (currentHeading && sentencesEmitted < max && stripped) {
+      out.push(line);
+      sentencesEmitted++;
+    }
+    i++;
+  }
+  const resultLines = [];
+  let prevBlank = false;
+  for (const ln of out) {
+    const isBlank = !ln.trim();
+    if (isBlank && prevBlank) {
+      continue;
+    }
+    resultLines.push(ln);
+    prevBlank = isBlank;
+  }
+  return resultLines.join("\n").trim() + "\n";
+}
+function extractDocCompact(body, heading) {
+  if (heading) {
+    const lines = body.split("\n");
+    const unfencedIdx = /* @__PURE__ */ new Set();
+    for (const [idx2] of eachUnfencedLine(lines)) unfencedIdx.add(idx2);
+    const compactIdx = lines.findIndex((line, idx2) => {
+      if (!unfencedIdx.has(idx2)) return false;
+      return matchAtxHeading(line.trim(), ATX_DOT_BREAK_RE, true)?.name === heading;
+    });
+    if (compactIdx === -1) return "";
+    const matchedHeadingLine = lines[compactIdx].trim();
+    const levelMatch = /^(#+)/.exec(matchedHeadingLine);
+    const matchedLevel = levelMatch ? levelMatch[1].length : 0;
+    let endIdx = lines.length;
+    for (let i = compactIdx + 1; i < lines.length; i++) {
+      if (!unfencedIdx.has(i)) continue;
+      const trimmed = lines[i].trim();
+      const nextLevelMatch = /^(#+)\s/.exec(trimmed);
+      if (nextLevelMatch) {
+        const nextLevel = nextLevelMatch[1].length;
+        if (nextLevel <= matchedLevel) {
+          endIdx = i;
+          break;
+        }
+      }
+    }
+    return lines.slice(compactIdx, endIdx).join("\n");
+  }
+  const compactMarker = "<!-- COMPACT_END -->";
+  const idx = body.indexOf(compactMarker);
+  if (idx === -1) return "";
+  return body.slice(0, idx).trim();
+}
+function compactDoc(filePath, heading) {
+  try {
+    const body = fs6.readFileSync(filePath, "utf-8");
+    const compact = extractDocCompact(body, heading);
+    return compact || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/notebook_compact.ts
+init_define_import_meta_env();
+import * as fs7 from "node:fs";
+import * as path5 from "node:path";
+var NB_STRIP_MIN_SAVINGS = 4096;
+function stripNotebook(nbDict) {
+  const cells = [];
+  for (const cell of nbDict.cells ?? []) {
+    if (cell.cell_type === "code") {
+      cells.push({
+        ...cell,
+        outputs: [],
+        execution_count: null
+      });
+    } else {
+      cells.push(cell);
+    }
+  }
+  return { ...nbDict, cells };
+}
+var SIDECAR_DEFAULT_MAX_COUNT = 200;
+var SIDECAR_DEFAULT_MAX_AGE_MS = 24 * 3600 * 1e3;
+function pruneSidecars(cacheRoot, maxCount = SIDECAR_DEFAULT_MAX_COUNT, maxAgeMs = SIDECAR_DEFAULT_MAX_AGE_MS) {
+  const nbStripDir = path5.join(cacheRoot, "nb_strip");
+  let removed = 0;
+  try {
+    if (!fs7.existsSync(nbStripDir)) return 0;
+    const cutoff = Date.now() - maxAgeMs;
+    const kept = [];
+    for (const entry of fs7.readdirSync(nbStripDir)) {
+      const dir = path5.join(nbStripDir, entry);
+      let mtime;
+      try {
+        mtime = fs7.statSync(dir).mtimeMs;
+      } catch {
+        continue;
+      }
+      if (mtime < cutoff) {
+        try {
+          fs7.rmSync(dir, { recursive: true, force: true });
+          removed++;
+        } catch {
+          continue;
+        }
+      } else {
+        kept.push([dir, mtime]);
+      }
+    }
+    if (kept.length > maxCount) {
+      kept.sort((a, b) => a[1] - b[1]);
+      for (const [dir] of kept.slice(0, kept.length - maxCount)) {
+        try {
+          fs7.rmSync(dir, { recursive: true, force: true });
+          removed++;
+        } catch {
+          continue;
+        }
+      }
+    }
+  } catch {
+    return removed;
+  }
+  return removed;
+}
+function getOrCreateSidecar(rawBytes, cacheRoot, opts = {}) {
+  const sha = fingerprintContent(rawBytes);
+  const sidecarDir = path5.join(cacheRoot, "nb_strip", sha);
+  const sidecarPath = path5.join(sidecarDir, "stripped.ipynb");
+  if (fs7.existsSync(sidecarPath)) {
+    return [sidecarPath, false];
+  }
+  let nb;
+  try {
+    nb = JSON.parse(rawBytes.toString("utf-8"));
+  } catch (err) {
+    throw new Error(`Failed to parse notebook JSON: ${String(err)}`, { cause: err });
+  }
+  if (typeof nb !== "object" || nb === null || !("cells" in nb)) {
+    throw new Error("Not a notebook");
+  }
+  const nbDict = nb;
+  const stripped = stripNotebook(nbDict);
+  try {
+    ensureDirSync(sidecarDir);
+  } catch (err) {
+    if (!fs7.existsSync(sidecarDir)) {
+      throw err;
+    }
+  }
+  const strippedJson = JSON.stringify(stripped, null, 2) + "\n";
+  atomicWriteBytes(sidecarPath, Buffer.from(strippedJson, "utf-8"));
+  pruneSidecars(cacheRoot, opts.maxCount ?? SIDECAR_DEFAULT_MAX_COUNT, opts.maxAgeMs ?? SIDECAR_DEFAULT_MAX_AGE_MS);
+  return [sidecarPath, true];
+}
+
+// src/hooks_read.ts
+function isTsConfigFile(basename5) {
+  const lower = basename5.toLowerCase();
+  return /^tsconfig(\..+)?\.json$/i.test(lower) || lower === "jsconfig.json";
+}
+var LARGE_FILE_BYTES = FILE_TYPE_THRESHOLDS.generic;
+var TASK_OUTPUT_DENY_BYTES = 20 * 1024;
+var SUBAGENT_MD_FIRST_READ_DENY_BYTES = 30 * 1024;
+var SUBAGENT_MD_FIRST_READ_DENY_EXT_RE = /\.(md|mdx|markdown)$/i;
+var DENY_THRESHOLD_TIER_MULTIPLIERS = {
+  cool: 1,
+  warm: 0.67,
+  hot: 0.33,
+  critical: 0.18
+};
+function largeFileDenyBytes() {
+  const base = loadConfig().hints.large_read_redirect_bytes;
+  const tier = getContextPressure(loadSessionCache(getSessionId()) ?? void 0, getTranscriptPath()).tier;
+  return Math.round(base * DENY_THRESHOLD_TIER_MULTIPLIERS[tier]);
+}
+function counterfactualCredit(counterfactualBytes, emittedBytes = 0) {
+  return Math.max(0, Math.min(counterfactualBytes, PER_FILE_COUNTERFACTUAL_CEILING) - emittedBytes);
+}
+function diffHintCredit(counterfactualBytes, body) {
+  const credit = counterfactualCredit(counterfactualBytes, body.length);
+  if (savedTokensFromBytes(credit) < loadConfig().hints.diff_hint_min_tokens_saved) return null;
+  return credit;
+}
+var SNAPSHOT_DIFF_LEAD = "Here is what changed:";
+function snapshotDenyText(normalized, snap, suffix) {
+  const subject = readSubject(normalized, suffix);
+  const lead = snap.kind === "unchanged" ? sentenceStart(subject) + " is unchanged since last read. " : "Content changed since last read of " + subject + ". " + SNAPSHOT_DIFF_LEAD + "\n\n" + fenceUntrustedFileContent("```diff\n" + snap.diff + "\n```") + "\n\n";
+  return (lead + suffix).trimEnd();
+}
+function readSubject(normalized, rest) {
+  return fileSubject(rest, displaySafePath(normalized), normalized);
+}
+function docSnapshotDenyText(normalized, basename5, snap) {
+  return snapshotDenyText(normalized, snap, surgicalHint(normalized, basename5, countTextLines(snap.currentContent), snap.currentContent));
+}
+function relPathWithinRoot(root, target) {
+  const rel = path6.relative(root, target).replace(/\\/g, "/");
+  if (rel.startsWith("..") || path6.isAbsolute(rel)) return null;
+  return rel;
+}
+function _isDocFile(filePath) {
+  const lower = filePath.toLowerCase();
+  return lower.endsWith(".md") || lower.endsWith(".mdx") || lower.endsWith(".markdown") || lower.endsWith(".rst");
+}
+function isSessionArtifactFile(filePath) {
+  if (/[/\\]tasks[/\\][a-z0-9]+\.output$/i.test(filePath)) return true;
+  if (new RegExp("[/\\\\]tool-results[/\\\\]" + TOOL_RESULTS_ID_CHARS + "\\.txt$", "i").test(filePath)) return true;
+  return false;
+}
+function lineWindowBytes(filePath, offset, limit) {
+  try {
+    const lines = fs8.readFileSync(filePath, "utf-8").split("\n").slice(offset - 1, offset - 1 + limit);
+    return lines.reduce((sum, line) => sum + Buffer.byteLength(line, "utf-8") + 1, 0);
+  } catch {
+    return Infinity;
+  }
+}
+function sessionArtifactRecall(rawPath) {
+  const filePath = displaySafePath(rawPath);
+  return "Use `token-goat bash-output --file " + quotedArg(filePath) + " --tail 50` (or `--grep PATTERN`) to read a slice instead of the full file.";
+}
+function priorOutputRecallHint(normalized) {
+  const ids = getFileServedOutputs(normalized);
+  if (ids.length === 0) return "";
+  const latestId = ids[ids.length - 1];
+  return " Recall earlier content with `token-goat bash-output " + latestId + "`.";
+}
+function isDiffableSource(basename5) {
+  return languageHasFlag(detectLanguage(basename5), "diffable");
+}
+function isSourceExtension(basename5) {
+  return languageHasFlag(detectLanguage(basename5), "sourceHints");
+}
+var BINARY_FILE_TYPE_EXTS = /* @__PURE__ */ new Set(["pdf", "docx", "xlsx", "pptx", "odt", "ods", "ott", "odp", "sqlite", "db", "sqlite3", "db3", "parquet"]);
+var TEXT_FILE_TYPE_EXTS = /* @__PURE__ */ new Set(["html", "htm", "xhtml", "txt", "log", "out", "err", "trace", "csv", "tsv", "vtt", "srt", "svg", "xml", "dtsx", "ampkg", "xaml", "json", "yaml", "yml", "jsonl"]);
+var DISPATCHED_FILE_TYPE_EXTS = /* @__PURE__ */ new Set([...BINARY_FILE_TYPE_EXTS, ...TEXT_FILE_TYPE_EXTS]);
+function isDispatchedFileType(basename5) {
+  return DISPATCHED_FILE_TYPE_EXTS.has(path6.extname(basename5).slice(1).toLowerCase());
+}
+function extractQuickSymbolSamples(content, _filePath, limit = 3) {
+  const symbols = [];
+  const isShell = _filePath !== void 0 ? /\.(sh|bash|zsh|ksh)$/i.test(_filePath) : /^#!\s*\/(?:usr\/)?(?:bin\/|local\/bin\/)?(?:bash|sh|zsh)/.test(content);
+  if (isShell) {
+    const lines = content.split(/\r?\n/);
+    for (const line of lines) {
+      const banner = extractShellBannerHeading(line);
+      if (banner !== null && !symbols.includes(banner.heading)) {
+        symbols.push(banner.heading);
+        if (symbols.length >= limit) return symbols;
+      }
+    }
+  }
+  const pesterRegex = /^\s*(?:Describe|Context|It|BeforeAll|BeforeEach|AfterAll|AfterEach)\b(?:\s+-[A-Za-z0-9_-]+(?:\s+(?:'[^']*'|"[^"]*"|[^\s{]+))?)*\s*(?:'([^']*)'|"([^"]*)"|([A-Za-z0-9_.-]+))?/gim;
+  let match;
+  while ((match = pesterRegex.exec(content)) !== null) {
+    const rawMatch = match[0].trimStart();
+    const blockKeyword = rawMatch.split(/\s+/)[0] ?? "";
+    const explicitName = match[1] ?? match[2] ?? match[3];
+    const name = explicitName || blockKeyword;
+    if (name && !symbols.includes(name)) {
+      symbols.push(name);
+      if (symbols.length >= limit) return symbols;
+    }
+  }
+  const psFnRegex = /^\s*(?:function|filter|workflow|configuration)\s+(?:(?:global|local|script|private):)?([A-Za-z0-9_\u00C0-\uFFFF-]+)/gim;
+  while ((match = psFnRegex.exec(content)) !== null) {
+    const name = match[1];
+    if (name && !symbols.includes(name)) {
+      symbols.push(name);
+      if (symbols.length >= limit) return symbols;
+    }
+  }
+  const fnRegex = /(?:(?:export\s+(?:default\s+)?(?:async\s+)?)?(?:function\s+|class\s+|(?:const|let|var)\s+)|def\s+|func(?:\s*\([^)]*\))?\s+|fn\s+)([A-Za-z0-9_$]+)/g;
+  while ((match = fnRegex.exec(content)) !== null) {
+    const name = match[1];
+    if (name && !symbols.includes(name)) {
+      symbols.push(name);
+      if (symbols.length >= limit) break;
+    }
+  }
+  return symbols;
+}
+var HINT_NAME_SCAN_LIMIT = 500;
+var HINT_NAME_COUNT = 3;
+function indexedHintNames(opts) {
+  return querySymbols({ ...opts, limit: HINT_NAME_SCAN_LIMIT }).map((symbol) => escapeHintName(symbol.name)).filter((name) => name !== "").slice(0, HINT_NAME_COUNT);
+}
+function surgicalHint(filePath, basename5, lineCount, fileContent) {
+  if (lineCount < loadConfig().hints.min_file_lines_for_hint) return "";
+  const isDocFile = /\.(md|mdx|rst|txt)$/i.test(basename5);
+  const isJsonFile = /\.(json|jsonc)$/i.test(basename5);
+  const isYamlFile = /\.(yaml|yml)$/i.test(basename5);
+  const isHtmlFile = /\.(html|htm)$/i.test(basename5);
+  const isSectionFile = /\.(css|scss|sass|less|toml)$/i.test(basename5);
+  const isXmlFile = /\.(xml|dtsx|ampkg|xaml)$/i.test(basename5) && !basename5.toLowerCase().endsWith("-meta.xml");
+  if (isXmlFile) {
+    return leadWithCommand(`token-goat xml-outline ${quotedArg(filePath)}`, `for structure, or \`token-goat xml-query ${quotedArgs(filePath, "<selector>").join(" ")}\` for nodes`);
+  } else if (isDocFile && !docNavigation(filePath).section) {
+    return fileQueryHint(filePath, "", "pattern");
+  } else if (isDocFile) {
+    let top = [];
+    if (fileContent !== void 0 && /\.(md|mdx)$/i.test(basename5)) {
+      top = extractMarkdownHeadings(fileContent).map((h) => escapeHintName(h.text.trim())).filter((name) => name !== "").slice(0, HINT_NAME_COUNT);
+    } else if (fileContent === void 0) {
+      try {
+        top = indexedHintNames({ filePath, kind: "heading" });
+      } catch {
+      }
+    }
+    const heading = hintTarget(filePath, "section", { content: fileContent });
+    return leadWithCommand(sectionOrRangeCommand(filePath, heading), (top.length > 0 ? `(or sections: ${top.join(", ")}) ` : "") + "to extract a part");
+  } else if (isJsonFile || isYamlFile) {
+    const fmt = isJsonFile ? "json" : "yaml";
+    const key = hintTarget(filePath, "key", { content: fileContent });
+    if (key.real) return leadWithCommand(sliceCommand(filePath, key), `to read that value, or \`token-goat ${fmt}-outline ${quotedArg(filePath)}\` for every top-level key`);
+    return isJsonFile ? leadWithCommand(`token-goat json-query ${quotedArgs(filePath, "<key>").join(" ")}`, `(or \`token-goat json-outline ${quotedArg(filePath)}\`) to slice one value`) : leadWithCommand(`token-goat section ${quotedArg(`${filePath}::name`)}`, `or \`token-goat yaml-query ${quotedArgs(filePath, "<key>").join(" ")}\` to extract a part`);
+  } else if (isHtmlFile) {
+    return leadWithCommand(sectionOrRangeCommand(filePath, hintTarget(filePath, "section", { content: fileContent })), `or \`token-goat outline ${quotedArg(filePath)}\` to navigate HTML structure`);
+  } else if (isSectionFile) {
+    if (!/\.toml$/i.test(basename5)) return leadWithCommand(`token-goat outline ${quotedArg(filePath)}`, "to list every selector");
+    const table = hintTarget(filePath, "section", { content: fileContent, placeholder: "name" }).name;
+    return leadWithCommand(`token-goat section ${quotedArg(`${filePath}::${table}`)}`, "to extract a part");
+  } else {
+    const isShellScript = /\.(sh|bash|zsh|ksh)$/i.test(basename5);
+    let namesAreHeadings = false;
+    const samples = fileContent !== void 0 ? extractQuickSymbolSamples(fileContent, filePath, HINT_NAME_SCAN_LIMIT).map(escapeHintName).filter((name) => name !== "").slice(0, HINT_NAME_COUNT) : (() => {
+      try {
+        if (isShellScript) {
+          const headings = indexedHintNames({ filePath, kind: "heading" });
+          if (headings.length > 0) {
+            namesAreHeadings = true;
+            return headings;
+          }
+        }
+        return indexedHintNames({ filePath });
+      } catch {
+        return [];
+      }
+    })();
+    const fallback = samples.length > 0 ? null : hintTarget(filePath, "symbol", { content: fileContent });
+    const sym = samples[0] ?? fallback?.name ?? HINT_PLACEHOLDERS.symbol;
+    const avail = samples.length > 0 ? `(available: ${samples.join(", ")}) ` : "";
+    if (namesAreHeadings) {
+      return leadWithCommand(`token-goat section ${quotedArg(`${filePath}::${sym}`)}`, `${avail}for a section, or \`token-goat skeleton ${quotedArg(filePath)}\` / \`token-goat outline ${quotedArg(filePath)}\` for structure`);
+    }
+    if (samples.length > 0) {
+      try {
+        const indexed = querySymbols({ filePath, name: sym, limit: 1 })[0];
+        if (indexed !== void 0 && isLargeSymbolSpan(indexed.lineStart, indexed.lineEnd, filePath)) {
+          return `${sentenceStart(nameSubject("symbol", sym))} spans ${indexed.lineEnd - indexed.lineStart + 1} lines -- use \`token-goat grep ${quotedArgs("<pattern>", filePath).join(" ")} -C 15 --symbol\` for a slice inside it, or \`token-goat scope ${quotedArg(`${filePath}:${indexed.lineStart}`)}\` to confirm the enclosing symbol.`;
+        }
+      } catch {
+      }
+    }
+    if (fallback?.real === false) return leadWithCommand(`token-goat skeleton ${quotedArg(filePath)}`, `or \`token-goat outline ${quotedArg(filePath)}\` for structure, then \`token-goat read ${quotedArg(`${filePath}::${sym}`)}\` for one function`);
+    return leadWithCommand(`token-goat read ${quotedArg(`${filePath}::${sym}`)}`, `${avail}for one function, or \`token-goat skeleton ${quotedArg(filePath)}\` / \`token-goat outline ${quotedArg(filePath)}\` for structure`);
+  }
+}
+function isLargeSymbolSpan(lineStart, lineEnd, filePath) {
+  const span = lineEnd - lineStart + 1;
+  if (span > LARGE_SYMBOL_LINE_THRESHOLD) return true;
+  const totalLines = lineCountForSurgicalHint(filePath);
+  return totalLines > 0 && span > totalLines / 2;
+}
+var SYMBOL_HINT_PAGE = 500;
+function symbolsMeetingRange(filePath, range, firstPage) {
+  const meets = (s) => s.lineStart <= range.end && s.lineEnd >= range.start;
+  const found = firstPage.filter(meets);
+  let page = firstPage;
+  let offset = 0;
+  for (; ; ) {
+    const last = page.length === SYMBOL_HINT_PAGE ? page[page.length - 1] : void 0;
+    if (last === void 0 || last.lineStart > range.end) break;
+    offset += SYMBOL_HINT_PAGE;
+    page = querySymbols({ filePath, limit: SYMBOL_HINT_PAGE, offset }).map((s) => ({ name: escapeHintName(s.name), lineStart: s.lineStart, lineEnd: s.lineEnd }));
+    for (const symbol of page) if (meets(symbol)) found.push(symbol);
+  }
+  return found;
+}
+function realSymbolReadHint(filePath, shown, range) {
+  let candidates;
+  try {
+    const all = querySymbols({ filePath, limit: SYMBOL_HINT_PAGE }).map((s) => ({ name: escapeHintName(s.name), lineStart: s.lineStart, lineEnd: s.lineEnd }));
+    const overlapping = range !== void 0 ? symbolsMeetingRange(filePath, range, all) : [];
+    candidates = (overlapping.length > 0 ? overlapping : all).filter((s) => s.name !== "");
+  } catch {
+    candidates = [];
+  }
+  const top = candidates[0];
+  if (top === void 0) {
+    return range !== void 0 ? "`token-goat read " + quotedArg(shown + "@" + range.start + "-" + range.end) + "`" : "`token-goat outline " + quotedArg(shown) + "`";
+  }
+  if (isLargeSymbolSpan(top.lineStart, top.lineEnd, filePath)) {
+    const line = range !== void 0 ? range.start : top.lineStart;
+    const span = top.lineEnd - top.lineStart + 1;
+    return "`token-goat grep " + quotedArgs("<pattern>", shown).join(" ") + " -C 15 --symbol` for a slice inside " + nameSubject("symbol", top.name) + " (" + span + " lines), or `token-goat scope " + quotedArg(shown + ":" + line) + "` to confirm the enclosing symbol";
+  }
+  const names = candidates.map((s) => s.name).slice(0, 3);
+  const rest = names.length > 1 ? " (or: " + names.slice(1).join(", ") + ")" : "";
+  return "`token-goat read " + quotedArg(shown + "::" + names[0]) + "`" + rest;
+}
+function lineCountForSurgicalHint(filePath, fileStatSize) {
+  try {
+    const onDisk = hostPathOfIndexKey(filePath);
+    if (fileStatSize !== void 0 && fileStatSize > SLICE_ESTIMATE_SCAN_CAP_BYTES) {
+      return 0;
+    }
+    const sz = fileStatSize ?? statSize(onDisk);
+    if (sz !== null && sz > SLICE_ESTIMATE_SCAN_CAP_BYTES) {
+      return 0;
+    }
+    return countTextLines(fs8.readFileSync(onDisk, "utf8"));
+  } catch {
+    return 0;
+  }
+}
+function detectSkillFile(filePath) {
+  const match = filePath.match(/\.claude[\\/]skills[\\/]([^\\/]+)[\\/]SKILL\.md$/i);
+  return match ? displaySafePath(match[1]) : null;
+}
+function scanCrossSessionManifests(projectRoot, projectHash, filePath, ttlSecs) {
+  try {
+    const relPath = relPathWithinRoot(projectRoot, filePath);
+    if (relPath === null) return false;
+    const foldedRelPath = foldPath(relPath);
+    const manifests = readAllSessionManifests(projectHash, ttlSecs);
+    for (const data of manifests) {
+      const files = data["files"];
+      if (!Array.isArray(files)) continue;
+      for (const entry of files) {
+        if (typeof entry !== "object" || entry === null) continue;
+        const entryRelPath = entry["rel_path"];
+        const entryHitCount = entry["hit_count"];
+        if (typeof entryRelPath === "string" && foldPath(entryRelPath) === foldedRelPath && typeof entryHitCount === "number" && entryHitCount > 0) {
+          return true;
+        }
+      }
+    }
+  } catch {
+  }
+  return false;
+}
+var recordedReadEvents = /* @__PURE__ */ new WeakSet();
+function recordActualRead(event, filePath) {
+  if (event.toolName === "Grep") return;
+  if (recordedReadEvents.has(event)) return;
+  recordedReadEvents.add(event);
+  recordFileRead(filePath, !readRequestedSliceWindow(event).isExplicitSlice);
+}
+function firstReadSymbolOutput(decision, policyContext, hints, recordRead) {
+  const { event, normalizedPath, fileSize } = policyContext;
+  if (decision.action === "deny") {
+    const denyCredit = counterfactualCredit(fileSize);
+    recordStat("session_hint", denyCredit, savedTokensFromBytes(denyCredit), void 0, "first-read-symbol-deny");
+    return denyOutput(decision.message);
+  }
+  if (decision.action === "warn" && fileSize < LARGE_FILE_BYTES) {
+    if (recordRead) {
+      recordActualRead(event, normalizedPath);
+      recordActualSlice(event, normalizedPath);
+    }
+    if (hints.log_large_file_hint_outcomes) {
+      recordLargeFileHintPending(normalizedPath, fileSize);
+    }
+    if (!policyContext.quiet) {
+      recordStat("session_hint", 0, 0);
+    }
+    return quietContextOutput(decision.message + contextPressureAdvisorySuffix(), [policyContext.shownPath]);
+  }
+  return null;
+}
+function recordActualSlice(event, filePath) {
+  const window = readRequestedSliceWindow(event);
+  const span = requestedSliceSpan(window);
+  if (window.isExplicitSlice && span !== void 0) {
+    recordFileLineRange(filePath, span.start, span.end);
+    recordRecentReadRange(foldPath(normalizePath(filePath)), [span.start, span.end]);
+  }
+}
+function quietContextOutput(context, correlators) {
+  if (isWithinQuietHours(loadConfig().hints.quiet_hours)) {
+    return passOutput();
+  }
+  return contextOutput(context, correlators);
+}
+function contextPressureAdvisorySuffix() {
+  if (!loadConfig().hints.context_threshold_advisory) return "";
+  const tier = getContextPressure(loadSessionCache(getSessionId()) ?? void 0, getTranscriptPath()).tier;
+  if (tier === "hot") {
+    return " Context pressure: hot -- consider wrapping up soon or running /compact.";
+  }
+  if (tier === "critical") {
+    return " Context pressure: critical -- strongly consider /compact now.";
+  }
+  return "";
+}
+function isProtectedRecentRead(normalized, n) {
+  if (n <= 0) return false;
+  const entry = getSessionFileEntry(normalized);
+  if (entry && epochReadCounts(entry).reads >= 4) return false;
+  const compactedAt = getCompactedAt();
+  const ranked = Array.from(getSessionFiles().entries()).filter(([, e]) => e.lastReadAt >= compactedAt).sort((a, b) => {
+    const byRecency = b[1].lastReadAt - a[1].lastReadAt;
+    return byRecency !== 0 ? byRecency : a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0;
+  });
+  const target = foldPath(normalized);
+  const rank = ranked.findIndex(([filePath]) => foldPath(filePath) === target);
+  return rank !== -1 && rank < n;
+}
+function alreadyServedOutputId(event, normalized) {
+  try {
+    const ids = getFileServedOutputs(normalized);
+    if (ids.length === 0) return null;
+    const wouldServe = readWindowFromDisk(event, normalized);
+    if (wouldServe === null) return null;
+    const bytes = Buffer.byteLength(wouldServe, "utf-8");
+    if (bytes < IDENTICAL_READ_MIN_BODY_BYTES) return null;
+    for (let i = ids.length - 1; i >= 0; i--) {
+      const id = ids[i];
+      if (id === void 0) continue;
+      const prior = getBashOutput(id);
+      if (prior !== null && containsLineRun(prior.output, wouldServe)) return { id, bytes };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function preReadHandlerInner(event) {
+  let filePath = getFilePath(event);
+  if (filePath === void 0 && event.toolName === "Grep") {
+    const rawPath = event.toolInput["path"];
+    if (typeof rawPath === "string" && rawPath !== "") filePath = resolveEventPath(event, rawPath);
+  }
+  if (filePath === void 0) return passOutput();
+  const normalized = normalizePath(filePath);
+  const shown = displaySafePath(normalized);
+  const onDisk = hostPathOfIndexKey(normalized);
+  const rangeWindow = readRequestedSliceWindow(event);
+  const rangeSpan = rangeWindow.isExplicitSlice ? requestedSliceSpan(rangeWindow) : void 0;
+  const rangeKey = foldPath(normalized);
+  let rangeIdentity;
+  if (event.toolName !== "Grep" && rangeSpan !== void 0 && loadConfig().hints.reread_deny) {
+    rangeIdentity = dropFileLineRangesIfChanged(normalized);
+    clearReadRangeIfChanged(rangeKey, rangeIdentity);
+    if (getReadRangeDenials(rangeKey).length > 0) {
+      lockReadRange(rangeKey, [rangeSpan.start, rangeSpan.end], rangeIdentity);
+      return denyOutput(rangeLockMessage(shown, [rangeSpan.start, rangeSpan.end]));
+    }
+  }
+  if (isNodeModulesPath(normalized)) {
+    return denyOutput(
+      "node_modules is typically noise; use npm ls, npm outdated, or npm audit instead for dependency info. To force access, use: token-goat read node_modules/package/file.js::symbol-name or token-goat section node_modules/package/file.js::heading"
+    );
+  }
+  if (event.toolName === "Read" && loadConfig().hints.cross_session_read_dedup) {
+    try {
+      const cwd = getCwd(event) ?? process.cwd();
+      const project = findProject(cwd) ?? makeProjectAt(cwd);
+      const current = readEvidenceFileText(normalized);
+      const evidence = current === null ? null : findVerifiedFileEvidence(project.root, normalized, current);
+      if (evidence !== null) {
+        recordStat("evidence_cache_hit", 0);
+        return quietContextOutput(
+          `Verified cross-session evidence exists for this unchanged file (${evidence.id}). Use a narrow read instead of loading the full file again.`
+        );
+      }
+    } catch {
+    }
+  }
+  const basename5 = displaySafePath(path6.basename(normalized));
+  if (isLockFile(basename5)) {
+    return denyOutput(
+      "Lock files are rarely useful to read in full. " + fileQueryHint(shown, "Or read the relevant manifest instead.", "package-name")
+    );
+  }
+  if (normalized.toLowerCase().endsWith(".tsbuildinfo")) {
+    return denyOutput(
+      "This is a TypeScript incremental build cache file. You don't need to read it directly."
+    );
+  }
+  if (event.toolName !== "Grep" && (isInBuildDir(normalized) || isGeneratedFile(normalized))) {
+    return denyOutput(
+      "Generated/build artifact \u2014 read the source file instead."
+    );
+  }
+  if (!wasFileReadThisSession(normalized)) {
+    const manifestHint = buildPackageManifestHint({ file_path: normalized, shown });
+    if (manifestHint) {
+      recordActualRead(event, normalized);
+      markHintShown("manifest-hint:" + normalized);
+      return quietContextOutput(manifestHint.text);
+    }
+  }
+  if (isTsConfigFile(basename5) && wasFileReadThisSession(normalized)) {
+    recordActualRead(event, normalized);
+    return quietContextOutput(
+      leadWithCommand(configGetCommand(shown, "compilerOptions.target"), "for a single compiler option, or `token-goat json-outline " + quotedArg(shown) + "` for every top-level key", "Already read this file.")
+    );
+  }
+  if (isManifestFile(basename5) && wasFileReadThisSession(normalized)) {
+    recordActualRead(event, normalized);
+    const field = hintTarget(normalized, sliceForPath(normalized));
+    return quietContextOutput(
+      field.real ? leadWithCommand(sliceCommand(shown, field), "to extract just the value you need", "You've already read this file.") : fileQueryHint(shown, "You've already read this file.", "field"),
+      [shown]
+    );
+  }
+  const skillName = detectSkillFile(normalized);
+  if (skillName && basename5 === "SKILL.md") {
+    try {
+      const body = fs8.readFileSync(onDisk, "utf-8");
+      const bodySha = contentHash(body);
+      const compact = getCompactAnySessionSync(skillName);
+      const stale = isCompactStale(compact, skillName, bodySha);
+      if (stale === true) {
+        recordActualRead(event, normalized);
+        return quietContextOutput(
+          "This skill's cached compact is stale. Run `token-goat skill-compact " + quotedArg(skillName) + "` to regenerate it."
+        );
+      }
+    } catch {
+    }
+  }
+  const compactUnrangedRead = !readRequestedSliceWindow(event).isExplicitSlice;
+  if (event.toolName !== "Grep" && compactUnrangedRead && loadConfig().hints.stable_doc_compacts && _isDocFile(normalized)) {
+    const compactPath = compactPathFor(normalized);
+    if (isCompactFresh(compactPath, onDisk)) {
+      const compactBody = readCompactBody(compactPath);
+      if (compactBody !== null) {
+        recordActualRead(event, normalized);
+        const fullSize = statSize(onDisk) ?? 0;
+        const savedBytes = counterfactualCredit(fullSize, compactBody.length);
+        recordStat("session_hint", savedBytes, savedTokensFromBytes(savedBytes), void 0, "stable-doc-compact");
+        return denyOutput(
+          "Serving the extractive compact sidecar in place of the full file (source unchanged since the last `compact-doc` build):\n\n" + fenceUntrustedFileContent(compactBody) + "\n\nThis is a lossy extract, not the whole file: front matter and any prose before the first heading are dropped entirely, each section is cut to its opening sentences, and long code fences are truncated. If you need content it left out, re-read with offset/limit for a line window, or `token-goat section " + quotedArg(shown + "::" + hintTarget(normalized, "section", { placeholder: "Heading" }).name) + "` for one section in full. Use `token-goat compact-doc " + quotedArg(shown) + " --force` to rebuild it, or `token-goat compact-doc " + quotedArg(shown) + " --show` to view it directly. " + editAnywayHint(normalized)
+        );
+      }
+    }
+  }
+  const isNotebook = /\.ipynb$/i.test(basename5);
+  if (event.toolName !== "Grep" && isNotebook) {
+    try {
+      const rawBytes = fs8.readFileSync(onDisk);
+      const [sidecarPath] = getOrCreateSidecar(rawBytes, dataDir());
+      const sidecarContent = fs8.readFileSync(sidecarPath, "utf-8");
+      const savedBytes = rawBytes.length - sidecarContent.length;
+      if (savedBytes >= NB_STRIP_MIN_SAVINGS) {
+        recordActualRead(event, normalized);
+        const nbCredit = counterfactualCredit(rawBytes.length, sidecarContent.length);
+        recordStat("session_hint", nbCredit, savedTokensFromBytes(nbCredit), void 0, "notebook-strip");
+        return denyOutput(
+          "Serving the output-stripped notebook in place of the full file (code-cell outputs and execution counts removed; source and metadata preserved):\n\n" + fenceUntrustedFileContent(sidecarContent) + "\n\n" + editAnywayHint(normalized)
+        );
+      }
+    } catch {
+    }
+  }
+  const isMarkdown = /\.(md|mdx|markdown|rst)$/i.test(basename5);
+  if (event.toolName !== "Grep" && isMarkdown) {
+    let fileContent = null;
+    let markdownSize = null;
+    try {
+      const sz = statSize(onDisk);
+      if (sz !== null && sz >= MARKDOWN_SIZE_THRESHOLD) {
+        markdownSize = sz;
+        fileContent = fs8.readFileSync(onDisk, "utf8");
+      }
+    } catch {
+    }
+    if (fileContent !== null) {
+      const headings = extractMarkdownHeadings(fileContent);
+      if (headings.length >= 3) {
+        const alreadyRead = wasFileFullyReadThisSession(normalized);
+        const { guidance, sectionsList } = headingTreeParts(headings, normalized, fileContent);
+        const headingTextsLower = new Set(headings.map((h) => h.text.trim().toLowerCase()));
+        const wellKnown = getWellKnownSections(basename5).filter((s) => headingTextsLower.has(s.trim().toLowerCase()));
+        const wellKnownText = wellKnown.length > 0 ? "\nQuick access: " + wellKnown.map((s) => "token-goat section " + quotedArg(shown + "::" + s)).join(" | ") : "";
+        const changelogExtra = basename5.toLowerCase() === "changelog.md" ? extractChangelogVersionHint(fileContent, normalized) : "";
+        const headingTarget = hintTarget(normalized, "section", { headings, content: fileContent });
+        const treeLead = headingTarget.real ? leadWithCommand("token-goat section " + quotedArg(shown + "::" + headingTarget.name), "to read one section") + "\n" : "";
+        const treeGuidance = headingTarget.real ? guidance.split("\n").filter((line) => !line.includes('::Heading Name"')).join("\n") : guidance;
+        let message = treeLead + treeGuidance + "\n" + fenceUntrustedFileContent(sectionsList + changelogExtra) + wellKnownText;
+        const slice = estimateRequestedSlice(event, normalized);
+        const gateSize = slice.kind === "bytes" && markdownSize !== null ? Math.min(slice.bytes, markdownSize) : markdownSize;
+        const tooLargeForFirstRead = gateSize !== null && gateSize >= largeFileDenyBytes();
+        const config2 = loadConfig();
+        const policyEvidence = !alreadyRead && gateSize !== null && config2.hints.first_read_symbol_policy === "deny" && meetsFirstReadSymbolThreshold(config2.hints.first_read_symbol_policy, config2.hints.first_read_symbol_bytes, gateSize) ? getReadNavigationEvidence(normalized) : null;
+        const policyHeadingCount = policyEvidence !== null && !policyEvidence.isStale ? policyEvidence.headingCount : 0;
+        const firstReadSymbolDeny = policyHeadingCount > 0;
+        if (alreadyRead || tooLargeForFirstRead || firstReadSymbolDeny) {
+          if (firstReadSymbolDeny) {
+            recordStat("session_hint", 0, 0);
+            const safeHeading = headingTarget.real ? headingTarget.name : null;
+            const explanation = `This file is large (${formatKb(markdownSize ?? 0)}KB with ${countNoun(policyHeadingCount, "heading")}). Whole-file first read denied by first_read_symbol_policy. Use ${fencedCommand("token-goat outline " + quotedArg(shown))} to map sections, or re-read with offset/limit for a specific section.`;
+            return denyOutput(
+              (safeHeading ? leadWithCommand("token-goat section " + quotedArg(`${shown}::${safeHeading}`), "to read surgically", explanation) : explanation) + "\n" + editAnywayHint(normalized)
+            );
+          }
+          if (alreadyRead) {
+            const snapDiff = loadSnapshotDiff(sessionStateKey(event), normalized, basename5);
+            if (snapDiff.kind === "unchanged") {
+              recordActualRead(event, normalized);
+              recordStat("session_hint", 0, 0);
+              return denyOutput(docSnapshotDenyText(normalized, basename5, snapDiff));
+            }
+            if (snapDiff.kind === "diff") {
+              const diffBody = docSnapshotDenyText(normalized, basename5, snapDiff);
+              if (diffHintCredit(snapDiff.currentContent.length, diffBody) !== null) {
+                recordActualRead(event, normalized);
+                recordStat("session_hint", 0, 0);
+                return denyOutput(diffBody);
+              }
+            }
+            recordActualRead(event, normalized);
+            recordStat("session_hint", 0, 0);
+          } else {
+            message += " " + editAnywayHint(normalized);
+          }
+          return denyOutput(message);
+        }
+        const unrangedRead = !readRequestedSliceWindow(event).isExplicitSlice;
+        if (loadConfig().hints.subagent_markdown_first_read_deny && event.agentId !== void 0 && unrangedRead && SUBAGENT_MD_FIRST_READ_DENY_EXT_RE.test(basename5) && markdownSize !== null && markdownSize >= SUBAGENT_MD_FIRST_READ_DENY_BYTES) {
+          recordStat("subagent_markdown_first_read_deny", 0, 0);
+          return denyOutput(
+            "Subagent first read of a large markdown file (" + Math.round(markdownSize / 1024) + "KB). Read the section you need, not the whole file.\n\n" + message + " " + editAnywayHint(normalized)
+          );
+        }
+        recordActualRead(event, normalized);
+        return quietContextOutput(message, [normalized]);
+      }
+    }
+  }
+  const isMemoryMd = normalized.toLowerCase().includes("memory/memory.md") || /[/\\]memory[/\\][^/\\]+\.md$/i.test(normalized);
+  if (isMemoryMd && wasFileFullyReadThisSession(normalized)) {
+    const memSnapDiff = loadSnapshotDiff(sessionStateKey(event), normalized, basename5);
+    if (memSnapDiff.kind === "unchanged") {
+      recordActualRead(event, normalized);
+      recordStat("session_hint", 0, 0);
+      return denyOutput(docSnapshotDenyText(normalized, basename5, memSnapDiff));
+    }
+    if (memSnapDiff.kind === "diff") {
+      const diffBody = docSnapshotDenyText(normalized, basename5, memSnapDiff);
+      if (diffHintCredit(memSnapDiff.currentContent.length, diffBody) !== null) {
+        recordActualRead(event, normalized);
+        recordStat("session_hint", 0, 0);
+        return denyOutput(diffBody);
+      }
+    }
+    recordActualRead(event, normalized);
+    recordStat("session_hint", 0, 0);
+    return denyOutput(leadWithCommand(
+      "token-goat section " + quotedArg(shown + "::" + hintTarget(normalized, "section").name),
+      "to extract one section",
+      "This file was already read this session. Memory files rarely change mid-session."
+    ));
+  }
+  if (/^\.improve-state-.*\.json$/.test(basename5) && wasFileReadThisSession(normalized)) {
+    recordActualRead(event, normalized);
+    recordStat("session_hint", 0, 0);
+    return denyOutput(
+      "Orchestrator state already read this session. " + sessionArtifactRecall(normalized)
+    );
+  }
+  if (basename5.toLowerCase() === "content.json" && wasFileReadThisSession(normalized)) {
+    recordActualRead(event, normalized);
+    recordStat("session_hint", 0, 0);
+    const [quotedShown, quotedQuery] = quotedArgs(shown, "<path>");
+    return denyOutput(
+      "This file was already read this session. Tool output spill files should not be re-read whole. Use `token-goat json-query " + quotedShown + " " + quotedQuery + "` or `token-goat mcp-output --file " + quotedShown + " --json-query " + quotedQuery + "` to extract what you need."
+    );
+  }
+  if (/^\.env(\.\w+)?$/.test(basename5) && wasFileReadThisSession(normalized)) {
+    recordActualRead(event, normalized);
+    recordStat("session_hint", 0, 0);
+    return denyOutput(leadWithCommand(
+      configGetCommand(shown, hintTarget(normalized, "key").name),
+      "to extract a specific variable",
+      "This file was already read this session. Environment files rarely change mid-session."
+    ));
+  }
+  if (isSessionArtifactFile(normalized)) {
+    if (wasFileFullyReadThisSession(normalized)) {
+      if (wasFileTruncatedThisSession(normalized)) {
+        recordActualRead(event, normalized);
+        recordStat("session_hint", 0, 0);
+        return denyOutput(
+          "File was truncated on last read. " + sessionArtifactRecall(normalized)
+        );
+      }
+      const artifactSessionId = sessionStateKey(event);
+      const snapDiff = loadSnapshotDiff(artifactSessionId, normalized, basename5);
+      if (snapDiff.kind === "unchanged") {
+        recordActualRead(event, normalized);
+        recordStat("session_hint", 0, 0);
+        return denyOutput(snapshotDenyText(normalized, snapDiff, sessionArtifactRecall(normalized)));
+      }
+      if (snapDiff.kind === "diff") {
+        const diffBody = snapshotDenyText(normalized, snapDiff, sessionArtifactRecall(normalized));
+        const artifactDiffCredit = diffHintCredit(snapDiff.currentContent.length, diffBody);
+        if (artifactDiffCredit !== null) {
+          recordActualRead(event, normalized);
+          recordStat("session_hint", artifactDiffCredit, savedTokensFromBytes(artifactDiffCredit), void 0, "artifact-snapshot-diff");
+          return denyOutput(diffBody);
+        }
+      }
+      recordActualRead(event, normalized);
+      recordStat("session_hint", 0, 0);
+      return denyOutput(
+        "This file was already read this session. " + sessionArtifactRecall(normalized)
+      );
+    }
+    {
+      const isTaskOutput = /[/\\]tasks[/\\][a-z0-9]+\.output$/i.test(normalized);
+      const label = isTaskOutput ? "Session transcript" : "Tool-result file";
+      const outputSize = statSize(onDisk);
+      const window = readRequestedSliceWindow(event);
+      const windowBytes = window.limit === void 0 ? void 0 : lineWindowBytes(onDisk, window.offset ?? 1, window.limit);
+      if (outputSize !== null && outputSize >= TASK_OUTPUT_DENY_BYTES && (windowBytes === void 0 || windowBytes >= TASK_OUTPUT_DENY_BYTES)) {
+        const artifactDenyCredit = counterfactualCredit(outputSize);
+        recordStat("session_hint", artifactDenyCredit, savedTokensFromBytes(artifactDenyCredit), void 0, "artifact-large-deny");
+        const windowNote = windowBytes === void 0 || window.limit === void 0 || !Number.isFinite(windowBytes) ? "" : " Lines " + (window.offset ?? 1) + "-" + ((window.offset ?? 1) + window.limit - 1) + " span " + toKB(windowBytes) + "KB.";
+        return denyOutput(
+          label + " is large (" + toKB(outputSize) + "KB)." + windowNote + " " + sessionArtifactRecall(normalized) + " A Read with `offset` and `limit` spanning under " + toKB(TASK_OUTPUT_DENY_BYTES) + "KB goes through."
+        );
+      }
+      recordActualRead(event, normalized);
+      return quietContextOutput(label + ": " + sessionArtifactRecall(normalized));
+    }
+  }
+  const isDocDiffable = /\.(md|mdx|markdown|rst|txt)$/i.test(basename5);
+  const isSourceDiffable = loadConfig().hints.serve_diff_on_reread && isDiffableSource(basename5);
+  if ((isDocDiffable || isSourceDiffable) && wasFileFullyReadThisSession(normalized) && !isProtectedRecentRead(normalized, loadConfig().hints.protect_recent_reads)) {
+    if (wasFileTruncatedThisSession(normalized)) {
+      if (estimateTruncatedLineCount(normalized) >= loadConfig().hints.truncated_read_min_lines) {
+        recordActualRead(event, normalized);
+        recordStat("session_hint", 0, 0);
+        return denyOutput(truncatedReadDenyMessage(normalized));
+      }
+    }
+    const sessionId = sessionStateKey(event);
+    const snapDiff = loadSnapshotDiff(sessionId, normalized, basename5);
+    if (snapDiff.kind === "unchanged") {
+      recordActualRead(event, normalized);
+      recordStat("session_hint", 0, 0);
+      return denyOutput(docSnapshotDenyText(normalized, basename5, snapDiff));
+    }
+    if (snapDiff.kind === "diff") {
+      const diffBody = docSnapshotDenyText(normalized, basename5, snapDiff);
+      const diffCredit = diffHintCredit(snapDiff.currentContent.length, diffBody);
+      if (diffCredit !== null) {
+        recordActualRead(event, normalized);
+        recordStat("diff_hint", diffCredit, savedTokensFromBytes(diffCredit));
+        return denyOutput(diffBody);
+      }
+    }
+  }
+  const config = loadConfig();
+  if (config.hints.cross_session_read_dedup && !wasFileReadThisSession(normalized)) {
+    try {
+      const cwd = getCwd(event) ?? process.cwd();
+      let project = findProject(cwd);
+      if (!project) {
+        project = makeProjectAt(cwd);
+      }
+      if (relPathWithinRoot(project.root, normalized) !== null) {
+        const ttlSecs = config.hints.cross_session_read_dedup_ttl_secs;
+        if (scanCrossSessionManifests(project.root, project.hash, normalized, ttlSecs)) {
+          recordActualRead(event, normalized);
+          const slice = hintTarget(normalized, sliceForPath(normalized));
+          return quietContextOutput(
+            "This file may have already been read by another agent/session working in this project recently. If you are a subagent continuing shared work, consider whether you already have this content from context, or use `" + (slice.real ? sliceCommand(shown, slice) : "token-goat read " + quotedArg(shown + "::SymbolName")) + "` for a narrower slice instead of a full re-read.",
+            [shown]
+          );
+        }
+      }
+    } catch {
+    }
+  }
+  if (event.toolName !== "Grep" && !isImagePath(normalized) && wasFileReadThisSession(normalized)) {
+    const entry = getSessionFileEntry(normalized);
+    const counts = entry !== void 0 ? epochReadCounts(entry) : { reads: 1, fullReads: 0 };
+    const reads = Math.max(1, counts.reads);
+    const plural = reads === 1 ? "read" : "reads";
+    const isSourceExt = isSourceExtension(basename5);
+    const fullReads = counts.fullReads;
+    const protectedRead = isProtectedRecentRead(normalized, loadConfig().hints.protect_recent_reads);
+    recordActualRead(event, normalized);
+    const rereadBytes = statSize(onDisk) ?? 0;
+    const requestedSlice = estimateRequestedSlice(event, normalized);
+    const rereadCreditBasis = requestedSlice.kind === "bytes" ? requestedSlice.bytes : rereadBytes;
+    const rereadCredit = counterfactualCredit(rereadCreditBasis);
+    const config2 = loadConfig();
+    const window = readRequestedSliceWindow(event);
+    const isSmallUnseenSlice = isSmallSlice(requestedSlice, config2.hints.reread_deny_min_bytes, rereadBytes) && isUnseenWindow(window, getFileLineRanges(normalized), fullReads);
+    if (fullReads === 0 && !window.isExplicitSlice && !isDispatchedFileType(normalized) && meetsFirstReadSymbolThreshold(config2.hints.first_read_symbol_policy, config2.hints.first_read_symbol_bytes, rereadBytes)) {
+      const policyContext = buildReadPolicyContext({ event, normalizedPath: normalized, shownPath: shown, fileSize: rereadBytes, hints: config2.hints, window, slice: requestedSlice });
+      const policyOutput = firstReadSymbolOutput(evaluateFirstReadSymbolPolicy(policyContext), policyContext, config2.hints, false);
+      if (policyOutput !== null) return policyOutput;
+    }
+    if (config2.hints.log_large_file_hint_outcomes) {
+      const pendingSize = takePendingLargeFileHint(normalized);
+      if (pendingSize !== null) {
+        recordStat("large_file_hint_ignored", 0, 0, void 0, `${normalized} (${pendingSize} bytes) \u2014 hint fired but file was fully re-read instead of surgically read`);
+      }
+    }
+    const fileRereadDenyKey = "reread-file-deny:" + getCompactedAt() + ":" + foldPath(normalized);
+    const fileAlreadyDenied = wasHintShown(fileRereadDenyKey);
+    if (config2.hints.reread_deny) {
+      const alreadyServed = alreadyServedOutputId(event, normalized);
+      if (alreadyServed !== null && !fileAlreadyDenied) {
+        markHintShown(fileRereadDenyKey);
+        if (rangeSpan !== void 0) lockReadRange(rangeKey, [rangeSpan.start, rangeSpan.end], rangeIdentity);
+        const blocked = counterfactualCredit(alreadyServed.bytes);
+        recordStat("read_served_deny", blocked, savedTokensFromBytes(blocked));
+        recordStat("session_hint", 0, 0);
+        return denyOutput(
+          "Every line of this file this read would return was already served in this session, byte for byte. Recall it with `token-goat bash-output " + alreadyServed.id + "`, or pull just the part you need with " + realSymbolReadHint(normalized, shown) + ". Do not attempt to re-read this file with shifted or different line ranges."
+        );
+      }
+      const prevRanges = getFileLineRanges(normalized);
+      if (window.isExplicitSlice && window.offset !== void 0 && window.limit !== void 0) {
+        const start = window.offset;
+        const end = window.offset + window.limit - 1;
+        const containing = prevRanges.find(([s, e]) => s <= start && e >= end);
+        if (containing !== void 0) {
+          const snapDiff = loadSnapshotDiff(sessionStateKey(event), normalized, basename5);
+          const denyRangeReread = () => {
+            markHintShown(fileRereadDenyKey);
+            lockReadRange(rangeKey, [start, end], rangeIdentity);
+            const blocked = counterfactualCredit(rereadCreditBasis);
+            recordStat("read_served_deny", blocked, savedTokensFromBytes(blocked));
+            recordStat("session_hint", 0, 0);
+            const [cStart, cEnd] = containing;
+            const rangeNote = cStart === start && cEnd === end ? "Lines " + start + ".." + end + " of this file were already read this session. " : "Lines " + start + ".." + end + " of this file were already read this session (served within lines " + cStart + ".." + cEnd + "). ";
+            return denyOutput(
+              rangeNote + "Pull just the part you need with " + realSymbolReadHint(normalized, shown, { start, end }) + "." + priorOutputRecallHint(normalized) + " Do not attempt to re-read this file with shifted or different line ranges."
+            );
+          };
+          if (snapDiff.kind === "unchanged") {
+            return denyRangeReread();
+          }
+          if (snapDiff.kind === "none") {
+            const recordedIdentity = getSessionFileEntry(normalized)?.rangeFileIdentity;
+            let currentIdentity;
+            try {
+              const st = fs8.statSync(onDisk);
+              currentIdentity = { size: st.size, mtimeMs: st.mtimeMs };
+            } catch {
+              currentIdentity = void 0;
+            }
+            if (recordedIdentity === void 0 || currentIdentity !== void 0 && recordedIdentity.size === currentIdentity.size && recordedIdentity.mtimeMs === currentIdentity.mtimeMs) {
+              return denyRangeReread();
+            }
+            resetFileLineRanges(normalized);
+          } else {
+            resetFileLineRanges(normalized);
+          }
+        }
+      }
+      const isPagingTracked = isSourceExt || /\.(md|mdx|markdown|rst|xml|dtsx|ampkg|xaml)$/i.test(basename5);
+      const pagingWindowSpan = requestedSliceSpan(window);
+      const isSequentialChain = pagingWindowSpan !== void 0 && isSequentialPagingChain([...prevRanges, [pagingWindowSpan.start, pagingWindowSpan.end]], 4);
+      if (isPagingTracked && window.isExplicitSlice && prevRanges.length >= 3 && isSequentialChain && pagingWindowSpan !== void 0) {
+        lockReadRange(rangeKey, [pagingWindowSpan.start, pagingWindowSpan.end], rangeIdentity);
+        recordStat("read_count_deny", rereadCredit, savedTokensFromBytes(rereadCredit));
+        recordStat("session_hint", 0, 0);
+        const hint2 = "For lines " + pagingWindowSpan.start + ".." + pagingWindowSpan.end + ", run `token-goat read " + quotedArg(shown + "@" + pagingWindowSpan.start + "-" + pagingWindowSpan.end) + "`; `token-goat skeleton " + quotedArg(shown) + "` maps the rest." + (isSourceExt ? "" : " " + surgicalHint(normalized, basename5, lineCountForSurgicalHint(normalized)));
+        return denyOutput(
+          "Sequential line-range paging detected on " + readSubject(normalized, hint2) + " (" + (prevRanges.length + 1) + " slices read). " + hint2 + " Inspect structure directly without manual chunk paging. Further Read/view line ranges of this file will be denied."
+        );
+      }
+      if (rangeSpan !== void 0 && evaluateRangeEvasion({
+        span: [rangeSpan.start, rangeSpan.end],
+        served: getRecentReadRanges(rangeKey),
+        denied: getReadRangeDenials(rangeKey)
+      }) !== null) {
+        lockReadRange(rangeKey, [rangeSpan.start, rangeSpan.end], rangeIdentity);
+        recordStat("session_hint", 0, 0);
+        return denyOutput(rangeLockMessage(shown, [rangeSpan.start, rangeSpan.end]));
+      }
+    }
+    const bookDenyIdentity = (branch) => {
+      const { identity, basis } = rereadIdentity(sessionStateKey(event), normalized, entry);
+      recordStat("reread_deny_identity", 0, 0, void 0, `branch=${branch} identity=${identity} basis=${basis} edited=${entry?.wasEdited === true ? 1 : 0}`);
+    };
+    if (config2.hints.reread_deny && !protectedRead) {
+      if (wasFileTruncatedThisSession(normalized)) {
+        if (estimateTruncatedLineCount(normalized) >= config2.hints.truncated_read_min_lines) {
+          recordStat("session_hint", rereadCredit, savedTokensFromBytes(rereadCredit), void 0, "reread-truncated-deny");
+          bookDenyIdentity("truncated");
+          return denyOutput(truncatedReadDenyMessage(normalized));
+        }
+      }
+      if (!window.isExplicitSlice && fullReads >= 1 && /\.(md|mdx|markdown|rst)$/i.test(basename5)) {
+        recordStat("session_hint", rereadCredit, savedTokensFromBytes(rereadCredit), void 0, "reread-doc-deny");
+        bookDenyIdentity("doc");
+        return denyOutput(leadWithCommand(
+          sectionOrRangeCommand(shown, hintTarget(normalized, "section")),
+          "to read one section",
+          "Markdown file already read this session." + priorOutputRecallHint(normalized)
+        ));
+      }
+      if (!window.isExplicitSlice && fullReads >= 1 && /\.(json|jsonc|html|htm)$/i.test(basename5) && rereadBytes >= 8192) {
+        const hint2 = surgicalHint(normalized, basename5, lineCountForSurgicalHint(normalized, rereadBytes));
+        recordStat("session_hint", rereadCredit, savedTokensFromBytes(rereadCredit), void 0, "reread-structured-deny");
+        bookDenyIdentity("structured");
+        return denyOutput((hint2 + " " + sentenceStart(readSubject(normalized, hint2)) + " was already read this session (" + reads + " " + plural + ")." + priorOutputRecallHint(normalized)).trimStart());
+      }
+      if (isSourceExt && fullReads >= 2 && !fileAlreadyDenied) {
+        markHintShown(fileRereadDenyKey);
+        recordStat("read_count_deny", rereadCredit, savedTokensFromBytes(rereadCredit));
+        recordStat("session_hint", 0, 0);
+        bookDenyIdentity("source-count");
+        return denyOutput((surgicalHint(normalized, basename5, lineCountForSurgicalHint(normalized)) + " Tried to read this file " + reads + " times already." + priorOutputRecallHint(normalized) + " Do not attempt to re-read this file with shifted or different line ranges.").trimStart());
+      }
+    }
+    const hint = surgicalHint(normalized, basename5, lineCountForSurgicalHint(normalized));
+    if (config2.hints.reread_deny && !protectedRead && !isSmallUnseenSlice && (fullReads >= 1 && rereadBytes >= config2.hints.reread_deny_min_bytes || fullReads >= 2) && !fileAlreadyDenied) {
+      markHintShown(fileRereadDenyKey);
+      recordStat("session_hint", rereadCredit, savedTokensFromBytes(rereadCredit), void 0, "reread-count-deny");
+      bookDenyIdentity("count");
+      return denyOutput((hint + " " + sentenceStart(readSubject(normalized, hint)) + " was already read this session (" + reads + " " + plural + ")." + priorOutputRecallHint(normalized) + " Do not attempt to re-read this file with shifted or different line ranges.").trimStart());
+    }
+    const pagingWindow = readRequestedSliceWindow(event);
+    const activeRanges = getFileLineRanges(normalized);
+    const activeSpan = requestedSliceSpan(pagingWindow);
+    const isSequentialNote = activeSpan !== void 0 && isSequentialPagingChain([...activeRanges, [activeSpan.start, activeSpan.end]], 3);
+    const pagingNote = pagingWindow.isExplicitSlice && activeRanges.length >= 2 && isSequentialNote ? " Sequential line-range paging detected (" + (activeRanges.length + 1) + " slices read). Prefer `token-goat skeleton " + quotedArg(shown) + "` or " + realSymbolReadHint(normalized, shown, activeSpan) + "." : "";
+    const windowIsNew = isUnseenWindow(pagingWindow, activeRanges, fullReads);
+    if (windowIsNew) {
+      recordActualSlice(event, normalized);
+      if (pagingNote === "") return passOutput();
+      if (!isWithinQuietHours(config2.hints.quiet_hours)) {
+        recordStat("session_hint", 0, 0);
+      }
+      return quietContextOutput(pagingNote.trimStart(), [shown]);
+    }
+    if (fullReads !== 0 || pagingWindow.isExplicitSlice) {
+      if (!isWithinQuietHours(config2.hints.quiet_hours)) {
+        recordStat("session_hint", 0, 0);
+      }
+      recordActualSlice(event, normalized);
+      const sectionCommand = _isDocFile(normalized) ? "token-goat section " + quotedArg(shown + "::" + hintTarget(normalized, "section", { placeholder: "SectionName" }).name) : "";
+      const rereadNote = "Note: " + readSubject(normalized, sectionCommand + pagingNote) + " was already read this session (" + reads + " " + plural + ").";
+      return quietContextOutput(
+        (sectionCommand !== "" ? leadWithCommand(sectionCommand, "to read one section", rereadNote) : rereadNote + " Use token-goat read/section/symbol to re-read surgically.") + pagingNote,
+        [shown]
+      );
+    }
+  }
+  const size = statSize(onDisk);
+  if (event.toolName !== "Grep" && size !== null && !wasFileReadThisSession(normalized) && !isImagePath(normalized) && !isDispatchedFileType(normalized)) {
+    const hints = loadConfig().hints;
+    const policyContext = buildReadPolicyContext({ event, normalizedPath: normalized, shownPath: shown, fileSize: size, hints });
+    const policyOutput = firstReadSymbolOutput(evaluateFirstReadSymbolPolicy(policyContext), policyContext, hints, true);
+    if (policyOutput !== null) return policyOutput;
+  }
+  if (event.toolName !== "Grep" && size !== null && size >= LARGE_FILE_BYTES && !isImagePath(normalized) && !isDispatchedFileType(normalized)) {
+    const slice = estimateRequestedSlice(event, normalized);
+    const gateSize = slice.kind === "bytes" ? Math.min(slice.bytes, size) : size;
+    if (gateSize < LARGE_FILE_BYTES) {
+      recordActualRead(event, normalized);
+      recordActualSlice(event, normalized);
+      return passOutput();
+    }
+    const kb = toKB(size);
+    const config2 = loadConfig();
+    const hint = surgicalHint(normalized, basename5, 1e3);
+    if (gateSize >= largeFileDenyBytes()) {
+      const denyCredit = counterfactualCredit(size);
+      recordStat("session_hint", denyCredit, savedTokensFromBytes(denyCredit), void 0, "large-file-deny");
+      const advice = describeSliceAdvice(slice, normalized) + " " + editAnywayHint(normalized);
+      return denyOutput((hint + " " + sentenceStart(readSubject(normalized, hint + advice)) + " is very large (" + kb + "KB). ").trimStart() + advice);
+    }
+    recordActualRead(event, normalized);
+    recordActualSlice(event, normalized);
+    if (!meetsSavingsFloor(size)) {
+      logSuppressedDetection("read_structural_nav", event.sessionId, normalized);
+      return passOutput();
+    }
+    if (config2.hints.log_large_file_hint_outcomes) {
+      recordLargeFileHintPending(normalized, size);
+    }
+    if (!isWithinQuietHours(config2.hints.quiet_hours)) {
+      recordStat("session_hint", 0, 0);
+    }
+    return quietContextOutput((hint + " " + sentenceStart(readSubject(normalized, hint)) + " is large (" + kb + "KB).").trimStart() + contextPressureAdvisorySuffix(), [shown]);
+  }
+  const fileTypeExt = path6.extname(normalized).slice(1).toLowerCase();
+  const fileStatSize = size ?? statSize(onDisk) ?? 0;
+  const isKnownFileType = DISPATCHED_FILE_TYPE_EXTS.has(fileTypeExt);
+  if (event.toolName !== "Grep" && !isImagePath(normalized) && (isKnownFileType || fileStatSize >= FILE_TYPE_THRESHOLDS.generic)) {
+    const ftSlice = estimateRequestedSlice(event, normalized);
+    const ftEffectiveLength = ftSlice.kind === "bytes" ? Math.min(ftSlice.bytes, fileStatSize) : fileStatSize;
+    let ftContent = "";
+    if (!BINARY_FILE_TYPE_EXTS.has(fileTypeExt) && fileStatSize <= SLICE_ESTIMATE_SCAN_CAP_BYTES) {
+      try {
+        ftContent = fs8.readFileSync(onDisk, "utf8");
+      } catch {
+      }
+    }
+    const ftResult = dispatchFileTypeHandler(normalized, ftContent, ftEffectiveLength);
+    if (ftResult?.shouldBlock) {
+      return denyOutput(ftResult.message);
+    }
+  }
+  const isXmlNudge = /\.(xml|dtsx|ampkg|xaml)$/i.test(basename5);
+  const isDocNudge = /\.(md|mdx|markdown)$/i.test(basename5);
+  const isScriptNudge = /\.(ps1|psm1)$/i.test(basename5);
+  if (event.toolName !== "Grep" && !BINARY_FILE_TYPE_EXTS.has(fileTypeExt) && (!isKnownFileType || isXmlNudge)) {
+    const reqWindow = readRequestedSliceWindow(event);
+    const lineCount = lineCountForSurgicalHint(normalized, fileStatSize);
+    const isSubstantial = fileStatSize >= 5 * 1024 || lineCount >= 50;
+    const isSpanningOver80 = !reqWindow.isExplicitSlice || reqWindow.limit !== void 0 && lineCount > 0 && reqWindow.limit / lineCount >= 0.8;
+    let isIndexedFile = false;
+    if (isSpanningOver80 && isSubstantial) {
+      try {
+        isIndexedFile = getFileEntry(normalized) !== null || filePath !== void 0 && getFileEntry(filePath) !== null;
+      } catch {
+        isIndexedFile = false;
+      }
+    }
+    let isDocEligible = isDocNudge && (reqWindow.isExplicitSlice || lineCount >= 50);
+    if (isDocEligible && !reqWindow.isExplicitSlice) {
+      try {
+        let content = "";
+        if (fileStatSize <= SLICE_ESTIMATE_SCAN_CAP_BYTES) {
+          content = fs8.readFileSync(onDisk, "utf8");
+        }
+        const headings = extractMarkdownHeadings(content);
+        if (headings.length < 3) {
+          isDocEligible = false;
+        }
+      } catch {
+      }
+    }
+    const shouldNudge = (isXmlNudge || isDocEligible || isScriptNudge || isIndexedFile) && !isWithinQuietHours(config.hints.quiet_hours) && (reqWindow.isExplicitSlice || isSubstantial);
+    if (shouldNudge) {
+      recordActualRead(event, normalized);
+      recordActualSlice(event, normalized);
+      recordStat("session_hint", 0, 0);
+      const isTestFile = /\.(tests|test)\.(ps1|[jt]sx?|py)$/i.test(basename5);
+      const nudge = isXmlNudge ? `Note: token-goat available for this file type, consider xml-query/xml-outline first: \`token-goat xml-outline ${quotedArg(shown)}\` or \`token-goat xml-query ${quotedArgs(shown, "<selector>").join(" ")}\`` : isDocNudge ? `Note: token-goat available for this file type, consider section first: \`${sectionOrRangeCommand(shown, hintTarget(normalized, "section"))}\`` : isTestFile ? `Note: token-goat available for this test file, consider surgical read first: \`token-goat read ${quotedArg(`${shown}::${hintTarget(normalized, "symbol", { placeholder: "DescribeBlockName" }).name}`)}\` or \`token-goat skeleton ${quotedArg(shown)}\`` : isScriptNudge ? `Note: token-goat available for this PowerShell file, consider surgical read first: \`token-goat read ${quotedArg(`${shown}::${hintTarget(normalized, "symbol", { placeholder: "FunctionName" }).name}`)}\` or \`token-goat skeleton ${quotedArg(shown)}\`` : `Note: token-goat has this file indexed (>80% read), consider surgical read first: ${surgicalHint(normalized, basename5, lineCount)}`;
+      return quietContextOutput(nudge, isXmlNudge ? void 0 : [shown]);
+    }
+  }
+  recordActualRead(event, normalized);
+  recordActualSlice(event, normalized);
+  return passOutput();
+}
+function preReadHandler(event) {
+  const rawGrepPath = event.toolName === "Grep" ? event.toolInput["path"] : void 0;
+  const target = getFilePath(event) ?? (typeof rawGrepPath === "string" && rawGrepPath !== "" ? resolveEventPath(event, rawGrepPath) : void 0);
+  if (preToolPathDeclined(event, target)) return passOutput();
+  const before = event.toolName === "Read" && target !== void 0 ? getSessionFileEntry(target) : void 0;
+  const output = preReadHandlerInner(event);
+  if (output.hookType !== "pass" && target !== void 0 && readHintCrossesRule(detectHarness(), getCwd(event) ?? process.cwd(), [target])) return passOutput();
+  if (output.hookType === "deny" && event.toolName === "Read" && target !== void 0 && !DELIVERS_CONTENT_RE.test(output.message) && !output.message.includes(SNAPSHOT_DIFF_LEAD)) {
+    unrecordRefusedRead(target, before);
+  }
+  return applyHintTracking(event, output, classifyReadHint);
+}
+registerHook("pre_tool_use", preReadHandler, { toolName: "Read" });
+registerHook("pre_tool_use", preReadHandler, { toolName: "Grep" });
+
+export {
+  indexedSourceText,
+  isVirtualIndexedPath,
+  virtualIndexedScopeNote,
+  NOTEBOOK_CELL_LINES_SUFFIX,
+  formatSymbolLocation,
+  indexMatchesDisk,
+  agentTypeOf,
+  namesRmOrProtectedPath,
+  isSimpleCommand,
+  shellPathWords,
+  primeManagedPolicyAhead,
+  loadCodexRules,
+  primeHiddenRulesAhead,
+  loadingHiddenRuleCheck,
+  permissionNeutralRewrite,
+  readHintCrossesRule,
+  LARGE_SYMBOL_LINE_THRESHOLD,
+  visionTokens,
+  visionTokensSaved,
+  visionTokensSavedByText,
+  canShrinkFormat,
+  decoderRefusal,
+  formatShrinkSummary,
+  ImageDecodeError,
+  probeImageMeta,
+  imageQualifiesForShrink,
+  shrinkImage,
+  compactPathFor,
+  isCompactFresh,
+  markCompactStale,
+  readCompactBody,
+  writeCompact,
+  buildExtractiveCompact,
+  compactDoc,
+  relPathWithinRoot,
+  isSessionArtifactFile,
+  isDiffableSource,
+  isSourceExtension,
+  recordActualSlice,
+  quietContextOutput,
+  sliceForPath,
+  headingTreeParts,
+  hintTarget,
+  sliceCommand,
+  sectionOrRangeCommand,
+  sharpenRepeatedDeny,
+  store,
+  cleanup_stale,
+  readRequestedSliceWindow,
+  readStartLine,
+  harnessNumbersReadContent,
+  numberedRenderBytes,
+  isTruncatedReadDelivery,
+  SLICE_ESTIMATE_SCAN_CAP_BYTES,
+  buildLineDiff,
+  countTextLines,
+  readWindowFromDisk,
+  parseReadDelivery
+};