@cortexkit/aft-opencode 0.35.4 → 0.36.1

package/dist/index.js

@@ -11597,9 +11597,6 @@ function error(message, meta) {
 var CONFLICT_HINT = `
 
 [Hint] Use aft_conflicts to see all conflict regions across files in a single call.`;
-var GREP_HINT = `
-
-[Hint] Use the grep tool instead of bash for faster indexed search.`;
 function maybeAppendConflictsHint(output) {
   if (!output.includes("Automatic merge failed; fix conflicts"))
     return output;
@@ -11607,12 +11604,12 @@ function maybeAppendConflictsHint(output) {
     return output;
   return output + CONFLICT_HINT;
 }
-function maybeAppendGrepHint(output, command) {
-  const probe = command !== undefined ? command : output.slice(0, 300).split(`
-`)[0] ?? "";
-  if (!/\b(rg|grep)\s/.test(probe))
-    return output;
-  return output + GREP_HINT;
+// ../aft-bridge/dist/bash-timeout.js
+function resolveBashKillTimeout(modelTimeout, foregroundWaitMs) {
+  if (modelTimeout !== undefined && modelTimeout >= foregroundWaitMs) {
+    return modelTimeout;
+  }
+  return;
 }
 // ../aft-bridge/dist/bridge.js
 import { spawn } from "node:child_process";
@@ -12467,6 +12464,27 @@ class BinaryBridge {
     }
   }
 }
+// ../aft-bridge/dist/coerce.js
+function coerceStringArray(value) {
+  if (Array.isArray(value)) {
+    return value.filter((entry) => typeof entry === "string" && entry.length > 0);
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+      return [];
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) {
+          return parsed.filter((entry) => typeof entry === "string" && entry.length > 0);
+        }
+      } catch {}
+    }
+    return [value];
+  }
+  return [];
+}
 // ../aft-bridge/dist/downloader.js
 import { spawnSync } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
