opencode-readseek 0.10.7 → 0.11.1

package/dist/index.js

@@ -1,19 +1,11 @@
 // index.ts
-import path7 from "node:path";
+import path8 from "node:path";
 
 // src/client.ts
 import { createRequire as createRequire2 } from "node:module";
 import { stat } from "node:fs/promises";
 
 // ../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,228 +193,62 @@ 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"])
 ];
 // ../readseek-api/src/policy.ts
 var BUILTIN_FALLBACKS = {
-  read: "inspect",
-  edit: "edit",
-  write: "write",
-  grep: "grep",
-  apply_patch: "edit"
+  read: "show_content",
+  edit: "edit_text",
+  write: "write_file",
+  grep: "find_text",
+  apply_patch: "edit_text"
 };
 var PREFERENCE_LEADS = {
-  inspect: "Preferred for reading source with anchors and facets.",
-  edit: "Preferred for editing existing text files with fresh LINE:HASH anchors.",
-  write: "Preferred for creating or replacing a complete text file; returns LINE:HASH anchors.",
-  grep: "Preferred text/regex search; returns edit-ready LINE:HASH anchors.",
-  search: "Preferred for AST or structural code search with ast-grep-style patterns.",
-  def: "Preferred for go-to-definition or declaration lookup by name.",
-  refs: "Preferred for finding identifier-name matches or binding-specific references before rename or delete.",
-  rename: "Preferred for renaming a symbol with binding-aware, verified edits.",
-  extract: "Preferred for saving a selected document asset to a file."
+  show_content: "Preferred for reading source with anchors.",
+  edit_text: "Preferred for editing existing text files with fresh LINE:HASH anchors.",
+  write_file: "Preferred for creating or replacing a complete text file; returns LINE:HASH anchors.",
+  find_text: "Preferred text/regex find_nodes; returns edit_text-ready LINE:HASH anchors.",
+  find_nodes: "Preferred for AST or structural code find_nodes with ast-find_text-style patterns.",
+  find_definitions: "Preferred for go-to-definition or declaration lookup by name.",
+  find_references: "Preferred for finding identifier-name matches or binding-specific references before rename_symbol or delete.",
+  rename_symbol: "Preferred for renaming a symbol with binding-aware, verified edits.",
+  show_assets: "Preferred for saving a selected document asset to a file."
 };
 var FALLBACK_TEMPLATES = {
-  read: "Prefer `inspect` with fresh LINE:HASH anchors.",
-  edit: "Prefer `edit` with fresh LINE:HASH anchors.",
-  write: "Prefer `write` so the result returns LINE:HASH anchors.",
-  grep: "Prefer `grep` for text/regex search with edit-ready anchors.",
-  apply_patch: "Prefer `edit` for existing text files."
+  read: "Prefer `show_content` with fresh LINE:HASH anchors.",
+  edit: "Prefer `edit_text` with fresh LINE:HASH anchors.",
+  write: "Prefer `write_file` so the result returns LINE:HASH anchors.",
+  grep: "Prefer `find_text` for text/regex search with edit-ready anchors.",
+  apply_patch: "Prefer `edit_text` for existing text files."
 };
 function resolveToolName(name, aliases = {}) {
   return aliases[name] ?? name;
@@ -418,7 +257,7 @@ function rewriteBacktickedToolNames(text, aliases = {}) {
   return TOOL_NAMES.reduce((rewritten, toolName) => rewritten.replaceAll(`\`${toolName}\``, `\`${resolveToolName(toolName, aliases)}\``), text);
 }
 function renderPreferredToolDescription(name, aliases = {}) {
-  return rewriteBacktickedToolNames(PREFERENCE_LEADS[name], aliases);
+  return rewriteBacktickedToolNames(PREFERENCE_LEADS[name] ?? `Preferred for ${name.replaceAll("_", " ")} with ReadSeek.`, aliases);
 }
 function renderFallbackToolDescription(builtIn, aliases = {}) {
   const template = FALLBACK_TEMPLATES[builtIn];
@@ -428,20 +267,20 @@ function renderFallbackToolDescription(builtIn, 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(" ");
@@ -451,7 +290,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.`);
   }
@@ -486,25 +325,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 = {
@@ -574,51 +397,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);
@@ -645,30 +425,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`);
@@ -714,224 +470,840 @@ 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 { homedir } from "node:os";
-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}`;
+// ../readseek-api/src/client-output.ts
+import { Type } from "@sinclair/typebox";
+import { AssertError, Value } from "@sinclair/typebox/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,
+  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)
+  });
 }
-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`);
-  }
-  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 recursiveStructureNode() {
+  return Type.Recursive((self) => mapNodeShape(self));
 }
