pi-readseek 0.10.6 → 0.11.0

package/dist/index.ts

@@ -6,14 +6,6 @@ import { Type as Type3 } from "@sinclair/typebox";
 import { Text as Text3 } from "@earendil-works/pi-tui";
 
 // ../readseek-api/src/contract.ts
-var INSPECT_FACETS = [
-  "metadata",
-  "content",
-  "map",
-  "diagnostics",
-  "identity"
-];
-var VISION_MODES = ["none", "all", "ocr", "caption", "objects"];
 var VISION_LEVELS = ["low", "medium", "high"];
 var EDIT_VARIANTS = [
   "set_line",
@@ -24,15 +16,22 @@ var EDIT_VARIANTS = [
 ];
 var GIT_SCOPES = ["tracked", "untracked", "ignored", "all"];
 var TOOL_NAMES = [
-  "inspect",
-  "edit",
-  "write",
-  "grep",
-  "extract",
-  "search",
-  "def",
-  "refs",
-  "rename"
+  "show_content",
+  "show_structure",
+  "show_metadata",
+  "show_assets",
+  "check_syntax",
+  "check_rules",
+  "generate_caption",
+  "detect_objects",
+  "recognize_text",
+  "find_nodes",
+  "find_text",
+  "find_definitions",
+  "find_references",
+  "edit_text",
+  "rename_symbol",
+  "write_file"
 ];
 var PARAM_DESCRIPTIONS = {
   path: "Absolute or relative file path",
@@ -43,31 +42,30 @@ var PARAM_DESCRIPTIONS = {
   languageOverride: "Language override",
   languageSymbol: "Language override for symbol replacement",
   pattern: "AST pattern (ast-grep style), such as console.log($$$ARGS)",
+  patternContext: "Surrounding code context for sub-statement patterns",
+  selector: "Target AST node kind to extract from pattern context",
   grepPattern: "Regex pattern; set literal for exact text",
   name: "Qualified or unqualified symbol name",
   refsName: "Identifier to find references for",
-  scope: "Restrict results to the binding at the cursor",
-  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",
   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",
-  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",
+  at: "Location selector: line:N[:COLUMN], hash:H[:COLUMN], symbol:NAME, page:N, node:ID, or asset:ID",
+  assetAt: "Document selector: page:N, node:ID, or asset:ID",
+  rule: "KDL node selection rule, @path, or '-' for standard input",
+  rules: "KDL structural checks, @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",
+  depth: "Maximum structural depth for structure 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.",
-  visionModeInspect: "Standalone image mode: none, all, caption, objects, or ocr",
-  visionLevel: "Vision inference level: low (default), medium, or high",
-  output: "Destination file for extracted binary data; stdout is not supported",
+  level: "Explicit inference level: low (default), medium, or high",
+  include: "Additional caption tasks: text and/or objects",
+  kind: "Restrict structure to this node kind",
+  outline: "Return a symbol outline",
+  noAnchors: "Omit source line anchors",
+  text: "Literal native text query; adapter find_text also supports regex via pattern",
   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":"..."}}',
@@ -104,15 +102,22 @@ var PARAM_DESCRIPTIONS = {
   scopeContext: "Context lines within each symbol"
 };
 var TOOL_DESCRIPTIONS = {
-  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.",
-  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.",
-  rename: "Rename a symbol at a source location. Resolvable same-named bindings are preserved; verified edits apply by default. Set `apply: false` to preview the plan before changing files."
+  show_content: "Read source, document content, or image descriptors without inference. Obtain fresh `LINE:HASH` anchors before edits; use at with a column for cursor context. Document results include typed nodes and cached asset paths.",
+  show_structure: "Show parsed source or document hierarchy. Use shallow depth for file overviews.",
+  show_metadata: "Show format, source identity, language, dimensions, or page count without decoding image content or inference.",
+  show_assets: "Return selected document asset descriptors with usable cached paths. Adapters attach images from those paths.",
+  check_syntax: "Check parser syntax diagnostics. Exit 0 is clean, 1 has findings, 2 is failure; this is not type checking.",
+  check_rules: "Evaluate KDL structural assertions. Exit 0 is clean, 1 has findings, 2 is failure.",
+  generate_caption: "Explicitly infer a caption using an installed model. Include text and objects to request OCR and detection too; never downloads models automatically.",
+  detect_objects: "Explicitly infer object labels and bounding boxes using an installed model.",
+  recognize_text: "Explicitly recognize text from pixels using an installed model; reading never silently invokes OCR.",
+  find_nodes: "Find AST nodes by pattern or KDL selection rule. Returns edit-ready anchors. Use `find_text` for text and regex.",
+  find_text: "Search text or regex and return edit-ready `LINE:HASH` anchors. Native CLI text is literal; adapters preserve regex, glob, context, summary, and symbol grouping.",
+  find_definitions: "Find a symbol definition or declaration by qualified or unqualified name.",
+  find_references: "Find identifier-name matches with name, or binding-scoped references with at. Use before renaming or deleting a symbol.",
+  edit_text: "Edit existing files with fresh `LINE:HASH` anchors. Each edits item contains exactly one set_line, replace_lines, insert_after, replace_symbol, or replace object. Preview before applying a verified plan.",
+  rename_symbol: "Rename a symbol at a line or hash cursor with binding-aware edits and stale-plan protection.",
+  write_file: "Create or replace a complete text file and return `LINE:HASH` anchors. Use `edit_text` for small changes."
 };
 function renderToolDescription(name, aliases = {}) {
   const desc = TOOL_DESCRIPTIONS[name];
@@ -188,244 +193,84 @@ var editItemSchema = {
   },
   description: PARAM_DESCRIPTIONS.editVariant
 };
+var string = (description) => ({ type: "string", description });
+var integer = (description, minimum = 1) => ({ type: "integer", minimum, description });
+var path = { path: string(PARAM_DESCRIPTIONS.path) };
+var at = { at: string(PARAM_DESCRIPTIONS.at) };
+var lang = { language: string(PARAM_DESCRIPTIONS.language) };
+var stdin = { stdinName: string(PARAM_DESCRIPTIONS.stdinName) };
+var noAnchors = { noAnchors: { type: "boolean", description: PARAM_DESCRIPTIONS.noAnchors } };
+var level = { level: { type: "string", enum: VISION_LEVELS, description: PARAM_DESCRIPTIONS.level } };
+var limit = { limit: integer(PARAM_DESCRIPTIONS.matchLimit) };
+var apply = { apply: { type: "boolean", description: PARAM_DESCRIPTIONS.apply }, planHash: string(PARAM_DESCRIPTIONS.planHash) };
+function tool(name, title, properties, required) {
+  return { name, title, description: TOOL_DESCRIPTIONS[name], inputSchema: { type: "object", properties, required, additionalProperties: false } };
+}
 var TOOL_CONTRACTS = [
-  {
-    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 },
-        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.visionModeInspect
-        },
-        visionLevel: {
-          type: "string",
-          enum: [...VISION_LEVELS],
-          description: PARAM_DESCRIPTIONS.visionLevel
-        },
-        stdinName: { type: "string", description: PARAM_DESCRIPTIONS.stdinName }
-      },
-      required: ["path"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "edit",
-    title: "Hash-verified edit",
-    description: TOOL_DESCRIPTIONS.edit,
-    inputSchema: {
-      type: "object",
-      properties: {
-        path: { type: "string", description: PARAM_DESCRIPTIONS.path },
-        edits: {
-          type: "array",
-          minItems: 1,
-          description: PARAM_DESCRIPTIONS.edits,
-          items: editItemSchema
-        },
-        language: { type: "string", description: PARAM_DESCRIPTIONS.languageSymbol },
-        apply: { type: "boolean", description: PARAM_DESCRIPTIONS.apply },
-        planHash: { type: "string", description: PARAM_DESCRIPTIONS.planHash },
-        postEditVerify: { type: "boolean", description: PARAM_DESCRIPTIONS.postEditVerify }
-      },
-      required: ["path", "edits"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "write",
-    title: "Write file",
-    description: TOOL_DESCRIPTIONS.write,
-    inputSchema: {
-      type: "object",
-      properties: {
-        path: { type: "string", description: PARAM_DESCRIPTIONS.path },
-        content: { type: "string", description: PARAM_DESCRIPTIONS.content }
-      },
-      required: ["path", "content"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "grep",
-    title: "Text search",
-    description: TOOL_DESCRIPTIONS.grep,
-    inputSchema: {
-      type: "object",
-      properties: {
-        pattern: { type: "string", description: PARAM_DESCRIPTIONS.grepPattern },
-        path: { type: "string", description: PARAM_DESCRIPTIONS.searchPath },
-        glob: { type: "string", description: PARAM_DESCRIPTIONS.glob },
-        ignoreCase: { type: "boolean", description: PARAM_DESCRIPTIONS.ignoreCase },
-        literal: { type: "boolean", description: PARAM_DESCRIPTIONS.literal },
-        context: { type: "integer", minimum: 0, description: PARAM_DESCRIPTIONS.context },
-        limit: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.matchLimit },
-        summary: { type: "boolean", description: PARAM_DESCRIPTIONS.summary },
-        scope: {
-          type: "string",
-          enum: ["symbol"],
-          description: PARAM_DESCRIPTIONS.grepScope
-        },
-        scopeContext: {
-          type: "integer",
-          minimum: 0,
-          description: PARAM_DESCRIPTIONS.scopeContext
-        }
-      },
-      required: ["pattern"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "extract",
-    title: "Extract asset",
-    description: TOOL_DESCRIPTIONS.extract,
-    inputSchema: {
-      type: "object",
-      properties: {
-        path: { type: "string", description: PARAM_DESCRIPTIONS.path },
-        selector: {
-          type: "string",
-          pattern: "^asset:.+",
-          description: PARAM_DESCRIPTIONS.assetSelector
-        },
-        output: {
-          type: "string",
-          minLength: 1,
-          pattern: "^(?!-$).+",
-          description: PARAM_DESCRIPTIONS.output
-        },
-        stdinName: { type: "string", description: PARAM_DESCRIPTIONS.stdinName }
-      },
-      required: ["path", "selector", "output"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "search",
-    title: "AST search",
-    description: TOOL_DESCRIPTIONS.search,
-    inputSchema: {
-      type: "object",
-      properties: {
-        pattern: { type: "string", description: PARAM_DESCRIPTIONS.pattern },
-        path: { type: "string", description: PARAM_DESCRIPTIONS.searchPath },
-        language: { type: "string", description: PARAM_DESCRIPTIONS.language },
-        limit: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.matchLimit },
-        ...gitScopeSchema
-      },
-      required: ["pattern"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "def",
-    title: "Find definition",
-    description: TOOL_DESCRIPTIONS.def,
-    inputSchema: {
-      type: "object",
-      properties: {
-        name: { type: "string", description: PARAM_DESCRIPTIONS.name },
-        path: { type: "string", description: PARAM_DESCRIPTIONS.searchPath },
-        language: { type: "string", description: PARAM_DESCRIPTIONS.language },
-        ...gitScopeSchema
-      },
-      required: ["name"],
-      additionalProperties: false
-    }
-  },
-  {
-    name: "refs",
-    title: "Find references",
-    description: TOOL_DESCRIPTIONS.refs,
-    inputSchema: {
-      type: "object",
-      properties: {
-        name: { type: "string", description: PARAM_DESCRIPTIONS.refsName },
-        path: { type: "string", description: PARAM_DESCRIPTIONS.searchPath },
-        language: { type: "string", description: PARAM_DESCRIPTIONS.language },
-        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 },
-        ...gitScopeSchema
-      },
-      additionalProperties: false
-    }
-  },
-  {
-    name: "rename",
-    title: "Rename symbol",
-    description: TOOL_DESCRIPTIONS.rename,
-    inputSchema: {
-      type: "object",
-      properties: {
-        path: { type: "string", description: PARAM_DESCRIPTIONS.path },
-        line: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.renameLine },
-        column: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.column },
-        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 },
-        language: { type: "string", description: PARAM_DESCRIPTIONS.language },
-        ...gitScopeSchema
-      },
-      required: ["path", "line", "to"],
-      additionalProperties: false
-    }
-  }
+  tool("show_content", "Show content", { ...path, ...at, ...lang, ...stdin, ...noAnchors, end: integer(PARAM_DESCRIPTIONS.end), limit: integer(PARAM_DESCRIPTIONS.limit) }, ["path"]),
+  tool("show_structure", "Show structure", { ...path, ...at, ...lang, ...stdin, depth: integer(PARAM_DESCRIPTIONS.depth, 0), kind: string(PARAM_DESCRIPTIONS.kind), outline: { type: "boolean", description: PARAM_DESCRIPTIONS.outline } }, ["path"]),
+  tool("show_metadata", "Show metadata", { ...path, ...lang, ...stdin }, ["path"]),
+  tool("show_assets", "Show assets", { ...path, at: string(PARAM_DESCRIPTIONS.assetAt), ...stdin }, ["path"]),
+  tool("check_syntax", "Check syntax", { ...path, ...lang, ...stdin }, ["path"]),
+  tool("check_rules", "Check rules", { ...path, ...gitScopeSchema, rules: string(PARAM_DESCRIPTIONS.rules) }, ["rules"]),
+  tool("generate_caption", "Generate caption", { ...path, ...at, ...stdin, ...level, include: { type: "array", items: { type: "string", enum: ["text", "objects"] }, minItems: 1, uniqueItems: true, description: PARAM_DESCRIPTIONS.include } }, ["path"]),
+  tool("detect_objects", "Detect objects", { ...path, ...at, ...stdin, ...level }, ["path"]),
+  tool("recognize_text", "Recognize text", { ...path, ...at, ...stdin, ...level }, ["path"]),
+  tool("find_nodes", "Find nodes", { ...path, ...lang, ...stdin, ...limit, ...gitScopeSchema, ...noAnchors, pattern: string(PARAM_DESCRIPTIONS.pattern), context: string(PARAM_DESCRIPTIONS.patternContext), selector: string(PARAM_DESCRIPTIONS.selector), rule: string(PARAM_DESCRIPTIONS.rule) }, []),
+  tool("find_text", "Find text", { ...path, ...limit, ...gitScopeSchema, text: string(PARAM_DESCRIPTIONS.text), pattern: string(PARAM_DESCRIPTIONS.grepPattern), glob: string(PARAM_DESCRIPTIONS.glob), ignoreCase: { type: "boolean", description: PARAM_DESCRIPTIONS.ignoreCase }, literal: { type: "boolean", description: PARAM_DESCRIPTIONS.literal }, context: integer(PARAM_DESCRIPTIONS.context, 0), summary: { type: "boolean", description: PARAM_DESCRIPTIONS.summary }, scope: { type: "string", enum: ["symbol"], description: PARAM_DESCRIPTIONS.grepScope }, scopeContext: integer(PARAM_DESCRIPTIONS.scopeContext, 0) }, []),
+  tool("find_definitions", "Find definitions", { ...path, ...lang, ...gitScopeSchema, ...noAnchors, name: string(PARAM_DESCRIPTIONS.name) }, ["name"]),
+  tool("find_references", "Find references", { ...path, ...at, ...lang, ...gitScopeSchema, ...noAnchors, name: string(PARAM_DESCRIPTIONS.refsName) }, []),
+  tool("edit_text", "Hash-verified edit", { ...path, ...lang, ...gitScopeSchema, ...apply, edits: { type: "array", minItems: 1, items: editItemSchema, description: PARAM_DESCRIPTIONS.edits }, postEditVerify: { type: "boolean", description: PARAM_DESCRIPTIONS.postEditVerify } }, ["path", "edits"]),
+  tool("rename_symbol", "Rename symbol", { ...path, ...at, ...lang, ...gitScopeSchema, ...apply, to: string(PARAM_DESCRIPTIONS.to), workspace: { type: "boolean", description: PARAM_DESCRIPTIONS.workspace } }, ["path", "at", "to"]),
+  tool("write_file", "Write file", { ...path, content: string(PARAM_DESCRIPTIONS.content) }, ["path", "content"])
 ];
+function getToolContract(name) {
+  const contract = TOOL_CONTRACTS.find((entry) => entry.name === name);
+  if (!contract)
+    throw new Error(`missing tool contract: ${name}`);
+  return contract;
+}
 // ../readseek-api/src/policy.ts
 var REPLACEABLE_TOOLS = [
   {
-    tool: "inspect",
+    tool: "show_content",
     builtIn: "read",
     benefit: "it returns LINE:HASH anchors for safe edits."
   },
   {
-    tool: "edit",
+    tool: "edit_text",
     builtIn: "edit",
     benefit: "it verifies fresh LINE:HASH anchors."
   },
   {
-    tool: "grep",
+    tool: "find_text",
     builtIn: "grep",
     benefit: "it returns LINE:HASH anchors."
   },
   {
-    tool: "write",
+    tool: "write_file",
     builtIn: "write",
     benefit: "it returns LINE:HASH anchors."
   }
 ];
 var TOOL_COMPACT_GUIDELINES = {
-  inspect: [
-    "Use `inspect` for shallow maps, diagnostics, and identity; use `def`, `refs`, or `search` for targeted symbol questions."
+  show_content: [
+    "Use `show_structure` for shallow overviews and `check_syntax` for diagnostics; use `find_definitions`, `find_references`, or `find_nodes` for targeted symbol questions."
   ],
-  edit: [
+  edit_text: [
     "Prefer set_line, replace_lines, and insert_after; use replace only when anchors are impractical."
   ],
-  grep: [
-    "Use `grep` with summary first for broad searches, then narrow by path, glob, or pattern."
+  find_text: [
+    "Use `find_text` with summary first for broad searches, then narrow by path, glob, or pattern."
   ],
-  write: [
-    "Use anchored edits rather than `write` for small changes or appends."
+  write_file: [
+    "Use anchored edits rather than `write_file` for small changes or appends."
   ],
-  search: [
-    "Use `search` for AST patterns; use `grep` for plain text."
+  find_nodes: [
+    "Use `find_nodes` for AST patterns; use `find_text` for plain text."
   ],
-  refs: [
-    "Use `refs` before changing a symbol; add scope plus line/column to follow one binding."
+  find_references: [
+    "Use `find_references` before changing a symbol; use at with line:N:C to follow one binding."
   ]
 };
 function resolveToolName(name, aliases = {}) {
@@ -439,20 +284,20 @@ function renderCompactGuidelines(name, aliases = {}) {
 }
 function renderToolRoutingPolicy(options = {}) {
   const aliases = options.aliases ?? {};
-  const inspect = resolveToolName("inspect", aliases);
-  const edit = resolveToolName("edit", aliases);
-  const write = resolveToolName("write", aliases);
-  const grep = resolveToolName("grep", aliases);
-  const search = resolveToolName("search", aliases);
-  const def = resolveToolName("def", aliases);
-  const refs = resolveToolName("refs", aliases);
-  const rename = resolveToolName("rename", aliases);
-  const extract = resolveToolName("extract", aliases);
+  const show_content = resolveToolName("show_content", aliases);
+  const edit_text = resolveToolName("edit_text", aliases);
+  const write_file = resolveToolName("write_file", aliases);
+  const find_text = resolveToolName("find_text", aliases);
+  const find_nodes = resolveToolName("find_nodes", aliases);
+  const find_definitions = resolveToolName("find_definitions", aliases);
+  const find_references = resolveToolName("find_references", aliases);
+  const rename_symbol = resolveToolName("rename_symbol", aliases);
+  const show_assets = resolveToolName("show_assets", aliases);
   if (options.style === "server") {
     return [
       "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).`,
+      "For structural questions, prefer these tools to text Grep/Bash: targeted definitions, references, and AST patterns; shallow show_structure views; check_syntax diagnostics and show_content cursor context; and document inspection.",
+      `Use ${edit_text} for LINE:HASH-anchored mutations (preview with apply=false; apply defaults to true and re-checks plan_hash).`,
       "Paths resolve against CLAUDE_PROJECT_DIR. Native Read/Grep/Edit hooks provide passive context;",
       "call MCP tools for active navigation, document questions, or anchored edits."
     ].join(" ");
@@ -462,7 +307,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 ${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.`);
+  bullets.push(`- Read with ${show_content} first; ${edit_text} needs fresh LINE:HASH anchors.`, `- Use ${find_text} for text/regex, ${find_nodes} for AST patterns, ${find_definitions}/${find_references} for targeted symbols, and shallow ${resolveToolName("show_structure", aliases)} structures only for file overviews.`, `- Use ${edit_text} for existing files, ${write_file} for whole-file creation or replacement, and ${rename_symbol} for symbol renames.`, `- Use ${resolveToolName("show_structure", aliases)} for document structure; run ${resolveToolName("check_syntax", aliases)} after source edits for a quick syntax check.`, `- Use ${show_assets} to materialize selected document assets and read their returned paths.`);
   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.`);
   }
@@ -489,25 +334,9 @@ function tryParseLineAnchor(anchor) {
 }
 
 // ../readseek-api/src/validation.ts
-function validateRefsNameVsScope(input) {
-  if (input.scope) {
-    if (input.line === undefined) {
-      return { ok: false, error: "scope requires line" };
-    }
-    return { ok: true };
-  }
-  if (input.line !== undefined || input.column !== undefined) {
-    return { ok: false, error: "line/column require scope=true" };
-  }
-  if (typeof input.name !== "string" || input.name.length === 0) {
-    return { ok: false, error: "name is required when scope is not set" };
-  }
-  return { ok: true };
-}
-function validateVisionLevelVsMode(input) {
-  if (input.visionLevel !== undefined && !["all", "ocr", "caption", "objects"].includes(input.visionMode ?? "")) {
-    return { ok: false, error: "visionLevel requires an analysis visionMode" };
-  }
+function validateReferencesSelection(input) {
+  if (Boolean(input.name) === Boolean(input.at))
+    return { ok: false, error: "exactly one of name or at is required" };
   return { ok: true };
 }
 var VARIANT_FIELDS = {
@@ -577,51 +406,8 @@ 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}`;
-}
+var DEFAULT_STRUCTURE_DEPTH = 1;
 function appendGitScopeArgs(args, input) {
   if (input.gitScope !== undefined)
     args.push("--git-scope", input.gitScope);
@@ -648,30 +434,6 @@ function appendApplyAndPlanHash(args, input) {
   pushOptionalString(args, "--plan-hash", input.planHash);
   return args;
 }
-function selectArg(select) {
-  if (select === undefined)
-    return;
-  return Array.isArray(select) ? select.join(",") : select;
-}
-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`);
@@ -717,1226 +479,1300 @@ function parseSelector(text) {
   }
   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");
+function start(verb, object, input) {
+  if (!input.path)
+    throw new Error(`${verb} ${object} requires a path`);
+  if (input.stdinName !== undefined && input.path !== "-")
+    throw new Error("stdinName requires '-' as the target");
+  const args = [];
+  pushOptionalString(args, "--readseek-dir", input.readseekDir);
+  args.push(verb, object, input.path);
+  pushOptionalString(args, "--stdin-name", input.stdinName);
+  return args;
+}
+function at2(args, value) {
+  if (value !== undefined) {
+    parseSelector(value);
+    args.push("--at", value);
   }
-  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;
+}
+function finish(args) {
+  args.push("--kdl");
+  return args;
+}
+function language(args, input) {
+  pushOptionalString(args, "--language", input.language);
+}
+function limit2(args, value) {
+  if (value !== undefined)
+    validatePositiveInteger(value, "limit");
+  pushOptionalNumber(args, "--limit", value);
+}
+function anchors(args, input) {
+  if (input.noAnchors)
+    args.push("--no-anchors");
+}
+function buildShowContentArgs(input) {
   if (input.end !== undefined)
     validatePositiveInteger(input.end, "end");
-  if (input.limit !== undefined)
-    validatePositiveInteger(input.limit, "limit");
-  if (input.end !== undefined && input.limit !== undefined) {
+  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("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, "--query", input.query);
+  const args = start("show", "content", input);
+  at2(args, input.at);
   pushOptionalNumber(args, "--end", input.end);
-  pushOptionalNumber(args, "--limit", input.limit);
+  limit2(args, input.limit);
+  language(args, input);
+  anchors(args, input);
+  return finish(args);
+}
+function buildShowStructureArgs(input) {
+  if (input.depth !== undefined && (!Number.isSafeInteger(input.depth) || input.depth < 0))
+    throw new Error("depth must be a non-negative integer");
+  const args = start("show", "structure", input);
+  at2(args, input.at);
   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");
+  pushOptionalString(args, "--kind", input.kind);
+  language(args, input);
+  if (input.outline)
+    args.push("--outline");
+  return finish(args);
+}
+function buildShowMetadataArgs(input) {
+  const args = start("show", "metadata", input);
+  language(args, input);
+  return finish(args);
+}
+function buildShowAssetsArgs(input) {
+  if (input.at !== undefined && !["page", "node", "asset"].includes(parseSelector(input.at).kind))
+    throw new Error("assets requires a page, node, or asset selector");
+  const args = start("show", "assets", input);
+  at2(args, input.at);
+  return finish(args);
+}
+function buildCheckSyntaxArgs(input) {
+  const args = start("check", "syntax", input);
+  language(args, input);
+  return finish(args);
+}
+function visionArgs(verb, object, input) {
+  if (input.level !== undefined && !VISION_LEVELS.includes(input.level))
+    throw new Error("invalid vision level");
+  if (input.at !== undefined && !["page", "node", "asset"].includes(parseSelector(input.at).kind))
+    throw new Error("vision requires a document selector");
+  const args = start(verb, object, input);
+  at2(args, input.at);
+  pushOptionalString(args, "--level", input.level);
   return args;
 }
-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("--output", input.output, "extract", input.path, input.selector);
-  pushOptionalString(args, "--stdin-name", input.stdinName);
-  return args;
+function buildGenerateCaptionArgs(input) {
+  const args = visionArgs("generate", "caption", input);
+  if (input.include !== undefined) {
+    if (input.include.length === 0 || input.include.some((task) => task !== "text" && task !== "objects"))
+      throw new Error("include requires text or objects");
+    args.push("--include", input.include.join(","));
+  }
+  return finish(args);
+}
+function buildDetectObjectsArgs(input) {
+  return finish(visionArgs("detect", "objects", input));
+}
+function buildRecognizeTextArgs(input) {
+  return finish(visionArgs("recognize", "text", input));
+}
+function buildFindNodesArgs(input) {
+  const hasPattern = Boolean(input.pattern);
+  const hasRule = Boolean(input.rule);
+  const hasContext = Boolean(input.context);
+  if (hasRule) {
+    if (hasPattern || hasContext || input.selector)
+      throw new Error("rule cannot be combined with pattern, context, or selector");
+  } else if (!hasPattern && !hasContext) {
+    throw new Error("find nodes requires pattern, context, or rule");
+  }
+  if (hasContext && !input.selector) {
+    throw new Error("context requires selector");
+  }
+  if (hasPattern && hasContext) {
+    throw new Error("pattern and context cannot be combined");
+  }
+  const args = start("find", "nodes", input);
+  pushOptionalString(args, "--pattern", input.pattern);
+  pushOptionalString(args, "--context", input.context);
+  pushOptionalString(args, "--selector", input.selector);
+  pushOptionalString(args, "--rule", input.rule);
+  language(args, input);
+  limit2(args, input.limit);
+  appendGitScopeArgs(args, input);
+  anchors(args, input);
+  return finish(args);
 }
-function buildSearchArgs(input) {
-  const args = ["search", input.pattern];
-  pushOptionalString(args, "--path", input.path);
-  pushOptionalString(args, "--language", input.language);
-  pushOptionalNumber(args, "--limit", input.limit);
+function buildFindTextArgs(input) {
+  const args = start("find", "text", input);
+  args.push("--text", input.text);
+  limit2(args, input.limit);
   appendGitScopeArgs(args, input);
-  args.push("--kdl");
-  return args;
+  return finish(args);
 }
-function buildDefArgs(input) {
-  const args = ["def", input.name];
-  pushOptionalString(args, "--path", input.path);
-  pushOptionalString(args, "--language", input.language);
+function buildFindDefinitionsArgs(input) {
+  const args = start("find", "definitions", input);
+  args.push("--name", input.name);
+  language(args, input);
   appendGitScopeArgs(args, input);
-  args.push("--kdl");
-  return args;
+  anchors(args, input);
+  return finish(args);
 }
-function buildRefsArgs(input) {
-  const validated = validateRefsNameVsScope(input);
+function buildFindReferencesArgs(input) {
+  const validated = validateReferencesSelection(input);
   if (!validated.ok)
     throw new Error(validated.error);
-  const args = ["refs"];
-  if (input.name !== undefined)
-    args.push(input.name);
-  pushOptionalString(args, "--path", input.path);
-  if (input.scope) {
-    args.push("--scope");
-    pushOptionalNumber(args, "--line", input.line);
-    pushOptionalNumber(args, "--column", input.column);
-  }
-  pushOptionalString(args, "--language", input.language);
+  if (input.at !== undefined && !["line", "hash"].includes(parseSelector(input.at).kind))
+    throw new Error("references requires a line or hash selector");
+  const args = start("find", "references", input);
+  pushOptionalString(args, "--name", input.name);
+  at2(args, input.at);
+  language(args, input);
   appendGitScopeArgs(args, input);
-  args.push("--kdl");
-  return args;
+  anchors(args, input);
+  return finish(args);
 }
-function buildEditArgs(input) {
-  const args = ["edit", input.path];
-  appendApplyAndPlanHash(args, {
-    apply: input.apply,
-    planHash: input.planHash,
-    flagOrder: input.flagOrder ?? "apply-first"
-  });
-  pushOptionalString(args, "--language", input.language);
+function buildCheckRulesArgs(input) {
+  const args = start("check", "rules", input);
+  args.push("--rules", input.rules);
+  appendGitScopeArgs(args, input);
+  return finish(args);
+}
+function buildEditTextArgs(input) {
+  const args = start("edit", "text", input);
+  appendApplyAndPlanHash(args, input);
+  language(args, input);
+  appendGitScopeArgs(args, input);
   if (input.requestFromStdin)
     args.push("--edits", "-");
-  args.push("--kdl");
-  return args;
-}
-function buildRenameArgs(input) {
-  const args = ["rename", input.path, "--at", buildLineLocation(input.line, input.column), "--to", input.to];
+  return finish(args);
+}
+function buildRenameSymbolArgs(input) {
+  if (!["line", "hash"].includes(parseSelector(input.at).kind))
+    throw new Error("rename requires a line or hash selector");
+  const args = start("rename", "symbol", input);
+  at2(args, input.at);
+  args.push("--to", input.to);
   if (input.workspace !== undefined)
     args.push(`--workspace=${input.workspace}`);
-  appendApplyAndPlanHash(args, {
-    apply: input.apply,
-    planHash: input.planHash,
-    flagOrder: input.flagOrder ?? "plan-hash-first"
-  });
-  pushOptionalString(args, "--language", input.language);
+  appendApplyAndPlanHash(args, { ...input, flagOrder: input.flagOrder ?? "plan-hash-first" });
+  language(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";
-import { createRequire } from "node:module";
-import path from "node:path";
-var READSEEK_BINARY_ENV = "READSEEK_BINARY";
-var READSEEK_PLATFORM_PACKAGES = {
-  "darwin-arm64": "@jarkkojs/readseek-darwin-arm64",
-  "linux-arm64": "@jarkkojs/readseek-linux-arm64",
-  "linux-x64": "@jarkkojs/readseek-linux-x64",
-  "win32-x64": "@jarkkojs/readseek-win32-x64"
-};
-var resolveFromPackage = createRequire(import.meta.url).resolve;
-function readSeekBinaryName(platform = process.platform) {
-  if (platform === "linux")
-    return "readseek.AppImage";
-  return platform === "win32" ? "readseek.exe" : "readseek";
+  return finish(args);
 }
-function readSeekPlatformKey(platform = process.platform, arch = process.arch) {
-  return `${platform}-${arch}`;
-}
-function resolveReadSeekBinaryOverride(environment = process.env) {
-  const binaryPath = environment[READSEEK_BINARY_ENV];
-  if (binaryPath === undefined)
-    return null;
-  if (!path.isAbsolute(binaryPath)) {
-    throw new Error(`${READSEEK_BINARY_ENV} must be an absolute path to the readseek executable`);
-  }
+// ../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 parse(schema, value, what) {
   try {
-    if (!statSync(binaryPath).isFile())
-      throw new Error("not a regular file");
-    accessSync(binaryPath, fsConstants.X_OK);
+    return Value.Parse(OPERATIONS, schema, value);
   } catch (error) {
-    throw new Error(`${READSEEK_BINARY_ENV} does not point to an executable file: ${binaryPath}`, {
-      cause: error
-    });
-  }
-  return binaryPath;
-}
-function resolveReadSeekBinaryFromPackages(resolver = resolveFromPackage, options = {}) {
-  const resolve = typeof resolver === "function" ? resolver : resolver.resolve.bind(resolver);
-  const platform = options.platform ?? process.platform;
-  const arch = options.arch ?? process.arch;
-  const key = readSeekPlatformKey(platform, arch);
-  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}`);
-  }
-  const metaPackage = options.metaPackage ?? "@jarkkojs/readseek";
-  let packageJsonPath;
-  try {
-    const metaPackageJson = resolve(`${metaPackage}/package.json`);
-    const metaPackageDir = path.dirname(metaPackageJson);
-    packageJsonPath = resolve(`${platformPackage}/package.json`, {
-      paths: [metaPackageDir]
-    });
-  } catch {
-    packageJsonPath = resolve(`${platformPackage}/package.json`);
+    if (!(error instanceof AssertError))
+      throw error;
+    const detail = error.error;
+    throw new Error(`invalid readseek ${what}${detail?.path ?? ""}: ${detail?.message ?? "invalid value"}`);
   }
-  const binaryPath = path.join(path.dirname(packageJsonPath), "bin", readSeekBinaryName(platform));
-  accessSync(binaryPath, fsConstants.X_OK);
-  return binaryPath;
 }
-// ../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();
-}
-// ../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]);
+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,
+  truncated: Type.Optional(Bool)
+});
+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
+});
+function mapNodeShape(child) {
+  return Type.Object({
+    kind: Str,
+    name: Str,
+    start_line: Int,
+    end_line: Int,
+    start_anchor: Str,
+    end_anchor: Str,
+    children: Type.Array(child)
+  });
 }
-
-// ../readseek-api/src/output-kdl.ts
-function properties(node) {
-  return Object.fromEntries(node.properties);
+function recursiveStructureNode() {
+  return Type.Recursive((self) => mapNodeShape(self));
 }
-function children(node, name) {
-  return node.children.filter((child) => child.name === name);
+var StructureNode = typeof Type.Recursive === "function" ? recursiveStructureNode() : Type.Cyclic({ StructureNode: mapNodeShape(Type.Ref("StructureNode")) }, "StructureNode");
+var StructureOutput = Type.Object({
+  file: Str,
+  language: Str,
+  line_count: Int,
+  file_hash: Str,
+  root: Type.Optional(StructureNode),
+  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 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,
+  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 PdfMetadata = 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 CursorEnvelope = 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) {
+  return parse(ReadOutput, value, "read output");
 }
-function child(node, name) {
-  return node.children.find((candidate) => candidate.name === name);
+function parseStructureOutput(value) {
+  return parse(StructureOutput, value, "structure output");
 }
-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 parseSearchOutput(value) {
+  const envelope = parse(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 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 parseRefsOutput(value) {
+  return parse(RefsEnvelope, value, "refs output").references.map(({ symbol, ...reference }) => ({
+    ...reference,
+    enclosingSymbol: symbol?.qualified_name
+  }));
 }
-function mapNode(node) {
+function parseCheckOutput(value) {
+  const output = parse(CheckEnvelope, value, "check output");
   return {
-    ...properties(node),
-    children: children(node, "node").map(mapNode)
+    file_hash: output.file_hash,
+    errorCount: output.error_count,
+    missingCount: output.missing_count,
+    diagnostics: output.diagnostics
   };
 }
-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")
-      ]
-    }));
+function parseDetectOutput(value) {
+  const output = value ?? {};
+  if (output.type === "application/pdf") {
+    return { kind: "pdf", ...parse(PdfDetectionInput, value, "detect output") };
   }
-  return result;
+  if (output.width !== undefined || output.height !== undefined) {
+    return { kind: "image", ...parse(ImageDetectionInput, value, "detect output") };
+  }
+  if (output.language !== undefined) {
+    return { kind: "source", ...parse(SourceDetectionInput, value, "detect output") };
+  }
+  return { kind: "text", ...parse(TextDetectionInput, value, "detect output") };
 }
-function sourceMap(node) {
-  const root = child(node, "node");
+function parseTextContent(value) {
+  const output = value ?? {};
+  if (output.hashlines === undefined || output.start_line !== undefined)
+    return parseReadOutput(value);
+  const spanned = parse(UnspannedContent, value, "content");
   return {
-    ...properties(node),
-    ...root ? { root: mapNode(root) } : {},
-    symbols: children(node, "symbol").map(properties)
+    ...spanned,
+    start_line: spanned.hashlines[0]?.line ?? 1,
+    end_line: spanned.hashlines[spanned.hashlines.length - 1]?.line ?? 0
   };
 }
-function diagnostics(node) {
+function parseCursorOutput(value) {
+  return parse(CursorEnvelope, value, "cursor output");
+}
+function parsePdfMetadata(value) {
+  if (!value || typeof value !== "object")
+    return;
+  if (value.format !== "pdf")
+    return;
+  const document = parse(PdfMetadata, value, "inspect metadata");
+  return { kind: "pdf", type: "application/pdf", file: document.source, format: "pdf", pages: document.pages };
+}
+function parseEditOutput(value) {
+  return parse(EditOutputSchema, value, "edit output");
+}
+function parseRenameOutput(value) {
+  return parse(RenameOutputSchema, value, "rename output");
+}
+function parseDefOutput(value) {
+  return parse(DefEnvelope, value, "def output").locations;
+}
+var Bbox = Type.Object({ x: Type.Number(), y: Type.Number(), width: Type.Number(), height: Type.Number() });
+var Position = { page: OptInt, destination: OptStr, bbox: Type.Optional(Bbox) };
+var Provenance = { inferred: Type.Optional(Bool), model: OptStr, level: OptStr, task: OptStr };
+var ImageDescriptor = Type.Object({
+  id: OptStr,
+  kind: Type.Optional(Type.Literal("image")),
+  content_identity: OptStr,
+  path: Str,
+  mime: Str,
+  width: Int,
+  height: Int,
+  caption: OptStr,
+  ocr: OptStr,
+  objects: Type.Optional(Type.Array(DetectedObject)),
+  ...Provenance
+});
+var DocumentNode = Type.Object({
+  id: Str,
+  kind: Str,
+  parent_id: OptStr,
+  title: OptStr,
+  level: OptInt,
+  column: OptInt,
+  text: OptStr,
+  ...Position
+});
+var DocumentAsset = Type.Object({
+  id: Str,
+  kind: Str,
+  mime: Str,
+  path: OptStr,
+  content_identity: OptStr,
+  bytes: OptInt,
+  ...Position
+});
+var DocumentVision = Type.Object({
+  asset_id: Str,
+  mode: OptStr,
+  caption: OptStr,
+  ocr: OptStr,
+  objects: Type.Optional(Type.Array(DetectedObject)),
+  caption_requested: Type.Optional(Bool),
+  objects_requested: Type.Optional(Bool),
+  ocr_requested: Type.Optional(Bool),
+  ...Provenance
+});
+var DocumentOutput = Type.Object({
+  id: OptStr,
+  format: Str,
+  source: Str,
+  title: OptStr,
+  pages: Int,
+  nodes: Type.Array(DocumentNode, { default: [] }),
+  assets: Type.Array(DocumentAsset, { default: [] }),
+  vision: Type.Array(DocumentVision, { default: [] })
+});
+var TextHit = Type.Object({
+  line: Int,
+  column: Int,
+  text: Str,
+  start_line: Int,
+  end_line: Int,
+  start_byte: Int,
+  end_byte: Int,
+  hashlines: Hashlines
+});
+var DocumentHit = Type.Object({ node_id: Str, kind: Str, snippet: Str, page: OptInt });
+var TextSearchOutput = Type.Object({
+  text: Str,
+  mode: Type.Literal("literal"),
+  total_matches: Int,
+  returned_matches: Int,
+  truncated: Bool,
+  results: Type.Array(Type.Object({ file: Str, file_hash: Str, matches: Type.Array(TextHit) })),
+  documents: Type.Array(Type.Object({ file: Str, content_hash: Str, hits: Type.Array(DocumentHit) }))
+});
+var RuleFinding = Type.Object({
+  name: Str,
+  message: Str,
+  path: Str,
+  language: Str,
+  start_byte: Int,
+  end_byte: Int,
+  line: Int,
+  column: Int,
+  end_line: Int,
+  end_column: Int
+});
+var RulesOutput = Type.Object({
+  complete: Bool,
+  check_count: Int,
+  file_count: Int,
+  violation_count: Int,
+  diagnostics: Type.Array(RuleFinding)
+});
+function parseDocumentOutput(value) {
+  return parse(DocumentOutput, value, "document output");
+}
+function parseContentOutput(value) {
+  const output = value;
+  if (output?.format !== undefined)
+    return parseDocumentOutput(value);
+  if (!output || output.metadata === undefined || output.content === undefined)
+    throw new Error("invalid readseek content: missing metadata or content");
+  const metadata = parseDetectOutput(output.metadata);
   return {
-    ...properties(node),
-    diagnostics: children(node, "diagnostic").map(properties)
+    metadata,
+    content: metadata.kind === "image" ? parse(ImageDescriptor, output.content, "image descriptor") : parseTextContent(output.content),
+    ...output.cursor !== undefined ? { cursor: parseCursorOutput(output.cursor) } : {}
   };
 }
-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 parseStructureEnvelope(value) {
+  const output = value;
+  if (output?.format !== undefined)
+    return parseDocumentOutput(value);
+  if (!output || output.structure === undefined)
+    throw new Error("invalid readseek structure: missing structure");
+  return { ...output.metadata !== undefined ? { metadata: parseDetectOutput(output.metadata) } : {}, structure: parseStructureOutput(output.structure) };
+}
+function parseTextSearchOutput(value) {
+  return parse(TextSearchOutput, value, "text search output");
+}
+function parseRulesOutput(value) {
+  return parse(RulesOutput, value, "rules output");
+}
+var SourceAssetsOutput = Type.Object({ file: OptStr, metadata: Type.Optional(Detection), assets: Type.Array(DocumentAsset, { default: [] }) });
+function parseAssetsOutput(value) {
+  const raw = value;
+  if (raw?.format !== undefined)
+    return parseDocumentOutput(value);
+  if (!raw || raw.file === undefined && raw.metadata === undefined)
+    throw new Error("invalid readseek assets output: missing file or metadata");
+  return parse(SourceAssetsOutput, { ...raw, ...raw.metadata !== undefined ? { metadata: parseDetectOutput(raw.metadata) } : {} }, "assets output");
 }
-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);
+
+// ../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 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 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 search(root) {
+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/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 runOptions(options, vision = false) {
   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)
-    }))
+    signal: options.signal,
+    stdin: options.stdin,
+    timeoutMs: options.timeoutMs,
+    cancelable: options.cancelable,
+    ...vision ? { vision: true } : {}
   };
 }
-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) } : {}
-    };
-  });
+function createReadSeekClient(runner) {
   return {
-    references: parsed,
-    locations: parsed.map((reference) => {
-      const { symbol, ...location } = reference;
-      return symbol && typeof symbol === "object" ? { ...location, ...symbol } : location;
-    })
+    async showContent(path, options = {}) {
+      const value = await runner.kdl(buildShowContentArgs({ ...options, path }), runOptions(options));
+      return parseContentOutput(value);
+    },
+    async showStructure(path, options = {}) {
+      const value = await runner.kdl(buildShowStructureArgs({ ...options, path }), runOptions(options));
+      return parseStructureEnvelope(value);
+    },
+    async showMetadata(path, options = {}) {
+      const value = await runner.kdl(buildShowMetadataArgs({ ...options, path }), runOptions(options));
+      return parsePdfMetadata(value) ?? parseDetectOutput(value?.metadata);
+    },
+    async showAssets(path, options = {}) {
+      const value = await runner.kdl(buildShowAssetsArgs({ ...options, path }), runOptions(options));
+      return parseAssetsOutput(value);
+    },
+    async checkSyntax(path, options = {}) {
+      const value = await runner.kdl(buildCheckSyntaxArgs({ ...options, path }), runOptions(options));
+      return parseCheckOutput(value?.diagnostics ?? value);
+    },
+    async checkRules(path, options) {
+      const value = await runner.kdl(buildCheckRulesArgs({ ...options, path }), runOptions(options));
+      return parseRulesOutput(value);
+    },
+    async generateCaption(path, options = {}) {
+      const value = await runner.kdl(buildGenerateCaptionArgs({ ...options, path }), runOptions(options, true));
+      return parseContentOutput(value);
+    },
+    async detectObjects(path, options = {}) {
+      const value = await runner.kdl(buildDetectObjectsArgs({ ...options, path }), runOptions(options, true));
+      return parseContentOutput(value);
+    },
+    async recognizeText(path, options = {}) {
+      const value = await runner.kdl(buildRecognizeTextArgs({ ...options, path }), runOptions(options, true));
+      return parseContentOutput(value);
+    },
+    async findNodes(path, options) {
+      const value = await runner.kdl(buildFindNodesArgs({ ...options, path }), runOptions(options));
+      return parseSearchOutput(value);
+    },
+    async findText(path, options) {
+      const value = await runner.kdl(buildFindTextArgs({ ...options, path }), runOptions(options));
+      return parseTextSearchOutput(value);
+    },
+    async findDefinitions(path, options) {
+      const value = await runner.kdl(buildFindDefinitionsArgs({ ...options, path }), runOptions(options));
+      return parseDefOutput(value);
+    },
+    async findReferences(path, options) {
+      const value = await runner.kdl(buildFindReferencesArgs({ ...options, path }), runOptions(options));
+      return parseRefsOutput(value);
+    },
+    async editText(path, edits, options = {}) {
+      const stdin = serializeEditPlan(edits);
+      return parseEditOutput(await runner.kdl(buildEditTextArgs({ ...options, path, requestFromStdin: true }), runOptions({ ...options, stdin })));
+    },
+    async renameSymbol(path, options) {
+      const value = await runner.kdl(buildRenameSymbolArgs({ ...options, path }), runOptions(options));
+      return parseRenameOutput(value);
+    }
   };
 }
-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
-      };
-    })
-  };
+// ../readseek-api/src/platform.ts
+import { accessSync, constants as fsConstants, existsSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import path2 from "node:path";
+var READSEEK_BINARY_ENV = "READSEEK_BINARY";
+var READSEEK_PLATFORM_PACKAGES = {
+  "darwin-arm64": "@jarkkojs/readseek-darwin-arm64",
+  "linux-arm64": "@jarkkojs/readseek-linux-arm64",
+  "linux-x64": "@jarkkojs/readseek-linux-x64",
+  "win32-x64": "@jarkkojs/readseek-win32-x64"
+};
+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 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");
+function readSeekPlatformKey(platform = process.platform, arch = process.arch) {
+  return `${platform}-${arch}`;
+}
+function resolveReadSeekBinaryOverride(environment = process.env) {
+  const binaryPath = environment[READSEEK_BINARY_ENV];
+  if (binaryPath === undefined)
+    return null;
+  if (!path2.isAbsolute(binaryPath)) {
+    throw new Error(`${READSEEK_BINARY_ENV} must be an absolute path to the readseek executable`);
   }
-  return result;
+  try {
+    if (!statSync(binaryPath).isFile())
+      throw new Error("not a regular file");
+    accessSync(binaryPath, fsConstants.X_OK);
+  } catch (error) {
+    throw new Error(`${READSEEK_BINARY_ENV} does not point to an executable file: ${binaryPath}`, {
+      cause: error
+    });
+  }
+  return binaryPath;
 }
-function renameEdit(node) {
-  const sourceLine = child(node, "line");
-  if (!sourceLine)
-    throw new Error("invalid readseek KDL rename edit: missing line");
+function resolveReadSeekBinaryFromPackages(resolver = resolveFromPackage, options = {}) {
+  const resolve = typeof resolver === "function" ? resolver : resolver.resolve.bind(resolver);
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
+  const key = readSeekPlatformKey(platform, arch);
+  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}`);
+  }
+  const metaPackage = options.metaPackage ?? "@jarkkojs/readseek";
+  let packageJsonPath;
+  try {
+    const metaPackageJson = resolve(`${metaPackage}/package.json`);
+    const metaPackageDir = path2.dirname(metaPackageJson);
+    packageJsonPath = resolve(`${platformPackage}/package.json`, {
+      paths: [metaPackageDir]
+    });
+  } catch {
+    packageJsonPath = resolve(`${platformPackage}/package.json`);
+  }
+  const binaryPath = path2.join(path2.dirname(packageJsonPath), "bin", readSeekBinaryName(platform));
+  accessSync(binaryPath, fsConstants.X_OK);
+  return binaryPath;
+}
+// ../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();
+}
+// ../readseek-api/src/kdl.ts
+import { parse as parse2 } 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 {
-    ...properties(node),
-    text: requireProperty(sourceLine, "content")
+    name: node.getName(),
+    properties,
+    children: node.children?.nodes.map(convertNode) ?? []
   };
 }
-function renameFile(node) {
+function parseKdlDocument(text) {
+  const document = parse2(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 {
-    ...properties(node),
-    edits: children(node, "edit").map(renameEdit),
-    conflicts: children(node, "conflict").map(properties)
+    line: Number(match[1]),
+    hash: match[2],
+    text: content
   };
 }
-function rename(root) {
+function mapNode(node) {
   return {
-    ...renameFile(root),
-    others: children(root, "other").map(renameFile)
+    ...properties(node),
+    children: children(node, "node").map(mapNode)
   };
 }
-function genericNode(node) {
+function sourceContent(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);
+  result.hashlines = children(node, "line").map(line);
   const objects = children(node, "object");
-  if (objects.length > 0)
-    result.objects = objects.map(genericNode);
+  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 pdfDocument(root) {
+function sourceMap(node) {
+  const root = child(node, "node");
   return {
-    ...properties(root),
-    nodes: children(root, "node").map(genericNode),
-    assets: children(root, "asset").map(genericNode),
-    vision: children(root, "vision").map(genericNode)
+    ...properties(node),
+    ...root ? { root: mapNode(root) } : {},
+    symbols: children(node, "symbol").map(properties)
   };
 }
-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 = {}) {
+function diagnostics(node) {
   return {
-    timeoutMs: options.timeoutMs ?? DEFAULT_READSEEK_TIMEOUT_MS,
-    maxOutputBytes: options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES,
-    cancelable: options.cancelable !== false
+    ...properties(node),
+    diagnostics: children(node, "diagnostic").map(properties)
   };
 }
-function readSeekCancellationError(signal) {
-  const reason = signal?.reason;
-  return reason instanceof Error && reason.name !== "AbortError" ? reason : new Error("readseek cancelled");
+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 failureFromProcessResult(result, options = {}) {
-  if (options.overflow) {
-    return new Error(`readseek ${options.overflow} exceeded the ${options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES}-byte output limit`);
-  }
-  if (options.timedOut) {
-    return new Error(`readseek timed out after ${options.timeoutMs ?? DEFAULT_READSEEK_TIMEOUT_MS} ms`);
-  }
-  const cleaned = cleanReadSeekErrorText(result.stderr);
-  if (cleaned)
-    return new Error(cleaned);
-  if (result.signal)
-    return new Error(`readseek killed by signal ${result.signal}`);
-  return new Error(`readseek exited with status ${result.exitCode}`);
-}
-function ensureSuccessfulStdout(result) {
-  if (result.exitCode === 0)
-    return result.stdout;
-  throw failureFromProcessResult(result);
-}
-// ../readseek-api/src/process-node.ts
-import { spawn } from "node:child_process";
-import { StringDecoder } from "node:string_decoder";
-function attachBoundedStream(stream, maxOutputBytes, onOverflow) {
-  const decoder = new StringDecoder("utf8");
-  let text = "";
-  let bytes = 0;
-  let overflowed = false;
-  stream.on("data", (chunk) => {
-    if (overflowed)
-      return;
-    const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
-    bytes += buffer.length;
-    if (bytes > maxOutputBytes) {
-      overflowed = true;
-      onOverflow();
-      return;
-    }
-    text += decoder.write(buffer);
-  });
-  return {
-    text: () => text + decoder.end()
-  };
-}
-async function runReadSeekNode(binaryPath, args, options = {}) {
-  const limits = resolveProcessLimits(options);
-  if (limits.cancelable && options.signal?.aborted) {
-    throw readSeekCancellationError(options.signal);
-  }
-  return await new Promise((resolve, reject) => {
-    let settled = false;
-    let child;
-    let timer;
-    const finish = (result) => {
-      if (settled)
-        return;
-      settled = true;
-      if (timer !== undefined)
-        clearTimeout(timer);
-      options.signal?.removeEventListener("abort", onAbort);
-      resolve(result);
-    };
-    const fail = (error) => {
-      if (settled)
-        return;
-      settled = true;
-      if (timer !== undefined)
-        clearTimeout(timer);
-      options.signal?.removeEventListener("abort", onAbort);
-      reject(error instanceof Error ? error : new Error(String(error)));
-    };
-    const terminate = (error) => {
-      if (settled)
-        return;
-      fail(error);
-      try {
-        child.kill("SIGKILL");
-      } catch {}
-    };
-    const onAbort = () => {
-      terminate(readSeekCancellationError(options.signal));
-    };
-    try {
-      child = spawn(binaryPath, [...args], {
-        cwd: options.cwd,
-        env: readSeekProcessEnvironment(),
-        shell: false,
-        stdio: [options.stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"],
-        windowsHide: true
-      });
-    } catch (error) {
-      fail(error);
-      return;
-    }
-    const stdout = attachBoundedStream(child.stdout, limits.maxOutputBytes, () => {
-      terminate(failureFromProcessResult({ stdout: "", stderr: "", exitCode: null, signal: null }, { overflow: "stdout", maxOutputBytes: limits.maxOutputBytes }));
-    });
-    const stderr = attachBoundedStream(child.stderr, limits.maxOutputBytes, () => {
-      terminate(failureFromProcessResult({ stdout: "", stderr: "", exitCode: null, signal: null }, { overflow: "stderr", maxOutputBytes: limits.maxOutputBytes }));
-    });
-    timer = setTimeout(() => {
-      terminate(failureFromProcessResult({ stdout: "", stderr: "", exitCode: null, signal: null }, { timedOut: true, timeoutMs: limits.timeoutMs }));
-    }, limits.timeoutMs);
-    timer.unref?.();
-    if (limits.cancelable && options.signal) {
-      options.signal.addEventListener("abort", onAbort, { once: true });
-    }
-    if (options.stdin !== undefined) {
-      child.stdin.on("error", (error) => {
-        if (error.code !== "EPIPE")
-          fail(error);
-      });
-      child.stdin.end(options.stdin, "utf8");
-    }
-    child.on("error", fail);
-    child.on("close", (code, signal) => {
-      finish({
-        stdout: stdout.text(),
-        stderr: stderr.text(),
-        exitCode: code,
-        signal
-      });
-    });
-  });
-}
-async function runReadSeekNodeText(binaryPath, args, options = {}) {
-  return ensureSuccessfulStdout(await runReadSeekNode(binaryPath, args, options));
-}
-// ../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
-});
-function mapNodeShape(child) {
-  return Type.Object({
-    kind: Str,
-    name: Str,
-    start_line: Int,
-    end_line: Int,
-    start_anchor: Str,
-    end_anchor: Str,
-    children: Type.Array(child)
-  });
-}
-function recursiveMapNode() {
-  return Type.Recursive((self) => mapNodeShape(self));
-}
-var MapNode = typeof Type.Recursive === "function" ? recursiveMapNode() : Type.Cyclic({ MapNode: mapNodeShape(Type.Ref("MapNode")) }, "MapNode");
-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) {
-  return parse2(ReadOutput, value, "read output");
+function sourceDocument(root) {
+  const result = {};
+  const metadata = child(root, "metadata");
+  const cache = child(root, "cache");
+  const content = child(root, "content");
+  const structure = child(root, "structure");
+  const diagnosticOutput = child(root, "diagnostics");
+  const identityOutput = child(root, "cursor");
+  if (metadata)
+    result.metadata = properties(metadata);
+  if (!metadata && !content && !structure && !diagnosticOutput && !identityOutput && root.properties.has("file"))
+    result.file = root.properties.get("file");
+  const assets = children(root, "asset");
+  if (assets.length > 0)
+    result.assets = assets.map(genericNode);
+  if (cache)
+    result.cache = properties(cache);
+  if (content)
+    result.content = sourceContent(content);
+  if (structure)
+    result.structure = sourceMap(structure);
+  if (diagnosticOutput)
+    result.diagnostics = diagnostics(diagnosticOutput);
+  if (identityOutput)
+    result.cursor = identity(identityOutput);
+  return result;
 }
-function parseMapOutput(value) {
-  return parse2(MapOutput, value, "map output");
+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 parseSearchOutput(value) {
-  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 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 parseRefsOutput(value) {
-  return parse2(RefsEnvelope, value, "refs output").references.map(({ symbol, ...reference }) => ({
-    ...reference,
-    enclosingSymbol: symbol?.qualified_name
-  }));
+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 parseCheckOutput(value) {
-  const output = parse2(CheckEnvelope, value, "check output");
+function definitions(root) {
   return {
-    file_hash: output.file_hash,
-    errorCount: output.error_count,
-    missingCount: output.missing_count,
-    diagnostics: output.diagnostics
+    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 parseDetectOutput(value) {
-  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", ...parse2(ImageDetectionInput, value, "detect output") };
-  }
-  if (output.language !== undefined) {
-    return { kind: "source", ...parse2(SourceDetectionInput, value, "detect output") };
+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 { kind: "text", ...parse2(TextDetectionInput, value, "detect output") };
+  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 parseImageContent(value) {
-  const detection = parseDetectOutput(value);
-  if (detection.kind !== "image")
-    throw new Error("invalid readseek image content: expected an image");
-  return detection;
+function renameFile(node) {
+  return {
+    ...properties(node),
+    edits: children(node, "edit").map(renameEdit),
+    conflicts: children(node, "conflict").map(properties)
+  };
 }
-function parseTextContent(value) {
-  const output = value ?? {};
-  if (output.hashlines === undefined || output.start_line !== undefined)
-    return parseReadOutput(value);
-  const spanned = parse2(UnspannedContent, value, "content");
+function rename(root) {
   return {
-    ...spanned,
-    start_line: spanned.hashlines[0]?.line ?? 1,
-    end_line: spanned.hashlines[spanned.hashlines.length - 1]?.line ?? 0
+    ...renameFile(root),
+    others: children(root, "other").map(renameFile)
   };
 }
-function parseDocumentCache(value) {
-  return parse2(DocumentCache, value, "document cache");
+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((object) => ({
+      label: requireProperty(object, "label"),
+      bbox: [requireProperty(object, "x0"), requireProperty(object, "y0"), requireProperty(object, "x1"), requireProperty(object, "y1")]
+    }));
+  return result;
 }
-function parseIdentifyOutput(value) {
-  return parse2(IdentifyEnvelope, value, "identify output");
+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 parsePdfInspectMetadata(value) {
-  if (!value || typeof value !== "object")
-    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 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}`);
+  }
 }
-function parseEditOutput(value) {
-  return parse2(EditOutputSchema, value, "edit output");
+// ../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 parseRenameOutput(value) {
-  return parse2(RenameOutputSchema, value, "rename output");
+function resolveProcessLimits(options = {}) {
+  return {
+    timeoutMs: options.timeoutMs ?? DEFAULT_READSEEK_TIMEOUT_MS,
+    maxOutputBytes: options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES,
+    cancelable: options.cancelable !== false
+  };
 }
-function parseDefOutput(value) {
-  return parse2(DefEnvelope, value, "def output").locations;
+function readSeekCancellationError(signal) {
+  const reason = signal?.reason;
+  return reason instanceof Error && reason.name !== "AbortError" ? reason : new Error("readseek cancelled");
 }
-
-// ../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." };
+function failureFromProcessResult(result, options = {}) {
+  if (options.overflow) {
+    return new Error(`readseek ${options.overflow} exceeded the ${options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES}-byte output limit`);
   }
-  return { code: "readseek-execution-error", message };
+  if (options.timedOut) {
+    return new Error(`readseek timed out after ${options.timeoutMs ?? DEFAULT_READSEEK_TIMEOUT_MS} ms`);
+  }
+  const cleaned = cleanReadSeekErrorText(result.stderr);
+  if (cleaned)
+    return new Error(cleaned);
+  if (result.signal)
+    return new Error(`readseek killed by signal ${result.signal}`);
+  return new Error(`readseek exited with status ${result.exitCode}`);
 }
-function parseSourceInspectEnvelope(value) {
-  if (!value || typeof value !== "object")
-    throw new Error("invalid readseek inspect output");
-  const output = value;
-  const result = {};
-  if (output.metadata !== undefined)
-    result.metadata = parseDetectOutput(output.metadata);
-  if (output.cache !== undefined)
-    result.cache = parseDocumentCache(output.cache);
-  if (output.content !== undefined)
-    result.content = output.content;
-  if (output.map !== undefined)
-    result.map = parseMapOutput(output.map);
-  if (output.diagnostics !== undefined)
-    result.diagnostics = parseCheckOutput(output.diagnostics);
-  if (output.identity !== undefined)
-    result.identity = parseIdentifyOutput(output.identity);
-  return result;
+function acceptsReadSeekExitCode(args, exitCode) {
+  if (exitCode === 0)
+    return true;
+  if (exitCode !== 1)
+    return false;
+  let index = 0;
+  const valued = new Set(["-C", "--directory", "--output", "--readseek-dir"]);
+  while (index < args.length) {
+    const arg = args[index];
+    if (valued.has(arg)) {
+      index += 2;
+      continue;
+    }
+    if ([...valued].some((flag) => arg.startsWith(`${flag}=`)) || arg === "--kdl") {
+      index++;
+      continue;
+    }
+    return arg === "find" || arg === "check";
+  }
+  return false;
 }
-function createReadSeekClient(runner) {
-  function inspectArgs(target, options) {
-    return buildInspectArgs({
-      path: target,
-      selector: options.selector,
-      select: options.select ?? "content",
-      query: options.query,
-      end: options.end,
-      limit: options.limit,
-      depth: options.depth,
-      language: options.language,
-      visionMode: options.visionMode,
-      visionLevel: options.visionLevel,
-      stdinName: options.stdinName
-    });
+function ensureSuccessfulStdout(result, args = []) {
+  if (!result.signal && acceptsReadSeekExitCode(args, result.exitCode))
+    return result.stdout;
+  throw failureFromProcessResult(result);
+}
+// ../readseek-api/src/process-node.ts
+import { spawn } from "node:child_process";
+import { StringDecoder } from "node:string_decoder";
+function attachBoundedStream(stream, maxOutputBytes, onOverflow) {
+  const decoder = new StringDecoder("utf8");
+  let text = "";
+  let bytes = 0;
+  let overflowed = false;
+  stream.on("data", (chunk) => {
+    if (overflowed)
+      return;
+    const buffer = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+    bytes += buffer.length;
+    if (bytes > maxOutputBytes) {
+      overflowed = true;
+      onOverflow();
+      return;
+    }
+    text += decoder.write(buffer);
+  });
+  return {
+    text: () => text + decoder.end()
+  };
+}
+async function runReadSeekNode(binaryPath, args, options = {}) {
+  const limits = resolveProcessLimits(options);
+  if (limits.cancelable && options.signal?.aborted) {
+    throw readSeekCancellationError(options.signal);
   }
-  function inspectRunOptions(options) {
-    return {
-      signal: options.signal,
-      stdin: options.stdin,
-      timeoutMs: options.timeoutMs,
-      vision: options.vision
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    let child;
+    let timer;
+    const finish = (result) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onAbort);
+      resolve(result);
     };
-  }
-  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 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 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
+    const fail = (error) => {
+      if (settled)
+        return;
+      settled = true;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onAbort);
+      reject(error instanceof Error ? error : new Error(String(error)));
+    };
+    const terminate = (error) => {
+      if (settled)
+        return;
+      fail(error);
+      try {
+        child.kill("SIGKILL");
+      } catch {}
+    };
+    const onAbort = () => {
+      terminate(readSeekCancellationError(options.signal));
+    };
+    try {
+      child = spawn(binaryPath, [...args], {
+        cwd: options.cwd,
+        env: readSeekProcessEnvironment(),
+        shell: false,
+        stdio: [options.stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"],
+        windowsHide: true
+      });
+    } catch (error) {
+      fail(error);
+      return;
+    }
+    const stdout = attachBoundedStream(child.stdout, limits.maxOutputBytes, () => {
+      terminate(failureFromProcessResult({ stdout: "", stderr: "", exitCode: null, signal: null }, { overflow: "stdout", maxOutputBytes: limits.maxOutputBytes }));
+    });
+    const stderr = attachBoundedStream(child.stderr, limits.maxOutputBytes, () => {
+      terminate(failureFromProcessResult({ stdout: "", stderr: "", exitCode: null, signal: null }, { overflow: "stderr", maxOutputBytes: limits.maxOutputBytes }));
     });
-    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) };
+    timer = setTimeout(() => {
+      terminate(failureFromProcessResult({ stdout: "", stderr: "", exitCode: null, signal: null }, { timedOut: true, timeoutMs: limits.timeoutMs }));
+    }, limits.timeoutMs);
+    timer.unref?.();
+    if (limits.cancelable && options.signal) {
+      options.signal.addEventListener("abort", onAbort, { once: true });
     }
-    return { metadata, text: parseTextContent(content) };
-  }
-  return {
-    inspect,
-    inspectText,
-    inspectContent,
-    async extract(target, selector, output, options = {}) {
-      await runner.text(buildExtractArgs({
-        path: target,
-        selector,
-        output,
-        stdinName: options.stdinName
-      }), {
-        signal: options.signal,
-        stdin: options.stdin,
-        timeoutMs: options.timeoutMs,
-        cancelable: options.cancelable
-      });
-    },
-    async image(filePath, modes, options = {}) {
-      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 inspected = await inspectContent(filePath, {
-        visionMode: "none",
-        signal: options.signal
-      });
-      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}`);
-      }
-      return { mime: output.mime, encoding: output.encoding, data: output.data };
-    },
-    async search(target, pattern, options = {}) {
-      const args = buildSearchArgs({
-        path: target,
-        pattern,
-        language: options.language,
-        limit: options.limit,
-        gitScope: options.gitScope
-      });
-      return parseSearchOutput(await runner.kdl(args, { signal: options.signal }));
-    },
-    async refs(target, options = {}) {
-      const args = buildRefsArgs({
-        path: target,
-        name: options.name,
-        scope: options.scope,
-        line: options.line,
-        column: options.column,
-        language: options.language,
-        gitScope: options.gitScope
-      });
-      return parseRefsOutput(await runner.kdl(args, { signal: options.signal }));
-    },
-    async def(target, options) {
-      const args = buildDefArgs({
-        path: target,
-        name: options.name,
-        language: options.language,
-        gitScope: options.gitScope
-      });
-      return parseDefOutput(await runner.kdl(args, { signal: options.signal }));
-    },
-    async check(filePath, content, options = {}) {
-      const envelope = await inspectSource("-", {
-        select: "diagnostics",
-        stdin: content,
-        stdinName: filePath,
-        signal: options.signal
-      });
-      if (!envelope.diagnostics)
-        throw new Error("invalid readseek diagnostics: missing diagnostics facet");
-      return envelope.diagnostics;
-    },
-    async identify(filePath, content, options) {
-      const envelope = await inspectSource("-", {
-        select: "identity",
-        stdin: content,
-        stdinName: filePath,
-        selector: buildLineLocation(options.line, options.column),
-        language: options.language,
-        signal: options.signal
-      });
-      if (!envelope.identity)
-        throw new Error("invalid readseek identity: missing identity facet");
-      return envelope.identity;
-    },
-    async detect(filePath, options = {}) {
-      const 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({
-        path: filePath,
-        apply: options.apply,
-        planHash: options.planHash,
-        language: options.language,
-        requestFromStdin: true
-      });
-      return parseEditOutput(await runner.kdl(args, {
-        signal: options.signal,
-        stdin: serializeEditPlan(edits),
-        timeoutMs: options.timeoutMs,
-        cancelable: options.cancelable
-      }));
-    },
-    async rename(filePath, options) {
-      const args = buildRenameArgs({
-        path: filePath,
-        to: options.to,
-        line: options.line,
-        column: options.column,
-        workspace: options.workspace,
-        apply: options.apply,
-        planHash: options.planHash,
-        language: options.language,
-        gitScope: options.gitScope
+    if (options.stdin !== undefined) {
+      child.stdin.on("error", (error) => {
+        if (error.code !== "EPIPE")
+          fail(error);
       });
-      return parseRenameOutput(await runner.kdl(args, { signal: options.signal }));
+      child.stdin.end(options.stdin, "utf8");
     }
-  };
+    child.on("error", fail);
+    child.on("close", (code, signal) => {
+      finish({
+        stdout: stdout.text(),
+        stderr: stderr.text(),
+        exitCode: code,
+        signal
+      });
+    });
+  });
+}
+async function runReadSeekNodeText(binaryPath, args, options = {}) {
+  return ensureSuccessfulStdout(await runReadSeekNode(binaryPath, args, options), args);
 }
 // src/tool-prompt-metadata.ts
 var REPLACEABLE_BY_TOOL = new Map(REPLACEABLE_TOOLS.map((entry) => [entry.tool, entry]));
@@ -2415,7 +2251,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_inspect/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_show_content/readSeek_find_text/readSeek_find_nodes.]";
 }
 function buildEditOutput(input) {
   const summary = `Updated ${input.displayPath}`;
@@ -2508,17 +2344,17 @@ function classifyEdit(oldContent, newContent) {
 import { existsSync as existsSync2, statSync as statSync3 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { homedir as homedir2 } from "node:os";
-import path2 from "node:path";
+import path3 from "node:path";
 
 // src/readseek-settings.ts
 import { readFileSync, statSync as statSync2 } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 var READSEEK_TOOL_REPLACEMENTS = {
-  read: "readSeek_inspect",
-  edit: "readSeek_edit",
-  grep: "readSeek_grep",
-  write: "readSeek_write"
+  read: "readSeek_show_content",
+  edit: "readSeek_edit_text",
+  grep: "readSeek_find_text",
+  write: "readSeek_write_file"
 };
 var READSEEK_KEYS = ["overrideTools", "imageMode", "syntaxValidation", "timeoutMs", "grep", "display"];
 var READSEEK_GREP_KEYS = ["maxLines", "maxBytes"];
@@ -2735,7 +2571,7 @@ function readSeekBinaryAvailability() {
 var defaultReadSeekDirInit;
 function defaultReadSeekDir() {
   const home = homedir2();
-  return home ? path2.join(home, ".pi", "readseek") : null;
+  return home ? path3.join(home, ".pi", "readseek") : null;
 }
 function directoryExists(dir) {
   try {
@@ -2754,24 +2590,39 @@ async function ensureDefaultReadSeekDir() {
     return null;
   if (directoryExists(dir))
     return dir;
-  defaultReadSeekDirInit ??= runReadSeekNodeText(readSeekBinaryPath(), ["--readseek-dir", dir, "init"], { timeoutMs: readSeekTimeoutMs() }).then(() => directoryExists(dir) ? dir : null).catch(() => null).finally(() => {
+  defaultReadSeekDirInit ??= runReadSeekNodeText(readSeekBinaryPath(), ["--readseek-dir", dir, "initialize", "index"], { timeoutMs: readSeekTimeoutMs() }).then(() => directoryExists(dir) ? dir : null).catch(() => null).finally(() => {
     defaultReadSeekDirInit = undefined;
   });
   return defaultReadSeekDirInit;
 }
 function hasProjectReadSeekDir(cwd = process.cwd()) {
-  let dir = path2.resolve(cwd);
+  let dir = path3.resolve(cwd);
   while (true) {
-    if (existsSync2(path2.join(dir, ".readseek")))
+    if (existsSync2(path3.join(dir, ".readseek")))
       return true;
-    const parent = path2.dirname(dir);
+    const parent = path3.dirname(dir);
     if (parent === dir)
       return false;
     dir = parent;
   }
 }
+function supportsReadSeekDir(args) {
+  const first = args[0];
+  const second = args[1];
+  if (first === "initialize" && second === "index")
+    return true;
+  if (first === "show" && (second === "content" || second === "assets"))
+    return true;
+  if (first === "generate" && second === "caption")
+    return true;
+  if (first === "detect" && second === "objects")
+    return true;
+  if (first === "recognize" && second === "text")
+    return true;
+  return false;
+}
 async function readSeekInvocationArgs(args) {
-  if (hasProjectReadSeekDir())
+  if (!supportsReadSeekDir(args) || hasProjectReadSeekDir())
     return [...args];
   const readSeekDir = await ensureDefaultReadSeekDir();
   return readSeekDir ? ["--readseek-dir", readSeekDir, ...args] : [...args];
@@ -2825,22 +2676,24 @@ var runner = {
   }),
   kdl: async (args, options = {}) => parseReadSeekKdl(await runner.text(args, options))
 };
-var client = createReadSeekClient(runner);
-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 readSeekEdit = client.edit;
-var readSeekRename = client.rename;
+var client2 = createReadSeekClient(runner);
+var readSeekShowContent = client2.showContent;
+var readSeekShowStructure = client2.showStructure;
+var readSeekShowMetadata = client2.showMetadata;
+var readSeekShowAssets = client2.showAssets;
+var readSeekGenerateCaption = client2.generateCaption;
+var readSeekDetectObjects = client2.detectObjects;
+var readSeekRecognizeText = client2.recognizeText;
+var readSeekFindNodes = client2.findNodes;
+var readSeekFindReferences = client2.findReferences;
+var readSeekFindDefinitions = client2.findDefinitions;
+var readSeekCheckSyntax = client2.checkSyntax;
+var readSeekCheckRules = client2.checkRules;
+var readSeekEditText = client2.editText;
+var readSeekRenameSymbol = client2.renameSymbol;
 async function readSeekMap(filePath, options = {}) {
-  const envelope = await client.inspect(filePath, {
-    select: "map",
-    depth: DEFAULT_INSPECT_MAP_DEPTH,
-    signal: options.signal
-  });
-  const map = envelope.map;
+  const envelope = await client2.showStructure(filePath, { depth: DEFAULT_STRUCTURE_DEPTH, signal: options.signal });
+  const map = "structure" in envelope ? envelope.structure : undefined;
   if (!map || map.language === "unknown" && map.symbols.length === 0)
     return null;
   return map;
@@ -2865,8 +2718,8 @@ async function validateSyntaxRegression(input, options = {}) {
   let before;
   let after;
   try {
-    before = input.before === undefined ? EMPTY : await readSeekCheck(input.filePath, input.before, { signal: options.signal });
-    after = await readSeekCheck(input.filePath, input.after, { signal: options.signal });
+    before = input.before === undefined ? EMPTY : await readSeekCheckSyntax("-", { stdinName: input.filePath, stdin: input.before, signal: options.signal });
+    after = await readSeekCheckSyntax("-", { stdinName: input.filePath, stdin: input.after, signal: options.signal });
   } catch {
     return null;
   }
@@ -3552,7 +3405,7 @@ async function executeEdit(opts) {
     return await withFileMutationQueue(absolutePath, async () => {
       throwIfAborted(signal);
       if (wasReadInSession && !wasReadInSession(absolutePath)) {
-        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.`;
+        const hint = `Call readSeek_show_content(${JSON.stringify(rawPath)}) first, or use readSeek_find_text, readSeek_find_nodes, or readSeek_write_file 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 ?? []);
@@ -3562,7 +3415,7 @@ async function executeEdit(opts) {
       const edits = parsedEdits.edits;
       let plan;
       try {
-        plan = await readSeekEdit(absolutePath, edits, { signal, language: parsed.language });
+        plan = await readSeekEditText(absolutePath, edits, { signal, language: parsed.language });
       } catch (err) {
         throwIfAborted(signal);
         const failure = classifyReadSeekFailure(err);
@@ -3598,7 +3451,7 @@ async function executeEdit(opts) {
       throwIfAborted(signal);
       let applied;
       try {
-        applied = await readSeekEdit(absolutePath, edits, {
+        applied = await readSeekEditText(absolutePath, edits, {
           apply: true,
           planHash: plan.plan_hash,
           language: parsed.language,
@@ -3666,9 +3519,9 @@ async function executeEdit(opts) {
   }
 }
 function registerEditTool(pi, options = {}) {
-  const name = options.name ?? "readSeek_edit";
+  const name = options.name ?? "readSeek_edit_text";
   const promptMetadata = defineToolPromptMetadata({
-    promptUrl: new URL("../prompts/edit.md", import.meta.url),
+    promptUrl: new URL("../prompts/edit_text.md", import.meta.url),
     promptSnippet: "Edit existing files with fresh LINE:HASH anchors",
     registeredName: name,
     toolAliases: options.toolAliases
@@ -3765,7 +3618,7 @@ ${theme.fg("error", info.errorText)}`;
 
 // src/grep.ts
 import { readFile as fsReadFile2, stat as fsStat } from "node:fs/promises";
-import path3 from "node:path";
+import path4 from "node:path";
 import { createGrepTool } from "@earendil-works/pi-coding-agent";
 import { Type as Type5 } from "@sinclair/typebox";
 import { Text as Text4 } from "@earendil-works/pi-tui";
@@ -4135,7 +3988,7 @@ function formatGrepResultText(input) {
 
 // src/coerce-obvious-int.ts
 import {
-  coerceObviousBase10Int as coerceObviousBase10Int2
+  coerceObviousBase10Int
 } from "@jarkkojs/readseek-api";
 
 // src/tui-source-render.ts
@@ -4255,21 +4108,21 @@ async function executeGrep(opts) {
   const { toolCallId, params, signal, onUpdate, cwd, onFileAnchored } = opts;
   await ensureHashInit();
   const rawParams = params;
-  const context = coerceObviousBase10Int2(rawParams.context, "context");
+  const context = coerceObviousBase10Int(rawParams.context, "context");
   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");
+  const limit = coerceObviousBase10Int(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");
+  const scopeContext = coerceObviousBase10Int(rawParams.scopeContext, "scopeContext");
   if (!scopeContext.ok) {
     return buildToolErrorResult("grep", "invalid-params-combo", scopeContext.message);
   }
@@ -4351,7 +4204,7 @@ async function executeGrep(opts) {
   };
   const toAbsolutePath = (displayPath) => {
     if (searchPathIsDirectory)
-      return path3.resolve(searchPath, displayPath);
+      return path4.resolve(searchPath, displayPath);
     return searchPath;
   };
   const groupsByPath = new Map;
@@ -4539,9 +4392,9 @@ ${warning}` } : item),
   };
 }
 function registerGrepTool(pi, options = {}) {
-  const name = options.name ?? "readSeek_grep";
+  const name = options.name ?? "readSeek_find_text";
   const promptMetadata = defineToolPromptMetadata({
-    promptUrl: new URL("../prompts/grep.md", import.meta.url),
+    promptUrl: new URL("../prompts/find_text.md", import.meta.url),
     promptSnippet: "Search text or regex with edit-ready LINE:HASH anchors",
     registeredName: name
   });
@@ -4628,7 +4481,7 @@ function registerGrepTool(pi, options = {}) {
 }
 
 // src/search.ts
-import path4 from "node:path";
+import path5 from "node:path";
 import { Type as Type6 } from "@sinclair/typebox";
 
 // src/stat-search-path.ts
@@ -4687,7 +4540,7 @@ function mergeRanges(ranges) {
   return merged;
 }
 var SEARCH_PROMPT_METADATA = defineToolPromptMetadata({
-  promptUrl: new URL("../prompts/search.md", import.meta.url),
+  promptUrl: new URL("../prompts/find_nodes.md", import.meta.url),
   promptSnippet: "Search code by AST structure using ast-grep-style patterns"
 });
 function linesFromSearchResult(result, ranges) {
@@ -4713,7 +4566,7 @@ function linesFromSearchResult(result, ranges) {
   return lines;
 }
 function readSeekLanguageForPath(language, searchPath, isFile) {
-  if (language === "typescript" && isFile && path4.extname(searchPath).toLowerCase() === ".tsx")
+  if (language === "typescript" && isFile && path5.extname(searchPath).toLowerCase() === ".tsx")
     return "tsx";
   return language;
 }
@@ -4727,13 +4580,18 @@ async function executeSearch(opts) {
   const searchPathIsFile = statResult.stats.isFile();
   try {
     const effectiveLang = readSeekLanguageForPath(p.language, searchPath, searchPathIsFile);
-    const results = await readSeekSearch(searchPath, p.pattern, {
+    const results = await readSeekFindNodes(searchPath, {
+      pattern: p.pattern,
+      context: p.context,
+      selector: p.selector,
+      rule: p.rule,
+      limit: p.limit,
       language: effectiveLang,
       gitScope: p.gitScope,
       signal
     });
     if (results.length === 0) {
-      const emptyOutput = buildSearchOutput({ pattern: p.pattern, files: [] });
+      const emptyOutput = buildSearchOutput({ pattern: p.pattern ?? p.context ?? p.rule ?? "", files: [] });
       return {
         content: [{ type: "text", text: emptyOutput.text }],
         details: {
@@ -4743,8 +4601,8 @@ async function executeSearch(opts) {
     }
     const readSeekFiles = [];
     for (const result of results) {
-      const abs = path4.isAbsolute(result.file) ? result.file : path4.resolve(cwd, result.file);
-      const display = path4.relative(cwd, abs) || abs;
+      const abs = path5.isAbsolute(result.file) ? result.file : path5.resolve(cwd, result.file);
+      const display = path5.relative(cwd, abs) || abs;
       const ranges = result.matches.map((match) => ({ startLine: match.start_line, endLine: match.end_line }));
       const mergedRanges = mergeRanges(ranges);
       const lines = linesFromSearchResult(result, mergedRanges);
@@ -4758,7 +4616,7 @@ async function executeSearch(opts) {
       });
     }
     if (readSeekFiles.length === 0) {
-      const emptyOutput = buildSearchOutput({ pattern: p.pattern, files: [] });
+      const emptyOutput = buildSearchOutput({ pattern: p.pattern ?? p.rule ?? "", files: [] });
       return {
         content: [{ type: "text", text: emptyOutput.text }],
         details: {
@@ -4767,7 +4625,7 @@ async function executeSearch(opts) {
       };
     }
     const builtOutput = buildSearchOutput({
-      pattern: p.pattern,
+      pattern: p.pattern ?? p.rule ?? "",
       files: readSeekFiles
     });
     for (const readSeekFile of readSeekFiles) {
@@ -4786,14 +4644,18 @@ async function executeSearch(opts) {
 }
 function registerSearchTool(pi, options = {}) {
   const tool = registerReadSeekTool(pi, {
-    name: "readSeek_search",
+    name: "readSeek_find_nodes",
     label: "Structural Search",
     description: SEARCH_PROMPT_METADATA.description,
     promptSnippet: SEARCH_PROMPT_METADATA.promptSnippet,
     promptGuidelines: SEARCH_PROMPT_METADATA.promptGuidelines,
     parameters: Type6.Object({
-      pattern: Type6.String({ description: PARAM_DESCRIPTIONS.pattern }),
+      pattern: Type6.Optional(Type6.String({ description: PARAM_DESCRIPTIONS.pattern })),
+      context: Type6.Optional(Type6.String({ description: PARAM_DESCRIPTIONS.patternContext })),
+      selector: Type6.Optional(Type6.String({ description: PARAM_DESCRIPTIONS.selector })),
       language: languageParam(),
+      rule: Type6.Optional(Type6.String({ description: PARAM_DESCRIPTIONS.rule })),
+      limit: Type6.Optional(Type6.Integer({ minimum: 1 })),
       path: searchPathParam(),
       ...readSeekGitSearchParams()
     }),
@@ -4803,7 +4665,7 @@ function registerSearchTool(pi, options = {}) {
     renderCall(args, theme, ...rest) {
       return renderReadSeekSearchCall(args, theme, rest, {
         label: "search",
-        accent: `/${args.pattern}/`,
+        accent: `/${args.pattern ?? args.context ?? args.rule}/`,
         flags: [args.gitScope && `git-scope=${args.gitScope}`]
       });
     },
@@ -4821,15 +4683,14 @@ function registerSearchTool(pi, options = {}) {
 
 // src/refs.ts
 import { Type as Type7 } from "@sinclair/typebox";
-import path5 from "node:path";
+import path6 from "node:path";
 
 // src/refs-output.ts
 function refsQueryLabel(input) {
   if (input.name)
     return input.name;
-  if (input.scope && input.line !== undefined) {
-    return input.column === undefined ? `line:${input.line}` : `line:${input.line}:${input.column}`;
-  }
+  if (input.at)
+    return input.at;
   return "?";
 }
 function buildRefsOutput(input) {
@@ -4853,7 +4714,7 @@ function buildRefsOutput(input) {
 
 // src/refs.ts
 var REFS_PROMPT_METADATA = defineToolPromptMetadata({
-  promptUrl: new URL("../prompts/refs.md", import.meta.url),
+  promptUrl: new URL("../prompts/find_references.md", import.meta.url),
   promptSnippet: "Find references by identifier name or cursor binding"
 });
 function refsLine(reference) {
@@ -4866,14 +4727,14 @@ function groupReferences(references, cwd) {
   const files = new Map;
   const seen = new Set;
   for (const reference of references) {
-    const abs = path5.isAbsolute(reference.file) ? reference.file : path5.resolve(cwd, reference.file);
+    const abs = path6.isAbsolute(reference.file) ? reference.file : path6.resolve(cwd, reference.file);
     const dedupeKey = `${abs}:${reference.line}:${reference.column}`;
     if (seen.has(dedupeKey))
       continue;
     seen.add(dedupeKey);
     let file = files.get(abs);
     if (!file) {
-      file = { displayPath: path5.relative(cwd, abs) || abs, path: abs, lines: [] };
+      file = { displayPath: path6.relative(cwd, abs) || abs, path: abs, lines: [] };
       files.set(abs, file);
     }
     file.lines.push(refsLine(reference));
@@ -4886,7 +4747,7 @@ function isReadSeekCursorValidationFailure(message) {
 async function executeRefs(opts) {
   const { params, signal, cwd, onFileAnchored } = opts;
   const p = params;
-  const scopeError = validateRefsNameVsScope(p);
+  const scopeError = validateReferencesSelection(p);
   if (!scopeError.ok) {
     return buildToolErrorResult("refs", "invalid-parameter", `refs parameter: ${scopeError.error}`);
   }
@@ -4895,11 +4756,9 @@ async function executeRefs(opts) {
   if (!statResult.ok)
     return statResult.error;
   try {
-    const references = await readSeekRefs(searchPath, {
+    const references = await readSeekFindReferences(searchPath, {
       name: p.name,
-      scope: p.scope,
-      line: p.line,
-      column: p.column,
+      at: p.at,
       language: p.language,
       gitScope: p.gitScope,
       signal
@@ -4907,9 +4766,7 @@ async function executeRefs(opts) {
     const files = groupReferences(references, cwd);
     const builtOutput = buildRefsOutput({
       name: p.name,
-      scope: p.scope,
-      line: p.line,
-      column: p.column,
+      at: p.at,
       files
     });
     for (const file of files) {
@@ -4921,7 +4778,7 @@ async function executeRefs(opts) {
     };
   } catch (err) {
     const failure = classifyReadSeekFailure(err);
-    if (p.scope && isReadSeekCursorValidationFailure(failure.message)) {
+    if (p.at && isReadSeekCursorValidationFailure(failure.message)) {
       return buildToolErrorResult("refs", "invalid-parameter", failure.message);
     }
     return buildToolErrorResult("refs", failure.code, failure.message, failure.hint ? { hint: failure.hint } : {});
@@ -4929,7 +4786,7 @@ async function executeRefs(opts) {
 }
 function registerRefsTool(pi, options = {}) {
   const tool = registerReadSeekTool(pi, {
-    name: "readSeek_refs",
+    name: "readSeek_find_references",
     label: "References",
     description: REFS_PROMPT_METADATA.description,
     promptSnippet: REFS_PROMPT_METADATA.promptSnippet,
@@ -4938,20 +4795,18 @@ function registerRefsTool(pi, options = {}) {
       name: Type7.Optional(Type7.String({ description: PARAM_DESCRIPTIONS.refsName })),
       path: searchPathParam(),
       language: languageParam(),
-      scope: Type7.Optional(Type7.Boolean({ description: PARAM_DESCRIPTIONS.scope })),
-      line: Type7.Optional(Type7.Number({ description: PARAM_DESCRIPTIONS.line })),
-      column: Type7.Optional(Type7.Number({ description: PARAM_DESCRIPTIONS.column })),
+      at: Type7.Optional(Type7.String({ description: PARAM_DESCRIPTIONS.at })),
       ...readSeekGitSearchParams()
     }),
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
       return executeRefs({ params, signal, cwd: ctx.cwd, onFileAnchored: options.onFileAnchored });
     },
     renderCall(args, theme, ...rest) {
-      const accent = args.name ?? (args.scope ? args.column === undefined ? `line:${args.line}` : `line:${args.line}:${args.column}` : "?");
+      const accent = args.name ?? args.at ?? "?";
       return renderReadSeekSearchCall(args, theme, rest, {
         label: "refs",
         accent,
-        flags: [args.scope && "scope", args.gitScope && `git-scope=${args.gitScope}`]
+        flags: [args.at && "binding", args.gitScope && `git-scope=${args.gitScope}`]
       });
     },
     renderResult(result, options, theme, ...rest) {
@@ -4968,16 +4823,15 @@ function registerRefsTool(pi, options = {}) {
 
 // src/rename.ts
 import { Type as Type8 } from "@sinclair/typebox";
-import path6 from "node:path";
+import path7 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),
+  promptUrl: new URL("../prompts/rename_symbol.md", import.meta.url),
   promptSnippet: "Rename a symbol at a source location with verified edits"
 });
 var renameSchema = Type8.Object({
   path: filePathParam(),
-  line: Type8.Integer({ minimum: 1, description: PARAM_DESCRIPTIONS.renameLine }),
-  column: Type8.Optional(Type8.Integer({ minimum: 1, description: PARAM_DESCRIPTIONS.column })),
+  at: Type8.String({ description: PARAM_DESCRIPTIONS.at }),
   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 }))
@@ -4988,18 +4842,14 @@ async function executeRename(opts) {
   if (!p.to.trim()) {
     return buildToolErrorResult("rename", "invalid-parameter", "rename parameter 'to' must not be empty");
   }
-  if (!Number.isSafeInteger(p.line) || p.line < 1) {
-    return buildToolErrorResult("rename", "invalid-parameter", "rename parameter 'line' must be a positive integer");
-  }
-  if (p.column !== undefined && (!Number.isSafeInteger(p.column) || p.column < 1)) {
-    return buildToolErrorResult("rename", "invalid-parameter", "rename parameter 'column' must be a positive integer");
+  if (typeof p.at !== "string" || !/^(line:[1-9][0-9]*|hash:[0-9a-fA-F]+)(:[1-9][0-9]*)?$/.test(p.at)) {
+    return buildToolErrorResult("rename_symbol", "invalid-parameter", "at must be a line or hash location with an optional positive column");
   }
   const filePath = resolveToCwd2(p.path, cwd);
   try {
-    const output = await readSeekRename(filePath, {
+    const output = await readSeekRenameSymbol(filePath, {
       to: p.to,
-      line: p.line,
-      column: p.column,
+      at: p.at,
       workspace: p.workspace ? cwd : undefined,
       apply: p.apply ?? true,
       signal
@@ -5008,14 +4858,14 @@ async function executeRename(opts) {
       for (const file of [output, ...output.others]) {
         if (file.edits.length === 0)
           continue;
-        const absoluteFile = path6.isAbsolute(file.file) ? file.file : path6.resolve(cwd, file.file);
+        const absoluteFile = path7.isAbsolute(file.file) ? file.file : path7.resolve(cwd, file.file);
         onFileMutated?.(absoluteFile);
       }
     }
-    const primaryAbs = path6.isAbsolute(output.file) ? output.file : path6.resolve(cwd, output.file);
+    const primaryAbs = path7.isAbsolute(output.file) ? output.file : path7.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);
+      const abs = path7.isAbsolute(other.file) ? other.file : path7.resolve(cwd, other.file);
       if (!files.includes(abs))
         files.push(abs);
     }
@@ -5054,7 +4904,7 @@ First conflict at ${firstConflict.line}:${firstConflict.column}: ${firstConflict
 }
 function registerRenameTool(pi, options = {}) {
   registerReadSeekTool(pi, {
-    name: "readSeek_rename",
+    name: "readSeek_rename_symbol",
     label: "Rename",
     description: RENAME_PROMPT_METADATA.description,
     promptSnippet: RENAME_PROMPT_METADATA.promptSnippet,
@@ -5097,7 +4947,7 @@ function registerRenameTool(pi, options = {}) {
       });
       if (expanded && output) {
         for (const file of outputs) {
-          const display = path6.relative(cwd, file.file) || file.file;
+          const display = path7.relative(cwd, file.file) || file.file;
           text += `
 ${linkedPathLine(theme, file.file, display, cwd, ` (${file.edits.length} edits)`, width)}`;
         }
@@ -5320,7 +5170,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_inspect/readSeek_edit would normalize differently.";
+    const message = "File content contains bare CR (\\r) line endings; readSeek_write_file refuses to emit anchors that readSeek_show_content/readSeek_edit_text would normalize differently.";
     warnings.push(message);
     readSeekWarnings.push(buildReadSeekWarning("bare-cr", message));
     return buildToolErrorResult("write", "bare-cr", `Cannot write ${filePath}
@@ -5399,9 +5249,9 @@ async function executeWrite(opts) {
   };
 }
 function registerWriteTool(pi, options = {}) {
-  const name = options.name ?? "readSeek_write";
+  const name = options.name ?? "readSeek_write_file";
   const promptMetadata = defineToolPromptMetadata({
-    promptUrl: new URL("../prompts/write.md", import.meta.url),
+    promptUrl: new URL("../prompts/write_file.md", import.meta.url),
     promptSnippet: "Create or replace a complete file with LINE:HASH anchors",
     registeredName: name
   });
@@ -5513,23 +5363,23 @@ function registerWriteTool(pi, options = {}) {
 
 // src/def.ts
 import { Type as Type10 } from "@sinclair/typebox";
-import path7 from "node:path";
+import path8 from "node:path";
 var DEF_PROMPT_METADATA = defineToolPromptMetadata({
-  promptUrl: new URL("../prompts/def.md", import.meta.url),
+  promptUrl: new URL("../prompts/find_definitions.md", import.meta.url),
   promptSnippet: "Go to a symbol definition or declaration by name"
 });
 async function executeDef(opts) {
   const { params, signal, cwd, onFileAnchored } = opts;
   const p = params;
   if (!p.name || !p.name.trim()) {
-    return buildToolErrorResult("def", "invalid-parameter", "readSeek_def requires 'name'");
+    return buildToolErrorResult("def", "invalid-parameter", "readSeek_find_definitions requires 'name'");
   }
   const searchPath = resolveToCwd2(p.path ?? ".", cwd);
   const statResult = await statSearchPathOrError("def", p.path, searchPath);
   if (!statResult.ok)
     return statResult.error;
   try {
-    const definitions = await readSeekDef(searchPath, {
+    const definitions = await readSeekFindDefinitions(searchPath, {
       name: p.name,
       language: p.language,
       gitScope: p.gitScope,
@@ -5545,10 +5395,10 @@ async function executeDef(opts) {
     }
     const files = new Map;
     for (const def of definitions) {
-      const abs = path7.isAbsolute(def.file) ? def.file : path7.resolve(cwd, def.file);
+      const abs = path8.isAbsolute(def.file) ? def.file : path8.resolve(cwd, def.file);
       let file = files.get(abs);
       if (!file) {
-        file = { displayPath: path7.relative(cwd, abs) || abs, path: abs, lines: [] };
+        file = { displayPath: path8.relative(cwd, abs) || abs, path: abs, lines: [] };
         files.set(abs, file);
       }
       file.lines.push(buildReadSeekLineWithHash(def.line, def.line_hash, def.text));
@@ -5578,7 +5428,7 @@ async function executeDef(opts) {
 }
 function registerDefTool(pi, options = {}) {
   registerReadSeekTool(pi, {
-    name: "readSeek_def",
+    name: "readSeek_find_definitions",
     label: "Definition",
     description: DEF_PROMPT_METADATA.description,
     promptSnippet: DEF_PROMPT_METADATA.promptSnippet,
@@ -5610,379 +5460,120 @@ function registerDefTool(pi, options = {}) {
   });
 }
 
-// src/inspect.ts
+// src/access.ts
 import { Text as Text7 } from "@earendil-works/pi-tui";
 import { Type as Type11 } from "@sinclair/typebox";
-var facetSchema = Type11.Union(INSPECT_FACETS.map((facet) => Type11.Literal(facet)));
-var inspectSchema = Type11.Object({
-  path: filePathParam(),
-  selector: Type11.Optional(Type11.String({ description: PARAM_DESCRIPTIONS.selector })),
-  select: Type11.Optional(Type11.Union([
-    facetSchema,
-    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),
-  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 hasInspectAnchors(value) {
+import { readFile as readFile2 } from "node:fs/promises";
+var operations = {
+  show_content: readSeekShowContent,
+  show_structure: readSeekShowStructure,
+  show_metadata: readSeekShowMetadata,
+  show_assets: readSeekShowAssets,
+  check_syntax: readSeekCheckSyntax,
+  check_rules: readSeekCheckRules,
+  generate_caption: readSeekGenerateCaption,
+  detect_objects: readSeekDetectObjects,
+  recognize_text: readSeekRecognizeText
+};
+function hasAnchors(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(hasInspectAnchors);
-}
-function parseSelect(select) {
-  if (select === undefined)
-    return;
-  if (Array.isArray(select)) {
-    const facets = select;
-    if (facets.length === 0)
-      throw new Error("select must include at least one facet");
-    for (const facet of facets) {
-      if (!INSPECT_FACETS.includes(facet)) {
-        throw new Error(`unknown inspect facet \`${facet}\`; expected ${INSPECT_FACETS.join(", ")}`);
-      }
-    }
-    return facets;
-  }
-  if (typeof select !== "string") {
-    throw new Error("select must be a facet, facet list, or comma-separated facets");
-  }
-  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 (!INSPECT_FACETS.includes(part)) {
-      throw new Error(`unknown inspect facet \`${part}\`; expected ${INSPECT_FACETS.join(", ")}`);
-    }
-  }
-  return parts;
-}
-function selectedFacets(select) {
-  if (select === undefined)
-    return ["content"];
-  return Array.isArray(select) ? select : [select];
-}
-function summarizeEnvelope(envelope, facets) {
-  if (!envelope || typeof envelope !== "object")
-    return `inspected ${facets.join(",")}`;
-  const record = envelope;
-  const parts = [];
-  for (const facet of facets) {
-    if (facet === "metadata" || record[facet] !== undefined)
-      parts.push(facet);
-  }
-  if (record.metadata !== undefined && !parts.includes("metadata"))
-    parts.unshift("metadata");
-  return `inspected ${parts.join(",") || "metadata"}`;
-}
-function parseImageEnvelope(envelope) {
-  if (!envelope || typeof envelope !== "object")
-    return;
-  const record = envelope;
-  if (!record.metadata || typeof record.metadata !== "object")
-    return;
-  const metadata = record.metadata;
-  if (typeof metadata.type !== "string" || !metadata.type.startsWith("image/"))
-    return;
-  if (!record.content || typeof record.content !== "object")
-    return { metadata };
-  const content = record.content;
-  const mime = content.mime ?? content.type ?? metadata.mime ?? metadata.type;
-  const prepared = content.encoding === "base64" && typeof content.data === "string" && typeof mime === "string" ? { data: content.data, mimeType: mime } : undefined;
-  return { metadata, prepared };
-}
-function buildInspectSuccess(filePath, facets, envelope, content = [{ type: "text", text: JSON.stringify(envelope) }]) {
-  return {
-    content,
-    details: {
-      readSeekValue: {
-        tool: "inspect",
-        ok: true,
-        path: filePath,
-        select: facets,
-        envelope
-      }
-    }
-  };
+  return Object.values(record).some(hasAnchors);
 }
-async function executeInspect(opts) {
-  const { params, signal, cwd, onFileAnchored } = opts;
-  const p = params;
-  let select;
-  try {
-    select = parseSelect(p.select);
-  } catch (err) {
-    return buildToolErrorResult("inspect", "invalid-parameter", err?.message ?? String(err), {
-      path: p.path
-    });
-  }
-  const facets = selectedFacets(select);
-  const appliesImagePolicy = opts.imageMode !== undefined && facets.includes("content");
-  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("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("inspect", "invalid-parameter", message, { 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 });
-  }
-  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,
-    depth: depth.value ?? (facets.includes("map") ? DEFAULT_INSPECT_MAP_DEPTH : undefined)
-  };
-  const selectionOptions = {
-    ...commonOptions,
-    selector,
-    query,
-    end: end.value,
-    limit: limit.value,
-    language: p.language
-  };
-  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;
+function imagePaths(value, paths = new Map) {
+  if (!value || typeof value !== "object")
+    return paths;
+  const record = value;
+  if (typeof record.path === "string" && typeof record.mime === "string" && record.mime.startsWith("image/")) {
+    paths.set(record.path, record.mime);
+  }
+  for (const child of Object.values(record))
+    imagePaths(child, paths);
+  return paths;
+}
+async function executeAccess(opts) {
+  if (!opts.params || typeof opts.params !== "object" || Array.isArray(opts.params)) {
+    return buildToolErrorResult(opts.tool, "invalid-parameter", "Expected an object");
+  }
+  const p = opts.params;
+  const contract = getToolContract(opts.tool);
+  for (const key of Object.keys(p)) {
+    if (key === "stdinName" || !Object.hasOwn(contract.inputSchema.properties, key))
+      return buildToolErrorResult(opts.tool, "invalid-parameter", `Unknown parameter: ${key}`);
+  }
+  const path = p.path === undefined && opts.tool === "check_rules" ? "." : p.path;
+  if (typeof path !== "string" || !path.trim())
+    return buildToolErrorResult(opts.tool, "invalid-parameter", "path is required");
+  if (path === "-")
+    return buildToolErrorResult(opts.tool, "invalid-parameter", "Agent tools require a file path; stdin is available through the CLI or API");
+  const filePath = resolveToCwd2(path, opts.cwd);
   try {
-    const envelope = await readSeekInspect(filePath, {
-      ...appliesImagePolicy ? probeOptions : selectionOptions,
-      visionMode: initialVisionMode,
-      visionLevel: initialVisionLevel,
-      vision: initialVisionMode !== undefined && initialVisionMode !== "none"
-    });
-    const image = appliesImagePolicy ? parseImageEnvelope(envelope) : undefined;
-    if (image) {
-      const imageDetails = { metadata: image.metadata };
-      if (opts.imageMode === "off") {
-        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 buildInspectSuccess(filePath, facets, imageDetails, [
-          { type: "image", data: image.prepared.data, mimeType: image.prepared.mimeType }
-        ]);
+    const { path: _path, ...options } = p;
+    const envelope = await operations[opts.tool](filePath, { ...options, signal: opts.signal });
+    if (hasAnchors(envelope))
+      opts.onFileAnchored?.(filePath);
+    const content = [
+      { type: "text", text: JSON.stringify(envelope) }
+    ];
+    if (opts.tool === "show_content" || opts.tool === "show_assets") {
+      for (const [imagePath, mimeType] of imagePaths(envelope)) {
+        if (opts.imageMode === "off")
+          content.push({ type: "text", text: `Image available at ${imagePath}; image attachments are disabled by readseek.imageMode.` });
+        else if (opts.modelSupportsImages)
+          content.push({ type: "image", data: (await readFile2(imagePath)).toString("base64"), mimeType });
+        else
+          content.push({ type: "text", text: `Image available at ${imagePath}; this host model does not support image attachments.` });
       }
-      const visionMode = p.visionMode && p.visionMode !== "none" ? p.visionMode : "all";
-      const analyzedEnvelope = await readSeekInspect(filePath, {
-        ...commonOptions,
-        visionMode,
-        visionLevel: p.visionLevel,
-        vision: true
-      });
-      return buildInspectSuccess(filePath, facets, analyzedEnvelope);
-    }
-    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 selectedEnvelope = appliesImagePolicy && (hasSelectionOptions || hasVisionOptions) ? await readSeekInspect(filePath, {
-      ...selectionOptions,
-      visionMode: p.visionMode,
-      visionLevel: p.visionLevel,
-      vision: p.visionMode !== undefined && p.visionMode !== "none"
-    }) : envelope;
-    if (hasInspectAnchors(selectedEnvelope))
-      onFileAnchored?.(filePath);
-    return buildInspectSuccess(filePath, facets, selectedEnvelope);
+    return { content, details: { readSeekValue: { tool: opts.tool, ok: true, path: filePath, envelope } } };
   } catch (err) {
     const failure = classifyReadSeekFailure(err);
-    return buildToolErrorResult("inspect", failure.code, failure.message, failure.hint ? { hint: failure.hint } : {});
-  }
-}
-function registerInspectTool(pi, options = {}) {
-  const promptMetadata = defineToolPromptMetadata({
-    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_inspect",
-    label: "Inspect",
-    description: promptMetadata.description,
-    promptSnippet: promptMetadata.promptSnippet,
-    toolAliases: options.toolAliases,
-    promptGuidelines: promptMetadata.promptGuidelines,
-    parameters: inspectSchema,
-    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-      return executeInspect({
-        params,
-        signal,
-        cwd: ctx.cwd,
-        onFileAnchored: options.onFileAnchored,
-        imageMode: options.imageMode,
-        modelSupportsImages: ctx.model?.input.includes("image") ?? false
-      });
-    },
-    renderCall(args, theme, ...rest) {
-      const context = rest[0] ?? {};
-      const cwd = context.cwd ?? process.cwd();
-      const displayPath = typeof args?.path === "string" ? args.path : "?";
-      let text = theme.fg("toolTitle", theme.bold("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?.selector === "string" && args.selector)
-        text += theme.fg("dim", ` @ ${args.selector}`);
-      return new Text7(clampLineToWidth(text, context.width), 0, 0);
-    },
-    renderResult(result, options, theme, ...rest) {
-      const { isPartial, isError, expanded, width } = resolveRenderResultContext(options, rest);
-      if (isPartial)
-        return renderPendingResult("pending inspect", width, theme);
-      const textContent = result.content?.[0]?.type === "text" ? result.content[0].text : "";
-      if (isError || result.isError) {
-        return renderErrorResult(textContent, { expanded, width, fallback: "inspect failed", theme });
-      }
-      const value = result.details?.readSeekValue;
-      const facets = Array.isArray(value?.select) ? value.select : ["content"];
-      const label = summarizeEnvelope(value?.envelope, facets);
-      let text = summaryLine(label, { hidden: !!textContent && !expanded, theme, style: "success" });
-      if (expanded && textContent)
-        text += `
-${textContent}`;
-      return new Text7(clampLinesToWidth(text.split(`
+    return buildToolErrorResult(opts.tool, failure.code, failure.message, failure.hint ? { hint: failure.hint } : {});
+  }
+}
+function registerAccessTools(pi, options = {}) {
+  for (const name of Object.keys(operations)) {
+    const registeredName = name === "show_content" ? options.name ?? `readSeek_${name}` : `readSeek_${name}`;
+    const contract = getToolContract(name);
+    const metadata = defineToolPromptMetadata({
+      promptUrl: new URL(`../prompts/${name}.md`, import.meta.url),
+      promptSnippet: contract.title,
+      registeredName,
+      toolAliases: options.toolAliases
+    });
+    registerReadSeekTool(pi, {
+      name: registeredName,
+      label: contract.title,
+      ...metadata,
+      parameters: Type11.Unsafe({
+        ...contract.inputSchema,
+        properties: Object.fromEntries(Object.entries(contract.inputSchema.properties).filter(([key]) => key !== "stdinName"))
+      }),
+      async execute(_id, params, signal, _update, ctx) {
+        return executeAccess({ tool: name, params, signal, cwd: ctx.cwd, onFileAnchored: options.onFileAnchored, imageMode: options.imageMode, modelSupportsImages: ctx.model?.input.includes("image") ?? false });
+      },
+      renderCall(args) {
+        return new Text7(`${name} ${args.path ?? ""}${args.at ? ` @ ${args.at}` : ""}`, 0, 0);
+      },
+      renderResult(result, renderOptions, theme, ...rest) {
+        const { isPartial, isError, expanded, width } = resolveRenderResultContext(renderOptions, rest);
+        if (isPartial)
+          return renderPendingResult(`pending ${name}`, width, theme);
+        const text = result.content?.find((item) => item.type === "text")?.text ?? "";
+        if (isError || result.isError)
+          return renderErrorResult(text, { expanded, width, fallback: `${name} failed`, theme });
+        const summary = summaryLine(contract.title, { hidden: !!text && !expanded, theme, style: "success" });
+        return new Text7(clampLinesToWidth((expanded ? `${summary}
+${text}` : summary).split(`
 `), width).join(`
 `), 0, 0);
-    }
-  });
-}
-
-// src/extract.ts
-import { Text as Text8 } from "@earendil-works/pi-tui";
-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 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 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 {
-    await readSeekExtract(filePath, selector, outputPath, { signal, cancelable: false });
-    onFileMutated?.(outputPath);
-    return {
-      content: [{ type: "text", text: `Extracted ${selector} to ${outputPath}` }],
-      details: {
-        readSeekValue: {
-          tool: "extract",
-          ok: true,
-          path: filePath,
-          selector,
-          output: outputPath
-        }
       }
-    };
-  } catch (error) {
-    const failure = classifyReadSeekFailure(error);
-    return buildToolErrorResult("extract", failure.code, failure.message, failure.hint ? { hint: failure.hint } : {});
+    });
   }
 }
-function registerExtractTool(pi, options = {}) {
-  return registerReadSeekTool(pi, {
-    name: "readSeek_extract",
-    label: "Extract",
-    ...EXTRACT_PROMPT_METADATA,
-    parameters: Type12.Object({
-      path: filePathParam(),
-      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 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 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, width } = resolveRenderResultContext(options, rest);
-      if (isPartial)
-        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: false, width, fallback: "extract failed", theme });
-      }
-      return new Text8(clampLineToWidth(summaryLine(textContent || "asset extracted", { theme, style: "success" }), width), 0, 0);
-    }
-  });
-}
 
 // src/session-anchors.ts
 class SessionAnchors {
@@ -6003,30 +5594,37 @@ class SessionAnchors {
 
 // index.ts
 var READSEEK_TOOL_ENTRIES = [
-  { builtIn: "edit", readSeekName: "readSeek_edit" },
-  { builtIn: "grep", readSeekName: "readSeek_grep" },
-  { builtIn: null, readSeekName: "readSeek_search" },
-  { builtIn: null, readSeekName: "readSeek_refs" },
-  { builtIn: null, readSeekName: "readSeek_rename" },
-  { builtIn: "write", readSeekName: "readSeek_write" },
-  { builtIn: null, readSeekName: "readSeek_def" },
-  { builtIn: "read", readSeekName: "readSeek_inspect" },
-  { builtIn: null, readSeekName: "readSeek_extract" }
+  { builtIn: "edit", readSeekName: "readSeek_edit_text" },
+  { builtIn: "grep", readSeekName: "readSeek_find_text" },
+  { builtIn: null, readSeekName: "readSeek_find_nodes" },
+  { builtIn: null, readSeekName: "readSeek_find_references" },
+  { builtIn: null, readSeekName: "readSeek_rename_symbol" },
+  { builtIn: "write", readSeekName: "readSeek_write_file" },
+  { builtIn: null, readSeekName: "readSeek_find_definitions" },
+  { builtIn: "read", readSeekName: "readSeek_show_content" },
+  { builtIn: null, readSeekName: "readSeek_show_structure" },
+  { builtIn: null, readSeekName: "readSeek_show_metadata" },
+  { builtIn: null, readSeekName: "readSeek_show_assets" },
+  { builtIn: null, readSeekName: "readSeek_check_syntax" },
+  { builtIn: null, readSeekName: "readSeek_check_rules" },
+  { builtIn: null, readSeekName: "readSeek_generate_caption" },
+  { builtIn: null, readSeekName: "readSeek_detect_objects" },
+  { builtIn: null, readSeekName: "readSeek_recognize_text" }
 ];
 function piReadSeekExtension(pi) {
   const sessionAnchors = new SessionAnchors;
   const { settings } = resolveReadSeekJsonSettings();
   const replacedBuiltIns = new Set(settings.overrideTools ?? []);
   const swap = (builtIn, readSeekName) => replacedBuiltIns.has(builtIn) ? builtIn : readSeekName;
-  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 readName = swap("read", "readSeek_show_content");
+  const editName = swap("edit", "readSeek_edit_text");
+  const writeName = swap("write", "readSeek_write_file");
+  const grepName = swap("grep", "readSeek_find_text");
   const toolAliases = {
-    readSeek_inspect: readName,
-    readSeek_edit: editName,
-    readSeek_grep: grepName,
-    readSeek_write: writeName
+    readSeek_show_content: readName,
+    readSeek_edit_text: editName,
+    readSeek_find_text: grepName,
+    readSeek_write_file: writeName
   };
   const policyAliases = Object.fromEntries(TOOL_NAMES.map((name) => {
     const readSeekName = `readSeek_${name}`;
@@ -6046,15 +5644,12 @@ function piReadSeekExtension(pi) {
   registerRefsTool(pi, { onFileAnchored: (absolutePath) => sessionAnchors.markAnchored(absolutePath) });
   registerRenameTool(pi, { onFileMutated: (absolutePath) => sessionAnchors.forget(absolutePath) });
   registerDefTool(pi, { onFileAnchored: (absolutePath) => sessionAnchors.markAnchored(absolutePath) });
-  registerInspectTool(pi, {
+  registerAccessTools(pi, {
     onFileAnchored: (absolutePath) => sessionAnchors.markAnchored(absolutePath),
     name: readName,
     toolAliases,
     imageMode: replacedBuiltIns.has("read") ? resolveReadSeekImageMode() : undefined
   });
-  registerExtractTool(pi, {
-    onFileMutated: (absolutePath) => sessionAnchors.forget(absolutePath)
-  });
   registerWriteTool(pi, {
     onFileAnchored: (absolutePath) => sessionAnchors.markAnchored(absolutePath),
     name: writeName