@cortexkit/aft-opencode 0.36.0 → 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}`);
@@ -12781,6 +13002,11 @@ function formatEditSummary(data) {
     const n = data.files_modified;
     return `Applied edits to ${n} file${n === 1 ? "" : "s"}.`;
   }
+  if (typeof data.total_files === "number") {
+    const files = data.total_files;
+    const reps = data.total_replacements ?? 0;
+    return `Edited ${files} file${files === 1 ? "" : "s"} (${reps} replacement${reps === 1 ? "" : "s"}).`;
+  }
   const additions = data.diff?.additions ?? 0;
   const deletions = data.diff?.deletions ?? 0;
   const counts = `+${additions}/-${deletions}`;
@@ -13994,7 +14220,23 @@ function isProcessAlive(pid) {
   }
 }
 // ../aft-bridge/dist/pipe-strip.js
-var NOISE_FILTERS = new Set(["grep", "rg", "head", "tail", "cat", "less", "more"]);
+var NOISE_FILTERS = new Set([
+  "grep",
+  "rg",
+  "head",
+  "tail",
+  "cat",
+  "less",
+  "more",
+  "sed",
+  "awk",
+  "cut",
+  "sort",
+  "uniq",
+  "tr",
+  "column",
+  "fold"
+]);
 var GREP_GUARD_FLAGS = new Set([
   "c",
   "count",
@@ -14008,6 +14250,8 @@ var GREP_GUARD_FLAGS = new Set([
 function maybeStripCompressorPipe(command, compressionEnabled) {
   if (!compressionEnabled)
     return { command, stripped: false };
+  if (containsUnsplittableConstruct(command))
+    return { command, stripped: false };
   const chain = splitTopLevelAndChain(command);
   if (chain === null)
     return { command, stripped: false };
@@ -14021,7 +14265,7 @@ function maybeStripCompressorPipe(command, compressionEnabled) {
     return { command, stripped: false };
   const filterStages = stages.slice(1).map((stage) => stage.trim());
   for (const stage of filterStages) {
-    if (!isPlainNoiseFilter(stage))
+    if (!filterStageIsSafeToDrop(stage))
       return { command, stripped: false };
   }
   const filters = filterStages.join(" | ");
@@ -14067,6 +14311,14 @@ function splitTopLevelAndChain(command) {
       return null;
     if (char === ";")
       return null;
+    if (char === `
+` || char === "\r")
+      return null;
+    if (char === "&") {
+      const prev = command[index - 1];
+      if (prev !== ">" && next !== ">")
+        return null;
+    }
   }
   segments.push(command.slice(start));
   return segments;
@@ -14109,45 +14361,262 @@ function isCompressorHandledRunner(stage) {
   const tokens = tokenizeStage(stage);
   if (tokens.length === 0)
     return false;
-  const [first, second, third] = tokens;
-  if (!first)
-    return false;
   if (tokens.some((token) => token === "&&" || token === "||" || token.includes(";"))) {
     return false;
   }
+  const first = runnerName(tokens[0]);
+  const second = tokens[1];
+  const third = tokens[2];
+  const rest = tokens.slice(1);
+  if (!first)
+    return false;
   if (first === "bun")
     return second === "test" || second === "run" && startsWithTest(third);
-  if (first === "cargo")
-    return ["test", "build", "check", "clippy"].includes(second ?? "");
-  if (first === "go")
-    return second === "test" || second === "build";
-  if (["npm", "pnpm"].includes(first)) {
+  if (first === "npm" || first === "pnpm") {
     return second === "test" || second === "run" && startsWithTest(third);
   }
-  if (first === "yarn")
-    return second === "test";
+  if (first === "yarn") {
+    return startsWithTest(second) || second === "run" && startsWithTest(third);
+  }
+  if (first === "deno")
+    return ["test", "lint", "check", "bench"].includes(second ?? "");
+  if (first === "npx") {
+    return ["tsc", "eslint", "vitest", "jest", "playwright", "biome"].includes(second ?? "");
+  }
   if (first === "playwright")
     return second === "test";
-  if (first === "npx")
-    return ["tsc", "eslint", "vitest", "jest"].includes(second ?? "");
-  return ["vitest", "jest", "pytest", "tsc", "eslint", "biome", "ruff", "mypy"].includes(first);
+  if (first === "cargo") {
+    return ["test", "build", "check", "clippy", "nextest"].includes(second ?? "");
+  }
+  if (first === "go")
+    return ["test", "build", "vet"].includes(second ?? "");
+  if (first === "gradle" || first === "gradlew") {
+    return hasBuildTask(rest, ["test", "check", "build", "assemble", "clean"]);
+  }
+  if (first === "mvn" || first === "mvnw") {
+    return hasBuildTask(rest, ["test", "verify", "package", "install"]);
+  }
+  if (first === "dotnet")
+    return ["test", "build"].includes(second ?? "");
+  if (first === "rspec")
+    return true;
+  if (first === "rake")
+    return second === "test" || second === "spec";
+  if (first === "phpunit" || first === "pest")
+    return true;
+  if (first === "xcodebuild")
+    return xcodebuildHasBuildAction(rest);
+  if (first === "swift")
+    return second === "test" || second === "build";
+  if (first === "make" || first === "gmake") {
+    return hasBuildTask(rest, ["test", "check", "lint", "clean"]);
+  }
+  return [
+    "vitest",
+    "jest",
+    "pytest",
+    "tsc",
+    "eslint",
+    "biome",
+    "ruff",
+    "mypy",
+    "tox",
+    "nox"
+  ].includes(first);
+}
+function runnerName(token) {
+  if (!token)
+    return "";
+  const slash = token.lastIndexOf("/");
+  return slash === -1 ? token : token.slice(slash + 1);
+}
+function hasBuildTask(args, tasks) {
+  const isAllowedTask = (arg) => tasks.some((task) => arg === task || arg.endsWith(`:${task}`));
+  const isFlagOrProperty = (arg) => arg.startsWith("-") || arg.includes("=");
+  let sawAllowed = false;
+  for (const arg of args) {
+    if (isFlagOrProperty(arg))
+      continue;
+    if (!isAllowedTask(arg))
+      return false;
+    sawAllowed = true;
+  }
+  return sawAllowed;
 }
 function startsWithTest(token) {
   return token?.startsWith("test") === true;
 }
-function isPlainNoiseFilter(stage) {
-  const tokens = tokenizeStage(stage);
-  const head = tokens[0];
+var XCODEBUILD_VALUE_FLAGS = new Set([
+  "-scheme",
+  "-target",
+  "-project",
+  "-workspace",
+  "-configuration",
+  "-sdk",
+  "-destination",
+  "-arch",
+  "-derivedDataPath",
+  "-resultBundlePath",
+  "-xcconfig",
+  "-toolchain"
+]);
+var XCODEBUILD_BUILD_ACTIONS = new Set([
+  "build",
+  "test",
+  "build-for-testing",
+  "test-without-building",
+  "analyze"
+]);
+function xcodebuildHasBuildAction(args) {
+  for (let i = 0;i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("-")) {
+      if (XCODEBUILD_VALUE_FLAGS.has(arg))
+        i++;
+      continue;
+    }
+    if (XCODEBUILD_BUILD_ACTIONS.has(arg))
+      return true;
+  }
+  return false;
+}
+function containsUnsplittableConstruct(command) {
+  let quote = null;
+  let escaped = false;
+  for (let i = 0;i < command.length; i++) {
+    const char = command[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\" && quote !== "'") {
+      escaped = true;
+      continue;
+    }
+    if (quote === "'") {
+      if (char === "'")
+        quote = null;
+      continue;
+    }
+    if (quote === '"') {
+      if (char === '"')
+        quote = null;
+      else if (char === "`")
+        return true;
+      else if (char === "$" && command[i + 1] === "(")
+        return true;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (char === "`")
+      return true;
+    if (char === "(" || char === ")")
+      return true;
+  }
+  return false;
+}
+var READS_FILE_OPERAND = new Set(["cat", "tac", "nl", "less", "more"]);
+function filterStageIsSafeToDrop(stage) {
+  const head = tokenizeStage(stage)[0];
   if (!head)
     return false;
   if (head === "wc")
     return false;
   if (!NOISE_FILTERS.has(head))
     return false;
-  if ((head === "grep" || head === "rg") && hasIntentChangingGrepFlag(tokens.slice(1)))
+  if (/[<>]/.test(stage))
+    return false;
+  if (hasUnquotedBackground(stage))
+    return false;
+  const args = tokenizeStage(stage).slice(1);
+  const hasFlag = (...names) => args.some((a) => names.some((n) => a === n || a.startsWith(`${n}=`)));
+  if (head === "grep" || head === "rg") {
+    if (hasIntentChangingGrepFlag(args))
+      return false;
+    if (countBareOperands(args) > 1)
+      return false;
+    return true;
+  }
+  if (head === "head" || head === "tail") {
+    if (bareOperands(args).some((op) => !/^\d+$/.test(op)))
+      return false;
+    return true;
+  }
+  if (READS_FILE_OPERAND.has(head)) {
+    if (countBareOperands(args) > 0)
+      return false;
+    return true;
+  }
+  if (head === "sed") {
+    if (hasFlag("-i", "--in-place"))
+      return false;
+    if (countBareOperands(args) > 1)
+      return false;
+    return true;
+  }
+  if (head === "awk") {
+    if (countBareOperands(args) > 1)
+      return false;
+    return true;
+  }
+  if (head === "sort" && hasFlag("-o", "--output"))
+    return false;
+  if (bareOperands(args).some((op) => op.includes("/") || op.includes(".")))
     return false;
   return true;
 }