-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]
+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
+  }))
+});
+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)
+});
+var SourceAssetsOutput = Type.Object({ file: OptStr, metadata: Type.Optional(Detection), assets: Type.Array(DocumentAsset, { default: [] }) });
+
+// ../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/show-presentation.ts
+function isShowTool(name) {
+  return name === "show_content" || name === "show_structure" || name === "show_metadata" || name === "show_assets";
+}
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function records(value) {
+  return Array.isArray(value) ? value.map(record) : [];
+}
+function text(value) {
+  return typeof value === "string" ? value : "";
+}
+function count(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+function safe(value) {
+  return value.replace(/[\x00-\x09\x0b-\x1f\x7f-\x9f]/g, (char) => {
+    if (char === "\t")
+      return "\\t";
+    if (char === "\r")
+      return "\\r";
+    return `\\x${char.charCodeAt(0).toString(16).padStart(2, "0")}`;
+  });
+}
+function inline(value) {
+  return safe(text(value)).replaceAll(`
+`, "\\n");
+}
+function plural(n, unit) {
+  return `${n} ${unit}${n === 1 ? "" : "s"}`;
+}
+function fields(value, omit = []) {
+  return Object.entries(value).flatMap(([key, item]) => {
+    if (omit.includes(key) || item === undefined || item === null || typeof item === "object")
+      return [];
+    const label = key.replaceAll("_", " ");
+    return [`${label[0]?.toUpperCase() ?? ""}${label.slice(1)}: ${safe(String(item))}`];
+  }).join(`
+`);
+}
+function location(value) {
+  const start = text(value.start_anchor) || (count(value.start_line) !== undefined ? `${value.start_line}${text(value.start_hash) ? `:${value.start_hash}` : ""}` : "");
+  const end = text(value.end_anchor) || (count(value.end_line) !== undefined ? `${value.end_line}${text(value.end_hash) ? `:${value.end_hash}` : ""}` : "");
+  return start ? `  ${inline(start)}${end && end !== start ? ` - ${inline(end)}` : ""}` : "";
+}
+function sourceStructure(structure) {
+  const sections = [];
+  if (structure.root) {
+    const lines = [];
+    const stack = [{ node: record(structure.root), depth: 0 }];
+    while (stack.length > 0) {
+      const { node, depth } = stack.pop();
+      lines.push(`${"  ".repeat(Math.min(depth, 12))}${inline(node.kind) || "node"}${text(node.name) ? ` ${inline(node.name)}` : ""}${location(node)}`);
+      const children = records(node.children);
+      for (let i = children.length - 1;i >= 0; i--)
+        stack.push({ node: children[i], depth: depth + 1 });
+    }
+    sections.push(`Tree
+${lines.join(`
+`)}`);
+  }
+  const symbols = records(structure.symbols);
+  if (symbols.length > 0) {
+    sections.push(`Symbols
+${symbols.map((symbol) => `${inline(symbol.kind) || "symbol"} ${inline(symbol.qualified_name || symbol.name)}${location(symbol)}`).join(`
+`)}`);
+  }
+  return sections.join(`
+
+`) || "No structure found in this selection.";
+}
+function documentNodes(nodes, content) {
+  const depths = new Map;
+  return nodes.map((node) => {
+    const depth = Math.min((depths.get(text(node.parent_id)) ?? -1) + 1, 12);
+    depths.set(text(node.id), depth);
+    const indent = "  ".repeat(depth);
+    const label = inline(node.title) || inline(node.kind) || "node";
+    const page = count(node.page);
+    const selector = text(node.id) ? `node:${inline(node.id)}` : "";
+    const position = [selector, page !== undefined ? `page:${page}` : ""].filter(Boolean).join(" · ");
+    const heading = `${indent}${label}${position ? `  [${position}]` : ""}`;
+    const body = text(node.text);
+    return content && body ? `${heading}
+${safe(body).split(`
+`).map((line) => indent + line).join(`
+`)}` : heading;
+  }).join(content ? `
+
+` : `
+`);
+}
+function assetList(assets) {
+  return assets.map((asset) => {
+    const id = text(asset.id);
+    const page = count(asset.page);
+    const heading = [id ? `asset:${inline(id)}` : inline(asset.kind) || "image", inline(asset.mime), page !== undefined ? `page:${page}` : ""].filter(Boolean).join(" · ");
+    const details = fields(asset, ["id", "kind", "mime", "page", "bbox", "content_identity"]);
+    return `${heading}${details ? `
+${details.split(`
+`).map((line) => `  ${line}`).join(`
+`)}` : ""}`;
+  }).join(`
+
+`);
+}
+function presentShowResult(tool, value, options = {}) {
+  const output = record(value);
+  const metadata = record(output.metadata);
+  const content = record(output.content);
+  const cursor = record(output.cursor);
+  const structure = record(output.structure);
+  const document = typeof output.format === "string" && (Array.isArray(output.nodes) || typeof output.source === "string");
+  const path = inline(options.path || output.source || output.file || content.file || structure.file || metadata.file || cursor.file) || "(unknown path)";
+  const summary = [];
+  const result = { summary: "", body: "", notices: [], metadata: {} };
+  if (tool === "show_metadata") {
+    const data = Object.keys(metadata).length > 0 ? metadata : output;
+    if (text(data.format || data.language || data.type))
+      summary.push(inline(data.format || data.language || data.type));
+    if (count(data.pages) !== undefined) {
+      result.metadata.pages = data.pages;
+      summary.push(plural(result.metadata.pages, "page"));
+    }
+    result.body = fields(data) || "No metadata available.";
+  } else if (tool === "show_assets") {
+    const assets = records(output.assets);
+    result.metadata.assets = assets.length;
+    summary.push(plural(assets.length, "asset"));
+    result.body = assetList(assets) || "No assets in this selection.";
+  } else if (document) {
+    const nodes = records(output.nodes);
+    const assets = records(output.assets);
+    result.metadata.nodes = nodes.length;
+    if (count(output.pages) !== undefined)
+      result.metadata.pages = output.pages;
+    summary.push(plural(nodes.length, "node"));
+    if (result.metadata.pages !== undefined)
+      summary.push(plural(result.metadata.pages, "page"));
+    const sections = [text(output.title) ? safe(text(output.title)) : "", documentNodes(nodes, tool === "show_content")];
+    if (assets.length > 0) {
+      result.metadata.assets = assets.length;
+      sections.push(`Assets
+${assetList(assets)}`);
+    }
+    result.body = sections.filter(Boolean).join(`
+
+`) || "No content in this selection.";
+  } else if (tool === "show_structure") {
+    const symbols = records(structure.symbols);
+    result.metadata.symbols = symbols.length;
+    summary.push(plural(symbols.length, "symbol"));
+    result.body = sourceStructure(structure);
+  } else if (content.kind === "image" || count(content.width) !== undefined && count(content.height) !== undefined || count(metadata.width) !== undefined && count(metadata.height) !== undefined || text(content.mime).startsWith("image/") || text(metadata.mime).startsWith("image/") || text(metadata.type).startsWith("image/")) {
+    const description = Object.keys(content).length > 0 ? content : Object.keys(metadata).length > 0 ? metadata : output;
+    if (count(description.width) !== undefined && count(description.height) !== undefined) {
+      summary.push(`${description.width} × ${description.height}`);
+    } else if (count(metadata.width) !== undefined && count(metadata.height) !== undefined) {
+      summary.push(`${metadata.width} × ${metadata.height}`);
+    }
+    const mime = text(description.mime || metadata.mime || metadata.type);
+    if (mime)
+      summary.push(inline(mime));
+    result.body = fields(description, ["hashlines"]) || fields(metadata) || "No content in this selection.";
+  } else if (Array.isArray(content.hashlines) || Array.isArray(cursor.hashlines)) {
+    const lines = records(content.hashlines ?? cursor.hashlines);
+    const start = count(content.start_line) ?? count(lines[0]?.line);
+    const end = count(content.end_line) ?? count(lines.at(-1)?.line);
+    const total = count(content.line_count) ?? count(cursor.line_count);
+    if (start !== undefined && end !== undefined && start <= end) {
+      result.metadata.start_line = start;
+      result.metadata.end_line = end;
+      summary.push(`lines ${start}-${end}${total !== undefined ? ` of ${total}` : ""}`);
+    } else
+      summary.push(plural(lines.length, "line"));
+    const lang = text(metadata.language || content.language);
+    if (lang)
+      summary.push(inline(lang));
+    const rows = lines.map((line) => `${line.line}${options.noAnchors ? "" : `:${text(line.hash)}`} | ${safe(text(line.text)).replaceAll("\\n", "\\\\n")}`);
+    const identifier = record(cursor.identifier);
+    if (count(cursor.line) !== undefined)
+      result.metadata.line = cursor.line;
+    if (count(cursor.column) !== undefined)
+      result.metadata.column = cursor.column;
+    if (Object.keys(cursor).length > 0) {
+      const symbol = record(cursor.symbol);
+      const description = [text(identifier.text), text(symbol.qualified_name || symbol.name), text(symbol.kind)].filter(Boolean);
+      rows.unshift(`Cursor: ${cursor.line ?? "?"}:${cursor.column ?? "?"}${description.length > 0 ? ` · ${[...new Set(description)].map(inline).join(" · ")}` : ""}`, "");
+    }
+    result.body = rows.join(`
+`) || "Empty source selection.";
+    if (start !== undefined && start > 1)
+      result.notices.push(`Earlier lines omitted. Read preceding content with at: line:1 and limit: ${start - 1}.`);
+    if (end !== undefined && total !== undefined && end < total) {
+      result.notices.push(`More lines available. Continue with at: line:${end + 1}.`);
+    } else if (content.truncated === true && (end === undefined || total === undefined)) {
+      result.notices.push(`Content is truncated.${end !== undefined ? ` Continue with at: line:${end + 1}.` : " Select a smaller range with at and limit."}`);
+    }
+  } else {
+    const description = Object.keys(content).length > 0 ? content : output;
+    result.body = fields(description) || "No content in this selection.";
+  }
+  if (tool === "show_structure")
+    result.notices.push("Structure is limited to the requested depth, kind, and outline. Use a deeper depth or focus with at to inspect further.");
+  if (text(output.warning))
+    result.notices.push(safe(text(output.warning)));
+  result.summary = summary.join(" · ") || "complete";
+  return result;
+}
+function formatShowResult(presentation) {
+  return [presentation.summary, presentation.body, ...presentation.notices.map((notice) => `Note: ${notice}`)].filter(Boolean).join(`
+
+`);
+}
+// ../readseek-api/src/platform.ts
+import { accessSync, constants as fsConstants, existsSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+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 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`);
+  }
+  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 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 = path.join(path.dirname(packageJsonPath), "bin", readSeekBinaryName(platform));
+  const binaryPath = path2.join(path2.dirname(packageJsonPath), "bin", readSeekBinaryName(platform));
   accessSync(binaryPath, fsConstants.X_OK);
   return binaryPath;
 }
@@ -942,18 +1314,18 @@ function resolveReadSeekCacheDir(subPath, options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const localDirName = options.localDirName ?? ".readseek";
   if (localDirName && localDirName.length > 0) {
-    const local = path.join(cwd, localDirName);
+    const local = path2.join(cwd, localDirName);
     if (existsSync(local))
       return local;
   }
   let base;
   if (platform === "win32") {
-    base = env.LOCALAPPDATA ?? path.join(home, "AppData", "Local");
+    base = env.LOCALAPPDATA ?? path2.join(home, "AppData", "Local");
   } else {
     const xdg = env.XDG_CACHE_HOME?.trim();
-    base = xdg && path.isAbsolute(xdg) ? xdg : path.join(home, ".cache");
+    base = xdg && path2.isAbsolute(xdg) ? xdg : path2.join(home, ".cache");
   }
-  const pathModule = platform === "win32" ? path.win32 : path;
+  const pathModule = platform === "win32" ? path2.win32 : path2;
   if (subPath === undefined) {
     return pathModule.join(base, "readseek");
   }
@@ -961,10 +1333,10 @@ function resolveReadSeekCacheDir(subPath, options = {}) {
   return pathModule.join(base, ...parts);
 }
 // ../readseek-api/src/path.ts
-import path2 from "node:path";
+import path3 from "node:path";
 function isSubPath(parent, candidate) {
-  const relative = path2.relative(parent, candidate);
-  return relative === "" || !relative.startsWith(`..${path2.sep}`) && relative !== ".." && !path2.isAbsolute(relative);
+  const relative = path3.relative(parent, candidate);
+  return relative === "" || !relative.startsWith(`..${path3.sep}`) && relative !== ".." && !path3.isAbsolute(relative);
 }
 // ../readseek-api/src/error.ts
 var READSEEK_USAGE_HINT = /(?:^|\n)\s*Run readseek(?: [\w-]+)* --help for more information\.?\s*$/;
@@ -1011,634 +1383,420 @@ function properties(node) {
   return Object.fromEntries(node.properties);
 }
 function children(node, name) {
-  return node.children.filter((child) => child.name === name);
-}
-function child(node, name) {
-  return node.children.find((candidate) => candidate.name === name);
-}
-function requireProperty(node, name) {
-  const value = node.properties.get(name);
-  if (value === undefined)
-    throw new Error(`invalid readseek KDL: ${node.name} is missing '${name}'`);
-  return value;
-}
-function line(node) {
-  const anchor = requireProperty(node, "anchor");
-  const content = requireProperty(node, "content");
-  if (typeof anchor !== "string" || typeof content !== "string") {
-    throw new Error("invalid readseek KDL line");
-  }
-  const match = /^(\d+):([0-9a-f]+)$/.exec(anchor);
-  if (!match)
-    throw new Error(`invalid readseek KDL line anchor: ${anchor}`);
-  return {
-    line: Number(match[1]),
-    hash: match[2],
-    text: content
-  };
-}
-function mapNode(node) {
-  return {
-    ...properties(node),
-    children: children(node, "node").map(mapNode)
-  };
-}
-function sourceContent(node) {
-  const result = properties(node);
-  result.hashlines = children(node, "line").map(line);
-  const objects = children(node, "object");
-  if (objects.length > 0) {
-    result.objects = objects.map((object) => ({
-      label: requireProperty(object, "label"),
-      bbox: [
-        requireProperty(object, "xmin"),
-        requireProperty(object, "ymin"),
-        requireProperty(object, "xmax"),
-        requireProperty(object, "ymax")
-      ]
-    }));
-  }
-  return result;
-}
-function sourceMap(node) {
-  const root = child(node, "node");
-  return {
-    ...properties(node),
-    ...root ? { root: mapNode(root) } : {},
-    symbols: children(node, "symbol").map(properties)
-  };
-}
-function diagnostics(node) {
-  return {
-    ...properties(node),
-    diagnostics: children(node, "diagnostic").map(properties)
-  };
-}
-function identity(node) {
-  const result = properties(node);
-  const identifier = child(node, "identifier");
-  const symbol = child(node, "symbol");
-  if (identifier)
-    result.identifier = properties(identifier);
-  if (symbol)
-    result.symbol = properties(symbol);
-  return result;
-}
-function sourceDocument(root) {
-  const result = {};
-  const metadata = child(root, "metadata");
-  const cache = child(root, "cache");
-  const content = child(root, "content");
-  const map = child(root, "map");
-  const diagnosticOutput = child(root, "diagnostics");
-  const identityOutput = child(root, "identity");
-  if (metadata)
-    result.metadata = properties(metadata);
-  if (cache)
-    result.cache = properties(cache);
-  if (content)
-    result.content = sourceContent(content);
-  if (map)
-    result.map = sourceMap(map);
-  if (diagnosticOutput)
-    result.diagnostics = diagnostics(diagnosticOutput);
-  if (identityOutput)
-    result.identity = identity(identityOutput);
-  return result;
-}
-function hit(node) {
-  return {
-    ...properties(node),
-    hashlines: children(node, "line").map(line),
-    captures: children(node, "capture").map((capture) => ({
-      ...properties(capture),
-      hashlines: children(capture, "line").map(line)
-    }))
-  };
-}
-function search(root) {
-  return {
-    ...properties(root),
-    results: children(root, "match").map((match) => ({
-      ...properties(match),
-      matches: children(match, "hit").map(hit)
-    })),
-    documents: children(root, "document").map((documentNode) => ({
-      ...properties(documentNode),
-      hits: children(documentNode, "hit").map(properties)
-    }))
-  };
-}
-function references(root) {
-  const parsed = children(root, "reference").map((reference) => {
-    const sourceLine = child(reference, "line");
-    if (!sourceLine)
-      throw new Error("invalid readseek KDL reference: missing line");
-    const parsedLine = line(sourceLine);
-    const symbol = child(reference, "symbol");
-    return {
-      ...properties(reference),
-      line_hash: parsedLine.hash,
-      text: parsedLine.text,
-      ...symbol ? { symbol: properties(symbol) } : {}
-    };
-  });
-  return {
-    references: parsed,
-    locations: parsed.map((reference) => {
-      const { symbol, ...location } = reference;
-      return symbol && typeof symbol === "object" ? { ...location, ...symbol } : location;
-    })
-  };
-}
-function definitions(root) {
-  return {
-    locations: children(root, "definition").map((definition) => {
-      const symbol = child(definition, "symbol");
-      const sourceLine = child(definition, "line");
-      if (!symbol || !sourceLine) {
-        throw new Error("invalid readseek KDL definition: missing symbol or line");
-      }
-      const symbolProperties = properties(symbol);
-      const parsedLine = line(sourceLine);
-      const definitionColumn = definition.properties.get("column");
-      const nameByte = symbol.properties.get("name_byte");
-      const startByte = symbol.properties.get("start_byte");
-      let column = 1;
-      if (typeof definitionColumn === "number") {
-        column = definitionColumn;
-      } else if (typeof nameByte === "number" && typeof startByte === "number") {
-        column = nameByte - startByte + 1;
-      }
-      return {
-        file: requireProperty(definition, "file"),
-        line: parsedLine.line,
-        column,
-        line_hash: parsedLine.hash,
-        text: parsedLine.text,
-        kind: symbolProperties.kind,
-        name: symbolProperties.name,
-        qualified_name: symbolProperties.qualified_name
-      };
-    })
-  };
-}
-function edit(root) {
-  const result = properties(root);
-  for (const name of ["before_content", "content"]) {
-    const contentNode = child(root, name);
-    if (contentNode)
-      result[name] = requireProperty(contentNode, "content");
-  }
-  return result;
-}
-function renameEdit(node) {
-  const sourceLine = child(node, "line");
-  if (!sourceLine)
-    throw new Error("invalid readseek KDL rename edit: missing line");
-  return {
-    ...properties(node),
-    text: requireProperty(sourceLine, "content")
-  };
-}
-function renameFile(node) {
-  return {
-    ...properties(node),
-    edits: children(node, "edit").map(renameEdit),
-    conflicts: children(node, "conflict").map(properties)
-  };
-}
-function rename(root) {
-  return {
-    ...renameFile(root),
-    others: children(root, "other").map(renameFile)
-  };
-}
-function genericNode(node) {
-  const result = properties(node);
-  const textNode = child(node, "text");
-  const bbox = child(node, "bbox");
-  if (textNode)
-    result.text = requireProperty(textNode, "content");
-  if (bbox)
-    result.bbox = properties(bbox);
-  const objects = children(node, "object");
-  if (objects.length > 0)
-    result.objects = objects.map(genericNode);
-  return result;
-}
-function pdfDocument(root) {
-  return {
-    ...properties(root),
-    nodes: children(root, "node").map(genericNode),
-    assets: children(root, "asset").map(genericNode),
-    vision: children(root, "vision").map(genericNode)
-  };
-}
-function parseReadSeekKdl(text) {
-  const root = parseKdlDocument(text);
-  switch (root.name) {
-    case "document":
-      return root.properties.has("format") ? pdfDocument(root) : sourceDocument(root);
-    case "search":
-      return search(root);
-    case "check":
-      return diagnostics(root);
-    case "refs":
-      return references(root);
-    case "def":
-      return definitions(root);
-    case "edit":
-      return edit(root);
-    case "edit-batch":
-      return { ...properties(root), files: children(root, "file").map(edit) };
-    case "rename":
-      return rename(root);
-    default:
-      throw new Error(`unsupported readseek KDL root: ${root.name}`);
-  }
+  return node.children.filter((child) => child.name === 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 child(node, name) {
+  return node.children.find((candidate) => candidate.name === name);
 }
-function resolveProcessLimits(options = {}) {
+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 {
-    timeoutMs: options.timeoutMs ?? DEFAULT_READSEEK_TIMEOUT_MS,
-    maxOutputBytes: options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES,
-    cancelable: options.cancelable !== false
+    line: Number(match[1]),
+    hash: match[2],
+    text: content
   };
 }
-function readSeekCancellationError(signal) {
-  const reason = signal?.reason;
-  return reason instanceof Error && reason.name !== "AbortError" ? reason : new Error("readseek cancelled");
+function mapNode(node) {
+  return {
+    ...properties(node),
+    children: children(node, "node").map(mapNode)
+  };
 }
-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`);
+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")
+      ]
+    }));
   }
