opencode-readseek 0.10.7 → 0.11.0

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,6 +397,597 @@ function validateExactlyOneEditVariant(edits) {
 }
 var MIN_SAFE_INTEGER = BigInt(Number.MIN_SAFE_INTEGER);
 var MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
+// ../readseek-api/src/argv.ts
+var DEFAULT_STRUCTURE_DEPTH = 1;
+function appendGitScopeArgs(args, input) {
+  if (input.gitScope !== undefined)
+    args.push("--git-scope", input.gitScope);
+  return args;
+}
+function pushOptionalString(args, flag, value) {
+  if (value !== undefined)
+    args.push(flag, value);
+}
+function pushOptionalNumber(args, flag, value) {
+  if (value !== undefined)
+    args.push(flag, String(value));
+}
+function appendApplyAndPlanHash(args, input) {
+  const order = input.flagOrder ?? "apply-first";
+  if (order === "plan-hash-first") {
+    pushOptionalString(args, "--plan-hash", input.planHash);
+    if (input.apply)
+      args.push("--apply");
+    return args;
+  }
+  if (input.apply)
+    args.push("--apply");
+  pushOptionalString(args, "--plan-hash", input.planHash);
+  return args;
+}
+function validatePositiveInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new Error(`${name} must be a positive integer`);
+  }
+}
+var SELECTOR_KINDS = ["line", "hash", "symbol", "page", "node", "asset"];
+function isSelectorKind(value) {
+  return SELECTOR_KINDS.includes(value);
+}
+function parseSelector(text) {
+  const separator = text.indexOf(":");
+  if (separator < 0) {
+    throw new Error("selector must start with line:, hash:, symbol:, page:, node:, or asset:");
+  }
+  const kind = text.slice(0, separator);
+  const value = text.slice(separator + 1);
+  if (value.length === 0)
+    throw new Error(`${kind} selector must not be empty`);
+  if (!isSelectorKind(kind)) {
+    throw new Error(`unknown selector kind \`${kind}\`; expected line, hash, symbol, page, node, or asset`);
+  }
+  if (kind === "line" || kind === "hash") {
+    const parts = value.split(":");
+    if (parts.length > 2)
+      throw new Error("selector has too many components");
+    if (parts.length === 2) {
+      const column = Number(parts[1]);
+      if (!Number.isSafeInteger(column))
+        throw new Error(`invalid column \`${parts[1]}\``);
+      if (column < 1)
+        throw new Error("column must be greater than zero");
+      return { kind, value: parts[0], column };
+    }
+  }
+  if (kind === "page") {
+    if (value.includes(":"))
+      throw new Error("page selector has too many components");
+    const page = Number(value);
+    if (!Number.isSafeInteger(page))
+      throw new Error(`invalid page \`${value}\``);
+    if (page < 1)
+      throw new Error("page must be greater than zero");
+  }
+  return { kind, value };
+}
+function 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);
+  }
+}
+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.end !== undefined && input.limit !== undefined)
+    throw new Error("cannot combine end with limit");
+  const args = start("show", "content", input);
+  at2(args, input.at);
+  pushOptionalNumber(args, "--end", input.end);
+  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, "--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 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 buildFindTextArgs(input) {
+  const args = start("find", "text", input);
+  args.push("--text", input.text);
+  limit2(args, input.limit);
+  appendGitScopeArgs(args, input);
+  return finish(args);
+}
+function buildFindDefinitionsArgs(input) {
+  const args = start("find", "definitions", input);
+  args.push("--name", input.name);
+  language(args, input);
+  appendGitScopeArgs(args, input);
+  anchors(args, input);
+  return finish(args);
+}
+function buildFindReferencesArgs(input) {
+  const validated = validateReferencesSelection(input);
+  if (!validated.ok)
+    throw new Error(validated.error);
+  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);
+  anchors(args, input);
+  return finish(args);
+}
+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", "-");
+  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, { ...input, flagOrder: input.flagOrder ?? "plan-hash-first" });
+  language(args, input);
+  appendGitScopeArgs(args, input);
+  return finish(args);
+}
+// ../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 recursiveStructureNode() {
+  return Type.Recursive((self) => mapNodeShape(self));
+}
+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 = []) {
@@ -614,268 +1028,11 @@ function serializeEditPlan(edits) {
     throw new Error(validation.error);
   return format(new Document([node("plan", {}, validation.edits.map(editNode))]));
 }
-// ../readseek-api/src/argv.ts
-var DEFAULT_INSPECT_MAP_DEPTH = 1;
-function buildLineLocation(line, column) {
-  return column === undefined ? `line:${line}` : `line:${line}:${column}`;
-}
-function appendGitScopeArgs(args, input) {
-  if (input.gitScope !== undefined)
-    args.push("--git-scope", input.gitScope);
-  return args;
-}
-function pushOptionalString(args, flag, value) {
-  if (value !== undefined)
-    args.push(flag, value);
-}
-function pushOptionalNumber(args, flag, value) {
-  if (value !== undefined)
-    args.push(flag, String(value));
-}
-function appendApplyAndPlanHash(args, input) {
-  const order = input.flagOrder ?? "apply-first";
-  if (order === "plan-hash-first") {
-    pushOptionalString(args, "--plan-hash", input.planHash);
-    if (input.apply)
-      args.push("--apply");
-    return args;
-  }
-  if (input.apply)
-    args.push("--apply");
-  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`);
-  }
-}
-var SELECTOR_KINDS = ["line", "hash", "symbol", "page", "node", "asset"];
-function isSelectorKind(value) {
-  return SELECTOR_KINDS.includes(value);
-}
-function parseSelector(text) {
-  const separator = text.indexOf(":");
-  if (separator < 0) {
-    throw new Error("selector must start with line:, hash:, symbol:, page:, node:, or asset:");
-  }
-  const kind = text.slice(0, separator);
-  const value = text.slice(separator + 1);
-  if (value.length === 0)
-    throw new Error(`${kind} selector must not be empty`);
-  if (!isSelectorKind(kind)) {
-    throw new Error(`unknown selector kind \`${kind}\`; expected line, hash, symbol, page, node, or asset`);
-  }
-  if (kind === "line" || kind === "hash") {
-    const parts = value.split(":");
-    if (parts.length > 2)
-      throw new Error("selector has too many components");
-    if (parts.length === 2) {
-      const column = Number(parts[1]);
-      if (!Number.isSafeInteger(column))
-        throw new Error(`invalid column \`${parts[1]}\``);
-      if (column < 1)
-        throw new Error("column must be greater than zero");
-      return { kind, value: parts[0], column };
-    }
-  }
-  if (kind === "page") {
-    if (value.includes(":"))
-      throw new Error("page selector has too many components");
-    const page = Number(value);
-    if (!Number.isSafeInteger(page))
-      throw new Error(`invalid page \`${value}\``);
-    if (page < 1)
-      throw new Error("page must be greater than zero");
-  }
-  return { kind, value };
-}
-function buildInspectArgs(input) {
-  validateTarget("inspect", input.path, input.stdinName);
-  if (input.selector !== undefined && input.selector.length === 0) {
-    throw new Error("selector must not be empty");
-  }
-  const vision = validateVisionLevelVsMode({
-    visionMode: input.visionMode,
-    visionLevel: input.visionLevel
-  });
-  if (!vision.ok)
-    throw new Error(vision.error);
-  const facets = selectedInspectFacets(input.select);
-  const hasContent = hasInspectFacet(facets, "content");
-  const hasIdentity = hasInspectFacet(facets, "identity");
-  const hasMap = hasInspectFacet(facets, "map");
-  const hasSourceFacet = hasMap || hasInspectFacet(facets, "diagnostics") || hasIdentity;
-  if (input.end !== undefined)
-    validatePositiveInteger(input.end, "end");
-  if (input.limit !== undefined)
-    validatePositiveInteger(input.limit, "limit");
-  if (input.end !== undefined && input.limit !== undefined) {
-    throw new Error("cannot combine end with limit");
-  }
-  if (input.depth !== undefined) {
-    if (!Number.isSafeInteger(input.depth) || input.depth < 0) {
-      throw new Error("depth must be a non-negative integer");
-    }
-    if (!hasMap)
-      throw new Error("depth requires the map facet");
-  }
-  if (input.selector !== undefined && input.query !== undefined) {
-    throw new Error("cannot combine selector with query");
-  }
-  if (!hasContent && (input.end !== undefined || input.limit !== undefined || input.query !== undefined)) {
-    throw new Error("ranges and queries require the content facet");
-  }
-  if (hasIdentity && input.selector === undefined) {
-    throw new Error("the identity facet requires a selector");
-  }
-  if (input.selector !== undefined && !hasContent && !hasIdentity) {
-    throw new Error("selectors require the content or identity facet");
-  }
-  if (input.selector !== undefined) {
-    const selector = parseSelector(input.selector);
-    if (selector.kind === "symbol" && hasIdentity) {
-      throw new Error("the identity facet does not accept symbol selectors");
-    }
-    if (selector.column !== undefined && !hasIdentity) {
-      throw new Error("selector columns require the identity facet");
-    }
-  }
-  const hasVision = input.visionMode !== undefined || input.visionLevel !== undefined;
-  if (hasVision && !hasContent) {
-    throw new Error("vision options require the content facet");
-  }
-  if (hasVision && hasSourceFacet) {
-    throw new Error("vision options cannot be combined with source facets");
-  }
-  const args = [];
-  if (input.readseekDir !== undefined)
-    args.push("--readseek-dir", input.readseekDir);
-  args.push("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);
-  pushOptionalNumber(args, "--end", input.end);
-  pushOptionalNumber(args, "--limit", input.limit);
-  pushOptionalNumber(args, "--depth", input.depth);
-  pushOptionalString(args, "--language", input.language);
-  pushOptionalString(args, "--vision-mode", input.visionMode);
-  pushOptionalString(args, "--vision-level", input.visionLevel);
-  pushOptionalString(args, "--stdin-name", input.stdinName);
-  args.push("--kdl");
-  return args;
-}
-function 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 buildSearchArgs(input) {
-  const args = ["search", input.pattern];
-  pushOptionalString(args, "--path", input.path);
-  pushOptionalString(args, "--language", input.language);
-  pushOptionalNumber(args, "--limit", input.limit);
-  appendGitScopeArgs(args, input);
-  args.push("--kdl");
-  return args;
-}
-function buildDefArgs(input) {
-  const args = ["def", input.name];
-  pushOptionalString(args, "--path", input.path);
-  pushOptionalString(args, "--language", input.language);
-  appendGitScopeArgs(args, input);
-  args.push("--kdl");
-  return args;
-}
-function buildRefsArgs(input) {
-  const validated = validateRefsNameVsScope(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);
-  appendGitScopeArgs(args, input);
-  args.push("--kdl");
-  return 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);
-  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];
-  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);
-  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";
+import path2 from "node:path";
 var READSEEK_BINARY_ENV = "READSEEK_BINARY";
 var READSEEK_PLATFORM_PACKAGES = {
   "darwin-arm64": "@jarkkojs/readseek-darwin-arm64",
@@ -896,7 +1053,7 @@ function resolveReadSeekBinaryOverride(environment = process.env) {
   const binaryPath = environment[READSEEK_BINARY_ENV];
   if (binaryPath === undefined)
     return null;
-  if (!path.isAbsolute(binaryPath)) {
+  if (!path2.isAbsolute(binaryPath)) {
     throw new Error(`${READSEEK_BINARY_ENV} must be an absolute path to the readseek executable`);
   }
   try {
@@ -924,14 +1081,14 @@ function resolveReadSeekBinaryFromPackages(resolver = resolveFromPackage, option
   let packageJsonPath;
   try {
     const metaPackageJson = resolve(`${metaPackage}/package.json`);
-    const metaPackageDir = path.dirname(metaPackageJson);
+    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 +1099,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 +1118,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*$/;
@@ -1089,21 +1246,26 @@ function sourceDocument(root) {
   const metadata = child(root, "metadata");
   const cache = child(root, "cache");
   const content = child(root, "content");
-  const map = child(root, "map");
+  const structure = child(root, "structure");
   const diagnosticOutput = child(root, "diagnostics");
-  const identityOutput = child(root, "identity");
+  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 (map)
-    result.map = sourceMap(map);
+  if (structure)
+    result.structure = sourceMap(structure);
   if (diagnosticOutput)
     result.diagnostics = diagnostics(diagnosticOutput);
   if (identityOutput)
-    result.identity = identity(identityOutput);
+    result.cursor = identity(identityOutput);
   return result;
 }
 function hit(node) {
@@ -1224,7 +1386,10 @@ function genericNode(node) {
     result.bbox = properties(bbox);
   const objects = children(node, "object");
   if (objects.length > 0)
-    result.objects = objects.map(genericNode);
+    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) {
@@ -1289,13 +1454,34 @@ function failureFromProcessResult(result, options = {}) {
     return new Error(`readseek killed by signal ${result.signal}`);
   return new Error(`readseek exited with status ${result.exitCode}`);
 }
-function ensureSuccessfulStdout(result) {
-  if (result.exitCode === 0)
+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) {
-  return parseReadSeekKdl(ensureSuccessfulStdout(result));
+function parseSuccessfulKdl(result, args = []) {
+  return parseReadSeekKdl(ensureSuccessfulStdout(result, args));
 }
 // ../readseek-api/src/process-bun.ts
 function getBunSpawn() {
@@ -1385,256 +1571,13 @@ async function runReadSeekBun(binaryPath, args, options = {}) {
   }
 }
 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));
-}
-// ../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)
-  });
+  return ensureSuccessfulStdout(await runReadSeekBun(binaryPath, args, options), args);
 }
-function recursiveMapNode() {
-  return Type.Recursive((self) => mapNodeShape(self));
+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);
 }
@@ -1672,12 +1615,12 @@ function renameFiles(value, directory = process.cwd()) {
   const output = record(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);
     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 +1671,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 = record(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 +1719,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 +1753,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 +1773,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 +1787,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 +1810,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 +1843,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 +1912,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 +2044,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 +2070,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 +2092,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 +2116,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 +2138,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 +2157,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,54 +2167,59 @@ 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);
   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);
+    case "show_assets":
+      return { title: `Assets ${args.path}`, metadata: {} };
+    case "show_structure": {
+      const symbols = items(record(output.structure).symbols).length;
+      return { title: `Structure ${args.path} (${symbols} symbols)`, metadata: { symbols } };
+    }
+    case "check_syntax": {
+      const diagnostics = record(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 "show_content": {
+      const identity = record(output.cursor);
       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 (output.cursor !== undefined) {
         if (typeof identity.line === "number")
           metadata.line = identity.line;
         if (typeof identity.column === "number")
@@ -2289,29 +2233,32 @@ function resultPresentation(kind, args, value) {
       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}`,
+        title: summary.length > 0 ? `Read ${args.path} (${summary.join(", ")})` : `Read ${args.path}`,
         metadata
       };
     }
-    case "search": {
+    case "find_nodes": {
       const results = items(output.results);
       const matches = results.reduce((total, result) => total + items(record(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 = record(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);
@@ -2321,16 +2268,16 @@ function resultPresentation(kind, args, value) {
       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,9 +2285,27 @@ 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 });
+      }
       return {
+        ...attachments.length > 0 ? { attachments } : {},
         title: presentation.title,
-        output: render(result),
+        output: render(imagePolicy === "off" && imagePaths.size > 0 ? { ...record(result), warning: "Image attachments are disabled; use the returned paths to view the images." } : result),
         metadata: presentation.metadata
       };
     }
@@ -2350,88 +2315,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 +2386,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,7 +2400,7 @@ 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 = record(await runContent(context, readRangeArgs(filePath, start, end)));
           for (const hashline of items(output.hashlines)) {
             const line = record(hashline).line;
             if (typeof line === "number" && !linesByNumber.has(line))
@@ -2505,30 +2416,43 @@ function createReadSeekTools(imagePolicy) {
       }
       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,58 +2461,56 @@ 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(record(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 && record(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);
@@ -2597,57 +2519,61 @@ function createReadSeekTools(imagePolicy) {
         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 +2582,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 }));
         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 +2606,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 = record(await runReadSeek(context, buildEditTextArgs({
           path: filePath,
           language: input.language,
+          gitScope: input.gitScope,
           requestFromStdin: true,
           apply: true,
           planHash: plan.plan_hash
@@ -2691,10 +2624,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 +2640,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 +2696,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,7 +2774,7 @@ 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) {
             for (const filePath of renameFiles(result))
@@ -2789,7 +2784,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) => {