+function bareOperands(args) {
+  const out = [];
+  let afterDoubleDash = false;
+  for (const arg of args) {
+    if (!afterDoubleDash && arg === "--") {
+      afterDoubleDash = true;
+      continue;
+    }
+    if (!afterDoubleDash && arg.startsWith("-") && arg !== "-")
+      continue;
+    out.push(arg);
+  }
+  return out;
+}
+function countBareOperands(args) {
+  return bareOperands(args).length;
+}
+function hasUnquotedBackground(stage) {
+  let quote = null;
+  let escaped = false;
+  for (let i = 0;i < stage.length; i++) {
+    const char = stage[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\" && quote !== "'") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote)
+        quote = null;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (char === "&") {
+      const prev = stage[i - 1];
+      const next = stage[i + 1];
+      if (prev === "&" || next === "&" || prev === ">" || next === ">")
+        continue;
+      return true;
+    }
+  }
+  return false;
+}
 function hasIntentChangingGrepFlag(args) {
   for (const arg of args) {
     if (arg === "--")
@@ -14210,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 {
@@ -14284,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));
@@ -14292,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);
@@ -14302,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;
@@ -32515,38 +32984,6 @@ function discoverRelevantGithubServers(projectRoot) {
   return relevant;
 }
 
-// src/metadata-store.ts
-var pendingStore = new Map;
-var STALE_TIMEOUT_MS = 15 * 60 * 1000;
-function makeKey(sessionID, callID) {
-  return `${sessionID}:${callID}`;
-}
-function cleanupStaleEntries() {
-  const now = Date.now();
-  for (const [key, entry] of pendingStore) {
-    if (now - entry.storedAt > STALE_TIMEOUT_MS) {
-      pendingStore.delete(key);
-    }
-  }
-}
-function storeToolMetadata(sessionID, callID, data) {
-  cleanupStaleEntries();
-  pendingStore.set(makeKey(sessionID, callID), {
-    ...data,
-    storedAt: Date.now()
-  });
-}
-function consumeToolMetadata(sessionID, callID) {
-  const key = makeKey(sessionID, callID);
-  const stored = pendingStore.get(key);
-  if (stored) {
-    pendingStore.delete(key);
-    const { storedAt: _, ...data } = stored;
-    return data;
-  }
-  return;
-}
-
 // src/normalize-schemas.ts
 import { tool } from "@opencode-ai/plugin";
 function stripRootJsonSchemaFields(jsonSchema) {
@@ -32665,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";
 
@@ -32680,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 {
@@ -32718,12 +33197,15 @@ class AftRpcServer {
           const dir = dirname9(this.portFilePath);
           mkdirSync10(dir, { recursive: true, mode: 448 });
           const tmpPath = `${this.portFilePath}.tmp`;
-          writeFileSync10(tmpPath, JSON.stringify({ port: this.port, token: this.token }), {
-            encoding: "utf-8",
-            mode: 384
-          });
+          writeFileSync10(tmpPath, JSON.stringify({
+            port: this.port,
+            token: this.token,
+            pid: process.pid,
+            started_at: Date.now()
+          }), { 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}`);
         }
@@ -32732,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();
@@ -32856,15 +33363,47 @@ function warmSessionDirectory(client, sessionId, fallbackDirectory) {
     return;
   getSessionDirectory(client, sessionId, fallbackDirectory);
 }
-
-// src/shared/status.ts
-function asRecord(value) {
-  return typeof value === "object" && value !== null ? value : {};
-}
-function readString(value, fallback = "") {
-  return typeof value === "string" ? value : fallback;
-}
-function readNullableString(value) {
+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) {
+  return typeof value === "object" && value !== null ? value : {};
+}
+function readString(value, fallback = "") {
+  return typeof value === "string" ? value : fallback;
+}
+function readNullableString(value) {
   return typeof value === "string" ? value : null;
 }
 function readBoolean(value, fallback = false) {
@@ -33068,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
@@ -33116,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"))) {
@@ -33193,7 +33732,7 @@ function registerShutdownCleanup(fn) {
 
 // src/status-bar-inject.ts
 var emitStateBySession = new Map;
-function statusBarSuffixForSession(sessionID, counts) {
+function statusBarSuffixForSession(sessionID, counts, force = false) {
   if (!counts)
     return "";
   let state = emitStateBySession.get(sessionID);
@@ -33201,12 +33740,67 @@ function statusBarSuffixForSession(sessionID, counts) {
     state = createStatusBarEmitState();
     emitStateBySession.set(sessionID, state);
   }
+  if (force) {
+    state.last = counts;
+    state.callsSinceEmit = 0;
+    return statusBarLine(counts);
+  }
   return shouldEmitStatusBar(state, counts) ? statusBarLine(counts) : "";
 }
 function clearStatusBarSession(sessionID) {
   emitStateBySession.delete(sessionID);
 }
 
+// src/tool-perf.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var perfStore = new AsyncLocalStorage;
+function markBridgeStart() {
+  const slot = perfStore.getStore();
+  if (slot && slot.bridgeStart === undefined) {
+    slot.bridgeStart = performance.now();
+  }
+}
+function markBridgeEnd() {
+  const slot = perfStore.getStore();
+  if (slot) {
+    slot.bridgeEnd = performance.now();
+  }
+}
+function emit(slot) {
+  const t3 = performance.now();
+  const total = Math.round(t3 - slot.t0);
+  if (slot.bridgeStart !== undefined && slot.bridgeEnd !== undefined) {
+    const pre = Math.round(slot.bridgeStart - slot.t0);
+    const bridge = Math.round(slot.bridgeEnd - slot.bridgeStart);
+    const post = Math.round(t3 - slot.bridgeEnd);
+    sessionLog(slot.sessionID, `perf tool=${slot.tool} total=${total}ms pre=${pre}ms bridge=${bridge}ms post=${post}ms`);
+  } else {
+    sessionLog(slot.sessionID, `perf tool=${slot.tool} total=${total}ms (no bridge call)`);
+  }
+}
+function instrumentToolMap(tools) {
+  for (const [name, def] of Object.entries(tools)) {
+    const original = def.execute;
+    if (typeof original !== "function")
+      continue;
+    def.execute = (args, context) => {
+      const slot = {
+        tool: name,
+        sessionID: context?.sessionID,
+        t0: performance.now()
+      };
+      return perfStore.run(slot, async () => {
+        try {
+          return await original(args, context);
+        } finally {
+          emit(slot);
+        }
+      });
+    };
+  }
+  return tools;
+}
+
 // src/tools/ast.ts
 import { tool as tool3 } from "@opencode-ai/plugin";
 
@@ -33229,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;
@@ -33360,7 +33941,13 @@ async function callBridge(ctx, runtime, command, params = {}, options) {
     configureWarningClient: ctx.client,
     ...options
   };
-  const response = await bridgeFor(ctx, runtime).send(command, merged, Object.keys(sendOptions).length > 0 ? sendOptions : undefined);
+  markBridgeStart();
+  let response;
+  try {
+    response = await bridgeFor(ctx, runtime).send(command, merged, Object.keys(sendOptions).length > 0 ? sendOptions : undefined);
+  } finally {
+    markBridgeEnd();
+  }
   ingestBgCompletions(runtime.sessionID, response.bg_completions);
   return response;
 }
@@ -33812,760 +34399,762 @@ ${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);
+  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);
   }
-  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++;
-    }
+
+// src/tools/bash.ts
+var z4 = tool4.schema;
+var METADATA_PREVIEW_LIMIT = 30 * 1024;
+var FOREGROUND_POLL_INTERVAL_MS = 100;
+var DEFAULT_HARD_TIMEOUT_MS = 30 * 60 * 1000;
+function resolveForegroundWaitMs(configured) {
+  const override = process.env.AFT_TEST_FOREGROUND_WAIT_MS;
+  if (override !== undefined) {
+    const parsed = Number(override);
+    if (Number.isFinite(parsed) && parsed >= 0)
+      return parsed;
   }
-  return { chunks, nextIdx: i };
+  return configured;
 }
-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`);
+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")
+    return first;
+  const asks = Array.isArray(first.asks) ? first.asks : [];
+  const permissionsGranted = [];
+  for (const ask of asks) {
+    const permission = ask.kind === "external_directory" ? "external_directory" : "bash";
+    await runAsk(runtime.ask({
+      permission,
+      patterns: ask.patterns,
+      always: ask.always,
+      metadata: {}
+    }));
+    permissionsGranted.push(...ask.always.length > 0 ? ask.always : ask.patterns);
   }
-  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");
+  const second = await bridgeCall(ctx, runtime, "bash", { ...params, permissions_granted: permissionsGranted }, options);
+  if (second.success === false && second.code === "permission_required") {
+    throw new Error("bash permission retry failed");
   }
-  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
+  return second;
+}
+function createBashTool(ctx, aftSearchRegisteredOverride) {
+  return {
+    description: (() => {
+      const cfg = resolveBashConfig(ctx.config);
+      return bashToolDescription(false, cfg.compress, cfg.background);
+    })(),
+    args: {
+      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: 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;
+      const rawCommand = args.command;
+      const compressionEnabled = bashCfg.compress && args.compressed !== false;
+      const pipeStrip = maybeStripCompressorPipe(rawCommand, compressionEnabled);
+      const command = pipeStrip.command;
+      const cwd = args.workdir ?? context.directory;
+      const isSubagent = await resolveIsSubagent(ctx.client, context.sessionID, context.directory);
+      const requestedPty = args.pty === true;
+      const requestedBackground = args.background === true || requestedPty;
+      if (requestedPty && isSubagent) {
+        throw new Error("PTY mode is not available in subagent sessions; subagents cannot drive interactive terminals.");
+      }
+      const allowSubagentBg = bashCfg.subagent_background;
+      const subagentForcedForeground = isSubagent && !allowSubagentBg;
+      const effectiveBackground = subagentForcedForeground ? false : requestedBackground;
+      const rawTimeout = args.timeout;
+      const effectiveTimeout = effectiveBackground ? rawTimeout : resolveBashKillTimeout(rawTimeout, bashCfg.foreground_wait_window_ms);
+      if (subagentForcedForeground && requestedBackground) {
+        sessionLog(context.sessionID, "[bash] subagent + background:true → converting to foreground (subagent would lose task_id)");
+      }
+      const shellEnv = await ctx.plugin?.trigger?.("shell.env", { cwd, sessionID: context.sessionID, callID: getCallID(context) }, { env: {} });
+      const data = await withPermissionLoop(ctx, context, {
+        command,
+        timeout: effectiveTimeout,
+        workdir: args.workdir,
+        env: shellEnv?.env ?? {},
+        description,
+        background: effectiveBackground,
+        notify_on_completion: effectiveBackground,
+        compressed: args.compressed,
+        pty: requestedPty,
+        pty_rows: args.ptyRows,
+        pty_cols: args.ptyCols,
+        permissions_requested: true
+      }, callBashBridge, {
+        onProgress: ({ text }) => {
+          accumulatedOutput = preview(accumulatedOutput + text);
+          metadata?.({ output: accumulatedOutput, description });
+        }
       });
-      i = nextIdx;
-    } else {
-      i++;
+      if (data.success === false) {
+        throw new Error(data.message || "bash failed");
+      }
+      if (data.status === "running" && typeof data.task_id === "string") {
+        const taskId = data.task_id;
+        const uiTitle = description ?? shortenCommand(command);
+        if (effectiveBackground) {
+          trackBgTask(context.sessionID, taskId);
+          let startedLine = formatBackgroundLaunch(taskId, requestedPty);
+          if (isSubagent && allowSubagentBg)
+            startedLine += subagentGuidance(taskId);
+          startedLine = appendPipeStripNote(startedLine, pipeStrip.note);
+          const metadataPayload2 = { description, output: startedLine, status: "running", taskId };
+          metadata?.(metadataPayload2);
+          return { output: startedLine, title: uiTitle, metadata: metadataPayload2 };
+        }
+        const foregroundWaitMs = resolveForegroundWaitMs(bashCfg.foreground_wait_window_ms);
+        const waitTimeoutMs = subagentForcedForeground ? effectiveTimeout ?? DEFAULT_HARD_TIMEOUT_MS : effectiveTimeout !== undefined ? Math.min(effectiveTimeout, foregroundWaitMs) : foregroundWaitMs;
+        const startedAt = Date.now();
+        while (true) {
+          const status = await callBashBridge(ctx, context, "bash_status", { task_id: taskId });
+          if (status.success === false) {
+            throw new Error(status.message ?? "bash_status failed");
+          }
+          if (isTerminalStatus(status.status)) {
+            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 };
+          }
+          if (Date.now() - startedAt >= waitTimeoutMs) {
+            if (subagentForcedForeground) {
+              await sleep(FOREGROUND_POLL_INTERVAL_MS);
+              continue;
+            }
+            const promoted = await callBashBridge(ctx, context, "bash_promote", {
+              task_id: taskId
+            });
+            if (promoted.success === false) {
+              throw new Error(promoted.message ?? "bash_promote failed");
+            }
+            trackBgTask(context.sessionID, taskId);
+            let message = formatPromotionMessage(taskId, effectiveTimeout, foregroundWaitMs);
+            if (isSubagent && allowSubagentBg)
+              message += subagentGuidance(taskId);
+            message = appendPipeStripNote(message, pipeStrip.note);
+            const metadataPayload2 = { description, output: message, status: "running", taskId };
+            metadata?.(metadataPayload2);
+            return { output: message, title: uiTitle, metadata: metadataPayload2 };
+          }
+          await sleep(FOREGROUND_POLL_INTERVAL_MS);
+        }
+      }
+      const output = data.output ?? "";
+      const metadataOutput = preview(output);
+      const exit = data.exit_code;
+      const truncated = data.truncated;
+      const outputPath = data.output_path;
+      const timedOut = data.timed_out === true;
+      const metadataPayload = {
+        description,
+        output: metadataOutput,
+        exit,
+        truncated,
+        ...outputPath ? { outputPath } : {}
+      };
+      metadata?.(metadataPayload);
+      let rendered = output;
+      if (truncated && outputPath) {
+        rendered += `
+[output truncated; full output at ${outputPath}]`;
+      }
+      if (timedOut) {
+        rendered += `
+[command timed out]`;
+      }
+      if (typeof exit === "number" && exit !== 0) {
+        rendered += `
+[exit code: ${exit}]`;
+      }
+      rendered = appendPipeStripNote(rendered, pipeStrip.note);
+      return {
+        output: rendered,
+        title: description ?? shortenCommand(command),
+        metadata: metadataPayload
+      };
     }
-  }
-  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 appendPipeStripNote(output, note) {
+  return note ? `${output}
+
+${note}` : output;
 }
-function normalizeIndent(str) {
-  return str.replace(/^[\t ]+/, (m) => " ".repeat(m.length));
+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 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;
-        }
+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");
       }
-      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;
+      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")}`;
     }
-    if (matches)
-      return i;
+  };
+}
+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 -1;
+  return data;
 }