@@ -12763,6 +12781,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}`;
@@ -13975,6 +13998,464 @@ function isProcessAlive(pid) {
     return true;
   }
 }
+// ../aft-bridge/dist/pipe-strip.js
+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",
+  "q",
+  "quiet",
+  "o",
+  "only-matching",
+  "l",
+  "files-with-matches"
+]);
+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 };
+  const prefix = chain.slice(0, -1).map((segment) => segment.trim()).filter(Boolean);
+  const pipeline3 = chain[chain.length - 1] ?? "";
+  const stages = splitTopLevelPipeline(pipeline3);
+  if (stages.length < 2)
+    return { command, stripped: false };
+  const firstStage = stages[0]?.trim() ?? "";
+  if (!isCompressorHandledRunner(firstStage))
+    return { command, stripped: false };
+  const filterStages = stages.slice(1).map((stage) => stage.trim());
+  for (const stage of filterStages) {
+    if (!filterStageIsSafeToDrop(stage))
+      return { command, stripped: false };
+  }
+  const filters = filterStages.join(" | ");
+  const rebuilt = [...prefix, firstStage].join(" && ");
+  return {
+    command: rebuilt,
+    stripped: true,
+    note: `[AFT dropped \`| ${filters}\` (compressed:false to keep)]`
+  };
+}
+function splitTopLevelAndChain(command) {
+  const segments = [];
+  let start = 0;
+  let quote = null;
+  let escaped = false;
+  for (let index = 0;index < command.length; index++) {
+    const char = command[index];
+    const next = command[index + 1];
+    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 === "&" && next === "&") {
+      segments.push(command.slice(start, index));
+      start = index + 2;
+      index++;
+      continue;
+    }
+    if (char === "|" && next === "|")
+      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;
+}
+function splitTopLevelPipeline(command) {
+  const stages = [];
+  let start = 0;
+  let quote = null;
+  let escaped = false;
+  for (let index = 0;index < command.length; index++) {
+    const char = command[index];
+    const next = command[index + 1];
+    const previous = command[index - 1];
+    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 === "|" && previous !== "|" && next !== "|") {
+      stages.push(command.slice(start, index));
+      start = index + 1;
+    }
+  }
+  stages.push(command.slice(start));
+  return stages;
+}
+function isCompressorHandledRunner(stage) {
+  const tokens = tokenizeStage(stage);
+  if (tokens.length === 0)
+    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 === "npm" || first === "pnpm") {
+    return second === "test" || second === "run" && startsWithTest(third);
+  }
+  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 === "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;
+}
+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 (/[<>]/.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 === "--")
+      return false;
+    if (!arg.startsWith("-") || arg === "-")
+      continue;
+    if (arg.startsWith("--")) {
+      const flag = arg.slice(2).split("=", 1)[0];
+      if (GREP_GUARD_FLAGS.has(flag))
+        return true;
+      continue;
+    }
+    for (const flag of arg.slice(1)) {
+      if (GREP_GUARD_FLAGS.has(flag))
+        return true;
+    }
+  }
+  return false;
+}
+function tokenizeStage(stage) {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  let escaped = false;
+  for (let index = 0;index < stage.length; index++) {
+    const char = stage[index];
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\" && quote !== "'") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current.length > 0) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (current.length > 0)
+    tokens.push(current);
+  return tokens;
+}
 // ../aft-bridge/dist/pool.js
 import { realpathSync as realpathSync2 } from "node:fs";
 var DEFAULT_IDLE_TIMEOUT_MS = Infinity;
@@ -32282,38 +32763,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) {
@@ -32485,10 +32934,12 @@ 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}`);
         } catch (err) {
@@ -32960,7 +33411,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);
@@ -32968,12 +33419,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";
 
@@ -33127,7 +33633,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;
 }
@@ -33964,6 +34476,15 @@ 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;
+  }
+  return configured;
+}
 var BASH_DESCRIPTION = `Hoisted bash tool with output compression, command rewriting to AFT tools, optional background execution, and PTY mode for interactive programs. By default, output is compressed; pass compressed: false for raw output. Pass background: true to spawn in the background and get a taskId for bash_status/bash_kill. Pass pty: true for interactive REPLs and drive them with bash_status({ outputMode: "screen" }) plus bash_write (pty implies background automatically). Use bash_watch to block on or register for pattern matches and exit events.`;
 async function withPermissionLoop(ctx, runtime, params, bridgeCall, options) {
   const first = await bridgeCall(ctx, runtime, "bash", params, options);
@@ -34006,7 +34527,10 @@ function createBashTool(ctx) {
       let accumulatedOutput = "";
       const description = args.description;
       const metadata = context.metadata;
-      const command = args.command;
+      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;
@@ -34017,13 +34541,15 @@ function createBashTool(ctx) {
       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: args.timeout,
+        timeout: effectiveTimeout,
         workdir: args.workdir,
         env: shellEnv?.env ?? {},
         description,
@@ -34044,26 +34570,20 @@ function createBashTool(ctx) {
         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;
+        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);
-          if (callID2) {
-            storeToolMetadata(context.sessionID, callID2, {
-              title: description ?? shortenCommand(command),
-              metadata: metadataPayload2
-            });
-          }
-          return startedLine;
+          return { output: startedLine, title: uiTitle, metadata: metadataPayload2 };
         }
-        const argTimeout = args.timeout;
-        const foregroundWaitMs = bashCfg.foreground_wait_window_ms;
-        const waitTimeoutMs = subagentForcedForeground ? argTimeout ?? DEFAULT_HARD_TIMEOUT_MS : argTimeout !== undefined ? Math.min(argTimeout, foregroundWaitMs) : foregroundWaitMs;
+        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 });
@@ -34071,16 +34591,10 @@ function createBashTool(ctx) {
             throw new Error(status.message ?? "bash_status failed");
           }
           if (isTerminalStatus(status.status)) {
-            const rendered2 = formatForegroundResult(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;
+            return { output: rendered2, title: uiTitle, metadata: metadataPayload2 };
           }
           if (Date.now() - startedAt >= waitTimeoutMs) {
             if (subagentForcedForeground) {
@@ -34094,18 +34608,13 @@ function createBashTool(ctx) {
               throw new Error(promoted.message ?? "bash_promote failed");
             }
             trackBgTask(context.sessionID, taskId);
-            let message = formatPromotionMessage(taskId, args.timeout, foregroundWaitMs);
+            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);
-            if (callID2) {
-              storeToolMetadata(context.sessionID, callID2, {
-                title: description ?? shortenCommand(command),
-                metadata: metadataPayload2
-              });
-            }
-            return message;
+            return { output: message, title: uiTitle, metadata: metadataPayload2 };
           }
           await sleep(FOREGROUND_POLL_INTERVAL_MS);
         }
@@ -34116,7 +34625,6 @@ function createBashTool(ctx) {
       const truncated = data.truncated;
       const outputPath = data.output_path;
       const timedOut = data.timed_out === true;
-      const callID = getCallID(context);
       const metadataPayload = {
         description,
         output: metadataOutput,
@@ -34125,12 +34633,6 @@ function createBashTool(ctx) {
         ...outputPath ? { outputPath } : {}
       };
       metadata?.(metadataPayload);
-      if (callID) {
-        storeToolMetadata(context.sessionID, callID, {
-          title: description ?? shortenCommand(command),
-          metadata: metadataPayload
-        });
-      }
       let rendered = output;
       if (truncated && outputPath) {
         rendered += `
