@cortexkit/aft-opencode 0.48.1 → 0.49.0

package/dist/index.js

@@ -9783,6 +9783,23 @@ async function renameIfPresent(from, to) {
       throw error2;
   }
 }
+// ../aft-bridge/dist/error-contract.js
+class AftToolError extends Error {
+  code;
+  response;
+  constructor(message, code, response) {
+    const cause = { code, message, response };
+    super(message, { cause });
+    this.name = "AftToolError";
+    this.code = code;
+    this.response = response;
+  }
+}
+function toolErrorFromResponse(command, response) {
+  const code = typeof response.code === "string" && response.code.length > 0 ? response.code : "unknown_error";
+  const message = typeof response.message === "string" && response.message.length > 0 ? response.message : `${command} failed`;
+  return new AftToolError(message, code, response);
+}
 // ../aft-bridge/dist/jsonc.js
 function stripJsoncSymbols(value) {
   if (Array.isArray(value)) {
@@ -11404,6 +11421,420 @@ function isProcessAlive(pid) {
     return true;
   }
 }
+// ../aft-bridge/dist/path-aliases.js
+class InvalidRequestError extends AftToolError {
+  constructor(message) {
+    super(message, "invalid_request", {
+      success: false,
+      code: "invalid_request",
+      message
+    });
+    this.name = "InvalidRequestError";
+  }
+}
+function isWellFormedUnicodeString(value) {
+  for (let index = 0;index < value.length; index++) {
+    const codeUnit = value.charCodeAt(index);
+    if (codeUnit >= 55296 && codeUnit <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (next < 56320 || next > 57343 || Number.isNaN(next))
+        return false;
+      index++;
+    } else if (codeUnit >= 56320 && codeUnit <= 57343) {
+      return false;
+    }
+  }
+  return true;
+}
+function hasOwn(record, key) {
+  return Object.hasOwn(record, key);
+}
+function invalidPathValue(property) {
+  throw new InvalidRequestError(`'${property}' must be a non-empty well-formed Unicode string`);
+}
+function pathValue(record, property) {
+  const value = record[property];
+  if (typeof value !== "string" || value.length === 0 || !isWellFormedUnicodeString(value)) {
+    invalidPathValue(property);
+  }
+  return value;
+}
+function normalizeAliasPair(record, canonical, legacy, required) {
+  const hasCanonical = hasOwn(record, canonical);
+  const hasLegacy = hasOwn(record, legacy);
+  if (!hasCanonical && !hasLegacy) {
+    if (required) {
+      throw new InvalidRequestError(`'${canonical}' is required`);
+    }
+    return;
+  }
+  if (hasCanonical && hasLegacy) {
+    let canonicalValue;
+    let legacyValue;
+    try {
+      canonicalValue = pathValue(record, canonical);
+      legacyValue = pathValue(record, legacy);
+    } catch {
+      throw new InvalidRequestError(`Invalid request: '${canonical}' and '${legacy}' must both be non-empty well-formed Unicode strings`);
+    }
+    if (canonicalValue !== legacyValue) {
+      throw new InvalidRequestError(`Invalid request: '${canonical}' and '${legacy}' must contain equal decoded strings`);
+    }
+    delete record[legacy];
+    return;
+  }
+  if (hasCanonical) {
+    pathValue(record, canonical);
+    return;
+  }
+  record[canonical] = pathValue(record, legacy);
+  delete record[legacy];
+}
+function validateOptionalCanonicalPath(record, property) {
+  if (hasOwn(record, property))
+    pathValue(record, property);
+}
+function normalizeZoomTargets(record) {
+  if (!hasOwn(record, "targets"))
+    return;
+  const targets = record.targets;
+  const normalizeTarget = (target, index) => {
+    if (!target || typeof target !== "object" || Array.isArray(target)) {
+      throw new InvalidRequestError(`'targets[${index}].path' must be a non-empty string`);
+    }
+    const source = target;
+    const emptyTarget = source.symbol === "" && (hasOwn(source, "path") && source.path === "" || hasOwn(source, "filePath") && source.filePath === "");
+    if (emptyTarget)
+      return { ...source };
+    const normalized = { ...source };
+    try {
+      normalizeAliasPair(normalized, "path", "filePath", true);
+    } catch (error2) {
+      if (error2 instanceof InvalidRequestError) {
+        throw new InvalidRequestError(error2.message.replace("'filePath'", `'targets[${index}].filePath'`).replace("'path'", `'targets[${index}].path'`));
+      }
+      throw error2;
+    }
+    return normalized;
+  };
+  if (Array.isArray(targets)) {
+    if (targets.length === 0)
+      return;
+    record.targets = targets.map(normalizeTarget);
+    return;
+  }
+  if (targets && typeof targets === "object") {
+    record.targets = normalizeTarget(targets, 0);
+  }
+}
+function bareToolName(toolName) {
+  const bare = toolName.startsWith("aft_") ? toolName.slice(4) : toolName;
+  if (bare === "read" || bare === "write" || bare === "edit" || bare === "zoom" || bare === "callgraph" || bare === "safety" || bare === "move" || bare === "import" || bare === "refactor" || bare === "grep" || bare === "search" || bare === "conflicts") {
+    return bare;
+  }
+  return;
+}
+function prepareCanonicalPathArguments(toolName, rawArguments) {
+  if (!rawArguments || typeof rawArguments !== "object" || Array.isArray(rawArguments)) {
+    throw new InvalidRequestError("tool arguments must be an object");
+  }
+  const tool = bareToolName(toolName);
+  const record = { ...rawArguments };
+  if (!tool)
+    return record;
+  switch (tool) {
+    case "read":
+    case "write":
+    case "edit":
+    case "move":
+    case "import":
+    case "refactor":
+      normalizeAliasPair(record, "path", "filePath", true);
+      break;
+    case "zoom":
+      normalizeAliasPair(record, "path", "filePath", false);
+      normalizeZoomTargets(record);
+      break;
+    case "callgraph":
+      normalizeAliasPair(record, "path", "filePath", true);
+      normalizeAliasPair(record, "toPath", "toFile", false);
+      break;
+    case "safety":
+      normalizeAliasPair(record, "path", "filePath", false);
+      break;
+    case "grep":
+    case "search":
+    case "conflicts":
+      validateOptionalCanonicalPath(record, "path");
+      break;
+  }
+  return record;
+}
+var EDIT_ROOT_COMPATIBILITY_KEYS = new Set([
+  "oldString",
+  "newString",
+  "replaceAll",
+  "occurrence"
+]);
+var EDIT_ROOT_CANONICAL_KEYS = new Set(["path", "appendContent", "edits", "symbol", "content"]);
+var EDIT_ITEM_KEYS = new Set([
+  "oldString",
+  "newString",
+  "replaceAll",
+  "occurrence",
+  "startLine",
+  "endLine",
+  "content"
+]);
+var ASCII_WHITESPACE = /^[\t\n\v\f\r ]+$/;
+var ASCII_TRIM = /^[\t\n\v\f\r ]+|[\t\n\v\f\r ]+$/g;
+var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+function prepareCanonicalEditArguments(toolName, rawArguments) {
+  if (!rawArguments || typeof rawArguments !== "object" || Array.isArray(rawArguments)) {
+    throw new InvalidRequestError("tool arguments must be an object");
+  }
+  const raw = rawArguments;
+  const record = copyOwnProperties(raw);
+  normalizeEditPathAlias(record);
+  const suppliedLineFields = ["startLine", "endLine"].filter((key) => hasOwn(record, key));
+  if (suppliedLineFields.length > 0) {
+    throw new InvalidRequestError(`edit: top-level ${suppliedLineFields.map((key) => `'${key}'`).join(" and ")} are invalid; ` + "line-range fields are valid only inside 'edits[]'. " + "Use edits: [{ startLine, endLine, content }].");
+  }
+  const isOpenCodeRetiredBoundary = toolName === "aft_edit";
+  const retiredFields = ["file", "mode"].filter((key) => hasOwn(record, key));
+  if (retiredFields.length > 0 && isOpenCodeRetiredBoundary) {
+    throw new InvalidRequestError("aft_edit: the retired `mode`/`file` edit form is no longer supported; use `path` with " + "exactly one of `appendContent`, `edits`, or `symbol` plus `content`.");
+  }
+  const unknownRootKeys = Object.getOwnPropertyNames(record).filter((key) => !EDIT_ROOT_CANONICAL_KEYS.has(key) && !EDIT_ROOT_COMPATIBILITY_KEYS.has(key) && key !== "filePath").sort();
+  if (unknownRootKeys.length > 0) {
+    throw new InvalidRequestError(formatUnknownKeys(unknownRootKeys));
+  }
+  const modes = editModesPresent(record);
+  if (modes.length > 1) {
+    throw new InvalidRequestError(`edit: conflicting modes: ${modes.join(", ")}`);
+  }
+  if (modes.length === 0) {
+    throw new InvalidRequestError("edit: exactly one of `appendContent`, `edits`, or `symbol` plus `content` is required");
+  }
+  const mode = modes[0];
+  if (mode === "appendContent") {
+    if (typeof record.appendContent !== "string") {
+      throw new InvalidRequestError("edit: 'appendContent' must be a string");
+    }
+  } else if (mode === "edits") {
+    const parsedEdits = parseEditArray(record.edits);
+    record.edits = parsedEdits.map((item, index) => normalizeEditItem(item, index));
+  } else if (mode === "symbol/content") {
+    if (!hasOwn(record, "symbol") || typeof record.symbol !== "string") {
+      throw new InvalidRequestError("edit: 'symbol' must be a string when symbol mode is selected");
+    }
+    if (!hasOwn(record, "content") || typeof record.content !== "string") {
+      throw new InvalidRequestError("edit: symbol mode requires both 'symbol' and 'content' string properties");
+    }
+  } else {
+    const item = {};
+    for (const key of EDIT_ROOT_COMPATIBILITY_KEYS) {
+      if (hasOwn(record, key))
+        item[key] = record[key];
+    }
+    record.edits = [normalizeEditItem(item, 0)];
+    for (const key of EDIT_ROOT_COMPATIBILITY_KEYS)
+      delete record[key];
+  }
+  validateEditPath(record);
+  return record;
+}
+function normalizeEditPathAlias(record) {
+  const hasCanonical = hasOwn(record, "path");
+  const hasLegacy = hasOwn(record, "filePath");
+  if (!hasCanonical && !hasLegacy)
+    return;
+  if (hasCanonical && hasLegacy) {
+    let canonical;
+    let legacy;
+    try {
+      canonical = pathValue(record, "path");
+      legacy = pathValue(record, "filePath");
+    } catch {
+      throw new InvalidRequestError("Invalid request: 'path' and 'filePath' must both be non-empty well-formed Unicode strings");
+    }
+    if (canonical !== legacy) {
+      throw new InvalidRequestError("Invalid request: 'path' and 'filePath' must contain equal decoded strings");
+    }
+    delete record.filePath;
+    return;
+  }
+  if (!hasCanonical) {
+    record.path = pathValue(record, "filePath");
+    delete record.filePath;
+  }
+}
+function validateEditPath(record) {
+  if (!hasOwn(record, "path")) {
+    throw new InvalidRequestError("'path' is required");
+  }
+  pathValue(record, "path");
+}
+function formatUnknownKeys(keys) {
+  return `Unrecognized keys: ${keys.map((key) => `"${key}"`).join(", ")}`;
+}
+function editModesPresent(record) {
+  const modes = [];
+  if (hasOwn(record, "appendContent"))
+    modes.push("appendContent");
+  if (hasOwn(record, "edits"))
+    modes.push("edits");
+  if (hasOwn(record, "symbol") || hasOwn(record, "content"))
+    modes.push("symbol/content");
+  if (["oldString", "newString", "replaceAll", "occurrence"].some((key) => hasOwn(record, key))) {
+    modes.push("oldString/newString");
+  }
+  return modes;
+}
+function parseEditArray(value) {
+  if (typeof value === "string") {
+    let parsed;
+    try {
+      parsed = JSON.parse(value);
+    } catch {
+      throw new InvalidRequestError("edit: 'edits' must contain valid JSON representing an array");
+    }
+    if (!Array.isArray(parsed)) {
+      throw new InvalidRequestError("edit: 'edits' JSON must have an array root");
+    }
+    if (parsed.length === 0) {
+      throw new InvalidRequestError("edit: 'edits' array must not be empty");
+    }
+    return parsed;
+  }
+  if (!Array.isArray(value)) {
+    throw new InvalidRequestError("edit: 'edits' must be a non-empty array");
+  }
+  if (value.length === 0) {
+    throw new InvalidRequestError("edit: 'edits' array must not be empty");
+  }
+  return value;
+}
+function normalizeEditItem(value, index) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new InvalidRequestError(`edit: edits[${index}] must be an object`);
+  }
+  const source = value;
+  const item = copyOwnProperties(source);
+  normalizeItemAlias(item, "oldString", "oldText");
+  normalizeItemAlias(item, "newString", "newText");
+  const hasFindField = ["oldString", "newString", "replaceAll", "occurrence"].some((key) => hasOwn(item, key));
+  const hasRangeField = ["startLine", "endLine", "content"].some((key) => hasOwn(item, key));
+  if (hasFindField && hasRangeField) {
+    throw new InvalidRequestError(`edit: edits[${index}] mixes find/replace and line-range fields`);
+  }
+  if (hasFindField) {
+    if (!hasOwn(item, "oldString") || typeof item.oldString !== "string") {
+      throw new InvalidRequestError(`edit: edits[${index}] requires string 'oldString'`);
+    }
+    if (hasOwn(item, "newString") && typeof item.newString !== "string") {
+      throw new InvalidRequestError(`edit: edits[${index}].newString must be a string`);
+    }
+    coerceEditScalars(item, index);
+    validateEditItemKeys(item, index);
+    return item;
+  }
+  if (hasRangeField) {
+    for (const key of ["startLine", "endLine"]) {
+      const value2 = item[key];
+      if (typeof value2 === "string" && /^[0-9]+$/.test(value2.trim())) {
+        item[key] = Number(value2.trim());
+      }
+      if (!hasOwn(item, key) || !isPositiveSafeInteger(item[key])) {
+        throw new InvalidRequestError(`edit: edits[${index}].${key} must be a positive integer`);
+      }
+    }
+    if (item.startLine > item.endLine) {
+      throw new InvalidRequestError(`edit: edits[${index}] requires startLine <= endLine`);
+    }
+    if (!hasOwn(item, "content") || typeof item.content !== "string") {
+      throw new InvalidRequestError(`edit: edits[${index}] requires string 'content'`);
+    }
+    validateEditItemKeys(item, index);
+    return item;
+  }
+  throw new InvalidRequestError(`edit: edits[${index}] must be a find/replace or line-range item`);
+}
+function normalizeItemAlias(item, canonical, legacy) {
+  if (hasOwn(item, legacy)) {
+    if (!hasOwn(item, canonical))
+      item[canonical] = item[legacy];
+    delete item[legacy];
+  }
+}
+function validateEditItemKeys(item, index) {
+  const unknown = Object.getOwnPropertyNames(item).filter((key) => !EDIT_ITEM_KEYS.has(key)).sort();
+  if (unknown.length > 0) {
+    throw new InvalidRequestError(`edit: edits[${index}] contains ${formatUnknownKeys(unknown)}`);
+  }
+}
+function coerceEditScalars(item, index) {
+  if (hasOwn(item, "replaceAll") && hasOwn(item, "occurrence")) {
+    throw new InvalidRequestError(`edit: edits[${index}] cannot contain both 'replaceAll' and 'occurrence'`);
+  }
+  if (hasOwn(item, "replaceAll"))
+    item.replaceAll = coerceEditBoolean(item.replaceAll, index);
+  if (hasOwn(item, "occurrence")) {
+    const occurrence = coerceEditOccurrence(item.occurrence, index);
+    if (occurrence === undefined)
+      delete item.occurrence;
+    else
+      item.occurrence = occurrence;
+  }
+}
+function coerceEditBoolean(value, index) {
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "number" && Number.isFinite(value) && (value === 0 || value === 1)) {
+    return value === 1;
+  }
+  if (typeof value === "string") {
+    if (value === "1")
+      return true;
+    if (value === "0")
+      return false;
+    if (/^(?:true|false)$/i.test(value))
+      return value.toLowerCase() === "true";
+  }
+  throw new InvalidRequestError(`edit: edits[${index}].replaceAll must be a boolean, true/false string, or 0/1`);
+}
+function coerceEditOccurrence(value, index) {
+  if (value === null)
+    return;
+  if (typeof value === "string") {
+    const trimmed = value.replace(ASCII_TRIM, "");
+    if (trimmed.length === 0 || ASCII_WHITESPACE.test(trimmed))
+      return;
+    if (!/^[+]?[0-9]+$/.test(trimmed)) {
+      throw new InvalidRequestError(`edit: edits[${index}].occurrence must be a positive integer`);
+    }
+    try {
+      const parsed = BigInt(trimmed);
+      if (parsed < 1n || parsed > BigInt(MAX_SAFE_INTEGER))
+        throw new Error("out of range");
+      return Number(parsed);
+    } catch {
+      throw new InvalidRequestError(`edit: edits[${index}].occurrence must be a positive integer`);
+    }
+  }
+  if (typeof value === "number" && isPositiveSafeInteger(value))
+    return value;
+  throw new InvalidRequestError(`edit: edits[${index}].occurrence must be a positive integer`);
+}
+function isPositiveSafeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 1;
+}
+function copyOwnProperties(source) {
+  const copy = Object.create(null);
+  for (const key of Object.getOwnPropertyNames(source))
+    copy[key] = source[key];
+  return copy;
+}
 // ../aft-bridge/dist/project-identity.js
 import { createHash as createHash4 } from "node:crypto";
 import { realpathSync as realpathSync2 } from "node:fs";
