opencode-readseek 0.11.4 → 0.12.1

package/dist/index.js

@@ -16,22 +16,22 @@ var EDIT_VARIANTS = [
 ];
 var GIT_SCOPES = ["tracked", "untracked", "ignored", "all"];
 var TOOL_NAMES = [
-  "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"
+  "show",
+  "tree",
+  "meta",
+  "assets",
+  "syntax",
+  "check",
+  "caption",
+  "objects",
+  "ocr",
+  "search",
+  "grep",
+  "def",
+  "refs",
+  "edit",
+  "rename",
+  "write"
 ];
 var PARAM_DESCRIPTIONS = {
   path: "Absolute or relative file path",
@@ -43,12 +43,12 @@ var PARAM_DESCRIPTIONS = {
   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",
+  grepPattern: "Native regex pattern; set literal for exact text. Empty regex matches every line; empty literal is invalid.",
   name: "Qualified or unqualified symbol name",
   refsName: "Identifier to find references for",
   gitScope: "In a Git repository, which files to search: tracked, untracked, ignored (untracked plus ignored), or all. Defaults to tracked plus untracked.",
-  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",
+  at: "Location selector: N[:COLUMN], START-END, H[:COLUMN], NAME, line:N[:COLUMN], hash:H[:COLUMN], symbol:NAME, page:N, node:ID, or asset:ID",
+  assetAt: "Document selector: N, 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 '-'",
@@ -60,7 +60,6 @@ var PARAM_DESCRIPTIONS = {
   kind: "Restrict structure to this node kind",
   outline: "Show outline of document hierarchy or source symbols",
   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":"..."}}',
@@ -92,27 +91,28 @@ var PARAM_DESCRIPTIONS = {
   literal: "Treat pattern literally",
   context: "Surrounding lines for each match",
   matchLimit: "Maximum matches to return",
+  grepLimit: "Maximum matching lines to return; positive integer, defaults to 100",
   summary: "Return per-file counts",
   grepScope: "Group matches by enclosing symbol",
-  scopeContext: "Context lines within each symbol"
+  scopeContext: "Non-negative context lines within each symbol; requires scope: symbol"
 };
 var TOOL_DESCRIPTIONS = {
-  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."
+  show: "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.",
+  tree: "Show parsed source or document hierarchy. Use shallow depth for file overviews.",
+  meta: "Show format, source identity, language, dimensions, or page count without decoding image content or inference.",
+  assets: "Return selected document asset descriptors with usable cached paths. Adapters attach images from those paths.",
+  syntax: "Check parser syntax diagnostics. Exit 0 is clean, 1 has findings, 2 is failure; this is not type checking.",
+  check: "Evaluate KDL structural assertions. Exit 0 is clean, 1 has findings, 2 is failure.",
+  caption: "Explicitly infer a caption using an installed model. Include text and objects to request OCR and detection too; never downloads models automatically.",
+  objects: "Explicitly infer object labels and bounding boxes using an installed model.",
+  ocr: "Explicitly recognize text from pixels using an installed model; reading never silently invokes OCR.",
+  search: "Find AST nodes by pattern or KDL selection rule. Returns edit-ready anchors. Use `grep` for text and regex.",
+  grep: "Search with native regex or literal matching. Returns matching-line counts, source LINE:HASH anchors, and document node-local locations. Native glob, context, summary, limits, Git scope, and symbol grouping apply; default limit is 100 matching lines.",
+  def: "Find a symbol definition or declaration by qualified or unqualified name.",
+  refs: "Find identifier-name matches with name, or binding-scoped references with at. Use before renaming or deleting a symbol.",
+  edit: "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: "Rename a symbol at a line or hash cursor with binding-aware edits and stale-plan protection.",
+  write: "Create or replace a complete text file and return `LINE:HASH` anchors. Use `edit` for small changes."
 };
 function rewriteBacktickedToolNames(text, aliases = {}) {
   return TOOL_NAMES.reduce((rewritten, toolName) => rewritten.replaceAll(`\`${toolName}\``, `\`${aliases[toolName] ?? toolName}\``), text);
@@ -205,48 +205,48 @@ function tool(name, title, properties, required) {
   return { name, title, description: TOOL_DESCRIPTIONS[name], inputSchema: { type: "object", properties, required, additionalProperties: false } };
 }
 var TOOL_CONTRACTS = [
-  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: string(PARAM_DESCRIPTIONS.searchPath), ...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"])
+  tool("show", "Show content", { ...path, ...at, ...lang, ...stdin, ...noAnchors, end: integer(PARAM_DESCRIPTIONS.end), limit: integer(PARAM_DESCRIPTIONS.limit) }, ["path"]),
+  tool("tree", "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("meta", "Show metadata", { ...path, ...lang, ...stdin }, ["path"]),
+  tool("assets", "Show assets", { ...path, at: string(PARAM_DESCRIPTIONS.assetAt), ...stdin }, ["path"]),
+  tool("syntax", "Check syntax", { ...path, ...lang, ...stdin }, ["path"]),
+  tool("check", "Check rules", { path: string(PARAM_DESCRIPTIONS.searchPath), ...gitScopeSchema, rules: string(PARAM_DESCRIPTIONS.rules) }, ["rules"]),
+  tool("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("objects", "Detect objects", { ...path, ...at, ...stdin, ...level }, ["path"]),
+  tool("ocr", "Recognize text", { ...path, ...at, ...stdin, ...level }, ["path"]),
+  tool("search", "Search AST 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("grep", "Search text", { path: string(PARAM_DESCRIPTIONS.searchPath), limit: { ...integer(PARAM_DESCRIPTIONS.grepLimit), default: 100 }, ...gitScopeSchema, 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) }, ["pattern"]),
+  tool("def", "Find definitions", { ...path, ...lang, ...gitScopeSchema, ...noAnchors, name: string(PARAM_DESCRIPTIONS.name) }, ["name"]),
+  tool("refs", "Find references", { ...path, ...at, ...lang, ...gitScopeSchema, ...noAnchors, name: string(PARAM_DESCRIPTIONS.refsName) }, []),
+  tool("edit", "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", "Rename symbol", { ...path, ...at, ...lang, ...gitScopeSchema, ...apply, to: string(PARAM_DESCRIPTIONS.to), workspace: { type: "boolean", description: PARAM_DESCRIPTIONS.workspace } }, ["path", "at", "to"]),
+  tool("write", "Write file", { ...path, content: string(PARAM_DESCRIPTIONS.content) }, ["path", "content"])
 ];
 // ../readseek-api/src/policy.ts
 var BUILTIN_FALLBACKS = {
-  read: "show_content",
-  edit: "edit_text",
-  write: "write_file",
-  grep: "find_text",
-  apply_patch: "edit_text"
+  read: "show",
+  edit: "edit",
+  write: "write",
+  grep: "grep",
+  apply_patch: "edit"
 };
 var PREFERENCE_LEADS = {
-  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 search; returns edit-ready LINE:HASH anchors.",
-  find_nodes: "Preferred for AST or structural code search with ast-grep-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 materializing selected document assets with usable cached paths."
+  show: "Preferred for reading source with anchors.",
+  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 native text/regex search; returns edit-ready source LINE:HASH anchors and document node-local locations.",
+  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.",
+  assets: "Preferred for materializing selected document assets with usable cached paths."
 };
 var FALLBACK_TEMPLATES = {
-  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."
+  read: "Prefer `show` 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 native text/regex search with source anchors and document locations.",
+  apply_patch: "Prefer `edit` for existing text files."
 };
 function resolveToolName(name, aliases = {}) {
   return aliases[name] ?? name;
@@ -262,21 +262,21 @@ function renderFallbackToolDescription(builtIn, aliases = {}) {
 }
 function renderToolRoutingPolicy(options = {}) {
   const aliases = options.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);
+  const show = resolveToolName("show", 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 assets = resolveToolName("assets", aliases);
   const title = options.title ?? "ReadSeek tool policy:";
   const bullets = [];
   if (options.preferOverBuiltIns) {
     bullets.push("- Prefer ReadSeek tools over built-ins when they can do the job.");
   }
-  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.`);
+  bullets.push(`- Read with ${show} first; ${edit} needs fresh LINE:HASH anchors.`, `- Use ${grep} for text/regex, ${search} for AST patterns, ${def}/${refs} for targeted symbols, and shallow ${resolveToolName("tree", aliases)} structures only for file overviews.`, `- Use ${edit} for existing files, ${write} for whole-file creation or replacement, and ${rename} for symbol renames.`, `- Use ${resolveToolName("tree", aliases)} for document structure; run ${resolveToolName("syntax", aliases)} after source edits for a quick syntax check.`, `- Use ${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.`);
   }
@@ -316,6 +316,59 @@ function validateReferencesSelection(input) {
     return { ok: false, error: "exactly one of name or at is required" };
   return { ok: true };
 }
+function validateGrepParams(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return { ok: false, error: "grep params must be an object" };
+  }
+  const params = input;
+  const allowed = [
+    "pattern",
+    "path",
+    "glob",
+    "ignoreCase",
+    "literal",
+    "context",
+    "limit",
+    "summary",
+    "scope",
+    "scopeContext",
+    "gitScope",
+    "signal",
+    "stdin",
+    "timeoutMs",
+    "cancelable"
+  ];
+  if (Object.keys(params).some((key) => !allowed.includes(key)))
+    return { ok: false, error: "unknown grep parameter" };
+  if (typeof params.pattern !== "string")
+    return { ok: false, error: "grep requires a pattern string" };
+  if (params.literal === true && params.pattern.length === 0)
+    return { ok: false, error: "literal pattern must not be empty" };
+  for (const key of ["path", "glob"]) {
+    if (params[key] !== undefined && (typeof params[key] !== "string" || params[key].length === 0)) {
+      return { ok: false, error: `${key} must be a non-empty string` };
+    }
+  }
+  for (const key of ["ignoreCase", "literal", "summary"]) {
+    if (params[key] !== undefined && typeof params[key] !== "boolean")
+      return { ok: false, error: `${key} must be a boolean` };
+  }
+  for (const key of ["context", "limit", "scopeContext"]) {
+    const value = params[key];
+    const minimum = key === "limit" ? 1 : 0;
+    if (value !== undefined && (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum)) {
+      return { ok: false, error: `${key} must be a ${minimum === 1 ? "positive" : "non-negative"} integer` };
+    }
+  }
+  if (params.scope !== undefined && params.scope !== "symbol")
+    return { ok: false, error: "scope must be symbol" };
+  if (params.scopeContext !== undefined && params.scope !== "symbol")
+    return { ok: false, error: "scopeContext requires scope" };
+  if (params.gitScope !== undefined && !GIT_SCOPES.includes(params.gitScope)) {
+    return { ok: false, error: "invalid gitScope" };
+  }
+  return { ok: true };
+}
 var VARIANT_FIELDS = {
   set_line: ["anchor", "new_text"],
   replace_lines: ["start_anchor", "end_anchor", "new_text"],
@@ -420,50 +473,111 @@ var SELECTOR_KINDS = ["line", "hash", "symbol", "page", "node", "asset"];
 function isSelectorKind(value) {
   return SELECTOR_KINDS.includes(value);
 }
+function parsePositiveSelectorInt(raw, name) {
+  if (!/^-?\d+$/.test(raw))
+    throw new Error(`invalid ${name} \`${raw}\``);
+  const parsed = Number(raw);
+  if (!Number.isSafeInteger(parsed))
+    throw new Error(`invalid ${name} \`${raw}\``);
+  if (parsed < 1)
+    throw new Error(`${name} must be greater than zero`);
+  return parsed;
+}
+function parseLineSelector(value, explicitKind) {
+  const parts = value.split(":");
+  if (parts.length > 2)
+    throw new Error("selector has too many components");
+  const head = parts[0];
+  if (parts.length === 2) {
+    if (head.slice(1).includes("-"))
+      throw new Error("line range cannot include a column");
+    const line = parsePositiveSelectorInt(head, "line");
+    const column = parsePositiveSelectorInt(parts[1], "column");
+    return { kind: "line", value: String(line), column, explicitKind };
+  }
+  const dash = head.indexOf("-", 1);
+  if (dash > 0) {
+    const start = parsePositiveSelectorInt(head.slice(0, dash), "line");
+    const endLine = parsePositiveSelectorInt(head.slice(dash + 1), "end line");
+    if (endLine < start)
+      throw new Error(`end line ${endLine} precedes start line ${start}`);
+    return { kind: "line", value: String(start), endLine, explicitKind };
+  }
+  const line = parsePositiveSelectorInt(head, "line");
+  return { kind: "line", value: String(line), explicitKind };
+}
+function parseHashSelector(value, explicitKind) {
+  const parts = value.split(":");
+  if (parts.length > 2)
+    throw new Error("selector has too many components");
+  const head = parts[0];
+  if (!/^[0-9a-fA-F]{6}$/.test(head))
+    throw new Error(`invalid line hash \`${head}\``);
+  if (parts.length === 2) {
+    const column = parsePositiveSelectorInt(parts[1], "column");
+    return { kind: "hash", value: head, column, explicitKind };
+  }
+  return { kind: "hash", value: head, explicitKind };
+}
+function isDocumentSelector(parsed) {
+  return ["page", "node", "asset"].includes(parsed.kind) || parsed.kind === "line" && !parsed.explicitKind && parsed.column === undefined && parsed.endLine === undefined;
+}
+function isBindingSelector(parsed) {
+  if (parsed.endLine !== undefined)
+    return false;
+  if (parsed.kind === "line" || parsed.kind === "hash")
+    return true;
+  return parsed.kind === "symbol" && !parsed.explicitKind && /^[0-9a-fA-F]{6}$/.test(parsed.value);
+}
 function parseSelector(text) {
+  if (text.length === 0)
+    throw new Error("selector must not be empty");
   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)) {
+  const hasSingleColon = separator >= 0 && text[separator + 1] !== ":";
+  if (hasSingleColon) {
+    const kind = text.slice(0, separator);
+    const value = text.slice(separator + 1);
+    if (isSelectorKind(kind)) {
+      if (value.length === 0)
+        throw new Error(`${kind} selector must not be empty`);
+      if (kind === "line")
+        return parseLineSelector(value, true);
+      if (kind === "hash")
+        return parseHashSelector(value, true);
+      if (kind === "page") {
+        if (value.includes(":"))
+          throw new Error("page selector has too many components");
+        parsePositiveSelectorInt(value, "page");
+      }
+      return { kind, value, explicitKind: true };
+    }
+    if (/^\d+$/.test(kind))
+      return parseLineSelector(text, false);
+    if (/^[0-9a-fA-F]{6}$/.test(kind) && /^\d+$/.test(value))
+      return parseHashSelector(text, false);
     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 (/^[0-9-]/.test(text)) {
+    if (/^[0-9a-fA-F]{6}$/.test(text) && /[a-fA-F]/.test(text)) {
+      return parseHashSelector(text, false);
     }
+    return parseLineSelector(text, false);
   }
-  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");
+  if (/^[0-9a-fA-F]{6}$/.test(text) && /\d/.test(text)) {
+    return parseHashSelector(text, false);
   }
-  return { kind, value };
+  if (/\s/.test(text))
+    throw new Error(`invalid selector \`${text}\``);
+  return { kind: "symbol", value: text, explicitKind: false };
 }
-function start(verb, object, input) {
+function start(command, input) {
   if (!input.path)
-    throw new Error(`${verb} ${object} requires a path`);
+    throw new Error(`${command} 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);
+  args.push(command, input.path);
   pushOptionalString(args, "--stdin-name", input.stdinName);
   return args;
 }
@@ -489,12 +603,12 @@ function anchors(args, input) {
   if (input.noAnchors)
     args.push("--no-anchors");
 }
-function buildShowContentArgs(input) {
+function buildShowArgs(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);
+  const args = start("show", input);
   at2(args, input.at);
   pushOptionalNumber(args, "--end", input.end);
   limit2(args, input.limit);
@@ -502,10 +616,10 @@ function buildShowContentArgs(input) {
   anchors(args, input);
   return finish(args);
 }
-function buildShowStructureArgs(input) {
+function buildTreeArgs(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);
+  const args = start("tree", input);
   at2(args, input.at);
   pushOptionalNumber(args, "--depth", input.depth);
   pushOptionalString(args, "--kind", input.kind);
@@ -514,35 +628,35 @@ function buildShowStructureArgs(input) {
     args.push("--outline");
   return finish(args);
 }
-function buildShowMetadataArgs(input) {
-  const args = start("show", "metadata", input);
+function buildMetaArgs(input) {
+  const args = start("meta", input);
   language(args, input);
   return finish(args);
 }
-function buildShowAssetsArgs(input) {
-  if (input.at !== undefined && !["page", "node", "asset"].includes(parseSelector(input.at).kind))
+function buildAssetsArgs(input) {
+  if (input.at !== undefined && !isDocumentSelector(parseSelector(input.at)))
     throw new Error("assets requires a page, node, or asset selector");
-  const args = start("show", "assets", input);
+  const args = start("assets", input);
   at2(args, input.at);
   return finish(args);
 }
-function buildCheckSyntaxArgs(input) {
-  const args = start("check", "syntax", input);
+function buildSyntaxArgs(input) {
+  const args = start("syntax", input);
   language(args, input);
   return finish(args);
 }
-function visionArgs(verb, object, input) {
+function visionArgs(command, 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))
+  if (input.at !== undefined && !isDocumentSelector(parseSelector(input.at)))
     throw new Error("vision requires a document selector");
-  const args = start(verb, object, input);
+  const args = start(command, input);
   at2(args, input.at);
   pushOptionalString(args, "--level", input.level);
   return args;
 }
-function buildGenerateCaptionArgs(input) {
-  const args = visionArgs("generate", "caption", input);
+function buildCaptionArgs(input) {
+  const args = visionArgs("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");
@@ -550,13 +664,13 @@ function buildGenerateCaptionArgs(input) {
   }
   return finish(args);
 }
-function buildDetectObjectsArgs(input) {
-  return finish(visionArgs("detect", "objects", input));
+function buildObjectsArgs(input) {
+  return finish(visionArgs("objects", input));
 }
-function buildRecognizeTextArgs(input) {
-  return finish(visionArgs("recognize", "text", input));
+function buildOcrArgs(input) {
+  return finish(visionArgs("ocr", input));
 }
-function buildFindNodesArgs(input) {
+function buildSearchArgs(input) {
   const hasPattern = Boolean(input.pattern);
   const hasRule = Boolean(input.rule);
   const hasContext = Boolean(input.context);
@@ -564,7 +678,7 @@ function buildFindNodesArgs(input) {
     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");
+    throw new Error("search requires pattern, context, or rule");
   }
   if (hasContext && !input.selector) {
     throw new Error("context requires selector");
@@ -572,7 +686,7 @@ function buildFindNodesArgs(input) {
   if (hasPattern && hasContext) {
     throw new Error("pattern and context cannot be combined");
   }
-  const args = start("find", "nodes", input);
+  const args = start("search", input);
   pushOptionalString(args, "--pattern", input.pattern);
   pushOptionalString(args, "--context", input.context);
   pushOptionalString(args, "--selector", input.selector);
@@ -583,28 +697,46 @@ function buildFindNodesArgs(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);
+function buildGrepArgs(input) {
+  const validated = validateGrepParams(input);
+  if (!validated.ok)
+    throw new Error(validated.error);
+  const args = ["grep", "--kdl", `--pattern=${input.pattern}`];
+  const needsPathTerminator = input.path !== undefined && input.path.startsWith("-") && input.path !== "-";
+  if (input.path !== undefined && !needsPathTerminator)
+    args.push(input.path);
+  if (input.literal)
+    args.push("--literal");
+  if (input.ignoreCase)
+    args.push("--ignore-case");
+  if (input.glob !== undefined)
+    args.push(`--glob=${input.glob}`);
+  pushOptionalNumber(args, "--context", input.context);
+  limit2(args, input.limit ?? 100);
+  if (input.summary)
+    args.push("--summary");
+  pushOptionalString(args, "--scope", input.scope);
+  pushOptionalNumber(args, "--scope-context", input.scopeContext);
   appendGitScopeArgs(args, input);
-  return finish(args);
+  if (input.path !== undefined && needsPathTerminator)
+    args.push("--", input.path);
+  return args;
 }
-function buildFindDefinitionsArgs(input) {
-  const args = start("find", "definitions", input);
+function buildDefArgs(input) {
+  const args = start("def", input);
   args.push("--name", input.name);
   language(args, input);
   appendGitScopeArgs(args, input);
   anchors(args, input);
   return finish(args);
 }
-function buildFindReferencesArgs(input) {
+function buildRefsArgs(input) {
   const validated = validateReferencesSelection(input);
   if (!validated.ok)
     throw new Error(validated.error);
-  if (input.at !== undefined && !["line", "hash"].includes(parseSelector(input.at).kind))
+  if (input.at !== undefined && !isBindingSelector(parseSelector(input.at)))
     throw new Error("references requires a line or hash selector");
-  const args = start("find", "references", input);
+  const args = start("refs", input);
   pushOptionalString(args, "--name", input.name);
   at2(args, input.at);
   language(args, input);
@@ -612,14 +744,14 @@ function buildFindReferencesArgs(input) {
   anchors(args, input);
   return finish(args);
 }
-function buildCheckRulesArgs(input) {
-  const args = start("check", "rules", input);
+function buildCheckArgs(input) {
+  const args = start("check", input);
   args.push("--rules", input.rules);
   appendGitScopeArgs(args, input);
   return finish(args);
 }
-function buildEditTextArgs(input) {
-  const args = start("edit", "text", input);
+function buildEditArgs(input) {
+  const args = start("edit", input);
   appendApplyAndPlanHash(args, input);
   language(args, input);
   appendGitScopeArgs(args, input);
@@ -627,10 +759,10 @@ function buildEditTextArgs(input) {
     args.push("--edits", "-");
   return finish(args);
 }
-function buildRenameSymbolArgs(input) {
-  if (!["line", "hash"].includes(parseSelector(input.at).kind))
+function buildRenameArgs(input) {
+  if (!isBindingSelector(parseSelector(input.at)))
     throw new Error("rename requires a line or hash selector");
-  const args = start("rename", "symbol", input);
+  const args = start("rename", input);
   at2(args, input.at);
   args.push("--to", input.to);
   if (input.workspace !== undefined)
@@ -643,6 +775,17 @@ function buildRenameSymbolArgs(input) {
 // ../readseek-api/src/client-output.ts
 import { Type } from "@sinclair/typebox";
 import { AssertError, Value } from "@sinclair/typebox/value";
+var OPERATIONS = ["Clone", "Clean", "Default", "Assert"];
+function parse(schema, value, what) {
+  try {
+    return Value.Parse(OPERATIONS, schema, value);
+  } catch (error) {
+    if (!(error instanceof AssertError))
+      throw error;
+    const detail = error.error;
+    throw new Error(`invalid readseek ${what}${detail?.path ?? ""}: ${detail?.message ?? "invalid value"}`);
+  }
+}
 var Int = Type.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER });
 var Str = Type.String();
 var Bool = Type.Boolean();
@@ -877,6 +1020,82 @@ var DefEnvelope = Type.Object({
     qualified_name: OptStr
   }))
 });
+function parseReadOutput(value) {
+  return parse(ReadOutput, value, "read output");
+}
+function parseStructureOutput(value) {
+  return parse(StructureOutput, value, "structure output");
+}
+function parseSearchOutput(value) {
+  const envelope = parse(SearchEnvelope, value, "search output");
+  const results = envelope.results;
+  if (envelope.returned_matches !== undefined)
+    results.returned_matches = envelope.returned_matches;
+  if (envelope.truncated !== undefined)
+    results.truncated = envelope.truncated;
+  if (envelope.byte_basis !== undefined)
+    results.byte_basis = envelope.byte_basis;
+  return results;
+}
+function parseRefsOutput(value) {
+  return parse(RefsEnvelope, value, "refs output").references.map(({ symbol, ...reference }) => ({
+    ...reference,
+    enclosingSymbol: symbol?.qualified_name
+  }));
+}
+function parseCheckOutput(value) {
+  const output = parse(CheckEnvelope, value, "check output");
+  return {
+    file_hash: output.file_hash,
+    errorCount: output.error_count,
+    missingCount: output.missing_count,
+    diagnostics: output.diagnostics
+  };
+}
+function parseDetectOutput(value) {
+  const output = value ?? {};
+  if (output.type === "application/pdf") {
+    return { kind: "pdf", ...parse(PdfDetectionInput, value, "detect output") };
+  }
+  if (output.width !== undefined || output.height !== undefined) {
+    return { kind: "image", ...parse(ImageDetectionInput, value, "detect output") };
+  }
+  if (output.language !== undefined) {
+    return { kind: "source", ...parse(SourceDetectionInput, value, "detect output") };
+  }
+  return { kind: "text", ...parse(TextDetectionInput, value, "detect output") };
+}
+function parseTextContent(value) {
+  const output = value ?? {};
+  if (output.hashlines === undefined || output.start_line !== undefined)
+    return parseReadOutput(value);
+  const spanned = parse(UnspannedContent, value, "content");
+  return {
+    ...spanned,
+    start_line: spanned.hashlines[0]?.line ?? 1,
+    end_line: spanned.hashlines[spanned.hashlines.length - 1]?.line ?? 0
+  };
+}
+function parseCursorOutput(value) {
+  return parse(CursorEnvelope, value, "cursor output");
+}
+function parsePdfMetadata(value) {
+  if (!value || typeof value !== "object")
+    return;
+  if (value.format !== "pdf")
+    return;
+  const document = parse(PdfMetadata, value, "inspect metadata");
+  return { kind: "pdf", type: "application/pdf", file: document.source, format: "pdf", pages: document.pages };
+}
+function parseEditOutput(value) {
+  return parse(EditOutputSchema, value, "edit output");
+}
+function parseRenameOutput(value) {
+  return parse(RenameOutputSchema, value, "rename output");
+}
+function parseDefOutput(value) {
+  return parse(DefEnvelope, value, "def output").locations;
+}
 var Bbox = Type.Object({ x: Type.Number(), y: Type.Number(), width: Type.Number(), height: Type.Number() });
 var Position = { page: OptInt, destination: OptStr, bbox: Type.Optional(Bbox) };
 var Provenance = { inferred: Type.Optional(Bool), model: OptStr, level: OptStr, task: OptStr };
@@ -933,25 +1152,41 @@ var DocumentOutput = Type.Object({
   assets: Type.Array(DocumentAsset, { default: [] }),
   vision: Type.Array(DocumentVision, { default: [] })
 });
-var TextHit = Type.Object({
-  line: Int,
-  column: Int,
+var GrepCount = Type.Integer({ minimum: 0, maximum: Number.MAX_SAFE_INTEGER });
+var GrepPosition = Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER });
+var GrepAnchor = Type.String({ pattern: "^[1-9][0-9]*:[0-9a-f]{6}$" });
+var GrepLineSchema = Type.Object({
+  line: GrepPosition,
+  hash: Type.String({ pattern: "^[0-9a-f]{6}$" }),
   text: Str,
-  start_line: Int,
-  end_line: Int,
-  start_byte: Int,
-  end_byte: Int,
-  hashlines: Hashlines
+  kind: Type.Union([Type.Literal("match"), Type.Literal("context")])
 });
-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,
+var GrepHitSchema = Type.Object({ line: GrepPosition, column: GrepPosition, start_byte: GrepCount, end_byte: GrepCount, text: Str, anchor: GrepAnchor });
+var GrepSymbolSchema = Type.Object({ name: Str, kind: Str, start_line: GrepPosition, end_line: GrepPosition, lines: Type.Array(GrepLineSchema) });
+var GrepSourceResultSchema = Type.Object({
+  file: Str,
+  file_hash: Str,
+  language: Str,
+  total_matches: GrepCount,
+  returned_matches: GrepCount,
+  hits: Type.Array(GrepHitSchema),
+  lines: Type.Array(GrepLineSchema),
+  symbols: Type.Array(GrepSymbolSchema)
+});
+var GrepDocumentHitSchema = Type.Object({ node_id: Str, kind: Str, snippet: Str, line: GrepPosition, page: Type.Optional(GrepPosition) });
+var GrepDocumentResultSchema = Type.Object({ file: Str, content_hash: Str, total_matches: GrepCount, returned_matches: GrepCount, hits: Type.Array(GrepDocumentHitSchema) });
+var GrepOutputSchema = Type.Object({
+  pattern: Str,
+  mode: Type.Union([Type.Literal("regex"), Type.Literal("literal")]),
+  ignore_case: Bool,
+  summary: Bool,
+  total_matches: GrepCount,
+  returned_matches: GrepCount,
   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) }))
+  count_unit: Type.Literal("lines"),
+  scope: Type.Optional(Type.Literal("symbol")),
+  results: Type.Array(GrepSourceResultSchema),
+  documents: Type.Array(GrepDocumentResultSchema)
 });
 var RuleFinding = Type.Object({
   name: Str,
@@ -972,7 +1207,72 @@ var RulesOutput = Type.Object({
   violation_count: Int,
   diagnostics: Type.Array(RuleFinding)
 });
+function parseDocumentOutput(value) {
+  return parse(DocumentOutput, value, "document output");
+}
+function parseContentOutput(value) {
+  const output = value;
+  if (output?.format !== undefined)
+    return parseDocumentOutput(value);
+  if (!output || output.metadata === undefined || output.content === undefined)
+    throw new Error("invalid readseek content: missing metadata or content");
+  const metadata = parseDetectOutput(output.metadata);
+  return {
+    metadata,
+    content: metadata.kind === "image" ? parse(ImageDescriptor, output.content, "image descriptor") : parseTextContent(output.content),
+    ...output.cursor !== undefined ? { cursor: parseCursorOutput(output.cursor) } : {}
+  };
+}
+function parseStructureEnvelope(value) {
+  const output = value;
+  if (output?.format !== undefined)
+    return parseDocumentOutput(value);
+  if (!output || output.structure === undefined)
+    throw new Error("invalid readseek structure: missing structure");
+  return { ...output.metadata !== undefined ? { metadata: parseDetectOutput(output.metadata) } : {}, structure: parseStructureOutput(output.structure) };
+}
+function parseGrepOutput(value) {
+  const output = parse(GrepOutputSchema, value, "grep output");
+  const invalid = (message) => {
+    throw new Error(`invalid readseek grep output: ${message}`);
+  };
+  const groups = [...output.results, ...output.documents];
+  if (output.returned_matches > output.total_matches || groups.reduce((sum, group) => sum + group.total_matches, 0) !== output.total_matches || groups.reduce((sum, group) => sum + group.returned_matches, 0) !== output.returned_matches)
+    invalid("inconsistent counts");
+  for (const group of groups) {
+    if (group.total_matches === 0 || group.returned_matches > group.total_matches)
+      invalid("inconsistent file counts");
+    if (output.summary ? group.hits.length !== 0 : group.hits.length !== group.returned_matches)
+      invalid("inconsistent hit count");
+  }
+  for (const result of output.results) {
+    if (output.summary && (result.lines.length > 0 || result.symbols.length > 0))
+      invalid("summary contains display entries");
+    if (output.scope !== "symbol" && result.symbols.length > 0)
+      invalid("symbols require symbol scope");
+    for (const hit of result.hits) {
+      if (hit.end_byte < hit.start_byte || Number(hit.anchor.split(":")[0]) !== hit.line)
+        invalid("invalid hit span or anchor");
+    }
+    for (const symbol of result.symbols) {
+      if (symbol.end_line < symbol.start_line || symbol.lines.some((line) => line.line < symbol.start_line || line.line > symbol.end_line))
+        invalid("invalid symbol range");
+    }
+  }
+  return output;
+}
+function parseRulesOutput(value) {
+  return parse(RulesOutput, value, "rules output");
+}
 var SourceAssetsOutput = Type.Object({ file: OptStr, metadata: Type.Optional(Detection), assets: Type.Array(DocumentAsset, { default: [] }) });
+function parseAssetsOutput(value) {
+  const raw = value;
+  if (raw?.format !== undefined)
+    return parseDocumentOutput(value);
+  if (!raw || raw.file === undefined && raw.metadata === undefined)
+    throw new Error("invalid readseek assets output: missing file or metadata");
+  return parse(SourceAssetsOutput, { ...raw, ...raw.metadata !== undefined ? { metadata: parseDetectOutput(raw.metadata) } : {} }, "assets output");
+}
 
 // ../readseek-api/src/edit-plan.ts
 import { Document, Node, format } from "@bgotink/kdl";
@@ -1014,9 +1314,84 @@ function serializeEditPlan(edits) {
     throw new Error(validation.error);
   return format(new Document([node("plan", {}, validation.edits.map(editNode))]));
 }
+
+// ../readseek-api/src/client.ts
+function runOptions(options, vision = false) {
+  return {
+    signal: options.signal,
+    stdin: options.stdin,
+    timeoutMs: options.timeoutMs,
+    cancelable: options.cancelable,
+    ...vision ? { vision: true } : {}
+  };
+}
+function createReadSeekClient(runner) {
+  return {
+    async show(path, options = {}) {
+      const value = await runner.kdl(buildShowArgs({ ...options, path }), runOptions(options));
+      return parseContentOutput(value);
+    },
+    async tree(path, options = {}) {
+      const value = await runner.kdl(buildTreeArgs({ ...options, path }), runOptions(options));
+      return parseStructureEnvelope(value);
+    },
+    async meta(path, options = {}) {
+      const value = await runner.kdl(buildMetaArgs({ ...options, path }), runOptions(options));
+      return parsePdfMetadata(value) ?? parseDetectOutput(value?.metadata);
+    },
+    async assets(path, options = {}) {
+      const value = await runner.kdl(buildAssetsArgs({ ...options, path }), runOptions(options));
+      return parseAssetsOutput(value);
+    },
+    async syntax(path, options = {}) {
+      const value = await runner.kdl(buildSyntaxArgs({ ...options, path }), runOptions(options));
+      return parseCheckOutput(value?.diagnostics ?? value);
+    },
+    async check(path, options) {
+      const value = await runner.kdl(buildCheckArgs({ ...options, path }), runOptions(options));
+      return parseRulesOutput(value);
+    },
+    async caption(path, options = {}) {
+      const value = await runner.kdl(buildCaptionArgs({ ...options, path }), runOptions(options, true));
+      return parseContentOutput(value);
+    },
+    async objects(path, options = {}) {
+      const value = await runner.kdl(buildObjectsArgs({ ...options, path }), runOptions(options, true));
+      return parseContentOutput(value);
+    },
+    async ocr(path, options = {}) {
+      const value = await runner.kdl(buildOcrArgs({ ...options, path }), runOptions(options, true));
+      return parseContentOutput(value);
+    },
+    async search(path, options) {
+      const value = await runner.kdl(buildSearchArgs({ ...options, path }), runOptions(options));
+      return parseSearchOutput(value);
+    },
+    async grep(params) {
+      const value = await runner.kdl(buildGrepArgs(params), runOptions(params));
+      return parseGrepOutput(value);
+    },
+    async def(path, options) {
+      const value = await runner.kdl(buildDefArgs({ ...options, path }), runOptions(options));
+      return parseDefOutput(value);
+    },
+    async refs(path, options) {
+      const value = await runner.kdl(buildRefsArgs({ ...options, path }), runOptions(options));
+      return parseRefsOutput(value);
+    },
+    async edit(path, edits, options = {}) {
+      const stdin = serializeEditPlan(edits);
+      return parseEditOutput(await runner.kdl(buildEditArgs({ ...options, path, requestFromStdin: true }), runOptions({ ...options, stdin })));
+    },
+    async rename(path, options) {
+      const value = await runner.kdl(buildRenameArgs({ ...options, path }), runOptions(options));
+      return parseRenameOutput(value);
+    }
+  };
+}
 // ../readseek-api/src/show-presentation.ts
 function isShowTool(name) {
-  return name === "show_content" || name === "show_structure" || name === "show_metadata" || name === "show_assets";
+  return name === "show" || name === "tree" || name === "meta" || name === "assets";
 }
 function record(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
@@ -1131,7 +1506,7 @@ function presentShowResult(tool, value, options = {}) {
   const path = inline(options.path || output.source || output.file || content.file || structure.file || metadata.file || cursor.file) || "(unknown path)";
   const summary = [];
   const result = { summary: "", body: "", notices: [], metadata: {} };
-  if (tool === "show_metadata") {
+  if (tool === "meta") {
     const data = Object.keys(metadata).length > 0 ? metadata : output;
     if (text(data.format || data.language || data.type))
       summary.push(inline(data.format || data.language || data.type));
@@ -1140,7 +1515,7 @@ function presentShowResult(tool, value, options = {}) {
       summary.push(plural(result.metadata.pages, "page"));
     }
     result.body = fields(data) || "No metadata available.";
-  } else if (tool === "show_assets") {
+  } else if (tool === "assets") {
     const assets = records(output.assets);
     result.metadata.assets = assets.length;
     summary.push(plural(assets.length, "asset"));
@@ -1154,7 +1529,7 @@ function presentShowResult(tool, value, options = {}) {
     summary.push(plural(nodes.length, "node"));
     if (result.metadata.pages !== undefined)
       summary.push(plural(result.metadata.pages, "page"));
-    const sections = [text(output.title) ? safe(text(output.title)) : "", documentNodes(nodes, tool === "show_content")];
+    const sections = [text(output.title) ? safe(text(output.title)) : "", documentNodes(nodes, tool === "show")];
     if (assets.length > 0) {
       result.metadata.assets = assets.length;
       sections.push(`Assets
@@ -1163,7 +1538,7 @@ ${assetList(assets)}`);
     result.body = sections.filter(Boolean).join(`
 
 `) || "No content in this selection.";
-  } else if (tool === "show_structure") {
+  } else if (tool === "tree") {
     const symbols = records(structure.symbols);
     result.metadata.symbols = symbols.length;
     summary.push(plural(symbols.length, "symbol"));
@@ -1217,7 +1592,7 @@ ${assetList(assets)}`);
     const description = Object.keys(content).length > 0 ? content : output;
     result.body = fields(description) || "No content in this selection.";
   }
-  if (tool === "show_structure")
+  if (tool === "tree")
     result.notices.push("Structure is limited to the requested depth, kind, and outline. Use a deeper depth or focus with at to inspect further.");
   if (text(output.warning))
     result.notices.push(safe(text(output.warning)));
@@ -1229,6 +1604,31 @@ function formatShowResult(presentation) {
 
 `);
 }
+// ../readseek-api/src/grep-presentation.ts
+function renderGrepOutput(output) {
+  const rendered = [`${output.returned_matches} of ${output.total_matches} matching lines${output.truncated ? " (truncated)" : ""}`];
+  const displayLine = (line) => `${line.line}:${line.hash}|${line.kind === "match" ? ">>" : "  "}${line.text}`;
+  for (const result of output.results) {
+    rendered.push(`${result.file}: ${result.total_matches} matching lines (${result.returned_matches} returned)`);
+    if (output.summary)
+      continue;
+    rendered.push(...result.lines.map(displayLine));
+    for (const symbol of result.symbols) {
+      rendered.push(`  ${symbol.kind} ${symbol.name} (${symbol.start_line}-${symbol.end_line})`);
+      rendered.push(...symbol.lines.map(displayLine));
+    }
+  }
+  for (const document of output.documents) {
+    rendered.push(`${document.file}: ${document.total_matches} matching lines (${document.returned_matches} returned)`);
+    if (output.summary)
+      continue;
+    for (const hit of document.hits) {
+      rendered.push(`  node:${hit.node_id}${hit.page === undefined ? "" : ` page:${hit.page}`} line:${hit.line} (${hit.kind}): ${hit.snippet}`);
+    }
+  }
+  return rendered.join(`
+`);
+}
 // ../readseek-api/src/platform.ts
 import { accessSync, constants as fsConstants, existsSync, statSync } from "node:fs";
 import { createRequire } from "node:module";
@@ -1330,7 +1730,7 @@ function cleanReadSeekErrorText(stderr) {
   return stderr.replace(READSEEK_USAGE_HINT, "").replace(/^error:\s*/i, "").replace(/\s*\n\s*/g, " ").trim();
 }
 // ../readseek-api/src/kdl.ts
-import { parse } from "@bgotink/kdl";
+import { parse as parse2 } from "@bgotink/kdl";
 function convertNode(node) {
   if (node.getTag() !== null)
     throw new Error("KDL node annotations are not supported");
@@ -1358,7 +1758,7 @@ function convertNode(node) {
   };
 }
 function parseKdlDocument(text) {
-  const document = parse(text);
+  const document = parse2(text);
   if (document.nodes.length !== 1)
     throw new Error("KDL document must contain exactly one root node");
   return convertNode(document.nodes[0]);
@@ -1492,6 +1892,46 @@ function search(root) {
     }))
   };
 }
+function grepChildren(node, allowed) {
+  if (node.children.some((child) => !allowed.includes(child.name))) {
+    throw new Error(`invalid readseek KDL grep: unexpected child of ${node.name}`);
+  }
+}
+function grepLine(node) {
+  grepChildren(node, []);
+  const parsed = line(node);
+  if (requireProperty(node, "number") !== parsed.line)
+    throw new Error("invalid readseek KDL grep line number");
+  return { ...parsed, kind: requireProperty(node, "kind") };
+}
+function grep(root) {
+  grepChildren(root, ["match", "document"]);
+  return parseGrepOutput({
+    ...properties(root),
+    results: children(root, "match").map((match) => {
+      grepChildren(match, ["hit", "line", "symbol"]);
+      return {
+        ...properties(match),
+        hits: children(match, "hit").map((hit) => {
+          grepChildren(hit, []);
+          return properties(hit);
+        }),
+        lines: children(match, "line").map(grepLine),
+        symbols: children(match, "symbol").map((symbol) => {
+          grepChildren(symbol, ["line"]);
+          return { ...properties(symbol), lines: children(symbol, "line").map(grepLine) };
+        })
+      };
+    }),
+    documents: children(root, "document").map((document) => {
+      grepChildren(document, ["hit"]);
+      return { ...properties(document), hits: children(document, "hit").map((hit) => {
+        grepChildren(hit, []);
+        return properties(hit);
+      }) };
+    })
+  });
+}
 function references(root) {
   const parsed = children(root, "reference").map((reference) => {
     const sourceLine = child(reference, "line");
@@ -1607,7 +2047,7 @@ function parseReadSeekKdl(text) {
     case "document":
       return root.properties.has("format") ? pdfDocument(root) : sourceDocument(root);
     case "search":
-      return search(root);
+      return ["mode", "ignore_case", "summary", "count_unit"].some((key) => root.properties.has(key)) ? grep(root) : search(root);
     case "check":
       return diagnostics(root);
     case "refs":
@@ -1672,7 +2112,7 @@ function acceptsReadSeekExitCode(args, exitCode) {
       index++;
       continue;
     }
-    return arg === "find" || arg === "check";
+    return arg === "grep" || arg === "search" || arg === "def" || arg === "refs" || arg === "syntax" || arg === "check";
   }
   return false;
 }
@@ -1806,8 +2246,8 @@ function collectAnchoredFiles(value, files) {
   if (!value || typeof value !== "object")
     return;
   const output = value;
-  const hashlines = output.hashlines;
-  if (typeof output.file === "string" && Array.isArray(hashlines) && hashlines.some((line) => typeof record2(line).line === "number" && typeof record2(line).hash === "string"))
+  const lineGroups = [output.hashlines, output.lines, ...items(output.symbols).map((symbol) => record2(symbol).lines)];
+  if (typeof output.file === "string" && lineGroups.some((lines) => items(lines).some((line) => typeof record2(line).line === "number" && typeof record2(line).hash === "string")))
     files.add(output.file);
   for (const item of Object.values(output))
     collectAnchoredFiles(item, files);
@@ -1873,12 +2313,12 @@ function resolveImagePolicy(options) {
   throw new Error('opencode-readseek imageMode must be "on", "auto", or "off"');
 }
 function contentArgs(filePath, options = {}) {
-  return buildShowContentArgs({ path: filePath, ...options, at: options.at ?? (options.end === undefined ? undefined : "line:1") });
+  return buildShowArgs({ path: filePath, ...options, at: options.at ?? (options.end === undefined ? undefined : "line:1") });
 }
 function requireContent(envelope) {
   const value = record2(envelope).content;
   if (value === undefined || value === null || typeof value !== "object") {
-    throw new Error("show content returned no source content");
+    throw new Error("show returned no source content");
   }
   return value;
 }
@@ -1920,6 +2360,12 @@ async function runReadSeek(context, args, options = {}) {
     timeoutMs: options.timeoutMs
   }));
 }
+function readSeekClient(context) {
+  return createReadSeekClient({
+    text: (args, options) => runReadSeekRaw(context, [...args], options),
+    kdl: (args, options) => runReadSeek(context, [...args], options)
+  });
+}
 async function runContent(context, args, options = {}) {
   return requireContent(await runReadSeek(context, args, options));
 }
@@ -1954,7 +2400,7 @@ async function ensureReadSeekCache(context) {
     if (error.code !== "ENOENT")
       throw error;
   }
-  readSeekCacheInit ??= runReadSeekRaw(context, ["--readseek-dir", cacheDir, "initialize", "index"], { cancelable: false }).then(() => cacheDir).finally(() => {
+  readSeekCacheInit ??= runReadSeekRaw(context, ["--readseek-dir", cacheDir, "init"], { cancelable: false }).then(() => cacheDir).finally(() => {
     readSeekCacheInit = undefined;
   });
   return readSeekCacheInit;
@@ -2043,7 +2489,6 @@ ${[...paths].sort().map((filePath) => `- ${filePath}`).join(`
 }
 
 // src/tools.ts
-import { readFile as readFile2, stat as stat3 } from "node:fs/promises";
 import { tool as tool3 } from "@opencode-ai/plugin";
 
 // src/constants.ts
@@ -2372,31 +2817,31 @@ import { pathToFileURL } from "node:url";
 import { tool as tool2 } from "@opencode-ai/plugin";
 function initialTitle(kind, args) {
   switch (kind) {
-    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":
+    case "tree":
+    case "meta":
+    case "syntax":
+    case "check":
+    case "caption":
+    case "objects":
+    case "ocr":
+      return `${kind} ${args.path}`;
+    case "show":
       return `Show content ${args.path}`;
-    case "show_assets":
+    case "assets":
       return `Show assets ${args.path}`;
-    case "find_nodes":
+    case "search":
       return `Find nodes ${args.pattern ?? args.context ?? args.rule}`;
-    case "find_text":
-      return `Find text ${args.pattern ?? args.text}`;
-    case "find_definitions":
+    case "grep":
+      return `Find text ${args.pattern}`;
+    case "def":
       return `Find definition ${args.name}`;
-    case "find_references":
+    case "refs":
       return `Find references to ${args.name ?? args.at}`;
-    case "rename_symbol":
+    case "rename":
       return `Rename ${args.path}:${args.at} to ${args.to}`;
-    case "edit_text":
+    case "edit":
       return `Edit ${args.path}`;
-    case "write_file":
+    case "write":
       return `Write ${args.path}`;
   }
 }
@@ -2407,34 +2852,31 @@ function resultPresentation(kind, args, value) {
     return { title: presentation.summary, metadata: presentation.metadata };
   }
   switch (kind) {
-    case "check_syntax": {
+    case "syntax": {
       const diagnostics = record2(output.diagnostics ?? output);
       const errors = typeof diagnostics.error_count === "number" ? diagnostics.error_count : 0;
       const missing = typeof diagnostics.missing_count === "number" ? diagnostics.missing_count : 0;
       return { title: `Syntax ${args.path} (${errors} errors, ${missing} missing)`, metadata: { error_count: errors, missing_count: missing } };
     }
-    case "find_nodes": {
+    case "search": {
       const results = items(output.results);
       const matches = results.reduce((total, result) => total + items(record2(result).matches).length, 0);
       return { title: `Found ${matches} matches`, metadata: { results: results.length, matches } };
     }
-    case "find_text": {
-      const results = items(output.results);
-      const matches = results.reduce((total, result) => {
-        const entry = record2(result);
-        return total + (typeof entry.count === "number" ? entry.count : items(entry.matches).length);
-      }, 0);
-      return { title: `Found ${matches} matches`, metadata: { results: results.length, matches } };
+    case "grep": {
+      const results = items(output.results).length + items(output.documents).length;
+      const matches = output.total_matches;
+      return { title: `Found ${matches} matches`, metadata: { results, matches } };
     }
-    case "find_definitions": {
+    case "def": {
       const locations = items(output.locations).length;
       return { title: `Found ${locations} definitions`, metadata: { locations } };
     }
-    case "find_references": {
+    case "refs": {
       const references = items(output.references).length;
       return { title: `Found ${references} references`, metadata: { references } };
     }
-    case "rename_symbol": {
+    case "rename": {
       const oldName = output.old_name;
       const newName = output.new_name;
       const otherOutputs = items(output.others).map(record2);
@@ -2444,10 +2886,10 @@ 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_text":
-    case "write_file": {
+    case "edit":
+    case "write": {
       const preview = typeof output.preview_error === "string" ? " (preview unavailable)" : "";
-      return { title: `${kind === "edit_text" ? "Edited" : "Wrote"} ${args.path}${preview}`, metadata: {} };
+      return { title: `${kind === "edit" ? "Edited" : "Wrote"} ${args.path}${preview}`, metadata: {} };
     }
   }
   return { title: initialTitle(kind, args), metadata: {} };
@@ -2482,8 +2924,8 @@ function readseekTool(description, args, kind, execute, imagePolicy) {
       return {
         ...attachments.length > 0 ? { attachments } : {},
         title: presentation.title,
-        output: isShowTool(kind) ? formatShowResult(presentShowResult(kind, displayResult, args)) : render(displayResult),
-        metadata: { ...presentation.metadata, ...isShowTool(kind) ? { readseek: result } : {} }
+        output: isShowTool(kind) ? formatShowResult(presentShowResult(kind, displayResult, args)) : kind === "grep" ? renderGrepOutput(result) : render(displayResult),
+        metadata: { ...presentation.metadata, ...isShowTool(kind) || kind === "grep" ? { readseek: result } : {} }
       };
     }
   });
@@ -2493,107 +2935,38 @@ function readseekTool(description, args, kind, execute, imagePolicy) {
 function createReadSeekTools(imagePolicy) {
   return {
     ...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),
+    readseek_grep: readseekTool(openCodeToolDescription("grep"), {
+      pattern: tool3.schema.string().describe(PARAM_DESCRIPTIONS.grepPattern),
       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) => {
+      limit: tool3.schema.number().int().positive().optional().describe(PARAM_DESCRIPTIONS.matchLimit),
+      scope: tool3.schema.literal("symbol").optional().describe(PARAM_DESCRIPTIONS.grepScope),
+      scopeContext: tool3.schema.number().int().nonnegative().optional().describe(PARAM_DESCRIPTIONS.scopeContext),
+      gitScope: tool3.schema.enum(GIT_SCOPES).optional().describe(PARAM_DESCRIPTIONS.gitScope)
+    }, "grep", async (input, context) => {
       const target = resolvePath(context.directory, input.path ?? ".");
-      if (input.pattern === undefined === (input.text === undefined)) {
-        throw new Error("exactly one of pattern or text is required");
-      }
-      const pattern = input.pattern ?? input.text;
+      const pattern = input.pattern;
       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 || 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)}`);
-      }
-      const info = await stat3(target);
-      const files = [];
-      if (info.isFile())
-        files.push(target);
-      else if (info.isDirectory()) {
-        const glob = new Bun.Glob(input.glob ?? "**/*");
-        for await (const filePath of glob.scan({ cwd: target, absolute: true, onlyFiles: true, followSymlinks: false })) {
-          files.push(filePath);
-        }
-      } else
-        throw new Error(`grep target is not a file or directory: ${target}`);
-      const maxMatches = input.limit ?? 100;
-      const contextLines = input.context ?? 0;
-      const results = [];
-      let totalMatches = 0;
-      let truncated = false;
-      for (const filePath of files.sort()) {
-        context.abort.throwIfAborted();
-        if (truncated)
-          break;
-        const buffer = await readFile2(filePath);
-        if (buffer.includes(0))
-          continue;
-        const lines = buffer.toString("utf8").replace(/\r\n/g, `
-`).split(`
-`);
-        const matchLines = new Set;
-        const ranges = [];
-        for (let index = 0;index < lines.length; index++) {
-          expression.lastIndex = 0;
-          if (!expression.test(lines[index] ?? ""))
-            continue;
-          if (totalMatches === maxMatches) {
-            truncated = true;
-            break;
-          }
-          const line = index + 1;
-          matchLines.add(line);
-          ranges.push([Math.max(1, line - contextLines), Math.min(lines.length, line + contextLines)]);
-          totalMatches++;
-        }
-        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);
-          if (previous && start <= previous[1] + 1)
-            previous[1] = Math.max(previous[1], end);
-          else
-            mergedRanges.push([start, end]);
-        }
-        const linesByNumber = new Map;
-        for (const [start, end] of mergedRanges) {
-          const output = record2(await runContent(context, readRangeArgs(filePath, start, end)));
-          for (const hashline of items(output.hashlines)) {
-            const line = record2(hashline).line;
-            if (typeof line === "number" && !linesByNumber.has(line))
-              linesByNumber.set(line, hashline);
-          }
-        }
-        const hashlines = [...linesByNumber.values()];
-        const matches = hashlines.filter((hashline) => {
-          const line = record2(hashline).line;
-          return typeof line === "number" && matchLines.has(line);
-        });
-        results.push({ file: filePath, matches, hashlines });
-      }
-      return { results, truncated };
+      return readSeekClient(context).grep({
+        pattern,
+        path: target,
+        glob: input.glob,
+        ignoreCase: input.ignoreCase,
+        literal: input.literal,
+        context: input.context,
+        limit: input.limit,
+        summary: input.summary,
+        scope: input.scope,
+        scopeContext: input.scopeContext,
+        gitScope: input.gitScope,
+        signal: context.abort
+      });
     }),
-    readseek_find_nodes: readseekTool(openCodeToolDescription("find_nodes"), {
+    readseek_search: readseekTool(openCodeToolDescription("search"), {
       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),
@@ -2602,9 +2975,9 @@ function createReadSeekTools(imagePolicy) {
       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) => {
+    }, "search", async (input, context) => {
       const target = resolvePath(context.directory, input.path ?? ".");
-      const args = buildFindNodesArgs({
+      const args = buildSearchArgs({
         path: target,
         pattern: input.pattern,
         context: input.context,
@@ -2622,14 +2995,14 @@ function createReadSeekTools(imagePolicy) {
         throw new Error("rule stdin is unavailable in OpenCode tools; use inline KDL or @path");
       return runReadSeek(context, args);
     }),
-    readseek_find_definitions: readseekTool(openCodeToolDescription("find_definitions"), {
+    readseek_def: readseekTool(openCodeToolDescription("def"), {
       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) => {
+    }, "def", async (input, context) => {
       const target = resolvePath(context.directory, input.path ?? ".");
-      const args = buildFindDefinitionsArgs({
+      const args = buildDefArgs({
         path: target,
         name: input.name,
         language: input.language,
@@ -2638,16 +3011,16 @@ function createReadSeekTools(imagePolicy) {
       await authorizeSearch(context, target, input.name);
       return runReadSeek(context, args);
     }),
-    readseek_find_references: readseekTool(openCodeToolDescription("find_references"), {
+    readseek_refs: readseekTool(openCodeToolDescription("refs"), {
       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) => {
+    }, "refs", async (input, context) => {
       const target = resolvePath(context.directory, input.path ?? ".");
       const name = input.name;
-      const args = buildFindReferencesArgs({
+      const args = buildRefsArgs({
         path: target,
         name,
         at: input.at,
@@ -2657,7 +3030,7 @@ function createReadSeekTools(imagePolicy) {
       await authorizeSearch(context, target, name ?? "*");
       return runReadSeek(context, args);
     }),
-    readseek_rename_symbol: readseekTool(openCodeToolDescription("rename_symbol"), {
+    readseek_rename: readseekTool(openCodeToolDescription("rename"), {
       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),
@@ -2666,7 +3039,7 @@ function createReadSeekTools(imagePolicy) {
       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) => {
+    }, "rename", async (input, context) => {
       const filePath = resolvePath(context.directory, input.path);
       await authorizeRead(context, filePath);
       if (input.workspace) {
@@ -2676,7 +3049,7 @@ function createReadSeekTools(imagePolicy) {
           throw new Error("readseek could not identify a binding at the rename cursor");
         await authorizeSearch(context, context.directory, name);
       }
-      const args = buildRenameSymbolArgs({
+      const args = buildRenameArgs({
         path: filePath,
         to: input.to,
         at: input.at,
@@ -2696,7 +3069,7 @@ function createReadSeekTools(imagePolicy) {
         throw new Error("readseek rename plan did not include a plan hash");
       }
       await authorizeEdit(context, files);
-      return runReadSeek(context, buildRenameSymbolArgs({
+      return runReadSeek(context, buildRenameArgs({
         path: filePath,
         to: input.to,
         at: input.at,
@@ -2710,7 +3083,7 @@ function createReadSeekTools(imagePolicy) {
         timeoutMs: DEFAULT_READSEEK_TIMEOUT_MS
       });
     }),
-    readseek_edit_text: readseekTool(openCodeToolDescription("edit_text"), {
+    readseek_edit: readseekTool(openCodeToolDescription("edit"), {
       path: tool3.schema.string().describe(PARAM_DESCRIPTIONS.projectPath),
       edits: tool3.schema.array(tool3.schema.union([
         tool3.schema.object({
@@ -2750,7 +3123,7 @@ function createReadSeekTools(imagePolicy) {
       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) => {
+    }, "edit", async (input, context) => {
       const filePath = resolvePath(context.directory, input.path);
       validateEdits(input.edits);
       return withFileMutationQueue(filePath, async () => {
@@ -2759,7 +3132,7 @@ function createReadSeekTools(imagePolicy) {
         await rejectSymlinkMutation(filePath);
         const edits = input.edits;
         const request = serializeEditPlan(edits);
-        const baseArgs = buildEditTextArgs({
+        const baseArgs = buildEditArgs({
           path: filePath,
           language: input.language,
           gitScope: input.gitScope,
@@ -2783,7 +3156,7 @@ function createReadSeekTools(imagePolicy) {
         }
         await authorizeEdit(context, [filePath], simpleDiff(filePath, before, after), false);
         context.abort.throwIfAborted();
-        const applied = record2(await runReadSeek(context, buildEditTextArgs({
+        const applied = record2(await runReadSeek(context, buildEditArgs({
           path: filePath,
           language: input.language,
           gitScope: input.gitScope,
@@ -2801,10 +3174,10 @@ function createReadSeekTools(imagePolicy) {
         return postMutationPreview(context, previewArgs, filePath, true);
       });
     }),
-    readseek_write_file: readseekTool(openCodeToolDescription("write_file"), {
+    readseek_write: readseekTool(openCodeToolDescription("write"), {
       path: tool3.schema.string().describe(PARAM_DESCRIPTIONS.projectPath),
       content: tool3.schema.string().describe(PARAM_DESCRIPTIONS.content)
-    }, "write_file", async (input, context) => {
+    }, "write", async (input, context) => {
       const filePath = resolvePath(context.directory, input.path);
       await authorizeExternal(context, filePath);
       return withFileMutationQueue(filePath, async () => {
@@ -2828,37 +3201,37 @@ function createAccessTools(imagePolicy) {
   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 } }
+    show: { build: buildShowArgs, args: { ...pathSchema, ...atSchema, ...languageSchema, end: tool3.schema.number().int().positive().optional(), limit: tool3.schema.number().int().positive().optional(), noAnchors: tool3.schema.boolean().optional() } },
+    tree: { build: buildTreeArgs, args: { ...pathSchema, ...atSchema, ...languageSchema, depth: tool3.schema.number().int().nonnegative().optional(), kind: tool3.schema.string().optional(), outline: tool3.schema.boolean().optional() } },
+    meta: { build: buildMetaArgs, args: { ...pathSchema, ...languageSchema } },
+    assets: { build: buildAssetsArgs, args: { ...pathSchema, ...atSchema } },
+    syntax: { build: buildSyntaxArgs, args: { ...pathSchema, ...languageSchema } },
+    check: { build: buildCheckArgs, args: { path: tool3.schema.string().optional().describe(PARAM_DESCRIPTIONS.projectSearchPath), rules: tool3.schema.string().min(1), gitScope: tool3.schema.enum(GIT_SCOPES).optional() } },
+    caption: { build: buildCaptionArgs, args: { ...pathSchema, ...atSchema, ...levelSchema, include: tool3.schema.array(tool3.schema.enum(["text", "objects"])).min(1).optional() } },
+    objects: { build: buildObjectsArgs, args: { ...pathSchema, ...atSchema, ...levelSchema } },
+    ocr: { build: buildOcrArgs, 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 } : {} };
+      const buildInput = { ...input, path: filePath, ...name === "tree" ? { depth: input.depth ?? DEFAULT_STRUCTURE_DEPTH } : {} };
       let args = definition.build(buildInput);
       await authorizeRead(context, filePath);
-      if (name === "check_rules") {
+      if (name === "check") {
         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 inference = ["caption", "objects", "ocr"].includes(name);
+      if (name === "show" || name === "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)
+    }, name === "show" || name === "assets" ? imagePolicy : undefined)
   ]));
 }
 
@@ -2873,28 +3246,28 @@ 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:
+Commands use flat single-word verbs, with target and primary query arguments 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
+readseek show file.ts --at line:10 --limit 40 --kdl
+readseek tree file.ts --depth 1 --kdl
+readseek meta paper.pdf --kdl
+readseek assets paper.pdf --at page:2 --kdl
+readseek syntax file.ts --kdl
+readseek check . @checks.kdl --kdl
+readseek search 'console.log($$$ARGS)' src --kdl
+readseek grep 'TODO' src --kdl
+readseek def main src --kdl
+readseek refs file.ts --at line:10:3 --kdl
+readseek edit file.ts @edits.kdl --kdl
+readseek rename file.ts --at line:10:3 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"\`.
+Native \`grep\` uses UTF-8 RE2 regex by default; add \`--literal\` for exact text. Its positive \`--limit\` defaults to 100 matching lines, not occurrences. Reference selection requires either a symbol \`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.
+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 \`caption\` (optionally \`--include text,objects\`), \`objects\`, or \`ocr\`, 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.`
 };
@@ -2951,7 +3324,7 @@ var ReadSeekPlugin = async (_input, options) => {
         return;
       try {
         const result = output.metadata.readseek ?? JSON.parse(output.output);
-        if (input.tool === "readseek_rename_symbol") {
+        if (input.tool === "readseek_rename") {
           anchors.planRename(input.sessionID, result);
           if (record2(result).applied === true) {
             for (const filePath of renameFiles(result))