tianshu-harness 3.23.0

package/dist/chunk-JSS75KCG.js

@@ -0,0 +1,2014 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  validatePath
+} from "./chunk-7RDOV3DF.js";
+import {
+  canonicalPathKey,
+  relativePosix
+} from "./chunk-GD4ZNZ7W.js";
+import {
+  compactProviderStrategy,
+  pruneThresholds
+} from "./chunk-TPI73L57.js";
+import {
+  debugLog
+} from "./chunk-CI4R6P2B.js";
+import {
+  persistRawOutput
+} from "./chunk-XU2YXCDL.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/tools/read-file.ts
+init_esm_shims();
+import { existsSync as existsSync2 } from "fs";
+import { stat as stat2, readFile as readFile3 } from "fs/promises";
+import { extname as extname3, relative } from "path";
+
+// src/tools/truncation.ts
+init_esm_shims();
+var TRUNCATION_NOTE = "... (truncated, use offset/limit for more specific ranges)";
+function truncateContent(content, maxChars, keepHead, keepTail) {
+  if (content.length <= maxChars) return content;
+  const head = content.slice(0, keepHead);
+  const tail = content.slice(-keepTail);
+  return `${head}
+${TRUNCATION_NOTE}
+${tail}`;
+}
+function buildPartialView(content, filePath, maxChars, skeletonOf) {
+  const lines = content.split("\n");
+  const totalLines = lines.length;
+  const totalChars = content.length;
+  const HEADER_OVERHEAD = skeletonOf ? 480 : 300;
+  const budget = Math.max(0, maxChars - HEADER_OVERHEAD);
+  let keptLines = 0;
+  let keptChars = 0;
+  while (keptLines < totalLines && keptChars + (lines[keptLines]?.length ?? 0) + 1 <= budget) {
+    keptChars += lines[keptLines].length + 1;
+    keptLines++;
+  }
+  keptLines = Math.max(1, keptLines);
+  const firstPage = lines.slice(0, keptLines).join("\n");
+  const header = skeletonOf ? [
+    `\u2500\u2500 SKELETON view of ${filePath} (${skeletonOf.lines} lines, ${skeletonOf.chars} chars) \u2500\u2500`,
+    `This is NOT the file's text: it is a structural outline (${keptLines} of ${totalLines} outline lines).`,
+    `Prose, comments and code bodies have been REMOVED \u2014 an empty block here means content was dropped, not that the file is empty.`,
+    `To read the actual content: read_file(file_path="${filePath}", offset=1, limit=200), then page with offset.`
+  ] : [
+    `\u2500\u2500 PARTIAL view of ${filePath} (${totalLines} lines, ${totalChars} chars) \u2500\u2500`,
+    `Showing lines 1-${keptLines} of ${totalLines}.`,
+    `To read more: read_file(file_path="${filePath}", offset=${keptLines + 1}, limit=200)`
+  ];
+  return [
+    ...header,
+    `To find specific code: use grep first, then read_file with offset/limit.`,
+    `For editing: use grep to locate the target line, then hash_edit with anchors \u2014 no full read needed.`,
+    "",
+    firstPage
+  ].join("\n");
+}
+
+// src/tools/gitignore.ts
+init_esm_shims();
+import { existsSync } from "fs";
+import { readFile } from "fs/promises";
+import { resolve, join } from "path";
+var DEFAULT_IGNORE = [
+  "node_modules",
+  ".git",
+  ".svn",
+  ".hg",
+  "__pycache__",
+  ".pytest_cache",
+  ".mypy_cache",
+  ".next",
+  ".nuxt",
+  ".cache",
+  ".turbo",
+  "dist",
+  "build",
+  "out",
+  "target",
+  ".env",
+  ".env.local",
+  ".env.production",
+  "*.pyc",
+  "*.pyo",
+  "*.so",
+  "*.dylib",
+  "*.dll",
+  "*.min.js",
+  "*.min.css",
+  "*.map",
+  "package-lock.json",
+  "yarn.lock",
+  "pnpm-lock.yaml",
+  ".DS_Store",
+  "Thumbs.db"
+];
+var GitignoreFilter = class _GitignoreFilter {
+  patterns;
+  constructor(_cwd, patterns) {
+    this.patterns = patterns ?? [...DEFAULT_IGNORE];
+  }
+  static async create(cwd) {
+    const patterns = [...DEFAULT_IGNORE];
+    const gitignorePath = join(cwd, ".gitignore");
+    if (existsSync(gitignorePath)) {
+      try {
+        const content = await readFile(gitignorePath, "utf-8");
+        for (const line of content.split("\n")) {
+          const trimmed = line.trim();
+          if (!trimmed || trimmed.startsWith("#")) continue;
+          patterns.push(trimmed);
+        }
+      } catch {
+      }
+    }
+    return new _GitignoreFilter(cwd, patterns);
+  }
+  isIgnored(cwd, filePath) {
+    const absPath = resolve(cwd, filePath);
+    const relPath = relativePosix(cwd, absPath);
+    if (relPath === ".." || relPath.startsWith("../")) return false;
+    for (const pattern of this.patterns) {
+      if (this.matchPattern(pattern, relPath)) return true;
+    }
+    return false;
+  }
+  matchPattern(pattern, relPath) {
+    if (pattern.startsWith("!")) return false;
+    let cleanPattern = pattern;
+    const dirOnly = cleanPattern.endsWith("/");
+    if (dirOnly) cleanPattern = cleanPattern.replace(/\/+$/, "");
+    const anchored = cleanPattern.startsWith("/");
+    if (anchored) cleanPattern = cleanPattern.replace(/^\/+/, "");
+    if (anchored) return this.matchGlob(cleanPattern, relPath);
+    const segments = relPath.split("/");
+    for (let i = 0; i < segments.length; i++) {
+      const candidate = segments.slice(i).join("/");
+      if (this.matchGlob(cleanPattern, candidate)) return true;
+      if (dirOnly && i === 0 && segments.length > 1 && this.matchGlob(cleanPattern, segments[i])) return true;
+    }
+    return false;
+  }
+  matchGlob(pattern, str) {
+    if (pattern === str) return true;
+    if (pattern.includes("*")) {
+      const re = globToRegex(pattern);
+      return re.test(str);
+    }
+    if (str.startsWith(pattern + "/") || str === pattern) return true;
+    if (pattern.startsWith(".") && str.endsWith(pattern)) return true;
+    return false;
+  }
+};
+var BACKSLASH = String.fromCharCode(92);
+var RE_SPECIAL = /* @__PURE__ */ new Set([
+  ".",
+  "$",
+  "^",
+  "{",
+  "}",
+  "(",
+  ")",
+  "|",
+  "[",
+  "]",
+  BACKSLASH
+]);
+function globToRegex(glob) {
+  let re = "";
+  for (let i = 0; i < glob.length; i++) {
+    const ch = glob[i];
+    if (ch === "*") {
+      if (glob[i + 1] === "*") {
+        i++;
+        if (glob[i + 1] === "/") {
+          i++;
+          re += "(?:.*/)?";
+        } else {
+          re += ".*";
+        }
+      } else {
+        re += "[^/]*";
+      }
+    } else if (ch === "?") {
+      re += "[^/]";
+    } else if (RE_SPECIAL.has(ch)) {
+      re += BACKSLASH + ch;
+    } else {
+      re += ch;
+    }
+  }
+  return new RegExp("^(?:" + re + ")(?:/.*)?$");
+}
+
+// src/artifact/summarize.ts
+init_esm_shims();
+function summarizeFileContent(content, filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase() ?? "";
+  switch (ext) {
+    case "ts":
+    case "tsx":
+    case "js":
+    case "jsx":
+      return summarizeJsTs(content, filePath);
+    case "py":
+      return summarizePython(content, filePath);
+    case "rs":
+      return summarizeRust(content, filePath);
+    case "go":
+      return summarizeGo(content, filePath);
+    case "md":
+    case "mdx":
+      return summarizeMarkdown(content, filePath);
+    case "json":
+      return summarizeJson(content, filePath);
+    default:
+      return summarizeGeneric(content, filePath);
+  }
+}
+function summarizeJsTs(content, filePath) {
+  const lines = content.split("\n");
+  const sections = [];
+  const exports = [];
+  const functions = [];
+  const classes = [];
+  const imports = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const importMatch = line.match(/^import\s+.*?\s+from\s+['"](.+?)['"]/) ?? line.match(/^import\s+['"](.+?)['"]/);
+    if (importMatch) {
+      imports.push(importMatch[1]);
+      continue;
+    }
+    const reExportMatch = line.match(/^export\s+\{[^}]*\}\s+from\s+['"](.+?)['"]/);
+    if (reExportMatch) {
+      imports.push(reExportMatch[1]);
+      continue;
+    }
+    const exportMatch = line.match(/^export\s+(?:default\s+)?(?:function|class|const|let|var)\s+(\w+)/);
+    if (exportMatch) {
+      exports.push(exportMatch[1]);
+      const end = findBlockEnd(lines, i);
+      sections.push({
+        name: `export:${exportMatch[1]}`,
+        lineStart: i + 1,
+        lineEnd: end + 1,
+        charCount: lines.slice(i, end + 1).join("\n").length
+      });
+      continue;
+    }
+    const bareExportMatch = line.match(/^export\s+\{([^}]+)\}/);
+    if (bareExportMatch) {
+      const names = bareExportMatch[1].split(",").map((n) => n.trim().split(/\s+as\s+/).pop().trim()).filter(Boolean);
+      exports.push(...names);
+      continue;
+    }
+    const fnMatch = line.match(/^(?:export\s+)?(?:async\s+)?function\s+(\w+)/);
+    if (fnMatch && !exports.includes(fnMatch[1])) {
+      functions.push(fnMatch[1]);
+    }
+    const classMatch = line.match(/^(?:export\s+)?(?:default\s+)?class\s+(\w+)/);
+    if (classMatch && !exports.includes(classMatch[1])) {
+      classes.push(classMatch[1]);
+    }
+  }
+  if (imports.length > 0) {
+    sections.unshift({
+      name: "imports",
+      lineStart: 1,
+      lineEnd: Math.min(imports.length, lines.length),
+      charCount: imports.join("\n").length
+    });
+  }
+  const ext = filePath.split(".").pop() ?? "";
+  const parts = [`${ext} file, ${lines.length} lines.`];
+  if (exports.length > 0) parts.push(`Exports: ${exports.slice(0, 8).join(", ")}${exports.length > 8 ? ` (+${exports.length - 8})` : ""}`);
+  if (functions.length > 0) parts.push(`Functions: ${functions.slice(0, 5).join(", ")}`);
+  if (classes.length > 0) parts.push(`Classes: ${classes.join(", ")}`);
+  return { summary: parts.join(" "), sections };
+}
+function summarizePython(content, _filePath) {
+  const lines = content.split("\n");
+  const sections = [];
+  const classes = [];
+  const functions = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const classMatch = line.match(/^class\s+(\w+)/);
+    if (classMatch) {
+      classes.push(classMatch[1]);
+      const end = findPythonBlockEnd(lines, i);
+      sections.push({
+        name: `class:${classMatch[1]}`,
+        lineStart: i + 1,
+        lineEnd: end + 1,
+        charCount: lines.slice(i, end + 1).join("\n").length
+      });
+      continue;
+    }
+    const fnMatch = line.match(/^(?:async\s+)?def\s+(\w+)/);
+    if (fnMatch) {
+      functions.push(fnMatch[1]);
+      const end = findPythonBlockEnd(lines, i);
+      sections.push({
+        name: `function:${fnMatch[1]}`,
+        lineStart: i + 1,
+        lineEnd: end + 1,
+        charCount: lines.slice(i, end + 1).join("\n").length
+      });
+    }
+  }
+  const parts = [`py file, ${lines.length} lines.`];
+  if (classes.length > 0) parts.push(`Classes: ${classes.join(", ")}`);
+  if (functions.length > 0) parts.push(`Functions: ${functions.join(", ")}`);
+  return { summary: parts.join(" "), sections };
+}
+function summarizeRust(content, _filePath) {
+  const lines = content.split("\n");
+  const sections = [];
+  const fns = [];
+  const structs = [];
+  const enums = [];
+  const impls = [];
+  const traits = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const fnMatch = line.match(/^(?:pub\s+)?(?:async\s+)?fn\s+(\w+)/);
+    if (fnMatch) {
+      fns.push(fnMatch[1]);
+      sections.push({
+        name: `fn:${fnMatch[1]}`,
+        lineStart: i + 1,
+        lineEnd: findBlockEnd(lines, i) + 1,
+        charCount: 0
+      });
+      continue;
+    }
+    const structMatch = line.match(/^(?:pub\s+)?struct\s+(\w+)/);
+    if (structMatch) {
+      structs.push(structMatch[1]);
+      continue;
+    }
+    const enumMatch = line.match(/^(?:pub\s+)?enum\s+(\w+)/);
+    if (enumMatch) {
+      enums.push(enumMatch[1]);
+      continue;
+    }
+    const implMatch = line.match(/^impl(?:<[^>]*>)?\s+(?:\w+\s+for\s+)?(\w+)/);
+    if (implMatch) {
+      impls.push(implMatch[1]);
+      continue;
+    }
+    const traitMatch = line.match(/^(?:pub\s+)?trait\s+(\w+)/);
+    if (traitMatch) {
+      traits.push(traitMatch[1]);
+      continue;
+    }
+  }
+  const parts = [`rs file, ${lines.length} lines.`];
+  if (structs.length > 0) parts.push(`Structs: ${structs.join(", ")}`);
+  if (enums.length > 0) parts.push(`Enums: ${enums.join(", ")}`);
+  if (traits.length > 0) parts.push(`Traits: ${traits.join(", ")}`);
+  if (impls.length > 0) parts.push(`Impls: ${impls.join(", ")}`);
+  if (fns.length > 0) parts.push(`Fns: ${fns.slice(0, 8).join(", ")}`);
+  return { summary: parts.join(" "), sections };
+}
+function summarizeGo(content, _filePath) {
+  const lines = content.split("\n");
+  return {
+    summary: `go file, ${lines.length} lines. low-detail summary (no Go structural parser yet), consider read_section for details.`,
+    sections: []
+  };
+}
+function summarizeMarkdown(content, _filePath) {
+  const lines = content.split("\n");
+  const sections = [];
+  const headings = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const headingMatch = line.match(/^(#{1,6})\s+(.+)/);
+    if (headingMatch) {
+      const title = headingMatch[2].trim();
+      headings.push(title);
+      const level = headingMatch[1].length;
+      const end = findMarkdownSectionEnd(lines, i, level);
+      sections.push({
+        name: `heading:${title}`,
+        lineStart: i + 1,
+        lineEnd: end + 1,
+        charCount: lines.slice(i, end + 1).join("\n").length
+      });
+    }
+  }
+  const parts = [`md file, ${lines.length} lines.`];
+  if (headings.length > 0) parts.push(`Headings: ${headings.slice(0, 10).join(", ")}`);
+  return { summary: parts.join(" "), sections };
+}
+function summarizeJson(content, _filePath) {
+  const lines = content.split("\n");
+  const sections = [];
+  try {
+    const parsed = JSON.parse(content);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      const topKeys = Object.keys(parsed);
+      const nestedKeys = [];
+      for (const key of topKeys) {
+        const val = parsed[key];
+        if (typeof val === "object" && val !== null) {
+          nestedKeys.push(key);
+        }
+      }
+      for (const key of topKeys) {
+        const keyLineIdx = lines.findIndex((l) => l.includes(`"${key}"`));
+        if (keyLineIdx >= 0) {
+          sections.push({
+            name: `key:${key}`,
+            lineStart: keyLineIdx + 1,
+            lineEnd: keyLineIdx + 1,
+            charCount: 0
+          });
+        }
+      }
+      const parts = [`json file, ${lines.length} lines.`];
+      parts.push(`Keys: ${topKeys.join(", ")}`);
+      if (nestedKeys.length > 0) {
+        parts.push(`Nested: ${nestedKeys.join(", ")}`);
+      }
+      return { summary: parts.join(" "), sections };
+    }
+  } catch {
+  }
+  return {
+    summary: `json file, ${lines.length} lines.`,
+    sections
+  };
+}
+function summarizeGeneric(content, filePath) {
+  const lines = content.split("\n");
+  const ext = filePath.split(".").pop() ?? "";
+  return {
+    summary: `${ext} file, ${lines.length} lines. low-detail summary, consider read_section for details.`,
+    sections: []
+  };
+}
+function findBlockEnd(lines, startIdx) {
+  let braceCount = 0;
+  let foundOpen = false;
+  for (let i = startIdx; i < lines.length; i++) {
+    const line = lines[i];
+    for (const ch of line) {
+      if (ch === "{") {
+        braceCount++;
+        foundOpen = true;
+      }
+      if (ch === "}") braceCount--;
+    }
+    if (foundOpen && braceCount <= 0) return i;
+  }
+  return Math.min(startIdx + 20, lines.length - 1);
+}
+function findPythonBlockEnd(lines, startIdx) {
+  const startIndent = lines[startIdx].search(/\S/);
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim().length === 0) continue;
+    const indent = line.search(/\S/);
+    if (indent <= startIndent) return i - 1;
+  }
+  return lines.length - 1;
+}
+function findMarkdownSectionEnd(lines, startIdx, level) {
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    const headingMatch = lines[i].match(/^(#{1,6})\s+/);
+    if (headingMatch && headingMatch[1].length <= level) return i - 1;
+  }
+  return lines.length - 1;
+}
+function grepLineFile(line) {
+  const m = line.match(/^(.+?):\d+:/) ?? line.match(/^(.+?)-\d+-/);
+  return (m ? m[1] : line.split(":")[0] ?? "").trim();
+}
+function summarizeGrepResult(content, pattern) {
+  const lines = content.split(/\r?\n/).filter((l) => l.trim());
+  const files = new Set(lines.map(grepLineFile).filter(Boolean));
+  return {
+    summary: `grep "${pattern}": ${lines.length} matches in ${files.size} files. Files: ${[...files].slice(0, 5).join(", ")}${files.size > 5 ? ` (+${files.size - 5})` : ""}`,
+    sections: []
+  };
+}
+function summarizeBashOutput(content, command, exitCode) {
+  const lines = content.split("\n");
+  const status = exitCode === 0 ? "success" : `failed (exit ${exitCode})`;
+  const testSummary = lines.find((l) => /tests?\s*(?:pass|passed|fail|failed)|total/i.test(l)) ?? lines.find((l) => /\d+\s+tests?\s+pass/i.test(l)) ?? lines.find((l) => /\d+\s+tests?\s+passed/i.test(l));
+  const errorLines = lines.filter((l) => /error|Error|FAIL/i.test(l)).slice(0, 3);
+  const parts = [`[${command.slice(0, 40)}] ${status}, ${lines.length} lines.`];
+  if (testSummary) parts.push(testSummary.trim());
+  if (exitCode === 0 && !testSummary) {
+    const lastLine = lines.filter((l) => l.trim()).pop();
+    if (lastLine) parts.push(lastLine.trim());
+  }
+  if (errorLines.length > 0 && exitCode !== 0) parts.push(`Errors: ${errorLines.map((l) => l.trim().slice(0, 60)).join("; ")}`);
+  return { summary: parts.join(" "), sections: [] };
+}
+
+// src/tools/model-read-cap.ts
+init_esm_shims();
+var DEFAULT_MODEL_READ_CAP = {
+  maxChars: 8e3,
+  headChars: 4e3,
+  tailChars: 2e3
+};
+var ABSOLUTE_MAX_CHARS = 12e4;
+function tokenFractionPerCall(contextWindow) {
+  if (contextWindow >= 5e5) return 0.05;
+  if (contextWindow >= 2e5) return 0.03;
+  return 0.02;
+}
+var CHARS_PER_TOKEN = 4;
+var STRATEGY_MULTIPLIER = {
+  "cache-preserving": 1.3,
+  balanced: 1,
+  aggressive: 0.65
+};
+function computeModelReadCap(input = {}) {
+  const { contextWindow, providerProfile } = input;
+  if (!contextWindow || contextWindow <= 0) {
+    return DEFAULT_MODEL_READ_CAP;
+  }
+  const strategy = compactProviderStrategy(providerProfile);
+  const multiplier = STRATEGY_MULTIPLIER[strategy];
+  const fraction = tokenFractionPerCall(contextWindow);
+  const computed = Math.floor(contextWindow * fraction * CHARS_PER_TOKEN * multiplier);
+  const maxChars = Math.min(Math.max(computed, DEFAULT_MODEL_READ_CAP.maxChars), ABSOLUTE_MAX_CHARS);
+  return {
+    maxChars,
+    headChars: Math.floor(maxChars * 0.6),
+    tailChars: Math.floor(maxChars * 0.3)
+  };
+}
+
+// src/tools/artifact-threshold.ts
+init_esm_shims();
+var TOOL_ARTIFACT_MULTIPLIERS = {
+  read_file: 2,
+  // B3 lowered from 5.0; on 1M window: 300K (B1 cap at 120K is tighter)
+  bash: 1,
+  // B3 lowered from 1.67; ~150K on 1M window (matches prune minChars)
+  grep: 0.67,
+  // search results are compact; wrap earlier at ~100K
+  run_tests: 1.5,
+  // B3 lowered from 3.33; ~225K on 1M window
+  diff: 1,
+  // B3 lowered from 2.0; ~150K on 1M window
+  glob: 0.5,
+  // file lists are very compact
+  repo_map: 0.5,
+  // file trees are compact
+  inspect_project: 0.5,
+  // project summaries are compact
+  web_fetch: 1,
+  // web content varies; default
+  read_section: 2
+  // B3 lowered from 5.0; same as read_file
+};
+var DEFAULT_MULTIPLIER = 1;
+function getToolArtifactThreshold(toolName, contextWindow) {
+  const base = contextWindow != null && contextWindow > 0 ? pruneThresholds(contextWindow).minChars : 800;
+  const multiplier = TOOL_ARTIFACT_MULTIPLIERS[toolName] ?? DEFAULT_MULTIPLIER;
+  return Math.round(base * multiplier);
+}
+
+// src/tools/read-policy.ts
+init_esm_shims();
+var LOG_PREVIEW_GUARD_BYTES = 16 * 1024;
+var DEFAULT_PREVIEW_LINES = 80;
+var DEFAULT_MAX_RANGE_LINES = 200;
+var SOURCE_SMALL_BYTES = 20 * 1024;
+var SOURCE_LARGE_BYTES = 80 * 1024;
+function classifyPath(filePath) {
+  const lower = filePath.toLowerCase();
+  if (/\.(?:jsonl|ndjson)(?:\.\d+)?$/.test(lower)) return "jsonl";
+  if (/\.(?:log|out|err|trace)(?:\.\d+)?$/.test(lower)) return "log";
+  if (/\.min\.(?:js|css)$/.test(lower)) return "minified";
+  if (/(?:^|\/)(?:dist|build|coverage|\.next)\//.test(lower)) return "generated";
+  if (/\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|css|scss|html|yml|yaml)$/.test(lower)) return "source";
+  return "unknown";
+}
+function decideReadPolicy(input) {
+  const kind = classifyPath(input.filePath);
+  const base = { kind, previewLines: DEFAULT_PREVIEW_LINES, maxRangeLines: DEFAULT_MAX_RANGE_LINES };
+  if (input.hasExplicitRange) {
+    return { ...base, action: "full", reason: "explicit range requested" };
+  }
+  if ((kind === "log" || kind === "jsonl") && input.sizeBytes > LOG_PREVIEW_GUARD_BYTES) {
+    return { ...base, action: "preview", reason: "log-like file over preview guard" };
+  }
+  if (kind === "generated" || kind === "minified") {
+    return { ...base, action: "reject-with-range", reason: "generated or minified file requires an explicit range" };
+  }
+  if (kind === "source" || kind === "unknown") {
+    if (input.sizeBytes > SOURCE_LARGE_BYTES) {
+      return { ...base, action: "partial", reason: "large source file \u2014 returning first page with navigation hints" };
+    }
+    if (input.sizeBytes > SOURCE_SMALL_BYTES) {
+      return { ...base, action: "full-with-hint", reason: "medium source file \u2014 full read with editing hints" };
+    }
+  }
+  return { ...base, action: "full", reason: "safe default read" };
+}
+
+// src/compact/code-fold.ts
+init_esm_shims();
+import { extname } from "path";
+var DEFAULT_MAX_LINES = 200;
+var MIN_LINES_TO_FOLD = 50;
+var MAX_SCAN_LINES = 3e3;
+var TAIL_KEEP = 20;
+function detectLanguage(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  const map = {
+    ".ts": "ts",
+    ".tsx": "tsx",
+    ".js": "js",
+    ".jsx": "jsx",
+    ".mjs": "js",
+    ".cjs": "js",
+    ".py": "py",
+    ".pyi": "py",
+    ".json": "json",
+    ".md": "md",
+    ".mdx": "md"
+  };
+  return map[ext] ?? "unknown";
+}
+function countNetBraces(line) {
+  let depth = 0;
+  let inString = null;
+  let escaped = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (ch === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (inString) {
+      if (ch === inString) inString = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      inString = ch;
+      continue;
+    }
+    if (ch === "{") depth++;
+    else if (ch === "}") depth--;
+  }
+  return depth;
+}
+var FUNCTION_LIKE = /^\s*(export\s+)?(default\s+)?(async\s+)?(function\s*\*?\s+\w+|const\s+\w+\s*(?::\s*[^=]+)?=\s*(?:async\s*)?\(|class\s+\w+|get\s+\w+|set\s+\w+|constructor\s*\()/;
+var STRUCTURAL_DECL = /^\s*(export\s+)?(abstract\s+)?(interface\s+\w+|type\s+\w+\s*=|enum\s+\w+)/;
+var IMPORT_EXPORT = /^\s*(import\s|export\s(?:\{|\*|type|default))/;
+function classifyLine(line) {
+  if (IMPORT_EXPORT.test(line)) return "import";
+  if (STRUCTURAL_DECL.test(line)) return "structural";
+  if (FUNCTION_LIKE.test(line)) return "signature";
+  return "other";
+}
+function truncateSig(line) {
+  const t = line.trim();
+  return t.length > 120 ? t.slice(0, 117) + "..." : t;
+}
+function foldTsLike(lines, originalLines, maxLines) {
+  const output = [];
+  const signatures = [];
+  const scanLimit = Math.min(lines.length, MAX_SCAN_LINES);
+  let braceDepth = 0;
+  let hadFold = false;
+  let i = 0;
+  while (i < scanLimit) {
+    const line = lines[i];
+    const cls = classifyLine(line);
+    const netBraces = countNetBraces(line);
+    if (cls === "import") {
+      output.push(line);
+      i++;
+      continue;
+    }
+    if (cls === "signature") {
+      signatures.push(truncateSig(line));
+      output.push(line);
+      const entryDepth = braceDepth;
+      let blockStartDepth = null;
+      if (netBraces > 0) {
+        blockStartDepth = braceDepth;
+        braceDepth += netBraces;
+        if (braceDepth <= entryDepth) blockStartDepth = null;
+      } else if (i + 1 < scanLimit) {
+        const nextLine = lines[i + 1];
+        const nextNet = countNetBraces(nextLine);
+        if (nextLine.trim().startsWith("{") && nextNet > 0) {
+          blockStartDepth = braceDepth;
+          braceDepth += nextNet;
+          i++;
+        }
+      }
+      if (blockStartDepth !== null && braceDepth > blockStartDepth) {
+        hadFold = true;
+        while (i + 1 < scanLimit && braceDepth > blockStartDepth) {
+          i++;
+          braceDepth += countNetBraces(lines[i]);
+        }
+        braceDepth = Math.max(0, braceDepth);
+        output.push("  { \u2026 }");
+      }
+      i++;
+      continue;
+    }
+    if (cls === "structural") {
+      signatures.push(truncateSig(line));
+      output.push(line);
+      braceDepth += netBraces;
+      braceDepth = Math.max(0, braceDepth);
+      i++;
+      continue;
+    }
+    output.push(line);
+    braceDepth += netBraces;
+    braceDepth = Math.max(0, braceDepth);
+    i++;
+  }
+  if (scanLimit < originalLines) {
+    output.push(`  \u2026 (${originalLines - scanLimit} more lines not scanned) \u2026`);
+  }
+  if (output.length > maxLines) {
+    const headCount = maxLines - TAIL_KEEP - 1;
+    const headPart = output.slice(0, headCount);
+    const tailPart = output.slice(-TAIL_KEEP);
+    const omitted = output.length - headCount - TAIL_KEEP;
+    output.length = 0;
+    output.push(...headPart, `  \u2026 (${omitted} lines omitted) \u2026`, ...tailPart);
+  }
+  const folded = output.join("\n");
+  return {
+    folded,
+    originalLines,
+    foldedLines: output.length,
+    signatures,
+    wasFolded: hadFold && output.length < originalLines
+  };
+}
+var PY_DEF = /^\s*(async\s+)?def\s+\w+/;
+var PY_CLASS = /^\s*class\s+\w+/;
+var PY_DECORATOR = /^\s*@/;
+function indentOf(line) {
+  let n = 0;
+  for (const ch of line) {
+    if (ch === " ") n++;
+    else break;
+  }
+  return n;
+}
+function foldPython(lines, originalLines, maxLines) {
+  const output = [];
+  const signatures = [];
+  let hadFold = false;
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (PY_DECORATOR.test(line)) {
+      output.push(line);
+      i++;
+      continue;
+    }
+    if (PY_DEF.test(line) || PY_CLASS.test(line)) {
+      signatures.push(truncateSig(line));
+      output.push(line);
+      const defIndent = indentOf(line);
+      let bodyStart = i + 1;
+      let bodyEnd = bodyStart;
+      while (bodyEnd < lines.length) {
+        const bodyLine = lines[bodyEnd];
+        if (bodyLine.trim() === "") {
+          bodyEnd++;
+          continue;
+        }
+        if (indentOf(bodyLine) <= defIndent) break;
+        bodyEnd++;
+      }
+      if (bodyEnd > bodyStart) {
+        hadFold = true;
+        output.push("  { \u2026 }");
+        i = bodyEnd;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    output.push(line);
+    i++;
+  }
+  if (output.length > maxLines) {
+    const headCount = maxLines - TAIL_KEEP - 1;
+    const headPart = output.slice(0, headCount);
+    const tailPart = output.slice(-TAIL_KEEP);
+    const omitted = output.length - headCount - TAIL_KEEP;
+    output.length = 0;
+    output.push(...headPart, `  \u2026 (${omitted} lines omitted) \u2026`, ...tailPart);
+  }
+  return {
+    folded: output.join("\n"),
+    originalLines,
+    foldedLines: output.length,
+    signatures,
+    wasFolded: hadFold && output.length < originalLines
+  };
+}
+function foldJson(content, originalLines) {
+  try {
+    const parsed = JSON.parse(content);
+    const summary = JSON.stringify(jsonSkeleton(parsed), null, 2);
+    const lines = summary.split("\n");
+    return {
+      folded: summary,
+      originalLines,
+      foldedLines: lines.length,
+      signatures: [],
+      wasFolded: lines.length < originalLines
+    };
+  } catch {
+    return { folded: content, originalLines, foldedLines: originalLines, signatures: [], wasFolded: false };
+  }
+}
+function jsonSkeleton(value, depth = 0) {
+  if (depth > 2) return "\u2026";
+  if (Array.isArray(value)) {
+    if (value.length === 0) return [];
+    return [`(${value.length} items)`, jsonSkeleton(value[0], depth + 1)];
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const key of Object.keys(value)) {
+      const v = value[key];
+      if (Array.isArray(v)) {
+        result[key] = v.length > 0 ? `[${v.length} items]` : [];
+      } else if (v !== null && typeof v === "object") {
+        result[key] = depth < 1 ? jsonSkeleton(v, depth + 1) : "{ \u2026 }";
+      } else {
+        result[key] = typeof v;
+      }
+    }
+    return result;
+  }
+  return typeof value;
+}
+function foldMarkdown(lines, originalLines, maxLines) {
+  const output = [];
+  let hadFold = false;
+  for (const line of lines) {
+    if (/^#{1,6}\s/.test(line)) {
+      output.push(line);
+      continue;
+    }
+    if (output.length > 0 && /^#{1,6}\s/.test(output[output.length - 1])) {
+      output.push(line);
+      continue;
+    }
+    if (line.trim().startsWith("```")) {
+      output.push(line);
+      continue;
+    }
+    if (line.trim() !== "") {
+      hadFold = true;
+    }
+  }
+  if (!hadFold || output.length >= originalLines) {
+    return { folded: lines.join("\n"), originalLines, foldedLines: originalLines, signatures: [], wasFolded: false };
+  }
+  if (output.length > maxLines) {
+    const headCount = maxLines - TAIL_KEEP - 1;
+    const headPart = output.slice(0, headCount);
+    const tailPart = output.slice(-TAIL_KEEP);
+    const omitted = output.length - headCount - TAIL_KEEP;
+    output.length = 0;
+    output.push(...headPart, `  \u2026 (${omitted} lines omitted) \u2026`, ...tailPart);
+  }
+  return {
+    folded: output.join("\n"),
+    originalLines,
+    foldedLines: output.length,
+    signatures: [],
+    wasFolded: true
+  };
+}
+function foldCode(content, options) {
+  const filePath = options.filePath;
+  const maxLines = options.maxLines ?? DEFAULT_MAX_LINES;
+  const lang = detectLanguage(filePath);
+  const lines = content.split("\n");
+  const originalLines = lines.length;
+  if (originalLines < MIN_LINES_TO_FOLD) {
+    return { folded: content, originalLines, foldedLines: originalLines, signatures: [], wasFolded: false };
+  }
+  switch (lang) {
+    case "unknown":
+      return { folded: content, originalLines, foldedLines: originalLines, signatures: [], wasFolded: false };
+    case "json":
+      return foldJson(content, originalLines);
+    case "md":
+      return foldMarkdown(lines, originalLines, maxLines);
+    case "py":
+      return foldPython(lines, originalLines, maxLines);
+    default:
+      return foldTsLike(lines, originalLines, maxLines);
+  }
+}
+
+// src/agent/prewarm-file.ts
+init_esm_shims();
+import { stat } from "fs/promises";
+import { statSync } from "fs";
+var MAX_PREWARM_BYTES = 1e5;
+function canUsePrewarmForRead(input) {
+  return typeof input.file_path === "string" && input.offset === void 0 && input.limit === void 0;
+}
+async function buildPrewarmValue(cwd, filePath) {
+  try {
+    const payload = await readFilePayload(cwd, { filePath });
+    const fileStat = await stat(payload.canonicalPath);
+    if (fileStat.size > MAX_PREWARM_BYTES) return void 0;
+    return {
+      canonicalPath: payload.canonicalPath,
+      content: payload.rawContent,
+      uiContent: payload.uiContent,
+      mtimeMs: fileStat.mtimeMs,
+      sizeBytes: fileStat.size
+    };
+  } catch {
+    return void 0;
+  }
+}
+var buildPrewarmValueAsync = buildPrewarmValue;
+function consumePrewarm(cache, canonicalPath) {
+  const value = cache.get(canonicalPath);
+  if (!value) return null;
+  try {
+    const live = statSync(canonicalPath);
+    if (live.mtimeMs !== value.mtimeMs || live.size !== value.sizeBytes) {
+      cache.invalidate(canonicalPath);
+      return null;
+    }
+    return value;
+  } catch {
+    cache.invalidate(canonicalPath);
+    return null;
+  }
+}
+async function batchPrewarm(cwd, paths, cache, limit = 5) {
+  let count = 0;
+  for (const filePath of paths) {
+    if (count >= limit) break;
+    const value = await buildPrewarmValueAsync(cwd, filePath);
+    if (!value) continue;
+    if (cache.has(value.canonicalPath)) continue;
+    cache.set(value.canonicalPath, value);
+    count++;
+    await new Promise((resolve2) => setImmediate(resolve2));
+  }
+}
+
+// src/tools/office-reader.ts
+init_esm_shims();
+import { execFile } from "child_process";
+import { access, readFile as readFile2, unlink } from "fs/promises";
+import { extname as extname2, basename } from "path";
+import { tmpdir } from "os";
+function execFileAsync(binary, args, opts) {
+  return new Promise((resolve2, reject) => {
+    execFile(binary, args, { timeout: opts?.timeout ?? 3e4, maxBuffer: 10 * 1024 * 1024, windowsHide: true }, (err, stdout, stderr) => {
+      if (err) reject(err);
+      else resolve2({ stdout, stderr });
+    });
+  });
+}
+var OFFICE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".doc",
+  ".docx",
+  ".rtf",
+  ".odt"
+]);
+var cachedSofficeBinary = "soffice";
+async function detectEngine() {
+  if (process.platform === "darwin") {
+    try {
+      await access("/usr/bin/textutil");
+      return "textutil";
+    } catch {
+    }
+  }
+  try {
+    await execFileAsync("soffice", ["--version"], { timeout: 5e3 });
+    cachedSofficeBinary = "soffice";
+    return "soffice";
+  } catch {
+  }
+  try {
+    await execFileAsync("libreoffice", ["--version"], { timeout: 5e3 });
+    cachedSofficeBinary = "libreoffice";
+    return "soffice";
+  } catch {
+  }
+  return null;
+}
+var cachedEngine;
+async function getEngine() {
+  if (cachedEngine !== void 0) return cachedEngine;
+  cachedEngine = await detectEngine();
+  if (!cachedEngine) {
+    try {
+      await import("mammoth");
+      cachedEngine = "mammoth";
+    } catch {
+      const installs = {
+        darwin: "",
+        // textutil is built-in
+        linux: "sudo apt install libreoffice",
+        win32: "winget install LibreOffice.LibreOffice"
+      };
+      throw new Error(
+        `No Office document converter available. Install LibreOffice${installs[process.platform] ? ": " + installs[process.platform] : ""}. Or install mammoth for .docx only: npm install mammoth`
+      );
+    }
+  }
+  return cachedEngine;
+}
+async function readOfficeFile(filePath) {
+  const ext = extname2(filePath).toLowerCase();
+  const engine = await getEngine();
+  if (engine === "textutil") {
+    return readWithTextutil(filePath, ext);
+  }
+  if (engine === "soffice") {
+    return readWithSoffice(filePath, ext);
+  }
+  return readWithMammoth(filePath, ext);
+}
+async function readWithTextutil(filePath, ext) {
+  const text = await execTextutil(filePath);
+  return { text, engine: "textutil", sourceFormat: ext };
+}
+async function readWithSoffice(filePath, ext) {
+  const text = await execSoffice(filePath);
+  return { text, engine: "soffice", sourceFormat: ext };
+}
+async function readWithMammoth(filePath, ext) {
+  if (ext !== ".docx") {
+    throw new Error(
+      `mammoth only supports .docx files (got ${ext}). Install LibreOffice for .doc/.rtf/.odt support: https://www.libreoffice.org/`
+    );
+  }
+  const text = await execMammoth(filePath);
+  return { text, engine: "mammoth", sourceFormat: ext };
+}
+function execTextutil(filePath) {
+  return new Promise((resolve2, reject) => {
+    execFile("textutil", ["-convert", "txt", "-stdout", filePath], {
+      timeout: 3e4,
+      maxBuffer: 10 * 1024 * 1024,
+      // 10 MB
+      windowsHide: true
+    }, (err, stdout) => {
+      if (err) reject(new Error(`textutil failed: ${err.message}`));
+      else resolve2(stdout);
+    });
+  });
+}
+function execSoffice(filePath) {
+  const name = basename(filePath);
+  const outName = name.replace(/\.[^.]+$/, ".txt");
+  const outPath = `${tmpdir()}/${outName}`;
+  return new Promise((resolve2, reject) => {
+    execFile(cachedSofficeBinary, ["--headless", "--convert-to", "txt", "--outdir", tmpdir(), filePath], {
+      timeout: 6e4,
+      windowsHide: true
+    }, async (err) => {
+      if (err) {
+        reject(new Error(`${cachedSofficeBinary} failed: ${err.message}`));
+        return;
+      }
+      try {
+        const text = await readFile2(outPath, "utf-8");
+        await unlink(outPath).catch(() => {
+        });
+        resolve2(text);
+      } catch (e) {
+        reject(new Error(`soffice output file not found: ${outPath}`));
+      }
+    });
+  });
+}
+async function execMammoth(filePath) {
+  const mammoth = await import("mammoth");
+  const result = await mammoth.extractRawText({ path: filePath });
+  return result.value;
+}
+
+// src/tools/focused-read.ts
+init_esm_shims();
+var DEFAULT_MAX_MATCHES = 8;
+var DEFAULT_CONTEXT_LINES = 2;
+var MAX_FOCUS_LENGTH = 240;
+var FOCUS_STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "for",
+  "from",
+  "find",
+  "file",
+  "into",
+  "look",
+  "read",
+  "the",
+  "this",
+  "with",
+  "please",
+  "show",
+  "where",
+  "what",
+  "which",
+  "code",
+  "source",
+  "implementation",
+  "\u8BF7",
+  "\u5E2E\u6211",
+  "\u67E5\u627E",
+  "\u8BFB\u53D6",
+  "\u770B\u770B",
+  "\u6587\u4EF6",
+  "\u4EE3\u7801",
+  "\u5B9E\u73B0",
+  "\u76F8\u5173",
+  "\u95EE\u9898",
+  "\u4E00\u4E0B",
+  "\u91CC\u9762"
+]);
+var STRUCTURAL_LINE = /^\s*(?:import\b|export\b|(?:async\s+)?function\b|class\b|interface\b|type\b|enum\b|const\b|let\b|var\b|def\b|struct\b|impl\b|trait\b|#{1,6}\s)/;
+function normalizeFocus(focus) {
+  return focus.replace(/\s+/g, " ").trim().slice(0, MAX_FOCUS_LENGTH);
+}
+function tokenizeFocus(focus) {
+  const fragments = normalizeFocus(focus).toLowerCase().match(/[a-z_$][a-z0-9_$-]{1,}|[\u4e00-\u9fff]+/g) ?? [];
+  const tokens = /* @__PURE__ */ new Set();
+  for (const fragment of fragments) {
+    if (/^[a-z_$]/.test(fragment)) {
+      if (fragment.length >= 2 && !FOCUS_STOP_WORDS.has(fragment)) tokens.add(fragment);
+      continue;
+    }
+    if (fragment.length === 1) {
+      if (!FOCUS_STOP_WORDS.has(fragment)) tokens.add(fragment);
+      continue;
+    }
+    for (let i = 0; i < fragment.length - 1; i++) {
+      const bigram = fragment.slice(i, i + 2);
+      if (!FOCUS_STOP_WORDS.has(bigram)) tokens.add(bigram);
+    }
+  }
+  return [...tokens];
+}
+function scoreLine(line, focus, tokens) {
+  const lower = line.toLowerCase();
+  const normalizedFocus = normalizeFocus(focus).toLowerCase();
+  let score = 0;
+  if (normalizedFocus.length >= 4 && lower.includes(normalizedFocus)) score += 24;
+  let matches = 0;
+  for (const token of tokens) {
+    if (!lower.includes(token)) continue;
+    matches++;
+    score += token.includes("_") || token.length >= 6 ? 7 : 3;
+  }
+  if (matches > 1) score += matches * 2;
+  if (matches > 0 && STRUCTURAL_LINE.test(line)) score += 4;
+  return score;
+}
+function mergeRanges(ranges) {
+  const sorted = [...ranges].sort((a, b) => a.startLine - b.startLine);
+  const merged = [];
+  for (const range of sorted) {
+    const previous = merged[merged.length - 1];
+    if (!previous || range.startLine > previous.endLine + 1) {
+      merged.push({ ...range });
+      continue;
+    }
+    previous.endLine = Math.max(previous.endLine, range.endLine);
+    previous.score = Math.max(previous.score, range.score);
+  }
+  return merged;
+}
+function structuralSkeleton(filePath, lines, content, maxChars) {
+  const folded = foldCode(content, { filePath, maxLines: 100 });
+  const structural = folded.wasFolded ? folded.folded : lines.filter((line) => STRUCTURAL_LINE.test(line)).slice(0, 100).join("\n");
+  const body = structural.trim() || lines.slice(0, 40).join("\n");
+  return body.slice(0, Math.max(600, maxChars));
+}
+function renderRanges(lines, ranges) {
+  return ranges.map((range) => {
+    const body = lines.slice(range.startLine, range.endLine + 1).map((line, offset) => `${String(range.startLine + offset + 1).padStart(5, " ")} | ${line}`).join("\n");
+    return `--- L${range.startLine + 1}-L${range.endLine + 1} (relevance ${range.score}) ---
+${body}`;
+  }).join("\n\n");
+}
+function renderFocusedContent(filePath, focus, lines, summary, ranges, maxChars) {
+  const shownLines = ranges.reduce((sum, range) => sum + range.endLine - range.startLine + 1, 0);
+  const header = [
+    `[focused-read] ${filePath}`,
+    `focus: ${normalizeFocus(focus)}`,
+    `source: ${lines.length} lines, ${lines.join("\n").length} chars; showing ${shownLines} relevant lines`,
+    summary ? `structural summary: ${summary}` : "",
+    "Only the ranges below are selected evidence; this is not the complete file."
+  ].filter(Boolean).join("\n");
+  const body = ranges.length > 0 ? renderRanges(lines, ranges) : `No direct focus match. Structural outline only:
+${structuralSkeleton(filePath, lines, lines.join("\n"), Math.max(800, maxChars - header.length))}`;
+  const omitted = Math.max(0, lines.length - shownLines);
+  const footer = `
+
+[focused-read] omitted ${omitted} source lines; use read_file(offset, limit) for an exact range.`;
+  const output = `${header}
+
+${body}${footer}`;
+  if (output.length <= maxChars) return output;
+  return `${output.slice(0, Math.max(0, maxChars - 80))}
+...[focused-read output capped at ${maxChars} chars]`;
+}
+function buildFocusedReadView(options) {
+  const focus = normalizeFocus(options.focus);
+  const lines = options.content.split("\n");
+  const tokens = tokenizeFocus(focus);
+  const contextLines = Math.max(0, Math.min(8, Math.floor(options.contextLines ?? DEFAULT_CONTEXT_LINES)));
+  const maxMatches = Math.max(1, Math.min(20, Math.floor(options.maxMatches ?? DEFAULT_MAX_MATCHES)));
+  const maxChars = Math.max(800, Math.floor(options.maxChars));
+  const summary = summarizeFileContent(options.content, options.filePath).summary.trim();
+  const ranked = tokens.length === 0 ? [] : lines.map((line, index) => ({ line, index, score: scoreLine(line, focus, tokens) })).filter((entry) => entry.score > 0).sort((a, b) => b.score - a.score || a.index - b.index);
+  const selected = ranked.slice(0, maxMatches).map((entry) => ({
+    startLine: Math.max(0, entry.index - contextLines),
+    endLine: Math.min(lines.length - 1, entry.index + contextLines),
+    score: entry.score
+  }));
+  let ranges = mergeRanges(selected);
+  while (ranges.length > 1 && renderRanges(lines, ranges).length > Math.max(400, maxChars - 600)) {
+    const lowest = ranges.reduce((index, range, current) => range.score < ranges[index].score ? current : index, 0);
+    ranges = ranges.filter((_, index) => index !== lowest);
+  }
+  const content = renderFocusedContent(options.filePath, focus, lines, summary, ranges, maxChars);
+  const matchedLines = ranges.reduce((sum, range) => sum + range.endLine - range.startLine + 1, 0);
+  return {
+    content,
+    ranges,
+    matchedLines,
+    omittedLines: Math.max(0, lines.length - matchedLines),
+    matched: ranges.length > 0
+  };
+}
+
+// src/tools/read-file.ts
+var gitignoreCache = /* @__PURE__ */ new Map();
+var GITIGNORE_CACHE_TTL = 6e4;
+var GITIGNORE_CACHE_MAX = 50;
+function trimGitignoreCache() {
+  if (gitignoreCache.size <= GITIGNORE_CACHE_MAX) return;
+  const now = Date.now();
+  for (const [key, val] of gitignoreCache) {
+    if (now - val.ts > GITIGNORE_CACHE_TTL) gitignoreCache.delete(key);
+  }
+  while (gitignoreCache.size > GITIGNORE_CACHE_MAX) {
+    const [key] = gitignoreCache.keys();
+    gitignoreCache.delete(key);
+  }
+}
+var readHistory = /* @__PURE__ */ new Map();
+var READ_HISTORY_MAX = 500;
+var neighborHintProvider;
+function setNeighborHintProvider(provider) {
+  neighborHintProvider = provider;
+}
+var fileReadHistory = /* @__PURE__ */ new Map();
+var FILE_READ_HISTORY_MAX = 200;
+var lastKnownFileState = /* @__PURE__ */ new Map();
+var LAST_KNOWN_MAX = 500;
+var editFailCount = /* @__PURE__ */ new Map();
+function incrementEditFailCount(canonicalPath) {
+  const n = (editFailCount.get(canonicalPath) ?? 0) + 1;
+  editFailCount.set(canonicalPath, n);
+  return n;
+}
+function resetEditFailCount(canonicalPath) {
+  editFailCount.delete(canonicalPath);
+}
+function trimLastKnown() {
+  if (lastKnownFileState.size <= LAST_KNOWN_MAX) return;
+  const drop = Math.ceil(lastKnownFileState.size * 0.2);
+  let i = 0;
+  for (const key of lastKnownFileState.keys()) {
+    lastKnownFileState.delete(key);
+    if (++i >= drop) break;
+  }
+}
+function isReadRefEnabled() {
+  return process.env["RIVET_READ_REF"] !== "0";
+}
+var READ_REF_THRESHOLD = 2048;
+var readRefSavedBytes = 0;
+var readRefCount = 0;
+var sessionFileEdits = /* @__PURE__ */ new Set();
+function markSessionFileEdit(canonicalPath, sessionId) {
+  sessionFileEdits.add(fileHistoryKey(sessionId, canonicalPath));
+}
+function wasFileEditedBySession(canonicalPath, sessionId) {
+  return sessionFileEdits.has(fileHistoryKey(sessionId, canonicalPath));
+}
+function readHistoryKey(cwd, canonicalPath, offset, limit, sessionId) {
+  return `${sessionId ?? ""}::${canonicalPathKey(cwd)}::${canonicalPathKey(canonicalPath)}::${offset}::${limit ?? "all"}`;
+}
+function fileHistoryKey(sessionId, canonicalPath) {
+  return `${sessionId ?? ""}::${canonicalPathKey(canonicalPath)}`;
+}
+function trimReadHistory() {
+  if (readHistory.size <= READ_HISTORY_MAX) return;
+  const sorted = [...readHistory.entries()].sort((a, b) => a[1].recordedAt - b[1].recordedAt);
+  const drop = Math.ceil(readHistory.size * 0.2);
+  for (let i = 0; i < drop; i++) readHistory.delete(sorted[i][0]);
+}
+function trimFileReadHistory() {
+  if (fileReadHistory.size <= FILE_READ_HISTORY_MAX) return;
+  const sorted = [...fileReadHistory.entries()].sort((a, b) => a[1].recordedAt - b[1].recordedAt);
+  const drop = Math.ceil(fileReadHistory.size * 0.2);
+  for (let i = 0; i < drop; i++) fileReadHistory.delete(sorted[i][0]);
+}
+function isUnchangedRepeatRead(canonical, currentMtimeMs, currentSizeBytes, dedupKey, offset, limit, sessionId) {
+  const priorSame = readHistory.get(dedupKey);
+  if (priorSame && priorSame.mtimeMs === currentMtimeMs && priorSame.sizeBytes === currentSizeBytes) return true;
+  const fullPrior = fileReadHistory.get(fileHistoryKey(sessionId, canonical));
+  if (fullPrior && fullPrior.mtimeMs === currentMtimeMs && fullPrior.sizeBytes === currentSizeBytes && offset === 1 && !limit) return true;
+  return false;
+}
+function maybeAppendNeighborHint(cwd, canonicalPath, sessionId, content) {
+  if (process.env["RIVET_NEIGHBOR_HINT"] !== "1") return content;
+  if (!neighborHintProvider) return content;
+  let neighbors;
+  try {
+    neighbors = neighborHintProvider(cwd, canonicalPath);
+  } catch {
+    return content;
+  }
+  const unread = neighbors.filter((abs) => !fileReadHistory.has(fileHistoryKey(sessionId, abs)));
+  if (unread.length === 0) return content;
+  const label = "\u7ED3\u6784\u90BB\u5C45: " + unread.slice(0, 3).map((abs) => relative(cwd, abs)).join(", ");
+  return content + "\n\n" + label.slice(0, 100);
+}
+function getFileReadMtime(canonicalPath, sessionId) {
+  const entry = lastKnownFileState.get(fileHistoryKey(sessionId, canonicalPath));
+  return entry ? entry.mtimeMs : null;
+}
+function noteFileObserved(canonicalPath, mtimeMs, sizeBytes, sessionId) {
+  lastKnownFileState.set(fileHistoryKey(sessionId, canonicalPath), { mtimeMs, sizeBytes });
+  trimLastKnown();
+}
+function invalidateReadHistory(canonicalPath) {
+  const keyPath = canonicalPathKey(canonicalPath);
+  const suffix = `::${keyPath}`;
+  for (const key of fileReadHistory.keys()) {
+    if (key.endsWith(suffix)) fileReadHistory.delete(key);
+  }
+  const segment = `::${keyPath}::`;
+  for (const key of readHistory.keys()) {
+    if (key.includes(segment)) readHistory.delete(key);
+  }
+}
+function invalidateSessionReadDedup(sessionId) {
+  const prefix = `${sessionId ?? ""}::`;
+  for (const key of readHistory.keys()) {
+    if (key.startsWith(prefix)) readHistory.delete(key);
+  }
+  for (const key of fileReadHistory.keys()) {
+    if (key.startsWith(prefix)) fileReadHistory.delete(key);
+  }
+}
+async function recordSuccessfulEdit(canonicalPath, sessionId) {
+  invalidateReadHistory(canonicalPath);
+  markSessionFileEdit(canonicalPath, sessionId);
+  try {
+    const s = await stat2(canonicalPath);
+    noteFileObserved(canonicalPath, s.mtimeMs, s.size, sessionId);
+  } catch {
+  }
+}
+function registerGrepFileAccess(canonicalPath, mtimeMs, sessionId) {
+  const key = fileHistoryKey(sessionId, canonicalPath);
+  if (lastKnownFileState.has(key)) return;
+  lastKnownFileState.set(key, { mtimeMs, sizeBytes: -1 });
+  trimLastKnown();
+}
+function getReadRefStats() {
+  return { savedBytes: readRefSavedBytes, count: readRefCount };
+}
+async function sliceFromArtifact(store, artifactId, offset, limit) {
+  const recovered = await store.readRaw(artifactId);
+  if (!recovered) return null;
+  const lines = recovered.split("\n");
+  const start = Math.max(0, offset - 1);
+  const end = limit ? start + limit : lines.length;
+  return lines.slice(start, end).join("\n");
+}
+function getGitignoreFilter(cwd) {
+  const cached = gitignoreCache.get(cwd);
+  if (cached && Date.now() - cached.ts < GITIGNORE_CACHE_TTL) {
+    return cached.filter;
+  }
+  const filterPromise = GitignoreFilter.create(cwd);
+  gitignoreCache.set(cwd, { filter: filterPromise, ts: Date.now() });
+  trimGitignoreCache();
+  return filterPromise;
+}
+var MAX_TOOL_INPUT_BYTES = 100 * 1024;
+var MAX_FOCUS_SCAN_BYTES = 2 * 1024 * 1024;
+var LOG_PREVIEW_LINES = 80;
+function applyFoldThenPartial(content, filePath, cap) {
+  const fold = foldCode(content, { filePath, maxLines: 200 });
+  if (fold.wasFolded && fold.foldedLines < fold.originalLines * 0.7) {
+    return buildPartialView(fold.folded, filePath, cap.maxChars, { lines: fold.originalLines, chars: content.length });
+  }
+  return buildPartialView(content, filePath, cap.maxChars);
+}
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".svgz",
+  ".pdf",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".wasm",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".bz2",
+  ".xz",
+  ".7z",
+  ".rar",
+  ".mp3",
+  ".mp4",
+  ".avi",
+  ".mov",
+  ".wav",
+  ".ogg",
+  ".flac",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".otf",
+  ".eot",
+  ".pyc",
+  ".class",
+  ".o",
+  ".obj",
+  ".db",
+  ".sqlite",
+  ".sqlite3"
+]);
+var IMAGE_EXTENSIONS = /* @__PURE__ */ new Map([
+  [".png", "image/png"],
+  [".jpg", "image/jpeg"],
+  [".jpeg", "image/jpeg"],
+  [".gif", "image/gif"],
+  [".webp", "image/webp"],
+  [".bmp", "image/bmp"]
+]);
+var MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+async function readImageFile(filePath, ext, sizeBytes) {
+  if (sizeBytes > MAX_IMAGE_BYTES) {
+    return {
+      content: `Error: image too large (${(sizeBytes / 1048576).toFixed(1)}MB\uFF0C\u4E0A\u9650 10MB)\u3002\u8BF7\u5148\u7F29\u653E/\u88C1\u526A\uFF08\u5982 sips -Z 1600 ${filePath} \u6216 magick ${filePath} -resize 1600x\uFF09\uFF0C\u6216\u7528 tesseract OCR \u63D0\u53D6\u6587\u5B57\u3002`,
+      isError: true
+    };
+  }
+  const buf = await readFile3(filePath);
+  const mime = IMAGE_EXTENSIONS.get(ext);
+  const dataUrl = `data:${mime};base64,${buf.toString("base64")}`;
+  return {
+    content: `read_file: ${filePath} \u662F\u56FE\u7247\uFF08${mime}\uFF0C${sizeBytes} bytes\uFF09\uFF0C\u5DF2\u4F5C\u4E3A\u89C6\u89C9\u9644\u4EF6\u9644\u4E0A\u2014\u2014\u8BF7\u76F4\u63A5\u67E5\u770B\u56FE\u7247\u5185\u5BB9\u4F5C\u7B54\uFF08\u89C6\u89C9\u6A21\u578B\u53EF\u89C1\uFF1B\u975E\u89C6\u89C9\u6A21\u578B\u8BE5\u9644\u4EF6\u4F1A\u88AB\u81EA\u52A8\u4E22\u5F03\uFF09\u3002`,
+    images: [dataUrl]
+  };
+}
+function buildLogPreviewContent(filePath, content) {
+  const lines = content.split("\n");
+  const headCount = Math.min(LOG_PREVIEW_LINES, lines.length);
+  const tailCount = Math.min(LOG_PREVIEW_LINES, Math.max(0, lines.length - headCount));
+  const head = lines.slice(0, headCount);
+  const tail = tailCount > 0 ? lines.slice(-tailCount) : [];
+  const omitted = Math.max(0, lines.length - head.length - tail.length);
+  const tailStart = tail.length > 0 ? lines.length - tail.length + 1 : 1;
+  const parts = [
+    `read_file: ${filePath} looks like a log/JSONL output file (${content.length} chars, ${lines.length} lines).`,
+    `Full first reads of log files waste context; returning a bounded preview only.`,
+    `Preview boundaries: head offset=1 limit=${head.length}${tail.length > 0 ? `; tail offset=${tailStart} limit=${tail.length}` : ""}.`,
+    `Next step: use read_file(file_path=..., offset=<known line>, limit<=200) for a specific range; use grep on this file for keywords/timestamps before reading middle ranges. Do not scan the whole project for this log.`,
+    "",
+    `\u2500\u2500 head (L1-L${head.length}) \u2500\u2500`,
+    ...head
+  ];
+  if (omitted > 0) {
+    parts.push("", `... ${omitted} lines omitted ...`, "", `\u2500\u2500 tail (L${tailStart}-L${lines.length}) \u2500\u2500`, ...tail);
+  }
+  return parts.join("\n");
+}
+function buildFileUiOutput(raw, maxLines) {
+  const lines = raw.split("\n");
+  const totalLines = lines.length;
+  if (totalLines <= maxLines) {
+    return lines.map((l, i) => `${String(i + 1).padStart(4, " ")}\u2502 ${l}`).join("\n");
+  }
+  const headLines = Math.ceil(maxLines * 0.6);
+  const tailLines = Math.floor(maxLines * 0.4);
+  const omitted = totalLines - headLines - tailLines;
+  const head = lines.slice(0, headLines).map((l, i) => `${String(i + 1).padStart(4, " ")}\u2502 ${l}`);
+  const tail = lines.slice(-tailLines).map((l, i) => `${String(totalLines - tailLines + i + 1).padStart(4, " ")}\u2502 ${l}`);
+  return [...head, `  ... ${omitted} lines omitted ...`, ...tail].join("\n");
+}
+function isRivetStatePath(cwd, filePath) {
+  const norm = (p) => p.replace(/\\/g, "/").replace(/\/+$/, "");
+  const base = `${norm(cwd)}/`;
+  return norm(filePath).startsWith(`${base}.rivet/`) || norm(filePath).startsWith(`${base}docs/superpowers/`);
+}
+async function readFilePayload(cwd, options) {
+  const filePath = validatePath(cwd, options.filePath);
+  let fileStat;
+  try {
+    fileStat = await stat2(filePath);
+  } catch {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  const filter = await getGitignoreFilter(cwd);
+  if (filter.isIgnored(cwd, filePath) && !isRivetStatePath(cwd, filePath)) {
+    throw new Error(`File is gitignored (node_modules, build artifacts, etc.): ${filePath}`);
+  }
+  const ext = extname3(filePath).toLowerCase();
+  if (OFFICE_EXTENSIONS.has(ext)) {
+    const result = await readOfficeFile(filePath);
+    const officeHint = `
+
+\u2500\u2500 Office document (${ext}, converted via ${result.engine}) \u2500\u2500`;
+    const cap2 = options.modelCap ?? DEFAULT_MODEL_READ_CAP;
+    return {
+      canonicalPath: filePath,
+      rawContent: result.text,
+      modelContent: truncateContent(result.text, cap2.maxChars, cap2.headChars, cap2.tailChars) + officeHint,
+      uiContent: result.text.slice(0, 200)
+    };
+  }
+  if (BINARY_EXTENSIONS.has(ext)) {
+    throw new Error(`File is binary (${ext} format). read_file only reads text files. Use file_info to inspect metadata.`);
+  }
+  const fileSize = fileStat.size;
+  const hasExplicitRange = options.offset !== void 0 || options.limit !== void 0;
+  const focus = typeof options.focus === "string" ? options.focus.trim() : "";
+  const hasFocus = focus.length > 0 && !hasExplicitRange;
+  const policy = decideReadPolicy({ filePath, sizeBytes: fileSize, hasExplicitRange });
+  if (hasFocus && fileSize > MAX_FOCUS_SCAN_BYTES) {
+    throw new Error(
+      `Focused read refuses files over ${(MAX_FOCUS_SCAN_BYTES / 1024 / 1024).toFixed(0)}MB. Use grep or an explicit offset/limit range first.`
+    );
+  }
+  if (fileSize > MAX_TOOL_INPUT_BYTES && !hasExplicitRange && !hasFocus) {
+    if (policy.action === "partial") {
+      const content2 = options.prefetchedContent ?? await readFile3(filePath, "utf-8");
+      const cap2 = options.modelCap ?? DEFAULT_MODEL_READ_CAP;
+      const partialContent = applyFoldThenPartial(content2, filePath, cap2);
+      return {
+        canonicalPath: filePath,
+        rawContent: content2,
+        modelContent: partialContent,
+        uiContent: buildFileUiOutput(content2, 80)
+      };
+    }
+    const sizeKB = (fileSize / 1024).toFixed(0);
+    const estLines = Math.ceil(fileSize / 80);
+    throw new Error(
+      `File too large (${sizeKB}KB, ~${estLines} lines). Use offset and limit to read specific ranges.`
+    );
+  }
+  let content = options.prefetchedContent ?? await readFile3(filePath, "utf-8");
+  const offset = options.offset ?? 1;
+  const limit = options.limit;
+  const cap = options.modelCap ?? DEFAULT_MODEL_READ_CAP;
+  if (policy.action === "reject-with-range" && !hasExplicitRange) {
+    throw new Error(`${policy.reason}. Use offset and limit to read a specific range.`);
+  }
+  if (hasFocus) {
+    const focused = buildFocusedReadView({
+      filePath,
+      content,
+      focus,
+      maxChars: cap.maxChars,
+      maxMatches: options.focusMaxMatches
+    });
+    return {
+      canonicalPath: filePath,
+      rawContent: content,
+      modelContent: focused.content,
+      uiContent: buildFileUiOutput(content, 80)
+    };
+  }
+  if (policy.action === "preview" && !hasExplicitRange) {
+    const preview = buildLogPreviewContent(filePath, content);
+    return {
+      canonicalPath: filePath,
+      rawContent: content,
+      modelContent: truncateContent(preview, cap.maxChars, cap.headChars, cap.tailChars),
+      uiContent: buildFileUiOutput(content, 80)
+    };
+  }
+  if (policy.action === "partial" && !hasExplicitRange) {
+    const partialContent = applyFoldThenPartial(content, filePath, cap);
+    return {
+      canonicalPath: filePath,
+      rawContent: content,
+      modelContent: partialContent,
+      uiContent: buildFileUiOutput(content, 80)
+    };
+  }
+  if (offset > 1 || limit) {
+    const lines = content.split("\n");
+    const startIdx = offset - 1;
+    if (startIdx >= lines.length) {
+      return {
+        canonicalPath: filePath,
+        rawContent: `Error: offset ${offset} exceeds file length (${lines.length} lines)`,
+        modelContent: `Error: offset ${offset} exceeds file length (${lines.length} lines). File has ${lines.length} lines. Re-read without offset or use a smaller offset value.`,
+        uiContent: ""
+      };
+    }
+    if (offset < 1) {
+      return {
+        canonicalPath: filePath,
+        rawContent: `Error: offset must be >= 1 (got ${offset})`,
+        modelContent: `Error: offset must be >= 1 (got ${offset}). Lines are 1-based.`,
+        uiContent: ""
+      };
+    }
+    const endIdx = limit ? startIdx + limit : void 0;
+    content = lines.slice(startIdx, endIdx).join("\n");
+  }
+  let modelContent;
+  if (options.preferFoldOnOverflow && !hasExplicitRange && content.length > cap.maxChars) {
+    const folded = applyFoldThenPartial(content, filePath, cap);
+    modelContent = folded.length <= Math.floor(cap.maxChars * 1.2) ? folded : truncateContent(content, cap.maxChars, cap.headChars, cap.tailChars);
+  } else {
+    modelContent = truncateContent(content, cap.maxChars, cap.headChars, cap.tailChars);
+  }
+  const hint = policy.action === "full-with-hint" ? `
+
+\u2500\u2500 Note: this file is ${content.split("\n").length} lines. For editing, consider: grep to locate target \u2192 hash_edit with anchors. \u2500\u2500` : "";
+  return {
+    canonicalPath: filePath,
+    rawContent: content,
+    modelContent: modelContent + hint,
+    uiContent: buildFileUiOutput(content, 50)
+  };
+}
+var READ_FILE_TOOL = {
+  definition: {
+    name: "read_file",
+    description: `\u4ECE\u6587\u4EF6\u7CFB\u7EDF\u8BFB\u53D6\u6587\u4EF6\uFF0C\u652F\u6301\u53EF\u9009\u7684\u884C\u8303\u56F4\u3002
+
+- \u7EA6 50,000 \u884C\u4EE5\u5185\u7684\u6587\u4EF6\u5B8C\u6574\u8FD4\u56DE\u2014\u2014\u4E0D\u8981\u81EA\u5DF1\u5207\u6210\u5C0F\u7247\u5206\u591A\u6B21\u8BFB
+- focus="..." \u7528\u4E8E\u6309\u5F53\u524D\u4EFB\u52A1\u63D0\u53D6\u5173\u952E\u4EE3\u7801\uFF1A\u8FD4\u56DE\u7ED3\u6784\u6458\u8981\u548C\u9AD8\u76F8\u5173\u884C\u6BB5\uFF0C\u907F\u514D\u628A\u65E0\u5173\u6B63\u6587\u585E\u8FDB\u4E0A\u4E0B\u6587
+- offset/limit \u53EA\u7528\u4E8E\u5DF2\u77E5\u5B50\u533A\u95F4\uFF08\u5982\u7B2C 800-900 \u884C\uFF09\uFF0C\u4E0D\u8981\u62FF\u5B83\u5F53\u957F\u6587\u4EF6\u7684\u7ED5\u884C\u624B\u6BB5
+- \u8D85\u8FC7\u7EA6 2000 \u884C\u7684\u6587\u4EF6\u8FD4\u56DE PARTIAL \u89C6\u56FE\u5E76\u9644\u5BFC\u822A\u63D0\u793A
+- \u5DF2\u8BFB\u6587\u4EF6\u7684\u5185\u5BB9\u4F1A\u9A7B\u7559\u4E0A\u4E0B\u6587\u3001\u53EF\u76F4\u63A5\u5F15\u7528\uFF1B\u4EC5\u5F53\u6587\u4EF6\u53EF\u80FD\u5DF2\u53D8\u5316\uFF08\u5916\u90E8\u4FEE\u6539\u3001\u5E76\u53D1\u5199\u5165\u3001\u6216\u4F60\u521A\u7F16\u8F91\u8FC7\uFF09\u6216\u6240\u9700\u5185\u5BB9\u4E0D\u5728\u5DF2\u8BFB\u8303\u56F4\u5185\u65F6\uFF0C\u91CD\u8BFB\u662F\u6070\u5F53\u7684
+- \u5C0F\u6587\u4EF6\uFF08\u5982\u6570\u767E\u884C\u5185\u7684\u65E5\u5FD7\u4E0E\u914D\u7F6E\uFF09\u4F18\u5148\u6574\u4F53\u8BFB\u53D6\u2014\u2014\u6574\u8BFB\u8986\u76D6\u5168\u90E8\u76F8\u5173\u7EC6\u8282\uFF0C\u5B9A\u5411\u641C\u7D22\u53EF\u80FD\u9057\u6F0F\u5173\u952E\u4E0A\u4E0B\u6587
+- file_paths \u4E00\u6B21\u8C03\u7528\u6700\u591A\u8BFB 5 \u4E2A\u6587\u4EF6
+- \u56FE\u7247\u6587\u4EF6\uFF08png / jpg / jpeg / gif / webp / bmp\uFF09\u4F1A\u4F5C\u4E3A\u89C6\u89C9\u9644\u4EF6\u8FD4\u56DE\u2014\u2014\u89C6\u89C9\u6A21\u578B\u53EF\u76F4\u63A5\u67E5\u770B\u56FE\u7247\u5185\u5BB9\u4F5C\u7B54\uFF08\u5982\u626B\u63CF\u4EF6\u3001\u622A\u56FE\u3001\u56FE\u8868\uFF09\uFF0C\u65E0\u9700\u5148 OCR\uFF1B\u975E\u89C6\u89C9\u6A21\u578B\u8BE5\u9644\u4EF6\u81EA\u52A8\u4E22\u5F03`,
+    input_schema: {
+      type: "object",
+      properties: {
+        file_path: { type: "string", description: "\u6587\u4EF6\u7684\u7EDD\u5BF9\u8DEF\u5F84" },
+        file_paths: {
+          type: "array",
+          items: { type: "string" },
+          description: "\u4E00\u6B21\u8C03\u7528\u8BFB\u53D6\u591A\u4E2A\u6587\u4EF6\u3002\u7528\u4E8E\u66FF\u4EE3\u91CD\u590D\u7684 read_file \u8C03\u7528\u3002\u6BCF\u4E2A\u6587\u4EF6\u5355\u72EC\u6210\u8282\u3002\u6700\u591A 5 \u4E2A\u6587\u4EF6\u3002"
+        },
+        offset: { type: "integer", description: "\u8D77\u59CB\u8BFB\u53D6\u884C\u53F7\uFF08\u4ECE 1 \u5F00\u59CB\uFF09" },
+        limit: { type: "integer", description: "\u6700\u591A\u8BFB\u53D6\u7684\u884C\u6570" },
+        focus: { type: "string", description: "\u4EFB\u52A1\u5173\u952E\u8BCD\u6216\u95EE\u9898\uFF1B\u53EA\u8FD4\u56DE\u7ED3\u6784\u6458\u8981\u548C\u76F8\u5173\u7247\u6BB5" },
+        focus_max_matches: { type: "integer", description: "focus \u6700\u591A\u8FD4\u56DE\u7684\u7247\u6BB5\u6570\u91CF\uFF08\u9ED8\u8BA4 8\uFF09" }
+      },
+      required: ["file_path"]
+    }
+  },
+  async execute(params) {
+    const filePaths = params.input.file_paths;
+    if (filePaths && filePaths.length > 0) {
+      const focus2 = typeof params.input.focus === "string" ? params.input.focus : void 0;
+      const focusMaxMatches = typeof params.input.focus_max_matches === "number" ? params.input.focus_max_matches : void 0;
+      return await handleMultiRead(params, filePaths.slice(0, 5), focus2, focusMaxMatches);
+    }
+    let payload;
+    const computedCap = params.readCapOverride ?? computeModelReadCap({
+      contextWindow: params.contextWindow,
+      providerProfile: params.providerProfile
+    });
+    const filePath = params.input.file_path;
+    const offset = params.input.offset ?? 1;
+    const limit = params.input.limit;
+    const focus = typeof params.input.focus === "string" ? params.input.focus.trim() : "";
+    const focusedRead = focus.length > 0 && params.input.offset === void 0 && params.input.limit === void 0;
+    let dedupKey = null;
+    let currentMtimeMs = null;
+    let currentSizeBytes = null;
+    let canonical = null;
+    try {
+      canonical = validatePath(params.cwd, filePath);
+      if (existsSync2(canonical)) {
+        const currentStat = await stat2(canonical);
+        currentMtimeMs = currentStat.mtimeMs;
+        currentSizeBytes = currentStat.size;
+        if (!focusedRead) {
+          dedupKey = readHistoryKey(params.cwd, canonical, offset, limit, params.sessionId);
+        }
+        const prior = focusedRead || !dedupKey ? void 0 : readHistory.get(dedupKey);
+        if (!focusedRead && prior && prior.mtimeMs === currentMtimeMs && prior.sizeBytes === currentSizeBytes && prior.artifactId) {
+          if (params.artifactStore) {
+            const slice = await sliceFromArtifact(params.artifactStore, prior.artifactId, offset, limit);
+            if (slice !== null) {
+              debugLog(`[read-dedup] re-serve from artifact file=${canonical} offset=${offset} limit=${limit ?? "all"}`);
+              noteFileObserved(canonical, currentMtimeMs, currentSizeBytes, params.sessionId);
+              return { content: slice };
+            }
+          }
+          debugLog(`[read-dedup] artifact unreadable, falling through to normal read file=${canonical}`);
+        }
+        const fullEntry = focusedRead ? void 0 : fileReadHistory.get(fileHistoryKey(params.sessionId, canonical));
+        if (!focusedRead && fullEntry && fullEntry.mtimeMs === currentMtimeMs && fullEntry.sizeBytes === currentSizeBytes && fullEntry.artifactId && (offset !== 1 || limit !== void 0)) {
+          if (params.artifactStore) {
+            const slice = await sliceFromArtifact(params.artifactStore, fullEntry.artifactId, offset, limit);
+            if (slice !== null) {
+              debugLog(`[read-dedup-file] re-serve slice from artifact file=${canonical} offset=${offset} limit=${limit ?? "all"}`);
+              noteFileObserved(canonical, currentMtimeMs, currentSizeBytes, params.sessionId);
+              return { content: slice };
+            }
+          }
+          debugLog(`[read-dedup-file] artifact unreadable, falling through file=${canonical}`);
+        }
+      }
+    } catch {
+    }
+    const imageExt = canonical ? extname3(canonical).toLowerCase() : "";
+    if (canonical && IMAGE_EXTENSIONS.has(imageExt)) {
+      return await readImageFile(canonical, imageExt, currentSizeBytes ?? 0);
+    }
+    const unchangedRepeat = !focusedRead && canonical && currentMtimeMs !== null && currentSizeBytes !== null && dedupKey ? isUnchangedRepeatRead(canonical, currentMtimeMs, currentSizeBytes, dedupKey, offset, limit, params.sessionId) : false;
+    let repeatWarning = null;
+    if (unchangedRepeat) {
+      const priorSame = readHistory.get(dedupKey);
+      const fullPrior = fileReadHistory.get(fileHistoryKey(params.sessionId, canonical));
+      if (priorSame && priorSame.mtimeMs === currentMtimeMs) {
+        repeatWarning = `
+\u2500\u2500 read-dedup \u2500\u2500
+\u26A0 \u6B64\u6587\u4EF6\u672C\u8F6E\u5DF2\u8BFB\u53D6\u8FC7\u4E14\u672A\u53D8\u66F4 (${priorSame.modelBytes} bytes, ${priorSame.truncated ? "\u5DF2\u622A\u65AD" : "\u5B8C\u6574"})\u3002\u5185\u5BB9\u9644\u5728\u4E0B\u65B9\uFF1B\u540E\u7EED\u8BF7\u52FF\u91CD\u590D\u8BFB\u53D6\u672A\u53D8\u66F4\u7684\u6587\u4EF6\u3002
+\u2500\u2500 read-dedup \u2500\u2500`;
+      } else if (fullPrior && fullPrior.mtimeMs === currentMtimeMs && offset === 1 && !limit) {
+        repeatWarning = `
+\u2500\u2500 read-dedup \u2500\u2500
+\u26A0 \u6B64\u6587\u4EF6\u672C\u8F6E\u5DF2\u5B8C\u6574\u8BFB\u53D6\u8FC7\u4E14\u672A\u53D8\u66F4 (${fullPrior.totalLines} lines, ${fullPrior.modelBytes} bytes)\u3002\u5185\u5BB9\u9644\u5728\u4E0B\u65B9\uFF1B\u540E\u7EED\u8BF7\u52FF\u91CD\u590D\u8BFB\u53D6\u672A\u53D8\u66F4\u7684\u6587\u4EF6\u3002
+\u2500\u2500 read-dedup \u2500\u2500`;
+      }
+    }
+    if (unchangedRepeat && isReadRefEnabled()) {
+      const priorSame = readHistory.get(dedupKey);
+      const fullPrior = fileReadHistory.get(fileHistoryKey(params.sessionId, canonical));
+      const matchedSame = priorSame?.mtimeMs === currentMtimeMs ? priorSame : void 0;
+      const matchedFull = fullPrior?.mtimeMs === currentMtimeMs ? fullPrior : void 0;
+      const entryBytes = matchedSame ? matchedSame.modelBytes : matchedFull?.modelBytes ?? 0;
+      const totalLines = matchedFull ? matchedFull.totalLines : 0;
+      const refAlreadyServed = Math.max(matchedSame?.refServed ?? 0, matchedFull?.refServed ?? 0) >= 1;
+      if (entryBytes > READ_REF_THRESHOLD && refAlreadyServed) {
+        debugLog(`[read-ref-degrade] file=${canonical} ref did not help, re-serving full content`);
+        repeatWarning = null;
+      } else if (entryBytes > READ_REF_THRESHOLD) {
+        const relPath = relative(params.cwd, canonical);
+        const sizeHint = totalLines > 0 ? `${totalLines} \u884C\uFF0C${entryBytes} bytes` : `${entryBytes} bytes`;
+        const ref = [
+          `[read-ref] ${relPath} \u672C\u4F1A\u8BDD\u5DF2\u8BFB\u4E14\u672A\u53D8\uFF08${sizeHint}\uFF09\u3002`,
+          `\u9700\u8981\u5177\u4F53\u533A\u6BB5\uFF1Aread_section(file_path="${relPath}", section="L{N}-L{M}")\u2014\u2014\u76F4\u63A5\u8BFB\u78C1\u76D8\uFF0C\u4E0D\u4F9D\u8D56\u4E0A\u6587\u3002`,
+          `\u82E5\u4E0A\u6587\u7684 tool_result \u4ECD\u5B8C\u6574\u53EF\u89C1\uFF0C\u56DE\u770B\u5373\u53EF\uFF1B\u82E5\u5DF2\u88AB\u538B\u7F29\u4E3A\u5360\u4F4D\u7B26\uFF0C\u7528 read_section\u3002`
+        ].join("\n");
+        if (matchedSame) matchedSame.refServed = (matchedSame.refServed ?? 0) + 1;
+        if (matchedFull) matchedFull.refServed = (matchedFull.refServed ?? 0) + 1;
+        if (params.readRefStats) {
+          params.readRefStats.savedBytes += entryBytes;
+          params.readRefStats.count++;
+        } else {
+          readRefSavedBytes += entryBytes;
+          readRefCount++;
+        }
+        const totalSaved = params.readRefStats?.savedBytes ?? readRefSavedBytes;
+        const totalCount = params.readRefStats?.count ?? readRefCount;
+        debugLog(`[read-ref] file=${canonical} saved=${entryBytes} total-saved=${totalSaved} count=${totalCount}`);
+        noteFileObserved(canonical, currentMtimeMs, currentSizeBytes, params.sessionId);
+        return { content: ref };
+      }
+    }
+    try {
+      let prefetchedContent;
+      if (params.prewarmCache && canonical && canUsePrewarmForRead(params.input)) {
+        const cached = consumePrewarm(params.prewarmCache, canonical);
+        if (cached) {
+          prefetchedContent = cached.content;
+          debugLog(`[prewarm-hit] file=${canonical} cached=${cached.content.length} bytes`);
+        }
+      }
+      payload = await readFilePayload(params.cwd, {
+        filePath,
+        ...params.input.offset !== void 0 ? { offset } : {},
+        ...params.input.limit !== void 0 ? { limit } : {},
+        ...focusedRead ? { focus, focusMaxMatches: typeof params.input.focus_max_matches === "number" ? params.input.focus_max_matches : void 0 } : {},
+        modelCap: computedCap,
+        prefetchedContent,
+        preferFoldOnOverflow: params.readCapOverride !== void 0
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { content: `Error: ${message}`, isError: true };
+    }
+    debugLog(`[read-cap] file=${payload.canonicalPath} raw=${payload.rawContent.length} model=${payload.modelContent.length} truncated=${payload.rawContent.length !== payload.modelContent.length} cap=${computedCap.maxChars} ctxWindow=${params.contextWindow ?? "undefined"}`);
+    const rawPath = await persistRawOutput(params.toolUseId, payload.rawContent);
+    if (canonical && currentMtimeMs !== null && currentSizeBytes !== null) {
+      noteFileObserved(canonical, currentMtimeMs, currentSizeBytes, params.sessionId);
+    }
+    const recordDedup = (artifactId) => {
+      if (!dedupKey || currentMtimeMs === null || currentSizeBytes === null) return;
+      readHistory.set(dedupKey, {
+        mtimeMs: currentMtimeMs,
+        sizeBytes: currentSizeBytes,
+        rawBytes: payload.rawContent.length,
+        modelBytes: payload.modelContent.length,
+        truncated: payload.rawContent.length !== payload.modelContent.length,
+        recordedAt: Date.now(),
+        artifactId
+      });
+      trimReadHistory();
+    };
+    const recordFileDedup = (artifactId) => {
+      if (!canonical || currentMtimeMs === null || currentSizeBytes === null) return;
+      if (offset !== 1 || limit !== void 0) return;
+      fileReadHistory.set(fileHistoryKey(params.sessionId, canonical), {
+        mtimeMs: currentMtimeMs,
+        sizeBytes: currentSizeBytes,
+        totalLines: payload.rawContent.split("\n").length,
+        rawBytes: payload.rawContent.length,
+        modelBytes: payload.modelContent.length,
+        artifactId,
+        recordedAt: Date.now()
+      });
+      trimFileReadHistory();
+    };
+    if (params.artifactStore) {
+      const artifactThreshold = getToolArtifactThreshold("read_file", params.contextWindow);
+      const wrapInArtifact = payload.rawContent.length >= artifactThreshold;
+      if (!wrapInArtifact) {
+        debugLog(`[artifact-skip] tool=read_file file=${payload.canonicalPath} raw=${payload.rawContent.length} threshold=${artifactThreshold}`);
+        recordDedup();
+        recordFileDedup();
+        return {
+          content: repeatWarning ? repeatWarning + "\n" + payload.modelContent : payload.modelContent,
+          uiContent: payload.uiContent,
+          rawPath
+        };
+      }
+      debugLog(`[artifact-wrap] tool=read_file file=${payload.canonicalPath} raw=${payload.rawContent.length} threshold=${artifactThreshold}`);
+      const { summary, sections } = summarizeFileContent(payload.rawContent, payload.canonicalPath);
+      const artifactId = await params.artifactStore.save({
+        tool: "read_file",
+        target: payload.canonicalPath,
+        rawContent: payload.rawContent,
+        summary,
+        sections
+      });
+      recordDedup(artifactId);
+      recordFileDedup(artifactId);
+      const summaryBlock = summary.trim() ? `
+
+\u2500\u2500 Structural outline \u2500\u2500
+${summary.trim()}` : "";
+      const hinted = maybeAppendNeighborHint(params.cwd, payload.canonicalPath, params.sessionId, payload.modelContent + summaryBlock);
+      const baseContent = hinted + `
+[artifact:${artifactId}]`;
+      return {
+        content: repeatWarning ? repeatWarning + "\n" + baseContent : baseContent,
+        rawContent: payload.modelContent,
+        uiContent: payload.uiContent,
+        rawPath
+      };
+    }
+    recordDedup();
+    recordFileDedup();
+    const plainContent = repeatWarning ? repeatWarning + "\n" + payload.modelContent : payload.modelContent;
+    return {
+      content: maybeAppendNeighborHint(params.cwd, payload.canonicalPath, params.sessionId, plainContent),
+      uiContent: payload.uiContent,
+      rawPath
+    };
+  },
+  requiresApproval: () => false,
+  isConcurrencySafe: () => true,
+  isEnabled: () => true
+};
+async function handleMultiRead(params, paths, focus, focusMaxMatches) {
+  const computedCap = params.readCapOverride ?? computeModelReadCap({
+    contextWindow: params.contextWindow,
+    providerProfile: params.providerProfile
+  });
+  const perFileCap = {
+    maxChars: Math.floor(computedCap.maxChars / paths.length),
+    headChars: Math.floor(computedCap.headChars / paths.length),
+    tailChars: Math.floor(computedCap.tailChars / paths.length)
+  };
+  const sections = [];
+  let totalBytes = 0;
+  let errors = 0;
+  for (const rawPath of paths) {
+    const trimmed = rawPath.trim();
+    if (!trimmed) continue;
+    try {
+      const payload = await readFilePayload(params.cwd, {
+        filePath: trimmed,
+        ...focus ? { focus, focusMaxMatches } : {},
+        modelCap: perFileCap,
+        preferFoldOnOverflow: params.readCapOverride !== void 0
+      });
+      const relPath = relative(params.cwd, payload.canonicalPath).replaceAll("\\", "/");
+      sections.push(`\u2500\u2500 ${relPath} \u2500\u2500
+${payload.modelContent}`);
+      totalBytes += payload.rawContent.length;
+      const currentStat = await stat2(payload.canonicalPath);
+      fileReadHistory.set(fileHistoryKey(params.sessionId, payload.canonicalPath), {
+        mtimeMs: currentStat.mtimeMs,
+        sizeBytes: currentStat.size,
+        totalLines: payload.rawContent.split("\n").length,
+        rawBytes: payload.rawContent.length,
+        modelBytes: payload.modelContent.length,
+        recordedAt: Date.now()
+      });
+      noteFileObserved(payload.canonicalPath, currentStat.mtimeMs, currentStat.size, params.sessionId);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const display = trimmed.startsWith(params.cwd) ? relative(params.cwd, trimmed) : trimmed;
+      sections.push(`\u2500\u2500 ${display} \u2500\u2500
+Error: ${msg}`);
+      errors++;
+    }
+  }
+  trimFileReadHistory();
+  const content = sections.join("\n\n");
+  return {
+    content,
+    uiContent: `Read ${paths.length - errors}/${paths.length} files (${(totalBytes / 1024).toFixed(1)} KB total)`
+  };
+}
+
+export {
+  truncateContent,
+  GitignoreFilter,
+  summarizeGrepResult,
+  summarizeBashOutput,
+  computeModelReadCap,
+  getToolArtifactThreshold,
+  buildPrewarmValue,
+  batchPrewarm,
+  setNeighborHintProvider,
+  incrementEditFailCount,
+  resetEditFailCount,
+  wasFileEditedBySession,
+  getFileReadMtime,
+  noteFileObserved,
+  invalidateReadHistory,
+  invalidateSessionReadDedup,
+  recordSuccessfulEdit,
+  registerGrepFileAccess,
+  getReadRefStats,
+  READ_FILE_TOOL
+};