-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;
+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;
 }
-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);
+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 (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
-      };
-    }
+  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 best.lineNumber === -1 ? null : best;
+  return suffix;
 }
-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(`
-`);
+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 `
 
-// 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;
+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.`;
   }
-  const cached2 = cache2.get(sessionId);
-  if (cached2) {
-    cache2.delete(sessionId);
-    cache2.set(sessionId, cached2);
-    return cached2.isSubagent;
+  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}]`;
   }
-  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;
+  if (status === "timed_out") {
+    rendered += `
+[command timed out]`;
   }
-  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 (typeof exit === "number" && exit !== 0) {
+    rendered += `
+[exit code: ${exit}]`;
   }
-  setCache2(sessionId, isSubagent);
-  return isSubagent;
+  return rendered;
 }
-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);
-  }
+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/bash.ts
+// src/tools/conflicts.ts
+import { tool as tool5 } from "@opencode-ai/plugin";
 var z5 = tool5.schema;
-var METADATA_PREVIEW_LIMIT = 30 * 1024;
-var FOREGROUND_POLL_INTERVAL_MS = 100;
-var DEFAULT_HARD_TIMEOUT_MS = 30 * 60 * 1000;
-function resolveForegroundWaitMs(configured) {
-  const override = process.env.AFT_TEST_FOREGROUND_WAIT_MS;
-  if (override !== undefined) {
-    const parsed = Number(override);
-    if (Number.isFinite(parsed) && parsed >= 0)
-      return parsed;
+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;
+      }
+    }
+  };
+}
+
+// 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;
   }
-  return configured;
+  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;
 }
-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.`;
-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")
-    return first;
-  const asks = Array.isArray(first.asks) ? first.asks : [];
-  const permissionsGranted = [];
-  for (const ask of asks) {
-    const permission = ask.kind === "external_directory" ? "external_directory" : "bash";
-    await runAsk(runtime.ask({
-      permission,
-      patterns: ask.patterns,
-      always: ask.always,
-      metadata: {}
-    }));
-    permissionsGranted.push(...ask.always.length > 0 ? ask.always : ask.patterns);
+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++;
   }
