@wolfx/oh-my-openagent 3.17.13 → 3.17.15

package/dist/index.js

@@ -2770,6 +2770,119 @@ var init_logger = __esm(() => {
   buffer = [];
 });
 
+// src/shared/bun-spawn-shim.ts
+import { spawn as nodeSpawn, spawnSync as nodeSpawnSync } from "child_process";
+import { Readable, Writable } from "stream";
+function emptyReadableStream() {
+  return new ReadableStream({
+    start(controller) {
+      controller.close();
+    }
+  });
+}
+function toReadableStream(stream) {
+  if (!stream)
+    return emptyReadableStream();
+  return Readable.toWeb(stream);
+}
+function emptyWritableStream() {
+  return new Writable({
+    write(_chunk, _encoding, callback) {
+      callback();
+    }
+  });
+}
+function resolveCommand(cmdOrOpts, optsArg) {
+  const isObj = !Array.isArray(cmdOrOpts);
+  const opts = isObj ? cmdOrOpts : optsArg ?? {};
+  return {
+    cmd: isObj ? cmdOrOpts.cmd : cmdOrOpts,
+    opts
+  };
+}
+function resolveStdio(options) {
+  if (options.stdio)
+    return options.stdio;
+  return [options.stdin ?? "ignore", options.stdout ?? "pipe", options.stderr ?? "inherit"];
+}
+function wrapNodeProcess(proc) {
+  let exitCode = null;
+  const exited = new Promise((resolve5, reject) => {
+    proc.on("exit", (code) => {
+      exitCode = code ?? 1;
+      resolve5(exitCode);
+    });
+    proc.on("error", (error) => {
+      if (exitCode === null) {
+        exitCode = 1;
+        reject(error);
+      }
+    });
+  });
+  return {
+    get exitCode() {
+      return exitCode;
+    },
+    exited,
+    stdout: toReadableStream(proc.stdout),
+    stderr: toReadableStream(proc.stderr),
+    stdin: proc.stdin ?? emptyWritableStream(),
+    kill(signal) {
+      if (proc.killed || exitCode !== null)
+        return;
+      try {
+        proc.kill(signal);
+      } catch (error) {
+        if (!String(error).includes("kill"))
+          throw error;
+      }
+    },
+    pid: proc.pid,
+    ref() {
+      proc.ref();
+    },
+    unref() {
+      proc.unref();
+    }
+  };
+}
+function spawn2(cmdOrOpts, opts) {
+  if (IS_BUN)
+    return runtime.Bun.spawn(cmdOrOpts, opts);
+  const { cmd, opts: options } = resolveCommand(cmdOrOpts, opts);
+  const [bin, ...args] = cmd;
+  const proc = nodeSpawn(bin, args, {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: resolveStdio(options),
+    detached: options.detached
+  });
+  return wrapNodeProcess(proc);
+}
+function spawnSync(cmdOrOpts, opts) {
+  if (IS_BUN)
+    return runtime.Bun.spawnSync(cmdOrOpts, opts);
+  const { cmd, opts: options } = resolveCommand(cmdOrOpts, opts);
+  const [bin, ...args] = cmd;
+  const result = nodeSpawnSync(bin, args, {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: resolveStdio(options)
+  });
+  return {
+    exitCode: result.status ?? 1,
+    stdout: result.stdout ?? undefined,
+    stderr: result.stderr ?? undefined,
+    success: (result.status ?? 1) === 0,
+    pid: result.pid ?? -1
+  };
+}
+var runtime, IS_BUN;
+var init_bun_spawn_shim = __esm(() => {
+  runtime = globalThis;
+  IS_BUN = typeof runtime.Bun !== "undefined";
+});
+
 // src/shared/agent-display-names.ts
 function stripInvisibleAgentCharacters(agentName) {
   return agentName.replace(INVISIBLE_AGENT_CHARACTERS_REGEX, "");
@@ -2873,12 +2986,11 @@ __export(exports_tmux_path_resolver, {
   getTmuxPath: () => getTmuxPath,
   getCachedTmuxPath: () => getCachedTmuxPath
 });
-var {spawn: spawn9 } = globalThis.Bun;
 async function findTmuxPath() {
   const isWindows = process.platform === "win32";
   const cmd = isWindows ? "where" : "which";
   try {
-    const proc = spawn9([cmd, "tmux"], {
+    const proc = spawn2([cmd, "tmux"], {
       stdout: "pipe",
       stderr: "pipe"
     });
@@ -2892,7 +3004,7 @@ async function findTmuxPath() {
     if (!path6) {
       return null;
     }
-    const verifyProc = spawn9([path6, "-V"], {
+    const verifyProc = spawn2([path6, "-V"], {
       stdout: "pipe",
       stderr: "pipe"
     });
@@ -2929,15 +3041,18 @@ function startBackgroundCheck() {
   }
 }
 var tmuxPath = null, initPromise = null;
-var init_tmux_path_resolver = () => {};
+var init_tmux_path_resolver = __esm(() => {
+  init_bun_spawn_shim();
+});
 
 // src/shared/tmux/tmux-utils/spawn-process.ts
 var exports_spawn_process = {};
 __export(exports_spawn_process, {
-  spawn: () => spawn11
+  spawn: () => spawn2
+});
+var init_spawn_process = __esm(() => {
+  init_bun_spawn_shim();
 });
-var {spawn: spawn11 } = globalThis.Bun;
-var init_spawn_process = () => {};
 
 // src/shared/tmux/tmux-utils/session-kill.ts
 var exports_session_kill = {};
@@ -2948,7 +3063,7 @@ async function readStream2(stream) {
   return stream ? new Response(stream).text() : "";
 }
 async function killTmuxSessionIfExists(sessionName) {
-  const [{ log: log2 }, { isInsideTmux: isInsideTmux2 }, { getTmuxPath: getTmuxPath2 }, { spawn: spawn15 }] = await Promise.all([
+  const [{ log: log2 }, { isInsideTmux: isInsideTmux2 }, { getTmuxPath: getTmuxPath2 }, { spawn: spawn3 }] = await Promise.all([
     Promise.resolve().then(() => (init_logger(), exports_logger)),
     Promise.resolve().then(() => exports_environment),
     Promise.resolve().then(() => (init_tmux_path_resolver(), exports_tmux_path_resolver)),
@@ -2963,7 +3078,7 @@ async function killTmuxSessionIfExists(sessionName) {
     log2("[killTmuxSessionIfExists] SKIP: tmux not found", { sessionName });
     return false;
   }
-  const hasSessionProcess = spawn15([tmux, "has-session", "-t", sessionName], {
+  const hasSessionProcess = spawn3([tmux, "has-session", "-t", sessionName], {
     stdout: "ignore",
     stderr: "ignore"
   });
@@ -2971,7 +3086,7 @@ async function killTmuxSessionIfExists(sessionName) {
     log2("[killTmuxSessionIfExists] SKIP: session not found", { sessionName });
     return false;
   }
-  const killSessionProcess = spawn15([tmux, "kill-session", "-t", sessionName], {
+  const killSessionProcess = spawn3([tmux, "kill-session", "-t", sessionName], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -15517,10 +15632,10 @@ var require_resolveCommand = __commonJS((exports, module) => {
     }
     return resolved;
   }
-  function resolveCommand(parsed) {
+  function resolveCommand2(parsed) {
     return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
   }
-  module.exports = resolveCommand;
+  module.exports = resolveCommand2;
 });
 
 // node_modules/cross-spawn/lib/util/escape.js
@@ -15588,19 +15703,19 @@ var require_readShebang = __commonJS((exports, module) => {
 // node_modules/cross-spawn/lib/parse.js
 var require_parse2 = __commonJS((exports, module) => {
   var path15 = __require("path");
-  var resolveCommand = require_resolveCommand();
+  var resolveCommand2 = require_resolveCommand();
   var escape2 = require_escape();
   var readShebang = require_readShebang();
   var isWin = process.platform === "win32";
   var isExecutableRegExp = /\.(?:com|exe)$/i;
   var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
   function detectShebang(parsed) {
-    parsed.file = resolveCommand(parsed);
+    parsed.file = resolveCommand2(parsed);
     const shebang = parsed.file && readShebang(parsed.file);
     if (shebang) {
       parsed.args.unshift(parsed.file);
       parsed.command = shebang;
-      return resolveCommand(parsed);
+      return resolveCommand2(parsed);
     }
     return parsed.file;
   }
@@ -15696,21 +15811,21 @@ var require_cross_spawn = __commonJS((exports, module) => {
   var cp = __require("child_process");
   var parse11 = require_parse2();
   var enoent = require_enoent();
-  function spawn21(command, args, options) {
+  function spawn4(command, args, options) {
     const parsed = parse11(command, args, options);
     const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
     enoent.hookChildProcess(spawned, parsed);
     return spawned;
   }
-  function spawnSync5(command, args, options) {
+  function spawnSync3(command, args, options) {
     const parsed = parse11(command, args, options);
     const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
     result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
     return result;
   }
-  module.exports = spawn21;
-  module.exports.spawn = spawn21;
-  module.exports.sync = spawnSync5;
+  module.exports = spawn4;
+  module.exports.spawn = spawn4;
+  module.exports.sync = spawnSync3;
   module.exports._parse = parse11;
   module.exports._enoent = enoent;
 });
@@ -18576,7 +18691,7 @@ Both ${PLUGIN_NAME} and ${pluginName} scan ~/.config/opencode/skills/ and regist
    3. Or uninstall ${PLUGIN_NAME} if you prefer ${pluginName}'s skill management`;
 }
 // src/shared/zip-extractor.ts
-var {spawn: spawn7, spawnSync: spawnSync3 } = globalThis.Bun;
+init_bun_spawn_shim();
 import { release } from "os";
 
 // src/shared/archive-entry-validator.ts
@@ -18635,7 +18750,7 @@ function validateArchiveEntries(entries, destDir) {
 }
 
 // src/shared/zip-entry-listing/python-zip-entry-listing.ts
-var {spawn: spawn2, spawnSync } = globalThis.Bun;
+init_bun_spawn_shim();
 function isPythonZipListingAvailable() {
   const proc = spawnSync(["python3", "--version"], {
     stdout: "ignore",
@@ -18681,7 +18796,7 @@ async function listZipEntriesWithPython(archivePath) {
   return JSON.parse(stdout);
 }
 // src/shared/zip-entry-listing/powershell-zip-entry-listing.ts
-var {spawn: spawn3 } = globalThis.Bun;
+init_bun_spawn_shim();
 function isPowerShellZipEntryRecord(value) {
   if (!value || typeof value !== "object") {
     return false;
@@ -18707,7 +18822,7 @@ function parsePowerShellZipEntryLine(line) {
   };
 }
 async function listZipEntriesWithPowerShell(archivePath, escapePowerShellPath, extractor) {
-  const proc = spawn3([
+  const proc = spawn2([
     extractor,
     "-Command",
     [
@@ -18746,8 +18861,8 @@ async function listZipEntriesWithPowerShell(archivePath, escapePowerShellPath, e
   return stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => parsePowerShellZipEntryLine(line)).filter((entry) => entry !== null);
 }
 // src/shared/zip-entry-listing/tar-zip-entry-listing.ts
+init_bun_spawn_shim();
 init_logger();
-var {spawn: spawn4 } = globalThis.Bun;
 function parseTarListedZipEntry(line) {
   const match = line.match(/^([^\s])\S*\s+\d+\s+\S+\s+\S+\s+\d+\s+\w+\s+\d+\s+(?:\d{2}:\d{2}|\d{4})\s+(.*)$/);
   if (!match) {
@@ -18793,7 +18908,7 @@ function parseTarListingOutput(stdout) {
   return parsedEntries;
 }
 async function listZipEntriesWithTar(archivePath) {
-  const proc = spawn4(["tar", "-tvf", archivePath], {
+  const proc = spawn2(["tar", "-tvf", archivePath], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -18808,12 +18923,12 @@ async function listZipEntriesWithTar(archivePath) {
   return parseTarListingOutput(stdout);
 }
 // src/shared/zip-entry-listing/zipinfo-zip-entry-listing.ts
-var {spawn: spawn6, spawnSync: spawnSync2 } = globalThis.Bun;
+init_bun_spawn_shim();
 
 // src/shared/zip-entry-listing/read-zip-symlink-target.ts
-var {spawn: spawn5 } = globalThis.Bun;
+init_bun_spawn_shim();
 async function readZipSymlinkTarget(archivePath, entryPath) {
-  const proc = spawn5(["unzip", "-p", archivePath, "--", entryPath], {
+  const proc = spawn2(["unzip", "-p", archivePath, "--", entryPath], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -18841,7 +18956,7 @@ function parseZipInfoListedEntry(line) {
   };
 }
 function isZipInfoZipListingAvailable() {
-  const proc = spawnSync2(["which", "zipinfo"], {
+  const proc = spawnSync(["which", "zipinfo"], {
     stdout: "ignore",
     stderr: "ignore"
   });
@@ -18854,7 +18969,7 @@ async function listZipEntriesWithZipInfo(archivePath) {
   if (!isZipInfoZipListingAvailable()) {
     throw new Error("zip entry listing requires zipinfo, but zipinfo is not installed");
   }
-  const proc = spawn6(["zipinfo", "-l", archivePath], {
+  const proc = spawn2(["zipinfo", "-l", archivePath], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -18893,7 +19008,7 @@ function getWindowsBuildNumber() {
 function isPwshAvailable() {
   if (process.platform !== "win32")
     return false;
-  const result = spawnSync3(["where", "pwsh"], { stdout: "pipe", stderr: "pipe" });
+  const result = spawnSync(["where", "pwsh"], { stdout: "pipe", stderr: "pipe" });
   return result.exitCode === 0;
 }
 function escapePowerShellPath(path5) {
@@ -18917,27 +19032,27 @@ async function extractZip(archivePath, destDir) {
     const extractor = getWindowsZipExtractor();
     switch (extractor) {
       case "tar":
-        proc = spawn7(["tar", "-xf", archivePath, "-C", destDir], {
+        proc = spawn2(["tar", "-xf", archivePath, "-C", destDir], {
           stdout: "ignore",
           stderr: "pipe"
         });
         break;
       case "pwsh":
-        proc = spawn7(["pwsh", "-Command", `Expand-Archive -Path '${escapePowerShellPath(archivePath)}' -DestinationPath '${escapePowerShellPath(destDir)}' -Force`], {
+        proc = spawn2(["pwsh", "-Command", `Expand-Archive -Path '${escapePowerShellPath(archivePath)}' -DestinationPath '${escapePowerShellPath(destDir)}' -Force`], {
           stdout: "ignore",
           stderr: "pipe"
         });
         break;
       case "powershell":
       default:
-        proc = spawn7(["powershell", "-Command", `Expand-Archive -Path '${escapePowerShellPath(archivePath)}' -DestinationPath '${escapePowerShellPath(destDir)}' -Force`], {
+        proc = spawn2(["powershell", "-Command", `Expand-Archive -Path '${escapePowerShellPath(archivePath)}' -DestinationPath '${escapePowerShellPath(destDir)}' -Force`], {
           stdout: "ignore",
           stderr: "pipe"
         });
         break;
     }
   } else {
-    proc = spawn7(["unzip", "-o", archivePath, "-d", destDir], {
+    proc = spawn2(["unzip", "-o", archivePath, "-d", destDir], {
       stdout: "ignore",
       stderr: "pipe"
     });
@@ -18965,9 +19080,9 @@ async function listZipEntries(archivePath) {
   throw new Error("zip entry listing requires either python3 or zipinfo to inspect the archive safely");
 }
 // src/shared/binary-downloader.ts
+init_bun_spawn_shim();
 import { chmodSync, existsSync as existsSync9, mkdirSync as mkdirSync3, unlinkSync as unlinkSync2 } from "fs";
 import * as path5 from "path";
-var {spawn: spawn8 } = globalThis.Bun;
 function isTarTraversalErrorOutput(output) {
   return /path contains '\.\.'|member name contains '\.\.'|removing leading [`'\"]?\.\.\//i.test(output);
 }
@@ -18992,7 +19107,7 @@ async function extractTarGz(archivePath, destDir, options) {
   const entries = await listTarEntries(archivePath, options?.cwd);
   validateArchiveEntries(entries, destDir);
   const args = options?.args ?? ["tar", "-xzf", archivePath, "-C", destDir];
-  const proc = spawn8(args, {
+  const proc = spawn2(args, {
     cwd: options?.cwd,
     stdout: "pipe",
     stderr: "pipe"
@@ -19042,7 +19157,7 @@ function parseTarEntry(line) {
   };
 }
 async function listTarEntries(archivePath, cwd) {
-  const proc = spawn8(["tar", "-tvzf", archivePath], {
+  const proc = spawn2(["tar", "-tvzf", archivePath], {
     cwd,
     stdout: "pipe",
     stderr: "pipe"
@@ -19612,6 +19727,7 @@ function toLogLabel(cacheLabel) {
 }
 function createJsonFileCacheStore(options) {
   let memoryValue;
+  let writtenInCurrentProcess = false;
   function getCacheFilePath() {
     return join10(options.getCacheDir(), options.filename);
   }
@@ -19646,6 +19762,12 @@ function createJsonFileCacheStore(options) {
     }
   }
   function has() {
+    if (memoryValue !== undefined && memoryValue !== null) {
+      return true;
+    }
+    if (writtenInCurrentProcess) {
+      return true;
+    }
     return existsSync10(getCacheFilePath());
   }
   function write(value) {
@@ -19654,6 +19776,7 @@ function createJsonFileCacheStore(options) {
     try {
       writeFileSync2(cacheFile, options.serialize?.(value) ?? JSON.stringify(value, null, 2));
       memoryValue = value;
+      writtenInCurrentProcess = true;
       log(`[${options.logPrefix}] ${options.cacheLabel} written`, options.describe(value));
     } catch (error) {
       log(`[${options.logPrefix}] Error writing ${toLogLabel(options.cacheLabel)}`, {
@@ -19663,6 +19786,7 @@ function createJsonFileCacheStore(options) {
   }
   function resetMemory() {
     memoryValue = undefined;
+    writtenInCurrentProcess = false;
   }
   return {
     read,
@@ -19673,6 +19797,7 @@ function createJsonFileCacheStore(options) {
 }
 
 // src/shared/connected-providers-cache.ts
+var providerModelsCacheWrittenInCurrentProcess = false;
 var CONNECTED_PROVIDERS_CACHE_FILE = "connected-providers.json";
 var PROVIDER_MODELS_CACHE_FILE = "provider-models.json";
 function isRecord(value) {
@@ -19712,6 +19837,9 @@ function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDi
     return providerModelsCacheStore.read();
   }
   function hasProviderModelsCache() {
+    if (providerModelsCacheWrittenInCurrentProcess) {
+      return true;
+    }
     return providerModelsCacheStore.has();
   }
   function writeProviderModelsCache(data) {
@@ -19719,6 +19847,7 @@ function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDi
       ...data,
       updatedAt: new Date().toISOString()
     });
+    providerModelsCacheWrittenInCurrentProcess = true;
   }
   async function updateConnectedProvidersCache(client) {
     if (!client?.provider?.list) {
@@ -19767,6 +19896,7 @@ function createConnectedProvidersCacheStore(getCacheDir2 = getOmoOpenCodeCacheDi
   function _resetMemCacheForTesting() {
     connectedProvidersCacheStore.resetMemory();
     providerModelsCacheStore.resetMemory();
+    providerModelsCacheWrittenInCurrentProcess = false;
   }
   return {
     readConnectedProvidersCache,
@@ -63825,10 +63955,11 @@ async function isServerRunning(serverUrl) {
   return false;
 }
 // src/shared/tmux/tmux-utils/pane-dimensions.ts
+init_bun_spawn_shim();
 init_tmux_path_resolver();
 // src/shared/tmux/tmux-utils/pane-spawn.ts
+init_bun_spawn_shim();
 init_tmux_path_resolver();
-var {spawn: spawn10 } = globalThis.Bun;
 async function spawnTmuxPane(sessionId, description, config, serverUrl, targetPaneId, splitDirection = "-h") {
   const { log: log2 } = await Promise.resolve().then(() => (init_logger(), exports_logger));
   log2("[spawnTmuxPane] called", {
@@ -63871,7 +64002,7 @@ async function spawnTmuxPane(sessionId, description, config, serverUrl, targetPa
     ...targetPaneId ? ["-t", targetPaneId] : [],
     opencodeCmd
   ];
-  const proc = spawn10([tmux, ...args], { stdout: "pipe", stderr: "pipe" });
+  const proc = spawn2([tmux, ...args], { stdout: "pipe", stderr: "pipe" });
   const exitCode = await proc.exited;
   const stdout = await new Response(proc.stdout).text();
   const paneId = stdout.trim();
@@ -63879,7 +64010,7 @@ async function spawnTmuxPane(sessionId, description, config, serverUrl, targetPa
     return { success: false };
   }
   const title = `omo-subagent-${description.slice(0, 20)}`;
-  const titleProc = spawn10([tmux, "select-pane", "-t", paneId, "-T", title], {
+  const titleProc = spawn2([tmux, "select-pane", "-t", paneId, "-T", title], {
     stdout: "ignore",
     stderr: "pipe"
   });
@@ -63904,7 +64035,7 @@ async function readStream(stream) {
   return stream ? new Response(stream).text() : "";
 }
 async function closeTmuxPane(paneId) {
-  const [{ log: log2 }, { isInsideTmux: isInsideTmux2 }, { getTmuxPath: getTmuxPath2 }, { spawn: spawn12 }] = await Promise.all([
+  const [{ log: log2 }, { isInsideTmux: isInsideTmux2 }, { getTmuxPath: getTmuxPath2 }, { spawn: spawn3 }] = await Promise.all([
     Promise.resolve().then(() => (init_logger(), exports_logger)),
     Promise.resolve().then(() => exports_environment),
     Promise.resolve().then(() => (init_tmux_path_resolver(), exports_tmux_path_resolver)),
@@ -63920,14 +64051,14 @@ async function closeTmuxPane(paneId) {
     return false;
   }
   log2("[closeTmuxPane] sending Ctrl+C for graceful shutdown", { paneId });
-  const ctrlCProc = spawn12([tmux, "send-keys", "-t", paneId, "C-c"], {
+  const ctrlCProc = spawn3([tmux, "send-keys", "-t", paneId, "C-c"], {
     stdout: "ignore",
     stderr: "ignore"
   });
   await ctrlCProc.exited;
   await delay2(250);
   log2("[closeTmuxPane] killing pane", { paneId });
-  const killPaneProc = spawn12([tmux, "kill-pane", "-t", paneId], {
+  const killPaneProc = spawn3([tmux, "kill-pane", "-t", paneId], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -63950,8 +64081,8 @@ async function closeTmuxPane(paneId) {
   return true;
 }
 // src/shared/tmux/tmux-utils/pane-replace.ts
+init_bun_spawn_shim();
 init_tmux_path_resolver();
-var {spawn: spawn12 } = globalThis.Bun;
 async function replaceTmuxPane(paneId, sessionId, description, config, serverUrl) {
   const { log: log2 } = await Promise.resolve().then(() => (init_logger(), exports_logger));
   log2("[replaceTmuxPane] called", { paneId, sessionId, description });
@@ -63966,7 +64097,7 @@ async function replaceTmuxPane(paneId, sessionId, description, config, serverUrl
     return { success: false };
   }
   log2("[replaceTmuxPane] sending Ctrl+C for graceful shutdown", { paneId });
-  const ctrlCProc = spawn12([tmux, "send-keys", "-t", paneId, "C-c"], {
+  const ctrlCProc = spawn2([tmux, "send-keys", "-t", paneId, "C-c"], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -63974,7 +64105,7 @@ async function replaceTmuxPane(paneId, sessionId, description, config, serverUrl
   const shell = process.env.SHELL || "/bin/sh";
   const escapedUrl = shellEscapeForDoubleQuotedCommand(serverUrl);
   const opencodeCmd = `${shell} -c "opencode attach ${escapedUrl} --session ${sessionId}"`;
-  const proc = spawn12([tmux, "respawn-pane", "-k", "-t", paneId, opencodeCmd], {
+  const proc = spawn2([tmux, "respawn-pane", "-k", "-t", paneId, opencodeCmd], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -63985,7 +64116,7 @@ async function replaceTmuxPane(paneId, sessionId, description, config, serverUrl
     return { success: false };
   }
   const title = `omo-subagent-${description.slice(0, 20)}`;
-  const titleProc = spawn12([tmux, "select-pane", "-t", paneId, "-T", title], {
+  const titleProc = spawn2([tmux, "select-pane", "-t", paneId, "-T", title], {
     stdout: "ignore",
     stderr: "pipe"
   });
@@ -64004,8 +64135,8 @@ async function replaceTmuxPane(paneId, sessionId, description, config, serverUrl
   return { success: true, paneId };
 }
 // src/shared/tmux/tmux-utils/window-spawn.ts
+init_bun_spawn_shim();
 init_tmux_path_resolver();
-var {spawn: spawn13 } = globalThis.Bun;
 var ISOLATED_WINDOW_NAME = "omo-agents";
 async function spawnTmuxWindow(sessionId, description, config, serverUrl) {
   const { log: log2 } = await Promise.resolve().then(() => (init_logger(), exports_logger));
@@ -64048,7 +64179,7 @@ async function spawnTmuxWindow(sessionId, description, config, serverUrl) {
     "#{pane_id}",
     opencodeCmd
   ];
-  const proc = spawn13([tmux, ...args], { stdout: "pipe", stderr: "pipe" });
+  const proc = spawn2([tmux, ...args], { stdout: "pipe", stderr: "pipe" });
   const exitCode = await proc.exited;
   const stdout = await new Response(proc.stdout).text();
   const paneId = stdout.trim();
@@ -64058,7 +64189,7 @@ async function spawnTmuxWindow(sessionId, description, config, serverUrl) {
     return { success: false };
   }
   const title = `omo-subagent-${description.slice(0, 20)}`;
-  const titleProc = spawn13([tmux, "select-pane", "-t", paneId, "-T", title], {
+  const titleProc = spawn2([tmux, "select-pane", "-t", paneId, "-T", title], {
     stdout: "ignore",
     stderr: "pipe"
   });
@@ -64077,14 +64208,14 @@ async function spawnTmuxWindow(sessionId, description, config, serverUrl) {
   return { success: true, paneId };
 }
 // src/shared/tmux/tmux-utils/session-spawn.ts
+init_bun_spawn_shim();
 init_tmux_path_resolver();
-var {spawn: spawn14 } = globalThis.Bun;
 var ISOLATED_SESSION_NAME_PREFIX = "omo-agents";
 function getIsolatedSessionName(pid = process.pid) {
   return `${ISOLATED_SESSION_NAME_PREFIX}-${pid}`;
 }
 async function getWindowDimensions(tmux, sourcePaneId) {
-  const proc = spawn14([tmux, "display", "-p", "-t", sourcePaneId, "#{window_width},#{window_height}"], { stdout: "pipe", stderr: "pipe" });
+  const proc = spawn2([tmux, "display", "-p", "-t", sourcePaneId, "#{window_width},#{window_height}"], { stdout: "pipe", stderr: "pipe" });
   const exitCode = await proc.exited;
   const stdout = await new Response(proc.stdout).text();
   if (exitCode !== 0)
@@ -64095,7 +64226,7 @@ async function getWindowDimensions(tmux, sourcePaneId) {
   return { width, height };
 }
 async function sessionExists(tmux, sessionName) {
-  const proc = spawn14([tmux, "has-session", "-t", sessionName], {
+  const proc = spawn2([tmux, "has-session", "-t", sessionName], {
     stdout: "ignore",
     stderr: "ignore"
   });
@@ -64164,7 +64295,7 @@ async function spawnTmuxSession(sessionId, description, config, serverUrl, sourc
     mode: sessionAlreadyExists ? "new-window" : "new-session",
     sessionName: isolatedSessionName
   });
-  const proc = spawn14([tmux, ...args], { stdout: "pipe", stderr: "pipe" });
+  const proc = spawn2([tmux, ...args], { stdout: "pipe", stderr: "pipe" });
   const exitCode = await proc.exited;
   const stdout = await new Response(proc.stdout).text();
   const paneId = stdout.trim();
@@ -64174,7 +64305,7 @@ async function spawnTmuxSession(sessionId, description, config, serverUrl, sourc
     return { success: false };
   }
   const title = `omo-subagent-${description.slice(0, 20)}`;
-  const titleProc = spawn14([tmux, "select-pane", "-t", paneId, "-T", title], {
+  const titleProc = spawn2([tmux, "select-pane", "-t", paneId, "-T", title], {
     stdout: "ignore",
     stderr: "pipe"
   });
@@ -64204,8 +64335,8 @@ function isProcessAlive(pid) {
   }
 }
 async function listOmoAgentSessionsViaTmux(tmux) {
-  const { spawn: spawn15 } = await Promise.resolve().then(() => (init_spawn_process(), exports_spawn_process));
-  const proc = spawn15([tmux, "list-sessions", "-F", "#{session_name}"], {
+  const { spawn: spawn3 } = await Promise.resolve().then(() => (init_spawn_process(), exports_spawn_process));
+  const proc = spawn3([tmux, "list-sessions", "-F", "#{session_name}"], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -64271,8 +64402,8 @@ async function sweepStaleOmoAgentSessions() {
   return sweepStaleOmoAgentSessionsWith(deps);
 }
 // src/shared/tmux/tmux-utils/layout.ts
+init_bun_spawn_shim();
 init_tmux_path_resolver();
-var {spawn: spawn15 } = globalThis.Bun;
 function clamp(value, min, max) {
   return Math.max(min, Math.min(max, value));
 }
@@ -64286,7 +64417,7 @@ function calculateMainPaneWidth(windowWidth, options) {
   return clamp(Math.max(desiredMainPaneWidth, minMainPaneWidth), 0, maxMainPaneWidth);
 }
 async function applyLayout(tmux, layout, mainPaneSize, deps) {
-  const spawnCommand = deps?.spawnCommand ?? spawn15;
+  const spawnCommand = deps?.spawnCommand ?? spawn2;
   const layoutProc = spawnCommand([tmux, "select-layout", layout], {
     stdout: "ignore",
     stderr: "ignore"
@@ -64305,7 +64436,7 @@ async function enforceMainPaneWidth(mainPaneId, windowWidth, mainPaneSizeOrOptio
     return;
   const options = typeof mainPaneSizeOrOptions === "number" ? { mainPaneSize: mainPaneSizeOrOptions } : mainPaneSizeOrOptions ?? {};
   const mainWidth = calculateMainPaneWidth(windowWidth, options);
-  const proc = spawn15([tmux, "resize-pane", "-t", mainPaneId, "-x", String(mainWidth)], {
+  const proc = spawn2([tmux, "resize-pane", "-t", mainPaneId, "-x", String(mainWidth)], {
     stdout: "ignore",
     stderr: "ignore"
   });
@@ -66659,7 +66790,7 @@ async function injectContinuation(args) {
     log(`[${HOOK_NAME}] Skipped injection: continuation stopped for session`, { sessionID });
     return;
   }
-  const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((task) => task.status === "running") : false;
+  const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((task) => task.status === "running" || task.status === "pending") : false;
   if (hasRunningBgTasks) {
     log(`[${HOOK_NAME}] Skipped injection: background tasks running`, { sessionID });
     return;
@@ -66865,7 +66996,7 @@ async function handleSessionIdle(args) {
     }
     state2.abortDetectedAt = undefined;
   }
-  const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((task) => task.status === "running") : false;
+  const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((task) => task.status === "running" || task.status === "pending") : false;
   if (hasRunningBgTasks) {
     log(`[${HOOK_NAME}] Skipped: background tasks running`, { sessionID });
     return;
@@ -67655,6 +67786,14 @@ function getDefaultSoundPath(platform2) {
       return "";
   }
 }
+async function runQuietNothrow(command) {
+  const safeCommand = typeof command.nothrow === "function" ? command.nothrow() : command;
+  if (typeof safeCommand.quiet === "function") {
+    await safeCommand.quiet();
+    return;
+  }
+  await safeCommand;
+}
 async function sendSessionNotification(ctx, platform2, title, message) {
   switch (platform2) {
     case "darwin": {
@@ -67682,14 +67821,14 @@ async function sendSessionNotification(ctx, platform2, title, message) {
         return;
       const escapedTitle = escapeAppleScriptText(title);
       const escapedMessage = escapeAppleScriptText(message);
-      await ctx.$`${osascriptPath} -e ${'display notification "' + escapedMessage + '" with title "' + escapedTitle + '"'}`.nothrow().quiet();
+      await runQuietNothrow(ctx.$`${osascriptPath} -e ${'display notification "' + escapedMessage + '" with title "' + escapedTitle + '"'}`);
       break;
     }
     case "linux": {
       const notifySendPath = await getNotifySendPath();
       if (!notifySendPath)
         return;
-      await ctx.$`${notifySendPath} ${title} ${message} 2>/dev/null`.nothrow().quiet();
+      await runQuietNothrow(ctx.$`${notifySendPath} ${title} ${message} 2>/dev/null`);
       break;
     }
     case "win32": {
@@ -67697,7 +67836,7 @@ async function sendSessionNotification(ctx, platform2, title, message) {
       if (!powershellPath)
         return;
       const toastScript = buildWindowsToastScript(title, message);
-      await ctx.$`${powershellPath} -Command ${toastScript}`.nothrow().quiet();
+      await runQuietNothrow(ctx.$`${powershellPath} -Command ${toastScript}`);
       break;
     }
   }
@@ -67708,17 +67847,17 @@ async function playSessionNotificationSound(ctx, platform2, soundPath) {
       const afplayPath = await getAfplayPath();
       if (!afplayPath)
         return;
-      ctx.$`${afplayPath} ${soundPath}`.nothrow().quiet();
+      await runQuietNothrow(ctx.$`${afplayPath} ${soundPath}`);
       break;
     }
     case "linux": {
       const paplayPath = await getPaplayPath();
       if (paplayPath) {
-        ctx.$`${paplayPath} ${soundPath} 2>/dev/null`.nothrow().quiet();
+        await runQuietNothrow(ctx.$`${paplayPath} ${soundPath} 2>/dev/null`);
       } else {
         const aplayPath = await getAplayPath();
         if (aplayPath) {
-          ctx.$`${aplayPath} ${soundPath} 2>/dev/null`.nothrow().quiet();
+          await runQuietNothrow(ctx.$`${aplayPath} ${soundPath} 2>/dev/null`);
         }
       }
       break;
@@ -67728,7 +67867,7 @@ async function playSessionNotificationSound(ctx, platform2, soundPath) {
       if (!powershellPath)
         return;
       const escaped = escapePowerShellSingleQuotedText(soundPath);
-      ctx.$`${powershellPath} -Command ${"(New-Object Media.SoundPlayer '" + escaped + "').PlaySync()"}`.nothrow().quiet();
+      await runQuietNothrow(ctx.$`${powershellPath} -Command ${"(New-Object Media.SoundPlayer '" + escaped + "').PlaySync()"}`);
       break;
     }
   }
@@ -82640,7 +82779,7 @@ var zod_default = exports_external;
 import { existsSync as existsSync33 } from "fs";
 
 // src/hooks/comment-checker/cli.ts
-var {spawn: spawn16 } = globalThis.Bun;
+init_bun_spawn_shim();
 import { createRequire as createRequire2 } from "module";
 import { dirname as dirname6, join as join34 } from "path";
 import { existsSync as existsSync32 } from "fs";
@@ -82846,7 +82985,7 @@ async function runCommentChecker(input, cliPath, customPrompt) {
     if (customPrompt) {
       args.push("--prompt", customPrompt);
     }
-    const proc = spawn16(args, {
+    const proc = spawn2(args, {
       stdin: "pipe",
       stdout: "pipe",
       stderr: "pipe"
@@ -88153,16 +88292,16 @@ import { join as join57 } from "path";
 init_logger();
 
 // src/shared/spawn-with-windows-hide.ts
-var {spawn: bunSpawn } = globalThis.Bun;
-import { spawn as nodeSpawn } from "child_process";
-import { Readable } from "stream";
-function toReadableStream(stream) {
+init_bun_spawn_shim();
+import { spawn as nodeSpawn2 } from "child_process";
+import { Readable as Readable2 } from "stream";
+function toReadableStream2(stream) {
   if (!stream) {
     return;
   }
-  return Readable.toWeb(stream);
+  return Readable2.toWeb(stream);
 }
-function wrapNodeProcess(proc) {
+function wrapNodeProcess2(proc) {
   let resolveExited;
   let exitCode = null;
   const exited = new Promise((resolve11) => {
@@ -88183,8 +88322,8 @@ function wrapNodeProcess(proc) {
       return exitCode;
     },
     exited,
-    stdout: toReadableStream(proc.stdout),
-    stderr: toReadableStream(proc.stderr),
+    stdout: toReadableStream2(proc.stdout),
+    stderr: toReadableStream2(proc.stderr),
     kill(signal) {
       try {
         if (!signal) {
@@ -88198,17 +88337,17 @@ function wrapNodeProcess(proc) {
 }
 function spawnWithWindowsHide(command, options) {
   if (process.platform !== "win32") {
-    return bunSpawn(command, options);
+    return spawn2(command, options);
   }
   const [cmd, ...args] = command;
-  const proc = nodeSpawn(cmd, args, {
+  const proc = nodeSpawn2(cmd, args, {
     cwd: options.cwd,
     env: options.env,
-    stdio: [options.stdin ?? "pipe", options.stdout ?? "pipe", options.stderr ?? "pipe"],
+    stdio: [options.stdin ?? "ignore", options.stdout ?? "pipe", options.stderr ?? "inherit"],
     windowsHide: true,
     shell: true
   });
-  return wrapNodeProcess(proc);
+  return wrapNodeProcess2(proc);
 }
 
 // src/shared/bun-install.ts
@@ -99494,6 +99633,7 @@ async function resolveRecentPromptContextForSession(ctx, sessionID) {
 }
 
 // src/hooks/atlas/boulder-continuation-injector.ts
+var ACTIVE_BACKGROUND_TASK_STATUSES = new Set(["pending", "running"]);
 async function injectBoulderContinuation(input) {
   const {
     ctx,
@@ -99508,7 +99648,7 @@ async function injectBoulderContinuation(input) {
     backgroundManager,
     sessionState
   } = input;
-  const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((t) => t.status === "running") : false;
+  const hasRunningBgTasks = backgroundManager ? backgroundManager.getTasksByParentSession(sessionID).some((t) => ACTIVE_BACKGROUND_TASK_STATUSES.has(t.status)) : false;
   if (hasRunningBgTasks) {
     log(`[${HOOK_NAME7}] Skipped injection: background tasks running`, { sessionID });
     return "skipped_background_tasks";
@@ -102159,6 +102299,10 @@ function isModelInCooldown(model, state3, cooldownSeconds) {
 function findNextAvailableFallback(state3, fallbackModels, cooldownSeconds) {
   for (let i2 = state3.fallbackIndex + 1;i2 < fallbackModels.length; i2++) {
     const candidate = fallbackModels[i2];
+    if (candidate === state3.currentModel) {
+      log(`[${HOOK_NAME11}] Skipping fallback model (same as current)`, { model: candidate, index: i2 });
+      continue;
+    }
     if (!isModelInCooldown(candidate, state3, cooldownSeconds)) {
       return candidate;
     }
@@ -105385,9 +105529,9 @@ function getLanguageId(ext) {
   return EXT_TO_LANG[ext] || "plaintext";
 }
 // src/tools/lsp/lsp-process.ts
+init_bun_spawn_shim();
 init_logger();
-var {spawn: bunSpawn2 } = globalThis.Bun;
-import { spawn as nodeSpawn2 } from "child_process";
+import { spawn as nodeSpawn3 } from "child_process";
 import { existsSync as existsSync67, statSync as statSync9 } from "fs";
 function shouldUseNodeSpawn() {
   return process.platform === "win32";
@@ -105406,7 +105550,7 @@ function validateCwd(cwd) {
     return { valid: false, error: `Cannot access working directory: ${cwd} (${err instanceof Error ? err.message : String(err)})` };
   }
 }
-function wrapNodeProcess2(proc) {
+function wrapNodeProcess3(proc) {
   let resolveExited;
   let exitCode = null;
   const exitedPromise = new Promise((resolve14) => {
@@ -105507,16 +105651,16 @@ function spawnProcess(command, options) {
   if (shouldUseNodeSpawn()) {
     const [cmd, ...args] = command;
     log("[LSP] Using Node.js child_process on Windows to avoid Bun spawn segfault");
-    const proc2 = nodeSpawn2(cmd, args, {
+    const proc2 = nodeSpawn3(cmd, args, {
       cwd: options.cwd,
       env: options.env,
       stdio: ["pipe", "pipe", "pipe"],
       windowsHide: true,
       shell: true
     });
-    return wrapNodeProcess2(proc2);
+    return wrapNodeProcess3(proc2);
   }
-  const proc = bunSpawn2(command, {
+  const proc = spawn2(command, {
     stdin: "pipe",
     stdout: "pipe",
     stderr: "pipe",
@@ -105535,7 +105679,7 @@ import { pathToFileURL } from "url";
 
 // src/tools/lsp/lsp-client-transport.ts
 var import_node = __toESM(require_main(), 1);
-import { Readable as Readable2, Writable } from "stream";
+import { Readable as Readable3, Writable as Writable2 } from "stream";
 import { delimiter as delimiter2 } from "path";
 init_logger();
 
@@ -105579,7 +105723,7 @@ class LSPClientTransport {
 stderr: ${stderr}` : ""));
     }
     const stdoutReader = this.proc.stdout.getReader();
-    const nodeReadable = new Readable2({
+    const nodeReadable = new Readable3({
       async read() {
         try {
           const { done, value } = await stdoutReader.read();
@@ -105594,7 +105738,7 @@ stderr: ${stderr}` : ""));
       }
     });
     const stdin = this.proc.stdin;
-    const nodeWritable = new Writable({
+    const nodeWritable = new Writable2({
       write(chunk, _encoding, callback) {
         try {
           stdin.write(chunk);
@@ -119368,7 +119512,7 @@ function setSgCliPath(path13) {
   resolvedCliPath2 = path13;
 }
 // src/tools/ast-grep/cli.ts
-var {spawn: spawn17 } = globalThis.Bun;
+init_bun_spawn_shim();
 import { existsSync as existsSync73 } from "fs";
 
 // src/tools/ast-grep/cli-binary-path-resolution.ts
@@ -119502,7 +119646,7 @@ async function runSg(options) {
     }
   }
   const timeout = DEFAULT_TIMEOUT_MS2;
-  const proc = spawn17([cliPath, ...args], {
+  const proc = spawn2([cliPath, ...args], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -119565,7 +119709,7 @@ async function runSg(options) {
   if (shouldSeparateWritePass && jsonResult.matches.length > 0) {
     const writeArgs = args.filter((a) => a !== "--json=compact");
     writeArgs.push("--update-all");
-    const writeProc = spawn17([cliPath, ...writeArgs], {
+    const writeProc = spawn2([cliPath, ...writeArgs], {
       stdout: "pipe",
       stderr: "pipe"
     });
@@ -119734,7 +119878,7 @@ ${hint}`;
 import { resolve as resolve18 } from "path";
 
 // src/shared/ripgrep-cli.ts
-import { spawnSync as spawnSync4 } from "child_process";
+import { spawnSync as spawnSync2 } from "child_process";
 import { existsSync as existsSync75 } from "fs";
 import { dirname as dirname23, join as join82 } from "path";
 
@@ -119844,7 +119988,7 @@ function findExecutable(name) {
   const isWindows2 = process.platform === "win32";
   const cmd = isWindows2 ? "where" : "which";
   try {
-    const result = spawnSync4(cmd, [name], { encoding: "utf-8", timeout: 5000 });
+    const result = spawnSync2(cmd, [name], { encoding: "utf-8", timeout: 5000 });
     if (result.status === 0 && result.stdout.trim()) {
       return result.stdout.trim().split(`
 `)[0];
@@ -119920,7 +120064,7 @@ async function resolveGrepCliWithAutoInstall() {
 }
 
 // src/tools/grep/cli.ts
-var {spawn: spawn18 } = globalThis.Bun;
+init_bun_spawn_shim();
 
 // src/tools/grep/constants.ts
 var DEFAULT_MAX_DEPTH = 20;
@@ -120109,7 +120253,7 @@ async function runRgInternal(options, resolvedCli) {
   }
   const paths = options.paths?.length ? options.paths : ["."];
   args.push(...paths);
-  const proc = spawn18([cli.path, ...args], {
+  const proc = spawn2([cli.path, ...args], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -120173,7 +120317,7 @@ async function runRgCountInternal(options, resolvedCli) {
   const paths = options.paths?.length ? options.paths : ["."];
   args.push(...paths);
   const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS3, DEFAULT_TIMEOUT_MS3);
-  const proc = spawn18([cli.path, ...args], {
+  const proc = spawn2([cli.path, ...args], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -120293,8 +120437,8 @@ function createGrepTools(ctx) {
 import { resolve as resolve20 } from "path";
 
 // src/tools/glob/cli.ts
+init_bun_spawn_shim();
 import { resolve as resolve19 } from "path";
-var {spawn: spawn19 } = globalThis.Bun;
 
 // src/tools/glob/constants.ts
 var DEFAULT_TIMEOUT_MS4 = 60000;
@@ -120390,7 +120534,7 @@ async function runRgFilesInternal(options, resolvedCli) {
     cwd = paths[0] || ".";
     command = [cli.path, ...args];
   }
-  const proc = spawn19(command, {
+  const proc = spawn2(command, {
     stdout: "pipe",
     stderr: "pipe",
     cwd
@@ -122078,7 +122222,8 @@ function createSkillMcpTool(options) {
         serverName: args.mcp_name,
         skillName: found.skill.name,
         sessionID,
-        scope: found.skill.scope
+        scope: found.skill.scope,
+        directory: toolContext.directory
       };
       const context = {
         config: found.config,
@@ -128602,6 +128747,7 @@ function normalizeHashlineEdits(rawEdits) {
 
 // src/tools/hashline-edit/formatter-trigger.ts
 import path14 from "path";
+init_bun_spawn_shim();
 var cachedFormattersByDirectory = new Map;
 function getFormatterCacheKey(directory) {
   return path14.resolve(directory);
@@ -128666,7 +128812,7 @@ async function runFormattersForFile(client2, directory, filePath) {
     const cmd = buildFormatterCommand(formatter.command, filePath);
     try {
       log("[formatter-trigger] Running formatter", { command: cmd, file: filePath });
-      const proc = Bun.spawn(cmd, {
+      const proc = spawn2(cmd, {
         cwd: directory,
         env: { ...process.env, ...formatter.environment },
         stdout: "ignore",
@@ -130091,11 +130237,17 @@ async function tryFallbackRetry(args) {
 }
 
 // src/features/background-agent/process-cleanup.ts
-function scheduleForcedExit(cleanupResult, exitCode) {
+var _scheduleForcedExitEnabled = true;
+function scheduleForcedExit(cleanupResult, exitCode, exitAfterCleanup = false) {
+  if (!_scheduleForcedExitEnabled)
+    return;
   process.exitCode = exitCode;
   const exitTimeout = setTimeout(() => process.exit(), 6000);
   Promise.resolve(cleanupResult).finally(() => {
     clearTimeout(exitTimeout);
+    if (exitAfterCleanup) {
+      process.exit(exitCode);
+    }
   });
 }
 function registerProcessSignal(signal, handler, exitAfter) {
@@ -130110,8 +130262,9 @@ function registerProcessSignal(signal, handler, exitAfter) {
 }
 function registerErrorEvent(signal, handler) {
   const listener = (error92) => {
+    process.off(signal, listener);
     log(`[background-agent] ${signal} received during shutdown cleanup:`, error92);
-    scheduleForcedExit(handler(error92), 1);
+    scheduleForcedExit(handler(error92), 1, true);
   };
   process.on(signal, listener);
   return listener;
@@ -130502,7 +130655,7 @@ async function checkAndInterruptStaleTasks(args) {
     const sessionStatus = sessionStatuses?.[sessionID]?.type;
     const sessionIsRunning = sessionStatus !== undefined && isActiveSessionStatus(sessionStatus);
     const sessionMissing = sessionStatuses !== undefined && sessionStatus === undefined;
-    const runtime = now - startedAt.getTime();
+    const runtime2 = now - startedAt.getTime();
     if (sessionMissing) {
       task.consecutiveMissedPolls = (task.consecutiveMissedPolls ?? 0) + 1;
     } else if (sessionStatuses !== undefined) {
@@ -130515,13 +130668,13 @@ async function checkAndInterruptStaleTasks(args) {
       if (sessionMissing && !sessionGone)
         continue;
       const effectiveTimeout = sessionGone ? sessionGoneTimeoutMs : messageStalenessMs;
-      if (runtime <= effectiveTimeout)
+      if (runtime2 <= effectiveTimeout)
         continue;
       if (sessionGone && await verifySessionExists(client2, sessionID, directory)) {
         task.consecutiveMissedPolls = 0;
         continue;
       }
-      const staleMinutes2 = Math.round(runtime / 60000);
+      const staleMinutes2 = Math.round(runtime2 / 60000);
       const reason2 = sessionGone ? "session gone from status registry" : "no activity";
       task.status = "cancelled";
       task.error = `Stale timeout (${reason2} for ${staleMinutes2}min since start). This is a FINAL cancellation - do NOT create a replacement task. If the timeout is too short, increase 'background_task.${sessionGone ? "sessionGoneTimeoutMs" : "staleTimeoutMs"}' in .opencode/${CONFIG_BASENAME}.json.`;
@@ -130542,7 +130695,7 @@ async function checkAndInterruptStaleTasks(args) {
     }
     if (sessionIsRunning)
       continue;
-    if (runtime < MIN_RUNTIME_BEFORE_STALE_MS)
+    if (runtime2 < MIN_RUNTIME_BEFORE_STALE_MS)
       continue;
     const timeSinceLastUpdate = now - task.progress.lastUpdate.getTime();
     const effectiveStaleTimeout = sessionGone ? sessionGoneTimeoutMs : staleTimeoutMs;
@@ -130950,6 +131103,7 @@ class BackgroundManager {
       }
       spawnReservation.commit();
       this.markPreStartDescendantReservation(task);
+      this.updateBackgroundTaskMarker(input.parentSessionId);
       this.processKey(key);
       return { ...task };
     } catch (error92) {
@@ -130997,6 +131151,7 @@ class BackgroundManager {
           if (item.task.sessionId) {
             await this.abortSessionWithLogging(item.task.sessionId, "startTask error cleanup");
           }
+          this.updateBackgroundTaskMarker(item.task.parentSessionId);
           this.markForNotification(item.task);
           this.enqueueNotificationForParent(item.task.parentSessionId, () => this.notifyParentSession(item.task)).catch((err) => {
             log("[background-agent] Failed to notify on startTask error:", err);
@@ -131251,6 +131406,15 @@ The fallback retry session is now created and can be inspected directly.
     }
     return tasks;
   }
+  updateBackgroundTaskMarker(parentSessionID) {
+    const tasks = this.getTasksByParentSession(parentSessionID);
+    const activeTasks = tasks.filter((t) => t.status === "running" || t.status === "pending");
+    if (activeTasks.length > 0) {
+      setContinuationMarkerSource(this.directory, parentSessionID, "background-task", "active", `${activeTasks.length} background task(s) active`);
+    } else {
+      setContinuationMarkerSource(this.directory, parentSessionID, "background-task", "idle");
+    }
+  }
   getAllDescendantTasks(sessionID) {
     const result = [];
     const directChildren = this.getTasksByParentSession(sessionID);
@@ -131831,6 +131995,9 @@ The fallback retry session is now created and can be inspected directly.
     if (task.sessionId) {
       SessionCategoryRegistry.remove(task.sessionId);
     }
+    if (task.parentSessionId) {
+      this.updateBackgroundTaskMarker(task.parentSessionId);
+    }
     this.markForNotification(task);
     this.enqueueNotificationForParent(task.parentSessionId, () => this.notifyParentSession(task)).catch((err) => {
       log("[background-agent] Error in notifyParentSession for errored task:", { taskId: task.id, error: err });
@@ -132065,6 +132232,9 @@ ${originalText}`;
       SessionCategoryRegistry.remove(task.sessionId);
     }
     removeTaskToastTracking(task.id);
+    if (task.parentSessionId) {
+      this.updateBackgroundTaskMarker(task.parentSessionId);
+    }
     if (options?.skipNotification) {
       this.cleanupPendingByParent(task);
       this.scheduleTaskRemoval(task.id);
@@ -132144,6 +132314,9 @@ ${originalText}`;
       await this.abortSessionWithLogging(task.sessionId, `task completion (${source})`);
       SessionCategoryRegistry.remove(task.sessionId);
     }
+    if (task.parentSessionId) {
+      this.updateBackgroundTaskMarker(task.parentSessionId);
+    }
     try {
       await this.enqueueNotificationForParent(task.parentSessionId, () => this.notifyParentSession(task));
       log(`[background-agent] Task completed via ${source}:`, task.id);
@@ -132327,6 +132500,9 @@ ${originalText}`;
           }
         }
         this.cleanupPendingByParent(task);
+        if (task.parentSessionId) {
+          this.updateBackgroundTaskMarker(task.parentSessionId);
+        }
         this.markForNotification(task);
         this.enqueueNotificationForParent(task.parentSessionId, () => this.notifyParentSession(task)).catch((err) => {
           log("[background-agent] Error in notifyParentSession for stale-pruned task:", { taskId: task.id, error: err });
@@ -132381,6 +132557,9 @@ ${originalText}`;
     if (task.sessionId) {
       SessionCategoryRegistry.remove(task.sessionId);
     }
+    if (task.parentSessionId) {
+      this.updateBackgroundTaskMarker(task.parentSessionId);
+    }
     this.markForNotification(task);
     this.enqueueNotificationForParent(task.parentSessionId, () => this.notifyParentSession(task)).catch((err) => {
       log("[background-agent] Error in notifyParentSession for crashed task:", { taskId: task.id, error: err });
@@ -132824,7 +133003,7 @@ async function findAvailablePort2(startPort = DEFAULT_PORT) {
 }
 
 // src/features/mcp-oauth/oauth-authorization-flow.ts
-import { spawn as spawn20 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
 import { createServer } from "http";
 function generateCodeVerifier() {
@@ -132905,7 +133084,7 @@ function openBrowser(url3) {
     args = [url3];
   }
   try {
-    const child = spawn20(command, args, { stdio: "ignore", detached: true });
+    const child = spawn3(command, args, { stdio: "ignore", detached: true });
     child.on("error", () => {});
     child.unref();
   } catch {}
@@ -137489,7 +137668,8 @@ async function createStdioClient(params) {
     command,
     args,
     env: mergedEnv,
-    stderr: "ignore"
+    stderr: "ignore",
+    ...info.directory ? { cwd: info.directory } : {}
   });
   const client2 = stdioClientDependencies.createClient({ name: `skill-mcp-${info.skillName}-${info.serverName}`, version: "1.0.0" }, { capabilities: {} });
   try {
@@ -137795,7 +137975,7 @@ function createModelFallbackControllerAccessor() {
   };
 }
 // src/features/tmux-subagent/pane-state-querier.ts
-var {spawn: spawn22 } = globalThis.Bun;
+init_bun_spawn_shim();
 
 // src/features/tmux-subagent/pane-state-parser.ts
 var MANDATORY_PANE_FIELD_COUNT = 8;
@@ -137884,7 +138064,7 @@ async function queryWindowState(sourcePaneId) {
   const tmux3 = await getTmuxPath();
   if (!tmux3)
     return null;
-  const proc = spawn22([
+  const proc = spawn2([
     tmux3,
     "list-panes",
     "-t",
@@ -139420,7 +139600,7 @@ function resolveGateway(config4, event) {
 }
 
 // src/openclaw/dispatcher.ts
-var {spawn: spawn23 } = globalThis.Bun;
+init_bun_spawn_shim();
 var DEFAULT_HTTP_TIMEOUT_MS = 1e4;
 var DEFAULT_COMMAND_TIMEOUT_MS = 5000;
 var MIN_COMMAND_TIMEOUT_MS = 100;
@@ -139554,7 +139734,7 @@ async function wakeCommandGateway(gatewayName, gatewayConfig, variables) {
         return _match;
       return shellEscapeArg(value);
     });
-    const proc = spawn23(["sh", "-c", interpolated], {
+    const proc = spawn2(["sh", "-c", interpolated], {
       env: { ...process.env },
       stdout: "pipe",
       stderr: "ignore",
@@ -139604,7 +139784,7 @@ function terminateCommandProcess(proc, signal) {
 }
 
 // src/openclaw/tmux.ts
-var {spawn: spawn24 } = globalThis.Bun;
+init_bun_spawn_shim();
 function getCurrentTmuxSession() {
   const env = process.env.TMUX;
   if (!env)
@@ -139614,7 +139794,7 @@ function getCurrentTmuxSession() {
 }
 async function captureTmuxPane(paneId, lines = 15) {
   try {
-    const proc = spawn24(["tmux", "capture-pane", "-p", "-t", paneId, "-S", `-${lines}`], {
+    const proc = spawn2(["tmux", "capture-pane", "-p", "-t", paneId, "-S", `-${lines}`], {
       stdout: "pipe",
       stderr: "ignore"
     });
@@ -139630,7 +139810,7 @@ async function captureTmuxPane(paneId, lines = 15) {
 }
 async function isTmuxAvailable() {
   try {
-    const proc = spawn24(["tmux", "-V"], {
+    const proc = spawn2(["tmux", "-V"], {
       stdout: "ignore",
       stderr: "ignore"
     });
@@ -140095,8 +140275,8 @@ function markReplyListenerStopped(state3, error92) {
 }
 
 // src/openclaw/reply-listener-process.ts
+init_bun_spawn_shim();
 import { readFileSync as readFileSync61 } from "fs";
-var {spawn: spawn25 } = globalThis.Bun;
 var REPLY_LISTENER_DAEMON_IDENTITY_MARKER = "--openclaw-reply-listener-daemon";
 var REPLY_LISTENER_DAEMON_ENV_ALLOWLIST = [
   "PATH",
@@ -140154,7 +140334,7 @@ async function isReplyListenerDaemonProcess(pid) {
       const cmdline = readFileSync61(`/proc/${pid}/cmdline`, "utf-8");
       return cmdline.includes(REPLY_LISTENER_DAEMON_IDENTITY_MARKER);
     }
-    const processInfo = spawn25(["ps", "-p", String(pid), "-o", "args="], {
+    const processInfo = spawn2(["ps", "-p", String(pid), "-o", "args="], {
       stdout: "pipe",
       stderr: "ignore"
     });
@@ -140168,9 +140348,9 @@ async function isReplyListenerDaemonProcess(pid) {
 }
 
 // src/openclaw/reply-listener-spawn.ts
-var {spawn: spawn26 } = globalThis.Bun;
+init_bun_spawn_shim();
 function spawnReplyListenerDaemon(daemonScript, startupToken) {
-  return spawn26(["bun", "run", daemonScript, REPLY_LISTENER_DAEMON_IDENTITY_MARKER], {
+  return spawn2(["bun", "run", daemonScript, REPLY_LISTENER_DAEMON_IDENTITY_MARKER], {
     detached: true,
     stdio: ["ignore", "ignore", "ignore"],
     cwd: process.cwd(),
@@ -153320,7 +153500,6 @@ init_agent_display_names();
 init_agent_display_names();
 
 // src/plugin/ultrawork-db-model-override.ts
-import { Database } from "bun:sqlite";
 import { join as join101 } from "path";
 import { existsSync as existsSync91 } from "fs";
 function getDbPath() {
@@ -153399,7 +153578,13 @@ function retryViaMicrotask(db, messageId, targetModel, variant, attempt) {
   });
 }
 function scheduleDeferredModelOverride(messageId, targetModel, variant) {
-  queueMicrotask(() => {
+  queueMicrotask(async () => {
+    const sqliteModule = await import("bun:sqlite").catch(() => null);
+    const Database = sqliteModule?.Database;
+    if (typeof Database !== "function") {
+      log("[ultrawork-db-override] bun:sqlite unavailable, skipping deferred override", { messageId });
+      return;
+    }
     const dbPath = getDbPath();
     if (!existsSync91(dbPath)) {
       log("[ultrawork-db-override] DB not found, skipping deferred override");