pi-readseek 0.9.15 → 0.10.0

package/dist/index.ts

@@ -2,11 +2,11 @@
 import { readFile as fsReadFile } from "node:fs/promises";
 import { createPatch } from "diff";
 import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
-import { Type as Type2 } from "@sinclair/typebox";
+import { Type as Type3 } from "@sinclair/typebox";
 import { Text as Text3 } from "@earendil-works/pi-tui";
 
 // ../readseek-api/src/contract.ts
-var DIGEST_FACETS = [
+var INSPECT_FACETS = [
   "metadata",
   "content",
   "map",
@@ -14,20 +14,7 @@ var DIGEST_FACETS = [
   "identity"
 ];
 var VISION_MODES = ["none", "all", "ocr", "caption", "objects"];
-var VISION_ANALYSIS_MODES = ["all", "ocr", "caption", "objects"];
 var VISION_LEVELS = ["low", "medium", "high"];
-var DOCUMENT_NODE_KINDS = [
-  "artifact",
-  "footer",
-  "header",
-  "heading",
-  "marginal_label",
-  "page",
-  "page_number",
-  "paragraph",
-  "section",
-  "structural_section"
-];
 var EDIT_VARIANTS = [
   "set_line",
   "replace_lines",
@@ -35,12 +22,13 @@ var EDIT_VARIANTS = [
   "replace",
   "replace_symbol"
 ];
+var GIT_SCOPES = ["tracked", "untracked", "ignored", "all"];
 var TOOL_NAMES = [
-  "digest",
+  "inspect",
   "edit",
   "write",
   "grep",
-  "view",
+  "extract",
   "search",
   "def",
   "refs",
@@ -62,27 +50,24 @@ var PARAM_DESCRIPTIONS = {
   line: "One-based cursor line; required with scope",
   renameLine: "One-based cursor line of the symbol to rename",
   column: "One-based cursor byte column for disambiguation",
-  cached: "In a Git repository, search tracked/indexed files",
-  others: "In a Git repository, search untracked files",
-  ignored: "With others=true, include ignored untracked files",
+  gitScope: "In a Git repository, which files to search: tracked, untracked, ignored (untracked plus ignored), or all. Defaults to tracked plus untracked.",
   select: "Facets: metadata, content, map, diagnostics, identity (default content)",
   selectComma: "Comma-separated facets: metadata, content, map, diagnostics, identity",
-  at: "Location: line:N[:COLUMN], hash:HASH[:COLUMN], or symbol:NAME",
+  selector: "Positional selector: line:N[:COLUMN], hash:H[:COLUMN], symbol:NAME, page:N, node:ID, or asset:ID. Columns require the identity facet, which in turn rejects symbol selectors",
+  assetSelector: "Document asset selector in the form asset:ID",
+  query: "KDL selection query, @path, or '-' for standard input",
+  stdinName: "File name hint when the target is '-'",
   end: "Last line to include",
   limit: "Maximum number of lines to include",
+  inspectDepth: "Maximum structural depth for map output; defaults to 1 in agent tools",
   offset: "One-based starting line",
   readLimit: "Maximum lines to return",
   symbolRead: "Symbol name to read",
   bundle: "Include related symbols from the same file; requires symbol",
   image: "Standalone image mode: none, all, ocr, caption, objects. Required for standalone images.",
-  visionModeDigest: "Standalone image mode: none, all, caption, objects, or ocr",
-  visionModeView: "Analyze selected assets: all, ocr, caption, or objects",
+  visionModeInspect: "Standalone image mode: none, all, caption, objects, or ocr",
   visionLevel: "Vision inference level: low (default), medium, or high",
-  node: "Node ID to use as the view root",
-  page: "One-based source page",
-  kind: "Node kind filter",
-  depth: "Maximum depth below selected roots",
-  outline: "Return outline nodes only",
+  output: "Destination file for extracted binary data; stdout is not supported",
   edits: "Use set_line, replace_lines, insert_after, replace_symbol, or replace",
   editVariant: "Exactly one nested edit variant",
   setLine: 'Replace one line: {"set_line":{"anchor":"LINE:HASH","new_text":"..."}}',
@@ -119,11 +104,11 @@ var PARAM_DESCRIPTIONS = {
   scopeContext: "Context lines within each symbol"
 };
 var TOOL_DESCRIPTIONS = {
-  digest: "Digest source content and images into the native CLI envelope. Returns metadata plus requested facets unchanged from `readseek digest`. Use it before edits to obtain fresh `LINE:HASH` anchors; use for structural maps, diagnostics, and cursor identity.",
+  inspect: "Inspect source content, images, and documents through the native CLI envelope. Use it before edits to obtain fresh `LINE:HASH` anchors; use shallow maps for structural overviews, diagnostics for syntax checks, and identity for cursor context.",
   edit: 'Edit existing text files with fresh `LINE:HASH` anchors. Read or search first when no fresh anchors are available. Each `edits[]` item must use exactly one nested object: `{"set_line":{"anchor":"LINE:HASH","new_text":"..."}}`, `{"replace_lines":{"start_anchor":"LINE:HASH","end_anchor":"LINE:HASH","new_text":"..."}}`, `{"insert_after":{"anchor":"LINE:HASH","new_text":"..."}}`, `{"replace_symbol":{"symbol":"name","new_body":"..."}}`, or `{"replace":{"old_text":"...","new_text":"..."}}`.',
   write: "Create or replace a complete text file and return `LINE:HASH` anchors. Use `edit` for small changes to an existing file.",
   grep: "Search text or regex in files and return edit-ready `LINE:HASH` anchors. Use for identifiers, strings, configuration, errors, comments, and documentation.",
-  view: "Digest a document's structure or selected content. Start with the overview, then narrow by page, node, kind, or depth instead of reading the whole document. PDF is the first supported document format.",
+  extract: "Extract a selected document asset into a destination file. Use an `asset:ID` selector discovered through `inspect`; extracted binary data is never returned on stdout.",
   search: "Search code by AST structure using ast-grep-style patterns. Results include line hashes usable as `LINE:HASH` anchors. Use `grep` for identifiers, strings, comments, configuration, documentation, or other plain text and regex.",
   def: "Go to a symbol definition or declaration by name. Accepts qualified or unqualified names; use this instead of text search for functions, methods, classes, types, and other declarations.",
   refs: "Find references or usages of an identifier by name or cursor binding. Results include enclosing symbols and line hashes usable as `LINE:HASH` anchors. Without cursor scope, results are identifier-name matches; with scope, they follow one binding and exclude shadows. Use text search for literals, and use this before renaming or deleting a symbol.",
@@ -135,18 +120,11 @@ function renderToolDescription(name, aliases = {}) {
     throw new Error(`Missing TOOL_DESCRIPTIONS for ${name}`);
   return TOOL_NAMES.reduce((description, toolName) => description.replaceAll(`\`${toolName}\``, `\`${aliases[toolName] ?? toolName}\``), desc);
 }
-var gitFlagsSchema = {
-  cached: {
-    type: "boolean",
-    description: PARAM_DESCRIPTIONS.cached
-  },
-  others: {
-    type: "boolean",
-    description: PARAM_DESCRIPTIONS.others
-  },
-  ignored: {
-    type: "boolean",
-    description: PARAM_DESCRIPTIONS.ignored
+var gitScopeSchema = {
+  gitScope: {
+    type: "string",
+    enum: GIT_SCOPES,
+    description: PARAM_DESCRIPTIONS.gitScope
   }
 };
 var editItemSchema = {
@@ -212,28 +190,31 @@ var editItemSchema = {
 };
 var TOOL_CONTRACTS = [
   {
-    name: "digest",
-    title: "Digest source",
-    description: TOOL_DESCRIPTIONS.digest,
+    name: "inspect",
+    title: "Inspect input",
+    description: TOOL_DESCRIPTIONS.inspect,
     inputSchema: {
       type: "object",
       properties: {
         path: { type: "string", description: PARAM_DESCRIPTIONS.path },
+        selector: { type: "string", description: PARAM_DESCRIPTIONS.selector },
         select: { type: "string", description: PARAM_DESCRIPTIONS.select },
-        at: { type: "string", description: PARAM_DESCRIPTIONS.at },
+        query: { type: "string", description: PARAM_DESCRIPTIONS.query },
         end: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.end },
         limit: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.limit },
+        depth: { type: "integer", minimum: 0, description: PARAM_DESCRIPTIONS.inspectDepth },
         language: { type: "string", description: PARAM_DESCRIPTIONS.languageOverride },
         visionMode: {
           type: "string",
           enum: [...VISION_MODES],
-          description: PARAM_DESCRIPTIONS.visionModeDigest
+          description: PARAM_DESCRIPTIONS.visionModeInspect
         },
         visionLevel: {
           type: "string",
           enum: [...VISION_LEVELS],
           description: PARAM_DESCRIPTIONS.visionLevel
-        }
+        },
+        stdinName: { type: "string", description: PARAM_DESCRIPTIONS.stdinName }
       },
       required: ["path"],
       additionalProperties: false
@@ -307,34 +288,27 @@ var TOOL_CONTRACTS = [
     }
   },
   {
-    name: "view",
-    title: "View document",
-    description: TOOL_DESCRIPTIONS.view,
+    name: "extract",
+    title: "Extract asset",
+    description: TOOL_DESCRIPTIONS.extract,
     inputSchema: {
       type: "object",
       properties: {
         path: { type: "string", description: PARAM_DESCRIPTIONS.path },
-        node: { type: "string", description: PARAM_DESCRIPTIONS.node },
-        page: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.page },
-        kind: {
+        selector: {
           type: "string",
-          enum: [...DOCUMENT_NODE_KINDS],
-          description: PARAM_DESCRIPTIONS.kind
+          pattern: "^asset:.+",
+          description: PARAM_DESCRIPTIONS.assetSelector
         },
-        depth: { type: "integer", minimum: 0, description: PARAM_DESCRIPTIONS.depth },
-        outline: { type: "boolean", description: PARAM_DESCRIPTIONS.outline },
-        visionMode: {
+        output: {
           type: "string",
-          enum: [...VISION_ANALYSIS_MODES],
-          description: PARAM_DESCRIPTIONS.visionModeView
+          minLength: 1,
+          pattern: "^(?!-$).+",
+          description: PARAM_DESCRIPTIONS.output
         },
-        visionLevel: {
-          type: "string",
-          enum: [...VISION_LEVELS],
-          description: PARAM_DESCRIPTIONS.visionLevel
-        }
+        stdinName: { type: "string", description: PARAM_DESCRIPTIONS.stdinName }
       },
-      required: ["path"],
+      required: ["path", "selector", "output"],
       additionalProperties: false
     }
   },
@@ -348,7 +322,8 @@ var TOOL_CONTRACTS = [
         pattern: { type: "string", description: PARAM_DESCRIPTIONS.pattern },
         path: { type: "string", description: PARAM_DESCRIPTIONS.searchPath },
         language: { type: "string", description: PARAM_DESCRIPTIONS.language },
-        ...gitFlagsSchema
+        limit: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.matchLimit },
+        ...gitScopeSchema
       },
       required: ["pattern"],
       additionalProperties: false
@@ -364,7 +339,7 @@ var TOOL_CONTRACTS = [
         name: { type: "string", description: PARAM_DESCRIPTIONS.name },
         path: { type: "string", description: PARAM_DESCRIPTIONS.searchPath },
         language: { type: "string", description: PARAM_DESCRIPTIONS.language },
-        ...gitFlagsSchema
+        ...gitScopeSchema
       },
       required: ["name"],
       additionalProperties: false
@@ -383,7 +358,7 @@ var TOOL_CONTRACTS = [
         scope: { type: "boolean", description: PARAM_DESCRIPTIONS.scope },
         line: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.line },
         column: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.column },
-        ...gitFlagsSchema
+        ...gitScopeSchema
       },
       additionalProperties: false
     }
@@ -401,7 +376,9 @@ var TOOL_CONTRACTS = [
         to: { type: "string", description: PARAM_DESCRIPTIONS.to },
         workspace: { type: "boolean", description: PARAM_DESCRIPTIONS.workspace },
         apply: { type: "boolean", description: PARAM_DESCRIPTIONS.apply },
-        planHash: { type: "string", description: PARAM_DESCRIPTIONS.planHash }
+        planHash: { type: "string", description: PARAM_DESCRIPTIONS.planHash },
+        language: { type: "string", description: PARAM_DESCRIPTIONS.language },
+        ...gitScopeSchema
       },
       required: ["path", "line", "to"],
       additionalProperties: false
@@ -411,7 +388,7 @@ var TOOL_CONTRACTS = [
 // ../readseek-api/src/policy.ts
 var REPLACEABLE_TOOLS = [
   {
-    tool: "digest",
+    tool: "inspect",
     builtIn: "read",
     benefit: "it returns LINE:HASH anchors for safe edits."
   },
@@ -432,8 +409,8 @@ var REPLACEABLE_TOOLS = [
   }
 ];
 var TOOL_COMPACT_GUIDELINES = {
-  digest: [
-    "Use `digest` for map, diagnostics, and identity facets instead of separate tools."
+  inspect: [
+    "Use `inspect` for shallow maps, diagnostics, and identity; use `def`, `refs`, or `search` for targeted symbol questions."
   ],
   edit: [
     "Prefer set_line, replace_lines, and insert_after; use replace only when anchors are impractical."
@@ -462,7 +439,7 @@ function renderCompactGuidelines(name, aliases = {}) {
 }
 function renderToolRoutingPolicy(options = {}) {
   const aliases = options.aliases ?? {};
-  const digest = resolveToolName("digest", aliases);
+  const inspect = resolveToolName("inspect", aliases);
   const edit = resolveToolName("edit", aliases);
   const write = resolveToolName("write", aliases);
   const grep = resolveToolName("grep", aliases);
@@ -470,11 +447,11 @@ function renderToolRoutingPolicy(options = {}) {
   const def = resolveToolName("def", aliases);
   const refs = resolveToolName("refs", aliases);
   const rename = resolveToolName("rename", aliases);
-  const view = resolveToolName("view", aliases);
+  const extract = resolveToolName("extract", aliases);
   if (options.style === "server") {
     return [
-      "Structural code navigation, document viewing, and hash-verified edits with readseek.",
-      "For structural questions, prefer these tools to text Grep/Bash: definitions, references, AST search, multi-facet digest (content/map/diagnostics/identity), and document views.",
+      "Structural code navigation, document inspection, and hash-verified edits with readseek.",
+      "For structural questions, prefer these tools to text Grep/Bash: targeted definitions, references, and AST search; shallow inspect maps; diagnostics and identity; and document inspection.",
       `Use ${edit} for LINE:HASH-anchored mutations (preview with apply=false; apply defaults to true and re-checks plan_hash).`,
       "Paths resolve against CLAUDE_PROJECT_DIR. Native Read/Grep/Edit hooks provide passive context;",
       "call MCP tools for active navigation, document questions, or anchored edits."
@@ -485,7 +462,7 @@ function renderToolRoutingPolicy(options = {}) {
   if (options.preferOverBuiltIns) {
     bullets.push("- Prefer ReadSeek tools over built-ins when they can do the job.");
   }
-  bullets.push(`- Read with ${digest} first; ${edit} needs fresh LINE:HASH anchors.`, `- Use ${grep} for text/regex, ${search} for AST patterns, and ${digest}/${def}/${refs} for symbol navigation.`, `- Use ${edit} for existing files, ${write} for whole-file creation or replacement, and ${rename} for symbol renames.`, `- Use ${view} for document structure; run ${digest} with select diagnostics after source edits for a quick syntax check.`);
+  bullets.push(`- Read with ${inspect} first; ${edit} needs fresh LINE:HASH anchors.`, `- Use ${grep} for text/regex, ${search} for AST patterns, ${def}/${refs} for targeted symbols, and shallow ${inspect} maps only for file overviews.`, `- Use ${edit} for existing files, ${write} for whole-file creation or replacement, and ${rename} for symbol renames.`, `- Use ${inspect} for document structure; run ${inspect} with select diagnostics after source edits for a quick syntax check.`, `- Use ${extract} to save a selected document asset.`);
   if (options.demoteBuiltIns && options.demoteBuiltIns.length > 0) {
     bullets.push(`- Do not use built-in ${options.demoteBuiltIns.join(", ")} when a ReadSeek tool can do the job.`);
   }
@@ -512,12 +489,6 @@ function tryParseLineAnchor(anchor) {
 }
 
 // ../readseek-api/src/validation.ts
-function validateGitSelection(input) {
-  if (input.ignored && !input.others) {
-    return { ok: false, error: "ignored requires others=true" };
-  }
-  return { ok: true };
-}
 function validateRefsNameVsScope(input) {
   if (input.scope) {
     if (input.line === undefined) {
@@ -534,11 +505,8 @@ function validateRefsNameVsScope(input) {
   return { ok: true };
 }
 function validateVisionLevelVsMode(input) {
-  if (input.outline && (input.visionMode !== undefined || input.visionLevel !== undefined)) {
-    return { ok: false, error: "Cannot combine outline with visionMode or visionLevel" };
-  }
-  if (input.visionLevel !== undefined && input.visionMode === undefined) {
-    return { ok: false, error: "visionLevel requires visionMode" };
+  if (input.visionLevel !== undefined && !["all", "ocr", "caption", "objects"].includes(input.visionMode ?? "")) {
+    return { ok: false, error: "visionLevel requires an analysis visionMode" };
   }
   return { ok: true };
 }
@@ -609,21 +577,54 @@ function validateExactlyOneEditVariant(edits) {
 }
 var MIN_SAFE_INTEGER = BigInt(Number.MIN_SAFE_INTEGER);
 var MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
+// ../readseek-api/src/edit-plan.ts
+import { Document, Node, format } from "@bgotink/kdl";
+function node(name, properties, children = []) {
+  const result = Node.create(name);
+  for (const [key, value] of Object.entries(properties))
+    result.setProperty(key, value);
+  if (children.length > 0)
+    result.children = new Document(children);
+  return result;
+}
+function editNode(edit) {
+  if ("set_line" in edit) {
+    const value = edit.set_line;
+    return node("set-line", { anchor: value.anchor, text: value.new_text });
+  }
+  if ("replace_lines" in edit) {
+    const value = edit.replace_lines;
+    return node("replace-lines", { start: value.start_anchor, end: value.end_anchor, text: value.new_text });
+  }
+  if ("insert_after" in edit) {
+    const value = edit.insert_after;
+    return node("insert-after", { anchor: value.anchor, text: value.new_text });
+  }
+  if ("replace_symbol" in edit) {
+    const value = edit.replace_symbol;
+    return node("replace-symbol", { symbol: value.symbol, body: value.new_body });
+  }
+  const value = edit.replace;
+  return node("replace", {
+    old: value.old_text,
+    new: value.new_text,
+    ...value.all === undefined ? {} : { all: value.all }
+  });
+}
+function serializeEditPlan(edits) {
+  const validation = validateExactlyOneEditVariant(edits);
+  if (!validation.ok)
+    throw new Error(validation.error);
+  return format(new Document([node("plan", {}, validation.edits.map(editNode))]));
+}
 // ../readseek-api/src/argv.ts
+var DEFAULT_INSPECT_MAP_DEPTH = 1;
 function buildLineLocation(line, column) {
   return column === undefined ? `line:${line}` : `line:${line}:${column}`;
 }
-function appendGitSelectionArgs(args, input) {
-  const validated = validateGitSelection(input);
-  if (!validated.ok) {
-    throw new Error(validated.error);
-  }
-  if (input.cached)
-    args.push("--cached");
-  if (input.others)
-    args.push("--others");
-  if (input.ignored)
-    args.push("--ignored");
+function appendGitScopeArgs(args, input) {
+  if (input.gitScope !== undefined)
+    args.push("--git-scope", input.gitScope);
   return args;
 }
 function pushOptionalString(args, flag, value) {
@@ -652,51 +653,163 @@ function selectArg(select) {
     return;
   return Array.isArray(select) ? select.join(",") : select;
 }
-function buildDigestArgs(input) {
+function selectedInspectFacets(select) {
+  const facets = (selectArg(select) ?? "content").split(",").map((facet) => facet.trim());
+  for (const facet of facets) {
+    if (!INSPECT_FACETS.includes(facet)) {
+      throw new Error(`unknown inspect facet: ${facet}`);
+    }
+  }
+  return facets;
+}
+function hasInspectFacet(facets, facet) {
+  return facets.includes(facet);
+}
+function validateTarget(command, target, stdinName) {
+  if (target.length === 0)
+    throw new Error(`${command} requires a target file path or '-'`);
+  if (stdinName !== undefined && stdinName.length > 0 && target !== "-") {
+    throw new Error("stdinName requires '-' as the target");
+  }
+}
+function validatePositiveInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new Error(`${name} must be a positive integer`);
+  }
+}
+var SELECTOR_KINDS = ["line", "hash", "symbol", "page", "node", "asset"];
+function isSelectorKind(value) {
+  return SELECTOR_KINDS.includes(value);
+}
+function parseSelector(text) {
+  const separator = text.indexOf(":");
+  if (separator < 0) {
+    throw new Error("selector must start with line:, hash:, symbol:, page:, node:, or asset:");
+  }
+  const kind = text.slice(0, separator);
+  const value = text.slice(separator + 1);
+  if (value.length === 0)
+    throw new Error(`${kind} selector must not be empty`);
+  if (!isSelectorKind(kind)) {
+    throw new Error(`unknown selector kind \`${kind}\`; expected line, hash, symbol, page, node, or asset`);
+  }
+  if (kind === "line" || kind === "hash") {
+    const parts = value.split(":");
+    if (parts.length > 2)
+      throw new Error("selector has too many components");
+    if (parts.length === 2) {
+      const column = Number(parts[1]);
+      if (!Number.isSafeInteger(column))
+        throw new Error(`invalid column \`${parts[1]}\``);
+      if (column < 1)
+        throw new Error("column must be greater than zero");
+      return { kind, value: parts[0], column };
+    }
+  }
+  if (kind === "page") {
+    if (value.includes(":"))
+      throw new Error("page selector has too many components");
+    const page = Number(value);
+    if (!Number.isSafeInteger(page))
+      throw new Error(`invalid page \`${value}\``);
+    if (page < 1)
+      throw new Error("page must be greater than zero");
+  }
+  return { kind, value };
+}
+function buildInspectArgs(input) {
+  validateTarget("inspect", input.path, input.stdinName);
+  if (input.selector !== undefined && input.selector.length === 0) {
+    throw new Error("selector must not be empty");
+  }
   const vision = validateVisionLevelVsMode({
     visionMode: input.visionMode,
     visionLevel: input.visionLevel
   });
   if (!vision.ok)
     throw new Error(vision.error);
+  const facets = selectedInspectFacets(input.select);
+  const hasContent = hasInspectFacet(facets, "content");
+  const hasIdentity = hasInspectFacet(facets, "identity");
+  const hasMap = hasInspectFacet(facets, "map");
+  const hasSourceFacet = hasMap || hasInspectFacet(facets, "diagnostics") || hasIdentity;
+  if (input.end !== undefined)
+    validatePositiveInteger(input.end, "end");
+  if (input.limit !== undefined)
+    validatePositiveInteger(input.limit, "limit");
+  if (input.end !== undefined && input.limit !== undefined) {
+    throw new Error("cannot combine end with limit");
+  }
+  if (input.depth !== undefined) {
+    if (!Number.isSafeInteger(input.depth) || input.depth < 0) {
+      throw new Error("depth must be a non-negative integer");
+    }
+    if (!hasMap)
+      throw new Error("depth requires the map facet");
+  }
+  if (input.selector !== undefined && input.query !== undefined) {
+    throw new Error("cannot combine selector with query");
+  }
+  if (!hasContent && (input.end !== undefined || input.limit !== undefined || input.query !== undefined)) {
+    throw new Error("ranges and queries require the content facet");
+  }
+  if (hasIdentity && input.selector === undefined) {
+    throw new Error("the identity facet requires a selector");
+  }
+  if (input.selector !== undefined && !hasContent && !hasIdentity) {
+    throw new Error("selectors require the content or identity facet");
+  }
+  if (input.selector !== undefined) {
+    const selector = parseSelector(input.selector);
+    if (selector.kind === "symbol" && hasIdentity) {
+      throw new Error("the identity facet does not accept symbol selectors");
+    }
+    if (selector.column !== undefined && !hasIdentity) {
+      throw new Error("selector columns require the identity facet");
+    }
+  }
+  const hasVision = input.visionMode !== undefined || input.visionLevel !== undefined;
+  if (hasVision && !hasContent) {
+    throw new Error("vision options require the content facet");
+  }
+  if (hasVision && hasSourceFacet) {
+    throw new Error("vision options cannot be combined with source facets");
+  }
   const args = [];
   if (input.readseekDir !== undefined)
     args.push("--readseek-dir", input.readseekDir);
-  args.push("digest", input.path);
+  args.push("inspect", input.path);
+  if (input.selector !== undefined)
+    args.push(input.selector);
   const select = selectArg(input.select);
   if (select !== undefined)
     args.push("--select", select);
-  pushOptionalString(args, "--at", input.at);
+  pushOptionalString(args, "--query", input.query);
   pushOptionalNumber(args, "--end", input.end);
   pushOptionalNumber(args, "--limit", input.limit);
+  pushOptionalNumber(args, "--depth", input.depth);
   pushOptionalString(args, "--language", input.language);
   pushOptionalString(args, "--vision-mode", input.visionMode);
   pushOptionalString(args, "--vision-level", input.visionLevel);
   pushOptionalString(args, "--stdin-name", input.stdinName);
+  args.push("--kdl");
   return args;
 }
-function buildViewArgs(input) {
-  const vision = validateVisionLevelVsMode({
-    visionMode: input.visionMode,
-    visionLevel: input.visionLevel,
-    outline: input.outline
-  });
-  if (!vision.ok)
-    throw new Error(vision.error);
+function buildExtractArgs(input) {
+  validateTarget("extract", input.path, input.stdinName);
+  if (input.selector.length === 0)
+    throw new Error("extract requires an asset selector");
+  if (!input.selector.startsWith("asset:") || input.selector === "asset:") {
+    throw new Error("extract requires an asset: selector");
+  }
+  if (input.output.length === 0 || input.output === "-") {
+    throw new Error("extract output must be a file path");
+  }
   const args = [];
   if (input.readseekDir !== undefined)
     args.push("--readseek-dir", input.readseekDir);
-  args.push("view", input.path);
-  if (input.format !== undefined)
-    args.push("--format", input.format);
-  pushOptionalString(args, "--node", input.node);
-  pushOptionalNumber(args, "--page", input.page);
-  pushOptionalString(args, "--kind", input.kind);
-  pushOptionalNumber(args, "--depth", input.depth);
-  if (input.outline)
-    args.push("--outline");
-  pushOptionalString(args, "--vision-mode", input.visionMode);
-  pushOptionalString(args, "--vision-level", input.visionLevel);
+  args.push("--output", input.output, "extract", input.path, input.selector);
+  pushOptionalString(args, "--stdin-name", input.stdinName);
   return args;
 }
 function buildSearchArgs(input) {
@@ -704,15 +817,17 @@ function buildSearchArgs(input) {
   pushOptionalString(args, "--path", input.path);
   pushOptionalString(args, "--language", input.language);
   pushOptionalNumber(args, "--limit", input.limit);
-  return appendGitSelectionArgs(args, input);
+  appendGitScopeArgs(args, input);
+  args.push("--kdl");
+  return args;
 }
 function buildDefArgs(input) {
   const args = ["def", input.name];
   pushOptionalString(args, "--path", input.path);
-  if (input.format !== undefined)
-    args.push("--format", input.format);
   pushOptionalString(args, "--language", input.language);
-  return appendGitSelectionArgs(args, input);
+  appendGitScopeArgs(args, input);
+  args.push("--kdl");
+  return args;
 }
 function buildRefsArgs(input) {
   const validated = validateRefsNameVsScope(input);
@@ -727,10 +842,10 @@ function buildRefsArgs(input) {
     pushOptionalNumber(args, "--line", input.line);
     pushOptionalNumber(args, "--column", input.column);
   }
-  if (input.format !== undefined)
-    args.push("--format", input.format);
   pushOptionalString(args, "--language", input.language);
-  return appendGitSelectionArgs(args, input);
+  appendGitScopeArgs(args, input);
+  args.push("--kdl");
+  return args;
 }
 function buildEditArgs(input) {
   const args = ["edit", input.path];
@@ -742,6 +857,7 @@ function buildEditArgs(input) {
   pushOptionalString(args, "--language", input.language);
   if (input.requestFromStdin)
     args.push("--edits", "-");
+  args.push("--kdl");
   return args;
 }
 function buildRenameArgs(input) {
@@ -754,7 +870,9 @@ function buildRenameArgs(input) {
     flagOrder: input.flagOrder ?? "plan-hash-first"
   });
   pushOptionalString(args, "--language", input.language);
-  return appendGitSelectionArgs(args, input);
+  appendGitScopeArgs(args, input);
+  args.push("--kdl");
+  return args;
 }
 // ../readseek-api/src/platform.ts
 import { accessSync, constants as fsConstants, existsSync, statSync } from "node:fs";
@@ -769,6 +887,8 @@ var READSEEK_PLATFORM_PACKAGES = {
 };
 var resolveFromPackage = createRequire(import.meta.url).resolve;
 function readSeekBinaryName(platform = process.platform) {
+  if (platform === "linux")
+    return "readseek.AppImage";
   return platform === "win32" ? "readseek.exe" : "readseek";
 }
 function readSeekPlatformKey(platform = process.platform, arch = process.arch) {
@@ -800,9 +920,9 @@ function resolveReadSeekBinaryFromPackages(resolver = resolveFromPackage, option
   const platformPackage = READSEEK_PLATFORM_PACKAGES[key];
   if (!platformPackage) {
     const supported = Object.keys(READSEEK_PLATFORM_PACKAGES).join(", ");
-    throw new Error(`@jarkkojs/readseek ships no binary for ${key}; it supports ${supported}`);
+    throw new Error(`@jarkkojs/readseek-api ships no binary for ${key}; it supports ${supported}`);
   }
-  const metaPackage = options.metaPackage ?? "@jarkkojs/readseek";
+  const metaPackage = options.metaPackage ?? "@jarkkojs/readseek-api";
   const metaPackageJson = resolve(`${metaPackage}/package.json`);
   const metaPackageDir = path.dirname(metaPackageJson);
   let packageJsonPath;
@@ -817,22 +937,304 @@ function resolveReadSeekBinaryFromPackages(resolver = resolveFromPackage, option
   accessSync(binaryPath, fsConstants.X_OK);
   return binaryPath;
 }
-// ../readseek-api/src/json.ts
-var READSEEK_USAGE_HINT = /\n\s*Run readseek(?: [\w-]+)* --help for more information\.?\s*$/;
+// ../readseek-api/src/error.ts
+var READSEEK_USAGE_HINT = /(?:^|\n)\s*Run readseek(?: [\w-]+)* --help for more information\.?\s*$/;
 function cleanReadSeekErrorText(stderr) {
   return stderr.replace(READSEEK_USAGE_HINT, "").replace(/^error:\s*/i, "").replace(/\s*\n\s*/g, " ").trim();
 }
-function parseReadSeekJson(stdout) {
-  try {
-    return JSON.parse(stdout);
-  } catch {
-    const preview = stdout.trim().slice(0, 200);
-    throw new Error(`readseek returned invalid JSON: ${preview}`);
+// ../readseek-api/src/kdl.ts
+import { parse } from "@bgotink/kdl";
+function convertNode(node) {
+  if (node.getTag() !== null)
+    throw new Error("KDL node annotations are not supported");
+  const properties = new Map;
+  for (const entry of node.entries) {
+    const name = entry.getName();
+    if (name === null)
+      throw new Error("KDL positional arguments are not supported");
+    if (properties.has(name))
+      throw new Error(`KDL duplicate property '${name}'`);
+    if (entry.getTag() !== null)
+      throw new Error("KDL value annotations are not supported");
+    const value = entry.getValue();
+    if (value === null)
+      throw new Error("KDL null values are not supported");
+    if (typeof value === "number" && !Number.isFinite(value)) {
+      throw new Error("KDL number out of range");
+    }
+    properties.set(name, value);
+  }
+  return {
+    name: node.getName(),
+    properties,
+    children: node.children?.nodes.map(convertNode) ?? []
+  };
+}
+function parseKdlDocument(text) {
+  const document = parse(text);
+  if (document.nodes.length !== 1)
+    throw new Error("KDL document must contain exactly one root node");
+  return convertNode(document.nodes[0]);
+}
+
+// ../readseek-api/src/output-kdl.ts
+function properties(node) {
+  return Object.fromEntries(node.properties);
+}
+function children(node, name) {
+  return node.children.filter((child) => child.name === name);
+}
+function child(node, name) {
+  return node.children.find((candidate) => candidate.name === name);
+}
+function requireProperty(node, name) {
+  const value = node.properties.get(name);
+  if (value === undefined)
+    throw new Error(`invalid readseek KDL: ${node.name} is missing '${name}'`);
+  return value;
+}
+function line(node) {
+  const anchor = requireProperty(node, "anchor");
+  const content = requireProperty(node, "content");
+  if (typeof anchor !== "string" || typeof content !== "string") {
+    throw new Error("invalid readseek KDL line");
+  }
+  const match = /^(\d+):([0-9a-f]+)$/.exec(anchor);
+  if (!match)
+    throw new Error(`invalid readseek KDL line anchor: ${anchor}`);
+  return {
+    line: Number(match[1]),
+    hash: match[2],
+    text: content
+  };
+}
+function mapNode(node) {
+  return {
+    ...properties(node),
+    children: children(node, "node").map(mapNode)
+  };
+}
+function sourceContent(node) {
+  const result = properties(node);
+  result.hashlines = children(node, "line").map(line);
+  const objects = children(node, "object");
+  if (objects.length > 0) {
+    result.objects = objects.map((object) => ({
+      label: requireProperty(object, "label"),
+      bbox: [
+        requireProperty(object, "xmin"),
+        requireProperty(object, "ymin"),
+        requireProperty(object, "xmax"),
+        requireProperty(object, "ymax")
+      ]
+    }));
+  }
+  return result;
+}
+function sourceMap(node) {
+  const root = child(node, "node");
+  return {
+    ...properties(node),
+    ...root ? { root: mapNode(root) } : {},
+    symbols: children(node, "symbol").map(properties)
+  };
+}
+function diagnostics(node) {
+  return {
+    ...properties(node),
+    diagnostics: children(node, "diagnostic").map(properties)
+  };
+}
+function identity(node) {
+  const result = properties(node);
+  const identifier = child(node, "identifier");
+  const symbol = child(node, "symbol");
+  if (identifier)
+    result.identifier = properties(identifier);
+  if (symbol)
+    result.symbol = properties(symbol);
+  return result;
+}
+function sourceDocument(root) {
+  const result = {};
+  const metadata = child(root, "metadata");
+  const cache = child(root, "cache");
+  const content = child(root, "content");
+  const map = child(root, "map");
+  const diagnosticOutput = child(root, "diagnostics");
+  const identityOutput = child(root, "identity");
+  if (metadata)
+    result.metadata = properties(metadata);
+  if (cache)
+    result.cache = properties(cache);
+  if (content)
+    result.content = sourceContent(content);
+  if (map)
+    result.map = sourceMap(map);
+  if (diagnosticOutput)
+    result.diagnostics = diagnostics(diagnosticOutput);
+  if (identityOutput)
+    result.identity = identity(identityOutput);
+  return result;
+}
+function hit(node) {
+  return {
+    ...properties(node),
+    hashlines: children(node, "line").map(line),
+    captures: children(node, "capture").map((capture) => ({
+      ...properties(capture),
+      hashlines: children(capture, "line").map(line)
+    }))
+  };
+}
+function search(root) {
+  return {
+    ...properties(root),
+    results: children(root, "match").map((match) => ({
+      ...properties(match),
+      matches: children(match, "hit").map(hit)
+    })),
+    documents: children(root, "document").map((documentNode) => ({
+      ...properties(documentNode),
+      hits: children(documentNode, "hit").map(properties)
+    }))
+  };
+}
+function references(root) {
+  const parsed = children(root, "reference").map((reference) => {
+    const sourceLine = child(reference, "line");
+    if (!sourceLine)
+      throw new Error("invalid readseek KDL reference: missing line");
+    const parsedLine = line(sourceLine);
+    const symbol = child(reference, "symbol");
+    return {
+      ...properties(reference),
+      line_hash: parsedLine.hash,
+      text: parsedLine.text,
+      ...symbol ? { symbol: properties(symbol) } : {}
+    };
+  });
+  return {
+    references: parsed,
+    locations: parsed.map((reference) => {
+      const { symbol, ...location } = reference;
+      return symbol && typeof symbol === "object" ? { ...location, ...symbol } : location;
+    })
+  };
+}
+function definitions(root) {
+  return {
+    locations: children(root, "definition").map((definition) => {
+      const symbol = child(definition, "symbol");
+      const sourceLine = child(definition, "line");
+      if (!symbol || !sourceLine) {
+        throw new Error("invalid readseek KDL definition: missing symbol or line");
+      }
+      const symbolProperties = properties(symbol);
+      const parsedLine = line(sourceLine);
+      const definitionColumn = definition.properties.get("column");
+      const nameByte = symbol.properties.get("name_byte");
+      const startByte = symbol.properties.get("start_byte");
+      let column = 1;
+      if (typeof definitionColumn === "number") {
+        column = definitionColumn;
+      } else if (typeof nameByte === "number" && typeof startByte === "number") {
+        column = nameByte - startByte + 1;
+      }
+      return {
+        file: requireProperty(definition, "file"),
+        line: parsedLine.line,
+        column,
+        line_hash: parsedLine.hash,
+        text: parsedLine.text,
+        kind: symbolProperties.kind,
+        name: symbolProperties.name,
+        qualified_name: symbolProperties.qualified_name
+      };
+    })
+  };
+}
+function edit(root) {
+  const result = properties(root);
+  for (const name of ["before_content", "content"]) {
+    const contentNode = child(root, name);
+    if (contentNode)
+      result[name] = requireProperty(contentNode, "content");
+  }
+  return result;
+}
+function renameEdit(node) {
+  const sourceLine = child(node, "line");
+  if (!sourceLine)
+    throw new Error("invalid readseek KDL rename edit: missing line");
+  return {
+    ...properties(node),
+    text: requireProperty(sourceLine, "content")
+  };
+}
+function renameFile(node) {
+  return {
+    ...properties(node),
+    edits: children(node, "edit").map(renameEdit),
+    conflicts: children(node, "conflict").map(properties)
+  };
+}
+function rename(root) {
+  return {
+    ...renameFile(root),
+    others: children(root, "other").map(renameFile)
+  };
+}
+function genericNode(node) {
+  const result = properties(node);
+  const textNode = child(node, "text");
+  const bbox = child(node, "bbox");
+  if (textNode)
+    result.text = requireProperty(textNode, "content");
+  if (bbox)
+    result.bbox = properties(bbox);
+  const objects = children(node, "object");
+  if (objects.length > 0)
+    result.objects = objects.map(genericNode);
+  return result;
+}
+function pdfDocument(root) {
+  return {
+    ...properties(root),
+    nodes: children(root, "node").map(genericNode),
+    assets: children(root, "asset").map(genericNode),
+    vision: children(root, "vision").map(genericNode)
+  };
+}
+function parseReadSeekKdl(text) {
+  const root = parseKdlDocument(text);
+  switch (root.name) {
+    case "document":
+      return root.properties.has("format") ? pdfDocument(root) : sourceDocument(root);
+    case "search":
+      return search(root);
+    case "check":
+      return diagnostics(root);
+    case "refs":
+      return references(root);
+    case "def":
+      return definitions(root);
+    case "edit":
+      return edit(root);
+    case "edit-batch":
+      return { ...properties(root), files: children(root, "file").map(edit) };
+    case "rename":
+      return rename(root);
+    default:
+      throw new Error(`unsupported readseek KDL root: ${root.name}`);
   }
 }
 // ../readseek-api/src/process.ts
 var DEFAULT_READSEEK_TIMEOUT_MS = 120000;
 var DEFAULT_MAX_OUTPUT_BYTES = 32 * 1024 * 1024;
+function readSeekProcessEnvironment() {
+  return process.platform === "linux" ? { ...process.env, APPIMAGE_EXTRACT_AND_RUN: "1" } : process.env;
+}
 function resolveProcessLimits(options = {}) {
   return {
     timeoutMs: options.timeoutMs ?? DEFAULT_READSEEK_TIMEOUT_MS,
@@ -863,9 +1265,6 @@ function ensureSuccessfulStdout(result) {
     return result.stdout;
   throw failureFromProcessResult(result);
 }
-function parseSuccessfulJson(result) {
-  return parseReadSeekJson(ensureSuccessfulStdout(result));
-}
 // ../readseek-api/src/process-node.ts
 import { spawn } from "node:child_process";
 import { StringDecoder } from "node:string_decoder";
@@ -931,7 +1330,7 @@ async function runReadSeekNode(binaryPath, args, options = {}) {
     try {
       child = spawn(binaryPath, [...args], {
         cwd: options.cwd,
-        env: process.env,
+        env: readSeekProcessEnvironment(),
         shell: false,
         stdio: [options.stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"],
         windowsHide: true
@@ -974,346 +1373,357 @@ async function runReadSeekNode(binaryPath, args, options = {}) {
 async function runReadSeekNodeText(binaryPath, args, options = {}) {
   return ensureSuccessfulStdout(await runReadSeekNode(binaryPath, args, options));
 }
-async function runReadSeekNodeJson(binaryPath, args, options = {}) {
-  return parseSuccessfulJson(await runReadSeekNode(binaryPath, args, options));
-}
-// ../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 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 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 {
-    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));
-}
+// ../readseek-api/src/client-output.ts
+import { Type } from "@sinclair/typebox";
+import { AssertError, Value } from "@sinclair/typebox/value";
+var OPERATIONS = ["Clone", "Clean", "Default", "Assert"];
+function parse2(schema, value, what) {
+  try {
+    return Value.Parse(OPERATIONS, schema, value);
+  } catch (error) {
+    if (!(error instanceof AssertError))
+      throw error;
+    const detail = error.error;
+    throw new Error(`invalid readseek ${what}${detail?.path ?? ""}: ${detail?.message ?? "invalid value"}`);
+  }
+}
+var Int = Type.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER });
+var Str = Type.String();
+var Bool = Type.Boolean();
+var OptStr = Type.Optional(Str);
+var OptInt = Type.Optional(Int);
+var Hashline = Type.Object({ line: Int, hash: Str, text: Str });
+var Hashlines = Type.Array(Hashline);
+var ReadOutput = Type.Object({
+  file: Str,
+  language: Str,
+  line_count: Int,
+  file_hash: Str,
+  start_line: Int,
+  end_line: Int,
+  hashlines: Hashlines
+});
+var SymbolOutput = Type.Object({
+  kind: Str,
+  name: Str,
+  qualified_name: OptStr,
+  start_line: Int,
+  end_line: Int,
+  start_hash: OptStr,
+  end_hash: OptStr,
+  start_anchor: OptStr,
+  end_anchor: OptStr
+});
+var MapNode = Type.Recursive((Self) => Type.Object({
+  kind: Str,
+  name: Str,
+  start_line: Int,
+  end_line: Int,
+  start_anchor: Str,
+  end_anchor: Str,
+  children: Type.Array(Self)
+}));
+var MapOutput = Type.Object({
+  file: Str,
+  language: Str,
+  line_count: Int,
+  file_hash: Str,
+  root: Type.Optional(MapNode),
+  symbols: Type.Array(SymbolOutput)
+});
+var SearchSpan = {
+  start_byte: OptInt,
+  end_byte: OptInt,
+  text: OptStr,
+  start_line: Int,
+  end_line: Int,
+  start_hash: Str,
+  end_hash: Str,
+  hashlines: Hashlines
+};
+var SearchCapture = Type.Object({ name: Str, ...SearchSpan });
+var SearchMatch = Type.Object({
+  pattern_index: Type.Integer({ default: 0 }),
+  ...SearchSpan,
+  captures: Type.Array(SearchCapture)
+});
+var SearchFileOutput = Type.Object({
+  file: Str,
+  language: Str,
+  file_hash: Str,
+  matches: Type.Array(SearchMatch)
+});
+var SearchEnvelope = Type.Object({
+  results: Type.Array(SearchFileOutput),
+  returned_matches: OptInt,
+  truncated: Type.Optional(Bool),
+  byte_basis: OptStr
+});
+var RefsEnvelope = Type.Object({
+  references: Type.Array(Type.Object({
+    file: Str,
+    line: Int,
+    column: Int,
+    line_hash: Str,
+    text: Str,
+    symbol: Type.Optional(Type.Object({ qualified_name: OptStr }))
+  }))
+});
+var Diagnostic = Type.Object({
+  kind: Type.Union([Type.Literal("error"), Type.Literal("missing")]),
+  start_line: Int,
+  end_line: Int
+});
+var CheckEnvelope = Type.Object({
+  file_hash: OptStr,
+  error_count: Int,
+  missing_count: Int,
+  diagnostics: Type.Array(Diagnostic)
+});
+var DetectedObject = Type.Object({
+  label: Str,
+  bbox: Type.Tuple([Int, Int, Int, Int])
+});
+var PreparedImage = Type.Object({
+  mime: Str,
+  encoding: Type.Literal("base64"),
+  data: Str
+});
+var SourceDetection = Type.Object({
+  kind: Type.Literal("source"),
+  type: Str,
+  file: Str,
+  language: Str,
+  engine: OptStr,
+  supported: Bool,
+  mime: OptStr,
+  syntax: OptStr
+});
+var ImageDetection = Type.Object({
+  kind: Type.Literal("image"),
+  type: Str,
+  file: Str,
+  mime: OptStr,
+  format: Str,
+  width: Int,
+  height: Int,
+  animated: Bool,
+  encoding: Type.Optional(Type.Literal("base64")),
+  data: OptStr,
+  ocr: OptStr,
+  caption: OptStr,
+  objects: Type.Optional(Type.Array(DetectedObject))
+});
+var TextDetection = Type.Object({
+  kind: Type.Literal("text"),
+  type: Str,
+  file: Str,
+  mime: OptStr
+});
+var PdfDetection = Type.Object({
+  kind: Type.Literal("pdf"),
+  type: Type.Literal("application/pdf"),
+  file: Str,
+  mime: OptStr,
+  format: Type.Literal("pdf"),
+  pages: Int
+});
+var Detection = Type.Union([SourceDetection, ImageDetection, TextDetection, PdfDetection]);
+var SourceDetectionInput = Type.Omit(SourceDetection, ["kind"]);
+var ImageDetectionInput = Type.Omit(ImageDetection, ["kind"]);
+var TextDetectionInput = Type.Omit(TextDetection, ["kind"]);
+var PdfDetectionInput = Type.Omit(PdfDetection, ["kind"]);
+var UnspannedContent = Type.Omit(ReadOutput, ["start_line", "end_line"]);
+var PdfInspectMetadata = Type.Object({ source: Str, format: Type.Literal("pdf"), pages: Int });
+var DocumentCache = Type.Object({
+  content_hash: Str,
+  state: Type.Union([Type.Literal("built"), Type.Literal("reused")])
+});
+var Identifier = Type.Object({
+  text: Str,
+  start_column: Int,
+  end_column: Int,
+  start_byte: Int,
+  end_byte: Int
+});
+var IdentifyEnvelope = Type.Object({
+  file: Str,
+  language: Str,
+  engine: OptStr,
+  line_count: Int,
+  file_hash: Str,
+  line: Int,
+  column: Int,
+  line_hash: Str,
+  identifier: Type.Optional(Identifier),
+  symbol: Type.Optional(Type.Object({
+    name: Str,
+    kind: Str,
+    qualified_name: Str,
+    start_line: Int,
+    end_line: Int
+  }))
+});
+var EditOutputSchema = Type.Object({
+  file: Str,
+  before_hash: Str,
+  file_hash: Str,
+  plan_hash: Str,
+  applied: Bool,
+  changed: Bool,
+  edit_count: Int,
+  before_content: OptStr,
+  content: OptStr
+});
+var RenameConflictSchema = Type.Object({ line: Int, column: Int, reason: Str });
+var RenameEditSchema = Type.Object({
+  line: Int,
+  start_column: Int,
+  end_column: Int,
+  start_byte: Int,
+  end_byte: Int,
+  occurrence: Str,
+  line_hash: Str,
+  text: Str
+});
+var Conflicts = Type.Array(RenameConflictSchema, { default: [] });
+var Edits = Type.Array(RenameEditSchema, { default: [] });
+var RenameFileOutputSchema = Type.Object({
+  file: Str,
+  language: Str,
+  engine: OptStr,
+  file_hash: Str,
+  conflicts: Conflicts,
+  edits: Edits
+});
+var RenameOutputSchema = Type.Object({
+  file: Str,
+  language: Str,
+  engine: OptStr,
+  file_hash: Str,
+  old_name: Str,
+  new_name: Str,
+  plan_hash: Str,
+  applied: Bool,
+  conflicts: Conflicts,
+  edits: Edits,
+  others: Type.Array(RenameFileOutputSchema, { default: [] })
+});
+var DefEnvelope = Type.Object({
+  locations: Type.Array(Type.Object({
+    file: Str,
+    line: Int,
+    column: Int,
+    line_hash: Str,
+    text: Str,
+    kind: OptStr,
+    name: OptStr,
+    qualified_name: OptStr
+  }))
+});
 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"))
-  };
+  return parse2(ReadOutput, value, "read output");
 }
 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")
-      };
-    })
-  };
+  return parse2(MapOutput, value, "map output");
 }
 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")
-            };
-          })
-        };
-      })
-    };
-  });
+  const envelope = parse2(SearchEnvelope, value, "search output");
+  const results = envelope.results;
+  if (envelope.returned_matches !== undefined)
+    results.returned_matches = envelope.returned_matches;
+  if (envelope.truncated !== undefined)
+    results.truncated = envelope.truncated;
+  if (envelope.byte_basis !== undefined)
+    results.byte_basis = envelope.byte_basis;
+  return results;
 }
 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 parseDiagnosticKind(value) {
-  if (value === "error" || value === "missing")
-    return value;
-  throw new Error("invalid readseek diagnostic.kind");
+  return parse2(RefsEnvelope, value, "refs output").references.map(({ symbol, ...reference }) => ({
+    ...reference,
+    enclosingSymbol: symbol?.qualified_name
+  }));
 }
 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");
+  const output = parse2(CheckEnvelope, value, "check output");
   return {
-    file_hash: optionalString(output.file_hash, "file_hash"),
-    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")
-      };
-    })
+    file_hash: output.file_hash,
+    errorCount: output.error_count,
+    missingCount: output.missing_count,
+    diagnostics: output.diagnostics
   };
 }
-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 parseImageEncoding(value) {
-  if (value === "base64")
-    return value;
-  throw new Error("invalid image encoding");
-}
 function parseDetectOutput(value) {
-  if (!value || typeof value !== "object")
-    throw new Error("invalid readseek detect output");
-  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")
-    };
+  const output = value ?? {};
+  if (output.type === "application/pdf") {
+    return { kind: "pdf", ...parse2(PdfDetectionInput, value, "detect output") };
   }
   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)
-    };
+    return { kind: "image", ...parse2(ImageDetectionInput, value, "detect output") };
   }
   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: "source", ...parse2(SourceDetectionInput, value, "detect output") };
   }
-  return { kind: "text", type, file, mime };
-}
-function parseDocumentCache(value) {
-  if (!value || typeof value !== "object")
-    throw new Error("invalid readseek document cache");
-  const cache = value;
-  const state = requireString(cache.state, "cache.state");
-  if (state !== "built" && state !== "reused")
-    throw new Error("invalid readseek cache.state");
-  return {
-    content_hash: requireString(cache.content_hash, "cache.content_hash"),
-    state
-  };
-}
-function parseIdentifyOutput(value) {
-  if (!value || typeof value !== "object")
-    throw new Error("invalid readseek identify output");
-  const output = value;
-  const identifier = output.identifier;
-  const symbol = output.symbol;
-  return {
-    file: requireString(output.file, "file"),
-    language: requireString(output.language, "language"),
-    engine: optionalString(output.engine, "engine"),
-    line_count: requireNumber(output.line_count, "line_count"),
-    file_hash: requireString(output.file_hash, "file_hash"),
-    line: requireNumber(output.line, "line"),
-    column: requireNumber(output.column, "column"),
-    line_hash: requireString(output.line_hash, "line_hash"),
-    identifier: identifier && typeof identifier === "object" ? {
-      text: requireString(identifier.text, "identifier.text"),
-      start_column: requireNumber(identifier.start_column, "identifier.start_column"),
-      end_column: requireNumber(identifier.end_column, "identifier.end_column"),
-      start_byte: requireNumber(identifier.start_byte, "identifier.start_byte"),
-      end_byte: requireNumber(identifier.end_byte, "identifier.end_byte")
-    } : undefined,
-    symbol: symbol && typeof symbol === "object" ? {
-      name: requireString(symbol.name, "symbol.name"),
-      kind: requireString(symbol.kind, "symbol.kind"),
-      qualified_name: requireString(symbol.qualified_name, "symbol.qualified_name"),
-      start_line: requireNumber(symbol.start_line, "symbol.start_line"),
-      end_line: requireNumber(symbol.end_line, "symbol.end_line")
-    } : undefined
-  };
+  return { kind: "text", ...parse2(TextDetectionInput, value, "detect output") };
 }
 function parseImageContent(value) {
   const detection = parseDetectOutput(value);
   if (detection.kind !== "image")
-    throw new Error("invalid readseek image content");
+    throw new Error("invalid readseek image content: expected an image");
   return detection;
 }
 function parseTextContent(value) {
+  const output = value ?? {};
+  if (output.hashlines === undefined || output.start_line !== undefined)
+    return parseReadOutput(value);
+  const spanned = parse2(UnspannedContent, value, "content");
+  return {
+    ...spanned,
+    start_line: spanned.hashlines[0]?.line ?? 1,
+    end_line: spanned.hashlines[spanned.hashlines.length - 1]?.line ?? 0
+  };
+}
+function parseDocumentCache(value) {
+  return parse2(DocumentCache, value, "document cache");
+}
+function parseIdentifyOutput(value) {
+  return parse2(IdentifyEnvelope, value, "identify output");
+}
+function parsePdfInspectMetadata(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;
+  if (value.format !== "pdf")
+    return;
+  const document = parse2(PdfInspectMetadata, value, "inspect metadata");
+  return { kind: "pdf", type: "application/pdf", file: document.source, format: "pdf", pages: document.pages };
+}
+function parseEditOutput(value) {
+  return parse2(EditOutputSchema, value, "edit output");
+}
+function parseRenameOutput(value) {
+  return parse2(RenameOutputSchema, value, "rename output");
+}
+function parseDefOutput(value) {
+  return parse2(DefEnvelope, value, "def output").locations;
+}
+
+// ../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 parseReadOutput(value);
+  return { code: "readseek-execution-error", message };
 }
