oh-my-opencode 4.3.0 → 4.4.0

package/dist/index.js

@@ -7285,7 +7285,6 @@ var init_model_versions = __esm(() => {
     "anthropic/claude-opus-4-5": "anthropic/claude-opus-4-7",
     "anthropic/claude-opus-4-6": "anthropic/claude-opus-4-7",
     "anthropic/claude-sonnet-4-5": "anthropic/claude-sonnet-4-6",
-    "openai/gpt-5.3-codex": "openai/gpt-5.4",
     "openai/gpt-5.4": "openai/gpt-5.5"
   };
 });
@@ -8570,6 +8569,12 @@ function migrateConfigFile(configPath, rawConfig) {
     delete copy.omo_agent;
     needsWrite = true;
   }
+  if (copy.lsp !== undefined) {
+    const droppedServers = copy.lsp && typeof copy.lsp === "object" ? Object.keys(copy.lsp) : [];
+    log("Removed obsolete 'lsp' config key from oh-my-opencode config. Custom LSP servers are now configured in .opencode/lsp.json at the project root (consumed by the 'lsp' MCP server). Move any server definitions there to restore them.", { configPath, droppedServers });
+    delete copy.lsp;
+    needsWrite = true;
+  }
   if (copy.experimental && typeof copy.experimental === "object") {
     const experimental = copy.experimental;
     if ("hashline_edit" in experimental) {
@@ -9157,8 +9162,14 @@ var init_external_plugin_detector = __esm(() => {
 });
 
 // src/shared/bun-spawn-shim.ts
-import { spawn as nodeSpawn, spawnSync as nodeSpawnSync } from "child_process";
+import {
+  spawn as nodeSpawn,
+  spawnSync as nodeSpawnSync
+} from "child_process";
 import { Readable, Writable } from "stream";
+function getBunRuntime() {
+  return typeof Bun === "undefined" ? undefined : runtime.Bun;
+}
 function emptyReadableStream() {
   return new ReadableStream({
     start(controller) {
@@ -9191,6 +9202,38 @@ function resolveStdio(options) {
     return options.stdio;
   return [options.stdin ?? "ignore", options.stdout ?? "pipe", options.stderr ?? "inherit"];
 }
+function createNodeSpawnOptions(options, platform = process.platform) {
+  const nodeOptions = {
+    stdio: resolveStdio(options),
+    shell: false
+  };
+  if (options.cwd !== undefined)
+    nodeOptions.cwd = options.cwd;
+  if (options.env !== undefined)
+    nodeOptions.env = options.env;
+  if (options.detached !== undefined)
+    nodeOptions.detached = options.detached;
+  if (options.signal !== undefined)
+    nodeOptions.signal = options.signal;
+  if (platform === "win32") {
+    nodeOptions.windowsHide = true;
+  }
+  return nodeOptions;
+}
+function createNodeSpawnSyncOptions(options, platform = process.platform) {
+  const nodeOptions = {
+    stdio: resolveStdio(options),
+    shell: false
+  };
+  if (options.cwd !== undefined)
+    nodeOptions.cwd = options.cwd;
+  if (options.env !== undefined)
+    nodeOptions.env = options.env;
+  if (platform === "win32") {
+    nodeOptions.windowsHide = true;
+  }
+  return nodeOptions;
+}
 function wrapNodeProcess(proc) {
   let exitCode = null;
   const exited = new Promise((resolve5, reject) => {
@@ -9232,42 +9275,45 @@ function wrapNodeProcess(proc) {
     }
   };
 }
+function toSpawnSyncBuffer(output) {
+  if (output === null) {
+    return;
+  }
+  return Buffer.isBuffer(output) ? output : Buffer.from(output, "utf8");
+}
 function spawn2(cmdOrOpts, opts) {
-  if (IS_BUN)
-    return runtime.Bun.spawn(cmdOrOpts, opts);
   const { cmd, opts: options } = resolveCommand(cmdOrOpts, opts);
+  const bun = getBunRuntime();
+  if (bun)
+    return bun.spawn(cmd, options);
   const [bin, ...args] = cmd;
-  const proc = nodeSpawn(bin, args, {
-    cwd: options.cwd,
-    env: options.env,
-    stdio: resolveStdio(options),
-    detached: options.detached,
-    signal: options.signal
-  });
+  if (bin === undefined) {
+    throw new Error("Cannot spawn an empty command");
+  }
+  const proc = nodeSpawn(bin, args, createNodeSpawnOptions(options));
   return wrapNodeProcess(proc);
 }
 function spawnSync(cmdOrOpts, opts) {
-  if (IS_BUN)
-    return runtime.Bun.spawnSync(cmdOrOpts, opts);
   const { cmd, opts: options } = resolveCommand(cmdOrOpts, opts);
+  const bun = getBunRuntime();
+  if (bun)
+    return bun.spawnSync(cmd, options);
   const [bin, ...args] = cmd;
-  const result = nodeSpawnSync(bin, args, {
-    cwd: options.cwd,
-    env: options.env,
-    stdio: resolveStdio(options)
-  });
+  if (bin === undefined) {
+    throw new Error("Cannot spawnSync an empty command");
+  }
+  const result = nodeSpawnSync(bin, args, createNodeSpawnSyncOptions(options));
   return {
     exitCode: result.status ?? 1,
-    stdout: result.stdout ?? undefined,
-    stderr: result.stderr ?? undefined,
+    stdout: toSpawnSyncBuffer(result.stdout),
+    stderr: toSpawnSyncBuffer(result.stderr),
     success: (result.status ?? 1) === 0,
     pid: result.pid ?? -1
   };
 }
-var runtime, IS_BUN;
+var runtime;
 var init_bun_spawn_shim = __esm(() => {
   runtime = globalThis;
-  IS_BUN = typeof runtime.Bun !== "undefined";
 });
 
 // src/shared/archive-entry-validator.ts
@@ -9326,6 +9372,52 @@ function validateArchiveEntries(entries, destDir) {
 }
 var init_archive_entry_validator = () => {};
 
+// src/shared/process-stream-reader.ts
+function bufferFromChunk(chunk) {
+  if (Buffer.isBuffer(chunk)) {
+    return chunk;
+  }
+  if (chunk instanceof Uint8Array) {
+    return Buffer.from(chunk);
+  }
+  if (typeof chunk === "string") {
+    return Buffer.from(chunk, "utf8");
+  }
+  throw new TypeError(`Unsupported process stream chunk type: ${typeof chunk}`);
+}
+async function readWebStream(stream) {
+  const reader = stream.getReader();
+  const chunks = [];
+  try {
+    while (true) {
+      const result = await reader.read();
+      if (result.done) {
+        return chunks;
+      }
+      chunks.push(Buffer.from(result.value));
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function readNodeStream(stream) {
+  const chunks = [];
+  for await (const chunk of stream) {
+    chunks.push(bufferFromChunk(chunk));
+  }
+  return chunks;
+}
+function isWebReadableStream(stream) {
+  return typeof ReadableStream !== "undefined" && stream instanceof ReadableStream;
+}
+async function readProcessStream(stream) {
+  if (!stream) {
+    return "";
+  }
+  const chunks = isWebReadableStream(stream) ? await readWebStream(stream) : await readNodeStream(stream);
+  return Buffer.concat(chunks).toString("utf8");
+}
+
 // src/shared/zip-entry-listing/python-zip-entry-listing.ts
 function isPythonZipListingAvailable() {
   const proc = spawnSync(["python3", "--version"], {
@@ -9363,8 +9455,8 @@ async function listZipEntriesWithPython(archivePath) {
   });
   const [exitCode, stdout, stderr] = await Promise.all([
     proc.exited,
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text()
+    readProcessStream(proc.stdout),
+    readProcessStream(proc.stderr)
   ]);
   if (exitCode !== 0) {
     throw new Error(`zip entry listing failed (exit ${exitCode}): ${stderr}`);
@@ -9431,8 +9523,8 @@ async function listZipEntriesWithPowerShell(archivePath, escapePowerShellPath, e
   });
   const [exitCode, stdout, stderr] = await Promise.all([
     proc.exited,
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text()
+    readProcessStream(proc.stdout),
+    readProcessStream(proc.stderr)
   ]);
   if (exitCode !== 0) {
     throw new Error(`zip entry listing failed (exit ${exitCode}): ${stderr}`);
@@ -9495,8 +9587,8 @@ async function listZipEntriesWithTar(archivePath) {
   });
   const [exitCode, stdout, stderr] = await Promise.all([
     proc.exited,
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text()
+    readProcessStream(proc.stdout),
+    readProcessStream(proc.stderr)
   ]);
   if (exitCode !== 0) {
     throw new Error(`zip entry listing failed (exit ${exitCode}): ${stderr}`);
@@ -9516,8 +9608,8 @@ async function readZipSymlinkTarget(archivePath, entryPath) {
   });
   const [exitCode, stdout, stderr] = await Promise.all([
     proc.exited,
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text()
+    readProcessStream(proc.stdout),
+    readProcessStream(proc.stderr)
   ]);
   if (exitCode !== 0) {
     throw new Error(`zip symlink target read failed (exit ${exitCode}): ${stderr}`);
@@ -9560,8 +9652,8 @@ async function listZipEntriesWithZipInfo(archivePath) {
   });
   const [exitCode, stdout, stderr] = await Promise.all([
     proc.exited,
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text()
+    readProcessStream(proc.stdout),
+    readProcessStream(proc.stderr)
   ]);
   if (exitCode !== 0) {
     throw new Error(`zip entry listing failed (exit ${exitCode}): ${stderr}`);
@@ -9657,7 +9749,7 @@ async function extractZip(archivePath, destDir) {
   }
   const exitCode = await proc.exited;
   if (exitCode !== 0) {
-    const stderr = await new Response(proc.stderr).text();
+    const stderr = await readProcessStream(proc.stderr);
     throw new Error(`zip extraction failed (exit ${exitCode}): ${stderr}`);
   }
 }
@@ -9716,20 +9808,20 @@ function createNodeFile(path6) {
   };
 }
 function bunFile(path6) {
-  if (IS_BUN2)
+  if (IS_BUN)
     return runtime2.Bun.file(path6);
   return createNodeFile(path6);
 }
 async function bunWrite(path6, data) {
-  if (IS_BUN2)
+  if (IS_BUN)
     return runtime2.Bun.write(path6, data);
   await writeFile(path6, toWritableData(data));
   return byteLength(data);
 }
-var runtime2, IS_BUN2;
+var runtime2, IS_BUN;
 var init_bun_file_shim = __esm(() => {
   runtime2 = globalThis;
-  IS_BUN2 = typeof runtime2.Bun !== "undefined";
+  IS_BUN = typeof runtime2.Bun !== "undefined";
 });
 
 // src/shared/binary-downloader.ts
@@ -9766,7 +9858,7 @@ async function extractTarGz(archivePath, destDir, options) {
   });
   const exitCode = await proc.exited;
   if (exitCode !== 0) {
-    const stderr = await new Response(proc.stderr).text();
+    const stderr = await readProcessStream(proc.stderr);
     if (isTarTraversalErrorOutput(stderr)) {
       throw new Error(`Unsafe archive entry: path contains path traversal (${archivePath})`);
     }
@@ -9816,8 +9908,8 @@ async function listTarEntries(archivePath, cwd) {
   });
   const [exitCode, stdout, stderr] = await Promise.all([
     proc.exited,
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text()
+    readProcessStream(proc.stdout),
+    readProcessStream(proc.stderr)
   ]);
   if (isTarTraversalErrorOutput(stderr)) {
     throw new Error(`Unsafe archive entry: path contains path traversal (${archivePath})`);
@@ -69279,6 +69371,8 @@ async function buildReadyNotificationContent(ctx, input) {
 
 // src/hooks/session-notification-sender.ts
 init_shared();
+import { execFile } from "child_process";
+import { promisify as promisify2 } from "util";
 import { platform } from "os";
 
 // src/hooks/session-notification-utils.ts
@@ -69288,7 +69382,7 @@ init_logger();
 import { accessSync as accessSync2, constants as constants4 } from "fs";
 import { delimiter, join as join29 } from "path";
 var runtime3 = globalThis;
-var IS_BUN3 = typeof runtime3.Bun !== "undefined";
+var IS_BUN2 = typeof runtime3.Bun !== "undefined";
 function isUnsafeCommandName(commandName) {
   if (commandName.includes("/") || commandName.includes("\\"))
     return true;
@@ -69323,7 +69417,7 @@ function bunWhich(commandName) {
     return null;
   if (isUnsafeCommandName(commandName))
     return null;
-  if (IS_BUN3)
+  if (IS_BUN2)
     return runtime3.Bun?.which(commandName) ?? null;
   const pathValue = resolvePathValue();
   if (!pathValue)
@@ -69459,14 +69553,33 @@ function getDefaultSoundPath(platform2) {
   }
 }
 var hasLoggedUnavailableShellHelper = false;
-function canRunNotificationCommand(ctx) {
-  if (typeof ctx?.$ === "function")
-    return true;
+function getShellRunner(ctx) {
+  if (typeof ctx.$ === "function")
+    return ctx.$;
   if (!hasLoggedUnavailableShellHelper) {
     hasLoggedUnavailableShellHelper = true;
-    log("[session-notification] ctx.$ unavailable; skipping notification command execution");
+    log("[session-notification] ctx.$ unavailable; falling back to child_process.execFile");
   }
-  return false;
+  return;
+}
+function logCommandFailure(commandName, error) {
+  log("[session-notification] notification command failed", {
+    commandName,
+    error: typeof error === "string" ? error : error.message
+  });
+}
+function logOperationFailure(operation, error) {
+  log("[session-notification] notification operation failed", {
+    operation,
+    error: typeof error === "string" ? error : error.message
+  });
+}
+async function runQuiet(command) {
+  if (typeof command.quiet === "function") {
+    await command.quiet();
+    return;
+  }
+  await command;
 }
 async function runQuietNothrow(command) {
   const safeCommand = typeof command.nothrow === "function" ? command.nothrow() : command;
@@ -69476,85 +69589,124 @@ async function runQuietNothrow(command) {
   }
   await safeCommand;
 }
-async function sendSessionNotification(ctx, platform2, title, message) {
-  if (!canRunNotificationCommand(ctx))
+async function runExecFile(commandPath, args) {
+  const execFileAsync = promisify2(execFile);
+  await execFileAsync(commandPath, [...args], { windowsHide: true });
+}
+async function runNotificationCommand(ctx, commandPath, args, shellCommand, shellFailureMode = "nothrow") {
+  const shell = getShellRunner(ctx);
+  if (shell) {
+    if (shellFailureMode === "throw") {
+      await runQuiet(shellCommand(shell));
+      return;
+    }
+    await runQuietNothrow(shellCommand(shell));
     return;
-  switch (platform2) {
-    case "darwin": {
-      const cmuxPath = await getCmuxPath();
-      if (cmuxPath) {
-        try {
-          await ctx.$`${cmuxPath} notify --title ${title} --body ${message}`.quiet();
-          break;
-        } catch {}
-      }
-      const terminalNotifierPath = await getTerminalNotifierPath();
-      if (terminalNotifierPath) {
-        const bundleId = process.env.__CFBundleIdentifier;
-        try {
-          if (bundleId) {
-            await ctx.$`${terminalNotifierPath} -title ${title} -message ${message} -activate ${bundleId}`.quiet();
-          } else {
-            await ctx.$`${terminalNotifierPath} -title ${title} -message ${message}`.quiet();
+  }
+  await runExecFile(commandPath, args);
+}
+async function sendSessionNotification(ctx, platform2, title, message) {
+  try {
+    switch (platform2) {
+      case "darwin": {
+        const cmuxPath = await getCmuxPath();
+        if (cmuxPath) {
+          try {
+            await runNotificationCommand(ctx, cmuxPath, ["notify", "--title", title, "--body", message], (shell) => shell`${cmuxPath} notify --title ${title} --body ${message}`, "throw");
+            break;
+          } catch (error) {
+            if (error instanceof Error) {
+              logCommandFailure("cmux", error);
+            } else {
+              logCommandFailure("cmux", String(error));
+            }
           }
-          break;
-        } catch {}
+        }
+        const terminalNotifierPath = await getTerminalNotifierPath();
+        if (terminalNotifierPath) {
+          const bundleId = process.env.__CFBundleIdentifier;
+          const args = bundleId ? ["-title", title, "-message", message, "-activate", bundleId] : ["-title", title, "-message", message];
+          try {
+            await runNotificationCommand(ctx, terminalNotifierPath, args, (shell) => bundleId ? shell`${terminalNotifierPath} -title ${title} -message ${message} -activate ${bundleId}` : shell`${terminalNotifierPath} -title ${title} -message ${message}`, "throw");
+            break;
+          } catch (error) {
+            if (error instanceof Error) {
+              logCommandFailure("terminal-notifier", error);
+            } else {
+              logCommandFailure("terminal-notifier", String(error));
+            }
+          }
+        }
+        const osascriptPath = await getOsascriptPath();
+        if (!osascriptPath)
+          return;
+        const escapedTitle = escapeAppleScriptText(title);
+        const escapedMessage = escapeAppleScriptText(message);
+        const appleScript = 'display notification "' + escapedMessage + '" with title "' + escapedTitle + '"';
+        await runNotificationCommand(ctx, osascriptPath, ["-e", appleScript], (shell) => shell`${osascriptPath} -e ${appleScript}`);
+        break;
+      }
+      case "linux": {
+        const notifySendPath = await getNotifySendPath();
+        if (!notifySendPath)
+          return;
+        await runNotificationCommand(ctx, notifySendPath, [title, message], (shell) => shell`${notifySendPath} ${title} ${message} 2>/dev/null`);
+        break;
+      }
+      case "win32": {
+        const powershellPath = await getPowershellPath();
+        if (!powershellPath)
+          return;
+        const toastScript = buildWindowsToastScript(title, message);
+        await runNotificationCommand(ctx, powershellPath, ["-Command", toastScript], (shell) => shell`${powershellPath} -Command ${toastScript}`);
+        break;
       }
-      const osascriptPath = await getOsascriptPath();
-      if (!osascriptPath)
-        return;
-      const escapedTitle = escapeAppleScriptText(title);
-      const escapedMessage = escapeAppleScriptText(message);
-      await runQuietNothrow(ctx.$`${osascriptPath} -e ${'display notification "' + escapedMessage + '" with title "' + escapedTitle + '"'}`);
-      break;
-    }
-    case "linux": {
-      const notifySendPath = await getNotifySendPath();
-      if (!notifySendPath)
-        return;
-      await runQuietNothrow(ctx.$`${notifySendPath} ${title} ${message} 2>/dev/null`);
-      break;
     }
-    case "win32": {
-      const powershellPath = await getPowershellPath();
-      if (!powershellPath)
-        return;
-      const toastScript = buildWindowsToastScript(title, message);
-      await runQuietNothrow(ctx.$`${powershellPath} -Command ${toastScript}`);
-      break;
+  } catch (error) {
+    if (error instanceof Error) {
+      logOperationFailure("send", error);
+    } else {
+      logOperationFailure("send", String(error));
     }
   }
 }
 async function playSessionNotificationSound(ctx, platform2, soundPath) {
-  if (!canRunNotificationCommand(ctx))
-    return;
-  switch (platform2) {
-    case "darwin": {
-      const afplayPath = await getAfplayPath();
-      if (!afplayPath)
-        return;
-      await runQuietNothrow(ctx.$`${afplayPath} ${soundPath}`);
-      break;
-    }
-    case "linux": {
-      const paplayPath = await getPaplayPath();
-      if (paplayPath) {
-        await runQuietNothrow(ctx.$`${paplayPath} ${soundPath} 2>/dev/null`);
-      } else {
-        const aplayPath = await getAplayPath();
-        if (aplayPath) {
-          await runQuietNothrow(ctx.$`${aplayPath} ${soundPath} 2>/dev/null`);
+  try {
+    switch (platform2) {
+      case "darwin": {
+        const afplayPath = await getAfplayPath();
+        if (!afplayPath)
+          return;
+        await runNotificationCommand(ctx, afplayPath, [soundPath], (shell) => shell`${afplayPath} ${soundPath}`);
+        break;
+      }
+      case "linux": {
+        const paplayPath = await getPaplayPath();
+        if (paplayPath) {
+          await runNotificationCommand(ctx, paplayPath, [soundPath], (shell) => shell`${paplayPath} ${soundPath} 2>/dev/null`);
+        } else {
+          const aplayPath = await getAplayPath();
+          if (aplayPath) {
+            await runNotificationCommand(ctx, aplayPath, [soundPath], (shell) => shell`${aplayPath} ${soundPath} 2>/dev/null`);
+          }
         }
+        break;
+      }
+      case "win32": {
+        const powershellPath = await getPowershellPath();
+        if (!powershellPath)
+          return;
+        const escaped = escapePowerShellSingleQuotedText(soundPath);
+        const soundScript = "(New-Object Media.SoundPlayer '" + escaped + "').PlaySync()";
+        await runNotificationCommand(ctx, powershellPath, ["-Command", soundScript], (shell) => shell`${powershellPath} -Command ${soundScript}`);
+        break;
       }
-      break;
     }
-    case "win32": {
-      const powershellPath = await getPowershellPath();
-      if (!powershellPath)
-        return;
-      const escaped = escapePowerShellSingleQuotedText(soundPath);
-      await runQuietNothrow(ctx.$`${powershellPath} -Command ${"(New-Object Media.SoundPlayer '" + escaped + "').PlaySync()"}`);
-      break;
+  } catch (error) {
+    if (error instanceof Error) {
+      logOperationFailure("sound", error);
+    } else {
+      logOperationFailure("sound", String(error));
     }
   }
 }
@@ -71625,6 +71777,27 @@ async function runCommentChecker2(input, cliPath, customPrompt) {
 // src/hooks/comment-checker/cli-runner.ts
 var cliPathPromise = null;
 var isRunning = false;
+var sessionLastWarning = new Map;
+var DEDUP_WINDOW_MS = 30000;
+function hasCommentSyntax(text) {
+  if (!text)
+    return false;
+  return /^\s*(\/\/|\/\*|#|--|<!--|:\s*)[\s\S]*$/m.test(text) || /<!--[\s\S]*-->/.test(text);
+}
+function hasNewCommentsOnly(oldText, newText) {
+  if (!hasCommentSyntax(newText))
+    return false;
+  if (!hasCommentSyntax(oldText))
+    return true;
+  const oldLines = new Set((oldText ?? "").split(`
+`).map((l) => l.trim()));
+  const newLines = (newText ?? "").split(`
+`);
+  return newLines.some((l) => {
+    const trimmed = l.trim();
+    return trimmed && hasCommentSyntax(trimmed) && !oldLines.has(trimmed);
+  });
+}
 async function withCommentCheckerLock(fn, fallback, debugLog3) {
   if (isRunning) {
     debugLog3("comment-checker already running, skipping");
@@ -71666,6 +71839,17 @@ async function processWithCli(input, pendingCall, output, cliPath, customPrompt,
         edits: pendingCall.edits
       }
     };
+    if (!hasNewCommentsOnly(pendingCall.oldString, pendingCall.newString)) {
+      debugLog3("skipping: no net-new comments in edit (oldString/newString)");
+      return;
+    }
+    const lastWarned = sessionLastWarning.get(pendingCall.sessionID) ?? 0;
+    const now = Date.now();
+    if (now - lastWarned < DEDUP_WINDOW_MS) {
+      debugLog3("dedup: skipping comment warning within dedup window for session", pendingCall.sessionID);
+      return;
+    }
+    sessionLastWarning.set(pendingCall.sessionID, now);
     const result = await (deps.runCommentChecker ?? runCommentChecker2)(hookInput, cliPath, customPrompt);
     if (result.hasComments && result.message) {
       debugLog3("CLI detected comments, appending message");
@@ -80498,6 +80682,7 @@ function createTeamModeStatusInjector(config, keywordDetectorConfig) {
 // src/hooks/tool-pair-validator/hook.ts
 init_logger();
 var TOOL_RESULT_PLACEHOLDER = "Tool output unavailable (context compacted)";
+var TOOL_RESULT_RECOVERY_CONTINUATION = "Recovered missing tool results. Continue from the repaired tool output.";
 function getToolUseID(part) {
   const candidate = part;
   if (candidate.type === "tool_use" && typeof candidate.id === "string" && candidate.id.length > 0) {
@@ -80575,7 +80760,14 @@ function createSyntheticUserMessage(assistantMessage, missingToolUseIDs) {
       role: "user",
       ...sessionID ? { sessionID } : {}
     },
-    parts: missingToolUseIDs.map((toolUseID) => createToolResultPart(toolUseID))
+    parts: [
+      ...missingToolUseIDs.map((toolUseID) => createToolResultPart(toolUseID)),
+      {
+        type: "text",
+        text: TOOL_RESULT_RECOVERY_CONTINUATION,
+        synthetic: true
+      }
+    ]
   };
 }
 function getMessageID(message) {
@@ -91844,6 +92036,10 @@ async function handleAtlasSessionIdle(input) {
   }
   const { boulderState, progress, appendedSession } = activeBoulderSession;
   if (progress.isComplete) {
+    if (sessionState.pendingRetryTimer) {
+      clearTimeout(sessionState.pendingRetryTimer);
+      sessionState.pendingRetryTimer = undefined;
+    }
     const work = getWorkForSession(ctx.directory, sessionID);
     if (work) {
       completeBoulder(ctx.directory, work.work_id);
@@ -91854,6 +92050,10 @@ async function handleAtlasSessionIdle(input) {
       log(`[${HOOK_NAME7}] Boulder complete`, { sessionID, plan: boulderState.plan_name });
       return;
     }
+    if (options?.isContinuationStopped?.(sessionID)) {
+      log(`[${HOOK_NAME7}] Boulder completion nudge skipped because continuation stopped`, { sessionID, plan: boulderState.plan_name });
+      return;
+    }
     if (sessionState.boulderCompletionNudgedAt?.[work.work_id]) {
       log(`[${HOOK_NAME7}] Boulder complete`, { sessionID, plan: boulderState.plan_name });
       return;
@@ -100037,11 +100237,17 @@ var cachedCli = null;
 var autoInstallAttempted = false;
 function findExecutable(name) {
   const isWindows2 = process.platform === "win32";
-  const cmd = isWindows2 ? "where" : "which";
+  const cmd = isWindows2 ? "where.exe" : "which";
   try {
-    const result = spawnSync2(cmd, [name], { encoding: "utf-8", timeout: 5000 });
-    if (result.status === 0 && result.stdout.trim()) {
-      return result.stdout.trim().split(`
+    const result = spawnSync2(cmd, [name], {
+      encoding: "utf-8",
+      timeout: 5000,
+      windowsHide: isWindows2,
+      shell: false
+    });
+    const stdout = result.stdout;
+    if (result.status === 0 && stdout.trim()) {
+      return stdout.trim().split(`
 `)[0];
     }
   } catch {
@@ -100055,6 +100261,7 @@ function getOpenCodeBundledRg() {
   const isWindows2 = process.platform === "win32";
   const rgName = isWindows2 ? "rg.exe" : "rg";
   const candidates = [
+    join81(getOpenCodeCacheDir(), "bin", rgName),
     join81(getDataDir(), "opencode", "bin", rgName),
     join81(execDir, rgName),
     join81(execDir, "bin", rgName),
@@ -100163,6 +100370,29 @@ class Semaphore {
 }
 var rgSemaphore = new Semaphore(2);
 
+// src/tools/shared/search-process-output.ts
+function getErrorMessage5(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function createProcessTimeout(proc, timeoutMs, timeoutMessage) {
+  return new Promise((_, reject) => {
+    const id = setTimeout(() => {
+      proc.kill();
+      reject(new Error(timeoutMessage));
+    }, timeoutMs);
+    proc.exited.then(() => clearTimeout(id), () => clearTimeout(id));
+  });
+}
+async function collectSearchProcessOutput(proc, timeoutMs, timeoutMessage) {
+  const stderrPromise = readProcessStream(proc.stderr).catch(getErrorMessage5);
+  const stdout = await Promise.race([
+    readProcessStream(proc.stdout),
+    createProcessTimeout(proc, timeoutMs, timeoutMessage)
+  ]);
+  const [exitCode, stderr] = await Promise.all([proc.exited, stderrPromise]);
+  return { stdout, stderr, exitCode };
+}
+
 // src/tools/grep/cli.ts
 function buildRgArgs(options) {
   const args = [
@@ -100286,15 +100516,15 @@ function parseCountOutput(output) {
   }
   return results;
 }
-async function runRg(options, resolvedCli) {
+async function runRg(options, resolvedCli, processSpawner = spawn2) {
   await rgSemaphore.acquire();
   try {
-    return await runRgInternal(options, resolvedCli);
+    return await runRgInternal(options, resolvedCli, processSpawner);
   } finally {
     rgSemaphore.release();
   }
 }
-async function runRgInternal(options, resolvedCli) {
+async function runRgInternal(options, resolvedCli, processSpawner = spawn2) {
   const cli = resolvedCli ?? resolveGrepCli();
   const args = buildArgs(options, cli.backend);
   const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS2, DEFAULT_TIMEOUT_MS2);
@@ -100305,21 +100535,12 @@ async function runRgInternal(options, resolvedCli) {
   }
   const paths = options.paths?.length ? options.paths : ["."];
   args.push(...paths);
-  const proc = spawn2([cli.path, ...args], {
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const timeoutPromise = new Promise((_, reject) => {
-    const id = setTimeout(() => {
-      proc.kill();
-      reject(new Error(`Search timeout after ${timeout}ms`));
-    }, timeout);
-    proc.exited.then(() => clearTimeout(id));
-  });
   try {
-    const stdout = await Promise.race([new Response(proc.stdout).text(), timeoutPromise]);
-    const stderr = await new Response(proc.stderr).text();
-    const exitCode = await proc.exited;
+    const proc = processSpawner([cli.path, ...args], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const { stdout, stderr, exitCode } = await collectSearchProcessOutput(proc, timeout, `Search timeout after ${timeout}ms`);
     const truncated = stdout.length >= DEFAULT_MAX_OUTPUT_BYTES;
     const outputToProcess = truncated ? stdout.substring(0, DEFAULT_MAX_OUTPUT_BYTES) : stdout;
     if (exitCode > 1 && stderr.trim()) {
@@ -100350,15 +100571,15 @@ async function runRgInternal(options, resolvedCli) {
     };
   }
 }
-async function runRgCount(options, resolvedCli) {
+async function runRgCount(options, resolvedCli, processSpawner = spawn2) {
   await rgSemaphore.acquire();
   try {
-    return await runRgCountInternal(options, resolvedCli);
+    return await runRgCountInternal(options, resolvedCli, processSpawner);
   } finally {
     rgSemaphore.release();
   }
 }
-async function runRgCountInternal(options, resolvedCli) {
+async function runRgCountInternal(options, resolvedCli, processSpawner = spawn2) {
   const cli = resolvedCli ?? resolveGrepCli();
   const args = buildArgs({ ...options, context: 0 }, cli.backend);
   if (cli.backend === "rg") {
@@ -100369,19 +100590,15 @@ async function runRgCountInternal(options, resolvedCli) {
   const paths = options.paths?.length ? options.paths : ["."];
   args.push(...paths);
   const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS2, DEFAULT_TIMEOUT_MS2);
-  const proc = spawn2([cli.path, ...args], {
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const timeoutPromise = new Promise((_, reject) => {
-    const id = setTimeout(() => {
-      proc.kill();
-      reject(new Error(`Search timeout after ${timeout}ms`));
-    }, timeout);
-    proc.exited.then(() => clearTimeout(id));
-  });
   try {
-    const stdout = await Promise.race([new Response(proc.stdout).text(), timeoutPromise]);
+    const proc = processSpawner([cli.path, ...args], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const { stdout, stderr, exitCode } = await collectSearchProcessOutput(proc, timeout, `Search timeout after ${timeout}ms`);
+    if (exitCode > 1 && stderr.trim()) {
+      throw new Error(stderr.trim());
+    }
     return parseCountOutput(stdout);
   } catch (e) {
     throw new Error(`Count search failed: ${e instanceof Error ? e.message : String(e)}`);
@@ -100542,12 +100759,12 @@ function buildPowerShellCommand(options) {
   const searchPath = paths[0] || ".";
   const escapedPath = searchPath.replace(/'/g, "''");
   const escapedPattern = options.pattern.replace(/'/g, "''");
-  let psCommand = `Get-ChildItem -Path '${escapedPath}' -File -Recurse -Depth ${maxDepth - 1} -Filter '${escapedPattern}'`;
+  let psCommand = `Get-ChildItem -LiteralPath '${escapedPath}' -File -Recurse -Depth ${maxDepth - 1} -Filter '${escapedPattern}'`;
   if (options.hidden !== false) {
     psCommand += " -Force";
   }
   psCommand += " -ErrorAction SilentlyContinue | Select-Object -ExpandProperty FullName";
-  return ["powershell", "-NoProfile", "-Command", psCommand];
+  return ["powershell.exe", "-NoProfile", "-Command", psCommand];
 }
 async function getFileMtime(filePath) {
   try {
@@ -100557,15 +100774,15 @@ async function getFileMtime(filePath) {
     return 0;
   }
 }
-async function runRgFiles(options, resolvedCli) {
+async function runRgFiles(options, resolvedCli, processSpawner = spawn2) {
   await rgSemaphore.acquire();
   try {
-    return await runRgFilesInternal(options, resolvedCli);
+    return await runRgFilesInternal(options, resolvedCli, processSpawner);
   } finally {
     rgSemaphore.release();
   }
 }
-async function runRgFilesInternal(options, resolvedCli) {
+async function runRgFilesInternal(options, resolvedCli, processSpawner = spawn2) {
   const cli = resolvedCli ?? resolveGrepCli();
   const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS3, DEFAULT_TIMEOUT_MS3);
   const limit = Math.min(options.limit ?? DEFAULT_LIMIT, DEFAULT_LIMIT);
@@ -100587,22 +100804,13 @@ async function runRgFilesInternal(options, resolvedCli) {
     cwd = paths[0] || ".";
     command = [cli.path, ...args];
   }
-  const proc = spawn2(command, {
-    stdout: "pipe",
-    stderr: "pipe",
-    cwd
-  });
-  const timeoutPromise = new Promise((_, reject) => {
-    const id = setTimeout(() => {
-      proc.kill();
-      reject(new Error(`Glob search timeout after ${timeout}ms`));
-    }, timeout);
-    proc.exited.then(() => clearTimeout(id));
-  });
   try {
-    const stdout = await Promise.race([new Response(proc.stdout).text(), timeoutPromise]);
-    const stderr = await new Response(proc.stderr).text();
-    const exitCode = await proc.exited;
+    const proc = processSpawner(command, {
+      stdout: "pipe",
+      stderr: "pipe",
+      cwd
+    });
+    const { stdout, stderr, exitCode } = await collectSearchProcessOutput(proc, timeout, `Glob search timeout after ${timeout}ms`);
     if (exitCode > 1 && stderr.trim()) {
       return {
         files: [],
@@ -102373,7 +102581,7 @@ init_opencode_message_dir();
 init_logger();
 
 // src/tools/background-task/session-messages.ts
-function getErrorMessage5(value) {
+function getErrorMessage6(value) {
   if (Array.isArray(value))
     return null;
   if (value.error === undefined || value.error === null)
@@ -102556,7 +102764,7 @@ async function formatFullSession(task, client, options) {
   } catch (error) {
     return `Error fetching messages: ${error instanceof Error ? error.message : String(error)}`;
   }
-  const errorMessage = getErrorMessage5(messagesResult);
+  const errorMessage = getErrorMessage6(messagesResult);
   if (errorMessage) {
     return `Error fetching messages: ${errorMessage}`;
   }
@@ -102762,7 +102970,7 @@ async function formatTaskResult(task, client) {
   } catch (error) {
     return `Error fetching messages: ${error instanceof Error ? error.message : String(error)}`;
   }
-  const errorMessage = getErrorMessage5(messagesResult);
+  const errorMessage = getErrorMessage6(messagesResult);
   if (errorMessage) {
     return `Error fetching messages: ${errorMessage}`;
   }
@@ -104640,10 +104848,10 @@ async function waitForLookAtSessionResult(client, sessionID, options) {
     const isActive = supportedButNeverSeen || statusType !== null && !isTerminal;
     const { messages, error: messagesError } = await getSessionMessages(client, sessionID);
     const outcome = extractLatestAssistantOutcome(messages);
-    if (outcome.text && !isActive) {
+    if (outcome.text && (!isActive || supportedButNeverSeen)) {
       return { messages, outcome, statusType };
     }
-    if (outcome.errorName && !isActive) {
+    if (outcome.errorName && (!isActive || supportedButNeverSeen)) {
       return { messages, outcome, statusType };
     }
     if (isActive) {
@@ -104719,7 +104927,7 @@ Original error: ${createResult.error}`;
   const sessionID = createResult.data.id;
   log(`[look_at] Created session: ${sessionID}`);
   log(`[look_at] Sending prompt with ${isBase64Input ? "base64 image" : "file"} to session ${sessionID}`);
-  let promptFailed = false;
+  let shouldWaitForStatus = true;
   try {
     await promptSyncWithModelSuggestionRetry(ctx.client, {
       path: { id: sessionID },
@@ -104742,15 +104950,14 @@ Original error: ${createResult.error}`;
       queueBehavior: "defer"
     });
   } catch (promptError) {
-    promptFailed = true;
-    log("[look_at] Prompt error (ignored, will still fetch messages):", promptError);
+    log("[look_at] Prompt dispatch failed; checking child session evidence:", promptError);
+    shouldWaitForStatus = isAmbiguousPromptDispatchFailure(promptError);
   }
   let observedMessages;
   let observedText;
-  if (typeof ctx.client.session.status === "function") {
+  if (shouldWaitForStatus && typeof ctx.client.session.status === "function") {
     const waitResult = await waitForLookAtSessionResult(ctx.client, sessionID, {
-      allowStableIdleWithoutActivity: true,
-      allowEmptyStableIdleWithoutActivity: promptFailed
+      allowStableIdleWithoutActivity: true
     });
     observedText = waitResult.outcome.text ?? undefined;
     if (observedText) {
@@ -106157,6 +106364,9 @@ async function executeBackgroundTask(args, ctx, executorCtx, parentContext, agen
 
 Task ID: ${task.id}`;
     }
+    if (!sessionId && updatedTask?.sessionId) {
+      sessionId = updatedTask.sessionId;
+    }
     if (sessionId) {
       registerBackgroundSessionContext({
         sessionId,
@@ -110502,6 +110712,42 @@ function detectRepetitiveToolUse(window) {
 
 // src/features/background-agent/parent-wake-notifier.ts
 init_shared();
+
+// src/features/background-agent/parent-wake-dedupe.ts
+function resolveParentWakePromptContext(promptContext) {
+  const resolvedAgent = resolveRegisteredAgentName(promptContext.agent);
+  return {
+    ...promptContext,
+    ...resolvedAgent ? { agent: resolvedAgent } : {},
+    ...promptContext.model ? { model: { ...promptContext.model } } : {},
+    ...promptContext.tools ? { tools: { ...promptContext.tools } } : {}
+  };
+}
+function cloneParentWake(wake) {
+  const promptContext = resolveParentWakePromptContext(wake.promptContext);
+  return {
+    promptContext,
+    notifications: [...wake.notifications],
+    shouldReply: wake.shouldReply,
+    ...wake.dispatchedAt !== undefined ? { dispatchedAt: wake.dispatchedAt } : {},
+    ...wake.toolCallDeferralStartedAt !== undefined ? { toolCallDeferralStartedAt: wake.toolCallDeferralStartedAt } : {}
+  };
+}
+function isRedundantParentWake(latestWake, dispatchedWake) {
+  return parentWakePromptContextMatches(latestWake, dispatchedWake) && parentWakeReplyModeIsCovered(latestWake, dispatchedWake) && parentWakeNotificationsAreCovered(latestWake, dispatchedWake);
+}
+function parentWakePromptContextMatches(left, right) {
+  return JSON.stringify(left.promptContext) === JSON.stringify(right.promptContext);
+}
+function parentWakeReplyModeIsCovered(latestWake, dispatchedWake) {
+  return !latestWake.shouldReply || dispatchedWake.shouldReply;
+}
+function parentWakeNotificationsAreCovered(latestWake, dispatchedWake) {
+  const dispatchedNotifications = new Set(dispatchedWake.notifications);
+  return latestWake.notifications.every((notification2) => dispatchedNotifications.has(notification2));
+}
+
+// src/features/background-agent/parent-wake-notifier.ts
 function unrefTimerHandle(handle) {
   const maybeUnref = handle.unref;
   if (typeof maybeUnref === "function") {
@@ -110539,7 +110785,7 @@ class ParentWakeNotifier {
     this.recentParentSessionActivity.set(sessionID, Date.now());
   }
   queuePendingParentWake(sessionID, notification2, promptContext, shouldReply, delayMs) {
-    const resolvedPromptContext = this.resolveParentWakePromptContext(promptContext);
+    const resolvedPromptContext = resolveParentWakePromptContext(promptContext);
     const pendingWake = this.pendingParentWakes.get(sessionID);
     if (pendingWake) {
       pendingWake.notifications.push(notification2);
@@ -110592,6 +110838,12 @@ class ParentWakeNotifier {
       });
       return;
     }
+    const dispatchedWake = this.dispatchedParentWakes.get(sessionID);
+    if (dispatchedWake && isRedundantParentWake(latestWake, dispatchedWake)) {
+      this.pendingParentWakes.delete(sessionID);
+      log("[background-agent] Suppressed duplicate parent wake already dispatched:", { sessionID });
+      return;
+    }
     this.pendingParentWakes.delete(sessionID);
     const notificationContent = latestWake.notifications.join(`
 
@@ -110619,9 +110871,9 @@ class ParentWakeNotifier {
       });
       if (promptResult.status === "failed") {
         if (isAmbiguousPostDispatchPromptFailure(promptResult)) {
-          const dispatchedWake = this.cloneParentWake(latestWake);
-          dispatchedWake.dispatchedAt = dispatchStartedAt;
-          if (await this.hasAcceptedMessageAfterDispatchedParentWake(sessionID, dispatchedWake)) {
+          const dispatchedWake2 = cloneParentWake(latestWake);
+          dispatchedWake2.dispatchedAt = dispatchStartedAt;
+          if (await this.hasAcceptedMessageAfterDispatchedParentWake(sessionID, dispatchedWake2)) {
             this.trackDispatchedParentWake(sessionID, latestWake, dispatchStartedAt);
             log("[background-agent] Treated failed parent wake prompt as accepted after observing session history:", {
               sessionID,
@@ -110633,6 +110885,11 @@ class ParentWakeNotifier {
         throw promptResult.error;
       }
       if (promptResult.status === "reserved" && promptResult.reservedBy === "background-agent-parent-wake") {
+        const dispatchedWake2 = this.dispatchedParentWakes.get(sessionID);
+        if (dispatchedWake2 && isRedundantParentWake(latestWake, dispatchedWake2)) {
+          log("[background-agent] Suppressed duplicate parent wake during promptAsync gate hold:", { sessionID });
+          return;
+        }
         this.requeueWake(sessionID, latestWake);
         this.schedulePendingParentWakeFlush(sessionID, 2000);
         log("[background-agent] Requeued parent wake flush reserved by promptAsync gate hold:", { sessionID });
@@ -110738,28 +110995,9 @@ class ParentWakeNotifier {
     this.recentParentSessionActivity.delete(sessionID);
     return false;
   }
-  resolveParentWakePromptContext(promptContext) {
-    const resolvedAgent = resolveRegisteredAgentName(promptContext.agent);
-    return {
-      ...promptContext,
-      ...resolvedAgent ? { agent: resolvedAgent } : {},
-      ...promptContext.model ? { model: { ...promptContext.model } } : {},
-      ...promptContext.tools ? { tools: { ...promptContext.tools } } : {}
-    };
-  }
-  cloneParentWake(wake) {
-    const promptContext = this.resolveParentWakePromptContext(wake.promptContext);
-    return {
-      promptContext,
-      notifications: [...wake.notifications],
-      shouldReply: wake.shouldReply,
-      ...wake.dispatchedAt !== undefined ? { dispatchedAt: wake.dispatchedAt } : {},
-      ...wake.toolCallDeferralStartedAt !== undefined ? { toolCallDeferralStartedAt: wake.toolCallDeferralStartedAt } : {}
-    };
-  }
   trackDispatchedParentWake(sessionID, wake, dispatchedAt) {
     this.clearDispatchedParentWake(sessionID);
-    const dispatchedWake = this.cloneParentWake(wake);
+    const dispatchedWake = cloneParentWake(wake);
     dispatchedWake.dispatchedAt = dispatchedAt;
     this.dispatchedParentWakes.set(sessionID, dispatchedWake);
     const timer = setTimeout(() => {
@@ -110937,7 +111175,7 @@ class ParentWakeNotifier {
       pendingWake.toolCallDeferralStartedAt ??= latestWake.toolCallDeferralStartedAt;
       return;
     }
-    this.pendingParentWakes.set(sessionID, this.cloneParentWake(latestWake));
+    this.pendingParentWakes.set(sessionID, cloneParentWake(latestWake));
   }
 }
 
@@ -110993,9 +111231,13 @@ function describeProcessCleanupError(error) {
   return { raw: String(error) };
 }
 function registerErrorEvent(signal) {
+  let logging = false;
   const listener = (error) => {
-    process.off(signal, listener);
+    if (logging)
+      return;
+    logging = true;
     log(`[background-agent] ${signal} observed; keeping host alive and skipping cleanup (signal handlers run on real shutdown)`, describeProcessCleanupError(error));
+    logging = false;
   };
   process.on(signal, listener);
   return listener;
@@ -132156,13 +132398,16 @@ function maybeCreateAtlasConfig(input) {
     return;
   const orchestratorOverride = agentOverrides["atlas"];
   const atlasRequirement = AGENT_MODEL_REQUIREMENTS["atlas"];
-  const atlasResolution = applyModelResolution({
+  let atlasResolution = applyModelResolution({
     uiSelectedModel: orchestratorOverride?.model !== undefined ? undefined : uiSelectedModel,
     userModel: orchestratorOverride?.model,
     requirement: atlasRequirement,
     availableModels,
     systemDefaultModel
   });
+  if (!atlasResolution && orchestratorOverride?.model) {
+    atlasResolution = { model: orchestratorOverride.model, provenance: "override" };
+  }
   if (!atlasResolution)
     return;
   const { model: atlasModel, variant: atlasResolvedVariant } = atlasResolution;
@@ -135833,6 +136078,14 @@ function supportsImageInput(modelConfig) {
   }
   return modelConfig?.capabilities?.input?.image === true;
 }
+function parseTrustedModel(modelString) {
+  const [providerID, ...modelIDParts] = modelString.split("/");
+  const modelID = modelIDParts.join("/");
+  if (!providerID || modelID.length === 0) {
+    return;
+  }
+  return { providerID, modelID };
+}
 function applyProviderConfig(params) {
   const providers = params.config.provider;
   const modelContextLimitsCache = params.modelCacheState.modelContextLimitsCache;
@@ -135843,22 +136096,31 @@ function applyProviderConfig(params) {
   params.modelCacheState.visionCapableModelsCache = visionCapableModelsCache2;
   visionCapableModelsCache2.clear();
   setVisionCapableModelsCache(visionCapableModelsCache2);
-  if (!providers)
-    return;
-  for (const [providerID, providerConfig] of Object.entries(providers)) {
-    const models = providerConfig?.models;
-    if (!models)
-      continue;
-    for (const [modelID, modelConfig] of Object.entries(models)) {
-      if (supportsImageInput(modelConfig)) {
-        visionCapableModelsCache2.set(`${providerID}/${modelID}`, { providerID, modelID });
-      }
-      const contextLimit = modelConfig?.limit?.context;
-      if (!contextLimit)
+  if (providers) {
+    for (const [providerID, providerConfig] of Object.entries(providers)) {
+      const models = providerConfig?.models;
+      if (!models)
         continue;
-      modelContextLimitsCache.set(`${providerID}/${modelID}`, contextLimit);
+      for (const [modelID, modelConfig] of Object.entries(models)) {
+        if (supportsImageInput(modelConfig)) {
+          visionCapableModelsCache2.set(`${providerID}/${modelID}`, { providerID, modelID });
+        }
+        const contextLimit = modelConfig?.limit?.context;
+        if (!contextLimit)
+          continue;
+        modelContextLimitsCache.set(`${providerID}/${modelID}`, contextLimit);
+      }
     }
   }
+  for (const trustedModelString of params.trustedVisionCapableModels ?? []) {
+    const trustedModel = parseTrustedModel(trustedModelString);
+    if (!trustedModel)
+      continue;
+    const key = `${trustedModel.providerID}/${trustedModel.modelID}`;
+    if (visionCapableModelsCache2.has(key))
+      continue;
+    visionCapableModelsCache2.set(key, trustedModel);
+  }
 }
 
 // src/plugin-handlers/plugin-components-loader.ts
@@ -136020,12 +136282,25 @@ function applyToolConfig(params) {
 }
 
 // src/plugin-handlers/config-handler.ts
+function collectTrustedVisionCapableModels(pluginConfig) {
+  const trusted = [];
+  const multimodalLookerOverride = pluginConfig.agents?.["multimodal-looker"];
+  const configuredModel = multimodalLookerOverride?.model;
+  if (typeof configuredModel === "string" && configuredModel.includes("/")) {
+    trusted.push(configuredModel);
+  }
+  return trusted;
+}
 function createConfigHandler(deps) {
   const { ctx, pluginConfig, modelCacheState } = deps;
   return async (config) => {
     const formatterConfig = config.formatter;
     setAdditionalAllowedMcpEnvVars(pluginConfig.mcp_env_allowlist ?? []);
-    applyProviderConfig({ config, modelCacheState });
+    applyProviderConfig({
+      config,
+      modelCacheState,
+      trustedVisionCapableModels: collectTrustedVisionCapableModels(pluginConfig)
+    });
     clearFormatterCache();
     const pluginComponents = await loadPluginComponents({ pluginConfig });
     applyHookConfig({ pluginComponents, ctx });
@@ -139870,7 +140145,7 @@ function createEventHandler2(args) {
   const recentSyntheticIdles = new Map;
   const recentRealIdles = new Map;
   const recentAnyIdles = new Map;
-  const DEDUP_WINDOW_MS = 500;
+  const DEDUP_WINDOW_MS2 = 500;
   const teamModeConfig = pluginConfig.team_mode?.enabled ? pluginConfig.team_mode : undefined;
   const teamLeadOrphanHandler = teamModeConfig ? createTeamLeadOrphanHandler(teamModeConfig, managers.tmuxSessionManager, managers.backgroundManager) : undefined;
   const teamMemberErrorHandler = teamModeConfig ? createTeamMemberErrorHandler(teamModeConfig, { client: pluginContext.client }) : undefined;
@@ -139896,7 +140171,7 @@ function createEventHandler2(args) {
   };
   const shouldDispatchIdleEvent = (sessionID, now) => {
     const lastDispatchedAt = recentAnyIdles.get(sessionID);
-    if (lastDispatchedAt !== undefined && now - lastDispatchedAt < DEDUP_WINDOW_MS) {
+    if (lastDispatchedAt !== undefined && now - lastDispatchedAt < DEDUP_WINDOW_MS2) {
       return false;
     }
     recentAnyIdles.set(sessionID, now);
@@ -140059,7 +140334,7 @@ function createEventHandler2(args) {
       recentRealIdles,
       recentAnyIdles,
       now: Date.now(),
-      dedupWindowMs: DEDUP_WINDOW_MS
+      dedupWindowMs: DEDUP_WINDOW_MS2
     });
     const syntheticIdle = normalizeSessionStatusToIdle(input);
     if (input.event.type === "session.idle") {
@@ -140067,7 +140342,7 @@ function createEventHandler2(args) {
       if (sessionID) {
         const now = Date.now();
         const emittedAt = recentSyntheticIdles.get(sessionID);
-        if (emittedAt !== undefined && now - emittedAt < DEDUP_WINDOW_MS) {
+        if (emittedAt !== undefined && now - emittedAt < DEDUP_WINDOW_MS2) {
           recentSyntheticIdles.delete(sessionID);
           const lastAnyIdleAt = recentAnyIdles.get(sessionID);
           if (lastAnyIdleAt === emittedAt) {
@@ -140097,7 +140372,7 @@ function createEventHandler2(args) {
       const sessionID = syntheticIdle.event.properties?.sessionID;
       const now = Date.now();
       const emittedAt = recentRealIdles.get(sessionID);
-      if (emittedAt !== undefined && now - emittedAt < DEDUP_WINDOW_MS) {
+      if (emittedAt !== undefined && now - emittedAt < DEDUP_WINDOW_MS2) {
         recentRealIdles.delete(sessionID);
         return;
       }