@@ -31564,8 +31995,8 @@ function restoreAutoUpdateSnapshot(snapshot) {
     rmSync4(snapshot.tempDir, { recursive: true, force: true });
   }
 }
-function stripPackageNameFromPath(pathValue, packageName) {
-  let current = pathValue;
+function stripPackageNameFromPath(pathValue2, packageName) {
+  let current = pathValue2;
   for (const segment of [...packageName.split("/")].reverse()) {
     if (basename3(current) !== segment)
       return null;
@@ -32707,7 +33138,7 @@ async function ensureServerInstalled(spec, config2, fetchImpl, signal) {
             return null;
           });
           if (currentHash && currentHash !== installedMeta.sha256) {
-            error2(`[lsp] ${spec.npm}@${version2}: TOFU sha256 mismatch — refusing to use ` + `tampered binary. Recorded ${installedMeta.sha256}, current ${currentHash}. ` + `Run \`aft doctor --clear\` to re-install from scratch.`);
+            error2(`[lsp] ${spec.npm}@${version2}: TOFU sha256 mismatch — refusing to use ` + `tampered binary. Recorded ${installedMeta.sha256}, current ${currentHash}. ` + `Run \`npx @cortexkit/aft doctor --clear\` to re-install from scratch.`);
             return {
               started: false,
               reason: `TOFU sha256 mismatch on ${spec.npm}@${version2} — see plugin log`
@@ -33500,7 +33931,7 @@ async function downloadAndInstall(spec, tag, assets, platform3, arch, fetchImpl,
   const previousArchiveSha256 = previousMeta?.archiveSha256 ?? (previousMeta?.binarySha256 ? undefined : previousMeta?.sha256);
   if (previousMeta && previousMeta.version === tag && previousArchiveSha256) {
     if (previousArchiveSha256 !== archiveSha256) {
-      error2(`[lsp] ${spec.id} ${tag}: TOFU sha256 mismatch — refusing install. ` + `Previously installed archive sha256=${previousArchiveSha256}, downloaded sha256=${archiveSha256}. ` + `This means the published release for tag ${tag} changed. Investigate before proceeding. ` + `Run \`aft doctor --clear\` to wipe the cache and force a fresh install if you've verified the change.`);
+      error2(`[lsp] ${spec.id} ${tag}: TOFU sha256 mismatch — refusing install. ` + `Previously installed archive sha256=${previousArchiveSha256}, downloaded sha256=${archiveSha256}. ` + `This means the published release for tag ${tag} changed. Investigate before proceeding. ` + `Run \`npx @cortexkit/aft doctor --clear\` to wipe the cache and force a fresh install if you've verified the change.`);
       try {
         unlinkSync7(archivePath);
       } catch {}
@@ -33732,12 +34163,43 @@ function normalizeToolArgSchemas(toolDefinition) {
   }
   return toolDefinition;
 }
-function normalizeToolMap(tools) {
-  for (const def of Object.values(tools)) {
-    normalizeToolArgSchemas(def);
+function bareToolName2(toolName) {
+  return toolName.startsWith("aft_") ? toolName.slice(4) : toolName;
+}
+function prepareOpenCodeArguments(toolName, rawArguments) {
+  const bare = bareToolName2(toolName);
+  if (bare === "edit") {
+    return prepareCanonicalEditArguments(toolName, rawArguments);
+  }
+  return prepareCanonicalPathArguments(toolName, rawArguments);
+}
+var DISPLAY_FILE_PATH_TOOLS = new Set(["read", "write", "edit"]);
+function preserveDisplayFilePathAlias(toolName, rawArguments, prepared) {
+  if (!DISPLAY_FILE_PATH_TOOLS.has(toolName))
+    return;
+  if (!rawArguments || typeof rawArguments !== "object" || Array.isArray(rawArguments))
+    return;
+  const raw = rawArguments;
+  if (typeof prepared.path === "string" && !Object.hasOwn(raw, "filePath")) {
+    raw.filePath = prepared.path;
+  }
+}
+function prepareToolMap(tools) {
+  for (const [toolName, def] of Object.entries(tools)) {
+    const execute = def.execute;
+    def.execute = async (args, context) => {
+      const prepared = prepareOpenCodeArguments(toolName, args);
+      preserveDisplayFilePathAlias(toolName, args, prepared);
+      return execute(prepared, context);
+    };
   }
   return tools;
 }
+function normalizeToolMap(tools) {
+  for (const def of Object.values(tools))
+    normalizeToolArgSchemas(def);
+  return prepareToolMap(tools);
+}
 // src/shared/ignored-message.ts
 async function sendIgnoredMessage2(client, sessionID, text) {
   const typedClient = client;
@@ -35039,8 +35501,45 @@ function astTools(ctx) {
   };
 }
 
-// src/tools/bash.ts
+// src/tools/conflicts.ts
 import { tool as tool4 } from "@opencode-ai/plugin";
+var z4 = tool4.schema;
+function conflictTools(ctx) {
+  return {
+    aft_conflicts: {
+      description: "Show all git merge conflicts across the repository — returns line-numbered conflict regions with context for every conflicted file in a single call. Conflicts are discovered from the git repository's top level. By default it inspects the session's project repository; pass `path` to inspect a different repository or git worktree (e.g. where a rebase/merge is running).",
+      args: {
+        path: z4.string().describe("Optional path inside the git repository or worktree to inspect (absolute or relative to project root). Conflicts are discovered from that repository's top level. Defaults to the session project root.").optional()
+      },
+      execute: async (args, context) => {
+        const rawArgs = {};
+        if (!isEmptyParam(args?.path)) {
+          const expanded = expandTilde2(String(args.path));
+          const projectRoot = await resolveProjectRoot(ctx, context);
+          const resolved = resolvePathFromProjectRoot(projectRoot, expanded);
+          const denied = await assertExternalDirectoryPermission(ctx, context, resolved, {
+            kind: "directory"
+          });
+          if (denied)
+            return permissionDeniedResponse(denied);
+          rawArgs.path = resolved;
+        }
+        const response = await callToolCall(ctx, context, "conflicts", rawArgs);
+        if (response.success === false) {
+          throw new Error(response.message || "git_conflicts failed");
+        }
+        return response.text;
+      }
+    }
+  };
+}
+
+// src/tools/hoisted.ts
+import * as path4 from "node:path";
+import { tool as tool8 } from "@opencode-ai/plugin";
+
+// src/tools/bash.ts
+import { tool as tool5 } from "@opencode-ai/plugin";
 
 // src/shared/subagent-detect.ts
 var CACHE_MAX_ENTRIES2 = 200;
@@ -35093,7 +35592,7 @@ function setCache2(sessionId, isSubagent) {
 }
 
 // src/tools/bash.ts
-var z4 = tool4.schema;
+var z5 = tool5.schema;
 var METADATA_PREVIEW_LIMIT = 30 * 1024;
 var DEFAULT_HARD_TIMEOUT_MS = 30 * 60 * 1000;
 var BASH_TRANSPORT_MARGIN_MS = 1e4;
@@ -35193,22 +35692,22 @@ async function withPermissionLoop(ctx, runtime, params, bridgeCall, options) {
 function createBashTool(ctx, aftSearchRegisteredOverride) {
   const initialBashCfg = resolveBashConfig(ctx.config);
   const backgroundFlagArg = initialBashCfg.background ? {
-    background: z4.boolean().optional().describe("When true, spawn the command in the background and return a taskId for bash_status/bash_kill instead of waiting for completion. Defaults to false.")
+    background: z5.boolean().optional().describe("When true, spawn the command in the background and return a taskId for bash_status/bash_kill instead of waiting for completion. Defaults to false.")
   } : {};
   const ptyArgs = initialBashCfg.background ? {
-    pty: z4.boolean().optional().describe('When true, spawn the command in a real PTY for interactive programs (python/node/bash REPLs, vim). Implies background: true automatically. Unavailable in subagent sessions. Inspect with bash_status({ taskId, outputMode: "screen" }) and drive interactively with bash_write — its input accepts either a string OR an array like [ "iHello", { key: "esc" }, ":wq", { key: "enter" } ] for atomic text+key sequences.'),
+    pty: z5.boolean().optional().describe('When true, spawn the command in a real PTY for interactive programs (python/node/bash REPLs, vim). Implies background: true automatically. Unavailable in subagent sessions. Inspect with bash_status({ taskId, outputMode: "screen" }) and drive interactively with bash_write — its input accepts either a string OR an array like [ "iHello", { key: "esc" }, ":wq", { key: "enter" } ] for atomic text+key sequences.'),
     ptyRows: optionalInt(1, 60).describe("PTY terminal height in rows — ignored when pty is false. Defaults to 24 when pty: true. Minimum 1, maximum 60."),
     ptyCols: optionalInt(1, 140).describe("PTY terminal width in columns — ignored when pty is false. Defaults to 80 when pty: true. Minimum 1, maximum 140.")
   } : {};
   const args = {
-    command: z4.string().describe("Shell command to execute. Supports pipes, redirection, and normal shell syntax."),
-    timeout: optionalInt(1, Number.MAX_SAFE_INTEGER).describe(initialBashCfg.background ? "Hard kill cap in milliseconds (positive integer). When omitted, the task can run up to 30 minutes. Foreground bash returns inline if the command finishes within ~8s (configurable via bash.foreground_wait_window_ms); otherwise it's automatically promoted to background and a completion reminder is delivered when the task actually finishes." : "Hard kill cap in milliseconds (positive integer). When omitted, the foreground command can run up to 30 minutes and returns inline when it finishes."),
-    workdir: z4.string().optional().describe("Working directory for command execution. Relative paths resolve through the bridge; defaults to the current tool context/project root when omitted."),
-    description: z4.string().optional().describe("Short 5-10 word human-readable summary shown in OpenCode UI metadata instead of raw shell syntax."),
-    wait: z4.boolean().optional().describe("When true, run in the foreground without auto-promoting and wait until the command finishes or reaches its timeout; if you send a new message, the wait detaches to background. Use only when you know the result is required before doing anything else."),
-    sandbox: z4.literal("host").optional().describe("Request one-command approval to run unsandboxed on the host; use only when native sandboxing blocks required work, and note that it is a no-op when sandboxing is disabled."),
+    command: z5.string().describe("Shell command to execute. Supports pipes, redirection, and normal shell syntax."),
+    timeout: optionalInt(1, Number.MAX_SAFE_INTEGER).describe(initialBashCfg.background ? "Hard kill cap in milliseconds (positive integer). In the default foreground mode when wait is false, a command that exceeds the configured wait window is promoted to background and gets a completion reminder when it exits; wait:true disables promotion and remains inline until completion or timeout." : "Hard kill cap in milliseconds (positive integer). When omitted, the foreground command can run up to 30 minutes and returns inline when it finishes."),
+    workdir: z5.string().optional().describe("Working directory for command execution. Relative paths resolve through the bridge; defaults to the current tool context/project root when omitted."),
+    description: z5.string().optional().describe("Short 5-10 word human-readable summary shown in OpenCode UI metadata instead of raw shell syntax."),
+    wait: z5.boolean().optional().describe("When true, run in the foreground without auto-promoting and wait until the command finishes or reaches its timeout; if you send a new message, the wait detaches to background. Use only when you know the result is required before doing anything else."),
+    sandbox: z5.literal("host").optional().describe("Request one-command approval to run unsandboxed on the host; use only when native sandboxing blocks required work, and note that it is a no-op when sandboxing is disabled."),
     ...backgroundFlagArg,
-    compressed: z4.boolean().optional().describe("When true or omitted, return compressed output with noisy terminal control sequences reduced. Set to false for raw output."),
+    compressed: z5.boolean().optional().describe("When true or omitted, return compressed output with noisy terminal control sequences reduced. Set to false for raw output."),
     ...ptyArgs
   };
   return {
@@ -35307,8 +35806,8 @@ function createBashStatusTool(ctx) {
   return {
     description: "Read-only snapshot of a background or PTY bash task's current state and output. Returns immediately. Never waits. One look to check on a task is fine — never loop it to wait for completion. To wait, use bash_watch.",
     args: {
-      taskId: z4.string().describe("Background task ID returned by bash({ background: true }), e.g. bash-6b454047a1c39ded."),
-      outputMode: z4.enum(["screen", "raw", "both"]).optional().describe("PTY output rendering mode. Defaults to screen for PTY tasks and preserves existing behavior for piped tasks when omitted.")
+      taskId: z5.string().describe("Background task ID returned by bash({ background: true }), e.g. bash-6b454047a1c39ded."),
+      outputMode: z5.enum(["screen", "raw", "both"]).optional().describe("PTY output rendering mode. Defaults to screen for PTY tasks and preserves existing behavior for piped tasks when omitted.")
     },
     execute: async (args, context) => {
       const taskId = args.taskId;
@@ -35322,7 +35821,7 @@ function createBashKillTool(ctx) {
   return {
     description: "Terminate a running background bash task spawned with bash({ background: true }). Returns confirmation of kill or an error if the task already finished.",
     args: {
-      taskId: z4.string().describe("Background task ID returned by bash({ background: true }), e.g. bash-6b454047a1c39ded.")
+      taskId: z5.string().describe("Background task ID returned by bash({ background: true }), e.g. bash-6b454047a1c39ded.")
     },
     execute: async (args, context) => {
       const data = await callBashBridge(ctx, context, "bash_kill", {
@@ -35414,44 +35913,6 @@ function shortenCommand(command) {
   return collapsed.length <= 80 ? collapsed : `${collapsed.slice(0, 77)}...`;
 }
 
-// src/tools/conflicts.ts
-import { tool as tool5 } from "@opencode-ai/plugin";
-var z5 = tool5.schema;
-function conflictTools(ctx) {
-  return {
-    aft_conflicts: {
-      description: "Show all git merge conflicts across the repository — returns line-numbered conflict regions with context for every conflicted file in a single call. Conflicts are discovered from the git repository's top level. By default it inspects the session's project repository; pass `path` to inspect a different repository or git worktree (e.g. where a rebase/merge is running).",
-      args: {
-        path: z5.string().describe("Optional path inside the git repository or worktree to inspect (absolute or relative to project root). Conflicts are discovered from that repository's top level. Defaults to the session project root.").optional()
-      },
-      execute: async (args, context) => {
-        const rawArgs = {};
-        if (!isEmptyParam(args?.path)) {
-          const expanded = expandTilde2(String(args.path));
-          const projectRoot = await resolveProjectRoot(ctx, context);
-          const resolved = resolvePathFromProjectRoot(projectRoot, expanded);
-          const denied = await assertExternalDirectoryPermission(ctx, context, resolved, {
-            kind: "directory"
-          });
-          if (denied)
-            return permissionDeniedResponse(denied);
-          rawArgs.path = resolved;
-        }
-        const response = await callToolCall(ctx, context, "conflicts", rawArgs);
-        if (response.success === false) {
-          throw new Error(response.message || "git_conflicts failed");
-        }
-        return response.text;
-      }
-    }
-  };
-}
-
-// src/tools/hoisted.ts
-import * as fs4 from "node:fs";
-import * as path4 from "node:path";
-import { tool as tool8 } from "@opencode-ai/plugin";
-
 // src/tools/bash_watch.ts
 import { tool as tool6 } from "@opencode-ai/plugin";
 var z6 = tool6.schema;
@@ -35569,7 +36030,7 @@ Waited ${waited.elapsed_ms}ms; matched ${JSON.stringify(waited.match ?? "")}${st
 Waited ${waited.elapsed_ms}ms; timeout reached without match.`;
     } else if (waited.reason === "unavailable") {
       text += `
-Waited ${waited.elapsed_ms}ms; the bridge stayed busy and status couldn't be read. The task may still be running — check with bash_status({ taskId }).`;
+Waited ${waited.elapsed_ms}ms; the bridge was busy, so task state is unknown. Do not poll; let the task's completion notification wake the session, or use one bash_status snapshot on the next normal tool call.`;
     } else {
       const stat2 = String(data.status ?? "unknown");
       const e = typeof data.exit_code === "number" ? `, exit ${data.exit_code}` : "";
@@ -35831,6 +36292,12 @@ function relativeToWorktree(fp, worktree) {
 function readAttachments(data) {
   return Array.isArray(data.attachments) ? data.attachments : [];
 }
+function persistFilePathAlias(args, context) {
+  if (typeof args.path === "string" && !Object.hasOwn(args, "filePath")) {
+    args.filePath = args.path;
+  }
+  context.metadata({ metadata: {} });
+}
 function buildUnifiedDiff(fp, before, after) {
   const beforeLines = before.split(`
 `);
@@ -35994,19 +36461,6 @@ function inferBeforeStart(ops, from, beforeLen) {
   return beforeLen;
 }
 var z8 = tool8.schema;
-function diagnosticsOnEditDefault(ctx) {
-  return ctx.config.lsp?.diagnostics_on_edit ?? false;
-}
-async function readCurrentFileForPreview(filePath) {
-  try {
-    return await fs4.promises.readFile(filePath, "utf-8");
-  } catch (error53) {
-    if (error53 && typeof error53 === "object" && "code" in error53 && error53.code === "ENOENT") {
-      return "";
-    }
-    throw error53;
-  }
-}
 var READ_DESCRIPTION = `Read file contents or list directory entries.
 
 Use either startLine/endLine OR offset/limit to read a section of a file.
@@ -36020,96 +36474,99 @@ Behavior:
 - Directories return sorted entries with trailing / for subdirectories
 
 Examples:
-  Read full file: { "filePath": "src/app.ts" }
-  Read lines 50-100: { "filePath": "src/app.ts", "startLine": 50, "endLine": 100 }
-  Read 30 lines from line 200: { "filePath": "src/app.ts", "offset": 200, "limit": 30 }
-  List directory: { "filePath": "src/" }
+  Read full file: { "path": "src/app.ts" }
+  Read lines 50-100: { "path": "src/app.ts", "startLine": 50, "endLine": 100 }
+  Read 30 lines from line 200: { "path": "src/app.ts", "offset": 200, "limit": 30 }
+  List directory: { "path": "src/" }
 `;
 function createReadTool(ctx) {
-  return {
-    description: READ_DESCRIPTION,
-    args: {
-      filePath: z8.string().describe("Path to file or directory (absolute or relative to project root)"),
-      startLine: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line to start reading from"),
-      endLine: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line to stop reading at (inclusive)"),
-      limit: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("Max lines to return (default: 2000)"),
-      offset: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line number to start reading from (use with limit). Ignored if startLine is provided")
-    },
-    execute: async (args, context) => {
-      const file2 = args.filePath;
-      const projectRoot = await resolveProjectRoot(ctx, context);
-      const filePath = resolvePathFromProjectRoot(projectRoot, file2);
-      {
-        const denial = await assertExternalDirectoryPermission(ctx, context, filePath, {
-          serverValidatedRead: true
-        });
-        if (denial)
-          return permissionDeniedResponse(denial);
-      }
-      try {
-        await runAsk(context.ask({
-          permission: "read",
-          patterns: [filePath],
-          always: ["*"],
-          metadata: {}
-        }));
-      } catch (error53) {
-        if (error53 instanceof Error && error53.message)
-          return permissionDeniedResponse(error53.message);
-        return permissionDeniedResponse("Permission denied.");
-      }
-      const rawStartLine = coerceOptionalInt(args.startLine, "startLine", 1, Number.MAX_SAFE_INTEGER);
-      const rawEndLine = coerceOptionalInt(args.endLine, "endLine", 1, Number.MAX_SAFE_INTEGER);
-      const rawLimit = coerceOptionalInt(args.limit, "limit", 1, Number.MAX_SAFE_INTEGER);
-      const rawOffset = coerceOptionalInt(args.offset, "offset", 1, Number.MAX_SAFE_INTEGER);
-      let startLine = rawStartLine;
-      let endLine = rawEndLine;
-      if (startLine === undefined && rawOffset !== undefined) {
-        startLine = rawOffset;
-        if (rawLimit !== undefined) {
-          endLine = rawOffset + rawLimit - 1;
-        }
-      }
-      const rawArgs = { filePath: file2 };
-      if (startLine !== undefined)
-        rawArgs.startLine = startLine;
-      if (endLine !== undefined)
-        rawArgs.endLine = endLine;
-      if (rawLimit !== undefined && rawOffset === undefined)
-        rawArgs.limit = rawLimit;
-      const response = await callToolCall(ctx, context, "read", rawArgs);
-      if (response.success === false) {
-        throw new Error(response.message || "read failed");
-      }
-      const dp = relativeToWorktree(filePath, projectRoot) || file2;
-      const output = response.text;
-      const attachments = readAttachments(response);
-      if (attachments.length > 0) {
-        const toolAttachments = attachments.filter((attachment) => typeof attachment.mime === "string" && typeof attachment.data === "string").map((attachment) => ({
-          type: "file",
-          mime: attachment.mime,
-          url: `data:${attachment.mime};base64,${attachment.data}`
-        }));
-        if (toolAttachments.length > 0) {
-          const first = attachments[0];
-          const firstMime = typeof first.mime === "string" ? first.mime : "";
-          return {
-            output,
-            title: dp,
-            attachments: toolAttachments,
-            metadata: {
-              preview: output,
-              filepath: filePath,
+  return prepareToolMap({
+    read: {
+      description: READ_DESCRIPTION,
+      args: {
+        filePath: z8.string().describe("Path to file or directory (absolute or relative to project root)"),
+        startLine: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line to start reading from"),
+        endLine: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line to stop reading at (inclusive)"),
+        limit: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("Max lines to return (default: 2000)"),
+        offset: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based line number to start reading from (use with limit). Ignored if startLine is provided")
+      },
+      execute: async (args, context) => {
+        const file2 = args.path;
+        const projectRoot = await resolveProjectRoot(ctx, context);
+        const filePath = resolvePathFromProjectRoot(projectRoot, file2);
+        persistFilePathAlias(args, context);
+        {
+          const denial = await assertExternalDirectoryPermission(ctx, context, filePath, {
+            serverValidatedRead: true
+          });
+          if (denial)
+            return permissionDeniedResponse(denial);
+        }
+        try {
+          await runAsk(context.ask({
+            permission: "read",
+            patterns: [filePath],
+            always: ["*"],
+            metadata: {}
+          }));
+        } catch (error53) {
+          if (error53 instanceof Error && error53.message)
+            return permissionDeniedResponse(error53.message);
+          return permissionDeniedResponse("Permission denied.");
+        }
+        const rawStartLine = coerceOptionalInt(args.startLine, "startLine", 1, Number.MAX_SAFE_INTEGER);
+        const rawEndLine = coerceOptionalInt(args.endLine, "endLine", 1, Number.MAX_SAFE_INTEGER);
+        const rawLimit = coerceOptionalInt(args.limit, "limit", 1, Number.MAX_SAFE_INTEGER);
+        const rawOffset = coerceOptionalInt(args.offset, "offset", 1, Number.MAX_SAFE_INTEGER);
+        let startLine = rawStartLine;
+        let endLine = rawEndLine;
+        if (startLine === undefined && rawOffset !== undefined) {
+          startLine = rawOffset;
+          if (rawLimit !== undefined) {
+            endLine = rawOffset + rawLimit - 1;
+          }
+        }
+        const rawArgs = { filePath: file2 };
+        if (startLine !== undefined)
+          rawArgs.startLine = startLine;
+        if (endLine !== undefined)
+          rawArgs.endLine = endLine;
+        if (rawLimit !== undefined && rawOffset === undefined)
+          rawArgs.limit = rawLimit;
+        const response = await callToolCall(ctx, context, "read", rawArgs);
+        if (response.success === false) {
+          throw new Error(response.message || "read failed");
+        }
+        const dp = relativeToWorktree(filePath, projectRoot) || file2;
+        const output = response.text;
+        const attachments = readAttachments(response);
+        if (attachments.length > 0) {
+          const toolAttachments = attachments.filter((attachment) => typeof attachment.mime === "string" && typeof attachment.data === "string").map((attachment) => ({
+            type: "file",
+            mime: attachment.mime,
+            url: `data:${attachment.mime};base64,${attachment.data}`
+          }));
+          if (toolAttachments.length > 0) {
+            const first = attachments[0];
+            const firstMime = typeof first.mime === "string" ? first.mime : "";
+            return {
+              output,
               title: dp,
-              isImage: first.kind === "image" || firstMime.startsWith("image/"),
-              isPdf: first.kind === "pdf" || firstMime === "application/pdf"
-            }
-          };
+              attachments: toolAttachments,
+              metadata: {
+                preview: output,
+                filepath: filePath,
+                title: dp,
+                isImage: first.kind === "image" || firstMime.startsWith("image/"),
+                isPdf: first.kind === "pdf" || firstMime === "application/pdf"
+              }
+            };
+          }
         }
+        return { output, title: dp, metadata: { title: dp } };
       }
-      return { output, title: dp, metadata: { title: dp } };
     }
-  };
+  }).read;
 }
 function getWriteDescription(ctx, editToolName) {
   const backupText = ctx.config.backup?.enabled === false ? "Backup capture is disabled by user config." : "Existing files are backed up before overwriting (undo via aft_safety).";
@@ -36123,10 +36580,12 @@ function createWriteTool(ctx, editToolName = "edit") {
       content: z8.string().describe("The full content to write to the file")
     },
     execute: async (args, context) => {
-      const file2 = args.filePath;
+      const argsRecord = args;
+      const file2 = args.path;
       const content = args.content;
       const projectRoot = await resolveProjectRoot(ctx, context);
       const filePath = resolvePathFromProjectRoot(projectRoot, file2);
+      persistFilePathAlias(argsRecord, context);
       const relPath = path4.relative(projectRoot, filePath);
       {
         const denial2 = await assertExternalDirectoryPermission(ctx, context, filePath);
@@ -36136,7 +36595,7 @@ function createWriteTool(ctx, editToolName = "edit") {
       const rawArgs = { filePath: file2, content };
       const preview2 = await callToolCall(ctx, context, "write", rawArgs, { preview: true });
       if (preview2.success === false) {
-        throw new Error(preview2.message || "write preview failed");
+        throw toolErrorFromResponse("write", preview2);
       }
       const denial = await askEditPermission(context, [relPath], {
         filepath: filePath,
@@ -36146,7 +36605,7 @@ function createWriteTool(ctx, editToolName = "edit") {
         return permissionDeniedResponse(denial);
       const data = await callToolCall(ctx, context, "write", rawArgs);
       if (data.success === false) {
-        throw new Error(data.message || "write failed");
+        throw toolErrorFromResponse("write", data);
       }
       const output = data.text;
       const diff = data.diff;
@@ -36156,20 +36615,20 @@ function createWriteTool(ctx, editToolName = "edit") {
       const dp = relativeToWorktree(filePath, projectRoot);
       const beforeContent = diff.before ?? "";
       const afterContent = diff.after ?? content;
+      const patch = truncated ? typeof preview2.preview_diff === "string" ? preview2.preview_diff : "" : buildUnifiedDiff(filePath, beforeContent, afterContent);
       return {
         output,
         title: dp,
         metadata: {
-          diff: truncated ? typeof preview2.preview_diff === "string" ? preview2.preview_diff : "" : buildUnifiedDiff(filePath, beforeContent, afterContent),
-          ...truncated ? {} : {
+          diff: patch,
+          ...patch ? {
             filediff: {
               file: filePath,
-              before: beforeContent,
-              after: afterContent,
-              additions: diff?.additions ?? 0,
-              deletions: diff?.deletions ?? 0
+              patch,
+              additions: diff.additions ?? 0,
+              deletions: diff.deletions ?? 0
             }
-          },
+          } : {},
           diagnostics: {}
         }
       };
@@ -36182,40 +36641,33 @@ function getEditDescription(ctx, writeToolName) {
 
 **Modes** (determined by which parameters you provide):
 
-Mode priority: appendContent > edits > symbol (without oldString) > oldString (find/replace). If none match, the call is rejected — there is no implicit "write" fallback. To edit multiple files, make parallel \`edit\` calls in one response.
+Provide exactly one mode per call: appendContent, edits[], or symbol plus content. Mixing modes or providing none is rejected — there is no implicit "write" fallback. To edit multiple files, make parallel \`edit\` calls in one response.
 
-1. **Append** — pass \`filePath\` + \`appendContent\`
-   Appends text to the end of a file, creating the file if it does not exist.
-   Example: \`{ "filePath": "notes.txt", "appendContent": "new line\\n" }\`
+1. **Append** — pass \`path\` + \`appendContent\`
+   Appends text to the end of a file, creating it if it does not exist.
+   Example: \`{ "path": "notes.txt", "appendContent": "new line\\n" }\`
 
-2. **Batch edits** — pass \`filePath\` + \`edits\` array
+2. **Batch edits** — pass \`path\` + \`edits\` array
    Multiple edits in one file atomically. Each edit is either:
    - \`{ "oldString": "old", "newString": "new" }\` — find/replace
    - \`{ "oldString": "old", "newString": "new", "replaceAll": true }\` — replace every match
    - \`{ "startLine": 5, "endLine": 7, "content": "new lines" }\` — replace line range (1-based, both inclusive)
    Set content to empty string to delete lines.
 
-3. **Symbol replace** — pass \`filePath\` + \`symbol\` + \`content\`
-   Replaces an entire named symbol (function, class, type) with new content.
+3. **Symbol replace** — pass \`path\` + \`symbol\` + \`content\`
+   Replaces an entire named symbol (function, class, type).
    Includes decorators, attributes, and doc comments in the replacement range.
-   **Important:** You must NOT provide \`oldString\` when using symbol mode — if present, the tool silently falls back to find/replace mode.
-   Example: \`{ "filePath": "src/app.ts", "symbol": "handleRequest", "content": "function handleRequest() { ... }" }\`
+   Example: \`{ "path": "src/app.ts", "symbol": "handleRequest", "content": "function handleRequest() { ... }" }\`
 
-4. **Find and replace** — pass \`filePath\` + \`oldString\` + \`newString\`
+4. **Find and replace** — put \`oldString\` and optional \`newString\` in an item of \`edits[]\`
    Finds the exact text in \`oldString\` and replaces it with \`newString\`.
    Supports fuzzy matching (handles whitespace differences automatically).
-   If multiple matches exist, specify which one with \`occurrence\` or use \`replaceAll: true\`.
-   Example: \`{ "filePath": "src/app.ts", "oldString": "const x = 1", "newString": "const x = 2" }\`
+   If multiple matches exist, specify \`occurrence\` or set \`replaceAll: true\` in that item.
 
-5. **Replace all occurrences** — add \`replaceAll: true\`
-   Replaces every occurrence of \`oldString\` in the file.
-   Example: \`{ "filePath": "src/app.ts", "oldString": "oldName", "newString": "newName", "replaceAll": true }\`
+5. **Replace all occurrences** — add \`replaceAll: true\` to a find/replace item.
 
-6. **Select specific occurrence** — add \`occurrence: N\` (0-indexed)
-   When multiple matches exist, select the Nth one (0 = first, 1 = second, etc.).
-   Example: \`{ "filePath": "src/app.ts", "oldString": "TODO", "newString": "DONE", "occurrence": 0 }\`
-
-Note: Modes 5 and 6 are options on mode 4 (find/replace) — they require \`oldString\`.
+6. **Select specific occurrence** — add \`occurrence: N\` to a find/replace item (1-based).
+   When multiple matches exist, select the Nth one (1 = first, 2 = second, etc.).
 
 **Behavior:**
 ${backupBehavior}
@@ -36228,64 +36680,45 @@ function createEditTool(ctx, writeToolName = "write") {
   return {
     description: getEditDescription(ctx, writeToolName),
     args: {
-      filePath: z8.string().optional().describe("Path to the file to edit (absolute or relative to project root)"),
-      oldString: z8.string().optional().describe("Text to find (exact match, with fuzzy fallback)"),
-      newString: z8.string().optional().describe("Text to replace with (omit or set to empty string to delete the matched text)"),
-      replaceAll: z8.boolean().optional().describe("Replace all occurrences"),
-      occurrence: optionalInt(0, Number.MAX_SAFE_INTEGER).describe("0-indexed occurrence to replace when multiple matches exist"),
+      filePath: z8.string().describe("Path to the file to edit (absolute or relative to project root)"),
       symbol: z8.string().optional().describe("Named symbol to replace (function, class, type)"),
       content: z8.string().optional().describe("Replacement content for symbol mode. For whole-file writes, use the `write` tool."),
-      appendContent: z8.string().optional().describe("Text to append to the end of filePath; creates the file if needed"),
+      appendContent: z8.string().optional().describe("Text to append to the end of path; creates the file if needed"),
       edits: z8.array(z8.object({
         oldString: z8.string().optional().describe("Text to find for a batch find/replace edit"),
         newString: z8.string().optional().describe("Replacement text for a batch find/replace edit"),
         replaceAll: z8.boolean().optional().describe("Replace every occurrence for this batch item"),
-        occurrence: optionalInt(0, Number.MAX_SAFE_INTEGER).describe("0-indexed occurrence for this batch item"),
+        occurrence: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based occurrence for this batch item (1 = first match)"),
         startLine: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based start line for a batch line-range edit"),
         endLine: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("1-based end line for a batch line-range edit"),
         content: z8.string().optional().describe("Replacement text for a batch line-range edit")
-      })).optional().describe("Batch edits — array of { oldString, newString }, { oldString, newString, replaceAll: true }, or { startLine, endLine, content } objects")
+      })).min(1).optional().describe("Batch edits — non-empty array of { oldString, newString }, { oldString, newString, replaceAll: true }, or { startLine, endLine, content } objects")
     },
     execute: async (args, context) => {
       const argsRecord = args;
       if (argsRecord.startLine !== undefined || argsRecord.endLine !== undefined) {
-        throw new Error("edit: 'startLine'/'endLine' are not top-level parameters. " + "For line-range edits, nest them inside the `edits` array: " + '`edits: [{ startLine: N, endLine: M, content: "..." }]`. ' + "For find/replace, use `oldString`/`newString` instead.");
+        throw new Error("edit: 'startLine'/'endLine' are not top-level parameters. " + "For line-range edits, nest them inside the `edits` array: " + '`edits: [{ startLine: N, endLine: M, content: "..." }]`. ' + "For find/replace, use an item in `edits[]` instead.");
       }
-      const file2 = args.filePath;
+      const file2 = args.path;
       if (!file2)
-        throw new Error("'filePath' parameter is required");
+        throw new Error("'path' parameter is required");
       const projectRoot = await resolveProjectRoot(ctx, context);
       const filePath = resolvePathFromProjectRoot(projectRoot, file2);
+      persistFilePathAlias(argsRecord, context);
       const relPath = path4.relative(projectRoot, filePath);
       {
         const denial2 = await assertExternalDirectoryPermission(ctx, context, filePath);
         if (denial2)
           return permissionDeniedResponse(denial2);
       }
-      const occurrence = coerceOptionalInt(args.occurrence, "occurrence", 0, Number.MAX_SAFE_INTEGER);
-      const rawArgs = { filePath: file2 };
-      for (const key of ["appendContent", "symbol", "content", "oldString", "newString"]) {
+      const rawArgs = { path: file2 };
+      for (const key of ["appendContent", "symbol", "content", "edits"]) {
         if (argsRecord[key] !== undefined)
           rawArgs[key] = argsRecord[key];
       }
-      if (Array.isArray(argsRecord.edits)) {
-        rawArgs.edits = argsRecord.edits.map((item) => {
-          if (!item || typeof item !== "object" || Array.isArray(item))
-            return item;
-          const batchItem = item;
-          return batchItem.replaceAll === undefined ? batchItem : { ...batchItem, replaceAll: coerceBoolean(batchItem.replaceAll) };
-        });
-      } else if (argsRecord.edits !== undefined) {
-        rawArgs.edits = argsRecord.edits;
-      }
-      if (argsRecord.replaceAll !== undefined) {
-        rawArgs.replaceAll = coerceBoolean(argsRecord.replaceAll);
-      }
-      if (occurrence !== undefined)
-        rawArgs.occurrence = occurrence;
       const preview2 = await callToolCall(ctx, context, "edit", rawArgs, { preview: true });
       if (preview2.success === false) {
-        throw new Error(preview2.message || "edit preview failed");
+        throw toolErrorFromResponse("edit", preview2);
       }
       const denial = await askEditPermission(context, [relPath], {
         filepath: filePath,
@@ -36295,7 +36728,7 @@ function createEditTool(ctx, writeToolName = "write") {
         return permissionDeniedResponse(denial);
       const data = await callToolCall(ctx, context, "edit", rawArgs);
       if (data.success === false) {
-        throw new Error(data.message || "edit failed");
+        throw toolErrorFromResponse("edit", data);
       }
       const output = data.text;
       const diff = data.diff;
@@ -36304,17 +36737,17 @@ function createEditTool(ctx, writeToolName = "write") {
       const truncated = diff.truncated === true;
       const beforeContent = diff.before ?? "";
       const afterContent = diff.after ?? "";
+      const patch = truncated ? typeof preview2.preview_diff === "string" ? preview2.preview_diff : "" : buildUnifiedDiff(filePath, beforeContent, afterContent);
       const uiMeta = {
-        diff: truncated ? typeof preview2.preview_diff === "string" ? preview2.preview_diff : "" : buildUnifiedDiff(filePath, beforeContent, afterContent),
-        ...truncated ? {} : {
+        diff: patch,
+        ...patch ? {
           filediff: {
             file: filePath,
-            before: beforeContent,
-            after: afterContent,
+            patch,
             additions: diff.additions ?? 0,
             deletions: diff.deletions ?? 0
           }
-        },
+        } : {},
         diagnostics: {}
       };
       return { output, title: relativeToWorktree(filePath, projectRoot), metadata: uiMeta };
@@ -36494,12 +36927,12 @@ function createMoveTool(ctx) {
   return {
     description: moveDescription(ctx),
     args: {
-      filePath: z8.string().describe("Source file path to move (absolute or relative to project root)"),
+      path: z8.string().describe("Source file path to move (absolute or relative to project root)"),
       destination: z8.string().describe("Destination file path (absolute or relative to project root)")
     },
     execute: async (args, context) => {
       const projectRoot = await resolveProjectRoot(ctx, context);
-      const filePath = resolvePathFromProjectRoot(projectRoot, args.filePath);
+      const filePath = resolvePathFromProjectRoot(projectRoot, args.path);
       const destPath = resolvePathFromProjectRoot(projectRoot, args.destination);
       {
         const sourceDenial = await assertExternalDirectoryPermission(ctx, context, filePath, {
@@ -36520,7 +36953,7 @@ function createMoveTool(ctx) {
         metadata: { action: "move" }
       }));
       const result = await callToolCall(ctx, context, "move", {
-        filePath: args.filePath,
+        filePath: args.path,
         destination: args.destination
       });
       if (result.success === false) {
@@ -36549,51 +36982,14 @@ function hoistedTools(ctx) {
       tools.bash_kill = createBashKillTool(ctx);
     }
   }
-  return tools;
+  return prepareToolMap(tools);
 }
 function aftPrefixedTools(ctx) {
   const aftEditTool = createEditTool(ctx, "aft_write");
   const tools = {
     aft_read: createReadTool(ctx),
     aft_write: createWriteTool(ctx, "aft_edit"),
-    aft_edit: {
-      ...aftEditTool,
-      execute: async (args, context) => {
-        const argRecord = args;
-        const normalizedArgs = argRecord.mode !== undefined && argRecord.filePath === undefined && typeof argRecord.file === "string" ? { ...argRecord, filePath: argRecord.file } : { ...argRecord };
-        if (normalizedArgs.mode === "write" && typeof normalizedArgs.filePath === "string" && typeof normalizedArgs.content === "string") {
-          const file2 = normalizedArgs.filePath;
-          const projectRoot = await resolveProjectRoot(ctx, context);
-          const filePath = resolvePathFromProjectRoot(projectRoot, file2);
-          const relPath = path4.relative(projectRoot, filePath);
-          {
-            const denial2 = await assertExternalDirectoryPermission(ctx, context, filePath);
-            if (denial2)
-              return permissionDeniedResponse(denial2);
-          }
-          const currentContent = await readCurrentFileForPreview(filePath);
-          const previewDiff = buildUnifiedDiff(filePath, currentContent, normalizedArgs.content);
-          const denial = await askEditPermission(context, [relPath], {
-            filepath: filePath,
-            diff: previewDiff
-          });
-          if (denial)
-            return permissionDeniedResponse(denial);
-          const writeParams = {
-            file: filePath,
-            content: normalizedArgs.content,
-            create_dirs: normalizedArgs.create_dirs !== false,
-            diagnostics: normalizedArgs.diagnostics ?? diagnosticsOnEditDefault(ctx)
-          };
-          const response = await callBridge(ctx, context, "write", writeParams);
-          if (response.success === false) {
-            throw new Error(response.message ?? "write failed");
-          }
-          return JSON.stringify(response);
-        }
-        return aftEditTool.execute(normalizedArgs, context);
-      }
-    },
+    aft_edit: aftEditTool,
     aft_apply_patch: createApplyPatchTool(ctx),
     aft_delete: createDeleteTool(ctx),
     aft_move: createMoveTool(ctx)
@@ -36608,7 +37004,7 @@ function aftPrefixedTools(ctx) {
       tools.bash_kill = createBashKillTool(ctx);
     }
   }
-  return tools;
+  return prepareToolMap(tools);
 }
 
 // src/tools/imports.ts
@@ -36616,17 +37012,17 @@ import { tool as tool9 } from "@opencode-ai/plugin";
 var z9 = tool9.schema;
 function importTools(ctx) {
   const organizeRecovery = ctx.config.backup?.enabled === false ? "Backup capture is disabled by user config; review broad cleanup changes before proceeding." : "Use aft_safety checkpoint/undo for recovery before broad cleanup.";
-  return {
+  return prepareToolMap({
     aft_import: {
       description: `Language-aware import management. Supports TS, JS, TSX, Python, Rust, Go, Solidity, Java, C#, PHP, Kotlin, Scala, Swift, Ruby, Lua, C, C++, Perl, and Vue.
 
 ` + `Ops:
 ` + `- 'add': Add an import. Auto-detects group (stdlib/external/internal), deduplicates. Requires 'module'. Optional 'names', 'defaultImport', 'typeOnly'.
 ` + `- 'remove': Remove an import or a specific named import. Requires 'module'. Provide 'removeName' to remove a single named import; omit to remove the entire import.
-` + `- 'organize': Re-sort and re-group all imports by language convention, deduplicate. Requires only 'filePath'. ${organizeRecovery}`,
+` + `- 'organize': Re-sort and re-group all imports by language convention, deduplicate. Requires only 'path'. ${organizeRecovery}`,
       args: {
         op: z9.enum(["add", "remove", "organize"]).describe("Import operation"),
-        filePath: z9.string().describe("Path to the file (absolute or relative to project root)"),
+        path: z9.string().describe("Path to the file (absolute or relative to project root)"),
         module: z9.string().optional().describe("Module path (required for add, remove — e.g. 'react', './utils', 'std::fmt')"),
         names: z9.array(z9.string()).optional().describe("Named imports to add. Each entry uses the language's native named-import text, " + "including per-name aliasing where the language uses `as` (e.g. ['useState', 'debounce as db'], " + "Solidity ['ERC20', 'IERC20 as IToken'])."),
         defaultImport: z9.string().optional().describe("Default import name, ES only (e.g. 'React')"),
@@ -36643,7 +37039,7 @@ function importTools(ctx) {
         if ((op === "add" || op === "remove") && isEmptyParam(args.module)) {
           throw new Error(`'module' is required for '${op}' op`);
         }
-        const filePath = await resolvePathArg(ctx, context, args.filePath);
+        const filePath = await resolvePathArg(ctx, context, args.path);
         {
           const denial = await assertExternalDirectoryPermission(ctx, context, filePath);
           if (denial)
@@ -36680,7 +37076,7 @@ function importTools(ctx) {
         return response.text;
       }
     }
-  };
+  });
 }
 
 // src/tools/inspect.ts
@@ -36787,7 +37183,7 @@ import { tool as tool11 } from "@opencode-ai/plugin";
 var z11 = tool11.schema;
 var CALLGRAPH_SOFT_CODES = new Set(["symbol_not_found", "callgraph_building"]);
 function navigationTools(ctx) {
-  return {
+  return prepareToolMap({
     aft_callgraph: {
       description: `Answer code-relationship questions from a real call graph — instead of grep + read chains. Reach for this whenever the question is about how symbols connect: who calls X, what X calls, what breaks if X changes, how execution reaches X, or how a value flows.
 
@@ -36796,27 +37192,27 @@ function navigationTools(ctx) {
 ` + `- 'impact': What breaks if a symbol changes — affected callers with signatures and entry-point status (blast radius). Use before a risky edit.
 ` + `- 'call_tree': What a function calls (forward traversal). Use to understand a function's dependencies before modifying it.
 ` + `- 'trace_to': How execution reaches a function from entry points (routes, exports, main). Use to understand context around deeply-nested code.
-` + `- 'trace_to_symbol': Shortest call path from one symbol to another. Requires 'toSymbol'. If multiple targets match, the error returns candidate files; retry with 'toFile' to disambiguate.
+` + `- 'trace_to_symbol': Shortest call path from one symbol to another. Requires 'toSymbol'. If multiple targets match, the error returns candidate files; retry with 'toPath' to disambiguate.
 ` + `- 'trace_data': Follow a value through variable assignments and function parameters across files. Requires 'symbol' (scope to trace from) and 'expression'.
 
-` + `All ops require both 'filePath' and 'symbol'. 'expression' is additionally required for trace_data; 'toSymbol' for trace_to_symbol.
+` + `All ops require both 'path' and 'symbol'. 'expression' is additionally required for trace_data; 'toSymbol' for trace_to_symbol.
 
 ` + `Markers: ~ = edge resolved by name only (may point at the wrong same-named symbol); [unresolved] = callee not resolved to a definition, so the location shown is the call site. Unmarked edges are resolved exactly. By default, unresolved external/stdlib leaf calls in call_tree are collapsed into one summary per parent; pass includeUnresolved=true to show every unresolved edge individually.
 `,
       args: {
         op: z11.enum(["call_tree", "callers", "trace_to", "trace_to_symbol", "impact", "trace_data"]).describe("Navigation operation"),
-        filePath: z11.string().describe("Path to the source file containing the symbol (absolute or relative to project root)"),
+        path: z11.string().describe("Path to the source file containing the symbol (absolute or relative to project root)"),
         symbol: z11.string().describe("Name of the symbol to analyze"),
         depth: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("Max traversal depth (default: call_tree=5, callers=1, trace_to=10, trace_to_symbol=10 capped at 16, impact=5, trace_data=5)"),
         expression: z11.string().optional().describe("Expression to track through data flow (required for trace_data op)"),
         toSymbol: z11.string().optional().describe("Target symbol name for trace_to_symbol; the returned path ends at this symbol"),
-        toFile: z11.string().optional().describe("Optional target file for trace_to_symbol; required when toSymbol exists in multiple files"),
+        toPath: z11.string().optional().describe("Optional target file for trace_to_symbol; required when toSymbol exists in multiple files"),
         includeTests: z11.boolean().optional().describe("Include test files in callers/paths. Defaults to false; tests are hidden."),
         includeUnresolved: z11.boolean().optional().describe("Show every unresolved external/stdlib call individually. Defaults to false; unresolved leaf calls are collapsed into one summary per parent.")
       },
       execute: async (args, context) => {
-        if (isEmptyParam(args.filePath)) {
-          throw new Error("'filePath' is required");
+        if (isEmptyParam(args.path)) {
+          throw new Error("'path' is required");
         }
         if (isEmptyParam(args.symbol)) {
           throw new Error("'symbol' is required");
@@ -36827,8 +37223,8 @@ function navigationTools(ctx) {
         if (args.op === "trace_to_symbol" && isEmptyParam(args.toSymbol)) {
           throw new Error("'toSymbol' is required for 'trace_to_symbol' op");
         }
-        const filePath = await resolvePathArg(ctx, context, args.filePath);
-        const toFile = !isEmptyParam(args.toFile) ? await resolvePathArg(ctx, context, args.toFile) : undefined;
+        const filePath = await resolvePathArg(ctx, context, args.path);
+        const toFile = !isEmptyParam(args.toPath) ? await resolvePathArg(ctx, context, args.toPath) : undefined;
         const checked = new Set;
         for (const target of [filePath, ...toFile !== undefined ? [toFile] : []]) {
           if (checked.has(target))
@@ -36840,7 +37236,7 @@ function navigationTools(ctx) {
         }
         const rawArgs = {
           op: args.op,
-          filePath: args.filePath,
+          filePath: args.path,
           symbol: args.symbol
         };
         const depth = coerceOptionalInt(args.depth, "depth", 1, Number.MAX_SAFE_INTEGER);
@@ -36850,8 +37246,8 @@ function navigationTools(ctx) {
           rawArgs.expression = args.expression;
         if (!isEmptyParam(args.toSymbol))
           rawArgs.toSymbol = args.toSymbol;
-        if (!isEmptyParam(args.toFile))
-          rawArgs.toFile = args.toFile;
+        if (!isEmptyParam(args.toPath))
+          rawArgs.toFile = args.toPath;
         if (!isEmptyParam(args.includeTests))
           rawArgs.includeTests = coerceBoolean(args.includeTests);
         if (!isEmptyParam(args.includeUnresolved))
@@ -36867,23 +37263,26 @@ function navigationTools(ctx) {
         return response.text;
       }
     }
-  };
+  });
 }
 
 // src/tools/reading.ts
 import { tool as tool12 } from "@opencode-ai/plugin";
 var z12 = tool12.schema;
 function buildZoomTitle(args) {
-  if (!isEmptyParam(args.targets)) {
-    if (Array.isArray(args.targets)) {
-      if (args.targets.length === 1 && args.targets[0]) {
-        return `${args.targets[0].filePath}#${args.targets[0].symbol}`;
+  const targets = args.targets;
+  if (!isEmptyParam(targets)) {
+    if (Array.isArray(targets)) {
+      if (targets.length === 1) {
+        return `${targets[0].path}#${targets[0].symbol}`;
       }
-      return `${args.targets.length} targets across files`;
+      return `${targets.length} targets across files`;
+    }
+    if (targets && typeof targets === "object") {
+      return `${targets.path}#${targets.symbol}`;
     }
-    return `${args.targets.filePath}#${args.targets.symbol}`;
   }
-  const path5 = args.filePath ?? args.url ?? "";
+  const path5 = args.path ?? args.url ?? "";
   if (typeof args.symbols === "string")
     return path5 ? `${path5}#${args.symbols}` : args.symbols;
   if (Array.isArray(args.symbols) && args.symbols.length > 0) {
@@ -36894,7 +37293,7 @@ function buildZoomTitle(args) {
   return path5 || "(no target)";
 }
 function readingTools(ctx) {
-  return {
+  return prepareToolMap({
     aft_outline: {
       description: "Structural outline of source code, documentation files, or remote URLs. For code, returns symbols (functions, classes, types) with line ranges. For Markdown and HTML, returns heading hierarchy. Use this to explore structure before reading specific sections with aft_zoom. Set `files: true` with a directory target for a flat indexed file tree with language, symbol count, and byte metadata.\n\n" + "For understanding a specific feature, prefer aft_search + aft_zoom on named symbols; use aft_outline on a whole directory only for high-level structure mapping. aft_zoom with `callgraph:true` gives one-level forward calls-out; use aft_callgraph only for reverse callers or multi-level traces.\n\n" + "Pass a single `target`:\n" + `  • file path → outline that file (with signatures)
 ` + `  • directory path → outline all source files under it (recursively, up to 200 files)
@@ -36943,21 +37342,21 @@ function readingTools(ctx) {
       }
     },
     aft_zoom: {
-      description: "Inspect code symbols or documentation sections. For code, returns the full source of a symbol. Pass `callgraph: true` to also include call-graph annotations (calls-out / called-by within the same file). For Markdown and HTML, returns the section content under the given heading.\n\nUse exactly ONE mode: `{ filePath, symbols }`, `{ url, symbols }`, or `{ targets }`. `symbols` can be a string or array (one or many lookups in the same file/URL). Use `targets` for cross-file batches: `{ filePath, symbol }` or an array of them.",
+      description: "Inspect code symbols or documentation sections. For code, returns the full source of a symbol. Pass `callgraph: true` to also include call-graph annotations (calls-out / called-by within the same file). For Markdown and HTML, returns the section content under the given heading.\n\nUse exactly ONE mode: `{ path, symbols }`, `{ url, symbols }`, or `{ targets }`. `symbols` can be a string or array (one or many lookups in the same file/URL). Use `targets` for cross-file batches: `{ path, symbol }` or an array of them.",
       args: {
-        filePath: z12.string().optional().describe("Path to file (absolute or relative to project root)"),
+        path: z12.string().optional().describe("Path to file (absolute or relative to project root)"),
         url: z12.string().optional().describe("HTTP/HTTPS URL of an HTML or Markdown document to fetch and zoom into"),
         symbols: z12.union([z12.string(), z12.array(z12.string())]).optional().describe("Symbol name for code, or heading text for Markdown/HTML. Pass a string for one lookup or an array for batched lookups in the same file/URL."),
         targets: z12.union([
           z12.object({
-            filePath: z12.string().describe("Path to file (absolute or relative to project root)"),
+            path: z12.string().describe("Path to file (absolute or relative to project root)"),
             symbol: z12.string().describe("Symbol name in that file")
           }),
           z12.array(z12.object({
-            filePath: z12.string().describe("Path to file (absolute or relative to project root)"),
+            path: z12.string().describe("Path to file (absolute or relative to project root)"),
             symbol: z12.string().describe("Symbol name in that file")
           }))
-        ]).optional().describe("Cross-file batch: `{ filePath, symbol }` or an array of them. Mutually exclusive with filePath/url/symbols."),
+        ]).optional().describe("Cross-file batch: `{ path, symbol }` or an array of them. Mutually exclusive with path/url/symbols."),
         contextLines: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("Lines of context before/after the symbol (default: 3)"),
         callgraph: z12.boolean().optional().describe("Include call-graph annotations (calls-out / called-by within the same file). Default false; off keeps zoom output minimal.")
       },
@@ -36968,7 +37367,7 @@ function readingTools(ctx) {
           const entryEmpty = (entry) => {
             if (!entry || typeof entry !== "object")
               return true;
-            const fp = entry.filePath;
+            const fp = entry.path;
             const sym = entry.symbol;
             const fpEmpty = typeof fp !== "string" || fp.length === 0;
             const symEmpty = typeof sym !== "string" || sym.length === 0;
@@ -36978,7 +37377,7 @@ function readingTools(ctx) {
             return !t.every(entryEmpty);
           return !entryEmpty(t);
         };
-        const hasFilePath = !isEmptyParam(args.filePath);
+        const hasFilePath = !isEmptyParam(args.path);
         const hasUrl = !isEmptyParam(args.url);
         const hasTargets = hasTargetsProvided(args.targets);
         const hasSymbols = !isEmptyParam(args.symbols);
@@ -36987,7 +37386,7 @@ function readingTools(ctx) {
         const zoomTitle = buildZoomTitle(args);
         const zoomDisplay = { title: zoomTitle };
         if (hasFilePath)
-          zoomDisplay.filePath = args.filePath;
+          zoomDisplay.path = args.path;
         if (hasUrl)
           zoomDisplay.url = args.url;
         if (hasSymbols) {
@@ -37006,25 +37405,31 @@ function readingTools(ctx) {
         });
         if (hasTargets) {
           if (hasFilePath || hasUrl || hasSymbols) {
-            throw new Error("'targets' is mutually exclusive with 'filePath', 'url', and 'symbols'");
+            throw new Error("'targets' is mutually exclusive with 'path', 'url', and 'symbols'");
           }
           const targets = Array.isArray(args.targets) ? args.targets : [args.targets];
           if (targets.length === 0) {
             throw new Error("'targets' must be a non-empty object or array");
           }
           for (const [i, entry] of targets.entries()) {
-            if (!entry || typeof entry.filePath !== "string" || entry.filePath.length === 0) {
-              throw new Error(`targets[${i}].filePath must be a non-empty string`);
+            const targetPath = entry?.path;
+            if (typeof targetPath !== "string" || targetPath.length === 0) {
+              throw new Error(`targets[${i}].path must be a non-empty string`);
             }
             if (typeof entry.symbol !== "string" || entry.symbol.length === 0) {
               throw new Error(`targets[${i}].symbol must be a non-empty string`);
             }
           }
-          const resolvedTargets = await Promise.all(targets.map((t) => resolvePathArg(ctx, context, t.filePath)));
+          const resolvedTargets = await Promise.all(targets.map((t) => resolvePathArg(ctx, context, t.path)));
           const permissionDenied = await assertPathExternalPermissions(ctx, context, resolvedTargets);
           if (permissionDenied)
             return permissionDeniedResponse(permissionDenied);
-          const rawArgs2 = { targets };
+          const rawArgs2 = {
+            targets: targets.map((target) => ({
+              filePath: target.path,
+              symbol: target.symbol
+            }))
+          };
           if (contextLines !== undefined)
             rawArgs2.contextLines = contextLines;
           if (wantCallgraph)
@@ -37036,18 +37441,18 @@ function readingTools(ctx) {
           return withMeta(response2.text);
         }
         if (!hasFilePath && !hasUrl) {
-          throw new Error("Provide exactly one of 'filePath', 'url', or 'targets'");
+          throw new Error("Provide exactly one of 'path', 'url', or 'targets'");
         }
         if (hasFilePath && hasUrl) {
-          throw new Error("Provide exactly ONE of 'filePath' or 'url' — not both");
+          throw new Error("Provide exactly ONE of 'path' or 'url' — not both");
         }
         if (!hasUrl) {
-          const file2 = await resolvePathArg(ctx, context, args.filePath);
+          const file2 = await resolvePathArg(ctx, context, args.path);
           const permissionDenied = await assertPathExternalPermissions(ctx, context, file2);
           if (permissionDenied)
             return permissionDeniedResponse(permissionDenied);
         }
-        const rawArgs = hasUrl ? { url: args.url } : { filePath: args.filePath };
+        const rawArgs = hasUrl ? { url: args.url } : { filePath: args.path };
         if (hasSymbols)
           rawArgs.symbols = args.symbols;
         if (contextLines !== undefined)
@@ -37061,7 +37466,7 @@ function readingTools(ctx) {
         return withMeta(response.text);
       }
     }
-  };
+  });
 }
 async function permissionKindForPath(resolvedPath) {
   try {
@@ -37151,7 +37556,7 @@ async function queryLspHints(client, symbolName, directory, sessionId) {
 // src/tools/refactoring.ts
 var z13 = tool13.schema;
 function refactoringTools(ctx) {
-  return {
+  return prepareToolMap({
     aft_refactor: {
       description: `Workspace-wide refactoring that updates imports and references across files.
 
@@ -37161,7 +37566,7 @@ function refactoringTools(ctx) {
 ` + "- 'inline': replace a function call with the function's body.",
       args: {
         op: z13.enum(["move", "extract", "inline"]).describe("Refactoring operation"),
-        filePath: z13.string().describe("Path to the source file (absolute or relative to project root)"),
+        path: z13.string().describe("Path to the source file (absolute or relative to project root)"),
         symbol: z13.string().optional().describe("Symbol name — required for 'move' and 'inline' ops"),
         destination: z13.string().optional().describe("Target file path — required for 'move' op"),
         scope: z13.string().optional().describe("Disambiguation scope for 'move' op — when multiple top-level symbols share the same name, specify the containing scope to disambiguate (e.g. 'MyClass'). Does NOT enable access to nested symbols or class methods."),
@@ -37192,7 +37597,7 @@ function refactoringTools(ctx) {
         if (op === "inline" && callSiteLine === undefined) {
           throw new Error("'callSiteLine' is required for 'inline' op");
         }
-        const filePath = await resolvePathArg(ctx, context, args.filePath);
+        const filePath = await resolvePathArg(ctx, context, args.path);
         const destination = op === "move" ? await resolvePathArg(ctx, context, args.destination) : undefined;
         const patterns = op === "move" ? resolveRelativePatterns(context, [
           workspacePattern(context),
@@ -37246,7 +37651,7 @@ function refactoringTools(ctx) {
         return response.text;
       }
     }
-  };
+  });
 }
 
 // src/tools/safety.ts
@@ -37273,15 +37678,15 @@ function relativePatternsFromPaths(context, paths) {
   return patterns;
 }
 function safetyTools(ctx) {
-  return {
+  return prepareToolMap({
     aft_safety: {
       description: `File safety and recovery operations.
 
 ` + `Per-file undo stack is capped at 20 entries (oldest evicted).
 
 ` + `Ops:
-` + `- 'undo': Undo the entire last tool call when 'filePath' is omitted (typical), or undo the last edit to one file when 'filePath' is provided. Note: pops from the undo stack (irreversible, no redo). Use 'history' to inspect per-file history before undoing.
-` + `- 'history': List all edit snapshots for a file. Requires 'filePath'.
+` + `- 'undo': Undo the entire last tool call when 'path' is omitted (typical), or undo the last edit to one file when 'path' is provided. Note: pops from the undo stack (irreversible, no redo). Use 'history' to inspect per-file history before undoing.
+` + `- 'history': List all edit snapshots for a file. Requires 'path'.
 ` + `- 'checkpoint': Save a named snapshot of tracked files. Requires 'name'. Optional 'files' to snapshot specific files only.
 ` + `- 'restore': Restore files to a previously saved checkpoint. Requires 'name'.
 ` + `- 'list': List all available named checkpoints. No extra params needed.
@@ -37291,22 +37696,22 @@ function safetyTools(ctx) {
 ` + "Use checkpoint before risky multi-file changes. Use undo for quick single-file rollback.",
       args: {
         op: z14.enum(["undo", "history", "checkpoint", "restore", "list"]).describe("Safety operation"),
-        filePath: z14.string().optional().describe("File path (required for history, optional for undo). Absolute or relative to project root"),
+        path: z14.string().optional().describe("File path (required for history, optional for undo). Absolute or relative to project root"),
         name: z14.string().optional().describe("Checkpoint name (required for checkpoint, restore)"),
         files: z14.array(z14.string()).optional().describe("Specific files to include in checkpoint (optional, defaults to all tracked files)")
       },
       execute: async (args, context) => {
         const op = args.op;
-        if (op === "history" && typeof args.filePath !== "string") {
-          throw new Error(`'filePath' is required for '${op}' op`);
+        if (op === "history" && typeof args.path !== "string") {
+          throw new Error(`'path' is required for '${op}' op`);
         }
         if ((op === "checkpoint" || op === "restore") && typeof args.name !== "string") {
           throw new Error(`'name' is required for '${op}' op`);
         }
         if (op === "undo") {
           const previewParams = {};
-          if (typeof args.filePath === "string")
-            previewParams.file = args.filePath;
+          if (typeof args.path === "string")
+            previewParams.file = args.path;
           const preview2 = await callBridge(ctx, context, "undo_preview", previewParams);
           if (preview2.success === false) {
             throw new Error(bridgeErrorMessage(preview2, "undo preview failed"));
@@ -37317,14 +37722,14 @@ function safetyTools(ctx) {
             if (denial)
               return permissionDeniedResponse(denial);
           }
-          const filePath = typeof args.filePath === "string" ? resolveAbsolutePath(context, args.filePath) : undefined;
+          const filePath = typeof args.path === "string" ? resolveAbsolutePath(context, args.path) : undefined;
           const permissionError = await askEditPermission(context, relativePatternsFromPaths(context, previewPaths), filePath ? { filepath: filePath } : { operation: "undo", paths: previewPaths });
           if (permissionError)
             return permissionDeniedResponse(permissionError);
         }
         if (op === "checkpoint") {
           const coercedFiles = coerceStringArray(args.files);
-          const checkpointFiles = coercedFiles.length > 0 ? coercedFiles : typeof args.filePath === "string" ? [args.filePath] : undefined;
+          const checkpointFiles = coercedFiles.length > 0 ? coercedFiles : typeof args.path === "string" ? [args.path] : undefined;
           if (Array.isArray(checkpointFiles)) {
             const projectRoot = await resolveProjectRoot(ctx, context);
             const uniqueParents = new Set;
@@ -37365,7 +37770,7 @@ function safetyTools(ctx) {
         if (args.name !== undefined)
           rawArgs.name = args.name;
         const payloadFiles = coerceStringArray(args.files).map(expandTilde2);
-        const filePathArg = typeof args.filePath === "string" ? expandTilde2(args.filePath) : undefined;
+        const filePathArg = typeof args.path === "string" ? expandTilde2(args.path) : undefined;
         if (filePathArg !== undefined)
           rawArgs.filePath = filePathArg;
         if (payloadFiles.length > 0)
@@ -37377,11 +37782,11 @@ function safetyTools(ctx) {
         return response.text;
       }
     }
-  };
+  });
 }
 
 // src/tools/search.ts
-import * as fs5 from "node:fs";
+import * as fs4 from "node:fs";
 import * as path6 from "node:path";
 function arg2(schema) {
   return schema;
@@ -37390,7 +37795,7 @@ function absoluteSearchPath(projectRoot, target) {
   return resolvePathFromProjectRoot(projectRoot, expandTilde2(target));
 }
 function searchPathExists(projectRoot, target) {
-  return fs5.existsSync(absoluteSearchPath(projectRoot, target));
+  return fs4.existsSync(absoluteSearchPath(projectRoot, target));
 }
 function splitSearchPathArg(projectRoot, raw) {
   if (searchPathExists(projectRoot, raw) || !/\s/.test(raw)) {
@@ -37433,7 +37838,7 @@ ${note}` : note;
 }
 function searchPathKind(projectRoot, target, defaultKind) {
   try {
-    const stat2 = fs5.lstatSync(absoluteSearchPath(projectRoot, target));
+    const stat2 = fs4.lstatSync(absoluteSearchPath(projectRoot, target));
     if (defaultKind === "file") {
       return stat2.isDirectory() ? "directory" : "file";
     }
@@ -37562,15 +37967,12 @@ function arg3(schema) {
 function semanticTools(ctx) {
   const searchTool = {
     description: [
-      "Search code with one tool: concepts, identifiers, error strings, regex, literals, and filenames are auto-routed to the right engine and returned ranked. For conceptual 'how does X work' queries, phrase a full natural-language sentence — the semantic lane is NL-aware and matches intent against docstrings and comments ('how does the ORM build and execute a query', 'where is rate limiting handled'), not just keywords. Exact names, strings, and regex stay terse ('^export', 'Cargo.lock').",
-      "",
-      "Set hint to 'regex', 'literal', or 'semantic' to force a lane."
+      "Search code with one tool: concepts, identifiers, error strings, regex, literals, and filenames are auto-routed to the right engine and returned ranked. For conceptual 'how does X work' queries, phrase a full natural-language sentence — the semantic lane is NL-aware and matches intent against docstrings and comments ('how does the ORM build and execute a query', 'where is rate limiting handled'), not just keywords. Exact names, strings, and regex stay terse ('^export', 'Cargo.lock')."
     ].join(`
 `),
     args: {
       query: arg3(z15.string().describe("Concept, regex, literal text, filename, or capability to find. Examples: 'fuzzy match with whitespace tolerance', '^export', 'Cargo.lock'.")),
       topK: arg3(optionalInt(1, 100).describe("Number of results (default: 10, max: 100)")),
-      hint: arg3(z15.enum(["regex", "literal", "semantic", "auto"]).optional().describe("Optional routing hint. Defaults to 'auto'.")),
       includeTests: arg3(z15.boolean().optional().describe("Include test files (*.test.*, *_test.rs, __tests__/, …) plus test-support, fixture, mock, snapshot, and corpus files. Defaults to false.")),
       path: arg3(z15.string().optional().describe("Search a different project root (absolute or ~ path). Requires that project to have been indexed by AFT."))
     },
@@ -37579,24 +37981,19 @@ function semanticTools(ctx) {
         throw new Error("semantic_search: invalid params: `query` must be a non-empty string");
       }
       const query = args.query;
-      const hint = typeof args.hint === "string" ? args.hint : undefined;
       const pathArg = typeof args.path === "string" && args.path.trim() ? args.path.trim() : undefined;
-      if (hint !== "semantic") {
-        const denied = await askSearchPermission(context, query);
-        if (denied)
-          return permissionDeniedResponse(denied);
-      }
+      const denied = await askSearchPermission(context, query);
+      if (denied)
+        return permissionDeniedResponse(denied);
       if (pathArg) {
-        const denied = await assertAftSearchExternalPermission(ctx, context, pathArg);
-        if (denied)
-          return permissionDeniedResponse(denied);
+        const denied2 = await assertAftSearchExternalPermission(ctx, context, pathArg);
+        if (denied2)
+          return permissionDeniedResponse(denied2);
       }
       const rawArgs = { query };
       const topK = coerceOptionalInt(args.topK, "topK", 1, 100);
       if (topK !== undefined)
         rawArgs.topK = topK;
-      if (hint)
-        rawArgs.hint = hint;
       if (typeof args.includeTests === "boolean")
         rawArgs.includeTests = args.includeTests;
       if (pathArg)
@@ -37614,6 +38011,37 @@ function semanticTools(ctx) {
   };
 }
 
+// src/tool-registration.ts
+var ALL_ONLY_TOOLS = ["aft_callgraph", "aft_delete", "aft_move", "aft_refactor"];
+function buildOpenCodeToolMap(ctx, config2, onUnknownDisabled) {
+  const surface = config2.tool_surface ?? "recommended";
+  const allTools = normalizeToolMap({
+    ...surface !== "minimal" && (config2.hoist_builtin_tools !== false ? hoistedTools(ctx) : aftPrefixedTools(ctx)),
+    ...readingTools(ctx),
+    ...config2.backup?.enabled === false ? {} : safetyTools(ctx),
+    ...surface !== "minimal" && importTools(ctx),
+    ...navigationTools(ctx),
+    ...surface !== "minimal" && astTools(ctx),
+    ...surface !== "minimal" && config2.semantic_search === true && semanticTools(ctx),
+    ...inspectToolSurfaceEnabled(config2) && inspectTools(ctx),
+    ...surface !== "minimal" && config2.search_index === true && searchTools(ctx),
+    ...refactoringTools(ctx),
+    ...surface !== "minimal" && conflictTools(ctx)
+  });
+  if (surface !== "all") {
+    for (const name of ALL_ONLY_TOOLS)
+      delete allTools[name];
+  }
+  for (const name of config2.disabled_tools ?? []) {
+    if (name in allTools) {
+      delete allTools[name];
+    } else {
+      onUnknownDisabled?.(name, Object.keys(allTools));
+    }
+  }
+  return allTools;
+}
+
 // src/workflow-hints.ts
 var HEADING = "## IMPORTANT NOTICE about your tools";
 function buildWorkflowHints(opts) {
@@ -37644,18 +38072,18 @@ function buildWorkflowHints(opts) {
   }
   if (hasOutline && hasZoom && (hasGrep || hasSearch)) {
     const searchName = hasSearch ? "aft_search" : grepName;
-    const locate = hasSearch ? '`aft_search` is the primary code-search tool: one call auto-routes concepts, identifiers, regex, error strings, and literals (pass `hint: "regex"`/`"literal"`/`"semantic"` to force a lane).' : `\`${grepName}\` (the tool — indexed and ranked) locates code.`;
+    const locate = hasSearch ? "`aft_search` is the primary code-search tool: one call auto-routes concepts, identifiers, regex, error strings, and literals." : `\`${grepName}\` (the tool — indexed and ranked) locates code.`;
     const readName = opts.hoistBuiltins ? "read" : "aft_read";
     sections.push([
       `**Code exploration**: ${locate} Then \`aft_outline\` for structure → \`aft_zoom\` for symbol(s). DO NOT run \`grep\`/\`rg\`/\`find\`/\`sed\`/\`cat\` through \`bash\` to locate or read code — the bash path is unindexed, unranked, serial, and routinely surfaces the wrong hit. Keep \`bash\` for shell facts (git state, file metadata, processes). Reflex translations:`,
       `- \`grep -rn "handleAuth" src/\` in bash → \`${searchName}({ query: "handleAuth" })\``,
       `- \`find . -name "*.ts" | xargs grep watcher\` in bash → \`${searchName}({ query: "watcher invalidation" })\` (concepts work too)`,
-      `- \`sed -n '100,160p' app.ts\` / \`cat app.ts\` in bash → \`${readName}({ filePath: "app.ts", startLine: 100, endLine: 160 })\``
+      `- \`sed -n '100,160p' app.ts\` / \`cat app.ts\` in bash → \`${readName}({ path: "app.ts", startLine: 100, endLine: 160 })\``
     ].join(`
 `));
   }
   if (hasInspect) {
-    sections.push("**Codebase health & diagnostics**: AFT does not surface compile/type errors automatically after edits — pull them with `aft_inspect`. Run it after a batch of edits and before you run tests or commit, when starting in unfamiliar code, or before a refactor/review. One call summarizes diagnostics (compile/type errors), TODOs, metrics, dead code, unused exports, and duplicates; pass `sections` for focused drill-down and `scope` to actively pull diagnostics for a specific file or directory. Its diagnostics are a fast checkpoint, not the authority — a clean `tsc` / `cargo check` / `pyright` run is the real gate. Treat `stale_categories` as a genuine stale-cache signal while an async Tier 2 refresh catches up.");
+    sections.push("**Codebase health & diagnostics**: AFT does not surface compile/type errors automatically after edits — pull them with `aft_inspect`. Run it after a batch of edits and before you run tests or commit, when starting in unfamiliar code, or before a refactor/review. One call summarizes diagnostics (compile/type errors), TODOs, metrics, dead code, unused exports, and duplicates; pass `sections` for focused drill-down and `scope` to actively pull diagnostics for a specific file or directory. Its diagnostics are a fast checkpoint, not the authority — a clean `tsc` / `cargo check` / `pyright` run is the real gate. Treat stale_categories/pending_categories as stale or incomplete cache state. AFT schedules a Tier-2 refresh after its next idle or inspect-triggered background run; use one later normal aft_inspect after that refresh, not a polling loop.");
     sections.push("**AFT status bar**: tool results may end with a one-line health bar `[AFT E<errors> W<warnings> | D<dead-code> U<unused-exports> C<clone/dup-groups> | T<todos>]` — an IDE-style glance that appears when a count changes. `E`/`W` are live LSP diagnostics for files touched this session (your universal compile-error signal across every language with an LSP). A `~` before `D` means the dead-code/unused/dup counts predate your latest edit — run `aft_inspect` for current numbers and detail. When `E>0`, you likely just introduced errors; investigate before moving on.");
   }
   if (hasNavigate) {
@@ -37728,11 +38156,11 @@ var PLUGIN_VERSION = (() => {
     return "0.0.0";
   }
 })();
-var ANNOUNCEMENT_VERSION = "0.48.0";
+var ANNOUNCEMENT_VERSION = "0.49.0";
 var ANNOUNCEMENT_FEATURES = [
-  "New (beta, off by default): an optional native sandbox for hoisted bash. Confines commands to your project and blocks reads of your credentials (~/.ssh, ~/.aws, cloud configs). Enable with sandbox.enabled in aft.jsonc — macOS and Linux; see docs/config.md for the platform matrix.",
-  "Fixed: Windows background bash tasks could report failed with no exit code after a detach/rebind — completion is now recorded reliably.",
-  "Fixed: search no longer rebuilds its index unnecessarily for repositories with grafted history."
+  "One unified tool surface: every tool now takes `path` (old spellings keep working), `edit` has one calling shape, and `occurrence` is 1-based. Fewer ways for models to get a call wrong; prompt caches re-warm once after this upgrade.",
+  "aft_search now routes queries itself — the hint parameter is gone, and searches that find no exact match are re-ranked by their terms instead of returning nothing.",
+  "Corporate and custom certificate authorities now work: HTTPS requests verify through the OS trust store (Keychain, Windows certificate store, SSL_CERT_FILE on Linux)."
 ];
 var ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/DSa65w8wuf";
 var plugin = async (input) => initializePluginForDirectory(input);
@@ -38168,38 +38596,12 @@ Install: ${getManualInstallHint()}`).catch(() => {});
   } else {
     cleanupWarnings(notifyOpts).catch(() => {});
   }
-  const surface = aftConfig.tool_surface ?? "recommended";
-  const ALL_ONLY_TOOLS = new Set(["aft_callgraph", "aft_delete", "aft_move", "aft_refactor"]);
-  const allTools = normalizeToolMap({
-    ...surface !== "minimal" && (aftConfig.hoist_builtin_tools !== false ? hoistedTools(ctx) : aftPrefixedTools(ctx)),
-    ...readingTools(ctx),
-    ...aftConfig.backup?.enabled === false ? {} : safetyTools(ctx),
-    ...surface !== "minimal" && importTools(ctx),
-    ...navigationTools(ctx),
-    ...surface !== "minimal" && astTools(ctx),
-    ...surface !== "minimal" && aftConfig.semantic_search === true && semanticTools(ctx),
-    ...inspectToolSurfaceEnabled(aftConfig) && inspectTools(ctx),
-    ...surface !== "minimal" && aftConfig.search_index === true && searchTools(ctx),
-    ...refactoringTools(ctx),
-    ...surface !== "minimal" && conflictTools(ctx)
+  const allTools = buildOpenCodeToolMap(ctx, aftConfig, (name, available) => {
+    warn2(`disabled_tools: "${name}" not found — available: ${available.join(", ")}`);
   });
-  if (surface !== "all") {
-    for (const name of ALL_ONLY_TOOLS) {
-      if (name in allTools) {
-        delete allTools[name];
-      }
-    }
-  }
-  const disabled = new Set(aftConfig.disabled_tools ?? []);
-  if (disabled.size > 0) {
-    for (const name of disabled) {
-      if (name in allTools) {
-        delete allTools[name];
-      } else {
-        warn2(`disabled_tools: "${name}" not found — available: ${Object.keys(allTools).join(", ")}`);
-      }
-    }
-    log2(`Disabled ${disabled.size} tool(s): ${[...disabled].join(", ")}`);
+  const disabled = aftConfig.disabled_tools ?? [];
+  if (disabled.length > 0) {
+    log2(`Disabled ${disabled.length} tool(s): ${disabled.join(", ")}`);
   }
   instrumentToolMap(allTools);
   const autoUpdateEventHook = createAutoUpdateCheckerHook(input, {
@@ -38314,7 +38716,8 @@ Install: ${getManualInstallHint()}`).catch(() => {});
       const sessionDir = getSessionDirectoryCached(sid) ?? await getSessionDirectory(input.client, sid, input.directory) ?? input.directory;
       signalBashWaitDetachForProject(pool, sessionDir, sid);
     },
-    "tool.execute.before": async (toolInput) => {
+    "tool.execute.before": async (toolInput, output) => {
+      output.args = prepareOpenCodeArguments(toolInput.tool, output.args);
       if (toolInput.sessionID)
         inspectTier2Idle.clear(toolInput.sessionID);
     },