oh-my-opencode 4.3.0 → 4.3.1

package/dist/cli/index.js

@@ -8093,8 +8093,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) {
@@ -8127,6 +8133,24 @@ 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 wrapNodeProcess(proc) {
   let exitCode = null;
   const exited = new Promise((resolve4, reject) => {
@@ -8169,28 +8193,24 @@ function wrapNodeProcess(proc) {
   };
 }
 function spawn(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);
 }
-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
 var init_archive_entry_validator = () => {};
-
 // src/shared/zip-entry-listing/python-zip-entry-listing.ts
 var init_python_zip_entry_listing = __esm(() => {
   init_bun_spawn_shim();
@@ -8234,10 +8254,10 @@ var init_zip_extractor = __esm(() => {
 });
 
 // src/shared/bun-file-shim.ts
-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
@@ -55420,7 +55440,7 @@ var {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "4.3.0",
+  version: "4.3.1",
   description: "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   main: "./dist/index.js",
   types: "dist/index.d.ts",
@@ -55530,17 +55550,17 @@ var package_default = {
     zod: "^4.4.3"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "4.3.0",
-    "oh-my-opencode-darwin-x64": "4.3.0",
-    "oh-my-opencode-darwin-x64-baseline": "4.3.0",
-    "oh-my-opencode-linux-arm64": "4.3.0",
-    "oh-my-opencode-linux-arm64-musl": "4.3.0",
-    "oh-my-opencode-linux-x64": "4.3.0",
-    "oh-my-opencode-linux-x64-baseline": "4.3.0",
-    "oh-my-opencode-linux-x64-musl": "4.3.0",
-    "oh-my-opencode-linux-x64-musl-baseline": "4.3.0",
-    "oh-my-opencode-windows-x64": "4.3.0",
-    "oh-my-opencode-windows-x64-baseline": "4.3.0"
+    "oh-my-opencode-darwin-arm64": "4.3.1",
+    "oh-my-opencode-darwin-x64": "4.3.1",
+    "oh-my-opencode-darwin-x64-baseline": "4.3.1",
+    "oh-my-opencode-linux-arm64": "4.3.1",
+    "oh-my-opencode-linux-arm64-musl": "4.3.1",
+    "oh-my-opencode-linux-x64": "4.3.1",
+    "oh-my-opencode-linux-x64-baseline": "4.3.1",
+    "oh-my-opencode-linux-x64-musl": "4.3.1",
+    "oh-my-opencode-linux-x64-musl-baseline": "4.3.1",
+    "oh-my-opencode-windows-x64": "4.3.1",
+    "oh-my-opencode-windows-x64-baseline": "4.3.1"
   },
   overrides: {
     hono: "^4.12.18",
@@ -82985,7 +83005,7 @@ import { basename as basename5 } from "path";
 import { accessSync as accessSync3, constants as constants6 } from "fs";
 import { delimiter as delimiter2, join as join39 } 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;
@@ -83020,7 +83040,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)

package/dist/features/background-agent/parent-wake-notifier.d.ts

@@ -62,6 +62,7 @@ export declare class ParentWakeNotifier {
     private resolveParentWakePromptContext;
     private cloneParentWake;
     private trackDispatchedParentWake;
+    private isSameParentWake;
     private loadParentWakeSessionMessages;
     private getParentWakeMessageRole;
     private getParentWakeMessageFinish;

package/dist/index.js

@@ -9157,8 +9157,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 +9197,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 +9270,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 +9367,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 +9450,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 +9518,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 +9582,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 +9603,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 +9647,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 +9744,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 +9803,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 +9853,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 +9903,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 +69366,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 +69377,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 +69412,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 +69548,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 +69584,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 +71772,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 +71834,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");
@@ -100037,11 +100216,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 {
@@ -100163,6 +100348,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 +100494,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 +100513,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 +100549,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 +100568,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 +100737,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 +100752,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 +100782,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 +102559,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 +102742,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 +102948,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}`;
   }
@@ -110633,6 +110819,11 @@ class ParentWakeNotifier {
         throw promptResult.error;
       }
       if (promptResult.status === "reserved" && promptResult.reservedBy === "background-agent-parent-wake") {
+        const dispatchedWake = this.dispatchedParentWakes.get(sessionID);
+        if (dispatchedWake && this.isSameParentWake(latestWake, dispatchedWake)) {
+          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 });
@@ -110769,6 +110960,9 @@ class ParentWakeNotifier {
     unrefTimerHandle(timer);
     this.dispatchedParentWakeTimers.set(sessionID, timer);
   }
+  isSameParentWake(left, right) {
+    return left.shouldReply === right.shouldReply && JSON.stringify(left.notifications) === JSON.stringify(right.notifications) && JSON.stringify(left.promptContext) === JSON.stringify(right.promptContext);
+  }
   async loadParentWakeSessionMessages(sessionID) {
     try {
       const messagesResp = await messagesInDirectory(this.deps.client, {
@@ -110993,9 +111187,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;
@@ -139870,7 +140068,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 +140094,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 +140257,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 +140265,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 +140295,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;
       }

package/dist/shared/bun-spawn-shim.d.ts

@@ -1,3 +1,4 @@
+import { type SpawnOptions as NodeSpawnOptions, type SpawnSyncOptions as NodeSpawnSyncOptions } from "node:child_process";
 type StdioMode = "pipe" | "inherit" | "ignore";
 type StdioTuple = [StdioMode, StdioMode, StdioMode];
 export interface SpawnOptions {
@@ -29,6 +30,8 @@ export interface SpawnSyncResult {
     readonly success: boolean;
     readonly pid: number;
 }
+export declare function createNodeSpawnOptions(options: SpawnOptions, platform?: NodeJS.Platform): NodeSpawnOptions;
+export declare function createNodeSpawnSyncOptions(options: SpawnOptions, platform?: NodeJS.Platform): NodeSpawnSyncOptions;
 export declare function spawn(command: string[], options?: SpawnOptions): SpawnedProcess;
 export declare function spawn(options: SpawnOptions & {
     cmd: string[];

package/dist/shared/process-stream-reader.d.ts

@@ -0,0 +1,3 @@
+import { Readable } from "node:stream";
+export type ProcessReadableStream = ReadableStream<Uint8Array> | Readable | null | undefined;
+export declare function readProcessStream(stream: ProcessReadableStream): Promise<string>;

package/dist/tools/glob/cli.d.ts

@@ -1,11 +1,13 @@
+import { type SpawnOptions, type SpawnedProcess } from "../../shared/bun-spawn-shim";
 import { type GrepBackend } from "./constants";
 import type { GlobOptions, GlobResult } from "./types";
 export interface ResolvedCli {
     path: string;
     backend: GrepBackend;
 }
+export type SearchProcessSpawner = (command: string[], options?: SpawnOptions) => SpawnedProcess;
 declare function buildRgArgs(options: GlobOptions): string[];
 declare function buildFindArgs(options: GlobOptions): string[];
 declare function buildPowerShellCommand(options: GlobOptions): string[];
 export { buildRgArgs, buildFindArgs, buildPowerShellCommand };
-export declare function runRgFiles(options: GlobOptions, resolvedCli?: ResolvedCli): Promise<GlobResult>;
+export declare function runRgFiles(options: GlobOptions, resolvedCli?: ResolvedCli, processSpawner?: SearchProcessSpawner): Promise<GlobResult>;

package/dist/tools/grep/cli.d.ts

@@ -1,4 +1,6 @@
+import { type SpawnOptions, type SpawnedProcess } from "../../shared/bun-spawn-shim";
 import { type ResolvedCli } from "../../shared/ripgrep-cli";
 import type { GrepOptions, GrepResult, CountResult } from "./types";
-export declare function runRg(options: GrepOptions, resolvedCli?: ResolvedCli): Promise<GrepResult>;
-export declare function runRgCount(options: Omit<GrepOptions, "context">, resolvedCli?: ResolvedCli): Promise<CountResult[]>;
+export type SearchProcessSpawner = (command: string[], options?: SpawnOptions) => SpawnedProcess;
+export declare function runRg(options: GrepOptions, resolvedCli?: ResolvedCli, processSpawner?: SearchProcessSpawner): Promise<GrepResult>;
+export declare function runRgCount(options: Omit<GrepOptions, "context">, resolvedCli?: ResolvedCli, processSpawner?: SearchProcessSpawner): Promise<CountResult[]>;

package/dist/tools/shared/search-process-output.d.ts

@@ -0,0 +1,7 @@
+import type { SpawnedProcess } from "../../shared/bun-spawn-shim";
+export interface SearchProcessOutput {
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly exitCode: number;
+}
+export declare function collectSearchProcessOutput(proc: SpawnedProcess, timeoutMs: number, timeoutMessage: string): Promise<SearchProcessOutput>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "4.3.0",
+  "version": "4.3.1",
   "description": "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   "main": "./dist/index.js",
   "types": "dist/index.d.ts",
@@ -110,17 +110,17 @@
     "zod": "^4.4.3"
   },
   "optionalDependencies": {
-    "oh-my-opencode-darwin-arm64": "4.3.0",
-    "oh-my-opencode-darwin-x64": "4.3.0",
-    "oh-my-opencode-darwin-x64-baseline": "4.3.0",
-    "oh-my-opencode-linux-arm64": "4.3.0",
-    "oh-my-opencode-linux-arm64-musl": "4.3.0",
-    "oh-my-opencode-linux-x64": "4.3.0",
-    "oh-my-opencode-linux-x64-baseline": "4.3.0",
-    "oh-my-opencode-linux-x64-musl": "4.3.0",
-    "oh-my-opencode-linux-x64-musl-baseline": "4.3.0",
-    "oh-my-opencode-windows-x64": "4.3.0",
-    "oh-my-opencode-windows-x64-baseline": "4.3.0"
+    "oh-my-opencode-darwin-arm64": "4.3.1",
+    "oh-my-opencode-darwin-x64": "4.3.1",
+    "oh-my-opencode-darwin-x64-baseline": "4.3.1",
+    "oh-my-opencode-linux-arm64": "4.3.1",
+    "oh-my-opencode-linux-arm64-musl": "4.3.1",
+    "oh-my-opencode-linux-x64": "4.3.1",
+    "oh-my-opencode-linux-x64-baseline": "4.3.1",
+    "oh-my-opencode-linux-x64-musl": "4.3.1",
+    "oh-my-opencode-linux-x64-musl-baseline": "4.3.1",
+    "oh-my-opencode-windows-x64": "4.3.1",
+    "oh-my-opencode-windows-x64-baseline": "4.3.1"
   },
   "overrides": {
     "hono": "^4.12.18",