@@ -34144,10 +34646,20 @@ function createBashTool(ctx) {
         rendered += `
 [exit code: ${exit}]`;
       }
-      return rendered;
+      rendered = appendPipeStripNote(rendered, pipeStrip.note);
+      return {
+        output: rendered,
+        title: description ?? shortenCommand(command),
+        metadata: metadataPayload
+      };
     }
   };
 }
+function appendPipeStripNote(output, note) {
+  return note ? `${output}
+
+${note}` : output;
+}
 function createBashStatusTool(ctx) {
   return {
     description: "Read-only snapshot of a background or PTY bash task's current state and output. Returns immediately. Never waits. Use bash_watch to block on or register for pattern matches and exit events.",
@@ -34202,7 +34714,7 @@ async function formatBashStatusText(runtime, taskId, data, requestedOutputMode)
     const preview = data.output_preview;
     if (preview && status !== "running") {
       text += `
-${preview.slice(0, 2000)}`;
+${preview}`;
     }
     if (status === "running") {
       text += `
@@ -34326,7 +34838,7 @@ var MAX_BASH_STATUS_WAIT_TIMEOUT_MS = 300000;
 var REGEX_WAIT_SCAN_WINDOW_BYTES = 64 * 1024;
 function createBashWatchTool(ctx) {
   return {
-    description: "Block on a background bash task until a pattern matches, it exits, or timeout elapses; or register an async pattern notification with background:true.",
+    description: "Watch a background bash task. Two modes. Async (background:true, requires pattern) registers a non-blocking notification and returns immediately — use this to be pinged when a specific line appears or the task exits, without freezing your turn. Sync (default) blocks until a pattern matches/the task exits/timeout, and is ONLY for short bounded waits (seconds, e.g. a dev server printing a readiness line). Do NOT sync-wait for a long task (build/test/install): blocking locks the user out until it ends — instead end your turn and let the automatic completion reminder arrive, or use async mode.",
     args: {
       taskId: z6.string().describe("Background task ID returned by bash({ background: true })."),
       pattern: z6.union([z6.string(), z6.object({ regex: z6.string() })]).optional().describe("Substring or regex pattern. Optional in sync mode; required with background:true. Sync substring watches keep only the overlap tail needed for boundary matches; sync regex watches use a 64 KB rolling output window."),
@@ -34407,7 +34919,7 @@ Waited ${waited.elapsed_ms}ms; task exited (${stat}${e}).`;
   const preview2 = data.output_preview;
   if (preview2 && status !== "running") {
     text += `
-${preview2.slice(0, 2000)}`;
+${preview2}`;
   }
   return text;
 }
@@ -34622,10 +35134,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);
 }
@@ -34911,19 +35419,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;
@@ -34944,32 +35449,24 @@ 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 } };
     }
   };
 }
@@ -35059,27 +35556,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: {}
+        }
+      };
     }
   };
 }
@@ -35088,45 +35582,39 @@ 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)
@@ -35140,16 +35628,15 @@ 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)
     },
     execute: async (args, context) => {
@@ -35157,38 +35644,6 @@ function createEditTool(ctx, writeToolName = "write") {
       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");
@@ -35245,34 +35700,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.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);
@@ -35309,6 +35763,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;
     }
   };
@@ -35458,6 +35915,9 @@ function createApplyPatchTool(ctx) {
                 include_diff_content: true,
                 multi_file_write_paths: multiFileWritePaths
               });
