opencode-readseek 0.9.16 → 0.10.0

package/dist/index.js

@@ -6,21 +6,15 @@ import { createRequire as createRequire2 } from "node:module";
 import { stat } from "node:fs/promises";
 
 // ../readseek-api/src/contract.ts
+var INSPECT_FACETS = [
+  "metadata",
+  "content",
+  "map",
+  "diagnostics",
+  "identity"
+];
 var VISION_MODES = ["none", "all", "ocr", "caption", "objects"];
-var VISION_ANALYSIS_MODES = ["all", "ocr", "caption", "objects"];
 var VISION_LEVELS = ["low", "medium", "high"];
-var DOCUMENT_NODE_KINDS = [
-  "artifact",
-  "footer",
-  "header",
-  "heading",
-  "marginal_label",
-  "page",
-  "page_number",
-  "paragraph",
-  "section",
-  "structural_section"
-];
 var EDIT_VARIANTS = [
   "set_line",
   "replace_lines",
@@ -28,12 +22,13 @@ var EDIT_VARIANTS = [
   "replace",
   "replace_symbol"
 ];
+var GIT_SCOPES = ["tracked", "untracked", "ignored", "all"];
 var TOOL_NAMES = [
-  "digest",
+  "inspect",
   "edit",
   "write",
   "grep",
-  "view",
+  "extract",
   "search",
   "def",
   "refs",
@@ -55,28 +50,24 @@ var PARAM_DESCRIPTIONS = {
   line: "One-based cursor line; required with scope",
   renameLine: "One-based cursor line of the symbol to rename",
   column: "One-based cursor byte column for disambiguation",
-  cached: "In a Git repository, search tracked/indexed files",
-  others: "In a Git repository, search untracked files",
-  ignored: "With others=true, include ignored untracked files",
+  gitScope: "In a Git repository, which files to search: tracked, untracked, ignored (untracked plus ignored), or all. Defaults to tracked plus untracked.",
   select: "Facets: metadata, content, map, diagnostics, identity (default content)",
   selectComma: "Comma-separated facets: metadata, content, map, diagnostics, identity",
-  at: "Location: line:N[:COLUMN], hash:HASH[:COLUMN], or symbol:NAME",
+  selector: "Positional selector: line:N[:COLUMN], hash:H[:COLUMN], symbol:NAME, page:N, node:ID, or asset:ID. Columns require the identity facet, which in turn rejects symbol selectors",
+  assetSelector: "Document asset selector in the form asset:ID",
+  query: "KDL selection query, @path, or '-' for standard input",
+  stdinName: "File name hint when the target is '-'",
   end: "Last line to include",
   limit: "Maximum number of lines to include",
-  digestDepth: "Maximum structural depth for map output; defaults to 1 in agent tools",
+  inspectDepth: "Maximum structural depth for map output; defaults to 1 in agent tools",
   offset: "One-based starting line",
   readLimit: "Maximum lines to return",
   symbolRead: "Symbol name to read",
   bundle: "Include related symbols from the same file; requires symbol",
   image: "Standalone image mode: none, all, ocr, caption, objects. Required for standalone images.",
-  visionModeDigest: "Standalone image mode: none, all, caption, objects, or ocr",
-  visionModeView: "Analyze selected assets: all, ocr, caption, or objects",
+  visionModeInspect: "Standalone image mode: none, all, caption, objects, or ocr",
   visionLevel: "Vision inference level: low (default), medium, or high",
-  node: "Node ID to use as the view root",
-  page: "One-based source page",
-  kind: "Node kind filter",
-  depth: "Maximum depth below selected roots",
-  outline: "Return outline nodes only",
+  output: "Destination file for extracted binary data; stdout is not supported",
   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":"..."}}',
@@ -113,11 +104,11 @@ var PARAM_DESCRIPTIONS = {
   scopeContext: "Context lines within each symbol"
 };
 var TOOL_DESCRIPTIONS = {
-  digest: "Digest source content and images into the native CLI envelope. Returns metadata plus requested facets unchanged from `readseek digest`. Use it before edits to obtain fresh `LINE:HASH` anchors; use shallow maps for structural overviews, diagnostics for syntax checks, and identity for cursor context.",
+  inspect: "Inspect source content, images, and documents through the native CLI envelope. Use it before edits to obtain fresh `LINE:HASH` anchors; use shallow maps for structural overviews, diagnostics for syntax checks, and identity for cursor context.",
   edit: 'Edit existing text files with fresh `LINE:HASH` anchors. Read or search first when no fresh anchors are available. Each `edits[]` item must use exactly one nested object: `{"set_line":{"anchor":"LINE:HASH","new_text":"..."}}`, `{"replace_lines":{"start_anchor":"LINE:HASH","end_anchor":"LINE:HASH","new_text":"..."}}`, `{"insert_after":{"anchor":"LINE:HASH","new_text":"..."}}`, `{"replace_symbol":{"symbol":"name","new_body":"..."}}`, or `{"replace":{"old_text":"...","new_text":"..."}}`.',
   write: "Create or replace a complete text file and return `LINE:HASH` anchors. Use `edit` for small changes to an existing file.",
   grep: "Search text or regex in files and return edit-ready `LINE:HASH` anchors. Use for identifiers, strings, configuration, errors, comments, and documentation.",
-  view: "Digest a document's structure or selected content. Start with the overview, then narrow by page, node, kind, or depth instead of reading the whole document. PDF is the first supported document format.",
+  extract: "Extract a selected document asset into a destination file. Use an `asset:ID` selector discovered through `inspect`; extracted binary data is never returned on stdout.",
   search: "Search code by AST structure using ast-grep-style patterns. Results include line hashes usable as `LINE:HASH` anchors. Use `grep` for identifiers, strings, comments, configuration, documentation, or other plain text and regex.",
   def: "Go to a symbol definition or declaration by name. Accepts qualified or unqualified names; use this instead of text search for functions, methods, classes, types, and other declarations.",
   refs: "Find references or usages of an identifier by name or cursor binding. Results include enclosing symbols and line hashes usable as `LINE:HASH` anchors. Without cursor scope, results are identifier-name matches; with scope, they follow one binding and exclude shadows. Use text search for literals, and use this before renaming or deleting a symbol.",
@@ -129,18 +120,11 @@ function renderToolDescription(name, aliases = {}) {
     throw new Error(`Missing TOOL_DESCRIPTIONS for ${name}`);
   return TOOL_NAMES.reduce((description, toolName) => description.replaceAll(`\`${toolName}\``, `\`${aliases[toolName] ?? toolName}\``), desc);
 }
-var gitFlagsSchema = {
-  cached: {
-    type: "boolean",
-    description: PARAM_DESCRIPTIONS.cached
-  },
-  others: {
-    type: "boolean",
-    description: PARAM_DESCRIPTIONS.others
-  },
-  ignored: {
-    type: "boolean",
-    description: PARAM_DESCRIPTIONS.ignored
+var gitScopeSchema = {
+  gitScope: {
+    type: "string",
+    enum: GIT_SCOPES,
+    description: PARAM_DESCRIPTIONS.gitScope
   }
 };
 var editItemSchema = {
@@ -206,29 +190,31 @@ var editItemSchema = {
 };
 var TOOL_CONTRACTS = [
   {
-    name: "digest",
-    title: "Digest source",
-    description: TOOL_DESCRIPTIONS.digest,
+    name: "inspect",
+    title: "Inspect input",
+    description: TOOL_DESCRIPTIONS.inspect,
     inputSchema: {
       type: "object",
       properties: {
         path: { type: "string", description: PARAM_DESCRIPTIONS.path },
+        selector: { type: "string", description: PARAM_DESCRIPTIONS.selector },
         select: { type: "string", description: PARAM_DESCRIPTIONS.select },
-        at: { type: "string", description: PARAM_DESCRIPTIONS.at },
+        query: { type: "string", description: PARAM_DESCRIPTIONS.query },
         end: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.end },
         limit: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.limit },
-        depth: { type: "integer", minimum: 0, description: PARAM_DESCRIPTIONS.digestDepth },
+        depth: { type: "integer", minimum: 0, description: PARAM_DESCRIPTIONS.inspectDepth },
         language: { type: "string", description: PARAM_DESCRIPTIONS.languageOverride },
         visionMode: {
           type: "string",
           enum: [...VISION_MODES],
-          description: PARAM_DESCRIPTIONS.visionModeDigest
+          description: PARAM_DESCRIPTIONS.visionModeInspect
         },
         visionLevel: {
           type: "string",
           enum: [...VISION_LEVELS],
           description: PARAM_DESCRIPTIONS.visionLevel
-        }
+        },
+        stdinName: { type: "string", description: PARAM_DESCRIPTIONS.stdinName }
       },
       required: ["path"],
       additionalProperties: false
@@ -302,34 +288,27 @@ var TOOL_CONTRACTS = [
     }
   },
   {
-    name: "view",
-    title: "View document",
-    description: TOOL_DESCRIPTIONS.view,
+    name: "extract",
+    title: "Extract asset",
+    description: TOOL_DESCRIPTIONS.extract,
     inputSchema: {
       type: "object",
       properties: {
         path: { type: "string", description: PARAM_DESCRIPTIONS.path },
-        node: { type: "string", description: PARAM_DESCRIPTIONS.node },
-        page: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.page },
-        kind: {
+        selector: {
           type: "string",
-          enum: [...DOCUMENT_NODE_KINDS],
-          description: PARAM_DESCRIPTIONS.kind
+          pattern: "^asset:.+",
+          description: PARAM_DESCRIPTIONS.assetSelector
         },
-        depth: { type: "integer", minimum: 0, description: PARAM_DESCRIPTIONS.depth },
-        outline: { type: "boolean", description: PARAM_DESCRIPTIONS.outline },
-        visionMode: {
+        output: {
           type: "string",
-          enum: [...VISION_ANALYSIS_MODES],
-          description: PARAM_DESCRIPTIONS.visionModeView
+          minLength: 1,
+          pattern: "^(?!-$).+",
+          description: PARAM_DESCRIPTIONS.output
         },
-        visionLevel: {
-          type: "string",
-          enum: [...VISION_LEVELS],
-          description: PARAM_DESCRIPTIONS.visionLevel
-        }
+        stdinName: { type: "string", description: PARAM_DESCRIPTIONS.stdinName }
       },
-      required: ["path"],
+      required: ["path", "selector", "output"],
       additionalProperties: false
     }
   },
@@ -343,7 +322,8 @@ var TOOL_CONTRACTS = [
         pattern: { type: "string", description: PARAM_DESCRIPTIONS.pattern },
         path: { type: "string", description: PARAM_DESCRIPTIONS.searchPath },
         language: { type: "string", description: PARAM_DESCRIPTIONS.language },
-        ...gitFlagsSchema
+        limit: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.matchLimit },
+        ...gitScopeSchema
       },
       required: ["pattern"],
       additionalProperties: false
@@ -359,7 +339,7 @@ var TOOL_CONTRACTS = [
         name: { type: "string", description: PARAM_DESCRIPTIONS.name },
         path: { type: "string", description: PARAM_DESCRIPTIONS.searchPath },
         language: { type: "string", description: PARAM_DESCRIPTIONS.language },
-        ...gitFlagsSchema
+        ...gitScopeSchema
       },
       required: ["name"],
       additionalProperties: false
@@ -378,7 +358,7 @@ var TOOL_CONTRACTS = [
         scope: { type: "boolean", description: PARAM_DESCRIPTIONS.scope },
         line: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.line },
         column: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.column },
-        ...gitFlagsSchema
+        ...gitScopeSchema
       },
       additionalProperties: false
     }
@@ -396,7 +376,9 @@ var TOOL_CONTRACTS = [
         to: { type: "string", description: PARAM_DESCRIPTIONS.to },
         workspace: { type: "boolean", description: PARAM_DESCRIPTIONS.workspace },
         apply: { type: "boolean", description: PARAM_DESCRIPTIONS.apply },
-        planHash: { type: "string", description: PARAM_DESCRIPTIONS.planHash }
+        planHash: { type: "string", description: PARAM_DESCRIPTIONS.planHash },
+        language: { type: "string", description: PARAM_DESCRIPTIONS.language },
+        ...gitScopeSchema
       },
       required: ["path", "line", "to"],
       additionalProperties: false
@@ -405,14 +387,14 @@ var TOOL_CONTRACTS = [
 ];
 // ../readseek-api/src/policy.ts
 var BUILTIN_FALLBACKS = {
-  read: "digest",
+  read: "inspect",
   edit: "edit",
   write: "write",
   grep: "grep",
   apply_patch: "edit"
 };
 var PREFERENCE_LEADS = {
-  digest: "Preferred for reading source with anchors and facets.",
+  inspect: "Preferred for reading source with anchors and facets.",
   edit: "Preferred for editing existing text files with fresh LINE:HASH anchors.",
   write: "Preferred for creating or replacing a complete text file; returns LINE:HASH anchors.",
   grep: "Preferred text/regex search; returns edit-ready LINE:HASH anchors.",
@@ -420,10 +402,10 @@ var PREFERENCE_LEADS = {
   def: "Preferred for go-to-definition or declaration lookup by name.",
   refs: "Preferred for finding identifier-name matches or binding-specific references before rename or delete.",
   rename: "Preferred for renaming a symbol with binding-aware, verified edits.",
-  view: "Preferred for digesting document structure or selected content."
+  extract: "Preferred for saving a selected document asset to a file."
 };
 var FALLBACK_TEMPLATES = {
-  read: "Prefer `digest` with fresh LINE:HASH anchors.",
+  read: "Prefer `inspect` with fresh LINE:HASH anchors.",
   edit: "Prefer `edit` with fresh LINE:HASH anchors.",
   write: "Prefer `write` so the result returns LINE:HASH anchors.",
   grep: "Prefer `grep` for text/regex search with edit-ready anchors.",
@@ -446,7 +428,7 @@ function renderFallbackToolDescription(builtIn, aliases = {}) {
 }
 function renderToolRoutingPolicy(options = {}) {
   const aliases = options.aliases ?? {};
-  const digest = resolveToolName("digest", aliases);
+  const inspect = resolveToolName("inspect", aliases);
   const edit = resolveToolName("edit", aliases);
   const write = resolveToolName("write", aliases);
   const grep = resolveToolName("grep", aliases);
@@ -454,11 +436,11 @@ function renderToolRoutingPolicy(options = {}) {
   const def = resolveToolName("def", aliases);
   const refs = resolveToolName("refs", aliases);
   const rename = resolveToolName("rename", aliases);
-  const view = resolveToolName("view", aliases);
+  const extract = resolveToolName("extract", aliases);
   if (options.style === "server") {
     return [
-      "Structural code navigation, document viewing, and hash-verified edits with readseek.",
-      "For structural questions, prefer these tools to text Grep/Bash: targeted definitions, references, and AST search; shallow digest maps; diagnostics and identity; and document views.",
+      "Structural code navigation, document inspection, and hash-verified edits with readseek.",
+      "For structural questions, prefer these tools to text Grep/Bash: targeted definitions, references, and AST search; shallow inspect maps; diagnostics and identity; and document inspection.",
       `Use ${edit} for LINE:HASH-anchored mutations (preview with apply=false; apply defaults to true and re-checks plan_hash).`,
       "Paths resolve against CLAUDE_PROJECT_DIR. Native Read/Grep/Edit hooks provide passive context;",
       "call MCP tools for active navigation, document questions, or anchored edits."
@@ -469,7 +451,7 @@ function renderToolRoutingPolicy(options = {}) {
   if (options.preferOverBuiltIns) {
     bullets.push("- Prefer ReadSeek tools over built-ins when they can do the job.");
   }
-  bullets.push(`- Read with ${digest} first; ${edit} needs fresh LINE:HASH anchors.`, `- Use ${grep} for text/regex, ${search} for AST patterns, ${def}/${refs} for targeted symbols, and shallow ${digest} maps only for file overviews.`, `- Use ${edit} for existing files, ${write} for whole-file creation or replacement, and ${rename} for symbol renames.`, `- Use ${view} for document structure; run ${digest} with select diagnostics after source edits for a quick syntax check.`);
+  bullets.push(`- Read with ${inspect} first; ${edit} needs fresh LINE:HASH anchors.`, `- Use ${grep} for text/regex, ${search} for AST patterns, ${def}/${refs} for targeted symbols, and shallow ${inspect} maps only for file overviews.`, `- Use ${edit} for existing files, ${write} for whole-file creation or replacement, and ${rename} for symbol renames.`, `- Use ${inspect} for document structure; run ${inspect} with select diagnostics after source edits for a quick syntax check.`, `- Use ${extract} to save a selected document asset.`);
   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.`);
   }
@@ -504,12 +486,6 @@ function tryParseLineAnchor(anchor) {
 }
 
 // ../readseek-api/src/validation.ts
-function validateGitSelection(input) {
-  if (input.ignored && !input.others) {
-    return { ok: false, error: "ignored requires others=true" };
-  }
-  return { ok: true };
-}
 function validateRefsNameVsScope(input) {
   if (input.scope) {
     if (input.line === undefined) {
@@ -526,11 +502,8 @@ function validateRefsNameVsScope(input) {
   return { ok: true };
 }
 function validateVisionLevelVsMode(input) {
-  if (input.outline && (input.visionMode !== undefined || input.visionLevel !== undefined)) {
-    return { ok: false, error: "Cannot combine outline with visionMode or visionLevel" };
-  }
-  if (input.visionLevel !== undefined && input.visionMode === undefined) {
-    return { ok: false, error: "visionLevel requires visionMode" };
+  if (input.visionLevel !== undefined && !["all", "ocr", "caption", "objects"].includes(input.visionMode ?? "")) {
+    return { ok: false, error: "visionLevel requires an analysis visionMode" };
   }
   return { ok: true };
 }
@@ -601,22 +574,54 @@ function validateExactlyOneEditVariant(edits) {
 }
 var MIN_SAFE_INTEGER = BigInt(Number.MIN_SAFE_INTEGER);
 var MAX_SAFE_INTEGER = BigInt(Number.MAX_SAFE_INTEGER);
+// ../readseek-api/src/edit-plan.ts
+import { Document, Node, format } from "@bgotink/kdl";
+function node(name, properties, children = []) {
+  const result = Node.create(name);
+  for (const [key, value] of Object.entries(properties))
+    result.setProperty(key, value);
+  if (children.length > 0)
+    result.children = new Document(children);
+  return result;
+}
+function editNode(edit) {
+  if ("set_line" in edit) {
+    const value = edit.set_line;
+    return node("set-line", { anchor: value.anchor, text: value.new_text });
+  }
+  if ("replace_lines" in edit) {
+    const value = edit.replace_lines;
+    return node("replace-lines", { start: value.start_anchor, end: value.end_anchor, text: value.new_text });
+  }
+  if ("insert_after" in edit) {
+    const value = edit.insert_after;
+    return node("insert-after", { anchor: value.anchor, text: value.new_text });
+  }
+  if ("replace_symbol" in edit) {
+    const value = edit.replace_symbol;
+    return node("replace-symbol", { symbol: value.symbol, body: value.new_body });
+  }
+  const value = edit.replace;
+  return node("replace", {
+    old: value.old_text,
+    new: value.new_text,
+    ...value.all === undefined ? {} : { all: value.all }
+  });
+}
+function serializeEditPlan(edits) {
+  const validation = validateExactlyOneEditVariant(edits);
+  if (!validation.ok)
+    throw new Error(validation.error);
+  return format(new Document([node("plan", {}, validation.edits.map(editNode))]));
+}
 // ../readseek-api/src/argv.ts
-var DEFAULT_DIGEST_MAP_DEPTH = 1;
+var DEFAULT_INSPECT_MAP_DEPTH = 1;
 function buildLineLocation(line, column) {
   return column === undefined ? `line:${line}` : `line:${line}:${column}`;
 }
-function appendGitSelectionArgs(args, input) {
-  const validated = validateGitSelection(input);
-  if (!validated.ok) {
-    throw new Error(validated.error);
-  }
-  if (input.cached)
-    args.push("--cached");
-  if (input.others)
-    args.push("--others");
-  if (input.ignored)
-    args.push("--ignored");
+function appendGitScopeArgs(args, input) {
+  if (input.gitScope !== undefined)
+    args.push("--git-scope", input.gitScope);
   return args;
 }
 function pushOptionalString(args, flag, value) {
@@ -645,33 +650,138 @@ function selectArg(select) {
     return;
   return Array.isArray(select) ? select.join(",") : select;
 }
-function selectsDigestMap(select) {
-  const value = selectArg(select);
-  return value?.split(",").some((facet) => facet.trim() === "map") ?? false;
+function selectedInspectFacets(select) {
+  const facets = (selectArg(select) ?? "content").split(",").map((facet) => facet.trim());
+  for (const facet of facets) {
+    if (!INSPECT_FACETS.includes(facet)) {
+      throw new Error(`unknown inspect facet: ${facet}`);
+    }
+  }
+  return facets;
+}
+function hasInspectFacet(facets, facet) {
+  return facets.includes(facet);
+}
+function validateTarget(command, target, stdinName) {
+  if (target.length === 0)
+    throw new Error(`${command} requires a target file path or '-'`);
+  if (stdinName !== undefined && stdinName.length > 0 && target !== "-") {
+    throw new Error("stdinName requires '-' as the target");
+  }
+}
+function validatePositiveInteger(value, name) {
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new Error(`${name} must be a positive integer`);
+  }
+}
+var SELECTOR_KINDS = ["line", "hash", "symbol", "page", "node", "asset"];
+function isSelectorKind(value) {
+  return SELECTOR_KINDS.includes(value);
+}
+function parseSelector(text) {
+  const separator = text.indexOf(":");
+  if (separator < 0) {
+    throw new Error("selector must start with line:, hash:, symbol:, page:, node:, or asset:");
+  }
+  const kind = text.slice(0, separator);
+  const value = text.slice(separator + 1);
+  if (value.length === 0)
+    throw new Error(`${kind} selector must not be empty`);
+  if (!isSelectorKind(kind)) {
+    throw new Error(`unknown selector kind \`${kind}\`; expected line, hash, symbol, page, node, or asset`);
+  }
+  if (kind === "line" || kind === "hash") {
+    const parts = value.split(":");
+    if (parts.length > 2)
+      throw new Error("selector has too many components");
+    if (parts.length === 2) {
+      const column = Number(parts[1]);
+      if (!Number.isSafeInteger(column))
+        throw new Error(`invalid column \`${parts[1]}\``);
+      if (column < 1)
+        throw new Error("column must be greater than zero");
+      return { kind, value: parts[0], column };
+    }
+  }
+  if (kind === "page") {
+    if (value.includes(":"))
+      throw new Error("page selector has too many components");
+    const page = Number(value);
+    if (!Number.isSafeInteger(page))
+      throw new Error(`invalid page \`${value}\``);
+    if (page < 1)
+      throw new Error("page must be greater than zero");
+  }
+  return { kind, value };
 }
-function buildDigestArgs(input) {
+function buildInspectArgs(input) {
+  validateTarget("inspect", input.path, input.stdinName);
+  if (input.selector !== undefined && input.selector.length === 0) {
+    throw new Error("selector must not be empty");
+  }
   const vision = validateVisionLevelVsMode({
     visionMode: input.visionMode,
     visionLevel: input.visionLevel
   });
   if (!vision.ok)
     throw new Error(vision.error);
-  const selectsMap = selectsDigestMap(input.select);
+  const facets = selectedInspectFacets(input.select);
+  const hasContent = hasInspectFacet(facets, "content");
+  const hasIdentity = hasInspectFacet(facets, "identity");
+  const hasMap = hasInspectFacet(facets, "map");
+  const hasSourceFacet = hasMap || hasInspectFacet(facets, "diagnostics") || hasIdentity;
+  if (input.end !== undefined)
+    validatePositiveInteger(input.end, "end");
+  if (input.limit !== undefined)
+    validatePositiveInteger(input.limit, "limit");
+  if (input.end !== undefined && input.limit !== undefined) {
+    throw new Error("cannot combine end with limit");
+  }
   if (input.depth !== undefined) {
-    if (!Number.isInteger(input.depth) || input.depth < 0) {
+    if (!Number.isSafeInteger(input.depth) || input.depth < 0) {
       throw new Error("depth must be a non-negative integer");
     }
-    if (!selectsMap)
+    if (!hasMap)
       throw new Error("depth requires the map facet");
   }
+  if (input.selector !== undefined && input.query !== undefined) {
+    throw new Error("cannot combine selector with query");
+  }
+  if (!hasContent && (input.end !== undefined || input.limit !== undefined || input.query !== undefined)) {
+    throw new Error("ranges and queries require the content facet");
+  }
+  if (hasIdentity && input.selector === undefined) {
+    throw new Error("the identity facet requires a selector");
+  }
+  if (input.selector !== undefined && !hasContent && !hasIdentity) {
+    throw new Error("selectors require the content or identity facet");
+  }
+  if (input.selector !== undefined) {
+    const selector = parseSelector(input.selector);
+    if (selector.kind === "symbol" && hasIdentity) {
+      throw new Error("the identity facet does not accept symbol selectors");
+    }
+    if (selector.column !== undefined && !hasIdentity) {
+      throw new Error("selector columns require the identity facet");
+    }
+  }
+  const hasVision = input.visionMode !== undefined || input.visionLevel !== undefined;
+  if (hasVision && !hasContent) {
+    throw new Error("vision options require the content facet");
+  }
+  if (hasVision && hasSourceFacet) {
+    throw new Error("vision options cannot be combined with source facets");
+  }
   const args = [];
   if (input.readseekDir !== undefined)
     args.push("--readseek-dir", input.readseekDir);
-  args.push("digest", input.path);
+  args.push("inspect", input.path);
+  if (input.selector !== undefined)
+    args.push(input.selector);
   const select = selectArg(input.select);
   if (select !== undefined)
     args.push("--select", select);
-  pushOptionalString(args, "--at", input.at);
+  pushOptionalString(args, "--query", input.query);
   pushOptionalNumber(args, "--end", input.end);
   pushOptionalNumber(args, "--limit", input.limit);
   pushOptionalNumber(args, "--depth", input.depth);
@@ -679,30 +789,24 @@ function buildDigestArgs(input) {
   pushOptionalString(args, "--vision-mode", input.visionMode);
   pushOptionalString(args, "--vision-level", input.visionLevel);
   pushOptionalString(args, "--stdin-name", input.stdinName);
+  args.push("--kdl");
   return args;
 }
-function buildViewArgs(input) {
-  const vision = validateVisionLevelVsMode({
-    visionMode: input.visionMode,
-    visionLevel: input.visionLevel,
-    outline: input.outline
-  });
-  if (!vision.ok)
-    throw new Error(vision.error);
+function buildExtractArgs(input) {
+  validateTarget("extract", input.path, input.stdinName);
+  if (input.selector.length === 0)
+    throw new Error("extract requires an asset selector");
+  if (!input.selector.startsWith("asset:") || input.selector === "asset:") {
+    throw new Error("extract requires an asset: selector");
+  }
+  if (input.output.length === 0 || input.output === "-") {
+    throw new Error("extract output must be a file path");
+  }
   const args = [];
   if (input.readseekDir !== undefined)
     args.push("--readseek-dir", input.readseekDir);
-  args.push("view", input.path);
-  if (input.format !== undefined)
-    args.push("--format", input.format);
-  pushOptionalString(args, "--node", input.node);
-  pushOptionalNumber(args, "--page", input.page);
-  pushOptionalString(args, "--kind", input.kind);
-  pushOptionalNumber(args, "--depth", input.depth);
-  if (input.outline)
-    args.push("--outline");
-  pushOptionalString(args, "--vision-mode", input.visionMode);
-  pushOptionalString(args, "--vision-level", input.visionLevel);
+  args.push("--output", input.output, "extract", input.path, input.selector);
+  pushOptionalString(args, "--stdin-name", input.stdinName);
   return args;
 }
 function buildSearchArgs(input) {
@@ -710,15 +814,17 @@ function buildSearchArgs(input) {
   pushOptionalString(args, "--path", input.path);
   pushOptionalString(args, "--language", input.language);
   pushOptionalNumber(args, "--limit", input.limit);
-  return appendGitSelectionArgs(args, input);
+  appendGitScopeArgs(args, input);
+  args.push("--kdl");
+  return args;
 }
 function buildDefArgs(input) {
   const args = ["def", input.name];
   pushOptionalString(args, "--path", input.path);
-  if (input.format !== undefined)
-    args.push("--format", input.format);
   pushOptionalString(args, "--language", input.language);
-  return appendGitSelectionArgs(args, input);
+  appendGitScopeArgs(args, input);
+  args.push("--kdl");
+  return args;
 }
 function buildRefsArgs(input) {
   const validated = validateRefsNameVsScope(input);
@@ -733,10 +839,10 @@ function buildRefsArgs(input) {
     pushOptionalNumber(args, "--line", input.line);
     pushOptionalNumber(args, "--column", input.column);
   }
-  if (input.format !== undefined)
-    args.push("--format", input.format);
   pushOptionalString(args, "--language", input.language);
-  return appendGitSelectionArgs(args, input);
+  appendGitScopeArgs(args, input);
+  args.push("--kdl");
+  return args;
 }
 function buildEditArgs(input) {
   const args = ["edit", input.path];
@@ -748,6 +854,7 @@ function buildEditArgs(input) {
   pushOptionalString(args, "--language", input.language);
   if (input.requestFromStdin)
     args.push("--edits", "-");
+  args.push("--kdl");
   return args;
 }
 function buildRenameArgs(input) {
@@ -760,7 +867,9 @@ function buildRenameArgs(input) {
     flagOrder: input.flagOrder ?? "plan-hash-first"
   });
   pushOptionalString(args, "--language", input.language);
-  return appendGitSelectionArgs(args, input);
+  appendGitScopeArgs(args, input);
+  args.push("--kdl");
+  return args;
 }
 // ../readseek-api/src/platform.ts
 import { accessSync, constants as fsConstants, existsSync, statSync } from "node:fs";
@@ -776,6 +885,8 @@ var READSEEK_PLATFORM_PACKAGES = {
 };
 var resolveFromPackage = createRequire(import.meta.url).resolve;
 function readSeekBinaryName(platform = process.platform) {
+  if (platform === "linux")
+    return "readseek.AppImage";
   return platform === "win32" ? "readseek.exe" : "readseek";
 }
 function readSeekPlatformKey(platform = process.platform, arch = process.arch) {
@@ -855,22 +966,304 @@ function isSubPath(parent, candidate) {
   const relative = path2.relative(parent, candidate);
   return relative === "" || !relative.startsWith(`..${path2.sep}`) && relative !== ".." && !path2.isAbsolute(relative);
 }
-// ../readseek-api/src/json.ts
-var READSEEK_USAGE_HINT = /\n\s*Run readseek(?: [\w-]+)* --help for more information\.?\s*$/;
+// ../readseek-api/src/error.ts
+var READSEEK_USAGE_HINT = /(?:^|\n)\s*Run readseek(?: [\w-]+)* --help for more information\.?\s*$/;
 function cleanReadSeekErrorText(stderr) {
   return stderr.replace(READSEEK_USAGE_HINT, "").replace(/^error:\s*/i, "").replace(/\s*\n\s*/g, " ").trim();
 }
-function parseReadSeekJson(stdout) {
-  try {
-    return JSON.parse(stdout);
-  } catch {
-    const preview = stdout.trim().slice(0, 200);
-    throw new Error(`readseek returned invalid JSON: ${preview}`);
+// ../readseek-api/src/kdl.ts
+import { parse } from "@bgotink/kdl";
+function convertNode(node) {
+  if (node.getTag() !== null)
+    throw new Error("KDL node annotations are not supported");
+  const properties = new Map;
+  for (const entry of node.entries) {
+    const name = entry.getName();
+    if (name === null)
+      throw new Error("KDL positional arguments are not supported");
+    if (properties.has(name))
+      throw new Error(`KDL duplicate property '${name}'`);
+    if (entry.getTag() !== null)
+      throw new Error("KDL value annotations are not supported");
+    const value = entry.getValue();
+    if (value === null)
+      throw new Error("KDL null values are not supported");
+    if (typeof value === "number" && !Number.isFinite(value)) {
+      throw new Error("KDL number out of range");
+    }
+    properties.set(name, value);
+  }
+  return {
+    name: node.getName(),
+    properties,
+    children: node.children?.nodes.map(convertNode) ?? []
+  };
+}
+function parseKdlDocument(text) {
+  const document = parse(text);
+  if (document.nodes.length !== 1)
+    throw new Error("KDL document must contain exactly one root node");
+  return convertNode(document.nodes[0]);
+}
+
+// ../readseek-api/src/output-kdl.ts
+function properties(node) {
+  return Object.fromEntries(node.properties);
+}
+function children(node, name) {
+  return node.children.filter((child) => child.name === name);
+}
+function child(node, name) {
+  return node.children.find((candidate) => candidate.name === name);
+}
+function requireProperty(node, name) {
+  const value = node.properties.get(name);
+  if (value === undefined)
+    throw new Error(`invalid readseek KDL: ${node.name} is missing '${name}'`);
+  return value;
+}
+function line(node) {
+  const anchor = requireProperty(node, "anchor");
+  const content = requireProperty(node, "content");
+  if (typeof anchor !== "string" || typeof content !== "string") {
+    throw new Error("invalid readseek KDL line");
+  }
+  const match = /^(\d+):([0-9a-f]+)$/.exec(anchor);
+  if (!match)
+    throw new Error(`invalid readseek KDL line anchor: ${anchor}`);
+  return {
+    line: Number(match[1]),
+    hash: match[2],
+    text: content
+  };
+}
+function mapNode(node) {
+  return {
+    ...properties(node),
+    children: children(node, "node").map(mapNode)
+  };
+}
+function sourceContent(node) {
+  const result = properties(node);
+  result.hashlines = children(node, "line").map(line);
+  const objects = children(node, "object");
+  if (objects.length > 0) {
+    result.objects = objects.map((object) => ({
+      label: requireProperty(object, "label"),
+      bbox: [
+        requireProperty(object, "xmin"),
+        requireProperty(object, "ymin"),
+        requireProperty(object, "xmax"),
+        requireProperty(object, "ymax")
+      ]
+    }));
+  }
+  return result;
+}
+function sourceMap(node) {
+  const root = child(node, "node");
+  return {
+    ...properties(node),
+    ...root ? { root: mapNode(root) } : {},
+    symbols: children(node, "symbol").map(properties)
+  };
+}
+function diagnostics(node) {
+  return {
+    ...properties(node),
+    diagnostics: children(node, "diagnostic").map(properties)
+  };
+}
+function identity(node) {
+  const result = properties(node);
+  const identifier = child(node, "identifier");
+  const symbol = child(node, "symbol");
+  if (identifier)
+    result.identifier = properties(identifier);
+  if (symbol)
+    result.symbol = properties(symbol);
+  return result;
+}
+function sourceDocument(root) {
+  const result = {};
+  const metadata = child(root, "metadata");
+  const cache = child(root, "cache");
+  const content = child(root, "content");
+  const map = child(root, "map");
+  const diagnosticOutput = child(root, "diagnostics");
+  const identityOutput = child(root, "identity");
+  if (metadata)
+    result.metadata = properties(metadata);
+  if (cache)
+    result.cache = properties(cache);
+  if (content)
+    result.content = sourceContent(content);
+  if (map)
+    result.map = sourceMap(map);
+  if (diagnosticOutput)
+    result.diagnostics = diagnostics(diagnosticOutput);
+  if (identityOutput)
+    result.identity = identity(identityOutput);
+  return result;
+}
+function hit(node) {
+  return {
+    ...properties(node),
+    hashlines: children(node, "line").map(line),
+    captures: children(node, "capture").map((capture) => ({
+      ...properties(capture),
+      hashlines: children(capture, "line").map(line)
+    }))
+  };
+}
+function search(root) {
+  return {
+    ...properties(root),
+    results: children(root, "match").map((match) => ({
+      ...properties(match),
+      matches: children(match, "hit").map(hit)
+    })),
+    documents: children(root, "document").map((documentNode) => ({
+      ...properties(documentNode),
+      hits: children(documentNode, "hit").map(properties)
+    }))
+  };
+}
+function references(root) {
+  const parsed = children(root, "reference").map((reference) => {
+    const sourceLine = child(reference, "line");
+    if (!sourceLine)
+      throw new Error("invalid readseek KDL reference: missing line");
+    const parsedLine = line(sourceLine);
+    const symbol = child(reference, "symbol");
+    return {
+      ...properties(reference),
+      line_hash: parsedLine.hash,
+      text: parsedLine.text,
+      ...symbol ? { symbol: properties(symbol) } : {}
+    };
+  });
+  return {
+    references: parsed,
+    locations: parsed.map((reference) => {
+      const { symbol, ...location } = reference;
+      return symbol && typeof symbol === "object" ? { ...location, ...symbol } : location;
+    })
+  };
+}
+function definitions(root) {
+  return {
+    locations: children(root, "definition").map((definition) => {
+      const symbol = child(definition, "symbol");
+      const sourceLine = child(definition, "line");
+      if (!symbol || !sourceLine) {
+        throw new Error("invalid readseek KDL definition: missing symbol or line");
+      }
+      const symbolProperties = properties(symbol);
+      const parsedLine = line(sourceLine);
+      const definitionColumn = definition.properties.get("column");
+      const nameByte = symbol.properties.get("name_byte");
+      const startByte = symbol.properties.get("start_byte");
+      let column = 1;
+      if (typeof definitionColumn === "number") {
+        column = definitionColumn;
+      } else if (typeof nameByte === "number" && typeof startByte === "number") {
+        column = nameByte - startByte + 1;
+      }
+      return {
+        file: requireProperty(definition, "file"),
+        line: parsedLine.line,
+        column,
+        line_hash: parsedLine.hash,
+        text: parsedLine.text,
+        kind: symbolProperties.kind,
+        name: symbolProperties.name,
+        qualified_name: symbolProperties.qualified_name
+      };
+    })
+  };
+}
+function edit(root) {
+  const result = properties(root);
+  for (const name of ["before_content", "content"]) {
+    const contentNode = child(root, name);
+    if (contentNode)
+      result[name] = requireProperty(contentNode, "content");
+  }
+  return result;
+}
+function renameEdit(node) {
+  const sourceLine = child(node, "line");
+  if (!sourceLine)
+    throw new Error("invalid readseek KDL rename edit: missing line");
+  return {
+    ...properties(node),
+    text: requireProperty(sourceLine, "content")
+  };
+}
+function renameFile(node) {
+  return {
+    ...properties(node),
+    edits: children(node, "edit").map(renameEdit),
+    conflicts: children(node, "conflict").map(properties)
+  };
+}
+function rename(root) {
+  return {
+    ...renameFile(root),
+    others: children(root, "other").map(renameFile)
+  };
+}
+function genericNode(node) {
+  const result = properties(node);
+  const textNode = child(node, "text");
+  const bbox = child(node, "bbox");
+  if (textNode)
+    result.text = requireProperty(textNode, "content");
+  if (bbox)
+    result.bbox = properties(bbox);
+  const objects = children(node, "object");
+  if (objects.length > 0)
+    result.objects = objects.map(genericNode);
+  return result;
+}
+function pdfDocument(root) {
+  return {
+    ...properties(root),
+    nodes: children(root, "node").map(genericNode),
+    assets: children(root, "asset").map(genericNode),
+    vision: children(root, "vision").map(genericNode)
+  };
+}
+function parseReadSeekKdl(text) {
+  const root = parseKdlDocument(text);
+  switch (root.name) {
+    case "document":
+      return root.properties.has("format") ? pdfDocument(root) : sourceDocument(root);
+    case "search":
+      return search(root);
+    case "check":
+      return diagnostics(root);
+    case "refs":
+      return references(root);
+    case "def":
+      return definitions(root);
+    case "edit":
+      return edit(root);
+    case "edit-batch":
+      return { ...properties(root), files: children(root, "file").map(edit) };
+    case "rename":
+      return rename(root);
+    default:
+      throw new Error(`unsupported readseek KDL root: ${root.name}`);
   }
 }
 // ../readseek-api/src/process.ts
 var DEFAULT_READSEEK_TIMEOUT_MS = 120000;
 var DEFAULT_MAX_OUTPUT_BYTES = 32 * 1024 * 1024;
+function readSeekProcessEnvironment() {
+  return process.platform === "linux" ? { ...process.env, APPIMAGE_EXTRACT_AND_RUN: "1" } : process.env;
+}
 function resolveProcessLimits(options = {}) {
   return {
     timeoutMs: options.timeoutMs ?? DEFAULT_READSEEK_TIMEOUT_MS,
@@ -901,8 +1294,8 @@ function ensureSuccessfulStdout(result) {
     return result.stdout;
   throw failureFromProcessResult(result);
 }
-function parseSuccessfulJson(result) {
-  return parseReadSeekJson(ensureSuccessfulStdout(result));
+function parseSuccessfulKdl(result) {
+  return parseReadSeekKdl(ensureSuccessfulStdout(result));
 }
 // ../readseek-api/src/process-bun.ts
 function getBunSpawn() {
@@ -952,7 +1345,7 @@ async function runReadSeekBun(binaryPath, args, options = {}) {
   const stdin = options.stdin === undefined ? undefined : new TextEncoder().encode(options.stdin);
   const spawnOptions = {
     cwd: options.cwd,
-    env: process.env,
+    env: readSeekProcessEnvironment(),
     stderr: "pipe",
     stdin,
     stdout: "pipe"
@@ -986,26 +1379,254 @@ async function runReadSeekBun(binaryPath, args, options = {}) {
   } finally {
     if (timeout !== undefined)
       clearTimeout(timeout);
+    pending.catch(() => {
+      return;
+    });
   }
 }
 async function runReadSeekBunText(binaryPath, args, options = {}) {
   return ensureSuccessfulStdout(await runReadSeekBun(binaryPath, args, options));
 }
-async function runReadSeekBunJson(binaryPath, args, options = {}) {
-  return parseSuccessfulJson(await runReadSeekBun(binaryPath, args, options));
-}
-// src/constants.ts
-var DEFAULT_VISION_TIMEOUT_MS = 30 * 60 * 1000;
-var DEFAULT_READ_LIMIT = 2000;
-var EDIT_RESULT_READ_LIMIT = 40;
-var MAX_DOCUMENT_OUTPUT_BYTES = 256 * 1024;
-var MAX_DOCUMENT_OUTPUT_LINES = 2000;
-var MAX_PERMISSION_DIFF_BYTES = 32 * 1024;
-var IMAGE_MODES = [...VISION_MODES];
-var VISION_ANALYSIS_MODE_VALUES = [...VISION_ANALYSIS_MODES];
-var VISION_LEVEL_VALUES = [...VISION_LEVELS];
-var DOCUMENT_NODE_KIND_VALUES = [...DOCUMENT_NODE_KINDS];
-
+async function runReadSeekBunKdl(binaryPath, args, options = {}) {
+  return parseSuccessfulKdl(await runReadSeekBun(binaryPath, args, options));
+}
+// ../readseek-api/src/client-output.ts
+import { Type } from "@sinclair/typebox";
+import { AssertError, Value } from "@sinclair/typebox/value";
+var Int = Type.Integer({ minimum: Number.MIN_SAFE_INTEGER, maximum: Number.MAX_SAFE_INTEGER });
+var Str = Type.String();
+var Bool = Type.Boolean();
+var OptStr = Type.Optional(Str);
+var OptInt = Type.Optional(Int);
+var Hashline = Type.Object({ line: Int, hash: Str, text: Str });
+var Hashlines = Type.Array(Hashline);
+var ReadOutput = Type.Object({
+  file: Str,
+  language: Str,
+  line_count: Int,
+  file_hash: Str,
+  start_line: Int,
+  end_line: Int,
+  hashlines: Hashlines
+});
+var SymbolOutput = Type.Object({
+  kind: Str,
+  name: Str,
+  qualified_name: OptStr,
+  start_line: Int,
+  end_line: Int,
+  start_hash: OptStr,
+  end_hash: OptStr,
+  start_anchor: OptStr,
+  end_anchor: OptStr
+});
+var MapNode = Type.Recursive((Self) => Type.Object({
+  kind: Str,
+  name: Str,
+  start_line: Int,
+  end_line: Int,
+  start_anchor: Str,
+  end_anchor: Str,
+  children: Type.Array(Self)
+}));
+var MapOutput = Type.Object({
+  file: Str,
+  language: Str,
+  line_count: Int,
+  file_hash: Str,
+  root: Type.Optional(MapNode),
+  symbols: Type.Array(SymbolOutput)
+});
+var SearchSpan = {
+  start_byte: OptInt,
+  end_byte: OptInt,
+  text: OptStr,
+  start_line: Int,
+  end_line: Int,
+  start_hash: Str,
+  end_hash: Str,
+  hashlines: Hashlines
+};
+var SearchCapture = Type.Object({ name: Str, ...SearchSpan });
+var SearchMatch = Type.Object({
+  pattern_index: Type.Integer({ default: 0 }),
+  ...SearchSpan,
+  captures: Type.Array(SearchCapture)
+});
+var SearchFileOutput = Type.Object({
+  file: Str,
+  language: Str,
+  file_hash: Str,
+  matches: Type.Array(SearchMatch)
+});
+var SearchEnvelope = Type.Object({
+  results: Type.Array(SearchFileOutput),
+  returned_matches: OptInt,
+  truncated: Type.Optional(Bool),
+  byte_basis: OptStr
+});
+var RefsEnvelope = Type.Object({
+  references: Type.Array(Type.Object({
+    file: Str,
+    line: Int,
+    column: Int,
+    line_hash: Str,
+    text: Str,
+    symbol: Type.Optional(Type.Object({ qualified_name: OptStr }))
+  }))
+});
+var Diagnostic = Type.Object({
+  kind: Type.Union([Type.Literal("error"), Type.Literal("missing")]),
+  start_line: Int,
+  end_line: Int
+});
+var CheckEnvelope = Type.Object({
+  file_hash: OptStr,
+  error_count: Int,
+  missing_count: Int,
+  diagnostics: Type.Array(Diagnostic)
+});
+var DetectedObject = Type.Object({
+  label: Str,
+  bbox: Type.Tuple([Int, Int, Int, Int])
+});
+var PreparedImage = Type.Object({
+  mime: Str,
+  encoding: Type.Literal("base64"),
+  data: Str
+});
+var SourceDetection = Type.Object({
+  kind: Type.Literal("source"),
+  type: Str,
+  file: Str,
+  language: Str,
+  engine: OptStr,
+  supported: Bool,
+  mime: OptStr,
+  syntax: OptStr
+});
+var ImageDetection = Type.Object({
+  kind: Type.Literal("image"),
+  type: Str,
+  file: Str,
+  mime: OptStr,
+  format: Str,
+  width: Int,
+  height: Int,
+  animated: Bool,
+  encoding: Type.Optional(Type.Literal("base64")),
+  data: OptStr,
+  ocr: OptStr,
+  caption: OptStr,
+  objects: Type.Optional(Type.Array(DetectedObject))
+});
+var TextDetection = Type.Object({
+  kind: Type.Literal("text"),
+  type: Str,
+  file: Str,
+  mime: OptStr
+});
+var PdfDetection = Type.Object({
+  kind: Type.Literal("pdf"),
+  type: Type.Literal("application/pdf"),
+  file: Str,
+  mime: OptStr,
+  format: Type.Literal("pdf"),
+  pages: Int
+});
+var Detection = Type.Union([SourceDetection, ImageDetection, TextDetection, PdfDetection]);
+var SourceDetectionInput = Type.Omit(SourceDetection, ["kind"]);
+var ImageDetectionInput = Type.Omit(ImageDetection, ["kind"]);
+var TextDetectionInput = Type.Omit(TextDetection, ["kind"]);
+var PdfDetectionInput = Type.Omit(PdfDetection, ["kind"]);
+var UnspannedContent = Type.Omit(ReadOutput, ["start_line", "end_line"]);
+var PdfInspectMetadata = Type.Object({ source: Str, format: Type.Literal("pdf"), pages: Int });
+var DocumentCache = Type.Object({
+  content_hash: Str,
+  state: Type.Union([Type.Literal("built"), Type.Literal("reused")])
+});
+var Identifier = Type.Object({
+  text: Str,
+  start_column: Int,
+  end_column: Int,
+  start_byte: Int,
+  end_byte: Int
+});
+var IdentifyEnvelope = Type.Object({
+  file: Str,
+  language: Str,
+  engine: OptStr,
+  line_count: Int,
+  file_hash: Str,
+  line: Int,
+  column: Int,
+  line_hash: Str,
+  identifier: Type.Optional(Identifier),
+  symbol: Type.Optional(Type.Object({
+    name: Str,
+    kind: Str,
+    qualified_name: Str,
+    start_line: Int,
+    end_line: Int
+  }))
+});
+var EditOutputSchema = Type.Object({
+  file: Str,
+  before_hash: Str,
+  file_hash: Str,
+  plan_hash: Str,
+  applied: Bool,
+  changed: Bool,
+  edit_count: Int,
+  before_content: OptStr,
+  content: OptStr
+});
+var RenameConflictSchema = Type.Object({ line: Int, column: Int, reason: Str });
+var RenameEditSchema = Type.Object({
+  line: Int,
+  start_column: Int,
+  end_column: Int,
+  start_byte: Int,
+  end_byte: Int,
+  occurrence: Str,
+  line_hash: Str,
+  text: Str
+});
+var Conflicts = Type.Array(RenameConflictSchema, { default: [] });
+var Edits = Type.Array(RenameEditSchema, { default: [] });
+var RenameFileOutputSchema = Type.Object({
+  file: Str,
+  language: Str,
+  engine: OptStr,
+  file_hash: Str,
+  conflicts: Conflicts,
+  edits: Edits
+});
+var RenameOutputSchema = Type.Object({
+  file: Str,
+  language: Str,
+  engine: OptStr,
+  file_hash: Str,
+  old_name: Str,
+  new_name: Str,
+  plan_hash: Str,
+  applied: Bool,
+  conflicts: Conflicts,
+  edits: Edits,
+  others: Type.Array(RenameFileOutputSchema, { default: [] })
+});
+var DefEnvelope = Type.Object({
+  locations: Type.Array(Type.Object({
+    file: Str,
+    line: Int,
+    column: Int,
+    line_hash: Str,
+    text: Str,
+    kind: OptStr,
+    name: OptStr,
+    qualified_name: OptStr
+  }))
+});
 // src/util.ts
 import path3 from "node:path";
 function render(value) {
@@ -1041,15 +1662,17 @@ function collectAnchoredFiles(value, files) {
   for (const item of Object.values(output))
     collectAnchoredFiles(item, files);
 }
-function renameFiles(value) {
+function renameFiles(value, directory = process.cwd()) {
   const output = record(value);
   const files = [];
-  if (typeof output.file === "string" && items(output.edits).length > 0)
-    files.push(path3.resolve(output.file));
+  if (typeof output.file === "string" && items(output.edits).length > 0) {
+    files.push(path3.resolve(directory, output.file));
+  }
   for (const other of items(output.others)) {
     const item = record(other);
-    if (typeof item.file === "string" && items(item.edits).length > 0)
-      files.push(path3.resolve(item.file));
+    if (typeof item.file === "string" && items(item.edits).length > 0) {
+      files.push(path3.resolve(directory, item.file));
+    }
   }
   return files;
 }
@@ -1099,25 +1722,21 @@ function resolveImagePolicy(options) {
     return value;
   throw new Error('opencode-readseek imageMode must be "on", "auto", or "off"');
 }
-function digestArgs(filePath, select, extra = []) {
-  return [...buildDigestArgs({ path: filePath, select }), ...extra];
+function inspectArgs(filePath, select, options = {}) {
+  return buildInspectArgs({ path: filePath, select, ...options });
 }
-function requireDigestFacet(envelope, facet) {
+function requireInspectFacet(envelope, facet) {
   const value = record(envelope)[facet];
   if (value === undefined || value === null || typeof value !== "object") {
-    throw new Error(`digest returned no ${facet} facet`);
+    throw new Error(`inspect returned no ${facet} facet`);
   }
   return value;
 }
-function withAt(args, line, column) {
-  args.push("--at", buildLineLocation(line, column));
-}
 function readRangeArgs(filePath, start, end) {
-  const extra = [];
-  if (start > 1)
-    withAt(extra, start);
-  extra.push("--end", String(end));
-  return digestArgs(filePath, "content", extra);
+  return inspectArgs(filePath, "content", {
+    selector: start > 1 ? `line:${start}` : undefined,
+    end
+  });
 }
 function readSeekBinaryPath() {
   return resolveReadSeekBinaryOverride() ?? resolveReadSeekBinaryFromPackages(resolveFromHost);
@@ -1146,7 +1765,7 @@ async function runReadSeekRaw(context, args, options = {}) {
 }
 async function runReadSeek(context, args, options = {}) {
   context.abort.throwIfAborted();
-  return preserveAbortReason(context.abort, options.cancelable !== false, () => runReadSeekBunJson(readSeekBinaryPath(), args, {
+  return preserveAbortReason(context.abort, options.cancelable !== false, () => runReadSeekBunKdl(readSeekBinaryPath(), args, {
     cwd: context.directory,
     signal: context.abort,
     cancelable: options.cancelable,
@@ -1154,12 +1773,12 @@ async function runReadSeek(context, args, options = {}) {
     timeoutMs: options.timeoutMs
   }));
 }
-async function runDigestContent(context, args, options = {}) {
-  return requireDigestFacet(await runReadSeek(context, args, options), "content");
+async function runInspectContent(context, args, options = {}) {
+  return requireInspectFacet(await runReadSeek(context, args, options), "content");
 }
 async function postMutationPreview(context, args, filePath, changed) {
   try {
-    return await runDigestContent(context, args, {
+    return await runInspectContent(context, args, {
       cancelable: false,
       timeoutMs: DEFAULT_READSEEK_TIMEOUT_MS
     });
@@ -1188,21 +1807,11 @@ async function ensureReadSeekCache(context) {
     if (error.code !== "ENOENT")
       throw error;
   }
-  readSeekCacheInit ??= runReadSeekRaw(context, ["--readseek-dir", cacheDir, "init"]).then(() => cacheDir).finally(() => {
+  readSeekCacheInit ??= runReadSeekRaw(context, ["--readseek-dir", cacheDir, "init"], { cancelable: false }).then(() => cacheDir).finally(() => {
     readSeekCacheInit = undefined;
   });
   return readSeekCacheInit;
 }
-function boundDocumentOutput(value) {
-  const lines = value.split(`
-`);
-  let output = lines.length > MAX_DOCUMENT_OUTPUT_LINES ? lines.slice(0, MAX_DOCUMENT_OUTPUT_LINES).join(`
-`) : value;
-  const truncated = output !== value || Buffer.byteLength(output, "utf8") > MAX_DOCUMENT_OUTPUT_BYTES;
-  output = utf8Prefix(output, MAX_DOCUMENT_OUTPUT_BYTES);
-  return truncated ? `${output}
-[… document view truncated; narrow it with page, node, kind, or depth]` : output;
-}
 
 // src/policy.ts
 var OPENCODE_TOOL_ALIASES = Object.fromEntries(TOOL_NAMES.map((name) => [name, `readseek_${name}`]));
@@ -1247,12 +1856,12 @@ class SessionAnchors {
   planRename(sessionID, output) {
     if (!output || typeof output !== "object")
       return;
-    const record2 = output;
-    if (record2.applied === true) {
+    const record = output;
+    if (record.applied === true) {
       this.#renamePlans.delete(sessionID);
       return;
     }
-    const { file, old_name: oldName, new_name: newName, others } = record2;
+    const { file, old_name: oldName, new_name: newName, others } = record;
     if (typeof file !== "string" || typeof oldName !== "string" || typeof newName !== "string")
       return;
     const files = new Set([path4.resolve(file)]);
@@ -1290,6 +1899,14 @@ ${[...paths].sort().map((filePath) => `- ${filePath}`).join(`
 import { readFile as readFile2, stat as stat3 } from "node:fs/promises";
 import { tool as tool2 } from "@opencode-ai/plugin";
 
+// src/constants.ts
+var DEFAULT_VISION_TIMEOUT_MS = 30 * 60 * 1000;
+var DEFAULT_READ_LIMIT = 2000;
+var EDIT_RESULT_READ_LIMIT = 40;
+var MAX_PERMISSION_DIFF_BYTES = 32 * 1024;
+var IMAGE_MODES = [...VISION_MODES];
+var VISION_LEVEL_VALUES = [...VISION_LEVELS];
+
 // src/edits.ts
 import { lstat, mkdir, open, readFile } from "node:fs/promises";
 import path5 from "node:path";
@@ -1352,9 +1969,9 @@ async function writeHandle(handle, content) {
 async function writeText(filePath, expected, content) {
   await mkdir(path5.dirname(filePath), { recursive: true });
   if (!expected.exists) {
-    let handle2;
+    let handle;
     try {
-      handle2 = await open(filePath, "wx+");
+      handle = await open(filePath, "wx+");
     } catch (error) {
       if (error.code === "EEXIST") {
         throw new Error(`refusing to overwrite changed file: ${filePath}`);
@@ -1362,9 +1979,9 @@ async function writeText(filePath, expected, content) {
       throw error;
     }
     try {
-      await writeHandle(handle2, content);
+      await writeHandle(handle, content);
     } finally {
-      await handle2.close();
+      await handle.close();
     }
     return;
   }
@@ -1608,10 +2225,10 @@ async function authorizeEdit(context, filePaths, diff = "", authorizeExternalPat
 import { tool } from "@opencode-ai/plugin";
 function initialTitle(kind, args) {
   switch (kind) {
-    case "view":
-      return `View ${args.path}`;
-    case "digest":
-      return `Digest ${args.path}`;
+    case "inspect":
+      return `Inspect ${args.path}`;
+    case "extract":
+      return `Extract ${args.selector} to ${args.output}`;
     case "search":
       return `Search ${args.pattern}`;
     case "grep":
@@ -1631,9 +2248,9 @@ function initialTitle(kind, args) {
 function resultPresentation(kind, args, value) {
   const output = record(value);
   switch (kind) {
-    case "view":
-      return { title: `Viewed ${args.path}`, metadata: {} };
-    case "digest": {
+    case "extract":
+      return { title: `Extracted ${args.selector} to ${args.output}`, metadata: {} };
+    case "inspect": {
       const map = record(output.map);
       const diagnostics = record(output.diagnostics);
       const identity = record(output.identity);
@@ -1666,7 +2283,7 @@ function resultPresentation(kind, args, value) {
       if (typeof content.end_line === "number")
         metadata.end_line = content.end_line;
       return {
-        title: summary.length > 0 ? `Digested ${args.path} (${summary.join(", ")})` : `Digested ${args.path}`,
+        title: summary.length > 0 ? `Inspected ${args.path} (${summary.join(", ")})` : `Inspected ${args.path}`,
         metadata
       };
     }
@@ -1706,18 +2323,18 @@ function resultPresentation(kind, args, value) {
   }
   return { title: initialTitle(kind, args), metadata: {} };
 }
-function readseekTool(description, args, kind, execute, formatResult = (result) => ({ output: render(result) })) {
+function readseekTool(description, args, kind, execute) {
   return tool({
     description,
     args,
-    async execute(args2, context) {
-      const title = initialTitle(kind, args2);
+    async execute(args, context) {
+      const title = initialTitle(kind, args);
       context.metadata({ title });
-      const result = await execute(args2, context);
-      const presentation = resultPresentation(kind, args2, result);
+      const result = await execute(args, context);
+      const presentation = resultPresentation(kind, args, result);
       return {
         title: presentation.title,
-        ...formatResult(result),
+        output: render(result),
         metadata: presentation.metadata
       };
     }
@@ -1727,52 +2344,18 @@ function readseekTool(description, args, kind, execute, formatResult = (result)
 // src/tools.ts
 function createReadSeekTools(imagePolicy) {
   return {
-    readseek_view: readseekTool(openCodeToolDescription("view"), {
-      path: tool2.schema.string().describe(PARAM_DESCRIPTIONS.projectPath),
-      node: tool2.schema.string().min(1).optional().describe(PARAM_DESCRIPTIONS.node),
-      page: tool2.schema.number().int().positive().optional().describe(PARAM_DESCRIPTIONS.page),
-      kind: tool2.schema.enum(DOCUMENT_NODE_KIND_VALUES).optional().describe(PARAM_DESCRIPTIONS.kind),
-      depth: tool2.schema.number().int().nonnegative().optional().describe(PARAM_DESCRIPTIONS.depth),
-      outline: tool2.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.outline),
-      visionMode: tool2.schema.enum(VISION_ANALYSIS_MODE_VALUES).optional().describe(PARAM_DESCRIPTIONS.visionModeView),
-      visionLevel: tool2.schema.enum(VISION_LEVEL_VALUES).optional().describe(PARAM_DESCRIPTIONS.visionLevel)
-    }, "view", async (input, context) => {
-      const filePath = resolvePath(context.directory, input.path);
-      await authorizeRead(context, filePath);
-      const visionMode = input.visionMode;
-      const visionLevel = input.visionLevel;
-      const vision = validateVisionLevelVsMode({
-        visionMode,
-        visionLevel,
-        outline: input.outline
-      });
-      if (!vision.ok)
-        throw new Error(vision.error);
-      const cacheDir = await ensureReadSeekCache(context);
-      const args = buildViewArgs({
-        path: filePath,
-        node: input.node,
-        page: input.page,
-        kind: input.kind,
-        depth: input.depth,
-        outline: input.outline,
-        visionMode,
-        visionLevel,
-        readseekDir: cacheDir
-      });
-      return runReadSeekRaw(context, args, visionMode === undefined ? {} : { timeoutMs: DEFAULT_VISION_TIMEOUT_MS });
-    }, (result) => ({ output: boundDocumentOutput(String(result)) })),
-    readseek_digest: readseekTool(openCodeToolDescription("digest"), {
+    readseek_inspect: readseekTool(openCodeToolDescription("inspect"), {
       path: tool2.schema.string().describe(PARAM_DESCRIPTIONS.projectPath),
+      selector: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.selector),
       select: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.selectComma),
-      at: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.at),
+      query: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.query),
       end: tool2.schema.number().int().positive().optional().describe(PARAM_DESCRIPTIONS.end),
       limit: tool2.schema.number().int().positive().optional().describe(PARAM_DESCRIPTIONS.limit),
-      depth: tool2.schema.number().int().nonnegative().optional().describe(PARAM_DESCRIPTIONS.digestDepth),
+      depth: tool2.schema.number().int().nonnegative().optional().describe(PARAM_DESCRIPTIONS.inspectDepth),
       language: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.languageOverride),
-      visionMode: tool2.schema.enum(IMAGE_MODES).optional().describe(PARAM_DESCRIPTIONS.visionModeDigest),
+      visionMode: tool2.schema.enum(IMAGE_MODES).optional().describe(PARAM_DESCRIPTIONS.visionModeInspect),
       visionLevel: tool2.schema.enum(VISION_LEVEL_VALUES).optional().describe(PARAM_DESCRIPTIONS.visionLevel)
-    }, "digest", async (input, context) => {
+    }, "inspect", async (input, context) => {
       const filePath = resolvePath(context.directory, input.path);
       await authorizeRead(context, filePath);
       const select = (input.select ?? "content").trim() || "content";
@@ -1782,13 +2365,14 @@ function createReadSeekTools(imagePolicy) {
       if (!vision.ok)
         throw new Error(vision.error);
       const cacheDir = await ensureReadSeekCache(context);
-      const args = buildDigestArgs({
+      const args = buildInspectArgs({
         path: filePath,
+        selector: input.selector,
         select,
-        at: input.at,
+        query: input.query,
         end: input.end,
         limit: input.limit,
-        depth: input.depth ?? (select.split(",").some((facet) => facet.trim() === "map") ? DEFAULT_DIGEST_MAP_DEPTH : undefined),
+        depth: input.depth ?? (select.split(",").some((facet) => facet.trim() === "map") ? DEFAULT_INSPECT_MAP_DEPTH : undefined),
         language: input.language,
         visionMode,
         visionLevel,
@@ -1796,6 +2380,37 @@ function createReadSeekTools(imagePolicy) {
       });
       return runReadSeek(context, args, visionMode === undefined || visionMode === "none" ? {} : { timeoutMs: DEFAULT_VISION_TIMEOUT_MS });
     }),
+    readseek_extract: readseekTool(openCodeToolDescription("extract"), {
+      path: tool2.schema.string().describe(PARAM_DESCRIPTIONS.projectPath),
+      selector: tool2.schema.string().min(1).describe(PARAM_DESCRIPTIONS.assetSelector),
+      output: tool2.schema.string().min(1).describe(PARAM_DESCRIPTIONS.output)
+    }, "extract", async (input, context) => {
+      const selector = String(input.selector ?? "").trim();
+      const output = String(input.output ?? "").trim();
+      if (!selector.startsWith("asset:") || selector === "asset:") {
+        throw new Error("extract requires an asset: selector");
+      }
+      if (!output || output === "-")
+        throw new Error("extract output must be a file path");
+      const filePath = resolvePath(context.directory, input.path);
+      const outputPath = resolvePath(context.directory, output);
+      await authorizeRead(context, filePath);
+      await rejectSymlinkMutation(outputPath);
+      await authorizeEdit(context, [outputPath]);
+      const cacheDir = await ensureReadSeekCache(context);
+      await runReadSeekRaw(context, buildExtractArgs({
+        path: filePath,
+        selector,
+        output: outputPath,
+        readseekDir: cacheDir
+      }), { cancelable: false, timeoutMs: 120000 });
+      return {
+        file: filePath,
+        selector,
+        output: outputPath,
+        changed: true
+      };
+    }),
     readseek_grep: readseekTool(openCodeToolDescription("grep"), {
       pattern: tool2.schema.string().describe(PARAM_DESCRIPTIONS.grepPattern),
       path: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.projectSearchPath),
@@ -1868,7 +2483,7 @@ function createReadSeekTools(imagePolicy) {
         }
         const linesByNumber = new Map;
         for (const [start, end] of mergedRanges) {
-          const output = record(await runDigestContent(context, readRangeArgs(filePath, start, end)));
+          const output = record(await runInspectContent(context, readRangeArgs(filePath, start, end)));
           for (const hashline of items(output.hashlines)) {
             const line = record(hashline).line;
             if (typeof line === "number" && !linesByNumber.has(line))
@@ -1888,18 +2503,14 @@ function createReadSeekTools(imagePolicy) {
       pattern: tool2.schema.string().describe(PARAM_DESCRIPTIONS.pattern),
       path: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.projectSearchPath),
       language: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.language),
-      cached: tool2.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.cached),
-      others: tool2.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.others),
-      ignored: tool2.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.ignored)
+      gitScope: tool2.schema.enum(GIT_SCOPES).optional().describe(PARAM_DESCRIPTIONS.gitScope)
     }, "search", async (input, context) => {
       const target = resolvePath(context.directory, input.path ?? ".");
       const args = buildSearchArgs({
         path: target,
         pattern: input.pattern,
         language: input.language,
-        cached: input.cached,
-        others: input.others,
-        ignored: input.ignored
+        gitScope: input.gitScope
       });
       await authorizeSearch(context, target, input.pattern);
       return runReadSeek(context, args);
@@ -1908,19 +2519,14 @@ function createReadSeekTools(imagePolicy) {
       name: tool2.schema.string().describe(PARAM_DESCRIPTIONS.name),
       path: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.projectSearchPath),
       language: tool2.schema.string().optional().describe(PARAM_DESCRIPTIONS.language),
-      cached: tool2.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.cached),
-      others: tool2.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.others),
-      ignored: tool2.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.ignored)
+      gitScope: tool2.schema.enum(GIT_SCOPES).optional().describe(PARAM_DESCRIPTIONS.gitScope)
     }, "def", async (input, context) => {
       const target = resolvePath(context.directory, input.path ?? ".");
       const args = buildDefArgs({
         path: target,
         name: input.name,
         language: input.language,
-        format: "plain",
-        cached: input.cached,
-        others: input.others,
-        ignored: input.ignored
+        gitScope: input.gitScope
       });
       await authorizeSearch(context, target, input.name);
       return runReadSeek(context, args);
@@ -1932,9 +2538,7 @@ function createReadSeekTools(imagePolicy) {
       scope: tool2.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.scope),
       line: tool2.schema.number().int().positive().optional().describe(PARAM_DESCRIPTIONS.line),
       column: tool2.schema.number().int().positive().optional().describe(PARAM_DESCRIPTIONS.column),
-      cached: tool2.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.cached),
-      others: tool2.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.others),
-      ignored: tool2.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.ignored)
+      gitScope: tool2.schema.enum(GIT_SCOPES).optional().describe(PARAM_DESCRIPTIONS.gitScope)
     }, "refs", async (input, context) => {
       const target = resolvePath(context.directory, input.path ?? ".");
       const name = input.name;
@@ -1945,9 +2549,7 @@ function createReadSeekTools(imagePolicy) {
         line: input.line,
         column: input.column,
         language: input.language,
-        cached: input.cached,
-        others: input.others,
-        ignored: input.ignored
+        gitScope: input.gitScope
       });
       await authorizeSearch(context, target, name ?? "*");
       return runReadSeek(context, args);
@@ -1963,10 +2565,12 @@ function createReadSeekTools(imagePolicy) {
       const filePath = resolvePath(context.directory, input.path);
       await authorizeRead(context, filePath);
       if (input.workspace) {
-        const identifyArgs = digestArgs(filePath, "identity");
-        withAt(identifyArgs, input.line, input.column);
+        const column = input.column;
+        const identifyArgs = inspectArgs(filePath, "identity", {
+          selector: `line:${input.line}${column === undefined ? "" : `:${column}`}`
+        });
         const envelope = await runReadSeek(context, identifyArgs);
-        const name = identifiedName(requireDigestFacet(envelope, "identity"));
+        const name = identifiedName(requireInspectFacet(envelope, "identity"));
         if (!name)
           throw new Error("readseek could not identify a binding at the rename cursor");
         await authorizeSearch(context, context.directory, name);
@@ -1981,7 +2585,7 @@ function createReadSeekTools(imagePolicy) {
       const plan = await runReadSeek(context, args);
       if (input.apply === false)
         return plan;
-      const files = renameFiles(plan);
+      const files = renameFiles(plan, context.directory);
       const planHash = record(plan).plan_hash;
       if (typeof planHash !== "string" || planHash.length === 0) {
         throw new Error("readseek rename plan did not include a plan hash");
@@ -2045,7 +2649,7 @@ function createReadSeekTools(imagePolicy) {
         await authorizeRead(context, filePath);
         await rejectSymlinkMutation(filePath);
         const edits = input.edits;
-        const request = JSON.stringify({ edits });
+        const request = serializeEditPlan(edits);
         const baseArgs = buildEditArgs({
           path: filePath,
           language: input.language,
@@ -2097,19 +2701,53 @@ function createReadSeekTools(imagePolicy) {
         await authorizeEdit(context, [filePath], simpleDiff(filePath, before.content, content), false);
         context.abort.throwIfAborted();
         await writeText(filePath, before, content);
-        return postMutationPreview(context, digestArgs(filePath, "content", ["--end", String(DEFAULT_READ_LIMIT)]), filePath, !before.exists || before.content !== content);
+        return postMutationPreview(context, inspectArgs(filePath, "content", { end: DEFAULT_READ_LIMIT }), filePath, !before.exists || before.content !== content);
       });
     })
   };
 }
 
+// v2.ts
+import { define } from "@opencode-ai/plugin/v2/promise";
+var GUIDANCE = "For structural code navigation, consult the readseek skill when ReadSeek tools are unavailable and the readseek CLI is installed.";
+var ReadSeekV2Plugin = define({
+  id: "opencode-readseek",
+  setup: async (ctx) => {
+    await ctx.skill.transform((draft) => {
+      draft.source({
+        type: "embedded",
+        skill: {
+          name: "readseek",
+          description: "Use for structural code navigation and anchored edits when the readseek CLI is installed.",
+          location: "/plugin/opencode-readseek/SKILL.md",
+          content: `# ReadSeek CLI
+
+When ReadSeek tools are unavailable, use the readseek CLI for structural navigation and anchored edits if it is installed and available on PATH. Run \`readseek --help\` to inspect supported commands before invoking them. Get fresh anchors before editing; re-read after external file changes.
+
+This V2 plugin supplies guidance only; it does not register readseek_* tools. If the CLI is unavailable, use OpenCode's built-in tools instead.`
+        }
+      });
+    });
+    await ctx.agent.transform((draft) => {
+      for (const agent of draft.list()) {
+        draft.update(agent.id, (item) => {
+          if (!item.system?.includes(GUIDANCE))
+            item.system = [item.system, GUIDANCE].filter(Boolean).join(`
+
+`);
+        });
+      }
+    });
+  }
+});
+
 // index.ts
 var ReadSeekPlugin = async (_input, options) => {
   const anchors = new SessionAnchors;
   const imagePolicy = resolveImagePolicy(options);
   return {
     tool: createReadSeekTools(imagePolicy),
-    "experimental.chat.system.transform": async (_input2, output) => {
+    "experimental.chat.system.transform": async (_input, output) => {
       output.system.push(TOOL_POLICY);
     },
     "tool.definition": async (input, output) => {
@@ -2155,8 +2793,8 @@ var ReadSeekPlugin = async (_input, options) => {
     }
   };
 };
-var opencode_readseek_default = { id: "opencode-readseek", server: ReadSeekPlugin };
+var opencode_readseek_default = { ...ReadSeekV2Plugin, server: ReadSeekPlugin };
 export {
-  opencode_readseek_default as default,
-  ReadSeekPlugin
+  ReadSeekPlugin,
+  opencode_readseek_default as default
 };