pi-readseek 0.8.24 → 0.9.0

package/dist/index.ts

@@ -35,7 +35,10 @@ var REPLACEABLE_TOOL_GUIDELINES = {
 };
 var COMPACT_GUIDELINES = {
   "read.md": [
-    "Use readSeek_read with map or symbol to inspect large files without reading them in full."
+    "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."
@@ -88,34 +91,10 @@ import * as Diff from "diff";
 
 // src/hashline.ts
 import xxhashWasm from "xxhash-wasm";
-
-// src/runtime.ts
-function throwIfAborted(signal) {
-  if (signal?.aborted)
-    throw new Error("Operation aborted");
-}
-
-// src/confusable-hyphens.ts
-var CONFUSABLE_HYPHENS_RE = /[\u2010\u2011\u2012\u2013\u2014\u2015\u2212\uFE63\uFF0D]/g;
-
-// src/hashline.ts
-class HashlineMismatchError extends Error {
-  updatedAnchors;
-  constructor(message, updatedAnchors) {
-    super(message);
-    this.name = "HashlineMismatchError";
-    this.updatedAnchors = updatedAnchors;
-  }
-}
 var HASH_LEN = 3;
 var RADIX = 16;
 var HASH_MOD = RADIX ** HASH_LEN;
 var DICT = Array.from({ length: HASH_MOD }, (_, i) => i.toString(RADIX).padStart(HASH_LEN, "0"));
-var HASHLINE_PREFIX_RE = /^[\s>]*\d+:[0-9a-zA-Z]{1,16}\|/;
-var DIFF_PLUS_RE = /^\+(?!\+)/;
-var HASH_ONLY_PREFIX_RE = /^[0-9a-f]{3}\|/;
-var HASH_RELOCATION_WINDOW_BASE = 20;
-var HASH_RELOCATION_WINDOW_CAP = 100;
 var HASHLINE_STATE_KEY = Symbol.for("pi-readseek.hashlineState.v1");
 function getHashlineState() {
   const globalObject = globalThis;
@@ -158,734 +137,19 @@ function escapeControlCharsForDisplay(text) {
 function formatHashlineDisplay(lineNumber, content) {
   return `${lineNumber}:${computeLineHash(content)}|${escapeControlCharsForDisplay(content)}`;
 }
-function parseLineRef(ref) {
-  const firstLine = ref.split(/\r?\n/, 1)[0];
-  const contentMatch = firstLine.match(/^[^|]*\|(.*)$/);
-  const contentAfterPipe = contentMatch ? contentMatch[1] : undefined;
-  const cleaned = firstLine.replace(/\|.*$/, "").replace(/^[\s>]+/, "").replace(/ {2}.*$/, "").trim();
-  const normalized = cleaned.replace(/\s*:\s*/, ":");
-  const match = normalized.match(new RegExp(`^(\\d+):([0-9a-fA-F]{${HASH_LEN}})$`));
-  if (!match)
-    throw new Error(`Invalid line reference "${ref}". Expected "LINE:HASH" (e.g. "5:abc").`);
-  const line = Number.parseInt(match[1], 10);
-  if (!Number.isSafeInteger(line))
-    throw new Error(`Line number must be a safe integer, got ${match[1]} in "${ref}".`);
-  if (line < 1)
-    throw new Error(`Line number must be >= 1, got ${line} in "${ref}".`);
-  return { line, hash: match[2], content: contentAfterPipe };
-}
-function tokenSimilarity(a, b) {
-  const tokA = new Set(a.trim().split(/\s+/));
-  const tokB = new Set(b.trim().split(/\s+/));
-  if (tokA.size === 0 && tokB.size === 0)
-    return 1;
-  if (tokA.size === 0 || tokB.size === 0)
-    return 0;
-  let overlap = 0;
-  for (const t of tokA) {
-    if (tokB.has(t))
-      overlap++;
-  }
-  return overlap / Math.max(tokA.size, tokB.size);
-}
-function findSimilarLines(expectedContent, fileLines, hintLine, maxSuggestions = 3) {
-  const SCAN_WINDOW = 50;
-  const MIN_SIMILARITY = 0.3;
-  const start = Math.max(0, hintLine - 1 - SCAN_WINDOW);
-  const end = Math.min(fileLines.length, hintLine - 1 + SCAN_WINDOW + 1);
-  const candidates = [];
-  for (let i = start;i < end; i++) {
-    const content = fileLines[i];
-    if (!content.trim())
-      continue;
-    const score = tokenSimilarity(expectedContent, content);
-    if (score >= MIN_SIMILARITY) {
-      candidates.push({ line: i + 1, score, content });
-    }
-  }
-  candidates.sort((a, b) => b.score - a.score);
-  return candidates.slice(0, maxSuggestions).map((c) => {
-    const hash = computeLineHash(c.content);
-    return `  ${c.line}:${hash}|${escapeControlCharsForDisplay(c.content)}`;
-  });
-}
-function formatMismatchError(mismatches, fileLines, relocationWindow) {
-  const mismatchSet = new Map;
-  for (const m of mismatches)
-    mismatchSet.set(m.line, m);
-  const updatedAnchors = mismatches.map((m) => {
-    const raw = fileLines[m.line - 1] ?? "";
-    const hash = computeLineHash(raw);
-    return {
-      line: m.line,
-      hash,
-      anchor: `${m.line}:${hash}`,
-      raw,
-      display: escapeControlCharsForDisplay(raw)
-    };
-  });
-  const displayLines = new Set;
-  for (const m of mismatches) {
-    for (let i = Math.max(1, m.line - 2);i <= Math.min(fileLines.length, m.line + 2); i++) {
-      displayLines.add(i);
-    }
-  }
-  const sorted = [...displayLines].sort((a, b) => a - b);
-  const out = [
-    "Edit rejected — nothing was written. The anchor hash did not match the current file content.",
-    `${mismatches.length} line${mismatches.length > 1 ? "s have" : " has"} changed since last read. Auto-relocation checks only within ±${relocationWindow} lines of each anchor. Use the updated LINE:HASH references shown below (>>> marks changed lines).`,
-    ""
-  ];
-  let prev = -1;
-  for (const num of sorted) {
-    if (prev !== -1 && num > prev + 1)
-      out.push("    ...");
-    prev = num;
-    const content = fileLines[num - 1];
-    const hash = computeLineHash(content);
-    const prefix = `${num}:${hash}`;
-    out.push(mismatchSet.has(num) ? `>>> ${prefix}|${escapeControlCharsForDisplay(content)}` : `    ${prefix}|${escapeControlCharsForDisplay(content)}`);
-  }
-  const withContent = mismatches.filter((m) => m.expectedContent !== undefined);
-  if (withContent.length > 0) {
-    for (const m of withContent) {
-      const suggestions = findSimilarLines(m.expectedContent, fileLines, m.line);
-      if (suggestions.length > 0) {
-        out.push("");
-        out.push("Did you mean one of these nearby lines?");
-        out.push(...suggestions);
-      }
-    }
-  }
-  return { message: out.join(`
-`), updatedAnchors };
-}
-function splitDst(dst) {
-  if (dst === "")
-    return [];
-  const normalized = dst.replace(/\r\n/g, `
-`).replace(/\r/g, `
-`).replace(/\n$/, "");
-  return normalized.split(`
-`);
-}
-function stripNewLinePrefixes(lines) {
-  let hashCount = 0;
-  let hashOnlyCount = 0;
-  let plusCount = 0;
-  let nonEmpty = 0;
-  for (const l of lines) {
-    if (!l.length)
-      continue;
-    nonEmpty++;
-    if (HASHLINE_PREFIX_RE.test(l))
-      hashCount++;
-    else if (HASH_ONLY_PREFIX_RE.test(l))
-      hashOnlyCount++;
-    if (DIFF_PLUS_RE.test(l))
-      plusCount++;
-  }
-  if (!nonEmpty)
-    return lines;
-  const stripHash = hashCount > 0 && hashCount >= nonEmpty * 0.5;
-  const stripHashOnly = !stripHash && nonEmpty >= 2 && hashOnlyCount > 0 && hashOnlyCount >= nonEmpty * 0.5;
-  const stripPlus = !stripHash && !stripHashOnly && plusCount > 0 && plusCount >= nonEmpty * 0.5;
-  if (!stripHash && !stripHashOnly && !stripPlus)
-    return lines;
-  return lines.map((l) => stripHash ? l.replace(HASHLINE_PREFIX_RE, "") : stripHashOnly ? l.replace(HASH_ONLY_PREFIX_RE, "") : stripPlus ? l.replace(DIFF_PLUS_RE, "") : l);
-}
-function stripAllWhitespace(s) {
-  return s.replace(/\s+/g, "");
-}
-function stripTrailingContinuationTokens(s) {
-  return s.replace(/(?:&&|\|\||\?\?|\?|:|=|,|\+|-|\*|\/|\.|\()\s*$/u, "");
-}
-function stripMergeOperatorChars(s) {
-  return s.replace(/[|&?]/g, "");
-}
-function normalizeConfusableHyphensInLines(lines) {
-  return lines.map((line) => line.replace(CONFUSABLE_HYPHENS_RE, "-"));
-}
-function wsEq(a, b) {
-  return a === b || a.replace(/\s+/g, "") === b.replace(/\s+/g, "");
-}
-function restoreIndent(tpl, line) {
-  if (!line.length)
-    return line;
-  const indent = tpl.match(/^\s*/)?.[0] ?? "";
-  if (!indent.length || (line.match(/^\s*/)?.[0] ?? "").length > 0)
-    return line;
-  return indent + line;
-}
-function restoreIndentPaired(old, next) {
-  if (old.length !== next.length)
-    return next;
-  let changed = false;
-  const out = next.map((line, i) => {
-    const restored = restoreIndent(old[i], line);
-    if (restored !== line)
-      changed = true;
-    return restored;
-  });
-  return changed ? out : next;
-}
-function restoreOldWrappedLines(oldLines, newLines) {
-  if (oldLines.length === 0 || newLines.length < 2)
-    return newLines;
-  const canonToOld = new Map;
-  for (const line of oldLines) {
-    const canon = stripAllWhitespace(line);
-    const bucket = canonToOld.get(canon);
-    if (bucket)
-      bucket.count++;
-    else
-      canonToOld.set(canon, { line, count: 1 });
-  }
-  const candidates = [];
-  for (let start = 0;start < newLines.length; start++) {
-    for (let len = 2;len <= 10 && start + len <= newLines.length; len++) {
-      const span = newLines.slice(start, start + len);
-      if (span.some((line) => line.trim().length === 0))
-        continue;
-      const canonSpan = stripAllWhitespace(span.join(""));
-      const old = canonToOld.get(canonSpan);
-      if (old && old.count === 1 && canonSpan.length >= 6) {
-        candidates.push({ start, len, replacement: old.line, canon: canonSpan });
-      }
-    }
-  }
-  if (candidates.length === 0)
-    return newLines;
-  const canonCounts = new Map;
-  for (const c of candidates) {
-    canonCounts.set(c.canon, (canonCounts.get(c.canon) ?? 0) + 1);
-  }
-  const uniqueCandidates = candidates.filter((c) => (canonCounts.get(c.canon) ?? 0) === 1);
-  if (uniqueCandidates.length === 0)
-    return newLines;
-  uniqueCandidates.sort((a, b) => b.start - a.start);
-  const out = [...newLines];
-  for (const c of uniqueCandidates) {
-    out.splice(c.start, c.len, c.replacement);
-  }
-  return out;
-}
-function stripInsertAnchorEcho(anchorLine, dst) {
-  if (dst.length > 1 && wsEq(dst[0], anchorLine))
-    return dst.slice(1);
-  return dst;
-}
-function stripRangeBoundaryEcho(fileLines, start, end, dst) {
-  const count = end - start + 1;
-  if (dst.length <= 1 || dst.length <= count)
-    return dst;
-  let out = dst;
-  if (start - 2 >= 0 && wsEq(out[0], fileLines[start - 2]))
-    out = out.slice(1);
-  if (end < fileLines.length && out.length > 0 && wsEq(out[out.length - 1], fileLines[end]))
-    out = out.slice(0, -1);
-  return out;
-}
-function parseHashlineEditItem(edit) {
-  if ("set_line" in edit) {
-    return {
-      spec: { kind: "single", ref: parseLineRef(edit.set_line.anchor) },
-      dstLines: stripNewLinePrefixes(splitDst(edit.set_line.new_text))
-    };
-  }
-  if ("replace_lines" in edit) {
-    const start = parseLineRef(edit.replace_lines.start_anchor);
-    const end = parseLineRef(edit.replace_lines.end_anchor);
-    return {
-      spec: start.line === end.line ? { kind: "single", ref: start } : { kind: "range", start, end },
-      dstLines: stripNewLinePrefixes(splitDst(edit.replace_lines.new_text))
-    };
-  }
-  if ("insert_after" in edit) {
-    return {
-      spec: { kind: "insertAfter", after: parseLineRef(edit.insert_after.anchor) },
-      dstLines: stripNewLinePrefixes(splitDst(edit.insert_after.new_text ?? ""))
-    };
-  }
-  throw new Error("replace edits are applied separately");
-}
-function applyHashlineEdits(content, edits, signal) {
-  throwIfAborted(signal);
-  if (!edits.length)
-    return { content, firstChangedLine: undefined };
-  const relocationWindow = Math.min(Math.max(HASH_RELOCATION_WINDOW_BASE, edits.length * 5), HASH_RELOCATION_WINDOW_CAP);
-  const fileLines = content.split(`
-`);
-  const origLines = [...fileLines];
-  let firstChanged;
-  const noopEdits = [];
-  const parsed = edits.map((edit, idx) => ({
-    ...parseHashlineEditItem(edit),
-    idx
-  }));
-  function collectExplicitlyTouchedLines() {
-    const touched = new Set;
-    for (const { spec } of parsed) {
-      if (spec.kind === "single")
-        touched.add(spec.ref.line);
-      else if (spec.kind === "insertAfter")
-        touched.add(spec.after.line);
-      else
-        for (let line = spec.start.line;line <= spec.end.line; line++)
-          touched.add(line);
-    }
-    return touched;
-  }
-  let explicitlyTouchedLines = collectExplicitlyTouchedLines();
-  const lineHashes = [];
-  const hashToLines = new Map;
-  for (let i = 0;i < fileLines.length; i++) {
-    throwIfAborted(signal);
-    const lineNumber = i + 1;
-    const h = computeLineHash(fileLines[i]);
-    lineHashes.push(h);
-    const lines = hashToLines.get(h);
-    if (lines)
-      lines.push(lineNumber);
-    else
-      hashToLines.set(h, [lineNumber]);
-  }
-  const relocationNotes = new Set;
-  function findRelocationLine(expectedHash, hintLine, relocationWindow2) {
-    const candidates = hashToLines.get(expectedHash);
-    if (!candidates?.length)
-      return;
-    const minLine = Math.max(1, hintLine - relocationWindow2);
-    const maxLine = Math.min(fileLines.length, hintLine + relocationWindow2);
-    let match;
-    for (const candidate of candidates) {
-      if (candidate < minLine || candidate > maxLine)
-        continue;
-      if (match !== undefined)
-        return;
-      match = candidate;
-    }
-    return match;
-  }
-  const mismatches = [];
-  function validate(ref) {
-    if (ref.line < 1 || ref.line > fileLines.length)
-      throw new Error(`Line ${ref.line} does not exist (file has ${fileLines.length} lines)`);
-    const expected = ref.hash.toLowerCase();
-    const originalLine = ref.line;
-    const actual = lineHashes[originalLine - 1];
-    if (actual === expected)
-      return true;
-    const relocated = findRelocationLine(expected, originalLine, relocationWindow);
-    if (relocated !== undefined) {
-      ref.line = relocated;
-      relocationNotes.add(`Auto-relocated anchor ${originalLine}:${ref.hash} -> ${relocated}:${ref.hash} (window ±${relocationWindow}).`);
-      return true;
-    }
-    if (ref.content) {
-      const FUZZY_THRESHOLD = 0.8;
-      const FUZZY_SCAN = 50;
-      const scanStart = Math.max(0, originalLine - 1 - FUZZY_SCAN);
-      const scanEnd = Math.min(fileLines.length, originalLine - 1 + FUZZY_SCAN + 1);
-      const fuzzyHits = [];
-      for (let i = scanStart;i < scanEnd; i++) {
-        const lineContent = fileLines[i];
-        if (!lineContent.trim())
-          continue;
-        const score = tokenSimilarity(ref.content, lineContent);
-        if (score > FUZZY_THRESHOLD) {
-          fuzzyHits.push({ line: i + 1, score });
-        }
-      }
-      if (fuzzyHits.length === 1) {
-        const hit = fuzzyHits[0];
-        const newHash = computeLineHash(fileLines[hit.line - 1]);
-        ref.line = hit.line;
-        ref.hash = newHash;
-        relocationNotes.add(`Fuzzy-relocated anchor ${originalLine}:${expected} → ${hit.line}:${newHash} (similarity: ${hit.score.toFixed(2)})`);
-        return true;
-      }
-    }
-    mismatches.push({ line: originalLine, expected: ref.hash, actual, expectedContent: ref.content });
-    return false;
-  }
-  for (const { spec } of parsed) {
-    throwIfAborted(signal);
-    if (spec.kind === "single") {
-      validate(spec.ref);
-    } else if (spec.kind === "insertAfter") {
-      validate(spec.after);
-    } else {
-      if (spec.start.line > spec.end.line) {
-        throw new Error(`Range start line ${spec.start.line} must be <= end line ${spec.end.line}`);
-      }
-      const originalStart = spec.start.line;
-      const originalEnd = spec.end.line;
-      const originalCount = originalEnd - originalStart + 1;
-      const startOk = validate(spec.start);
-      const endOk = validate(spec.end);
-      if (startOk && endOk) {
-        const relocatedCount = spec.end.line - spec.start.line + 1;
-        const invalidRange = spec.start.line > spec.end.line;
-        const scopeChanged = relocatedCount !== originalCount;
-        if (invalidRange || scopeChanged) {
-          spec.start.line = originalStart;
-          spec.end.line = originalEnd;
-          mismatches.push({ line: originalStart, expected: spec.start.hash, actual: lineHashes[originalStart - 1] }, { line: originalEnd, expected: spec.end.hash, actual: lineHashes[originalEnd - 1] });
-        }
-      }
-    }
-  }
-  if (mismatches.length) {
-    const formatted = formatMismatchError(mismatches, fileLines, relocationWindow);
-    throw new HashlineMismatchError(formatted.message, formatted.updatedAnchors);
-  }
-  explicitlyTouchedLines = collectExplicitlyTouchedLines();
-  const duplicateTargetWarnings = [];
-  const warnedSingleTargets = new Set;
-  const seenSingleTargets = new Map;
-  const seenSingleEditByKey = new Map;
-  const seenNonSingleEditByKey = new Map;
-  const dupes = new Set;
-  for (let i = 0;i < parsed.length; i++) {
-    throwIfAborted(signal);
-    const p = parsed[i];
-    const lk = p.spec.kind === "single" ? `s:${p.spec.ref.line}` : p.spec.kind === "range" ? `r:${p.spec.start.line}:${p.spec.end.line}` : `i:${p.spec.after.line}`;
-    const dstKey = p.dstLines.join(`
-`);
-    const key = `${lk}|${dstKey}`;
-    if (p.spec.kind === "single") {
-      const previousIdx = seenSingleEditByKey.get(key);
-      if (previousIdx !== undefined)
-        dupes.add(previousIdx);
-      seenSingleEditByKey.set(key, i);
-      const previousDstKey = seenSingleTargets.get(lk);
-      if (previousDstKey !== undefined && previousDstKey !== dstKey && !warnedSingleTargets.has(lk)) {
-        duplicateTargetWarnings.push(`Warning: multiple edits target the same anchor ${p.spec.ref.line}:${p.spec.ref.hash} — only the last will apply`);
-        warnedSingleTargets.add(lk);
-      }
-      seenSingleTargets.set(lk, dstKey);
-      continue;
-    }
-    if (seenNonSingleEditByKey.has(key)) {
-      dupes.add(i);
-    } else {
-      seenNonSingleEditByKey.set(key, i);
-    }
-  }
-  const deduped = parsed.filter((_, i) => !dupes.has(i));
-  const sorted = deduped.map((p) => {
-    const sl = p.spec.kind === "single" ? p.spec.ref.line : p.spec.kind === "range" ? p.spec.end.line : p.spec.after.line;
-    const pr = p.spec.kind === "insertAfter" ? 1 : 0;
-    return { ...p, sl, pr };
-  }).sort((a, b) => b.sl - a.sl || a.pr - b.pr || a.idx - b.idx);
-  function track(line) {
-    if (firstChanged === undefined || line < firstChanged)
-      firstChanged = line;
-  }
-  function maybeExpandSingleLineMerge(line, dst) {
-    if (dst.length !== 1)
-      return null;
-    if (line < 1 || line > fileLines.length)
-      return null;
-    const newLine = dst[0];
-    const newCanon = stripAllWhitespace(newLine);
-    const newCanonForMergeOps = stripMergeOperatorChars(newCanon);
-    if (!newCanon.length)
-      return null;
-    const orig = fileLines[line - 1];
-    const origCanon = stripAllWhitespace(orig);
-    const origCanonForMatch = stripTrailingContinuationTokens(origCanon);
-    const origCanonForMergeOps = stripMergeOperatorChars(origCanon);
-    const origLooksLikeContinuation = origCanonForMatch.length < origCanon.length;
-    if (!origCanon.length)
-      return null;
-    const nextIdx = line;
-    const prevIdx = line - 2;
-    if (origLooksLikeContinuation && nextIdx < fileLines.length && !explicitlyTouchedLines.has(line + 1)) {
-      const next = fileLines[nextIdx];
-      const nextCanon = stripAllWhitespace(next);
-      const a = newCanon.indexOf(origCanonForMatch);
-      const b = newCanon.indexOf(nextCanon);
-      if (a !== -1 && b !== -1 && a < b && newCanon.length <= origCanon.length + nextCanon.length + 32) {
-        return { startLine: line, deleteCount: 2, newLines: [newLine] };
-      }
-    }
-    if (prevIdx >= 0 && !explicitlyTouchedLines.has(line - 1)) {
-      const prev = fileLines[prevIdx];
-      const prevCanon = stripAllWhitespace(prev);
-      const prevCanonForMatch = stripTrailingContinuationTokens(prevCanon);
-      const prevLooksLikeContinuation = prevCanonForMatch.length < prevCanon.length;
-      if (!prevLooksLikeContinuation)
-        return null;
-      const a = newCanonForMergeOps.indexOf(stripMergeOperatorChars(prevCanonForMatch));
-      const b = newCanonForMergeOps.indexOf(origCanonForMergeOps);
-      if (a !== -1 && b !== -1 && a < b && newCanon.length <= prevCanon.length + origCanon.length + 32) {
-        return { startLine: line - 1, deleteCount: 2, newLines: [newLine] };
-      }
-    }
-    return null;
-  }
-  for (const { spec, dstLines, idx } of sorted) {
-    throwIfAborted(signal);
-    if (spec.kind === "single") {
-      const merged = maybeExpandSingleLineMerge(spec.ref.line, dstLines);
-      if (merged) {
-        const orig2 = origLines.slice(merged.startLine - 1, merged.startLine - 1 + merged.deleteCount);
-        let newL2 = restoreIndentPaired([orig2[0] ?? ""], merged.newLines);
-        if (orig2.join(`
-`) === newL2.join(`
-`) && orig2.some((line) => CONFUSABLE_HYPHENS_RE.test(line))) {
-          newL2 = normalizeConfusableHyphensInLines(newL2);
-        }
-        if (orig2.join(`
-`) === newL2.join(`
-`)) {
-          noopEdits.push({ editIndex: idx, loc: `${spec.ref.line}:${spec.ref.hash}`, currentContent: orig2.join(`
-`) });
-          continue;
-        }
-        fileLines.splice(merged.startLine - 1, merged.deleteCount, ...newL2);
-        track(merged.startLine);
-        continue;
-      }
-      const orig = origLines.slice(spec.ref.line - 1, spec.ref.line);
-      let stripped = stripRangeBoundaryEcho(origLines, spec.ref.line, spec.ref.line, dstLines);
-      stripped = restoreOldWrappedLines(orig, stripped);
-      let newL = restoreIndentPaired(orig, stripped);
-      if (orig.join(`
-`) === newL.join(`
-`) && orig.some((line) => CONFUSABLE_HYPHENS_RE.test(line))) {
-        newL = normalizeConfusableHyphensInLines(newL);
-      }
-      if (orig.length === newL.length && orig.join(`
-`) === newL.join(`
-`)) {
-        noopEdits.push({ editIndex: idx, loc: `${spec.ref.line}:${spec.ref.hash}`, currentContent: orig.join(`
-`) });
-        continue;
-      }
-      fileLines.splice(spec.ref.line - 1, 1, ...newL);
-      track(spec.ref.line);
-    } else if (spec.kind === "range") {
-      const count = spec.end.line - spec.start.line + 1;
-      const orig = origLines.slice(spec.start.line - 1, spec.start.line - 1 + count);
-      let stripped = stripRangeBoundaryEcho(origLines, spec.start.line, spec.end.line, dstLines);
-      stripped = restoreOldWrappedLines(orig, stripped);
-      let newL = restoreIndentPaired(orig, stripped);
-      if (orig.join(`
-`) === newL.join(`
-`) && orig.some((line) => CONFUSABLE_HYPHENS_RE.test(line))) {
-        newL = normalizeConfusableHyphensInLines(newL);
-      }
-      if (orig.length === newL.length && orig.join(`
-`) === newL.join(`
-`)) {
-        noopEdits.push({ editIndex: idx, loc: `${spec.start.line}:${spec.start.hash}`, currentContent: orig.join(`
-`) });
-        continue;
-      }
-      fileLines.splice(spec.start.line - 1, count, ...newL);
-      track(spec.start.line);
-    } else {
-      const anchor = origLines[spec.after.line - 1];
-      const inserted = stripInsertAnchorEcho(anchor, dstLines);
-      if (!inserted.length) {
-        noopEdits.push({ editIndex: idx, loc: `${spec.after.line}:${spec.after.hash}`, currentContent: anchor });
-        continue;
-      }
-      if (content === "" && spec.after.line === 1 && anchor === "") {
-        fileLines.splice(0, 1, ...inserted);
-        track(1);
-        continue;
-      }
-      fileLines.splice(spec.after.line, 0, ...inserted);
-      track(spec.after.line + 1);
-    }
-  }
-  const warnings = [...relocationNotes, ...duplicateTargetWarnings];
-  let diff = Math.abs(fileLines.length - origLines.length);
-  for (let i = 0;i < Math.min(fileLines.length, origLines.length); i++) {
-    if (fileLines[i] !== origLines[i])
-      diff++;
-  }
-  if (diff > edits.length * 4) {
-    warnings.push(`Edit changed ${diff} lines across ${edits.length} operations — verify no unintended reformatting.`);
-  }
-  return {
-    content: fileLines.join(`
-`),
-    firstChangedLine: firstChanged,
-    ...warnings.length ? { warnings } : {},
-    ...noopEdits.length ? { noopEdits } : {}
-  };
-}
 
 // src/edit-diff.ts
-function detectLineEnding(content) {
-  let crlf = 0;
-  let lf = 0;
-  for (let i = 0;i < content.length; i++) {
-    if (content[i] === "\r" && i + 1 < content.length && content[i + 1] === `
-`) {
-      crlf++;
-      i++;
-    } else if (content[i] === `
-`) {
-      lf++;
-    }
-  }
-  if (lf === 0 && crlf === 0)
-    return `
-`;
-  if (lf === 0)
-    return `\r
-`;
-  if (crlf === 0)
-    return `
-`;
-  return crlf > lf ? `\r
-` : `
-`;
-}
 function normalizeToLF(text) {
   return text.replace(/\r\n/g, `
 `).replace(/\r/g, `
 `);
 }
-function restoreLineEndings(text, ending) {
-  return ending === `\r
-` ? text.replace(/\n/g, `\r
-`) : text;
-}
 function stripBom(content) {
   return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
 }
 function hasBareCarriageReturn(content) {
   return content.replace(/\r\n/g, "").includes("\r");
 }
-var SINGLE_QUOTES_RE = /[\u2018\u2019\u201A\u201B]/g;
-var DOUBLE_QUOTES_RE = /[\u201C\u201D\u201E\u201F]/g;
-var UNICODE_SPACES_RE = /[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g;
-function normalizeFuzzyChar(ch) {
-  return ch.replace(SINGLE_QUOTES_RE, "'").replace(DOUBLE_QUOTES_RE, '"').replace(CONFUSABLE_HYPHENS_RE, "-").replace(UNICODE_SPACES_RE, " ");
-}
-function normalizeForFuzzyMatch(text) {
-  return text.split(`
-`).map((line) => line.trimEnd()).join(`
-`).replace(SINGLE_QUOTES_RE, "'").replace(DOUBLE_QUOTES_RE, '"').replace(CONFUSABLE_HYPHENS_RE, "-").replace(UNICODE_SPACES_RE, " ");
-}
-function buildNormalizedWithMap(text) {
-  const lines = text.split(`
-`);
-  const normalizedChars = [];
-  const indexMap = [];
-  let originalOffset = 0;
-  for (let i = 0;i < lines.length; i++) {
-    const line = lines[i];
-    const trimmed = line.replace(/\s+$/u, "");
-    for (let j = 0;j < trimmed.length; j++) {
-      normalizedChars.push(normalizeFuzzyChar(trimmed[j]));
-      indexMap.push(originalOffset + j);
-    }
-    if (i < lines.length - 1) {
-      normalizedChars.push(`
-`);
-      indexMap.push(originalOffset + line.length);
-    }
-    originalOffset += line.length + 1;
-  }
-  return { normalized: normalizedChars.join(""), indexMap };
-}
-function mapNormalizedSpanToOriginal(indexMap, normalizedStart, normalizedLength) {
-  if (normalizedStart < 0 || normalizedLength <= 0)
-    return null;
-  const normalizedEnd = normalizedStart + normalizedLength;
-  if (normalizedEnd > indexMap.length)
-    return null;
-  const start = indexMap[normalizedStart];
-  const end = indexMap[normalizedEnd - 1];
-  if (start === undefined || end === undefined || end < start)
-    return null;
-  return { index: start, matchLength: end - start + 1 };
-}
-function fuzzyFindText(content, oldText) {
-  const exactIndex = content.indexOf(oldText);
-  if (exactIndex !== -1) {
-    return { found: true, index: exactIndex, matchLength: oldText.length, usedFuzzyMatch: false };
-  }
-  const normalizedNeedle = normalizeForFuzzyMatch(oldText);
-  if (!normalizedNeedle.length)
-    return { found: false, index: -1, matchLength: 0, usedFuzzyMatch: false };
-  const { normalized, indexMap } = buildNormalizedWithMap(content);
-  const normalizedIndex = normalized.indexOf(normalizedNeedle);
-  if (normalizedIndex === -1) {
-    return { found: false, index: -1, matchLength: 0, usedFuzzyMatch: false };
-  }
-  const mapped = mapNormalizedSpanToOriginal(indexMap, normalizedIndex, normalizedNeedle.length);
-  if (!mapped) {
-    return { found: false, index: -1, matchLength: 0, usedFuzzyMatch: false };
-  }
-  return { found: true, index: mapped.index, matchLength: mapped.matchLength, usedFuzzyMatch: true };
-}
-function replaceText(content, oldText, newText, opts) {
-  if (!oldText.length)
-    return { content, count: 0, usedFuzzyMatch: false };
-  const normalizedNew = normalizeToLF(newText);
-  if (opts.all) {
-    const exactCount = content.split(oldText).length - 1;
-    if (exactCount > 0) {
-      return { content: content.split(oldText).join(normalizedNew), count: exactCount, usedFuzzyMatch: false };
-    }
-    if (!opts.fuzzy)
-      return { content, count: 0, usedFuzzyMatch: false };
-    const normalizedNeedle = normalizeForFuzzyMatch(oldText);
-    if (!normalizedNeedle.length)
-      return { content, count: 0, usedFuzzyMatch: false };
-    const { normalized, indexMap } = buildNormalizedWithMap(content);
-    const spans = [];
-    let searchFrom = 0;
-    while (searchFrom <= normalized.length - normalizedNeedle.length) {
-      const pos = normalized.indexOf(normalizedNeedle, searchFrom);
-      if (pos === -1)
-        break;
-      const mapped = mapNormalizedSpanToOriginal(indexMap, pos, normalizedNeedle.length);
-      if (mapped) {
-        const prev = spans[spans.length - 1];
-        if (!prev || mapped.index >= prev.index + prev.matchLength) {
-          spans.push(mapped);
-        }
-      }
-      searchFrom = pos + Math.max(1, normalizedNeedle.length);
-    }
-    if (!spans.length)
-      return { content, count: 0, usedFuzzyMatch: false };
-    let out = content;
-    for (let i = spans.length - 1;i >= 0; i--) {
-      const span = spans[i];
-      out = out.substring(0, span.index) + normalizedNew + out.substring(span.index + span.matchLength);
-    }
-    return { content: out, count: spans.length, usedFuzzyMatch: true };
-  }
-  const exactIndex = content.indexOf(oldText);
-  if (exactIndex !== -1) {
-    return {
-      content: content.substring(0, exactIndex) + normalizedNew + content.substring(exactIndex + oldText.length),
-      count: 1,
-      usedFuzzyMatch: false
-    };
-  }
-  if (!opts.fuzzy)
-    return { content, count: 0, usedFuzzyMatch: false };
-  const result = fuzzyFindText(content, oldText);
-  if (!result.found)
-    return { content, count: 0, usedFuzzyMatch: false };
-  return {
-    content: content.substring(0, result.index) + normalizedNew + content.substring(result.index + result.matchLength),
-    count: 1,
-    usedFuzzyMatch: result.usedFuzzyMatch
-  };
-}
 function generateDiffString(oldContent, newContent, contextLines = 4) {
   const parts = Diff.diffLines(oldContent, newContent);
   const output = [];
@@ -1121,6 +385,12 @@ function resolveToCwd(filePath, cwd) {
   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) {
@@ -1182,7 +452,7 @@ var READSEEK_TOOL_REPLACEMENTS = {
   grep: "readSeek_grep",
   write: "readSeek_write"
 };
-var READSEEK_KEYS = ["replacedTools", "imageMode", "syntaxValidation", "timeoutMs", "grep", "display"];
+var READSEEK_KEYS = ["overrideTools", "imageMode", "syntaxValidation", "timeoutMs", "grep", "display"];
 var READSEEK_GREP_KEYS = ["maxLines", "maxBytes"];
 var READSEEK_DISPLAY_KEYS = ["read", "grep", "edit", "write"];
 var DEFAULT_DISPLAY_MODES = {
@@ -1238,12 +508,12 @@ function readImageMode(raw, source, warnings) {
   warnings.push(invalid(source, "readseek.imageMode"));
   return;
 }
-function readReplacedTools(raw, source, warnings) {
-  if (!("replacedTools" in raw))
+function readOverrideTools(raw, source, warnings) {
+  if (!("overrideTools" in raw))
     return;
-  const value = raw.replacedTools;
+  const value = raw.overrideTools;
   if (!Array.isArray(value)) {
-    warnings.push(invalid(source, "readseek.replacedTools"));
+    warnings.push(invalid(source, "readseek.overrideTools"));
     return;
   }
   const tools = [];
@@ -1251,7 +521,7 @@ function readReplacedTools(raw, source, warnings) {
     if (typeof tool === "string" && Object.hasOwn(READSEEK_TOOL_REPLACEMENTS, tool)) {
       tools.push(tool);
     } else {
-      warnings.push(invalid(source, `readseek.replacedTools[${index}]`));
+      warnings.push(invalid(source, `readseek.overrideTools[${index}]`));
     }
   });
   return tools;
@@ -1296,9 +566,9 @@ function validateSettings(raw, source) {
   }
   const section = raw.readseek;
   warnUnknownKeys(section, READSEEK_KEYS, "readseek", source, warnings);
-  const replacedTools = readReplacedTools(section, source, warnings);
-  if (replacedTools !== undefined)
-    settings.replacedTools = replacedTools;
+  const overrideTools = readOverrideTools(section, source, warnings);
+  if (overrideTools !== undefined)
+    settings.overrideTools = overrideTools;
   const imageMode = readImageMode(section, source, warnings);
   if (imageMode !== undefined)
     settings.imageMode = imageMode;
@@ -1398,6 +668,9 @@ function appendGitSelection(args, options) {
   if (selection.length > 0)
     args.push("--git", selection.join(","));
 }
+function lineLocationSelector(line, column) {
+  return column === undefined ? `line:${line}` : `line:${line}:${column}`;
+}
 function normalizeLanguage(language) {
   return language === "java" ? "Java" : language;
 }
@@ -1458,6 +731,8 @@ function readSeekPlatform() {
   return `${process.platform}-${process.arch}`;
 }
 function readSeekBinaryPath() {
+  if (process.env.READSEEK_BIN)
+    return process.env.READSEEK_BIN;
   const platform = readSeekPlatform();
   const platformPackage = READSEEK_PLATFORM_PACKAGES[platform];
   if (!platformPackage) {
@@ -1553,13 +828,19 @@ async function spawnReadSeekRaw(args, options = {}) {
     };
     const stdin = options.stdin;
     const stdio = [stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"];
-    const child = spawn(readSeekBinaryPath(), args, { stdio, signal: options.signal });
-    const timeoutMs = options.timeoutMs ?? readSeekTimeoutMs();
-    timeout = setTimeout(() => {
-      child.kill("SIGKILL");
-      fail(new Error(`readseek timed out after ${timeoutMs} ms`));
-    }, timeoutMs);
-    timeout.unref?.();
+    const cancelable = options.cancelable !== false;
+    const child = spawn(readSeekBinaryPath(), args, {
+      stdio,
+      signal: cancelable ? options.signal : undefined
+    });
+    if (cancelable) {
+      const timeoutMs = options.timeoutMs ?? readSeekTimeoutMs();
+      timeout = setTimeout(() => {
+        child.kill("SIGKILL");
+        fail(new Error(`readseek timed out after ${timeoutMs} ms`));
+      }, timeoutMs);
+      timeout.unref?.();
+    }
     const childStdout = child.stdout;
     const childStderr = child.stderr;
     const childStdin = child.stdin;
@@ -1644,10 +925,15 @@ async function readSeekView(filePath, options = {}) {
     args.push("--depth", String(options.depth));
   if (options.outline)
     args.push("--outline");
-  return runReadSeekRaw(args, { signal: options.signal });
+  if (options.visionMode !== undefined)
+    args.push("--vision-mode", options.visionMode);
+  if (options.visionLevel !== undefined)
+    args.push("--vision-level", options.visionLevel);
+  const runOptions = { signal: options.signal };
+  return options.visionMode !== undefined ? runReadSeekVisionRaw(args, runOptions) : runReadSeekRaw(args, runOptions);
 }
 var visionInvocationTail = Promise.resolve();
-async function runReadSeekVision(args, options = {}) {
+async function runReadSeekVisionRaw(args, options = {}) {
   let release;
   const gate = new Promise((resolve) => {
     release = resolve;
@@ -1676,7 +962,7 @@ async function runReadSeekVision(args, options = {}) {
       await predecessor;
     }
     signal?.throwIfAborted();
-    return await runReadSeek(args, {
+    return await runReadSeekRaw(args, {
       ...options,
       timeoutMs: options.timeoutMs ?? resolveReadSeekTimeoutMs() ?? DEFAULT_READSEEK_VISION_TIMEOUT_MS
     });
@@ -1684,6 +970,9 @@ async function runReadSeekVision(args, options = {}) {
     release();
   }
 }
+async function runReadSeekVision(args, options = {}) {
+  return JSON.parse(await runReadSeekVisionRaw(args, options));
+}
 function requireNumber(value, field) {
   if (typeof value !== "number" || !Number.isSafeInteger(value))
     throw new Error(`invalid readseek ${field}: expected safe integer`);
@@ -1808,39 +1097,6 @@ function parseSearchOutput(value) {
     })
   };
 }
-async function readSeekRead(filePath, startLine, endLine, options = {}) {
-  const args = ["read", startLine === undefined ? filePath : `${filePath}:${startLine}`];
-  if (endLine !== undefined)
-    args.push("--end", String(endLine));
-  return parseReadOutput(await runReadSeek(args, { signal: options.signal }));
-}
-function fileMapFromReadSeekOutput(output, filePath, totalBytes) {
-  if (output.language === "unknown" && output.symbols.length === 0)
-    return null;
-  return {
-    path: filePath,
-    totalLines: output.line_count,
-    totalBytes,
-    language: normalizeLanguage(output.language),
-    detailLevel: "full" /* Full */,
-    symbols: symbolsFromReadSeek(output.symbols)
-  };
-}
-async function readSeekMap(filePath, totalBytes, options = {}) {
-  const output = parseMapOutput(await runReadSeek(["map", filePath], { signal: options.signal }));
-  return fileMapFromReadSeekOutput(output, filePath, totalBytes);
-}
-async function readSeekSearch(target, pattern, options = {}) {
-  const args = ["search", target, pattern];
-  if (options.language)
-    args.push("--language", options.language);
-  appendGitSelection(args, options);
-  return parseSearchOutput(await runReadSeek(args, { signal: options.signal })).results;
-}
-async function readSeekMapContent(filePath, content, options = {}) {
-  const output = parseMapOutput(await runReadSeek(["map", `stdin:${filePath}`], { signal: options.signal, stdin: content }));
-  return fileMapFromReadSeekOutput(output, filePath, Buffer.byteLength(content, "utf8"));
-}
 function optionalString(value, field) {
   if (value === undefined || value === null)
     return;
@@ -1870,19 +1126,6 @@ function parseRefsOutput(value) {
     })
   };
 }
-async function readSeekRefs(target, name, options = {}) {
-  const args = ["refs", target, name];
-  if (options.scope)
-    args.push("--scope");
-  if (options.line !== undefined)
-    args.push("--line", String(options.line));
-  if (options.column !== undefined)
-    args.push("--column", String(options.column));
-  if (options.language)
-    args.push("--language", options.language);
-  appendGitSelection(args, options);
-  return parseRefsOutput(await runReadSeek(args, { signal: options.signal })).references;
-}
 function parseDiagnosticKind(value) {
   if (value === "error" || value === "missing")
     return value;
@@ -1909,9 +1152,6 @@ function parseCheckOutput(value) {
     })
   };
 }
-async function readSeekCheck(filePath, content, options = {}) {
-  return parseCheckOutput(await runReadSeek(["check", `stdin:${filePath}`], { signal: options.signal, stdin: content }));
-}
 function parseOcrText(value) {
   return optionalString(value, "ocr");
 }
@@ -1933,6 +1173,11 @@ function parseDetectedObjects(value) {
     };
   });
 }
+function parseImageEncoding(value) {
+  if (value === "base64")
+    return value;
+  throw new Error("invalid image encoding");
+}
 function parseDetectOutput(value) {
   if (!value || typeof value !== "object")
     throw new Error("invalid readseek detect output");
@@ -1983,20 +1228,228 @@ function parseDetectOutput(value) {
   }
   return { kind: "text", type, file, mime };
 }
-function parseImageEncoding(value) {
-  if (value === "base64")
-    return value;
-  throw new Error("invalid image encoding");
+function parseDocumentCache(value) {
+  if (!value || typeof value !== "object")
+    throw new Error("invalid readseek document cache");
+  const cache = value;
+  const state = requireString(cache.state, "cache.state");
+  if (state !== "built" && state !== "reused")
+    throw new Error("invalid readseek cache.state");
+  return {
+    content_hash: requireString(cache.content_hash, "cache.content_hash"),
+    state
+  };
+}
+function parseIdentifyOutput(value) {
+  if (!value || typeof value !== "object")
+    throw new Error("invalid readseek identify output");
+  const output = value;
+  const identifier = output.identifier;
+  const symbol = output.symbol;
+  return {
+    file: requireString(output.file, "file"),
+    language: requireString(output.language, "language"),
+    engine: optionalString(output.engine, "engine"),
+    line_count: requireNumber(output.line_count, "line_count"),
+    file_hash: requireString(output.file_hash, "file_hash"),
+    line: requireNumber(output.line, "line"),
+    column: requireNumber(output.column, "column"),
+    line_hash: requireString(output.line_hash, "line_hash"),
+    identifier: identifier && typeof identifier === "object" ? {
+      text: requireString(identifier.text, "identifier.text"),
+      start_column: requireNumber(identifier.start_column, "identifier.start_column"),
+      end_column: requireNumber(identifier.end_column, "identifier.end_column"),
+      start_byte: requireNumber(identifier.start_byte, "identifier.start_byte"),
+      end_byte: requireNumber(identifier.end_byte, "identifier.end_byte")
+    } : undefined,
+    symbol: symbol && typeof symbol === "object" ? {
+      name: requireString(symbol.name, "symbol.name"),
+      kind: requireString(symbol.kind, "symbol.kind"),
+      qualified_name: requireString(symbol.qualified_name, "symbol.qualified_name"),
+      start_line: requireNumber(symbol.start_line, "symbol.start_line"),
+      end_line: requireNumber(symbol.end_line, "symbol.end_line")
+    } : 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");
+  const output = value;
+  if (output.metadata === undefined)
+    throw new Error("invalid readseek digest metadata");
+  const result = {
+    metadata: parseDetectOutput(output.metadata)
+  };
+  if (output.cache !== undefined)
+    result.cache = parseDocumentCache(output.cache);
+  if (output.content !== undefined)
+    result.content = output.content;
+  if (output.map !== undefined)
+    result.map = parseMapOutput(output.map);
+  if (output.diagnostics !== undefined)
+    result.diagnostics = parseCheckOutput(output.diagnostics);
+  if (output.identity !== undefined)
+    result.identity = parseIdentifyOutput(output.identity);
+  return result;
+}
+function digestSelectArg(select) {
+  if (select === undefined)
+    return "content";
+  return Array.isArray(select) ? select.join(",") : select;
+}
+function digestArgs(target, options) {
+  const args = ["digest", target, "--select", digestSelectArg(options.select)];
+  if (options.at !== undefined)
+    args.push("--at", options.at);
+  if (options.end !== undefined)
+    args.push("--end", String(options.end));
+  if (options.limit !== undefined)
+    args.push("--limit", String(options.limit));
+  if (options.language)
+    args.push("--language", options.language);
+  if (options.visionMode !== undefined)
+    args.push("--vision-mode", options.visionMode);
+  if (options.visionLevel !== undefined)
+    args.push("--vision-level", options.visionLevel);
+  if (options.stdin !== undefined) {
+    const stdinName = options.stdinName ?? target;
+    if (target === "-")
+      args.push("--stdin-name", stdinName);
+  }
+  return args;
+}
+async function runDigestRaw(target, options = {}) {
+  const args = digestArgs(target, options);
+  const runOptions = {
+    signal: options.signal,
+    stdin: options.stdin,
+    timeoutMs: options.timeoutMs
+  };
+  return options.vision ? await runReadSeekVision(args, runOptions) : await runReadSeek(args, runOptions);
+}
+async function readSeekDigestNative(target, options = {}) {
+  return runDigestRaw(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;
+  return {
+    path: filePath,
+    totalLines: output.line_count,
+    totalBytes,
+    language: normalizeLanguage(output.language),
+    detailLevel: "full" /* Full */,
+    symbols: symbolsFromReadSeek(output.symbols)
+  };
+}
+async function readSeekMap(filePath, totalBytes, options = {}) {
+  const envelope = await readSeekDigest(filePath, { select: "map", signal: options.signal });
+  if (!envelope.map)
+    return null;
+  return fileMapFromReadSeekOutput(envelope.map, filePath, totalBytes);
+}
+async function readSeekSearch(target, pattern, options = {}) {
+  const args = ["search", target, pattern];
+  if (options.language)
+    args.push("--language", options.language);
+  appendGitSelection(args, options);
+  return parseSearchOutput(await runReadSeek(args, { signal: options.signal })).results;
+}
+async function readSeekRefs(target, name, options = {}) {
+  const args = ["refs", target];
+  if (options.scope) {
+    if (options.line !== undefined)
+      args.push("--at", lineLocationSelector(options.line, options.column));
+  } else {
+    args.push(name);
+  }
+  if (options.language)
+    args.push("--language", options.language);
+  appendGitSelection(args, options);
+  return parseRefsOutput(await runReadSeek(args, { signal: options.signal })).references;
+}
+async function readSeekCheck(filePath, content, options = {}) {
+  const envelope = await readSeekDigest("-", {
+    select: "diagnostics",
+    stdin: content,
+    stdinName: filePath,
+    signal: options.signal
+  });
+  if (!envelope.diagnostics)
+    throw new Error("invalid readseek diagnostics: missing diagnostics facet");
+  return envelope.diagnostics;
 }
 async function readSeekDetect(filePath, options = {}) {
-  return parseDetectOutput(await runReadSeek(["detect", filePath], { signal: options.signal }));
+  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 ? lineLocationSelector(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) => parseDetectOutput(await runReadSeekVision(["read", "--vision-mode", mode, filePath], { signal: options.signal }))));
+  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" || result.value.kind !== "image")
+    if (result.status !== "fulfilled")
       continue;
     const detection = result.value;
     merged = merged === undefined ? detection : {
@@ -2014,52 +1467,46 @@ async function readSeekImage(filePath, modes, options = {}) {
   throw new Error(`readseek returned no image analysis for ${filePath}`);
 }
 async function readSeekPreparedImage(filePath, options = {}) {
-  const output = parseDetectOutput(await runReadSeek(["read", "--vision-mode", "none", filePath], { signal: options.signal }));
-  if (output.kind !== "image" || output.encoding !== "base64" || output.data === undefined || output.mime === undefined) {
+  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 parsePdfImage(value) {
+function parseEditOutput(value) {
   if (!value || typeof value !== "object")
-    throw new Error("invalid readseek PDF image");
-  const image = value;
-  const mode = requireString(image.mode, "PDF image.mode");
-  if (mode !== "none" && mode !== "all" && mode !== "ocr" && mode !== "caption" && mode !== "objects") {
-    throw new Error("invalid readseek PDF image.mode");
-  }
-  return {
-    page: requireNumber(image.page, "PDF image.page"),
-    width: requireNumber(image.width, "PDF image.width"),
-    height: requireNumber(image.height, "PDF image.height"),
-    mime: requireString(image.mime, "PDF image.mime"),
-    mode,
-    encoding: image.encoding === undefined ? undefined : parseImageEncoding(image.encoding),
-    data: optionalString(image.data, "PDF image.data"),
-    ocr: parseOcrText(image.ocr),
-    caption: optionalString(image.caption, "PDF image.caption"),
-    objects: parseDetectedObjects(image.objects)
-  };
-}
-function parsePdfOutput(value) {
-  if (!value || typeof value !== "object")
-    throw new Error("invalid readseek PDF output");
+    throw new Error("invalid readseek edit output");
   const output = value;
-  if (output.format !== "pdf" || !Array.isArray(output.images))
-    throw new Error("invalid readseek PDF output");
   return {
-    format: output.format,
-    pages: requireNumber(output.pages, "PDF pages"),
-    markdown: requireString(output.markdown, "PDF markdown"),
-    images: output.images.map(parsePdfImage)
+    file: requireString(output.file, "file"),
+    before_hash: requireString(output.before_hash, "before_hash"),
+    file_hash: requireString(output.file_hash, "file_hash"),
+    plan_hash: requireString(output.plan_hash, "plan_hash"),
+    applied: requireBoolean(output.applied, "applied"),
+    changed: requireBoolean(output.changed, "changed"),
+    edit_count: requireNumber(output.edit_count, "edit_count"),
+    before_content: optionalString(output.before_content, "before_content"),
+    content: optionalString(output.content, "content")
   };
 }
-async function readSeekPdf(filePath, mode, options = {}) {
-  const run = mode === "none" ? runReadSeek : runReadSeekVision;
-  const args = ["read", "--vision-mode", mode, filePath];
-  if (options.page !== undefined)
-    args.push("--page", String(options.page));
-  return parsePdfOutput(await run(args, { signal: options.signal }));
+async function readSeekEdit(filePath, edits, options = {}) {
+  const args = ["edit", filePath];
+  if (options.apply)
+    args.push("--apply");
+  if (options.planHash)
+    args.push("--plan-hash", options.planHash);
+  if (options.language)
+    args.push("--language", options.language);
+  return parseEditOutput(await runReadSeek(args, {
+    signal: options.signal,
+    stdin: JSON.stringify({ edits }),
+    timeoutMs: options.timeoutMs,
+    cancelable: options.cancelable
+  }));
 }
 function parseRenameConflicts(value, field) {
   if (value === undefined)
@@ -2131,10 +1578,7 @@ function parseRenameOutput(value) {
   };
 }
 async function readSeekRename(filePath, options) {
-  const args = ["rename", filePath, "--line", String(options.line)];
-  if (options.column !== undefined)
-    args.push("--column", String(options.column));
-  args.push("--to", options.to);
+  const args = ["rename", filePath, "--at", lineLocationSelector(options.line, options.column), "--to", options.to];
   if (options.apply)
     args.push("--apply");
   if (options.workspace)
@@ -2144,46 +1588,6 @@ async function readSeekRename(filePath, options) {
   appendGitSelection(args, options);
   return parseRenameOutput(await runReadSeek(args, { signal: options.signal }));
 }
-function parseIdentifyOutput(value) {
-  if (!value || typeof value !== "object")
-    throw new Error("invalid readseek identify output");
-  const output = value;
-  const identifier = output.identifier;
-  const symbol = output.symbol;
-  return {
-    file: requireString(output.file, "file"),
-    language: requireString(output.language, "language"),
-    engine: optionalString(output.engine, "engine"),
-    line_count: requireNumber(output.line_count, "line_count"),
-    file_hash: requireString(output.file_hash, "file_hash"),
-    line: requireNumber(output.line, "line"),
-    column: requireNumber(output.column, "column"),
-    line_hash: requireString(output.line_hash, "line_hash"),
-    identifier: identifier && typeof identifier === "object" ? {
-      text: requireString(identifier.text, "identifier.text"),
-      start_column: requireNumber(identifier.start_column, "identifier.start_column"),
-      end_column: requireNumber(identifier.end_column, "identifier.end_column"),
-      start_byte: requireNumber(identifier.start_byte, "identifier.start_byte"),
-      end_byte: requireNumber(identifier.end_byte, "identifier.end_byte")
-    } : undefined,
-    symbol: symbol && typeof symbol === "object" ? {
-      name: requireString(symbol.name, "symbol.name"),
-      kind: requireString(symbol.kind, "symbol.kind"),
-      qualified_name: requireString(symbol.qualified_name, "symbol.qualified_name"),
-      start_line: requireNumber(symbol.start_line, "symbol.start_line"),
-      end_line: requireNumber(symbol.end_line, "symbol.end_line")
-    } : undefined
-  };
-}
-async function readSeekIdentify(filePath, content, options = {}) {
-  const target = options.line === undefined ? `stdin:${filePath}` : `stdin:${filePath}:${options.line}`;
-  const args = ["identify", target];
-  if (options.column !== undefined)
-    args.push("--column", String(options.column));
-  if (options.language)
-    args.push("--language", options.language);
-  return parseIdentifyOutput(await runReadSeek(args, { signal: options.signal, stdin: content }));
-}
 function parseDefCompact(value) {
   if (!value || typeof value !== "object")
     throw new Error("invalid readseek def output");
@@ -2871,9 +2275,6 @@ function formatReadCallText(args) {
   if (typeof args?.symbol === "string" && args.symbol) {
     return { path: rawPath, suffix: `→ symbol ${args.symbol}` };
   }
-  if (args?.map === true) {
-    return { path: rawPath, suffix: "+ map" };
-  }
   if (typeof args?.offset === "number") {
     const offset = args.offset;
     const limit = typeof args?.limit === "number" ? args.limit : undefined;
@@ -3162,9 +2563,6 @@ function optionalIntOrString(description) {
 function filePathParam() {
   return Type.String({ description: "Absolute or relative file path" });
 }
-function mapParam() {
-  return Type.Optional(Type.Boolean({ description: "Append structural map" }));
-}
 function registerReadSeekTool(pi, tool) {
   pi.registerTool(tool);
   return tool;
@@ -3211,50 +2609,9 @@ ${lines.join(`
     return "No image analysis returned.";
   return "Image caption returned no text.";
 }
-function formatPdfAnalysis(pdf) {
-  const sections = [pdf.markdown.trimEnd()];
-  for (const image of pdf.images) {
-    const details = [];
-    const ocr = image.ocr?.trim();
-    if (ocr)
-      details.push(`OCR text:
-${ocr}`);
-    const caption = image.caption?.trim();
-    if (caption)
-      details.push(`Caption:
-${caption}`);
-    if (image.objects?.length) {
-      const lines = image.objects.map((object) => `- ${object.label} [${object.bbox.join(", ")}]`);
-      details.push(`Detected objects:
-${lines.join(`
-`)}`);
-    }
-    if (details.length > 0)
-      sections.push(`PDF page ${image.page} image:
-${details.join(`
-
-`)}`);
-  }
-  return sections.filter(Boolean).join(`
-
-`);
-}
-function preparedPdfContent(pdf) {
-  const content = [{ type: "text", text: truncateDocumentText(pdf.markdown) }];
-  for (const image of pdf.images) {
-    if (image.encoding !== "base64" || image.data === undefined)
-      continue;
-    content.push({ type: "text", text: `[PDF page ${image.page} image]` });
-    content.push({ type: "image", data: image.data, mimeType: image.mime });
-  }
-  return content;
-}
-function truncateDocumentText(text) {
-  const truncation = truncateHead2(text, { maxLines: DEFAULT_MAX_LINES3, maxBytes: DEFAULT_MAX_BYTES3 });
-  if (!truncation.truncated)
-    return truncation.content;
-  return `${truncation.content}
-[… document output truncated; use readSeek_view with page or node selectors]`;
+function documentRedirectMessage(path2, cache) {
+  const cacheNote = cache ? ` Index ${cache.state} (hash ${cache.content_hash}).` : "";
+  return `Document content is not available via readSeek_read for ${path2}.${cacheNote} Use readSeek_view to digest structure or selected content.`;
 }
 function skippedImageFile(path2) {
   return {
@@ -3282,25 +2639,14 @@ async function executeRead(opts) {
     const message = `Invalid offset: expected a positive integer, received ${offset.value}.`;
     return buildToolErrorResult("read", "invalid-offset", message, { path: rawParams.path });
   }
-  const page = coerceObviousBase10Int(rawParams.page, "page");
-  if (!page.ok) {
-    return buildToolErrorResult("read", "invalid-page", page.message, { path: rawParams.path });
-  }
-  if (page.value !== undefined && page.value < 1) {
-    const message = `Invalid page: expected a positive integer, received ${page.value}.`;
-    return buildToolErrorResult("read", "invalid-page", 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 requestedMapViaBundle = rawBundle === "map" || rawBundle === "local" && rawSymbol === undefined && (rawParams.map ?? true);
   const p = {
     ...rawParams,
     offset: offset.value,
     limit: limit.value,
-    page: page.value,
     symbol: rawSymbol,
-    map: rawParams.map === true || requestedMapViaBundle,
-    bundle: requestedMapViaBundle ? undefined : rawBundle
+    bundle: rawBundle
   };
   const rawPath = p.path.replace(/^@/, "");
   const absolutePath = resolveToCwd(rawPath, cwd);
@@ -3324,14 +2670,6 @@ async function executeRead(opts) {
     const message = 'Cannot use bundle without symbol. Use read({ path, symbol, bundle: "local" }).';
     return buildToolErrorResult("read", "invalid-params-combo", message, { path: rawParams.path });
   }
-  if (p.bundle && p.map) {
-    const message = "Cannot combine bundle with map. Use one or the other.";
-    return buildToolErrorResult("read", "invalid-params-combo", message, { path: rawParams.path });
-  }
-  if (p.map && p.symbol) {
-    const message = "Cannot combine map with symbol. Use one or the other.";
-    return buildToolErrorResult("read", "invalid-params-combo", message, { path: rawParams.path });
-  }
   throwIfAborted(signal);
   const ext = rawPath.split(".").pop()?.toLowerCase() ?? "";
   let rawBuffer;
@@ -3345,27 +2683,31 @@ async function executeRead(opts) {
   }
   const hasBinaryContent = looksLikeBinary(rawBuffer);
   const hasPdfHeader = rawBuffer.subarray(0, 1024).includes(Buffer.from("%PDF-"));
-  if (hasBinaryContent || ext === "pdf" || hasPdfHeader) {
+  const maybeVisual = hasBinaryContent || ext === "pdf" || hasPdfHeader;
+  let earlyDigest;
+  if (maybeVisual) {
     let detection;
     try {
-      detection = await readSeekDetect(absolutePath, { signal });
-    } catch {
-      return buildToolErrorResult("read", "read-error", `Visual file detection failed for ${absolutePath}.`, {
-        path: rawParams.path
+      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) {
-      return buildToolErrorResult("read", "read-error", `Visual file detection returned no data 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" || detection.kind === "pdf") {
+    if (detection.kind === "image") {
       if (p.offset !== undefined || p.limit !== undefined) {
-        const message = "Cannot combine offset/limit with image or PDF reads.";
-        return buildToolErrorResult("read", "invalid-params-combo", message, { path: rawParams.path });
-      }
-      if (detection.kind !== "pdf" && p.page !== undefined) {
-        const message = "The page parameter applies to PDFs only.";
+        const message = "Cannot combine offset/limit with image reads.";
         return buildToolErrorResult("read", "invalid-params-combo", message, { path: rawParams.path });
       }
       const imageMode = resolveReadSeekImageMode();
@@ -3375,38 +2717,14 @@ async function executeRead(opts) {
           path: rawParams.path
         });
       }
-      if (detection.kind === "pdf") {
-        let pdfImageMode = "none";
-        if (imageMode !== "off" && p.image !== undefined && p.image !== "none" && !useNativeVision) {
-          pdfImageMode = p.image;
-        }
-        try {
-          const pdf = await readSeekPdf(absolutePath, pdfImageMode, { page: p.page ?? 1, signal });
-          if (pdfImageMode !== "none") {
-            return succeed({
-              content: [{ type: "text", text: truncateDocumentText(formatPdfAnalysis(pdf)) }],
-              details: {}
-            });
-          }
-          return succeed({
-            content: useNativeVision ? preparedPdfContent(pdf) : [{ type: "text", text: truncateDocumentText(pdf.markdown) }],
-            details: {}
-          });
-        } catch (error) {
-          const message = error instanceof Error ? error.message : String(error);
-          return buildToolErrorResult("read", "read-error", `PDF reading unavailable: ${message}`, {
-            path: rawParams.path
-          });
-        }
-      }
       if (imageMode === "off" || p.image === undefined) {
         return skippedImageFile(rawParams.path);
       }
       if (useNativeVision || p.image === "none") {
         try {
-          const image = await readSeekPreparedImage(absolutePath, { signal });
+          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: image.data, mimeType: image.mime }],
+            content: [{ type: "image", data: prepared.data, mimeType: prepared.mime }],
             details: {}
           });
         } catch (error) {
@@ -3436,10 +2754,6 @@ async function executeRead(opts) {
       });
     }
   }
-  if (p.page !== undefined) {
-    const message = "The page parameter applies to PDFs only.";
-    return buildToolErrorResult("read", "invalid-params-combo", message, { path: rawParams.path });
-  }
   throwIfAborted(signal);
   const rawText = rawBuffer.toString("utf-8");
   const normalized = normalizeToLF(stripBom(rawText).text);
@@ -3562,7 +2876,11 @@ async function executeRead(opts) {
   throwIfAborted(signal);
   let readSeekOutput;
   try {
-    readSeekOutput = total === 0 ? await readSeekRead(absolutePath, undefined, undefined, { signal }) : await readSeekRead(absolutePath, startLine, endIdx, { signal });
+    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}`;
@@ -3584,7 +2902,7 @@ async function executeRead(opts) {
   const selected = readSeekLines.map((line) => line.raw);
   const formatted = renderReadSeekLines(readSeekLines);
   const truncation = truncateHead2(formatted, { maxLines: DEFAULT_MAX_LINES3, maxBytes: DEFAULT_MAX_BYTES3 });
-  const shouldAppendMap = !!p.map || !!truncation.truncated && !p.offset && !p.limit && !symbolMatch;
+  const shouldAppendMap = !!truncation.truncated && !p.offset && !p.limit && !symbolMatch;
   let appendedMap = false;
   let mapText = null;
   if (shouldAppendMap) {
@@ -3597,6 +2915,16 @@ async function executeRead(opts) {
       }
     } 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()));
   }
@@ -3632,7 +2960,7 @@ async function executeRead(opts) {
       endLine: symbolMatch.endLine
     } : null,
     map: {
-      requested: !!p.map,
+      requested: false,
       appended: appendedMap,
       text: mapText
     },
@@ -3660,13 +2988,13 @@ function registerReadTool(pi, options = {}) {
   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, symbols, maps, or PDF text" : "Read anchored text, symbols, maps, images, or PDFs",
+    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, symbol, or map. Images are disabled; PDFs still return text." : promptMetadata.description,
+    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,
@@ -3676,15 +3004,13 @@ function registerReadTool(pi, options = {}) {
       path: filePathParam(),
       offset: optionalIntOrString("One-based starting line"),
       limit: optionalIntOrString("Maximum lines to return"),
-      page: optionalIntOrString("One-based PDF page; defaults to 1"),
       symbol: Type2.Optional(Type2.String({ description: "Symbol name to read" })),
-      map: mapParam(),
       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/PDF-embedded image mode: ${imageModes.join(", ")}. Required for standalone images.${imageMode === "auto" ? " For standalone images, none skips local analysis." : ""}`
+          description: `Standalone image mode: ${imageModes.join(", ")}. Required for standalone images.${imageMode === "auto" ? " For standalone images, none skips local analysis." : ""}`
         }))
       }
     }),
@@ -3773,7 +3099,7 @@ ${textContent}`;
 }
 
 // src/edit.ts
-import { readFile as fsReadFile2, writeFile as fsWriteFile } from "node:fs/promises";
+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";
@@ -4056,77 +3382,12 @@ async function validateSyntaxRegression(input, options = {}) {
   };
 }
 
-// src/syntax-validate-mode.ts
-var DEFAULT = "warn";
-function resolveSyntaxValidateMode(opts) {
-  return opts.syntaxValidate ?? resolveReadSeekSyntaxValidation() ?? DEFAULT;
-}
-
-// src/replace-symbol.ts
-function detectIndent(line) {
-  return line.match(/^\s*/)?.[0] ?? "";
-}
-function dedent(text) {
-  const lines = text.split(`
-`);
-  const nonEmpty = lines.filter((l) => l.trim().length);
-  if (!nonEmpty.length)
-    return text;
-  const minIndent = Math.min(...nonEmpty.map((l) => l.match(/^\s*/)?.[0].length ?? 0));
-  return lines.map((l) => l.slice(minIndent)).join(`
-`);
-}
-function reindent(text, indent) {
-  return text.split(`
-`).map((l) => l.length ? indent + l : l).join(`
-`);
-}
-async function replaceSymbol(input) {
-  const map = await readSeekMapContent(input.filePath, input.content);
-  if (!map) {
-    return {
-      type: "unsupported",
-      message: `Unsupported file for replace_symbol: readseek could not map '${input.filePath}'. Use anchored edits for this file type.`
-    };
-  }
-  const lookup = findSymbol(map, input.symbol);
-  if (lookup.type === "not-found") {
-    return { type: "not-found", message: formatNotFound(input.symbol, map) };
-  }
-  if (lookup.type === "ambiguous") {
-    return { type: "ambiguous", message: formatAmbiguous(input.symbol, lookup.candidates) };
-  }
-  const sym = lookup.symbol;
-  const lines = input.content.split(`
-`);
-  const sigLine = lines[sym.startLine - 1] ?? "";
-  const indent = detectIndent(sigLine);
-  const reindented = reindent(dedent(normalizeToLF(input.newBody)), indent);
-  const warnings = [];
-  const leaf = input.symbol.replace(/@\d+$/, "").split(".").pop() ?? "";
-  const declNameRe = /\b(?:(?:export\s+(?:default\s+)?|async\s+|public\s+|private\s+|protected\s+|static\s+)*)(?:function\*?|class|const|let|var|fn|def|method|type|interface|enum)\s+([A-Za-z_$][\w$]*)/s;
-  const firstDeclName = reindented.match(declNameRe)?.[1] ?? reindented.match(/^\s*(?:(?:async\s+)?[\w$<>,?\s]+\s+)?([A-Za-z_$][\w$]*)\s*\(/)?.[1];
-  if (leaf && firstDeclName && firstDeclName !== leaf) {
-    warnings.push(`name-mismatch: expected ${leaf}, got ${firstDeclName}`);
-  }
-  const before = lines.slice(0, sym.startLine - 1).join(`
-`);
-  const after = lines.slice(sym.endLine).join(`
-`);
-  const beforePart = before.length ? before + `
-` : "";
-  const afterPart = after.length ? `
-` + after : "";
-  const newContent = beforePart + reindented + afterPart;
-  return {
-    type: "ok",
-    content: newContent,
-    replacement: reindented,
-    warnings,
-    range: { start: sym.startLine, end: sym.endLine }
-  };
-}
-
+// src/syntax-validate-mode.ts
+var DEFAULT = "warn";
+function resolveSyntaxValidateMode(opts) {
+  return opts.syntaxValidate ?? resolveReadSeekSyntaxValidation() ?? DEFAULT;
+}
+
 // src/pending-diff-preview.ts
 import { existsSync as existsSync2, readFileSync as readFileSync4, realpathSync, statSync as statSync3 } from "node:fs";
 import { dirname, isAbsolute as isAbsolute2, relative as relative2, resolve, sep } from "node:path";
@@ -4188,57 +3449,6 @@ function buildData(filePath, previousContent, nextContent, existed, headerLabel)
 function getEdits(input) {
   return Array.isArray(input.edits) ? input.edits : [];
 }
-function isReplaceEdit(edit) {
-  if (!edit || typeof edit !== "object" || !("replace" in edit))
-    return false;
-  const replace = edit.replace;
-  return typeof replace?.old_text === "string" && typeof replace?.new_text === "string";
-}
-function isAnchorEdit(edit) {
-  return !!edit && typeof edit === "object" && (("set_line" in edit) || ("replace_lines" in edit) || ("insert_after" in edit));
-}
-function applyAnchoredPreview(content, edits) {
-  try {
-    return { type: "ok", content: applyHashlineEdits(content, edits).content };
-  } catch (err) {
-    return { type: "skip", reason: `anchor projection failed: ${err?.message ?? String(err)}` };
-  }
-}
-function isReplaceSymbolEdit(edit) {
-  if (!edit || typeof edit !== "object" || !("replace_symbol" in edit))
-    return false;
-  const replaceSymbol2 = edit.replace_symbol;
-  return typeof replaceSymbol2?.symbol === "string" && typeof replaceSymbol2?.new_body === "string";
-}
-async function applyReplaceSymbolPreview(filePath, content, edit) {
-  try {
-    if (!edit.replace_symbol.new_body.trim())
-      return { type: "skip", reason: "replace_symbol new_body is empty" };
-    const probe = await replaceSymbol({
-      filePath,
-      content,
-      symbol: edit.replace_symbol.symbol,
-      newBody: edit.replace_symbol.new_body
-    });
-    if (probe.type !== "ok")
-      return { type: "skip", reason: `symbol projection failed: ${probe.message}` };
-    return { type: "ok", content: probe.content };
-  } catch (err) {
-    return { type: "skip", reason: `symbol projection failed: ${err?.message ?? String(err)}` };
-  }
-}
-function applyReplacePreview(content, edit) {
-  const { old_text, new_text } = edit.replace;
-  if (!old_text.length)
-    return { type: "skip", reason: "replace old_text is empty" };
-  const replacement = replaceText(content, old_text, new_text, {
-    all: edit.replace.all ?? false,
-    fuzzy: edit.replace.fuzzy ?? false
-  });
-  if (!replacement.count)
-    return { type: "skip", reason: "replace old_text was not found" };
-  return { type: "ok", content: replacement.content };
-}
 function buildPendingWritePreviewData(input, cwd) {
   if (typeof input.content !== "string")
     return skip("missing content");
@@ -4262,50 +3472,16 @@ async function buildPendingEditPreviewData(input, cwd) {
   const previous = readUtf8File(resolved.path);
   if (previous.type === "skip")
     return previous;
-  let next = normalizeToLF(previous.content);
-  const anchorBatch = [];
-  for (const edit of edits) {
-    if (isReplaceEdit(edit)) {
-      if (anchorBatch.length > 0) {
-        const anchored = applyAnchoredPreview(next, anchorBatch);
-        if (anchored.type === "skip")
-          return anchored;
-        next = anchored.content;
-        anchorBatch.length = 0;
-      }
-      const projected = applyReplacePreview(next, edit);
-      if (projected.type === "skip")
-        return projected;
-      next = projected.content;
-      continue;
-    }
-    if (isAnchorEdit(edit)) {
-      anchorBatch.push(edit);
-      continue;
-    }
-    if (isReplaceSymbolEdit(edit)) {
-      if (anchorBatch.length > 0) {
-        const anchored = applyAnchoredPreview(next, anchorBatch);
-        if (anchored.type === "skip")
-          return anchored;
-        next = anchored.content;
-        anchorBatch.length = 0;
-      }
-      const projected = await applyReplaceSymbolPreview(resolved.path, next, edit);
-      if (projected.type === "skip")
-        return projected;
-      next = projected.content;
-      continue;
-    }
-    return skip("unsupported edit variant");
-  }
-  if (anchorBatch.length > 0) {
-    const anchored = applyAnchoredPreview(next, anchorBatch);
-    if (anchored.type === "skip")
-      return anchored;
-    next = anchored.content;
+  try {
+    const plan = await readSeekEdit(resolved.path, edits, {
+      language: typeof input.language === "string" ? input.language : undefined
+    });
+    if (typeof plan.content !== "string")
+      return skip("edit plan did not include content");
+    return buildData(resolved.path, previous.content, plan.content, true, "pending edit");
+  } catch (err) {
+    return skip(`edit projection failed: ${err?.message ?? String(err)}`);
   }
-  return buildData(resolved.path, previous.content, next, true, "pending edit");
 }
 function buildEditPreviewKey(input) {
   if (typeof input.path !== "string")
@@ -4313,7 +3489,7 @@ function buildEditPreviewKey(input) {
   const edits = getEdits(input);
   if (edits.length === 0)
     return;
-  return JSON.stringify({ path: input.path, edits });
+  return JSON.stringify({ path: input.path, edits, language: input.language });
 }
 function buildWritePreviewKey(input) {
   if (typeof input.path !== "string" || typeof input.content !== "string")
@@ -4796,26 +3972,25 @@ 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" })
-  }, { description: 'Replace one line: {"set_line":{"anchor":"LINE:HASH","new_text":"..."}}' })),
+  }, { 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" })
-  }, { description: 'Replace a range: {"replace_lines":{"start_anchor":"LINE:HASH","end_anchor":"LINE:HASH","new_text":"..."}}' })),
+  }, { 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" })
-  }, { description: 'Insert text: {"insert_after":{"anchor":"LINE:HASH","new_text":"..."}}' })),
+  }, { 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" })),
-    fuzzy: Type3.Optional(Type3.Boolean({ description: "Allow unverified fuzzy matching when exact text is absent" }))
-  }, { description: 'Replace text: {"replace":{"old_text":"...","new_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" })
-  }, { description: 'Replace a symbol: {"replace_symbol":{"symbol":"name","new_body":"..."}}' }))
+  }, { additionalProperties: false, description: 'Replace a symbol: {"replace_symbol":{"symbol":"name","new_body":"..."}}' }))
 }, {
   additionalProperties: false,
   minProperties: 1,
@@ -4824,13 +3999,15 @@ var hashlineEditItemSchema = Type3.Object({
 });
 var hashlineEditSchema = Type3.Object({
   path: filePathParam(),
-  edits: Type3.Optional(Type3.Array(hashlineEditItemSchema, {
+  language: Type3.Optional(Type3.String({ description: "Language override for symbol replacement" })),
+  edits: Type3.Array(hashlineEditItemSchema, {
+    minItems: 1,
     description: "Use set_line, replace_lines, insert_after, replace_symbol, or replace"
-  })),
+  }),
   postEditVerify: Type3.Optional(Type3.Boolean({
     description: "Read back and verify persisted content"
   }))
-}, { additionalProperties: true });
+}, { additionalProperties: false });
 function buildEditError(path2, code, message, hint, errorDetails) {
   return {
     content: [{ type: "text", text: message }],
@@ -4854,9 +4031,7 @@ function mapEditFileError(err, filePath, _displayPath, _phase) {
 }
 async function executeEdit(opts) {
   const { params, signal, cwd, wasReadInSession, onFileMutated, syntaxValidate } = opts;
-  await ensureHashInit();
   const parsed = params;
-  const input = params;
   const rawPath = parsed.path;
   const path2 = rawPath.replace(/^@/, "");
   const absolutePath = resolveToCwd(path2, cwd);
@@ -4865,345 +4040,105 @@ async function executeEdit(opts) {
     return await withFileMutationQueue(absolutePath, async () => {
       throwIfAborted(signal);
       if (wasReadInSession && !wasReadInSession(absolutePath)) {
-        const message = [
-          `You must get fresh anchors for ${absolutePath} before editing it.`,
-          `Call readSeek_read(${JSON.stringify(rawPath)}) first, or use readSeek_grep, readSeek_search, or readSeek_write to produce fresh anchors for this file.`,
-          "readSeek_edit requires fresh LINE:HASH anchors from readSeek_read, readSeek_grep, readSeek_search, or readSeek_write so the hashes match the current file contents."
-        ].join(" ");
-        return buildEditError(absolutePath, "file-not-read", message, `Call readSeek_read(${JSON.stringify(rawPath)}) first, or use readSeek_grep, readSeek_search, or readSeek_write to produce fresh anchors for this file.`);
-      }
-      const hasTopLevelReplaceInput = typeof input.oldText === "string" || typeof input.newText === "string" || typeof input.old_text === "string" || typeof input.new_text === "string";
-      if (hasTopLevelReplaceInput) {
-        return buildEditError(absolutePath, "invalid-edit-variant", "Top-level oldText/newText and old_text/new_text are no longer supported. Use edits[0].replace instead.", "Use edits: [{ replace: { old_text, new_text } }].");
+        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.`;
+        return buildEditError(absolutePath, "file-not-read", `You must get fresh anchors for ${absolutePath} before editing it. ${hint}`, hint);
       }
       const edits = parsed.edits ?? [];
       if (!edits.length) {
         return buildEditError(absolutePath, "invalid-edit-variant", "No edits provided.");
       }
-      for (let i = 0;i < edits.length; i++) {
-        throwIfAborted(signal);
-        const edit = edits[i];
-        if (!edit || typeof edit !== "object" || Array.isArray(edit)) {
-          const message = `edits[${i}] must be an object containing exactly one edit variant.`;
-          return buildEditError(absolutePath, "invalid-edit-variant", message);
-        }
-        const e = edit;
-        if ((("old_text" in e) || ("new_text" in e)) && !("replace" in e)) {
-          const message = `edits[${i}] has top-level 'old_text'/'new_text'. Use {replace: {old_text, new_text}} or {set_line}, {replace_lines}, {insert_after}.`;
-          return buildEditError(absolutePath, "invalid-edit-variant", message);
-        }
-        if ("diff" in e) {
-          const message = `edits[${i}] contains 'diff' from patch mode. Hashline edit expects one of: {set_line}, {replace_lines}, {insert_after}, {replace}.`;
-          return buildEditError(absolutePath, "invalid-edit-variant", message);
-        }
-        const variantCount = Number("set_line" in e) + Number("replace_lines" in e) + Number("insert_after" in e) + Number("replace" in e) + Number("replace_symbol" in e);
-        if (variantCount !== 1 || Object.keys(e).length !== 1) {
-          const message = `edits[${i}] must contain exactly one of: 'set_line', 'replace_lines', 'insert_after', 'replace', 'replace_symbol'. Got: [${Object.keys(e).join(", ")}].`;
-          return buildEditError(absolutePath, "invalid-edit-variant", message);
-        }
-      }
-      const anchorEdits = edits.filter((e) => ("set_line" in e) || ("replace_lines" in e) || ("insert_after" in e));
-      const replaceEdits = edits.filter((e) => ("replace" in e));
-      const replaceSymbolEdits = edits.filter((e) => ("replace_symbol" in e));
-      for (const rs of replaceSymbolEdits) {
-        if (!rs.replace_symbol.new_body.trim()) {
-          return buildEditError(absolutePath, "invalid-edit-variant", "replace_symbol.new_body must not be empty or whitespace-only.");
-        }
-      }
-      let rawBuffer;
-      try {
-        rawBuffer = await fsReadFile2(absolutePath);
-      } catch (err) {
-        return mapEditFileError(err, absolutePath, path2, "read");
-      }
-      if (looksLikeBinary(rawBuffer)) {
-        const message = `Cannot edit binary file: ${path2}`;
-        return buildEditError(absolutePath, "binary-file", message);
-      }
-      throwIfAborted(signal);
-      const raw = rawBuffer.toString("utf-8");
-      const { bom, text: content } = stripBom(raw);
-      const originalEnding = detectLineEnding(content);
-      const originalNormalized = normalizeToLF(content);
-      const origLines = originalNormalized.split(`
-`);
-      const anchorSnapshots = new Map;
-      for (const edit of anchorEdits) {
-        const refs = [];
-        if ("set_line" in edit)
-          refs.push(edit.set_line.anchor);
-        else if ("replace_lines" in edit) {
-          refs.push(edit.replace_lines.start_anchor, edit.replace_lines.end_anchor);
-        } else if ("insert_after" in edit)
-          refs.push(edit.insert_after.anchor);
-        for (const ref of refs) {
-          try {
-            const parsed2 = parseLineRef(ref);
-            if (parsed2.line >= 1 && parsed2.line <= origLines.length) {
-              const lineContent = origLines[parsed2.line - 1];
-              const hash = computeLineHash(lineContent);
-              anchorSnapshots.set(ref, `${parsed2.line}:${hash}|${escapeControlCharsForDisplay(lineContent)}`);
-            }
-          } catch {}
+      const variants = new Set(["set_line", "replace_lines", "insert_after", "replace", "replace_symbol"]);
+      for (let index = 0;index < edits.length; index++) {
+        const edit = edits[index];
+        const keys = edit && typeof edit === "object" && !Array.isArray(edit) ? Object.keys(edit) : [];
+        if (keys.length !== 1 || !variants.has(keys[0])) {
+          return buildEditError(absolutePath, "invalid-edit-variant", `edits[${index}] must contain exactly one of: 'set_line', 'replace_lines', 'insert_after', 'replace', 'replace_symbol'. Got: [${keys.join(", ")}].`);
         }
       }
-      let preAnchorContent = originalNormalized;
-      const replaceSymbolRanges = [];
-      const rsProbeResults = [];
+      let plan;
       try {
-        for (const rs of replaceSymbolEdits) {
-          throwIfAborted(signal);
-          const probe = await replaceSymbol({
-            filePath: absolutePath,
-            content: originalNormalized,
-            symbol: rs.replace_symbol.symbol,
-            newBody: rs.replace_symbol.new_body
-          });
-          if (probe.type !== "ok") {
-            return buildEditError(absolutePath, "invalid-edit-variant", probe.message);
-          }
-          rsProbeResults.push(probe);
-          replaceSymbolRanges.push(probe.range);
-        }
+        plan = await readSeekEdit(absolutePath, edits, { signal, language: parsed.language });
       } catch (err) {
         throwIfAborted(signal);
         const failure = classifyReadSeekFailure(err);
-        return buildEditError(absolutePath, failure.code, failure.message, failure.hint);
-      }
-      const sortedReplaceSymbolRanges = [...replaceSymbolRanges].sort((a, b) => a.start - b.start || a.end - b.end);
-      for (let i = 1;i < sortedReplaceSymbolRanges.length; i++) {
-        const prev = sortedReplaceSymbolRanges[i - 1];
-        const current = sortedReplaceSymbolRanges[i];
-        if (current.start <= prev.end) {
-          const message = `replace_symbol ranges overlap or duplicate (lines ${prev.start}-${prev.end} and ${current.start}-${current.end}).`;
-          return buildEditError(absolutePath, "invalid-edit-variant", message);
-        }
+        const code = failure.message.includes("stale anchor") ? "hash-mismatch" : failure.code;
+        return buildEditError(absolutePath, code, failure.message, failure.hint);
       }
-      if (replaceSymbolRanges.length > 0) {
-        for (const edit of anchorEdits) {
-          if ("replace_lines" in edit) {
-            let startLine;
-            let endLine;
-            try {
-              startLine = parseLineRef(edit.replace_lines.start_anchor).line;
-              endLine = parseLineRef(edit.replace_lines.end_anchor).line;
-            } catch {}
-            if (startLine !== undefined && endLine !== undefined) {
-              const lo = Math.min(startLine, endLine);
-              const hi = Math.max(startLine, endLine);
-              for (const range of replaceSymbolRanges) {
-                if (lo <= range.end && hi >= range.start) {
-                  const message = `replace_lines range ${lo}-${hi} overlaps a replace_symbol range (lines ${range.start}-${range.end}).`;
-                  return buildEditError(absolutePath, "invalid-edit-variant", message);
-                }
-              }
-            }
-          }
-          const refs = [];
-          if ("set_line" in edit)
-            refs.push(edit.set_line.anchor);
-          else if ("replace_lines" in edit) {
-            refs.push(edit.replace_lines.start_anchor, edit.replace_lines.end_anchor);
-          } else if ("insert_after" in edit)
-            refs.push(edit.insert_after.anchor);
-          for (const ref of refs) {
-            let parsedLine;
-            try {
-              parsedLine = parseLineRef(ref).line;
-            } catch {
-              continue;
-            }
-            for (const range of replaceSymbolRanges) {
-              if (parsedLine >= range.start && parsedLine <= range.end) {
-                const message = `Anchor at line ${parsedLine} falls inside a replace_symbol range (lines ${range.start}-${range.end}).`;
-                return buildEditError(absolutePath, "invalid-edit-variant", message);
-              }
-            }
-          }
-        }
-      }
-      const anchorIntervals = [];
-      for (const edit of anchorEdits) {
-        try {
-          if ("set_line" in edit) {
-            const line = parseLineRef(edit.set_line.anchor).line;
-            anchorIntervals.push({ lo: line, hi: line });
-          } else if ("replace_lines" in edit) {
-            const start = parseLineRef(edit.replace_lines.start_anchor).line;
-            const end = parseLineRef(edit.replace_lines.end_anchor).line;
-            anchorIntervals.push({ lo: Math.min(start, end), hi: Math.max(start, end) });
-          }
-        } catch {}
-      }
-      const seenAnchorIntervals = new Set;
-      const uniqueAnchorIntervals = [];
-      for (const interval of anchorIntervals) {
-        const key = `${interval.lo}:${interval.hi}`;
-        if (seenAnchorIntervals.has(key))
-          continue;
-        seenAnchorIntervals.add(key);
-        uniqueAnchorIntervals.push(interval);
-      }
-      uniqueAnchorIntervals.sort((a, b) => a.lo - b.lo || a.hi - b.hi);
-      for (let i = 1;i < uniqueAnchorIntervals.length; i++) {
-        const prev = uniqueAnchorIntervals[i - 1];
-        const current = uniqueAnchorIntervals[i];
-        if (current.lo <= prev.hi) {
-          const message = `Anchored edits overlap (lines ${prev.lo}-${prev.hi} and ${current.lo}-${current.hi}). Split into separate, non-overlapping edits or re-read for fresh anchors.`;
-          return buildEditError(absolutePath, "invalid-edit-variant", message);
-        }
-      }
-      const replaceSymbolWarnings = [];
-      if (rsProbeResults.length > 0) {
-        const lines = originalNormalized.split(`
-`);
-        for (const probe of rsProbeResults) {
-          replaceSymbolWarnings.push(...probe.warnings);
-        }
-        for (const probe of [...rsProbeResults].sort((a, b) => b.range.start - a.range.start)) {
-          lines.splice(probe.range.start - 1, probe.range.end - probe.range.start + 1, ...probe.replacement.split(`
-`));
-        }
-        preAnchorContent = lines.join(`
-`);
-      }
-      let result = preAnchorContent;
-      let anchorResult;
-      try {
-        anchorResult = applyHashlineEdits(result, anchorEdits, signal);
-      } catch (err) {
-        if (err instanceof HashlineMismatchError) {
-          return buildEditError(absolutePath, "hash-mismatch", err.message, undefined, {
-            updatedAnchors: err.updatedAnchors
-          });
-        }
-        throw err;
+      if (typeof plan.before_content !== "string" || typeof plan.content !== "string") {
+        return buildEditError(absolutePath, "invalid-output", "readseek edit plan did not include before_content and content");
       }
-      result = anchorResult.content;
-      const replaceWarnings = [];
-      for (const r of replaceEdits) {
-        throwIfAborted(signal);
-        if (!r.replace.old_text.length) {
-          const message = "replace.old_text must not be empty.";
-          return buildEditError(absolutePath, "invalid-edit-variant", message);
-        }
-        const rep = replaceText(result, r.replace.old_text, r.replace.new_text, {
-          all: r.replace.all ?? false,
-          fuzzy: r.replace.fuzzy ?? false
-        });
-        if (!rep.count) {
-          const message = `Could not find exact text to replace in ${path2}.`;
-          const hint = "Re-read the file and prefer set_line/replace_lines/insert_after for hash-verified edits. " + "The replace variant is exact-only by default because fuzzy fallback is unverified.";
-          return buildEditError(absolutePath, "text-not-found", message, hint);
-        }
-        if (rep.usedFuzzyMatch) {
-          replaceWarnings.push("replace used fuzzy matching because exact old_text was not found; re-read the file and prefer set_line/replace_lines/insert_after for hash-verified edits.");
-        }
-        result = rep.content;
-      }
-      if (originalNormalized === result) {
-        let diagnostic = `No changes made to ${path2}. The edits produced identical content.`;
-        if (anchorResult.noopEdits?.length) {
-          diagnostic += `
-` + anchorResult.noopEdits.map((e) => `Edit ${e.editIndex}: replacement for ${e.loc} is identical to current content:
-  ${e.loc}| ${escapeControlCharsForDisplay(e.currentContent)}`).join(`
-`);
-          diagnostic += `
-Re-read the file to see the current state.`;
-        } else {
-          const targetLines = [...new Set(anchorSnapshots.values())];
-          if (targetLines.length > 0) {
-            const preview = targetLines.slice(0, 5).join(`
-`);
-            diagnostic += `
-The file currently contains:
-${preview}
-Your edits were normalized back to the original content. Ensure your replacement changes actual code, not just formatting.`;
-          }
-        }
-        return buildEditError(absolutePath, "no-op", diagnostic);
+      const original = plan.before_content;
+      const result = plan.content;
+      const originalForSyntax = normalizeToLF(stripBom(original).text);
+      const resultForSyntax = normalizeToLF(stripBom(result).text);
+      if (!plan.changed) {
+        return buildEditError(absolutePath, "no-op", `No changes made to ${path2}. The edits produced identical content.`);
       }
-      throwIfAborted(signal);
       const syntaxMode = resolveSyntaxValidateMode({ syntaxValidate });
       let syntaxWarning;
       if (syntaxMode !== "off") {
         const regression = await validateSyntaxRegression({
           filePath: absolutePath,
-          before: originalNormalized,
-          after: result
+          before: originalForSyntax,
+          after: resultForSyntax
         }, { signal });
         if (regression) {
-          const lines = regression.errorLines.join(", ");
-          const message = `syntax-regression: lines ${lines}`;
+          const message = `syntax-regression: lines ${regression.errorLines.join(", ")}`;
           if (syntaxMode === "block") {
             return buildEditError(absolutePath, "syntax-regression", message);
           }
           syntaxWarning = message;
         }
       }
-      const writeContent = bom + restoreLineEndings(result, originalEnding);
+      throwIfAborted(signal);
+      let applied;
       try {
-        await fsWriteFile(absolutePath, writeContent, "utf-8");
+        applied = await readSeekEdit(absolutePath, edits, {
+          apply: true,
+          planHash: plan.plan_hash,
+          language: parsed.language,
+          cancelable: false
+        });
       } catch (err) {
-        return mapEditFileError(err, absolutePath, path2, "write");
+        throwIfAborted(signal);
+        const failure = classifyReadSeekFailure(err);
+        return buildEditError(absolutePath, failure.code, failure.message, failure.hint);
+      }
+      if (!applied.applied) {
+        return buildEditError(absolutePath, "invalid-output", "readseek did not confirm that the edit was applied");
       }
       onFileMutated?.(absolutePath);
-      if (input.postEditVerify === true) {
+      if (parsed.postEditVerify === true) {
         let verifiedContent;
         try {
-          const verified = await fsReadFile2(absolutePath, "utf-8");
-          verifiedContent = verified;
+          verifiedContent = await fsReadFile2(absolutePath, "utf-8");
         } catch (err) {
-          const message = `Edit write completed but post-edit verification failed: could not read ${path2} after writing.`;
-          return buildEditError(absolutePath, "post-edit-verification-read-failed", message, undefined, {
-            fsCode: err?.code,
-            fsMessage: err?.message
-          });
+          return buildEditError(absolutePath, "post-edit-verification-read-failed", `Edit write completed but post-edit verification failed: could not read ${path2} after writing.`, undefined, { fsCode: err?.code, fsMessage: err?.message });
         }
-        if (verifiedContent !== writeContent) {
-          const message = `Edit write completed but post-edit verification did not confirm the intended content for ${path2}. Re-read the file before making follow-up edits.`;
-          return buildEditError(absolutePath, "post-edit-verification-mismatch", message, undefined, {
-            expectedLength: writeContent.length,
-            actualLength: verifiedContent.length
-          });
+        if (verifiedContent !== plan.content) {
+          return buildEditError(absolutePath, "post-edit-verification-mismatch", `Edit write completed but post-edit verification did not confirm the intended content for ${path2}. Re-read the file before making follow-up edits.`, undefined, { expectedLength: plan.content.length, actualLength: verifiedContent.length });
         }
       }
-      const diffResult = generateCompactOrFullDiff(originalNormalized, result);
-      const patch = createPatch(path2, originalNormalized, result);
-      const blockRanges = rsProbeResults.map((probe) => ({
-        kind: "remove",
-        startLine: probe.range.start,
-        endLine: probe.range.end
-      }));
+      const diffResult = generateCompactOrFullDiff(original, result);
+      const patch = createPatch(path2, original, result);
       const diffData = buildDiffData({
         path: absolutePath,
-        oldContent: originalNormalized,
+        oldContent: original,
         newContent: result,
-        diff: diffResult.diff,
-        ...blockRanges.length ? { blockRanges } : {}
+        diff: diffResult.diff
       });
-      const warnings = [];
-      if (anchorResult.warnings?.length)
-        warnings.push(...anchorResult.warnings);
-      if (replaceWarnings.length)
-        warnings.push(...replaceWarnings);
-      if (replaceSymbolWarnings.length)
-        warnings.push(...replaceSymbolWarnings);
-      if (syntaxWarning)
-        warnings.push(syntaxWarning);
-      const internalClassification = classifyEdit(originalNormalized, result);
-      const semanticSummary = {
-        classification: internalClassification.classification
-      };
+      const warnings = syntaxWarning ? [syntaxWarning] : [];
+      const classification = classifyEdit(original, result);
+      const semanticSummary = { classification: classification.classification };
       const builtOutput = buildEditOutput({
         path: absolutePath,
         displayPath: path2,
         diff: diffResult.diff,
         patch,
         diffData,
-        firstChangedLine: anchorResult.firstChangedLine ?? diffResult.firstChangedLine,
+        firstChangedLine: diffResult.firstChangedLine,
         warnings,
-        noopEdits: anchorResult.noopEdits ?? [],
+        noopEdits: [],
         edits,
         semanticSummary
       });
@@ -5213,7 +4148,7 @@ Your edits were normalized back to the original content. Ensure your replacement
           diff: diffResult.diff,
           patch: builtOutput.patch,
           diffData,
-          firstChangedLine: anchorResult.firstChangedLine ?? diffResult.firstChangedLine,
+          firstChangedLine: diffResult.firstChangedLine,
           readSeekValue: builtOutput.readSeekValue
         }
       };
@@ -6627,120 +5562,12 @@ ${linkedPathLine(theme, file.file, display, cwd, ` (${file.edits.length} edits)`
   });
 }
 
-// src/hover.ts
-import { readFile } from "node:fs/promises";
-import { Type as Type9 } from "@sinclair/typebox";
-import { Text as Text7 } from "@earendil-works/pi-tui";
-var HOVER_PROMPT_METADATA = defineToolPromptMetadata({
-  promptUrl: new URL("../prompts/hover.md", import.meta.url),
-  promptSnippet: "Inspect the symbol at a source location"
-});
-var hoverSchema = Type9.Object({
-  path: filePathParam(),
-  line: Type9.Integer({ minimum: 1, description: "One-based cursor line" }),
-  column: Type9.Optional(Type9.Integer({ minimum: 1, description: "One-based cursor byte column for disambiguation" }))
-});
-async function executeHover(opts) {
-  const { params, signal, cwd } = opts;
-  const p = params;
-  if (!Number.isSafeInteger(p.line) || p.line < 1) {
-    return buildToolErrorResult("hover", "invalid-parameter", "hover parameter 'line' must be a positive integer");
-  }
-  if (p.column !== undefined && (!Number.isSafeInteger(p.column) || p.column < 1)) {
-    return buildToolErrorResult("hover", "invalid-parameter", "hover parameter 'column' must be a positive integer");
-  }
-  const filePath = resolveToCwd(p.path, cwd);
-  let content;
-  try {
-    content = await readFile(filePath, "utf-8");
-  } catch (err) {
-    const { code, message } = formatFsError(err, "hover-error");
-    return buildToolErrorResult("hover", code, message, { path: p.path });
-  }
-  try {
-    const output = await readSeekIdentify(filePath, content, {
-      line: p.line,
-      column: p.column,
-      signal
-    });
-    const lines = [];
-    if (output.identifier) {
-      lines.push(`identifier: ${output.identifier.text}`);
-    }
-    if (output.symbol) {
-      lines.push(`symbol: ${output.symbol.name}`);
-      lines.push(`kind: ${output.symbol.kind}`);
-      lines.push(`qualified: ${output.symbol.qualified_name}`);
-    }
-    lines.push(`file: ${output.file}`);
-    lines.push(`language: ${output.language}`);
-    lines.push(`location: ${output.line}:${output.column}`);
-    return {
-      content: [{ type: "text", text: lines.join(`
-`) }],
-      details: {
-        readSeekValue: {
-          tool: "hover",
-          ok: true,
-          path: filePath,
-          output
-        }
-      }
-    };
-  } catch (err) {
-    const failure = classifyReadSeekFailure(err);
-    return buildToolErrorResult("hover", failure.code, failure.message, failure.hint ? { hint: failure.hint } : {});
-  }
-}
-function registerHoverTool(pi) {
-  registerReadSeekTool(pi, {
-    name: "readSeek_hover",
-    label: "Hover",
-    description: HOVER_PROMPT_METADATA.description,
-    promptSnippet: HOVER_PROMPT_METADATA.promptSnippet,
-    promptGuidelines: HOVER_PROMPT_METADATA.promptGuidelines,
-    parameters: hoverSchema,
-    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-      return executeHover({ params, signal, cwd: ctx.cwd });
-    },
-    renderCall(args, theme, ...rest) {
-      const context = rest[0] ?? {};
-      const cwd = context.cwd ?? process.cwd();
-      const displayPath = typeof args?.path === "string" ? args.path : "?";
-      let text = theme.fg("toolTitle", theme.bold("hover"));
-      text += ` ${linkToolPath(theme.fg("accent", displayPath), displayPath, cwd)}`;
-      if (args?.line)
-        text += theme.fg("dim", `:${args.line}`);
-      return new Text7(clampLineToWidth(text, context.width), 0, 0);
-    },
-    renderResult(result, options, theme, ...rest) {
-      const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
-      if (isPartial)
-        return renderPendingResult("pending hover", width, theme);
-      const content = result.content?.[0];
-      const textContent = content?.type === "text" ? content.text : "";
-      if (isError || result.isError) {
-        return renderErrorResult(textContent, { expanded, width, fallback: "hover failed", theme });
-      }
-      const output = result.details?.readSeekValue?.output;
-      const label = output?.identifier?.text ? `identified ${output.identifier.text}` : output?.symbol?.name ? `symbol ${output.symbol.name}` : "identified cursor";
-      let text = summaryLine(label, { hidden: !!textContent && !expanded, theme, style: "success" });
-      if (expanded && textContent)
-        text += `
-${textContent}`;
-      return new Text7(clampLinesToWidth(text.split(`
-`), width).join(`
-`), 0, 0);
-    }
-  });
-}
-
 // src/write.ts
-import { mkdir, readFile as readFile2, writeFile } from "node:fs/promises";
+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 Text8 } from "@earendil-works/pi-tui";
-import { Type as Type10 } from "@sinclair/typebox";
+import { Text as Text7 } from "@earendil-works/pi-tui";
+import { Type as Type9 } from "@sinclair/typebox";
 var WRITE_PENDING_PREVIEW_STATE_KEY = "hashline-write-pending-preview";
 var CONTENT_PREVIEW_MAX_LINES = 200;
 function formatContentPreviewLines(content, theme) {
@@ -6780,7 +5607,7 @@ function isToolErrorResult(result) {
 }
 async function readPreviousTextForDiff(filePath) {
   try {
-    const previous = await readFile2(filePath);
+    const previous = await readFile(filePath);
     return {
       content: looksLikeBinary(previous) ? "" : previous.toString("utf-8"),
       existed: true
@@ -6818,7 +5645,7 @@ function buildWriteFsErrorResult(err, absolutePath) {
 }
 async function executeWrite(opts) {
   await ensureHashInit();
-  const { path: filePath, content, map: requestMap, cwd } = opts;
+  const { path: filePath, content, cwd } = opts;
   const warnings = [];
   const readSeekWarnings = [];
   if (hasBareCarriageReturn(content)) {
@@ -6844,8 +5671,15 @@ async function executeWrite(opts) {
   const { content: previousContent, existed: existedBeforeWrite } = await readPreviousTextForDiff(filePath);
   await mkdir(dirname2(filePath), { recursive: true });
   await writeFile(filePath, content, "utf-8");
-  const rawLines = content.split(`
+  const normalizedContent = stripBom(content).text;
+  const rawLines = normalizedContent === "" ? [] : normalizedContent.split(`
 `);
+  if (rawLines[rawLines.length - 1] === "")
+    rawLines.pop();
+  for (let i = 0;i < rawLines.length; i++) {
+    if (rawLines[i].endsWith("\r"))
+      rawLines[i] = rawLines[i].slice(0, -1);
+  }
   const readSeekLines = [];
   const displayLines = [];
   for (let i = 0;i < rawLines.length; i++) {
@@ -6867,21 +5701,6 @@ async function executeWrite(opts) {
 [… output truncated at 50 KB — full anchors in readSeekValue]`;
     }
   }
-  let mapAppended = false;
-  if (requestMap) {
-    try {
-      const fileMap = await getOrGenerateMap(filePath);
-      if (fileMap) {
-        const mapText = formatFileMapWithBudget(fileMap);
-        if (mapText) {
-          text += `
-
-` + mapText;
-          mapAppended = true;
-        }
-      }
-    } catch {}
-  }
   const displayPath = cwd ? relative3(cwd, filePath) || filePath : filePath;
   const normalizedPrevious = normalizeToLF(previousContent);
   const normalizedNext = normalizeToLF(content);
@@ -6904,8 +5723,7 @@ async function executeWrite(opts) {
       lines: readSeekLines,
       warnings: readSeekWarnings,
       diff: diffResult.diff,
-      diffData,
-      ...requestMap ? { map: { appended: mapAppended } } : {}
+      diffData
     }
   };
 }
@@ -6922,10 +5740,9 @@ function registerWriteTool(pi, options = {}) {
     description: promptMetadata.description,
     promptSnippet: promptMetadata.promptSnippet,
     promptGuidelines: promptMetadata.promptGuidelines,
-    parameters: Type10.Object({
+    parameters: Type9.Object({
       path: filePathParam(),
-      content: Type10.String({ description: "Complete text file content" }),
-      map: mapParam()
+      content: Type9.String({ description: "Complete text file content" })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const cwd = ctx?.cwd ?? process.cwd();
@@ -6937,7 +5754,6 @@ function registerWriteTool(pi, options = {}) {
             result = await executeWrite({
               path: absolutePath,
               content: params.content,
-              map: params.map,
               cwd
             });
           } catch (err) {
@@ -7007,7 +5823,7 @@ function registerWriteTool(pi, options = {}) {
 `);
           lines.push(...formatContentPreviewLines(content, theme));
         }
-        return new Text8(clampLinesToWidth(lines, width).join(`
+        return new Text7(clampLinesToWidth(lines, width).join(`
 `), 0, 0);
       }
       const hasExpandableDiff = !!diffData;
@@ -7016,7 +5832,7 @@ function registerWriteTool(pi, options = {}) {
         return upsertDiffComponent(context.lastComponent, { prefixLines: text.split(`
 `), diffData, theme, expanded: true });
       }
-      return new Text8(clampLinesToWidth(text.split(`
+      return new Text7(clampLinesToWidth(text.split(`
 `), width).join(`
 `), 0, 0);
     }
@@ -7025,7 +5841,7 @@ function registerWriteTool(pi, options = {}) {
 }
 
 // src/def.ts
-import { Type as Type11 } from "@sinclair/typebox";
+import { Type as Type10 } from "@sinclair/typebox";
 import path6 from "node:path";
 var DEF_PROMPT_METADATA = defineToolPromptMetadata({
   promptUrl: new URL("../prompts/def.md", import.meta.url),
@@ -7101,8 +5917,8 @@ function registerDefTool(pi, options = {}) {
     description: DEF_PROMPT_METADATA.description,
     promptSnippet: DEF_PROMPT_METADATA.promptSnippet,
     promptGuidelines: DEF_PROMPT_METADATA.promptGuidelines,
-    parameters: Type11.Object({
-      name: Type11.String({ description: "Qualified or unqualified symbol name" }),
+    parameters: Type10.Object({
+      name: Type10.String({ description: "Qualified or unqualified symbol name" }),
       path: searchPathParam(),
       lang: langParam(),
       ...readSeekGitSearchParams()
@@ -7128,77 +5944,205 @@ function registerDefTool(pi, options = {}) {
   });
 }
 
-// src/check.ts
-import { readFile as readFile3 } from "node:fs/promises";
-import { Text as Text9 } from "@earendil-works/pi-tui";
-import { Type as Type12 } from "@sinclair/typebox";
-var CHECK_PROMPT_METADATA = defineToolPromptMetadata({
-  promptUrl: new URL("../prompts/check.md", import.meta.url),
-  promptSnippet: "Check source syntax for parser errors after edits"
+// src/digest.ts
+import { Text as Text8 } from "@earendil-works/pi-tui";
+import { Type as Type11 } from "@sinclair/typebox";
+var DIGEST_FACETS = ["metadata", "content", "map", "diagnostics", "identity"];
+var DIGEST_PROMPT_METADATA = defineToolPromptMetadata({
+  promptUrl: new URL("../prompts/digest.md", import.meta.url),
+  promptSnippet: "Digest source facets as a native CLI envelope"
 });
-async function executeCheck(opts) {
-  const { params, signal, cwd } = opts;
+var facetSchema = Type11.Union(DIGEST_FACETS.map((facet) => Type11.Literal(facet)));
+var digestSchema = Type11.Object({
+  path: filePathParam(),
+  select: Type11.Optional(Type11.Union([
+    facetSchema,
+    Type11.Array(facetSchema, { minItems: 1 }),
+    Type11.String({
+      description: "Comma-separated facets: metadata, content, map, diagnostics, identity"
+    })
+  ], {
+    description: "Facets: metadata, content, map, diagnostics, identity (default content)"
+  })),
+  at: Type11.Optional(Type11.String({
+    description: "Location: line:N[:COLUMN], hash:HASH[:COLUMN], or symbol:NAME"
+  })),
+  end: optionalIntOrString("Last line to include"),
+  limit: optionalIntOrString("Maximum number of lines to include"),
+  language: Type11.Optional(Type11.String({ description: "Language override" })),
+  visionMode: Type11.Optional(Type11.Union([
+    Type11.Literal("none"),
+    Type11.Literal("all"),
+    Type11.Literal("ocr"),
+    Type11.Literal("caption"),
+    Type11.Literal("objects")
+  ], { description: "Standalone image mode: none, all, caption, objects, or ocr" })),
+  visionLevel: Type11.Optional(Type11.Union([Type11.Literal("low"), Type11.Literal("medium"), Type11.Literal("high")], { description: "Vision inference level: low (default), medium, or high" }))
+});
+function hasDigestAnchors(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const record = value;
+  if (Array.isArray(record.hashlines) && record.hashlines.length > 0)
+    return true;
+  return Object.values(record).some(hasDigestAnchors);
+}
+function parseSelect(select) {
+  if (select === undefined)
+    return;
+  if (Array.isArray(select)) {
+    const facets = select;
+    if (facets.length === 0)
+      throw new Error("select must include at least one facet");
+    for (const facet of facets) {
+      if (!DIGEST_FACETS.includes(facet)) {
+        throw new Error(`unknown digest facet \`${facet}\`; expected ${DIGEST_FACETS.join(", ")}`);
+      }
+    }
+    return facets;
+  }
+  if (typeof select !== "string") {
+    throw new Error("select must be a facet, facet list, or comma-separated facets");
+  }
+  if (DIGEST_FACETS.includes(select)) {
+    return select;
+  }
+  const parts = select.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+  if (parts.length === 0)
+    throw new Error("select must include at least one facet");
+  for (const part of parts) {
+    if (!DIGEST_FACETS.includes(part)) {
+      throw new Error(`unknown digest facet \`${part}\`; expected ${DIGEST_FACETS.join(", ")}`);
+    }
+  }
+  return parts;
+}
+function selectedFacets(select) {
+  if (select === undefined)
+    return ["content"];
+  return Array.isArray(select) ? select : [select];
+}
+function summarizeEnvelope(envelope, facets) {
+  if (!envelope || typeof envelope !== "object")
+    return `digested ${facets.join(",")}`;
+  const record = envelope;
+  const parts = [];
+  for (const facet of facets) {
+    if (facet === "metadata" || record[facet] !== undefined)
+      parts.push(facet);
+  }
+  if (record.metadata !== undefined && !parts.includes("metadata"))
+    parts.unshift("metadata");
+  return `digested ${parts.join(",") || "metadata"}`;
+}
+async function executeDigest(opts) {
+  const { params, signal, cwd, onFileAnchored } = opts;
   const p = params;
-  const filePath = resolveToCwd(p.path, cwd);
-  let content;
+  let select;
   try {
-    content = await readFile3(filePath, "utf-8");
+    select = parseSelect(p.select);
   } catch (err) {
-    const { code, message } = formatFsError(err, "check-error");
-    return buildToolErrorResult("check", code, message, { path: p.path });
+    return buildToolErrorResult("digest", "invalid-parameter", err?.message ?? String(err), {
+      path: p.path
+    });
+  }
+  const end = coerceObviousBase10Int(p.end, "end");
+  if (!end.ok || end.value !== undefined && end.value < 1) {
+    const message = end.ok ? `Invalid end: expected a positive integer, received ${end.value}.` : end.message;
+    return buildToolErrorResult("digest", "invalid-parameter", message, { path: p.path });
+  }
+  const limit = coerceObviousBase10Int(p.limit, "limit");
+  if (!limit.ok || limit.value !== undefined && limit.value < 1) {
+    const message = limit.ok ? `Invalid limit: expected a positive integer, received ${limit.value}.` : limit.message;
+    return buildToolErrorResult("digest", "invalid-parameter", message, { path: p.path });
+  }
+  const at = typeof p.at === "string" ? p.at.trim() : undefined;
+  if (p.at !== undefined && !at) {
+    return buildToolErrorResult("digest", "invalid-parameter", "Invalid at: expected a non-empty location.", {
+      path: p.path
+    });
+  }
+  if (p.visionLevel !== undefined && p.visionMode === undefined) {
+    return buildToolErrorResult("digest", "invalid-params-combo", "visionLevel requires visionMode.", {
+      path: p.path
+    });
   }
+  const filePath = resolveToCwd(p.path, cwd);
+  const facets = selectedFacets(select);
+  const vision = p.visionMode !== undefined && p.visionMode !== "none";
   try {
-    const output = await readSeekCheck(filePath, content, { signal });
-    const lines = output.diagnostics.map((diagnostic) => `${diagnostic.kind}: lines ${diagnostic.start_line}-${diagnostic.end_line}`);
-    const summary = output.errorCount === 0 && output.missingCount === 0 ? "No syntax errors found." : `${output.errorCount} error(s), ${output.missingCount} missing syntax node(s)`;
+    const envelope = await readSeekDigestNative(filePath, {
+      select,
+      at,
+      end: end.value,
+      limit: limit.value,
+      language: p.language,
+      visionMode: p.visionMode,
+      visionLevel: p.visionLevel,
+      signal,
+      vision
+    });
+    if (hasDigestAnchors(envelope))
+      onFileAnchored?.(filePath);
+    const text = JSON.stringify(envelope);
     return {
-      content: [{ type: "text", text: [summary, ...lines].join(`
-`) }],
+      content: [{ type: "text", text }],
       details: {
-        readSeekValue: { tool: "check", ok: true, path: filePath, output }
+        readSeekValue: {
+          tool: "digest",
+          ok: true,
+          path: filePath,
+          select: facets,
+          envelope
+        }
       }
     };
   } catch (err) {
     const failure = classifyReadSeekFailure(err);
-    return buildToolErrorResult("check", failure.code, failure.message, failure.hint ? { hint: failure.hint } : {});
+    return buildToolErrorResult("digest", failure.code, failure.message, failure.hint ? { hint: failure.hint } : {});
   }
 }
-function registerCheckTool(pi) {
+function registerDigestTool(pi, options = {}) {
   return registerReadSeekTool(pi, {
-    name: "readSeek_check",
-    label: "Check",
-    description: CHECK_PROMPT_METADATA.description,
-    promptSnippet: CHECK_PROMPT_METADATA.promptSnippet,
-    promptGuidelines: CHECK_PROMPT_METADATA.promptGuidelines,
-    parameters: Type12.Object({ path: filePathParam() }),
+    name: "readSeek_digest",
+    label: "Digest",
+    description: DIGEST_PROMPT_METADATA.description,
+    promptSnippet: DIGEST_PROMPT_METADATA.promptSnippet,
+    promptGuidelines: DIGEST_PROMPT_METADATA.promptGuidelines,
+    parameters: digestSchema,
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-      return executeCheck({ params, signal, cwd: ctx.cwd });
+      return executeDigest({ params, signal, cwd: ctx.cwd, onFileAnchored: options.onFileAnchored });
     },
     renderCall(args, theme, ...rest) {
       const context = rest[0] ?? {};
       const cwd = context.cwd ?? process.cwd();
       const displayPath = typeof args?.path === "string" ? args.path : "?";
-      const text = `${theme.fg("toolTitle", theme.bold("check"))} ${linkToolPath(theme.fg("accent", displayPath), displayPath, cwd)}`;
-      return new Text9(clampLineToWidth(text, context.width), 0, 0);
+      let text = theme.fg("toolTitle", theme.bold("digest"));
+      text += ` ${linkToolPath(theme.fg("accent", displayPath), displayPath, cwd)}`;
+      if (args?.select !== undefined) {
+        const select = Array.isArray(args.select) ? args.select.join(",") : String(args.select);
+        text += theme.fg("dim", ` [${select}]`);
+      }
+      if (typeof args?.at === "string" && args.at)
+        text += theme.fg("dim", ` @ ${args.at}`);
+      return new Text8(clampLineToWidth(text, context.width), 0, 0);
     },
-    renderResult(result, options, theme, ...rest) {
-      const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
+    renderResult(result, options2, theme, ...rest) {
+      const { isPartial, isError, expanded, width } = resolveRenderResultContext(options2, rest);
       if (isPartial)
-        return renderPendingResult("pending check", width, theme);
+        return renderPendingResult("pending digest", width, theme);
       const textContent = result.content?.[0]?.type === "text" ? result.content[0].text : "";
       if (isError || result.isError) {
-        return renderErrorResult(textContent, { expanded, width, fallback: "check failed", theme });
+        return renderErrorResult(textContent, { expanded, width, fallback: "digest failed", theme });
       }
-      const output = result.details?.readSeekValue?.output;
-      const issueCount = (output?.errorCount ?? 0) + (output?.missingCount ?? 0);
-      let text = summaryLine(issueCount === 0 ? "syntax valid" : `${issueCount} syntax issue(s)`, {
-        theme,
-        style: issueCount === 0 ? "success" : "warning"
-      });
+      const value = result.details?.readSeekValue;
+      const facets = Array.isArray(value?.select) ? value.select : ["content"];
+      const label = summarizeEnvelope(value?.envelope, facets);
+      let text = summaryLine(label, { hidden: !!textContent && !expanded, theme, style: "success" });
       if (expanded && textContent)
         text += `
 ${textContent}`;
-      return new Text9(clampLinesToWidth(text.split(`
+      return new Text8(clampLinesToWidth(text.split(`
 `), width).join(`
 `), 0, 0);
     }
@@ -7211,8 +6155,8 @@ import {
   DEFAULT_MAX_LINES as DEFAULT_MAX_LINES5,
   truncateHead as truncateHead5
 } from "@earendil-works/pi-coding-agent";
-import { Text as Text10 } from "@earendil-works/pi-tui";
-import { Type as Type13 } from "@sinclair/typebox";
+import { Text as Text9 } from "@earendil-works/pi-tui";
+import { Type as Type12 } from "@sinclair/typebox";
 var NODE_KINDS = [
   "artifact",
   "footer",
@@ -7227,7 +6171,7 @@ var NODE_KINDS = [
 ];
 var VIEW_PROMPT_METADATA = defineToolPromptMetadata({
   promptUrl: new URL("../prompts/view.md", import.meta.url),
-  promptSnippet: "Inspect a PDF's structure or selected content"
+  promptSnippet: "Digest a document's structure or selected content"
 });
 async function executeView(opts) {
   const { params, signal, cwd } = opts;
@@ -7248,6 +6192,12 @@ async function executeView(opts) {
       path: input.path
     });
   }
+  if (input.outline && (input.visionMode !== undefined || input.visionLevel !== undefined)) {
+    return buildToolErrorResult("view", "invalid-params-combo", "Cannot combine outline with visionMode or visionLevel.", { path: input.path });
+  }
+  if (input.visionLevel !== undefined && input.visionMode === undefined) {
+    return buildToolErrorResult("view", "invalid-params-combo", "visionLevel requires visionMode.", { path: input.path });
+  }
   const filePath = resolveToCwd(input.path, cwd);
   try {
     const output = await readSeekView(filePath, {
@@ -7256,6 +6206,8 @@ async function executeView(opts) {
       kind: input.kind,
       depth: depth.value,
       outline: input.outline,
+      visionMode: input.visionMode,
+      visionLevel: input.visionLevel,
       signal
     });
     const truncation = truncateHead5(output, {
@@ -7286,15 +6238,26 @@ function registerViewTool(pi) {
     description: VIEW_PROMPT_METADATA.description,
     promptSnippet: VIEW_PROMPT_METADATA.promptSnippet,
     promptGuidelines: VIEW_PROMPT_METADATA.promptGuidelines,
-    parameters: Type13.Object({
+    parameters: Type12.Object({
       path: filePathParam(),
-      node: Type13.Optional(Type13.String({ description: "Node ID to use as the view root" })),
-      page: optionalIntOrString("One-based PDF page"),
-      kind: Type13.Optional(Type13.Union(NODE_KINDS.map((kind) => Type13.Literal(kind)), {
+      node: Type12.Optional(Type12.String({ description: "Node ID to use as the view root" })),
+      page: optionalIntOrString("One-based source page"),
+      kind: Type12.Optional(Type12.Union(NODE_KINDS.map((kind) => Type12.Literal(kind)), {
         description: "Node kind filter"
       })),
       depth: optionalIntOrString("Maximum depth below selected roots"),
-      outline: Type13.Optional(Type13.Boolean({ description: "Return outline nodes only" }))
+      visionMode: Type12.Optional(Type12.Union([
+        Type12.Literal("all"),
+        Type12.Literal("ocr"),
+        Type12.Literal("caption"),
+        Type12.Literal("objects")
+      ], { description: "Analyze selected assets: all, ocr, caption, or objects" })),
+      visionLevel: Type12.Optional(Type12.Union([
+        Type12.Literal("low"),
+        Type12.Literal("medium"),
+        Type12.Literal("high")
+      ], { description: "Vision inference level: low (default), medium, or high" })),
+      outline: Type12.Optional(Type12.Boolean({ description: "Return outline nodes only" }))
     }),
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       return executeView({ params, signal, cwd: ctx.cwd });
@@ -7304,7 +6267,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 Text10(clampLineToWidth(text, context.width), 0, 0);
+      return new Text9(clampLineToWidth(text, context.width), 0, 0);
     },
     renderResult(result, options, theme, ...rest) {
       const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
@@ -7324,7 +6287,7 @@ function registerViewTool(pi) {
       if (expanded && textContent)
         text += `
 ${textContent}`;
-      return new Text10(clampLinesToWidth(text.split(`
+      return new Text9(clampLinesToWidth(text.split(`
 `), width).join(`
 `), 0, 0);
     }
@@ -7356,10 +6319,9 @@ var READSEEK_TOOL_ENTRIES = [
   { builtIn: null, readSeekName: "readSeek_search" },
   { builtIn: null, readSeekName: "readSeek_refs" },
   { builtIn: null, readSeekName: "readSeek_rename" },
-  { builtIn: null, readSeekName: "readSeek_hover" },
   { builtIn: "write", readSeekName: "readSeek_write" },
   { builtIn: null, readSeekName: "readSeek_def" },
-  { builtIn: null, readSeekName: "readSeek_check" },
+  { builtIn: null, readSeekName: "readSeek_digest" },
   { builtIn: null, readSeekName: "readSeek_view" }
 ];
 function formatSettingsWarning(warning) {
@@ -7370,7 +6332,7 @@ function editingPolicy(readName, editName, writeName) {
     "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_check after source edits for a quick syntax check."
+    "- Run readSeek_digest with select diagnostics after source edits for a quick syntax check."
   ].join(`
 `);
 }
@@ -7380,7 +6342,7 @@ function piReadSeekExtension(pi) {
   const hasFreshAnchors = (absolutePath) => sessionAnchors.hasFreshAnchors(absolutePath);
   const forgetAnchors = (absolutePath) => sessionAnchors.forget(absolutePath);
   const { settings } = resolveReadSeekJsonSettings();
-  const replacedBuiltIns = new Set(settings.replacedTools ?? []);
+  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");
@@ -7399,9 +6361,8 @@ function piReadSeekExtension(pi) {
   registerSearchTool(pi, { onFileAnchored: markAnchored });
   registerRefsTool(pi, { onFileAnchored: markAnchored });
   registerRenameTool(pi, { onFileMutated: forgetAnchors });
-  registerHoverTool(pi);
   registerDefTool(pi, { onFileAnchored: markAnchored });
-  registerCheckTool(pi);
+  registerDigestTool(pi, { onFileAnchored: markAnchored });
   registerViewTool(pi);
   registerWriteTool(pi, { onFileAnchored: markAnchored, name: writeName });
   pi.on("before_agent_start", (event) => {