opencode-readseek 0.9.4 → 0.9.6

package/dist/index.js

@@ -0,0 +1,1962 @@
+// index.ts
+import { lstat, mkdir, open, readFile, readlink, realpath, stat } from "node:fs/promises";
+import { createRequire as createRequire2 } from "node:module";
+import { homedir } from "node:os";
+import path2 from "node:path";
+import { tool } from "@opencode-ai/plugin";
+
+// ../readseek-api/src/contract.ts
+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 TOOL_NAMES = [
+  "digest",
+  "edit",
+  "write",
+  "grep",
+  "view",
+  "search",
+  "def",
+  "refs",
+  "rename"
+];
+var PARAM_DESCRIPTIONS = {
+  path: "Absolute or relative file path",
+  searchPath: "File or directory to search; defaults to the current directory",
+  language: "Language override when auto-detection is ambiguous",
+  languageOverride: "Language override",
+  languageSymbol: "Language override for symbol replacement",
+  pattern: "AST pattern (ast-grep style), such as console.log($$$ARGS)",
+  grepPattern: "Regex pattern; set literal for exact text",
+  name: "Qualified or unqualified symbol name",
+  refsName: "Identifier to find references for",
+  scope: "Restrict results to the binding at the cursor",
+  line: "One-based cursor line; required with scope",
+  renameLine: "One-based cursor line of the symbol to rename",
+  column: "One-based cursor byte column for disambiguation",
+  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",
+  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",
+  end: "Last line to include",
+  limit: "Maximum number of lines to include",
+  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",
+  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",
+  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":"..."}}',
+  replaceLines: 'Replace a range: {"replace_lines":{"start_anchor":"LINE:HASH","end_anchor":"LINE:HASH","new_text":"..."}}',
+  insertAfter: 'Insert text: {"insert_after":{"anchor":"LINE:HASH","new_text":"..."}}',
+  replace: 'Replace text: {"replace":{"old_text":"...","new_text":"..."}}',
+  replaceSymbol: 'Replace a symbol: {"replace_symbol":{"symbol":"name","new_body":"..."}}',
+  anchor: "Fresh LINE:HASH anchor for the line to replace",
+  startAnchor: "Fresh LINE:HASH anchor for the first line in the range",
+  endAnchor: "Fresh LINE:HASH anchor for the last line in the range",
+  insertAnchor: "Fresh LINE:HASH anchor for the line after which to insert",
+  newTextLine: "Replacement text; use an empty string to delete the line",
+  newTextRange: "Replacement text; use an empty string to delete the range",
+  newTextInsert: "Text to insert after the anchored line",
+  oldText: "Exact text to find",
+  newText: "Replacement text",
+  all: "Replace every exact match",
+  symbol: "Mapped symbol name",
+  newBody: "Complete replacement body for the symbol",
+  apply: "When supported by the host, apply the verified plan instead of previewing only",
+  planHash: "Require the apply plan to match this dry-run plan hash",
+  workspace: "Rename across the project",
+  to: "New symbol name",
+  postEditVerify: "Read back and verify persisted content",
+  content: "Complete text file content",
+  glob: "File-name glob, such as *.ts",
+  ignoreCase: "Ignore case",
+  literal: "Treat pattern literally",
+  context: "Surrounding lines for each match",
+  matchLimit: "Maximum matches to return",
+  summary: "Return per-file counts",
+  grepScope: "Group matches by enclosing symbol",
+  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 for structural maps, diagnostics, and cursor identity.",
+  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.",
+  search: "Search code by AST structure using ast-grep-style patterns. Results include line hashes usable as `LINE:HASH` anchors. Use `grep` for identifiers, strings, comments, configuration, documentation, or other plain text and regex.",
+  def: "Go to a symbol definition or declaration by name. Accepts qualified or unqualified names; use this instead of text search for functions, methods, classes, types, and other declarations.",
+  refs: "Find references or usages of an identifier by name or cursor binding. Results include enclosing symbols and line hashes usable as `LINE:HASH` anchors. Without cursor scope, results are identifier-name matches; with scope, they follow one binding and exclude shadows. Use text search for literals, and use this before renaming or deleting a symbol.",
+  rename: "Rename a symbol at a source location. Resolvable same-named bindings are preserved; verified edits apply by default. Set `apply: false` to preview the plan before changing files."
+};
+function renderToolDescription(name, aliases = {}) {
+  const desc = TOOL_DESCRIPTIONS[name];
+  if (!desc)
+    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 editItemSchema = {
+  type: "object",
+  additionalProperties: false,
+  minProperties: 1,
+  maxProperties: 1,
+  properties: {
+    set_line: {
+      type: "object",
+      additionalProperties: false,
+      required: ["anchor", "new_text"],
+      properties: {
+        anchor: { type: "string", description: PARAM_DESCRIPTIONS.anchor },
+        new_text: { type: "string", description: PARAM_DESCRIPTIONS.newTextLine }
+      },
+      description: PARAM_DESCRIPTIONS.setLine
+    },
+    replace_lines: {
+      type: "object",
+      additionalProperties: false,
+      required: ["start_anchor", "end_anchor", "new_text"],
+      properties: {
+        start_anchor: { type: "string", description: PARAM_DESCRIPTIONS.startAnchor },
+        end_anchor: { type: "string", description: PARAM_DESCRIPTIONS.endAnchor },
+        new_text: { type: "string", description: PARAM_DESCRIPTIONS.newTextRange }
+      },
+      description: PARAM_DESCRIPTIONS.replaceLines
+    },
+    insert_after: {
+      type: "object",
+      additionalProperties: false,
+      required: ["anchor", "new_text"],
+      properties: {
+        anchor: { type: "string", description: PARAM_DESCRIPTIONS.insertAnchor },
+        new_text: { type: "string", description: PARAM_DESCRIPTIONS.newTextInsert }
+      },
+      description: PARAM_DESCRIPTIONS.insertAfter
+    },
+    replace: {
+      type: "object",
+      additionalProperties: false,
+      required: ["old_text", "new_text"],
+      properties: {
+        old_text: { type: "string", description: PARAM_DESCRIPTIONS.oldText },
+        new_text: { type: "string", description: PARAM_DESCRIPTIONS.newText },
+        all: { type: "boolean", description: PARAM_DESCRIPTIONS.all }
+      },
+      description: PARAM_DESCRIPTIONS.replace
+    },
+    replace_symbol: {
+      type: "object",
+      additionalProperties: false,
+      required: ["symbol", "new_body"],
+      properties: {
+        symbol: { type: "string", description: PARAM_DESCRIPTIONS.symbol },
+        new_body: { type: "string", description: PARAM_DESCRIPTIONS.newBody }
+      },
+      description: PARAM_DESCRIPTIONS.replaceSymbol
+    }
+  },
+  description: PARAM_DESCRIPTIONS.editVariant
+};
+var TOOL_CONTRACTS = [
+  {
+    name: "digest",
+    title: "Digest source",
+    description: TOOL_DESCRIPTIONS.digest,
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: PARAM_DESCRIPTIONS.path },
+        select: { type: "string", description: PARAM_DESCRIPTIONS.select },
+        at: { type: "string", description: PARAM_DESCRIPTIONS.at },
+        end: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.end },
+        limit: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.limit },
+        language: { type: "string", description: PARAM_DESCRIPTIONS.languageOverride },
+        visionMode: {
+          type: "string",
+          enum: [...VISION_MODES],
+          description: PARAM_DESCRIPTIONS.visionModeDigest
+        },
+        visionLevel: {
+          type: "string",
+          enum: [...VISION_LEVELS],
+          description: PARAM_DESCRIPTIONS.visionLevel
+        }
+      },
+      required: ["path"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "edit",
+    title: "Hash-verified edit",
+    description: TOOL_DESCRIPTIONS.edit,
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: PARAM_DESCRIPTIONS.path },
+        edits: {
+          type: "array",
+          minItems: 1,
+          description: PARAM_DESCRIPTIONS.edits,
+          items: editItemSchema
+        },
+        language: { type: "string", description: PARAM_DESCRIPTIONS.languageSymbol },
+        apply: { type: "boolean", description: PARAM_DESCRIPTIONS.apply },
+        planHash: { type: "string", description: PARAM_DESCRIPTIONS.planHash },
+        postEditVerify: { type: "boolean", description: PARAM_DESCRIPTIONS.postEditVerify }
+      },
+      required: ["path", "edits"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "write",
+    title: "Write file",
+    description: TOOL_DESCRIPTIONS.write,
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: PARAM_DESCRIPTIONS.path },
+        content: { type: "string", description: PARAM_DESCRIPTIONS.content }
+      },
+      required: ["path", "content"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "grep",
+    title: "Text search",
+    description: TOOL_DESCRIPTIONS.grep,
+    inputSchema: {
+      type: "object",
+      properties: {
+        pattern: { type: "string", description: PARAM_DESCRIPTIONS.grepPattern },
+        path: { type: "string", description: PARAM_DESCRIPTIONS.searchPath },
+        glob: { type: "string", description: PARAM_DESCRIPTIONS.glob },
+        ignoreCase: { type: "boolean", description: PARAM_DESCRIPTIONS.ignoreCase },
+        literal: { type: "boolean", description: PARAM_DESCRIPTIONS.literal },
+        context: { type: "integer", minimum: 0, description: PARAM_DESCRIPTIONS.context },
+        limit: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.matchLimit },
+        summary: { type: "boolean", description: PARAM_DESCRIPTIONS.summary },
+        scope: {
+          type: "string",
+          enum: ["symbol"],
+          description: PARAM_DESCRIPTIONS.grepScope
+        },
+        scopeContext: {
+          type: "integer",
+          minimum: 0,
+          description: PARAM_DESCRIPTIONS.scopeContext
+        }
+      },
+      required: ["pattern"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "view",
+    title: "View document",
+    description: TOOL_DESCRIPTIONS.view,
+    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: {
+          type: "string",
+          enum: [...DOCUMENT_NODE_KINDS],
+          description: PARAM_DESCRIPTIONS.kind
+        },
+        depth: { type: "integer", minimum: 0, description: PARAM_DESCRIPTIONS.depth },
+        outline: { type: "boolean", description: PARAM_DESCRIPTIONS.outline },
+        visionMode: {
+          type: "string",
+          enum: [...VISION_ANALYSIS_MODES],
+          description: PARAM_DESCRIPTIONS.visionModeView
+        },
+        visionLevel: {
+          type: "string",
+          enum: [...VISION_LEVELS],
+          description: PARAM_DESCRIPTIONS.visionLevel
+        }
+      },
+      required: ["path"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "search",
+    title: "AST search",
+    description: TOOL_DESCRIPTIONS.search,
+    inputSchema: {
+      type: "object",
+      properties: {
+        pattern: { type: "string", description: PARAM_DESCRIPTIONS.pattern },
+        path: { type: "string", description: PARAM_DESCRIPTIONS.searchPath },
+        language: { type: "string", description: PARAM_DESCRIPTIONS.language },
+        ...gitFlagsSchema
+      },
+      required: ["pattern"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "def",
+    title: "Find definition",
+    description: TOOL_DESCRIPTIONS.def,
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: PARAM_DESCRIPTIONS.name },
+        path: { type: "string", description: PARAM_DESCRIPTIONS.searchPath },
+        language: { type: "string", description: PARAM_DESCRIPTIONS.language },
+        ...gitFlagsSchema
+      },
+      required: ["name"],
+      additionalProperties: false
+    }
+  },
+  {
+    name: "refs",
+    title: "Find references",
+    description: TOOL_DESCRIPTIONS.refs,
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string", description: PARAM_DESCRIPTIONS.refsName },
+        path: { type: "string", description: PARAM_DESCRIPTIONS.searchPath },
+        language: { type: "string", description: PARAM_DESCRIPTIONS.language },
+        scope: { type: "boolean", description: PARAM_DESCRIPTIONS.scope },
+        line: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.line },
+        column: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.column },
+        ...gitFlagsSchema
+      },
+      additionalProperties: false
+    }
+  },
+  {
+    name: "rename",
+    title: "Rename symbol",
+    description: TOOL_DESCRIPTIONS.rename,
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: PARAM_DESCRIPTIONS.path },
+        line: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.renameLine },
+        column: { type: "integer", minimum: 1, description: PARAM_DESCRIPTIONS.column },
+        to: { type: "string", description: PARAM_DESCRIPTIONS.to },
+        workspace: { type: "boolean", description: PARAM_DESCRIPTIONS.workspace },
+        apply: { type: "boolean", description: PARAM_DESCRIPTIONS.apply },
+        planHash: { type: "string", description: PARAM_DESCRIPTIONS.planHash }
+      },
+      required: ["path", "line", "to"],
+      additionalProperties: false
+    }
+  }
+];
+// ../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) {
+      return { ok: false, error: "scope requires line" };
+    }
+    return { ok: true };
+  }
+  if (input.line !== undefined || input.column !== undefined) {
+    return { ok: false, error: "line/column require scope=true" };
+  }
+  if (typeof input.name !== "string" || input.name.length === 0) {
+    return { ok: false, error: "name is required when scope is not set" };
+  }
+  return { ok: true };
+}
+function validateVisionLevelVsMode(input) {
+  if (input.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" };
+  }
+  return { ok: true };
+}
+// ../readseek-api/src/argv.ts
+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);
+  }
+  const selection = [
+    input.cached ? "cached" : undefined,
+    input.others ? "others" : undefined,
+    input.ignored ? "ignored" : undefined
+  ].filter((value) => value !== undefined);
+  if (selection.length > 0) {
+    args.push("--git", selection.join(","));
+  }
+  return args;
+}
+function pushOptionalString(args, flag, value) {
+  if (value !== undefined)
+    args.push(flag, value);
+}
+function pushOptionalNumber(args, flag, value) {
+  if (value !== undefined)
+    args.push(flag, String(value));
+}
+function appendApplyAndPlanHash(args, input) {
+  const order = input.flagOrder ?? "apply-first";
+  if (order === "plan-hash-first") {
+    pushOptionalString(args, "--plan-hash", input.planHash);
+    if (input.apply)
+      args.push("--apply");
+    return args;
+  }
+  if (input.apply)
+    args.push("--apply");
+  pushOptionalString(args, "--plan-hash", input.planHash);
+  return args;
+}
+function selectArg(select) {
+  if (select === undefined)
+    return;
+  return Array.isArray(select) ? select.join(",") : select;
+}
+function buildDigestArgs(input) {
+  const vision = validateVisionLevelVsMode({
+    visionMode: input.visionMode,
+    visionLevel: input.visionLevel
+  });
+  if (!vision.ok)
+    throw new Error(vision.error);
+  const args = [];
+  if (input.readseekDir !== undefined)
+    args.push("--readseek-dir", input.readseekDir);
+  args.push("digest", input.path);
+  const select = selectArg(input.select);
+  if (select !== undefined)
+    args.push("--select", select);
+  pushOptionalString(args, "--at", input.at);
+  pushOptionalNumber(args, "--end", input.end);
+  pushOptionalNumber(args, "--limit", input.limit);
+  pushOptionalString(args, "--language", input.language);
+  pushOptionalString(args, "--vision-mode", input.visionMode);
+  pushOptionalString(args, "--vision-level", input.visionLevel);
+  pushOptionalString(args, "--stdin-name", input.stdinName);
+  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);
+  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);
+  return args;
+}
+function buildSearchArgs(input) {
+  const args = ["search", input.path, input.pattern];
+  pushOptionalString(args, "--language", input.language);
+  return appendGitSelectionArgs(args, input);
+}
+function buildDefArgs(input) {
+  const args = ["def", input.path];
+  if (input.format !== undefined)
+    args.push("--format", input.format);
+  args.push(input.name);
+  pushOptionalString(args, "--language", input.language);
+  return appendGitSelectionArgs(args, input);
+}
+function buildRefsArgs(input) {
+  const validated = validateRefsNameVsScope(input);
+  if (!validated.ok)
+    throw new Error(validated.error);
+  const args = ["refs", input.path];
+  if (input.scope) {
+    args.push("--at", buildLineLocation(input.line, input.column));
+  } else if (input.name !== undefined) {
+    args.push(input.name);
+  }
+  if (input.format !== undefined)
+    args.push("--format", input.format);
+  pushOptionalString(args, "--language", input.language);
+  return appendGitSelectionArgs(args, input);
+}
+function buildEditArgs(input) {
+  const args = ["edit", input.path];
+  appendApplyAndPlanHash(args, {
+    apply: input.apply,
+    planHash: input.planHash,
+    flagOrder: input.flagOrder ?? "apply-first"
+  });
+  pushOptionalString(args, "--language", input.language);
+  if (input.requestFromStdin)
+    args.push("--request", "-");
+  return args;
+}
+function buildRenameArgs(input) {
+  const args = ["rename", input.path, "--at", buildLineLocation(input.line, input.column), "--to", input.to];
+  if (input.workspace !== undefined)
+    args.push("--workspace", input.workspace);
+  appendApplyAndPlanHash(args, {
+    apply: input.apply,
+    planHash: input.planHash,
+    flagOrder: input.flagOrder ?? "plan-hash-first"
+  });
+  pushOptionalString(args, "--language", input.language);
+  return appendGitSelectionArgs(args, input);
+}
+// ../readseek-api/src/platform.ts
+import { createRequire } from "node:module";
+import path from "node:path";
+var READSEEK_PLATFORM_PACKAGES = {
+  "darwin-arm64": "@jarkkojs/readseek-darwin-arm64",
+  "linux-arm64": "@jarkkojs/readseek-linux-arm64",
+  "linux-x64": "@jarkkojs/readseek-linux-x64",
+  "win32-x64": "@jarkkojs/readseek-win32-x64"
+};
+var resolveFromPackage = createRequire(import.meta.url).resolve;
+function readSeekBinaryName(platform = process.platform) {
+  return platform === "win32" ? "readseek.exe" : "readseek";
+}
+function readSeekPlatformKey(platform = process.platform, arch = process.arch) {
+  return `${platform}-${arch}`;
+}
+function resolveReadSeekBinaryFromPackages(resolver = resolveFromPackage, options = {}) {
+  const resolve = typeof resolver === "function" ? resolver : resolver.resolve.bind(resolver);
+  const platform = options.platform ?? process.platform;
+  const arch = options.arch ?? process.arch;
+  const key = readSeekPlatformKey(platform, arch);
+  const platformPackage = READSEEK_PLATFORM_PACKAGES[key];
+  if (!platformPackage) {
+    const supported = Object.keys(READSEEK_PLATFORM_PACKAGES).join(", ");
+    throw new Error(`@jarkkojs/readseek ships no binary for ${key}; it supports ${supported}`);
+  }
+  const metaPackage = options.metaPackage ?? "@jarkkojs/readseek";
+  const metaPackageJson = resolve(`${metaPackage}/package.json`);
+  const metaPackageDir = path.dirname(metaPackageJson);
+  const packageJsonPath = resolve(`${platformPackage}/package.json`, {
+    paths: [metaPackageDir]
+  });
+  return path.join(path.dirname(packageJsonPath), "bin", readSeekBinaryName(platform));
+}
+// ../readseek-api/src/json.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/process.ts
+var DEFAULT_READSEEK_TIMEOUT_MS = 120000;
+var DEFAULT_MAX_OUTPUT_BYTES = 32 * 1024 * 1024;
+function resolveProcessLimits(options = {}) {
+  return {
+    timeoutMs: options.timeoutMs ?? DEFAULT_READSEEK_TIMEOUT_MS,
+    maxOutputBytes: options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES,
+    cancelable: options.cancelable !== false
+  };
+}
+function readSeekCancellationError(signal) {
+  const reason = signal?.reason;
+  return reason instanceof Error && reason.name !== "AbortError" ? reason : new Error("readseek cancelled");
+}
+function failureFromProcessResult(result, options = {}) {
+  if (options.overflow) {
+    return new Error(`readseek ${options.overflow} exceeded the ${options.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES}-byte output limit`);
+  }
+  if (options.timedOut) {
+    return new Error(`readseek timed out after ${options.timeoutMs ?? DEFAULT_READSEEK_TIMEOUT_MS} ms`);
+  }
+  const cleaned = cleanReadSeekErrorText(result.stderr);
+  if (cleaned)
+    return new Error(cleaned);
+  if (result.signal)
+    return new Error(`readseek killed by signal ${result.signal}`);
+  return new Error(`readseek exited with status ${result.exitCode}`);
+}
+function ensureSuccessfulStdout(result) {
+  if (result.exitCode === 0)
+    return result.stdout;
+  throw failureFromProcessResult(result);
+}
+function parseSuccessfulJson(result) {
+  return parseReadSeekJson(ensureSuccessfulStdout(result));
+}
+// ../readseek-api/src/process-bun.ts
+function getBunSpawn() {
+  const bunGlobal = globalThis;
+  const spawn = bunGlobal.Bun?.spawn;
+  if (typeof spawn !== "function") {
+    throw new Error("Bun.spawn is unavailable in this runtime");
+  }
+  return spawn;
+}
+async function readBoundedText(stream, streamName, maxOutputBytes, onOverflow) {
+  const reader = stream.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      totalBytes += value.byteLength;
+      if (totalBytes > maxOutputBytes) {
+        onOverflow();
+        await reader.cancel().catch(() => {
+          return;
+        });
+        throw failureFromProcessResult({ stdout: "", stderr: "", exitCode: null, signal: null }, { overflow: streamName, maxOutputBytes });
+      }
+      chunks.push(value);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  const bytes = new Uint8Array(totalBytes);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(bytes);
+}
+async function runReadSeekBun(binaryPath, args, options = {}) {
+  const limits = resolveProcessLimits(options);
+  if (limits.cancelable && options.signal?.aborted) {
+    throw readSeekCancellationError(options.signal);
+  }
+  const spawn = getBunSpawn();
+  const stdin = options.stdin === undefined ? undefined : new TextEncoder().encode(options.stdin);
+  const spawnOptions = {
+    cwd: options.cwd,
+    env: process.env,
+    stderr: "pipe",
+    stdin,
+    stdout: "pipe"
+  };
+  const child = spawn([binaryPath, ...args], limits.cancelable && options.signal ? { ...spawnOptions, killSignal: "SIGKILL", signal: options.signal } : spawnOptions);
+  const killForOverflow = () => {
+    try {
+      child.kill("SIGKILL");
+    } catch {}
+  };
+  let timeout;
+  const timeoutResult = new Promise((_resolve, reject) => {
+    timeout = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {}
+      reject(failureFromProcessResult({ stdout: "", stderr: "", exitCode: null, signal: null }, { timedOut: true, timeoutMs: limits.timeoutMs }));
+    }, limits.timeoutMs);
+    timeout.unref?.();
+  });
+  const pending = Promise.all([
+    readBoundedText(child.stdout, "stdout", limits.maxOutputBytes, killForOverflow),
+    readBoundedText(child.stderr, "stderr", limits.maxOutputBytes, killForOverflow),
+    child.exited
+  ]);
+  try {
+    const [stdout, stderr, exitCode] = await Promise.race([pending, timeoutResult]);
+    if (limits.cancelable && options.signal?.aborted)
+      throw readSeekCancellationError(options.signal);
+    return { stdout, stderr, exitCode, signal: null };
+  } finally {
+    if (timeout !== undefined)
+      clearTimeout(timeout);
+  }
+}
+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));
+}
+// index.ts
+var resolveFromHost = createRequire2(import.meta.url).resolve;
+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 TOOL_POLICY = [
+  "ReadSeek tool policy:",
+  "- Prefer readseek_* tools over built-ins when they can do the job.",
+  "- Read with readseek_digest first; readseek_edit needs fresh LINE:HASH anchors.",
+  "- Use readseek_grep for text/regex, readseek_search for AST patterns, and readseek_digest/def/refs for symbol navigation.",
+  "- Use readseek_edit for existing files, readseek_write for whole-file creation or replacement, and readseek_rename for symbol renames.",
+  "- Do not use built-in read, edit, write, grep, or apply_patch when a ReadSeek tool can do the job.",
+  "- Run readseek_digest with select=diagnostics after source edits for a quick syntax check."
+].join(`
+`);
+var OPENCODE_TOOL_ALIASES = Object.fromEntries(TOOL_NAMES.map((name) => [name, `readseek_${name}`]));
+function openCodeToolDescription(name) {
+  return renderToolDescription(name, OPENCODE_TOOL_ALIASES);
+}
+var PREFERRED_TOOL_DESCRIPTIONS = {
+  readseek_edit: "Preferred tool for editing existing text files with fresh LINE:HASH anchors.",
+  readseek_write: "Preferred tool for creating or replacing a complete text file; returns LINE:HASH anchors.",
+  readseek_rename: "Use to rename a symbol with binding-aware, verified edits.",
+  readseek_grep: "Preferred text/regex search; returns edit-ready LINE:HASH anchors.",
+  readseek_search: "Use for AST or structural code search with ast-grep-style patterns.",
+  readseek_digest: "Use to digest native facets (metadata, content, map, diagnostics, identity) and return the full envelope.",
+  readseek_def: "Use for go-to-definition or declaration lookup by name.",
+  readseek_refs: "Use to find identifier-name matches or binding-specific references before rename or delete.",
+  readseek_view: "Use to digest document structure or selected content."
+};
+var FALLBACK_TOOL_DESCRIPTIONS = {
+  edit: "Fallback only. Prefer readseek_edit with fresh LINE:HASH anchors.",
+  write: "Fallback only. Prefer readseek_write so the result returns LINE:HASH anchors.",
+  grep: "Fallback only. Prefer readseek_grep for text/regex search with edit-ready anchors.",
+  apply_patch: "Fallback only. Prefer readseek_edit for existing text files."
+};
+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];
+function resolveImagePolicy(options) {
+  const value = options?.imageMode;
+  if (value === undefined)
+    return "auto";
+  if (value === "on" || value === "auto" || value === "off")
+    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 requireDigestFacet(envelope, facet) {
+  const value = record(envelope)[facet];
+  if (value === undefined || value === null || typeof value !== "object") {
+    throw new Error(`digest returned no ${facet} facet`);
+  }
+  return value;
+}
+class SessionAnchors {
+  #pathsBySession = new Map;
+  #renamePlans = new Map;
+  mark(sessionID, filePath) {
+    let paths = this.#pathsBySession.get(sessionID);
+    if (!paths) {
+      paths = new Set;
+      this.#pathsBySession.set(sessionID, paths);
+    }
+    paths.add(filePath);
+  }
+  forget(filePath) {
+    const absolutePath = path2.resolve(filePath);
+    for (const paths of this.#pathsBySession.values())
+      paths.delete(absolutePath);
+    for (const [sessionID, plan] of this.#renamePlans) {
+      if (plan.files.has(absolutePath))
+        this.#renamePlans.delete(sessionID);
+    }
+  }
+  deleteSession(sessionID) {
+    this.#pathsBySession.delete(sessionID);
+    this.#renamePlans.delete(sessionID);
+  }
+  planRename(sessionID, output) {
+    if (!output || typeof output !== "object")
+      return;
+    const record = output;
+    if (record.applied === true) {
+      this.#renamePlans.delete(sessionID);
+      return;
+    }
+    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([path2.resolve(file)]);
+    if (Array.isArray(others)) {
+      for (const item of others) {
+        if (!item || typeof item !== "object")
+          continue;
+        const otherFile = item.file;
+        if (typeof otherFile === "string")
+          files.add(path2.resolve(otherFile));
+      }
+    }
+    this.#renamePlans.set(sessionID, { summary: `${oldName} -> ${newName}`, files });
+  }
+  render(sessionID) {
+    const paths = this.#pathsBySession.get(sessionID);
+    const sections = [];
+    if (paths?.size) {
+      sections.push(`## ReadSeek Anchors
+The following files have fresh LINE:HASH anchors:
+${[...paths].sort().map((filePath) => `- ${filePath}`).join(`
+`)}`);
+    }
+    const renamePlan = this.#renamePlans.get(sessionID);
+    if (renamePlan)
+      sections.push(`## Pending ReadSeek Rename Plan
+- ${renamePlan.summary}`);
+    return sections.length === 0 ? undefined : sections.join(`
+
+`);
+  }
+}
+function resolvePath(directory, filePath) {
+  return path2.resolve(directory, filePath);
+}
+function containsPath(directory, filePath) {
+  const relative = path2.relative(directory, filePath);
+  return relative === "" || !relative.startsWith(`..${path2.sep}`) && relative !== ".." && !path2.isAbsolute(relative);
+}
+async function resolveSymlinks(filePath) {
+  let unresolved = path2.resolve(filePath);
+  let symlinks = 0;
+  while (true) {
+    const parsed = path2.parse(unresolved);
+    const parts = unresolved.slice(parsed.root.length).split(path2.sep).filter(Boolean);
+    let resolved = parsed.root;
+    let restart = false;
+    for (let index = 0;index < parts.length; index++) {
+      const candidate = path2.join(resolved, parts[index]);
+      const info = await lstat(candidate);
+      if (!info.isSymbolicLink()) {
+        resolved = candidate;
+        continue;
+      }
+      symlinks++;
+      if (symlinks > 40) {
+        const error = new Error(`too many symbolic links: ${filePath}`);
+        error.code = "ELOOP";
+        throw error;
+      }
+      const target = await readlink(candidate);
+      unresolved = path2.resolve(path2.dirname(candidate), target, ...parts.slice(index + 1));
+      restart = true;
+      break;
+    }
+    if (!restart)
+      return resolved;
+  }
+}
+async function portableRealpath(filePath) {
+  try {
+    return await realpath(filePath);
+  } catch (error) {
+    if (error.code !== "EACCES")
+      throw error;
+    return resolveSymlinks(filePath);
+  }
+}
+async function canonicalPath(filePath) {
+  const missing = [];
+  let existing = filePath;
+  while (true) {
+    try {
+      return path2.join(await portableRealpath(existing), ...missing.reverse());
+    } catch (error) {
+      if (error.code !== "ENOENT")
+        throw error;
+      const parent = path2.dirname(existing);
+      if (parent === existing)
+        throw error;
+      missing.push(path2.basename(existing));
+      existing = parent;
+    }
+  }
+}
+async function authorizeExternal(context, filePath) {
+  const [accessPath, directory, worktree] = await Promise.all([
+    canonicalPath(filePath),
+    canonicalPath(context.directory),
+    context.worktree === "/" ? Promise.resolve("/") : canonicalPath(context.worktree)
+  ]);
+  if (containsPath(directory, accessPath) || worktree !== "/" && containsPath(worktree, accessPath)) {
+    return;
+  }
+  const info = await stat(accessPath).catch(() => {
+    return;
+  });
+  const parentDir = info?.isDirectory() ? accessPath : path2.dirname(accessPath);
+  const pattern = path2.join(parentDir, "*").replaceAll("\\", "/");
+  await context.ask({
+    permission: "external_directory",
+    patterns: [pattern],
+    always: [pattern],
+    metadata: { filepath: filePath, parentDir }
+  });
+}
+async function rejectSymlinkMutation(filePath) {
+  const info = await lstat(filePath).catch((error) => {
+    if (error.code === "ENOENT")
+      return;
+    throw error;
+  });
+  if (info?.isSymbolicLink())
+    throw new Error(`refusing to modify symbolic link: ${filePath}`);
+}
+async function authorizeRead(context, filePath) {
+  await authorizeExternal(context, filePath);
+  await context.ask({
+    permission: "read",
+    patterns: [path2.relative(context.worktree, filePath).replaceAll("\\", "/")],
+    always: ["*"],
+    metadata: {}
+  });
+}
+async function authorizeSearch(context, filePath, pattern) {
+  await context.ask({
+    permission: "grep",
+    patterns: [pattern],
+    always: ["*"],
+    metadata: { pattern, path: filePath }
+  });
+  await authorizeExternal(context, filePath);
+}
+async function authorizeEdit(context, filePaths, diff = "", authorizeExternalPaths = true) {
+  if (authorizeExternalPaths) {
+    for (const filePath of filePaths)
+      await authorizeExternal(context, filePath);
+  }
+  const patterns = filePaths.map((filePath) => path2.relative(context.worktree, filePath).replaceAll("\\", "/"));
+  await context.ask({
+    permission: "edit",
+    patterns,
+    always: ["*"],
+    metadata: { filepath: filePaths.join(", "), diff }
+  });
+}
+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);
+}
+async function runDigestContent(context, args, options = {}) {
+  return requireDigestFacet(await runReadSeek(context, args, options), "content");
+}
+function readSeekBinaryPath() {
+  return resolveReadSeekBinaryFromPackages(resolveFromHost);
+}
+async function preserveAbortReason(signal, cancelable, invoke) {
+  try {
+    const value = await invoke();
+    if (cancelable)
+      signal.throwIfAborted();
+    return value;
+  } catch (error) {
+    if (cancelable)
+      signal.throwIfAborted();
+    throw error;
+  }
+}
+async function runReadSeekRaw(context, args, options = {}) {
+  context.abort.throwIfAborted();
+  return preserveAbortReason(context.abort, options.cancelable !== false, () => runReadSeekBunText(readSeekBinaryPath(), args, {
+    cwd: context.directory,
+    signal: context.abort,
+    cancelable: options.cancelable,
+    stdin: options.stdin,
+    timeoutMs: options.timeoutMs
+  }));
+}
+async function runReadSeek(context, args, options = {}) {
+  context.abort.throwIfAborted();
+  return preserveAbortReason(context.abort, options.cancelable !== false, () => runReadSeekBunJson(readSeekBinaryPath(), args, {
+    cwd: context.directory,
+    signal: context.abort,
+    cancelable: options.cancelable,
+    stdin: options.stdin,
+    timeoutMs: options.timeoutMs
+  }));
+}
+async function postMutationPreview(context, args, filePath, changed) {
+  try {
+    return await runDigestContent(context, args, {
+      cancelable: false,
+      timeoutMs: DEFAULT_READSEEK_TIMEOUT_MS
+    });
+  } catch (error) {
+    const previewError = error instanceof Error ? error.message : String(error);
+    return {
+      file: filePath,
+      changed,
+      preview_error: previewError,
+      warning: "File mutation completed, but the post-write preview failed. Do not retry the mutation; read the file to verify content and refresh anchors."
+    };
+  }
+}
+var readSeekCacheInit;
+function readSeekCacheDir() {
+  const xdgCacheHome = process.env.XDG_CACHE_HOME?.trim();
+  const cacheHome = xdgCacheHome || path2.join(homedir(), ".cache");
+  return path2.join(cacheHome, "opencode", "readseek");
+}
+async function ensureReadSeekCache(context) {
+  const cacheDir = readSeekCacheDir();
+  try {
+    const info = await stat(cacheDir);
+    if (!info.isDirectory())
+      throw new Error(`readseek cache is not a directory: ${cacheDir}`);
+    return cacheDir;
+  } catch (error) {
+    if (error.code !== "ENOENT")
+      throw error;
+  }
+  readSeekCacheInit ??= runReadSeekRaw(context, ["--readseek-dir", cacheDir, "init"]).then(() => cacheDir).finally(() => {
+    readSeekCacheInit = undefined;
+  });
+  return readSeekCacheInit;
+}
+function render(value) {
+  return JSON.stringify(value, null, 2);
+}
+function collectAnchoredFiles(value, files) {
+  if (Array.isArray(value)) {
+    for (const item of value)
+      collectAnchoredFiles(item, files);
+    return;
+  }
+  if (!value || typeof value !== "object")
+    return;
+  const output = value;
+  const hashlines = output.hashlines;
+  if (typeof output.file === "string" && Array.isArray(hashlines) && hashlines.some((line) => typeof record(line).line === "number" && typeof record(line).hash === "string"))
+    files.add(output.file);
+  for (const item of Object.values(output))
+    collectAnchoredFiles(item, files);
+}
+var fileMutationTails = new Map;
+var MAX_PERMISSION_DIFF_BYTES = 32 * 1024;
+async function withFileMutationQueue(filePath, operation) {
+  const key = path2.resolve(filePath);
+  const previous = fileMutationTails.get(key);
+  let release = () => {};
+  const current = new Promise((resolve) => {
+    release = resolve;
+  });
+  fileMutationTails.set(key, current);
+  if (previous)
+    await previous;
+  try {
+    return await operation();
+  } finally {
+    release();
+    if (fileMutationTails.get(key) === current)
+      fileMutationTails.delete(key);
+  }
+}
+function validateEdits(value) {
+  if (!Array.isArray(value) || value.length === 0)
+    throw new Error("edits must contain at least one edit");
+  const requiredFields = {
+    set_line: ["anchor", "new_text"],
+    replace_lines: ["end_anchor", "new_text", "start_anchor"],
+    insert_after: ["anchor", "new_text"],
+    replace: ["new_text", "old_text"],
+    replace_symbol: ["new_body", "symbol"]
+  };
+  for (const [index, item] of value.entries()) {
+    if (!item || typeof item !== "object")
+      throw new Error(`edits[${index}] must be an edit object`);
+    const keys = Object.keys(item);
+    const variant = keys[0];
+    if (keys.length !== 1 || !Object.hasOwn(requiredFields, variant)) {
+      throw new Error(`edits[${index}] must contain exactly one of: set_line, replace_lines, insert_after, replace, replace_symbol`);
+    }
+    const payload = item[variant];
+    if (!payload || typeof payload !== "object")
+      throw new Error(`edits[${index}].${variant} must be an object`);
+    const expectedFields = requiredFields[variant];
+    const allowedFields = variant === "replace" ? [...expectedFields, "all"] : expectedFields;
+    const actualFields = Object.keys(payload).sort();
+    if (actualFields.some((field) => !allowedFields.includes(field)) || expectedFields.some((field) => !actualFields.includes(field))) {
+      throw new Error(`edits[${index}].${variant} contains invalid fields`);
+    }
+    const values = payload;
+    for (const field of expectedFields) {
+      if (typeof values[field] !== "string") {
+        throw new Error(`edits[${index}].${variant}.${field} must be a string`);
+      }
+    }
+    if (variant === "replace" && values.all !== undefined && typeof values.all !== "boolean") {
+      throw new Error(`edits[${index}].replace.all must be a boolean`);
+    }
+    for (const field of expectedFields.filter((field2) => field2.endsWith("anchor"))) {
+      parseAnchor(values[field]);
+    }
+  }
+}
+function parseAnchor(anchor) {
+  const match = /^(\d+):([0-9a-fA-F]{3})$/.exec(anchor.trim());
+  if (!match)
+    throw new Error(`invalid LINE:HASH anchor: ${anchor}`);
+  const line = Number(match[1]);
+  if (line === 0)
+    throw new Error(`anchor line must be greater than zero: ${anchor}`);
+  return { line, hash: match[2].toLowerCase() };
+}
+function firstChangedLine(before, after) {
+  const beforeLines = normalizeToLf(before).split(`
+`);
+  const afterLines = normalizeToLf(after).split(`
+`);
+  const count = Math.max(beforeLines.length, afterLines.length);
+  for (let index = 0;index < count; index++) {
+    if (beforeLines[index] !== afterLines[index])
+      return index + 1;
+  }
+  return 1;
+}
+async function readTextSnapshot(filePath) {
+  try {
+    return { exists: true, content: await readFile(filePath, "utf8") };
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return { exists: false, content: "" };
+    throw error;
+  }
+}
+async function writeHandle(handle, content) {
+  const data = Buffer.from(content, "utf8");
+  await handle.truncate(0);
+  let offset = 0;
+  while (offset < data.length) {
+    const { bytesWritten } = await handle.write(data, offset, data.length - offset, offset);
+    if (bytesWritten === 0)
+      throw new Error("write made no progress");
+    offset += bytesWritten;
+  }
+}
+async function writeText(filePath, expected, content) {
+  await mkdir(path2.dirname(filePath), { recursive: true });
+  if (!expected.exists) {
+    let handle2;
+    try {
+      handle2 = await open(filePath, "wx+");
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        throw new Error(`refusing to overwrite changed file: ${filePath}`);
+      }
+      throw error;
+    }
+    try {
+      await writeHandle(handle2, content);
+    } finally {
+      await handle2.close();
+    }
+    return;
+  }
+  const pathInfo = await lstat(filePath);
+  if (pathInfo.isSymbolicLink())
+    throw new Error(`refusing to modify symbolic link: ${filePath}`);
+  const handle = await open(filePath, "r+");
+  try {
+    const handleInfo = await handle.stat();
+    const currentPathInfo = await lstat(filePath);
+    if (currentPathInfo.isSymbolicLink() || currentPathInfo.dev !== handleInfo.dev || currentPathInfo.ino !== handleInfo.ino) {
+      throw new Error(`refusing to overwrite changed file: ${filePath}`);
+    }
+    const current = (await handle.readFile()).toString("utf8");
+    if (current !== expected.content)
+      throw new Error(`refusing to overwrite changed file: ${filePath}`);
+    if (current !== content)
+      await writeHandle(handle, content);
+  } finally {
+    await handle.close();
+  }
+}
+function renameFiles(value) {
+  const output = record(value);
+  const files = [];
+  if (typeof output.file === "string" && items(output.edits).length > 0)
+    files.push(path2.resolve(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(path2.resolve(item.file));
+  }
+  return files;
+}
+function normalizeToLf(content) {
+  return content.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+}
+function diffLines(content) {
+  if (content === "")
+    return [];
+  const lines = content.split(`
+`);
+  if (lines.at(-1) === "")
+    lines.pop();
+  return lines.map((line) => line.replace(/\r/g, "\\r"));
+}
+function hasFinalNewline(content) {
+  return content === "" || /[\r\n]$/.test(content);
+}
+function diffRange(start, count) {
+  return count === 0 ? `${start},0` : `${start + 1},${count}`;
+}
+function utf8Prefix(value, maxBytes) {
+  const bytes = Buffer.from(value, "utf8");
+  if (bytes.length <= maxBytes)
+    return value;
+  let end = maxBytes;
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  while (end > 0) {
+    try {
+      return decoder.decode(bytes.subarray(0, end));
+    } catch {
+      end--;
+    }
+  }
+  return "";
+}
+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;
+}
+function previewDiffLine(prefix, line) {
+  const value = `${prefix}${line}`;
+  const maxBytes = 256;
+  if (Buffer.byteLength(value) <= maxBytes)
+    return value;
+  return `${utf8Prefix(value, maxBytes - Buffer.byteLength("…"))}…`;
+}
+function sampleDiffLines(lines, start, end, prefix) {
+  const sampleSize = 20;
+  const count = end - start;
+  if (count <= sampleSize * 2) {
+    return lines.slice(start, end).map((line) => previewDiffLine(prefix, line));
+  }
+  return [
+    ...lines.slice(start, start + sampleSize).map((line) => previewDiffLine(prefix, line)),
+    ` ${count - sampleSize * 2} ${prefix === "-" ? "removed" : "added"} lines omitted`,
+    ...lines.slice(end - sampleSize, end).map((line) => previewDiffLine(prefix, line))
+  ];
+}
+function simpleDiff(filePath, before, after) {
+  if (before === after)
+    return "";
+  const oldLines = diffLines(before);
+  const newLines = diffLines(after);
+  const oldHasFinalNewline = hasFinalNewline(before);
+  const newHasFinalNewline = hasFinalNewline(after);
+  let prefix = 0;
+  while (prefix < oldLines.length && prefix < newLines.length && oldLines[prefix] === newLines[prefix])
+    prefix++;
+  let suffix = 0;
+  while (suffix < oldLines.length - prefix && suffix < newLines.length - prefix && oldLines[oldLines.length - 1 - suffix] === newLines[newLines.length - 1 - suffix])
+    suffix++;
+  if (prefix === oldLines.length && prefix === newLines.length) {
+    prefix = Math.max(0, prefix - 1);
+    suffix = 0;
+  }
+  const oldChangeEnd = oldLines.length - suffix;
+  const newChangeEnd = newLines.length - suffix;
+  const oldStart = Math.max(0, prefix - 3);
+  const newStart = Math.max(0, prefix - 3);
+  const oldEnd = Math.min(oldLines.length, oldChangeEnd + 3);
+  const newEnd = Math.min(newLines.length, newChangeEnd + 3);
+  const safePath = utf8Prefix(filePath.replace(/[\r\n]/g, ""), 1024);
+  const header = [
+    `--- ${safePath}`,
+    `+++ ${safePath}`,
+    `@@ -${diffRange(oldStart, oldEnd - oldStart)} +${diffRange(newStart, newEnd - newStart)} @@`
+  ];
+  const fullDiff = [...header];
+  let fullDiffBytes = Buffer.byteLength(header.join(`
+`));
+  let complete = true;
+  const ranges = [
+    [oldLines, oldStart, prefix, " ", oldHasFinalNewline],
+    [oldLines, prefix, oldChangeEnd, "-", oldHasFinalNewline],
+    [newLines, prefix, newChangeEnd, "+", newHasFinalNewline],
+    [newLines, newChangeEnd, newEnd, " ", newHasFinalNewline]
+  ];
+  outer:
+    for (const [lines, start, end, marker, hasNewline] of ranges) {
+      for (let index = start;index < end; index++) {
+        const lineBytes = 2 + Buffer.byteLength(lines[index]);
+        if (fullDiffBytes + lineBytes > MAX_PERMISSION_DIFF_BYTES) {
+          complete = false;
+          break outer;
+        }
+        fullDiff.push(`${marker}${lines[index]}`);
+        fullDiffBytes += lineBytes;
+        if (index === lines.length - 1 && !hasNewline) {
+          const eofMarker = "\";
+          if (fullDiffBytes + Buffer.byteLength(eofMarker) + 1 > MAX_PERMISSION_DIFF_BYTES) {
+            complete = false;
+            break outer;
+          }
+          fullDiff.push(eofMarker);
+          fullDiffBytes += Buffer.byteLength(eofMarker) + 1;
+        }
+      }
+    }
+  if (complete)
+    return fullDiff.join(`
+`);
+  const newlineSummary = oldHasFinalNewline === newHasFinalNewline ? [] : [` final newline: ${oldHasFinalNewline ? "present" : "missing"} -> ${newHasFinalNewline ? "present" : "missing"}`];
+  return [
+    ...header,
+    ` diff truncated: ${oldChangeEnd - prefix} removed, ${newChangeEnd - prefix} added lines`,
+    ...newlineSummary,
+    ...sampleDiffLines(oldLines, prefix, oldChangeEnd, "-"),
+    ...sampleDiffLines(newLines, prefix, newChangeEnd, "+")
+  ].join(`
+`);
+}
+function identifiedName(value) {
+  if (!value || typeof value !== "object")
+    return;
+  const identifier = value.identifier;
+  if (!identifier || typeof identifier !== "object")
+    return;
+  const text = identifier.text;
+  return typeof text === "string" ? text : undefined;
+}
+function record(value) {
+  return value && typeof value === "object" ? value : {};
+}
+function items(value) {
+  return Array.isArray(value) ? value : [];
+}
+function initialTitle(kind, args) {
+  switch (kind) {
+    case "read":
+      return `Read ${args.path}`;
+    case "view":
+      return `View ${args.path}`;
+    case "digest":
+      return `Digest ${args.path}`;
+    case "search":
+      return `Search ${args.pattern}`;
+    case "grep":
+      return `Grep ${args.pattern}`;
+    case "def":
+      return `Find definition ${args.name}`;
+    case "refs":
+      return `Find references to ${args.name}`;
+    case "rename":
+      return `Rename ${args.path}:${args.line} to ${args.to}`;
+    case "edit":
+      return `Edit ${args.path}`;
+    case "write":
+      return `Write ${args.path}`;
+  }
+}
+function resultPresentation(kind, args, value) {
+  const output = record(value);
+  switch (kind) {
+    case "read": {
+      const startLine = output.start_line;
+      const endLine = output.end_line;
+      if (typeof startLine === "number" && typeof endLine === "number") {
+        return {
+          title: `Read ${args.path}:${startLine}-${endLine}`,
+          metadata: { start_line: startLine, end_line: endLine, line_count: endLine - startLine + 1 }
+        };
+      }
+      const width = output.width;
+      const height = output.height;
+      if (typeof width === "number" && typeof height === "number") {
+        return { title: `Read ${args.path} (${width}x${height})`, metadata: { width, height } };
+      }
+      break;
+    }
+    case "view":
+      return { title: `Viewed ${args.path}`, metadata: {} };
+    case "digest": {
+      const map = record(output.map);
+      const diagnostics = record(output.diagnostics);
+      const identity = record(output.identity);
+      const content = record(output.content);
+      const metadata = {};
+      const summary = [];
+      if (output.map !== undefined) {
+        const symbols = items(map.symbols).length;
+        metadata.symbols = symbols;
+        summary.push(`${symbols} symbols`);
+      }
+      if (output.diagnostics !== undefined) {
+        const errors = typeof diagnostics.error_count === "number" ? diagnostics.error_count : 0;
+        const missing = typeof diagnostics.missing_count === "number" ? diagnostics.missing_count : 0;
+        metadata.error_count = errors;
+        metadata.missing_count = missing;
+        summary.push(`${errors} errors, ${missing} missing`);
+      }
+      if (output.identity !== undefined) {
+        if (typeof identity.line === "number")
+          metadata.line = identity.line;
+        if (typeof identity.column === "number")
+          metadata.column = identity.column;
+        const identifier = record(identity.identifier).text;
+        if (typeof identifier === "string")
+          summary.push(identifier);
+      }
+      if (typeof content.start_line === "number")
+        metadata.start_line = content.start_line;
+      if (typeof content.end_line === "number")
+        metadata.end_line = content.end_line;
+      return {
+        title: summary.length > 0 ? `Digested ${args.path} (${summary.join(", ")})` : `Digested ${args.path}`,
+        metadata
+      };
+    }
+    case "search": {
+      const results = items(output.results);
+      const matches = results.reduce((total, result) => total + items(record(result).matches).length, 0);
+      return { title: `Found ${matches} matches`, metadata: { results: results.length, matches } };
+    }
+    case "grep": {
+      const results = items(output.results);
+      const matches = results.reduce((total, result) => total + items(record(result).matches).length, 0);
+      return { title: `Found ${matches} matches`, metadata: { results: results.length, matches } };
+    }
+    case "def": {
+      const locations = items(output.locations).length;
+      return { title: `Found ${locations} definitions`, metadata: { locations } };
+    }
+    case "refs": {
+      const references = items(output.references).length;
+      return { title: `Found ${references} references`, metadata: { references } };
+    }
+    case "rename": {
+      const oldName = output.old_name;
+      const newName = output.new_name;
+      const otherOutputs = items(output.others).map(record);
+      const edits = otherOutputs.reduce((total, item) => total + items(item.edits).length, items(output.edits).length);
+      const conflicts = otherOutputs.reduce((total, item) => total + items(item.conflicts).length, items(output.conflicts).length);
+      const others = otherOutputs.length;
+      const title = typeof oldName === "string" && typeof newName === "string" ? `${output.applied === true ? "Renamed" : "Plan"} ${oldName} -> ${newName}` : initialTitle(kind, args);
+      return { title, metadata: { edits, conflicts, others } };
+    }
+    case "edit":
+    case "write": {
+      const preview = typeof output.preview_error === "string" ? " (preview unavailable)" : "";
+      return { title: `${kind === "edit" ? "Edited" : "Wrote"} ${args.path}${preview}`, metadata: {} };
+    }
+  }
+  return { title: initialTitle(kind, args), metadata: {} };
+}
+function readseekTool(description, args, kind, execute, formatResult = (result) => ({ output: render(result) })) {
+  return tool({
+    description,
+    args,
+    async execute(args2, context) {
+      const title = initialTitle(kind, args2);
+      context.metadata({ title });
+      const result = await execute(args2, context);
+      const presentation = resultPresentation(kind, args2, result);
+      return {
+        title: presentation.title,
+        ...formatResult(result),
+        metadata: presentation.metadata
+      };
+    }
+  });
+}
+var ReadSeekPlugin = async (_input, options) => {
+  const anchors = new SessionAnchors;
+  const imagePolicy = resolveImagePolicy(options);
+  const imageModes = imagePolicy === "auto" ? ["none", "all", "ocr", "caption", "objects"] : ["all", "ocr", "caption", "objects"];
+  return {
+    tool: {
+      readseek_view: readseekTool(openCodeToolDescription("view"), {
+        path: tool.schema.string().describe("Document path relative to the project directory"),
+        node: tool.schema.string().min(1).optional().describe(PARAM_DESCRIPTIONS.node),
+        page: tool.schema.number().int().positive().optional().describe(PARAM_DESCRIPTIONS.page),
+        kind: tool.schema.enum(DOCUMENT_NODE_KIND_VALUES).optional().describe(PARAM_DESCRIPTIONS.kind),
+        depth: tool.schema.number().int().nonnegative().optional().describe(PARAM_DESCRIPTIONS.depth),
+        outline: tool.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.outline),
+        visionMode: tool.schema.enum(VISION_ANALYSIS_MODE_VALUES).optional().describe(PARAM_DESCRIPTIONS.visionModeView),
+        visionLevel: tool.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"), {
+        path: tool.schema.string().describe("Path relative to the project directory"),
+        select: tool.schema.string().optional().describe("Comma-separated facets: metadata, content, map, diagnostics, identity; defaults to content"),
+        at: tool.schema.string().optional().describe(PARAM_DESCRIPTIONS.at),
+        end: tool.schema.number().int().positive().optional().describe("Last line to include; content facet only"),
+        limit: tool.schema.number().int().positive().optional().describe("Maximum number of lines; content facet only"),
+        language: tool.schema.string().optional().describe(PARAM_DESCRIPTIONS.language),
+        visionMode: tool.schema.enum(IMAGE_MODES).optional().describe("Standalone image mode for the content facet: none, all, ocr, caption, or objects"),
+        visionLevel: tool.schema.enum(VISION_LEVEL_VALUES).optional().describe("Vision inference level: low (default), medium, or high; content facet only")
+      }, "digest", async (input, context) => {
+        const filePath = resolvePath(context.directory, input.path);
+        await authorizeRead(context, filePath);
+        const select = (input.select ?? "content").trim() || "content";
+        const visionMode = input.visionMode;
+        const visionLevel = input.visionLevel;
+        const vision = validateVisionLevelVsMode({ visionMode, visionLevel });
+        if (!vision.ok)
+          throw new Error(vision.error);
+        const cacheDir = await ensureReadSeekCache(context);
+        const args = buildDigestArgs({
+          path: filePath,
+          select,
+          at: input.at,
+          end: input.end,
+          limit: input.limit,
+          language: input.language,
+          visionMode,
+          visionLevel,
+          readseekDir: cacheDir
+        });
+        return runReadSeek(context, args, visionMode === undefined || visionMode === "none" ? {} : { timeoutMs: DEFAULT_VISION_TIMEOUT_MS });
+      }),
+      readseek_grep: readseekTool(openCodeToolDescription("grep"), {
+        pattern: tool.schema.string().describe("Text or regular expression to search for; set literal for exact text"),
+        path: tool.schema.string().optional().describe("File or directory to search; defaults to the project directory"),
+        glob: tool.schema.string().optional().describe("File-name glob, such as **/*.ts"),
+        literal: tool.schema.boolean().optional().describe("Treat pattern as literal text"),
+        ignoreCase: tool.schema.boolean().optional().describe("Ignore case"),
+        context: tool.schema.number().int().nonnegative().optional().describe("Surrounding lines for each match"),
+        limit: tool.schema.number().int().positive().optional().describe("Maximum matching lines; defaults to 100")
+      }, "grep", async (input, context) => {
+        const target = resolvePath(context.directory, input.path ?? ".");
+        const pattern = input.pattern;
+        await authorizeSearch(context, target, pattern);
+        let expression;
+        try {
+          const source = input.literal ? pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") : pattern;
+          expression = new RegExp(source, input.ignoreCase ? "i" : "");
+        } catch (error) {
+          throw new Error(`invalid regular expression: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const info = await stat(target);
+        const files = [];
+        if (info.isFile())
+          files.push(target);
+        else if (info.isDirectory()) {
+          const glob = new Bun.Glob(input.glob ?? "**/*");
+          for await (const filePath of glob.scan({ cwd: target, absolute: true, onlyFiles: true, followSymlinks: false })) {
+            files.push(filePath);
+          }
+        } else
+          throw new Error(`grep target is not a file or directory: ${target}`);
+        const maxMatches = input.limit ?? 100;
+        const contextLines = input.context ?? 0;
+        const results = [];
+        let totalMatches = 0;
+        let truncated = false;
+        for (const filePath of files.sort()) {
+          context.abort.throwIfAborted();
+          if (truncated)
+            break;
+          const buffer = await readFile(filePath);
+          if (buffer.includes(0))
+            continue;
+          const lines = buffer.toString("utf8").replace(/\r\n/g, `
+`).split(`
+`);
+          const matchLines = new Set;
+          const ranges = [];
+          for (let index = 0;index < lines.length; index++) {
+            expression.lastIndex = 0;
+            if (!expression.test(lines[index] ?? ""))
+              continue;
+            if (totalMatches === maxMatches) {
+              truncated = true;
+              break;
+            }
+            const line = index + 1;
+            matchLines.add(line);
+            ranges.push([Math.max(1, line - contextLines), Math.min(lines.length, line + contextLines)]);
+            totalMatches++;
+          }
+          if (ranges.length === 0)
+            continue;
+          const mergedRanges = [];
+          for (const [start, end] of ranges) {
+            const previous = mergedRanges.at(-1);
+            if (previous && start <= previous[1] + 1)
+              previous[1] = Math.max(previous[1], end);
+            else
+              mergedRanges.push([start, end]);
+          }
+          const linesByNumber = new Map;
+          for (const [start, end] of mergedRanges) {
+            const output = record(await runDigestContent(context, readRangeArgs(filePath, start, end)));
+            for (const hashline of items(output.hashlines)) {
+              const line = record(hashline).line;
+              if (typeof line === "number" && !linesByNumber.has(line))
+                linesByNumber.set(line, hashline);
+            }
+          }
+          const hashlines = [...linesByNumber.values()];
+          const matches = hashlines.filter((hashline) => {
+            const line = record(hashline).line;
+            return typeof line === "number" && matchLines.has(line);
+          });
+          results.push({ file: filePath, matches, hashlines });
+        }
+        return { results, truncated };
+      }),
+      readseek_search: readseekTool(openCodeToolDescription("search"), {
+        pattern: tool.schema.string().describe(PARAM_DESCRIPTIONS.pattern),
+        path: tool.schema.string().optional().describe("File or directory to search; defaults to the project directory"),
+        language: tool.schema.string().optional().describe(PARAM_DESCRIPTIONS.language),
+        cached: tool.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.cached),
+        others: tool.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.others),
+        ignored: tool.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.ignored)
+      }, "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
+        });
+        await authorizeSearch(context, target, input.pattern);
+        return runReadSeek(context, args);
+      }),
+      readseek_def: readseekTool(openCodeToolDescription("def"), {
+        name: tool.schema.string().describe(PARAM_DESCRIPTIONS.name),
+        path: tool.schema.string().optional().describe("File or directory to search; defaults to the project directory"),
+        language: tool.schema.string().optional().describe(PARAM_DESCRIPTIONS.language),
+        cached: tool.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.cached),
+        others: tool.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.others),
+        ignored: tool.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.ignored)
+      }, "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
+        });
+        await authorizeSearch(context, target, input.name);
+        return runReadSeek(context, args);
+      }),
+      readseek_refs: readseekTool(openCodeToolDescription("refs"), {
+        name: tool.schema.string().optional().describe(PARAM_DESCRIPTIONS.refsName),
+        path: tool.schema.string().optional().describe("File or directory to search; defaults to the project directory"),
+        language: tool.schema.string().optional().describe(PARAM_DESCRIPTIONS.language),
+        scope: tool.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.scope),
+        line: tool.schema.number().int().positive().optional().describe(PARAM_DESCRIPTIONS.line),
+        column: tool.schema.number().int().positive().optional().describe(PARAM_DESCRIPTIONS.column),
+        cached: tool.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.cached),
+        others: tool.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.others),
+        ignored: tool.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.ignored)
+      }, "refs", async (input, context) => {
+        const target = resolvePath(context.directory, input.path ?? ".");
+        const name = input.name;
+        const args = buildRefsArgs({
+          path: target,
+          name,
+          scope: input.scope,
+          line: input.line,
+          column: input.column,
+          language: input.language,
+          cached: input.cached,
+          others: input.others,
+          ignored: input.ignored
+        });
+        await authorizeSearch(context, target, name ?? "*");
+        return runReadSeek(context, args);
+      }),
+      readseek_rename: readseekTool(openCodeToolDescription("rename"), {
+        path: tool.schema.string().describe("Path relative to the project directory"),
+        line: tool.schema.number().int().positive().describe(PARAM_DESCRIPTIONS.renameLine),
+        column: tool.schema.number().int().positive().optional().describe(PARAM_DESCRIPTIONS.column),
+        to: tool.schema.string().min(1).describe(PARAM_DESCRIPTIONS.to),
+        workspace: tool.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.workspace),
+        apply: tool.schema.boolean().optional().describe("Apply the verified edits; defaults to true")
+      }, "rename", async (input, context) => {
+        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 envelope = await runReadSeek(context, identifyArgs);
+          const name = identifiedName(requireDigestFacet(envelope, "identity"));
+          if (!name)
+            throw new Error("readseek could not identify a binding at the rename cursor");
+          await authorizeSearch(context, context.directory, name);
+        }
+        const args = buildRenameArgs({
+          path: filePath,
+          to: input.to,
+          line: input.line,
+          column: input.column,
+          workspace: input.workspace ? context.directory : undefined
+        });
+        const plan = await runReadSeek(context, args);
+        if (input.apply === false)
+          return plan;
+        const files = renameFiles(plan);
+        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");
+        }
+        await authorizeEdit(context, files);
+        return runReadSeek(context, buildRenameArgs({
+          path: filePath,
+          to: input.to,
+          line: input.line,
+          column: input.column,
+          workspace: input.workspace ? context.directory : undefined,
+          apply: true,
+          planHash
+        }), {
+          cancelable: false,
+          timeoutMs: DEFAULT_READSEEK_TIMEOUT_MS
+        });
+      }),
+      readseek_edit: readseekTool(openCodeToolDescription("edit"), {
+        path: tool.schema.string().describe("Path relative to the project directory"),
+        edits: tool.schema.array(tool.schema.union([
+          tool.schema.object({
+            set_line: tool.schema.object({
+              anchor: tool.schema.string().describe(PARAM_DESCRIPTIONS.anchor),
+              new_text: tool.schema.string().describe(PARAM_DESCRIPTIONS.newTextLine)
+            }).strict()
+          }).strict(),
+          tool.schema.object({
+            replace_lines: tool.schema.object({
+              start_anchor: tool.schema.string().describe(PARAM_DESCRIPTIONS.startAnchor),
+              end_anchor: tool.schema.string().describe(PARAM_DESCRIPTIONS.endAnchor),
+              new_text: tool.schema.string().describe(PARAM_DESCRIPTIONS.newTextRange)
+            }).strict()
+          }).strict(),
+          tool.schema.object({
+            insert_after: tool.schema.object({
+              anchor: tool.schema.string().describe(PARAM_DESCRIPTIONS.insertAnchor),
+              new_text: tool.schema.string().describe(PARAM_DESCRIPTIONS.newTextInsert)
+            }).strict()
+          }).strict(),
+          tool.schema.object({
+            replace: tool.schema.object({
+              old_text: tool.schema.string().describe(PARAM_DESCRIPTIONS.oldText),
+              new_text: tool.schema.string().describe(PARAM_DESCRIPTIONS.newText),
+              all: tool.schema.boolean().optional().describe(PARAM_DESCRIPTIONS.all)
+            }).strict()
+          }).strict(),
+          tool.schema.object({
+            replace_symbol: tool.schema.object({
+              symbol: tool.schema.string().describe(PARAM_DESCRIPTIONS.symbol),
+              new_body: tool.schema.string().describe(PARAM_DESCRIPTIONS.newBody)
+            }).strict()
+          }).strict()
+        ])).min(1).describe(PARAM_DESCRIPTIONS.edits),
+        language: tool.schema.string().optional().describe(PARAM_DESCRIPTIONS.languageSymbol)
+      }, "edit", async (input, context) => {
+        const filePath = resolvePath(context.directory, input.path);
+        validateEdits(input.edits);
+        return withFileMutationQueue(filePath, async () => {
+          context.abort.throwIfAborted();
+          await authorizeRead(context, filePath);
+          await rejectSymlinkMutation(filePath);
+          const edits = input.edits;
+          const request = JSON.stringify({ edits });
+          const baseArgs = buildEditArgs({
+            path: filePath,
+            language: input.language,
+            requestFromStdin: true
+          });
+          const plan = record(await runReadSeek(context, baseArgs, { stdin: request }));
+          if (typeof plan.before_content !== "string" || typeof plan.content !== "string" || typeof plan.plan_hash !== "string") {
+            throw new Error("readseek edit plan is missing before_content, content, or plan_hash");
+          }
+          const before = plan.before_content;
+          const after = plan.content;
+          const previewStart = Math.max(1, firstChangedLine(before, after) - 3);
+          const previewArgs = readRangeArgs(filePath, previewStart, previewStart + EDIT_RESULT_READ_LIMIT - 1);
+          if (before === after) {
+            return postMutationPreview(context, previewArgs, filePath, false);
+          }
+          await authorizeEdit(context, [filePath], simpleDiff(filePath, before, after), false);
+          context.abort.throwIfAborted();
+          const applied = record(await runReadSeek(context, buildEditArgs({
+            path: filePath,
+            language: input.language,
+            requestFromStdin: true,
+            apply: true,
+            planHash: plan.plan_hash
+          }), {
+            cancelable: false,
+            stdin: request,
+            timeoutMs: DEFAULT_READSEEK_TIMEOUT_MS
+          }));
+          if (applied.applied !== true) {
+            throw new Error("readseek did not confirm that the edit was applied");
+          }
+          return postMutationPreview(context, previewArgs, filePath, true);
+        });
+      }),
+      readseek_write: readseekTool(openCodeToolDescription("write"), {
+        path: tool.schema.string().describe("Path relative to the project directory"),
+        content: tool.schema.string().describe("Complete text file content")
+      }, "write", async (input, context) => {
+        const filePath = resolvePath(context.directory, input.path);
+        await authorizeExternal(context, filePath);
+        return withFileMutationQueue(filePath, async () => {
+          context.abort.throwIfAborted();
+          await rejectSymlinkMutation(filePath);
+          const before = await readTextSnapshot(filePath);
+          const content = input.content;
+          if (content.includes("\x00"))
+            throw new Error("write content must be text");
+          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);
+        });
+      })
+    },
+    "experimental.chat.system.transform": async (_input2, output) => {
+      output.system.push(TOOL_POLICY);
+    },
+    "tool.definition": async (input, output) => {
+      const preference = PREFERRED_TOOL_DESCRIPTIONS[input.toolID];
+      if (preference) {
+        output.description = `${preference} ${output.description}`;
+        return;
+      }
+      const fallback = FALLBACK_TOOL_DESCRIPTIONS[input.toolID];
+      if (fallback)
+        output.description = `${fallback} ${output.description}`;
+    },
+    event: async ({ event }) => {
+      if (event.type === "file.edited" || event.type === "file.watcher.updated") {
+        anchors.forget(event.properties.file);
+        return;
+      }
+      if (event.type === "session.deleted")
+        anchors.deleteSession(event.properties.info.id);
+    },
+    "tool.execute.after": async (input, output) => {
+      if (!input.tool.startsWith("readseek_"))
+        return;
+      try {
+        const result = JSON.parse(output.output);
+        if (input.tool === "readseek_rename") {
+          anchors.planRename(input.sessionID, result);
+          if (record(result).applied === true) {
+            for (const filePath of renameFiles(result))
+              anchors.forget(filePath);
+          }
+        }
+        const files = new Set;
+        collectAnchoredFiles(result, files);
+        for (const filePath of files)
+          anchors.mark(input.sessionID, path2.resolve(filePath));
+      } catch {}
+    },
+    "experimental.session.compacting": async (input, output) => {
+      const context = anchors.render(input.sessionID);
+      if (context)
+        output.context.push(context);
+    }
+  };
+};
+var opencode_readseek_default = { id: "opencode-readseek", server: ReadSeekPlugin };
+export {
+  opencode_readseek_default as default,
+  ReadSeekPlugin
+};