-  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}`);
+  return result;
 }
-function ensureSuccessfulStdout(result) {
-  if (result.exitCode === 0)
-    return result.stdout;
-  throw failureFromProcessResult(result);
+function sourceMap(node) {
+  const root = child(node, "node");
+  return {
+    ...properties(node),
+    ...root ? { root: mapNode(root) } : {},
+    symbols: children(node, "symbol").map(properties)
+  };
 }
-function parseSuccessfulKdl(result) {
-  return parseReadSeekKdl(ensureSuccessfulStdout(result));
+function diagnostics(node) {
+  return {
+    ...properties(node),
+    diagnostics: children(node, "diagnostic").map(properties)
+  };
 }
-// ../readseek-api/src/process-bun.ts
-function getBunSpawn() {
-  const bunGlobal = globalThis;
-  const spawn = bunGlobal.Bun?.spawn;
-  if (typeof spawn !== "function") {
-    throw new Error("Bun.spawn is unavailable in this runtime");
-  }
-  return spawn;
+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;
 }
-async function readBoundedText(stream, streamName, maxOutputBytes, onOverflow) {
-  const reader = stream.getReader();
-  const chunks = [];
-  let totalBytes = 0;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done)
-        break;
-      totalBytes += value.byteLength;
-      if (totalBytes > maxOutputBytes) {
-        onOverflow();
-        await reader.cancel().catch(() => {
-          return;
-        });
-        throw failureFromProcessResult({ stdout: "", stderr: "", exitCode: null, signal: null }, { overflow: streamName, maxOutputBytes });
-      }
-      chunks.push(value);
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  const bytes = new Uint8Array(totalBytes);
-  let offset = 0;
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return new TextDecoder().decode(bytes);
+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;
 }
-async function runReadSeekBun(binaryPath, args, options = {}) {
-  const limits = resolveProcessLimits(options);
-  if (limits.cancelable && options.signal?.aborted) {
-    throw readSeekCancellationError(options.signal);
-  }
-  const spawn = getBunSpawn();
-  const stdin = options.stdin === undefined ? undefined : new TextEncoder().encode(options.stdin);
-  const spawnOptions = {
-    cwd: options.cwd,
-    env: readSeekProcessEnvironment(),
-    stderr: "pipe",
-    stdin,
-    stdout: "pipe"
-  };
-  const child = spawn([binaryPath, ...args], limits.cancelable && options.signal ? { ...spawnOptions, killSignal: "SIGKILL", signal: options.signal } : spawnOptions);
-  const killForOverflow = () => {
-    try {
-      child.kill("SIGKILL");
-    } catch {}
+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)
+    }))
   };
-  let timeout;
-  const timeoutResult = new Promise((_resolve, reject) => {
-    timeout = setTimeout(() => {
-      try {
-        child.kill("SIGKILL");
-      } catch {}
-      reject(failureFromProcessResult({ stdout: "", stderr: "", exitCode: null, signal: null }, { timedOut: true, timeoutMs: limits.timeoutMs }));
-    }, limits.timeoutMs);
-    timeout.unref?.();
-  });
-  const pending = Promise.all([
-    readBoundedText(child.stdout, "stdout", limits.maxOutputBytes, killForOverflow),
-    readBoundedText(child.stderr, "stderr", limits.maxOutputBytes, killForOverflow),
-    child.exited
-  ]);
-  try {
-    const [stdout, stderr, exitCode] = await Promise.race([pending, timeoutResult]);
-    if (limits.cancelable && options.signal?.aborted)
-      throw readSeekCancellationError(options.signal);
-    return { stdout, stderr, exitCode, signal: null };
-  } finally {
-    if (timeout !== undefined)
-      clearTimeout(timeout);
-    pending.catch(() => {
-      return;
-    });
-  }
-}
-async function runReadSeekBunText(binaryPath, args, options = {}) {
-  return ensureSuccessfulStdout(await runReadSeekBun(binaryPath, args, options));
 }
-async function runReadSeekBunKdl(binaryPath, args, options = {}) {
-  return parseSuccessfulKdl(await runReadSeekBun(binaryPath, args, options));
+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)
+    }))
+  };
 }
-// ../readseek-api/src/client-output.ts
-import { Type } from "@sinclair/typebox";
-import { AssertError, Value } from "@sinclair/typebox/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 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 recursiveMapNode() {
-  return Type.Recursive((self) => mapNodeShape(self));
+function definitions(root) {
+  return {
+    locations: children(root, "definition").map((definition) => {
+      const symbol = child(definition, "symbol");
+      const sourceLine = child(definition, "line");
+      if (!symbol || !sourceLine) {
+        throw new Error("invalid readseek KDL definition: missing symbol or line");
+      }
+      const symbolProperties = properties(symbol);
+      const parsedLine = line(sourceLine);
+      const definitionColumn = definition.properties.get("column");
+      const nameByte = symbol.properties.get("name_byte");
+      const startByte = symbol.properties.get("start_byte");
+      let column = 1;
+      if (typeof definitionColumn === "number") {
+        column = definitionColumn;
+      } else if (typeof nameByte === "number" && typeof startByte === "number") {
+        column = nameByte - startByte + 1;
+      }
+      return {
+        file: requireProperty(definition, "file"),
+        line: parsedLine.line,
+        column,
+        line_hash: parsedLine.hash,
+        text: parsedLine.text,
+        kind: symbolProperties.kind,
+        name: symbolProperties.name,
+        qualified_name: symbolProperties.qualified_name
+      };
+    })
+  };
+}
+function edit(root) {
+  const result = properties(root);
+  for (const name of ["before_content", "content"]) {
+    const contentNode = child(root, name);
+    if (contentNode)
+      result[name] = requireProperty(contentNode, "content");
+  }
+  return result;
+}
+function renameEdit(node) {
+  const sourceLine = child(node, "line");
+  if (!sourceLine)
+    throw new Error("invalid readseek KDL rename edit: missing line");
+  return {
+    ...properties(node),
+    text: requireProperty(sourceLine, "content")
+  };
+}
+function renameFile(node) {
+  return {
+    ...properties(node),
+    edits: children(node, "edit").map(renameEdit),
+    conflicts: children(node, "conflict").map(properties)
+  };
+}
+function rename(root) {
+  return {
+    ...renameFile(root),
+    others: children(root, "other").map(renameFile)
+  };
+}
+function genericNode(node) {
+  const result = properties(node);
+  const textNode = child(node, "text");
+  const bbox = child(node, "bbox");
+  if (textNode)
+    result.text = requireProperty(textNode, "content");
+  if (bbox)
+    result.bbox = properties(bbox);
+  const objects = children(node, "object");
+  if (objects.length > 0)
+    result.objects = objects.map((object) => ({
+      label: requireProperty(object, "label"),
+      bbox: [requireProperty(object, "x0"), requireProperty(object, "y0"), requireProperty(object, "x1"), requireProperty(object, "y1")]
+    }));
+  return result;
+}
+function pdfDocument(root) {
+  return {
+    ...properties(root),
+    nodes: children(root, "node").map(genericNode),
+    assets: children(root, "asset").map(genericNode),
+    vision: children(root, "vision").map(genericNode)
+  };
+}
+function parseReadSeekKdl(text) {
+  const root = parseKdlDocument(text);
+  switch (root.name) {
+    case "document":
+      return root.properties.has("format") ? pdfDocument(root) : sourceDocument(root);
+    case "search":
+      return search(root);
+    case "check":
+      return diagnostics(root);
+    case "refs":
+      return references(root);
+    case "def":
+      return definitions(root);
+    case "edit":
+      return edit(root);
+    case "edit-batch":
+      return { ...properties(root), files: children(root, "file").map(edit) };
+    case "rename":
+      return rename(root);
+    default:
+      throw new Error(`unsupported readseek KDL root: ${root.name}`);
+  }
+}
+// ../readseek-api/src/process.ts
+var DEFAULT_READSEEK_TIMEOUT_MS = 120000;
+var DEFAULT_MAX_OUTPUT_BYTES = 32 * 1024 * 1024;
+function readSeekProcessEnvironment() {
+  return process.platform === "linux" ? { ...process.env, APPIMAGE_EXTRACT_AND_RUN: "1" } : process.env;
+}
+function resolveProcessLimits(options = {}) {
+  return {
+    timeoutMs: options.timeoutMs ?? DEFAULT_READSEEK_TIMEOUT_MS,
+    maxOutputBytes: options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES,
+    cancelable: options.cancelable !== false
+  };
+}
+function readSeekCancellationError(signal) {
+  const reason = signal?.reason;
+  return reason instanceof Error && reason.name !== "AbortError" ? reason : new Error("readseek cancelled");
+}
+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 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 ensureSuccessfulStdout(result, args = []) {
+  if (!result.signal && acceptsReadSeekExitCode(args, result.exitCode))
+    return result.stdout;
+  throw failureFromProcessResult(result);
+}
+function parseSuccessfulKdl(result, args = []) {
+  return parseReadSeekKdl(ensureSuccessfulStdout(result, args));
+}
+// ../readseek-api/src/process-bun.ts
+function getBunSpawn() {
+  const bunGlobal = globalThis;
+  const spawn = bunGlobal.Bun?.spawn;
+  if (typeof spawn !== "function") {
+    throw new Error("Bun.spawn is unavailable in this runtime");
+  }
+  return spawn;
+}
+async function readBoundedText(stream, streamName, maxOutputBytes, onOverflow) {
+  const reader = stream.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      totalBytes += value.byteLength;
+      if (totalBytes > maxOutputBytes) {
+        onOverflow();
+        await reader.cancel().catch(() => {
+          return;
+        });
+        throw failureFromProcessResult({ stdout: "", stderr: "", exitCode: null, signal: null }, { overflow: streamName, maxOutputBytes });
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(bytes);
+}
+async function runReadSeekBun(binaryPath, args, options = {}) {
+  const limits = resolveProcessLimits(options);
+  if (limits.cancelable && options.signal?.aborted) {
+    throw readSeekCancellationError(options.signal);
+  }
+  const spawn = getBunSpawn();
+  const stdin = options.stdin === undefined ? undefined : new TextEncoder().encode(options.stdin);
+  const spawnOptions = {
+    cwd: options.cwd,
+    env: readSeekProcessEnvironment(),
+    stderr: "pipe",
+    stdin,
+    stdout: "pipe"
+  };
+  const child = spawn([binaryPath, ...args], limits.cancelable && options.signal ? { ...spawnOptions, killSignal: "SIGKILL", signal: options.signal } : spawnOptions);
+  const killForOverflow = () => {
+    try {
+      child.kill("SIGKILL");
+    } catch {}
+  };
+  let timeout;
+  const timeoutResult = new Promise((_resolve, reject) => {
+    timeout = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {}
+      reject(failureFromProcessResult({ stdout: "", stderr: "", exitCode: null, signal: null }, { timedOut: true, timeoutMs: limits.timeoutMs }));
+    }, limits.timeoutMs);
+    timeout.unref?.();
+  });
+  const pending = Promise.all([
+    readBoundedText(child.stdout, "stdout", limits.maxOutputBytes, killForOverflow),
+    readBoundedText(child.stderr, "stderr", limits.maxOutputBytes, killForOverflow),
+    child.exited
+  ]);
+  try {
+    const [stdout, stderr, exitCode] = await Promise.race([pending, timeoutResult]);
+    if (limits.cancelable && options.signal?.aborted)
+      throw readSeekCancellationError(options.signal);
+    return { stdout, stderr, exitCode, signal: null };
+  } finally {
+    if (timeout !== undefined)
+      clearTimeout(timeout);
+    pending.catch(() => {
+      return;
+    });
+  }
+}
+async function runReadSeekBunText(binaryPath, args, options = {}) {
+  return ensureSuccessfulStdout(await runReadSeekBun(binaryPath, args, options), args);
+}
+async function runReadSeekBunKdl(binaryPath, args, options = {}) {
+  return parseSuccessfulKdl(await runReadSeekBun(binaryPath, args, options), args);
 }
-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
-  }))
-});
 // src/util.ts
-import path3 from "node:path";
+import path4 from "node:path";
 function render(value) {
   return JSON.stringify(value, null, 2);
 }
-function record(value) {
+function record2(value) {
   return value && typeof value === "object" ? value : {};
 }
 function items(value) {
@@ -1663,21 +1821,21 @@ function collectAnchoredFiles(value, files) {
     return;
   const output = value;
   const hashlines = output.hashlines;
-  if (typeof output.file === "string" && Array.isArray(hashlines) && hashlines.some((line) => typeof record(line).line === "number" && typeof record(line).hash === "string"))
+  if (typeof output.file === "string" && Array.isArray(hashlines) && hashlines.some((line) => typeof record2(line).line === "number" && typeof record2(line).hash === "string"))
     files.add(output.file);
   for (const item of Object.values(output))
     collectAnchoredFiles(item, files);
 }
 function renameFiles(value, directory = process.cwd()) {
-  const output = record(value);
+  const output = record2(value);
   const files = [];
   if (typeof output.file === "string" && items(output.edits).length > 0) {
-    files.push(path3.resolve(directory, output.file));
+    files.push(path4.resolve(directory, output.file));
   }
   for (const other of items(output.others)) {
-    const item = record(other);
+    const item = record2(other);
     if (typeof item.file === "string" && items(item.edits).length > 0) {
-      files.push(path3.resolve(directory, item.file));
+      files.push(path4.resolve(directory, item.file));
     }
   }
   return files;
@@ -1728,21 +1886,18 @@ function resolveImagePolicy(options) {
     return value;
   throw new Error('opencode-readseek imageMode must be "on", "auto", or "off"');
 }
-function inspectArgs(filePath, select, options = {}) {
-  return buildInspectArgs({ path: filePath, select, ...options });
+function contentArgs(filePath, options = {}) {
+  return buildShowContentArgs({ path: filePath, ...options, at: options.at ?? (options.end === undefined ? undefined : "line:1") });
 }
-function requireInspectFacet(envelope, facet) {
-  const value = record(envelope)[facet];
+function requireContent(envelope) {
+  const value = record2(envelope).content;
   if (value === undefined || value === null || typeof value !== "object") {
-    throw new Error(`inspect returned no ${facet} facet`);
+    throw new Error("show content returned no source content");
   }
   return value;
 }
 function readRangeArgs(filePath, start, end) {
-  return inspectArgs(filePath, "content", {
-    selector: start > 1 ? `line:${start}` : undefined,
-    end
-  });
+  return contentArgs(filePath, { at: `line:${start}`, end });
 }
 function readSeekBinaryPath() {
   return resolveReadSeekBinaryOverride() ?? resolveReadSeekBinaryFromPackages(resolveFromHost);
@@ -1779,12 +1934,12 @@ async function runReadSeek(context, args, options = {}) {
     timeoutMs: options.timeoutMs
   }));
 }
-async function runInspectContent(context, args, options = {}) {
-  return requireInspectFacet(await runReadSeek(context, args, options), "content");
+async function runContent(context, args, options = {}) {
+  return requireContent(await runReadSeek(context, args, options));
 }
 async function postMutationPreview(context, args, filePath, changed) {
   try {
-    return await runInspectContent(context, args, {
+    return await runContent(context, args, {
       cancelable: false,
       timeoutMs: DEFAULT_READSEEK_TIMEOUT_MS
     });
@@ -1813,7 +1968,7 @@ async function ensureReadSeekCache(context) {
     if (error.code !== "ENOENT")
       throw error;
   }
-  readSeekCacheInit ??= runReadSeekRaw(context, ["--readseek-dir", cacheDir, "init"], { cancelable: false }).then(() => cacheDir).finally(() => {
+  readSeekCacheInit ??= runReadSeekRaw(context, ["--readseek-dir", cacheDir, "initialize", "index"], { cancelable: false }).then(() => cacheDir).finally(() => {
     readSeekCacheInit = undefined;
   });
   return readSeekCacheInit;
@@ -1833,7 +1988,7 @@ function openCodeToolDescription(name) {
 }
 
 // src/session-anchors.ts
-import path4 from "node:path";
+import path5 from "node:path";
 
 class SessionAnchors {
   #pathsBySession = new Map;
@@ -1847,7 +2002,7 @@ class SessionAnchors {
     paths.add(filePath);
   }
   forget(filePath) {
-    const absolutePath = path4.resolve(filePath);
+    const absolutePath = path5.resolve(filePath);
     for (const paths of this.#pathsBySession.values())
       paths.delete(absolutePath);
     for (const [sessionID, plan] of this.#renamePlans) {
@@ -1870,14 +2025,14 @@ class SessionAnchors {
     const { file, old_name: oldName, new_name: newName, others } = record;
     if (typeof file !== "string" || typeof oldName !== "string" || typeof newName !== "string")
       return;
-    const files = new Set([path4.resolve(file)]);
+    const files = new Set([path5.resolve(file)]);
     if (Array.isArray(others)) {
       for (const item of others) {
         if (!item || typeof item !== "object")
           continue;
         const otherFile = item.file;
         if (typeof otherFile === "string")
-          files.add(path4.resolve(otherFile));
+          files.add(path5.resolve(otherFile));
       }
     }
     this.#renamePlans.set(sessionID, { summary: `${oldName} -> ${newName}`, files });
@@ -1903,22 +2058,21 @@ ${[...paths].sort().map((filePath) => `- ${filePath}`).join(`
 
 // src/tools.ts
 import { readFile as readFile2, stat as stat3 } from "node:fs/promises";