-  const second = await bridgeCall(ctx, runtime, "bash", { ...params, permissions_granted: permissionsGranted }, options);
-  if (second.success === false && second.code === "permission_required") {
-    throw new Error("bash permission retry failed");
+  if (content.endsWith(`
+`)) {
+    content = content.slice(0, -1);
   }
-  return second;
+  return { content, nextIdx: i };
 }
-function createBashTool(ctx) {
-  return {
-    description: BASH_DESCRIPTION,
-    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."),
-      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.'),
-      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);
-      let accumulatedOutput = "";
-      const description = args.description;
-      const metadata = context.metadata;
-      const rawCommand = args.command;
-      const compressionEnabled = bashCfg.compress && args.compressed !== false;
-      const pipeStrip = maybeStripCompressorPipe(rawCommand, compressionEnabled);
-      const command = pipeStrip.command;
-      const cwd = args.workdir ?? context.directory;
-      const isSubagent = await resolveIsSubagent(ctx.client, context.sessionID, context.directory);
-      const requestedPty = args.pty === true;
-      const requestedBackground = args.background === true || requestedPty;
-      if (requestedPty && isSubagent) {
-        throw new Error("PTY mode is not available in subagent sessions; subagents cannot drive interactive terminals.");
-      }
-      const allowSubagentBg = bashCfg.subagent_background;
-      const subagentForcedForeground = isSubagent && !allowSubagentBg;
-      const effectiveBackground = subagentForcedForeground ? false : requestedBackground;
-      const rawTimeout = args.timeout;
-      const effectiveTimeout = effectiveBackground ? rawTimeout : resolveBashKillTimeout(rawTimeout, bashCfg.foreground_wait_window_ms);
-      if (subagentForcedForeground && requestedBackground) {
-        sessionLog(context.sessionID, "[bash] subagent + background:true → converting to foreground (subagent would lose task_id)");
-      }
-      const shellEnv = await ctx.plugin?.trigger?.("shell.env", { cwd, sessionID: context.sessionID, callID: getCallID(context) }, { env: {} });
-      const data = await withPermissionLoop(ctx, context, {
-        command,
-        timeout: effectiveTimeout,
-        workdir: args.workdir,
-        env: shellEnv?.env ?? {},
-        description,
-        background: effectiveBackground,
-        notify_on_completion: effectiveBackground,
-        compressed: args.compressed,
-        pty: requestedPty,
-        pty_rows: args.ptyRows,
-        pty_cols: args.ptyCols,
-        permissions_requested: true
-      }, callBashBridge, {
-        onProgress: ({ text }) => {
-          accumulatedOutput = preview(accumulatedOutput + text);
-          metadata?.({ output: accumulatedOutput, description });
-        }
-      });
-      if (data.success === false) {
-        throw new Error(data.message || "bash failed");
-      }
-      if (data.status === "running" && typeof data.task_id === "string") {
-        const callID2 = getCallID(context);
-        const taskId = data.task_id;
-        if (effectiveBackground) {
-          trackBgTask(context.sessionID, taskId);
-          let startedLine = formatBackgroundLaunch(taskId, requestedPty);
-          if (isSubagent && allowSubagentBg)
-            startedLine += subagentGuidance(taskId);
-          const metadataPayload2 = { description, output: startedLine, status: "running", taskId };
-          metadata?.(metadataPayload2);
-          if (callID2) {
-            storeToolMetadata(context.sessionID, callID2, {
-              title: description ?? shortenCommand(command),
-              metadata: metadataPayload2
-            });
-          }
-          return startedLine;
-        }
-        const foregroundWaitMs = resolveForegroundWaitMs(bashCfg.foreground_wait_window_ms);
-        const waitTimeoutMs = subagentForcedForeground ? effectiveTimeout ?? DEFAULT_HARD_TIMEOUT_MS : effectiveTimeout !== undefined ? Math.min(effectiveTimeout, foregroundWaitMs) : foregroundWaitMs;
-        const startedAt = Date.now();
-        while (true) {
-          const status = await callBashBridge(ctx, context, "bash_status", { task_id: taskId });
-          if (status.success === false) {
-            throw new Error(status.message ?? "bash_status failed");
-          }
-          if (isTerminalStatus(status.status)) {
-            const rendered2 = appendPipeStripNote(formatForegroundResult(status), pipeStrip.note);
-            const metadataPayload2 = foregroundMetadata(description, status, rendered2);
-            metadata?.(metadataPayload2);
-            if (callID2) {
-              storeToolMetadata(context.sessionID, callID2, {
-                title: description ?? shortenCommand(command),
-                metadata: metadataPayload2
-              });
-            }
-            return rendered2;
-          }
-          if (Date.now() - startedAt >= waitTimeoutMs) {
-            if (subagentForcedForeground) {
-              await sleep(FOREGROUND_POLL_INTERVAL_MS);
-              continue;
-            }
-            const promoted = await callBashBridge(ctx, context, "bash_promote", {
-              task_id: taskId
-            });
-            if (promoted.success === false) {
-              throw new Error(promoted.message ?? "bash_promote failed");
-            }
-            trackBgTask(context.sessionID, taskId);
-            let message = formatPromotionMessage(taskId, effectiveTimeout, foregroundWaitMs);
-            if (isSubagent && allowSubagentBg)
-              message += subagentGuidance(taskId);
-            const metadataPayload2 = { description, output: message, status: "running", taskId };
-            metadata?.(metadataPayload2);
-            if (callID2) {
-              storeToolMetadata(context.sessionID, callID2, {
-                title: description ?? shortenCommand(command),
-                metadata: metadataPayload2
-              });
-            }
-            return message;
-          }
-          await sleep(FOREGROUND_POLL_INTERVAL_MS);
+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++;
       }
-      const output = data.output ?? "";
-      const metadataOutput = preview(output);
-      const exit = data.exit_code;
-      const truncated = data.truncated;
-      const outputPath = data.output_path;
-      const timedOut = data.timed_out === true;
-      const callID = getCallID(context);
-      const metadataPayload = {
-        description,
-        output: metadataOutput,
-        exit,
-        truncated,
-        ...outputPath ? { outputPath } : {}
-      };
-      metadata?.(metadataPayload);
-      if (callID) {
-        storeToolMetadata(context.sessionID, callID, {
-          title: description ?? shortenCommand(command),
-          metadata: metadataPayload
-        });
-      }
-      let rendered = output;
-      if (truncated && outputPath) {
-        rendered += `
-[output truncated; full output at ${outputPath}]`;
-      }
-      if (timedOut) {
-        rendered += `
-[command timed out]`;
-      }
-      if (typeof exit === "number" && exit !== 0) {
-        rendered += `
-[exit code: ${exit}]`;
-      }
-      rendered = appendPipeStripNote(rendered, pipeStrip.note);
-      return rendered;
-    }
-  };
-}
-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: 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 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
+      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");
-      }
-      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")}`;
+    } else {
+      i++;
     }