+              if (writeResult.success === false) {
+                throw new Error(writeResult.message ?? "write failed");
+              }
               const wrDiff = writeResult.diff;
               perFileDiffs.push({
                 filePath,
@@ -35483,7 +35943,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,
@@ -35511,6 +35976,9 @@ function createApplyPatchTool(ctx) {
                 include_diff_content: true,
                 multi_file_write_paths: multiFileWritePaths
               });
+              if (writeResult.success === false) {
+                throw new Error(writeResult.message ?? "write failed");
+              }
               const diags = writeResult.lsp_diagnostics;
               if (diags && diags.length > 0) {
                 const errors3 = diags.filter((d) => d.severity === "error");
@@ -35590,10 +36058,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;
@@ -35619,20 +36088,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(`
-`);
     }
   };
 }
@@ -35647,7 +36117,10 @@ function createDeleteTool(ctx) {
       recursive: z8.boolean().optional().describe("Required to delete a directory and its contents. Defaults to false; passing a directory without this returns an error.")
     },
     execute: async (args, context) => {
-      const inputs = args.files;
+      const inputs = coerceStringArray(args.files);
+      if (inputs.length === 0) {
+        throw new Error("delete: `files` must be a non-empty array of paths");
+      }
       const recursive = args.recursive === true;
       const projectRoot = await resolveProjectRoot(ctx, context);
       const absolutePaths = inputs.map((f) => resolvePathFromProjectRoot(projectRoot, f));
@@ -36073,6 +36546,7 @@ ${diagnostics}` : json2;
 // src/tools/navigation.ts
 import { tool as tool11 } from "@opencode-ai/plugin";
 var z11 = tool11.schema;
+var CALLGRAPH_SOFT_CODES = new Set(["symbol_not_found", "callgraph_building"]);
 function navigationTools(ctx) {
   return {
     aft_callgraph: {
@@ -36136,7 +36610,12 @@ function navigationTools(ctx) {
           params.toFile = toFile;
         const response = await callBridge(ctx, context, args.op, params);
         if (response.success === false) {
-          throw new Error(formatBridgeErrorMessage(args.op, response, params));
+          const message = formatBridgeErrorMessage(args.op, response, params);
+          const code = typeof response.code === "string" ? response.code : "";
+          if (CALLGRAPH_SOFT_CODES.has(code)) {
+            return message;
+          }
+          throw new Error(message);
         }
         return JSON.stringify(response);
       }
@@ -36147,10 +36626,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)) {
@@ -36313,25 +36788,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'");
@@ -36371,7 +36847,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'");
@@ -36404,9 +36880,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)
@@ -36417,7 +36893,7 @@ function readingTools(ctx) {
         if (data.success === false) {
           throw new Error(data.message || "zoom failed");
         }
-        return formatZoomText(targetLabel, data);
+        return withMeta(formatZoomText(targetLabel, data));
       }
     }
   };
@@ -36747,7 +37223,8 @@ function safetyTools(ctx) {
             return permissionDeniedResponse(permissionError);
         }
         if (op === "checkpoint") {
-          const checkpointFiles = Array.isArray(args.files) ? args.files : typeof args.filePath === "string" ? [args.filePath] : undefined;
+          const coercedFiles = coerceStringArray(args.files);
+          const checkpointFiles = coercedFiles.length > 0 ? coercedFiles : typeof args.filePath === "string" ? [args.filePath] : undefined;
           if (Array.isArray(checkpointFiles)) {
             const projectRoot = await resolveProjectRoot(ctx, context);
             const uniqueParents = new Set;
@@ -36793,17 +37270,18 @@ function safetyTools(ctx) {
         const params = {};
         if (args.name !== undefined)
           params.name = args.name;
+        const payloadFiles = coerceStringArray(args.files);
         if (op === "checkpoint") {
-          if (args.files !== undefined) {
-            params.files = args.files;
+          if (payloadFiles.length > 0) {
+            params.files = payloadFiles;
           } else if (args.filePath !== undefined) {
             params.files = [args.filePath];
           }
         } else {
           if (args.filePath !== undefined)
             params.file = args.filePath;
-          if (args.files !== undefined)
-            params.files = args.files;
+          if (payloadFiles.length > 0)
+            params.files = payloadFiles;
         }
         const response = await callBridge(ctx, context, commandMap[op], params);
         if (response.success === false) {
@@ -36829,7 +37307,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";
@@ -36840,7 +37318,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("**/")) {
@@ -37229,16 +37707,15 @@ function buildWorkflowHints(opts) {
   const hasInspect = opts.toolSurface !== "minimal" && !opts.disabledTools.has("aft_inspect");
   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.");
+  }
   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)) {
-    if (hasSearch) {
-      const grepFallback = hasGrep ? ` Use \`${grepName}\` directly only when you need exhaustive enumeration of literal text (every TODO, every import of X) without ranking.` : "";
-      sections.push(`**Code exploration**: \`aft_search\` is the primary code-search tool. It auto-routes by query shape — exact identifiers, regex, error messages, natural language all use the same call. Very short queries fall back to literal scans; pass \`hint: "regex"\` / \`hint: "literal"\` / \`hint: "semantic"\` to override routing if needed. Then \`aft_outline\` for structure → \`aft_zoom\` for symbol(s).${grepFallback}`);
-    } else {
-      sections.push(`**Code exploration**: \`${grepName}\` to locate → \`aft_outline\` for structure → \`aft_zoom\` for symbol(s).`);
-    }
+    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).`);
   }
   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.");
@@ -37256,12 +37733,13 @@ function buildWorkflowHints(opts) {
 `));
   }
   if (hasBash && hasBgBash) {
-    sections.push(`**Long-running commands** (builds, installs, full test suites): \`${bashName}({ background: true })\` returns immediately with a \`taskId\`. A completion reminder is delivered automatically — do not poll \`${bashStatusName}({ taskId })\`. Use \`${bashStatusName}\` only after the reminder arrives, or to inspect a task you already know is complete.`);
+    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(`**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.");
   return `${HEADING}
 
 ${sections.join(`
@@ -37274,6 +37752,7 @@ function buildHintsFromConfig(config2, disabledTools) {
     hoistBuiltins: config2.hoist_builtin_tools !== false,
     semanticEnabled: config2.semantic_search === true,
     bashBackgroundEnabled: resolveBashConfig(config2).background,
+    bashCompressionEnabled: resolveBashConfig(config2).compress,
     disabledTools
   });
 }
@@ -37322,12 +37801,12 @@ var PLUGIN_VERSION = (() => {
     return "0.0.0";
   }
 })();
-var ANNOUNCEMENT_VERSION = "0.35.3";
+var ANNOUNCEMENT_VERSION = "0.36.0";
 var ANNOUNCEMENT_FEATURES = [
-  "Code Health in the TUI sidebar and `/aft-status`: live LSP errors and warnings plus duplicate and TODO counts, shown as at-a-glance traffic lights when the sidebar is collapsed.",
-  "The semantic index now recovers on its own from a transient embedding-backend blip (a restarted local server, or a model still loading) instead of getting stuck on `failed`.",
-  "Fixed a background codebase-scan crash on very deep or minified files.",
-  "More reliable LSP auto-install when a parent directory has its own `package.json`."
+  "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."
 ];
 var ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/DSa65w8wuf";
 var plugin = async (input) => initializePluginForDirectory(input);
@@ -37554,10 +38033,10 @@ ${lines}
     const sessionID = params.sessionID || "rpc";
     const cachedDir = getSessionDirectoryCached(sessionID);
     const candidateDirs = new Set;
+    candidateDirs.add(input.directory);
     if (typeof cachedDir === "string" && cachedDir.length > 0) {
       candidateDirs.add(cachedDir);
     }
-    candidateDirs.add(input.directory);
     let bridge = null;
     for (const dir of candidateDirs) {
       bridge = pool.getActiveBridgeForRoot(dir);
@@ -37680,6 +38159,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,
@@ -37699,6 +38179,7 @@ Install: ${getManualInstallHint()}`).catch(() => {});
     "bash_status"
   ];
   const registeredTools = new Set(Object.keys(allTools));
+  pool.setConfigureOverride("aft_search_registered", registeredTools.has("aft_search"));
   const hintsAbsentTools = new Set;
   for (const name of HINTS_TOOL_NAMES) {
     if (!registeredTools.has(name))
@@ -37785,22 +38266,14 @@ 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);
-        output.output = maybeAppendGrepHint(output.output);
       }
       const sessionDir = getSessionDirectoryCached(toolInput.sessionID) ?? input.directory;
       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;
       }