-function parseDigestEnvelope(value) {
+function parseSourceInspectEnvelope(value) {
   if (!value || typeof value !== "object")
-    throw new Error("invalid readseek digest output");
+    throw new Error("invalid readseek inspect output");
   const output = value;
-  if (output.metadata === undefined)
-    throw new Error("invalid readseek digest metadata");
-  const result = {
-    metadata: parseDetectOutput(output.metadata)
-  };
+  const result = {};
+  if (output.metadata !== undefined)
+    result.metadata = parseDetectOutput(output.metadata);
   if (output.cache !== undefined)
     result.cache = parseDocumentCache(output.cache);
   if (output.content !== undefined)
@@ -1326,223 +1736,104 @@ function parseDigestEnvelope(value) {
     result.identity = parseIdentifyOutput(output.identity);
   return result;
 }
-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")
-  };
-}
-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")
-      };
-    }) ?? []
-  };
-}
-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 createReadSeekClient(runner) {
-  function digestArgs(target, options) {
-    return buildDigestArgs({
+  function inspectArgs(target, options) {
+    return buildInspectArgs({
       path: target,
+      selector: options.selector,
       select: options.select ?? "content",
-      at: options.at,
+      query: options.query,
       end: options.end,
       limit: options.limit,
+      depth: options.depth,
       language: options.language,
       visionMode: options.visionMode,
       visionLevel: options.visionLevel,
-      stdinName: options.stdin !== undefined && target === "-" ? options.stdinName ?? target : undefined
+      stdinName: options.stdinName
     });
   }
-  async function runDigestRaw(target, options = {}) {
-    const args = digestArgs(target, options);
-    const runOptions = {
+  function inspectRunOptions(options) {
+    return {
       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));
+  async function inspect(target, options = {}) {
+    return runner.kdl(inspectArgs(target, options), inspectRunOptions(options));
+  }
+  async function inspectText(target, options = {}) {
+    return runner.text(inspectArgs(target, options), inspectRunOptions(options));
+  }
+  async function inspectSource(target, options = {}) {
+    return parseSourceInspectEnvelope(await inspect(target, options));
   }
-  function requireDigestContent(envelope, field) {
+  function requireInspectMetadata(envelope, field) {
+    if (envelope.metadata === undefined)
+      throw new Error(`invalid readseek ${field}: missing metadata`);
+    return envelope.metadata;
+  }
+  function requireInspectContent(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,
+  async function inspectContent(filePath, options = {}) {
+    const inspected = await inspect(filePath, {
+      select: ["metadata", "content"],
+      selector: options.startLine !== undefined ? buildLineLocation(options.startLine) : undefined,
       end: options.endLine,
       visionMode: options.visionMode,
       signal: options.signal,
       vision: options.vision
     });
-    if (envelope.metadata.kind === "pdf") {
-      return { metadata: envelope.metadata, cache: envelope.cache };
-    }
-    const content = requireDigestContent(envelope, "content");
-    if (envelope.metadata.kind === "image") {
-      return { metadata: envelope.metadata, image: parseImageContent(content) };
+    const pdf = parsePdfInspectMetadata(inspected);
+    if (pdf)
+      return { metadata: pdf };
+    const envelope = parseSourceInspectEnvelope(inspected);
+    const metadata = requireInspectMetadata(envelope, "content");
+    const content = requireInspectContent(envelope, "content");
+    if (metadata.kind === "image") {
+      return { metadata, image: parseImageContent(content) };
     }
-    return { metadata: envelope.metadata, text: parseTextContent(content) };
+    return { metadata, text: parseTextContent(content) };
   }
   return {
-    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, {
+    inspect,
+    inspectText,
+    inspectContent,
+    async extract(target, selector, output, options = {}) {
+      await runner.text(buildExtractArgs({
+        path: target,
+        selector,
+        output,
+        stdinName: options.stdinName
+      }), {
         signal: options.signal,
-        vision: options.visionMode !== undefined
+        stdin: options.stdin,
+        timeoutMs: options.timeoutMs,
+        cancelable: options.cancelable
       });
     },
-    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}`);
+      if (modes.length === 0)
+        throw new Error(`readseek returned no image analysis for ${filePath}`);
+      const inspected = await inspectContent(filePath, {
+        visionMode: modes.length > 1 ? "all" : modes[0],
+        signal: options.signal,
+        vision: true
+      });
+      if (!inspected.image)
+        throw new Error(`readseek returned no image analysis for ${filePath}`);
+      return inspected.image;
     },
     async preparedImage(filePath, options = {}) {
-      const digested = await digestContent(filePath, {
+      const inspected = await inspectContent(filePath, {
         visionMode: "none",
         signal: options.signal
       });
-      const output = digested.image;
+      const output = inspected.image;
       if (!output || output.encoding !== "base64" || output.data === undefined || output.mime === undefined) {
         throw new Error(`readseek returned no prepared image for ${filePath}`);
       }
@@ -1554,11 +1845,9 @@ function createReadSeekClient(runner) {
         pattern,
         language: options.language,
         limit: options.limit,
-        cached: options.cached,
-        others: options.others,
-        ignored: options.ignored
+        gitScope: options.gitScope
       });
-      return parseSearchOutput(await runner.json(args, { signal: options.signal }));
+      return parseSearchOutput(await runner.kdl(args, { signal: options.signal }));
     },
     async refs(target, options = {}) {
       const args = buildRefsArgs({
@@ -1568,26 +1857,21 @@ function createReadSeekClient(runner) {
         line: options.line,
         column: options.column,
         language: options.language,
-        cached: options.cached,
-        others: options.others,
-        ignored: options.ignored
+        gitScope: options.gitScope
       });
-      return parseRefsOutput(await runner.json(args, { signal: options.signal }));
+      return parseRefsOutput(await runner.kdl(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
+        gitScope: options.gitScope
       });
-      return parseDefCompact(await runner.json(args, { signal: options.signal }));
+      return parseDefOutput(await runner.kdl(args, { signal: options.signal }));
     },
     async check(filePath, content, options = {}) {
-      const envelope = await digest("-", {
+      const envelope = await inspectSource("-", {
         select: "diagnostics",
         stdin: content,
         stdinName: filePath,
@@ -1597,12 +1881,12 @@ function createReadSeekClient(runner) {
         throw new Error("invalid readseek diagnostics: missing diagnostics facet");
       return envelope.diagnostics;
     },
-    async identify(filePath, content, options = {}) {
-      const envelope = await digest("-", {
+    async identify(filePath, content, options) {
+      const envelope = await inspectSource("-", {
         select: "identity",
         stdin: content,
         stdinName: filePath,
-        at: options.line !== undefined ? buildLineLocation(options.line, options.column) : undefined,
+        selector: buildLineLocation(options.line, options.column),
         language: options.language,
         signal: options.signal
       });
@@ -1611,8 +1895,11 @@ function createReadSeekClient(runner) {
       return envelope.identity;
     },
     async detect(filePath, options = {}) {
-      const envelope = await digest(filePath, { select: "metadata", signal: options.signal });
-      return envelope.metadata;
+      const inspected = await inspect(filePath, { select: "metadata", signal: options.signal });
+      const pdf = parsePdfInspectMetadata(inspected);
+      if (pdf)
+        return pdf;
+      return requireInspectMetadata(parseSourceInspectEnvelope(inspected), "metadata");
     },
     async edit(filePath, edits, options = {}) {
       const args = buildEditArgs({
@@ -1622,9 +1909,9 @@ function createReadSeekClient(runner) {
         language: options.language,
         requestFromStdin: true
       });
-      return parseEditOutput(await runner.json(args, {
+      return parseEditOutput(await runner.kdl(args, {
         signal: options.signal,
-        stdin: JSON.stringify({ edits }),
+        stdin: serializeEditPlan(edits),
         timeoutMs: options.timeoutMs,
         cancelable: options.cancelable
       }));
@@ -1637,12 +1924,11 @@ function createReadSeekClient(runner) {
         column: options.column,
         workspace: options.workspace,
         apply: options.apply,
+        planHash: options.planHash,
         language: options.language,
-        cached: options.cached,
-        others: options.others,
-        ignored: options.ignored
+        gitScope: options.gitScope
       });
-      return parseRenameOutput(await runner.json(args, { signal: options.signal }));
+      return parseRenameOutput(await runner.kdl(args, { signal: options.signal }));
     }
   };
 }
@@ -2123,7 +2409,7 @@ function formatReplaceHint(edits, noopEdits) {
     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.]";
+  return "[info: this edit used replace (unverified). For safer future edits, prefer set_line/replace_lines with an anchor from readSeek_inspect/readSeek_grep/readSeek_search.]";
 }
 function buildEditOutput(input) {
   const summary = `Updated ${input.displayPath}`;
@@ -2170,20 +2456,20 @@ function classifyEdit(oldContent, newContent) {
   const newLines = newContent.split(`
 `);
   if (oldLines.length === newLines.length) {
-    let hasWhitespaceChange2 = false;
-    let hasSemanticChange2 = false;
+    let hasWhitespaceChange = false;
+    let hasSemanticChange = false;
     for (let i = 0;i < oldLines.length; i++) {
       if (oldLines[i] === newLines[i])
         continue;
       if (oldLines[i].trim() === newLines[i].trim()) {
-        hasWhitespaceChange2 = true;
+        hasWhitespaceChange = true;
       } else {
-        hasSemanticChange2 = true;
+        hasSemanticChange = true;
       }
     }
-    if (hasSemanticChange2 && hasWhitespaceChange2)
+    if (hasSemanticChange && hasWhitespaceChange)
       return { classification: "mixed" };
-    if (hasWhitespaceChange2)
+    if (hasWhitespaceChange)
       return { classification: "whitespace-only" };
     return { classification: "semantic" };
   }
@@ -2223,7 +2509,7 @@ import { readFileSync, statSync as statSync2 } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 var READSEEK_TOOL_REPLACEMENTS = {
-  read: "readSeek_digest",
+  read: "readSeek_inspect",
   edit: "readSeek_edit",
   grep: "readSeek_grep",
   write: "readSeek_write"
@@ -2236,42 +2522,36 @@ var DEFAULT_DISPLAY_MODES = {
   edit: "expanded",
   write: "expanded"
 };
-function globalSettingsPath() {
-  return join(homedir(), ".pi/agent/settings.json");
-}
-function projectSettingsPath() {
-  return join(process.cwd(), ".pi/settings.json");
-}
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function invalid(source, path2) {
-  return { source, path: path2, message: `Invalid readseek setting at ${path2}` };
+function invalid(source, path) {
+  return { source, path, message: `Invalid readseek setting at ${path}` };
 }
 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}` });
+    const path = `${prefix}.${key}`;
+    warnings.push({ source, path, message: `Unknown readseek setting at ${path}` });
   }
 }
-function readPositive(raw, key, path2, source, warnings) {
+function readPositive(raw, key, path, 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));
+  warnings.push(invalid(source, path));
   return;
 }
-function readEnum(raw, key, values, path2, source, warnings) {
+function readEnum(raw, key, values, path, 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));
+  warnings.push(invalid(source, path));
   return;
 }
 function readImageMode(raw, source, warnings) {
@@ -2375,31 +2655,31 @@ function validateSettings(raw, source) {
   return { settings, warnings };
 }
 var settingsFileCache = new Map;
-function statFileOrNull(path2) {
+function statFileOrNull(path) {
   try {
-    return statSync2(path2);
+    return statSync2(path);
   } catch {
     return null;
   }
 }
-function readSettingsFile(path2) {
-  const stats = statFileOrNull(path2);
+function readSettingsFile(path) {
+  const stats = statFileOrNull(path);
   if (!stats) {
-    settingsFileCache.delete(path2);
+    settingsFileCache.delete(path);
     return { settings: {}, warnings: [] };
   }
-  const cached = settingsFileCache.get(path2);
+  const cached = settingsFileCache.get(path);
   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);
+    const text = readFileSync(path, "utf8");
+    result = validateSettings(JSON.parse(text), path);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    result = { settings: {}, warnings: [{ source: path2, message: `Invalid JSON: ${message}` }] };
+    result = { settings: {}, warnings: [{ source: path, message: `Invalid JSON: ${message}` }] };
   }
-  settingsFileCache.set(path2, { mtimeMs: stats.mtimeMs, size: stats.size, result });
+  settingsFileCache.set(path, { mtimeMs: stats.mtimeMs, size: stats.size, result });
   return result;
 }
 function mergeSettings(base, override) {
@@ -2413,8 +2693,8 @@ function mergeSettings(base, override) {
   return settings;
 }
 function resolveReadSeekJsonSettings() {
-  const globalResult = readSettingsFile(globalSettingsPath());
-  const projectResult = readSettingsFile(projectSettingsPath());
+  const globalResult = readSettingsFile(join(homedir(), ".pi/agent/settings.json"));
+  const projectResult = readSettingsFile(join(process.cwd(), ".pi/settings.json"));
   return {
     settings: mergeSettings(globalResult.settings, projectResult.settings),
     warnings: [...globalResult.warnings, ...projectResult.warnings]
@@ -2462,21 +2742,13 @@ 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 ??= runReadSeekNodeText(readSeekBinaryPath(), ["--readseek-dir", dir, "init"], { timeoutMs: readSeekTimeoutMs() }).then(() => directoryExists(dir) ? dir : null).catch(() => null).finally(() => {
     defaultReadSeekDirInit = undefined;
   });
   return defaultReadSeekDirInit;
@@ -2498,17 +2770,6 @@ async function readSeekInvocationArgs(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 runReadSeek(args, options = {}) {
-  return runReadSeekNodeJson(readSeekBinaryPath(), await readSeekInvocationArgs(args), {
-    signal: options.signal,
-    stdin: options.stdin,
-    timeoutMs: options.timeoutMs ?? readSeekTimeoutMs(),
-    cancelable: options.cancelable
-  });
-}
 var visionInvocationTail = Promise.resolve();
 async function runReadSeekVisionRaw(args, options = {}) {
   let release;
@@ -2539,38 +2800,40 @@ async function runReadSeekVisionRaw(args, options = {}) {
       await predecessor;
     }
     signal?.throwIfAborted();
-    return await runReadSeekRaw(args, {
-      ...options,
-      timeoutMs: options.timeoutMs ?? resolveReadSeekTimeoutMs() ?? DEFAULT_READSEEK_VISION_TIMEOUT_MS
+    return await runReadSeekNodeText(readSeekBinaryPath(), await readSeekInvocationArgs(args), {
+      signal: options.signal,
+      stdin: options.stdin,
+      timeoutMs: options.timeoutMs ?? resolveReadSeekTimeoutMs() ?? DEFAULT_READSEEK_VISION_TIMEOUT_MS,
+      cancelable: options.cancelable
     });
   } finally {
     release();
   }
 }
-async function runReadSeekVision(args, options = {}) {
-  return parseReadSeekJson(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)
+  text: async (args, options = {}) => options.vision ? runReadSeekVisionRaw(args, options) : runReadSeekNodeText(readSeekBinaryPath(), await readSeekInvocationArgs(args), {
+    signal: options.signal,
+    stdin: options.stdin,
+    timeoutMs: options.timeoutMs ?? readSeekTimeoutMs(),
+    cancelable: options.cancelable
+  }),
+  kdl: async (args, options = {}) => parseReadSeekKdl(await runner.text(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 readSeekInspect = client.inspect;
+var readSeekExtract = client.extract;
 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;
 async function readSeekMap(filePath, options = {}) {
-  const envelope = await client.digest(filePath, { select: "map", signal: options.signal });
+  const envelope = await client.inspect(filePath, {
+    select: "map",
+    depth: DEFAULT_INSPECT_MAP_DEPTH,
+    signal: options.signal
+  });
   const map = envelope.map;
   if (!map || map.language === "unknown" && map.symbols.length === 0)
     return null;
@@ -2634,8 +2897,8 @@ var LANGUAGE_BY_EXTENSION = new Map([
   [".rs", "rust"],
   [".java", "java"]
 ]);
-function inferLanguage(path3) {
-  const extensionMatch = path3.match(/\.[^.\/\\]+$/);
+function inferLanguage(path) {
+  const extensionMatch = path.match(/\.[^.\/\\]+$/);
   if (!extensionMatch)
     return;
   return LANGUAGE_BY_EXTENSION.get(extensionMatch[0].toLowerCase());
@@ -2681,10 +2944,10 @@ function parseCompactDiffEntries(diff, oldContent, newContent) {
 `);
   const compactDelete = diff.match(/^(\d+):[0-9a-f]{6}\|(.*) → \[deleted\]$/);
   if (compactDelete) {
-    const oldLine2 = Number(compactDelete[1]);
+    const oldLine = Number(compactDelete[1]);
     const text = compactDelete[2] ?? "";
-    if (oldLines[oldLine2 - 1] === text)
-      return [{ kind: "remove", oldLine: oldLine2, text }];
+    if (oldLines[oldLine - 1] === text)
+      return [{ kind: "remove", oldLine, text }];
   }
   const compactPrefix = diff.match(/^(\d+):[0-9a-f]{6}\|/);
   if (!compactPrefix)
@@ -2724,9 +2987,9 @@ function longestCommonSubsequence(a, b) {
   const rows = a.length + 1;
   const cols = b.length + 1;
   const table = Array.from({ length: rows }, () => Array(cols).fill(0));
-  for (let i2 = a.length - 1;i2 >= 0; i2--) {
-    for (let j2 = b.length - 1;j2 >= 0; j2--) {
-      table[i2][j2] = a[i2] === b[j2] ? table[i2 + 1][j2 + 1] + 1 : Math.max(table[i2 + 1][j2], table[i2][j2 + 1]);
+  for (let i = a.length - 1;i >= 0; i--) {
+    for (let j = b.length - 1;j >= 0; j--) {
+      table[i][j] = a[i] === b[j] ? table[i + 1][j + 1] + 1 : Math.max(table[i + 1][j], table[i][j + 1]);
     }
   }
   const pairs = [];
@@ -2844,8 +3107,8 @@ function buildInlineDiffs(entries) {
   }
   return inlineDiffs.length ? inlineDiffs : undefined;
 }
-function finalizeDiffData(path3, entries, blockRanges) {
-  const language = inferLanguage(path3);
+function finalizeDiffData(path, entries, blockRanges) {
+  const language = inferLanguage(path);
   const inlineDiffs = buildInlineDiffs(entries);
   return {
     version: 1,
@@ -2938,7 +3201,6 @@ function wrapWithHangingIndent(prefix, content, width, options = {}) {
   const indent = " ".repeat(prefixWidth);
   return wrapped.map((line, index) => tint(clampLineToWidth(index === 0 ? prefix + line : indent + line, normalized)));
 }
-var wrappedHashlinesCache = new WeakMap;
 function renderPendingResult(pendingLabel, width, theme) {
   return new Text(clampLinesToWidth([summaryLine(pendingLabel, { theme, style: "muted" })], width).join(`
 `), 0, 0);
@@ -3004,28 +3266,53 @@ import { Text as Text2, visibleWidth as visibleWidth3 } from "@earendil-works/pi
 
 // src/tui-diff-renderer.ts
 import { visibleWidth as visibleWidth2 } from "@earendil-works/pi-tui";
-function hasOldSide(data) {
-  return data.entries.some((e) => e.kind === "remove" || e.kind === "context");
+function isDiffEntry(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const entry = value;
+  if (typeof entry.text !== "string")
+    return false;
+  if (entry.kind === "meta")
+    return true;
+  if (entry.kind === "add")
+    return Number.isInteger(entry.newLine) && Number(entry.newLine) > 0;
+  if (entry.kind === "remove")
+    return Number.isInteger(entry.oldLine) && Number(entry.oldLine) > 0;
+  return entry.kind === "context" && Number.isInteger(entry.oldLine) && Number(entry.oldLine) > 0 && Number.isInteger(entry.newLine) && Number(entry.newLine) > 0;
+}
+function indexedDiffEntries(data) {
+  if (!Array.isArray(data.entries))
+    return [];
+  const entries = [];
+  for (const [index, entry] of data.entries.entries()) {
+    if (isDiffEntry(entry))
+      entries.push([index, entry]);
+  }
+  return entries;
+}
+function hasOldSide(entries) {
+  return entries.some(([, entry]) => entry.kind === "remove" || entry.kind === "context");
 }
-function chooseMode(width, data) {
+function chooseMode(width, entries) {
   if (width < 24)
     return "summary";
   if (width < 50)
     return "compact";
-  if (width >= 100 && hasOldSide(data))
+  if (width >= 100 && hasOldSide(entries))
     return "split";
   return "unified";
 }
-function hunkCount(data) {
-  return Math.max(1, data.blockRanges?.length ?? (data.entries.some((e) => e.kind === "add" || e.kind === "remove") ? 1 : 0));
+function hunkCount(data, entries) {
+  const blockRangeCount = Array.isArray(data.blockRanges) ? data.blockRanges.length : undefined;
+  return Math.max(1, blockRangeCount ?? (entries.some(([, entry]) => entry.kind === "add" || entry.kind === "remove") ? 1 : 0));
 }
 function compactHeader(data) {
   return `↳ diff +${data.stats.added} -${data.stats.removed}`;
 }
-function header(data, mode, width) {
+function header(data, mode, width, entries) {
   if (mode === "summary" && width <= 10)
     return `↳ diff +${data.stats.added}`;
-  const full = `${compactHeader(data)} • ${hunkCount(data)} hunk • 1 file • ${mode === "split" ? "split" : "unified"}`;
+  const full = `${compactHeader(data)} • ${hunkCount(data, entries)} hunk • 1 file • ${mode === "split" ? "split" : "unified"}`;
   return visibleWidth2(full) <= width ? full : clampLineToWidth(compactHeader(data), width);
 }
 function lineNo(entry) {
@@ -3044,18 +3331,18 @@ function padRightVisual(line, width) {
 function tint(theme, entry, text) {
   return entry.kind === "add" ? theme.fg("success", text) : entry.kind === "remove" ? theme.fg("error", text) : theme.fg("toolOutput", text);
 }
-function spans(theme, spans2, fallback) {
-  return spans2?.map((s) => s.kind === "add" ? theme.fg("success", s.text) : s.kind === "remove" ? theme.fg("error", s.text) : s.text).join("") ?? fallback;
+function spans(theme, spans, fallback) {
+  return spans?.map((s) => s.kind === "add" ? theme.fg("success", s.text) : s.kind === "remove" ? theme.fg("error", s.text) : s.text).join("") ?? fallback;
 }
 function inlineText(input, index, entry) {
-  const pair = input.diffData.inlineDiffs?.find((d) => entry.kind === "remove" ? d.removeLineIndex === index : entry.kind === "add" ? d.addLineIndex === index : false);
+  const pair = Array.isArray(input.diffData.inlineDiffs) ? input.diffData.inlineDiffs.find((d) => entry.kind === "remove" ? d.removeLineIndex === index : entry.kind === "add" ? d.addLineIndex === index : false) : undefined;
   if (!pair)
     return textOf(entry);
   return entry.kind === "remove" ? spans(input.theme, pair.removeSpans, textOf(entry)) : entry.kind === "add" ? spans(input.theme, pair.addSpans, textOf(entry)) : textOf(entry);
 }
-function unifiedRows(input, width) {
+function unifiedRows(input, width, entries) {
   const rows = [];
-  for (const [i, e] of input.diffData.entries.entries()) {
+  for (const [i, e] of entries) {
     if (e.kind === "meta")
       continue;
     const prefix = `▌${gutterMarker(e)} ${lineNo(e)} │ `;
@@ -3064,9 +3351,9 @@ function unifiedRows(input, width) {
   }
   return rows;
 }
-function compactRows(input, width) {
+function compactRows(input, width, entries) {
   const rows = [];
-  for (const [i, e] of input.diffData.entries.entries()) {
+  for (const [i, e] of entries) {
     if (e.kind !== "add" && e.kind !== "remove")
       continue;
     const prefix = `▌${gutterMarker(e)} ${lineNo(e)} `;
@@ -3075,11 +3362,11 @@ function compactRows(input, width) {
   }
   return rows;
 }
-function splitRows(input, width) {
+function splitRows(input, width, entries) {
   const pane = Math.max(10, Math.floor((width - 3) / 2));
   const rows = [`${padRightVisual("old", pane)} │ new`];
   const blankPane = " ".repeat(pane);
-  for (const [i, e] of input.diffData.entries.entries()) {
+  for (const [i, e] of entries) {
     if (e.kind === "remove") {
       const left = wrapWithHangingIndent(`▌- ${e.oldLine} │ `, inlineText(input, i, e), pane, { tint: (text) => tint(input.theme, e, text) });
       for (const line of left)
@@ -3107,13 +3394,18 @@ function hiddenHint(hiddenLines, hiddenHunks, width) {
 }
 function renderTuiDiff(input) {
   const width = normalizeWidth(input.width);
-  const mode = chooseMode(width, input.diffData);
-  const lines = [header(input.diffData, mode, width)];
+  const entries = indexedDiffEntries(input.diffData);
+  const rawEntryCount = Array.isArray(input.diffData.entries) ? input.diffData.entries.length : input.diffData.stats.added + input.diffData.stats.removed + input.diffData.stats.context;
+  const truncated = !Array.isArray(input.diffData.entries) || entries.length !== rawEntryCount;
+  const mode = chooseMode(width, entries);
+  const lines = [header(input.diffData, mode, width, entries)];
   if (!input.expanded)
-    return { mode, width, lines: clampLinesToWidth([...lines, hiddenHint(input.diffData.entries.length, hunkCount(input.diffData), width)], width) };
+    return { mode, width, lines: clampLinesToWidth([...lines, hiddenHint(rawEntryCount, hunkCount(input.diffData, entries), width)], width) };
   if (mode === "summary")
     return { mode, width, lines: clampLinesToWidth(lines, width) };
-  const rows = mode === "split" ? splitRows(input, width) : mode === "compact" ? compactRows(input, width) : unifiedRows(input, width);
+  const rows = mode === "split" ? splitRows(input, width, entries) : mode === "compact" ? compactRows(input, width, entries) : unifiedRows(input, width, entries);
+  if (truncated)
+    rows.push(clampLineToWidth("… diff preview truncated", width));
   return { mode, width, lines: [...lines, ...rows] };
 }
 
@@ -3169,12 +3461,12 @@ function upsertTextComponent(lastComponent, text) {
 }
 
 // src/register-tool.ts
-import { Type } from "@sinclair/typebox";
+import { Type as Type2 } from "@sinclair/typebox";
 function optionalIntOrString(description) {
-  return Type.Optional(Type.Union([Type.Number({ description }), Type.String({ description })]));
+  return Type2.Optional(Type2.Union([Type2.Number({ description }), Type2.String({ description })]));
 }
 function filePathParam() {
-  return Type.String({ description: PARAM_DESCRIPTIONS.path });
+  return Type2.String({ description: PARAM_DESCRIPTIONS.path });
 }
 function registerReadSeekTool(pi, tool) {
   pi.registerTool(tool);
@@ -3182,28 +3474,28 @@ function registerReadSeekTool(pi, tool) {
 }
 
 // src/edit.ts
-var hashlineEditItemSchema = Type2.Object({
-  set_line: Type2.Optional(Type2.Object({
-    anchor: Type2.String({ description: PARAM_DESCRIPTIONS.anchor }),
-    new_text: Type2.String({ description: PARAM_DESCRIPTIONS.newTextLine })
+var hashlineEditItemSchema = Type3.Object({
+  set_line: Type3.Optional(Type3.Object({
+    anchor: Type3.String({ description: PARAM_DESCRIPTIONS.anchor }),
+    new_text: Type3.String({ description: PARAM_DESCRIPTIONS.newTextLine })
   }, { additionalProperties: false, description: PARAM_DESCRIPTIONS.setLine })),
-  replace_lines: Type2.Optional(Type2.Object({
-    start_anchor: Type2.String({ description: PARAM_DESCRIPTIONS.startAnchor }),
-    end_anchor: Type2.String({ description: PARAM_DESCRIPTIONS.endAnchor }),
-    new_text: Type2.String({ description: PARAM_DESCRIPTIONS.newTextRange })
+  replace_lines: Type3.Optional(Type3.Object({
+    start_anchor: Type3.String({ description: PARAM_DESCRIPTIONS.startAnchor }),
+    end_anchor: Type3.String({ description: PARAM_DESCRIPTIONS.endAnchor }),
+    new_text: Type3.String({ description: PARAM_DESCRIPTIONS.newTextRange })
   }, { additionalProperties: false, description: PARAM_DESCRIPTIONS.replaceLines })),
-  insert_after: Type2.Optional(Type2.Object({
-    anchor: Type2.String({ description: PARAM_DESCRIPTIONS.insertAnchor }),
-    new_text: Type2.String({ description: PARAM_DESCRIPTIONS.newTextInsert })
+  insert_after: Type3.Optional(Type3.Object({
+    anchor: Type3.String({ description: PARAM_DESCRIPTIONS.insertAnchor }),
+    new_text: Type3.String({ description: PARAM_DESCRIPTIONS.newTextInsert })
   }, { additionalProperties: false, description: PARAM_DESCRIPTIONS.insertAfter })),
-  replace: Type2.Optional(Type2.Object({
-    old_text: Type2.String({ description: PARAM_DESCRIPTIONS.oldText }),
-    new_text: Type2.String({ description: PARAM_DESCRIPTIONS.newText }),
-    all: Type2.Optional(Type2.Boolean({ description: PARAM_DESCRIPTIONS.all }))
+  replace: Type3.Optional(Type3.Object({
+    old_text: Type3.String({ description: PARAM_DESCRIPTIONS.oldText }),
+    new_text: Type3.String({ description: PARAM_DESCRIPTIONS.newText }),
+    all: Type3.Optional(Type3.Boolean({ description: PARAM_DESCRIPTIONS.all }))
   }, { additionalProperties: false, description: PARAM_DESCRIPTIONS.replace })),
-  replace_symbol: Type2.Optional(Type2.Object({
-    symbol: Type2.String({ description: PARAM_DESCRIPTIONS.symbol }),
-    new_body: Type2.String({ description: PARAM_DESCRIPTIONS.newBody })
+  replace_symbol: Type3.Optional(Type3.Object({
+    symbol: Type3.String({ description: PARAM_DESCRIPTIONS.symbol }),
+    new_body: Type3.String({ description: PARAM_DESCRIPTIONS.newBody })
   }, { additionalProperties: false, description: PARAM_DESCRIPTIONS.replaceSymbol }))
 }, {
   additionalProperties: false,
@@ -3211,18 +3503,18 @@ var hashlineEditItemSchema = Type2.Object({
   maxProperties: 1,
   description: PARAM_DESCRIPTIONS.editVariant
 });
-var hashlineEditSchema = Type2.Object({
+var hashlineEditSchema = Type3.Object({
   path: filePathParam(),
-  language: Type2.Optional(Type2.String({ description: PARAM_DESCRIPTIONS.languageSymbol })),
-  edits: Type2.Array(hashlineEditItemSchema, {
+  language: Type3.Optional(Type3.String({ description: PARAM_DESCRIPTIONS.languageSymbol })),
+  edits: Type3.Array(hashlineEditItemSchema, {
     minItems: 1,
     description: PARAM_DESCRIPTIONS.edits
   }),
-  postEditVerify: Type2.Optional(Type2.Boolean({
+  postEditVerify: Type3.Optional(Type3.Boolean({
     description: PARAM_DESCRIPTIONS.postEditVerify
   }))
 }, { additionalProperties: false });
-function buildEditError(path3, code, message, hint, errorDetails) {
+function buildEditError(path, code, message, hint, errorDetails) {
   return {
     content: [{ type: "text", text: message }],
     isError: true,
@@ -3233,7 +3525,7 @@ function buildEditError(path3, code, message, hint, errorDetails) {
       readSeekValue: {
         tool: "edit",
         ok: false,
-        path: path3,
+        path,
         error: buildReadSeekError(code, message, hint, errorDetails)
       }
     }
@@ -3247,14 +3539,14 @@ async function executeEdit(opts) {
   const { params, signal, cwd, wasReadInSession, onFileMutated, syntaxValidate } = opts;
   const parsed = params;
   const rawPath = parsed.path;
-  const path3 = rawPath.replace(/^@/, "");
-  const absolutePath = resolveToCwd2(path3, cwd);
+  const path = rawPath.replace(/^@/, "");
+  const absolutePath = resolveToCwd2(path, cwd);
   throwIfAborted(signal);
   try {
     return await withFileMutationQueue(absolutePath, async () => {
       throwIfAborted(signal);
       if (wasReadInSession && !wasReadInSession(absolutePath)) {
-        const hint = `Call readSeek_digest(${JSON.stringify(rawPath)}) first, or use readSeek_grep, readSeek_search, or readSeek_write to produce fresh anchors for this file.`;
+        const hint = `Call readSeek_inspect(${JSON.stringify(rawPath)}) first, or use readSeek_grep, readSeek_search, or readSeek_write to produce fresh anchors for this file.`;
         return buildEditError(absolutePath, "file-not-read", `You must get fresh anchors for ${absolutePath} before editing it. ${hint}`, hint);
       }
       const parsedEdits = validateExactlyOneEditVariant(parsed.edits ?? []);
@@ -3279,7 +3571,7 @@ async function executeEdit(opts) {
       const originalForSyntax = normalizeToLF(stripBom(original).text);
       const resultForSyntax = normalizeToLF(stripBom(result).text);
       if (!plan.changed) {
-        return buildEditError(absolutePath, "no-op", `No changes made to ${path3}. The edits produced identical content.`);
+        return buildEditError(absolutePath, "no-op", `No changes made to ${path}. The edits produced identical content.`);
       }
       const syntaxMode = resolveSyntaxValidateMode({ syntaxValidate });
       let syntaxWarning;
@@ -3320,14 +3612,14 @@ async function executeEdit(opts) {
         try {
           verifiedContent = await fsReadFile(absolutePath, "utf-8");
         } catch (err) {
-          return buildEditError(absolutePath, "post-edit-verification-read-failed", `Edit write completed but post-edit verification failed: could not read ${path3} after writing.`, undefined, { fsCode: err?.code, fsMessage: err?.message });
+          return buildEditError(absolutePath, "post-edit-verification-read-failed", `Edit write completed but post-edit verification failed: could not read ${path} after writing.`, undefined, { fsCode: err?.code, fsMessage: err?.message });
         }
         if (verifiedContent !== plan.content) {
-          return buildEditError(absolutePath, "post-edit-verification-mismatch", `Edit write completed but post-edit verification did not confirm the intended content for ${path3}. Re-read the file before making follow-up edits.`, undefined, { expectedLength: plan.content.length, actualLength: verifiedContent.length });
+          return buildEditError(absolutePath, "post-edit-verification-mismatch", `Edit write completed but post-edit verification did not confirm the intended content for ${path}. Re-read the file before making follow-up edits.`, undefined, { expectedLength: plan.content.length, actualLength: verifiedContent.length });
         }
       }
       const diffResult = generateCompactOrFullDiff(original, result);
-      const patch = createPatch(path3, original, result);
+      const patch = createPatch(path, original, result);
       const diffData = buildDiffData({
         path: absolutePath,
         oldContent: original,
@@ -3339,7 +3631,7 @@ async function executeEdit(opts) {
       const semanticSummary = { classification: classification.classification };
       const builtOutput = buildEditOutput({
         path: absolutePath,
-        displayPath: path3,
+        displayPath: path,
         diff: diffResult.diff,
         patch,
         diffData,
@@ -3362,7 +3654,7 @@ async function executeEdit(opts) {
     });
   } catch (err) {
     if (typeof err?.code === "string") {
-      return mapEditFileError(err, absolutePath, path3, "read");
+      return mapEditFileError(err, absolutePath, path, "read");
     }
     throw err;
   }
@@ -3412,8 +3704,8 @@ function registerEditTool(pi, options = {}) {
       text = clampLineToWidth(text, context.width);
       return upsertTextComponent(context.lastComponent, text);
     },
-    renderResult(result, options2, theme, ...rest) {
-      const { isPartial, isError, expanded, width, context } = resolveRenderResultContext(options2, rest, resolveReadSeekToolDisplayMode("edit") === "expanded");
+    renderResult(result, options, theme, ...rest) {
+      const { isPartial, isError, expanded, width, context } = resolveRenderResultContext(options, rest, resolveReadSeekToolDisplayMode("edit") === "expanded");
       if (isPartial) {
         return renderPendingResult("pending edit", width, theme);
       }
@@ -3469,7 +3761,7 @@ ${theme.fg("error", info.errorText)}`;
 import { readFile as fsReadFile2, stat as fsStat } from "node:fs/promises";
 import path3 from "node:path";
 import { createGrepTool } from "@earendil-works/pi-coding-agent";
-import { Type as Type4 } from "@sinclair/typebox";
+import { Type as Type5 } from "@sinclair/typebox";
 import { Text as Text4 } from "@earendil-works/pi-tui";
 
 // src/binary-detect.ts
@@ -3541,14 +3833,14 @@ function buildScopeMetadata(groups, warnings) {
 }
 function buildGrepOutput(input) {
   const fileCount = new Set(input.groups.map((group) => group.absolutePath)).size;
-  const header2 = `[${input.totalMatches} matches in ${fileCount} files]`;
+  const header = `[${input.totalMatches} matches in ${fileCount} files]`;
   let text;
   if (input.summary) {
     const fileLines = [...input.groups].sort((a, b) => b.matchCount - a.matchCount).map((group) => `${group.absolutePath}: ${group.matchCount} matches`);
-    text = [header2, ...fileLines].join(`
+    text = [header, ...fileLines].join(`
 `);
   } else {
-    const blocks = [header2];
+    const blocks = [header];
     for (const group of input.groups) {
       blocks.push(renderGroupHeader(group));
       for (const entry of group.entries) {
@@ -3653,12 +3945,12 @@ function firstLineNumber(group) {
 }
 function buildSymbolEntries(fileLines, symbol, matchLines, scopeContext) {
   if (scopeContext === undefined) {
-    const entries2 = [];
+    const entries = [];
     for (let lineNumber = symbol.startLine;lineNumber <= symbol.endLine; lineNumber++) {
       const built = buildReadSeekLine(lineNumber, fileLines[lineNumber - 1] ?? "");
-      entries2.push({ kind: matchLines.has(lineNumber) ? "match" : "context", line: built });
+      entries.push({ kind: matchLines.has(lineNumber) ? "match" : "context", line: built });
     }
-    return entries2;
+    return entries;
   }
   const ranges = [...matchLines].sort((a, b) => a - b).map((ln) => ({
     startLine: Math.max(symbol.startLine, ln - scopeContext),
@@ -3841,11 +4133,8 @@ import {
 } from "@jarkkojs/readseek-api";
 
 // src/tui-source-render.ts
-import { getLanguageFromPath, highlightCode } from "@earendil-works/pi-coding-agent";
-import { wrapTextWithAnsi as wrapTextWithAnsi2 } from "@earendil-works/pi-tui";
 var GREP_ANCHOR_RE = /^(.*?):(>>|  )(\d+):([0-9a-zA-Z]{1,16})\|(.*)$/;
-var readSourceCache = new WeakMap;
-function renderGrepSourceForDisplay(text, anchors, renderPath = (path3) => path3) {
+function renderGrepSourceForDisplay(text, anchors, renderPath = (path) => path) {
   return text.split(`
 `).map((line) => {
     const match = line.match(GREP_ANCHOR_RE);
@@ -3861,39 +4150,30 @@ function renderGrepSourceForDisplay(text, anchors, renderPath = (path3) => path3
 }
 
 // src/readseek-params.ts
-import { Type as Type3 } from "@sinclair/typebox";
+import { Type as Type4 } from "@sinclair/typebox";
 function searchPathParam() {
-  return Type3.Optional(Type3.String({ description: PARAM_DESCRIPTIONS.searchPath }));
+  return Type4.Optional(Type4.String({ description: PARAM_DESCRIPTIONS.searchPath }));
 }
 function languageParam() {
-  return Type3.Optional(Type3.String({ description: PARAM_DESCRIPTIONS.language }));
+  return Type4.Optional(Type4.String({ description: PARAM_DESCRIPTIONS.language }));
 }
 function readSeekGitSearchParams() {
   return {
-    cached: Type3.Optional(Type3.Boolean({ description: PARAM_DESCRIPTIONS.cached })),
-    others: Type3.Optional(Type3.Boolean({ description: PARAM_DESCRIPTIONS.others })),
-    ignored: Type3.Optional(Type3.Boolean({ description: PARAM_DESCRIPTIONS.ignored }))
+    gitScope: Type4.Optional(Type4.Union(GIT_SCOPES.map((scope) => Type4.Literal(scope)), { description: PARAM_DESCRIPTIONS.gitScope }))
   };
 }
-function validateIgnoredRequiresOthers(tool, params) {
-  const validated = validateGitSelection(params);
-  if (!validated.ok) {
-    return buildToolErrorResult(tool, "invalid-parameter", `${tool} parameter 'ignored' requires 'others'`);
-  }
-  return null;
-}
 
 // src/grep.ts
-var grepSchema = Type4.Object({
-  pattern: Type4.String({ description: PARAM_DESCRIPTIONS.grepPattern }),
+var grepSchema = Type5.Object({
+  pattern: Type5.String({ description: PARAM_DESCRIPTIONS.grepPattern }),
   path: searchPathParam(),
-  glob: Type4.Optional(Type4.String({ description: PARAM_DESCRIPTIONS.glob })),
-  ignoreCase: Type4.Optional(Type4.Boolean({ description: PARAM_DESCRIPTIONS.ignoreCase })),
-  literal: Type4.Optional(Type4.Boolean({ description: PARAM_DESCRIPTIONS.literal })),
+  glob: Type5.Optional(Type5.String({ description: PARAM_DESCRIPTIONS.glob })),
+  ignoreCase: Type5.Optional(Type5.Boolean({ description: PARAM_DESCRIPTIONS.ignoreCase })),
+  literal: Type5.Optional(Type5.Boolean({ description: PARAM_DESCRIPTIONS.literal })),
   context: optionalIntOrString(PARAM_DESCRIPTIONS.context),
   limit: optionalIntOrString(PARAM_DESCRIPTIONS.matchLimit),
-  summary: Type4.Optional(Type4.Boolean({ description: PARAM_DESCRIPTIONS.summary })),
-  scope: Type4.Optional(Type4.Literal("symbol", {
+  summary: Type5.Optional(Type5.Boolean({ description: PARAM_DESCRIPTIONS.summary })),
+  scope: Type5.Optional(Type5.Literal("symbol", {
     description: PARAM_DESCRIPTIONS.grepScope
   })),
   scopeContext: optionalIntOrString(PARAM_DESCRIPTIONS.scopeContext)
@@ -3965,12 +4245,6 @@ function truncateGroupEntries(group) {
   }
   return { ...group, entries: kept };
 }
-function recordsFromGroups(groups) {
-  return groups.flatMap((group) => group.entries.flatMap((entry) => entry.kind === "separator" ? [] : [{ path: group.absolutePath, ...entry.line, kind: entry.kind }]));
-}
-function escapeForRegex(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 async function executeGrep(opts) {
   const { toolCallId, params, signal, onUpdate, cwd, onFileAnchored } = opts;
   await ensureHashInit();
@@ -3979,10 +4253,16 @@ async function executeGrep(opts) {
   if (!context.ok) {
     return buildToolErrorResult("grep", "invalid-params-combo", context.message);
   }
+  if (context.value !== undefined && context.value < 0) {
+    return buildToolErrorResult("grep", "invalid-params-combo", `Invalid context: expected a non-negative integer, received ${context.value}.`);
+  }
   const limit = coerceObviousBase10Int2(rawParams.limit, "limit");
   if (!limit.ok) {
     return buildToolErrorResult("grep", "invalid-limit", limit.message);
   }
+  if (limit.value !== undefined && limit.value < 1) {
+    return buildToolErrorResult("grep", "invalid-limit", `Invalid limit: expected a positive integer, received ${limit.value}.`);
+  }
   const scopeContext = coerceObviousBase10Int2(rawParams.scopeContext, "scopeContext");
   if (!scopeContext.ok) {
     return buildToolErrorResult("grep", "invalid-params-combo", scopeContext.message);
@@ -4087,7 +4367,7 @@ async function executeGrep(opts) {
     const CONCURRENCY = 8;
     const pathList = [...pathsToRead];
     for (let i = 0;i < pathList.length; i += CONCURRENCY) {
-      await Promise.all(pathList.slice(i, i + CONCURRENCY).map((p2) => getFileLines(p2)));
+      await Promise.all(pathList.slice(i, i + CONCURRENCY).map((p) => getFileLines(p)));
     }
   }
   const addSummaryMatch = (displayPath, absolutePath) => {
@@ -4140,7 +4420,7 @@ async function executeGrep(opts) {
       const flags = p.ignoreCase ? "i" : "";
       let patternRe = null;
       try {
-        patternRe = p.literal ? new RegExp(escapeForRegex(p.pattern), flags) : new RegExp(p.pattern, flags);
+        patternRe = p.literal ? new RegExp(p.pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), flags) : new RegExp(p.pattern, flags);
       } catch {}
       if (patternRe !== null) {
         let emitted = false;
@@ -4224,7 +4504,7 @@ ${warning}` } : item),
     renderedGroups = scoped.groups;
     scopeWarnings = scoped.warnings;
   }
-  const readSeekRecords = recordsFromGroups(renderedGroups);
+  const readSeekRecords = renderedGroups.flatMap((group) => group.entries.flatMap((entry) => entry.kind === "separator" ? [] : [{ path: group.absolutePath, ...entry.line, kind: entry.kind }]));
   const builtOutput = buildGrepOutput({
     summary: !!summary,
     totalMatches,
@@ -4295,8 +4575,8 @@ function registerGrepTool(pi, options = {}) {
       }
       return new Text4(clampLineToWidth(text, context.width), 0, 0);
     },
-    renderResult(result, options2, theme, ...rest) {
-      const { isPartial, isError, expanded, cwd, width } = resolveRenderResultContext(options2, rest, resolveReadSeekToolDisplayMode("grep") === "expanded");
+    renderResult(result, options, theme, ...rest) {
+      const { isPartial, isError, expanded, cwd, width } = resolveRenderResultContext(options, rest, resolveReadSeekToolDisplayMode("grep") === "expanded");
       if (isPartial)
         return renderPendingResult("pending grep", width, theme);
       const content = result.content?.[0];
@@ -4343,7 +4623,7 @@ function registerGrepTool(pi, options = {}) {
 
 // src/search.ts
 import path4 from "node:path";
-import { Type as Type5 } from "@sinclair/typebox";
+import { Type as Type6 } from "@sinclair/typebox";
 
 // src/stat-search-path.ts
 import { stat as fsStat2 } from "node:fs/promises";
@@ -4351,9 +4631,9 @@ async function statSearchPathOrError(tool, rawPath, searchPath) {
   try {
     return { ok: true, stats: await fsStat2(searchPath) };
   } catch (err) {
-    const path4 = rawPath ?? searchPath;
+    const path = rawPath ?? searchPath;
     const { code, message } = formatFsError(err, "stat-error");
-    return { ok: false, error: buildToolErrorResult(tool, code, message, { path: path4 }) };
+    return { ok: false, error: buildToolErrorResult(tool, code, message, { path }) };
   }
 }
 
@@ -4434,9 +4714,6 @@ function readSeekLanguageForPath(language, searchPath, isFile) {
 async function executeSearch(opts) {
   const { params, signal, cwd, onFileAnchored } = opts;
   const p = params;
-  const ignoredError = validateIgnoredRequiresOthers("search", p);
-  if (ignoredError)
-    return ignoredError;
   const searchPath = resolveToCwd2(p.path ?? ".", cwd);
   const statResult = await statSearchPathOrError("search", p.path, searchPath);
   if (!statResult.ok)
@@ -4446,9 +4723,7 @@ async function executeSearch(opts) {
     const effectiveLang = readSeekLanguageForPath(p.language, searchPath, searchPathIsFile);
     const results = await readSeekSearch(searchPath, p.pattern, {
       language: effectiveLang,
-      cached: p.cached,
-      others: p.others,
-      ignored: p.ignored,
+      gitScope: p.gitScope,
       signal
     });
     if (results.length === 0) {
@@ -4510,8 +4785,8 @@ function registerSearchTool(pi, options = {}) {
     description: SEARCH_PROMPT_METADATA.description,
     promptSnippet: SEARCH_PROMPT_METADATA.promptSnippet,
     promptGuidelines: SEARCH_PROMPT_METADATA.promptGuidelines,
-    parameters: Type5.Object({
-      pattern: Type5.String({ description: PARAM_DESCRIPTIONS.pattern }),
+    parameters: Type6.Object({
+      pattern: Type6.String({ description: PARAM_DESCRIPTIONS.pattern }),
       language: languageParam(),
       path: searchPathParam(),
       ...readSeekGitSearchParams()
@@ -4523,11 +4798,11 @@ function registerSearchTool(pi, options = {}) {
       return renderReadSeekSearchCall(args, theme, rest, {
         label: "search",
         accent: `/${args.pattern}/`,
-        flags: [args.cached && "cached", args.others && "others", args.ignored && "ignored"]
+        flags: [args.gitScope && `git-scope=${args.gitScope}`]
       });
     },
-    renderResult(result, options2, theme, ...rest) {
-      return renderAnchoredFilesResult(result, options2, theme, rest, {
+    renderResult(result, options, theme, ...rest) {
+      return renderAnchoredFilesResult(result, options, theme, rest, {
         pendingLabel: "pending search",
         emptyLabel: "no matches",
         unitSingular: "match",
@@ -4539,7 +4814,7 @@ function registerSearchTool(pi, options = {}) {
 }
 
 // src/refs.ts
-import { Type as Type6 } from "@sinclair/typebox";
+import { Type as Type7 } from "@sinclair/typebox";
 import path5 from "node:path";
 
 // src/refs-output.ts
@@ -4605,9 +4880,6 @@ function isReadSeekCursorValidationFailure(message) {
 async function executeRefs(opts) {
   const { params, signal, cwd, onFileAnchored } = opts;
   const p = params;
-  const ignoredError = validateIgnoredRequiresOthers("refs", p);
-  if (ignoredError)
-    return ignoredError;
   const scopeError = validateRefsNameVsScope(p);
   if (!scopeError.ok) {
     return buildToolErrorResult("refs", "invalid-parameter", `refs parameter: ${scopeError.error}`);
@@ -4623,9 +4895,7 @@ async function executeRefs(opts) {
       line: p.line,
       column: p.column,
       language: p.language,
-      cached: p.cached,
-      others: p.others,
-      ignored: p.ignored,
+      gitScope: p.gitScope,
       signal
     });
     const files = groupReferences(references, cwd);
@@ -4658,13 +4928,13 @@ function registerRefsTool(pi, options = {}) {
     description: REFS_PROMPT_METADATA.description,
     promptSnippet: REFS_PROMPT_METADATA.promptSnippet,
     promptGuidelines: REFS_PROMPT_METADATA.promptGuidelines,
-    parameters: Type6.Object({
-      name: Type6.Optional(Type6.String({ description: PARAM_DESCRIPTIONS.refsName })),
+    parameters: Type7.Object({
+      name: Type7.Optional(Type7.String({ description: PARAM_DESCRIPTIONS.refsName })),
       path: searchPathParam(),
       language: languageParam(),
-      scope: Type6.Optional(Type6.Boolean({ description: PARAM_DESCRIPTIONS.scope })),
-      line: Type6.Optional(Type6.Number({ description: PARAM_DESCRIPTIONS.line })),
-      column: Type6.Optional(Type6.Number({ description: PARAM_DESCRIPTIONS.column })),
+      scope: Type7.Optional(Type7.Boolean({ description: PARAM_DESCRIPTIONS.scope })),
+      line: Type7.Optional(Type7.Number({ description: PARAM_DESCRIPTIONS.line })),
+      column: Type7.Optional(Type7.Number({ description: PARAM_DESCRIPTIONS.column })),
       ...readSeekGitSearchParams()
     }),
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
@@ -4675,11 +4945,11 @@ function registerRefsTool(pi, options = {}) {
       return renderReadSeekSearchCall(args, theme, rest, {
         label: "refs",
         accent,
-        flags: [args.scope && "scope", args.cached && "cached", args.others && "others", args.ignored && "ignored"]
+        flags: [args.scope && "scope", args.gitScope && `git-scope=${args.gitScope}`]
       });
     },
-    renderResult(result, options2, theme, ...rest) {
-      return renderAnchoredFilesResult(result, options2, theme, rest, {
+    renderResult(result, options, theme, ...rest) {
+      return renderAnchoredFilesResult(result, options, theme, rest, {
         pendingLabel: "pending refs",
         emptyLabel: "no references",
         unitSingular: "reference",
@@ -4691,20 +4961,20 @@ function registerRefsTool(pi, options = {}) {
 }
 
 // src/rename.ts
-import { Type as Type7 } from "@sinclair/typebox";
+import { Type as Type8 } from "@sinclair/typebox";
 import path6 from "node:path";
 import { Text as Text5 } from "@earendil-works/pi-tui";
 var RENAME_PROMPT_METADATA = defineToolPromptMetadata({
   promptUrl: new URL("../prompts/rename.md", import.meta.url),
   promptSnippet: "Rename a symbol at a source location with verified edits"
 });
-var renameSchema = Type7.Object({
+var renameSchema = Type8.Object({
   path: filePathParam(),
-  line: Type7.Integer({ minimum: 1, description: PARAM_DESCRIPTIONS.renameLine }),
-  column: Type7.Optional(Type7.Integer({ minimum: 1, description: PARAM_DESCRIPTIONS.column })),
-  to: Type7.String({ description: PARAM_DESCRIPTIONS.to }),
-  workspace: Type7.Optional(Type7.Boolean({ description: PARAM_DESCRIPTIONS.workspace })),
-  apply: Type7.Optional(Type7.Boolean({ description: PARAM_DESCRIPTIONS.applyDefaultTrue }))
+  line: Type8.Integer({ minimum: 1, description: PARAM_DESCRIPTIONS.renameLine }),
+  column: Type8.Optional(Type8.Integer({ minimum: 1, description: PARAM_DESCRIPTIONS.column })),
+  to: Type8.String({ description: PARAM_DESCRIPTIONS.to }),
+  workspace: Type8.Optional(Type8.Boolean({ description: PARAM_DESCRIPTIONS.workspace })),
+  apply: Type8.Optional(Type8.Boolean({ description: PARAM_DESCRIPTIONS.applyDefaultTrue }))
 });
 async function executeRename(opts) {
   const { params, signal, cwd, onFileMutated } = opts;
@@ -4736,7 +5006,8 @@ async function executeRename(opts) {
         onFileMutated?.(absoluteFile);
       }
     }
-    const files = [output.file];
+    const primaryAbs = path6.isAbsolute(output.file) ? output.file : path6.resolve(cwd, output.file);
+    const files = [primaryAbs];
     for (const other of output.others) {
       const abs = path6.isAbsolute(other.file) ? other.file : path6.resolve(cwd, other.file);
       if (!files.includes(abs))
@@ -4796,8 +5067,8 @@ function registerRenameTool(pi, options = {}) {
         text += theme.fg("dim", ` → ${args.to}`);
       return new Text5(clampLineToWidth(text, context.width), 0, 0);
     },
-    renderResult(result, options2, theme, ...rest) {
-      const { isPartial, isError, expanded, cwd, width } = resolveRenderResultContext(options2, rest);
+    renderResult(result, options, theme, ...rest) {
+      const { isPartial, isError, expanded, cwd, width } = resolveRenderResultContext(options, rest);
       if (isPartial)
         return renderPendingResult("pending rename", width, theme);
       const content = result.content?.[0];
@@ -4838,7 +5109,7 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname as dirname2, relative as relative3 } from "node:path";
 import { withFileMutationQueue as withFileMutationQueue2, truncateHead as truncateHead2 } from "@earendil-works/pi-coding-agent";
 import { Text as Text6 } from "@earendil-works/pi-tui";
-import { Type as Type8 } from "@sinclair/typebox";
+import { Type as Type9 } from "@sinclair/typebox";
 
 // src/pending-diff-preview.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2, realpathSync, statSync as statSync4 } from "node:fs";
@@ -4985,9 +5256,9 @@ function pendingWritePreviewParts(summary, preview, expanded, theme) {
   if (!preview || preview.type !== "ok")
     return { lines: summary.split(`
 `) };
-  const hasOldSide2 = preview.data.fileExistedBeforeWrite;
+  const hasOldSide = preview.data.fileExistedBeforeWrite;
   const headerLine = summaryLine(preview.data.headerLabel, { hidden: !expanded });
-  if (!hasOldSide2) {
+  if (!hasOldSide) {
     const lines = [summary, headerLine];
     if (expanded)
       lines.push(...formatContentPreviewLines(preview.data.nextContent, theme));
@@ -5043,7 +5314,7 @@ async function executeWrite(opts) {
   const warnings = [];
   const readSeekWarnings = [];
   if (hasBareCarriageReturn(content)) {
-    const message = "File content contains bare CR (\\r) line endings; readSeek_write refuses to emit anchors that readSeek_digest/readSeek_edit would normalize differently.";
+    const message = "File content contains bare CR (\\r) line endings; readSeek_write refuses to emit anchors that readSeek_inspect/readSeek_edit would normalize differently.";
     warnings.push(message);
     readSeekWarnings.push(buildReadSeekWarning("bare-cr", message));
     return buildToolErrorResult("write", "bare-cr", `Cannot write ${filePath}
@@ -5134,9 +5405,9 @@ function registerWriteTool(pi, options = {}) {
     description: promptMetadata.description,
     promptSnippet: promptMetadata.promptSnippet,
     promptGuidelines: promptMetadata.promptGuidelines,
-    parameters: Type8.Object({
+    parameters: Type9.Object({
       path: filePathParam(),
-      content: Type8.String({ description: PARAM_DESCRIPTIONS.content })
+      content: Type9.String({ description: PARAM_DESCRIPTIONS.content })
     }),
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const cwd = ctx?.cwd ?? process.cwd();
@@ -5174,13 +5445,13 @@ function registerWriteTool(pi, options = {}) {
       }
     },
     renderCall(args, theme, context = {}) {
-      const { path: path7, content } = args;
+      const { path, content } = args;
       const cwd = context.cwd ?? process.cwd();
       const label = renderToolLabel(theme, "write");
       const lineCount = typeof content === "string" ? content.split(`
 `).length : 0;
       const bytes = typeof content === "string" ? Buffer.byteLength(content, "utf8") : 0;
-      const renderedPath = typeof path7 === "string" ? linkToolPath(theme.fg("muted", path7), path7, cwd) : theme.fg("toolOutput", "...");
+      const renderedPath = typeof path === "string" ? linkToolPath(theme.fg("muted", path), path, cwd) : theme.fg("toolOutput", "...");
       let text = clampLineToWidth(`${label} ${renderedPath}${typeof content === "string" ? ` (${lineCount} ${lineCount === 1 ? "line" : "lines"} • ${bytes} B)` : ""}`, context.width);
       if (context.executionStarted) {
         return upsertTextComponent(context.lastComponent, text);
@@ -5195,8 +5466,8 @@ function registerWriteTool(pi, options = {}) {
       return upsertTextComponent(context.lastComponent, clampLinesToWidth(parts.lines, context.width).join(`
 `));
     },
-    renderResult(result, options2, theme, ...rest) {
-      const { isPartial, expanded, width, context } = resolveRenderResultContext(options2, rest, resolveReadSeekToolDisplayMode("write") === "expanded");
+    renderResult(result, options, theme, ...rest) {
+      const { isPartial, expanded, width, context } = resolveRenderResultContext(options, rest, resolveReadSeekToolDisplayMode("write") === "expanded");
       if (isPartial)
         return renderPendingResult("pending write", width, theme);
       const details = result.details ?? {};
@@ -5209,8 +5480,8 @@ function registerWriteTool(pi, options = {}) {
       if (state === "created") {
         const readSeekLines = details.readSeekValue?.lines ?? [];
         const hasContent = readSeekLines.length > 0;
-        const header2 = summaryLine(state, { hidden: hasContent && !expanded, theme, style: "success" });
-        const lines = header2.split(`
+        const header = summaryLine(state, { hidden: hasContent && !expanded, theme, style: "success" });
+        const lines = header.split(`
 `);
         if (expanded && hasContent) {
           const content = readSeekLines.map((l) => l.raw).join(`
@@ -5235,7 +5506,7 @@ function registerWriteTool(pi, options = {}) {
 }
 
 // src/def.ts
-import { Type as Type9 } from "@sinclair/typebox";
+import { Type as Type10 } from "@sinclair/typebox";
 import path7 from "node:path";
 var DEF_PROMPT_METADATA = defineToolPromptMetadata({
   promptUrl: new URL("../prompts/def.md", import.meta.url),
@@ -5244,9 +5515,6 @@ var DEF_PROMPT_METADATA = defineToolPromptMetadata({
 async function executeDef(opts) {
   const { params, signal, cwd, onFileAnchored } = opts;
   const p = params;
-  const ignoredError = validateIgnoredRequiresOthers("def", p);
-  if (ignoredError)
-    return ignoredError;
   if (!p.name || !p.name.trim()) {
     return buildToolErrorResult("def", "invalid-parameter", "readSeek_def requires 'name'");
   }
@@ -5258,9 +5526,7 @@ async function executeDef(opts) {
     const definitions = await readSeekDef(searchPath, {
       name: p.name,
       language: p.language,
-      cached: p.cached,
-      others: p.others,
-      ignored: p.ignored,
+      gitScope: p.gitScope,
       signal
     });
     if (definitions.length === 0) {
@@ -5311,8 +5577,8 @@ function registerDefTool(pi, options = {}) {
     description: DEF_PROMPT_METADATA.description,
     promptSnippet: DEF_PROMPT_METADATA.promptSnippet,
     promptGuidelines: DEF_PROMPT_METADATA.promptGuidelines,
-    parameters: Type9.Object({
-      name: Type9.String({ description: PARAM_DESCRIPTIONS.name }),
+    parameters: Type10.Object({
+      name: Type10.String({ description: PARAM_DESCRIPTIONS.name }),
       path: searchPathParam(),
       language: languageParam(),
       ...readSeekGitSearchParams()
@@ -5324,11 +5590,11 @@ function registerDefTool(pi, options = {}) {
       return renderReadSeekSearchCall(args, theme, rest, {
         label: "def",
         accent: args.name,
-        flags: [args.cached && "cached", args.others && "others", args.ignored && "ignored"]
+        flags: [args.gitScope && `git-scope=${args.gitScope}`]
       });
     },
-    renderResult(result, options2, theme, ...rest) {
-      return renderAnchoredFilesResult(result, options2, theme, rest, {
+    renderResult(result, options, theme, ...rest) {
+      return renderAnchoredFilesResult(result, options, theme, rest, {
         pendingLabel: "pending def",
         emptyLabel: "no definitions",
         unitSingular: "definition",
@@ -5338,38 +5604,33 @@ function registerDefTool(pi, options = {}) {
   });
 }
 
-// src/digest.ts
+// src/inspect.ts
 import { Text as Text7 } from "@earendil-works/pi-tui";
-import { Type as Type10 } from "@sinclair/typebox";
-var DIGEST_FACETS2 = DIGEST_FACETS;
-var facetSchema = Type10.Union(DIGEST_FACETS2.map((facet) => Type10.Literal(facet)));
-var digestSchema = Type10.Object({
+import { Type as Type11 } from "@sinclair/typebox";
+var facetSchema = Type11.Union(INSPECT_FACETS.map((facet) => Type11.Literal(facet)));
+var inspectSchema = Type11.Object({
   path: filePathParam(),
-  select: Type10.Optional(Type10.Union([
+  selector: Type11.Optional(Type11.String({ description: PARAM_DESCRIPTIONS.selector })),
+  select: Type11.Optional(Type11.Union([
     facetSchema,
-    Type10.Array(facetSchema, { minItems: 1 }),
-    Type10.String({
-      description: PARAM_DESCRIPTIONS.selectComma
-    })
-  ], {
-    description: PARAM_DESCRIPTIONS.select
-  })),
-  at: Type10.Optional(Type10.String({
-    description: PARAM_DESCRIPTIONS.at
-  })),
+    Type11.Array(facetSchema, { minItems: 1 }),
+    Type11.String({ description: PARAM_DESCRIPTIONS.selectComma })
+  ], { description: PARAM_DESCRIPTIONS.select })),
+  query: Type11.Optional(Type11.String({ description: PARAM_DESCRIPTIONS.query })),
   end: optionalIntOrString(PARAM_DESCRIPTIONS.end),
   limit: optionalIntOrString(PARAM_DESCRIPTIONS.limit),
-  language: Type10.Optional(Type10.String({ description: PARAM_DESCRIPTIONS.languageOverride })),
-  visionMode: Type10.Optional(Type10.Union(VISION_MODES.map((mode) => Type10.Literal(mode)), { description: PARAM_DESCRIPTIONS.visionModeDigest })),
-  visionLevel: Type10.Optional(Type10.Union(VISION_LEVELS.map((level) => Type10.Literal(level)), { description: PARAM_DESCRIPTIONS.visionLevel }))
+  depth: optionalIntOrString(PARAM_DESCRIPTIONS.inspectDepth),
+  language: Type11.Optional(Type11.String({ description: PARAM_DESCRIPTIONS.languageOverride })),
+  visionMode: Type11.Optional(Type11.Union(VISION_MODES.map((mode) => Type11.Literal(mode)), { description: PARAM_DESCRIPTIONS.visionModeInspect })),
+  visionLevel: Type11.Optional(Type11.Union(VISION_LEVELS.map((level) => Type11.Literal(level)), { description: PARAM_DESCRIPTIONS.visionLevel }))
 });
-function hasDigestAnchors(value) {
+function hasInspectAnchors(value) {
   if (!value || typeof value !== "object")
     return false;
   const record = value;
   if (Array.isArray(record.hashlines) && record.hashlines.length > 0)
     return true;
-  return Object.values(record).some(hasDigestAnchors);
+  return Object.values(record).some(hasInspectAnchors);
 }
 function parseSelect(select) {
   if (select === undefined)
@@ -5379,8 +5640,8 @@ function parseSelect(select) {
     if (facets.length === 0)
       throw new Error("select must include at least one facet");
     for (const facet of facets) {
-      if (!DIGEST_FACETS2.includes(facet)) {
-        throw new Error(`unknown digest facet \`${facet}\`; expected ${DIGEST_FACETS2.join(", ")}`);
+      if (!INSPECT_FACETS.includes(facet)) {
+        throw new Error(`unknown inspect facet \`${facet}\`; expected ${INSPECT_FACETS.join(", ")}`);
       }
     }
     return facets;
@@ -5388,15 +5649,15 @@ function parseSelect(select) {
   if (typeof select !== "string") {
     throw new Error("select must be a facet, facet list, or comma-separated facets");
   }
-  if (DIGEST_FACETS2.includes(select)) {
+  if (INSPECT_FACETS.includes(select)) {
     return select;
   }
   const parts = select.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
   if (parts.length === 0)
     throw new Error("select must include at least one facet");
   for (const part of parts) {
-    if (!DIGEST_FACETS2.includes(part)) {
-      throw new Error(`unknown digest facet \`${part}\`; expected ${DIGEST_FACETS2.join(", ")}`);
+    if (!INSPECT_FACETS.includes(part)) {
+      throw new Error(`unknown inspect facet \`${part}\`; expected ${INSPECT_FACETS.join(", ")}`);
     }
   }
   return parts;
@@ -5408,7 +5669,7 @@ function selectedFacets(select) {
 }
 function summarizeEnvelope(envelope, facets) {
   if (!envelope || typeof envelope !== "object")
-    return `digested ${facets.join(",")}`;
+    return `inspected ${facets.join(",")}`;
   const record = envelope;
   const parts = [];
   for (const facet of facets) {
@@ -5417,7 +5678,7 @@ function summarizeEnvelope(envelope, facets) {
   }
   if (record.metadata !== undefined && !parts.includes("metadata"))
     parts.unshift("metadata");
-  return `digested ${parts.join(",") || "metadata"}`;
+  return `inspected ${parts.join(",") || "metadata"}`;
 }
 function parseImageEnvelope(envelope) {
   if (!envelope || typeof envelope !== "object")
@@ -5435,12 +5696,12 @@ function parseImageEnvelope(envelope) {
   const prepared = content.encoding === "base64" && typeof content.data === "string" && typeof mime === "string" ? { data: content.data, mimeType: mime } : undefined;
   return { metadata, prepared };
 }
-function buildDigestSuccess(filePath, facets, envelope, content = [{ type: "text", text: JSON.stringify(envelope) }]) {
+function buildInspectSuccess(filePath, facets, envelope, content = [{ type: "text", text: JSON.stringify(envelope) }]) {
   return {
     content,
     details: {
       readSeekValue: {
-        tool: "digest",
+        tool: "inspect",
         ok: true,
         path: filePath,
         select: facets,
@@ -5449,14 +5710,14 @@ function buildDigestSuccess(filePath, facets, envelope, content = [{ type: "text
     }
   };
 }
-async function executeDigest(opts) {
+async function executeInspect(opts) {
   const { params, signal, cwd, onFileAnchored } = opts;
   const p = params;
   let select;
   try {
     select = parseSelect(p.select);
   } catch (err) {
-    return buildToolErrorResult("digest", "invalid-parameter", err?.message ?? String(err), {
+    return buildToolErrorResult("inspect", "invalid-parameter", err?.message ?? String(err), {
       path: p.path
     });
   }
@@ -5465,40 +5726,66 @@ async function executeDigest(opts) {
   const end = coerceObviousBase10Int2(p.end, "end");
   if (!end.ok || end.value !== undefined && end.value < 1) {
     const message = end.ok ? `Invalid end: expected a positive integer, received ${end.value}.` : end.message;
-    return buildToolErrorResult("digest", "invalid-parameter", message, { path: p.path });
+    return buildToolErrorResult("inspect", "invalid-parameter", message, { path: p.path });
   }
   const limit = coerceObviousBase10Int2(p.limit, "limit");
   if (!limit.ok || limit.value !== undefined && limit.value < 1) {
     const message = limit.ok ? `Invalid limit: expected a positive integer, received ${limit.value}.` : limit.message;
-    return buildToolErrorResult("digest", "invalid-parameter", message, { path: p.path });
+    return buildToolErrorResult("inspect", "invalid-parameter", message, { path: p.path });
   }
-  const at = typeof p.at === "string" ? p.at.trim() : undefined;
-  if (p.at !== undefined && !at) {
-    return buildToolErrorResult("digest", "invalid-parameter", "Invalid at: expected a non-empty location.", {
-      path: p.path
-    });
+  if (end.value !== undefined && limit.value !== undefined) {
+    return buildToolErrorResult("inspect", "invalid-params-combo", "end and limit cannot be combined.", { path: p.path });
   }
-  if (p.visionLevel !== undefined && p.visionMode === undefined && !appliesImagePolicy) {
-    return buildToolErrorResult("digest", "invalid-params-combo", "visionLevel requires visionMode.", {
-      path: p.path
-    });
+  const depth = coerceObviousBase10Int2(p.depth, "depth");
+  if (!depth.ok || depth.value !== undefined && depth.value < 0) {
+    const message = depth.ok ? `Invalid depth: expected a non-negative integer, received ${depth.value}.` : depth.message;
+    return buildToolErrorResult("inspect", "invalid-parameter", message, { path: p.path });
+  }
+  if (depth.value !== undefined && !facets.includes("map")) {
+    return buildToolErrorResult("inspect", "invalid-parameter", "depth requires the map facet.", { path: p.path });
+  }
+  const selector = typeof p.selector === "string" ? p.selector.trim() : undefined;
+  if (p.selector !== undefined && !selector) {
+    return buildToolErrorResult("inspect", "invalid-parameter", "Invalid selector: expected a non-empty selector.", { path: p.path });
+  }
+  const query = typeof p.query === "string" ? p.query.trim() : undefined;
+  if (p.query !== undefined && !query) {
+    return buildToolErrorResult("inspect", "invalid-parameter", "Invalid query: expected a non-empty query.", { path: p.path });
+  }
+  if (selector !== undefined && query !== undefined) {
+    return buildToolErrorResult("inspect", "invalid-params-combo", "selector and query cannot be combined.", { path: p.path });
+  }
+  if (facets.includes("identity") && selector === undefined) {
+    return buildToolErrorResult("inspect", "invalid-params-combo", "the identity facet requires a selector.", { path: p.path });
+  }
+  if (p.visionLevel !== undefined && (p.visionMode === undefined || p.visionMode === "none") && !appliesImagePolicy) {
+    return buildToolErrorResult("inspect", "invalid-params-combo", "visionLevel requires an analysis visionMode.", { path: p.path });
   }
   const filePath = resolveToCwd2(p.path, cwd);
-  const commonOptions = { select, signal };
-  const textOptions = {
+  const commonOptions = {
+    select,
+    signal,
+    depth: depth.value ?? (facets.includes("map") ? DEFAULT_INSPECT_MAP_DEPTH : undefined)
+  };
+  const selectionOptions = {
     ...commonOptions,
-    at,
+    selector,
+    query,
     end: end.value,
     limit: limit.value,
     language: p.language
   };
-  const hasTextOptions = at !== undefined || end.value !== undefined || limit.value !== undefined || p.language !== undefined;
+  const probeOptions = {
+    ...commonOptions,
+    select: [...new Set(["metadata", ...facets])].filter((facet) => facet !== "identity")
+  };
+  const hasSelectionOptions = selector !== undefined || query !== undefined || end.value !== undefined || limit.value !== undefined || p.language !== undefined;
   const hasVisionOptions = p.visionMode !== undefined || p.visionLevel !== undefined;
   const initialVisionMode = appliesImagePolicy ? undefined : p.visionMode;
   const initialVisionLevel = appliesImagePolicy ? undefined : p.visionLevel;
   try {
-    const envelope = await readSeekDigestNative(filePath, {
-      ...appliesImagePolicy ? commonOptions : textOptions,
+    const envelope = await readSeekInspect(filePath, {
+      ...appliesImagePolicy ? probeOptions : selectionOptions,
       visionMode: initialVisionMode,
       visionLevel: initialVisionLevel,
       vision: initialVisionMode !== undefined && initialVisionMode !== "none"
@@ -5507,60 +5794,60 @@ async function executeDigest(opts) {
     if (image) {
       const imageDetails = { metadata: image.metadata };
       if (opts.imageMode === "off") {
-        return buildDigestSuccess(filePath, facets, imageDetails, [
+        return buildInspectSuccess(filePath, facets, imageDetails, [
           { type: "text", text: `[Skipped standalone image: ${p.path}; readseek.imageMode is off]` }
         ]);
       }
       if (opts.imageMode === "auto" && opts.modelSupportsImages && image.prepared) {
-        return buildDigestSuccess(filePath, facets, imageDetails, [
+        return buildInspectSuccess(filePath, facets, imageDetails, [
           { type: "image", data: image.prepared.data, mimeType: image.prepared.mimeType }
         ]);
       }
       const visionMode = p.visionMode && p.visionMode !== "none" ? p.visionMode : "all";
-      const analyzedEnvelope = await readSeekDigestNative(filePath, {
+      const analyzedEnvelope = await readSeekInspect(filePath, {
         ...commonOptions,
         visionMode,
         visionLevel: p.visionLevel,
         vision: true
       });
-      return buildDigestSuccess(filePath, facets, analyzedEnvelope);
+      return buildInspectSuccess(filePath, facets, analyzedEnvelope);
     }
-    if (p.visionLevel !== undefined && p.visionMode === undefined) {
-      return buildToolErrorResult("digest", "invalid-params-combo", "visionLevel requires visionMode.", {
+    if (p.visionLevel !== undefined && (p.visionMode === undefined || p.visionMode === "none")) {
+      return buildToolErrorResult("inspect", "invalid-params-combo", "visionLevel requires an analysis visionMode.", {
         path: p.path
       });
     }
-    const textEnvelope = appliesImagePolicy && (hasTextOptions || hasVisionOptions) ? await readSeekDigestNative(filePath, {
-      ...textOptions,
+    const selectedEnvelope = appliesImagePolicy && (hasSelectionOptions || hasVisionOptions) ? await readSeekInspect(filePath, {
+      ...selectionOptions,
       visionMode: p.visionMode,
       visionLevel: p.visionLevel,
       vision: p.visionMode !== undefined && p.visionMode !== "none"
     }) : envelope;
-    if (hasDigestAnchors(textEnvelope))
+    if (hasInspectAnchors(selectedEnvelope))
       onFileAnchored?.(filePath);
-    return buildDigestSuccess(filePath, facets, textEnvelope);
+    return buildInspectSuccess(filePath, facets, selectedEnvelope);
   } catch (err) {
     const failure = classifyReadSeekFailure(err);
-    return buildToolErrorResult("digest", failure.code, failure.message, failure.hint ? { hint: failure.hint } : {});
+    return buildToolErrorResult("inspect", failure.code, failure.message, failure.hint ? { hint: failure.hint } : {});
   }
 }
-function registerDigestTool(pi, options = {}) {
+function registerInspectTool(pi, options = {}) {
   const promptMetadata = defineToolPromptMetadata({
-    promptUrl: new URL("../prompts/digest.md", import.meta.url),
-    promptSnippet: "Digest source facets as a native CLI envelope",
-    registeredName: options.name ?? "readSeek_digest",
+    promptUrl: new URL("../prompts/inspect.md", import.meta.url),
+    promptSnippet: "Inspect source, images, and documents",
+    registeredName: options.name ?? "readSeek_inspect",
     toolAliases: options.toolAliases
   });
   return registerReadSeekTool(pi, {
-    name: options.name ?? "readSeek_digest",
-    label: "Digest",
+    name: options.name ?? "readSeek_inspect",
+    label: "Inspect",
     description: promptMetadata.description,
     promptSnippet: promptMetadata.promptSnippet,
     toolAliases: options.toolAliases,
     promptGuidelines: promptMetadata.promptGuidelines,
-    parameters: digestSchema,
+    parameters: inspectSchema,
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-      return executeDigest({
+      return executeInspect({
         params,
         signal,
         cwd: ctx.cwd,
@@ -5573,23 +5860,23 @@ function registerDigestTool(pi, options = {}) {
       const context = rest[0] ?? {};
       const cwd = context.cwd ?? process.cwd();
       const displayPath = typeof args?.path === "string" ? args.path : "?";
-      let text = theme.fg("toolTitle", theme.bold("digest"));
+      let text = theme.fg("toolTitle", theme.bold("inspect"));
       text += ` ${linkToolPath(theme.fg("accent", displayPath), displayPath, cwd)}`;
       if (args?.select !== undefined) {
         const select = Array.isArray(args.select) ? args.select.join(",") : String(args.select);
         text += theme.fg("dim", ` [${select}]`);
       }
-      if (typeof args?.at === "string" && args.at)
-        text += theme.fg("dim", ` @ ${args.at}`);
+      if (typeof args?.selector === "string" && args.selector)
+        text += theme.fg("dim", ` @ ${args.selector}`);
       return new Text7(clampLineToWidth(text, context.width), 0, 0);
     },
-    renderResult(result, options2, theme, ...rest) {
-      const { isPartial, isError, expanded, width } = resolveRenderResultContext(options2, rest);
+    renderResult(result, options, theme, ...rest) {
+      const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
       if (isPartial)
-        return renderPendingResult("pending digest", width, theme);
+        return renderPendingResult("pending inspect", width, theme);
       const textContent = result.content?.[0]?.type === "text" ? result.content[0].text : "";
       if (isError || result.isError) {
-        return renderErrorResult(textContent, { expanded, width, fallback: "digest failed", theme });
+        return renderErrorResult(textContent, { expanded, width, fallback: "inspect failed", theme });
       }
       const value = result.details?.readSeekValue;
       const facets = Array.isArray(value?.select) ? value.select : ["content"];
@@ -5605,131 +5892,88 @@ ${textContent}`;
   });
 }
 
-// src/view.ts
-import {
-  DEFAULT_MAX_BYTES as DEFAULT_MAX_BYTES2,
-  DEFAULT_MAX_LINES as DEFAULT_MAX_LINES2,
-  truncateHead as truncateHead3
-} from "@earendil-works/pi-coding-agent";
+// src/extract.ts
 import { Text as Text8 } from "@earendil-works/pi-tui";
-import { Type as Type11 } from "@sinclair/typebox";
-var NODE_KINDS = DOCUMENT_NODE_KINDS;
-var VIEW_PROMPT_METADATA = defineToolPromptMetadata({
-  promptUrl: new URL("../prompts/view.md", import.meta.url),
-  promptSnippet: "Digest a document's structure or selected content"
+import { Type as Type12 } from "@sinclair/typebox";
+var EXTRACT_PROMPT_METADATA = defineToolPromptMetadata({
+  promptUrl: new URL("../prompts/extract.md", import.meta.url),
+  promptSnippet: "Extract a selected document asset to a file"
 });
-async function executeView(opts) {
-  const { params, signal, cwd } = opts;
-  const input = params;
-  const page = coerceObviousBase10Int2(input.page, "page");
-  if (!page.ok || page.value !== undefined && page.value < 1) {
-    const message = page.ok ? `Invalid page: expected a positive integer, received ${page.value}.` : page.message;
-    return buildToolErrorResult("view", "invalid-page", message, { path: input.path });
-  }
-  const depth = coerceObviousBase10Int2(input.depth, "depth");
-  if (!depth.ok || depth.value !== undefined && depth.value < 0) {
-    const message = depth.ok ? `Invalid depth: expected a non-negative integer, received ${depth.value}.` : depth.message;
-    return buildToolErrorResult("view", "invalid-depth", message, { path: input.path });
-  }
-  const node = input.node?.trim();
-  if (input.node !== undefined && !node) {
-    return buildToolErrorResult("view", "invalid-node", "Invalid node: expected a non-empty ID.", {
+async function executeExtract(opts) {
+  const { signal, cwd, onFileMutated } = opts;
+  const input = opts.params;
+  const selector = typeof input.selector === "string" ? input.selector.trim() : "";
+  if (!selector.startsWith("asset:") || selector === "asset:") {
+    return buildToolErrorResult("extract", "invalid-selector", "selector must identify an asset as asset:ID.", {
       path: input.path
     });
   }
-  const visionValidation = validateVisionLevelVsMode({
-    outline: input.outline,
-    visionMode: input.visionMode,
-    visionLevel: input.visionLevel
-  });
-  if (!visionValidation.ok) {
-    return buildToolErrorResult("view", "invalid-params-combo", `${visionValidation.error}.`, {
+  const output = typeof input.output === "string" ? input.output.trim() : "";
+  if (!output || output === "-") {
+    return buildToolErrorResult("extract", "invalid-output", "output must be a file path, not stdout.", {
       path: input.path
     });
   }
   const filePath = resolveToCwd2(input.path, cwd);
+  const outputPath = resolveToCwd2(output, cwd);
   try {
-    const output = await readSeekView(filePath, {
-      node,
-      page: page.value,
-      kind: input.kind,
-      depth: depth.value,
-      outline: input.outline,
-      visionMode: input.visionMode,
-      visionLevel: input.visionLevel,
-      signal
-    });
-    const truncation = truncateHead3(output, {
-      maxLines: DEFAULT_MAX_LINES2,
-      maxBytes: DEFAULT_MAX_BYTES2
-    });
-    const notice = truncation.truncated ? `
-[… document view truncated; narrow it with page, node, kind, or depth]` : "";
+    await readSeekExtract(filePath, selector, outputPath, { signal, cancelable: false });
+    onFileMutated?.(outputPath);
     return {
-      content: [{ type: "text", text: `${truncation.content}${notice}` }],
+      content: [{ type: "text", text: `Extracted ${selector} to ${outputPath}` }],
       details: {
         readSeekValue: {
-          tool: "view",
+          tool: "extract",
+          ok: true,
           path: filePath,
-          truncated: truncation.truncated
+          selector,
+          output: outputPath
         }
       }
     };
   } catch (error) {
     const failure = classifyReadSeekFailure(error);
-    return buildToolErrorResult("view", failure.code, failure.message, failure.hint ? { hint: failure.hint } : {});
+    return buildToolErrorResult("extract", failure.code, failure.message, failure.hint ? { hint: failure.hint } : {});
   }
 }
-function registerViewTool(pi) {
+function registerExtractTool(pi, options = {}) {
   return registerReadSeekTool(pi, {
-    name: "readSeek_view",
-    label: "View",
-    description: VIEW_PROMPT_METADATA.description,
-    promptSnippet: VIEW_PROMPT_METADATA.promptSnippet,
-    promptGuidelines: VIEW_PROMPT_METADATA.promptGuidelines,
-    parameters: Type11.Object({
+    name: "readSeek_extract",
+    label: "Extract",
+    ...EXTRACT_PROMPT_METADATA,
+    parameters: Type12.Object({
       path: filePathParam(),
-      node: Type11.Optional(Type11.String({ description: PARAM_DESCRIPTIONS.node })),
-      page: optionalIntOrString(PARAM_DESCRIPTIONS.page),
-      kind: Type11.Optional(Type11.Union(NODE_KINDS.map((kind) => Type11.Literal(kind)), {
-        description: PARAM_DESCRIPTIONS.kind
-      })),
-      depth: optionalIntOrString(PARAM_DESCRIPTIONS.depth),
-      visionMode: Type11.Optional(Type11.Union(VISION_ANALYSIS_MODES.map((mode) => Type11.Literal(mode)), { description: PARAM_DESCRIPTIONS.visionModeView })),
-      visionLevel: Type11.Optional(Type11.Union(VISION_LEVELS.map((level) => Type11.Literal(level)), { description: PARAM_DESCRIPTIONS.visionLevel })),
-      outline: Type11.Optional(Type11.Boolean({ description: PARAM_DESCRIPTIONS.outline }))
+      selector: Type12.String({ pattern: "^asset:.+", description: PARAM_DESCRIPTIONS.assetSelector }),
+      output: Type12.String({ minLength: 1, pattern: "^(?!-$).+", description: PARAM_DESCRIPTIONS.output })
     }),
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-      return executeView({ params, signal, cwd: ctx.cwd });
+      return executeExtract({
+        params,
+        signal,
+        cwd: ctx.cwd,
+        onFileMutated: options.onFileMutated
+      });
     },
     renderCall(args, theme, ...rest) {
       const context = rest[0] ?? {};
       const cwd = context.cwd ?? process.cwd();
       const displayPath = typeof args?.path === "string" ? args.path : "?";
-      const text = `${theme.fg("toolTitle", theme.bold("view"))} ${linkToolPath(theme.fg("accent", displayPath), displayPath, cwd)}`;
+      const output = typeof args?.output === "string" ? args.output : "?";
+      let text = `${theme.fg("toolTitle", theme.bold("extract"))} ${linkToolPath(theme.fg("accent", displayPath), displayPath, cwd)}`;
+      if (typeof args?.selector === "string")
+        text += theme.fg("dim", ` ${args.selector}`);
+      text += theme.fg("dim", ` → ${output}`);
       return new Text8(clampLineToWidth(text, context.width), 0, 0);
     },
     renderResult(result, options, theme, ...rest) {
-      const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
+      const { isPartial, isError, width } = resolveRenderResultContext(options, rest);
       if (isPartial)
-        return renderPendingResult("pending view", width, theme);
+        return renderPendingResult("pending extract", width, theme);
       const textContent = result.content?.[0]?.type === "text" ? result.content[0].text : "";
       if (isError || result.isError) {
-        return renderErrorResult(textContent, { expanded, width, fallback: "view failed", theme });
+        return renderErrorResult(textContent, { expanded: false, width, fallback: "extract failed", theme });
       }
-      const lines = textContent.split(`
-`).filter(Boolean).length;
-      let text = summaryLine(`loaded ${lines} document ${lines === 1 ? "line" : "lines"}`, {
-        hidden: !!textContent && !expanded,
-        theme,
-        style: "success"
-      });
-      if (expanded && textContent)
-        text += `
-${textContent}`;
-      return new Text8(clampLinesToWidth(text.split(`
-`), width).join(`
-`), 0, 0);
+      return new Text8(clampLineToWidth(summaryLine(textContent || "asset extracted", { theme, style: "success" }), width), 0, 0);
     }
   });
 }
@@ -5760,32 +6004,20 @@ 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_view" }
+  { builtIn: "read", readSeekName: "readSeek_inspect" },
+  { builtIn: null, readSeekName: "readSeek_extract" }
 ];
-function formatSettingsWarning(warning) {
-  return `${warning.message} (${warning.source})`;
-}
-function toolRoutingPolicy(aliases) {
-  return renderToolRoutingPolicy({
-    aliases,
-    title: "ReadSeek tool policy:"
-  });
-}
 function piReadSeekExtension(pi) {
   const sessionAnchors = new SessionAnchors;
-  const markAnchored = (absolutePath) => sessionAnchors.markAnchored(absolutePath);
-  const hasFreshAnchors = (absolutePath) => sessionAnchors.hasFreshAnchors(absolutePath);
-  const forgetAnchors = (absolutePath) => sessionAnchors.forget(absolutePath);
   const { settings } = resolveReadSeekJsonSettings();
   const replacedBuiltIns = new Set(settings.overrideTools ?? []);
   const swap = (builtIn, readSeekName) => replacedBuiltIns.has(builtIn) ? builtIn : readSeekName;
-  const readName = swap("read", "readSeek_digest");
+  const readName = swap("read", "readSeek_inspect");
   const editName = swap("edit", "readSeek_edit");
   const writeName = swap("write", "readSeek_write");
   const grepName = swap("grep", "readSeek_grep");
   const toolAliases = {
-    readSeek_digest: readName,
+    readSeek_inspect: readName,
     readSeek_edit: editName,
     readSeek_grep: grepName,
     readSeek_write: writeName
@@ -5794,20 +6026,33 @@ function piReadSeekExtension(pi) {
     const readSeekName = `readSeek_${name}`;
     return [name, toolAliases[readSeekName] ?? readSeekName];
   }));
-  registerEditTool(pi, { wasReadInSession: hasFreshAnchors, onFileMutated: forgetAnchors, name: editName, toolAliases });
-  registerGrepTool(pi, { onFileAnchored: markAnchored, name: grepName });
-  registerSearchTool(pi, { onFileAnchored: markAnchored });
-  registerRefsTool(pi, { onFileAnchored: markAnchored });
-  registerRenameTool(pi, { onFileMutated: forgetAnchors });
-  registerDefTool(pi, { onFileAnchored: markAnchored });
-  registerDigestTool(pi, {
-    onFileAnchored: markAnchored,
+  registerEditTool(pi, {
+    wasReadInSession: (absolutePath) => sessionAnchors.hasFreshAnchors(absolutePath),
+    onFileMutated: (absolutePath) => sessionAnchors.forget(absolutePath),
+    name: editName,
+    toolAliases
+  });
+  registerGrepTool(pi, {
+    onFileAnchored: (absolutePath) => sessionAnchors.markAnchored(absolutePath),
+    name: grepName
+  });
+  registerSearchTool(pi, { onFileAnchored: (absolutePath) => sessionAnchors.markAnchored(absolutePath) });
+  registerRefsTool(pi, { onFileAnchored: (absolutePath) => sessionAnchors.markAnchored(absolutePath) });
+  registerRenameTool(pi, { onFileMutated: (absolutePath) => sessionAnchors.forget(absolutePath) });
+  registerDefTool(pi, { onFileAnchored: (absolutePath) => sessionAnchors.markAnchored(absolutePath) });
+  registerInspectTool(pi, {
+    onFileAnchored: (absolutePath) => sessionAnchors.markAnchored(absolutePath),
     name: readName,
     toolAliases,
     imageMode: replacedBuiltIns.has("read") ? resolveReadSeekImageMode() : undefined
   });
-  registerViewTool(pi);
-  registerWriteTool(pi, { onFileAnchored: markAnchored, name: writeName });
+  registerExtractTool(pi, {
+    onFileMutated: (absolutePath) => sessionAnchors.forget(absolutePath)
+  });
+  registerWriteTool(pi, {
+    onFileAnchored: (absolutePath) => sessionAnchors.markAnchored(absolutePath),
+    name: writeName
+  });
   const activeReadSeekNames = READSEEK_TOOL_ENTRIES.map((entry) => entry.builtIn && replacedBuiltIns.has(entry.builtIn) ? entry.builtIn : entry.readSeekName);
   const inactiveReadSeekNames = new Set(READSEEK_TOOL_ENTRIES.filter((entry) => entry.builtIn !== null && replacedBuiltIns.has(entry.builtIn)).map((entry) => entry.readSeekName));
   const activateReadSeekTools = () => {
@@ -5827,14 +6072,16 @@ function piReadSeekExtension(pi) {
   pi.on("before_agent_start", (event) => {
     if (!activateReadSeekTools())
       return;
-    return { systemPrompt: `${event.systemPrompt}
+    return {
+      systemPrompt: `${event.systemPrompt}
 
-${toolRoutingPolicy(policyAliases)}` };
+${renderToolRoutingPolicy({ aliases: policyAliases, title: "ReadSeek tool policy:" })}`
+    };
   });
   pi.on("session_start", (_event, ctx) => {
     sessionAnchors.clear();
     const { warnings } = resolveReadSeekJsonSettings();
-    const problems = warnings.map(formatSettingsWarning);
+    const problems = warnings.map((warning) => `${warning.message} (${warning.source})`);
     const availability = readSeekBinaryAvailability();
     if (!availability.available) {
       problems.push(`readseek installation is broken: ${availability.reason}`);