pi-readseek 0.11.4 → 0.12.1

package/dist/index.ts

@@ -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,22 +205,22 @@ 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"])
 ];
 function getToolContract(name) {
   const contract = TOOL_CONTRACTS.find((entry) => entry.name === name);
@@ -231,44 +231,44 @@ function getToolContract(name) {
 // ../readseek-api/src/policy.ts
 var REPLACEABLE_TOOLS = [
   {
-    tool: "show_content",
+    tool: "show",
     builtIn: "read",
     benefit: "it returns LINE:HASH anchors for safe edits."
   },
   {
-    tool: "edit_text",
+    tool: "edit",
     builtIn: "edit",
     benefit: "it verifies fresh LINE:HASH anchors."
   },
   {
-    tool: "find_text",
+    tool: "grep",
     builtIn: "grep",
-    benefit: "it returns LINE:HASH anchors."
+    benefit: "it runs native regex/literal matching and returns source LINE:HASH anchors or document locations."
   },
   {
-    tool: "write_file",
+    tool: "write",
     builtIn: "write",
     benefit: "it returns LINE:HASH anchors."
   }
 ];
 var TOOL_COMPACT_GUIDELINES = {
-  show_content: [
-    "Use `show_structure` for shallow overviews and `check_syntax` for diagnostics; use `find_definitions`, `find_references`, or `find_nodes` for targeted symbol questions."
+  show: [
+    "Use `tree` for shallow overviews and `syntax` for diagnostics; use `def`, `refs`, or `search` for targeted symbol questions."
   ],
-  edit_text: [
+  edit: [
     "Prefer set_line, replace_lines, and insert_after; use replace only when anchors are impractical."
   ],
-  find_text: [
-    "Use `find_text` with summary first for broad searches, then narrow by path, glob, or pattern."
+  grep: [
+    "Use `grep` with summary first for broad searches, then narrow by path, glob, or pattern."
   ],
-  write_file: [
-    "Use anchored edits rather than `write_file` for small changes or appends."
+  write: [
+    "Use anchored edits rather than `write` for small changes or appends."
   ],
-  find_nodes: [
-    "Use `find_nodes` for AST patterns; use `find_text` for plain text."
+  search: [
+    "Use `search` for AST patterns; use `grep` for plain text."
   ],
-  find_references: [
-    "Use `find_references` before changing a symbol; use at with line:N:C to follow one binding."
+  refs: [
+    "Use `refs` before changing a symbol; use at with line:N:C to follow one binding."
   ]
 };
 function resolveToolName(name, aliases = {}) {
@@ -279,21 +279,21 @@ function renderCompactGuidelines(name, 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.`);
   }
@@ -325,6 +325,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"],
@@ -423,7 +476,6 @@ function coerceObviousBase10Int(value, name) {
   return invalidInteger(value, name);
 }
 // ../readseek-api/src/argv.ts
-var DEFAULT_STRUCTURE_DEPTH = 1;
 function appendGitScopeArgs(args, input) {
   if (input.gitScope !== undefined)
     args.push("--git-scope", input.gitScope);
@@ -459,50 +511,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;
 }
@@ -528,12 +641,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);
@@ -541,10 +654,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);
@@ -553,35 +666,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");
@@ -589,13 +702,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);
@@ -603,7 +716,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");
@@ -611,7 +724,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);
@@ -622,28 +735,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);
@@ -651,14 +782,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);
@@ -666,10 +797,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)
@@ -1059,25 +1190,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,
@@ -1122,8 +1269,35 @@ function parseStructureEnvelope(value) {
     throw new Error("invalid readseek structure: missing structure");
   return { ...output.metadata !== undefined ? { metadata: parseDetectOutput(output.metadata) } : {}, structure: parseStructureOutput(output.structure) };
 }
-function parseTextSearchOutput(value) {
-  return parse(TextSearchOutput, value, "text search output");
+function 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");
@@ -1200,71 +1374,71 @@ function runOptions(options, vision = false) {
 }
 function createReadSeekClient(runner) {
   return {
-    async showContent(path, options = {}) {
-      const value = await runner.kdl(buildShowContentArgs({ ...options, path }), runOptions(options));
+    async show(path, options = {}) {
+      const value = await runner.kdl(buildShowArgs({ ...options, path }), runOptions(options));
       return parseContentOutput(value);
     },
-    async showStructure(path, options = {}) {
-      const value = await runner.kdl(buildShowStructureArgs({ ...options, path }), runOptions(options));
+    async tree(path, options = {}) {
+      const value = await runner.kdl(buildTreeArgs({ ...options, path }), runOptions(options));
       return parseStructureEnvelope(value);
     },
-    async showMetadata(path, options = {}) {
-      const value = await runner.kdl(buildShowMetadataArgs({ ...options, path }), runOptions(options));
+    async meta(path, options = {}) {
+      const value = await runner.kdl(buildMetaArgs({ ...options, path }), runOptions(options));
       return parsePdfMetadata(value) ?? parseDetectOutput(value?.metadata);
     },
-    async showAssets(path, options = {}) {
-      const value = await runner.kdl(buildShowAssetsArgs({ ...options, path }), runOptions(options));
+    async assets(path, options = {}) {
+      const value = await runner.kdl(buildAssetsArgs({ ...options, path }), runOptions(options));
       return parseAssetsOutput(value);
     },
-    async checkSyntax(path, options = {}) {
-      const value = await runner.kdl(buildCheckSyntaxArgs({ ...options, path }), runOptions(options));
+    async syntax(path, options = {}) {
+      const value = await runner.kdl(buildSyntaxArgs({ ...options, path }), runOptions(options));
       return parseCheckOutput(value?.diagnostics ?? value);
     },
-    async checkRules(path, options) {
-      const value = await runner.kdl(buildCheckRulesArgs({ ...options, path }), runOptions(options));
+    async check(path, options) {
+      const value = await runner.kdl(buildCheckArgs({ ...options, path }), runOptions(options));
       return parseRulesOutput(value);
     },
-    async generateCaption(path, options = {}) {
-      const value = await runner.kdl(buildGenerateCaptionArgs({ ...options, path }), runOptions(options, true));
+    async caption(path, options = {}) {
+      const value = await runner.kdl(buildCaptionArgs({ ...options, path }), runOptions(options, true));
       return parseContentOutput(value);
     },
-    async detectObjects(path, options = {}) {
-      const value = await runner.kdl(buildDetectObjectsArgs({ ...options, path }), runOptions(options, true));
+    async objects(path, options = {}) {
+      const value = await runner.kdl(buildObjectsArgs({ ...options, path }), runOptions(options, true));
       return parseContentOutput(value);
     },
-    async recognizeText(path, options = {}) {
-      const value = await runner.kdl(buildRecognizeTextArgs({ ...options, path }), runOptions(options, true));
+    async ocr(path, options = {}) {
+      const value = await runner.kdl(buildOcrArgs({ ...options, path }), runOptions(options, true));
       return parseContentOutput(value);
     },
-    async findNodes(path, options) {
-      const value = await runner.kdl(buildFindNodesArgs({ ...options, path }), runOptions(options));
+    async search(path, options) {
+      const value = await runner.kdl(buildSearchArgs({ ...options, path }), runOptions(options));
       return parseSearchOutput(value);
     },
-    async findText(path, options) {
-      const value = await runner.kdl(buildFindTextArgs({ ...options, path }), runOptions(options));
-      return parseTextSearchOutput(value);
+    async grep(params) {
+      const value = await runner.kdl(buildGrepArgs(params), runOptions(params));
+      return parseGrepOutput(value);
     },
-    async findDefinitions(path, options) {
-      const value = await runner.kdl(buildFindDefinitionsArgs({ ...options, path }), runOptions(options));
+    async def(path, options) {
+      const value = await runner.kdl(buildDefArgs({ ...options, path }), runOptions(options));
       return parseDefOutput(value);
     },
-    async findReferences(path, options) {
-      const value = await runner.kdl(buildFindReferencesArgs({ ...options, path }), runOptions(options));
+    async refs(path, options) {
+      const value = await runner.kdl(buildRefsArgs({ ...options, path }), runOptions(options));
       return parseRefsOutput(value);
     },
-    async editText(path, edits, options = {}) {
+    async edit(path, edits, options = {}) {
       const stdin = serializeEditPlan(edits);
-      return parseEditOutput(await runner.kdl(buildEditTextArgs({ ...options, path, requestFromStdin: true }), runOptions({ ...options, stdin })));
+      return parseEditOutput(await runner.kdl(buildEditArgs({ ...options, path, requestFromStdin: true }), runOptions({ ...options, stdin })));
     },
-    async renameSymbol(path, options) {
-      const value = await runner.kdl(buildRenameSymbolArgs({ ...options, path }), runOptions(options));
+    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 : {};
@@ -1379,7 +1553,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));
@@ -1388,7 +1562,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"));
@@ -1402,7 +1576,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
@@ -1411,7 +1585,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"));
@@ -1465,7 +1639,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)));
@@ -1725,6 +1899,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");
@@ -1840,7 +2054,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":
@@ -1905,7 +2119,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;
 }
@@ -2491,7 +2705,7 @@ function formatReplaceHint(edits, noopEdits) {
     return;
   if (counts.replace !== counts.total)
     return;
-  return "[info: this edit used replace (unverified). For safer future edits, prefer set_line/replace_lines with an anchor from readSeek_show_content/readSeek_find_text/readSeek_find_nodes.]";
+  return "[info: this edit used replace (unverified). For safer future edits, prefer set_line/replace_lines with an anchor from readSeek_show/readSeek_grep/readSeek_search.]";
 }
 function buildEditOutput(input) {
   const summary = `Updated ${input.displayPath}`;
@@ -2591,10 +2805,10 @@ import { readFileSync, statSync as statSync2 } from "node:fs";
 import { homedir as homedir2 } from "node:os";
 import { join } from "node:path";
 var READSEEK_TOOL_REPLACEMENTS = {
-  read: "readSeek_show_content",
-  edit: "readSeek_edit_text",
-  grep: "readSeek_find_text",
-  write: "readSeek_write_file"
+  read: "readSeek_show",
+  edit: "readSeek_edit",
+  grep: "readSeek_grep",
+  write: "readSeek_write"
 };
 var READSEEK_KEYS = ["overrideTools", "imageMode", "syntaxValidation", "timeoutMs", "grep", "display"];
 var READSEEK_GREP_KEYS = ["maxLines", "maxBytes"];
@@ -2830,7 +3044,7 @@ async function ensureDefaultReadSeekDir() {
     return null;
   if (directoryExists(dir))
     return dir;
-  defaultReadSeekDirInit ??= runReadSeekNodeText(readSeekBinaryPath(), ["--readseek-dir", dir, "initialize", "index"], { timeoutMs: readSeekTimeoutMs() }).then(() => directoryExists(dir) ? dir : null).catch(() => null).finally(() => {
+  defaultReadSeekDirInit ??= runReadSeekNodeText(readSeekBinaryPath(), ["--readseek-dir", dir, "init"], { timeoutMs: readSeekTimeoutMs() }).then(() => directoryExists(dir) ? dir : null).catch(() => null).finally(() => {
     defaultReadSeekDirInit = undefined;
   });
   return defaultReadSeekDirInit;
@@ -2848,18 +3062,7 @@ function hasProjectReadSeekDir(cwd = process.cwd()) {
 }
 function supportsReadSeekDir(args) {
   const first = args[0];
-  const second = args[1];
-  if (first === "initialize" && second === "index")
-    return true;
-  if (first === "show" && (second === "content" || second === "assets"))
-    return true;
-  if (first === "generate" && second === "caption")
-    return true;
-  if (first === "detect" && second === "objects")
-    return true;
-  if (first === "recognize" && second === "text")
-    return true;
-  return false;
+  return first === "init" || first === "show" || first === "assets" || first === "caption" || first === "objects" || first === "ocr";
 }
 async function readSeekInvocationArgs(args) {
   if (!supportsReadSeekDir(args) || hasProjectReadSeekDir())
@@ -2917,27 +3120,21 @@ var runner = {
   kdl: async (args, options = {}) => parseReadSeekKdl(await runner.text(args, options))
 };
 var client2 = createReadSeekClient(runner);
-var readSeekShowContent = client2.showContent;
-var readSeekShowStructure = client2.showStructure;
-var readSeekShowMetadata = client2.showMetadata;
-var readSeekShowAssets = client2.showAssets;
-var readSeekGenerateCaption = client2.generateCaption;
-var readSeekDetectObjects = client2.detectObjects;
-var readSeekRecognizeText = client2.recognizeText;
-var readSeekFindNodes = client2.findNodes;
-var readSeekFindReferences = client2.findReferences;
-var readSeekFindDefinitions = client2.findDefinitions;
-var readSeekCheckSyntax = client2.checkSyntax;
-var readSeekCheckRules = client2.checkRules;
-var readSeekEditText = client2.editText;
-var readSeekRenameSymbol = client2.renameSymbol;
-async function readSeekMap(filePath, options = {}) {
-  const envelope = await client2.showStructure(filePath, { depth: DEFAULT_STRUCTURE_DEPTH, signal: options.signal });
-  const map = "structure" in envelope ? envelope.structure : undefined;
-  if (!map || map.language === "unknown" && map.symbols.length === 0)
-    return null;
-  return map;
-}
+var readSeekShow = client2.show;
+var readSeekTree = client2.tree;
+var readSeekMeta = client2.meta;
+var readSeekAssets = client2.assets;
+var readSeekCaption = client2.caption;
+var readSeekObjects = client2.objects;
+var readSeekOcr = client2.ocr;
+var readSeekSearch = client2.search;
+var readSeekGrep = client2.grep;
+var readSeekRefs = client2.refs;
+var readSeekDef = client2.def;
+var readSeekSyntax = client2.syntax;
+var readSeekCheck = client2.check;
+var readSeekEdit = client2.edit;
+var readSeekRename = client2.rename;
 
 // src/edit-syntax-validate.ts
 function dedupeSortLines(diagnostics) {
@@ -2958,8 +3155,8 @@ async function validateSyntaxRegression(input, options = {}) {
   let before;
   let after;
   try {
-    before = input.before === undefined ? EMPTY : await readSeekCheckSyntax("-", { stdinName: input.filePath, stdin: input.before, signal: options.signal });
-    after = await readSeekCheckSyntax("-", { stdinName: input.filePath, stdin: input.after, signal: options.signal });
+    before = input.before === undefined ? EMPTY : await readSeekSyntax("-", { stdinName: input.filePath, stdin: input.before, signal: options.signal });
+    after = await readSeekSyntax("-", { stdinName: input.filePath, stdin: input.after, signal: options.signal });
   } catch {
     return null;
   }
@@ -3645,7 +3842,7 @@ async function executeEdit(opts) {
     return await withFileMutationQueue(absolutePath, async () => {
       throwIfAborted(signal);
       if (wasReadInSession && !wasReadInSession(absolutePath)) {
-        const hint = `Call readSeek_show_content(${JSON.stringify(rawPath)}) first, or use readSeek_find_text, readSeek_find_nodes, or readSeek_write_file to produce fresh anchors for this file.`;
+        const hint = `Call readSeek_show(${JSON.stringify(rawPath)}) first, or use readSeek_grep, readSeek_search, or readSeek_write to produce fresh anchors for this file.`;
         return buildEditError(absolutePath, "file-not-read", `You must get fresh anchors for ${absolutePath} before editing it. ${hint}`, hint);
       }
       const parsedEdits = validateExactlyOneEditVariant(parsed.edits ?? []);
@@ -3655,7 +3852,7 @@ async function executeEdit(opts) {
       const edits = parsedEdits.edits;
       let plan;
       try {
-        plan = await readSeekEditText(absolutePath, edits, { signal, language: parsed.language });
+        plan = await readSeekEdit(absolutePath, edits, { signal, language: parsed.language });
       } catch (err) {
         throwIfAborted(signal);
         const failure = classifyReadSeekFailure(err);
@@ -3691,7 +3888,7 @@ async function executeEdit(opts) {
       throwIfAborted(signal);
       let applied;
       try {
-        applied = await readSeekEditText(absolutePath, edits, {
+        applied = await readSeekEdit(absolutePath, edits, {
           apply: true,
           planHash: plan.plan_hash,
           language: parsed.language,
@@ -3759,9 +3956,9 @@ async function executeEdit(opts) {
   }
 }
 function registerEditTool(pi, options = {}) {
-  const name = options.name ?? "readSeek_edit_text";
+  const name = options.name ?? "readSeek_edit";
   const promptMetadata = defineToolPromptMetadata({
-    toolName: "edit_text",
+    toolName: "edit",
     promptSnippet: "Edit existing files with fresh LINE:HASH anchors",
     registeredName: name,
     toolAliases: options.toolAliases
@@ -3857,29 +4054,12 @@ ${theme.fg("error", info.errorText)}`;
 }
 
 // src/grep.ts
-import { readFile as fsReadFile2, stat as fsStat } from "node:fs/promises";
-import path5 from "node:path";
-import { createGrepTool } from "@earendil-works/pi-coding-agent";
 import { Type as Type5 } from "@sinclair/typebox";
 import { Text as Text4 } from "@earendil-works/pi-tui";
 
-// src/binary-detect.ts
-function looksLikeBinary(buf) {
-  if (buf.length === 0)
-    return false;
-  if (buf.includes(0))
-    return true;
-  const decoded = buf.toString("utf8");
-  if (!decoded.includes("�"))
-    return false;
-  return !Buffer.from(decoded, "utf8").equals(buf);
-}
-
 // src/grep-output.ts
-import {
-  formatSize,
-  truncateHead
-} from "@earendil-works/pi-coding-agent";
+import path5 from "node:path";
+import { formatSize, truncateHead } from "@earendil-works/pi-coding-agent";
 
 // src/grep-budget.ts
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES } from "@earendil-works/pi-coding-agent";
@@ -3899,283 +4079,75 @@ function resolveGrepOutputBudget() {
 }
 
 // src/grep-output.ts
-function hasScope(group) {
-  return group.scope !== undefined;
-}
-function renderEntry(displayPath, entry) {
-  if (entry.kind === "separator")
-    return entry.text;
-  const marker = entry.kind === "match" ? ">>" : "  ";
-  return `${displayPath}:${marker}${entry.line.anchor}|${entry.line.display}`;
-}
-function renderGroupHeader(group) {
-  if (!group.scope) {
-    return `--- ${group.displayPath} (${group.matchCount} matches) ---`;
-  }
-  const parent = group.scope.symbol.parentName ? ` in ${group.scope.symbol.parentName}` : "";
-  const suffix = group.scope.contextLines !== undefined ? `, scoped to ±${group.scope.contextLines} lines` : "";
-  return `--- ${group.displayPath} :: ${group.scope.symbol.kind} ${group.scope.symbol.name}${parent} (${group.scope.symbol.startLine}-${group.scope.symbol.endLine}, ${group.matchCount} matches${suffix}) ---`;
-}
-function buildScopeMetadata(groups, warnings) {
-  return {
-    mode: "symbol",
-    groups: groups.filter(hasScope).map((group) => ({
-      path: group.absolutePath,
-      displayPath: group.displayPath,
-      symbol: group.scope.symbol,
-      matchCount: group.matchCount,
-      matchLines: [...group.scope.matchLines],
-      lineAnchors: group.entries.flatMap((entry) => entry.kind === "separator" ? [] : [entry.line.anchor])
-    })),
-    warnings: [...warnings]
-  };
-}
-function buildGrepOutput(input) {
-  const fileCount = new Set(input.groups.map((group) => group.absolutePath)).size;
-  const header = `[${input.totalMatches} matches in ${fileCount} files]`;
-  let text;
-  if (input.summary) {
-    const fileLines = [...input.groups].sort((a, b) => b.matchCount - a.matchCount).map((group) => `${group.absolutePath}: ${group.matchCount} matches`);
-    text = [header, ...fileLines].join(`
-`);
-  } else {
-    const blocks = [header];
-    for (const group of input.groups) {
-      blocks.push(renderGroupHeader(group));
-      for (const entry of group.entries) {
-        blocks.push(renderEntry(group.displayPath, entry));
+function buildGrepOutput(output, cwd) {
+  const recordBlocks = new Map;
+  const fileCount = new Set([...output.results, ...output.documents].map((group) => path5.resolve(cwd, group.file))).size;
+  const blocks = [`[${output.total_matches} matches in ${fileCount} files]`];
+  for (const group of output.results) {
+    const absolutePath = path5.resolve(cwd, group.file);
+    const displayPath = path5.relative(cwd, absolutePath) || absolutePath;
+    if (output.summary) {
+      blocks.push(`${absolutePath}: ${group.total_matches} matches`);
+      continue;
+    }
+    blocks.push(`--- ${displayPath} (${group.total_matches} matches) ---`);
+    const renderLines = (lines) => {
+      for (const line of lines) {
+        const built = buildReadSeekLineWithHash(line.line, line.hash, line.text);
+        const marker = line.kind === "match" ? ">>" : "  ";
+        blocks.push(`${displayPath}:${marker}${built.anchor}|${built.display}`);
+        recordBlocks.set(blocks.length - 1, { path: absolutePath, line: line.line, anchor: built.anchor, kind: line.kind });
       }
+    };
+    renderLines(group.lines);
+    for (const symbol of group.symbols) {
+      blocks.push(`--- ${displayPath} :: ${symbol.kind} ${symbol.name} (${symbol.start_line}-${symbol.end_line}) ---`);
+      renderLines(symbol.lines);
     }
-    text = blocks.join(`
-`);
   }
-  const passthroughLines = input.passthroughLines ?? [];
-  if (passthroughLines.length > 0) {
-    text += `
-
-${passthroughLines.join(`
-`)}`;
-  }
-  if (input.limit !== undefined && input.totalMatches === input.limit) {
-    text += `
-
-[Results truncated at ${input.limit} matches — refine pattern or increase limit]`;
+  for (const group of output.documents) {
+    const absolutePath = path5.resolve(cwd, group.file);
+    const displayPath = path5.relative(cwd, absolutePath) || absolutePath;
+    if (output.summary) {
+      blocks.push(`${absolutePath}: ${group.total_matches} matches`);
+      continue;
+    }
+    blocks.push(`--- ${displayPath} (${group.total_matches} matches, document) ---`);
+    for (const hit of group.hits) {
+      const page = hit.page === undefined ? "" : ` page:${hit.page}`;
+      blocks.push(`${displayPath} node:${hit.node_id}${page} (${hit.kind}): ${escapeControlCharsForDisplay(hit.snippet)}`);
+    }
   }
-  const scopeWarnings = input.scopeWarnings ?? [];
-  if (!input.summary && input.scopeMode === "symbol" && scopeWarnings.length > 0) {
-    text = `${scopeWarnings.map((warning) => warning.message).join(`
-
-`)}
-
-${text}`;
+  if (output.truncated) {
+    blocks.push(`
+[Results truncated: ${output.returned_matches} of ${output.total_matches} matching lines returned — refine pattern or increase limit]`);
   }
+  let text = blocks.join(`
+`);
   const budget = resolveGrepOutputBudget();
-  const truncated = truncateHead(text, {
-    maxLines: budget.maxLines,
-    maxBytes: budget.maxBytes
+  const truncated = truncateHead(text, { maxLines: budget.maxLines, maxBytes: budget.maxBytes });
+  let endOffset = 0;
+  const records = blocks.flatMap((block, index) => {
+    endOffset += block.length + (index > 0 ? 1 : 0);
+    const record = recordBlocks.get(index);
+    return record && endOffset <= truncated.content.length ? [record] : [];
   });
   if (truncated.truncated) {
     text = `${truncated.content}
 
 [Output truncated: showing ${truncated.outputLines} of ${truncated.totalLines} lines (${formatSize(truncated.outputBytes)} of ${formatSize(truncated.totalBytes)}). Refine pattern or increase limit.]`;
   }
-  const readSeekValue = {
-    tool: "grep",
-    summary: input.summary,
-    totalMatches: input.totalMatches,
-    records: input.records.map((record) => ({
-      path: record.path,
-      line: record.line,
-      anchor: record.anchor,
-      kind: record.kind
-    }))
-  };
-  if (!input.summary && input.scopeMode === "symbol") {
-    readSeekValue.scopes = buildScopeMetadata(input.groups, scopeWarnings);
-  }
   return {
     text,
-    readSeekValue
-  };
-}
-
-// src/file-map.ts
-async function getOrGenerateMap(absPath) {
-  try {
-    return await readSeekMap(absPath);
-  } catch {
-    return null;
-  }
-}
-
-// src/grep-symbol-scope.ts
-function findEnclosingSymbol(map, lineNumber) {
-  const byQualifiedName = new Map;
-  for (const symbol of map.symbols) {
-    const qname = symbol.qualified_name ?? symbol.name;
-    if (!byQualifiedName.has(qname))
-      byQualifiedName.set(qname, symbol);
-  }
-  const candidates = map.symbols.filter((symbol) => lineNumber >= symbol.start_line && lineNumber <= symbol.end_line).map((symbol) => {
-    const qname = symbol.qualified_name ?? symbol.name;
-    const dot = qname.lastIndexOf(".");
-    const parent = dot === -1 ? undefined : byQualifiedName.get(qname.slice(0, dot));
-    return {
-      name: symbol.name,
-      kind: symbol.kind === "constructor" ? "method" : symbol.kind,
-      startLine: symbol.start_line,
-      endLine: symbol.end_line,
-      parentName: parent?.name
-    };
-  }).sort((a, b) => {
-    const rangeA = a.endLine - a.startLine;
-    const rangeB = b.endLine - b.startLine;
-    if (rangeA !== rangeB)
-      return rangeA - rangeB;
-    if (a.startLine !== b.startLine)
-      return a.startLine - b.startLine;
-    return a.name.localeCompare(b.name);
-  });
-  return candidates[0] ?? null;
-}
-function firstLineNumber(group) {
-  const first = group.entries.find((e) => e.kind !== "separator");
-  return first ? first.line.line : Number.MAX_SAFE_INTEGER;
-}
-function buildSymbolEntries(fileLines, symbol, matchLines, scopeContext) {
-  if (scopeContext === undefined) {
-    const entries = [];
-    for (let lineNumber = symbol.startLine;lineNumber <= symbol.endLine; lineNumber++) {
-      const built = buildReadSeekLine(lineNumber, fileLines[lineNumber - 1] ?? "");
-      entries.push({ kind: matchLines.has(lineNumber) ? "match" : "context", line: built });
-    }
-    return entries;
-  }
-  const ranges = [...matchLines].sort((a, b) => a - b).map((ln) => ({
-    startLine: Math.max(symbol.startLine, ln - scopeContext),
-    endLine: Math.min(symbol.endLine, ln + scopeContext)
-  }));
-  const merged = [];
-  for (const r of ranges) {
-    const last = merged[merged.length - 1];
-    if (last && r.startLine <= last.endLine + 1) {
-      last.endLine = Math.max(last.endLine, r.endLine);
-    } else {
-      merged.push({ ...r });
-    }
-  }
-  const entries = [];
-  for (let i = 0;i < merged.length; i++) {
-    if (i > 0)
-      entries.push({ kind: "separator", text: "--" });
-    const range = merged[i];
-    for (let ln = range.startLine;ln <= range.endLine; ln++) {
-      const built = buildReadSeekLine(ln, fileLines[ln - 1] ?? "");
-      entries.push({ kind: matchLines.has(ln) ? "match" : "context", line: built });
-    }
-  }
-  return entries;
-}
-function buildFallbackEntries(fileLines, matchLines, contextLines) {
-  const lineMap = new Map;
-  for (const matchLine of matchLines) {
-    const start = Math.max(1, matchLine - contextLines);
-    const end = Math.min(fileLines.length, matchLine + contextLines);
-    for (let lineNumber = start;lineNumber <= end; lineNumber++) {
-      const built = buildReadSeekLine(lineNumber, fileLines[lineNumber - 1] ?? "");
-      const candidate = { kind: lineNumber === matchLine ? "match" : "context", line: built };
-      const existing = lineMap.get(lineNumber);
-      if (!existing || existing.kind === "context" && candidate.kind === "match") {
-        lineMap.set(lineNumber, candidate);
-      }
-    }
-  }
-  const ordered = [...lineMap.entries()].sort(([a], [b]) => a - b);
-  const entries = [];
-  for (let i = 0;i < ordered.length; i++) {
-    if (i > 0 && ordered[i][0] > ordered[i - 1][0] + 1)
-      entries.push({ kind: "separator", text: "--" });
-    entries.push(ordered[i][1]);
-  }
-  return entries;
-}
-function scopeGrepGroupsToSymbols(input) {
-  const warnings = [];
-  const rendered = [];
-  for (const group of input.groups) {
-    const fileLines = input.fileLinesByPath.get(group.absolutePath);
-    const fileMap = input.fileMapsByPath.get(group.absolutePath) ?? null;
-    if (!fileLines || !fileMap) {
-      warnings.push({
-        code: "unmappable-file",
-        message: `[Warning: symbol scoping unavailable for ${group.absolutePath} — showing normal grep lines for this file]`,
-        path: group.absolutePath
-      });
-      rendered.push({ order: firstLineNumber(group), group });
-      continue;
-    }
-    const symbolBuckets = new Map;
-    const fallbackMatchLines = [];
-    for (const entry of group.entries) {
-      if (entry.kind !== "match")
-        continue;
-      const symbol = findEnclosingSymbol(fileMap, entry.line.line);
-      if (!symbol) {
-        fallbackMatchLines.push(entry.line.line);
-        warnings.push({
-          code: "no-enclosing-symbol",
-          message: `[Warning: no enclosing symbol for ${group.absolutePath}:${entry.line.line} — showing normal grep lines for this match]`,
-          path: group.absolutePath,
-          line: entry.line.line
-        });
-        continue;
-      }
-      const key = `${symbol.startLine}:${symbol.endLine}:${symbol.parentName ?? ""}:${symbol.name}`;
-      const bucket = symbolBuckets.get(key) ?? { symbol, matchLines: new Set };
-      bucket.matchLines.add(entry.line.line);
-      symbolBuckets.set(key, bucket);
-    }
-    const scopedGroups = [...symbolBuckets.values()].sort((a, b) => {
-      if (a.symbol.startLine !== b.symbol.startLine)
-        return a.symbol.startLine - b.symbol.startLine;
-      return a.symbol.name.localeCompare(b.symbol.name);
-    }).map(({ symbol, matchLines }) => ({
-      displayPath: group.displayPath,
-      absolutePath: group.absolutePath,
-      matchCount: matchLines.size,
-      scope: {
-        mode: "symbol",
-        symbol,
-        matchLines: [...matchLines].sort((a, b) => a - b),
-        ...input.scopeContext !== undefined ? { contextLines: input.scopeContext } : {}
-      },
-      entries: buildSymbolEntries(fileLines, symbol, matchLines, input.scopeContext)
-    }));
-    for (const scopedGroup of scopedGroups)
-      rendered.push({ order: scopedGroup.scope.symbol.startLine, group: scopedGroup });
-    if (fallbackMatchLines.length > 0) {
-      rendered.push({
-        order: Math.min(...fallbackMatchLines),
-        group: {
-          displayPath: group.displayPath,
-          absolutePath: group.absolutePath,
-          matchCount: fallbackMatchLines.length,
-          entries: buildFallbackEntries(fileLines, fallbackMatchLines, input.contextLines)
-        }
-      });
-    }
-    if (scopedGroups.length === 0 && fallbackMatchLines.length === 0) {
-      rendered.push({ order: firstLineNumber(group), group });
+    readSeekValue: {
+      ...output,
+      tool: "grep",
+      totalMatches: output.total_matches,
+      returnedMatches: output.returned_matches,
+      fileCount,
+      records
     }
-  }
-  rendered.sort((a, b) => {
-    if (a.order !== b.order)
-      return a.order - b.order;
-    if (a.group.absolutePath !== b.group.absolutePath)
-      return a.group.absolutePath.localeCompare(b.group.absolutePath);
-    return a.group.displayPath.localeCompare(b.group.displayPath);
-  });
-  return { groups: rendered.map((item) => item.group), warnings };
+  };
 }
 
 // src/grep-render-helpers.ts
@@ -4193,7 +4165,6 @@ function formatGrepCallText(args) {
     suffix: parts.length > 0 ? parts.join(" ") : undefined
   };
 }
-var GREP_TRUNCATION_THRESHOLD = 50;
 function formatGrepResultText(input) {
   if (input.isError && input.errorText) {
     return {
@@ -4206,17 +4177,15 @@ function formatGrepResultText(input) {
   }
   const { totalMatches, summary, fileCount } = input;
   const noMatches = totalMatches === 0;
-  const truncated = totalMatches > GREP_TRUNCATION_THRESHOLD;
+  const truncated = input.truncated ?? false;
   const matchWord = totalMatches === 1 ? "match" : "matches";
   const fileWord = fileCount === 1 ? "file" : "files";
   const summaryText = noMatches ? "" : `✓ ${totalMatches} ${matchWord} in ${fileCount} ${fileWord}`;
   const badges = [];
   if (truncated)
-    badges.push("10/file cap");
+    badges.push("truncated");
   if (summary)
     badges.push("summary");
-  if (input.hasBinaryWarning)
-    badges.push("⚠ binary");
   return {
     summary: summaryText,
     badges,
@@ -4269,78 +4238,12 @@ var grepSchema = Type5.Object({
   scope: Type5.Optional(Type5.Literal("symbol", {
     description: PARAM_DESCRIPTIONS.grepScope
   })),
-  scopeContext: optionalIntOrString(PARAM_DESCRIPTIONS.scopeContext)
+  scopeContext: optionalIntOrString(PARAM_DESCRIPTIONS.scopeContext),
+  ...readSeekGitSearchParams()
 });
-var MATCH_LINE_RE = /^(.*?):(\d+): (.*)$/;
-var CONTEXT_LINE_RE = /^(.*?)-(\d+)- (.*)$/;
-function parseGrepOutputLine(line) {
-  const match = line.match(MATCH_LINE_RE);
-  if (match) {
-    return {
-      kind: "match",
-      displayPath: match[1],
-      lineNumber: Number.parseInt(match[2], 10),
-      text: match[3]
-    };
-  }
-  const context = line.match(CONTEXT_LINE_RE);
-  if (context) {
-    return {
-      kind: "context",
-      displayPath: context[1],
-      lineNumber: Number.parseInt(context[2], 10),
-      text: context[3]
-    };
-  }
-  return null;
-}
-var GREP_MAX_MATCHES_PER_FILE = 10;
-function dedupeContextEntries(entries) {
-  if (entries.length === 0)
-    return entries;
-  const byLine = new Map;
-  for (const entry of entries) {
-    if (entry.kind === "separator")
-      continue;
-    const existing = byLine.get(entry.line.line);
-    if (!existing || entry.kind === "match" && existing.kind === "context") {
-      byLine.set(entry.line.line, entry);
-    }
-  }
-  const sorted = [...byLine.entries()].sort(([a], [b]) => a - b);
-  const result = [];
-  for (let i = 0;i < sorted.length; i++) {
-    if (i > 0 && sorted[i][0] > sorted[i - 1][0] + 1) {
-      result.push({ kind: "separator", text: "--" });
-    }
-    result.push(sorted[i][1]);
-  }
-  return result;
-}
-function truncateGroupEntries(group) {
-  let matchesSeen = 0;
-  let truncatedCount = 0;
-  const kept = [];
-  for (const entry of group.entries) {
-    if (entry.kind === "match") {
-      matchesSeen++;
-      if (matchesSeen <= GREP_MAX_MATCHES_PER_FILE) {
-        kept.push(entry);
-      } else {
-        truncatedCount++;
-      }
-    } else if (matchesSeen <= GREP_MAX_MATCHES_PER_FILE) {
-      kept.push(entry);
-    }
-  }
-  if (truncatedCount > 0) {
-    kept.push({ kind: "separator", text: `... +${truncatedCount} more matches` });
-  }
-  return { ...group, entries: kept };
-}
 async function executeGrep(opts) {
-  const { toolCallId, params, signal, onUpdate, cwd, onFileAnchored } = opts;
-  await ensureHashInit();
+  const { params, signal, cwd, onFileAnchored } = opts;
+  signal?.throwIfAborted();
   const rawParams = params;
   const context = coerceObviousBase10Int(rawParams.context, "context");
   if (!context.ok) {
@@ -4368,267 +4271,34 @@ async function executeGrep(opts) {
     const message = `Invalid scopeContext: expected a non-negative integer, received ${scopeContext.value}.`;
     return buildToolErrorResult("grep", "invalid-params-combo", message);
   }
-  const p = {
-    ...rawParams,
+  const output = await readSeekGrep({
+    pattern: rawParams.pattern,
+    path: resolveToCwd(rawParams.path ?? ".", cwd),
+    glob: rawParams.glob,
+    ignoreCase: rawParams.ignoreCase,
+    literal: rawParams.literal,
     context: context.value,
     limit: limit.value,
-    scopeContext: scopeContext.value
-  };
-  const builtin = createGrepTool(cwd);
-  const result = await builtin.execute(toolCallId, {
-    ...p,
-    context: context.value,
-    limit: limit.value
-  }, signal, onUpdate);
-  const textBlock = result.content?.find((item) => item.type === "text" && ("text" in item) && typeof item.text === "string");
-  if (!textBlock?.text)
-    return result;
-  const { path: rawSearchPath } = p;
-  const searchPath = resolveToCwd(rawSearchPath || ".", cwd);
-  let searchPathIsDirectory = false;
-  try {
-    searchPathIsDirectory = (await fsStat(searchPath)).isDirectory();
-  } catch {
-    searchPathIsDirectory = false;
-  }
-  if (!searchPathIsDirectory) {
-    try {
-      const buf = await fsReadFile2(searchPath);
-      if (looksLikeBinary(buf)) {
-        const warning = `[Warning: '${p.path ?? searchPath}' appears to be a binary file — grep skips binary files by default. Use a hex tool or the read tool to inspect it.]`;
-        return {
-          ...result,
-          content: result.content.map((item) => item === textBlock ? { ...item, text: warning } : item),
-          details: {
-            ...typeof result.details === "object" && result.details !== null ? result.details : {},
-            readSeekValue: {
-              tool: "grep",
-              summary: !!p.summary,
-              totalMatches: 0,
-              records: []
-            }
-          }
-        };
-      }
-    } catch {}
-  }
-  const fileCache = new Map;
-  const bareCRFiles = new Set;
-  const getFileLines = async (absolutePath) => {
-    throwIfAborted(signal);
-    if (fileCache.has(absolutePath))
-      return fileCache.get(absolutePath);
-    try {
-      const rawBuffer = await fsReadFile2(absolutePath);
-      if (looksLikeBinary(rawBuffer)) {
-        fileCache.set(absolutePath, undefined);
-        return;
-      }
-      const raw = rawBuffer.toString("utf-8");
-      if (hasBareCarriageReturn(raw))
-        bareCRFiles.add(absolutePath);
-      const lines = normalizeToLF(stripBom(raw).text).split(`
-`);
-      fileCache.set(absolutePath, lines);
-      return lines;
-    } catch {
-      fileCache.set(absolutePath, undefined);
-      return;
-    }
-  };
-  const toAbsolutePath = (displayPath) => {
-    if (searchPathIsDirectory)
-      return path5.resolve(searchPath, displayPath);
-    return searchPath;
-  };
-  const groupsByPath = new Map;
-  const passthroughLines = [];
-  let totalMatches = 0;
-  let parsedCount = 0;
-  let candidateUnparsedCount = 0;
-  const candidateLinePattern = /^.+(?::|-)\d+(?::|-)\s/;
-  if (!p.summary) {
-    const pathsToRead = new Set;
-    for (const line of textBlock.text.split(`
-`)) {
-      throwIfAborted(signal);
-      const parsed = parseGrepOutputLine(line);
-      if (parsed && Number.isFinite(parsed.lineNumber) && parsed.lineNumber >= 1) {
-        pathsToRead.add(toAbsolutePath(parsed.displayPath));
-      }
-    }
-    const CONCURRENCY = 8;
-    const pathList = [...pathsToRead];
-    for (let i = 0;i < pathList.length; i += CONCURRENCY) {
-      await Promise.all(pathList.slice(i, i + CONCURRENCY).map((p) => getFileLines(p)));
-    }
-  }
-  const addSummaryMatch = (displayPath, absolutePath) => {
-    let group = groupsByPath.get(displayPath);
-    if (!group) {
-      group = { displayPath, absolutePath, matchCount: 0, entries: [] };
-      groupsByPath.set(displayPath, group);
-    }
-    group.matchCount++;
-    totalMatches++;
-  };
-  const addEntry = (displayPath, absolutePath, kind, line) => {
-    let group = groupsByPath.get(displayPath);
-    if (!group) {
-      group = { displayPath, absolutePath, matchCount: 0, entries: [] };
-      groupsByPath.set(displayPath, group);
-    }
-    group.entries.push({ kind, line });
-    if (kind === "match") {
-      group.matchCount++;
-      totalMatches++;
-    }
-  };
-  for (const line of textBlock.text.split(`
-`)) {
-    throwIfAborted(signal);
-    const parsed = parseGrepOutputLine(line);
-    if (!parsed || !Number.isFinite(parsed.lineNumber) || parsed.lineNumber < 1) {
-      if (candidateLinePattern.test(line)) {
-        candidateUnparsedCount++;
-      }
-      const trimmed = line.trim();
-      if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
-        passthroughLines.push(trimmed);
-      }
-      continue;
-    }
-    parsedCount++;
-    const absolute = toAbsolutePath(parsed.displayPath);
-    if (p.summary) {
-      if (parsed.kind === "match") {
-        addSummaryMatch(parsed.displayPath, absolute);
-      }
-      continue;
-    }
-    const fileLines = await getFileLines(absolute);
-    if (fileLines === undefined)
-      continue;
-    if (parsed.kind === "match" && bareCRFiles.has(absolute)) {
-      const flags = p.ignoreCase ? "i" : "";
-      let patternRe = null;
-      try {
-        patternRe = p.literal ? new RegExp(p.pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), flags) : new RegExp(p.pattern, flags);
-      } catch {}
-      if (patternRe !== null) {
-        let emitted = false;
-        for (let i = 0;i < fileLines.length; i++) {
-          if (!patternRe.test(fileLines[i]))
-            continue;
-          addEntry(parsed.displayPath, absolute, "match", buildReadSeekLine(i + 1, fileLines[i]));
-          emitted = true;
-        }
-        if (emitted)
-          continue;
-      }
-    }
-    const sourceLine = fileLines[parsed.lineNumber - 1] ?? parsed.text;
-    const built = buildReadSeekLine(parsed.lineNumber, sourceLine);
-    addEntry(parsed.displayPath, absolute, parsed.kind, {
-      ...built,
-      display: escapeControlCharsForDisplay(parsed.text)
-    });
-  }
-  if (p.summary && parsedCount === 0 && candidateUnparsedCount > 0) {
-    const passthroughDetails = typeof result.details === "object" && result.details !== null ? result.details : {};
-    return {
-      ...result,
-      details: {
-        ...passthroughDetails,
-        readSeekValue: {
-          tool: "grep",
-          summary: true,
-          totalMatches: 0,
-          records: []
-        }
-      }
-    };
-  }
-  if (parsedCount === 0 && candidateUnparsedCount > 0) {
-    const warning = "[hashline grep passthrough] Unparsed grep format; returned original output.";
-    const passthroughDetails = typeof result.details === "object" && result.details !== null ? result.details : {};
-    return {
-      ...result,
-      content: result.content.map((item) => item === textBlock ? { ...item, text: `${textBlock.text}
-
-${warning}` } : item),
-      details: {
-        ...passthroughDetails,
-        hashlinePassthrough: true,
-        hashlineWarning: warning,
-        readSeekValue: {
-          tool: "grep",
-          summary: !!p.summary,
-          totalMatches: 0,
-          records: []
-        }
-      }
-    };
-  }
-  const summary = !!p.summary;
-  const effectiveLimit = typeof p.limit === "number" ? p.limit : 100;
-  const groups = [...groupsByPath.values()];
-  for (const group of groups) {
-    group.entries = dedupeContextEntries(group.entries);
-  }
-  let renderedGroups = totalMatches > GREP_TRUNCATION_THRESHOLD ? groups.map(truncateGroupEntries) : groups;
-  let scopeWarnings = [];
-  if (p.scope === "symbol" && !summary) {
-    const fileLinesByPath = new Map;
-    const fileMapsByPath = new Map;
-    for (const group of renderedGroups) {
-      const lines = await getFileLines(group.absolutePath);
-      if (lines)
-        fileLinesByPath.set(group.absolutePath, lines);
-      fileMapsByPath.set(group.absolutePath, await getOrGenerateMap(group.absolutePath));
-    }
-    const scoped = scopeGrepGroupsToSymbols({
-      groups: renderedGroups,
-      fileLinesByPath,
-      fileMapsByPath,
-      contextLines: typeof p.context === "number" ? p.context : 0,
-      scopeContext: typeof p.scopeContext === "number" ? p.scopeContext : undefined
-    });
-    renderedGroups = scoped.groups;
-    scopeWarnings = scoped.warnings;
-  }
-  const readSeekRecords = renderedGroups.flatMap((group) => group.entries.flatMap((entry) => entry.kind === "separator" ? [] : [{ path: group.absolutePath, ...entry.line, kind: entry.kind }]));
-  const builtOutput = buildGrepOutput({
-    summary: !!summary,
-    totalMatches,
-    groups: renderedGroups,
-    limit: effectiveLimit,
-    records: readSeekRecords,
-    scopeMode: p.scope === "symbol" && !summary ? "symbol" : undefined,
-    scopeWarnings,
-    passthroughLines
+    summary: rawParams.summary,
+    scope: rawParams.scope,
+    scopeContext: scopeContext.value,
+    gitScope: rawParams.gitScope,
+    signal
   });
-  if (!summary && readSeekRecords.length > 0) {
-    const anchoredPaths = new Set(readSeekRecords.map((record) => record.path));
-    for (const absolutePath of anchoredPaths) {
-      onFileAnchored?.(absolutePath);
-    }
+  signal?.throwIfAborted();
+  const builtOutput = buildGrepOutput(output, cwd);
+  for (const absolutePath of new Set(builtOutput.readSeekValue.records.map((record) => record.path))) {
+    onFileAnchored?.(absolutePath);
   }
-  const existingDetails = typeof result.details === "object" && result.details !== null ? result.details : {};
-  const { linesTruncated: _ignoredLinesTruncated, truncation: _ignoredTruncation, ...compactDetails } = existingDetails;
   return {
-    ...result,
-    content: result.content.map((item) => item === textBlock ? { ...item, text: builtOutput.text } : item),
-    details: {
-      ...compactDetails,
-      readSeekValue: builtOutput.readSeekValue
-    }
+    content: [{ type: "text", text: builtOutput.text }],
+    details: { readSeekValue: builtOutput.readSeekValue }
   };
 }
 function registerGrepTool(pi, options = {}) {
-  const name = options.name ?? "readSeek_find_text";
+  const name = options.name ?? "readSeek_grep";
   const promptMetadata = defineToolPromptMetadata({
-    toolName: "find_text",
+    toolName: "grep",
     promptSnippet: "Search text or regex with edit-ready LINE:HASH anchors",
     registeredName: name
   });
@@ -4677,22 +4347,16 @@ function registerGrepTool(pi, options = {}) {
       if (isError || result.isError)
         return renderErrorResult(textContent, { expanded, width, theme });
       const readSeekValue = result.details?.readSeekValue;
-      const hasBinaryWarning = textContent.includes("appears to be a binary file");
-      const fileSet = new Set;
-      for (const r of readSeekValue?.records ?? []) {
-        if (r.path)
-          fileSet.add(r.path);
-      }
       const info = formatGrepResultText({
         totalMatches: readSeekValue?.totalMatches ?? 0,
         summary: readSeekValue?.summary ?? false,
         records: readSeekValue?.records ?? [],
-        fileCount: fileSet.size,
-        hasBinaryWarning
+        fileCount: readSeekValue?.fileCount ?? 0,
+        truncated: readSeekValue?.truncated
       });
-      if (info.noMatches && !hasBinaryWarning)
+      if (info.noMatches)
         return new Text4(summaryLine("no matches", { theme, style: "dim" }), 0, 0);
-      const matchCount = readSeekValue?.totalMatches ?? 0;
+      const matchCount = readSeekValue?.returnedMatches ?? 0;
       const matchWord = matchCount === 1 ? "match" : "matches";
       let text = summaryLine(`${matchCount} ${matchWord} returned`, {
         hidden: !!textContent && !expanded,
@@ -4719,10 +4383,10 @@ import path6 from "node:path";
 import { Type as Type6 } from "@sinclair/typebox";
 
 // src/stat-search-path.ts
-import { stat as fsStat2 } from "node:fs/promises";
+import { stat as fsStat } from "node:fs/promises";
 async function statSearchPathOrError(tool, rawPath, searchPath) {
   try {
-    return { ok: true, stats: await fsStat2(searchPath) };
+    return { ok: true, stats: await fsStat(searchPath) };
   } catch (err) {
     const path = rawPath ?? searchPath;
     const { code, message } = formatFsError(err, "stat-error");
@@ -4774,7 +4438,7 @@ function mergeRanges(ranges) {
   return merged;
 }
 var SEARCH_PROMPT_METADATA = defineToolPromptMetadata({
-  toolName: "find_nodes",
+  toolName: "search",
   promptSnippet: "Search code by AST structure using ast-grep-style patterns"
 });
 function linesFromSearchResult(result, ranges) {
@@ -4814,7 +4478,7 @@ async function executeSearch(opts) {
   const searchPathIsFile = statResult.stats.isFile();
   try {
     const effectiveLang = readSeekLanguageForPath(p.language, searchPath, searchPathIsFile);
-    const results = await readSeekFindNodes(searchPath, {
+    const results = await readSeekSearch(searchPath, {
       pattern: p.pattern,
       context: p.context,
       selector: p.selector,
@@ -4878,7 +4542,7 @@ async function executeSearch(opts) {
 }
 function registerSearchTool(pi, options = {}) {
   const tool = registerReadSeekTool(pi, {
-    name: "readSeek_find_nodes",
+    name: "readSeek_search",
     label: "Structural Search",
     description: SEARCH_PROMPT_METADATA.description,
     promptSnippet: SEARCH_PROMPT_METADATA.promptSnippet,
@@ -4898,14 +4562,14 @@ function registerSearchTool(pi, options = {}) {
     },
     renderCall(args, theme, ...rest) {
       return renderReadSeekSearchCall(args, theme, rest, {
-        label: "readSeek_find_nodes",
+        label: "readSeek_search",
         accent: `/${args.pattern ?? args.context ?? args.rule}/`,
         flags: [args.gitScope && `git-scope=${args.gitScope}`]
       });
     },
     renderResult(result, options, theme, ...rest) {
       return renderAnchoredFilesResult(result, options, theme, rest, {
-        pendingLabel: "pending readSeek_find_nodes",
+        pendingLabel: "pending readSeek_search",
         emptyLabel: "no matches",
         unitSingular: "match",
         unitPlural: "matches"
@@ -4948,7 +4612,7 @@ function buildRefsOutput(input) {
 
 // src/refs.ts
 var REFS_PROMPT_METADATA = defineToolPromptMetadata({
-  toolName: "find_references",
+  toolName: "refs",
   promptSnippet: "Find references by identifier name or cursor binding"
 });
 function refsLine(reference) {
@@ -4990,7 +4654,7 @@ async function executeRefs(opts) {
   if (!statResult.ok)
     return statResult.error;
   try {
-    const references = await readSeekFindReferences(searchPath, {
+    const references = await readSeekRefs(searchPath, {
       name: p.name,
       at: p.at,
       language: p.language,
@@ -5020,7 +4684,7 @@ async function executeRefs(opts) {
 }
 function registerRefsTool(pi, options = {}) {
   const tool = registerReadSeekTool(pi, {
-    name: "readSeek_find_references",
+    name: "readSeek_refs",
     label: "References",
     description: REFS_PROMPT_METADATA.description,
     promptSnippet: REFS_PROMPT_METADATA.promptSnippet,
@@ -5038,14 +4702,14 @@ function registerRefsTool(pi, options = {}) {
     renderCall(args, theme, ...rest) {
       const accent = args.name ?? args.at ?? "?";
       return renderReadSeekSearchCall(args, theme, rest, {
-        label: "readSeek_find_references",
+        label: "readSeek_refs",
         accent,
         flags: [args.at && "binding", args.gitScope && `git-scope=${args.gitScope}`]
       });
     },
     renderResult(result, options, theme, ...rest) {
       return renderAnchoredFilesResult(result, options, theme, rest, {
-        pendingLabel: "pending readSeek_find_references",
+        pendingLabel: "pending readSeek_refs",
         emptyLabel: "no references",
         unitSingular: "reference",
         unitPlural: "references"
@@ -5060,7 +4724,7 @@ import { Type as Type8 } from "@sinclair/typebox";
 import path8 from "node:path";
 import { Text as Text5 } from "@earendil-works/pi-tui";
 var RENAME_PROMPT_METADATA = defineToolPromptMetadata({
-  toolName: "rename_symbol",
+  toolName: "rename",
   promptSnippet: "Rename a symbol at a source location with verified edits"
 });
 var renameSchema = Type8.Object({
@@ -5076,12 +4740,12 @@ async function executeRename(opts) {
   if (!p.to.trim()) {
     return buildToolErrorResult("rename", "invalid-parameter", "rename parameter 'to' must not be empty");
   }
-  if (typeof p.at !== "string" || !/^(line:[1-9][0-9]*|hash:[0-9a-fA-F]+)(:[1-9][0-9]*)?$/.test(p.at)) {
-    return buildToolErrorResult("rename_symbol", "invalid-parameter", "at must be a line or hash location with an optional positive column");
+  if (typeof p.at !== "string" || !/^(line:[1-9][0-9]*|hash:[0-9a-fA-F]+|[1-9][0-9]*|[0-9a-fA-F]{6})(:[1-9][0-9]*)?$/.test(p.at)) {
+    return buildToolErrorResult("rename", "invalid-parameter", "at must be a line or hash location with an optional positive column");
   }
   const filePath = resolveToCwd(p.path, cwd);
   try {
-    const output = await readSeekRenameSymbol(filePath, {
+    const output = await readSeekRename(filePath, {
       to: p.to,
       at: p.at,
       workspace: p.workspace ? cwd : undefined,
@@ -5138,7 +4802,7 @@ First conflict at ${firstConflict.line}:${firstConflict.column}: ${firstConflict
 }
 function registerRenameTool(pi, options = {}) {
   registerReadSeekTool(pi, {
-    name: "readSeek_rename_symbol",
+    name: "readSeek_rename",
     label: "Rename",
     description: RENAME_PROMPT_METADATA.description,
     promptSnippet: RENAME_PROMPT_METADATA.promptSnippet,
@@ -5151,7 +4815,7 @@ function registerRenameTool(pi, options = {}) {
       const context = rest[0] ?? {};
       const cwd = context.cwd ?? process.cwd();
       const displayPath = typeof args?.path === "string" ? args.path : "?";
-      let text = theme.fg("toolTitle", theme.bold("readSeek_rename_symbol"));
+      let text = theme.fg("toolTitle", theme.bold("readSeek_rename"));
       text += ` ${linkToolPath(theme.fg("accent", displayPath), displayPath, cwd)}`;
       if (args?.to)
         text += theme.fg("dim", ` → ${args.to}`);
@@ -5160,13 +4824,13 @@ function registerRenameTool(pi, options = {}) {
     renderResult(result, options, theme, ...rest) {
       const { isPartial, isError, expanded, cwd, width } = resolveRenderResultContext(options, rest);
       if (isPartial)
-        return renderPendingResult("pending readSeek_rename_symbol", width, theme);
+        return renderPendingResult("pending readSeek_rename", width, theme);
       const content = result.content?.[0];
       const textContent = content?.type === "text" ? content.text : "";
       const readSeekValue = result.details?.readSeekValue;
       const output = readSeekValue?.output;
       if (isError || result.isError) {
-        return renderErrorResult(textContent, { expanded, width, fallback: "readSeek_rename_symbol failed", theme });
+        return renderErrorResult(textContent, { expanded, width, fallback: "readSeek_rename failed", theme });
       }
       const outputs = output ? [output, ...output.others] : [];
       const editCount = outputs.reduce((total, file) => total + file.edits.length, 0);
@@ -5201,6 +4865,18 @@ import { withFileMutationQueue as withFileMutationQueue2, truncateHead as trunca
 import { Text as Text6 } from "@earendil-works/pi-tui";
 import { Type as Type9 } from "@sinclair/typebox";
 
+// src/binary-detect.ts
+function looksLikeBinary(buf) {
+  if (buf.length === 0)
+    return false;
+  if (buf.includes(0))
+    return true;
+  const decoded = buf.toString("utf8");
+  if (!decoded.includes("�"))
+    return false;
+  return !Buffer.from(decoded, "utf8").equals(buf);
+}
+
 // src/pending-diff-preview.ts
 import { existsSync as existsSync3, readFileSync as readFileSync2, realpathSync, statSync as statSync4 } from "node:fs";
 import { dirname, isAbsolute, relative as relative2, resolve, sep } from "node:path";
@@ -5404,7 +5080,7 @@ async function executeWrite(opts) {
   const warnings = [];
   const readSeekWarnings = [];
   if (hasBareCarriageReturn(content)) {
-    const message = "File content contains bare CR (\\r) line endings; readSeek_write_file refuses to emit anchors that readSeek_show_content/readSeek_edit_text would normalize differently.";
+    const message = "File content contains bare CR (\\r) line endings; readSeek_write refuses to emit anchors that readSeek_show/readSeek_edit would normalize differently.";
     warnings.push(message);
     readSeekWarnings.push(buildReadSeekWarning("bare-cr", message));
     return buildToolErrorResult("write", "bare-cr", `Cannot write ${filePath}
@@ -5483,9 +5159,9 @@ async function executeWrite(opts) {
   };
 }
 function registerWriteTool(pi, options = {}) {
-  const name = options.name ?? "readSeek_write_file";
+  const name = options.name ?? "readSeek_write";
   const promptMetadata = defineToolPromptMetadata({
-    toolName: "write_file",
+    toolName: "write",
     promptSnippet: "Create or replace a complete file with LINE:HASH anchors",
     registeredName: name
   });
@@ -5599,21 +5275,21 @@ function registerWriteTool(pi, options = {}) {
 import { Type as Type10 } from "@sinclair/typebox";
 import path9 from "node:path";
 var DEF_PROMPT_METADATA = defineToolPromptMetadata({
-  toolName: "find_definitions",
+  toolName: "def",
   promptSnippet: "Go to a symbol definition or declaration by name"
 });
 async function executeDef(opts) {
   const { params, signal, cwd, onFileAnchored } = opts;
   const p = params;
   if (!p.name || !p.name.trim()) {
-    return buildToolErrorResult("def", "invalid-parameter", "readSeek_find_definitions requires 'name'");
+    return buildToolErrorResult("def", "invalid-parameter", "readSeek_def requires 'name'");
   }
   const searchPath = resolveToCwd(p.path ?? ".", cwd);
   const statResult = await statSearchPathOrError("def", p.path, searchPath);
   if (!statResult.ok)
     return statResult.error;
   try {
-    const definitions = await readSeekFindDefinitions(searchPath, {
+    const definitions = await readSeekDef(searchPath, {
       name: p.name,
       language: p.language,
       gitScope: p.gitScope,
@@ -5662,7 +5338,7 @@ async function executeDef(opts) {
 }
 function registerDefTool(pi, options = {}) {
   registerReadSeekTool(pi, {
-    name: "readSeek_find_definitions",
+    name: "readSeek_def",
     label: "Definition",
     description: DEF_PROMPT_METADATA.description,
     promptSnippet: DEF_PROMPT_METADATA.promptSnippet,
@@ -5678,14 +5354,14 @@ function registerDefTool(pi, options = {}) {
     },
     renderCall(args, theme, ...rest) {
       return renderReadSeekSearchCall(args, theme, rest, {
-        label: "readSeek_find_definitions",
+        label: "readSeek_def",
         accent: args.name,
         flags: [args.gitScope && `git-scope=${args.gitScope}`]
       });
     },
     renderResult(result, options, theme, ...rest) {
       return renderAnchoredFilesResult(result, options, theme, rest, {
-        pendingLabel: "pending readSeek_find_definitions",
+        pendingLabel: "pending readSeek_def",
         emptyLabel: "no definitions",
         unitSingular: "definition",
         unitPlural: "definitions"
@@ -5699,32 +5375,32 @@ import { Text as Text7, wrapTextWithAnsi as wrapTextWithAnsi2 } from "@earendil-
 import { Type as Type11 } from "@sinclair/typebox";
 import { readFile as readFile2 } from "node:fs/promises";
 var operations = {
-  show_content: readSeekShowContent,
-  show_structure: readSeekShowStructure,
-  show_metadata: readSeekShowMetadata,
-  show_assets: readSeekShowAssets,
-  check_syntax: readSeekCheckSyntax,
-  check_rules: readSeekCheckRules,
-  generate_caption: readSeekGenerateCaption,
-  detect_objects: readSeekDetectObjects,
-  recognize_text: readSeekRecognizeText
+  show: readSeekShow,
+  tree: readSeekTree,
+  meta: readSeekMeta,
+  assets: readSeekAssets,
+  syntax: readSeekSyntax,
+  check: readSeekCheck,
+  caption: readSeekCaption,
+  objects: readSeekObjects,
+  ocr: readSeekOcr
 };
 function resolveNonShowSummary(tool, envelope) {
-  if (tool === "check_syntax") {
+  if (tool === "syntax") {
     const errorCount = envelope?.diagnostics?.error_count ?? 0;
     return errorCount === 0 ? "clean" : `${errorCount} syntax error${errorCount === 1 ? "" : "s"}`;
   }
-  if (tool === "check_rules") {
+  if (tool === "check") {
     const violations = Array.isArray(envelope?.violations) ? envelope.violations.length : 0;
     return violations === 0 ? "clean" : `${violations} rule violation${violations === 1 ? "" : "s"}`;
   }
-  if (tool === "detect_objects") {
+  if (tool === "objects") {
     const objects = Array.isArray(envelope?.objects) ? envelope.objects.length : 0;
     return `${objects} object${objects === 1 ? "" : "s"}`;
   }
-  if (tool === "generate_caption")
+  if (tool === "caption")
     return "caption generated";
-  if (tool === "recognize_text")
+  if (tool === "ocr")
     return "text recognized";
   return "complete";
 }
@@ -5799,7 +5475,7 @@ async function executeAccess(opts) {
     if (key === "stdinName" || !Object.hasOwn(contract.inputSchema.properties, key))
       return buildToolErrorResult(opts.tool, "invalid-parameter", `Unknown parameter: ${key}`);
   }
-  const path = p.path === undefined && opts.tool === "check_rules" ? "." : p.path;
+  const path = p.path === undefined && opts.tool === "check" ? "." : p.path;
   if (typeof path !== "string" || !path.trim())
     return buildToolErrorResult(opts.tool, "invalid-parameter", "path is required");
   if (path === "-")
@@ -5814,7 +5490,7 @@ async function executeAccess(opts) {
     const content = [
       { type: "text", text: presentation ? formatShowResult(presentation) : JSON.stringify(envelope) }
     ];
-    if (opts.tool === "show_content" || opts.tool === "show_assets") {
+    if (opts.tool === "show" || opts.tool === "assets") {
       for (const [imagePath, mimeType] of imagePaths(envelope)) {
         if (opts.imageMode === "off")
           content.push({ type: "text", text: `Image available at ${imagePath}; image attachments are disabled by readseek.imageMode.` });
@@ -5832,7 +5508,7 @@ async function executeAccess(opts) {
 }
 function registerAccessTools(pi, options = {}) {
   for (const name of Object.keys(operations)) {
-    const registeredName = name === "show_content" ? options.name ?? `readSeek_${name}` : `readSeek_${name}`;
+    const registeredName = name === "show" ? options.name ?? `readSeek_${name}` : `readSeek_${name}`;
     const contract = getToolContract(name);
     const metadata = defineToolPromptMetadata({
       toolName: name,
@@ -5919,37 +5595,37 @@ class SessionAnchors {
 
 // index.ts
 var READSEEK_TOOL_ENTRIES = [
-  { builtIn: "edit", readSeekName: "readSeek_edit_text" },
-  { builtIn: "grep", readSeekName: "readSeek_find_text" },
-  { builtIn: null, readSeekName: "readSeek_find_nodes" },
-  { builtIn: null, readSeekName: "readSeek_find_references" },
-  { builtIn: null, readSeekName: "readSeek_rename_symbol" },
-  { builtIn: "write", readSeekName: "readSeek_write_file" },
-  { builtIn: null, readSeekName: "readSeek_find_definitions" },
-  { builtIn: "read", readSeekName: "readSeek_show_content" },
-  { builtIn: null, readSeekName: "readSeek_show_structure" },
-  { builtIn: null, readSeekName: "readSeek_show_metadata" },
-  { builtIn: null, readSeekName: "readSeek_show_assets" },
-  { builtIn: null, readSeekName: "readSeek_check_syntax" },
-  { builtIn: null, readSeekName: "readSeek_check_rules" },
-  { builtIn: null, readSeekName: "readSeek_generate_caption" },
-  { builtIn: null, readSeekName: "readSeek_detect_objects" },
-  { builtIn: null, readSeekName: "readSeek_recognize_text" }
+  { builtIn: "edit", readSeekName: "readSeek_edit" },
+  { builtIn: "grep", readSeekName: "readSeek_grep" },
+  { builtIn: null, readSeekName: "readSeek_search" },
+  { builtIn: null, readSeekName: "readSeek_refs" },
+  { builtIn: null, readSeekName: "readSeek_rename" },
+  { builtIn: "write", readSeekName: "readSeek_write" },
+  { builtIn: null, readSeekName: "readSeek_def" },
+  { builtIn: "read", readSeekName: "readSeek_show" },
+  { builtIn: null, readSeekName: "readSeek_tree" },
+  { builtIn: null, readSeekName: "readSeek_meta" },
+  { builtIn: null, readSeekName: "readSeek_assets" },
+  { builtIn: null, readSeekName: "readSeek_syntax" },
+  { builtIn: null, readSeekName: "readSeek_check" },
+  { builtIn: null, readSeekName: "readSeek_caption" },
+  { builtIn: null, readSeekName: "readSeek_objects" },
+  { builtIn: null, readSeekName: "readSeek_ocr" }
 ];
 function piReadSeekExtension(pi) {
   const sessionAnchors = new SessionAnchors;
   const { settings } = resolveReadSeekJsonSettings();
   const replacedBuiltIns = new Set(settings.overrideTools ?? []);
   const swap = (builtIn, readSeekName) => replacedBuiltIns.has(builtIn) ? builtIn : readSeekName;
-  const readName = swap("read", "readSeek_show_content");
-  const editName = swap("edit", "readSeek_edit_text");
-  const writeName = swap("write", "readSeek_write_file");
-  const grepName = swap("grep", "readSeek_find_text");
+  const readName = swap("read", "readSeek_show");
+  const editName = swap("edit", "readSeek_edit");
+  const writeName = swap("write", "readSeek_write");
+  const grepName = swap("grep", "readSeek_grep");
   const toolAliases = {
-    readSeek_show_content: readName,
-    readSeek_edit_text: editName,
-    readSeek_find_text: grepName,
-    readSeek_write_file: writeName
+    readSeek_show: readName,
+    readSeek_edit: editName,
+    readSeek_grep: grepName,
+    readSeek_write: writeName
   };
   const policyAliases = Object.fromEntries(TOOL_NAMES.map((name) => {
     const readSeekName = `readSeek_${name}`;