opencode-readseek 0.8.24 → 0.9.1

package/README.md

@@ -3,7 +3,7 @@
 <img alt="OpenCode running opencode-readseek" src="screenshot.png" width="800">
 
 `opencode-readseek` adds anchored file operations, structural search, symbol
-navigation, and PDF tools to OpenCode.
+navigation, and document tools to OpenCode.
 
 ## Install
 
@@ -20,20 +20,18 @@ OpenCode installs the package and its platform-specific
 
 ## Tools
 
-| Tool | Purpose |
-| --- | --- |
-| `readseek_read` | Read text with `LINE:HASH` anchors; read images or one PDF page |
-| `readseek_edit` | Apply hash-verified edits to an existing text file |
-| `readseek_write` | Create or replace a complete text file |
-| `readseek_grep` | Search text or regex and return anchors |
-| `readseek_map` | Show a source file's symbol outline |
-| `readseek_search` | Search AST patterns |
-| `readseek_def` | Find symbol definitions |
-| `readseek_refs` | Find identifier usages, optionally scoped to a cursor binding |
-| `readseek_hover` | Identify the token and enclosing symbol at a cursor |
-| `readseek_rename` | Apply a binding-aware rename; set `apply: false` for a dry run |
-| `readseek_check` | Report parser errors and missing syntax |
-| `readseek_view` | View or narrow a structural PDF index |
+| Tool               | Purpose                                                                 |
+| ------------------ | ----------------------------------------------------------------------- |
+| `readseek_read`    | Read text with `LINE:HASH` anchors; read standalone images              |
+| `readseek_edit`    | Apply hash-verified edits to an existing text file                      |
+| `readseek_write`   | Create or replace a complete text file                                  |
+| `readseek_grep`    | Search text or regex and return anchors                                 |
+| `readseek_digest`  | Native digest envelope: metadata, content, map, diagnostics, identity   |
+| `readseek_search`  | Search AST patterns                                                     |
+| `readseek_def`     | Find symbol definitions                                                 |
+| `readseek_refs`    | Find identifier usages, optionally scoped to a cursor binding           |
+| `readseek_rename`  | Apply a binding-aware rename; set `apply: false` for a dry run          |
+| `readseek_view`    | View or narrow a structural document index                              |
 
 The plugin requests read, grep, external-directory, and edit permissions as
 needed. Mutations invalidate remembered anchors; compaction preserves fresh
@@ -44,6 +42,9 @@ OpenCode is instructed to prefer ReadSeek over the built-in `read`, `edit`,
 `write`, `grep`, and `apply_patch` tools when ReadSeek can do the job. Built-ins
 remain available as fallbacks.
 
+Documents such as PDFs are owned by `readseek_view`. Calling `readseek_read` on
+a document returns a cache receipt and directs the caller to `readseek_view`.
+
 ## Configuration
 
 Pass options with OpenCode's plugin tuple syntax:
@@ -58,9 +59,11 @@ Pass options with OpenCode's plugin tuple syntax:
 
 - `"auto"` (default): expose `none`, `all`, `ocr`, `caption`, and `objects`.
 - `"on"`: expose local analysis modes and omit `none`.
-- `"off"`: skip image and PDF reads.
+- `"off"`: skip image reads.
 
-Omitting `image` from a read also skips visual files.
+Omitting `image` from a read also skips image files. Document asset analysis
+uses `readseek_view` with optional `visionMode` (`all` | `ocr` | `caption` |
+`objects`) and `visionLevel` (`low` | `medium` | `high`).
 
 ## Development
 

package/index.ts