-  };
-}
-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;
+  return { chunks, nextIdx: i };
 }
-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}`;
+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 (status === "running") {
-      text += `
-A completion reminder will be delivered automatically; don't poll.`;
+    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 text;
+  return hunks;
 }
-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}` : "";
+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;
+    }
   }
-  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);
+  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 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 };
+  return -1;
 }
-function ptyCacheKey(runtime, taskId) {
-  return `${projectRootFor(runtime)}::${runtime.sessionID ?? "__default__"}::${taskId}`;
+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 preview(output) {
-  return output.length <= METADATA_PREVIEW_LIMIT ? output : output.slice(-METADATA_PREVIEW_LIMIT);
+function seekSequence(lines, pattern, startIndex, eof = false) {
+  const r = seekSequenceTiered(lines, pattern, startIndex, eof);
+  return r ? r.found : -1;
 }
-function isTerminalStatus(status) {
-  return status === "completed" || status === "failed" || status === "killed" || status === "timed_out";
+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 subagentGuidance(taskId) {
-  return `
+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 = `
 
-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
@@ -34874,10 +35463,6 @@ function createBashWriteTool(ctx) {
 }
 
 // src/tools/hoisted.ts
-function getCallID2(ctx) {
-  const c = ctx;
-  return c.callID ?? c.callId ?? c.call_id;
-}
 function relativeToWorktree(fp, worktree) {
   return path4.relative(worktree, fp);
 }
@@ -35083,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;
 }
@@ -35163,19 +35747,16 @@ function createReadTool(ctx) {
         } catch {}
         const sizeStr = fileSize > 1048576 ? `${(fileSize / 1048576).toFixed(1)}MB` : fileSize > 1024 ? `${(fileSize / 1024).toFixed(0)}KB` : `${fileSize} bytes`;
         const msg = `${label} read successfully`;
-        const imgCallID = getCallID2(context);
-        if (imgCallID) {
-          storeToolMetadata(context.sessionID, imgCallID, {
-            title: path4.relative(projectRoot, filePath),
-            metadata: {
-              preview: msg,
-              filepath: filePath,
-              isImage,
-              isPdf: mime === "application/pdf"
-            }
-          });
-        }
-        return `${msg} (${ext.slice(1).toUpperCase()}, ${sizeStr}). File: ${filePath}`;
+        return {
+          output: `${msg} (${ext.slice(1).toUpperCase()}, ${sizeStr}). File: ${filePath}`,
+          title: path4.relative(projectRoot, filePath),
+          metadata: {
+            preview: msg,
+            filepath: filePath,
+            isImage,
+            isPdf: mime === "application/pdf"
+          }
+        };
       }
       let startLine = args.startLine;
       let endLine = args.endLine;
@@ -35196,60 +35777,36 @@ function createReadTool(ctx) {
       if (data.success === false) {
         throw new Error(data.message || "read failed");
       }
-      const readCallID = getCallID2(context);
+      const dp = relativeToWorktree(filePath, projectRoot) || file2;
       if (data.entries) {
-        if (readCallID) {
-          const dp = relativeToWorktree(filePath, projectRoot) || file2;
-          storeToolMetadata(context.sessionID, readCallID, { title: dp, metadata: { title: dp } });
-        }
-        return data.entries.join(`
-`);
+        return {
+          output: data.entries.join(`
+`),
+          title: dp,
+          metadata: { title: dp }
+        };
       }
       if (data.binary) {
-        if (readCallID) {
-          const dp = relativeToWorktree(filePath, projectRoot) || file2;
-          storeToolMetadata(context.sessionID, readCallID, { title: dp, metadata: { title: dp } });
-        }
-        return data.message;
-      }
-      if (readCallID) {
-        const dp = relativeToWorktree(filePath, projectRoot) || file2;
-        storeToolMetadata(context.sessionID, readCallID, { title: dp, metadata: { title: dp } });
+        return { output: data.message, title: dp, metadata: { title: dp } };
       }
       let output = data.content;
       const agentSpecifiedRange = args.startLine !== undefined || args.endLine !== undefined || args.offset !== undefined || args.limit !== undefined;
       const footer = formatReadFooter(agentSpecifiedRange, data);
       if (footer)
         output += footer;
-      return output;
+      return { output, title: dp, metadata: { title: dp } };
     }
   };
 }
 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;
@@ -35272,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.";
@@ -35311,27 +35871,24 @@ Note: LSP server(s) did not respond in time: ${pendingServers.join(", ")}. Diagn
 Note: LSP server(s) exited during this edit: ${exitedServers.join(", ")}. Their diagnostics could not be collected.`;
       }
       const diff = data.diff;
