pi-readseek 0.9.5 → 0.9.7

package/dist/index.ts

@@ -1,12 +1,9 @@
-// src/read.ts
+// src/edit.ts
 import { readFile as fsReadFile } from "node:fs/promises";
-import {
-  truncateHead as truncateHead2,
-  DEFAULT_MAX_BYTES as DEFAULT_MAX_BYTES2,
-  DEFAULT_MAX_LINES as DEFAULT_MAX_LINES2
-} from "@earendil-works/pi-coding-agent";
+import { createPatch } from "diff";
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
 import { Type as Type2 } from "@sinclair/typebox";
-import { Text as Text2 } from "@earendil-works/pi-tui";
+import { Text as Text3 } from "@earendil-works/pi-tui";
 
 // ../readseek-api/src/contract.ts
 var DIGEST_FACETS = [
@@ -32,11 +29,10 @@ var DOCUMENT_NODE_KINDS = [
   "structural_section"
 ];
 var TOOL_NAMES = [
-  "read",
+  "digest",
   "edit",
   "write",
   "grep",
-  "digest",
   "view",
   "search",
   "def",
@@ -45,6 +41,8 @@ var TOOL_NAMES = [
 ];
 var PARAM_DESCRIPTIONS = {
   path: "Absolute or relative file path",
+  projectPath: "Path relative to the project directory",
+  projectSearchPath: "File or directory to search; defaults to the project directory",
   searchPath: "File or directory to search; defaults to the current directory",
   language: "Language override when auto-detection is ambiguous",
   languageOverride: "Language override",
@@ -98,6 +96,7 @@ var PARAM_DESCRIPTIONS = {
   symbol: "Mapped symbol name",
   newBody: "Complete replacement body for the symbol",
   apply: "When supported by the host, apply the verified plan instead of previewing only",
+  applyDefaultTrue: "Apply the verified edits; defaults to true",
   planHash: "Require the apply plan to match this dry-run plan hash",
   workspace: "Rename across the project",
   to: "New symbol name",
@@ -113,11 +112,10 @@ var PARAM_DESCRIPTIONS = {
   scopeContext: "Context lines within each symbol"
 };
 var TOOL_DESCRIPTIONS = {
-  read: "Read anchored text by range or symbol. Standalone images require an explicit mode. Use it before edits to obtain fresh `LINE:HASH` anchors; use `view` for documents and `digest` with the map facet for structural outlines.",
+  digest: "Digest source content and images into the native CLI envelope. Returns metadata plus requested facets unchanged from `readseek digest`. Use it before edits to obtain fresh `LINE:HASH` anchors; use for structural maps, diagnostics, and cursor identity.",
   edit: 'Edit existing text files with fresh `LINE:HASH` anchors. Read or search first when no fresh anchors are available. Each `edits[]` item must use exactly one nested object: `{"set_line":{"anchor":"LINE:HASH","new_text":"..."}}`, `{"replace_lines":{"start_anchor":"LINE:HASH","end_anchor":"LINE:HASH","new_text":"..."}}`, `{"insert_after":{"anchor":"LINE:HASH","new_text":"..."}}`, `{"replace_symbol":{"symbol":"name","new_body":"..."}}`, or `{"replace":{"old_text":"...","new_text":"..."}}`.',
   write: "Create or replace a complete text file and return `LINE:HASH` anchors. Use `edit` for small changes to an existing file.",
   grep: "Search text or regex in files and return edit-ready `LINE:HASH` anchors. Use for identifiers, strings, configuration, errors, comments, and documentation.",
-  digest: "Digest source content and images into the native CLI envelope. Returns metadata plus requested facets unchanged from `readseek digest`; use for structural maps, diagnostics, and cursor identity.",
   view: "Digest a document's structure or selected content. Start with the overview, then narrow by page, node, kind, or depth instead of reading the whole document. PDF is the first supported document format.",
   search: "Search code by AST structure using ast-grep-style patterns. Results include line hashes usable as `LINE:HASH` anchors. Use `grep` for identifiers, strings, comments, configuration, documentation, or other plain text and regex.",
   def: "Go to a symbol definition or declaration by name. Accepts qualified or unqualified names; use this instead of text search for functions, methods, classes, types, and other declarations.",
@@ -125,7 +123,10 @@ var TOOL_DESCRIPTIONS = {
   rename: "Rename a symbol at a source location. Resolvable same-named bindings are preserved; verified edits apply by default. Set `apply: false` to preview the plan before changing files."
 };
 function renderToolDescription(name, aliases = {}) {
-  return TOOL_NAMES.reduce((description, toolName) => description.replaceAll(`\`${toolName}\``, `\`${aliases[toolName] ?? toolName}\``), TOOL_DESCRIPTIONS[name]);
+  const desc = TOOL_DESCRIPTIONS[name];
+  if (!desc)
+    throw new Error(`Missing TOOL_DESCRIPTIONS for ${name}`);
+  return TOOL_NAMES.reduce((description, toolName) => description.replaceAll(`\`${toolName}\``, `\`${aliases[toolName] ?? toolName}\``), desc);
 }
 var gitFlagsSchema = {
   cached: {
@@ -204,25 +205,27 @@ var editItemSchema = {
 };
 var TOOL_CONTRACTS = [
   {
-    name: "read",
-    title: "Read anchored text",
-    description: TOOL_DESCRIPTIONS.read,
+    name: "digest",
+    title: "Digest source",
+    description: TOOL_DESCRIPTIONS.digest,
     inputSchema: {
       type: "object",
       properties: {
         path: { type: "string", description: PARAM_DESCRIPTIONS.path },
-        offset: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.offset },
-        limit: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.readLimit },
-        symbol: { type: "string", description: PARAM_DESCRIPTIONS.symbolRead },
-        bundle: {
+        select: { type: "string", description: PARAM_DESCRIPTIONS.select },
+        at: { type: "string", description: PARAM_DESCRIPTIONS.at },
+        end: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.end },
+        limit: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.limit },
+        language: { type: "string", description: PARAM_DESCRIPTIONS.languageOverride },
+        visionMode: {
           type: "string",
-          enum: ["local"],
-          description: PARAM_DESCRIPTIONS.bundle
+          enum: [...VISION_MODES],
+          description: PARAM_DESCRIPTIONS.visionModeDigest
         },
-        image: {
+        visionLevel: {
           type: "string",
-          enum: [...VISION_MODES],
-          description: PARAM_DESCRIPTIONS.image
+          enum: [...VISION_LEVELS],
+          description: PARAM_DESCRIPTIONS.visionLevel
         }
       },
       required: ["path"],
@@ -296,34 +299,6 @@ var TOOL_CONTRACTS = [
       additionalProperties: false
     }
   },
-  {
-    name: "digest",
-    title: "Digest source",
-    description: TOOL_DESCRIPTIONS.digest,
-    inputSchema: {
-      type: "object",
-      properties: {
-        path: { type: "string", description: PARAM_DESCRIPTIONS.path },
-        select: { type: "string", description: PARAM_DESCRIPTIONS.select },
-        at: { type: "string", description: PARAM_DESCRIPTIONS.at },
-        end: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.end },
-        limit: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.limit },
-        language: { type: "string", description: PARAM_DESCRIPTIONS.languageOverride },
-        visionMode: {
-          type: "string",
-          enum: [...VISION_MODES],
-          description: PARAM_DESCRIPTIONS.visionModeDigest
-        },
-        visionLevel: {
-          type: "string",
-          enum: [...VISION_LEVELS],
-          description: PARAM_DESCRIPTIONS.visionLevel
-        }
-      },
-      required: ["path"],
-      additionalProperties: false
-    }
-  },
   {
     name: "view",
     title: "View document",
@@ -426,6 +401,90 @@ var TOOL_CONTRACTS = [
     }
   }
 ];
+// ../readseek-api/src/policy.ts
+var REPLACEABLE_TOOLS = [
+  {
+    tool: "digest",
+    builtIn: "read",
+    benefit: "it returns LINE:HASH anchors for safe edits."
+  },
+  {
+    tool: "edit",
+    builtIn: "edit",
+    benefit: "it verifies fresh LINE:HASH anchors."
+  },
+  {
+    tool: "grep",
+    builtIn: "grep",
+    benefit: "it returns LINE:HASH anchors."
+  },
+  {
+    tool: "write",
+    builtIn: "write",
+    benefit: "it returns LINE:HASH anchors."
+  }
+];
+var TOOL_COMPACT_GUIDELINES = {
+  digest: [
+    "Use `digest` for map, diagnostics, and identity facets instead of separate tools."
+  ],
+  edit: [
+    "Prefer set_line, replace_lines, and insert_after; use replace only when anchors are impractical."
+  ],
+  grep: [
+    "Use `grep` with summary first for broad searches, then narrow by path, glob, or pattern."
+  ],
+  write: [
+    "Use anchored edits rather than `write` for small changes or appends."
+  ],
+  search: [
+    "Use `search` for AST patterns; use `grep` for plain text."
+  ],
+  refs: [
+    "Use `refs` before changing a symbol; add scope plus line/column to follow one binding."
+  ]
+};
+function resolveToolName(name, aliases = {}) {
+  return aliases[name] ?? name;
+}
+function rewriteBacktickedToolNames(text, aliases = {}) {
+  return TOOL_NAMES.reduce((rewritten, toolName) => rewritten.replaceAll(`\`${toolName}\``, `\`${resolveToolName(toolName, aliases)}\``), text);
+}
+function renderCompactGuidelines(name, aliases = {}) {
+  return (TOOL_COMPACT_GUIDELINES[name] ?? []).map((guideline) => rewriteBacktickedToolNames(guideline, aliases));
+}
+function renderToolRoutingPolicy(options = {}) {
+  const aliases = options.aliases ?? {};
+  const digest = resolveToolName("digest", aliases);
+  const edit = resolveToolName("edit", aliases);
+  const write = resolveToolName("write", aliases);
+  const grep = resolveToolName("grep", aliases);
+  const search = resolveToolName("search", aliases);
+  const def = resolveToolName("def", aliases);
+  const refs = resolveToolName("refs", aliases);
+  const rename = resolveToolName("rename", aliases);
+  const view = resolveToolName("view", aliases);
+  if (options.style === "server") {
+    return [
+      "Structural code navigation, document viewing, and hash-verified edits with readseek.",
+      "For structural questions, prefer these tools to text Grep/Bash: definitions, references, AST search, multi-facet digest (content/map/diagnostics/identity), and document views.",
+      `Use ${edit} for LINE:HASH-anchored mutations (preview with apply=false; apply defaults to true and re-checks plan_hash).`,
+      "Paths resolve against CLAUDE_PROJECT_DIR. Native Read/Grep/Edit hooks provide passive context;",
+      "call MCP tools for active navigation, document questions, or anchored edits."
+    ].join(" ");
+  }
+  const title = options.title ?? "ReadSeek tool policy:";
+  const bullets = [];
+  if (options.preferOverBuiltIns) {
+    bullets.push("- Prefer ReadSeek tools over built-ins when they can do the job.");
+  }
+  bullets.push(`- Read with ${digest} first; ${edit} needs fresh LINE:HASH anchors.`, `- Use ${grep} for text/regex, ${search} for AST patterns, and ${digest}/${def}/${refs} for symbol navigation.`, `- Use ${edit} for existing files, ${write} for whole-file creation or replacement, and ${rename} for symbol renames.`, `- Use ${view} for document structure; run ${digest} with select diagnostics after source edits for a quick syntax check.`);
+  if (options.demoteBuiltIns && options.demoteBuiltIns.length > 0) {
+    bullets.push(`- Do not use built-in ${options.demoteBuiltIns.join(", ")} when a ReadSeek tool can do the job.`);
+  }
+  return [title, ...bullets].join(`
+`);
+}
 // ../readseek-api/src/validation.ts
 function validateGitSelection(input) {
   if (input.ignored && !input.others) {
@@ -796,51 +855,7 @@ async function runReadSeekNodeJson(binaryPath, args, options = {}) {
   return parseSuccessfulJson(await runReadSeekNode(binaryPath, args, options));
 }
 // src/tool-prompt-metadata.ts
-var REPLACEABLE_TOOL_GUIDELINES = {
-  "read.md": {
-    readSeekName: "readSeek_read",
-    builtInName: "read",
-    benefit: "it returns LINE:HASH anchors for safe edits."
-  },
-  "edit.md": {
-    readSeekName: "readSeek_edit",
-    builtInName: "edit",
-    benefit: "it verifies fresh LINE:HASH anchors."
-  },
-  "grep.md": {
-    readSeekName: "readSeek_grep",
-    builtInName: "grep",
-    benefit: "it returns LINE:HASH anchors."
-  },
-  "write.md": {
-    readSeekName: "readSeek_write",
-    builtInName: "write",
-    benefit: "it returns LINE:HASH anchors."
-  }
-};
-var COMPACT_GUIDELINES = {
-  "read.md": [
-    "Use readSeek_read with symbol or offset/limit to inspect large files without reading them in full."
-  ],
-  "digest.md": [
-    "Use readSeek_digest for map, diagnostics, and identity facets instead of separate tools."
-  ],
-  "edit.md": [
-    "Prefer set_line, replace_lines, and insert_after; use replace only when anchors are impractical."
-  ],
-  "grep.md": [
-    "Use readSeek_grep with summary first for broad searches, then narrow by path, glob, or pattern."
-  ],
-  "write.md": [
-    "Use anchored edits rather than readSeek_write for small changes or appends."
-  ],
-  "search.md": [
-    "Use readSeek_search for AST patterns; use readSeek_grep for plain text."
-  ],
-  "refs.md": [
-    "Use readSeek_refs before changing a symbol; add scope plus line/column to follow one binding."
-  ]
-};
+var REPLACEABLE_BY_TOOL = new Map(REPLACEABLE_TOOLS.map((entry) => [entry.tool, entry]));
 function toolNameFromPrompt(fileName) {
   const name = fileName.replace(/\.md$/, "");
   if (!TOOL_NAMES.includes(name))
@@ -850,28 +865,32 @@ function toolNameFromPrompt(fileName) {
 function promptFileName(promptUrl) {
   return promptUrl.pathname.split("/").pop() ?? "";
 }
-function rewriteToolAliases(value, toolAliases) {
+function rewriteRegisteredToolNames(value, toolAliases) {
   if (!toolAliases)
     return value;
   return Object.entries(toolAliases).reduce((rewritten, [canonicalName, registeredName]) => rewritten.replaceAll(canonicalName, registeredName), value);
 }
-function defineToolPromptMetadata(options) {
-  const fileName = promptFileName(options.promptUrl);
-  const toolName = toolNameFromPrompt(fileName);
-  const replaceable = REPLACEABLE_TOOL_GUIDELINES[fileName];
-  const registeredName = options.registeredName ?? replaceable?.readSeekName;
-  const preferenceGuideline = replaceable && registeredName ? registeredName === replaceable.readSeekName ? `Prefer ${registeredName} over ${replaceable.builtInName} when both are available; ${replaceable.benefit}` : `Use ${registeredName}; ${replaceable.benefit}` : undefined;
-  const aliases = Object.fromEntries(TOOL_NAMES.map((name) => {
+function descriptionAliases(toolName, registeredName, toolAliases) {
+  return Object.fromEntries(TOOL_NAMES.map((name) => {
     const readSeekName = `readSeek_${name}`;
-    const alias = name === toolName && registeredName ? registeredName : options.toolAliases?.[readSeekName] ?? readSeekName;
+    const alias = name === toolName && registeredName ? registeredName : toolAliases?.[readSeekName] ?? readSeekName;
     return [name, alias];
   }));
+}
+function defineToolPromptMetadata(options) {
+  const fileName = promptFileName(options.promptUrl);
+  const toolName = toolNameFromPrompt(fileName);
+  const replaceable = REPLACEABLE_BY_TOOL.get(toolName);
+  const defaultReadSeekName = `readSeek_${toolName}`;
+  const registeredName = options.registeredName ?? (replaceable ? defaultReadSeekName : undefined);
+  const preferenceGuideline = replaceable && registeredName ? registeredName === defaultReadSeekName ? `Prefer ${registeredName} over ${replaceable.builtIn} when both are available; ${replaceable.benefit}` : `Use ${registeredName}; ${replaceable.benefit}` : undefined;
+  const aliases = descriptionAliases(toolName, registeredName, options.toolAliases);
   return {
     description: renderToolDescription(toolName, aliases),
-    promptSnippet: rewriteToolAliases(options.promptSnippet, options.toolAliases),
+    promptSnippet: rewriteRegisteredToolNames(options.promptSnippet, options.toolAliases),
     promptGuidelines: [
       ...preferenceGuideline ? [preferenceGuideline] : [],
-      ...(COMPACT_GUIDELINES[fileName] ?? []).map((guideline) => rewriteToolAliases(registeredName && replaceable ? guideline.replaceAll(replaceable.readSeekName, registeredName) : guideline, options.toolAliases))
+      ...renderCompactGuidelines(toolName, aliases)
     ]
   };
 }
@@ -1068,6 +1087,146 @@ function generateCompactOrFullDiff(oldContent, newContent, contextLines = 4) {
   return generateDiffString(oldContent, newContent, contextLines);
 }
 
+// src/path-utils.ts
+import { homedir } from "node:os";
+import { isAbsolute, resolve as resolvePath } from "node:path";
+var UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+function normalizeUnicodeSpaces(str) {
+  return str.replace(UNICODE_SPACES, " ");
+}
+function normalizeAtPrefix(filePath) {
+  return filePath.startsWith("@") ? filePath.slice(1) : filePath;
+}
+function expandPath(filePath) {
+  const normalized = normalizeUnicodeSpaces(normalizeAtPrefix(filePath));
+  if (normalized === "~")
+    return homedir();
+  if (normalized.startsWith("~/"))
+    return homedir() + normalized.slice(1);
+  return normalized;
+}
+function resolveToCwd(filePath, cwd) {
+  const expanded = expandPath(filePath);
+  return isAbsolute(expanded) ? expanded : resolvePath(cwd, expanded);
+}
+
+// src/runtime.ts
+function throwIfAborted(signal) {
+  if (signal?.aborted)
+    throw new Error("Operation aborted");
+}
+
+// src/fs-error.ts
+var SYSLOG_PATH_SUFFIX = /,\s+[a-z]+(\s+'.*')?$/;
+function strerror(err) {
+  const raw = String(err?.message ?? String(err));
+  return raw.replace(SYSLOG_PATH_SUFFIX, "");
+}
+function formatFsError(err, domain) {
+  const errno = typeof err.code === "string" ? err.code : "EIO";
+  return {
+    code: errno,
+    message: `${domain}: ${errno}: ${strerror(err)}`
+  };
+}
+
+// src/edit-render-helpers.ts
+var VARIANT_KEYS = ["set_line", "replace_lines", "insert_after", "replace"];
+function countEditTypes(edits) {
+  const counts = {
+    set_line: 0,
+    replace_lines: 0,
+    insert_after: 0,
+    replace: 0,
+    total: 0
+  };
+  if (!edits)
+    return counts;
+  for (const edit of edits) {
+    counts.total++;
+    if (edit && typeof edit === "object") {
+      for (const key of VARIANT_KEYS) {
+        if (key in edit) {
+          counts[key]++;
+          break;
+        }
+      }
+    }
+  }
+  return counts;
+}
+function parseDiffStats(diff) {
+  if (!diff)
+    return { added: 0, removed: 0 };
+  let added = 0;
+  let removed = 0;
+  for (const line of diff.split(`
+`)) {
+    if (line.startsWith("+++") || line.startsWith("---"))
+      continue;
+    if (line.startsWith("+"))
+      added++;
+    else if (line.startsWith("-"))
+      removed++;
+  }
+  return { added, removed };
+}
+function formatEditCallText(args, argsComplete) {
+  const rawPath = typeof args?.path === "string" ? args.path : null;
+  if (!argsComplete) {
+    return { path: rawPath, suffix: undefined };
+  }
+  const edits = args?.edits;
+  if (!Array.isArray(edits) || edits.length === 0) {
+    return { path: rawPath, suffix: undefined };
+  }
+  const counts = countEditTypes(edits);
+  const parts = [];
+  for (const key of VARIANT_KEYS) {
+    if (counts[key] > 0) {
+      parts.push(`${counts[key]} ${key}`);
+    }
+  }
+  const word = counts.total === 1 ? "edit" : "edits";
+  const suffix = `${counts.total} ${word} (${parts.join(", ")})`;
+  return { path: rawPath, suffix };
+}
+function formatEditResultText(input) {
+  const { isError, diff, warnings, noopEdits, errorText } = input;
+  const isNoOp = isError && (Array.isArray(noopEdits) && noopEdits.length > 0 || errorText.includes("No changes made"));
+  const stats = parseDiffStats(diff);
+  const hasDiffStats = stats.added > 0 || stats.removed > 0;
+  const diffStats = hasDiffStats ? `+${stats.added} / -${stats.removed}` : undefined;
+  let warningsBadge;
+  if (warnings.length === 1) {
+    warningsBadge = "⚠ 1 warning";
+  } else if (warnings.length > 1) {
+    warningsBadge = `⚠ ${warnings.length} warnings`;
+  }
+  const showErrorText = isError ? errorText : undefined;
+  let semanticBadge;
+  if (!isError && !isNoOp && input.semanticClassification) {
+    switch (input.semanticClassification) {
+      case "whitespace-only":
+        semanticBadge = "ws-only";
+        break;
+      case "semantic":
+        semanticBadge = "✓ semantic";
+        break;
+      case "mixed":
+        semanticBadge = "mixed";
+        break;
+    }
+  }
+  return {
+    diffStats,
+    noOp: isNoOp,
+    warningsBadge,
+    errorText: showErrorText,
+    semanticBadge
+  };
+}
+
 // src/readseek-value.ts
 function buildReadSeekLineWithHash(line, hash, raw) {
   return {
@@ -1081,13 +1240,6 @@ function buildReadSeekLineWithHash(line, hash, raw) {
 function buildReadSeekLine(line, raw) {
   return buildReadSeekLineWithHash(line, computeLineHash(raw), raw);
 }
-function buildReadSeekLines(startLine, rawLines) {
-  return rawLines.map((raw, index) => buildReadSeekLine(startLine + index, raw));
-}
-function renderReadSeekLines(lines) {
-  return lines.map((line) => `${line.anchor}|${line.display}`).join(`
-`);
-}
 function formatAnchoredFileBlocks(files, lineSuffix) {
   const blocks = [];
   for (const file of files) {
@@ -1140,63 +1292,150 @@ function buildReadSeekEditResult(input) {
   };
 }
 
-// src/binary-detect.ts
-function looksLikeBinary(buf) {
-  if (buf.length === 0)
-    return false;
-  if (buf.includes(0))
-    return true;
-  const decoded = buf.toString("utf8");
-  if (!decoded.includes("�"))
-    return false;
-  return !Buffer.from(decoded, "utf8").equals(buf);
-}
-
-// src/path-utils.ts
-import { homedir } from "node:os";
-import { isAbsolute, resolve as resolvePath } from "node:path";
-var UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
-function normalizeUnicodeSpaces(str) {
-  return str.replace(UNICODE_SPACES, " ");
+// src/edit-output.ts
+var EDIT_OPERATION_NAMES = ["set_line", "replace_lines", "insert_after", "replace"];
+function hasNewText(value) {
+  return typeof value === "object" && value !== null && typeof value.new_text === "string";
 }
-function normalizeAtPrefix(filePath) {
-  return filePath.startsWith("@") ? filePath.slice(1) : filePath;
+function getVisibleDiffStats(diff) {
+  const stats = parseDiffStats(diff);
+  if (stats.added > 0 || stats.removed > 0)
+    return stats;
+  if (!diff.includes("→"))
+    return stats;
+  if (diff.includes("→ [deleted]"))
+    return { added: 0, removed: 1 };
+  return { added: 1, removed: 1 };
 }
-function expandPath(filePath) {
-  const normalized = normalizeUnicodeSpaces(normalizeAtPrefix(filePath));
-  if (normalized === "~")
-    return homedir();
-  if (normalized.startsWith("~/"))
-    return homedir() + normalized.slice(1);
-  return normalized;
+function buildVisibleSummary(displayPath, diff, edits) {
+  let stats = getVisibleDiffStats(diff);
+  const counts = countEditTypes(edits);
+  const editCount = counts.total || 1;
+  if (counts.total > 0 && counts.insert_after === counts.total && stats.removed > 0 && stats.added === stats.removed + counts.insert_after) {
+    stats = { added: counts.insert_after, removed: 0 };
+  }
+  const changeWord = editCount === 1 ? "change" : "changes";
+  const changedLineCount = Math.max(stats.added, stats.removed);
+  const lineWord = changedLineCount === 1 ? "line" : "lines";
+  return `Edited ${displayPath} (${editCount} ${changeWord}, +${stats.added} -${stats.removed} ${lineWord})`;
 }
-function resolveToCwd(filePath, cwd) {
-  const expanded = expandPath(filePath);
-  return isAbsolute(expanded) ? expanded : resolvePath(cwd, expanded);
+function extractNewTextValues(edits) {
+  const values = [];
+  for (const edit of edits ?? []) {
+    if (!edit || typeof edit !== "object")
+      continue;
+    const operations = edit;
+    for (const operationName of EDIT_OPERATION_NAMES) {
+      const operation = operations[operationName];
+      if (hasNewText(operation))
+        values.push(operation.new_text);
+    }
+  }
+  return values;
 }
-
-// src/runtime.ts
-function throwIfAborted(signal) {
-  if (signal?.aborted)
-    throw new Error("Operation aborted");
+function formatWhitespaceOnlyWarning(semanticSummary, edits) {
+  if (semanticSummary?.classification !== "whitespace-only")
+    return;
+  if (!extractNewTextValues(edits).some((text) => /\S/.test(text)))
+    return;
+  return "⚠ Edit classified as whitespace-only — if you intended a behavior change, re-read to verify.";
 }
-
-// src/fs-error.ts
-var SYSLOG_PATH_SUFFIX = /,\s+[a-z]+(\s+'.*')?$/;
-function strerror(err) {
-  const raw = String(err?.message ?? String(err));
-  return raw.replace(SYSLOG_PATH_SUFFIX, "");
+function formatReplaceHint(edits, noopEdits) {
+  if ((noopEdits ?? []).length > 0)
+    return;
+  const counts = countEditTypes(edits);
+  if (counts.replace === 0)
+    return;
+  if (counts.replace !== counts.total)
+    return;
+  return "[info: this edit used replace (unverified). For safer future edits, prefer set_line/replace_lines with an anchor from readSeek_digest/readSeek_grep/readSeek_search.]";
 }
-function formatFsError(err, domain) {
-  const errno = typeof err.code === "string" ? err.code : "EIO";
+function buildEditOutput(input) {
+  const summary = `Updated ${input.displayPath}`;
+  const visibleSummary = buildVisibleSummary(input.displayPath, input.diff, input.edits);
+  const semanticWarning = formatWhitespaceOnlyWarning(input.semanticSummary, input.edits);
+  const warningText = input.warnings.length ? `
+
+Warnings:
+${input.warnings.join(`
+`)}` : "";
+  const replaceHint = formatReplaceHint(input.edits, input.noopEdits);
+  let text = visibleSummary;
+  if (semanticWarning)
+    text += `
+${semanticWarning}`;
+  text += warningText;
+  if (replaceHint)
+    text += `
+${replaceHint}`;
   return {
-    code: errno,
-    message: `${domain}: ${errno}: ${strerror(err)}`
+    text,
+    patch: input.patch ?? "",
+    readSeekValue: buildReadSeekEditResult({
+      path: input.path,
+      summary,
+      diff: input.diff,
+      ...input.diffData ? { diffData: input.diffData } : {},
+      firstChangedLine: input.firstChangedLine,
+      warnings: input.warnings,
+      noopEdits: input.noopEdits,
+      ...input.semanticSummary ? { semanticSummary: input.semanticSummary } : {}
+    })
   };
 }
 
-// src/file-map.ts
-import { stat } from "node:fs/promises";
+// src/edit-classify.ts
+import * as Diff2 from "diff";
+function classifyEdit(oldContent, newContent) {
+  if (oldContent === newContent) {
+    return { classification: "no-op" };
+  }
+  const oldLines = oldContent.split(`
+`);
+  const newLines = newContent.split(`
+`);
+  if (oldLines.length === newLines.length) {
+    let hasWhitespaceChange2 = false;
+    let hasSemanticChange2 = false;
+    for (let i = 0;i < oldLines.length; i++) {
+      if (oldLines[i] === newLines[i])
+        continue;
+      if (oldLines[i].trim() === newLines[i].trim()) {
+        hasWhitespaceChange2 = true;
+      } else {
+        hasSemanticChange2 = true;
+      }
+    }
+    if (hasSemanticChange2 && hasWhitespaceChange2)
+      return { classification: "mixed" };
+    if (hasWhitespaceChange2)
+      return { classification: "whitespace-only" };
+    return { classification: "semantic" };
+  }
+  const parts = Diff2.diffLines(oldContent, newContent);
+  let hasWhitespaceChange = false;
+  let hasSemanticChange = false;
+  for (const part of parts) {
+    if (!part.added && !part.removed)
+      continue;
+    const lines = part.value.split(`
+`);
+    if (lines[lines.length - 1] === "")
+      lines.pop();
+    for (const line of lines) {
+      if (line.trim() === "") {
+        hasWhitespaceChange = true;
+      } else {
+        hasSemanticChange = true;
+      }
+    }
+  }
+  if (hasSemanticChange && hasWhitespaceChange)
+    return { classification: "mixed" };
+  if (hasWhitespaceChange)
+    return { classification: "whitespace-only" };
+  return { classification: "semantic" };
+}
 
 // src/readseek-client.ts
 import { existsSync, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
@@ -1236,7 +1475,7 @@ import { readFileSync, statSync } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { join } from "node:path";
 var READSEEK_TOOL_REPLACEMENTS = {
-  read: "readSeek_read",
+  read: "readSeek_digest",
   edit: "readSeek_edit",
   grep: "readSeek_grep",
   write: "readSeek_write"
@@ -1434,9 +1673,6 @@ function resolveReadSeekJsonSettings() {
     warnings: [...globalResult.warnings, ...projectResult.warnings]
   };
 }
-function resolveReadSeekImageMode() {
-  return resolveReadSeekJsonSettings().settings.imageMode ?? "auto";
-}
 function resolveReadSeekSyntaxValidation() {
   return resolveReadSeekJsonSettings().settings.syntaxValidation;
 }
@@ -1665,23 +1901,6 @@ function requireBoolean(value, field) {
     throw new Error(`invalid readseek ${field}: expected boolean`);
   return value;
 }
-function parseReadOutput(value) {
-  if (!value || typeof value !== "object")
-    throw new Error("invalid readseek read output");
-  const output = value;
-  const hashlines = output.hashlines;
-  if (!Array.isArray(hashlines))
-    throw new Error("invalid readseek hashlines");
-  return {
-    file: requireString(output.file, "file"),
-    language: requireString(output.language, "language"),
-    line_count: requireNumber(output.line_count, "line_count"),
-    file_hash: requireString(output.file_hash, "file_hash"),
-    start_line: requireNumber(output.start_line, "start_line"),
-    end_line: requireNumber(output.end_line, "end_line"),
-    hashlines: hashlines.map((line) => parseHashline(line, "hashline"))
-  };
-}
 function parseMapOutput(value) {
   if (!value || typeof value !== "object")
     throw new Error("invalid readseek map output");
@@ -1948,32 +2167,6 @@ function parseIdentifyOutput(value) {
     } : undefined
   };
 }
-function parseImageContent(value) {
-  const detection = parseDetectOutput(value);
-  if (detection.kind !== "image")
-    throw new Error("invalid readseek image content");
-  return detection;
-}
-function parseTextContent(value) {
-  if (!value || typeof value !== "object")
-    throw new Error("invalid readseek content");
-  const output = value;
-  if (output.hashlines !== undefined && output.start_line === undefined) {
-    const hashlines = parseSearchHashlines(output.hashlines, "content.hashlines");
-    const first = hashlines[0];
-    const last = hashlines[hashlines.length - 1];
-    return {
-      file: requireString(output.file, "file"),
-      language: requireString(output.language, "language"),
-      line_count: requireNumber(output.line_count, "line_count"),
-      file_hash: requireString(output.file_hash, "file_hash"),
-      start_line: first?.line ?? 1,
-      end_line: last?.line ?? 0,
-      hashlines
-    };
-  }
-  return parseReadOutput(value);
-}
 function parseDigestEnvelope(value) {
   if (!value || typeof value !== "object")
     throw new Error("invalid readseek digest output");
@@ -2023,11 +2216,6 @@ async function readSeekDigestNative(target, options = {}) {
 async function readSeekDigest(target, options = {}) {
   return parseDigestEnvelope(await runDigestRaw(target, options));
 }
-function requireDigestContent(envelope, field) {
-  if (envelope.content === undefined)
-    throw new Error(`invalid readseek ${field}: missing content`);
-  return envelope.content;
-}
 function fileMapFromReadSeekOutput(output, filePath, totalBytes) {
   if (output.language === "unknown" && output.symbols.length === 0)
     return null;
@@ -2082,70 +2270,6 @@ async function readSeekCheck(filePath, content, options = {}) {
     throw new Error("invalid readseek diagnostics: missing diagnostics facet");
   return envelope.diagnostics;
 }
-async function readSeekDetect(filePath, options = {}) {
-  const envelope = await readSeekDigest(filePath, { select: "metadata", signal: options.signal });
-  return envelope.metadata;
-}
-async function readSeekDigestContent(filePath, options = {}) {
-  const envelope = await readSeekDigest(filePath, {
-    select: "content",
-    at: options.startLine !== undefined ? buildLineLocation(options.startLine) : undefined,
-    end: options.endLine,
-    visionMode: options.visionMode,
-    signal: options.signal,
-    vision: options.vision
-  });
-  if (envelope.metadata.kind === "pdf") {
-    return { metadata: envelope.metadata, cache: envelope.cache };
-  }
-  const content = requireDigestContent(envelope, "content");
-  if (envelope.metadata.kind === "image") {
-    return { metadata: envelope.metadata, image: parseImageContent(content) };
-  }
-  return { metadata: envelope.metadata, text: parseTextContent(content) };
-}
-async function readSeekImage(filePath, modes, options = {}) {
-  const requestedModes = modes.length > 1 ? ["all"] : modes;
-  const results = await Promise.allSettled(requestedModes.map(async (mode) => {
-    const digested = await readSeekDigestContent(filePath, {
-      visionMode: mode,
-      signal: options.signal,
-      vision: true
-    });
-    if (!digested.image)
-      throw new Error(`readseek returned no image analysis for ${filePath}`);
-    return digested.image;
-  }));
-  let merged;
-  for (const result of results) {
-    if (result.status !== "fulfilled")
-      continue;
-    const detection = result.value;
-    merged = merged === undefined ? detection : {
-      ...merged,
-      ocr: detection.ocr ?? merged.ocr,
-      caption: detection.caption ?? merged.caption,
-      objects: detection.objects ?? merged.objects
-    };
-  }
-  if (merged !== undefined)
-    return merged;
-  const failure = results.find((result) => result.status === "rejected");
-  if (failure?.status === "rejected")
-    throw failure.reason;
-  throw new Error(`readseek returned no image analysis for ${filePath}`);
-}
-async function readSeekPreparedImage(filePath, options = {}) {
-  const digested = await readSeekDigestContent(filePath, {
-    visionMode: "none",
-    signal: options.signal
-  });
-  const output = digested.image;
-  if (!output || output.encoding !== "base64" || output.data === undefined || output.mime === undefined) {
-    throw new Error(`readseek returned no prepared image for ${filePath}`);
-  }
-  return { mime: output.mime, encoding: output.encoding, data: output.data };
-}
 function parseEditOutput(value) {
   if (!value || typeof value !== "object")
     throw new Error("invalid readseek edit output");
@@ -2296,1774 +2420,45 @@ async function readSeekDef(target, options) {
   return parseDefCompact(await runReadSeek(args, { signal: options.signal }));
 }
 
-// src/file-map.ts
-async function getOrGenerateMap(absPath) {
+// src/edit-syntax-validate.ts
+function dedupeSortLines(diagnostics) {
+  const seen = new Set;
+  const out = [];
+  for (const diagnostic of diagnostics) {
+    const key = diagnostic.start_line === diagnostic.end_line ? String(diagnostic.start_line) : `${diagnostic.start_line}-${diagnostic.end_line}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      out.push({ key, start: diagnostic.start_line });
+    }
+  }
+  out.sort((a, b) => a.start - b.start);
+  return out.map((o) => o.key);
+}
+var EMPTY = { errorCount: 0, missingCount: 0, diagnostics: [] };
+async function validateSyntaxRegression(input, options = {}) {
+  let before;
+  let after;
   try {
-    const { size } = await stat(absPath);
-    return await readSeekMap(absPath, size);
+    before = input.before === undefined ? EMPTY : await readSeekCheck(input.filePath, input.before, { signal: options.signal });
+    after = await readSeekCheck(input.filePath, input.after, { signal: options.signal });
   } catch {
     return null;
   }
+  const newErrorCount = Math.max(0, after.errorCount - before.errorCount);
+  const newMissingCount = Math.max(0, after.missingCount - before.missingCount);
+  if (newErrorCount === 0 && newMissingCount === 0)
+    return null;
+  return {
+    errorLines: dedupeSortLines(after.diagnostics),
+    newErrorCount,
+    newMissingCount
+  };
 }
 
-// src/readseek/formatter.ts
-import { basename } from "node:path";
-
-// src/readseek/constants.ts
-var THRESHOLDS = {
-  MAX_MAP_BYTES: 25 * 1024,
-  FULL_TARGET_BYTES: 10 * 1024,
-  COMPACT_TARGET_BYTES: 20 * 1024,
-  MAX_OUTLINE_BYTES: 50 * 1024,
-  MAX_TRUNCATED_BYTES: 100 * 1024,
-  TRUNCATED_SYMBOLS_EACH: 50
-};
-
-// src/readseek/formatter.ts
-var BOX_LINE = "───────────────────────────────────────";
-function formatSize(bytes) {
-  if (bytes < 1024) {
-    return `${bytes} B`;
-  }
-  if (bytes < 1024 * 1024) {
-    return `${(bytes / 1024).toFixed(1)} KB`;
-  }
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-function formatNumber(n) {
-  return n.toLocaleString("en-US");
-}
-function formatSymbol(symbol, indent = 0) {
-  const prefix = "  ".repeat(indent);
-  const lineRange = symbol.startLine === symbol.endLine ? `[${symbol.startLine}]` : `[${symbol.startLine}-${symbol.endLine}]`;
-  const { name } = symbol;
-  let formatted;
-  switch (symbol.kind) {
-    case "class":
-    case "interface":
-    case "struct":
-    case "enum":
-    case "type": {
-      formatted = `${prefix}${symbol.kind} ${name}: ${lineRange}`;
-      break;
-    }
-    case "function":
-    case "method": {
-      formatted = `${prefix}${name}: ${lineRange}`;
-      break;
-    }
-    case "variable":
-    case "constant": {
-      formatted = `${prefix}${name} = ... ${lineRange}`;
-      break;
-    }
-    default: {
-      formatted = `${prefix}${name}: ${lineRange}`;
-    }
-  }
-  return formatted;
-}
-function formatSymbols(symbols, level, indent = 0) {
-  const lines = [];
-  for (const symbol of symbols) {
-    lines.push(formatSymbol(symbol, indent));
-    if (level !== "outline" /* Outline */ && level !== "truncated" /* Truncated */ && symbol.children?.length) {
-      if (level === "minimal" /* Minimal */) {
-        for (const child of symbol.children) {
-          lines.push(formatSymbol(child, indent + 1));
-        }
-      } else {
-        lines.push(...formatSymbols(symbol.children, level, indent + 1));
-      }
-    }
-  }
-  return lines;
-}
-function formatFileMap(map, level) {
-  const effectiveLevel = level ?? map.detailLevel;
-  const fileName = basename(map.path);
-  const lines = [
-    "",
-    BOX_LINE,
-    `File Map: ${fileName}`,
-    `${formatNumber(map.totalLines)} lines │ ${formatSize(map.totalBytes)} │ ${map.language}`,
-    BOX_LINE,
-    ""
-  ];
-  if (map.truncatedInfo) {
-    const { shownSymbols, totalSymbols } = map.truncatedInfo;
-    lines.push(`[Map ≤${formatSize(THRESHOLDS.MAX_TRUNCATED_BYTES)} | ${shownSymbols} of ${formatNumber(totalSymbols)} symbols]`);
-    lines.push("");
-  } else if (effectiveLevel === "outline" /* Outline */) {
-    lines.push(`[Map ≤${formatSize(THRESHOLDS.MAX_OUTLINE_BYTES)} | outline]`);
-    lines.push("");
-  } else if (effectiveLevel === "minimal" /* Minimal */) {
-    lines.push(`[Map ≤${formatSize(THRESHOLDS.MAX_MAP_BYTES)} | minimal]`);
-    lines.push("");
-  } else if (effectiveLevel === "compact" /* Compact */) {
-    lines.push(`[Map ≤${formatSize(THRESHOLDS.COMPACT_TARGET_BYTES)} | compact]`);
-    lines.push("");
-  }
-  if (map.truncatedInfo) {
-    const half = Math.floor(map.symbols.length / 2);
-    const firstSymbols = map.symbols.slice(0, half);
-    const lastSymbols = map.symbols.slice(half);
-    const firstLines = formatSymbols(firstSymbols, effectiveLevel);
-    lines.push(...firstLines);
-    lines.push("");
-    lines.push(`  ─ ─ ─ ${formatNumber(map.truncatedInfo.omittedSymbols)} more symbols ─ ─ ─`);
-    lines.push("");
-    const lastLines = formatSymbols(lastSymbols, effectiveLevel);
-    lines.push(...lastLines);
-  } else {
-    const symbolLines = formatSymbols(map.symbols, effectiveLevel);
-    lines.push(...symbolLines);
-  }
-  lines.push("");
-  lines.push(BOX_LINE);
-  if (map.truncatedInfo) {
-    const firstShown = map.symbols.slice(0, Math.floor(map.symbols.length / 2));
-    const lastShown = map.symbols.slice(Math.floor(map.symbols.length / 2));
-    const lastFirst = firstShown.at(-1);
-    const firstLast = lastShown.at(0);
-    if (lastFirst && firstLast) {
-      const omitStart = lastFirst.endLine + 1;
-      const omitEnd = firstLast.startLine - 1;
-      lines.push(`Omitted symbols are in lines ${formatNumber(omitStart)}-${formatNumber(omitEnd)}.`);
-    }
-    lines.push("Use read(path, offset=LINE, limit=N) to view specific sections.");
-  } else {
-    lines.push("Use read(path, offset=LINE, limit=N) for targeted reads.");
-  }
-  lines.push(BOX_LINE);
-  return lines.join(`
-`);
-}
-function reduceToLevel(map, level) {
-  if (level === "outline" /* Outline */) {
-    return {
-      ...map,
-      detailLevel: "outline" /* Outline */,
-      symbols: map.symbols.map((s) => ({
-        name: s.name,
-        kind: s.kind,
-        startLine: s.startLine,
-        endLine: s.endLine
-      }))
-    };
-  }
-  if (level === "minimal" /* Minimal */) {
-    return {
-      ...map,
-      detailLevel: "minimal" /* Minimal */,
-      symbols: map.symbols.map((s) => ({
-        name: s.name,
-        kind: s.kind,
-        startLine: s.startLine,
-        endLine: s.endLine,
-        children: s.children?.map((c) => ({
-          name: c.name,
-          kind: c.kind,
-          startLine: c.startLine,
-          endLine: c.endLine
-        }))
-      }))
-    };
-  }
-  if (level === "compact" /* Compact */) {
-    return { ...map, detailLevel: "compact" /* Compact */ };
-  }
-  return { ...map, detailLevel: "full" /* Full */ };
-}
-function reduceToTruncated(map, symbolsEach = THRESHOLDS.TRUNCATED_SYMBOLS_EACH) {
-  const { symbols } = map;
-  const total = symbols.length;
-  if (total <= symbolsEach * 2) {
-    return reduceToLevel(map, "outline" /* Outline */);
-  }
-  const firstSymbols = symbols.slice(0, symbolsEach).map((s) => ({
-    name: s.name,
-    kind: s.kind,
-    startLine: s.startLine,
-    endLine: s.endLine
-  }));
-  const lastSymbols = symbols.slice(-symbolsEach).map((s) => ({
-    name: s.name,
-    kind: s.kind,
-    startLine: s.startLine,
-    endLine: s.endLine
-  }));
-  return {
-    ...map,
-    symbols: [...firstSymbols, ...lastSymbols],
-    detailLevel: "truncated" /* Truncated */,
-    truncatedInfo: {
-      totalSymbols: total,
-      shownSymbols: symbolsEach * 2,
-      omittedSymbols: total - symbolsEach * 2
-    }
-  };
-}
-function formatFileMapWithBudget(map, maxBytes = THRESHOLDS.MAX_TRUNCATED_BYTES) {
-  const tiers = [
-    { level: "full" /* Full */, budget: THRESHOLDS.FULL_TARGET_BYTES },
-    { level: "compact" /* Compact */, budget: THRESHOLDS.COMPACT_TARGET_BYTES },
-    { level: "minimal" /* Minimal */, budget: THRESHOLDS.MAX_MAP_BYTES },
-    { level: "outline" /* Outline */, budget: THRESHOLDS.MAX_OUTLINE_BYTES }
-  ];
-  for (const { level, budget } of tiers) {
-    const reduced = reduceToLevel(map, level);
-    const formatted = formatFileMap(reduced, level);
-    const size = Buffer.byteLength(formatted, "utf8");
-    if (size <= budget && size <= maxBytes) {
-      return formatted;
-    }
-  }
-  const outline = reduceToLevel(map, "outline" /* Outline */);
-  const outlineFormatted = formatFileMap(outline, "outline" /* Outline */);
-  const outlineSize = Buffer.byteLength(outlineFormatted, "utf8");
-  if (outlineSize <= maxBytes) {
-    return outlineFormatted;
-  }
-  const totalSymbols = map.symbols.length;
-  const minSymbols = 10;
-  const maxSymbolsEach = Math.floor(totalSymbols / 2);
-  let low = minSymbols;
-  let high = maxSymbolsEach;
-  let bestResult = null;
-  while (low <= high) {
-    const mid = Math.floor((low + high) / 2);
-    const truncated = reduceToTruncated(map, mid);
-    const formatted = formatFileMap(truncated, "truncated" /* Truncated */);
-    const size = Buffer.byteLength(formatted, "utf8");
-    if (size <= maxBytes) {
-      bestResult = formatted;
-      low = mid + 1;
-    } else {
-      high = mid - 1;
-    }
-  }
-  if (bestResult) {
-    return bestResult;
-  }
-  const minimal = reduceToTruncated(map, minSymbols);
-  return formatFileMap(minimal, "truncated" /* Truncated */);
-}
-
-// src/readseek/symbol-tree.ts
-function traverseSymbolTree(symbols, visit) {
-  const result = [];
-  const walk = (nodes, parentName) => {
-    for (const symbol of nodes) {
-      result.push(visit(symbol, parentName));
-      if (symbol.children?.length)
-        walk(symbol.children, symbol.name);
-    }
-  };
-  walk(symbols);
-  return result;
-}
-
-// src/readseek/symbol-lookup.ts
-function toMatch(symbol, parentName) {
-  return {
-    name: symbol.name,
-    kind: symbol.kind,
-    startLine: symbol.startLine,
-    endLine: symbol.endLine,
-    ...parentName ? { parentName } : {}
-  };
-}
-function toMatches(candidates) {
-  return candidates.map((candidate) => toMatch(candidate.symbol, candidate.parentName));
-}
-function flattenSymbols(symbols) {
-  return traverseSymbolTree(symbols, (symbol, parentName) => ({ symbol, parentName }));
-}
-function resolveDotPath(symbols, parts) {
-  let candidates = symbols.filter((symbol) => symbol.name === parts[0]).map((symbol) => ({ symbol }));
-  for (let i = 1;i < parts.length; i++) {
-    const nextCandidates = [];
-    for (const candidate of candidates) {
-      for (const child of candidate.symbol.children ?? []) {
-        if (child.name === parts[i]) {
-          nextCandidates.push({ symbol: child, parentName: candidate.symbol.name });
-        }
-      }
-    }
-    candidates = nextCandidates;
-  }
-  return candidates;
-}
-var JAVA_TOP_LEVEL_TYPE_KINDS = new Set(["class", "interface", "enum", "module"]);
-function preferJavaTopLevelType(map, candidates) {
-  if (map.language !== "Java")
-    return;
-  const topLevelTypes = candidates.filter((candidate) => !candidate.parentName && JAVA_TOP_LEVEL_TYPE_KINDS.has(candidate.symbol.kind));
-  return topLevelTypes.length === 1 ? topLevelTypes[0] : undefined;
-}
-function resolveDotPathSuffix(symbols, parts) {
-  for (let start = 1;start < parts.length; start++) {
-    const candidates = resolveDotPath(symbols, parts.slice(start));
-    if (candidates.length > 0)
-      return candidates;
-  }
-  return [];
-}
-function findSymbol(map, query) {
-  const q = query.trim();
-  if (!q)
-    return { type: "not-found" };
-  if (map.symbols.length === 0)
-    return { type: "not-found" };
-  const allSymbols = flattenSymbols(map.symbols);
-  const atLineMatch = /^(.+?)@(\d+)$/.exec(q);
-  if (atLineMatch) {
-    const namePart = atLineMatch[1];
-    const lineNum = Number.parseInt(atLineMatch[2], 10);
-    let pool;
-    if (namePart.includes(".")) {
-      const parts = namePart.split(".").map((p) => p.trim());
-      pool = parts.every((p) => p.length > 0) ? resolveDotPath(map.symbols, parts) : [];
-      if (pool.length === 0) {
-        pool = allSymbols.filter((c) => c.symbol.name === namePart);
-      }
-    } else {
-      pool = allSymbols.filter((c) => c.symbol.name === namePart);
-    }
-    pool = pool.filter((c) => Number.isFinite(c.symbol.startLine) && c.symbol.startLine > 0);
-    if (pool.length === 0) {
-      const leaf = namePart.split(".").pop() ?? namePart;
-      const sameLeaf = allSymbols.filter((c) => c.symbol.name === leaf && Number.isFinite(c.symbol.startLine) && c.symbol.startLine > 0);
-      if (sameLeaf.length > 0) {
-        const list = sameLeaf.slice(0, 5).map((c) => `${c.parentName ? c.parentName + "." : ""}${c.symbol.name}@${c.symbol.startLine}`).join(", ");
-        return {
-          type: "not-found",
-          message: `${q} not found. Candidates: ${list}`,
-          candidates: toMatches(sameLeaf.slice(0, 5))
-        };
-      }
-    }
-    if (pool.length > 0) {
-      const containing = pool.filter((c) => c.symbol.startLine <= lineNum && c.symbol.endLine >= lineNum);
-      if (containing.length > 0) {
-        return { type: "found", symbol: toMatch(containing[0].symbol, containing[0].parentName) };
-      }
-      const below = pool.filter((c) => c.symbol.startLine >= lineNum).sort((a, b) => a.symbol.startLine - b.symbol.startLine);
-      if (below.length) {
-        return { type: "found", symbol: toMatch(below[0].symbol, below[0].parentName) };
-      }
-      const above = pool.filter((c) => c.symbol.startLine < lineNum).sort((a, b) => b.symbol.startLine - a.symbol.startLine);
-      if (above.length) {
-        return { type: "found", symbol: toMatch(above[0].symbol, above[0].parentName) };
-      }
-    }
-  }
-  const exact = allSymbols.filter((c) => c.symbol.name === q);
-  if (exact.length === 1)
-    return { type: "found", symbol: toMatch(exact[0].symbol, exact[0].parentName) };
-  if (exact.length > 1) {
-    const preferred = preferJavaTopLevelType(map, exact);
-    if (preferred)
-      return { type: "found", symbol: toMatch(preferred.symbol, preferred.parentName) };
-    return { type: "ambiguous", candidates: toMatches(exact.slice(0, 5)) };
-  }
-  if (q.includes(".")) {
-    const parts = q.split(".").map((p) => p.trim());
-    if (parts.length >= 2 && parts.every((p) => p.length > 0)) {
-      const candidates = resolveDotPath(map.symbols, parts);
-      if (candidates.length === 1) {
-        return { type: "found", symbol: toMatch(candidates[0].symbol, candidates[0].parentName) };
-      }
-      if (candidates.length > 1) {
-        return {
-          type: "ambiguous",
-          candidates: toMatches(candidates.slice(0, 5))
-        };
-      }
-      const suffixCandidates = resolveDotPathSuffix(map.symbols, parts);
-      if (suffixCandidates.length === 1) {
-        return { type: "found", symbol: toMatch(suffixCandidates[0].symbol, suffixCandidates[0].parentName) };
-      }
-      if (suffixCandidates.length > 1) {
-        return {
-          type: "ambiguous",
-          candidates: toMatches(suffixCandidates.slice(0, 5))
-        };
-      }
-    }
-  }
-  const qLower = q.toLowerCase();
-  const ci = allSymbols.filter((c) => c.symbol.name.toLowerCase() === qLower);
-  if (ci.length === 1)
-    return { type: "found", symbol: toMatch(ci[0].symbol, ci[0].parentName) };
-  if (ci.length > 1)
-    return { type: "ambiguous", candidates: toMatches(ci.slice(0, 5)) };
-  const prefix = allSymbols.filter((c) => c.symbol.name.toLowerCase().startsWith(qLower));
-  if (prefix.length === 1)
-    return { type: "found", symbol: toMatch(prefix[0].symbol, prefix[0].parentName) };
-  if (prefix.length > 1)
-    return { type: "ambiguous", candidates: toMatches(prefix.slice(0, 5)) };
-  const camelCase = allSymbols.filter((c) => {
-    const words = c.symbol.name.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().split(/[\s_]+/);
-    return words.some((w) => w === qLower);
-  });
-  const partial = allSymbols.filter((c) => c.symbol.name.toLowerCase().includes(qLower));
-  const buildOtherCandidates = (chosen) => {
-    const pool = [];
-    const seen = new Set;
-    seen.add(chosen.symbol);
-    for (const c of [...camelCase, ...partial]) {
-      if (seen.has(c.symbol))
-        continue;
-      seen.add(c.symbol);
-      pool.push(c);
-    }
-    return toMatches(pool.slice(0, 4));
-  };
-  if (camelCase.length === 1) {
-    return {
-      type: "fuzzy",
-      symbol: toMatch(camelCase[0].symbol, camelCase[0].parentName),
-      tier: "camelCase",
-      otherCandidates: buildOtherCandidates(camelCase[0])
-    };
-  }
-  if (camelCase.length > 1)
-    return { type: "ambiguous", candidates: toMatches(camelCase.slice(0, 5)) };
-  if (partial.length === 1) {
-    return {
-      type: "fuzzy",
-      symbol: toMatch(partial[0].symbol, partial[0].parentName),
-      tier: "substring",
-      otherCandidates: buildOtherCandidates(partial[0])
-    };
-  }
-  if (partial.length > 1)
-    return { type: "ambiguous", candidates: toMatches(partial.slice(0, 5)) };
-  return { type: "not-found" };
-}
-
-// src/readseek/symbol-error-format.ts
-function formatAmbiguous(query, candidates) {
-  const lines = candidates.map((c) => `- ${c.name} (${c.kind}) — lines ${c.startLine}-${c.endLine}`);
-  const hints = candidates.map((c) => `${query}@${c.startLine}`).join(" or ");
-  return [
-    `Symbol '${query}' is ambiguous.`,
-    "Matches:",
-    ...lines,
-    `Use ${hints} to select by start line.`
-  ].join(`
-`);
-}
-function formatNotFound(query, map) {
-  const available = map.symbols.slice(0, 20).map((s) => s.name).join(", ");
-  return `[Warning: symbol '${query}' not found. Available symbols: ${available}]`;
-}
-
-// src/read-output.ts
-import {
-  DEFAULT_MAX_BYTES,
-  DEFAULT_MAX_LINES,
-  formatSize as formatSize2,
-  truncateHead
-} from "@earendil-works/pi-coding-agent";
-function buildReadOutput(input) {
-  const selectedLines = input.selectedLines ?? input.lines?.map((line) => line.raw) ?? [];
-  const lines = input.lines ?? buildReadSeekLines(input.startLine, selectedLines);
-  const warnings = input.warnings ?? [];
-  const renderedLines = renderReadSeekLines(lines);
-  const truncated = truncateHead(renderedLines, {
-    maxLines: DEFAULT_MAX_LINES,
-    maxBytes: DEFAULT_MAX_BYTES
-  });
-  let text = input.truncation ? truncated.content : renderedLines;
-  if (input.truncation) {
-    text += `
-
-[Output truncated: showing ${input.truncation.outputLines} of ${input.totalLines} lines (${formatSize2(input.truncation.outputBytes)} of ${formatSize2(input.truncation.totalBytes)}). Use offset=${input.startLine + input.truncation.outputLines} to continue.]`;
-  } else if (input.continuation) {
-    text += `
-
-[Showing lines ${input.startLine}-${input.endLine} of ${input.totalLines}. Use offset=${input.continuation.nextOffset} to continue.]`;
-  }
-  if (input.bundle?.applied) {
-    const supportBlocks = input.bundle.localSupport.map((item) => {
-      const supportLines = buildReadSeekLines(item.symbol.startLine, item.lines);
-      return renderReadSeekLines(supportLines);
-    });
-    text = [
-      "## Requested symbol",
-      text,
-      "",
-      "## Local support",
-      ...supportBlocks
-    ].join(`
-`);
-  }
-  if (input.map?.appended && input.map.text) {
-    text += `
-
-${input.map.text}`;
-  }
-  if (input.symbol) {
-    const parentInfo = input.symbol.parentName ? ` in ${input.symbol.parentName}` : "";
-    text = `[Symbol: ${input.symbol.name} (${input.symbol.kind})${parentInfo}, lines ${input.symbol.startLine}-${input.symbol.endLine} of ${input.totalLines}]
-
-${text}`;
-  }
-  if (warnings.length) {
-    text = `${warnings.map((warning) => warning.message).join(`
-
-`)}
-
-${text}`;
-  }
-  const readSeekValue = {
-    tool: "read",
-    path: input.path,
-    range: {
-      startLine: input.startLine,
-      endLine: input.endLine,
-      totalLines: input.totalLines
-    },
-    warnings,
-    truncation: input.truncation ?? null,
-    symbol: input.symbol ?? null,
-    map: {
-      requested: input.map?.requested ?? false,
-      appended: input.map?.appended ?? false
-    },
-    lines
-  };
-  if (input.bundle) {
-    readSeekValue.bundle = {
-      mode: input.bundle.mode,
-      applied: input.bundle.applied,
-      localSupport: input.bundle.localSupport.map((item) => {
-        const supportLines = buildReadSeekLines(item.symbol.startLine, item.lines);
-        return {
-          name: item.symbol.name,
-          kind: item.symbol.kind,
-          parentName: item.symbol.parentName,
-          startLine: item.symbol.startLine,
-          endLine: item.symbol.endLine,
-          lineAnchors: supportLines.map((line) => line.anchor)
-        };
-      }),
-      warnings: input.bundle.warnings ?? []
-    };
-  }
-  return {
-    text,
-    lines,
-    readSeekValue
-  };
-}
-
-// src/read-local-bundle.ts
-var CONTAINER_KINDS = new Set([
-  "class" /* Class */,
-  "module" /* Module */,
-  "namespace" /* Namespace */
-]);
-function buildLocalBundle(fileMap, requested, allLines) {
-  const requestedText = allLines.slice(requested.startLine - 1, requested.endLine).join(`
-`);
-  const identifiers = new Set(requestedText.match(/\b[A-Za-z_][A-Za-z0-9_]*\b/g) ?? []);
-  const candidates = traverseSymbolTree(fileMap.symbols, (symbol, parentName) => ({ symbol, parentName })).filter(({ symbol }) => {
-    if (CONTAINER_KINDS.has(symbol.kind))
-      return false;
-    return !(symbol.name === requested.name && symbol.startLine === requested.startLine && symbol.endLine === requested.endLine);
-  });
-  const symbolsByName = new Map;
-  for (const candidate of candidates) {
-    const bucket = symbolsByName.get(candidate.symbol.name) ?? [];
-    bucket.push(candidate);
-    symbolsByName.set(candidate.symbol.name, bucket);
-  }
-  const support = [];
-  for (const identifier of identifiers) {
-    const matches = symbolsByName.get(identifier) ?? [];
-    if (matches.length === 0)
-      continue;
-    if (matches.length > 1)
-      return null;
-    const match = matches[0];
-    support.push({
-      symbol: {
-        name: match.symbol.name,
-        kind: match.symbol.kind,
-        startLine: match.symbol.startLine,
-        endLine: match.symbol.endLine,
-        ...match.parentName ? { parentName: match.parentName } : {}
-      },
-      lines: allLines.slice(match.symbol.startLine - 1, match.symbol.endLine)
-    });
-  }
-  support.sort((a, b) => {
-    if (a.symbol.startLine !== b.symbol.startLine)
-      return a.symbol.startLine - b.symbol.startLine;
-    return a.symbol.name.localeCompare(b.symbol.name);
-  });
-  return {
-    requested,
-    support
-  };
-}
-
-// src/coerce-obvious-int.ts
-var BASE10_INT_RE = /^-?\d+$/;
-var MIN_SAFE_INTEGER = BigInt(Number.MIN_SAFE_INTEGER);
-var MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
-function formatReceived(value) {
-  if (typeof value === "number" || typeof value === "bigint")
-    return String(value);
-  return JSON.stringify(value) ?? String(value);
-}
-function invalidInteger(value, name) {
-  return {
-    ok: false,
-    message: `Invalid ${name}: expected a safe base-10 integer, received ${formatReceived(value)}.`
-  };
-}
-function coerceObviousBase10Int(value, name) {
-  if (value === undefined || typeof value === "string" && value.trim() === "") {
-    return { ok: true, value: undefined };
-  }
-  if (typeof value === "number") {
-    if (Number.isSafeInteger(value)) {
-      return { ok: true, value };
-    }
-    return invalidInteger(value, name);
-  }
-  if (typeof value === "string" && BASE10_INT_RE.test(value)) {
-    const parsed = BigInt(value);
-    if (parsed >= MIN_SAFE_INTEGER && parsed <= MAX_SAFE_INTEGER) {
-      return { ok: true, value: Number(parsed) };
-    }
-  }
-  return invalidInteger(value, name);
-}
-
-// src/read-render-helpers.ts
-function formatReadCallText(args) {
-  const rawPath = typeof args?.path === "string" ? args.path : null;
-  if (typeof args?.symbol === "string" && args.symbol) {
-    return { path: rawPath, suffix: `→ symbol ${args.symbol}` };
-  }
-  if (typeof args?.offset === "number") {
-    const offset = args.offset;
-    const limit = typeof args?.limit === "number" ? args.limit : undefined;
-    if (offset < 1) {
-      return { path: rawPath, suffix: undefined };
-    }
-    if (limit !== undefined) {
-      if (limit < 1) {
-        return { path: rawPath, suffix: undefined };
-      }
-      return { path: rawPath, suffix: `lines ${offset}-${offset + limit - 1}` };
-    }
-    return { path: rawPath, suffix: `from line ${offset}` };
-  }
-  return { path: rawPath, suffix: undefined };
-}
-function formatReadResultText(input) {
-  const { range, truncation, symbol, map, warnings } = input;
-  if (input.isError && input.errorText) {
-    return {
-      summary: "",
-      symbolBadge: undefined,
-      badges: [],
-      truncated: false,
-      errorText: input.errorText
-    };
-  }
-  const lineCount = range.endLine - range.startLine + 1;
-  const isFullFile = range.startLine === 1 && range.endLine === range.totalLines;
-  const isTruncated = !!truncation;
-  let summary;
-  if (isTruncated) {
-    summary = `✓ ${truncation.outputLines} of ${truncation.totalLines} lines (truncated)`;
-  } else if (isFullFile) {
-    summary = `✓ ${lineCount} lines`;
-  } else {
-    summary = `✓ ${lineCount} lines (${range.startLine}-${range.endLine} of ${range.totalLines})`;
-  }
-  const symbolBadge = symbol ? `${symbol.kind} ${symbol.name}` : undefined;
-  const badges = [];
-  if (map.appended)
-    badges.push("\uD83D\uDCD0 map");
-  for (const w of warnings) {
-    if (w.code === "binary-content")
-      badges.push("⚠ binary");
-    if (w.code === "bare-cr")
-      badges.push("⚠ bare CR");
-    if (w.code === "fuzzy-symbol-match")
-      badges.push("⚠ fuzzy match");
-  }
-  return {
-    summary,
-    symbolBadge,
-    badges,
-    truncated: isTruncated,
-    errorText: undefined
-  };
-}
-
-// src/tui-render-utils.ts
-import { relative } from "node:path";
-import { pathToFileURL } from "node:url";
-import { getCapabilities, hyperlink, Text, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
-var SUMMARY_PREFIX = "↳";
-var EXPAND_HINT = " • Ctrl+O to expand";
-function renderToolLabel(theme, label) {
-  const boldFn = typeof theme.bold === "function" ? theme.bold.bind(theme) : (text) => text;
-  return theme.fg("toolTitle", boldFn(label));
-}
-function linkToolPath(styledText, rawPath, cwd) {
-  try {
-    if (!getCapabilities().hyperlinks)
-      return styledText;
-    const absolutePath = resolveToCwd(rawPath, cwd);
-    return hyperlink(styledText, pathToFileURL(absolutePath).href);
-  } catch {
-    return styledText;
-  }
-}
-function linkedPathLine(theme, rawPath, displayPath, cwd, suffix, width) {
-  const pathWidth = width === undefined ? undefined : Math.max(1, width - 2 - visibleWidth(suffix));
-  const visiblePath = pathWidth === undefined ? displayPath : truncateToWidth(displayPath, pathWidth);
-  const linkedPath = linkToolPath(theme.fg("dim", visiblePath), rawPath, cwd);
-  return `  ${linkedPath}${theme.fg("dim", suffix)}`;
-}
-function appendExpandHint(text, hidden) {
-  return hidden ? `${text}${EXPAND_HINT}` : text;
-}
-function summaryLine(summary, options = {}) {
-  const prefix = options.theme ? options.theme.fg(options.style ?? "dim", SUMMARY_PREFIX) : SUMMARY_PREFIX;
-  return appendExpandHint(`${prefix} ${summary}`, !!options.hidden);
-}
-function isRendererExpanded(options, context, defaultExpanded = false) {
-  return context?.expanded ?? options?.expanded ?? defaultExpanded;
-}
-function resolveRenderResultContext(options, rest, defaultExpanded = false) {
-  const context = rest[0] ?? options ?? {};
-  return {
-    isPartial: context.isPartial ?? options?.isPartial ?? false,
-    isError: context.isError ?? false,
-    expanded: isRendererExpanded(options, context, defaultExpanded),
-    width: context.width ?? options?.width,
-    cwd: context.cwd ?? process.cwd(),
-    context
-  };
-}
-function normalizeWidth(width, fallback = 80) {
-  return typeof width === "number" && Number.isFinite(width) && width > 0 ? Math.floor(width) : fallback;
-}
-function clampLineToWidth(line, width) {
-  if (width === undefined || width === null)
-    return line;
-  const normalized = normalizeWidth(width);
-  return visibleWidth(line) <= normalized ? line : truncateToWidth(line, normalized);
-}
-function clampLinesToWidth(lines, width) {
-  if (width === undefined || width === null)
-    return lines;
-  return lines.map((line) => clampLineToWidth(line, width));
-}
-function wrapWithHangingIndent(prefix, content, width, options = {}) {
-  const tint = options.tint ?? ((text) => text);
-  if (width === undefined || width === null)
-    return [tint(prefix + content)];
-  const normalized = normalizeWidth(width);
-  const combined = prefix + content;
-  if (visibleWidth(combined) <= normalized)
-    return [tint(combined)];
-  const prefixWidth = visibleWidth(prefix);
-  const contentWidth = Math.max(1, normalized - prefixWidth);
-  const wrapped = wrapTextWithAnsi(content, contentWidth);
-  if (wrapped.length === 0)
-    return [tint(clampLineToWidth(prefix, normalized))];
-  const indent = " ".repeat(prefixWidth);
-  return wrapped.map((line, index) => tint(clampLineToWidth(index === 0 ? prefix + line : indent + line, normalized)));
-}
-var wrappedHashlinesCache = new WeakMap;
-function renderPendingResult(pendingLabel, width, theme) {
-  return new Text(clampLinesToWidth([summaryLine(pendingLabel, { theme, style: "muted" })], width).join(`
-`), 0, 0);
-}
-function renderErrorResult(textContent, options) {
-  const firstLine = textContent.split(`
-`)[0] || (options.fallback ?? "Error");
-  const body = options.expanded && textContent ? textContent : firstLine;
-  return new Text(clampLinesToWidth(summaryLine(body, { theme: options.theme, style: "error" }).split(`
-`), options.width).join(`
-`), 0, 0);
-}
-function renderReadSeekSearchCall(args, theme, rest, opts) {
-  const context = rest[0] ?? {};
-  let text = `${renderToolLabel(theme, opts.label)} ${theme.fg("accent", opts.accent)}`;
-  text += theme.fg("dim", ` in ${args.path ?? "."}`);
-  const language = args.language ?? args.lang;
-  if (language)
-    text += theme.fg("dim", ` (${language})`);
-  const flags = opts.flags.filter(Boolean);
-  if (flags.length > 0)
-    text += theme.fg("dim", ` [${flags.join(",")}]`);
-  return new Text(clampLineToWidth(text, context.width), 0, 0);
-}
-function renderAnchoredFilesResult(result, options, theme, rest, labels) {
-  const { isPartial, isError, expanded, cwd, width } = resolveRenderResultContext(options, rest);
-  if (isPartial)
-    return renderPendingResult(labels.pendingLabel, width, theme);
-  const content = result.content?.[0];
-  const textContent = content?.type === "text" ? content.text : "";
-  if (isError || result.isError)
-    return renderErrorResult(textContent, { expanded, width, theme });
-  const readSeekValue = result.details?.readSeekValue;
-  const files = readSeekValue?.files ?? [];
-  if (files.length === 0)
-    return new Text(summaryLine(labels.emptyLabel, { theme, style: "dim" }), 0, 0);
-  const fileCount = files.length;
-  const total = files.reduce((sum, f) => sum + f.lines.length, 0);
-  const unitWord = total === 1 ? labels.unitSingular : labels.unitPlural;
-  const fileWord = fileCount === 1 ? "file" : "files";
-  let text = summaryLine(`${total} ${unitWord} in ${fileCount} ${fileWord}`, {
-    hidden: !expanded,
-    theme,
-    style: "success"
-  });
-  if (expanded) {
-    for (const file of files.slice(0, 20)) {
-      const display = relative(cwd, file.path) || file.path;
-      text += `
-${linkedPathLine(theme, file.path, display, cwd, ` (${file.lines.length})`, width)}`;
-    }
-    if (files.length > 20)
-      text += `
-` + theme.fg("muted", `  … and ${files.length - 20} more files`);
-  }
-  return new Text(clampLinesToWidth(text.split(`
-`), width).join(`
-`), 0, 0);
-}
-
-// src/tui-source-render.ts
-import { getLanguageFromPath, highlightCode } from "@earendil-works/pi-coding-agent";
-import { wrapTextWithAnsi as wrapTextWithAnsi2 } from "@earendil-works/pi-tui";
-var READ_ANCHOR_RE = /^(\d+:[0-9a-zA-Z]{1,16})\|(.*)$/;
-var GREP_ANCHOR_RE = /^(.*?):(>>|  )(\d+):([0-9a-zA-Z]{1,16})\|(.*)$/;
-var SOURCE_THEME_STYLES = [
-  "mdCodeBlock",
-  "muted",
-  "syntaxComment",
-  "syntaxKeyword",
-  "syntaxFunction",
-  "syntaxVariable",
-  "syntaxString",
-  "syntaxNumber",
-  "syntaxType",
-  "syntaxOperator",
-  "syntaxPunctuation",
-  "toolDiffAdded",
-  "toolDiffRemoved"
-];
-function wrapDisplayLines(lines, width) {
-  if (width === undefined || width === null)
-    return lines;
-  const normalized = normalizeWidth(width);
-  return lines.flatMap((line) => {
-    const wrapped = wrapTextWithAnsi2(line, normalized);
-    return wrapped.length > 0 ? wrapped : [""];
-  });
-}
-function renderSourceBlock(lines, path3) {
-  return highlightCode(lines.join(`
-`), getLanguageFromPath(path3));
-}
-function renderReadSourceForDisplay(text, path3, anchors, width) {
-  const output = [];
-  let sourceLines = [];
-  const flushSourceLines = () => {
-    if (sourceLines.length === 0)
-      return;
-    output.push(...wrapDisplayLines(renderSourceBlock(sourceLines, path3), width));
-    sourceLines = [];
-  };
-  for (const line of text.split(`
-`)) {
-    const match = line.match(READ_ANCHOR_RE);
-    if (match && anchors.has(match[1])) {
-      sourceLines.push(match[2] ?? "");
-      continue;
-    }
-    flushSourceLines();
-    output.push(...wrapDisplayLines([line], width));
-  }
-  flushSourceLines();
-  return output.join(`
-`);
-}
-var readSourceCache = new WeakMap;
-function renderReadSourceForDisplayCached(cacheKey, text, path3, anchors, width, theme) {
-  const themeKey = SOURCE_THEME_STYLES.map((style) => theme.fg(style, "")).join("");
-  const anchorKey = [...anchors].join(`
-`);
-  const cached = readSourceCache.get(cacheKey);
-  if (cached && cached.text === text && cached.path === path3 && cached.width === width && cached.theme === themeKey && cached.anchors === anchorKey) {
-    return cached.rendered;
-  }
-  const rendered = renderReadSourceForDisplay(text, path3, anchors, width);
-  readSourceCache.set(cacheKey, { text, path: path3, width, theme: themeKey, anchors: anchorKey, rendered });
-  return rendered;
-}
-function renderGrepSourceForDisplay(text, anchors, renderPath = (path3) => path3) {
-  return text.split(`
-`).map((line) => {
-    const match = line.match(GREP_ANCHOR_RE);
-    if (!match)
-      return line;
-    const anchor = `${match[3]}:${match[4]}`;
-    if (!anchors.has(anchor))
-      return line;
-    const separator = match[2] === ">>" ? ":" : "-";
-    return `${renderPath(match[1])}${separator}${match[3]}${separator}${match[5] ?? ""}`;
-  }).join(`
-`);
-}
-
-// src/register-tool.ts
-import { Type } from "@sinclair/typebox";
-function optionalIntOrString(description) {
-  return Type.Optional(Type.Union([Type.Number({ description }), Type.String({ description })]));
-}
-function filePathParam() {
-  return Type.String({ description: "Absolute or relative file path" });
-}
-function registerReadSeekTool(pi, tool) {
-  pi.registerTool(tool);
-  return tool;
-}
-
-// src/read.ts
-function hasReadAnchors(result) {
-  const details = result.details;
-  if (!details || typeof details !== "object")
-    return false;
-  const readSeekValue = details.readSeekValue;
-  if (!readSeekValue || typeof readSeekValue !== "object")
-    return false;
-  const lines = readSeekValue.lines;
-  return Array.isArray(lines) && lines.length > 0;
-}
-function formatImageAnalysis(detection, mode) {
-  if (detection.kind !== "image")
-    return;
-  const sections = [];
-  const ocr = detection.ocr?.trim();
-  if (ocr)
-    sections.push(`OCR text from image:
-${ocr}`);
-  const caption = detection.caption?.trim();
-  if (caption)
-    sections.push(`Image caption:
-${caption}`);
-  if (detection.objects?.length) {
-    const lines = detection.objects.map((object) => `- ${object.label} [${object.bbox.join(", ")}]`);
-    sections.push(`Detected objects:
-${lines.join(`
-`)}`);
-  }
-  if (sections.length > 0)
-    return sections.join(`
-
-`);
-  if (mode === "ocr")
-    return "No OCR text detected in image.";
-  if (mode === "objects")
-    return "No objects detected in image.";
-  if (mode === "all")
-    return "No image analysis returned.";
-  return "Image caption returned no text.";
-}
-function documentRedirectMessage(path3, cache) {
-  const cacheNote = cache ? ` Index ${cache.state} (hash ${cache.content_hash}).` : "";
-  return `Document content is not available via readSeek_read for ${path3}.${cacheNote} Use readSeek_view to digest structure or selected content.`;
-}
-function skippedImageFile(path3) {
-  return {
-    content: [{ type: "text", text: `[Skipped image: ${path3}; no image mode selected]` }],
-    details: {}
-  };
-}
-async function executeRead(opts) {
-  const { params, signal, cwd, onSuccessfulRead } = opts;
-  await ensureHashInit();
-  const rawParams = params;
-  const offset = coerceObviousBase10Int(rawParams.offset, "offset");
-  if (!offset.ok) {
-    return buildToolErrorResult("read", "invalid-offset", offset.message, { path: rawParams.path });
-  }
-  const limit = coerceObviousBase10Int(rawParams.limit, "limit");
-  if (!limit.ok) {
-    return buildToolErrorResult("read", "invalid-limit", limit.message, { path: rawParams.path });
-  }
-  if (limit.value !== undefined && limit.value < 1) {
-    const message = `Invalid limit: expected a positive integer, received ${limit.value}.`;
-    return buildToolErrorResult("read", "invalid-limit", message, { path: rawParams.path });
-  }
-  if (offset.value !== undefined && offset.value < 1) {
-    const message = `Invalid offset: expected a positive integer, received ${offset.value}.`;
-    return buildToolErrorResult("read", "invalid-offset", message, { path: rawParams.path });
-  }
-  const rawSymbol = typeof rawParams.symbol === "string" && rawParams.symbol.trim().length > 0 ? rawParams.symbol.trim() : undefined;
-  const rawBundle = typeof rawParams.bundle === "string" ? rawParams.bundle.trim() : undefined;
-  const p = {
-    ...rawParams,
-    offset: offset.value,
-    limit: limit.value,
-    symbol: rawSymbol,
-    bundle: rawBundle
-  };
-  const rawPath = p.path.replace(/^@/, "");
-  const absolutePath = resolveToCwd(rawPath, cwd);
-  const succeed = (result) => {
-    const isError = result.isError;
-    if (!isError && hasReadAnchors(result)) {
-      onSuccessfulRead?.(absolutePath);
-    }
-    return result;
-  };
-  throwIfAborted(signal);
-  if (p.bundle !== undefined && p.bundle !== "local") {
-    const message = `Invalid bundle: expected "local", received ${JSON.stringify(p.bundle)}.`;
-    return buildToolErrorResult("read", "invalid-params-combo", message, { path: rawParams.path });
-  }
-  if (p.symbol && (p.offset !== undefined || p.limit !== undefined)) {
-    const message = "Cannot combine symbol with offset/limit. Use one or the other.";
-    return buildToolErrorResult("read", "invalid-params-combo", message, { path: rawParams.path });
-  }
-  if (p.bundle && !p.symbol) {
-    const message = 'Cannot use bundle without symbol. Use read({ path, symbol, bundle: "local" }).';
-    return buildToolErrorResult("read", "invalid-params-combo", message, { path: rawParams.path });
-  }
-  throwIfAborted(signal);
-  const ext = rawPath.split(".").pop()?.toLowerCase() ?? "";
-  let rawBuffer;
-  try {
-    rawBuffer = await fsReadFile(absolutePath);
-  } catch (err) {
-    const { code, message } = formatFsError(err, "read-error");
-    return buildToolErrorResult("read", code, message, {
-      path: rawParams.path
-    });
-  }
-  const hasBinaryContent = looksLikeBinary(rawBuffer);
-  const hasPdfHeader = rawBuffer.subarray(0, 1024).includes(Buffer.from("%PDF-"));
-  const maybeVisual = hasBinaryContent || ext === "pdf" || hasPdfHeader;
-  let earlyDigest;
-  if (maybeVisual) {
-    let detection;
-    try {
-      earlyDigest = await readSeekDigestContent(absolutePath, {
-        ...ext === "pdf" || hasPdfHeader ? {} : { visionMode: "none" },
-        signal
-      });
-      detection = earlyDigest.metadata;
-    } catch {
-      try {
-        detection = await readSeekDetect(absolutePath, { signal });
-      } catch {
-        return buildToolErrorResult("read", "read-error", `Visual file detection failed for ${absolutePath}.`, {
-          path: rawParams.path
-        });
-      }
-    }
-    if (detection.kind === "pdf") {
-      return buildToolErrorResult("read", "document-use-view", documentRedirectMessage(rawParams.path, earlyDigest?.cache), { path: rawParams.path });
-    }
-    if (detection.kind === "image") {
-      if (p.offset !== undefined || p.limit !== undefined) {
-        const message = "Cannot combine offset/limit with image reads.";
-        return buildToolErrorResult("read", "invalid-params-combo", message, { path: rawParams.path });
-      }
-      const imageMode = resolveReadSeekImageMode();
-      const useNativeVision = imageMode === "auto" && opts.modelSupportsImages === true;
-      if (imageMode === "on" && p.image === "none") {
-        return buildToolErrorResult("read", "invalid-params-combo", 'image="none" is only available when imageMode is "auto".', {
-          path: rawParams.path
-        });
-      }
-      if (imageMode === "off" || p.image === undefined) {
-        return skippedImageFile(rawParams.path);
-      }
-      if (useNativeVision || p.image === "none") {
-        try {
-          const prepared = earlyDigest?.image && earlyDigest.image.encoding === "base64" && earlyDigest.image.data !== undefined && earlyDigest.image.mime !== undefined ? { mime: earlyDigest.image.mime, encoding: earlyDigest.image.encoding, data: earlyDigest.image.data } : await readSeekPreparedImage(absolutePath, { signal });
-          return succeed({
-            content: [{ type: "image", data: prepared.data, mimeType: prepared.mime }],
-            details: {}
-          });
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          return buildToolErrorResult("read", "read-error", `Image preprocessing unavailable: ${message}`, {
-            path: rawParams.path
-          });
-        }
-      }
-      try {
-        const analysis = await readSeekImage(absolutePath, [p.image], { signal });
-        const imageAnalysis = formatImageAnalysis(analysis, p.image);
-        if (imageAnalysis) {
-          return succeed({
-            content: [{ type: "text", text: imageAnalysis }],
-            details: {}
-          });
-        }
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return buildToolErrorResult("read", "read-error", `Image analysis unavailable: ${message}`, {
-          path: rawParams.path
-        });
-      }
-      return buildToolErrorResult("read", "read-error", "Image analysis returned no content.", {
-        path: rawParams.path
-      });
-    }
-  }
-  throwIfAborted(signal);
-  const rawText = rawBuffer.toString("utf-8");
-  const normalized = normalizeToLF(stripBom(rawText).text);
-  const allLines = splitReadSeekLines(normalized);
-  const total = allLines.length;
-  const structuredWarnings = [];
-  let startLine = p.offset !== undefined ? p.offset : 1;
-  let endIdx = p.limit !== undefined ? Math.min(startLine - 1 + p.limit, total) : total;
-  if (p.offset !== undefined && startLine > total) {
-    const message = `offset ${p.offset} is past end of file (${total} lines)`;
-    return buildToolErrorResult("read", "offset-past-end", message, { path: rawParams.path });
-  }
-  let symbolMatch;
-  let symbolFileMap = null;
-  let symbolWarning;
-  let bundleMetadata = null;
-  if (p.symbol) {
-    symbolFileMap = await getOrGenerateMap(absolutePath);
-    if (!symbolFileMap) {
-      const extLabel = ext || "unknown";
-      symbolWarning = `[Warning: symbol lookup not available for .${extLabel} files — showing full file]
-
-`;
-    } else {
-      const lookup = findSymbol(symbolFileMap, p.symbol);
-      if (lookup.type === "ambiguous") {
-        return succeed({
-          content: [
-            {
-              type: "text",
-              text: formatAmbiguous(p.symbol, lookup.candidates)
-            }
-          ],
-          isError: false,
-          details: {}
-        });
-      }
-      if (lookup.type === "not-found") {
-        symbolWarning = `${formatNotFound(p.symbol, symbolFileMap)}
-
-`;
-      }
-      if (lookup.type === "found") {
-        startLine = Math.max(1, lookup.symbol.startLine);
-        endIdx = Math.min(total, lookup.symbol.endLine);
-        symbolMatch = lookup.symbol;
-      }
-      if (lookup.type === "fuzzy") {
-        startLine = Math.max(1, lookup.symbol.startLine);
-        endIdx = Math.min(total, lookup.symbol.endLine);
-        symbolMatch = lookup.symbol;
-        const tierLabel = lookup.tier === "camelCase" ? "camelCase word boundary" : "substring";
-        const otherNames = lookup.otherCandidates.map((c) => `\`${c.name}\``).join(", ");
-        const confirmHint = `read({ symbol: "${lookup.symbol.name}" }) or ${lookup.symbol.name}@${lookup.symbol.startLine} to select by start line`;
-        const lines = [
-          `[Symbol '${p.symbol}' not exact-matched. Closest match: \`${lookup.symbol.name}\` (${lookup.symbol.kind}, lines ${lookup.symbol.startLine}-${lookup.symbol.endLine}) via ${tierLabel}.`
-        ];
-        if (otherNames)
-          lines.push(` Other candidates: ${otherNames}.`);
-        lines.push(` To confirm: ${confirmHint}.]`);
-        const bannerText = lines.join(`
-`);
-        structuredWarnings.push(buildReadSeekWarning("fuzzy-symbol-match", bannerText, {
-          tier: lookup.tier,
-          symbol: lookup.symbol,
-          otherCandidates: lookup.otherCandidates
-        }));
-      }
-    }
-  }
-  if (p.bundle === "local") {
-    if (!symbolFileMap) {
-      const extLabel = ext || "unknown";
-      const warning = buildReadSeekWarning("bundle-unmappable", `[Warning: local bundle unavailable because symbol mapping is not available for .${extLabel} files — showing plain symbol read]`);
-      structuredWarnings.push(warning);
-      bundleMetadata = {
-        mode: "local",
-        applied: false,
-        localSupport: [],
-        warnings: [warning]
-      };
-    } else if (!symbolMatch) {
-      bundleMetadata = {
-        mode: "local",
-        applied: false,
-        localSupport: [],
-        warnings: []
-      };
-    } else {
-      const bundle = buildLocalBundle(symbolFileMap, symbolMatch, allLines);
-      if (!bundle) {
-        const warning = buildReadSeekWarning("bundle-context-unavailable", `[Warning: local bundle context could not be determined for symbol '${symbolMatch.name}' — showing plain symbol read]`);
-        structuredWarnings.push(warning);
-        bundleMetadata = {
-          mode: "local",
-          applied: false,
-          localSupport: [],
-          warnings: [warning]
-        };
-      } else {
-        bundleMetadata = {
-          mode: "local",
-          applied: true,
-          localSupport: bundle.support.map((item) => ({
-            symbol: {
-              query: item.symbol.name,
-              name: item.symbol.name,
-              kind: item.symbol.kind,
-              parentName: item.symbol.parentName,
-              startLine: item.symbol.startLine,
-              endLine: item.symbol.endLine
-            },
-            lines: item.lines
-          })),
-          warnings: []
-        };
-      }
-    }
-  }
-  throwIfAborted(signal);
-  let readSeekOutput;
-  try {
-    const digested = total === 0 ? await readSeekDigestContent(absolutePath, { signal }) : await readSeekDigestContent(absolutePath, { startLine, endLine: endIdx, signal });
-    if (!digested.text) {
-      throw new Error(`readseek returned no text content for ${absolutePath}`);
-    }
-    readSeekOutput = digested.text;
-  } catch (err) {
-    const detail = err?.message ? ` — ${err.message}` : "";
-    const message = `readseek failed while reading ${rawPath}${detail}`;
-    return buildToolErrorResult("read", "readseek-error", message, { path: rawParams.path, hint: "Ensure @jarkkojs/readseek and its npm platform package are installed.", details: { message: err?.message } });
-  }
-  const expectedLineCount = Math.max(0, endIdx - startLine + 1);
-  const invalidLine = readSeekOutput.hashlines.find((line, index) => line.line !== startLine + index);
-  if (readSeekOutput.hashlines.length !== expectedLineCount || invalidLine) {
-    const message = invalidLine ? `readseek returned non-sequential line ${invalidLine.line} for requested range ${startLine}-${endIdx}` : `readseek returned ${readSeekOutput.hashlines.length} lines for requested range ${startLine}-${endIdx} (${expectedLineCount} expected)`;
-    return buildToolErrorResult("read", "readseek-output-mismatch", message, { path: rawParams.path });
-  }
-  const readSeekLines = readSeekOutput.hashlines.map((line) => ({
-    line: line.line,
-    hash: line.hash,
-    anchor: `${line.line}:${line.hash}`,
-    raw: line.text,
-    display: escapeControlCharsForDisplay(line.text)
-  }));
-  const selected = readSeekLines.map((line) => line.raw);
-  const formatted = renderReadSeekLines(readSeekLines);
-  const truncation = truncateHead2(formatted, { maxLines: DEFAULT_MAX_LINES2, maxBytes: DEFAULT_MAX_BYTES2 });
-  const shouldAppendMap = !!truncation.truncated && !p.offset && !p.limit && !symbolMatch;
-  let appendedMap = false;
-  let mapText = null;
-  if (shouldAppendMap) {
-    try {
-      const fileMap = await getOrGenerateMap(absolutePath);
-      if (fileMap) {
-        const formattedMap = formatFileMapWithBudget(fileMap);
-        mapText = formattedMap;
-        appendedMap = true;
-      }
-    } catch {}
-  }
-  let currentBuffer;
-  try {
-    currentBuffer = await fsReadFile(absolutePath);
-  } catch (err) {
-    const { code, message } = formatFsError(err, "read-error");
-    return buildToolErrorResult("read", code, message, { path: rawParams.path });
-  }
-  if (!currentBuffer.equals(rawBuffer)) {
-    return buildToolErrorResult("read", "file-changed-during-read", `File changed while it was being read: ${rawPath}. Re-read it to obtain a consistent snapshot.`, { path: rawParams.path });
-  }
-  if (symbolWarning) {
-    structuredWarnings.push(buildReadSeekWarning("symbol-warning", symbolWarning.trim()));
-  }
-  if (hasBinaryContent) {
-    const warning = "[Warning: file appears to be binary — output may be garbled]";
-    structuredWarnings.push(buildReadSeekWarning("binary-content", warning));
-  }
-  if (hasBareCarriageReturn(rawText)) {
-    const warning = "[Warning: file contains bare CR (\\r) line endings — line numbering may be inconsistent with grep and other tools]";
-    structuredWarnings.push(buildReadSeekWarning("bare-cr", warning));
-  }
-  const readOutput = buildReadOutput({
-    path: absolutePath,
-    startLine,
-    endLine: endIdx,
-    totalLines: total,
-    selectedLines: selected,
-    lines: readSeekLines,
-    warnings: structuredWarnings,
-    truncation: truncation.truncated ? {
-      outputLines: truncation.outputLines,
-      totalLines: total,
-      outputBytes: truncation.outputBytes,
-      totalBytes: truncation.totalBytes
-    } : null,
-    continuation: !truncation.truncated && endIdx < total ? { nextOffset: endIdx + 1 } : null,
-    symbol: symbolMatch ? {
-      query: p.symbol ?? symbolMatch.name,
-      name: symbolMatch.name,
-      kind: symbolMatch.kind,
-      parentName: symbolMatch.parentName,
-      startLine: symbolMatch.startLine,
-      endLine: symbolMatch.endLine
-    } : null,
-    map: {
-      requested: false,
-      appended: appendedMap,
-      text: mapText
-    },
-    ...bundleMetadata ? { bundle: bundleMetadata } : {}
-  });
-  return succeed({
-    content: [{ type: "text", text: readOutput.text }],
-    details: {
-      truncation: truncation.truncated ? truncation : undefined,
-      readSeekValue: readOutput.readSeekValue
-    }
-  });
-}
-function splitReadSeekLines(text) {
-  if (text.length === 0)
-    return [];
-  const withoutTrailingTerminator = text.endsWith(`
-`) ? text.slice(0, -1) : text;
-  return withoutTrailingTerminator.split(`
-`);
-}
-function registerReadTool(pi, options = {}) {
-  const name = options.name ?? "readSeek_read";
-  const imageMode = resolveReadSeekImageMode();
-  const imageModes = imageMode === "auto" ? ["none", "all", "ocr", "caption", "objects"] : ["all", "ocr", "caption", "objects"];
-  const promptMetadata = defineToolPromptMetadata({
-    promptUrl: new URL("../prompts/read.md", import.meta.url),
-    promptSnippet: imageMode === "off" ? "Read anchored text or symbols" : "Read anchored text, symbols, or images",
-    registeredName: name
-  });
-  const tool = registerReadSeekTool(pi, {
-    name,
-    label: "Read",
-    description: imageMode === "off" ? "Read anchored text by range or symbol. Images and documents are disabled; use readSeek_view for documents." : promptMetadata.description,
-    promptSnippet: promptMetadata.promptSnippet,
-    promptGuidelines: [
-      ...promptMetadata.promptGuidelines,
-      ...imageMode === "auto" ? ["Image-capable Pi models receive prepared images directly. For standalone images, image=none skips local analysis; other modes use ReadSeek when native vision is unavailable."] : []
-    ],
-    parameters: Type2.Object({
-      path: filePathParam(),
-      offset: optionalIntOrString("One-based starting line"),
-      limit: optionalIntOrString("Maximum lines to return"),
-      symbol: Type2.Optional(Type2.String({ description: "Symbol name to read" })),
-      bundle: Type2.Optional(Type2.Literal("local", {
-        description: "Include related symbols from the same file; requires symbol"
-      })),
-      ...imageMode === "off" ? {} : {
-        image: Type2.Optional(Type2.Union(imageModes.map((mode) => Type2.Literal(mode)), {
-          description: `Standalone image mode: ${imageModes.join(", ")}. Required for standalone images.${imageMode === "auto" ? " For standalone images, none skips local analysis." : ""}`
-        }))
-      }
-    }),
-    async execute(toolCallId, params, signal, onUpdate, ctx) {
-      return executeRead({
-        toolCallId,
-        params,
-        signal,
-        onUpdate,
-        cwd: ctx.cwd,
-        onSuccessfulRead: options.onSuccessfulRead,
-        modelSupportsImages: ctx.model?.input.includes("image") ?? false
-      });
-    },
-    renderCall(args, theme, ...rest) {
-      const context = rest[0] ?? {};
-      const cwd = context.cwd ?? process.cwd();
-      const { path: filePath, suffix } = formatReadCallText(args);
-      const rangeSuffix = typeof args?.offset === "number" && typeof args?.limit === "number" && args.offset > 0 && args.limit > 0 ? `:${args.offset}-${args.offset + args.limit - 1}` : "";
-      let text = renderToolLabel(theme, "read");
-      if (filePath) {
-        text += ` ${linkToolPath(theme.fg("accent", `${filePath}${rangeSuffix}`), filePath, cwd)}`;
-      } else {
-        text += ` ${theme.fg("toolOutput", "...")}`;
-      }
-      if (!rangeSuffix && suffix)
-        text += ` ${theme.fg("dim", suffix)}`;
-      return new Text2(clampLineToWidth(text, context.width), 0, 0);
-    },
-    renderResult(result, options2, theme, ...rest) {
-      const { isPartial, isError, expanded, width, context } = resolveRenderResultContext(options2, rest, resolveReadSeekToolDisplayMode("read") === "expanded");
-      if (isPartial)
-        return renderPendingResult("pending read", width, theme);
-      const content = result.content?.[0];
-      const textContent = content?.type === "text" ? content.text : "";
-      if (isError || result.isError) {
-        const firstLine = textContent.split(`
-`)[0] || "Error";
-        const errorText = expanded ? textContent || firstLine : firstLine;
-        return new Text2(clampLinesToWidth([summaryLine(errorText, { theme, style: "error" })], width).join(`
-`), 0, 0);
-      }
-      const readSeekValue = result.details?.readSeekValue;
-      if (!readSeekValue) {
-        const lines = textContent.split(`
-`).filter(Boolean).length;
-        let text2 = summaryLine(`loaded ${lines} ${lines === 1 ? "line" : "lines"}`, {
-          hidden: !!textContent && !expanded,
-          theme,
-          style: "success"
-        });
-        if (expanded && textContent) {
-          text2 += `
-${textContent}`;
-        }
-        return new Text2(clampLinesToWidth(text2.split(`
-`), width).join(`
-`), 0, 0);
-      }
-      const info = formatReadResultText({ range: readSeekValue.range, truncation: readSeekValue.truncation, symbol: readSeekValue.symbol, map: readSeekValue.map, warnings: readSeekValue.warnings });
-      const visibleLines = info.truncated && readSeekValue.truncation ? readSeekValue.truncation.outputLines : readSeekValue.range.endLine - readSeekValue.range.startLine + 1;
-      const loadedWord = visibleLines === 1 ? "line" : "lines";
-      const summaryParts = [info.truncated ? `loaded ${visibleLines} of ${readSeekValue.truncation?.totalLines ?? readSeekValue.range.totalLines} ${loadedWord} (truncated)` : `loaded ${visibleLines} ${loadedWord}`];
-      if (info.symbolBadge)
-        summaryParts.push(info.symbolBadge);
-      for (const badge of info.badges)
-        summaryParts.push(badge);
-      const summary = summaryParts.join(" • ");
-      let text = summaryLine(summary, { hidden: !!textContent && !expanded, theme, style: "success" });
-      if (expanded && textContent) {
-        const anchors = new Set(readSeekValue.lines?.map((line) => line.anchor) ?? []);
-        for (const item of readSeekValue.bundle?.localSupport ?? []) {
-          for (const anchor of item.lineAnchors)
-            anchors.add(anchor);
-        }
-        const sourcePath = readSeekValue.path ?? context.args?.path ?? "";
-        text += `
-` + renderReadSourceForDisplayCached(content, textContent, sourcePath, anchors, width, theme);
-      }
-      return new Text2(clampLinesToWidth(text.split(`
-`), width).join(`
-`), 0, 0);
-    }
-  });
-  return tool;
-}
-
-// src/edit.ts
-import { readFile as fsReadFile2 } from "node:fs/promises";
-import { createPatch } from "diff";
-import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
-import { Type as Type3 } from "@sinclair/typebox";
-import { Text as Text4 } from "@earendil-works/pi-tui";
-
-// src/edit-render-helpers.ts
-var VARIANT_KEYS = ["set_line", "replace_lines", "insert_after", "replace"];
-function countEditTypes(edits) {
-  const counts = {
-    set_line: 0,
-    replace_lines: 0,
-    insert_after: 0,
-    replace: 0,
-    total: 0
-  };
-  if (!edits)
-    return counts;
-  for (const edit of edits) {
-    counts.total++;
-    if (edit && typeof edit === "object") {
-      for (const key of VARIANT_KEYS) {
-        if (key in edit) {
-          counts[key]++;
-          break;
-        }
-      }
-    }
-  }
-  return counts;
-}
-function parseDiffStats(diff) {
-  if (!diff)
-    return { added: 0, removed: 0 };
-  let added = 0;
-  let removed = 0;
-  for (const line of diff.split(`
-`)) {
-    if (line.startsWith("+++") || line.startsWith("---"))
-      continue;
-    if (line.startsWith("+"))
-      added++;
-    else if (line.startsWith("-"))
-      removed++;
-  }
-  return { added, removed };
-}
-function formatEditCallText(args, argsComplete) {
-  const rawPath = typeof args?.path === "string" ? args.path : null;
-  if (!argsComplete) {
-    return { path: rawPath, suffix: undefined };
-  }
-  const edits = args?.edits;
-  if (!Array.isArray(edits) || edits.length === 0) {
-    return { path: rawPath, suffix: undefined };
-  }
-  const counts = countEditTypes(edits);
-  const parts = [];
-  for (const key of VARIANT_KEYS) {
-    if (counts[key] > 0) {
-      parts.push(`${counts[key]} ${key}`);
-    }
-  }
-  const word = counts.total === 1 ? "edit" : "edits";
-  const suffix = `${counts.total} ${word} (${parts.join(", ")})`;
-  return { path: rawPath, suffix };
-}
-function formatEditResultText(input) {
-  const { isError, diff, warnings, noopEdits, errorText } = input;
-  const isNoOp = isError && (Array.isArray(noopEdits) && noopEdits.length > 0 || errorText.includes("No changes made"));
-  const stats = parseDiffStats(diff);
-  const hasDiffStats = stats.added > 0 || stats.removed > 0;
-  const diffStats = hasDiffStats ? `+${stats.added} / -${stats.removed}` : undefined;
-  let warningsBadge;
-  if (warnings.length === 1) {
-    warningsBadge = "⚠ 1 warning";
-  } else if (warnings.length > 1) {
-    warningsBadge = `⚠ ${warnings.length} warnings`;
-  }
-  const showErrorText = isError ? errorText : undefined;
-  let semanticBadge;
-  if (!isError && !isNoOp && input.semanticClassification) {
-    switch (input.semanticClassification) {
-      case "whitespace-only":
-        semanticBadge = "ws-only";
-        break;
-      case "semantic":
-        semanticBadge = "✓ semantic";
-        break;
-      case "mixed":
-        semanticBadge = "mixed";
-        break;
-    }
-  }
-  return {
-    diffStats,
-    noOp: isNoOp,
-    warningsBadge,
-    errorText: showErrorText,
-    semanticBadge
-  };
-}
-
-// src/edit-output.ts
-var EDIT_OPERATION_NAMES = ["set_line", "replace_lines", "insert_after", "replace"];
-function hasNewText(value) {
-  return typeof value === "object" && value !== null && typeof value.new_text === "string";
-}
-function getVisibleDiffStats(diff) {
-  const stats = parseDiffStats(diff);
-  if (stats.added > 0 || stats.removed > 0)
-    return stats;
-  if (!diff.includes("→"))
-    return stats;
-  if (diff.includes("→ [deleted]"))
-    return { added: 0, removed: 1 };
-  return { added: 1, removed: 1 };
-}
-function buildVisibleSummary(displayPath, diff, edits) {
-  let stats = getVisibleDiffStats(diff);
-  const counts = countEditTypes(edits);
-  const editCount = counts.total || 1;
-  if (counts.total > 0 && counts.insert_after === counts.total && stats.removed > 0 && stats.added === stats.removed + counts.insert_after) {
-    stats = { added: counts.insert_after, removed: 0 };
-  }
-  const changeWord = editCount === 1 ? "change" : "changes";
-  const changedLineCount = Math.max(stats.added, stats.removed);
-  const lineWord = changedLineCount === 1 ? "line" : "lines";
-  return `Edited ${displayPath} (${editCount} ${changeWord}, +${stats.added} -${stats.removed} ${lineWord})`;
-}
-function extractNewTextValues(edits) {
-  const values = [];
-  for (const edit of edits ?? []) {
-    if (!edit || typeof edit !== "object")
-      continue;
-    const operations = edit;
-    for (const operationName of EDIT_OPERATION_NAMES) {
-      const operation = operations[operationName];
-      if (hasNewText(operation))
-        values.push(operation.new_text);
-    }
-  }
-  return values;
-}
-function formatWhitespaceOnlyWarning(semanticSummary, edits) {
-  if (semanticSummary?.classification !== "whitespace-only")
-    return;
-  if (!extractNewTextValues(edits).some((text) => /\S/.test(text)))
-    return;
-  return "⚠ Edit classified as whitespace-only — if you intended a behavior change, re-read to verify.";
-}
-function formatReplaceHint(edits, noopEdits) {
-  if ((noopEdits ?? []).length > 0)
-    return;
-  const counts = countEditTypes(edits);
-  if (counts.replace === 0)
-    return;
-  if (counts.replace !== counts.total)
-    return;
-  return "[info: this edit used replace (unverified). For safer future edits, prefer set_line/replace_lines with an anchor from readSeek_read/readSeek_grep/readSeek_search.]";
-}
-function buildEditOutput(input) {
-  const summary = `Updated ${input.displayPath}`;
-  const visibleSummary = buildVisibleSummary(input.displayPath, input.diff, input.edits);
-  const semanticWarning = formatWhitespaceOnlyWarning(input.semanticSummary, input.edits);
-  const warningText = input.warnings.length ? `
-
-Warnings:
-${input.warnings.join(`
-`)}` : "";
-  const replaceHint = formatReplaceHint(input.edits, input.noopEdits);
-  let text = visibleSummary;
-  if (semanticWarning)
-    text += `
-${semanticWarning}`;
-  text += warningText;
-  if (replaceHint)
-    text += `
-${replaceHint}`;
-  return {
-    text,
-    patch: input.patch ?? "",
-    readSeekValue: buildReadSeekEditResult({
-      path: input.path,
-      summary,
-      diff: input.diff,
-      ...input.diffData ? { diffData: input.diffData } : {},
-      firstChangedLine: input.firstChangedLine,
-      warnings: input.warnings,
-      noopEdits: input.noopEdits,
-      ...input.semanticSummary ? { semanticSummary: input.semanticSummary } : {}
-    })
-  };
-}
-
-// src/edit-classify.ts
-import * as Diff2 from "diff";
-function classifyEdit(oldContent, newContent) {
-  if (oldContent === newContent) {
-    return { classification: "no-op" };
-  }
-  const oldLines = oldContent.split(`
-`);
-  const newLines = newContent.split(`
-`);
-  if (oldLines.length === newLines.length) {
-    let hasWhitespaceChange2 = false;
-    let hasSemanticChange2 = false;
-    for (let i = 0;i < oldLines.length; i++) {
-      if (oldLines[i] === newLines[i])
-        continue;
-      if (oldLines[i].trim() === newLines[i].trim()) {
-        hasWhitespaceChange2 = true;
-      } else {
-        hasSemanticChange2 = true;
-      }
-    }
-    if (hasSemanticChange2 && hasWhitespaceChange2)
-      return { classification: "mixed" };
-    if (hasWhitespaceChange2)
-      return { classification: "whitespace-only" };
-    return { classification: "semantic" };
-  }
-  const parts = Diff2.diffLines(oldContent, newContent);
-  let hasWhitespaceChange = false;
-  let hasSemanticChange = false;
-  for (const part of parts) {
-    if (!part.added && !part.removed)
-      continue;
-    const lines = part.value.split(`
-`);
-    if (lines[lines.length - 1] === "")
-      lines.pop();
-    for (const line of lines) {
-      if (line.trim() === "") {
-        hasWhitespaceChange = true;
-      } else {
-        hasSemanticChange = true;
-      }
-    }
-  }
-  if (hasSemanticChange && hasWhitespaceChange)
-    return { classification: "mixed" };
-  if (hasWhitespaceChange)
-    return { classification: "whitespace-only" };
-  return { classification: "semantic" };
-}
-
-// src/edit-syntax-validate.ts
-function dedupeSortLines(diagnostics) {
-  const seen = new Set;
-  const out = [];
-  for (const diagnostic of diagnostics) {
-    const key = diagnostic.start_line === diagnostic.end_line ? String(diagnostic.start_line) : `${diagnostic.start_line}-${diagnostic.end_line}`;
-    if (!seen.has(key)) {
-      seen.add(key);
-      out.push({ key, start: diagnostic.start_line });
-    }
-  }
-  out.sort((a, b) => a.start - b.start);
-  return out.map((o) => o.key);
-}
-var EMPTY = { errorCount: 0, missingCount: 0, diagnostics: [] };
-async function validateSyntaxRegression(input, options = {}) {
-  let before;
-  let after;
-  try {
-    before = input.before === undefined ? EMPTY : await readSeekCheck(input.filePath, input.before, { signal: options.signal });
-    after = await readSeekCheck(input.filePath, input.after, { signal: options.signal });
-  } catch {
-    return null;
-  }
-  const newErrorCount = Math.max(0, after.errorCount - before.errorCount);
-  const newMissingCount = Math.max(0, after.missingCount - before.missingCount);
-  if (newErrorCount === 0 && newMissingCount === 0)
-    return null;
-  return {
-    errorLines: dedupeSortLines(after.diagnostics),
-    newErrorCount,
-    newMissingCount
-  };
-}
-
-// src/syntax-validate-mode.ts
-var DEFAULT = "warn";
-function resolveSyntaxValidateMode(opts) {
-  return opts.syntaxValidate ?? resolveReadSeekSyntaxValidation() ?? DEFAULT;
+// src/syntax-validate-mode.ts
+var DEFAULT = "warn";
+function resolveSyntaxValidateMode(opts) {
+  return opts.syntaxValidate ?? resolveReadSeekSyntaxValidation() ?? DEFAULT;
 }
 
 // src/diff-data.ts
@@ -4251,66 +2646,204 @@ function buildInlineSpans(removeText, addText) {
     return;
   return { removeSpans, addSpans };
 }
-function buildInlineDiffs(entries) {
-  const inlineDiffs = [];
-  let remainingPairs = MAX_INLINE_DIFF_PAIRS;
-  for (let index = 0;index < entries.length; ) {
-    if (entries[index]?.kind !== "remove") {
-      index++;
-      continue;
-    }
-    const removeStart = index;
-    while (entries[index]?.kind === "remove")
-      index++;
-    const addStart = index;
-    while (entries[index]?.kind === "add")
-      index++;
-    const removeCount = addStart - removeStart;
-    const addCount = index - addStart;
-    if (removeCount === 0 || addCount === 0 || removeCount !== addCount)
-      continue;
-    for (let offset = 0;offset < removeCount; offset++) {
-      if (remainingPairs <= 0)
-        break;
-      remainingPairs--;
-      const removeIndex = removeStart + offset;
-      const addIndex = addStart + offset;
-      const removeEntry = entries[removeIndex];
-      const addEntry = entries[addIndex];
-      if (removeEntry?.kind !== "remove" || addEntry?.kind !== "add")
-        continue;
-      const spans = buildInlineSpans(removeEntry.text, addEntry.text);
-      if (!spans)
-        continue;
-      inlineDiffs.push({
-        removeLineIndex: removeIndex,
-        addLineIndex: addIndex,
-        removeSpans: spans.removeSpans,
-        addSpans: spans.addSpans
-      });
+function buildInlineDiffs(entries) {
+  const inlineDiffs = [];
+  let remainingPairs = MAX_INLINE_DIFF_PAIRS;
+  for (let index = 0;index < entries.length; ) {
+    if (entries[index]?.kind !== "remove") {
+      index++;
+      continue;
+    }
+    const removeStart = index;
+    while (entries[index]?.kind === "remove")
+      index++;
+    const addStart = index;
+    while (entries[index]?.kind === "add")
+      index++;
+    const removeCount = addStart - removeStart;
+    const addCount = index - addStart;
+    if (removeCount === 0 || addCount === 0 || removeCount !== addCount)
+      continue;
+    for (let offset = 0;offset < removeCount; offset++) {
+      if (remainingPairs <= 0)
+        break;
+      remainingPairs--;
+      const removeIndex = removeStart + offset;
+      const addIndex = addStart + offset;
+      const removeEntry = entries[removeIndex];
+      const addEntry = entries[addIndex];
+      if (removeEntry?.kind !== "remove" || addEntry?.kind !== "add")
+        continue;
+      const spans = buildInlineSpans(removeEntry.text, addEntry.text);
+      if (!spans)
+        continue;
+      inlineDiffs.push({
+        removeLineIndex: removeIndex,
+        addLineIndex: addIndex,
+        removeSpans: spans.removeSpans,
+        addSpans: spans.addSpans
+      });
+    }
+  }
+  return inlineDiffs.length ? inlineDiffs : undefined;
+}
+function finalizeDiffData(path3, entries, blockRanges) {
+  const language = inferLanguage(path3);
+  const inlineDiffs = buildInlineDiffs(entries);
+  return {
+    version: 1,
+    entries,
+    stats: buildStats(entries),
+    ...language ? { language } : {},
+    ...blockRanges?.length ? { blockRanges: [...blockRanges] } : {},
+    ...inlineDiffs ? { inlineDiffs } : {}
+  };
+}
+function buildDiffData(input) {
+  const entries = parseCompactDiffEntries(input.diff, input.oldContent, input.newContent) ?? parseFullDiffEntries(input.diff);
+  return finalizeDiffData(input.path, entries, input.blockRanges);
+}
+
+// src/tui-render-utils.ts
+import { relative } from "node:path";
+import { pathToFileURL } from "node:url";
+import { getCapabilities, hyperlink, Text, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
+var SUMMARY_PREFIX = "↳";
+var EXPAND_HINT = " • Ctrl+O to expand";
+function renderToolLabel(theme, label) {
+  const boldFn = typeof theme.bold === "function" ? theme.bold.bind(theme) : (text) => text;
+  return theme.fg("toolTitle", boldFn(label));
+}
+function linkToolPath(styledText, rawPath, cwd) {
+  try {
+    if (!getCapabilities().hyperlinks)
+      return styledText;
+    const absolutePath = resolveToCwd(rawPath, cwd);
+    return hyperlink(styledText, pathToFileURL(absolutePath).href);
+  } catch {
+    return styledText;
+  }
+}
+function linkedPathLine(theme, rawPath, displayPath, cwd, suffix, width) {
+  const pathWidth = width === undefined ? undefined : Math.max(1, width - 2 - visibleWidth(suffix));
+  const visiblePath = pathWidth === undefined ? displayPath : truncateToWidth(displayPath, pathWidth);
+  const linkedPath = linkToolPath(theme.fg("dim", visiblePath), rawPath, cwd);
+  return `  ${linkedPath}${theme.fg("dim", suffix)}`;
+}
+function appendExpandHint(text, hidden) {
+  return hidden ? `${text}${EXPAND_HINT}` : text;
+}
+function summaryLine(summary, options = {}) {
+  const prefix = options.theme ? options.theme.fg(options.style ?? "dim", SUMMARY_PREFIX) : SUMMARY_PREFIX;
+  return appendExpandHint(`${prefix} ${summary}`, !!options.hidden);
+}
+function isRendererExpanded(options, context, defaultExpanded = false) {
+  return context?.expanded ?? options?.expanded ?? defaultExpanded;
+}
+function resolveRenderResultContext(options, rest, defaultExpanded = false) {
+  const context = rest[0] ?? options ?? {};
+  return {
+    isPartial: context.isPartial ?? options?.isPartial ?? false,
+    isError: context.isError ?? false,
+    expanded: isRendererExpanded(options, context, defaultExpanded),
+    width: context.width ?? options?.width,
+    cwd: context.cwd ?? process.cwd(),
+    context
+  };
+}
+function normalizeWidth(width, fallback = 80) {
+  return typeof width === "number" && Number.isFinite(width) && width > 0 ? Math.floor(width) : fallback;
+}
+function clampLineToWidth(line, width) {
+  if (width === undefined || width === null)
+    return line;
+  const normalized = normalizeWidth(width);
+  return visibleWidth(line) <= normalized ? line : truncateToWidth(line, normalized);
+}
+function clampLinesToWidth(lines, width) {
+  if (width === undefined || width === null)
+    return lines;
+  return lines.map((line) => clampLineToWidth(line, width));
+}
+function wrapWithHangingIndent(prefix, content, width, options = {}) {
+  const tint = options.tint ?? ((text) => text);
+  if (width === undefined || width === null)
+    return [tint(prefix + content)];
+  const normalized = normalizeWidth(width);
+  const combined = prefix + content;
+  if (visibleWidth(combined) <= normalized)
+    return [tint(combined)];
+  const prefixWidth = visibleWidth(prefix);
+  const contentWidth = Math.max(1, normalized - prefixWidth);
+  const wrapped = wrapTextWithAnsi(content, contentWidth);
+  if (wrapped.length === 0)
+    return [tint(clampLineToWidth(prefix, normalized))];
+  const indent = " ".repeat(prefixWidth);
+  return wrapped.map((line, index) => tint(clampLineToWidth(index === 0 ? prefix + line : indent + line, normalized)));
+}
+var wrappedHashlinesCache = new WeakMap;
+function renderPendingResult(pendingLabel, width, theme) {
+  return new Text(clampLinesToWidth([summaryLine(pendingLabel, { theme, style: "muted" })], width).join(`
+`), 0, 0);
+}
+function renderErrorResult(textContent, options) {
+  const firstLine = textContent.split(`
+`)[0] || (options.fallback ?? "Error");
+  const body = options.expanded && textContent ? textContent : firstLine;
+  return new Text(clampLinesToWidth(summaryLine(body, { theme: options.theme, style: "error" }).split(`
+`), options.width).join(`
+`), 0, 0);
+}
+function renderReadSeekSearchCall(args, theme, rest, opts) {
+  const context = rest[0] ?? {};
+  let text = `${renderToolLabel(theme, opts.label)} ${theme.fg("accent", opts.accent)}`;
+  text += theme.fg("dim", ` in ${args.path ?? "."}`);
+  const language = args.language ?? args.lang;
+  if (language)
+    text += theme.fg("dim", ` (${language})`);
+  const flags = opts.flags.filter(Boolean);
+  if (flags.length > 0)
+    text += theme.fg("dim", ` [${flags.join(",")}]`);
+  return new Text(clampLineToWidth(text, context.width), 0, 0);
+}
+function renderAnchoredFilesResult(result, options, theme, rest, labels) {
+  const { isPartial, isError, expanded, cwd, width } = resolveRenderResultContext(options, rest);
+  if (isPartial)
+    return renderPendingResult(labels.pendingLabel, width, theme);
+  const content = result.content?.[0];
+  const textContent = content?.type === "text" ? content.text : "";
+  if (isError || result.isError)
+    return renderErrorResult(textContent, { expanded, width, theme });
+  const readSeekValue = result.details?.readSeekValue;
+  const files = readSeekValue?.files ?? [];
+  if (files.length === 0)
+    return new Text(summaryLine(labels.emptyLabel, { theme, style: "dim" }), 0, 0);
+  const fileCount = files.length;
+  const total = files.reduce((sum, f) => sum + f.lines.length, 0);
+  const unitWord = total === 1 ? labels.unitSingular : labels.unitPlural;
+  const fileWord = fileCount === 1 ? "file" : "files";
+  let text = summaryLine(`${total} ${unitWord} in ${fileCount} ${fileWord}`, {
+    hidden: !expanded,
+    theme,
+    style: "success"
+  });
+  if (expanded) {
+    for (const file of files.slice(0, 20)) {
+      const display = relative(cwd, file.path) || file.path;
+      text += `
+${linkedPathLine(theme, file.path, display, cwd, ` (${file.lines.length})`, width)}`;
     }
+    if (files.length > 20)
+      text += `
+` + theme.fg("muted", `  … and ${files.length - 20} more files`);
   }
-  return inlineDiffs.length ? inlineDiffs : undefined;
-}
-function finalizeDiffData(path3, entries, blockRanges) {
-  const language = inferLanguage(path3);
-  const inlineDiffs = buildInlineDiffs(entries);
-  return {
-    version: 1,
-    entries,
-    stats: buildStats(entries),
-    ...language ? { language } : {},
-    ...blockRanges?.length ? { blockRanges: [...blockRanges] } : {},
-    ...inlineDiffs ? { inlineDiffs } : {}
-  };
-}
-function buildDiffData(input) {
-  const entries = parseCompactDiffEntries(input.diff, input.oldContent, input.newContent) ?? parseFullDiffEntries(input.diff);
-  return finalizeDiffData(input.path, entries, input.blockRanges);
+  return new Text(clampLinesToWidth(text.split(`
+`), width).join(`
+`), 0, 0);
 }
 
 // src/tui-diff-component.ts
-import { Text as Text3, visibleWidth as visibleWidth3 } from "@earendil-works/pi-tui";
+import { Text as Text2, visibleWidth as visibleWidth3 } from "@earendil-works/pi-tui";
 
 // src/tui-diff-renderer.ts
 import { visibleWidth as visibleWidth2 } from "@earendil-works/pi-tui";
@@ -4478,50 +3011,63 @@ function upsertDiffComponent(lastComponent, options) {
   return component;
 }
 function upsertTextComponent(lastComponent, text) {
-  const component = lastComponent && !(lastComponent instanceof DiffPreviewComponent) ? lastComponent : new Text3("", 0, 0);
+  const component = lastComponent && !(lastComponent instanceof DiffPreviewComponent) ? lastComponent : new Text2("", 0, 0);
   component.setText(text);
   return component;
 }
 
+// src/register-tool.ts
+import { Type } from "@sinclair/typebox";
+function optionalIntOrString(description) {
+  return Type.Optional(Type.Union([Type.Number({ description }), Type.String({ description })]));
+}
+function filePathParam() {
+  return Type.String({ description: PARAM_DESCRIPTIONS.path });
+}
+function registerReadSeekTool(pi, tool) {
+  pi.registerTool(tool);
+  return tool;
+}
+
 // src/edit.ts
-var hashlineEditItemSchema = Type3.Object({
-  set_line: Type3.Optional(Type3.Object({
-    anchor: Type3.String({ description: "Fresh LINE:HASH anchor for the line to replace" }),
-    new_text: Type3.String({ description: "Replacement text; use an empty string to delete the line" })
-  }, { additionalProperties: false, description: 'Replace one line: {"set_line":{"anchor":"LINE:HASH","new_text":"..."}}' })),
-  replace_lines: Type3.Optional(Type3.Object({
-    start_anchor: Type3.String({ description: "Fresh LINE:HASH anchor for the first line in the range" }),
-    end_anchor: Type3.String({ description: "Fresh LINE:HASH anchor for the last line in the range" }),
-    new_text: Type3.String({ description: "Replacement text; use an empty string to delete the range" })
-  }, { additionalProperties: false, description: 'Replace a range: {"replace_lines":{"start_anchor":"LINE:HASH","end_anchor":"LINE:HASH","new_text":"..."}}' })),
-  insert_after: Type3.Optional(Type3.Object({
-    anchor: Type3.String({ description: "Fresh LINE:HASH anchor for the line after which to insert" }),
-    new_text: Type3.String({ description: "Text to insert after the anchored line" })
-  }, { additionalProperties: false, description: 'Insert text: {"insert_after":{"anchor":"LINE:HASH","new_text":"..."}}' })),
-  replace: Type3.Optional(Type3.Object({
-    old_text: Type3.String({ description: "Exact text to find" }),
-    new_text: Type3.String({ description: "Replacement text" }),
-    all: Type3.Optional(Type3.Boolean({ description: "Replace every exact match" }))
-  }, { additionalProperties: false, description: 'Replace text: {"replace":{"old_text":"...","new_text":"..."}}' })),
-  replace_symbol: Type3.Optional(Type3.Object({
-    symbol: Type3.String({ description: "Mapped symbol name" }),
-    new_body: Type3.String({ description: "Complete replacement body for the symbol" })
-  }, { additionalProperties: false, description: 'Replace a symbol: {"replace_symbol":{"symbol":"name","new_body":"..."}}' }))
+var hashlineEditItemSchema = Type2.Object({
+  set_line: Type2.Optional(Type2.Object({
+    anchor: Type2.String({ description: PARAM_DESCRIPTIONS.anchor }),
+    new_text: Type2.String({ description: PARAM_DESCRIPTIONS.newTextLine })
+  }, { additionalProperties: false, description: PARAM_DESCRIPTIONS.setLine })),
+  replace_lines: Type2.Optional(Type2.Object({
+    start_anchor: Type2.String({ description: PARAM_DESCRIPTIONS.startAnchor }),
+    end_anchor: Type2.String({ description: PARAM_DESCRIPTIONS.endAnchor }),
+    new_text: Type2.String({ description: PARAM_DESCRIPTIONS.newTextRange })
+  }, { additionalProperties: false, description: PARAM_DESCRIPTIONS.replaceLines })),
+  insert_after: Type2.Optional(Type2.Object({
+    anchor: Type2.String({ description: PARAM_DESCRIPTIONS.insertAnchor }),
+    new_text: Type2.String({ description: PARAM_DESCRIPTIONS.newTextInsert })
+  }, { additionalProperties: false, description: PARAM_DESCRIPTIONS.insertAfter })),
+  replace: Type2.Optional(Type2.Object({
+    old_text: Type2.String({ description: PARAM_DESCRIPTIONS.oldText }),
+    new_text: Type2.String({ description: PARAM_DESCRIPTIONS.newText }),
+    all: Type2.Optional(Type2.Boolean({ description: PARAM_DESCRIPTIONS.all }))
+  }, { additionalProperties: false, description: PARAM_DESCRIPTIONS.replace })),
+  replace_symbol: Type2.Optional(Type2.Object({
+    symbol: Type2.String({ description: PARAM_DESCRIPTIONS.symbol }),
+    new_body: Type2.String({ description: PARAM_DESCRIPTIONS.newBody })
+  }, { additionalProperties: false, description: PARAM_DESCRIPTIONS.replaceSymbol }))
 }, {
   additionalProperties: false,
   minProperties: 1,
   maxProperties: 1,
-  description: "Exactly one nested edit variant"
+  description: PARAM_DESCRIPTIONS.editVariant
 });
-var hashlineEditSchema = Type3.Object({
+var hashlineEditSchema = Type2.Object({
   path: filePathParam(),
-  language: Type3.Optional(Type3.String({ description: "Language override for symbol replacement" })),
-  edits: Type3.Array(hashlineEditItemSchema, {
+  language: Type2.Optional(Type2.String({ description: PARAM_DESCRIPTIONS.languageSymbol })),
+  edits: Type2.Array(hashlineEditItemSchema, {
     minItems: 1,
-    description: "Use set_line, replace_lines, insert_after, replace_symbol, or replace"
+    description: PARAM_DESCRIPTIONS.edits
   }),
-  postEditVerify: Type3.Optional(Type3.Boolean({
-    description: "Read back and verify persisted content"
+  postEditVerify: Type2.Optional(Type2.Boolean({
+    description: PARAM_DESCRIPTIONS.postEditVerify
   }))
 }, { additionalProperties: false });
 function buildEditError(path3, code, message, hint, errorDetails) {
@@ -4556,7 +3102,7 @@ async function executeEdit(opts) {
     return await withFileMutationQueue(absolutePath, async () => {
       throwIfAborted(signal);
       if (wasReadInSession && !wasReadInSession(absolutePath)) {
-        const hint = `Call readSeek_read(${JSON.stringify(rawPath)}) first, or use readSeek_grep, readSeek_search, or readSeek_write to produce fresh anchors for this file.`;
+        const hint = `Call readSeek_digest(${JSON.stringify(rawPath)}) first, or use readSeek_grep, readSeek_search, or readSeek_write to produce fresh anchors for this file.`;
         return buildEditError(absolutePath, "file-not-read", `You must get fresh anchors for ${absolutePath} before editing it. ${hint}`, hint);
       }
       const edits = parsed.edits ?? [];
@@ -4627,7 +3173,7 @@ async function executeEdit(opts) {
       if (parsed.postEditVerify === true) {
         let verifiedContent;
         try {
-          verifiedContent = await fsReadFile2(absolutePath, "utf-8");
+          verifiedContent = await fsReadFile(absolutePath, "utf-8");
         } catch (err) {
           return buildEditError(absolutePath, "post-edit-verification-read-failed", `Edit write completed but post-edit verification failed: could not read ${path3} after writing.`, undefined, { fsCode: err?.code, fsMessage: err?.message });
         }
@@ -4766,7 +3312,7 @@ ${theme.fg("error", info.errorText)}`;
 `), diffData, theme, expanded: true });
         }
       }
-      return new Text4(clampLinesToWidth(text.split(`
+      return new Text3(clampLinesToWidth(text.split(`
 `), width).join(`
 `), 0, 0);
     }
@@ -4775,22 +3321,34 @@ ${theme.fg("error", info.errorText)}`;
 }
 
 // src/grep.ts
-import { readFile as fsReadFile3, stat as fsStat } from "node:fs/promises";
+import { readFile as fsReadFile2, stat as fsStat } from "node:fs/promises";
 import path3 from "node:path";
 import { createGrepTool } from "@earendil-works/pi-coding-agent";
-import { Type as Type5 } from "@sinclair/typebox";
-import { Text as Text5 } from "@earendil-works/pi-tui";
+import { Type as Type4 } from "@sinclair/typebox";
+import { Text as Text4 } from "@earendil-works/pi-tui";
+
+// src/binary-detect.ts
+function looksLikeBinary(buf) {
+  if (buf.length === 0)
+    return false;
+  if (buf.includes(0))
+    return true;
+  const decoded = buf.toString("utf8");
+  if (!decoded.includes("�"))
+    return false;
+  return !Buffer.from(decoded, "utf8").equals(buf);
+}
 
 // src/grep-output.ts
 import {
-  formatSize as formatSize3,
-  truncateHead as truncateHead3
+  formatSize,
+  truncateHead
 } from "@earendil-works/pi-coding-agent";
 
 // src/grep-budget.ts
-import { DEFAULT_MAX_BYTES as DEFAULT_MAX_BYTES3, DEFAULT_MAX_LINES as DEFAULT_MAX_LINES3 } from "@earendil-works/pi-coding-agent";
-var GREP_OUTPUT_DEFAULT_MAX_LINES = DEFAULT_MAX_LINES3;
-var GREP_OUTPUT_DEFAULT_MAX_BYTES = Math.min(DEFAULT_MAX_BYTES3, 50 * 1024);
+import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES } from "@earendil-works/pi-coding-agent";
+var GREP_OUTPUT_DEFAULT_MAX_LINES = DEFAULT_MAX_LINES;
+var GREP_OUTPUT_DEFAULT_MAX_BYTES = Math.min(DEFAULT_MAX_BYTES, 50 * 1024);
 function resolveDimension(jsonValue, ceiling) {
   if (jsonValue !== undefined)
     return Math.min(jsonValue, ceiling);
@@ -4876,14 +3434,14 @@ ${passthroughLines.join(`
 ${text}`;
   }
   const budget = resolveGrepOutputBudget();
-  const truncated = truncateHead3(text, {
+  const truncated = truncateHead(text, {
     maxLines: budget.maxLines,
     maxBytes: budget.maxBytes
   });
   if (truncated.truncated) {
     text = `${truncated.content}
 
-[Output truncated: showing ${truncated.outputLines} of ${truncated.totalLines} lines (${formatSize3(truncated.outputBytes)} of ${formatSize3(truncated.totalBytes)}). Refine pattern or increase limit.]`;
+[Output truncated: showing ${truncated.outputLines} of ${truncated.totalLines} lines (${formatSize(truncated.outputBytes)} of ${formatSize(truncated.totalBytes)}). Refine pattern or increase limit.]`;
   }
   const readSeekValue = {
     tool: "grep",
@@ -4905,6 +3463,31 @@ ${text}`;
   };
 }
 
+// src/file-map.ts
+import { stat } from "node:fs/promises";
+async function getOrGenerateMap(absPath) {
+  try {
+    const { size } = await stat(absPath);
+    return await readSeekMap(absPath, size);
+  } catch {
+    return null;
+  }
+}
+
+// src/readseek/symbol-tree.ts
+function traverseSymbolTree(symbols, visit) {
+  const result = [];
+  const walk = (nodes, parentName) => {
+    for (const symbol of nodes) {
+      result.push(visit(symbol, parentName));
+      if (symbol.children?.length)
+        walk(symbol.children, symbol.name);
+    }
+  };
+  walk(symbols);
+  return result;
+}
+
 // src/grep-symbol-scope.ts
 function findEnclosingSymbol(map, lineNumber) {
   const candidates = traverseSymbolTree(map.symbols, (symbol, parentName) => ({
@@ -5112,19 +3695,73 @@ function formatGrepResultText(input) {
   };
 }
 
+// src/coerce-obvious-int.ts
+var BASE10_INT_RE = /^-?\d+$/;
+var MIN_SAFE_INTEGER = BigInt(Number.MIN_SAFE_INTEGER);
+var MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
+function formatReceived(value) {
+  if (typeof value === "number" || typeof value === "bigint")
+    return String(value);
+  return JSON.stringify(value) ?? String(value);
+}
+function invalidInteger(value, name) {
+  return {
+    ok: false,
+    message: `Invalid ${name}: expected a safe base-10 integer, received ${formatReceived(value)}.`
+  };
+}
+function coerceObviousBase10Int(value, name) {
+  if (value === undefined || typeof value === "string" && value.trim() === "") {
+    return { ok: true, value: undefined };
+  }
+  if (typeof value === "number") {
+    if (Number.isSafeInteger(value)) {
+      return { ok: true, value };
+    }
+    return invalidInteger(value, name);
+  }
+  if (typeof value === "string" && BASE10_INT_RE.test(value)) {
+    const parsed = BigInt(value);
+    if (parsed >= MIN_SAFE_INTEGER && parsed <= MAX_SAFE_INTEGER) {
+      return { ok: true, value: Number(parsed) };
+    }
+  }
+  return invalidInteger(value, name);
+}
+
+// src/tui-source-render.ts
+import { getLanguageFromPath, highlightCode } from "@earendil-works/pi-coding-agent";
+import { wrapTextWithAnsi as wrapTextWithAnsi2 } from "@earendil-works/pi-tui";
+var GREP_ANCHOR_RE = /^(.*?):(>>|  )(\d+):([0-9a-zA-Z]{1,16})\|(.*)$/;
+var readSourceCache = new WeakMap;
+function renderGrepSourceForDisplay(text, anchors, renderPath = (path3) => path3) {
+  return text.split(`
+`).map((line) => {
+    const match = line.match(GREP_ANCHOR_RE);
+    if (!match)
+      return line;
+    const anchor = `${match[3]}:${match[4]}`;
+    if (!anchors.has(anchor))
+      return line;
+    const separator = match[2] === ">>" ? ":" : "-";
+    return `${renderPath(match[1])}${separator}${match[3]}${separator}${match[5] ?? ""}`;
+  }).join(`
+`);
+}
+
 // src/readseek-params.ts
-import { Type as Type4 } from "@sinclair/typebox";
+import { Type as Type3 } from "@sinclair/typebox";
 function searchPathParam() {
-  return Type4.Optional(Type4.String({ description: PARAM_DESCRIPTIONS.searchPath }));
+  return Type3.Optional(Type3.String({ description: PARAM_DESCRIPTIONS.searchPath }));
 }
 function languageParam() {
-  return Type4.Optional(Type4.String({ description: PARAM_DESCRIPTIONS.language }));
+  return Type3.Optional(Type3.String({ description: PARAM_DESCRIPTIONS.language }));
 }
 function readSeekGitSearchParams() {
   return {
-    cached: Type4.Optional(Type4.Boolean({ description: PARAM_DESCRIPTIONS.cached })),
-    others: Type4.Optional(Type4.Boolean({ description: PARAM_DESCRIPTIONS.others })),
-    ignored: Type4.Optional(Type4.Boolean({ description: PARAM_DESCRIPTIONS.ignored }))
+    cached: Type3.Optional(Type3.Boolean({ description: PARAM_DESCRIPTIONS.cached })),
+    others: Type3.Optional(Type3.Boolean({ description: PARAM_DESCRIPTIONS.others })),
+    ignored: Type3.Optional(Type3.Boolean({ description: PARAM_DESCRIPTIONS.ignored }))
   };
 }
 function validateIgnoredRequiresOthers(tool, params) {
@@ -5136,19 +3773,19 @@ function validateIgnoredRequiresOthers(tool, params) {
 }
 
 // src/grep.ts
-var grepSchema = Type5.Object({
-  pattern: Type5.String({ description: "Regex pattern; set literal for exact text" }),
+var grepSchema = Type4.Object({
+  pattern: Type4.String({ description: PARAM_DESCRIPTIONS.grepPattern }),
   path: searchPathParam(),
-  glob: Type5.Optional(Type5.String({ description: "File-name glob, such as *.ts" })),
-  ignoreCase: Type5.Optional(Type5.Boolean({ description: "Ignore case" })),
-  literal: Type5.Optional(Type5.Boolean({ description: "Treat pattern literally" })),
-  context: optionalIntOrString("Surrounding lines for each match"),
-  limit: optionalIntOrString("Maximum matches to return"),
-  summary: Type5.Optional(Type5.Boolean({ description: "Return per-file counts" })),
-  scope: Type5.Optional(Type5.Literal("symbol", {
-    description: "Group matches by enclosing symbol"
+  glob: Type4.Optional(Type4.String({ description: PARAM_DESCRIPTIONS.glob })),
+  ignoreCase: Type4.Optional(Type4.Boolean({ description: PARAM_DESCRIPTIONS.ignoreCase })),
+  literal: Type4.Optional(Type4.Boolean({ description: PARAM_DESCRIPTIONS.literal })),
+  context: optionalIntOrString(PARAM_DESCRIPTIONS.context),
+  limit: optionalIntOrString(PARAM_DESCRIPTIONS.matchLimit),
+  summary: Type4.Optional(Type4.Boolean({ description: PARAM_DESCRIPTIONS.summary })),
+  scope: Type4.Optional(Type4.Literal("symbol", {
+    description: PARAM_DESCRIPTIONS.grepScope
   })),
-  scopeContext: optionalIntOrString("Context lines within each symbol")
+  scopeContext: optionalIntOrString(PARAM_DESCRIPTIONS.scopeContext)
 });
 var MATCH_LINE_RE = /^(.*?):(\d+): (.*)$/;
 var CONTEXT_LINE_RE = /^(.*?)-(\d+)- (.*)$/;
@@ -5272,7 +3909,7 @@ async function executeGrep(opts) {
   }
   if (!searchPathIsDirectory) {
     try {
-      const buf = await fsReadFile3(searchPath);
+      const buf = await fsReadFile2(searchPath);
       if (looksLikeBinary(buf)) {
         const warning = `[Warning: '${p.path ?? searchPath}' appears to be a binary file — grep skips binary files by default. Use a hex tool or the read tool to inspect it.]`;
         return {
@@ -5298,7 +3935,7 @@ async function executeGrep(opts) {
     if (fileCache.has(absolutePath))
       return fileCache.get(absolutePath);
     try {
-      const rawBuffer = await fsReadFile3(absolutePath);
+      const rawBuffer = await fsReadFile2(absolutePath);
       if (looksLikeBinary(rawBuffer)) {
         fileCache.set(absolutePath, undefined);
         return;
@@ -5545,7 +4182,7 @@ function registerGrepTool(pi, options = {}) {
           text += theme.fg("dim", ` in ${suffix}`);
         }
       }
-      return new Text5(clampLineToWidth(text, context.width), 0, 0);
+      return new Text4(clampLineToWidth(text, context.width), 0, 0);
     },
     renderResult(result, options2, theme, ...rest) {
       const { isPartial, isError, expanded, cwd, width } = resolveRenderResultContext(options2, rest, resolveReadSeekToolDisplayMode("grep") === "expanded");
@@ -5570,7 +4207,7 @@ function registerGrepTool(pi, options = {}) {
         hasBinaryWarning
       });
       if (info.noMatches && !hasBinaryWarning)
-        return new Text5(summaryLine("no matches", { theme, style: "dim" }), 0, 0);
+        return new Text4(summaryLine("no matches", { theme, style: "dim" }), 0, 0);
       const matchCount = readSeekValue?.totalMatches ?? 0;
       const matchWord = matchCount === 1 ? "match" : "matches";
       let text = summaryLine(`${matchCount} ${matchWord} returned`, {
@@ -5585,7 +4222,7 @@ function registerGrepTool(pi, options = {}) {
         text += `
 ` + renderGrepSourceForDisplay(textContent, anchors, (displayPath) => linkToolPath(theme.fg("dim", displayPath), displayPath, cwd));
       }
-      return new Text5(clampLinesToWidth(text.split(`
+      return new Text4(clampLinesToWidth(text.split(`
 `), width).join(`
 `), 0, 0);
     }
@@ -5595,7 +4232,7 @@ function registerGrepTool(pi, options = {}) {
 
 // src/search.ts
 import path4 from "node:path";
-import { Type as Type6 } from "@sinclair/typebox";
+import { Type as Type5 } from "@sinclair/typebox";
 
 // src/stat-search-path.ts
 import { stat as fsStat2 } from "node:fs/promises";
@@ -5762,8 +4399,8 @@ function registerSearchTool(pi, options = {}) {
     description: SEARCH_PROMPT_METADATA.description,
     promptSnippet: SEARCH_PROMPT_METADATA.promptSnippet,
     promptGuidelines: SEARCH_PROMPT_METADATA.promptGuidelines,
-    parameters: Type6.Object({
-      pattern: Type6.String({ description: PARAM_DESCRIPTIONS.pattern }),
+    parameters: Type5.Object({
+      pattern: Type5.String({ description: PARAM_DESCRIPTIONS.pattern }),
       language: languageParam(),
       path: searchPathParam(),
       ...readSeekGitSearchParams()
@@ -5791,7 +4428,7 @@ function registerSearchTool(pi, options = {}) {
 }
 
 // src/refs.ts
-import { Type as Type7 } from "@sinclair/typebox";
+import { Type as Type6 } from "@sinclair/typebox";
 import path5 from "node:path";
 
 // src/refs-output.ts
@@ -5910,13 +4547,13 @@ function registerRefsTool(pi, options = {}) {
     description: REFS_PROMPT_METADATA.description,
     promptSnippet: REFS_PROMPT_METADATA.promptSnippet,
     promptGuidelines: REFS_PROMPT_METADATA.promptGuidelines,
-    parameters: Type7.Object({
-      name: Type7.Optional(Type7.String({ description: PARAM_DESCRIPTIONS.refsName })),
+    parameters: Type6.Object({
+      name: Type6.Optional(Type6.String({ description: PARAM_DESCRIPTIONS.refsName })),
       path: searchPathParam(),
       language: languageParam(),
-      scope: Type7.Optional(Type7.Boolean({ description: PARAM_DESCRIPTIONS.scope })),
-      line: Type7.Optional(Type7.Number({ description: PARAM_DESCRIPTIONS.line })),
-      column: Type7.Optional(Type7.Number({ description: PARAM_DESCRIPTIONS.column })),
+      scope: Type6.Optional(Type6.Boolean({ description: PARAM_DESCRIPTIONS.scope })),
+      line: Type6.Optional(Type6.Number({ description: PARAM_DESCRIPTIONS.line })),
+      column: Type6.Optional(Type6.Number({ description: PARAM_DESCRIPTIONS.column })),
       ...readSeekGitSearchParams()
     }),
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
@@ -5943,20 +4580,20 @@ function registerRefsTool(pi, options = {}) {
 }
 
 // src/rename.ts
-import { Type as Type8 } from "@sinclair/typebox";
+import { Type as Type7 } from "@sinclair/typebox";
 import path6 from "node:path";
-import { Text as Text6 } from "@earendil-works/pi-tui";
+import { Text as Text5 } from "@earendil-works/pi-tui";
 var RENAME_PROMPT_METADATA = defineToolPromptMetadata({
   promptUrl: new URL("../prompts/rename.md", import.meta.url),
   promptSnippet: "Rename a symbol at a source location with verified edits"
 });
-var renameSchema = Type8.Object({
+var renameSchema = Type7.Object({
   path: filePathParam(),
-  line: Type8.Integer({ minimum: 1, description: "One-based cursor line of the symbol to rename" }),
-  column: Type8.Optional(Type8.Integer({ minimum: 1, description: "One-based cursor byte column for disambiguation" })),
-  to: Type8.String({ description: "New symbol name" }),
-  workspace: Type8.Optional(Type8.Boolean({ description: "Rename across the project" })),
-  apply: Type8.Optional(Type8.Boolean({ description: "Apply the verified edits; defaults to true" }))
+  line: Type7.Integer({ minimum: 1, description: PARAM_DESCRIPTIONS.renameLine }),
+  column: Type7.Optional(Type7.Integer({ minimum: 1, description: PARAM_DESCRIPTIONS.column })),
+  to: Type7.String({ description: PARAM_DESCRIPTIONS.to }),
+  workspace: Type7.Optional(Type7.Boolean({ description: PARAM_DESCRIPTIONS.workspace })),
+  apply: Type7.Optional(Type7.Boolean({ description: PARAM_DESCRIPTIONS.applyDefaultTrue }))
 });
 async function executeRename(opts) {
   const { params, signal, cwd, onFileMutated } = opts;
@@ -6046,7 +4683,7 @@ function registerRenameTool(pi, options = {}) {
       text += ` ${linkToolPath(theme.fg("accent", displayPath), displayPath, cwd)}`;
       if (args?.to)
         text += theme.fg("dim", ` → ${args.to}`);
-      return new Text6(clampLineToWidth(text, context.width), 0, 0);
+      return new Text5(clampLineToWidth(text, context.width), 0, 0);
     },
     renderResult(result, options2, theme, ...rest) {
       const { isPartial, isError, expanded, cwd, width } = resolveRenderResultContext(options2, rest);
@@ -6079,7 +4716,7 @@ ${linkedPathLine(theme, file.file, display, cwd, ` (${file.edits.length} edits)`
       }
       const lines = clampLinesToWidth(text.split(`
 `), width);
-      return new Text6(lines.join(`
+      return new Text5(lines.join(`
 `), 0, 0);
     }
   });
@@ -6088,9 +4725,9 @@ ${linkedPathLine(theme, file.file, display, cwd, ` (${file.edits.length} edits)`
 // src/write.ts
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname as dirname2, relative as relative3 } from "node:path";
-import { withFileMutationQueue as withFileMutationQueue2, truncateHead as truncateHead4 } from "@earendil-works/pi-coding-agent";
-import { Text as Text7 } from "@earendil-works/pi-tui";
-import { Type as Type9 } from "@sinclair/typebox";
+import { withFileMutationQueue as withFileMutationQueue2, truncateHead as truncateHead2 } from "@earendil-works/pi-coding-agent";
+import { Text as Text6 } from "@earendil-works/pi-tui";
+import { Type as Type8 } from "@sinclair/typebox";
 
 // src/pending-diff-preview.ts
 import { existsSync as existsSync2, readFileSync as readFileSync3, realpathSync, statSync as statSync3 } from "node:fs";
@@ -6295,7 +4932,7 @@ async function executeWrite(opts) {
   const warnings = [];
   const readSeekWarnings = [];
   if (hasBareCarriageReturn(content)) {
-    const message = "File content contains bare CR (\\r) line endings; readSeek_write refuses to emit anchors that readSeek_read/readSeek_edit would normalize differently.";
+    const message = "File content contains bare CR (\\r) line endings; readSeek_write refuses to emit anchors that readSeek_digest/readSeek_edit would normalize differently.";
     warnings.push(message);
     readSeekWarnings.push(buildReadSeekWarning("bare-cr", message));
     return buildToolErrorResult("write", "bare-cr", `Cannot write ${filePath}
@@ -6336,7 +4973,7 @@ async function executeWrite(opts) {
   }
   const fullText = displayLines.join(`
 `);
-  const truncated = truncateHead4(fullText);
+  const truncated = truncateHead2(fullText);
   let text = truncated.content;
   if (truncated.truncated) {
     if (truncated.truncatedBy === "lines") {
@@ -6386,9 +5023,9 @@ function registerWriteTool(pi, options = {}) {
     description: promptMetadata.description,
     promptSnippet: promptMetadata.promptSnippet,
     promptGuidelines: promptMetadata.promptGuidelines,
-    parameters: Type9.Object({
+    parameters: Type8.Object({
       path: filePathParam(),
-      content: Type9.String({ description: "Complete text file content" })
+      content: Type8.String({ description: PARAM_DESCRIPTIONS.content })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const cwd = ctx?.cwd ?? process.cwd();
@@ -6469,7 +5106,7 @@ function registerWriteTool(pi, options = {}) {
 `);
           lines.push(...formatContentPreviewLines(content, theme));
         }
-        return new Text7(clampLinesToWidth(lines, width).join(`
+        return new Text6(clampLinesToWidth(lines, width).join(`
 `), 0, 0);
       }
       const hasExpandableDiff = !!diffData;
@@ -6478,7 +5115,7 @@ function registerWriteTool(pi, options = {}) {
         return upsertDiffComponent(context.lastComponent, { prefixLines: text.split(`
 `), diffData, theme, expanded: true });
       }
-      return new Text7(clampLinesToWidth(text.split(`
+      return new Text6(clampLinesToWidth(text.split(`
 `), width).join(`
 `), 0, 0);
     }
@@ -6487,7 +5124,7 @@ function registerWriteTool(pi, options = {}) {
 }
 
 // src/def.ts
-import { Type as Type10 } from "@sinclair/typebox";
+import { Type as Type9 } from "@sinclair/typebox";
 import path7 from "node:path";
 var DEF_PROMPT_METADATA = defineToolPromptMetadata({
   promptUrl: new URL("../prompts/def.md", import.meta.url),
@@ -6563,8 +5200,8 @@ function registerDefTool(pi, options = {}) {
     description: DEF_PROMPT_METADATA.description,
     promptSnippet: DEF_PROMPT_METADATA.promptSnippet,
     promptGuidelines: DEF_PROMPT_METADATA.promptGuidelines,
-    parameters: Type10.Object({
-      name: Type10.String({ description: PARAM_DESCRIPTIONS.name }),
+    parameters: Type9.Object({
+      name: Type9.String({ description: PARAM_DESCRIPTIONS.name }),
       path: searchPathParam(),
       language: languageParam(),
       ...readSeekGitSearchParams()
@@ -6591,33 +5228,29 @@ function registerDefTool(pi, options = {}) {
 }
 
 // src/digest.ts
-import { Text as Text8 } from "@earendil-works/pi-tui";
-import { Type as Type11 } from "@sinclair/typebox";
+import { Text as Text7 } from "@earendil-works/pi-tui";
+import { Type as Type10 } from "@sinclair/typebox";
 var DIGEST_FACETS2 = DIGEST_FACETS;
-var DIGEST_PROMPT_METADATA = defineToolPromptMetadata({
-  promptUrl: new URL("../prompts/digest.md", import.meta.url),
-  promptSnippet: "Digest source facets as a native CLI envelope"
-});
-var facetSchema = Type11.Union(DIGEST_FACETS2.map((facet) => Type11.Literal(facet)));
-var digestSchema = Type11.Object({
+var facetSchema = Type10.Union(DIGEST_FACETS2.map((facet) => Type10.Literal(facet)));
+var digestSchema = Type10.Object({
   path: filePathParam(),
-  select: Type11.Optional(Type11.Union([
+  select: Type10.Optional(Type10.Union([
     facetSchema,
-    Type11.Array(facetSchema, { minItems: 1 }),
-    Type11.String({
+    Type10.Array(facetSchema, { minItems: 1 }),
+    Type10.String({
       description: PARAM_DESCRIPTIONS.selectComma
     })
   ], {
     description: PARAM_DESCRIPTIONS.select
   })),
-  at: Type11.Optional(Type11.String({
+  at: Type10.Optional(Type10.String({
     description: PARAM_DESCRIPTIONS.at
   })),
   end: optionalIntOrString(PARAM_DESCRIPTIONS.end),
   limit: optionalIntOrString(PARAM_DESCRIPTIONS.limit),
-  language: Type11.Optional(Type11.String({ description: PARAM_DESCRIPTIONS.languageOverride })),
-  visionMode: Type11.Optional(Type11.Union(VISION_MODES.map((mode) => Type11.Literal(mode)), { description: PARAM_DESCRIPTIONS.visionModeDigest })),
-  visionLevel: Type11.Optional(Type11.Union(VISION_LEVELS.map((level) => Type11.Literal(level)), { description: PARAM_DESCRIPTIONS.visionLevel }))
+  language: Type10.Optional(Type10.String({ description: PARAM_DESCRIPTIONS.languageOverride })),
+  visionMode: Type10.Optional(Type10.Union(VISION_MODES.map((mode) => Type10.Literal(mode)), { description: PARAM_DESCRIPTIONS.visionModeDigest })),
+  visionLevel: Type10.Optional(Type10.Union(VISION_LEVELS.map((level) => Type10.Literal(level)), { description: PARAM_DESCRIPTIONS.visionLevel }))
 });
 function hasDigestAnchors(value) {
   if (!value || typeof value !== "object")
@@ -6743,12 +5376,19 @@ async function executeDigest(opts) {
   }
 }
 function registerDigestTool(pi, options = {}) {
+  const promptMetadata = defineToolPromptMetadata({
+    promptUrl: new URL("../prompts/digest.md", import.meta.url),
+    promptSnippet: "Digest source facets as a native CLI envelope",
+    registeredName: options.name ?? "readSeek_digest",
+    toolAliases: options.toolAliases
+  });
   return registerReadSeekTool(pi, {
-    name: "readSeek_digest",
+    name: options.name ?? "readSeek_digest",
     label: "Digest",
-    description: DIGEST_PROMPT_METADATA.description,
-    promptSnippet: DIGEST_PROMPT_METADATA.promptSnippet,
-    promptGuidelines: DIGEST_PROMPT_METADATA.promptGuidelines,
+    description: promptMetadata.description,
+    promptSnippet: promptMetadata.promptSnippet,
+    toolAliases: options.toolAliases,
+    promptGuidelines: promptMetadata.promptGuidelines,
     parameters: digestSchema,
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       return executeDigest({ params, signal, cwd: ctx.cwd, onFileAnchored: options.onFileAnchored });
@@ -6765,7 +5405,7 @@ function registerDigestTool(pi, options = {}) {
       }
       if (typeof args?.at === "string" && args.at)
         text += theme.fg("dim", ` @ ${args.at}`);
-      return new Text8(clampLineToWidth(text, context.width), 0, 0);
+      return new Text7(clampLineToWidth(text, context.width), 0, 0);
     },
     renderResult(result, options2, theme, ...rest) {
       const { isPartial, isError, expanded, width } = resolveRenderResultContext(options2, rest);
@@ -6782,7 +5422,7 @@ function registerDigestTool(pi, options = {}) {
       if (expanded && textContent)
         text += `
 ${textContent}`;
-      return new Text8(clampLinesToWidth(text.split(`
+      return new Text7(clampLinesToWidth(text.split(`
 `), width).join(`
 `), 0, 0);
     }
@@ -6791,12 +5431,12 @@ ${textContent}`;
 
 // src/view.ts
 import {
-  DEFAULT_MAX_BYTES as DEFAULT_MAX_BYTES4,
-  DEFAULT_MAX_LINES as DEFAULT_MAX_LINES4,
-  truncateHead as truncateHead5
+  DEFAULT_MAX_BYTES as DEFAULT_MAX_BYTES2,
+  DEFAULT_MAX_LINES as DEFAULT_MAX_LINES2,
+  truncateHead as truncateHead3
 } from "@earendil-works/pi-coding-agent";
-import { Text as Text9 } from "@earendil-works/pi-tui";
-import { Type as Type12 } from "@sinclair/typebox";
+import { Text as Text8 } from "@earendil-works/pi-tui";
+import { Type as Type11 } from "@sinclair/typebox";
 var NODE_KINDS = DOCUMENT_NODE_KINDS;
 var VIEW_PROMPT_METADATA = defineToolPromptMetadata({
   promptUrl: new URL("../prompts/view.md", import.meta.url),
@@ -6843,9 +5483,9 @@ async function executeView(opts) {
       visionLevel: input.visionLevel,
       signal
     });
-    const truncation = truncateHead5(output, {
-      maxLines: DEFAULT_MAX_LINES4,
-      maxBytes: DEFAULT_MAX_BYTES4
+    const truncation = truncateHead3(output, {
+      maxLines: DEFAULT_MAX_LINES2,
+      maxBytes: DEFAULT_MAX_BYTES2
     });
     const notice = truncation.truncated ? `
 [… document view truncated; narrow it with page, node, kind, or depth]` : "";
@@ -6871,17 +5511,17 @@ function registerViewTool(pi) {
     description: VIEW_PROMPT_METADATA.description,
     promptSnippet: VIEW_PROMPT_METADATA.promptSnippet,
     promptGuidelines: VIEW_PROMPT_METADATA.promptGuidelines,
-    parameters: Type12.Object({
+    parameters: Type11.Object({
       path: filePathParam(),
-      node: Type12.Optional(Type12.String({ description: PARAM_DESCRIPTIONS.node })),
+      node: Type11.Optional(Type11.String({ description: PARAM_DESCRIPTIONS.node })),
       page: optionalIntOrString(PARAM_DESCRIPTIONS.page),
-      kind: Type12.Optional(Type12.Union(NODE_KINDS.map((kind) => Type12.Literal(kind)), {
+      kind: Type11.Optional(Type11.Union(NODE_KINDS.map((kind) => Type11.Literal(kind)), {
         description: PARAM_DESCRIPTIONS.kind
       })),
       depth: optionalIntOrString(PARAM_DESCRIPTIONS.depth),
-      visionMode: Type12.Optional(Type12.Union(VISION_ANALYSIS_MODES.map((mode) => Type12.Literal(mode)), { description: PARAM_DESCRIPTIONS.visionModeView })),
-      visionLevel: Type12.Optional(Type12.Union(VISION_LEVELS.map((level) => Type12.Literal(level)), { description: PARAM_DESCRIPTIONS.visionLevel })),
-      outline: Type12.Optional(Type12.Boolean({ description: PARAM_DESCRIPTIONS.outline }))
+      visionMode: Type11.Optional(Type11.Union(VISION_ANALYSIS_MODES.map((mode) => Type11.Literal(mode)), { description: PARAM_DESCRIPTIONS.visionModeView })),
+      visionLevel: Type11.Optional(Type11.Union(VISION_LEVELS.map((level) => Type11.Literal(level)), { description: PARAM_DESCRIPTIONS.visionLevel })),
+      outline: Type11.Optional(Type11.Boolean({ description: PARAM_DESCRIPTIONS.outline }))
     }),
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       return executeView({ params, signal, cwd: ctx.cwd });
@@ -6891,7 +5531,7 @@ function registerViewTool(pi) {
       const cwd = context.cwd ?? process.cwd();
       const displayPath = typeof args?.path === "string" ? args.path : "?";
       const text = `${theme.fg("toolTitle", theme.bold("view"))} ${linkToolPath(theme.fg("accent", displayPath), displayPath, cwd)}`;
-      return new Text9(clampLineToWidth(text, context.width), 0, 0);
+      return new Text8(clampLineToWidth(text, context.width), 0, 0);
     },
     renderResult(result, options, theme, ...rest) {
       const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
@@ -6911,7 +5551,7 @@ function registerViewTool(pi) {
       if (expanded && textContent)
         text += `
 ${textContent}`;
-      return new Text9(clampLinesToWidth(text.split(`
+      return new Text8(clampLinesToWidth(text.split(`
 `), width).join(`
 `), 0, 0);
     }
@@ -6937,7 +5577,6 @@ class SessionAnchors {
 
 // index.ts
 var READSEEK_TOOL_ENTRIES = [
-  { builtIn: "read", readSeekName: "readSeek_read" },
   { builtIn: "edit", readSeekName: "readSeek_edit" },
   { builtIn: "grep", readSeekName: "readSeek_grep" },
   { builtIn: null, readSeekName: "readSeek_search" },
@@ -6945,20 +5584,17 @@ var READSEEK_TOOL_ENTRIES = [
   { builtIn: null, readSeekName: "readSeek_rename" },
   { builtIn: "write", readSeekName: "readSeek_write" },
   { builtIn: null, readSeekName: "readSeek_def" },
-  { builtIn: null, readSeekName: "readSeek_digest" },
+  { builtIn: "read", readSeekName: "readSeek_digest" },
   { builtIn: null, readSeekName: "readSeek_view" }
 ];
 function formatSettingsWarning(warning) {
   return `${warning.message} (${warning.source})`;
 }
-function editingPolicy(readName, editName, writeName) {
-  return [
-    "ReadSeek editing policy:",
-    `- Read first with ${readName} when preparing to edit; ${editName} needs fresh LINE:HASH anchors.`,
-    `- Use ${editName} for existing files, ${writeName} for whole-file creation or replacement, and readSeek_rename for symbol renames.`,
-    "- Run readSeek_digest with select diagnostics after source edits for a quick syntax check."
-  ].join(`
-`);
+function toolRoutingPolicy(aliases) {
+  return renderToolRoutingPolicy({
+    aliases,
+    title: "ReadSeek tool policy:"
+  });
 }
 function piReadSeekExtension(pi) {
   const sessionAnchors = new SessionAnchors;
@@ -6969,24 +5605,27 @@ function piReadSeekExtension(pi) {
   const replacedBuiltIns = new Set(settings.overrideTools ?? []);
   const binaryAvailable = readSeekBinaryAvailability().available;
   const swap = (builtIn, readSeekName) => binaryAvailable && replacedBuiltIns.has(builtIn) ? builtIn : readSeekName;
-  const readName = swap("read", "readSeek_read");
+  const readName = swap("read", "readSeek_digest");
   const editName = swap("edit", "readSeek_edit");
   const writeName = swap("write", "readSeek_write");
   const grepName = swap("grep", "readSeek_grep");
   const toolAliases = {
-    readSeek_read: readName,
+    readSeek_digest: readName,
     readSeek_edit: editName,
     readSeek_grep: grepName,
     readSeek_write: writeName
   };
-  registerReadTool(pi, { onSuccessfulRead: markAnchored, name: readName });
+  const policyAliases = Object.fromEntries(TOOL_NAMES.map((name) => {
+    const readSeekName = `readSeek_${name}`;
+    return [name, toolAliases[readSeekName] ?? readSeekName];
+  }));
   registerEditTool(pi, { wasReadInSession: hasFreshAnchors, onFileMutated: forgetAnchors, name: editName, toolAliases });
   registerGrepTool(pi, { onFileAnchored: markAnchored, name: grepName });
   registerSearchTool(pi, { onFileAnchored: markAnchored });
   registerRefsTool(pi, { onFileAnchored: markAnchored });
   registerRenameTool(pi, { onFileMutated: forgetAnchors });
   registerDefTool(pi, { onFileAnchored: markAnchored });
-  registerDigestTool(pi, { onFileAnchored: markAnchored });
+  registerDigestTool(pi, { onFileAnchored: markAnchored, name: readName, toolAliases });
   registerViewTool(pi);
   registerWriteTool(pi, { onFileAnchored: markAnchored, name: writeName });
   pi.on("before_agent_start", (event) => {
@@ -6994,7 +5633,7 @@ function piReadSeekExtension(pi) {
       return;
     return { systemPrompt: `${event.systemPrompt}
 
-${editingPolicy(readName, editName, writeName)}` };
+${toolRoutingPolicy(policyAliases)}` };
   });
   pi.on("session_start", (_event, ctx) => {
     sessionAnchors.clear();