@@ -10,6 +10,8 @@ import { tool, type Plugin, type PluginOptions, type ToolAttachment, type ToolCo
 
 const require = createRequire(import.meta.url);
 const MAX_OUTPUT_BYTES = 32 * 1024 * 1024;
+const DEFAULT_READSEEK_TIMEOUT_MS = 120_000;
+const DEFAULT_VISION_TIMEOUT_MS = 30 * 60 * 1000;
 const DEFAULT_READ_LIMIT = 2000;
 const EDIT_RESULT_READ_LIMIT = 40;
 const MAX_DOCUMENT_OUTPUT_BYTES = 256 * 1024;
@@ -18,10 +20,10 @@ const TOOL_POLICY = [
   "ReadSeek tool policy:",
   "- Prefer readseek_* tools over built-ins when they can do the job.",
   "- Read with readseek_read first; readseek_edit needs fresh LINE:HASH anchors.",
-  "- Use readseek_grep for text/regex, readseek_search for AST patterns, and readseek_map/def/refs/hover for symbol navigation.",
+  "- Use readseek_grep for text/regex, readseek_search for AST patterns, and readseek_digest/def/refs for symbol navigation.",
   "- Use readseek_edit for existing files, readseek_write for whole-file creation or replacement, and readseek_rename for symbol renames.",
   "- Do not use built-in read, edit, write, grep, or apply_patch when a ReadSeek tool can do the job.",
-  "- Run readseek_check after source edits for a quick syntax check.",
+  "- Run readseek_digest with select=diagnostics after source edits for a quick syntax check.",
 ].join("\n");
 const PREFERRED_TOOL_DESCRIPTIONS: Record<string, string> = {
   readseek_read: "Preferred file reader; returns LINE:HASH anchors for durable references.",
@@ -30,12 +32,10 @@ const PREFERRED_TOOL_DESCRIPTIONS: Record<string, string> = {
   readseek_rename: "Use to rename a symbol with binding-aware, verified edits.",
   readseek_grep: "Preferred text/regex search; returns edit-ready LINE:HASH anchors.",
   readseek_search: "Use for AST or structural code search with ast-grep-style patterns.",
-  readseek_map: "Use to inspect a source file's symbol outline without reading the whole file.",
+  readseek_digest: "Use to digest native facets (metadata, content, map, diagnostics, identity) and return the full envelope.",
   readseek_def: "Use for go-to-definition or declaration lookup by name.",
   readseek_refs: "Use to find identifier-name matches or binding-specific references before rename or delete.",
-  readseek_hover: "Use to inspect symbol identity at a source location.",
-  readseek_view: "Use to inspect PDF structure or selected content.",
-  readseek_check: "Use for a quick parser syntax check after source edits; unsupported languages are not validated.",
+  readseek_view: "Use to digest document structure or selected content.",
 };
 const FALLBACK_TOOL_DESCRIPTIONS: Record<string, string> = {
   read: "Fallback only. Prefer readseek_read so edits can use LINE:HASH anchors.",
@@ -56,7 +56,7 @@ type RenamePlan = {
   files: Set<string>;
 };
 
-type PresentationKind = "read" | "view" | "map" | "search" | "grep" | "def" | "refs" | "hover" | "rename" | "edit" | "write" | "check";
+type PresentationKind = "read" | "view" | "digest" | "search" | "grep" | "def" | "refs" | "rename" | "edit" | "write";
 
 type Presentation = {
   title: string;
@@ -70,7 +70,11 @@ type RenderedToolResult = {
 
 type ImagePolicy = "on" | "auto" | "off";
 type ImageMode = "none" | "all" | "ocr" | "caption" | "objects";
+type VisionAnalysisMode = Exclude<ImageMode, "none">;
+type VisionLevel = "low" | "medium" | "high";
 type DocumentNodeKind = "artifact" | "footer" | "header" | "heading" | "marginal_label" | "page" | "page_number" | "paragraph" | "section" | "structural_section";
+const VISION_ANALYSIS_MODES: [VisionAnalysisMode, ...VisionAnalysisMode[]] = ["all", "ocr", "caption", "objects"];
+const VISION_LEVELS: [VisionLevel, ...VisionLevel[]] = ["low", "medium", "high"];
 
 const DOCUMENT_NODE_KINDS: [DocumentNodeKind, ...DocumentNodeKind[]] = [
   "artifact",
@@ -95,11 +99,65 @@ function resolveImagePolicy(options: PluginOptions | undefined): ImagePolicy {
 function isVisualFile(value: unknown): boolean {
   const output = record(value);
   const type = output.type;
-  return typeof output.width === "number" || type === "application/pdf";
+  return typeof output.width === "number"
+    || (typeof type === "string" && type.startsWith("image/"));
+}
+
+function isVisualBoundsError(error: unknown): boolean {
+  if (!(error instanceof Error)) return false;
+  const message = error.message.replace(/^error:\s*/, "");
+  return message.startsWith("--end")
+    && /(?:does|do) not apply to images/.test(message);
+}
+
+function isDocumentBoundsError(error: unknown): boolean {
+  if (!(error instanceof Error)) return false;
+  const message = error.message.replace(/^error:\s*/, "");
+  return /(?:does|do) not apply to (?:documents|PDFs)/.test(message)
+    || /document content belongs to view/.test(message)
+    || /source facets do not apply to documents/.test(message);
 }
 
 function isPdfFile(value: unknown): boolean {
-  return record(value).format === "pdf";
+  const output = record(value);
+  return output.format === "pdf" || output.type === "application/pdf";
+}
+
+function documentReceipt(filePath: string, envelope: unknown): Record<string, unknown> {
+  const recordEnvelope = record(envelope);
+  return {
+    file: filePath,
+    use: "readseek_view",
+    reason: "document content belongs to readseek_view",
+    metadata: digestMetadata(envelope),
+    ...(recordEnvelope.cache !== undefined ? { cache: recordEnvelope.cache } : {}),
+  };
+}
+
+async function digestDocumentReceipt(context: ToolContext, filePath: string): Promise<Record<string, unknown>> {
+  const cacheDir = await ensureReadSeekCache(context);
+  const envelope = await runReadSeek(context, [
+    "--readseek-dir",
+    cacheDir,
+    ...digestArgs(filePath, "metadata"),
+  ]);
+  return documentReceipt(filePath, envelope);
+}
+
+function digestArgs(filePath: string, select: string, extra: string[] = []): string[] {
+  return ["digest", filePath, "--select", select, ...extra];
+}
+
+function requireDigestFacet(envelope: unknown, facet: "content" | "map" | "diagnostics" | "identity"): unknown {
+  const value = record(envelope)[facet];
+  if (value === undefined || value === null || typeof value !== "object") {
+    throw new Error(`digest returned no ${facet} facet`);
+  }
+  return value;
+}
+
+function digestMetadata(envelope: unknown): Record<string, unknown> {
+  return record(record(envelope).metadata);
 }
 
 class SessionAnchors {
@@ -304,6 +362,37 @@ function optionalFlag(args: string[], enabled: boolean | undefined, flag: string
   if (enabled) args.push(flag);
 }
 
+function atLocation(line: number, column?: number): string {
+  return column === undefined ? `line:${line}` : `line:${line}:${column}`;
+}
+
+function withAt(args: string[], line: number, column?: number): void {
+  args.push("--at", atLocation(line, column));
+}
+
+function isLikelyImagePath(filePath: string): boolean {
+  return /\.(avif|bmp|gif|heic|heif|ico|jpe?g|png|svg|tiff?|webp)$/i.test(filePath);
+}
+
+function isLikelyDocumentPath(filePath: string): boolean {
+  return /\.pdf$/i.test(filePath);
+}
+
+function readRangeArgs(filePath: string, start: number, end: number): string[] {
+  const extra: string[] = [];
+  if (start > 1) withAt(extra, start);
+  extra.push("--end", String(end));
+  return digestArgs(filePath, "content", extra);
+}
+
+async function runDigestContent(
+  context: ToolContext,
+  args: string[],
+  options: { cancelable?: boolean; timeoutMs?: number } = {},
+): Promise<unknown> {
+  return requireDigestFacet(await runReadSeek(context, args, options), "content");
+}
+
 function readSeekBinaryPath(): string {
   const platform = `${process.platform}-${process.arch}`;
   const platformPackage = READSEEK_PLATFORM_PACKAGES[platform];
@@ -331,7 +420,7 @@ async function readBoundedText(
       totalBytes += value.byteLength;
       if (totalBytes > MAX_OUTPUT_BYTES) {
         onOverflow();
-        void reader.cancel().catch(() => undefined);
+        await reader.cancel().catch(() => undefined);
         throw new Error(`readseek ${streamName} exceeded the ${MAX_OUTPUT_BYTES}-byte output limit`);
       }
       chunks.push(value);
@@ -352,13 +441,14 @@ async function readBoundedText(
 async function runReadSeekRaw(
   context: ToolContext,
   args: string[],
-  options: { cancelable?: boolean } = {},
+  options: { cancelable?: boolean; stdin?: string; timeoutMs?: number } = {},
 ): Promise<string> {
   context.abort.throwIfAborted();
   const cancelable = options.cancelable !== false;
   const spawnOptions = {
     cwd: context.directory,
     stderr: "pipe" as const,
+    stdin: options.stdin === undefined ? undefined : Buffer.from(options.stdin),
     stdout: "pipe" as const,
   };
   const child = Bun.spawn(
@@ -377,11 +467,31 @@ async function runReadSeekRaw(
       // Preserve the output-limit error if the process exited concurrently.
     }
   };
-  const [stdout, stderr, exitCode] = await Promise.all([
+  const timeoutMs = options.timeoutMs ?? DEFAULT_READSEEK_TIMEOUT_MS;
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  const timeoutResult = new Promise<never>((_resolve, reject) => {
+    timeout = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+        // Preserve the timeout error if the process exited concurrently.
+      }
+      reject(new Error(`readseek timed out after ${timeoutMs} ms`));
+    }, timeoutMs);
+    timeout.unref?.();
+  });
+  const pending = Promise.all([
     readBoundedText(child.stdout, "stdout", killForOverflow),
     readBoundedText(child.stderr, "stderr", killForOverflow),
     child.exited,
   ]);
+  let result: Awaited<typeof pending>;
+  try {
+    result = await Promise.race([pending, timeoutResult]);
+  } finally {
+    if (timeout !== undefined) clearTimeout(timeout);
+  }
+  const [stdout, stderr, exitCode] = result;
   if (cancelable) context.abort.throwIfAborted();
   if (exitCode !== 0) throw new Error(stderr.trim() || `readseek exited with status ${exitCode}`);
   return stdout;
@@ -390,7 +500,7 @@ async function runReadSeekRaw(
 async function runReadSeek(
   context: ToolContext,
   args: string[],
-  options: { cancelable?: boolean } = {},
+  options: { cancelable?: boolean; stdin?: string; timeoutMs?: number } = {},
 ): Promise<unknown> {
   const stdout = await runReadSeekRaw(context, args, options);
   try {
@@ -407,7 +517,10 @@ async function postMutationPreview(
   changed: boolean,
 ): Promise<unknown> {
   try {
-    return await runReadSeek(context, args, { cancelable: false });
+    return await runDigestContent(context, args, {
+      cancelable: false,
+      timeoutMs: DEFAULT_READSEEK_TIMEOUT_MS,
+    });
   } catch (error) {
     const previewError = error instanceof Error ? error.message : String(error);
     return {
@@ -471,6 +584,11 @@ type AnchorEdit =
   | { replace_lines: { start_anchor: string; end_anchor: string; new_text: string } }
   | { insert_after: { anchor: string; new_text: string } };
 
+type EditItem =
+  | AnchorEdit
+  | { replace: { old_text: string; new_text: string; all?: boolean } }
+  | { replace_symbol: { symbol: string; new_body: string } };
+
 type TextSnapshot = {
   exists: boolean;
   content: string;
@@ -496,25 +614,28 @@ async function withFileMutationQueue<T>(filePath: string, operation: () => Promi
   }
 }
 
-function validateAnchorEdits(value: unknown): asserts value is AnchorEdit[] {
+function validateEdits(value: unknown): asserts value is EditItem[] {
   if (!Array.isArray(value) || value.length === 0) throw new Error("edits must contain at least one edit");
-  const fields = {
+  const requiredFields = {
     set_line: ["anchor", "new_text"],
     replace_lines: ["end_anchor", "new_text", "start_anchor"],
     insert_after: ["anchor", "new_text"],
+    replace: ["new_text", "old_text"],
+    replace_symbol: ["new_body", "symbol"],
   } as const;
   for (const [index, item] of value.entries()) {
     if (!item || typeof item !== "object") throw new Error(`edits[${index}] must be an edit object`);
     const keys = Object.keys(item);
-    const variant = keys[0] as keyof typeof fields;
-    if (keys.length !== 1 || !Object.hasOwn(fields, variant)) {
-      throw new Error(`edits[${index}] must contain exactly one of: set_line, replace_lines, insert_after`);
+    const variant = keys[0] as keyof typeof requiredFields;
+    if (keys.length !== 1 || !Object.hasOwn(requiredFields, variant)) {
+      throw new Error(`edits[${index}] must contain exactly one of: set_line, replace_lines, insert_after, replace, replace_symbol`);
     }
     const payload = (item as Record<string, unknown>)[variant];
     if (!payload || typeof payload !== "object") throw new Error(`edits[${index}].${variant} must be an object`);
-    const expectedFields = fields[variant];
+    const expectedFields: readonly string[] = requiredFields[variant];
+    const allowedFields = variant === "replace" ? [...expectedFields, "all"] : expectedFields;
     const actualFields = Object.keys(payload).sort();
-    if (actualFields.length !== expectedFields.length || actualFields.some((field, fieldIndex) => field !== expectedFields[fieldIndex])) {
+    if (actualFields.some((field) => !allowedFields.includes(field)) || expectedFields.some((field) => !actualFields.includes(field))) {
       throw new Error(`edits[${index}].${variant} contains invalid fields`);
     }
     const values = payload as Record<string, unknown>;
@@ -523,6 +644,9 @@ function validateAnchorEdits(value: unknown): asserts value is AnchorEdit[] {
         throw new Error(`edits[${index}].${variant}.${field} must be a string`);
       }
     }
+    if (variant === "replace" && values.all !== undefined && typeof values.all !== "boolean") {
+      throw new Error(`edits[${index}].replace.all must be a boolean`);
+    }
     for (const field of expectedFields.filter((field) => field.endsWith("anchor"))) {
       parseAnchor(values[field] as string);
     }
@@ -537,125 +661,16 @@ function parseAnchor(anchor: string): { line: number; hash: string } {
   return { line, hash: match[2].toLowerCase() };
 }
 
-function anchorRefs(edit: AnchorEdit): { line: number; hash: string }[] {
-  if ("set_line" in edit) return [parseAnchor(edit.set_line.anchor)];
-  if ("insert_after" in edit) return [parseAnchor(edit.insert_after.anchor)];
-  return [parseAnchor(edit.replace_lines.start_anchor), parseAnchor(edit.replace_lines.end_anchor)];
-}
-
-async function verifyAnchors(context: ToolContext, filePath: string, edits: AnchorEdit[]): Promise<void> {
-  const refs = new Map<number, string>();
-  for (const edit of edits) {
-    for (const ref of anchorRefs(edit)) {
-      const previous = refs.get(ref.line);
-      if (previous !== undefined && previous !== ref.hash) throw new Error(`conflicting hashes for line ${ref.line}`);
-      refs.set(ref.line, ref.hash);
-    }
-  }
-  for (const [line, expected] of refs) {
-    const output = record(await runReadSeek(context, ["read", `${filePath}:${line}`, "--end", String(line)]));
-    const hashline = items(output.hashlines).map(record)[0];
-    const actual = hashline?.hash;
-    if (typeof actual !== "string" || actual !== expected) {
-      throw new Error(`stale anchor ${line}:${expected}; current hash is ${typeof actual === "string" ? actual : "unavailable"}`);
-    }
+function firstChangedLine(before: string, after: string): number {
+  const beforeLines = normalizeToLf(before).split("\n");
+  const afterLines = normalizeToLf(after).split("\n");
+  const count = Math.max(beforeLines.length, afterLines.length);
+  for (let index = 0; index < count; index++) {
+    if (beforeLines[index] !== afterLines[index]) return index + 1;
   }
+  return 1;
 }
 
-type EditableLine = {
-  text: string;
-  ending: "\r\n" | "\n" | "\r" | "";
-};
-
-function parseEditableLines(content: string): EditableLine[] {
-  const lines: EditableLine[] = [];
-  let start = 0;
-  for (let index = 0; index < content.length; index++) {
-    const character = content[index];
-    if (character !== "\r" && character !== "\n") continue;
-    const ending = character === "\r" && content[index + 1] === "\n" ? "\r\n" : character;
-    lines.push({ text: content.slice(start, index), ending });
-    if (ending === "\r\n") index++;
-    start = index + 1;
-  }
-  if (start < content.length || content.length === 0) lines.push({ text: content.slice(start), ending: "" });
-  return lines;
-}
-
-function detectLineEnding(lines: EditableLine[]): "\r\n" | "\n" | "\r" {
-  const counts = new Map<"\r\n" | "\n" | "\r", number>([
-    ["\r\n", 0],
-    ["\n", 0],
-    ["\r", 0],
-  ]);
-  for (const line of lines) {
-    if (line.ending !== "") counts.set(line.ending, (counts.get(line.ending) ?? 0) + 1);
-  }
-  let selected: "\r\n" | "\n" | "\r" = "\n";
-  for (const ending of ["\r\n", "\r"] as const) {
-    if ((counts.get(ending) ?? 0) > (counts.get(selected) ?? 0)) selected = ending;
-  }
-  return selected;
-}
-
-function normalizeToLf(content: string): string {
-  return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-}
-
-function replacementLines(text: string): string[] {
-  if (text === "") return [];
-  return normalizeToLf(text).replace(/\n$/, "").split("\n");
-}
-
-function applyAnchorEdits(content: string, edits: AnchorEdit[]): string {
-  const bom = content.startsWith("\uFEFF") ? "\uFEFF" : "";
-  const lines = parseEditableLines(bom ? content.slice(1) : content);
-  const newline = detectLineEnding(lines);
-  const planned = edits.map((edit) => {
-    if ("set_line" in edit) {
-      const { line } = parseAnchor(edit.set_line.anchor);
-      return { start: line - 1, deleteCount: 1, text: edit.set_line.new_text };
-    }
-    if ("insert_after" in edit) {
-      const { line } = parseAnchor(edit.insert_after.anchor);
-      return { start: line, deleteCount: 0, text: edit.insert_after.new_text };
-    }
-    const start = parseAnchor(edit.replace_lines.start_anchor).line;
-    const end = parseAnchor(edit.replace_lines.end_anchor).line;
-    if (end < start) throw new Error("replace_lines end anchor precedes start anchor");
-    return { start: start - 1, deleteCount: end - start + 1, text: edit.replace_lines.new_text };
-  });
-  const ascending = [...planned].sort((left, right) => left.start - right.start || left.deleteCount - right.deleteCount);
-  for (let index = 1; index < ascending.length; index++) {
-    const previous = ascending[index - 1];
-    const current = ascending[index];
-    const previousEnd = previous.start + Math.max(previous.deleteCount, 1);
-    if (current.start < previousEnd) throw new Error("anchored edits overlap or target the same location");
-  }
-  planned.sort((left, right) => right.start - left.start);
-  for (const edit of planned) {
-    if (edit.start < 0 || edit.start > lines.length || edit.start + edit.deleteCount > lines.length) {
-      throw new Error("anchor line is outside the file");
-    }
-    const removed = lines.slice(edit.start, edit.start + edit.deleteCount);
-    const replacement = replacementLines(edit.text).map((text): EditableLine => ({ text, ending: newline }));
-    if (edit.deleteCount === 0 && edit.start === lines.length && replacement.length > 0) {
-      const previous = lines.at(-1);
-      const terminalEnding = previous?.ending ?? "";
-      if (previous?.ending === "") previous.ending = newline;
-      replacement[replacement.length - 1].ending = terminalEnding;
-    } else if (edit.deleteCount > 0) {
-      const terminalEnding = removed.at(-1)?.ending ?? "";
-      if (replacement.length > 0) {
-        replacement[replacement.length - 1].ending = terminalEnding;
-      } else if (edit.start + edit.deleteCount === lines.length && edit.start > 0) {
-        lines[edit.start - 1].ending = terminalEnding;
-      }
-    }
-    lines.splice(edit.start, edit.deleteCount, ...replacement);
-  }
-  return bom + lines.map((line) => line.text + line.ending).join("");
-}
 
 async function readTextSnapshot(filePath: string): Promise<TextSnapshot> {
   try {
@@ -729,11 +744,19 @@ function renameFiles(value: unknown): string[] {
   return files;
 }
 
+function normalizeToLf(content: string): string {
+  return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
 function diffLines(content: string): string[] {
   if (content === "") return [];
-  const lines = normalizeToLf(content).split("\n");
+  const lines = content.split("\n");
   if (lines.at(-1) === "") lines.pop();
-  return lines;
+  return lines.map((line) => line.replace(/\r/g, "\\r"));
+}
+
+function hasFinalNewline(content: string): boolean {
+  return content === "" || /[\r\n]$/.test(content);
 }
 
 function diffRange(start: number, count: number): string {
@@ -796,23 +819,7 @@ function imageAttachment(image: Record<string, unknown>, filename: string): Tool
 
 function formatReadResult(value: unknown): RenderedToolResult {
   const output = record(value);
-  if (output.format === "pdf") {
-    const attachments: ToolAttachment[] = [];
-    const images = items(output.images).map((value, index) => {
-      const image = record(value);
-      const page = typeof image.page === "number" ? image.page : "unknown";
-      const attachment = imageAttachment(image, `pdf-page-${page}-image-${index + 1}`);
-      if (attachment) attachments.push(attachment);
-      const sanitized = { ...image };
-      delete sanitized.data;
-      delete sanitized.encoding;
-      return sanitized;
-    });
-    return {
-      output: boundDocumentOutput(render({ ...output, images })),
-      ...(attachments.length > 0 ? { attachments } : {}),
-    };
-  }
+  if (output.use === "readseek_view") return { output: render(value) };
 
   const attachment = imageAttachment(output, "image");
   if (!attachment) return { output: render(value) };
@@ -846,6 +853,8 @@ function simpleDiff(filePath: string, before: string, after: string): string {
   if (before === after) return "";
   const oldLines = diffLines(before);
   const newLines = diffLines(after);
+  const oldHasFinalNewline = hasFinalNewline(before);
+  const newHasFinalNewline = hasFinalNewline(after);
   let prefix = 0;
   while (prefix < oldLines.length && prefix < newLines.length && oldLines[prefix] === newLines[prefix]) prefix++;
   let suffix = 0;
@@ -874,13 +883,13 @@ function simpleDiff(filePath: string, before: string, after: string): string {
   const fullDiff = [...header];
   let fullDiffBytes = Buffer.byteLength(header.join("\n"));
   let complete = true;
-  const ranges: Array<[string[], number, number, string]> = [
-    [oldLines, oldStart, prefix, " "],
-    [oldLines, prefix, oldChangeEnd, "-"],
-    [newLines, prefix, newChangeEnd, "+"],
-    [newLines, newChangeEnd, newEnd, " "],
+  const ranges: Array<[string[], number, number, string, boolean]> = [
+    [oldLines, oldStart, prefix, " ", oldHasFinalNewline],
+    [oldLines, prefix, oldChangeEnd, "-", oldHasFinalNewline],
+    [newLines, prefix, newChangeEnd, "+", newHasFinalNewline],
+    [newLines, newChangeEnd, newEnd, " ", newHasFinalNewline],
   ];
-  outer: for (const [lines, start, end, marker] of ranges) {
+  outer: for (const [lines, start, end, marker, hasNewline] of ranges) {
     for (let index = start; index < end; index++) {
       const lineBytes = 2 + Buffer.byteLength(lines[index]);
       if (fullDiffBytes + lineBytes > MAX_PERMISSION_DIFF_BYTES) {
@@ -889,13 +898,26 @@ function simpleDiff(filePath: string, before: string, after: string): string {
       }
       fullDiff.push(`${marker}${lines[index]}`);
       fullDiffBytes += lineBytes;
+      if (index === lines.length - 1 && !hasNewline) {
+        const eofMarker = "\";
+        if (fullDiffBytes + Buffer.byteLength(eofMarker) + 1 > MAX_PERMISSION_DIFF_BYTES) {
+          complete = false;
+          break outer;
+        }
+        fullDiff.push(eofMarker);
+        fullDiffBytes += Buffer.byteLength(eofMarker) + 1;
+      }
     }
   }
   if (complete) return fullDiff.join("\n");
 
+  const newlineSummary = oldHasFinalNewline === newHasFinalNewline
+    ? []
+    : [` final newline: ${oldHasFinalNewline ? "present" : "missing"} -> ${newHasFinalNewline ? "present" : "missing"}`];
   return [
     ...header,
     ` diff truncated: ${oldChangeEnd - prefix} removed, ${newChangeEnd - prefix} added lines`,
+    ...newlineSummary,
     ...sampleDiffLines(oldLines, prefix, oldChangeEnd, "-"),
     ...sampleDiffLines(newLines, prefix, newChangeEnd, "+"),
   ].join("\n");
@@ -923,8 +945,8 @@ function initialTitle(kind: PresentationKind, args: any): string {
       return `Read ${args.path}`;
     case "view":
       return `View ${args.path}`;
-    case "map":
-      return `Map ${args.path}`;
+    case "digest":
+      return `Digest ${args.path}`;
     case "search":
       return `Search ${args.pattern}`;
     case "grep":
@@ -933,16 +955,12 @@ function initialTitle(kind: PresentationKind, args: any): string {
       return `Find definition ${args.name}`;
     case "refs":
       return `Find references to ${args.name}`;
-    case "hover":
-      return `Identify ${args.path}:${args.line}`;
     case "rename":
       return `Rename ${args.path}:${args.line} to ${args.to}`;
     case "edit":
       return `Edit ${args.path}`;
     case "write":
       return `Write ${args.path}`;
-    case "check":
-      return `Check ${args.path}`;
   }
 }
 
@@ -967,9 +985,37 @@ function resultPresentation(kind: PresentationKind, args: any, value: unknown):
     }
     case "view":
       return { title: `Viewed ${args.path}`, metadata: {} };
-    case "map": {
-      const symbols = items(output.symbols).length;
-      return { title: `Mapped ${args.path} (${symbols} symbols)`, metadata: { symbols } };
+    case "digest": {
+      const map = record(output.map);
+      const diagnostics = record(output.diagnostics);
+      const identity = record(output.identity);
+      const content = record(output.content);
+      const metadata: Record<string, number> = {};
+      const summary: string[] = [];
+      if (output.map !== undefined) {
+        const symbols = items(map.symbols).length;
+        metadata.symbols = symbols;
+        summary.push(`${symbols} symbols`);
+      }
+      if (output.diagnostics !== undefined) {
+        const errors = typeof diagnostics.error_count === "number" ? diagnostics.error_count : 0;
+        const missing = typeof diagnostics.missing_count === "number" ? diagnostics.missing_count : 0;
+        metadata.error_count = errors;
+        metadata.missing_count = missing;
+        summary.push(`${errors} errors, ${missing} missing`);
+      }
+      if (output.identity !== undefined) {
+        if (typeof identity.line === "number") metadata.line = identity.line;
+        if (typeof identity.column === "number") metadata.column = identity.column;
+        const identifier = record(identity.identifier).text;
+        if (typeof identifier === "string") summary.push(identifier);
+      }
+      if (typeof content.start_line === "number") metadata.start_line = content.start_line;
+      if (typeof content.end_line === "number") metadata.end_line = content.end_line;
+      return {
+        title: summary.length > 0 ? `Digested ${args.path} (${summary.join(", ")})` : `Digested ${args.path}`,
+        metadata,
+      };
     }
     case "search": {
       const results = items(output.results);
@@ -989,15 +1035,6 @@ function resultPresentation(kind: PresentationKind, args: any, value: unknown):
       const references = items(output.references).length;
       return { title: `Found ${references} references`, metadata: { references } };
     }
-    case "hover": {
-      const identifier = record(output.identifier).text;
-      const line = output.line;
-      const column = output.column;
-      const metadata: Record<string, number> = {};
-      if (typeof line === "number") metadata.line = line;
-      if (typeof column === "number") metadata.column = column;
-      return { title: typeof identifier === "string" ? `Identified ${identifier}` : initialTitle(kind, args), metadata };
-    }
     case "rename": {
       const oldName = output.old_name;
       const newName = output.new_name;
@@ -1019,14 +1056,6 @@ function resultPresentation(kind: PresentationKind, args: any, value: unknown):
       const preview = typeof output.preview_error === "string" ? " (preview unavailable)" : "";
       return { title: `${kind === "edit" ? "Edited" : "Wrote"} ${args.path}${preview}`, metadata: {} };
     }
-    case "check": {
-      const errors = typeof output.error_count === "number" ? output.error_count : 0;
-      const missing = typeof output.missing_count === "number" ? output.missing_count : 0;
-      return {
-        title: `Checked ${args.path} (${errors} errors, ${missing} missing)`,
-        metadata: { error_count: errors, missing_count: missing },
-      };
-    }
   }
   return { title: initialTitle(kind, args), metadata: {} };
 }
@@ -1079,19 +1108,18 @@ export const ReadSeekPlugin: Plugin = async (_input, options) => {
     tool: {
       readseek_read: readseekTool(
         imagePolicy === "off"
-          ? "Read text with LINE:HASH anchors. Image and PDF reads are disabled."
-          : `Read text with LINE:HASH anchors. For an image or PDF, select image (${imageModes.join(", ")}); omit it to skip visual files.`,
+          ? "Read text with LINE:HASH anchors. Image reads are disabled. For documents, use readseek_view."
+          : `Read text with LINE:HASH anchors. For an image, select image (${imageModes.join(", ")}); omit it to skip image files. For documents such as PDFs, use readseek_view.`,
         {
           path: tool.schema.string().describe("Path relative to the project directory"),
           offset: tool.schema.number().int().positive().optional().describe("One-based starting line"),
           limit: tool.schema.number().int().positive().optional().describe(`Maximum number of lines; defaults to ${DEFAULT_READ_LIMIT}`),
-          page: tool.schema.number().int().positive().optional().describe("One-based PDF page; defaults to 1"),
           language: tool.schema.string().optional().describe("Language override when auto-detection is ambiguous"),
           ...(imagePolicy === "off"
             ? {}
             : {
                 image: tool.schema.enum(imageModes as [ImageMode, ...ImageMode[]]).optional()
-                  .describe("Image/PDF processing mode")
+                  .describe("Standalone image processing mode")
               }),
         },
         "read",
@@ -1099,47 +1127,123 @@ export const ReadSeekPlugin: Plugin = async (_input, options) => {
           const filePath = resolvePath(context.directory, input.path as string);
           await authorizeRead(context, filePath);
           const image = input.image as ImageMode | undefined;
-          if (imagePolicy === "off" && image !== undefined) throw new Error("image and PDF reads are disabled");
+          if (imagePolicy === "off" && image !== undefined) throw new Error("image reads are disabled");
           if (imagePolicy === "on" && image === "none") throw new Error('image="none" requires imageMode="auto"');
-          const detection = await runReadSeek(context, ["detect", filePath]);
-          const visual = isVisualFile(detection);
-          const pdf = isPdfFile(detection);
+
+          if (isLikelyDocumentPath(filePath)) {
+            if (image !== undefined) throw new Error("image does not apply to documents; use readseek_view");
+            if (input.offset !== undefined || input.limit !== undefined) {
+              throw new Error("offset and limit do not apply to documents; use readseek_view");
+            }
+            if (input.language !== undefined) {
+              throw new Error("language does not apply to documents; use readseek_view");
+            }
+            return digestDocumentReceipt(context, filePath);
+          }
+
+          // Image paths without an image mode only need metadata (skip without loading content).
+          // Text paths always use one digest --select content spawn.
+          let detectedText = false;
+          if (image === undefined && isLikelyImagePath(filePath)) {
+            const envelope = await runReadSeek(context, digestArgs(filePath, "metadata"));
+            const metadata = digestMetadata(envelope);
+            if (isPdfFile(metadata)) return documentReceipt(filePath, envelope);
+            if (isVisualFile(metadata)) {
+              return { file: filePath, skipped: true, reason: "image mode not selected" };
+            }
+            detectedText = true;
+          }
+
+          const extra: string[] = [];
+          const wantsImage = !detectedText
+            && (image !== undefined || isLikelyImagePath(filePath));
+          if (!wantsImage) {
+            const start = (input.offset as number | undefined) ?? 1;
+            const end = start + ((input.limit as number | undefined) ?? DEFAULT_READ_LIMIT) - 1;
+            if (start > 1) withAt(extra, start);
+            extra.push("--end", String(end));
+            if (input.language) extra.push("--language", input.language as string);
+          } else {
+            if (input.offset !== undefined || input.limit !== undefined) {
+              throw new Error("offset and limit do not apply to image reads");
+            }
+            if (input.language !== undefined) {
+              throw new Error("language does not apply to image reads");
+            }
+            if (image !== undefined) extra.push("--vision-mode", image);
+          }
+
+          let envelope: unknown;
+          try {
+            envelope = await runReadSeek(
+              context,
+              digestArgs(filePath, "content", extra),
+              image !== undefined && image !== "none" ? { timeoutMs: DEFAULT_VISION_TIMEOUT_MS } : {},
+            );
+          } catch (error) {
+            // A visual or document file with an uncommon extension rejects text bounds before
+            // an envelope can be returned. Probe metadata only on this cold path.
+            if (image !== undefined) throw error;
+            if (isDocumentBoundsError(error)) {
+              return digestDocumentReceipt(context, filePath);
+            }
+            if (isVisualBoundsError(error)) {
+              const metadataEnvelope = await runReadSeek(context, digestArgs(filePath, "metadata"));
+              if (isPdfFile(digestMetadata(metadataEnvelope))) {
+                return documentReceipt(filePath, metadataEnvelope);
+              }
+              if (isVisualFile(digestMetadata(metadataEnvelope))) {
+                return { file: filePath, skipped: true, reason: "image mode not selected" };
+              }
+            }
+            throw error;
+          }
+          const metadata = digestMetadata(envelope);
+          if (isPdfFile(metadata) || record(envelope).cache !== undefined) {
+            return documentReceipt(filePath, envelope);
+          }
+          const visual = isVisualFile(metadata);
+
           if (visual && image === undefined) {
             return { file: filePath, skipped: true, reason: "image mode not selected" };
           }
           if (visual && (input.offset !== undefined || input.limit !== undefined)) {
-            throw new Error("offset and limit do not apply to image or PDF reads");
+            throw new Error("offset and limit do not apply to image reads");
           }
           if (visual && input.language !== undefined) {
-            throw new Error("language does not apply to image or PDF reads");
+            throw new Error("language does not apply to image reads");
           }
-          if (!pdf && input.page !== undefined) throw new Error("page applies to PDF reads only");
 
-          const args = ["read", input.offset === undefined ? filePath : `${filePath}:${input.offset}`];
-          if (!visual) {
-            args.push("--end", String((input.offset ?? 1) + ((input.limit as number | undefined) ?? DEFAULT_READ_LIMIT) - 1));
-          }
-          if (input.language) args.push("--language", input.language as string);
-          if (image !== undefined) args.push("--vision-mode", image);
-          if (pdf) args.push("--page", String(input.page ?? 1));
-          return runReadSeek(context, args);
+          return requireDigestFacet(envelope, "content");
         },
         formatReadResult,
       ),
       readseek_view: readseekTool(
-        "Inspect a PDF's structure or selected content. Start with the overview, then narrow by page, node, kind, or depth instead of reading the whole document.",
+        "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.",
         {
-          path: tool.schema.string().describe("PDF path relative to the project directory"),
+          path: tool.schema.string().describe("Document path relative to the project directory"),
           node: tool.schema.string().min(1).optional().describe("Node ID to use as the view root"),
           page: tool.schema.number().int().positive().optional().describe("One-based source page"),
           kind: tool.schema.enum(DOCUMENT_NODE_KINDS).optional().describe("Node kind filter"),
           depth: tool.schema.number().int().nonnegative().optional().describe("Maximum depth below selected roots"),
           outline: tool.schema.boolean().optional().describe("Return outline nodes only"),
+          visionMode: tool.schema.enum(VISION_ANALYSIS_MODES).optional()
+            .describe("Analyze selected assets: all, ocr, caption, or objects"),
+          visionLevel: tool.schema.enum(VISION_LEVELS).optional()
+            .describe("Vision inference level: low (default), medium, or high"),
         },
         "view",
         async (input, context) => {
           const filePath = resolvePath(context.directory, input.path as string);
           await authorizeRead(context, filePath);
+          const visionMode = input.visionMode as VisionAnalysisMode | undefined;
+          const visionLevel = input.visionLevel as VisionLevel | undefined;
+          if (visionLevel !== undefined && visionMode === undefined) {
+            throw new Error("visionLevel requires visionMode");
+          }
+          if (input.outline && (visionMode !== undefined || visionLevel !== undefined)) {
+            throw new Error("vision options cannot be combined with outline");
+          }
           const cacheDir = await ensureReadSeekCache(context);
           const args = ["--readseek-dir", cacheDir, "view", filePath];
           if (input.node) args.push("--node", input.node as string);
@@ -1147,23 +1251,57 @@ export const ReadSeekPlugin: Plugin = async (_input, options) => {
           if (input.kind) args.push("--kind", input.kind as string);
           if (input.depth !== undefined) args.push("--depth", String(input.depth));
           optionalFlag(args, input.outline as boolean | undefined, "--outline");
-          return runReadSeekRaw(context, args);
+          if (visionMode !== undefined) args.push("--vision-mode", visionMode);
+          if (visionLevel !== undefined) args.push("--vision-level", visionLevel);
+          return runReadSeekRaw(
+            context,
+            args,
+            visionMode === undefined ? {} : { timeoutMs: DEFAULT_VISION_TIMEOUT_MS },
+          );
         },
         (result) => ({ output: boundDocumentOutput(String(result)) }),
       ),
-      readseek_map: readseekTool(
-        "Inspect a source file's symbol outline. Use this instead of reading the whole file when only declarations, names, kinds, ranges, and line hashes are needed.",
+      readseek_digest: readseekTool(
+        "Digest native facets for a path and return the full envelope unchanged. Facets: metadata, content, map, diagnostics, identity (comma-separated). Metadata is always present; other selected facets appear when available.",
         {
           path: tool.schema.string().describe("Path relative to the project directory"),
+          select: tool.schema.string().optional()
+            .describe("Comma-separated facets: metadata, content, map, diagnostics, identity; defaults to content"),
+          at: tool.schema.string().optional()
+            .describe("Location: line:N[:COLUMN], hash:HASH[:COLUMN], or symbol:NAME"),
+          end: tool.schema.number().int().positive().optional().describe("Last line to include; content facet only"),
+          limit: tool.schema.number().int().positive().optional().describe("Maximum number of lines; content facet only"),
           language: tool.schema.string().optional().describe("Language override when auto-detection is ambiguous"),
+          visionMode: tool.schema.enum(["none", ...VISION_ANALYSIS_MODES] as [ImageMode, ...ImageMode[]]).optional()
+            .describe("Standalone image mode for the content facet: none, all, ocr, caption, or objects"),
+          visionLevel: tool.schema.enum(VISION_LEVELS).optional()
+            .describe("Vision inference level: low (default), medium, or high; content facet only"),
         },
-        "map",
+        "digest",
         async (input, context) => {
           const filePath = resolvePath(context.directory, input.path as string);
           await authorizeRead(context, filePath);
-          const args = ["map", filePath];
+          const select = ((input.select as string | undefined) ?? "content").trim() || "content";
+          const visionMode = input.visionMode as ImageMode | undefined;
+          const visionLevel = input.visionLevel as VisionLevel | undefined;
+          if (visionLevel !== undefined && visionMode === undefined) {
+            throw new Error("visionLevel requires visionMode");
+          }
+          const cacheDir = await ensureReadSeekCache(context);
+          const args = ["--readseek-dir", cacheDir, ...digestArgs(filePath, select)];
+          if (input.at) args.push("--at", input.at as string);
+          if (input.end !== undefined) args.push("--end", String(input.end));
+          if (input.limit !== undefined) args.push("--limit", String(input.limit));
           if (input.language) args.push("--language", input.language as string);
-          return runReadSeek(context, args);
+          if (visionMode !== undefined) args.push("--vision-mode", visionMode);
+          if (visionLevel !== undefined) args.push("--vision-level", visionLevel);
+          return runReadSeek(
+            context,
+            args,
+            visionMode === undefined || visionMode === "none"
+              ? {}
+              : { timeoutMs: DEFAULT_VISION_TIMEOUT_MS },
+          );
         },
       ),
       readseek_grep: readseekTool(
@@ -1235,7 +1373,7 @@ export const ReadSeekPlugin: Plugin = async (_input, options) => {
             }
             const linesByNumber = new Map<number, unknown>();
             for (const [start, end] of mergedRanges) {
-              const output = record(await runReadSeek(context, ["read", `${filePath}:${start}`, "--end", String(end)]));
+              const output = record(await runDigestContent(context, readRangeArgs(filePath, start, end)));
               for (const hashline of items(output.hashlines)) {
                 const line = record(hashline).line;
                 if (typeof line === "number" && !linesByNumber.has(line)) linesByNumber.set(line, hashline);
@@ -1312,34 +1450,18 @@ export const ReadSeekPlugin: Plugin = async (_input, options) => {
             throw new Error("line and column require scope");
           }
           const target = resolvePath(context.directory, (input.path as string | undefined) ?? ".");
-          const args = ["refs", target, input.name as string];
-          optionalFlag(args, input.scope as boolean | undefined, "--scope");
-          if (input.line !== undefined) args.push("--line", String(input.line));
-          if (input.column !== undefined) args.push("--column", String(input.column));
+          const args = ["refs", target];
+          if (input.scope) {
+            withAt(args, input.line as number, input.column as number | undefined);
+          } else {
+            args.push(input.name as string);
+          }
           if (input.language) args.push("--language", input.language as string);
           withSearchFlags(args, input);
           await authorizeSearch(context, target, input.name as string);
           return runReadSeek(context, args);
         },
       ),
-      readseek_hover: readseekTool(
-        "Inspect the symbol at a source location. This identifies the token and enclosing symbol; use it before definition lookup or binding-specific references.",
-        {
-          path: tool.schema.string().describe("Path relative to the project directory"),
-          line: tool.schema.number().int().positive().describe("One-based cursor line"),
-          column: tool.schema.number().int().positive().optional().describe("One-based cursor byte column for disambiguation"),
-          language: tool.schema.string().optional().describe("Language override when auto-detection is ambiguous"),
-        },
-        "hover",
-        async (input, context) => {
-          const filePath = resolvePath(context.directory, input.path as string);
-          await authorizeRead(context, filePath);
-          const args = ["identify", `${filePath}:${input.line}`];
-          if (input.column !== undefined) args.push("--column", String(input.column));
-          if (input.language) args.push("--language", input.language as string);
-          return runReadSeek(context, args);
-        },
-      ),
       readseek_rename: readseekTool(
         "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.",
         {
@@ -1355,14 +1477,16 @@ export const ReadSeekPlugin: Plugin = async (_input, options) => {
           const filePath = resolvePath(context.directory, input.path as string);
           await authorizeRead(context, filePath);
           if (input.workspace) {
-            const identifyArgs = ["identify", `${filePath}:${input.line}`];
-            if (input.column !== undefined) identifyArgs.push("--column", String(input.column));
-            const name = identifiedName(await runReadSeek(context, identifyArgs));
+            const identifyArgs = digestArgs(filePath, "identity");
+            withAt(identifyArgs, input.line as number, input.column as number | undefined);
+            const envelope = await runReadSeek(context, identifyArgs);
+            const name = identifiedName(requireDigestFacet(envelope, "identity"));
             if (!name) throw new Error("readseek could not identify a binding at the rename cursor");
             await authorizeSearch(context, context.directory, name);
           }
-          const args = ["rename", filePath, "--line", String(input.line), "--to", input.to as string];
-          if (input.column !== undefined) args.push("--column", String(input.column));
+          const args = ["rename", filePath];
+          withAt(args, input.line as number, input.column as number | undefined);
+          args.push("--to", input.to as string);
           if (input.workspace) args.push("--workspace", context.directory);
           const plan = await runReadSeek(context, args);
           if (input.apply === false) return plan;
@@ -1372,11 +1496,14 @@ export const ReadSeekPlugin: Plugin = async (_input, options) => {
             throw new Error("readseek rename plan did not include a plan hash");
           }
           await authorizeEdit(context, files);
-          return runReadSeek(context, [...args, "--plan-hash", planHash, "--apply"], { cancelable: false });
+          return runReadSeek(context, [...args, "--plan-hash", planHash, "--apply"], {
+            cancelable: false,
+            timeoutMs: DEFAULT_READSEEK_TIMEOUT_MS,
+          });
         },
       ),
       readseek_edit: readseekTool(
-        "Edit an existing text file with fresh LINE:HASH anchors. Supports set_line, replace_lines, and insert_after only. Stale hashes are rejected before writing.",
+        "Edit an existing text file with fresh LINE:HASH anchors, exact text, or a mapped symbol. The native engine rejects stale or overlapping edits before writing.",
         {
           path: tool.schema.string().describe("Path relative to the project directory"),
           edits: tool.schema.array(tool.schema.union([
@@ -1399,31 +1526,64 @@ export const ReadSeekPlugin: Plugin = async (_input, options) => {
                 new_text: tool.schema.string().describe("Text to insert after the anchored line"),
               }).strict(),
             }).strict(),
-          ])).min(1).describe("Anchored edits: set_line, replace_lines, or insert_after"),
+            tool.schema.object({
+              replace: tool.schema.object({
+                old_text: tool.schema.string().describe("Exact text to find"),
+                new_text: tool.schema.string().describe("Replacement text"),
+                all: tool.schema.boolean().optional().describe("Replace every exact match"),
+              }).strict(),
+            }).strict(),
+            tool.schema.object({
+              replace_symbol: tool.schema.object({
+                symbol: tool.schema.string().describe("Mapped symbol name"),
+                new_body: tool.schema.string().describe("Complete replacement body for the symbol"),
+              }).strict(),
+            }).strict(),
+          ])).min(1).describe("Use set_line, replace_lines, insert_after, replace, or replace_symbol"),
+          language: tool.schema.string().optional().describe("Language override for symbol replacement"),
         },
         "edit",
         async (input, context) => {
           const filePath = resolvePath(context.directory, input.path as string);
-          validateAnchorEdits(input.edits);
+          validateEdits(input.edits);
           return withFileMutationQueue(filePath, async () => {
             context.abort.throwIfAborted();
             await authorizeRead(context, filePath);
             await rejectSymlinkMutation(filePath);
-            const edits = input.edits as AnchorEdit[];
-            const before = await readFile(filePath, "utf8");
-            await verifyAnchors(context, filePath, edits);
-            const after = applyAnchorEdits(before, edits);
+            const edits = input.edits as EditItem[];
+            const request = JSON.stringify({ edits });
+            const baseArgs = ["edit", filePath];
+            if (input.language) baseArgs.push("--language", input.language as string);
+            const plan = record(await runReadSeek(context, baseArgs, { stdin: request }));
+            if (
+              typeof plan.before_content !== "string" ||
+              typeof plan.content !== "string" ||
+              typeof plan.plan_hash !== "string"
+            ) {
+              throw new Error("readseek edit plan is missing before_content, content, or plan_hash");
+            }
+            const before = plan.before_content;
+            const after = plan.content;
+            const previewStart = Math.max(1, firstChangedLine(before, after) - 3);
+            const previewArgs = readRangeArgs(filePath, previewStart, previewStart + EDIT_RESULT_READ_LIMIT - 1);
+            if (before === after) {
+              return postMutationPreview(context, previewArgs, filePath, false);
+            }
             await authorizeEdit(context, [filePath], simpleDiff(filePath, before, after), false);
             context.abort.throwIfAborted();
-            if (before !== after) await writeText(filePath, { exists: true, content: before }, after);
-            const firstEditedLine = Math.min(...edits.flatMap((edit) => anchorRefs(edit).map((ref) => ref.line)));
-            const previewStart = Math.max(1, firstEditedLine - 3);
-            return postMutationPreview(
+            const applied = record(await runReadSeek(
               context,
-              ["read", `${filePath}:${previewStart}`, "--end", String(previewStart + EDIT_RESULT_READ_LIMIT - 1)],
-              filePath,
-              before !== after,
-            );
+              [...baseArgs, "--apply", "--plan-hash", plan.plan_hash],
+              {
+                cancelable: false,
+                stdin: request,
+                timeoutMs: DEFAULT_READSEEK_TIMEOUT_MS,
+              },
+            ));
+            if (applied.applied !== true) {
+              throw new Error("readseek did not confirm that the edit was applied");
+            }
+            return postMutationPreview(context, previewArgs, filePath, true);
           });
         },
       ),
@@ -1448,28 +1608,13 @@ export const ReadSeekPlugin: Plugin = async (_input, options) => {
             await writeText(filePath, before, content);
             return postMutationPreview(
               context,
-              ["read", filePath, "--end", String(DEFAULT_READ_LIMIT)],
+              digestArgs(filePath, "content", ["--end", String(DEFAULT_READ_LIMIT)]),
               filePath,
               !before.exists || before.content !== content,
             );
           });
         },
       ),
-      readseek_check: readseekTool(
-        "Check a source file for parser errors or missing syntax after edits. Validation requires a supported tree-sitter language; files without a supported parser are not checked. This is not a compiler, type checker, test runner, or linter.",
-        {
-          path: tool.schema.string().describe("Path relative to the project directory"),
-          language: tool.schema.string().optional().describe("Language override when auto-detection is ambiguous"),
-        },
-        "check",
-        async (input, context) => {
-          const filePath = resolvePath(context.directory, input.path as string);
-          await authorizeRead(context, filePath);
-          const args = ["check", filePath];
-          if (input.language) args.push("--language", input.language as string);
-          return runReadSeek(context, args);
-        },
-      ),
     },
     "experimental.chat.system.transform": async (_input, output) => {
       output.system.push(TOOL_POLICY);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-readseek",
-  "version": "0.8.24",
+  "version": "0.9.1",
   "description": "OpenCode plugin for anchored file operations and structural code navigation",
   "type": "module",
   "main": "./index.ts",
@@ -31,7 +31,7 @@
     "node": ">=20.0.0"
   },
   "dependencies": {
-    "@jarkkojs/readseek": "^0.8.24",
+    "@jarkkojs/readseek": "^0.9.1",
     "@opencode-ai/plugin": "^1.17.20"
   },
   "devDependencies": {