-      const callID = getCallID2(context);
-      if (callID) {
-        const dp = relativeToWorktree(filePath, projectRoot);
-        const beforeContent = diff?.before ?? "";
-        const afterContent = diff?.after ?? content;
-        storeToolMetadata(context.sessionID, callID, {
-          title: dp,
-          metadata: {
-            diff: buildUnifiedDiff(filePath, beforeContent, afterContent),
-            filediff: {
-              file: filePath,
-              before: beforeContent,
-              after: afterContent,
-              additions: diff?.additions ?? 0,
-              deletions: diff?.deletions ?? 0
-            },
-            diagnostics: {}
-          }
-        });
-      }
-      return output;
+      const dp = relativeToWorktree(filePath, projectRoot);
+      const beforeContent = diff?.before ?? "";
+      const afterContent = diff?.after ?? content;
+      return {
+        output,
+        title: dp,
+        metadata: {
+          diff: buildUnifiedDiff(filePath, beforeContent, afterContent),
+          filediff: {
+            file: filePath,
+            before: beforeContent,
+            after: afterContent,
+            additions: diff?.additions ?? 0,
+            deletions: diff?.deletions ?? 0
+          },
+          diagnostics: {}
+        }
+      };
     }
   };
 }
@@ -35340,107 +35897,66 @@ function getEditDescription(writeToolName) {
 
 **Modes** (determined by which parameters you provide):
 
-Mode priority: operations > appendContent > edits > symbol (without oldString) > oldString (find/replace). If none match, the call is rejected — there is no implicit "write" fallback.
+Mode priority: appendContent > edits > symbol (without oldString) > oldString (find/replace). If none match, the call is rejected — there is no implicit "write" fallback. To edit multiple files, make parallel \`edit\` calls in one response.
 
-1. **Multi-file transaction** — pass \`operations\` array
-   Edits across multiple files with checkpoint-based rollback on failure.
-   Each operation: \`{ "file": "path", "command": "edit_match" | "write", ... }\`.
-   For \`edit_match\`: include \`match\`, \`replacement\`. For \`write\`: include \`content\`.
-   Example: \`{ "operations": [{ "file": "a.ts", "command": "edit_match", "match": "old", "replacement": "new" }, { "file": "b.ts", "command": "write", "content": "..." }] }\`
-
-2. **Append** — pass \`filePath\` + \`appendContent\`
+1. **Append** — pass \`filePath\` + \`appendContent\`
    Appends text to the end of a file, creating the file if it does not exist.
    Example: \`{ "filePath": "notes.txt", "appendContent": "new line\\n" }\`
 
-3. **Batch edits** — pass \`filePath\` + \`edits\` array
+2. **Batch edits** — pass \`filePath\` + \`edits\` array
    Multiple edits in one file atomically. Each edit is either:
    - \`{ "oldString": "old", "newString": "new" }\` — find/replace
    - \`{ "startLine": 5, "endLine": 7, "content": "new lines" }\` — replace line range (1-based, both inclusive)
    Set content to empty string to delete lines.
 
-4. **Symbol replace** — pass \`filePath\` + \`symbol\` + \`content\`
+3. **Symbol replace** — pass \`filePath\` + \`symbol\` + \`content\`
    Replaces an entire named symbol (function, class, type) with new content.
    Includes decorators, attributes, and doc comments in the replacement range.
    **Important:** You must NOT provide \`oldString\` when using symbol mode — if present, the tool silently falls back to find/replace mode.
    Example: \`{ "filePath": "src/app.ts", "symbol": "handleRequest", "content": "function handleRequest() { ... }" }\`
 
-5. **Find and replace** — pass \`filePath\` + \`oldString\` + \`newString\`
+4. **Find and replace** — pass \`filePath\` + \`oldString\` + \`newString\`
    Finds the exact text in \`oldString\` and replaces it with \`newString\`.
    Supports fuzzy matching (handles whitespace differences automatically).
    If multiple matches exist, specify which one with \`occurrence\` or use \`replaceAll: true\`.
    Example: \`{ "filePath": "src/app.ts", "oldString": "const x = 1", "newString": "const x = 2" }\`
 
-6. **Replace all occurrences** — add \`replaceAll: true\`
+5. **Replace all occurrences** — add \`replaceAll: true\`
    Replaces every occurrence of \`oldString\` in the file.
    Example: \`{ "filePath": "src/app.ts", "oldString": "oldName", "newString": "newName", "replaceAll": true }\`
 
-7. **Select specific occurrence** — add \`occurrence: N\` (0-indexed)
+6. **Select specific occurrence** — add \`occurrence: N\` (0-indexed)
    When multiple matches exist, select the Nth one (0 = first, 1 = second, etc.).
    Example: \`{ "filePath": "src/app.ts", "oldString": "TODO", "newString": "DONE", "occurrence": 0 }\`
 
-Note: Modes 6 and 7 are options on mode 5 (find/replace) — they require \`oldString\`.
+Note: Modes 5 and 6 are options on mode 4 (find/replace) — they require \`oldString\`.
 
 **Behavior:**
 - Backs up files before editing (recoverable via aft_safety undo)
 - 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") {
   return {
     description: getEditDescription(writeToolName),
     args: {
-      filePath: z8.string().optional().describe("Path to the file to edit (absolute or relative to project root). Required for all modes except 'operations' multi-file transactions"),
+      filePath: z8.string().optional().describe("Path to the file to edit (absolute or relative to project root)"),
       oldString: z8.string().optional().describe("Text to find (exact match, with fuzzy fallback)"),
       newString: z8.string().optional().describe("Text to replace with (omit or set to empty string to delete the matched text)"),
       replaceAll: z8.boolean().optional().describe("Replace all occurrences"),
       occurrence: optionalInt(0, Number.MAX_SAFE_INTEGER).describe("0-indexed occurrence to replace when multiple matches exist"),
       symbol: z8.string().optional().describe("Named symbol to replace (function, class, type)"),
-      content: z8.string().optional().describe("Replacement content for symbol mode or operations[].command='write'. For whole-file writes, use the `write` tool."),
+      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 }"),
-      operations: z8.array(z8.record(z8.string(), z8.unknown())).optional().describe("Transaction — array of { file: string, command: 'edit_match' | 'write', match?: string, replacement?: string, content?: string } for multi-file edits with rollback. Note: uses 'file'/'match'/'replacement' (not filePath/oldString/newString)"),
-      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;
       if (argsRecord.startLine !== undefined || argsRecord.endLine !== undefined) {
         throw new Error("edit: 'startLine'/'endLine' are not top-level parameters. For line-range edits, nest them inside the `edits` array: `edits: [{ startLine: N, endLine: M, content: \"...\" }]`. For find/replace, use `oldString`/`newString` instead.");
       }
-      if (Array.isArray(args.operations)) {
-        const ops = args.operations;
-        const files = ops.map((op) => op.file).filter(Boolean);
-        const projectRoot2 = await resolveProjectRoot(ctx, context);
-        {
-          const asked = new Set;
-          for (const file3 of files) {
-            const absPath = resolvePathFromProjectRoot(projectRoot2, file3);
-            if (asked.has(absPath))
-              continue;
-            asked.add(absPath);
-            const denial = await assertExternalDirectoryPermission(context, absPath);
-            if (denial)
-              return permissionDeniedResponse(denial);
-          }
-        }
-        await runAsk(context.ask({
-          permission: "edit",
-          patterns: files.map((f) => path4.relative(projectRoot2, resolvePathFromProjectRoot(projectRoot2, f))),
-          always: ["*"],
-          metadata: {}
-        }));
-        const resolvedOps = ops.map((op) => ({
-          ...op,
-          file: resolvePathFromProjectRoot(projectRoot2, op.file)
-        }));
-        const response = await callBridge(ctx, context, "transaction", { operations: resolvedOps });
-        if (response.success === false) {
-          throw new Error(response.message ?? "transaction failed");
-        }
-        return formatEditSummary(response);
-      }
       const file2 = args.filePath;
       if (!file2)
         throw new Error("'filePath' parameter is required");
@@ -35497,34 +36013,33 @@ function createEditTool(ctx, writeToolName = "write") {
         if (args.occurrence !== undefined)
           params.occurrence = args.occurrence;
       } else {
-        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', 'edits' array, or 'operations' array.";
+        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) {
+        throw new Error(data.message || "edit failed");
+      }
+      let uiMeta;
+      let uiTitle;
       if (data.success && data.diff) {
         const diff = data.diff;
-        const callID = getCallID2(context);
-        if (callID) {
-          const dp = relativeToWorktree(filePath, projectRoot);
-          const beforeContent = diff.before ?? "";
-          const afterContent = diff.after ?? "";
-          storeToolMetadata(context.sessionID, callID, {
-            title: dp,
-            metadata: {
-              diff: buildUnifiedDiff(filePath, beforeContent, afterContent),
-              filediff: {
-                file: filePath,
-                before: beforeContent,
-                after: afterContent,
-                additions: diff.additions ?? 0,
-                deletions: diff.deletions ?? 0
-              },
-              diagnostics: {}
-            }
-          });
-        }
+        uiTitle = relativeToWorktree(filePath, projectRoot);
+        const beforeContent = diff.before ?? "";
+        const afterContent = diff.after ?? "";
+        uiMeta = {
+          diff: buildUnifiedDiff(filePath, beforeContent, afterContent),
+          filediff: {
+            file: filePath,
+            before: beforeContent,
+            after: afterContent,
+            additions: diff.additions ?? 0,
+            deletions: diff.deletions ?? 0
+          },
+          diagnostics: {}
+        };
       }
       let result = formatEditSummary(data);
       const globSkipNote = formatGlobSkipReasonsNote(data.format_skip_reasons);
@@ -35561,6 +36076,9 @@ Note: LSP server(s) did not respond in time: ${pendingServers.join(", ")}. Diagn
 
 Note: LSP server(s) exited during this edit: ${exitedServers.join(", ")}. Their diagnostics could not be collected.`;
       }
+      if (uiMeta) {
+        return { output: result, title: uiTitle ?? "", metadata: uiMeta };
+      }
       return result;
     }
   };
@@ -35620,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;
@@ -35710,6 +36227,12 @@ function createApplyPatchTool(ctx) {
                 include_diff_content: true,
                 multi_file_write_paths: multiFileWritePaths
               });
+              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,
@@ -35735,7 +36258,12 @@ function createApplyPatchTool(ctx) {
           case "delete": {
             try {
               const before = await fs6.promises.readFile(filePath, "utf-8").catch(() => "");
-              await callBridge(ctx, context, "delete_file", { file: filePath });
+              const deleteResult = await callBridge(ctx, context, "delete_file", {
+                file: filePath
+              });
+              if (deleteResult.success === false) {
+                throw new Error(deleteResult.message ?? "delete failed");
+              }
               perFileDiffs.push({
                 filePath,
                 before,
@@ -35763,6 +36291,12 @@ function createApplyPatchTool(ctx) {
                 include_diff_content: true,
                 multi_file_write_paths: multiFileWritePaths
               });
+              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");
@@ -35842,10 +36376,11 @@ ${diagLines}`);
 `));
         }
       }
-      const callID = getCallID2(context);
-      if (callID) {
+      {
         const diffByPath = new Map(perFileDiffs.map((d) => [d.filePath, d]));
-        const files = hunks.map((h) => {
+        const failedPaths = new Set(failures);
+        const appliedHunks = hunks.filter((h) => !failedPaths.has(h.path));
+        const files = appliedHunks.map((h) => {
           const filePath = resolvePathFromProjectRoot(projectRoot, h.path);
           const rawMovePath = h.type === "update" ? h.move_path : undefined;
           const movePath = rawMovePath ? resolvePathFromProjectRoot(projectRoot, rawMovePath) : undefined;
@@ -35871,20 +36406,21 @@ ${diagLines}`);
           return `${prefix} ${f.relativePath}`;
         }).join(`
 `);