-import { tool as tool2 } from "@opencode-ai/plugin";
+import { tool as tool3 } from "@opencode-ai/plugin";
 
 // src/constants.ts
 var DEFAULT_VISION_TIMEOUT_MS = 30 * 60 * 1000;
 var DEFAULT_READ_LIMIT = 2000;
 var EDIT_RESULT_READ_LIMIT = 40;
 var MAX_PERMISSION_DIFF_BYTES = 32 * 1024;
-var IMAGE_MODES = [...VISION_MODES];
 var VISION_LEVEL_VALUES = [...VISION_LEVELS];
 
 // src/edits.ts
 import { lstat, mkdir, open, readFile } from "node:fs/promises";
-import path5 from "node:path";
+import path6 from "node:path";
 var fileMutationTails = new Map;
 async function withFileMutationQueue(filePath, operation) {
-  const key = path5.resolve(filePath);
+  const key = path6.resolve(filePath);
   const previous = fileMutationTails.get(key);
   let release = () => {};
   const current = new Promise((resolve) => {
@@ -1973,7 +2127,7 @@ async function writeHandle(handle, content) {
   }
 }
 async function writeText(filePath, expected, content) {
-  await mkdir(path5.dirname(filePath), { recursive: true });
+  await mkdir(path6.dirname(filePath), { recursive: true });
   if (!expected.exists) {
     let handle;
     try {
@@ -2105,20 +2259,20 @@ function simpleDiff(filePath, before, after) {
 
 // src/paths.ts
 import { lstat as lstat2, readlink, realpath, stat as stat2 } from "node:fs/promises";
-import path6 from "node:path";
+import path7 from "node:path";
 function resolvePath(directory, filePath) {
-  return path6.resolve(directory, filePath);
+  return path7.resolve(directory, filePath);
 }
 async function resolveSymlinks(filePath) {
-  let unresolved = path6.resolve(filePath);
+  let unresolved = path7.resolve(filePath);
   let symlinks = 0;
   while (true) {
-    const parsed = path6.parse(unresolved);
-    const parts = unresolved.slice(parsed.root.length).split(path6.sep).filter(Boolean);
+    const parsed = path7.parse(unresolved);
+    const parts = unresolved.slice(parsed.root.length).split(path7.sep).filter(Boolean);
     let resolved = parsed.root;
     let restart = false;
     for (let index = 0;index < parts.length; index++) {
-      const candidate = path6.join(resolved, parts[index]);
+      const candidate = path7.join(resolved, parts[index]);
       const info = await lstat2(candidate);
       if (!info.isSymbolicLink()) {
         resolved = candidate;
@@ -2131,7 +2285,7 @@ async function resolveSymlinks(filePath) {
         throw error;
       }
       const target = await readlink(candidate);
-      unresolved = path6.resolve(path6.dirname(candidate), target, ...parts.slice(index + 1));
+      unresolved = path7.resolve(path7.dirname(candidate), target, ...parts.slice(index + 1));
       restart = true;
       break;
     }
@@ -2153,14 +2307,14 @@ async function canonicalPath(filePath) {
   let existing = filePath;
   while (true) {
     try {
-      return path6.join(await portableRealpath(existing), ...missing.reverse());
+      return path7.join(await portableRealpath(existing), ...missing.reverse());
     } catch (error) {
       if (error.code !== "ENOENT")
         throw error;
-      const parent = path6.dirname(existing);
+      const parent = path7.dirname(existing);
       if (parent === existing)
         throw error;
-      missing.push(path6.basename(existing));
+      missing.push(path7.basename(existing));
       existing = parent;
     }
   }
@@ -2177,8 +2331,8 @@ async function authorizeExternal(context, filePath) {
   const info = await stat2(accessPath).catch(() => {
     return;
   });
-  const parentDir = info?.isDirectory() ? accessPath : path6.dirname(accessPath);
-  const pattern = path6.join(parentDir, "*").replaceAll("\\", "/");
+  const parentDir = info?.isDirectory() ? accessPath : path7.dirname(accessPath);
+  const pattern = path7.join(parentDir, "*").replaceAll("\\", "/");
   await context.ask({
     permission: "external_directory",
     patterns: [pattern],
@@ -2199,7 +2353,7 @@ async function authorizeRead(context, filePath) {
   await authorizeExternal(context, filePath);
   await context.ask({
     permission: "read",
-    patterns: [path6.relative(context.worktree, filePath).replaceAll("\\", "/")],
+    patterns: [path7.relative(context.worktree, filePath).replaceAll("\\", "/")],
     always: ["*"],
     metadata: {}
   });
@@ -2218,7 +2372,7 @@ async function authorizeEdit(context, filePaths, diff = "", authorizeExternalPat
     for (const filePath of filePaths)
       await authorizeExternal(context, filePath);
   }
-  const patterns = filePaths.map((filePath) => path6.relative(context.worktree, filePath).replaceAll("\\", "/"));
+  const patterns = filePaths.map((filePath) => path7.relative(context.worktree, filePath).replaceAll("\\", "/"));
   await context.ask({
     permission: "edit",
     patterns,
@@ -2228,109 +2382,92 @@ async function authorizeEdit(context, filePaths, diff = "", authorizeExternalPat
 }
 
 // src/presentation.ts
-import { tool } from "@opencode-ai/plugin";
+import { pathToFileURL } from "node:url";
+import { tool as tool2 } from "@opencode-ai/plugin";
 function initialTitle(kind, args) {
   switch (kind) {
-    case "inspect":
-      return `Inspect ${args.path}`;
-    case "extract":
-      return `Extract ${args.selector} to ${args.output}`;
-    case "search":
-      return `Search ${args.pattern}`;
-    case "grep":
-      return `Grep ${args.pattern}`;
-    case "def":
+    case "show_structure":
+    case "show_metadata":
+    case "check_syntax":
+    case "check_rules":
+    case "generate_caption":
+    case "detect_objects":
+    case "recognize_text":
+      return `${kind.replaceAll("_", " ")} ${args.path}`;
+    case "show_content":
+      return `Show content ${args.path}`;
+    case "show_assets":
+      return `Show assets ${args.path}`;
+    case "find_nodes":
+      return `Find nodes ${args.pattern ?? args.context ?? args.rule}`;
+    case "find_text":
+      return `Find text ${args.pattern ?? args.text}`;
+    case "find_definitions":
       return `Find definition ${args.name}`;
-    case "refs":
+    case "find_references":
       return `Find references to ${args.name}`;
-    case "rename":
-      return `Rename ${args.path}:${args.line} to ${args.to}`;
-    case "edit":
+    case "rename_symbol":
+      return `Rename ${args.path}:${args.at} to ${args.to}`;
+    case "edit_text":
       return `Edit ${args.path}`;
-    case "write":
+    case "write_file":
       return `Write ${args.path}`;
   }
 }
 function resultPresentation(kind, args, value) {
-  const output = record(value);
+  const output = record2(value);
+  if (isShowTool(kind)) {
+    const presentation = presentShowResult(kind, value, args);
+    return { title: presentation.summary, metadata: presentation.metadata };
+  }
   switch (kind) {
-    case "extract":
-      return { title: `Extracted ${args.selector} to ${args.output}`, metadata: {} };
-    case "inspect": {
-      const map = record(output.map);
-      const diagnostics = record(output.diagnostics);
-      const identity = record(output.identity);
-      const content = record(output.content);
-      const metadata = {};
-      const summary = [];
-      if (output.map !== undefined) {
-        const symbols = items(map.symbols).length;
-        metadata.symbols = symbols;
-        summary.push(`${symbols} symbols`);
-      }
-      if (output.diagnostics !== undefined) {
-        const errors = typeof diagnostics.error_count === "number" ? diagnostics.error_count : 0;
-        const missing = typeof diagnostics.missing_count === "number" ? diagnostics.missing_count : 0;
-        metadata.error_count = errors;
-        metadata.missing_count = missing;
-        summary.push(`${errors} errors, ${missing} missing`);
-      }
-      if (output.identity !== undefined) {
-        if (typeof identity.line === "number")
-          metadata.line = identity.line;
-        if (typeof identity.column === "number")
-          metadata.column = identity.column;
-        const identifier = record(identity.identifier).text;
-        if (typeof identifier === "string")
-          summary.push(identifier);
-      }
-      if (typeof content.start_line === "number")
-        metadata.start_line = content.start_line;
-      if (typeof content.end_line === "number")
-        metadata.end_line = content.end_line;
-      return {
-        title: summary.length > 0 ? `Inspected ${args.path} (${summary.join(", ")})` : `Inspected ${args.path}`,
-        metadata
-      };
+    case "check_syntax": {
+      const diagnostics = record2(output.diagnostics ?? output);
+      const errors = typeof diagnostics.error_count === "number" ? diagnostics.error_count : 0;
+      const missing = typeof diagnostics.missing_count === "number" ? diagnostics.missing_count : 0;
+      return { title: `Syntax ${args.path} (${errors} errors, ${missing} missing)`, metadata: { error_count: errors, missing_count: missing } };
     }
-    case "search": {
+    case "find_nodes": {
       const results = items(output.results);
-      const matches = results.reduce((total, result) => total + items(record(result).matches).length, 0);
+      const matches = results.reduce((total, result) => total + items(record2(result).matches).length, 0);
       return { title: `Found ${matches} matches`, metadata: { results: results.length, matches } };
     }
-    case "grep": {
+    case "find_text": {
       const results = items(output.results);
-      const matches = results.reduce((total, result) => total + items(record(result).matches).length, 0);
+      const matches = results.reduce((total, result) => {
+        const entry = record2(result);
+        return total + (typeof entry.count === "number" ? entry.count : items(entry.matches).length);
+      }, 0);
       return { title: `Found ${matches} matches`, metadata: { results: results.length, matches } };
     }
-    case "def": {
+    case "find_definitions": {
       const locations = items(output.locations).length;
       return { title: `Found ${locations} definitions`, metadata: { locations } };
     }
-    case "refs": {
+    case "find_references": {
       const references = items(output.references).length;
       return { title: `Found ${references} references`, metadata: { references } };
     }
-    case "rename": {
+    case "rename_symbol": {
       const oldName = output.old_name;
       const newName = output.new_name;
-      const otherOutputs = items(output.others).map(record);
+      const otherOutputs = items(output.others).map(record2);
       const edits = otherOutputs.reduce((total, item) => total + items(item.edits).length, items(output.edits).length);
       const conflicts = otherOutputs.reduce((total, item) => total + items(item.conflicts).length, items(output.conflicts).length);
       const others = otherOutputs.length;
       const title = typeof oldName === "string" && typeof newName === "string" ? `${output.applied === true ? "Renamed" : "Plan"} ${oldName} -> ${newName}` : initialTitle(kind, args);
       return { title, metadata: { edits, conflicts, others } };
     }
-    case "edit":
-    case "write": {
+    case "edit_text":
+    case "write_file": {
       const preview = typeof output.preview_error === "string" ? " (preview unavailable)" : "";
-      return { title: `${kind === "edit" ? "Edited" : "Wrote"} ${args.path}${preview}`, metadata: {} };
+      return { title: `${kind === "edit_text" ? "Edited" : "Wrote"} ${args.path}${preview}`, metadata: {} };
     }
   }
   return { title: initialTitle(kind, args), metadata: {} };
 }
-function readseekTool(description, args, kind, execute) {
-  return tool({
+function readseekTool(description, args, kind, execute, imagePolicy) {
+  return tool2({
     description,
     args,
     async execute(args, context) {
@@ -2338,10 +2475,29 @@ function readseekTool(description, args, kind, execute) {
       context.metadata({ title });
       const result = await execute(args, context);
       const presentation = resultPresentation(kind, args, result);
+      const attachments = [];
+      const imagePaths = new Map;
+      const visit = (value) => {
+        if (!value || typeof value !== "object")
+          return;
+        const item = value;
+        if (typeof item.path === "string" && typeof item.mime === "string" && item.mime.startsWith("image/"))
+          imagePaths.set(item.path, item.mime);
+        for (const child of Object.values(item))
+          visit(child);
+      };
+      if (imagePolicy !== undefined)
+        visit(result);
+      for (const [path, mime] of imagePaths) {
+        if (imagePolicy !== "off")
+          attachments.push({ type: "file", mime, url: pathToFileURL(path).href });
+      }
+      const displayResult = imagePolicy === "off" && imagePaths.size > 0 ? { ...record2(result), warning: "Image attachments are disabled; use the returned paths to view the images." } : result;
       return {
+        ...attachments.length > 0 ? { attachments } : {},
         title: presentation.title,
-        output: render(result),
-        metadata: presentation.metadata
+        output: isShowTool(kind) ? formatShowResult(presentShowResult(kind, displayResult, args)) : render(displayResult),
+        metadata: { ...presentation.metadata, ...isShowTool(kind) ? { readseek: result } : {} }
       };
     }
   });
@@ -2350,88 +2506,30 @@ function readseekTool(description, args, kind, execute) {
 // src/tools.ts
 function createReadSeekTools(imagePolicy) {
   return {
-    readseek_inspect: readseekTool(openCodeToolDescription("inspect"), {
-      path: tool2.schema.string().describe(PARAM_DESCRIPTIONS.projectPath),
-      selector: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.selector),
-      select: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.selectComma),
-      query: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.query),
-      end: tool2.schema.number().int().positive().optional().describe(PARAM_DESCRIPTIONS.end),
-      limit: tool2.schema.number().int().positive().optional().describe(PARAM_DESCRIPTIONS.limit),
-      depth: tool2.schema.number().int().nonnegative().optional().describe(PARAM_DESCRIPTIONS.inspectDepth),
-      language: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.languageOverride),
-      visionMode: tool2.schema.enum(IMAGE_MODES).optional().describe(PARAM_DESCRIPTIONS.visionModeInspect),
-      visionLevel: tool2.schema.enum(VISION_LEVEL_VALUES).optional().describe(PARAM_DESCRIPTIONS.visionLevel)
-    }, "inspect", async (input, context) => {
-      const filePath = resolvePath(context.directory, input.path);
-      await authorizeRead(context, filePath);
-      const select = (input.select ?? "content").trim() || "content";
-      const visionMode = input.visionMode;
-      const visionLevel = input.visionLevel;
-      const vision = validateVisionLevelVsMode({ visionMode, visionLevel });
-      if (!vision.ok)
-        throw new Error(vision.error);
-      const cacheDir = await ensureReadSeekCache(context);
-      const args = buildInspectArgs({
-        path: filePath,
-        selector: input.selector,
-        select,
-        query: input.query,
-        end: input.end,
-        limit: input.limit,
-        depth: input.depth ?? (select.split(",").some((facet) => facet.trim() === "map") ? DEFAULT_INSPECT_MAP_DEPTH : undefined),
-        language: input.language,
-        visionMode,
-        visionLevel,
-        readseekDir: cacheDir
-      });
-      return runReadSeek(context, args, visionMode === undefined || visionMode === "none" ? {} : { timeoutMs: DEFAULT_VISION_TIMEOUT_MS });
-    }),
-    readseek_extract: readseekTool(openCodeToolDescription("extract"), {
-      path: tool2.schema.string().describe(PARAM_DESCRIPTIONS.projectPath),
-      selector: tool2.schema.string().min(1).describe(PARAM_DESCRIPTIONS.assetSelector),
-      output: tool2.schema.string().min(1).describe(PARAM_DESCRIPTIONS.output)
-    }, "extract", async (input, context) => {
-      const selector = String(input.selector ?? "").trim();
-      const output = String(input.output ?? "").trim();
-      if (!selector.startsWith("asset:") || selector === "asset:") {
-        throw new Error("extract requires an asset: selector");
-      }
-      if (!output || output === "-")
-        throw new Error("extract output must be a file path");
-      const filePath = resolvePath(context.directory, input.path);
-      const outputPath = resolvePath(context.directory, output);
-      await authorizeRead(context, filePath);
-      await rejectSymlinkMutation(outputPath);
-      await authorizeEdit(context, [outputPath]);
-      const cacheDir = await ensureReadSeekCache(context);
-      await runReadSeekRaw(context, buildExtractArgs({
-        path: filePath,
-        selector,
-        output: outputPath,
-        readseekDir: cacheDir
-      }), { cancelable: false, timeoutMs: 120000 });
-      return {
-        file: filePath,
-        selector,
-        output: outputPath,
-        changed: true
-      };
-    }),
-    readseek_grep: readseekTool(openCodeToolDescription("grep"), {
-      pattern: tool2.schema.string().describe(PARAM_DESCRIPTIONS.grepPattern),
-      path: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.projectSearchPath),
-      glob: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.glob),
-      literal: tool2.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.literal),
-      ignoreCase: tool2.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.ignoreCase),
-      context: tool2.schema.number().int().nonnegative().optional().describe(PARAM_DESCRIPTIONS.context),
-      limit: tool2.schema.number().int().positive().optional().describe(PARAM_DESCRIPTIONS.matchLimit)
-    }, "grep", async (input, context) => {
+    ...createAccessTools(imagePolicy),
+    readseek_find_text: readseekTool(openCodeToolDescription("find_text"), {
+      pattern: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.grepPattern),
+      text: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.text),
+      summary: tool3.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.summary),
+      path: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.projectSearchPath),
+      glob: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.glob),
+      literal: tool3.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.literal),
+      ignoreCase: tool3.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.ignoreCase),
+      context: tool3.schema.number().int().nonnegative().optional().describe(PARAM_DESCRIPTIONS.context),
+      limit: tool3.schema.number().int().positive().optional().describe(PARAM_DESCRIPTIONS.matchLimit)
+    }, "find_text", async (input, context) => {
       const target = resolvePath(context.directory, input.path ?? ".");
-      const pattern = input.pattern;
+      if (input.pattern === undefined === (input.text === undefined)) {
+        throw new Error("exactly one of pattern or text is required");
+      }
+      const pattern = input.pattern ?? input.text;
       await authorizeSearch(context, target, pattern);
+      if (input.text !== undefined && !input.glob && !input.ignoreCase && !input.context && !input.summary) {
+        return runReadSeek(context, buildFindTextArgs({ path: target, text: pattern, limit: input.limit }));
+      }
       let expression;
       try {
-        const source = input.literal ? pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") : pattern;
+        const source = input.literal || input.text !== undefined ? pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") : pattern;
         expression = new RegExp(source, input.ignoreCase ? "i" : "");
       } catch (error) {
         throw new Error(`invalid regular expression: ${error instanceof Error ? error.message : String(error)}`);
@@ -2479,6 +2577,10 @@ function createReadSeekTools(imagePolicy) {
         }
         if (ranges.length === 0)
           continue;
+        if (input.summary) {
+          results.push({ file: filePath, count: matchLines.size });
+          continue;
+        }
         const mergedRanges = [];
         for (const [start, end] of ranges) {
           const previous = mergedRanges.at(-1);
@@ -2489,46 +2591,59 @@ function createReadSeekTools(imagePolicy) {
         }
         const linesByNumber = new Map;
         for (const [start, end] of mergedRanges) {
-          const output = record(await runInspectContent(context, readRangeArgs(filePath, start, end)));
+          const output = record2(await runContent(context, readRangeArgs(filePath, start, end)));
           for (const hashline of items(output.hashlines)) {
-            const line = record(hashline).line;
+            const line = record2(hashline).line;
             if (typeof line === "number" && !linesByNumber.has(line))
               linesByNumber.set(line, hashline);
           }
         }
         const hashlines = [...linesByNumber.values()];
         const matches = hashlines.filter((hashline) => {
-          const line = record(hashline).line;
+          const line = record2(hashline).line;
           return typeof line === "number" && matchLines.has(line);
         });
         results.push({ file: filePath, matches, hashlines });
       }
       return { results, truncated };
     }),
-    readseek_search: readseekTool(openCodeToolDescription("search"), {
-      pattern: tool2.schema.string().describe(PARAM_DESCRIPTIONS.pattern),
-      path: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.projectSearchPath),
-      language: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.language),
-      gitScope: tool2.schema.enum(GIT_SCOPES).optional().describe(PARAM_DESCRIPTIONS.gitScope)
-    }, "search", async (input, context) => {
+    readseek_find_nodes: readseekTool(openCodeToolDescription("find_nodes"), {
+      pattern: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.pattern),
+      context: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.patternContext),
+      selector: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.selector),
+      rule: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.rule),
+      limit: tool3.schema.number().int().positive().optional(),
+      path: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.projectSearchPath),
+      language: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.language),
+      gitScope: tool3.schema.enum(GIT_SCOPES).optional().describe(PARAM_DESCRIPTIONS.gitScope)
+    }, "find_nodes", async (input, context) => {
       const target = resolvePath(context.directory, input.path ?? ".");
-      const args = buildSearchArgs({
+      const args = buildFindNodesArgs({
         path: target,
         pattern: input.pattern,
+        context: input.context,
+        selector: input.selector,
+        rule: input.rule,
+        limit: input.limit,
         language: input.language,
         gitScope: input.gitScope
       });
-      await authorizeSearch(context, target, input.pattern);
+      await authorizeSearch(context, target, input.pattern ?? input.context ?? input.rule);
+      if (input.rule?.startsWith("@")) {
+        await authorizeRead(context, resolvePath(context.directory, input.rule.slice(1)));
+      }
+      if (input.rule === "-")
+        throw new Error("rule stdin is unavailable in OpenCode tools; use inline KDL or @path");
       return runReadSeek(context, args);
     }),
-    readseek_def: readseekTool(openCodeToolDescription("def"), {
-      name: tool2.schema.string().describe(PARAM_DESCRIPTIONS.name),
-      path: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.projectSearchPath),
-      language: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.language),
-      gitScope: tool2.schema.enum(GIT_SCOPES).optional().describe(PARAM_DESCRIPTIONS.gitScope)
-    }, "def", async (input, context) => {
+    readseek_find_definitions: readseekTool(openCodeToolDescription("find_definitions"), {
+      name: tool3.schema.string().describe(PARAM_DESCRIPTIONS.name),
+      path: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.projectSearchPath),
+      language: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.language),
+      gitScope: tool3.schema.enum(GIT_SCOPES).optional().describe(PARAM_DESCRIPTIONS.gitScope)
+    }, "find_definitions", async (input, context) => {
       const target = resolvePath(context.directory, input.path ?? ".");
-      const args = buildDefArgs({
+      const args = buildFindDefinitionsArgs({
         path: target,
         name: input.name,
         language: input.language,
@@ -2537,117 +2652,119 @@ function createReadSeekTools(imagePolicy) {
       await authorizeSearch(context, target, input.name);
       return runReadSeek(context, args);
     }),
-    readseek_refs: readseekTool(openCodeToolDescription("refs"), {
-      name: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.refsName),
-      path: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.projectSearchPath),
-      language: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.language),
-      scope: tool2.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.scope),
-      line: tool2.schema.number().int().positive().optional().describe(PARAM_DESCRIPTIONS.line),
-      column: tool2.schema.number().int().positive().optional().describe(PARAM_DESCRIPTIONS.column),
-      gitScope: tool2.schema.enum(GIT_SCOPES).optional().describe(PARAM_DESCRIPTIONS.gitScope)
-    }, "refs", async (input, context) => {
+    readseek_find_references: readseekTool(openCodeToolDescription("find_references"), {
+      name: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.refsName),
+      path: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.projectSearchPath),
+      language: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.language),
+      at: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.at),
+      gitScope: tool3.schema.enum(GIT_SCOPES).optional().describe(PARAM_DESCRIPTIONS.gitScope)
+    }, "find_references", async (input, context) => {
       const target = resolvePath(context.directory, input.path ?? ".");
       const name = input.name;
-      const args = buildRefsArgs({
+      const args = buildFindReferencesArgs({
         path: target,
         name,
-        scope: input.scope,
-        line: input.line,
-        column: input.column,
+        at: input.at,
         language: input.language,
         gitScope: input.gitScope
       });
       await authorizeSearch(context, target, name ?? "*");
       return runReadSeek(context, args);
     }),
-    readseek_rename: readseekTool(openCodeToolDescription("rename"), {
-      path: tool2.schema.string().describe(PARAM_DESCRIPTIONS.projectPath),
-      line: tool2.schema.number().int().positive().describe(PARAM_DESCRIPTIONS.renameLine),
-      column: tool2.schema.number().int().positive().optional().describe(PARAM_DESCRIPTIONS.column),
-      to: tool2.schema.string().min(1).describe(PARAM_DESCRIPTIONS.to),
-      workspace: tool2.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.workspace),
-      apply: tool2.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.applyDefaultTrue)
-    }, "rename", async (input, context) => {
+    readseek_rename_symbol: readseekTool(openCodeToolDescription("rename_symbol"), {
+      path: tool3.schema.string().describe(PARAM_DESCRIPTIONS.projectPath),
+      at: tool3.schema.string().describe(PARAM_DESCRIPTIONS.at),
+      to: tool3.schema.string().min(1).describe(PARAM_DESCRIPTIONS.to),
+      workspace: tool3.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.workspace),
+      apply: tool3.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.applyDefaultTrue),
+      planHash: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.planHash),
+      language: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.language),
+      gitScope: tool3.schema.enum(GIT_SCOPES).optional().describe(PARAM_DESCRIPTIONS.gitScope)
+    }, "rename_symbol", async (input, context) => {
       const filePath = resolvePath(context.directory, input.path);
       await authorizeRead(context, filePath);
       if (input.workspace) {
-        const column = input.column;
-        const identifyArgs = inspectArgs(filePath, "identity", {
-          selector: `line:${input.line}${column === undefined ? "" : `:${column}`}`
-        });
-        const envelope = await runReadSeek(context, identifyArgs);
-        const name = identifiedName(requireInspectFacet(envelope, "identity"));
+        const envelope = await runReadSeek(context, contentArgs(filePath, { at: input.at }));
+        const name = identifiedName(record2(envelope).cursor);
         if (!name)
           throw new Error("readseek could not identify a binding at the rename cursor");
         await authorizeSearch(context, context.directory, name);
       }
-      const args = buildRenameArgs({
+      const args = buildRenameSymbolArgs({
         path: filePath,
         to: input.to,
-        line: input.line,
-        column: input.column,
-        workspace: input.workspace ? context.directory : undefined
+        at: input.at,
+        workspace: input.workspace ? context.directory : undefined,
+        language: input.language,
+        gitScope: input.gitScope
       });
       const plan = await runReadSeek(context, args);
+      if (input.planHash !== undefined && record2(plan).plan_hash !== input.planHash) {
+        throw new Error("readseek rename plan does not match planHash");
+      }
       if (input.apply === false)
         return plan;
       const files = renameFiles(plan, context.directory);
-      const planHash = record(plan).plan_hash;
+      const planHash = record2(plan).plan_hash;
       if (typeof planHash !== "string" || planHash.length === 0) {
         throw new Error("readseek rename plan did not include a plan hash");
       }
       await authorizeEdit(context, files);
-      return runReadSeek(context, buildRenameArgs({
+      return runReadSeek(context, buildRenameSymbolArgs({
         path: filePath,
         to: input.to,
-        line: input.line,
-        column: input.column,
+        at: input.at,
         workspace: input.workspace ? context.directory : undefined,
         apply: true,
-        planHash
+        planHash,
+        language: input.language,
+        gitScope: input.gitScope
       }), {
         cancelable: false,
         timeoutMs: DEFAULT_READSEEK_TIMEOUT_MS
       });
     }),
-    readseek_edit: readseekTool(openCodeToolDescription("edit"), {
-      path: tool2.schema.string().describe(PARAM_DESCRIPTIONS.projectPath),
-      edits: tool2.schema.array(tool2.schema.union([
-        tool2.schema.object({
-          set_line: tool2.schema.object({
-            anchor: tool2.schema.string().describe(PARAM_DESCRIPTIONS.anchor),
-            new_text: tool2.schema.string().describe(PARAM_DESCRIPTIONS.newTextLine)
+    readseek_edit_text: readseekTool(openCodeToolDescription("edit_text"), {
+      path: tool3.schema.string().describe(PARAM_DESCRIPTIONS.projectPath),
+      edits: tool3.schema.array(tool3.schema.union([
+        tool3.schema.object({
+          set_line: tool3.schema.object({
+            anchor: tool3.schema.string().describe(PARAM_DESCRIPTIONS.anchor),
+            new_text: tool3.schema.string().describe(PARAM_DESCRIPTIONS.newTextLine)
           }).strict()
         }).strict(),
-        tool2.schema.object({
-          replace_lines: tool2.schema.object({
-            start_anchor: tool2.schema.string().describe(PARAM_DESCRIPTIONS.startAnchor),
-            end_anchor: tool2.schema.string().describe(PARAM_DESCRIPTIONS.endAnchor),
-            new_text: tool2.schema.string().describe(PARAM_DESCRIPTIONS.newTextRange)
+        tool3.schema.object({
+          replace_lines: tool3.schema.object({
+            start_anchor: tool3.schema.string().describe(PARAM_DESCRIPTIONS.startAnchor),
+            end_anchor: tool3.schema.string().describe(PARAM_DESCRIPTIONS.endAnchor),
+            new_text: tool3.schema.string().describe(PARAM_DESCRIPTIONS.newTextRange)
           }).strict()
         }).strict(),
-        tool2.schema.object({
-          insert_after: tool2.schema.object({
-            anchor: tool2.schema.string().describe(PARAM_DESCRIPTIONS.insertAnchor),
-            new_text: tool2.schema.string().describe(PARAM_DESCRIPTIONS.newTextInsert)
+        tool3.schema.object({
+          insert_after: tool3.schema.object({
+            anchor: tool3.schema.string().describe(PARAM_DESCRIPTIONS.insertAnchor),
+            new_text: tool3.schema.string().describe(PARAM_DESCRIPTIONS.newTextInsert)
           }).strict()
         }).strict(),
-        tool2.schema.object({
-          replace: tool2.schema.object({
-            old_text: tool2.schema.string().describe(PARAM_DESCRIPTIONS.oldText),
-            new_text: tool2.schema.string().describe(PARAM_DESCRIPTIONS.newText),
-            all: tool2.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.all)
+        tool3.schema.object({
+          replace: tool3.schema.object({
+            old_text: tool3.schema.string().describe(PARAM_DESCRIPTIONS.oldText),
+            new_text: tool3.schema.string().describe(PARAM_DESCRIPTIONS.newText),
+            all: tool3.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.all)
           }).strict()
         }).strict(),
-        tool2.schema.object({
-          replace_symbol: tool2.schema.object({
-            symbol: tool2.schema.string().describe(PARAM_DESCRIPTIONS.symbol),
-            new_body: tool2.schema.string().describe(PARAM_DESCRIPTIONS.newBody)
+        tool3.schema.object({
+          replace_symbol: tool3.schema.object({
+            symbol: tool3.schema.string().describe(PARAM_DESCRIPTIONS.symbol),
+            new_body: tool3.schema.string().describe(PARAM_DESCRIPTIONS.newBody)
           }).strict()
         }).strict()
       ])).min(1).describe(PARAM_DESCRIPTIONS.edits),
-      language: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.languageSymbol)
-    }, "edit", async (input, context) => {
+      language: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.languageSymbol),
+      apply: tool3.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.applyDefaultTrue),
+      planHash: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.planHash),
+      gitScope: tool3.schema.enum(GIT_SCOPES).optional().describe(PARAM_DESCRIPTIONS.gitScope)
+    }, "edit_text", async (input, context) => {
       const filePath = resolvePath(context.directory, input.path);
       validateEdits(input.edits);
       return withFileMutationQueue(filePath, async () => {
@@ -2656,15 +2773,21 @@ function createReadSeekTools(imagePolicy) {
         await rejectSymlinkMutation(filePath);
         const edits = input.edits;
         const request = serializeEditPlan(edits);
-        const baseArgs = buildEditArgs({
+        const baseArgs = buildEditTextArgs({
           path: filePath,
           language: input.language,
+          gitScope: input.gitScope,
           requestFromStdin: true
         });
-        const plan = record(await runReadSeek(context, baseArgs, { stdin: request }));
+        const plan = record2(await runReadSeek(context, baseArgs, { stdin: request }));
         if (typeof plan.before_content !== "string" || typeof plan.content !== "string" || typeof plan.plan_hash !== "string") {
           throw new Error("readseek edit plan is missing before_content, content, or plan_hash");
         }
+        if (input.planHash !== undefined && plan.plan_hash !== input.planHash) {
+          throw new Error("readseek edit plan does not match planHash");
+        }
+        if (input.apply === false)
+          return plan;
         const before = plan.before_content;
         const after = plan.content;
         const previewStart = Math.max(1, firstChangedLine(before, after) - 3);
@@ -2674,9 +2797,10 @@ function createReadSeekTools(imagePolicy) {
         }
         await authorizeEdit(context, [filePath], simpleDiff(filePath, before, after), false);
         context.abort.throwIfAborted();
-        const applied = record(await runReadSeek(context, buildEditArgs({
+        const applied = record2(await runReadSeek(context, buildEditTextArgs({
           path: filePath,
           language: input.language,
+          gitScope: input.gitScope,
           requestFromStdin: true,
           apply: true,
           planHash: plan.plan_hash
@@ -2691,10 +2815,10 @@ function createReadSeekTools(imagePolicy) {
         return postMutationPreview(context, previewArgs, filePath, true);
       });
     }),
-    readseek_write: readseekTool(openCodeToolDescription("write"), {
-      path: tool2.schema.string().describe(PARAM_DESCRIPTIONS.projectPath),
-      content: tool2.schema.string().describe(PARAM_DESCRIPTIONS.content)
-    }, "write", async (input, context) => {
+    readseek_write_file: readseekTool(openCodeToolDescription("write_file"), {
+      path: tool3.schema.string().describe(PARAM_DESCRIPTIONS.projectPath),
+      content: tool3.schema.string().describe(PARAM_DESCRIPTIONS.content)
+    }, "write_file", async (input, context) => {
       const filePath = resolvePath(context.directory, input.path);
       await authorizeExternal(context, filePath);
       return withFileMutationQueue(filePath, async () => {
@@ -2707,11 +2831,50 @@ function createReadSeekTools(imagePolicy) {
         await authorizeEdit(context, [filePath], simpleDiff(filePath, before.content, content), false);
         context.abort.throwIfAborted();
         await writeText(filePath, before, content);
-        return postMutationPreview(context, inspectArgs(filePath, "content", { end: DEFAULT_READ_LIMIT }), filePath, !before.exists || before.content !== content);
+        return postMutationPreview(context, contentArgs(filePath, { end: DEFAULT_READ_LIMIT }), filePath, !before.exists || before.content !== content);
       });
     })
   };
 }
+function createAccessTools(imagePolicy) {
+  const pathSchema = { path: tool3.schema.string().describe(PARAM_DESCRIPTIONS.projectPath) };
+  const atSchema = { at: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.at) };
+  const languageSchema = { language: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.language) };
+  const levelSchema = { level: tool3.schema.enum(VISION_LEVEL_VALUES).optional().describe(PARAM_DESCRIPTIONS.level) };
+  const definitions = {
+    show_content: { build: buildShowContentArgs, args: { ...pathSchema, ...atSchema, ...languageSchema, end: tool3.schema.number().int().positive().optional(), limit: tool3.schema.number().int().positive().optional(), noAnchors: tool3.schema.boolean().optional() } },
+    show_structure: { build: buildShowStructureArgs, args: { ...pathSchema, ...atSchema, ...languageSchema, depth: tool3.schema.number().int().nonnegative().optional(), kind: tool3.schema.string().optional(), outline: tool3.schema.boolean().optional() } },
+    show_metadata: { build: buildShowMetadataArgs, args: { ...pathSchema, ...languageSchema } },
+    show_assets: { build: buildShowAssetsArgs, args: { ...pathSchema, ...atSchema } },
+    check_syntax: { build: buildCheckSyntaxArgs, args: { ...pathSchema, ...languageSchema } },
+    check_rules: { build: buildCheckRulesArgs, args: { path: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.projectSearchPath), rules: tool3.schema.string().min(1), gitScope: tool3.schema.enum(GIT_SCOPES).optional() } },
+    generate_caption: { build: buildGenerateCaptionArgs, args: { ...pathSchema, ...atSchema, ...levelSchema, include: tool3.schema.array(tool3.schema.enum(["text", "objects"])).min(1).optional() } },
+    detect_objects: { build: buildDetectObjectsArgs, args: { ...pathSchema, ...atSchema, ...levelSchema } },
+    recognize_text: { build: buildRecognizeTextArgs, args: { ...pathSchema, ...atSchema, ...levelSchema } }
+  };
+  return Object.fromEntries(Object.entries(definitions).map(([name, definition]) => [
+    `readseek_${name}`,
+    readseekTool(openCodeToolDescription(name), definition.args, name, async (input, context) => {
+      const filePath = resolvePath(context.directory, input.path ?? ".");
+      const buildInput = { ...input, path: filePath, ...name === "show_structure" ? { depth: input.depth ?? DEFAULT_STRUCTURE_DEPTH } : {} };
+      let args = definition.build(buildInput);
+      await authorizeRead(context, filePath);
+      if (name === "check_rules") {
+        if (input.rules === "-")
+          throw new Error("rules stdin is unavailable in OpenCode tools; use inline KDL or @path");
+        await authorizeSearch(context, filePath, input.rules);
+        if (input.rules.startsWith("@"))
+          await authorizeRead(context, resolvePath(context.directory, input.rules.slice(1)));
+      }
+      const inference = ["generate_caption", "detect_objects", "recognize_text"].includes(name);
+      if (name === "show_content" || name === "show_assets" || inference) {
+        const readseekDir = await ensureReadSeekCache(context);
+        args = definition.build({ ...buildInput, readseekDir });
+      }
+      return runReadSeek(context, args, { timeoutMs: inference ? DEFAULT_VISION_TIMEOUT_MS : DEFAULT_READSEEK_TIMEOUT_MS });
+    }, name === "show_content" || name === "show_assets" ? imagePolicy : undefined)
+  ]));
+}
 
 // v2.ts
 var GUIDANCE = "For structural code navigation, consult the readseek skill when ReadSeek tools are unavailable and the readseek CLI is installed.";
@@ -2724,6 +2887,29 @@ var SKILL = {
 
 When ReadSeek tools are unavailable, use the readseek CLI for structural navigation and anchored edits if it is installed and available on PATH. Run \`readseek --help\` to inspect supported commands before invoking them. Get fresh anchors before editing; re-read after external file changes.
 
+Commands use verb-object pairs, with the target path positional:
+
+\`\`\`sh
+readseek show content file.ts --at line:10 --limit 40 --kdl
+readseek show structure file.ts --depth 1 --kdl
+readseek show metadata paper.pdf --kdl
+readseek show assets paper.pdf --at page:2 --kdl
+readseek check syntax file.ts --kdl
+readseek check rules . --rules @checks.kdl --kdl
+readseek find nodes src --pattern 'console.log($$$ARGS)' --kdl
+readseek find text src --text 'TODO' --kdl
+readseek find definitions src --name main --kdl
+readseek find references file.ts --at line:10:3 --kdl
+readseek edit text file.ts --edits @edits.kdl --kdl
+readseek rename symbol file.ts --at line:10:3 --to nextName --kdl
+\`\`\`
+
+Native \`find text\` is literal, not regex. Reference selection requires exactly one of \`--name\` or \`--at\`; rename requires a line or hash cursor. Preview mutations first, then use \`--apply --plan-hash HASH\` with the returned plan hash. Edit requests are KDL: for example, \`set_line anchor="10:HASH" new_text="replacement"\`.
+
+Syntax and rule checks return exit 0 when clean, 1 for findings, and 2 on failure. Exit 1 is not a transport failure. Syntax checks are parser checks, not type checking.
+
+Content and assets return cached paths; assets auto-materialize. Read those paths directly. There is no extract command or asset destination option. Reading does not invoke inference. Request inference explicitly with \`generate caption\` (optionally \`--include text,objects\`), \`detect objects\`, or \`recognize text\`, using \`--level low|medium|high\` and an installed model; models are never downloaded automatically.
+
 This V2 plugin supplies guidance only; it does not register readseek_* tools. If the CLI is unavailable, use OpenCode's built-in tools instead.`
 };
 var ReadSeekV2Plugin = {
@@ -2779,9 +2965,9 @@ var ReadSeekPlugin = async (_input, options) => {
         return;
       try {
         const result = JSON.parse(output.output);
-        if (input.tool === "readseek_rename") {
+        if (input.tool === "readseek_rename_symbol") {
           anchors.planRename(input.sessionID, result);
-          if (record(result).applied === true) {
+          if (record2(result).applied === true) {
             for (const filePath of renameFiles(result))
               anchors.forget(filePath);
           }
@@ -2789,7 +2975,7 @@ var ReadSeekPlugin = async (_input, options) => {
         const files = new Set;
         collectAnchoredFiles(result, files);
         for (const filePath of files)
-          anchors.mark(input.sessionID, path7.resolve(filePath));
+          anchors.mark(input.sessionID, path8.resolve(filePath));
       } catch {}
     },
     "experimental.session.compacting": async (input, output) => {