@cortexkit/aft-opencode 0.36.1 → 0.37.0

package/dist/index.js

@@ -11597,6 +11597,9 @@ function error(message, meta) {
 var CONFLICT_HINT = `
 
 [Hint] Use aft_conflicts to see all conflict regions across files in a single call.`;
+var GREP_SEARCH_AFT_SEARCH_HINT = "DO NOT search code by running grep/rg in bash — it is unindexed, unranked, and serial. Use the `aft_search` tool instead (it auto-routes concepts, identifiers, regex, and literals).";
+var GREP_SEARCH_GREP_HINT = "DO NOT search code by running grep/rg in bash — it is unindexed, unranked, and serial. Use the `grep` tool instead (indexed and ranked).";
+var GREP_SEARCH_HINT_PREFIX = "DO NOT search code by running grep/rg in bash —";
 function maybeAppendConflictsHint(output) {
   if (!output.includes("Automatic merge failed; fix conflicts"))
     return output;
@@ -11604,6 +11607,146 @@ function maybeAppendConflictsHint(output) {
     return output;
   return output + CONFLICT_HINT;
 }
+function commandLeadsWithCodeSearch(command) {
+  const trimmed = command.trim();
+  if (!trimmed)
+    return false;
+  const afterCd = peelLeadingCdAnd(trimmed);
+  if (afterCd === null)
+    return false;
+  const firstStage = firstPipelineStage(afterCd);
+  if (firstStage === null)
+    return false;
+  const firstToken = readShellToken(firstStage, skipSpaces(firstStage, 0));
+  if (firstToken === null)
+    return false;
+  return firstToken.token === "grep" || firstToken.token === "rg";
+}
+function maybeAppendGrepSearchHint(output, command, aftSearchRegistered) {
+  if (output === "")
+    return output;
+  if (!commandLeadsWithCodeSearch(command))
+    return output;
+  if (output.includes(GREP_SEARCH_HINT_PREFIX))
+    return output;
+  const hint = aftSearchRegistered ? GREP_SEARCH_AFT_SEARCH_HINT : GREP_SEARCH_GREP_HINT;
+  return `${output}
+
+${hint}`;
+}
+function peelLeadingCdAnd(command) {
+  const first = readShellToken(command, skipSpaces(command, 0));
+  if (first === null)
+    return null;
+  if (first.token !== "cd")
+    return command;
+  const dir = readShellToken(command, skipSpaces(command, first.end));
+  if (dir === null)
+    return null;
+  if (!dir.token)
+    return command;
+  const afterDir = skipSpaces(command, dir.end);
+  if (!command.startsWith("&&", afterDir))
+    return command;
+  return command.slice(afterDir + 2).trim();
+}
+function firstPipelineStage(command) {
+  let quote = "none";
+  let firstPipeIndex;
+  for (let index = 0;index < command.length; index++) {
+    const ch = command[index];
+    if (quote === "single") {
+      if (ch === "'")
+        quote = "none";
+      continue;
+    }
+    if (quote === "double") {
+      if (ch === '"') {
+        quote = "none";
+      } else if (ch === "\\") {
+        index++;
+      } else if (ch === "`") {
+        return null;
+      }
+      continue;
+    }
+    if (ch === "'") {
+      quote = "single";
+    } else if (ch === '"') {
+      quote = "double";
+    } else if (ch === "\\") {
+      index++;
+    } else if (ch === "`") {
+      return null;
+    } else if (ch === "|") {
+      if (command[index + 1] === "|") {
+        index++;
+      } else if (firstPipeIndex === undefined) {
+        firstPipeIndex = index;
+      }
+    }
+  }
+  if (quote !== "none")
+    return null;
+  return command.slice(0, firstPipeIndex ?? command.length).trim();
+}
+function readShellToken(command, start) {
+  let quote = "none";
+  let token = "";
+  let index = start;
+  for (;index < command.length; index++) {
+    const ch = command[index];
+    if (quote === "single") {
+      if (ch === "'") {
+        quote = "none";
+      } else {
+        token += ch;
+      }
+      continue;
+    }
+    if (quote === "double") {
+      if (ch === '"') {
+        quote = "none";
+      } else if (ch === "\\") {
+        index++;
+        token += command[index] ?? "\\";
+      } else if (ch === "`") {
+        return null;
+      } else {
+        token += ch;
+      }
+      continue;
+    }
+    if (/\s/.test(ch))
+      break;
+    if (isTokenBoundary(ch))
+      break;
+    if (ch === "'") {
+      quote = "single";
+    } else if (ch === '"') {
+      quote = "double";
+    } else if (ch === "\\") {
+      index++;
+      token += command[index] ?? "\\";
+    } else if (ch === "`") {
+      return null;
+    } else {
+      token += ch;
+    }
+  }
+  if (quote !== "none")
+    return null;
+  return { token, end: index };
+}
+function isTokenBoundary(ch) {
+  return ch === "|" || ch === ";" || ch === "&" || ch === "<" || ch === ">";
+}
+function skipSpaces(input, start) {
+  let index = start;
+  while (index < input.length && /\s/.test(input[index]))
+    index++;
+  return index;
+}
 // ../aft-bridge/dist/bash-timeout.js
 function resolveBashKillTimeout(modelTimeout, foregroundWaitMs) {
   if (modelTimeout !== undefined && modelTimeout >= foregroundWaitMs) {
@@ -11617,6 +11760,21 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { StringDecoder } from "node:string_decoder";
 
+// ../aft-bridge/dist/command-timeouts.js
+var LONG_RUNNING_COMMAND_TIMEOUT_MS = {
+  callers: 60000,
+  trace_to: 60000,
+  trace_to_symbol: 60000,
+  trace_data: 60000,
+  impact: 60000,
+  grep: 60000,
+  glob: 60000,
+  semantic_search: 60000
+};
+function timeoutForCommand(command) {
+  return LONG_RUNNING_COMMAND_TIMEOUT_MS[command];
+}
+
 // ../aft-bridge/dist/status-bar.js
 var STATUS_BAR_HEARTBEAT_CALLS = 15;
 function createStatusBarEmitState() {
@@ -11669,6 +11827,27 @@ var DEFAULT_BRIDGE_TIMEOUT_MS = 30000;
 var BRIDGE_HANG_TIMEOUT_THRESHOLD = 2;
 var SEMANTIC_TIMEOUT_SAFETY_MARGIN_MS = 5000;
 var MAX_STDOUT_BUFFER = 64 * 1024 * 1024;
+var STDOUT_BUFFER_COMPACT_THRESHOLD = 64 * 1024;
+var TERMINAL_BASH_STATUSES = new Set([
+  "completed",
+  "failed",
+  "killed",
+  "timed_out",
+  "cancelled",
+  "timeout"
+]);
+function isTerminalBashStatus(status) {
+  return typeof status === "string" && TERMINAL_BASH_STATUSES.has(status);
+}
+function bashTaskIdFrom(response) {
+  const snakeCase = response.task_id;
+  if (typeof snakeCase === "string" && snakeCase.length > 0)
+    return snakeCase;
+  const camelCase = response.taskId;
+  if (typeof camelCase === "string" && camelCase.length > 0)
+    return camelCase;
+  return;
+}
 function tagStderrLine(line) {
   return /^\[aft(-\w+)?\] /.test(line) ? line : `[aft] ${line}`;
 }
@@ -11723,11 +11902,12 @@ function clampSemanticTimeout(configOverrides, bridgeTimeoutMs) {
   if (typeof timeoutMs !== "number" || !Number.isFinite(timeoutMs)) {
     return configOverrides;
   }
-  const maxSemanticTimeoutMs = bridgeTimeoutMs > SEMANTIC_TIMEOUT_SAFETY_MARGIN_MS ? bridgeTimeoutMs - SEMANTIC_TIMEOUT_SAFETY_MARGIN_MS : Math.max(1, bridgeTimeoutMs - 1);
+  const semanticTransportBudgetMs = Math.max(bridgeTimeoutMs, LONG_RUNNING_COMMAND_TIMEOUT_MS.semantic_search ?? 0);
+  const maxSemanticTimeoutMs = semanticTransportBudgetMs > SEMANTIC_TIMEOUT_SAFETY_MARGIN_MS ? semanticTransportBudgetMs - SEMANTIC_TIMEOUT_SAFETY_MARGIN_MS : Math.max(1, semanticTransportBudgetMs - 1);
   if (timeoutMs <= maxSemanticTimeoutMs) {
     return configOverrides;
   }
-  warn(`semantic.timeout_ms=${timeoutMs} exceeds bridge timeout budget; clamping to ${maxSemanticTimeoutMs}ms (bridge timeout: ${bridgeTimeoutMs}ms)`);
+  warn(`semantic.timeout_ms=${timeoutMs} exceeds the semantic transport budget; clamping to ${maxSemanticTimeoutMs}ms (budget: ${semanticTransportBudgetMs}ms)`);
   return {
     ...configOverrides,
     semantic: {
@@ -11753,8 +11933,10 @@ class BinaryBridge {
   cwd;
   process = null;
   pending = new Map;
+  outstandingBackgroundTaskIds = new Set;
   nextId = 1;
   stdoutBuffer = "";
+  stdoutReadOffset = 0;
   stderrBuffer = "";
   stderrTail = [];
   _restartCount = 0;
@@ -11864,6 +12046,9 @@ class BinaryBridge {
   hasPendingRequests() {
     return this.pending.size > 0;
   }
+  hasOutstandingBackgroundTasks() {
+    return this.outstandingBackgroundTaskIds.size > 0;
+  }
   getCwd() {
     return this.cwd;
   }
@@ -11985,7 +12170,7 @@ class BinaryBridge {
           entry.reject(new Error(`${this.errorPrefix} Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`));
           this.handleTimeout(requestSessionId);
         }, effectiveTimeoutMs);
-        this.pending.set(id, { resolve, reject, timer, onProgress: options?.onProgress });
+        this.pending.set(id, { resolve, reject, timer, onProgress: options?.onProgress, command });
         if (!this.process?.stdin?.writable) {
           this.pending.delete(id);
           clearTimeout(timer);
@@ -12246,6 +12431,7 @@ class BinaryBridge {
     });
     this.process = child;
     this.stdoutBuffer = "";
+    this.stdoutReadOffset = 0;
     this.stderrBuffer = "";
     this.lastChildActivityAt = 0;
     this.consecutiveRequestTimeouts = 0;
@@ -12290,24 +12476,41 @@ class BinaryBridge {
   ${tail}`;
   }
   onStdoutData(data) {
+    if (this.stdoutReadOffset > STDOUT_BUFFER_COMPACT_THRESHOLD) {
+      this.compactStdoutBuffer();
+    }
     this.stdoutBuffer += data;
-    if (this.stdoutBuffer.length > MAX_STDOUT_BUFFER) {
+    if (this.stdoutBuffer.length - this.stdoutReadOffset > MAX_STDOUT_BUFFER) {
       this.handleCrash(new Error(`aft bridge stdout buffer exceeded ${MAX_STDOUT_BUFFER} bytes — killing bridge`));
       return;
     }
     let newlineIdx;
     while ((newlineIdx = this.stdoutBuffer.indexOf(`
-`)) !== -1) {
-      const line = this.stdoutBuffer.slice(0, newlineIdx).trim();
-      this.stdoutBuffer = this.stdoutBuffer.slice(newlineIdx + 1);
-      if (!line)
-        continue;
-      this.processStdoutLine(line);
+`, this.stdoutReadOffset)) !== -1) {
+      const line = this.stdoutBuffer.slice(this.stdoutReadOffset, newlineIdx).trim();
+      this.stdoutReadOffset = newlineIdx + 1;
+      if (line) {
+        this.processStdoutLine(line);
+      }
+      if (this.stdoutReadOffset > STDOUT_BUFFER_COMPACT_THRESHOLD && this.stdoutReadOffset > this.stdoutBuffer.length / 2) {
+        this.compactStdoutBuffer();
+      }
     }
+    if (this.stdoutReadOffset === this.stdoutBuffer.length) {
+      this.stdoutBuffer = "";
+      this.stdoutReadOffset = 0;
+    }
+  }
+  compactStdoutBuffer() {
+    if (this.stdoutReadOffset === 0)
+      return;
+    this.stdoutBuffer = this.stdoutBuffer.slice(this.stdoutReadOffset);
+    this.stdoutReadOffset = 0;
   }
   flushStdoutBuffer() {
-    const line = this.stdoutBuffer.trim();
+    const line = this.stdoutBuffer.slice(this.stdoutReadOffset).trim();
     this.stdoutBuffer = "";
+    this.stdoutReadOffset = 0;
     if (!line)
       return;
     this.processStdoutLine(line);
@@ -12340,6 +12543,9 @@ class BinaryBridge {
         return;
       }
       if (response.type === "bash_completed") {
+        const taskId = bashTaskIdFrom(response);
+        if (taskId)
+          this.outstandingBackgroundTaskIds.delete(taskId);
         this.onBashCompletion?.(response, this);
         return;
       }
@@ -12370,6 +12576,7 @@ class BinaryBridge {
         clearTimeout(entry.timer);
         this.consecutiveRequestTimeouts = 0;
         this.scheduleRestartCountReset();
+        this.accountForBashTaskResponse(entry.command, response);
         this.captureStatusBar(response);
         entry.resolve(response);
       } else if (typeof response.type === "string") {
@@ -12379,6 +12586,18 @@ class BinaryBridge {
       this.warnVia(`Failed to parse stdout line: ${line}`);
     }
   }
+  accountForBashTaskResponse(command, response) {
+    const taskId = bashTaskIdFrom(response);
+    if (!taskId)
+      return;
+    if (isTerminalBashStatus(response.status)) {
+      this.outstandingBackgroundTaskIds.delete(taskId);
+      return;
+    }
+    if (command === "bash" && response.success !== false) {
+      this.outstandingBackgroundTaskIds.add(taskId);
+    }
+  }
   captureStatusBar(response) {
     const parsed = parseStatusBarCounts(response.status_bar);
     if (parsed)
@@ -12390,6 +12609,7 @@ class BinaryBridge {
   handleTimeout(triggeringSessionId) {
     this.consecutiveRequestTimeouts = 0;
     this.rejectAllPending(new Error(`${this.errorPrefix} bridge killed during sibling timeout — request aborted`));
+    this.outstandingBackgroundTaskIds.clear();
     if (this.process) {
       this.process.kill("SIGKILL");
       this.process = null;
@@ -12419,6 +12639,7 @@ class BinaryBridge {
     }
     this.clearRestartResetTimer();
     this.configured = false;
+    this.outstandingBackgroundTaskIds.clear();
     const tail = this.formatStderrTail();
     if (tail) {
       this.errorVia(`Binary crashed (restarts: ${this._restartCount})${cause ? `: ${cause.message}` : ""}.${tail}`);
@@ -14458,7 +14679,7 @@ function tokenizeStage(stage) {
 }
 // ../aft-bridge/dist/pool.js
 import { realpathSync as realpathSync2 } from "node:fs";
-var DEFAULT_IDLE_TIMEOUT_MS = Infinity;
+var DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1000;
 var DEFAULT_MAX_POOL_SIZE = 8;
 var CLEANUP_INTERVAL_MS = 60 * 1000;
 class BridgePool {
@@ -14532,7 +14753,7 @@ class BridgePool {
   cleanup() {
     const now = Date.now();
     for (const [dir, entry] of this.bridges) {
-      if (entry.bridge.hasPendingRequests())
+      if (entry.bridge.hasPendingRequests() || entry.bridge.hasOutstandingBackgroundTasks())
         continue;
       if (now - entry.lastUsed > this.idleTimeoutMs) {
         entry.bridge.shutdown().catch((err) => this.error("cleanup shutdown failed:", err));
@@ -14540,7 +14761,7 @@ class BridgePool {
       }
     }
     for (const bridge of this.staleBridges) {
-      if (bridge.hasPendingRequests())
+      if (bridge.hasPendingRequests() || bridge.hasOutstandingBackgroundTasks())
         continue;
       bridge.shutdown().catch((err) => this.error("stale cleanup shutdown failed:", err));
       this.staleBridges.delete(bridge);
@@ -14550,7 +14771,7 @@ class BridgePool {
     let oldestDir = null;
     let oldestTime = Infinity;
     for (const [dir, entry] of this.bridges) {
-      if (entry.bridge.hasPendingRequests())
+      if (entry.bridge.hasPendingRequests() || entry.bridge.hasOutstandingBackgroundTasks())
         continue;
       if (entry.lastUsed < oldestTime) {
         oldestTime = entry.lastUsed;
@@ -32881,7 +33102,14 @@ function writeTerminal(terminal, data) {
 
 // src/shared/rpc-server.ts
 import { randomBytes as randomBytes2 } from "node:crypto";
-import { mkdirSync as mkdirSync10, renameSync as renameSync8, unlinkSync as unlinkSync7, writeFileSync as writeFileSync10 } from "node:fs";
+import {
+  mkdirSync as mkdirSync10,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync13,
+  renameSync as renameSync8,
+  unlinkSync as unlinkSync7,
+  writeFileSync as writeFileSync10
+} from "node:fs";
 import { createServer } from "node:http";
 import { dirname as dirname9, join as join19 } from "node:path";
 
@@ -32896,6 +33124,41 @@ function rpcPortFileDir(storageDir, directory) {
   const hash2 = projectHash(directory);
   return join18(storageDir, "rpc", hash2, "ports");
 }
+function isPidAlive(pid) {
+  if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0)
+    return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function parseRpcPortRecord(content) {
+  const trimmed = content.trim();
+  if (trimmed.length === 0)
+    return null;
+  if (trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      const port2 = typeof parsed.port === "number" ? parsed.port : Number.NaN;
+      if (!Number.isInteger(port2) || port2 <= 0 || port2 > 65535)
+        return null;
+      return {
+        port: port2,
+        token: typeof parsed.token === "string" ? parsed.token : null,
+        pid: typeof parsed.pid === "number" && Number.isInteger(parsed.pid) ? parsed.pid : undefined,
+        started_at: typeof parsed.started_at === "number" ? parsed.started_at : undefined
+      };
+    } catch {
+      return null;
+    }
+  }
+  const port = Number.parseInt(trimmed, 10);
+  if (!Number.isInteger(port) || port <= 0 || port > 65535)
+    return null;
+  return { port, token: null };
+}
 
 // src/shared/rpc-server.ts
 class AftRpcServer {
@@ -32942,6 +33205,7 @@ class AftRpcServer {
           }), { encoding: "utf-8", mode: 384 });
           renameSync8(tmpPath, this.portFilePath);
           log2(`RPC server listening on 127.0.0.1:${this.port}`);
+          this.sweepDeadPortFiles();
         } catch (err) {
           warn2(`Failed to write RPC port file: ${err}`);
         }
@@ -32950,6 +33214,31 @@ class AftRpcServer {
       server.unref();
     });
   }
+  sweepDeadPortFiles() {
+    let entries;
+    try {
+      entries = readdirSync5(this.portsDir);
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.endsWith(".json"))
+        continue;
+      const filePath = join19(this.portsDir, entry);
+      if (filePath === this.portFilePath)
+        continue;
+      try {
+        const record2 = parseRpcPortRecord(readFileSync13(filePath, "utf-8"));
+        if (record2 === null) {
+          unlinkSync7(filePath);
+          continue;
+        }
+        if (record2.pid !== undefined && !isPidAlive(record2.pid)) {
+          unlinkSync7(filePath);
+        }
+      } catch {}
+    }
+  }
   stop() {
     if (this.server) {
       this.server.close();
@@ -33074,6 +33363,38 @@ function warmSessionDirectory(client, sessionId, fallbackDirectory) {
     return;
   getSessionDirectory(client, sessionId, fallbackDirectory);
 }
+var VERIFY_TTL_MS = 15000;
+var verifyCache = new Map;
+async function verifySessionDirectory(client, sessionId) {
+  if (!sessionId)
+    return null;
+  const hit = verifyCache.get(sessionId);
+  if (hit && Date.now() - hit.verifiedAt < VERIFY_TTL_MS)
+    return hit.directory;
+  const c = client;
+  const sessionApi = c?.session;
+  if (!sessionApi || typeof sessionApi.get !== "function")
+    return null;
+  let dir = null;
+  try {
+    const result = await sessionApi.get({ path: { id: sessionId } });
+    const session = result?.data ?? result;
+    if (session && typeof session.directory === "string" && session.directory.length > 0) {
+      dir = session.directory;
+    }
+  } catch {
+    return null;
+  }
+  verifyCache.set(sessionId, { directory: dir, verifiedAt: Date.now() });
+  if (verifyCache.size > CACHE_MAX_ENTRIES) {
+    const oldest = verifyCache.keys().next().value;
+    if (oldest !== undefined)
+      verifyCache.delete(oldest);
+  }
+  if (dir !== null)
+    setCache(sessionId, dir);
+  return dir;
+}
 
 // src/shared/status.ts
 function asRecord(value) {
@@ -33286,7 +33607,7 @@ function formatStatusMarkdown(status) {
 
 // src/shared/tui-config.ts
 var import_comment_json4 = __toESM(require_src2(), 1);
-import { existsSync as existsSync14, mkdirSync as mkdirSync11, readFileSync as readFileSync13, writeFileSync as writeFileSync11 } from "node:fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync11 } from "node:fs";
 import { dirname as dirname10, join as join21 } from "node:path";
 
 // src/shared/opencode-config-dir.ts
@@ -33334,7 +33655,7 @@ function ensureTuiPluginEntry() {
     const configPath = resolveTuiConfigPath();
     let config2 = {};
     if (existsSync14(configPath)) {
-      config2 = import_comment_json4.parse(readFileSync13(configPath, "utf-8")) ?? {};
+      config2 = import_comment_json4.parse(readFileSync14(configPath, "utf-8")) ?? {};
     }
     const plugins = Array.isArray(config2.plugin) ? config2.plugin.filter((value) => typeof value === "string") : [];
     if (plugins.some((plugin) => plugin === PLUGIN_NAME || plugin.startsWith(`${PLUGIN_NAME}@`) || plugin.includes("opencode-plugin") || plugin.includes("aft-opencode"))) {
@@ -33502,19 +33823,6 @@ function isEmptyParam(value) {
   return false;
 }
 var BASH_TRANSPORT_TIMEOUT_MS = 30000;
-var LONG_RUNNING_COMMAND_TIMEOUT_MS = {
-  callers: 60000,
-  trace_to: 60000,
-  trace_to_symbol: 60000,
-  trace_data: 60000,
-  impact: 60000,
-  grep: 60000,
-  glob: 60000,
-  semantic_search: 60000
-};
-function timeoutForCommand(command) {
-  return LONG_RUNNING_COMMAND_TIMEOUT_MS[command];
-}
 function asPlainObject(value) {
   if (!value || typeof value !== "object" || Array.isArray(value))
     return;
@@ -34091,388 +34399,61 @@ ${hint}`;
   };
 }
 
-// src/tools/conflicts.ts
+// src/tools/bash.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 params = {};
-        if (!isEmptyParam(args?.path))
-          params.path = args.path;
-        const response = await callBridge(ctx, context, "git_conflicts", params);
-        if (response.success === false) {
-          throw new Error(response.message || "git_conflicts failed");
-        }
-        return response.text;
-      }
-    }
-  };
-}
-
-// src/tools/hoisted.ts
-import * as fs6 from "node:fs";
-import * as path4 from "node:path";
-import { tool as tool8 } from "@opencode-ai/plugin";
 
-// src/patch-parser.ts
-function stripHeredoc(input) {
-  const heredocMatch = input.match(/^(?:cat\s+)?<<['"]?(\w+)['"]?\s*\n([\s\S]*?)\n\1\s*$/);
-  return heredocMatch ? heredocMatch[2] : input;
-}
-function parsePatchHeader(lines, startIdx) {
-  const line = lines[startIdx];
-  if (line.startsWith("*** Add File:")) {
-    const filePath = line.slice("*** Add File:".length).trim();
-    return filePath ? { filePath, nextIdx: startIdx + 1 } : null;
+// src/shared/subagent-detect.ts
+var CACHE_MAX_ENTRIES2 = 200;
+var cache2 = new Map;
+async function resolveIsSubagent(client, sessionId, _fallbackDirectory) {
+  if (!sessionId) {
+    sessionLog(undefined, "[subagent-detect] no sessionId provided → primary");
+    return false;
   }
-  if (line.startsWith("*** Delete File:")) {
-    const filePath = line.slice("*** Delete File:".length).trim();
-    return filePath ? { filePath, nextIdx: startIdx + 1 } : null;
+  const cached2 = cache2.get(sessionId);
+  if (cached2) {
+    cache2.delete(sessionId);
+    cache2.set(sessionId, cached2);
+    return cached2.isSubagent;
   }
-  if (line.startsWith("*** Update File:")) {
-    const filePath = line.slice("*** Update File:".length).trim();
-    let movePath;
-    let nextIdx = startIdx + 1;
-    if (nextIdx < lines.length && lines[nextIdx].startsWith("*** Move to:")) {
-      movePath = lines[nextIdx].slice("*** Move to:".length).trim();
-      nextIdx++;
-    }
-    return filePath ? { filePath, movePath, nextIdx } : null;
+  const c = client;
+  const sessionApi = c?.session;
+  if (!sessionApi || typeof sessionApi.get !== "function") {
+    sessionLog(sessionId, `[subagent-detect] client.session.get unavailable (client=${typeof client}, session=${typeof sessionApi}, get=${typeof sessionApi?.get}) → caching as primary`);
+    setCache2(sessionId, false);
+    return false;
   }
-  return null;
-}
-function parseAddFileContent(lines, startIdx) {
-  let content = "";
-  let i = startIdx;
-  while (i < lines.length && !lines[i].startsWith("***")) {
-    if (lines[i].startsWith("+")) {
-      content += `${lines[i].substring(1)}
-`;
-    }
-    i++;
+  sessionLog(sessionId, `[subagent-detect] cache miss, calling client.session.get(id=${sessionId})`);
+  let isSubagent = false;
+  let parentIdRaw;
+  try {
+    const result = await sessionApi.get({
+      path: { id: sessionId }
+    });
+    const session = result?.data ?? result;
+    parentIdRaw = session?.parentID;
+    isSubagent = session !== undefined && typeof session.parentID === "string" && session.parentID.length > 0;
+    sessionLog(sessionId, `[subagent-detect] SDK returned session=${session !== undefined ? "present" : "undefined"}, parentID=${JSON.stringify(parentIdRaw)} → isSubagent=${isSubagent}`);
+  } catch (err) {
+    sessionWarn(sessionId, `[subagent-detect] SDK lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    return false;
   }
-  if (content.endsWith(`
-`)) {
-    content = content.slice(0, -1);
-  }
-  return { content, nextIdx: i };
-}
-function parseUpdateFileChunks(lines, startIdx) {
-  const chunks = [];
-  let i = startIdx;
-  while (i < lines.length && !lines[i].startsWith("***")) {
-    if (lines[i].startsWith("@@")) {
-      const contextLine = lines[i].substring(2).trim();
-      i++;
-      const oldLines = [];
-      const newLines = [];
-      let isEndOfFile = false;
-      while (i < lines.length && !lines[i].startsWith("@@") && !lines[i].startsWith("***")) {
-        const changeLine = lines[i];
-        if (changeLine === "*** End of File") {
-          isEndOfFile = true;
-          i++;
-          break;
-        }
-        if (changeLine.startsWith(" ")) {
-          const content = changeLine.substring(1);
-          oldLines.push(content);
-          newLines.push(content);
-        } else if (changeLine.startsWith("-")) {
-          oldLines.push(changeLine.substring(1));
-        } else if (changeLine.startsWith("+")) {
-          newLines.push(changeLine.substring(1));
-        }
-        i++;
-      }
-      chunks.push({
-        old_lines: oldLines,
-        new_lines: newLines,
-        change_context: contextLine || undefined,
-        is_end_of_file: isEndOfFile || undefined
-      });
-    } else {
-      i++;
-    }
-  }
-  return { chunks, nextIdx: i };
-}
-var MAX_PATCH_SIZE = 1024 * 1024;
-var MAX_HUNKS = 500;
-function parsePatch(patchText) {
-  if (patchText.length > MAX_PATCH_SIZE) {
-    throw new Error(`Patch too large: ${patchText.length} bytes exceeds limit of ${MAX_PATCH_SIZE} bytes`);
-  }
-  const cleaned = stripHeredoc(patchText.trim());
-  const lines = cleaned.split(`
-`);
-  const hunks = [];
-  const beginIdx = lines.findIndex((line) => line.trim() === "*** Begin Patch");
-  const endIdx = lines.findIndex((line) => line.trim() === "*** End Patch");
-  if (beginIdx === -1 || endIdx === -1 || beginIdx >= endIdx) {
-    throw new Error("Invalid patch format: missing *** Begin Patch / *** End Patch markers");
-  }
-  let i = beginIdx + 1;
-  while (i < endIdx) {
-    const header = parsePatchHeader(lines, i);
-    if (!header) {
-      i++;
-      continue;
-    }
-    if (hunks.length >= MAX_HUNKS) {
-      throw new Error(`Patch exceeds maximum of ${MAX_HUNKS} file operations`);
-    }
-    if (lines[i].startsWith("*** Add File:")) {
-      const { content, nextIdx } = parseAddFileContent(lines, header.nextIdx);
-      hunks.push({ type: "add", path: header.filePath, contents: content });
-      i = nextIdx;
-    } else if (lines[i].startsWith("*** Delete File:")) {
-      hunks.push({ type: "delete", path: header.filePath });
-      i = header.nextIdx;
-    } else if (lines[i].startsWith("*** Update File:")) {
-      const { chunks, nextIdx } = parseUpdateFileChunks(lines, header.nextIdx);
-      hunks.push({
-        type: "update",
-        path: header.filePath,
-        move_path: header.movePath,
-        chunks
-      });
-      i = nextIdx;
-    } else {
-      i++;
-    }
-  }
-  return hunks;
-}
-function normalizeUnicode(str) {
-  return str.replace(/[\u2018\u2019\u201A\u201B]/g, "'").replace(/[\u201C\u201D\u201E\u201F]/g, '"').replace(/[\u2010\u2011\u2012\u2013\u2014\u2015]/g, "-").replace(/\u2026/g, "...").replace(/\u00A0/g, " ");
-}
-function normalizeIndent(str) {
-  return str.replace(/^[\t ]+/, (m) => " ".repeat(m.length));
-}
-function tryMatch(lines, pattern, startIndex, compare, eof) {
-  if (eof) {
-    const fromEnd = lines.length - pattern.length;
-    if (fromEnd >= startIndex) {
-      let matches = true;
-      for (let j = 0;j < pattern.length; j++) {
-        if (!compare(lines[fromEnd + j], pattern[j])) {
-          matches = false;
-          break;
-        }
-      }
-      if (matches)
-        return fromEnd;
-    }
-  }
-  for (let i = startIndex;i <= lines.length - pattern.length; i++) {
-    let matches = true;
-    for (let j = 0;j < pattern.length; j++) {
-      if (!compare(lines[i + j], pattern[j])) {
-        matches = false;
-        break;
-      }
-    }
-    if (matches)
-      return i;
-  }
-  return -1;
-}
-function seekSequenceTiered(lines, pattern, startIndex, eof = false) {
-  if (pattern.length === 0)
-    return null;
-  const exact = tryMatch(lines, pattern, startIndex, (a, b) => a === b, eof);
-  if (exact !== -1)
-    return { found: exact, tier: "exact" };
-  const rstrip = tryMatch(lines, pattern, startIndex, (a, b) => a.trimEnd() === b.trimEnd(), eof);
-  if (rstrip !== -1)
-    return { found: rstrip, tier: "rstrip" };
-  const trim = tryMatch(lines, pattern, startIndex, (a, b) => a.trim() === b.trim(), eof);
-  if (trim !== -1)
-    return { found: trim, tier: "trim" };
-  const indent = tryMatch(lines, pattern, startIndex, (a, b) => normalizeIndent(a).trimEnd() === normalizeIndent(b).trimEnd(), eof);
-  if (indent !== -1)
-    return { found: indent, tier: "indent" };
-  const unicode = tryMatch(lines, pattern, startIndex, (a, b) => normalizeUnicode(a.trim()) === normalizeUnicode(b.trim()), eof);
-  if (unicode !== -1)
-    return { found: unicode, tier: "unicode" };
-  return null;
-}
-function seekSequence(lines, pattern, startIndex, eof = false) {
-  const r = seekSequenceTiered(lines, pattern, startIndex, eof);
-  return r ? r.found : -1;
-}
-function findClosestPartialMatch(lines, pattern) {
-  if (pattern.length === 0 || lines.length === 0)
-    return null;
-  const compareAny = (a, b) => a === b || a.trimEnd() === b.trimEnd() || a.trim() === b.trim() || normalizeIndent(a).trimEnd() === normalizeIndent(b).trimEnd() || normalizeUnicode(a.trim()) === normalizeUnicode(b.trim());
-  const candidates = [];
-  for (let i = 0;i < lines.length && candidates.length < 16; i++) {
-    if (compareAny(lines[i], pattern[0]))
-      candidates.push(i);
-  }
-  if (candidates.length === 0)
-    return null;
-  let best = { lineNumber: -1, matchedLines: 0, firstDivergence: -1 };
-  for (const start of candidates) {
-    let matched = 0;
-    for (let j = 0;j < pattern.length && start + j < lines.length; j++) {
-      if (!compareAny(lines[start + j], pattern[j]))
-        break;
-      matched++;
-    }
-    if (matched > best.matchedLines) {
-      best = {
-        lineNumber: start + 1,
-        matchedLines: matched,
-        firstDivergence: matched
-      };
-    }
-  }
-  return best.lineNumber === -1 ? null : best;
-}
-function applyUpdateChunks(originalContent, filePath, chunks) {
-  const originalLines = originalContent.split(`
-`);
-  if (originalLines.length > 0 && originalLines[originalLines.length - 1] === "") {
-    originalLines.pop();
-  }
-  const replacements = [];
-  let lineIndex = 0;
-  for (const chunk of chunks) {
-    if (chunk.change_context) {
-      const contextIdx = seekSequence(originalLines, [chunk.change_context], lineIndex);
-      if (contextIdx === -1) {
-        throw new Error(`Failed to find context '${chunk.change_context}' in ${filePath}`);
-      }
-      lineIndex = contextIdx + 1;
-    }
-    if (chunk.old_lines.length === 0) {
-      let insertionIdx;
-      if (chunk.change_context) {
-        insertionIdx = lineIndex;
-      } else if (originalLines.length > 0 && originalLines[originalLines.length - 1] === "") {
-        insertionIdx = originalLines.length - 1;
-      } else {
-        insertionIdx = originalLines.length;
-      }
-      replacements.push([insertionIdx, 0, chunk.new_lines]);
-      continue;
-    }
-    let pattern = chunk.old_lines;
-    let newSlice = chunk.new_lines;
-    let found = seekSequence(originalLines, pattern, lineIndex, chunk.is_end_of_file);
-    if (found === -1 && pattern.length > 0 && pattern[pattern.length - 1] === "") {
-      pattern = pattern.slice(0, -1);
-      if (newSlice.length > 0 && newSlice[newSlice.length - 1] === "") {
-        newSlice = newSlice.slice(0, -1);
-      }
-      found = seekSequence(originalLines, pattern, lineIndex, chunk.is_end_of_file);
-    }
-    if (found !== -1) {
-      replacements.push([found, pattern.length, newSlice]);
-      lineIndex = found + pattern.length;
-    } else {
-      const newSliceTrimmed = newSlice.filter((line) => line.trim().length > 0);
-      const alreadyApplied = newSliceTrimmed.length > 0 && seekSequence(originalLines, newSliceTrimmed, 0, chunk.is_end_of_file) !== -1;
-      const closest = findClosestPartialMatch(originalLines, pattern);
-      let closestHint = "";
-      if (closest && closest.matchedLines > 0) {
-        const fileLineNo = closest.lineNumber + closest.firstDivergence;
-        const expectedLine = pattern[closest.firstDivergence];
-        const actualLine = fileLineNo - 1 < originalLines.length ? originalLines[fileLineNo - 1] : "<EOF>";
-        closestHint = `
-
-Closest match starts at line ${closest.lineNumber} ` + `(${closest.matchedLines} of ${pattern.length} lines matched).
-` + `First divergence at line ${fileLineNo}:
-` + `  expected: ${JSON.stringify(expectedLine)}
-` + `  actual:   ${JSON.stringify(actualLine)}`;
-      }
-      const triedTiers = "exact, trimEnd, trim, indent (tab/space), unicode";
-      const alreadyAppliedHint = alreadyApplied ? `
-
-Hint: the replacement content for this hunk already appears in the file. ` + "The patch may have been partially applied in a prior turn — re-read the file " + "to confirm which hunks still need to apply." : "";
-      throw new Error(`Failed to find expected lines in ${filePath}:
-${chunk.old_lines.join(`
-`)}
-
-` + `Tried match tiers: ${triedTiers}.${closestHint}${alreadyAppliedHint}`);
-    }
-  }
-  replacements.sort((a, b) => a[0] - b[0]);
-  const result = [...originalLines];
-  for (let i = replacements.length - 1;i >= 0; i--) {
-    const [startIdx, oldLen, newSegment] = replacements[i];
-    result.splice(startIdx, oldLen, ...newSegment);
-  }
-  if (result.length === 0 || result[result.length - 1] !== "") {
-    result.push("");
-  }
-  return result.join(`
-`);
-}
-
-// src/tools/bash.ts
-import { tool as tool5 } from "@opencode-ai/plugin";
-
-// src/shared/subagent-detect.ts
-var CACHE_MAX_ENTRIES2 = 200;
-var cache2 = new Map;
-async function resolveIsSubagent(client, sessionId, _fallbackDirectory) {
-  if (!sessionId) {
-    sessionLog(undefined, "[subagent-detect] no sessionId provided → primary");
-    return false;
-  }
-  const cached2 = cache2.get(sessionId);
-  if (cached2) {
-    cache2.delete(sessionId);
-    cache2.set(sessionId, cached2);
-    return cached2.isSubagent;
-  }
-  const c = client;
-  const sessionApi = c?.session;
-  if (!sessionApi || typeof sessionApi.get !== "function") {
-    sessionLog(sessionId, `[subagent-detect] client.session.get unavailable (client=${typeof client}, session=${typeof sessionApi}, get=${typeof sessionApi?.get}) → caching as primary`);
-    setCache2(sessionId, false);
-    return false;
-  }
-  sessionLog(sessionId, `[subagent-detect] cache miss, calling client.session.get(id=${sessionId})`);
-  let isSubagent = false;
-  let parentIdRaw;
-  try {
-    const result = await sessionApi.get({
-      path: { id: sessionId }
-    });
-    const session = result?.data ?? result;
-    parentIdRaw = session?.parentID;
-    isSubagent = session !== undefined && typeof session.parentID === "string" && session.parentID.length > 0;
-    sessionLog(sessionId, `[subagent-detect] SDK returned session=${session !== undefined ? "present" : "undefined"}, parentID=${JSON.stringify(parentIdRaw)} → isSubagent=${isSubagent}`);
-  } catch (err) {
-    sessionWarn(sessionId, `[subagent-detect] SDK lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-    return false;
-  }
-  setCache2(sessionId, isSubagent);
-  return isSubagent;
-}
-function setCache2(sessionId, isSubagent) {
-  if (cache2.has(sessionId))
-    cache2.delete(sessionId);
-  cache2.set(sessionId, { isSubagent, recordedAt: Date.now() });
-  if (cache2.size > CACHE_MAX_ENTRIES2) {
-    const oldest = cache2.keys().next().value;
-    if (oldest !== undefined)
-      cache2.delete(oldest);
+  setCache2(sessionId, isSubagent);
+  return isSubagent;
+}
+function setCache2(sessionId, isSubagent) {
+  if (cache2.has(sessionId))
+    cache2.delete(sessionId);
+  cache2.set(sessionId, { isSubagent, recordedAt: Date.now() });
+  if (cache2.size > CACHE_MAX_ENTRIES2) {
+    const oldest = cache2.keys().next().value;
+    if (oldest !== undefined)
+      cache2.delete(oldest);
   }
 }
 
 // src/tools/bash.ts
-var z5 = tool5.schema;
+var z4 = tool4.schema;
 var METADATA_PREVIEW_LIMIT = 30 * 1024;
 var FOREGROUND_POLL_INTERVAL_MS = 100;
 var DEFAULT_HARD_TIMEOUT_MS = 30 * 60 * 1000;
@@ -34485,7 +34466,14 @@ function resolveForegroundWaitMs(configured) {
   }
   return configured;
 }
-var BASH_DESCRIPTION = `Hoisted bash tool with output compression, command rewriting to AFT tools, optional background execution, and PTY mode for interactive programs. By default, output is compressed; pass compressed: false for raw output. Pass background: true to spawn in the background and get a taskId for bash_status/bash_kill. Pass pty: true for interactive REPLs and drive them with bash_status({ outputMode: "screen" }) plus bash_write (pty implies background automatically). Use bash_watch to block on or register for pattern matches and exit events.`;
+function bashToolDescription(aftSearchRegistered, compressionOn, backgroundOn) {
+  const searchSteer = aftSearchRegistered ? "use aft_search (concepts, identifiers, regex, literals), read, aft_outline, or aft_zoom instead" : "use the grep tool, read, aft_outline, or aft_zoom instead";
+  const compression = compressionOn ? " Output is compressed by default; pass compressed: false for raw output." : "";
+  const tasks = backgroundOn ? ' Pass background: true to run in the background and get a taskId for bash_status/bash_kill. Pass pty: true for interactive programs (REPLs, TUIs) and drive them with bash_status({ outputMode: "screen" }) plus bash_write (pty implies background automatically).' : " Commands that outlive the foreground wait window are promoted to background tasks; inspect them with bash_status({ taskId }) or terminate with bash_kill.";
+  return `Execute shell commands.${compression}${tasks} Use bash_watch to wait for output patterns or exit events.
+
+DO NOT use bash for code search or code exploration. If you are about to run grep, rg, sed, awk, find, or cat through bash to locate or read code: STOP — ${searchSteer}.`;
+}
 async function withPermissionLoop(ctx, runtime, params, bridgeCall, options) {
   const first = await bridgeCall(ctx, runtime, "bash", params, options);
   if (first.success !== false || first.code !== "permission_required")
@@ -34508,22 +34496,27 @@ async function withPermissionLoop(ctx, runtime, params, bridgeCall, options) {
   }
   return second;
 }
-function createBashTool(ctx) {
+function createBashTool(ctx, aftSearchRegisteredOverride) {
   return {
-    description: BASH_DESCRIPTION,
+    description: (() => {
+      const cfg = resolveBashConfig(ctx.config);
+      return bashToolDescription(false, cfg.compress, cfg.background);
+    })(),
     args: {
-      command: z5.string().describe("Shell command to execute through AFT's unified bash schema. Supports normal shell syntax, pipes, redirection, and command rewriting to dedicated AFT tools when available."),
+      command: z4.string().describe("Shell command to execute. Supports pipes, redirection, and normal shell syntax."),
       timeout: optionalInt(1, Number.MAX_SAFE_INTEGER).describe("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."),
-      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."),
-      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."),
-      compressed: z5.boolean().optional().describe("When true or omitted, return compressed output with noisy terminal control sequences reduced. Set to false for raw output."),
-      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.'),
+      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."),
+      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."),
+      compressed: z4.boolean().optional().describe("When true or omitted, return compressed output with noisy terminal control sequences reduced. Set to false for raw output."),
+      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.'),
       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.")
     },
     execute: async (args, context) => {
       const bashCfg = resolveBashConfig(ctx.config);
+      const ctxAftSearchRegistered = ctx.aftSearchRegistered === true;
+      const aftSearchRegistered = aftSearchRegisteredOverride ?? ctxAftSearchRegistered;
       let accumulatedOutput = "";
       const description = args.description;
       const metadata = context.metadata;
@@ -34591,7 +34584,7 @@ function createBashTool(ctx) {
             throw new Error(status.message ?? "bash_status failed");
           }
           if (isTerminalStatus(status.status)) {
-            const rendered2 = appendPipeStripNote(formatForegroundResult(status), pipeStrip.note);
+            const rendered2 = maybeAppendGrepSearchHint(appendPipeStripNote(formatForegroundResult(status), pipeStrip.note), command, aftSearchRegistered);
             const metadataPayload2 = foregroundMetadata(description, status, rendered2);
             metadata?.(metadataPayload2);
             return { output: rendered2, title: uiTitle, metadata: metadataPayload2 };
@@ -34646,186 +34639,522 @@ function createBashTool(ctx) {
         rendered += `
 [exit code: ${exit}]`;
       }
-      rendered = appendPipeStripNote(rendered, pipeStrip.note);
-      return {
-        output: rendered,
-        title: description ?? shortenCommand(command),
-        metadata: metadataPayload
-      };
+      rendered = appendPipeStripNote(rendered, pipeStrip.note);
+      return {
+        output: rendered,
+        title: description ?? shortenCommand(command),
+        metadata: metadataPayload
+      };
+    }
+  };
+}
+function appendPipeStripNote(output, note) {
+  return note ? `${output}
+
+${note}` : output;
+}
+function createBashStatusTool(ctx) {
+  return {
+    description: "Read-only snapshot of a background or PTY bash task's current state and output. Returns immediately. Never waits. Use bash_watch to block on or register for pattern matches and exit events.",
+    args: {
+      taskId: z4.string().describe("Background task ID returned by bash({ background: true }), e.g. bash-6b454047."),
+      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.")
+    },
+    execute: async (args, context) => {
+      const taskId = args.taskId;
+      const outputMode = args.outputMode;
+      const data = await bashStatusSnapshot(ctx, context, taskId, outputMode);
+      return await formatBashStatusText(context, taskId, data, outputMode);
+    }
+  };
+}
+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-6b454047.")
+    },
+    execute: async (args, context) => {
+      const data = await callBashBridge(ctx, context, "bash_kill", {
+        task_id: args.taskId
+      });
+      if (data.success === false) {
+        throw new Error(data.message ?? "bash_kill failed");
+      }
+      await disposePtyTerminal(ptyCacheKey(context, args.taskId));
+      if (data.kill_signaled === true) {
+        return `Task ${args.taskId}: kill_signaled`;
+      }
+      return `Task ${args.taskId}: ${String(data.status ?? "killed")}`;
+    }
+  };
+}
+async function bashStatusSnapshot(ctx, runtime, taskId, outputMode, options) {
+  const data = await callBashBridge(ctx, runtime, "bash_status", { task_id: taskId, output_mode: outputMode }, options);
+  if (data.success === false) {
+    throw new Error(data.message ?? "bash_status failed");
+  }
+  return data;
+}
+async function formatBashStatusText(runtime, taskId, data, requestedOutputMode) {
+  const status = data.status;
+  const exit = typeof data.exit_code === "number" ? ` (exit ${data.exit_code})` : "";
+  const dur = typeof data.duration_ms === "number" ? ` ${Math.round(data.duration_ms / 1000)}s` : "";
+  let text = `Task ${taskId}: ${status}${exit}${dur}`;
+  if (data.mode === "pty") {
+    text += await formatPtyStatus(runtime, taskId, data, requestedOutputMode);
+  } else {
+    const preview = data.output_preview;
+    if (preview && status !== "running") {
+      text += `
+${preview}`;
+    }
+    if (status === "running") {
+      text += `
+A completion reminder will be delivered automatically; don't poll.`;
+    }
+  }
+  return text;
+}
+async function formatPtyStatus(runtime, taskId, data, requestedOutputMode) {
+  const outputPath = data.output_path;
+  if (!outputPath)
+    return `
+[PTY output path unavailable]`;
+  const key = ptyCacheKey(runtime, taskId);
+  const { rows, cols } = ptyDimensions(data);
+  const state = await getOrCreatePtyTerminal(key, outputPath, rows, cols);
+  const raw = await readPtyBytes(state);
+  const outputMode = requestedOutputMode ?? "screen";
+  let suffix = "";
+  if (outputMode === "raw") {
+    suffix = raw.length > 0 ? `
+${raw.toString("utf8")}` : "";
+  } else if (outputMode === "both") {
+    suffix = `
+${JSON.stringify({ screen: renderScreen(state, rows, cols), raw: raw.toString("utf8") }, null, 2)}`;
+  } else {
+    const screen = renderScreen(state, rows, cols);
+    suffix = screen ? `
+${screen}` : "";
+  }
+  if (data.status === "running") {
+    suffix += `
+PTY task is still running. Use bash_status({ taskId: "${taskId}", outputMode: "screen" }) to inspect, bash_write({ taskId: "${taskId}", input: "..." }) to send keystrokes.`;
+  } else if (isTerminalStatus(data.status)) {
+    await disposePtyTerminal(key);
+  }
+  return suffix;
+}
+function ptyDimensions(data) {
+  const rows = typeof data.pty_rows === "number" ? data.pty_rows : 24;
+  const cols = typeof data.pty_cols === "number" ? data.pty_cols : 80;
+  return { rows, cols };
+}
+function ptyCacheKey(runtime, taskId) {
+  return `${projectRootFor(runtime)}::${runtime.sessionID ?? "__default__"}::${taskId}`;
+}
+function preview(output) {
+  return output.length <= METADATA_PREVIEW_LIMIT ? output : output.slice(-METADATA_PREVIEW_LIMIT);
+}
+function isTerminalStatus(status) {
+  return status === "completed" || status === "failed" || status === "killed" || status === "timed_out";
+}
+function subagentGuidance(taskId) {
+  return `
+
+NOTE (subagent session): Continue with other work if you have it. If you don't, call bash_watch({ taskId: "${taskId}", timeoutMs: 60000 }) to wait for completion before returning to the parent. Subagents don't survive turn-end and won't receive the completion reminder.`;
+}
+function formatBackgroundLaunch(taskId, isPty) {
+  if (isPty) {
+    return `PTY task started: ${taskId}. Use bash_status({ taskId: "${taskId}", outputMode: "screen" }) to see the visible terminal, bash_write({ taskId: "${taskId}", input: ... }) to send keystrokes. A completion reminder fires automatically when the task exits.`;
+  }
+  return `Background task started: ${taskId}. A completion reminder will be delivered automatically; don't poll bash_status.`;
+}
+function formatPromotionMessage(taskId, timeout, waitWindowMs) {
+  const waited = timeout !== undefined ? Math.min(timeout, waitWindowMs) : waitWindowMs;
+  return `Foreground bash didn't finish within ${formatSeconds(waited)} and was promoted to background: ${taskId}. A completion reminder will be delivered automatically; use bash_status({ taskId: "${taskId}" }) to inspect output or bash_kill({ taskId: "${taskId}" }) to terminate.`;
+}
+function formatSeconds(ms) {
+  return `${Number((ms / 1000).toFixed(1))}s`;
+}
+function formatForegroundResult(data) {
+  const output = data.output_preview ?? "";
+  const outputPath = data.output_path;
+  const truncated = data.output_truncated === true;
+  const status = data.status;
+  const exit = data.exit_code;
+  let rendered = output;
+  if (truncated && outputPath) {
+    rendered += `
+[output truncated; full output at ${outputPath}]`;
+  }
+  if (status === "timed_out") {
+    rendered += `
+[command timed out]`;
+  }
+  if (typeof exit === "number" && exit !== 0) {
+    rendered += `
+[exit code: ${exit}]`;
+  }
+  return rendered;
+}
+function foregroundMetadata(description, data, rendered) {
+  const outputPath = data.output_path;
+  return {
+    description,
+    output: preview(rendered),
+    exit: data.exit_code,
+    truncated: data.output_truncated,
+    ...outputPath ? { outputPath } : {}
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve7) => setTimeout(resolve7, ms));
+}
+function getCallID(ctx) {
+  const c = ctx;
+  return c.callID ?? c.callId ?? c.call_id;
+}
+function shortenCommand(command) {
+  const collapsed = command.replace(/\s+/g, " ").trim();
+  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 params = {};
+        if (!isEmptyParam(args?.path)) {
+          const expanded = expandTilde(String(args.path));
+          const projectRoot = await resolveProjectRoot(ctx, context);
+          const resolved = resolvePathFromProjectRoot(projectRoot, expanded);
+          const denied = await assertExternalDirectoryPermission(context, resolved, {
+            kind: "directory"
+          });
+          if (denied)
+            return permissionDeniedResponse(denied);
+          params.path = resolved;
+        }
+        const response = await callBridge(ctx, context, "git_conflicts", params);
+        if (response.success === false) {
+          throw new Error(response.message || "git_conflicts failed");
+        }
+        return response.text;
+      }
     }
   };
 }
-function appendPipeStripNote(output, note) {
-  return note ? `${output}
 
-${note}` : output;
+// src/tools/hoisted.ts
+import * as fs6 from "node:fs";
+import * as path4 from "node:path";
+import { tool as tool8 } from "@opencode-ai/plugin";
+
+// src/patch-parser.ts
+function stripHeredoc(input) {
+  const heredocMatch = input.match(/^(?:cat\s+)?<<['"]?(\w+)['"]?\s*\n([\s\S]*?)\n\1\s*$/);
+  return heredocMatch ? heredocMatch[2] : input;
 }
-function createBashStatusTool(ctx) {
-  return {
-    description: "Read-only snapshot of a background or PTY bash task's current state and output. Returns immediately. Never waits. Use bash_watch to block on or register for pattern matches and exit events.",
-    args: {
-      taskId: z5.string().describe("Background task ID returned by bash({ background: true }), e.g. bash-6b454047."),
-      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;
-      const outputMode = args.outputMode;
-      const data = await bashStatusSnapshot(ctx, context, taskId, outputMode);
-      return await formatBashStatusText(context, taskId, data, outputMode);
+function parsePatchHeader(lines, startIdx) {
+  const line = lines[startIdx];
+  if (line.startsWith("*** Add File:")) {
+    const filePath = line.slice("*** Add File:".length).trim();
+    return filePath ? { filePath, nextIdx: startIdx + 1 } : null;
+  }
+  if (line.startsWith("*** Delete File:")) {
+    const filePath = line.slice("*** Delete File:".length).trim();
+    return filePath ? { filePath, nextIdx: startIdx + 1 } : null;
+  }
+  if (line.startsWith("*** Update File:")) {
+    const filePath = line.slice("*** Update File:".length).trim();
+    let movePath;
+    let nextIdx = startIdx + 1;
+    if (nextIdx < lines.length && lines[nextIdx].startsWith("*** Move to:")) {
+      movePath = lines[nextIdx].slice("*** Move to:".length).trim();
+      nextIdx++;
     }
-  };
+    return filePath ? { filePath, movePath, nextIdx } : null;
+  }
+  return null;
 }
-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: z5.string().describe("Background task ID returned by bash({ background: true }), e.g. bash-6b454047.")
-    },
-    execute: async (args, context) => {
-      const data = await callBashBridge(ctx, context, "bash_kill", {
-        task_id: args.taskId
+function parseAddFileContent(lines, startIdx) {
+  let content = "";
+  let i = startIdx;
+  while (i < lines.length && !lines[i].startsWith("***")) {
+    if (lines[i].startsWith("+")) {
+      content += `${lines[i].substring(1)}
+`;
+    }
+    i++;
+  }
+  if (content.endsWith(`
+`)) {
+    content = content.slice(0, -1);
+  }
+  return { content, nextIdx: i };
+}
+function parseUpdateFileChunks(lines, startIdx) {
+  const chunks = [];
+  let i = startIdx;
+  while (i < lines.length && !lines[i].startsWith("***")) {
+    if (lines[i].startsWith("@@")) {
+      const contextLine = lines[i].substring(2).trim();
+      i++;
+      const oldLines = [];
+      const newLines = [];
+      let isEndOfFile = false;
+      while (i < lines.length && !lines[i].startsWith("@@") && !lines[i].startsWith("***")) {
+        const changeLine = lines[i];
+        if (changeLine === "*** End of File") {
+          isEndOfFile = true;
+          i++;
+          break;
+        }
+        if (changeLine.startsWith(" ")) {
+          const content = changeLine.substring(1);
+          oldLines.push(content);
+          newLines.push(content);
+        } else if (changeLine.startsWith("-")) {
+          oldLines.push(changeLine.substring(1));
+        } else if (changeLine.startsWith("+")) {
+          newLines.push(changeLine.substring(1));
+        }
+        i++;
+      }
+      chunks.push({
+        old_lines: oldLines,
+        new_lines: newLines,
+        change_context: contextLine || undefined,
+        is_end_of_file: isEndOfFile || undefined
       });
-      if (data.success === false) {
-        throw new Error(data.message ?? "bash_kill failed");
+    } else {
+      i++;
+    }
+  }
+  return { chunks, nextIdx: i };
+}
+var MAX_PATCH_SIZE = 1024 * 1024;
+var MAX_HUNKS = 500;
+function parsePatch(patchText) {
+  if (patchText.length > MAX_PATCH_SIZE) {
+    throw new Error(`Patch too large: ${patchText.length} bytes exceeds limit of ${MAX_PATCH_SIZE} bytes`);
+  }
+  const cleaned = stripHeredoc(patchText.trim());
+  const lines = cleaned.split(`
+`);
+  const hunks = [];
+  const beginIdx = lines.findIndex((line) => line.trim() === "*** Begin Patch");
+  const endIdx = lines.findIndex((line) => line.trim() === "*** End Patch");
+  if (beginIdx === -1 || endIdx === -1 || beginIdx >= endIdx) {
+    throw new Error("Invalid patch format: missing *** Begin Patch / *** End Patch markers");
+  }
+  let i = beginIdx + 1;
+  while (i < endIdx) {
+    const header = parsePatchHeader(lines, i);
+    if (!header) {
+      i++;
+      continue;
+    }
+    if (hunks.length >= MAX_HUNKS) {
+      throw new Error(`Patch exceeds maximum of ${MAX_HUNKS} file operations`);
+    }
+    if (lines[i].startsWith("*** Add File:")) {
+      const { content, nextIdx } = parseAddFileContent(lines, header.nextIdx);
+      hunks.push({ type: "add", path: header.filePath, contents: content });
+      i = nextIdx;
+    } else if (lines[i].startsWith("*** Delete File:")) {
+      hunks.push({ type: "delete", path: header.filePath });
+      i = header.nextIdx;
+    } else if (lines[i].startsWith("*** Update File:")) {
+      const { chunks, nextIdx } = parseUpdateFileChunks(lines, header.nextIdx);
+      hunks.push({
+        type: "update",
+        path: header.filePath,
+        move_path: header.movePath,
+        chunks
+      });
+      i = nextIdx;
+    } else {
+      i++;
+    }
+  }
+  return hunks;
+}
+function normalizeUnicode(str) {
+  return str.replace(/[\u2018\u2019\u201A\u201B]/g, "'").replace(/[\u201C\u201D\u201E\u201F]/g, '"').replace(/[\u2010\u2011\u2012\u2013\u2014\u2015]/g, "-").replace(/\u2026/g, "...").replace(/\u00A0/g, " ");
+}
+function normalizeIndent(str) {
+  return str.replace(/^[\t ]+/, (m) => " ".repeat(m.length));
+}
+function tryMatch(lines, pattern, startIndex, compare, eof) {
+  if (eof) {
+    const fromEnd = lines.length - pattern.length;
+    if (fromEnd >= startIndex) {
+      let matches = true;
+      for (let j = 0;j < pattern.length; j++) {
+        if (!compare(lines[fromEnd + j], pattern[j])) {
+          matches = false;
+          break;
+        }
       }
-      await disposePtyTerminal(ptyCacheKey(context, args.taskId));
-      if (data.kill_signaled === true) {
-        return `Task ${args.taskId}: kill_signaled`;
+      if (matches)
+        return fromEnd;
+    }
+  }
+  for (let i = startIndex;i <= lines.length - pattern.length; i++) {
+    let matches = true;
+    for (let j = 0;j < pattern.length; j++) {
+      if (!compare(lines[i + j], pattern[j])) {
+        matches = false;
+        break;
       }
-      return `Task ${args.taskId}: ${String(data.status ?? "killed")}`;
     }
-  };
-}
-async function bashStatusSnapshot(ctx, runtime, taskId, outputMode, options) {
-  const data = await callBashBridge(ctx, runtime, "bash_status", { task_id: taskId, output_mode: outputMode }, options);
-  if (data.success === false) {
-    throw new Error(data.message ?? "bash_status failed");
+    if (matches)
+      return i;
   }
-  return data;
+  return -1;
 }
-async function formatBashStatusText(runtime, taskId, data, requestedOutputMode) {
-  const status = data.status;
-  const exit = typeof data.exit_code === "number" ? ` (exit ${data.exit_code})` : "";
-  const dur = typeof data.duration_ms === "number" ? ` ${Math.round(data.duration_ms / 1000)}s` : "";
-  let text = `Task ${taskId}: ${status}${exit}${dur}`;
-  if (data.mode === "pty") {
-    text += await formatPtyStatus(runtime, taskId, data, requestedOutputMode);
-  } else {
-    const preview = data.output_preview;
-    if (preview && status !== "running") {
-      text += `
-${preview}`;
+function seekSequenceTiered(lines, pattern, startIndex, eof = false) {
+  if (pattern.length === 0)
+    return null;
+  const exact = tryMatch(lines, pattern, startIndex, (a, b) => a === b, eof);
+  if (exact !== -1)
+    return { found: exact, tier: "exact" };
+  const rstrip = tryMatch(lines, pattern, startIndex, (a, b) => a.trimEnd() === b.trimEnd(), eof);
+  if (rstrip !== -1)
+    return { found: rstrip, tier: "rstrip" };
+  const trim = tryMatch(lines, pattern, startIndex, (a, b) => a.trim() === b.trim(), eof);
+  if (trim !== -1)
+    return { found: trim, tier: "trim" };
+  const indent = tryMatch(lines, pattern, startIndex, (a, b) => normalizeIndent(a).trimEnd() === normalizeIndent(b).trimEnd(), eof);
+  if (indent !== -1)
+    return { found: indent, tier: "indent" };
+  const unicode = tryMatch(lines, pattern, startIndex, (a, b) => normalizeUnicode(a.trim()) === normalizeUnicode(b.trim()), eof);
+  if (unicode !== -1)
+    return { found: unicode, tier: "unicode" };
+  return null;
+}
+function seekSequence(lines, pattern, startIndex, eof = false) {
+  const r = seekSequenceTiered(lines, pattern, startIndex, eof);
+  return r ? r.found : -1;
+}
+function findClosestPartialMatch(lines, pattern) {
+  if (pattern.length === 0 || lines.length === 0)
+    return null;
+  const compareAny = (a, b) => a === b || a.trimEnd() === b.trimEnd() || a.trim() === b.trim() || normalizeIndent(a).trimEnd() === normalizeIndent(b).trimEnd() || normalizeUnicode(a.trim()) === normalizeUnicode(b.trim());
+  const candidates = [];
+  for (let i = 0;i < lines.length && candidates.length < 16; i++) {
+    if (compareAny(lines[i], pattern[0]))
+      candidates.push(i);
+  }
+  if (candidates.length === 0)
+    return null;
+  let best = { lineNumber: -1, matchedLines: 0, firstDivergence: -1 };
+  for (const start of candidates) {
+    let matched = 0;
+    for (let j = 0;j < pattern.length && start + j < lines.length; j++) {
+      if (!compareAny(lines[start + j], pattern[j]))
+        break;
+      matched++;
     }
-    if (status === "running") {
-      text += `
-A completion reminder will be delivered automatically; don't poll.`;
+    if (matched > best.matchedLines) {
+      best = {
+        lineNumber: start + 1,
+        matchedLines: matched,
+        firstDivergence: matched
+      };
     }
   }
-  return text;
+  return best.lineNumber === -1 ? null : best;
 }
-async function formatPtyStatus(runtime, taskId, data, requestedOutputMode) {
-  const outputPath = data.output_path;
-  if (!outputPath)
-    return `
-[PTY output path unavailable]`;
-  const key = ptyCacheKey(runtime, taskId);
-  const { rows, cols } = ptyDimensions(data);
-  const state = await getOrCreatePtyTerminal(key, outputPath, rows, cols);
-  const raw = await readPtyBytes(state);
-  const outputMode = requestedOutputMode ?? "screen";
-  let suffix = "";
-  if (outputMode === "raw") {
-    suffix = raw.length > 0 ? `
-${raw.toString("utf8")}` : "";
-  } else if (outputMode === "both") {
-    suffix = `
-${JSON.stringify({ screen: renderScreen(state, rows, cols), raw: raw.toString("utf8") }, null, 2)}`;
-  } else {
-    const screen = renderScreen(state, rows, cols);
-    suffix = screen ? `
-${screen}` : "";
-  }
-  if (data.status === "running") {
-    suffix += `
-PTY task is still running. Use bash_status({ taskId: "${taskId}", outputMode: "screen" }) to inspect, bash_write({ taskId: "${taskId}", input: "..." }) to send keystrokes.`;
-  } else if (isTerminalStatus(data.status)) {
-    await disposePtyTerminal(key);
+function applyUpdateChunks(originalContent, filePath, chunks) {
+  const originalLines = originalContent.split(`
+`);
+  if (originalLines.length > 0 && originalLines[originalLines.length - 1] === "") {
+    originalLines.pop();
   }
-  return suffix;
-}
-function ptyDimensions(data) {
-  const rows = typeof data.pty_rows === "number" ? data.pty_rows : 24;
-  const cols = typeof data.pty_cols === "number" ? data.pty_cols : 80;
-  return { rows, cols };
-}
-function ptyCacheKey(runtime, taskId) {
-  return `${projectRootFor(runtime)}::${runtime.sessionID ?? "__default__"}::${taskId}`;
-}
-function preview(output) {
-  return output.length <= METADATA_PREVIEW_LIMIT ? output : output.slice(-METADATA_PREVIEW_LIMIT);
-}
-function isTerminalStatus(status) {
-  return status === "completed" || status === "failed" || status === "killed" || status === "timed_out";
-}
-function subagentGuidance(taskId) {
-  return `
+  const replacements = [];
+  let lineIndex = 0;
+  for (const chunk of chunks) {
+    if (chunk.change_context) {
+      const contextIdx = seekSequence(originalLines, [chunk.change_context], lineIndex);
+      if (contextIdx === -1) {
+        throw new Error(`Failed to find context '${chunk.change_context}' in ${filePath}`);
+      }
+      lineIndex = contextIdx + 1;
+    }
+    if (chunk.old_lines.length === 0) {
+      let insertionIdx;
+      if (chunk.change_context) {
+        insertionIdx = lineIndex;
+      } else if (originalLines.length > 0 && originalLines[originalLines.length - 1] === "") {
+        insertionIdx = originalLines.length - 1;
+      } else {
+        insertionIdx = originalLines.length;
+      }
+      replacements.push([insertionIdx, 0, chunk.new_lines]);
+      continue;
+    }
+    let pattern = chunk.old_lines;
+    let newSlice = chunk.new_lines;
+    let found = seekSequence(originalLines, pattern, lineIndex, chunk.is_end_of_file);
+    if (found === -1 && pattern.length > 0 && pattern[pattern.length - 1] === "") {
+      pattern = pattern.slice(0, -1);
+      if (newSlice.length > 0 && newSlice[newSlice.length - 1] === "") {
+        newSlice = newSlice.slice(0, -1);
+      }
+      found = seekSequence(originalLines, pattern, lineIndex, chunk.is_end_of_file);
+    }
+    if (found !== -1) {
+      replacements.push([found, pattern.length, newSlice]);
+      lineIndex = found + pattern.length;
+    } else {
+      const newSliceTrimmed = newSlice.filter((line) => line.trim().length > 0);
+      const alreadyApplied = newSliceTrimmed.length > 0 && seekSequence(originalLines, newSliceTrimmed, 0, chunk.is_end_of_file) !== -1;
+      const closest = findClosestPartialMatch(originalLines, pattern);
+      let closestHint = "";
+      if (closest && closest.matchedLines > 0) {
+        const fileLineNo = closest.lineNumber + closest.firstDivergence;
+        const expectedLine = pattern[closest.firstDivergence];
+        const actualLine = fileLineNo - 1 < originalLines.length ? originalLines[fileLineNo - 1] : "<EOF>";
+        closestHint = `
 
-NOTE (subagent session): Continue with other work if you have it. If you don't, call bash_watch({ taskId: "${taskId}", timeoutMs: 60000 }) to wait for completion before returning to the parent. Subagents don't survive turn-end and won't receive the completion reminder.`;
-}
-function formatBackgroundLaunch(taskId, isPty) {
-  if (isPty) {
-    return `PTY task started: ${taskId}. Use bash_status({ taskId: "${taskId}", outputMode: "screen" }) to see the visible terminal, bash_write({ taskId: "${taskId}", input: ... }) to send keystrokes. A completion reminder fires automatically when the task exits.`;
-  }
-  return `Background task started: ${taskId}. A completion reminder will be delivered automatically; don't poll bash_status.`;
-}
-function formatPromotionMessage(taskId, timeout, waitWindowMs) {
-  const waited = timeout !== undefined ? Math.min(timeout, waitWindowMs) : waitWindowMs;
-  return `Foreground bash didn't finish within ${formatSeconds(waited)} and was promoted to background: ${taskId}. A completion reminder will be delivered automatically; use bash_status({ taskId: "${taskId}" }) to inspect output or bash_kill({ taskId: "${taskId}" }) to terminate.`;
-}
-function formatSeconds(ms) {
-  return `${Number((ms / 1000).toFixed(1))}s`;
-}
-function formatForegroundResult(data) {
-  const output = data.output_preview ?? "";
-  const outputPath = data.output_path;
-  const truncated = data.output_truncated === true;
-  const status = data.status;
-  const exit = data.exit_code;
-  let rendered = output;
-  if (truncated && outputPath) {
-    rendered += `
-[output truncated; full output at ${outputPath}]`;
+Closest match starts at line ${closest.lineNumber} ` + `(${closest.matchedLines} of ${pattern.length} lines matched).
+` + `First divergence at line ${fileLineNo}:
+` + `  expected: ${JSON.stringify(expectedLine)}
+` + `  actual:   ${JSON.stringify(actualLine)}`;
+      }
+      const triedTiers = "exact, trimEnd, trim, indent (tab/space), unicode";
+      const alreadyAppliedHint = alreadyApplied ? `
+
+Hint: the replacement content for this hunk already appears in the file. ` + "The patch may have been partially applied in a prior turn — re-read the file " + "to confirm which hunks still need to apply." : "";
+      throw new Error(`Failed to find expected lines in ${filePath}:
+${chunk.old_lines.join(`
+`)}
+
+` + `Tried match tiers: ${triedTiers}.${closestHint}${alreadyAppliedHint}`);
+    }
   }
-  if (status === "timed_out") {
-    rendered += `
-[command timed out]`;
+  replacements.sort((a, b) => a[0] - b[0]);
+  const result = [...originalLines];
+  for (let i = replacements.length - 1;i >= 0; i--) {
+    const [startIdx, oldLen, newSegment] = replacements[i];
+    result.splice(startIdx, oldLen, ...newSegment);
   }
-  if (typeof exit === "number" && exit !== 0) {
-    rendered += `
-[exit code: ${exit}]`;
+  if (result.length === 0 || result[result.length - 1] !== "") {
+    result.push("");
   }
-  return rendered;
-}
-function foregroundMetadata(description, data, rendered) {
-  const outputPath = data.output_path;
-  return {
-    description,
-    output: preview(rendered),
-    exit: data.exit_code,
-    truncated: data.output_truncated,
-    ...outputPath ? { outputPath } : {}
-  };
-}
-function sleep(ms) {
-  return new Promise((resolve7) => setTimeout(resolve7, ms));
-}
-function getCallID(ctx) {
-  const c = ctx;
-  return c.callID ?? c.callId ?? c.call_id;
-}
-function shortenCommand(command) {
-  const collapsed = command.replace(/\s+/g, " ").trim();
-  return collapsed.length <= 80 ? collapsed : `${collapsed.slice(0, 77)}...`;
+  return result.join(`
+`);
 }
 
 // src/tools/bash_watch.ts
@@ -35339,7 +35668,6 @@ function inferBeforeStart(ops, from, beforeLen) {
   return beforeLen;
 }
 var z8 = tool8.schema;
-var DIAGNOSTICS_PARAM_DESCRIPTION = "When true, wait up to 3 seconds for fresh LSP diagnostics on the edited file and include them in the result. Defaults to the configured `lsp.diagnostics_on_edit` value (false unless configured); per-call true/false overrides. Use aft_inspect to check diagnostics across a batch of edits or before tests/commits.";
 function diagnosticsOnEditDefault(ctx) {
   return ctx.config.lsp?.diagnostics_on_edit ?? false;
 }
@@ -35471,30 +35799,14 @@ function createReadTool(ctx) {
   };
 }
 function getWriteDescription(editToolName) {
-  return `Write content to a file, creating it (and parent directories) if needed.
-
-Automatically creates parent directories. Backs up existing files before overwriting.
-If the project has a formatter configured (biome, prettier, rustfmt, etc.), the file
-is auto-formatted after writing. Edits return as soon as the write completes unless
-the configured \`lsp.diagnostics_on_edit\` default or a per-call \`diagnostics: true\`
-asks for legacy sync-wait behavior. Call \`aft_inspect\` afterward to check
-diagnostics across a batch of edits.
-
-**Behavior:**
-- Creates parent directories automatically (no need to mkdir first)
-- Existing files are backed up before overwriting (recoverable via aft_safety undo)
-- Auto-formats using project formatter if configured (biome.json, .prettierrc, etc.)
-- LSP diagnostics follow \`lsp.diagnostics_on_edit\` by default; pass \`diagnostics\` to override per call
-- Use this for creating new files or completely replacing file contents
-- For partial edits (find/replace), use the \`${editToolName}\` tool instead`;
+  return `Write content to a file, creating it and parent directories automatically. Existing files are backed up before overwriting (undo via aft_safety) and auto-formatted when the project has a formatter configured. Use it to create files or replace whole contents; for partial edits, use the \`${editToolName}\` tool.`;
 }
 function createWriteTool(ctx, editToolName = "edit") {
   return {
     description: getWriteDescription(editToolName),
     args: {
       filePath: z8.string().describe("Path to the file to write (absolute or relative to project root)"),
-      content: z8.string().describe("The full content to write to the file"),
-      diagnostics: z8.boolean().optional().describe(DIAGNOSTICS_PARAM_DESCRIPTION)
+      content: z8.string().describe("The full content to write to the file")
     },
     execute: async (args, context) => {
       const file2 = args.filePath;
@@ -35517,12 +35829,15 @@ function createWriteTool(ctx, editToolName = "edit") {
         file: filePath,
         content,
         create_dirs: true,
-        diagnostics: args.diagnostics ?? diagnosticsOnEditDefault(ctx),
+        diagnostics: diagnosticsOnEditDefault(ctx),
         include_diff_content: true
       });
       if (data.success === false) {
         throw new Error(data.message || "write failed");
       }
+      if (data.rolled_back === true) {
+        return "Write rolled back: the content produced invalid syntax, so the file was left unchanged.";
+      }
       let output = data.created ? "Created new file." : "File updated.";
       if (data.formatted)
         output += " Auto-formatted.";
@@ -35621,7 +35936,6 @@ Note: Modes 5 and 6 are options on mode 4 (find/replace) — they require \`oldS
 - Auto-formats using project formatter if configured
 - Tree-sitter syntax validation on all edits
 - Symbol replace includes decorators, attributes, and doc comments in range
-- Edits return as soon as the write completes unless \`lsp.diagnostics_on_edit\` or a per-call \`diagnostics: true\` requests legacy sync-wait behavior. Call \`aft_inspect\` afterward to check diagnostics across a batch of edits.
 - Response is a JSON string for the selected edit mode; key fields include success, diff, backup_id, syntax_valid, and mode-specific fields.`;
 }
 function createEditTool(ctx, writeToolName = "write") {
@@ -35636,8 +35950,7 @@ function createEditTool(ctx, writeToolName = "write") {
       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"),
-      edits: z8.array(z8.record(z8.string(), z8.unknown())).optional().describe("Batch edits — array of { oldString: string, newString: string } or { startLine: number (1-based), endLine: number (1-based, inclusive), content: string }"),
-      diagnostics: z8.boolean().optional().describe(DIAGNOSTICS_PARAM_DESCRIPTION)
+      edits: z8.array(z8.record(z8.string(), z8.unknown())).optional().describe("Batch edits — array of { oldString: string, newString: string } or { startLine: number (1-based), endLine: number (1-based, inclusive), content: string }")
     },
     execute: async (args, context) => {
       const argsRecord = args;
@@ -35703,7 +36016,7 @@ function createEditTool(ctx, writeToolName = "write") {
         const hint = typeof args.content === "string" ? ` To write the whole file, use the '${writeToolName}' tool. To edit existing content, provide 'oldString' (and optionally 'newString'), 'symbol' + 'content', or an 'edits' array.` : " Provide 'oldString' (+ optional 'newString'), 'symbol' + 'content', or an 'edits' array.";
         throw new Error(`edit: no edit mode resolved from arguments.${hint}`);
       }
-      params.diagnostics = args.diagnostics ?? diagnosticsOnEditDefault(ctx);
+      params.diagnostics = diagnosticsOnEditDefault(ctx);
       params.include_diff_content = true;
       const data = await callBridge(ctx, context, command, params);
       if (data.success === false) {
@@ -35825,12 +36138,11 @@ function createApplyPatchTool(ctx) {
   return {
     description: APPLY_PATCH_DESCRIPTION,
     args: {
-      patchText: z8.string().describe("The full patch text including Begin/End markers"),
-      diagnostics: z8.boolean().optional().describe(DIAGNOSTICS_PARAM_DESCRIPTION)
+      patchText: z8.string().describe("The full patch text including Begin/End markers")
     },
     execute: async (args, context) => {
       const patchText = args.patchText;
-      const diagnostics = args.diagnostics ?? diagnosticsOnEditDefault(ctx);
+      const diagnostics = diagnosticsOnEditDefault(ctx);
       if (!patchText)
         throw new Error("'patchText' is required");
       let hunks;
@@ -35918,6 +36230,9 @@ function createApplyPatchTool(ctx) {
               if (writeResult.success === false) {
                 throw new Error(writeResult.message ?? "write failed");
               }
+              if (writeResult.rolled_back === true) {
+                throw new Error("produced invalid syntax (rolled back)");
+              }
               const wrDiff = writeResult.diff;
               perFileDiffs.push({
                 filePath,
@@ -35979,6 +36294,9 @@ function createApplyPatchTool(ctx) {
               if (writeResult.success === false) {
                 throw new Error(writeResult.message ?? "write failed");
               }
+              if (writeResult.rolled_back === true) {
+                throw new Error("produced invalid syntax (rolled back)");
+              }
               const diags = writeResult.lsp_diagnostics;
               if (diags && diags.length > 0) {
                 const errors3 = diags.filter((d) => d.severity === "error");
@@ -37049,17 +37367,12 @@ var z13 = tool13.schema;
 function refactoringTools(ctx) {
   return {
     aft_refactor: {
-      description: `Workspace-wide refactoring operations that update imports and references across files.
+      description: `Workspace-wide refactoring that updates imports and references across files.
 
 ` + `Ops:
-` + `- 'move': Move a top-level symbol to another file, updating all imports workspace-wide. Requires 'symbol', 'destination'. Creates a checkpoint before mutating. Only works on top-level exports (not nested functions or class methods).
-` + `   Note: This moves code symbols between files. To rename/move an entire file, use aft_move instead.
-` + `- 'extract': Extract a line range into a new function with auto-detected parameters. Requires 'name', 'startLine', 'endLine' (1-based, both inclusive). Supports TS/JS/TSX and Python.
-` + `- 'inline': Replace a function call with the function's body, substituting args for params. Requires 'symbol', 'callSiteLine' (1-based). Validates single-return constraint.
-
-` + `Each op requires specific parameters — see parameter descriptions for requirements.
-
-` + "All ops need 'filePath'. Use aft_safety checkpoint/undo before risky refactors.",
+` + `- 'move': move a top-level symbol (not nested functions or class methods) to another file, rewriting imports workspace-wide. A checkpoint is created first. To move/rename a whole file, use aft_move.
+` + `- 'extract': extract a line range into a new function with auto-detected parameters (TS/JS/TSX, Python).
+` + "- '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)"),
@@ -37228,9 +37541,10 @@ function safetyTools(ctx) {
           if (Array.isArray(checkpointFiles)) {
             const projectRoot = await resolveProjectRoot(ctx, context);
             const uniqueParents = new Set;
-            for (const file2 of checkpointFiles) {
-              if (typeof file2 !== "string")
+            for (const rawFile of checkpointFiles) {
+              if (typeof rawFile !== "string")
                 continue;
+              const file2 = expandTilde(rawFile);
               const abs = path5.isAbsolute(file2) ? file2 : path5.resolve(projectRoot, file2);
               const parent = path5.dirname(abs);
               if (uniqueParents.has(parent))
@@ -37270,16 +37584,17 @@ function safetyTools(ctx) {
         const params = {};
         if (args.name !== undefined)
           params.name = args.name;
-        const payloadFiles = coerceStringArray(args.files);
+        const payloadFiles = coerceStringArray(args.files).map(expandTilde);
+        const filePathArg = typeof args.filePath === "string" ? expandTilde(args.filePath) : undefined;
         if (op === "checkpoint") {
           if (payloadFiles.length > 0) {
             params.files = payloadFiles;
-          } else if (args.filePath !== undefined) {
-            params.files = [args.filePath];
+          } else if (filePathArg !== undefined) {
+            params.files = [filePathArg];
           }
         } else {
-          if (args.filePath !== undefined)
-            params.file = args.filePath;
+          if (filePathArg !== undefined)
+            params.file = filePathArg;
           if (payloadFiles.length > 0)
             params.files = payloadFiles;
         }
@@ -37523,21 +37838,9 @@ function arg3(schema) {
 function semanticTools(ctx) {
   const searchTool = {
     description: [
-      "Find code with unified semantic, lexical, literal, and regex search. Returns ranked symbol/file results or exact matching lines, with routing metadata.",
-      "",
-      "When to reach for it:",
-      "- Exploring an unfamiliar area: 'where is rate limiting handled', 'how does auth flow work'",
-      "- Concept doesn't appear as a literal string: 'retry logic', 'cache invalidation', 'graceful shutdown'",
-      "- Filename-shaped concepts: 'the bridge spawn helper', 'the session detection module'",
-      "- Regex-shaped or exact text queries when you want AFT to classify and route automatically",
-      "- You know roughly what the function does but not what it's named",
-      "",
-      "When NOT to use:",
-      "- You need exhaustive literal enumeration → use grep directly",
-      "- You want the file/module structure → use aft_outline",
-      "- You're following a call chain → use aft_callgraph",
+      "Search code with one tool: concepts, identifiers, error strings, regex, literals, and filenames are auto-routed to the right engine and returned ranked. Use it for any code search — including when you only know what the code does, not what it's named ('where is rate limiting handled', 'retry logic', '^export', 'Cargo.lock').",
       "",
-      "Set hint to 'regex', 'literal', 'semantic', or 'auto' to override or document routing intent."
+      "Set hint to 'regex', 'literal', or 'semantic' to force a lane."
     ].join(`
 `),
     args: {
@@ -37581,118 +37884,8 @@ ${note}` : response.text;
   };
 }
 
-// src/tools/structure.ts
-import { tool as tool16 } from "@opencode-ai/plugin";
-var z16 = tool16.schema;
-function structureTools(ctx) {
-  return {
-    aft_transform: {
-      description: `Scope-aware structural code transformations with correct indentation.
-
-` + `Language-specific: add_derive (Rust), add_struct_tags (Go), add_decorator (Python), wrap_try_catch (TS/JS), add_member (any language).
-
-` + `Ops:
-` + `- 'add_member': Insert method/field into class, struct, or impl block. Requires 'container' (container name) and 'code'. Optional 'position'.
-` + `- 'add_derive': Add Rust derive macros to a struct/enum. Requires 'target' and 'derives' array. Deduplicates existing derives.
-` + `- 'wrap_try_catch': Wrap a TS/JS function body in try/catch. Requires 'target' (function name). Optional 'catchBody'.
-` + `- 'add_decorator': Add Python decorator to function/class. Requires 'target' and 'decorator' (without @). Optional 'position'.
-` + `- 'add_struct_tags': Add/update Go struct field tags. Requires 'target' (struct name), 'field', 'tag', 'value'.
-
-` + "Each op requires specific parameters — see parameter descriptions for requirements. Use aft_safety checkpoint/undo before risky transforms.",
-      args: {
-        op: z16.enum(["add_member", "add_derive", "wrap_try_catch", "add_decorator", "add_struct_tags"]).describe("Transformation operation"),
-        filePath: z16.string().describe("Path to the source file (absolute or relative to project root)"),
-        container: z16.string().optional().describe("Container name for add_member — the class, struct, or impl block to insert into. Appears as 'scope' in the response."),
-        code: z16.string().optional().describe("Member code to insert (add_member)"),
-        position: z16.string().optional().describe("For add_member: 'first', 'last' (default), 'before:name', 'after:name'. For add_decorator: 'first' (default) or 'last' only."),
-        target: z16.string().optional().describe("Target symbol name (add_derive: struct/enum, wrap_try_catch: function, add_decorator: function/class, add_struct_tags: struct)"),
-        derives: z16.array(z16.string()).optional().describe("Derive macro names (add_derive — e.g. ['Clone', 'Debug'])"),
-        catchBody: z16.string().optional().describe("Catch block body (wrap_try_catch — default: 'throw error;')"),
-        decorator: z16.string().optional().describe("Decorator text without @ (add_decorator — e.g. 'staticmethod')"),
-        field: z16.string().optional().describe("Struct field name (add_struct_tags)"),
-        tag: z16.string().optional().describe("Tag key (add_struct_tags — e.g. 'json')"),
-        value: z16.string().optional().describe("Tag value (add_struct_tags — e.g. 'user_name,omitempty')"),
-        validate: z16.enum(["syntax", "full"]).optional().describe("Validation level: 'syntax' (default) or 'full'. Syntax = tree-sitter parse check only. Full = also runs LSP type-checking (slower, catches more errors)")
-      },
-      execute: async (args, context) => {
-        const op = args.op;
-        if (op === "add_member") {
-          if (isEmptyParam(args.container))
-            throw new Error("'container' is required for 'add_member' op");
-          if (isEmptyParam(args.code))
-            throw new Error("'code' is required for 'add_member' op");
-        }
-        if (op === "add_derive" || op === "wrap_try_catch" || op === "add_decorator" || op === "add_struct_tags") {
-          if (isEmptyParam(args.target))
-            throw new Error(`'target' is required for '${op}' op`);
-        }
-        if (op === "add_derive" && isEmptyParam(args.derives)) {
-          throw new Error("'derives' array is required for 'add_derive' op");
-        }
-        if (op === "add_decorator" && isEmptyParam(args.decorator)) {
-          throw new Error("'decorator' is required for 'add_decorator' op");
-        }
-        if (op === "add_struct_tags") {
-          if (isEmptyParam(args.field))
-            throw new Error("'field' is required for 'add_struct_tags' op");
-          if (isEmptyParam(args.tag))
-            throw new Error("'tag' is required for 'add_struct_tags' op");
-          if (isEmptyParam(args.value))
-            throw new Error("'value' is required for 'add_struct_tags' op");
-        }
-        const filePath = await resolvePathArg(ctx, context, args.filePath);
-        {
-          const denial = await assertExternalDirectoryPermission(context, filePath);
-          if (denial)
-            return permissionDeniedResponse(denial);
-        }
-        const permissionError = await askEditPermission(context, [resolveRelativePattern(context, filePath)], { filepath: filePath });
-        if (permissionError)
-          return permissionDeniedResponse(permissionError);
-        const params = { file: filePath };
-        if (args.validate !== undefined)
-          params.validate = args.validate;
-        switch (op) {
-          case "add_member":
-            params.scope = args.container;
-            params.code = args.code;
-            if (args.position !== undefined)
-              params.position = args.position;
-            break;
-          case "add_derive":
-            params.target = args.target;
-            params.derives = args.derives;
-            break;
-          case "wrap_try_catch":
-            params.target = args.target;
-            if (args.catchBody !== undefined)
-              params.catch_body = args.catchBody;
-            break;
-          case "add_decorator":
-            params.target = args.target;
-            params.decorator = args.decorator;
-            if (args.position !== undefined)
-              params.position = args.position;
-            break;
-          case "add_struct_tags":
-            params.target = args.target;
-            params.field = args.field;
-            params.tag = args.tag;
-            params.value = args.value;
-            break;
-        }
-        const response = await callBridge(ctx, context, op, params);
-        if (response.success === false) {
-          throw new Error(response.message || `${op} failed`);
-        }
-        return JSON.stringify(response);
-      }
-    }
-  };
-}
-
 // src/workflow-hints.ts
-var HEADING = "## Prefer AFT tools for token efficiency";
+var HEADING = "## IMPORTANT NOTICE about your tools";
 function buildWorkflowHints(opts) {
   const sections = [];
   const grepName = opts.hoistBuiltins ? "grep" : "aft_grep";
@@ -37708,14 +37901,28 @@ function buildWorkflowHints(opts) {
   const hasBash = !opts.disabledTools.has(bashName);
   const hasBgBash = hasBash && opts.bashBackgroundEnabled && !opts.disabledTools.has(bashStatusName);
   if (hasBash && opts.bashCompressionEnabled) {
-    sections.push("When AFT bash output compression is on, do NOT pipe test/build commands through grep/head/tail (e.g. `bun test | grep fail`) to summarize. The compressor already keeps failures and the summary; piping hides failures. Run the command bare.");
+    sections.push([
+      "**Test/build output**: bash output is auto-compressed — failures and the summary are always kept. DO NOT pipe test/build commands through filters to summarize; that hides failures:",
+      "- `bun test | grep fail` → run `bun test`",
+      "- `cargo test 2>&1 | tail -20` → run `cargo test`",
+      "- `npm run build | head -50` → run `npm run build`"
+    ].join(`
+`));
   }
   if (hasOutline && hasZoom) {
     sections.push(`**Web/URL access**: \`aft_outline({ target: url })\` first for structure, then \`aft_zoom({ url, symbols: "<heading>" })\` for the specific section.`);
   }
   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.`;
-    sections.push(`**Code exploration**: fire independent lookups in ONE parallel tool-call wave — do NOT serialize them. ${locate} Then \`aft_outline\` for structure → \`aft_zoom\` for symbol(s). DO NOT run \`grep\`/\`rg\`/\`find\` through \`bash\` to locate code — the bash path is unindexed, unranked, serial, and routinely surfaces the wrong hit. Keep \`bash\` for shell facts (git state, file metadata, processes).`);
+    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 })\``
+    ].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.");
@@ -37733,13 +37940,22 @@ function buildWorkflowHints(opts) {
 `));
   }
   if (hasBash && hasBgBash) {
-    sections.push(`**Long-running commands** (builds, installs, full test suites): \`${bashName}({ background: true })\` returns immediately with a \`taskId\`, then **end your turn** — a completion reminder arrives automatically when it finishes. Do not poll \`${bashStatusName}({ taskId })\`, and do not sync-wait with \`bash_watch\` for a long task: blocking freezes your turn and locks the user out until it ends. For an early non-blocking ping on a specific output line, register an async watch \`bash_watch({ taskId, pattern, background: true })\`. \`bash_watch\` synchronous mode is only for short bounded waits (seconds, e.g. a dev server printing a readiness line), never for multi-minute jobs.`);
+    sections.push([
+      `**Long-running commands** (builds, installs, full test suites): \`${bashName}({ background: true })\` returns a \`taskId\` immediately. Then do ONE of these:`,
+      "1. Keep working on something independent of the result.",
+      "2. End your turn — a completion reminder with the result arrives automatically.",
+      `3. Need to react to a specific output line early? Register \`bash_watch({ taskId, pattern, background: true })\`, then end your turn — it pings you the moment the pattern appears.`,
+      `\`${bashStatusName}({ taskId })\` is for inspecting output AFTER the reminder arrives, or one quick look at a live task — never call it repeatedly to wait: the reminder already delivers the result, and each poll wastes a turn. Sync \`bash_watch\` (without \`background: true\`) blocks your turn and locks the user out — reserve it for waits of a few seconds (a dev server printing its ready line), never for builds or test suites.`
+    ].join(`
+`));
     sections.push(`**PTY / interactive commands**: PTY mode is for interactive REPLs and terminal apps (python, node, bash itself, vim). Start with \`${bashName}({ command: "python", pty: true, background: true })\`, read the screen with \`${bashStatusName}({ taskId, outputMode: "screen" })\`, and send input with \`${bashWriteName}({ taskId, input: "..." })\`.`);
   }
   if (sections.length === 0) {
     return null;
   }
-  sections.unshift("**Parallel tool calls**: when several read-only operations are independent, emit them in ONE response instead of serializing — file reads, structure and symbol lookups, code search, diagnostics, and git status/diff/log. Sequence only when a call depends on a prior result or when a command mutates state.");
+  sections.unshift(`You are equipped with a non-standard tool set: indexed code search, symbol-level reading, structural editing, and code analysis that are faster, more precise, and far cheaper in tokens than stitching together command-line utilities in bash. Always reach for these tools first.
+
+**Parallel tool calls**: when several read-only operations are independent, emit them in ONE response instead of serializing — file reads, structure and symbol lookups, code search, diagnostics, and git status/diff/log. Sequence only when a call depends on a prior result or when a command mutates state.`);
   return `${HEADING}
 
 ${sections.join(`
@@ -37801,12 +38017,12 @@ var PLUGIN_VERSION = (() => {
     return "0.0.0";
   }
 })();
-var ANNOUNCEMENT_VERSION = "0.36.0";
+var ANNOUNCEMENT_VERSION = "0.37.0";
 var ANNOUNCEMENT_FEATURES = [
-  "Persisted call graph: dead-code analysis runs on large repositories again (the file-count cap is gone), `aft_callgraph` queries resolve from disk, and method-call edges are more accurate across more languages.",
-  "Bash output stops hiding failures: piping a test/build through `grep`/`head` with compression on now keeps the failures and summary instead of stripping them.",
-  "Code search steering: guidance and hints now point to `aft_search` and parallel `aft_*` tools instead of `grep`/`find` in bash.",
-  "Fixes: a small `timeout` no longer kills a foreground `bash` command (#102), and `aft_delete`/`aft_safety checkpoint` no longer crash on a mistyped `files` argument."
+  "Much lower background CPU: idle bridges shut down after 30 minutes, deleted project roots stop the watcher instead of spinning it, and background scans reuse warm caches on a bounded thread pool.",
+  "`aft_transform` removed: usage data showed agents never called it — `edit` covers everything it did, and every request now carries a smaller tool surface.",
+  "Leaner tools: `bash`, `write`, `edit`, `apply_patch`, `aft_search`, and `aft_refactor` descriptions trimmed and config-aware; system-prompt guidance rewritten around what to do instead of what to avoid.",
+  "Background bash reminders are right-sized: failures keep head + tail context, successes show a short tail, and compressors never print a success summary for a non-zero exit."
 ];
 var ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/DSa65w8wuf";
 var plugin = async (input) => initializePluginForDirectory(input);
@@ -38031,17 +38247,25 @@ ${lines}
   });
   rpcServer.handle("status", async (params) => {
     const sessionID = params.sessionID || "rpc";
-    const cachedDir = getSessionDirectoryCached(sessionID);
-    const candidateDirs = new Set;
-    candidateDirs.add(input.directory);
-    if (typeof cachedDir === "string" && cachedDir.length > 0) {
-      candidateDirs.add(cachedDir);
-    }
     let bridge = null;
-    for (const dir of candidateDirs) {
-      bridge = pool.getActiveBridgeForRoot(dir);
-      if (bridge)
-        break;
+    let servedDirectory = input.directory;
+    const realSessionID = params.sessionID || "";
+    const verifiedDir = realSessionID ? await verifySessionDirectory(input.client, realSessionID) : null;
+    if (verifiedDir) {
+      bridge = pool.getActiveBridgeForRoot(verifiedDir);
+      if (bridge) {
+        servedDirectory = verifiedDir;
+      } else if (verifiedDir !== input.directory) {
+        return {
+          success: true,
+          status: "not_initialized",
+          message: "AFT bridge is now spawned lazily, information here will be populated after first tool call."
+        };
+      }
+    }
+    if (!bridge) {
+      bridge = pool.getActiveBridgeForRoot(input.directory);
+      servedDirectory = input.directory;
     }
     if (!bridge) {
       return {
@@ -38054,13 +38278,13 @@ ${lines}
     const cachedSessionId = cached2?.session;
     const cachedId = cachedSessionId?.id;
     if (cached2 !== null && cachedId === sessionID) {
-      return { success: true, ...cached2 };
+      return { success: true, ...cached2, served_directory: servedDirectory };
     }
     const response = await bridge.send("status", { session_id: sessionID });
     if (response.success !== false) {
       bridge.cacheStatusSnapshot(response);
     }
-    return response;
+    return { ...response, served_directory: servedDirectory };
   });
   const storageDir = configOverrides.storage_dir;
   rpcServer.handle("get-announcement", async () => {
@@ -38120,19 +38344,12 @@ Install: ${getManualInstallHint()}`).catch(() => {});
     cleanupWarnings(notifyOpts).catch(() => {});
   }
   const surface = aftConfig.tool_surface ?? "recommended";
-  const ALL_ONLY_TOOLS = new Set([
-    "aft_callgraph",
-    "aft_delete",
-    "aft_move",
-    "aft_transform",
-    "aft_refactor"
-  ]);
+  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),
     ...safetyTools(ctx),
     ...surface !== "minimal" && importTools(ctx),
-    ...structureTools(ctx),
     ...navigationTools(ctx),
     ...surface !== "minimal" && astTools(ctx),
     ...surface !== "minimal" && aftConfig.semantic_search === true && semanticTools(ctx),
@@ -38179,7 +38396,16 @@ Install: ${getManualInstallHint()}`).catch(() => {});
     "bash_status"
   ];
   const registeredTools = new Set(Object.keys(allTools));
-  pool.setConfigureOverride("aft_search_registered", registeredTools.has("aft_search"));
+  const aftSearchRegistered = registeredTools.has("aft_search");
+  pool.setConfigureOverride("aft_search_registered", aftSearchRegistered);
+  ctx.aftSearchRegistered = aftSearchRegistered;
+  for (const name of ["bash", "aft_bash"]) {
+    const def = allTools[name];
+    if (def) {
+      const bashCfg = resolveBashConfig(aftConfig);
+      def.description = bashToolDescription(aftSearchRegistered, bashCfg.compress, bashCfg.background);
+    }
+  }
   const hintsAbsentTools = new Set;
   for (const name of HINTS_TOOL_NAMES) {
     if (!registeredTools.has(name))