-        const title = `Success. Updated the following files:
+        const title = failures.length > 0 ? `Partially applied (${files.length} of ${hunks.length}). Updated:
+${fileList}` : `Success. Updated the following files:
 ${fileList}`;
         const diffText = files.map((f) => f.patch).filter(Boolean).join(`
 `);
-        storeToolMetadata(context.sessionID, callID, {
+        return {
+          output: results.join(`
+`),
           title,
           metadata: {
             diff: diffText,
             files
           }
-        });
+        };
       }
-      return results.join(`
-`);
     }
   };
 }
@@ -36408,10 +36944,6 @@ function navigationTools(ctx) {
 // src/tools/reading.ts
 import { tool as tool12 } from "@opencode-ai/plugin";
 var z12 = tool12.schema;
-function getCallID3(ctx) {
-  const c = ctx;
-  return c.callID ?? c.callId ?? c.call_id;
-}
 function buildZoomTitle(args) {
   if (!isEmptyParam(args.targets)) {
     if (Array.isArray(args.targets)) {
@@ -36574,25 +37106,26 @@ function readingTools(ctx) {
         const hasTargets = hasTargetsProvided(args.targets);
         const hasSymbols = !isEmptyParam(args.symbols);
         const wantCallgraph = args.callgraph === true;
-        const zoomCallID = getCallID3(context);
-        if (zoomCallID) {
-          const title = buildZoomTitle(args);
-          const display = { title };
-          if (hasFilePath)
-            display.filePath = args.filePath;
-          if (hasUrl)
-            display.url = args.url;
-          if (hasSymbols) {
-            display.symbols = typeof args.symbols === "string" ? args.symbols : JSON.stringify(args.symbols);
-          }
-          if (hasTargets)
-            display.targets = JSON.stringify(args.targets);
-          if (args.contextLines !== undefined)
-            display.contextLines = args.contextLines;
-          if (wantCallgraph)
-            display.callgraph = true;
-          storeToolMetadata(context.sessionID, zoomCallID, { title, metadata: display });
-        }
+        const zoomTitle = buildZoomTitle(args);
+        const zoomDisplay = { title: zoomTitle };
+        if (hasFilePath)
+          zoomDisplay.filePath = args.filePath;
+        if (hasUrl)
+          zoomDisplay.url = args.url;
+        if (hasSymbols) {
+          zoomDisplay.symbols = typeof args.symbols === "string" ? args.symbols : JSON.stringify(args.symbols);
+        }
+        if (hasTargets)
+          zoomDisplay.targets = JSON.stringify(args.targets);
+        if (args.contextLines !== undefined)
+          zoomDisplay.contextLines = args.contextLines;
+        if (wantCallgraph)
+          zoomDisplay.callgraph = true;
+        const withMeta = (output) => ({
+          output,
+          title: zoomTitle,
+          metadata: zoomDisplay
+        });
         if (hasTargets) {
           if (hasFilePath || hasUrl || hasSymbols) {
             throw new Error("'targets' is mutually exclusive with 'filePath', 'url', and 'symbols'");
@@ -36632,7 +37165,7 @@ function readingTools(ctx) {
             name: t.symbol,
             response: responses[i] ?? { success: false, message: "missing zoom response" }
           }));
-          return formatZoomMultiTargetResult(entries).text;
+          return withMeta(formatZoomMultiTargetResult(entries).text);
         }
         if (!hasFilePath && !hasUrl) {
           throw new Error("Provide exactly one of 'filePath', 'url', or 'targets'");
@@ -36665,9 +37198,9 @@ function readingTools(ctx) {
             if (response.success === false) {
               throw new Error(response.message || "zoom failed");
             }
-            return formatZoomText(targetLabel, response);
+            return withMeta(formatZoomText(targetLabel, response));
           }
-          return formatZoomBatchResult(targetLabel, symbolsArray, results).text;
+          return withMeta(formatZoomBatchResult(targetLabel, symbolsArray, results).text);
         }
         const params = { file: file2 };
         if (args.contextLines !== undefined)
@@ -36678,7 +37211,7 @@ function readingTools(ctx) {
         if (data.success === false) {
           throw new Error(data.message || "zoom failed");
         }
-        return formatZoomText(targetLabel, data);
+        return withMeta(formatZoomText(targetLabel, data));
       }
     }
   };
@@ -36834,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)"),
@@ -37013,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))
@@ -37055,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;
         }
@@ -37092,7 +37622,7 @@ function formatGrepOutput(response) {
   const totalMatches = response.total_matches ?? matches.length;
   const filesWithMatches = response.files_with_matches ?? new Set(matches.map((m) => m.file)).size;
   if (matches.length === 0) {
-    return `Found ${totalMatches} match(es) in ${filesWithMatches} file(s).`;
+    return `Found ${totalMatches} match across ${filesWithMatches} file`;
   }
   const body = matches.map((match) => {
     const file2 = match.file ?? "unknown";
@@ -37103,7 +37633,7 @@ function formatGrepOutput(response) {
 `);
   return `${body}
 
-Found ${totalMatches} match(es) in ${filesWithMatches} file(s).`;
+Found ${totalMatches} match across ${filesWithMatches} file`;
 }
 function normalizeGlob(pattern) {
   if (!pattern.includes("/") && !pattern.startsWith("**/")) {
@@ -37308,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",
+      "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').",
       "",
-      "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",
-      "",
-      "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: {
@@ -37366,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";
@@ -37493,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.");
@@ -37518,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(`
@@ -37586,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);
@@ -37816,17 +38247,25 @@ ${lines}
   });
   rpcServer.handle("status", async (params) => {
     const sessionID = params.sessionID || "rpc";
-    const cachedDir = getSessionDirectoryCached(sessionID);
-    const candidateDirs = new Set;
-    if (typeof cachedDir === "string" && cachedDir.length > 0) {
-      candidateDirs.add(cachedDir);
-    }
-    candidateDirs.add(input.directory);
     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 {
@@ -37839,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 () => {
@@ -37905,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),
@@ -37944,6 +38376,7 @@ Install: ${getManualInstallHint()}`).catch(() => {});
     }
     log2(`Disabled ${disabled.size} tool(s): ${[...disabled].join(", ")}`);
   }
+  instrumentToolMap(allTools);
   const autoUpdateEventHook = createAutoUpdateCheckerHook(input, {
     enabled: true,
     autoUpdate: aftConfig.auto_update ?? true,
@@ -37963,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))
@@ -38050,13 +38492,6 @@ Install: ${getManualInstallHint()}`).catch(() => {});
     "tool.execute.after": async (toolInput, output) => {
       if (!output)
         return;
-      const stored = consumeToolMetadata(toolInput.sessionID, toolInput.callID);
-      if (stored) {
-        if (stored.title)
-          output.title = stored.title;
-        if (stored.metadata)
-          output.metadata = { ...output.metadata, ...stored.metadata };
-      }
       if (toolInput.tool === "bash" && output.output) {
         output.output = maybeAppendConflictsHint(output.output);
       }
@@ -38064,7 +38499,7 @@ Install: ${getManualInstallHint()}`).catch(() => {});
       await appendInTurnBgCompletions({ ctx, directory: sessionDir, sessionID: toolInput.sessionID }, output);
       if (output.output !== undefined) {
         const activeBridge = ctx.pool.getActiveBridgeForRoot(sessionDir);
-        const suffix = statusBarSuffixForSession(toolInput.sessionID, activeBridge?.getStatusBar());
+        const suffix = statusBarSuffixForSession(toolInput.sessionID, activeBridge?.getStatusBar(), toolInput.tool === "aft_inspect");
         if (suffix)
           output.output += suffix;
       }