pi-readseek 0.9.8 → 0.9.10

package/dist/index.ts

@@ -403,11 +403,6 @@ var TOOL_CONTRACTS = [
 ];
 // ../readseek-api/src/policy.ts
 var REPLACEABLE_TOOLS = [
-  {
-    tool: "digest",
-    builtIn: "read",
-    benefit: "it returns LINE:HASH anchors for safe edits."
-  },
   {
     tool: "edit",
     builtIn: "edit",
@@ -661,6 +656,7 @@ function buildRenameArgs(input) {
   return appendGitSelectionArgs(args, input);
 }
 // ../readseek-api/src/platform.ts
+import { accessSync, constants as fsConstants } from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 var READSEEK_PLATFORM_PACKAGES = {
@@ -694,6 +690,19 @@ function resolveReadSeekBinaryFromPackages(resolver = resolveFromPackage, option
   });
   return path.join(path.dirname(packageJsonPath), "bin", readSeekBinaryName(platform));
 }
+function resolveReadSeekBinaryFromPath(pathEnv = process.env.PATH) {
+  const name = readSeekBinaryName();
+  for (const dir of (pathEnv ?? "").split(path.delimiter)) {
+    if (!dir)
+      continue;
+    const candidate = path.join(dir, name);
+    try {
+      accessSync(candidate, fsConstants.X_OK);
+      return candidate;
+    } catch {}
+  }
+  return null;
+}
 // ../readseek-api/src/json.ts
 var READSEEK_USAGE_HINT = /\n\s*Run readseek(?: [\w-]+)* --help for more information\.?\s*$/;
 function cleanReadSeekErrorText(stderr) {
@@ -854,1367 +863,1695 @@ async function runReadSeekNodeText(binaryPath, args, options = {}) {
 async function runReadSeekNodeJson(binaryPath, args, options = {}) {
   return parseSuccessfulJson(await runReadSeekNode(binaryPath, args, options));
 }
-// src/tool-prompt-metadata.ts
-var REPLACEABLE_BY_TOOL = new Map(REPLACEABLE_TOOLS.map((entry) => [entry.tool, entry]));
-function toolNameFromPrompt(fileName) {
-  const name = fileName.replace(/\.md$/, "");
-  if (!TOOL_NAMES.includes(name))
-    throw new Error(`unknown ReadSeek tool prompt: ${fileName}`);
-  return name;
+// ../readseek-api/src/client.ts
+function classifyReadSeekFailure(err) {
+  const failure = err;
+  const message = String(failure?.message ?? err);
+  const missing = failure?.code === "ENOENT" || /Cannot find package|Cannot find module|no such file/i.test(message);
+  if (missing) {
+    return { code: "readseek-not-installed", message, hint: "Run npm install to install @jarkkojs/readseek." };
+  }
+  return { code: "readseek-execution-error", message };
 }
-function promptFileName(promptUrl) {
-  return promptUrl.pathname.split("/").pop() ?? "";
+function requireNumber(value, field) {
+  if (typeof value !== "number" || !Number.isSafeInteger(value))
+    throw new Error(`invalid readseek ${field}: expected safe integer`);
+  return value;
 }
-function rewriteRegisteredToolNames(value, toolAliases) {
-  if (!toolAliases)
-    return value;
-  return Object.entries(toolAliases).reduce((rewritten, [canonicalName, registeredName]) => rewritten.replaceAll(canonicalName, registeredName), value);
+function requireString(value, field) {
+  if (typeof value !== "string")
+    throw new Error(`invalid readseek ${field}`);
+  return value;
 }
-function descriptionAliases(toolName, registeredName, toolAliases) {
-  return Object.fromEntries(TOOL_NAMES.map((name) => {
-    const readSeekName = `readSeek_${name}`;
-    const alias = name === toolName && registeredName ? registeredName : toolAliases?.[readSeekName] ?? readSeekName;
-    return [name, alias];
-  }));
+function requireBoolean(value, field) {
+  if (typeof value !== "boolean")
+    throw new Error(`invalid readseek ${field}: expected boolean`);
+  return value;
 }
-function defineToolPromptMetadata(options) {
-  const fileName = promptFileName(options.promptUrl);
-  const toolName = toolNameFromPrompt(fileName);
-  const replaceable = REPLACEABLE_BY_TOOL.get(toolName);
-  const defaultReadSeekName = `readSeek_${toolName}`;
-  const registeredName = options.registeredName ?? (replaceable ? defaultReadSeekName : undefined);
-  const preferenceGuideline = replaceable && registeredName ? registeredName === defaultReadSeekName ? `Prefer ${registeredName} over ${replaceable.builtIn} when both are available; ${replaceable.benefit}` : `Use ${registeredName}; ${replaceable.benefit}` : undefined;
-  const aliases = descriptionAliases(toolName, registeredName, options.toolAliases);
+function optionalString(value, field) {
+  if (value === undefined || value === null)
+    return;
+  return requireString(value, field);
+}
+function parseHashline(value, field) {
+  if (!value || typeof value !== "object")
+    throw new Error(`invalid readseek ${field}`);
+  const item = value;
   return {
-    description: renderToolDescription(toolName, aliases),
-    promptSnippet: rewriteRegisteredToolNames(options.promptSnippet, options.toolAliases),
-    promptGuidelines: [
-      ...preferenceGuideline ? [preferenceGuideline] : [],
-      ...renderCompactGuidelines(toolName, aliases)
-    ]
+    line: requireNumber(item.line, `${field}.line`),
+    hash: requireString(item.hash, `${field}.hash`),
+    text: requireString(item.text, `${field}.text`)
   };
 }
-
-// src/edit-diff.ts
-import * as Diff from "diff";
-
-// src/hashline.ts
-import xxhashWasm from "xxhash-wasm";
-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_STATE_KEY = Symbol.for("pi-readseek.hashlineState.v1");
-function getHashlineState() {
-  const globalObject = globalThis;
-  const state = globalObject[HASHLINE_STATE_KEY] ?? {
-    h32Fn: null,
-    initPromise: null
-  };
-  globalObject[HASHLINE_STATE_KEY] = state;
-  return state;
+function parseSearchHashlines(value, field) {
+  if (!Array.isArray(value))
+    throw new Error(`invalid readseek ${field}`);
+  return value.map((line) => parseHashline(line, field));
 }
-async function ensureHashInit() {
-  const state = getHashlineState();
-  if (state.h32Fn)
-    return;
-  if (!state.initPromise) {
-    state.initPromise = xxhashWasm().then((hasher) => {
-      state.h32Fn = hasher.h32;
-    });
-  }
-  await state.initPromise;
+function parseReadOutput(value) {
+  if (!value || typeof value !== "object")
+    throw new Error("invalid readseek read output");
+  const output = value;
+  const hashlines = output.hashlines;
+  if (!Array.isArray(hashlines))
+    throw new Error("invalid readseek hashlines");
+  return {
+    file: requireString(output.file, "file"),
+    language: requireString(output.language, "language"),
+    line_count: requireNumber(output.line_count, "line_count"),
+    file_hash: requireString(output.file_hash, "file_hash"),
+    start_line: requireNumber(output.start_line, "start_line"),
+    end_line: requireNumber(output.end_line, "end_line"),
+    hashlines: hashlines.map((line) => parseHashline(line, "hashline"))
+  };
 }
-function xxh32(input) {
-  const state = getHashlineState();
-  if (!state.h32Fn)
-    throw new Error("Hash not initialized — call ensureHashInit() first");
-  return state.h32Fn(input, 0) >>> 0;
+function parseMapOutput(value) {
+  if (!value || typeof value !== "object")
+    throw new Error("invalid readseek map output");
+  const output = value;
+  const symbols = output.symbols;
+  if (!Array.isArray(symbols))
+    throw new Error("invalid readseek symbols");
+  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"),
+    symbols: symbols.map((symbol) => {
+      if (!symbol || typeof symbol !== "object")
+        throw new Error("invalid readseek symbol");
+      const item = symbol;
+      return {
+        kind: requireString(item.kind, "symbol.kind"),
+        name: requireString(item.name, "symbol.name"),
+        qualified_name: requireString(item.qualified_name, "symbol.qualified_name"),
+        start_line: requireNumber(item.start_line, "symbol.start_line"),
+        end_line: requireNumber(item.end_line, "symbol.end_line"),
+        start_hash: requireString(item.start_hash, "symbol.start_hash"),
+        end_hash: requireString(item.end_hash, "symbol.end_hash")
+      };
+    })
+  };
 }
-function computeLineHash(line) {
-  if (line.endsWith("\r"))
-    line = line.slice(0, -1);
-  line = line.replace(/\s+/g, "");
-  return DICT[xxh32(line) % HASH_MOD];
+function parseSearchOutput(value) {
+  if (!value || typeof value !== "object")
+    throw new Error("invalid readseek search output");
+  const output = value;
+  if (!Array.isArray(output.results))
+    throw new Error("invalid readseek search results");
+  return output.results.map((result) => {
+    if (!result || typeof result !== "object")
+      throw new Error("invalid readseek search result");
+    const file = result;
+    if (!Array.isArray(file.matches))
+      throw new Error("invalid readseek search matches");
+    return {
+      file: requireString(file.file, "search.file"),
+      language: requireString(file.language, "search.language"),
+      file_hash: requireString(file.file_hash, "search.file_hash"),
+      matches: file.matches.map((match) => {
+        if (!match || typeof match !== "object")
+          throw new Error("invalid readseek search match");
+        const item = match;
+        if (!Array.isArray(item.captures))
+          throw new Error("invalid readseek search captures");
+        return {
+          pattern_index: item.pattern_index === undefined ? 0 : requireNumber(item.pattern_index, "search.match.pattern_index"),
+          start_line: requireNumber(item.start_line, "search.match.start_line"),
+          end_line: requireNumber(item.end_line, "search.match.end_line"),
+          start_hash: requireString(item.start_hash, "search.match.start_hash"),
+          end_hash: requireString(item.end_hash, "search.match.end_hash"),
+          hashlines: parseSearchHashlines(item.hashlines, "search.match.hashlines"),
+          captures: item.captures.map((capture) => {
+            if (!capture || typeof capture !== "object")
+              throw new Error("invalid readseek search capture");
+            const captureItem = capture;
+            return {
+              name: requireString(captureItem.name, "search.capture.name"),
+              start_line: requireNumber(captureItem.start_line, "search.capture.start_line"),
+              end_line: requireNumber(captureItem.end_line, "search.capture.end_line"),
+              start_hash: requireString(captureItem.start_hash, "search.capture.start_hash"),
+              end_hash: requireString(captureItem.end_hash, "search.capture.end_hash"),
+              hashlines: parseSearchHashlines(captureItem.hashlines, "search.capture.hashlines")
+            };
+          })
+        };
+      })
+    };
+  });
 }
-var DISPLAY_CONTROL_CHAR_RE = /[\x00-\x08\x0b\x0c\x0e-\x1f]/g;
-function escapeControlCharsForDisplay(text) {
-  return text.replace(DISPLAY_CONTROL_CHAR_RE, (ch) => {
-    return `\\u${ch.charCodeAt(0).toString(16).padStart(4, "0")}`;
+function parseRefsOutput(value) {
+  if (!value || typeof value !== "object")
+    throw new Error("invalid readseek refs output");
+  const output = value;
+  if (!Array.isArray(output.references))
+    throw new Error("invalid readseek references");
+  return output.references.map((reference) => {
+    if (!reference || typeof reference !== "object")
+      throw new Error("invalid readseek reference");
+    const item = reference;
+    const symbol = item.symbol;
+    const enclosing = symbol && typeof symbol === "object" ? optionalString(symbol.qualified_name, "reference.symbol.qualified_name") : undefined;
+    return {
+      file: requireString(item.file, "reference.file"),
+      line: requireNumber(item.line, "reference.line"),
+      column: requireNumber(item.column, "reference.column"),
+      line_hash: requireString(item.line_hash, "reference.line_hash"),
+      text: requireString(item.text, "reference.text"),
+      enclosingSymbol: enclosing
+    };
   });
 }
-function formatHashlineDisplay(lineNumber, content) {
-  return `${lineNumber}:${computeLineHash(content)}|${escapeControlCharsForDisplay(content)}`;
+function parseDiagnosticKind(value) {
+  if (value === "error" || value === "missing")
+    return value;
+  throw new Error("invalid readseek diagnostic.kind");
 }
-
-// src/edit-diff.ts
-function normalizeToLF(text) {
-  return text.replace(/\r\n/g, `
-`).replace(/\r/g, `
-`);
+function parseCheckOutput(value) {
+  if (!value || typeof value !== "object")
+    throw new Error("invalid readseek check output");
+  const output = value;
+  if (!Array.isArray(output.diagnostics))
+    throw new Error("invalid readseek diagnostics");
+  return {
+    errorCount: requireNumber(output.error_count, "error_count"),
+    missingCount: requireNumber(output.missing_count, "missing_count"),
+    diagnostics: output.diagnostics.map((diagnostic) => {
+      if (!diagnostic || typeof diagnostic !== "object")
+        throw new Error("invalid readseek diagnostic");
+      const item = diagnostic;
+      return {
+        kind: parseDiagnosticKind(item.kind),
+        start_line: requireNumber(item.start_line, "diagnostic.start_line"),
+        end_line: requireNumber(item.end_line, "diagnostic.end_line")
+      };
+    })
+  };
 }
-function stripBom(content) {
-  return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
+function parseDetectedObjects(value) {
+  if (value === undefined || value === null)
+    return;
+  if (!Array.isArray(value))
+    throw new Error("invalid readseek detect objects");
+  return value.map((object) => {
+    if (!object || typeof object !== "object")
+      throw new Error("invalid readseek detect object");
+    const item = object;
+    const bbox = item.bbox;
+    if (!Array.isArray(bbox) || bbox.length !== 4)
+      throw new Error("invalid readseek detect object.bbox");
+    return {
+      label: requireString(item.label, "object.label"),
+      bbox: bbox.map((n, i) => requireNumber(n, `object.bbox[${i}]`))
+    };
+  });
 }
-function hasBareCarriageReturn(content) {
-  return content.replace(/\r\n/g, "").includes("\r");
+function parseImageEncoding(value) {
+  if (value === "base64")
+    return value;
+  throw new Error("invalid image encoding");
 }
-function generateDiffString(oldContent, newContent, contextLines = 4) {
-  const parts = Diff.diffLines(oldContent, newContent);
-  const output = [];
-  const maxLineNum = Math.max(oldContent.split(`
-`).length, newContent.split(`
-`).length);
-  const lineNumWidth = String(maxLineNum).length;
-  let oldLineNum = 1;
-  let newLineNum = 1;
-  let lastWasChange = false;
-  let firstChangedLine;
-  for (let i = 0;i < parts.length; i++) {
-    const part = parts[i];
-    const raw = part.value.split(`
-`);
-    if (raw[raw.length - 1] === "")
-      raw.pop();
-    if (part.added || part.removed) {
-      if (firstChangedLine === undefined)
-        firstChangedLine = newLineNum;
-      for (const line of raw) {
-        if (part.added) {
-          output.push(`+${String(newLineNum).padStart(lineNumWidth, " ")} ${line}`);
-          newLineNum++;
-        } else {
-          output.push(`-${String(oldLineNum).padStart(lineNumWidth, " ")} ${line}`);
-          oldLineNum++;
-        }
-      }
-      lastWasChange = true;
-      continue;
-    }
-    const nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
-    if (lastWasChange || nextPartIsChange) {
-      let linesToShow = raw;
-      let skipStart = 0;
-      let skipEnd = 0;
-      if (!lastWasChange) {
-        skipStart = Math.max(0, raw.length - contextLines);
-        linesToShow = raw.slice(skipStart);
-      }
-      if (!nextPartIsChange && linesToShow.length > contextLines) {
-        skipEnd = linesToShow.length - contextLines;
-        linesToShow = linesToShow.slice(0, contextLines);
-      }
-      if (skipStart > 0) {
-        output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
-        oldLineNum += skipStart;
-        newLineNum += skipStart;
-      }
-      for (const line of linesToShow) {
-        output.push(` ${String(oldLineNum).padStart(lineNumWidth, " ")} ${line}`);
-        oldLineNum++;
-        newLineNum++;
-      }
-      if (skipEnd > 0) {
-        output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
-        oldLineNum += skipEnd;
-        newLineNum += skipEnd;
-      }
-    } else {
-      oldLineNum += raw.length;
-      newLineNum += raw.length;
-    }
-    lastWasChange = false;
+function parseDetectOutput(value) {
+  if (!value || typeof value !== "object")
+    throw new Error("invalid readseek detect output");
+  const output = value;
+  const type = requireString(output.type, "type");
+  const file = requireString(output.file, "file");
+  const mime = optionalString(output.mime, "mime");
+  if (type === "application/pdf") {
+    if (output.format !== "pdf")
+      throw new Error("invalid readseek PDF format");
+    return {
+      kind: "pdf",
+      type,
+      file,
+      mime,
+      format: output.format,
+      pages: requireNumber(output.pages, "pages")
+    };
   }
-  return { diff: output.join(`
-`), firstChangedLine };
-}
-function generateCompactOrFullDiff(oldContent, newContent, contextLines = 4) {
-  if (oldContent === newContent)
-    return { diff: "", firstChangedLine: undefined };
-  const oldLines = oldContent.split(`
-`);
-  const newLines = newContent.split(`
-`);
-  if (oldLines.length === newLines.length) {
-    let changedIndex = -1;
-    let changeCount = 0;
-    for (let i = 0;i < oldLines.length; i++) {
-      if (oldLines[i] !== newLines[i]) {
-        changedIndex = i;
-        changeCount++;
-        if (changeCount > 1)
-          break;
-      }
-    }
-    if (changeCount === 1 && changedIndex >= 0) {
-      const lineNum = changedIndex + 1;
-      const oldLine = oldLines[changedIndex] ?? "";
-      const newLine = newLines[changedIndex] ?? "";
-      const oldHash = computeLineHash(oldLine);
-      const newHash = computeLineHash(newLine);
-      return {
-        diff: `${lineNum}:${oldHash}|${oldLine} → ${lineNum}:${newHash}|${newLine}`,
-        firstChangedLine: lineNum
-      };
-    }
+  if (output.width !== undefined || output.height !== undefined) {
+    return {
+      kind: "image",
+      type,
+      file,
+      mime,
+      format: requireString(output.format, "format"),
+      width: requireNumber(output.width, "width"),
+      height: requireNumber(output.height, "height"),
+      animated: requireBoolean(output.animated, "animated"),
+      encoding: output.encoding === undefined ? undefined : parseImageEncoding(output.encoding),
+      data: output.data === undefined ? undefined : requireString(output.data, "data"),
+      ocr: optionalString(output.ocr, "ocr"),
+      caption: optionalString(output.caption, "caption"),
+      objects: parseDetectedObjects(output.objects)
+    };
   }
-  if (oldLines.length === newLines.length + 1) {
-    let deletedIndex = -1;
-    let j = 0;
-    let failed = false;
-    for (let i = 0;i < oldLines.length; i++) {
-      if (j < newLines.length && oldLines[i] === newLines[j]) {
-        j++;
-        continue;
-      }
-      if (deletedIndex === -1) {
-        deletedIndex = i;
-        continue;
-      }
-      failed = true;
-      break;
-    }
-    if (!failed && deletedIndex !== -1 && j === newLines.length) {
-      const lineNum = deletedIndex + 1;
-      const oldLine = oldLines[deletedIndex] ?? "";
-      const oldHash = computeLineHash(oldLine);
-      return {
-        diff: `${lineNum}:${oldHash}|${oldLine} → [deleted]`,
-        firstChangedLine: lineNum
-      };
-    }
+  if (output.language !== undefined) {
+    return {
+      kind: "source",
+      type,
+      file,
+      language: requireString(output.language, "language"),
+      engine: optionalString(output.engine, "engine"),
+      supported: requireBoolean(output.supported, "supported"),
+      mime,
+      syntax: optionalString(output.syntax, "syntax")
+    };
   }
-  return generateDiffString(oldContent, newContent, contextLines);
-}
-
-// src/path-utils.ts
-import { homedir } from "node:os";
-import { isAbsolute, resolve as resolvePath } from "node:path";
-var UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
-function normalizeUnicodeSpaces(str) {
-  return str.replace(UNICODE_SPACES, " ");
+  return { kind: "text", type, file, mime };
 }
-function normalizeAtPrefix(filePath) {
-  return filePath.startsWith("@") ? filePath.slice(1) : filePath;
+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 expandPath(filePath) {
-  const normalized = normalizeUnicodeSpaces(normalizeAtPrefix(filePath));
-  if (normalized === "~")
-    return homedir();
-  if (normalized.startsWith("~/"))
-    return homedir() + normalized.slice(1);
-  return normalized;
+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 resolveToCwd(filePath, cwd) {
-  const expanded = expandPath(filePath);
-  return isAbsolute(expanded) ? expanded : resolvePath(cwd, expanded);
+function parseImageContent(value) {
+  const detection = parseDetectOutput(value);
+  if (detection.kind !== "image")
+    throw new Error("invalid readseek image content");
+  return detection;
 }
-
-// src/runtime.ts
-function throwIfAborted(signal) {
-  if (signal?.aborted)
-    throw new Error("Operation aborted");
+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);
 }
-
-// src/fs-error.ts
-var SYSLOG_PATH_SUFFIX = /,\s+[a-z]+(\s+'.*')?$/;
-function strerror(err) {
-  const raw = String(err?.message ?? String(err));
-  return raw.replace(SYSLOG_PATH_SUFFIX, "");
+function 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 formatFsError(err, domain) {
-  const errno = typeof err.code === "string" ? err.code : "EIO";
+function parseEditOutput(value) {
+  if (!value || typeof value !== "object")
+    throw new Error("invalid readseek edit output");
+  const output = value;
   return {
-    code: errno,
-    message: `${domain}: ${errno}: ${strerror(err)}`
+    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")
   };
 }
-
-// src/edit-render-helpers.ts
-var VARIANT_KEYS = ["set_line", "replace_lines", "insert_after", "replace"];
-function countEditTypes(edits) {
-  const counts = {
-    set_line: 0,
-    replace_lines: 0,
-    insert_after: 0,
-    replace: 0,
-    total: 0
+function parseRenameConflicts(value, field) {
+  if (value === undefined)
+    return [];
+  if (!Array.isArray(value))
+    throw new Error(`invalid readseek ${field}`);
+  return value.map((item) => {
+    if (!item || typeof item !== "object")
+      throw new Error(`invalid readseek ${field} entry`);
+    const c = item;
+    return {
+      line: requireNumber(c.line, `${field}.line`),
+      column: requireNumber(c.column, `${field}.column`),
+      reason: requireString(c.reason, `${field}.reason`)
+    };
+  });
+}
+function parseRenameEdits(value, field) {
+  if (value === undefined)
+    return [];
+  if (!Array.isArray(value))
+    throw new Error(`invalid readseek ${field} entry`);
+  return value.map((item) => {
+    if (!item || typeof item !== "object")
+      throw new Error(`invalid readseek ${field} entry`);
+    const e = item;
+    return {
+      line: requireNumber(e.line, `${field}.line`),
+      start_column: requireNumber(e.start_column, `${field}.start_column`),
+      end_column: requireNumber(e.end_column, `${field}.end_column`),
+      start_byte: requireNumber(e.start_byte, `${field}.start_byte`),
+      end_byte: requireNumber(e.end_byte, `${field}.end_byte`),
+      occurrence: requireString(e.occurrence, `${field}.occurrence`),
+      line_hash: requireString(e.line_hash, `${field}.line_hash`),
+      text: requireString(e.text, `${field}.text`)
+    };
+  });
+}
+function parseRenameOutput(value) {
+  if (!value || typeof value !== "object")
+    throw new Error("invalid readseek rename output");
+  const output = value;
+  const others = output.others;
+  if (others !== undefined && !Array.isArray(others))
+    throw new Error("invalid readseek others");
+  return {
+    file: requireString(output.file, "file"),
+    language: requireString(output.language, "language"),
+    engine: optionalString(output.engine, "engine"),
+    file_hash: requireString(output.file_hash, "file_hash"),
+    old_name: requireString(output.old_name, "old_name"),
+    new_name: requireString(output.new_name, "new_name"),
+    applied: requireBoolean(output.applied, "applied"),
+    conflicts: parseRenameConflicts(output.conflicts, "conflicts"),
+    edits: parseRenameEdits(output.edits, "edits"),
+    others: others?.map((entry) => {
+      if (!entry || typeof entry !== "object")
+        throw new Error("invalid readseek other");
+      const o = entry;
+      return {
+        file: requireString(o.file, "other.file"),
+        language: requireString(o.language, "other.language"),
+        engine: optionalString(o.engine, "other.engine"),
+        file_hash: requireString(o.file_hash, "other.file_hash"),
+        conflicts: parseRenameConflicts(o.conflicts, "other.conflicts"),
+        edits: parseRenameEdits(o.edits, "other.edits")
+      };
+    }) ?? []
   };
-  if (!edits)
-    return counts;
-  for (const edit of edits) {
-    counts.total++;
-    if (edit && typeof edit === "object") {
-      for (const key of VARIANT_KEYS) {
-        if (key in edit) {
-          counts[key]++;
-          break;
-        }
-      }
-    }
-  }
-  return counts;
 }
-function parseDiffStats(diff) {
-  if (!diff)
-    return { added: 0, removed: 0 };
-  let added = 0;
-  let removed = 0;
-  for (const line of diff.split(`
-`)) {
-    if (line.startsWith("+++") || line.startsWith("---"))
-      continue;
-    if (line.startsWith("+"))
-      added++;
-    else if (line.startsWith("-"))
-      removed++;
-  }
-  return { added, removed };
+function parseDefCompact(value) {
+  if (!value || typeof value !== "object")
+    throw new Error("invalid readseek def output");
+  const output = value;
+  const locations = output.locations;
+  if (!Array.isArray(locations))
+    throw new Error("invalid readseek def locations");
+  return locations.map((loc) => {
+    if (!loc || typeof loc !== "object")
+      throw new Error("invalid readseek def location");
+    const item = loc;
+    return {
+      file: requireString(item.file, "location.file"),
+      line: requireNumber(item.line, "location.line"),
+      column: requireNumber(item.column, "location.column"),
+      line_hash: requireString(item.line_hash, "location.line_hash"),
+      text: requireString(item.text, "location.text"),
+      kind: optionalString(item.kind, "location.kind"),
+      name: optionalString(item.name, "location.name"),
+      qualified_name: optionalString(item.qualified_name, "location.qualified_name")
+    };
+  });
 }
-function formatEditCallText(args, argsComplete) {
-  const rawPath = typeof args?.path === "string" ? args.path : null;
-  if (!argsComplete) {
-    return { path: rawPath, suffix: undefined };
-  }
-  const edits = args?.edits;
-  if (!Array.isArray(edits) || edits.length === 0) {
-    return { path: rawPath, suffix: undefined };
+function createReadSeekClient(runner) {
+  function digestArgs(target, options) {
+    return buildDigestArgs({
+      path: target,
+      select: options.select ?? "content",
+      at: options.at,
+      end: options.end,
+      limit: options.limit,
+      language: options.language,
+      visionMode: options.visionMode,
+      visionLevel: options.visionLevel,
+      stdinName: options.stdin !== undefined && target === "-" ? options.stdinName ?? target : undefined
+    });
   }
-  const counts = countEditTypes(edits);
-  const parts = [];
-  for (const key of VARIANT_KEYS) {
-    if (counts[key] > 0) {
-      parts.push(`${counts[key]} ${key}`);
+  async function runDigestRaw(target, options = {}) {
+    const args = digestArgs(target, options);
+    const runOptions = {
+      signal: options.signal,
+      stdin: options.stdin,
+      timeoutMs: options.timeoutMs,
+      vision: options.vision
+    };
+    return runner.json(args, runOptions);
+  }
+  async function digest(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;
+  }
+  async function digestContent(filePath, options = {}) {
+    const envelope = await digest(filePath, {
+      select: "content",
+      at: options.startLine !== undefined ? buildLineLocation(options.startLine) : undefined,
+      end: options.endLine,
+      visionMode: options.visionMode,
+      signal: options.signal,
+      vision: options.vision
+    });
+    if (envelope.metadata.kind === "pdf") {
+      return { metadata: envelope.metadata, cache: envelope.cache };
     }
-  }
-  const word = counts.total === 1 ? "edit" : "edits";
-  const suffix = `${counts.total} ${word} (${parts.join(", ")})`;
-  return { path: rawPath, suffix };
-}
-function formatEditResultText(input) {
-  const { isError, diff, warnings, noopEdits, errorText } = input;
-  const isNoOp = isError && (Array.isArray(noopEdits) && noopEdits.length > 0 || errorText.includes("No changes made"));
-  const stats = parseDiffStats(diff);
-  const hasDiffStats = stats.added > 0 || stats.removed > 0;
-  const diffStats = hasDiffStats ? `+${stats.added} / -${stats.removed}` : undefined;
-  let warningsBadge;
-  if (warnings.length === 1) {
-    warningsBadge = "⚠ 1 warning";
-  } else if (warnings.length > 1) {
-    warningsBadge = `⚠ ${warnings.length} warnings`;
-  }
-  const showErrorText = isError ? errorText : undefined;
-  let semanticBadge;
-  if (!isError && !isNoOp && input.semanticClassification) {
-    switch (input.semanticClassification) {
-      case "whitespace-only":
-        semanticBadge = "ws-only";
-        break;
-      case "semantic":
-        semanticBadge = "✓ semantic";
-        break;
-      case "mixed":
-        semanticBadge = "mixed";
-        break;
+    const content = requireDigestContent(envelope, "content");
+    if (envelope.metadata.kind === "image") {
+      return { metadata: envelope.metadata, image: parseImageContent(content) };
     }
+    return { metadata: envelope.metadata, text: parseTextContent(content) };
   }
   return {
-    diffStats,
-    noOp: isNoOp,
-    warningsBadge,
-    errorText: showErrorText,
-    semanticBadge
+    async view(filePath, options = {}) {
+      const args = buildViewArgs({
+        path: filePath,
+        node: options.node,
+        page: options.page,
+        kind: options.kind,
+        depth: options.depth,
+        outline: options.outline,
+        visionMode: options.visionMode,
+        visionLevel: options.visionLevel
+      });
+      return runner.text(args, {
+        signal: options.signal,
+        vision: options.visionMode !== undefined
+      });
+    },
+    digestRaw(target, options = {}) {
+      return runDigestRaw(target, options);
+    },
+    digest,
+    digestContent,
+    async image(filePath, modes, options = {}) {
+      const requestedModes = modes.length > 1 ? ["all"] : modes;
+      const results = await Promise.allSettled(requestedModes.map(async (mode) => {
+        const digested = await digestContent(filePath, {
+          visionMode: mode,
+          signal: options.signal,
+          vision: true
+        });
+        if (!digested.image)
+          throw new Error(`readseek returned no image analysis for ${filePath}`);
+        return digested.image;
+      }));
+      let merged;
+      for (const result of results) {
+        if (result.status !== "fulfilled")
+          continue;
+        const detection = result.value;
+        merged = merged === undefined ? detection : {
+          ...merged,
+          ocr: detection.ocr ?? merged.ocr,
+          caption: detection.caption ?? merged.caption,
+          objects: detection.objects ?? merged.objects
+        };
+      }
+      if (merged !== undefined)
+        return merged;
+      const failure = results.find((result) => result.status === "rejected");
+      if (failure?.status === "rejected")
+        throw failure.reason;
+      throw new Error(`readseek returned no image analysis for ${filePath}`);
+    },
+    async preparedImage(filePath, options = {}) {
+      const digested = await digestContent(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 };
+    },
+    async search(target, pattern, options = {}) {
+      const args = buildSearchArgs({
+        path: target,
+        pattern,
+        language: options.language,
+        cached: options.cached,
+        others: options.others,
+        ignored: options.ignored
+      });
+      return parseSearchOutput(await runner.json(args, { signal: options.signal }));
+    },
+    async refs(target, options = {}) {
+      const args = buildRefsArgs({
+        path: target,
+        name: options.name,
+        scope: options.scope,
+        line: options.line,
+        column: options.column,
+        language: options.language,
+        cached: options.cached,
+        others: options.others,
+        ignored: options.ignored
+      });
+      return parseRefsOutput(await runner.json(args, { signal: options.signal }));
+    },
+    async def(target, options) {
+      const args = buildDefArgs({
+        path: target,
+        name: options.name,
+        format: "plain",
+        language: options.language,
+        cached: options.cached,
+        others: options.others,
+        ignored: options.ignored
+      });
+      return parseDefCompact(await runner.json(args, { signal: options.signal }));
+    },
+    async check(filePath, content, options = {}) {
+      const envelope = await digest("-", {
+        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 identify(filePath, content, options = {}) {
+      const envelope = await digest("-", {
+        select: "identity",
+        stdin: content,
+        stdinName: filePath,
+        at: options.line !== undefined ? buildLineLocation(options.line, options.column) : undefined,
+        language: options.language,
+        signal: options.signal
+      });
+      if (!envelope.identity)
+        throw new Error("invalid readseek identity: missing identity facet");
+      return envelope.identity;
+    },
+    async detect(filePath, options = {}) {
+      const envelope = await digest(filePath, { select: "metadata", signal: options.signal });
+      return envelope.metadata;
+    },
+    async edit(filePath, edits, options = {}) {
+      const args = buildEditArgs({
+        path: filePath,
+        apply: options.apply,
+        planHash: options.planHash,
+        language: options.language
+      });
+      return parseEditOutput(await runner.json(args, {
+        signal: options.signal,
+        stdin: JSON.stringify({ edits }),
+        timeoutMs: options.timeoutMs,
+        cancelable: options.cancelable
+      }));
+    },
+    async rename(filePath, options) {
+      const args = buildRenameArgs({
+        path: filePath,
+        to: options.to,
+        line: options.line,
+        column: options.column,
+        workspace: options.workspace,
+        apply: options.apply,
+        language: options.language,
+        cached: options.cached,
+        others: options.others,
+        ignored: options.ignored
+      });
+      return parseRenameOutput(await runner.json(args, { signal: options.signal }));
+    }
+  };
+}
+// src/tool-prompt-metadata.ts
+var REPLACEABLE_BY_TOOL = new Map(REPLACEABLE_TOOLS.map((entry) => [entry.tool, entry]));
+function toolNameFromPrompt(fileName) {
+  const name = fileName.replace(/\.md$/, "");
+  if (!TOOL_NAMES.includes(name))
+    throw new Error(`unknown ReadSeek tool prompt: ${fileName}`);
+  return name;
+}
+function promptFileName(promptUrl) {
+  return promptUrl.pathname.split("/").pop() ?? "";
+}
+function rewriteRegisteredToolNames(value, toolAliases) {
+  if (!toolAliases)
+    return value;
+  return Object.entries(toolAliases).reduce((rewritten, [canonicalName, registeredName]) => rewritten.replaceAll(canonicalName, registeredName), value);
+}
+function descriptionAliases(toolName, registeredName, toolAliases) {
+  return Object.fromEntries(TOOL_NAMES.map((name) => {
+    const readSeekName = `readSeek_${name}`;
+    const alias = name === toolName && registeredName ? registeredName : toolAliases?.[readSeekName] ?? readSeekName;
+    return [name, alias];
+  }));
+}
+function defineToolPromptMetadata(options) {
+  const fileName = promptFileName(options.promptUrl);
+  const toolName = toolNameFromPrompt(fileName);
+  const replaceable = REPLACEABLE_BY_TOOL.get(toolName);
+  const defaultReadSeekName = `readSeek_${toolName}`;
+  const registeredName = options.registeredName ?? (replaceable ? defaultReadSeekName : undefined);
+  const preferenceGuideline = replaceable && registeredName ? registeredName === defaultReadSeekName ? `Prefer ${registeredName} over ${replaceable.builtIn} when both are available; ${replaceable.benefit}` : `Use ${registeredName}; ${replaceable.benefit}` : undefined;
+  const aliases = descriptionAliases(toolName, registeredName, options.toolAliases);
+  return {
+    description: renderToolDescription(toolName, aliases),
+    promptSnippet: rewriteRegisteredToolNames(options.promptSnippet, options.toolAliases),
+    promptGuidelines: [
+      ...preferenceGuideline ? [preferenceGuideline] : [],
+      ...renderCompactGuidelines(toolName, aliases)
+    ]
   };
 }
 
-// src/readseek-value.ts
-function buildReadSeekLineWithHash(line, hash, raw) {
-  return {
-    line,
-    hash,
-    anchor: `${line}:${hash}`,
-    raw,
-    display: escapeControlCharsForDisplay(raw)
+// src/edit-diff.ts
+import * as Diff from "diff";
+
+// src/hashline.ts
+import xxhashWasm from "xxhash-wasm";
+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_STATE_KEY = Symbol.for("pi-readseek.hashlineState.v1");
+function getHashlineState() {
+  const globalObject = globalThis;
+  const state = globalObject[HASHLINE_STATE_KEY] ?? {
+    h32Fn: null,
+    initPromise: null
   };
+  globalObject[HASHLINE_STATE_KEY] = state;
+  return state;
 }
-function buildReadSeekLine(line, raw) {
-  return buildReadSeekLineWithHash(line, computeLineHash(raw), raw);
-}
-function formatAnchoredFileBlocks(files, lineSuffix) {
-  const blocks = [];
-  for (const file of files) {
-    blocks.push(`--- ${file.displayPath} ---`);
-    for (const line of file.lines) {
-      blocks.push(`>>${line.anchor}|${line.display}${lineSuffix?.(line) ?? ""}`);
-    }
+async function ensureHashInit() {
+  const state = getHashlineState();
+  if (state.h32Fn)
+    return;
+  if (!state.initPromise) {
+    state.initPromise = xxhashWasm().then((hasher) => {
+      state.h32Fn = hasher.h32;
+    });
   }
-  return blocks.join(`
-`);
+  await state.initPromise;
 }
-function buildReadSeekWarning(code, message, metadata = {}) {
-  return { code, message, ...metadata };
+function xxh32(input) {
+  const state = getHashlineState();
+  if (!state.h32Fn)
+    throw new Error("Hash not initialized — call ensureHashInit() first");
+  return state.h32Fn(input, 0) >>> 0;
 }
-function buildReadSeekError(code, message, hint, details) {
-  return {
-    code,
-    message,
-    ...hint !== undefined ? { hint } : {},
-    ...details !== undefined ? { details } : {}
-  };
+function computeLineHash(line) {
+  if (line.endsWith("\r"))
+    line = line.slice(0, -1);
+  line = line.replace(/\s+/g, "");
+  return DICT[xxh32(line) % HASH_MOD];
 }
-function buildToolErrorResult(tool, code, message, opts = {}) {
-  return {
-    content: [{ type: "text", text: message }],
-    isError: true,
-    details: {
-      readSeekValue: {
-        tool,
-        ...opts.extra ?? {},
-        ok: false,
-        ...opts.path !== undefined ? { path: opts.path } : {},
-        error: buildReadSeekError(code, message, opts.hint, opts.details)
-      }
-    }
-  };
+var DISPLAY_CONTROL_CHAR_RE = /[\x00-\x08\x0b\x0c\x0e-\x1f]/g;
+function escapeControlCharsForDisplay(text) {
+  return text.replace(DISPLAY_CONTROL_CHAR_RE, (ch) => {
+    return `\\u${ch.charCodeAt(0).toString(16).padStart(4, "0")}`;
+  });
 }
-function buildReadSeekEditResult(input) {
-  return {
-    tool: "edit",
-    ok: input.ok ?? true,
-    path: input.path,
-    summary: input.summary,
-    diff: input.diff,
-    ...input.diffData ? { diffData: input.diffData } : {},
-    firstChangedLine: input.firstChangedLine,
-    warnings: [...input.warnings],
-    noopEdits: [...input.noopEdits],
-    ...input.semanticSummary ? { semanticSummary: input.semanticSummary } : {}
-  };
+function formatHashlineDisplay(lineNumber, content) {
+  return `${lineNumber}:${computeLineHash(content)}|${escapeControlCharsForDisplay(content)}`;
 }
 
-// src/edit-output.ts
-var EDIT_OPERATION_NAMES = ["set_line", "replace_lines", "insert_after", "replace"];
-function hasNewText(value) {
-  return typeof value === "object" && value !== null && typeof value.new_text === "string";
+// src/edit-diff.ts
+function normalizeToLF(text) {
+  return text.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
 }
-function getVisibleDiffStats(diff) {
-  const stats = parseDiffStats(diff);
-  if (stats.added > 0 || stats.removed > 0)
-    return stats;
-  if (!diff.includes("→"))
-    return stats;
-  if (diff.includes("→ [deleted]"))
-    return { added: 0, removed: 1 };
-  return { added: 1, removed: 1 };
+function stripBom(content) {
+  return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
 }
-function buildVisibleSummary(displayPath, diff, edits) {
-  let stats = getVisibleDiffStats(diff);
-  const counts = countEditTypes(edits);
-  const editCount = counts.total || 1;
-  if (counts.total > 0 && counts.insert_after === counts.total && stats.removed > 0 && stats.added === stats.removed + counts.insert_after) {
-    stats = { added: counts.insert_after, removed: 0 };
-  }
-  const changeWord = editCount === 1 ? "change" : "changes";
-  const changedLineCount = Math.max(stats.added, stats.removed);
-  const lineWord = changedLineCount === 1 ? "line" : "lines";
-  return `Edited ${displayPath} (${editCount} ${changeWord}, +${stats.added} -${stats.removed} ${lineWord})`;
+function hasBareCarriageReturn(content) {
+  return content.replace(/\r\n/g, "").includes("\r");
 }
-function extractNewTextValues(edits) {
-  const values = [];
-  for (const edit of edits ?? []) {
-    if (!edit || typeof edit !== "object")
+function generateDiffString(oldContent, newContent, contextLines = 4) {
+  const parts = Diff.diffLines(oldContent, newContent);
+  const output = [];
+  const maxLineNum = Math.max(oldContent.split(`
+`).length, newContent.split(`
+`).length);
+  const lineNumWidth = String(maxLineNum).length;
+  let oldLineNum = 1;
+  let newLineNum = 1;
+  let lastWasChange = false;
+  let firstChangedLine;
+  for (let i = 0;i < parts.length; i++) {
+    const part = parts[i];
+    const raw = part.value.split(`
+`);
+    if (raw[raw.length - 1] === "")
+      raw.pop();
+    if (part.added || part.removed) {
+      if (firstChangedLine === undefined)
+        firstChangedLine = newLineNum;
+      for (const line of raw) {
+        if (part.added) {
+          output.push(`+${String(newLineNum).padStart(lineNumWidth, " ")} ${line}`);
+          newLineNum++;
+        } else {
+          output.push(`-${String(oldLineNum).padStart(lineNumWidth, " ")} ${line}`);
+          oldLineNum++;
+        }
+      }
+      lastWasChange = true;
       continue;
-    const operations = edit;
-    for (const operationName of EDIT_OPERATION_NAMES) {
-      const operation = operations[operationName];
-      if (hasNewText(operation))
-        values.push(operation.new_text);
     }
+    const nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
+    if (lastWasChange || nextPartIsChange) {
+      let linesToShow = raw;
+      let skipStart = 0;
+      let skipEnd = 0;
+      if (!lastWasChange) {
+        skipStart = Math.max(0, raw.length - contextLines);
+        linesToShow = raw.slice(skipStart);
+      }
+      if (!nextPartIsChange && linesToShow.length > contextLines) {
+        skipEnd = linesToShow.length - contextLines;
+        linesToShow = linesToShow.slice(0, contextLines);
+      }
+      if (skipStart > 0) {
+        output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+        oldLineNum += skipStart;
+        newLineNum += skipStart;
+      }
+      for (const line of linesToShow) {
+        output.push(` ${String(oldLineNum).padStart(lineNumWidth, " ")} ${line}`);
+        oldLineNum++;
+        newLineNum++;
+      }
+      if (skipEnd > 0) {
+        output.push(` ${"".padStart(lineNumWidth, " ")} ...`);
+        oldLineNum += skipEnd;
+        newLineNum += skipEnd;
+      }
+    } else {
+      oldLineNum += raw.length;
+      newLineNum += raw.length;
+    }
+    lastWasChange = false;
   }
-  return values;
-}
-function formatWhitespaceOnlyWarning(semanticSummary, edits) {
-  if (semanticSummary?.classification !== "whitespace-only")
-    return;
-  if (!extractNewTextValues(edits).some((text) => /\S/.test(text)))
-    return;
-  return "⚠ Edit classified as whitespace-only — if you intended a behavior change, re-read to verify.";
-}
-function formatReplaceHint(edits, noopEdits) {
-  if ((noopEdits ?? []).length > 0)
-    return;
-  const counts = countEditTypes(edits);
-  if (counts.replace === 0)
-    return;
-  if (counts.replace !== counts.total)
-    return;
-  return "[info: this edit used replace (unverified). For safer future edits, prefer set_line/replace_lines with an anchor from readSeek_digest/readSeek_grep/readSeek_search.]";
-}
-function buildEditOutput(input) {
-  const summary = `Updated ${input.displayPath}`;
-  const visibleSummary = buildVisibleSummary(input.displayPath, input.diff, input.edits);
-  const semanticWarning = formatWhitespaceOnlyWarning(input.semanticSummary, input.edits);
-  const warningText = input.warnings.length ? `
-
-Warnings:
-${input.warnings.join(`
-`)}` : "";
-  const replaceHint = formatReplaceHint(input.edits, input.noopEdits);
-  let text = visibleSummary;
-  if (semanticWarning)
-    text += `
-${semanticWarning}`;
-  text += warningText;
-  if (replaceHint)
-    text += `
-${replaceHint}`;
-  return {
-    text,
-    patch: input.patch ?? "",
-    readSeekValue: buildReadSeekEditResult({
-      path: input.path,
-      summary,
-      diff: input.diff,
-      ...input.diffData ? { diffData: input.diffData } : {},
-      firstChangedLine: input.firstChangedLine,
-      warnings: input.warnings,
-      noopEdits: input.noopEdits,
-      ...input.semanticSummary ? { semanticSummary: input.semanticSummary } : {}
-    })
-  };
-}
-
-// src/edit-classify.ts
-import * as Diff2 from "diff";
-function classifyEdit(oldContent, newContent) {
-  if (oldContent === newContent) {
-    return { classification: "no-op" };
-  }
+  return { diff: output.join(`
+`), firstChangedLine };
+}
+function generateCompactOrFullDiff(oldContent, newContent, contextLines = 4) {
+  if (oldContent === newContent)
+    return { diff: "", firstChangedLine: undefined };
   const oldLines = oldContent.split(`
 `);
   const newLines = newContent.split(`
 `);
   if (oldLines.length === newLines.length) {
-    let hasWhitespaceChange2 = false;
-    let hasSemanticChange2 = false;
+    let changedIndex = -1;
+    let changeCount = 0;
     for (let i = 0;i < oldLines.length; i++) {
-      if (oldLines[i] === newLines[i])
-        continue;
-      if (oldLines[i].trim() === newLines[i].trim()) {
-        hasWhitespaceChange2 = true;
-      } else {
-        hasSemanticChange2 = true;
+      if (oldLines[i] !== newLines[i]) {
+        changedIndex = i;
+        changeCount++;
+        if (changeCount > 1)
+          break;
       }
     }
-    if (hasSemanticChange2 && hasWhitespaceChange2)
-      return { classification: "mixed" };
-    if (hasWhitespaceChange2)
-      return { classification: "whitespace-only" };
-    return { classification: "semantic" };
+    if (changeCount === 1 && changedIndex >= 0) {
+      const lineNum = changedIndex + 1;
+      const oldLine = oldLines[changedIndex] ?? "";
+      const newLine = newLines[changedIndex] ?? "";
+      const oldHash = computeLineHash(oldLine);
+      const newHash = computeLineHash(newLine);
+      return {
+        diff: `${lineNum}:${oldHash}|${oldLine} → ${lineNum}:${newHash}|${newLine}`,
+        firstChangedLine: lineNum
+      };
+    }
   }
-  const parts = Diff2.diffLines(oldContent, newContent);
-  let hasWhitespaceChange = false;
-  let hasSemanticChange = false;
-  for (const part of parts) {
-    if (!part.added && !part.removed)
-      continue;
-    const lines = part.value.split(`
-`);
-    if (lines[lines.length - 1] === "")
-      lines.pop();
-    for (const line of lines) {
-      if (line.trim() === "") {
-        hasWhitespaceChange = true;
-      } else {
-        hasSemanticChange = true;
+  if (oldLines.length === newLines.length + 1) {
+    let deletedIndex = -1;
+    let j = 0;
+    let failed = false;
+    for (let i = 0;i < oldLines.length; i++) {
+      if (j < newLines.length && oldLines[i] === newLines[j]) {
+        j++;
+        continue;
+      }
+      if (deletedIndex === -1) {
+        deletedIndex = i;
+        continue;
       }
+      failed = true;
+      break;
+    }
+    if (!failed && deletedIndex !== -1 && j === newLines.length) {
+      const lineNum = deletedIndex + 1;
+      const oldLine = oldLines[deletedIndex] ?? "";
+      const oldHash = computeLineHash(oldLine);
+      return {
+        diff: `${lineNum}:${oldHash}|${oldLine} → [deleted]`,
+        firstChangedLine: lineNum
+      };
     }
   }
-  if (hasSemanticChange && hasWhitespaceChange)
-    return { classification: "mixed" };
-  if (hasWhitespaceChange)
-    return { classification: "whitespace-only" };
-  return { classification: "semantic" };
+  return generateDiffString(oldContent, newContent, contextLines);
 }
 
-// src/readseek-client.ts
-import { existsSync, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
-import { createRequire as createRequire2 } from "node:module";
-import { homedir as homedir3 } from "node:os";
-import path2 from "node:path";
-
-// src/readseek/enums.ts
-var SymbolKind;
-((SymbolKind2) => {
-  SymbolKind2["Class"] = "class";
-  SymbolKind2["Function"] = "function";
-  SymbolKind2["Method"] = "method";
-  SymbolKind2["Variable"] = "variable";
-  SymbolKind2["Constant"] = "constant";
-  SymbolKind2["Interface"] = "interface";
-  SymbolKind2["Type"] = "type";
-  SymbolKind2["Enum"] = "enum";
-  SymbolKind2["Struct"] = "struct";
-  SymbolKind2["Import"] = "import";
-  SymbolKind2["Module"] = "module";
-  SymbolKind2["Namespace"] = "namespace";
-  SymbolKind2["Property"] = "property";
-  SymbolKind2["Heading"] = "heading";
-  SymbolKind2["Table"] = "table";
-  SymbolKind2["View"] = "view";
-  SymbolKind2["Procedure"] = "procedure";
-  SymbolKind2["Trigger"] = "trigger";
-  SymbolKind2["Index"] = "index";
-  SymbolKind2["Schema"] = "schema";
-  SymbolKind2["Signal"] = "signal";
-  SymbolKind2["Unknown"] = "unknown";
-})(SymbolKind ||= {});
-
-// src/readseek-settings.ts
-import { readFileSync, statSync } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import { join } from "node:path";
-var READSEEK_TOOL_REPLACEMENTS = {
-  read: "readSeek_digest",
-  edit: "readSeek_edit",
-  grep: "readSeek_grep",
-  write: "readSeek_write"
-};
-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 = {
-  read: "compact",
-  grep: "compact",
-  edit: "expanded",
-  write: "expanded"
-};
-function globalSettingsPath() {
-  return join(homedir2(), ".pi/agent/settings.json");
-}
-function projectSettingsPath() {
-  return join(process.cwd(), ".pi/settings.json");
+// src/path-utils.ts
+import { homedir } from "node:os";
+import { isAbsolute, resolve as resolvePath } from "node:path";
+var UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
+function normalizeUnicodeSpaces(str) {
+  return str.replace(UNICODE_SPACES, " ");
 }
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function normalizeAtPrefix(filePath) {
+  return filePath.startsWith("@") ? filePath.slice(1) : filePath;
 }
-function invalid(source, path2) {
-  return { source, path: path2, message: `Invalid readseek setting at ${path2}` };
+function expandPath(filePath) {
+  const normalized = normalizeUnicodeSpaces(normalizeAtPrefix(filePath));
+  if (normalized === "~")
+    return homedir();
+  if (normalized.startsWith("~/"))
+    return homedir() + normalized.slice(1);
+  return normalized;
 }
-function warnUnknownKeys(raw, known, prefix, source, warnings) {
-  for (const key of Object.keys(raw)) {
-    if (known.includes(key))
-      continue;
-    const path2 = `${prefix}.${key}`;
-    warnings.push({ source, path: path2, message: `Unknown readseek setting at ${path2}` });
-  }
+function resolveToCwd(filePath, cwd) {
+  const expanded = expandPath(filePath);
+  return isAbsolute(expanded) ? expanded : resolvePath(cwd, expanded);
 }
-function readPositive(raw, key, path2, source, warnings) {
-  if (!(key in raw))
-    return;
-  const val = raw[key];
-  if (typeof val === "number" && Number.isSafeInteger(val) && val > 0)
-    return val;
-  warnings.push(invalid(source, path2));
-  return;
+
+// src/runtime.ts
+function throwIfAborted(signal) {
+  if (signal?.aborted)
+    throw new Error("Operation aborted");
 }
-function readEnum(raw, key, values, path2, source, warnings) {
-  if (!(key in raw))
-    return;
-  const val = raw[key];
-  if (typeof val === "string" && values.includes(val))
-    return val;
-  warnings.push(invalid(source, path2));
-  return;
+
+// src/fs-error.ts
+var SYSLOG_PATH_SUFFIX = /,\s+[a-z]+(\s+'.*')?$/;
+function strerror(err) {
+  const raw = String(err?.message ?? String(err));
+  return raw.replace(SYSLOG_PATH_SUFFIX, "");
 }
-function readImageMode(raw, source, warnings) {
-  if (!("imageMode" in raw))
-    return;
-  const val = raw.imageMode;
-  if (val === "on" || val === "off" || val === "auto")
-    return val;
-  warnings.push(invalid(source, "readseek.imageMode"));
-  return;
+function formatFsError(err, domain) {
+  const errno = typeof err.code === "string" ? err.code : "EIO";
+  return {
+    code: errno,
+    message: `${domain}: ${errno}: ${strerror(err)}`
+  };
 }
-function readOverrideTools(raw, source, warnings) {
-  if (!("overrideTools" in raw))
-    return;
-  const value = raw.overrideTools;
-  if (!Array.isArray(value)) {
-    warnings.push(invalid(source, "readseek.overrideTools"));
-    return;
-  }
-  const tools = [];
-  value.forEach((tool, index) => {
-    if (typeof tool === "string" && Object.hasOwn(READSEEK_TOOL_REPLACEMENTS, tool)) {
-      tools.push(tool);
-    } else {
-      warnings.push(invalid(source, `readseek.overrideTools[${index}]`));
+
+// src/edit-render-helpers.ts
+var VARIANT_KEYS = ["set_line", "replace_lines", "insert_after", "replace"];
+function countEditTypes(edits) {
+  const counts = {
+    set_line: 0,
+    replace_lines: 0,
+    insert_after: 0,
+    replace: 0,
+    total: 0
+  };
+  if (!edits)
+    return counts;
+  for (const edit of edits) {
+    counts.total++;
+    if (edit && typeof edit === "object") {
+      for (const key of VARIANT_KEYS) {
+        if (key in edit) {
+          counts[key]++;
+          break;
+        }
+      }
     }
-  });
-  return tools;
-}
-function readDisplaySettings(raw, source, warnings) {
-  if (!("display" in raw))
-    return;
-  if (!isRecord(raw.display)) {
-    warnings.push(invalid(source, "readseek.display"));
-    return;
   }
-  warnUnknownKeys(raw.display, READSEEK_DISPLAY_KEYS, "readseek.display", source, warnings);
-  const display = {};
-  for (const tool of READSEEK_DISPLAY_KEYS) {
-    const mode = readEnum(raw.display, tool, ["compact", "expanded"], `readseek.display.${tool}`, source, warnings);
-    if (mode !== undefined)
-      display[tool] = mode;
+  return counts;
+}
+function parseDiffStats(diff) {
+  if (!diff)
+    return { added: 0, removed: 0 };
+  let added = 0;
+  let removed = 0;
+  for (const line of diff.split(`
+`)) {
+    if (line.startsWith("+++") || line.startsWith("---"))
+      continue;
+    if (line.startsWith("+"))
+      added++;
+    else if (line.startsWith("-"))
+      removed++;
   }
-  return Object.keys(display).length > 0 ? display : undefined;
+  return { added, removed };
 }
-function validateSettings(raw, source) {
-  const settings = {};
-  const warnings = [];
-  if (!isRecord(raw)) {
-    warnings.push({ source, message: "Invalid readseek settings: expected a JSON object" });
-    return { settings, warnings };
+function formatEditCallText(args, argsComplete) {
+  const rawPath = typeof args?.path === "string" ? args.path : null;
+  if (!argsComplete) {
+    return { path: rawPath, suffix: undefined };
   }
-  if (!("readseek" in raw)) {
-    const misplaced = READSEEK_KEYS.filter((key) => (key in raw));
-    if (misplaced.length > 0) {
-      warnings.push({
-        source,
-        path: misplaced[0],
-        message: `Readseek setting at top level: move ${misplaced.join(", ")} under "readseek"`
-      });
+  const edits = args?.edits;
+  if (!Array.isArray(edits) || edits.length === 0) {
+    return { path: rawPath, suffix: undefined };
+  }
+  const counts = countEditTypes(edits);
+  const parts = [];
+  for (const key of VARIANT_KEYS) {
+    if (counts[key] > 0) {
+      parts.push(`${counts[key]} ${key}`);
     }
-    return { settings, warnings };
   }
-  if (!isRecord(raw.readseek)) {
-    warnings.push(invalid(source, "readseek"));
-    return { settings, warnings };
+  const word = counts.total === 1 ? "edit" : "edits";
+  const suffix = `${counts.total} ${word} (${parts.join(", ")})`;
+  return { path: rawPath, suffix };
+}
+function formatEditResultText(input) {
+  const { isError, diff, warnings, noopEdits, errorText } = input;
+  const isNoOp = isError && (Array.isArray(noopEdits) && noopEdits.length > 0 || errorText.includes("No changes made"));
+  const stats = parseDiffStats(diff);
+  const hasDiffStats = stats.added > 0 || stats.removed > 0;
+  const diffStats = hasDiffStats ? `+${stats.added} / -${stats.removed}` : undefined;
+  let warningsBadge;
+  if (warnings.length === 1) {
+    warningsBadge = "⚠ 1 warning";
+  } else if (warnings.length > 1) {
+    warningsBadge = `⚠ ${warnings.length} warnings`;
   }
-  const section = raw.readseek;
-  warnUnknownKeys(section, READSEEK_KEYS, "readseek", source, warnings);
-  const overrideTools = readOverrideTools(section, source, warnings);
-  if (overrideTools !== undefined)
-    settings.overrideTools = overrideTools;
-  const imageMode = readImageMode(section, source, warnings);
-  if (imageMode !== undefined)
-    settings.imageMode = imageMode;
-  const syntaxValidation = readEnum(section, "syntaxValidation", ["warn", "block", "off"], "readseek.syntaxValidation", source, warnings);
-  if (syntaxValidation !== undefined)
-    settings.syntaxValidation = syntaxValidation;
-  const timeoutMs = readPositive(section, "timeoutMs", "readseek.timeoutMs", source, warnings);
-  if (timeoutMs !== undefined)
-    settings.timeoutMs = timeoutMs;
-  if ("grep" in section) {
-    if (isRecord(section.grep)) {
-      warnUnknownKeys(section.grep, READSEEK_GREP_KEYS, "readseek.grep", source, warnings);
-      const grep = {};
-      const maxLines = readPositive(section.grep, "maxLines", "readseek.grep.maxLines", source, warnings);
-      if (maxLines !== undefined)
-        grep.maxLines = maxLines;
-      const maxBytes = readPositive(section.grep, "maxBytes", "readseek.grep.maxBytes", source, warnings);
-      if (maxBytes !== undefined)
-        grep.maxBytes = maxBytes;
-      if (Object.keys(grep).length > 0)
-        settings.grep = grep;
-    } else {
-      warnings.push(invalid(source, "readseek.grep"));
+  const showErrorText = isError ? errorText : undefined;
+  let semanticBadge;
+  if (!isError && !isNoOp && input.semanticClassification) {
+    switch (input.semanticClassification) {
+      case "whitespace-only":
+        semanticBadge = "ws-only";
+        break;
+      case "semantic":
+        semanticBadge = "✓ semantic";
+        break;
+      case "mixed":
+        semanticBadge = "mixed";
+        break;
     }
   }
-  const display = readDisplaySettings(section, source, warnings);
-  if (display !== undefined)
-    settings.display = display;
-  return { settings, warnings };
+  return {
+    diffStats,
+    noOp: isNoOp,
+    warningsBadge,
+    errorText: showErrorText,
+    semanticBadge
+  };
 }
-var settingsFileCache = new Map;
-function statFileOrNull(path2) {
-  try {
-    return statSync(path2);
-  } catch {
-    return null;
-  }
+
+// src/readseek-value.ts
+function buildReadSeekLineWithHash(line, hash, raw) {
+  return {
+    line,
+    hash,
+    anchor: `${line}:${hash}`,
+    raw,
+    display: escapeControlCharsForDisplay(raw)
+  };
 }
-function readSettingsFile(path2) {
-  const stats = statFileOrNull(path2);
-  if (!stats) {
-    settingsFileCache.delete(path2);
-    return { settings: {}, warnings: [] };
-  }
-  const cached = settingsFileCache.get(path2);
-  if (cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size)
-    return cached.result;
-  let result;
-  try {
-    const text = readFileSync(path2, "utf8");
-    result = validateSettings(JSON.parse(text), path2);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    result = { settings: {}, warnings: [{ source: path2, message: `Invalid JSON: ${message}` }] };
+function buildReadSeekLine(line, raw) {
+  return buildReadSeekLineWithHash(line, computeLineHash(raw), raw);
+}
+function formatAnchoredFileBlocks(files, lineSuffix) {
+  const blocks = [];
+  for (const file of files) {
+    blocks.push(`--- ${file.displayPath} ---`);
+    for (const line of file.lines) {
+      blocks.push(`>>${line.anchor}|${line.display}${lineSuffix?.(line) ?? ""}`);
+    }
   }
-  settingsFileCache.set(path2, { mtimeMs: stats.mtimeMs, size: stats.size, result });
-  return result;
+  return blocks.join(`
+`);
 }
-function mergeSettings(base, override) {
-  const settings = { ...base, ...override };
-  const grep = { ...base.grep ?? {}, ...override.grep ?? {} };
-  if (Object.keys(grep).length > 0)
-    settings.grep = grep;
-  const display = { ...base.display ?? {}, ...override.display ?? {} };
-  if (Object.keys(display).length > 0)
-    settings.display = display;
-  return settings;
+function buildReadSeekWarning(code, message, metadata = {}) {
+  return { code, message, ...metadata };
 }
-function resolveReadSeekJsonSettings() {
-  const globalResult = readSettingsFile(globalSettingsPath());
-  const projectResult = readSettingsFile(projectSettingsPath());
+function buildReadSeekError(code, message, hint, details) {
   return {
-    settings: mergeSettings(globalResult.settings, projectResult.settings),
-    warnings: [...globalResult.warnings, ...projectResult.warnings]
+    code,
+    message,
+    ...hint !== undefined ? { hint } : {},
+    ...details !== undefined ? { details } : {}
   };
 }
-function resolveReadSeekSyntaxValidation() {
-  return resolveReadSeekJsonSettings().settings.syntaxValidation;
-}
-function resolveReadSeekTimeoutMs() {
-  return resolveReadSeekJsonSettings().settings.timeoutMs;
+function buildToolErrorResult(tool, code, message, opts = {}) {
+  return {
+    content: [{ type: "text", text: message }],
+    isError: true,
+    details: {
+      readSeekValue: {
+        tool,
+        ...opts.extra ?? {},
+        ok: false,
+        ...opts.path !== undefined ? { path: opts.path } : {},
+        error: buildReadSeekError(code, message, opts.hint, opts.details)
+      }
+    }
+  };
 }
-function resolveReadSeekToolDisplayMode(tool) {
-  return resolveReadSeekJsonSettings().settings.display?.[tool] ?? DEFAULT_DISPLAY_MODES[tool];
+function buildReadSeekEditResult(input) {
+  return {
+    tool: "edit",
+    ok: input.ok ?? true,
+    path: input.path,
+    summary: input.summary,
+    diff: input.diff,
+    ...input.diffData ? { diffData: input.diffData } : {},
+    firstChangedLine: input.firstChangedLine,
+    warnings: [...input.warnings],
+    noopEdits: [...input.noopEdits],
+    ...input.semanticSummary ? { semanticSummary: input.semanticSummary } : {}
+  };
 }
 
-// src/readseek-client.ts
-var resolveFromHost = createRequire2(import.meta.url).resolve;
-function normalizeLanguage(language) {
-  return language === "java" ? "Java" : language;
-}
-function normalizeKind(kind) {
-  if (kind === "constructor")
-    return "method" /* Method */;
-  if (Object.values(SymbolKind).includes(kind))
-    return kind;
-  return "unknown" /* Unknown */;
-}
-function parentQualifiedNameFor(qualifiedName) {
-  const lastDot = qualifiedName.lastIndexOf(".");
-  return lastDot === -1 ? "" : qualifiedName.slice(0, lastDot);
+// src/edit-output.ts
+var EDIT_OPERATION_NAMES = ["set_line", "replace_lines", "insert_after", "replace"];
+function hasNewText(value) {
+  return typeof value === "object" && value !== null && typeof value.new_text === "string";
 }
-function symbolsFromReadSeek(symbols) {
-  const symbolsByQualifiedName = new Map;
-  const entries = [];
-  for (const symbol of symbols) {
-    const parentQualifiedName = parentQualifiedNameFor(symbol.qualified_name);
-    const fileSymbol = {
-      name: symbol.name,
-      kind: normalizeKind(symbol.kind),
-      startLine: symbol.start_line,
-      endLine: symbol.end_line
-    };
-    const bucket = symbolsByQualifiedName.get(symbol.qualified_name);
-    if (bucket)
-      bucket.push(fileSymbol);
-    else
-      symbolsByQualifiedName.set(symbol.qualified_name, [fileSymbol]);
-    entries.push({ parentQualifiedName, symbol: fileSymbol });
+function getVisibleDiffStats(diff) {
+  const stats = parseDiffStats(diff);
+  if (stats.added > 0 || stats.removed > 0)
+    return stats;
+  if (!diff.includes("→"))
+    return stats;
+  if (diff.includes("→ [deleted]"))
+    return { added: 0, removed: 1 };
+  return { added: 1, removed: 1 };
+}
+function buildVisibleSummary(displayPath, diff, edits) {
+  let stats = getVisibleDiffStats(diff);
+  const counts = countEditTypes(edits);
+  const editCount = counts.total || 1;
+  if (counts.total > 0 && counts.insert_after === counts.total && stats.removed > 0 && stats.added === stats.removed + counts.insert_after) {
+    stats = { added: counts.insert_after, removed: 0 };
   }
-  const roots = [];
-  for (const entry of entries) {
-    const parent = entry.parentQualifiedName ? symbolsByQualifiedName.get(entry.parentQualifiedName)?.[0] : undefined;
-    if (!parent) {
-      roots.push(entry.symbol);
+  const changeWord = editCount === 1 ? "change" : "changes";
+  const changedLineCount = Math.max(stats.added, stats.removed);
+  const lineWord = changedLineCount === 1 ? "line" : "lines";
+  return `Edited ${displayPath} (${editCount} ${changeWord}, +${stats.added} -${stats.removed} ${lineWord})`;
+}
+function extractNewTextValues(edits) {
+  const values = [];
+  for (const edit of edits ?? []) {
+    if (!edit || typeof edit !== "object")
       continue;
+    const operations = edit;
+    for (const operationName of EDIT_OPERATION_NAMES) {
+      const operation = operations[operationName];
+      if (hasNewText(operation))
+        values.push(operation.new_text);
     }
-    parent.children ??= [];
-    parent.children.push(entry.symbol);
   }
-  return roots;
+  return values;
 }
-var READSEEK_REPO_PACKAGE_NAMES = new Set(["@jarkkojs/readseek", "readseek"]);
-var defaultReadSeekDirInit;
-function readSeekBinaryPath() {
-  if (process.env.READSEEK_BIN)
-    return process.env.READSEEK_BIN;
-  return resolveReadSeekBinaryFromPackages(resolveFromHost);
+function formatWhitespaceOnlyWarning(semanticSummary, edits) {
+  if (semanticSummary?.classification !== "whitespace-only")
+    return;
+  if (!extractNewTextValues(edits).some((text) => /\S/.test(text)))
+    return;
+  return "⚠ Edit classified as whitespace-only — if you intended a behavior change, re-read to verify.";
 }
-function readSeekBinaryAvailability() {
-  try {
-    readSeekBinaryPath();
-    return { available: true };
-  } catch (err) {
-    return { available: false, reason: classifyReadSeekFailure(err).message };
-  }
+function formatReplaceHint(edits, noopEdits) {
+  if ((noopEdits ?? []).length > 0)
+    return;
+  const counts = countEditTypes(edits);
+  if (counts.replace === 0)
+    return;
+  if (counts.replace !== counts.total)
+    return;
+  return "[info: this edit used replace (unverified). For safer future edits, prefer set_line/replace_lines with an anchor from readSeek_digest/readSeek_grep/readSeek_search.]";
 }
-function classifyReadSeekFailure(err) {
-  const failure = err;
-  const message = String(failure?.message ?? err);
-  const missing = failure?.code === "ENOENT" || /Cannot find package|Cannot find module|no such file/i.test(message);
-  if (missing) {
-    return { code: "readseek-not-installed", message, hint: "Run npm install to install @jarkkojs/readseek." };
-  }
-  return { code: "readseek-execution-error", message };
+function buildEditOutput(input) {
+  const summary = `Updated ${input.displayPath}`;
+  const visibleSummary = buildVisibleSummary(input.displayPath, input.diff, input.edits);
+  const semanticWarning = formatWhitespaceOnlyWarning(input.semanticSummary, input.edits);
+  const warningText = input.warnings.length ? `
+
+Warnings:
+${input.warnings.join(`
+`)}` : "";
+  const replaceHint = formatReplaceHint(input.edits, input.noopEdits);
+  let text = visibleSummary;
+  if (semanticWarning)
+    text += `
+${semanticWarning}`;
+  text += warningText;
+  if (replaceHint)
+    text += `
+${replaceHint}`;
+  return {
+    text,
+    patch: input.patch ?? "",
+    readSeekValue: buildReadSeekEditResult({
+      path: input.path,
+      summary,
+      diff: input.diff,
+      ...input.diffData ? { diffData: input.diffData } : {},
+      firstChangedLine: input.firstChangedLine,
+      warnings: input.warnings,
+      noopEdits: input.noopEdits,
+      ...input.semanticSummary ? { semanticSummary: input.semanticSummary } : {}
+    })
+  };
 }
-function directoryExists(dirPath) {
-  try {
-    return statSync2(dirPath).isDirectory();
-  } catch {
-    return false;
+
+// src/edit-classify.ts
+import * as Diff2 from "diff";
+function classifyEdit(oldContent, newContent) {
+  if (oldContent === newContent) {
+    return { classification: "no-op" };
   }
-}
-var ownRepositoryByDir = new Map;
-function isOwnReadSeekRepository(cwd = process.cwd()) {
-  const start = path2.resolve(cwd);
-  const cached = ownRepositoryByDir.get(start);
-  if (cached !== undefined)
-    return cached;
-  let dir = start;
-  let result = false;
-  while (true) {
-    const packageJsonPath = path2.join(dir, "package.json");
-    if (existsSync(packageJsonPath)) {
-      try {
-        const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
-        if (typeof packageJson.name === "string" && READSEEK_REPO_PACKAGE_NAMES.has(packageJson.name)) {
-          result = true;
-          break;
-        }
-      } catch {}
+  const oldLines = oldContent.split(`
+`);
+  const newLines = newContent.split(`
+`);
+  if (oldLines.length === newLines.length) {
+    let hasWhitespaceChange2 = false;
+    let hasSemanticChange2 = false;
+    for (let i = 0;i < oldLines.length; i++) {
+      if (oldLines[i] === newLines[i])
+        continue;
+      if (oldLines[i].trim() === newLines[i].trim()) {
+        hasWhitespaceChange2 = true;
+      } else {
+        hasSemanticChange2 = true;
+      }
     }
-    const parent = path2.dirname(dir);
-    if (parent === dir)
-      break;
-    dir = parent;
+    if (hasSemanticChange2 && hasWhitespaceChange2)
+      return { classification: "mixed" };
+    if (hasWhitespaceChange2)
+      return { classification: "whitespace-only" };
+    return { classification: "semantic" };
   }
-  ownRepositoryByDir.set(start, result);
-  return result;
+  const parts = Diff2.diffLines(oldContent, newContent);
+  let hasWhitespaceChange = false;
+  let hasSemanticChange = false;
+  for (const part of parts) {
+    if (!part.added && !part.removed)
+      continue;
+    const lines = part.value.split(`
+`);
+    if (lines[lines.length - 1] === "")
+      lines.pop();
+    for (const line of lines) {
+      if (line.trim() === "") {
+        hasWhitespaceChange = true;
+      } else {
+        hasSemanticChange = true;
+      }
+    }
+  }
+  if (hasSemanticChange && hasWhitespaceChange)
+    return { classification: "mixed" };
+  if (hasWhitespaceChange)
+    return { classification: "whitespace-only" };
+  return { classification: "semantic" };
+}
+
+// src/readseek-client.ts
+import { existsSync, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import { homedir as homedir3 } from "node:os";
+import path2 from "node:path";
+
+// src/readseek/enums.ts
+var SymbolKind;
+((SymbolKind2) => {
+  SymbolKind2["Class"] = "class";
+  SymbolKind2["Function"] = "function";
+  SymbolKind2["Method"] = "method";
+  SymbolKind2["Variable"] = "variable";
+  SymbolKind2["Constant"] = "constant";
+  SymbolKind2["Interface"] = "interface";
+  SymbolKind2["Type"] = "type";
+  SymbolKind2["Enum"] = "enum";
+  SymbolKind2["Struct"] = "struct";
+  SymbolKind2["Import"] = "import";
+  SymbolKind2["Module"] = "module";
+  SymbolKind2["Namespace"] = "namespace";
+  SymbolKind2["Property"] = "property";
+  SymbolKind2["Heading"] = "heading";
+  SymbolKind2["Table"] = "table";
+  SymbolKind2["View"] = "view";
+  SymbolKind2["Procedure"] = "procedure";
+  SymbolKind2["Trigger"] = "trigger";
+  SymbolKind2["Index"] = "index";
+  SymbolKind2["Schema"] = "schema";
+  SymbolKind2["Signal"] = "signal";
+  SymbolKind2["Unknown"] = "unknown";
+})(SymbolKind ||= {});
+
+// src/readseek-settings.ts
+import { readFileSync, statSync } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { join } from "node:path";
+var READSEEK_TOOL_REPLACEMENTS = {
+  edit: "readSeek_edit",
+  grep: "readSeek_grep",
+  write: "readSeek_write"
+};
+var READSEEK_KEYS = ["overrideTools", "imageMode", "syntaxValidation", "timeoutMs", "grep", "display"];
+var READSEEK_GREP_KEYS = ["maxLines", "maxBytes"];
+var READSEEK_DISPLAY_KEYS = ["grep", "edit", "write"];
+var DEFAULT_DISPLAY_MODES = {
+  grep: "compact",
+  edit: "expanded",
+  write: "expanded"
+};
+function globalSettingsPath() {
+  return join(homedir2(), ".pi/agent/settings.json");
+}
+function projectSettingsPath() {
+  return join(process.cwd(), ".pi/settings.json");
 }
-function defaultReadSeekDir() {
-  const home = homedir3();
-  return home ? path2.join(home, ".pi", "readseek") : null;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-var DEFAULT_READSEEK_VISION_TIMEOUT_MS = 30 * 60000;
-function readSeekTimeoutMs() {
-  return resolveReadSeekTimeoutMs() ?? DEFAULT_READSEEK_TIMEOUT_MS;
+function invalid(source, path2) {
+  return { source, path: path2, message: `Invalid readseek setting at ${path2}` };
 }
-async function spawnReadSeekRaw(args, options = {}) {
-  return runReadSeekNodeText(readSeekBinaryPath(), args, {
-    signal: options.signal,
-    stdin: options.stdin,
-    timeoutMs: options.timeoutMs ?? readSeekTimeoutMs(),
-    cancelable: options.cancelable
-  });
+function warnUnknownKeys(raw, known, prefix, source, warnings) {
+  for (const key of Object.keys(raw)) {
+    if (known.includes(key))
+      continue;
+    const path2 = `${prefix}.${key}`;
+    warnings.push({ source, path: path2, message: `Unknown readseek setting at ${path2}` });
+  }
 }
-async function ensureDefaultReadSeekDir() {
-  const dir = defaultReadSeekDir();
-  if (!dir)
-    return null;
-  if (directoryExists(dir))
-    return dir;
-  defaultReadSeekDirInit ??= spawnReadSeekRaw(["--readseek-dir", dir, "init"]).then(() => directoryExists(dir) ? dir : null).catch(() => null).finally(() => {
-    defaultReadSeekDirInit = undefined;
-  });
-  return defaultReadSeekDirInit;
+function readPositive(raw, key, path2, source, warnings) {
+  if (!(key in raw))
+    return;
+  const val = raw[key];
+  if (typeof val === "number" && Number.isSafeInteger(val) && val > 0)
+    return val;
+  warnings.push(invalid(source, path2));
+  return;
 }
-async function readSeekInvocationArgs(args) {
-  if (isOwnReadSeekRepository())
-    return args;
-  const readSeekDir = await ensureDefaultReadSeekDir();
-  return readSeekDir ? ["--readseek-dir", readSeekDir, ...args] : args;
+function readEnum(raw, key, values, path2, source, warnings) {
+  if (!(key in raw))
+    return;
+  const val = raw[key];
+  if (typeof val === "string" && values.includes(val))
+    return val;
+  warnings.push(invalid(source, path2));
+  return;
 }
-async function runReadSeekRaw(args, options = {}) {
-  return spawnReadSeekRaw(await readSeekInvocationArgs(args), options);
+function readImageMode(raw, source, warnings) {
+  if (!("imageMode" in raw))
+    return;
+  const val = raw.imageMode;
+  if (val === "on" || val === "off" || val === "auto")
+    return val;
+  warnings.push(invalid(source, "readseek.imageMode"));
+  return;
 }
-async function runReadSeek(args, options = {}) {
-  return runReadSeekNodeJson(readSeekBinaryPath(), await readSeekInvocationArgs(args), {
-    signal: options.signal,
-    stdin: options.stdin,
-    timeoutMs: options.timeoutMs ?? readSeekTimeoutMs(),
-    cancelable: options.cancelable
+function readOverrideTools(raw, source, warnings) {
+  if (!("overrideTools" in raw))
+    return;
+  const value = raw.overrideTools;
+  if (!Array.isArray(value)) {
+    warnings.push(invalid(source, "readseek.overrideTools"));
+    return;
+  }
+  const tools = [];
+  value.forEach((tool, index) => {
+    if (typeof tool === "string" && Object.hasOwn(READSEEK_TOOL_REPLACEMENTS, tool)) {
+      tools.push(tool);
+    } else {
+      warnings.push(invalid(source, `readseek.overrideTools[${index}]`));
+    }
   });
+  return tools;
 }
-async function readSeekView(filePath, options = {}) {
-  const args = buildViewArgs({
-    path: filePath,
-    node: options.node,
-    page: options.page,
-    kind: options.kind,
-    depth: options.depth,
-    outline: options.outline,
-    visionMode: options.visionMode,
-    visionLevel: options.visionLevel
-  });
-  const runOptions = { signal: options.signal };
-  return options.visionMode !== undefined ? runReadSeekVisionRaw(args, runOptions) : runReadSeekRaw(args, runOptions);
+function readDisplaySettings(raw, source, warnings) {
+  if (!("display" in raw))
+    return;
+  if (!isRecord(raw.display)) {
+    warnings.push(invalid(source, "readseek.display"));
+    return;
+  }
+  warnUnknownKeys(raw.display, READSEEK_DISPLAY_KEYS, "readseek.display", source, warnings);
+  const display = {};
+  for (const tool of READSEEK_DISPLAY_KEYS) {
+    const mode = readEnum(raw.display, tool, ["compact", "expanded"], `readseek.display.${tool}`, source, warnings);
+    if (mode !== undefined)
+      display[tool] = mode;
+  }
+  return Object.keys(display).length > 0 ? display : undefined;
 }
-var visionInvocationTail = Promise.resolve();
-async function runReadSeekVisionRaw(args, options = {}) {
-  let release;
-  const gate = new Promise((resolve) => {
-    release = resolve;
-  });
-  const predecessor = visionInvocationTail;
-  visionInvocationTail = predecessor.then(() => gate);
-  const signal = options.signal;
-  try {
-    if (signal) {
-      signal.throwIfAborted();
-      await new Promise((resolve, reject) => {
-        const onAbort = () => {
-          signal.removeEventListener("abort", onAbort);
-          reject(signal.reason);
-        };
-        signal.addEventListener("abort", onAbort, { once: true });
-        predecessor.then(() => {
-          signal.removeEventListener("abort", onAbort);
-          resolve();
-        }, (error) => {
-          signal.removeEventListener("abort", onAbort);
-          reject(error);
-        });
+function validateSettings(raw, source) {
+  const settings = {};
+  const warnings = [];
+  if (!isRecord(raw)) {
+    warnings.push({ source, message: "Invalid readseek settings: expected a JSON object" });
+    return { settings, warnings };
+  }
+  if (!("readseek" in raw)) {
+    const misplaced = READSEEK_KEYS.filter((key) => (key in raw));
+    if (misplaced.length > 0) {
+      warnings.push({
+        source,
+        path: misplaced[0],
+        message: `Readseek setting at top level: move ${misplaced.join(", ")} under "readseek"`
       });
-    } else {
-      await predecessor;
     }
-    signal?.throwIfAborted();
-    return await runReadSeekRaw(args, {
-      ...options,
-      timeoutMs: options.timeoutMs ?? resolveReadSeekTimeoutMs() ?? DEFAULT_READSEEK_VISION_TIMEOUT_MS
-    });
-  } finally {
-    release();
+    return { settings, warnings };
   }
+  if (!isRecord(raw.readseek)) {
+    warnings.push(invalid(source, "readseek"));
+    return { settings, warnings };
+  }
+  const section = raw.readseek;
+  warnUnknownKeys(section, READSEEK_KEYS, "readseek", source, warnings);
+  const overrideTools = readOverrideTools(section, source, warnings);
+  if (overrideTools !== undefined)
+    settings.overrideTools = overrideTools;
+  const imageMode = readImageMode(section, source, warnings);
+  if (imageMode !== undefined)
+    settings.imageMode = imageMode;
+  const syntaxValidation = readEnum(section, "syntaxValidation", ["warn", "block", "off"], "readseek.syntaxValidation", source, warnings);
+  if (syntaxValidation !== undefined)
+    settings.syntaxValidation = syntaxValidation;
+  const timeoutMs = readPositive(section, "timeoutMs", "readseek.timeoutMs", source, warnings);
+  if (timeoutMs !== undefined)
+    settings.timeoutMs = timeoutMs;
+  if ("grep" in section) {
+    if (isRecord(section.grep)) {
+      warnUnknownKeys(section.grep, READSEEK_GREP_KEYS, "readseek.grep", source, warnings);
+      const grep = {};
+      const maxLines = readPositive(section.grep, "maxLines", "readseek.grep.maxLines", source, warnings);
+      if (maxLines !== undefined)
+        grep.maxLines = maxLines;
+      const maxBytes = readPositive(section.grep, "maxBytes", "readseek.grep.maxBytes", source, warnings);
+      if (maxBytes !== undefined)
+        grep.maxBytes = maxBytes;
+      if (Object.keys(grep).length > 0)
+        settings.grep = grep;
+    } else {
+      warnings.push(invalid(source, "readseek.grep"));
+    }
+  }
+  const display = readDisplaySettings(section, source, warnings);
+  if (display !== undefined)
+    settings.display = display;
+  return { settings, warnings };
 }
-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`);
-  return value;
-}
-function requireString(value, field) {
-  if (typeof value !== "string")
-    throw new Error(`invalid readseek ${field}`);
-  return value;
-}
-function requireBoolean(value, field) {
-  if (typeof value !== "boolean")
-    throw new Error(`invalid readseek ${field}: expected boolean`);
-  return value;
-}
-function parseMapOutput(value) {
-  if (!value || typeof value !== "object")
-    throw new Error("invalid readseek map output");
-  const output = value;
-  const symbols = output.symbols;
-  if (!Array.isArray(symbols))
-    throw new Error("invalid readseek symbols");
-  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"),
-    symbols: symbols.map((symbol) => {
-      if (!symbol || typeof symbol !== "object")
-        throw new Error("invalid readseek symbol");
-      const item = symbol;
-      return {
-        kind: requireString(item.kind, "symbol.kind"),
-        name: requireString(item.name, "symbol.name"),
-        qualified_name: requireString(item.qualified_name, "symbol.qualified_name"),
-        start_line: requireNumber(item.start_line, "symbol.start_line"),
-        end_line: requireNumber(item.end_line, "symbol.end_line"),
-        start_hash: requireString(item.start_hash, "symbol.start_hash"),
-        end_hash: requireString(item.end_hash, "symbol.end_hash")
-      };
-    })
-  };
-}
-function parseHashline(value, field) {
-  if (!value || typeof value !== "object")
-    throw new Error(`invalid readseek ${field}`);
-  const item = value;
-  return {
-    line: requireNumber(item.line, `${field}.line`),
-    hash: requireString(item.hash, `${field}.hash`),
-    text: requireString(item.text, `${field}.text`)
-  };
-}
-function parseSearchHashlines(value, field) {
-  if (!Array.isArray(value))
-    throw new Error(`invalid readseek ${field}`);
-  return value.map((line) => parseHashline(line, field));
-}
-function parseSearchOutput(value) {
-  if (!value || typeof value !== "object")
-    throw new Error("invalid readseek search output");
-  const output = value;
-  if (!Array.isArray(output.results))
-    throw new Error("invalid readseek search results");
-  return {
-    results: output.results.map((result) => {
-      if (!result || typeof result !== "object")
-        throw new Error("invalid readseek search result");
-      const file = result;
-      if (!Array.isArray(file.matches))
-        throw new Error("invalid readseek search matches");
-      return {
-        file: requireString(file.file, "search.file"),
-        language: requireString(file.language, "search.language"),
-        file_hash: requireString(file.file_hash, "search.file_hash"),
-        matches: file.matches.map((match) => {
-          if (!match || typeof match !== "object")
-            throw new Error("invalid readseek search match");
-          const item = match;
-          if (!Array.isArray(item.captures))
-            throw new Error("invalid readseek search captures");
-          return {
-            pattern_index: item.pattern_index === undefined ? 0 : requireNumber(item.pattern_index, "search.match.pattern_index"),
-            start_line: requireNumber(item.start_line, "search.match.start_line"),
-            end_line: requireNumber(item.end_line, "search.match.end_line"),
-            start_hash: requireString(item.start_hash, "search.match.start_hash"),
-            end_hash: requireString(item.end_hash, "search.match.end_hash"),
-            hashlines: parseSearchHashlines(item.hashlines, "search.match.hashlines"),
-            captures: item.captures.map((capture) => {
-              if (!capture || typeof capture !== "object")
-                throw new Error("invalid readseek search capture");
-              const captureItem = capture;
-              return {
-                name: requireString(captureItem.name, "search.capture.name"),
-                start_line: requireNumber(captureItem.start_line, "search.capture.start_line"),
-                end_line: requireNumber(captureItem.end_line, "search.capture.end_line"),
-                start_hash: requireString(captureItem.start_hash, "search.capture.start_hash"),
-                end_hash: requireString(captureItem.end_hash, "search.capture.end_hash"),
-                hashlines: parseSearchHashlines(captureItem.hashlines, "search.capture.hashlines")
-              };
-            })
-          };
-        })
-      };
-    })
-  };
-}
-function optionalString(value, field) {
-  if (value === undefined || value === null)
-    return;
-  return requireString(value, field);
+var settingsFileCache = new Map;
+function statFileOrNull(path2) {
+  try {
+    return statSync(path2);
+  } catch {
+    return null;
+  }
 }
-function parseRefsOutput(value) {
-  if (!value || typeof value !== "object")
-    throw new Error("invalid readseek refs output");
-  const output = value;
-  if (!Array.isArray(output.references))
-    throw new Error("invalid readseek references");
-  return {
-    references: output.references.map((reference) => {
-      if (!reference || typeof reference !== "object")
-        throw new Error("invalid readseek reference");
-      const item = reference;
-      const symbol = item.symbol;
-      const enclosing = symbol && typeof symbol === "object" ? optionalString(symbol.qualified_name, "reference.symbol.qualified_name") : undefined;
-      return {
-        file: requireString(item.file, "reference.file"),
-        line: requireNumber(item.line, "reference.line"),
-        column: requireNumber(item.column, "reference.column"),
-        line_hash: requireString(item.line_hash, "reference.line_hash"),
-        text: requireString(item.text, "reference.text"),
-        enclosingSymbol: enclosing
-      };
-    })
-  };
+function readSettingsFile(path2) {
+  const stats = statFileOrNull(path2);
+  if (!stats) {
+    settingsFileCache.delete(path2);
+    return { settings: {}, warnings: [] };
+  }
+  const cached = settingsFileCache.get(path2);
+  if (cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size)
+    return cached.result;
+  let result;
+  try {
+    const text = readFileSync(path2, "utf8");
+    result = validateSettings(JSON.parse(text), path2);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    result = { settings: {}, warnings: [{ source: path2, message: `Invalid JSON: ${message}` }] };
+  }
+  settingsFileCache.set(path2, { mtimeMs: stats.mtimeMs, size: stats.size, result });
+  return result;
 }
-function parseDiagnosticKind(value) {
-  if (value === "error" || value === "missing")
-    return value;
-  throw new Error("invalid readseek diagnostic.kind");
+function mergeSettings(base, override) {
+  const settings = { ...base, ...override };
+  const grep = { ...base.grep ?? {}, ...override.grep ?? {} };
+  if (Object.keys(grep).length > 0)
+    settings.grep = grep;
+  const display = { ...base.display ?? {}, ...override.display ?? {} };
+  if (Object.keys(display).length > 0)
+    settings.display = display;
+  return settings;
 }
-function parseCheckOutput(value) {
-  if (!value || typeof value !== "object")
-    throw new Error("invalid readseek check output");
-  const output = value;
-  if (!Array.isArray(output.diagnostics))
-    throw new Error("invalid readseek diagnostics");
+function resolveReadSeekJsonSettings() {
+  const globalResult = readSettingsFile(globalSettingsPath());
+  const projectResult = readSettingsFile(projectSettingsPath());
   return {
-    errorCount: requireNumber(output.error_count, "error_count"),
-    missingCount: requireNumber(output.missing_count, "missing_count"),
-    diagnostics: output.diagnostics.map((diagnostic) => {
-      if (!diagnostic || typeof diagnostic !== "object")
-        throw new Error("invalid readseek diagnostic");
-      const item = diagnostic;
-      return {
-        kind: parseDiagnosticKind(item.kind),
-        start_line: requireNumber(item.start_line, "diagnostic.start_line"),
-        end_line: requireNumber(item.end_line, "diagnostic.end_line")
-      };
-    })
+    settings: mergeSettings(globalResult.settings, projectResult.settings),
+    warnings: [...globalResult.warnings, ...projectResult.warnings]
   };
 }
-function parseOcrText(value) {
-  return optionalString(value, "ocr");
+function resolveReadSeekSyntaxValidation() {
+  return resolveReadSeekJsonSettings().settings.syntaxValidation;
 }
-function parseDetectedObjects(value) {
-  if (value === undefined || value === null)
-    return;
-  if (!Array.isArray(value))
-    throw new Error("invalid readseek detect objects");
-  return value.map((object) => {
-    if (!object || typeof object !== "object")
-      throw new Error("invalid readseek detect object");
-    const item = object;
-    const bbox = item.bbox;
-    if (!Array.isArray(bbox) || bbox.length !== 4)
-      throw new Error("invalid readseek detect object.bbox");
-    return {
-      label: requireString(item.label, "object.label"),
-      bbox: bbox.map((n, i) => requireNumber(n, `object.bbox[${i}]`))
-    };
-  });
+function resolveReadSeekTimeoutMs() {
+  return resolveReadSeekJsonSettings().settings.timeoutMs;
 }
-function parseImageEncoding(value) {
-  if (value === "base64")
-    return value;
-  throw new Error("invalid image encoding");
+function resolveReadSeekToolDisplayMode(tool) {
+  return resolveReadSeekJsonSettings().settings.display?.[tool] ?? DEFAULT_DISPLAY_MODES[tool];
 }
-function parseDetectOutput(value) {
-  if (!value || typeof value !== "object")
-    throw new Error("invalid readseek detect output");
-  const output = value;
-  const type = requireString(output.type, "type");
-  const file = requireString(output.file, "file");
-  const mime = optionalString(output.mime, "mime");
-  if (type === "application/pdf") {
-    if (output.format !== "pdf")
-      throw new Error("invalid readseek PDF format");
-    return {
-      kind: "pdf",
-      type,
-      file,
-      mime,
-      format: output.format,
-      pages: requireNumber(output.pages, "pages")
-    };
-  }
-  if (output.width !== undefined || output.height !== undefined) {
-    return {
-      kind: "image",
-      type,
-      file,
-      mime,
-      format: requireString(output.format, "format"),
-      width: requireNumber(output.width, "width"),
-      height: requireNumber(output.height, "height"),
-      animated: requireBoolean(output.animated, "animated"),
-      encoding: output.encoding === undefined ? undefined : parseImageEncoding(output.encoding),
-      data: output.data === undefined ? undefined : requireString(output.data, "data"),
-      ocr: parseOcrText(output.ocr),
-      caption: optionalString(output.caption, "caption"),
-      objects: parseDetectedObjects(output.objects)
-    };
-  }
-  if (output.language !== undefined) {
-    return {
-      kind: "source",
-      type,
-      file,
-      language: requireString(output.language, "language"),
-      engine: optionalString(output.engine, "engine"),
-      supported: requireBoolean(output.supported, "supported"),
-      mime,
-      syntax: optionalString(output.syntax, "syntax")
-    };
-  }
-  return { kind: "text", type, file, mime };
+
+// src/readseek-client.ts
+var resolveFromHost = createRequire2(import.meta.url).resolve;
+function readSeekBinaryPath() {
+  return resolveReadSeekBinaryFromPath() ?? resolveReadSeekBinaryFromPackages(resolveFromHost);
 }
-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 readSeekBinaryAvailability() {
+  try {
+    readSeekBinaryPath();
+    return { available: true };
+  } catch (err) {
+    return { available: false, reason: classifyReadSeekFailure(err).message };
+  }
 }
-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
-  };
+var READSEEK_REPO_PACKAGE_NAMES = new Set(["@jarkkojs/readseek", "readseek"]);
+var defaultReadSeekDirInit;
+function directoryExists(dirPath) {
+  try {
+    return statSync2(dirPath).isDirectory();
+  } catch {
+    return false;
+  }
 }
-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);
+var ownRepositoryByDir = new Map;
+function isOwnReadSeekRepository(cwd = process.cwd()) {
+  const start = path2.resolve(cwd);
+  const cached = ownRepositoryByDir.get(start);
+  if (cached !== undefined)
+    return cached;
+  let dir = start;
+  let result = false;
+  while (true) {
+    const packageJsonPath = path2.join(dir, "package.json");
+    if (existsSync(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
+        if (typeof packageJson.name === "string" && READSEEK_REPO_PACKAGE_NAMES.has(packageJson.name)) {
+          result = true;
+          break;
+        }
+      } catch {}
+    }
+    const parent = path2.dirname(dir);
+    if (parent === dir)
+      break;
+    dir = parent;
+  }
+  ownRepositoryByDir.set(start, result);
   return result;
 }
-function digestArgs(target, options) {
-  return buildDigestArgs({
-    path: target,
-    select: options.select ?? "content",
-    at: options.at,
-    end: options.end,
-    limit: options.limit,
-    language: options.language,
-    visionMode: options.visionMode,
-    visionLevel: options.visionLevel,
-    stdinName: options.stdin !== undefined && target === "-" ? options.stdinName ?? target : undefined
+function defaultReadSeekDir() {
+  const home = homedir3();
+  return home ? path2.join(home, ".pi", "readseek") : null;
+}
+var DEFAULT_READSEEK_VISION_TIMEOUT_MS = 30 * 60000;
+function readSeekTimeoutMs() {
+  return resolveReadSeekTimeoutMs() ?? DEFAULT_READSEEK_TIMEOUT_MS;
+}
+async function spawnReadSeekRaw(args, options = {}) {
+  return runReadSeekNodeText(readSeekBinaryPath(), args, {
+    signal: options.signal,
+    stdin: options.stdin,
+    timeoutMs: options.timeoutMs ?? readSeekTimeoutMs(),
+    cancelable: options.cancelable
+  });
+}
+async function ensureDefaultReadSeekDir() {
+  const dir = defaultReadSeekDir();
+  if (!dir)
+    return null;
+  if (directoryExists(dir))
+    return dir;
+  defaultReadSeekDirInit ??= spawnReadSeekRaw(["--readseek-dir", dir, "init"]).then(() => directoryExists(dir) ? dir : null).catch(() => null).finally(() => {
+    defaultReadSeekDirInit = undefined;
   });
+  return defaultReadSeekDirInit;
+}
+async function readSeekInvocationArgs(args) {
+  if (isOwnReadSeekRepository())
+    return [...args];
+  const readSeekDir = await ensureDefaultReadSeekDir();
+  return readSeekDir ? ["--readseek-dir", readSeekDir, ...args] : [...args];
+}
+async function runReadSeekRaw(args, options = {}) {
+  return spawnReadSeekRaw(await readSeekInvocationArgs(args), options);
 }
-async function runDigestRaw(target, options = {}) {
-  const args = digestArgs(target, options);
-  const runOptions = {
+async function runReadSeek(args, options = {}) {
+  return runReadSeekNodeJson(readSeekBinaryPath(), await readSeekInvocationArgs(args), {
     signal: options.signal,
     stdin: options.stdin,
-    timeoutMs: options.timeoutMs
-  };
-  return options.vision ? await runReadSeekVision(args, runOptions) : await runReadSeek(args, runOptions);
+    timeoutMs: options.timeoutMs ?? readSeekTimeoutMs(),
+    cancelable: options.cancelable
+  });
+}
+var visionInvocationTail = Promise.resolve();
+async function runReadSeekVisionRaw(args, options = {}) {
+  let release;
+  const gate = new Promise((resolve) => {
+    release = resolve;
+  });
+  const predecessor = visionInvocationTail;
+  visionInvocationTail = predecessor.then(() => gate);
+  const signal = options.signal;
+  try {
+    if (signal) {
+      signal.throwIfAborted();
+      await new Promise((resolve, reject) => {
+        const onAbort = () => {
+          signal.removeEventListener("abort", onAbort);
+          reject(signal.reason);
+        };
+        signal.addEventListener("abort", onAbort, { once: true });
+        predecessor.then(() => {
+          signal.removeEventListener("abort", onAbort);
+          resolve();
+        }, (error) => {
+          signal.removeEventListener("abort", onAbort);
+          reject(error);
+        });
+      });
+    } else {
+      await predecessor;
+    }
+    signal?.throwIfAborted();
+    return await runReadSeekRaw(args, {
+      ...options,
+      timeoutMs: options.timeoutMs ?? resolveReadSeekTimeoutMs() ?? DEFAULT_READSEEK_VISION_TIMEOUT_MS
+    });
+  } finally {
+    release();
+  }
+}
+async function runReadSeekVision(args, options = {}) {
+  return JSON.parse(await runReadSeekVisionRaw(args, options));
+}
+var runner = {
+  text: (args, options = {}) => options.vision ? runReadSeekVisionRaw(args, options) : runReadSeekRaw(args, options),
+  json: (args, options = {}) => options.vision ? runReadSeekVision(args, options) : runReadSeek(args, options)
+};
+var client = createReadSeekClient(runner);
+var readSeekView = client.view;
+var readSeekDigestNative = client.digestRaw;
+var readSeekDigest = client.digest;
+var readSeekDigestContent = client.digestContent;
+var readSeekImage = client.image;
+var readSeekPreparedImage = client.preparedImage;
+var readSeekSearch = client.search;
+var readSeekRefs = client.refs;
+var readSeekDef = client.def;
+var readSeekCheck = client.check;
+var readSeekIdentify = client.identify;
+var readSeekDetect = client.detect;
+var readSeekEdit = client.edit;
+var readSeekRename = client.rename;
+function normalizeLanguage(language) {
+  return language === "java" ? "Java" : language;
+}
+function normalizeKind(kind) {
+  if (kind === "constructor")
+    return "method" /* Method */;
+  if (Object.values(SymbolKind).includes(kind))
+    return kind;
+  return "unknown" /* Unknown */;
 }
-async function readSeekDigestNative(target, options = {}) {
-  return runDigestRaw(target, options);
+function parentQualifiedNameFor(qualifiedName) {
+  const lastDot = qualifiedName.lastIndexOf(".");
+  return lastDot === -1 ? "" : qualifiedName.slice(0, lastDot);
 }
-async function readSeekDigest(target, options = {}) {
-  return parseDigestEnvelope(await runDigestRaw(target, options));
+function symbolsFromReadSeek(symbols) {
+  const symbolsByQualifiedName = new Map;
+  const entries = [];
+  for (const symbol of symbols) {
+    const parentQualifiedName = parentQualifiedNameFor(symbol.qualified_name);
+    const fileSymbol = {
+      name: symbol.name,
+      kind: normalizeKind(symbol.kind),
+      startLine: symbol.start_line,
+      endLine: symbol.end_line
+    };
+    const bucket = symbolsByQualifiedName.get(symbol.qualified_name);
+    if (bucket)
+      bucket.push(fileSymbol);
+    else
+      symbolsByQualifiedName.set(symbol.qualified_name, [fileSymbol]);
+    entries.push({ parentQualifiedName, symbol: fileSymbol });
+  }
+  const roots = [];
+  for (const entry of entries) {
+    const parent = entry.parentQualifiedName ? symbolsByQualifiedName.get(entry.parentQualifiedName)?.[0] : undefined;
+    if (!parent) {
+      roots.push(entry.symbol);
+      continue;
+    }
+    parent.children ??= [];
+    parent.children.push(entry.symbol);
+  }
+  return roots;
 }
 function fileMapFromReadSeekOutput(output, filePath, totalBytes) {
   if (output.language === "unknown" && output.symbols.length === 0)
@@ -2229,196 +2566,11 @@ function fileMapFromReadSeekOutput(output, filePath, totalBytes) {
   };
 }
 async function readSeekMap(filePath, totalBytes, options = {}) {
-  const envelope = await readSeekDigest(filePath, { select: "map", signal: options.signal });
+  const envelope = await client.digest(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 = buildSearchArgs({
-    path: target,
-    pattern,
-    language: options.language,
-    cached: options.cached,
-    others: options.others,
-    ignored: options.ignored
-  });
-  return parseSearchOutput(await runReadSeek(args, { signal: options.signal })).results;
-}
-async function readSeekRefs(target, options = {}) {
-  const args = buildRefsArgs({
-    path: target,
-    name: options.name,
-    scope: options.scope,
-    line: options.line,
-    column: options.column,
-    language: options.language,
-    cached: options.cached,
-    others: options.others,
-    ignored: options.ignored
-  });
-  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;
-}
-function parseEditOutput(value) {
-  if (!value || typeof value !== "object")
-    throw new Error("invalid readseek edit output");
-  const output = value;
-  return {
-    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 readSeekEdit(filePath, edits, options = {}) {
-  const args = buildEditArgs({
-    path: filePath,
-    apply: options.apply,
-    planHash: options.planHash,
-    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)
-    return [];
-  if (!Array.isArray(value))
-    throw new Error(`invalid readseek ${field}`);
-  return value.map((item) => {
-    if (!item || typeof item !== "object")
-      throw new Error(`invalid readseek ${field} entry`);
-    const c = item;
-    return {
-      line: requireNumber(c.line, `${field}.line`),
-      column: requireNumber(c.column, `${field}.column`),
-      reason: requireString(c.reason, `${field}.reason`)
-    };
-  });
-}
-function parseRenameEdits(value, field) {
-  if (value === undefined)
-    return [];
-  if (!Array.isArray(value))
-    throw new Error(`invalid readseek ${field}`);
-  return value.map((item) => {
-    if (!item || typeof item !== "object")
-      throw new Error(`invalid readseek ${field} entry`);
-    const e = item;
-    return {
-      line: requireNumber(e.line, `${field}.line`),
-      start_column: requireNumber(e.start_column, `${field}.start_column`),
-      end_column: requireNumber(e.end_column, `${field}.end_column`),
-      start_byte: requireNumber(e.start_byte, `${field}.start_byte`),
-      end_byte: requireNumber(e.end_byte, `${field}.end_byte`),
-      occurrence: requireString(e.occurrence, `${field}.occurrence`),
-      line_hash: requireString(e.line_hash, `${field}.line_hash`),
-      text: requireString(e.text, `${field}.text`)
-    };
-  });
-}
-function parseRenameOutput(value) {
-  if (!value || typeof value !== "object")
-    throw new Error("invalid readseek rename output");
-  const output = value;
-  const others = output.others;
-  if (others !== undefined && !Array.isArray(others))
-    throw new Error("invalid readseek others");
-  return {
-    file: requireString(output.file, "file"),
-    language: requireString(output.language, "language"),
-    engine: optionalString(output.engine, "engine"),
-    file_hash: requireString(output.file_hash, "file_hash"),
-    old_name: requireString(output.old_name, "old_name"),
-    new_name: requireString(output.new_name, "new_name"),
-    applied: requireBoolean(output.applied, "applied"),
-    conflicts: parseRenameConflicts(output.conflicts, "conflicts"),
-    edits: parseRenameEdits(output.edits, "edits"),
-    others: others?.map((entry) => {
-      if (!entry || typeof entry !== "object")
-        throw new Error("invalid readseek other");
-      const o = entry;
-      return {
-        file: requireString(o.file, "other.file"),
-        language: requireString(o.language, "other.language"),
-        engine: optionalString(o.engine, "other.engine"),
-        file_hash: requireString(o.file_hash, "other.file_hash"),
-        conflicts: parseRenameConflicts(o.conflicts, "other.conflicts"),
-        edits: parseRenameEdits(o.edits, "other.edits")
-      };
-    }) ?? []
-  };
-}
-async function readSeekRename(filePath, options) {
-  const args = buildRenameArgs({
-    path: filePath,
-    to: options.to,
-    line: options.line,
-    column: options.column,
-    workspace: options.workspace,
-    apply: options.apply,
-    language: options.language,
-    cached: options.cached,
-    others: options.others,
-    ignored: options.ignored
-  });
-  return parseRenameOutput(await runReadSeek(args, { signal: options.signal }));
-}
-function parseDefCompact(value) {
-  if (!value || typeof value !== "object")
-    throw new Error("invalid readseek def output");
-  const output = value;
-  const locations = output.locations;
-  if (!Array.isArray(locations))
-    throw new Error("invalid readseek def locations");
-  return locations.map((loc) => {
-    if (!loc || typeof loc !== "object")
-      throw new Error("invalid readseek def location");
-    const item = loc;
-    return {
-      file: requireString(item.file, "location.file"),
-      line: requireNumber(item.line, "location.line"),
-      column: requireNumber(item.column, "location.column"),
-      line_hash: requireString(item.line_hash, "location.line_hash"),
-      text: requireString(item.text, "location.text"),
-      kind: optionalString(item.kind, "location.kind"),
-      name: optionalString(item.name, "location.name"),
-      qualified_name: optionalString(item.qualified_name, "location.qualified_name")
-    };
-  });
-}
-async function readSeekDef(target, options) {
-  const args = buildDefArgs({
-    path: target,
-    name: options.name,
-    format: "plain",
-    language: options.language,
-    cached: options.cached,
-    others: options.others,
-    ignored: options.ignored
-  });
-  return parseDefCompact(await runReadSeek(args, { signal: options.signal }));
-}
 
 // src/edit-syntax-validate.ts
 function dedupeSortLines(diagnostics) {
@@ -5584,7 +5736,7 @@ var READSEEK_TOOL_ENTRIES = [
   { builtIn: null, readSeekName: "readSeek_rename" },
   { builtIn: "write", readSeekName: "readSeek_write" },
   { builtIn: null, readSeekName: "readSeek_def" },
-  { builtIn: "read", readSeekName: "readSeek_digest" },
+  { builtIn: null, readSeekName: "readSeek_digest" },
   { builtIn: null, readSeekName: "readSeek_view" }
 ];
 function formatSettingsWarning(warning) {
@@ -5605,12 +5757,10 @@ function piReadSeekExtension(pi) {
   const replacedBuiltIns = new Set(settings.overrideTools ?? []);
   const binaryAvailable = readSeekBinaryAvailability().available;
   const swap = (builtIn, readSeekName) => binaryAvailable && replacedBuiltIns.has(builtIn) ? builtIn : readSeekName;
-  const readName = swap("read", "readSeek_digest");
   const editName = swap("edit", "readSeek_edit");
   const writeName = swap("write", "readSeek_write");
   const grepName = swap("grep", "readSeek_grep");
   const toolAliases = {
-    readSeek_digest: readName,
     readSeek_edit: editName,
     readSeek_grep: grepName,
     readSeek_write: writeName
@@ -5625,7 +5775,7 @@ function piReadSeekExtension(pi) {
   registerRefsTool(pi, { onFileAnchored: markAnchored });
   registerRenameTool(pi, { onFileMutated: forgetAnchors });
   registerDefTool(pi, { onFileAnchored: markAnchored });
-  registerDigestTool(pi, { onFileAnchored: markAnchored, name: readName, toolAliases });
+  registerDigestTool(pi, { onFileAnchored: markAnchored, name: "readSeek_digest", toolAliases });
   registerViewTool(pi);
   registerWriteTool(pi, { onFileAnchored: markAnchored, name: writeName });
   pi.on("before_agent_start", (event) => {