oh-my-opencode 3.5.2 → 3.5.3

package/dist/cli/index.js

@@ -7052,6 +7052,12 @@ var init_tmux = __esm(() => {
 var init_model_suggestion_retry = __esm(() => {
   init_logger();
 });
+
+// src/shared/opencode-server-auth.ts
+var init_opencode_server_auth = __esm(() => {
+  init_logger();
+});
+
 // src/shared/port-utils.ts
 async function isPortAvailable(port, hostname = "127.0.0.1") {
   try {
@@ -7128,6 +7134,7 @@ var init_shared = __esm(() => {
   init_session_utils();
   init_tmux();
   init_model_suggestion_retry();
+  init_opencode_server_auth();
   init_port_utils();
   init_git_worktree();
   init_safe_create_hook();
@@ -8870,7 +8877,7 @@ var {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "3.5.2",
+  version: "3.5.3",
   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",
@@ -8944,13 +8951,13 @@ var package_default = {
     typescript: "^5.7.3"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "3.5.2",
-    "oh-my-opencode-darwin-x64": "3.5.2",
-    "oh-my-opencode-linux-arm64": "3.5.2",
-    "oh-my-opencode-linux-arm64-musl": "3.5.2",
-    "oh-my-opencode-linux-x64": "3.5.2",
-    "oh-my-opencode-linux-x64-musl": "3.5.2",
-    "oh-my-opencode-windows-x64": "3.5.2"
+    "oh-my-opencode-darwin-arm64": "3.5.3",
+    "oh-my-opencode-darwin-x64": "3.5.3",
+    "oh-my-opencode-linux-arm64": "3.5.3",
+    "oh-my-opencode-linux-arm64-musl": "3.5.3",
+    "oh-my-opencode-linux-x64": "3.5.3",
+    "oh-my-opencode-linux-x64-musl": "3.5.3",
+    "oh-my-opencode-windows-x64": "3.5.3"
   },
   trustedDependencies: [
     "@ast-grep/cli",
@@ -24752,11 +24759,14 @@ async function areAllDescendantsIdle(ctx, sessionID, allStatuses) {
 var DEFAULT_POLL_INTERVAL_MS = 500;
 var DEFAULT_REQUIRED_CONSECUTIVE = 3;
 var ERROR_GRACE_CYCLES = 3;
+var MIN_STABILIZATION_MS = 1e4;
 async function pollForCompletion(ctx, eventState, abortController, options = {}) {
   const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
   const requiredConsecutive = options.requiredConsecutive ?? DEFAULT_REQUIRED_CONSECUTIVE;
+  const minStabilizationMs = options.minStabilizationMs ?? MIN_STABILIZATION_MS;
   let consecutiveCompleteChecks = 0;
   let errorCycleCount = 0;
+  let firstWorkTimestamp = null;
   while (!abortController.signal.aborted) {
     await new Promise((resolve2) => setTimeout(resolve2, pollIntervalMs));
     if (eventState.mainSessionError) {
@@ -24784,6 +24794,13 @@ Session ended with error: ${eventState.lastError}`));
       consecutiveCompleteChecks = 0;
       continue;
     }
+    if (firstWorkTimestamp === null) {
+      firstWorkTimestamp = Date.now();
+    }
+    if (Date.now() - firstWorkTimestamp < minStabilizationMs) {
+      consecutiveCompleteChecks = 0;
+      continue;
+    }
     const shouldExit = await checkCompletionConditions(ctx);
     if (shouldExit) {
       consecutiveCompleteChecks++;
@@ -24848,7 +24865,7 @@ Interrupted. Shutting down...`));
       });
       console.log(import_picocolors14.default.dim(`Session: ${sessionID}`));
       const ctx = { client: client3, sessionID, directory, abortController };
-      const events = await client3.event.subscribe();
+      const events = await client3.event.subscribe({ query: { directory } });
       const eventState = createEventState();
       const eventProcessor = processEvents(ctx, events.stream, eventState).catch(() => {});
       console.log(import_picocolors14.default.dim(`

package/dist/cli/run/poll-for-completion.d.ts

@@ -3,5 +3,6 @@ import type { EventState } from "./events";
 export interface PollOptions {
     pollIntervalMs?: number;
     requiredConsecutive?: number;
+    minStabilizationMs?: number;
 }
 export declare function pollForCompletion(ctx: RunContext, eventState: EventState, abortController: AbortController, options?: PollOptions): Promise<number>;

package/dist/features/background-agent/background-event-handler.d.ts

@@ -7,6 +7,7 @@ export declare function handleBackgroundEvent(args: {
     event: Event;
     findBySession: (sessionID: string) => BackgroundTask | undefined;
     getAllDescendantTasks: (sessionID: string) => BackgroundTask[];
+    releaseConcurrencyKey?: (key: string) => void;
     cancelTask: (taskId: string, options: {
         source: string;
         reason: string;

package/dist/features/background-agent/manager.d.ts

@@ -114,6 +114,8 @@ export declare class BackgroundManager {
     private formatDuration;
     private isAbortedSessionError;
     private getErrorText;
+    private isRecord;
+    private getSessionErrorMessage;
     private hasRunningTasks;
     private pruneStaleTasksAndNotifications;
     private checkAndInterruptStaleTasks;

package/dist/features/background-agent/session-idle-event-handler.d.ts

@@ -0,0 +1,10 @@
+import type { BackgroundTask } from "./types";
+export declare function handleSessionIdleBackgroundEvent(args: {
+    properties: Record<string, unknown>;
+    findBySession: (sessionID: string) => BackgroundTask | undefined;
+    idleDeferralTimers: Map<string, ReturnType<typeof setTimeout>>;
+    validateSessionHasOutput: (sessionID: string) => Promise<boolean>;
+    checkSessionTodos: (sessionID: string) => Promise<boolean>;
+    tryCompleteTask: (task: BackgroundTask, source: string) => Promise<boolean>;
+    emitIdleEvent: (sessionID: string) => void;
+}): void;

package/dist/features/background-agent/session-task-cleanup.d.ts

@@ -0,0 +1,10 @@
+import type { BackgroundTask } from "./types";
+export declare function cleanupTaskAfterSessionEnds(args: {
+    task: BackgroundTask;
+    tasks: Map<string, BackgroundTask>;
+    idleDeferralTimers: Map<string, ReturnType<typeof setTimeout>>;
+    completionTimers: Map<string, ReturnType<typeof setTimeout>>;
+    cleanupPendingByParent: (task: BackgroundTask) => void;
+    clearNotificationsForTask: (taskId: string) => void;
+    releaseConcurrencyKey?: (key: string) => void;
+}): void;

package/dist/features/background-agent/stale-task-pruner.d.ts

@@ -1,9 +1,15 @@
-import type { BackgroundTask } from "./types";
+import type { BackgroundTask, LaunchInput } from "./types";
 import type { ConcurrencyManager } from "./concurrency";
+type QueueItem = {
+    task: BackgroundTask;
+    input: LaunchInput;
+};
 export declare function pruneStaleState(args: {
     tasks: Map<string, BackgroundTask>;
     notifications: Map<string, BackgroundTask[]>;
+    queuesByKey: Map<string, QueueItem[]>;
     concurrencyManager: ConcurrencyManager;
     cleanupPendingByParent: (task: BackgroundTask) => void;
     clearNotificationsForTask: (taskId: string) => void;
 }): void;
+export {};

package/dist/hooks/prometheus-md-only/agent-matcher.d.ts

@@ -0,0 +1 @@
+export declare function isPrometheusAgent(agentName: string | undefined): boolean;

package/dist/index.js

@@ -34314,6 +34314,7 @@ async function promptSyncWithModelSuggestionRetry(client, args) {
   }
 }
 // src/shared/opencode-server-auth.ts
+init_logger();
 function getServerBasicAuthHeader() {
   const password = process.env.OPENCODE_SERVER_PASSWORD;
   if (!password) {
@@ -34323,27 +34324,128 @@ function getServerBasicAuthHeader() {
   const token = Buffer.from(`${username}:${password}`, "utf8").toString("base64");
   return `Basic ${token}`;
 }
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isRequestFetch(value) {
+  return typeof value === "function";
+}
+function wrapRequestFetch(baseFetch, auth) {
+  return async (request) => {
+    const headers = new Headers(request.headers);
+    headers.set("Authorization", auth);
+    return baseFetch(new Request(request, { headers }));
+  };
+}
+function getInternalClient(client) {
+  if (!isRecord(client)) {
+    return null;
+  }
+  const internal = client["_client"];
+  return isRecord(internal) ? internal : null;
+}
+function tryInjectViaSetConfigHeaders(internal, auth) {
+  const setConfig = internal["setConfig"];
+  if (typeof setConfig !== "function") {
+    return false;
+  }
+  setConfig({
+    headers: {
+      Authorization: auth
+    }
+  });
+  return true;
+}
+function tryInjectViaInterceptors(internal, auth) {
+  const interceptors = internal["interceptors"];
+  if (!isRecord(interceptors)) {
+    return false;
+  }
+  const requestInterceptors = interceptors["request"];
+  if (!isRecord(requestInterceptors)) {
+    return false;
+  }
+  const use = requestInterceptors["use"];
+  if (typeof use !== "function") {
+    return false;
+  }
+  use((request) => {
+    if (!request.headers.get("Authorization")) {
+      request.headers.set("Authorization", auth);
+    }
+    return request;
+  });
+  return true;
+}
+function tryInjectViaFetchWrapper(internal, auth) {
+  const getConfig = internal["getConfig"];
+  const setConfig = internal["setConfig"];
+  if (typeof getConfig !== "function" || typeof setConfig !== "function") {
+    return false;
+  }
+  const config2 = getConfig();
+  if (!isRecord(config2)) {
+    return false;
+  }
+  const fetchValue = config2["fetch"];
+  if (!isRequestFetch(fetchValue)) {
+    return false;
+  }
+  setConfig({
+    fetch: wrapRequestFetch(fetchValue, auth)
+  });
+  return true;
+}
+function tryInjectViaMutableInternalConfig(internal, auth) {
+  const configValue = internal["_config"];
+  if (!isRecord(configValue)) {
+    return false;
+  }
+  const fetchValue = configValue["fetch"];
+  if (!isRequestFetch(fetchValue)) {
+    return false;
+  }
+  configValue["fetch"] = wrapRequestFetch(fetchValue, auth);
+  return true;
+}
+function tryInjectViaTopLevelFetch(client, auth) {
+  if (!isRecord(client)) {
+    return false;
+  }
+  const fetchValue = client["fetch"];
+  if (!isRequestFetch(fetchValue)) {
+    return false;
+  }
+  client["fetch"] = wrapRequestFetch(fetchValue, auth);
+  return true;
+}
 function injectServerAuthIntoClient(client) {
   const auth = getServerBasicAuthHeader();
   if (!auth) {
     return;
   }
   try {
-    if (typeof client !== "object" || client === null || !("_client" in client) || typeof client._client !== "object" || client._client === null) {
-      throw new Error("[opencode-server-auth] OPENCODE_SERVER_PASSWORD is set but SDK client structure is incompatible. " + "This may indicate an OpenCode SDK version mismatch.");
+    const internal = getInternalClient(client);
+    if (internal) {
+      const injectedHeaders = tryInjectViaSetConfigHeaders(internal, auth);
+      const injectedInterceptors = tryInjectViaInterceptors(internal, auth);
+      const injectedFetch = tryInjectViaFetchWrapper(internal, auth);
+      const injectedMutable = tryInjectViaMutableInternalConfig(internal, auth);
+      const injected2 = injectedHeaders || injectedInterceptors || injectedFetch || injectedMutable;
+      if (!injected2) {
+        log("[opencode-server-auth] OPENCODE_SERVER_PASSWORD is set but SDK client structure is incompatible", {
+          keys: Object.keys(internal)
+        });
+      }
+      return;
     }
-    const internal = client._client;
-    if (typeof internal.setConfig !== "function") {
-      throw new Error("[opencode-server-auth] OPENCODE_SERVER_PASSWORD is set but SDK client._client.setConfig is not a function. " + "This may indicate an OpenCode SDK version mismatch.");
+    const injected = tryInjectViaTopLevelFetch(client, auth);
+    if (!injected) {
+      log("[opencode-server-auth] OPENCODE_SERVER_PASSWORD is set but no compatible SDK client found");
     }
-    internal.setConfig({
-      headers: {
-        Authorization: auth
-      }
-    });
   } catch (error45) {
     const message = error45 instanceof Error ? error45.message : String(error45);
-    console.warn(`[opencode-server-auth] Failed to inject server auth: ${message}`);
+    log("[opencode-server-auth] Failed to inject server auth", { message });
   }
 }
 // src/shared/git-worktree/parse-status-porcelain.ts
@@ -42711,7 +42813,7 @@ async function executeSlashCommand(parsed, options) {
   if (!command) {
     return {
       success: false,
-      error: `Command "/${parsed.command}" not found. Use the slashcommand tool to list available commands.`
+      error: parsed.command.includes(":") ? `Marketplace plugin commands like "/${parsed.command}" are not supported. Use .claude/commands/ for custom commands.` : `Command "/${parsed.command}" not found. Use the slashcommand tool to list available commands.`
     };
   }
   try {
@@ -42984,6 +43086,11 @@ function getAgentFromSession(sessionID, directory) {
   return getAgentFromMessageFiles(sessionID);
 }
 
+// src/hooks/prometheus-md-only/agent-matcher.ts
+function isPrometheusAgent(agentName) {
+  return agentName?.toLowerCase().includes(PROMETHEUS_AGENT) ?? false;
+}
+
 // src/hooks/prometheus-md-only/path-policy.ts
 import { relative as relative3, resolve as resolve7, isAbsolute as isAbsolute3 } from "path";
 function isAllowedFile(filePath, workspaceRoot) {
@@ -43008,7 +43115,7 @@ function createPrometheusMdOnlyHook(ctx) {
   return {
     "tool.execute.before": async (input, output) => {
       const agentName = getAgentFromSession(input.sessionID, ctx.directory);
-      if (agentName !== PROMETHEUS_AGENT) {
+      if (!isPrometheusAgent(agentName)) {
         return;
       }
       const toolName = input.tool;
@@ -44410,16 +44517,16 @@ var THINKING_SUMMARY_MAX_CHARS = 500;
 function hasData(value) {
   return typeof value === "object" && value !== null && "data" in value;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 function getMessageInfo(value) {
-  if (!isRecord(value))
+  if (!isRecord2(value))
     return;
-  if (!isRecord(value.info))
+  if (!isRecord2(value.info))
     return;
   const info = value.info;
-  const modelValue = isRecord(info.model) ? info.model : undefined;
+  const modelValue = isRecord2(info.model) ? info.model : undefined;
   const model = modelValue && typeof modelValue.providerID === "string" && typeof modelValue.modelID === "string" ? { providerID: modelValue.providerID, modelID: modelValue.modelID } : undefined;
   return {
     role: typeof info.role === "string" ? info.role : undefined,
@@ -44430,11 +44537,11 @@ function getMessageInfo(value) {
   };
 }
 function getMessageParts(value) {
-  if (!isRecord(value))
+  if (!isRecord2(value))
     return [];
   if (!Array.isArray(value.parts))
     return [];
-  return value.parts.filter(isRecord).map((part) => ({
+  return value.parts.filter(isRecord2).map((part) => ({
     type: typeof part.type === "string" ? part.type : undefined,
     text: typeof part.text === "string" ? part.text : undefined,
     thinking: typeof part.thinking === "string" ? part.thinking : undefined
@@ -47834,7 +47941,9 @@ Provide a command or skill name to execute.`;
 
 ${formatCommandList(allItems)}`;
       }
-      return `Command or skill "/${commandName}" not found.
+      return commandName.includes(":") ? `Marketplace plugin commands like "/${commandName}" are not supported. Use .claude/commands/ for custom commands.
+
+${formatCommandList(allItems)}` : `Command or skill "/${commandName}" not found.
 
 ${formatCommandList(allItems)}
 
@@ -50213,7 +50322,8 @@ Use \`background_output\` with task_id="${task.id}" to check progress.
 
 <task_metadata>
 session_id: ${task.sessionID}
-</task_metadata>`;
+${task.agent ? `subagent: ${task.agent}
+` : ""}</task_metadata>`;
   } catch (error45) {
     return formatDetailedError(error45, {
       operation: "Continue background task",
@@ -50666,7 +50776,8 @@ ${result.textContent || "(No text output)"}
 
 <task_metadata>
 session_id: ${args.session_id}
-</task_metadata>`;
+${resumeAgent ? `subagent: ${resumeAgent}
+` : ""}</task_metadata>`;
   } finally {
     if (toastManager) {
       toastManager.removeTask(taskId);
@@ -52764,7 +52875,7 @@ class BackgroundManager {
       while (queue && queue.length > 0) {
         const item = queue[0];
         await this.concurrencyManager.acquire(key);
-        if (item.task.status === "cancelled") {
+        if (item.task.status === "cancelled" || item.task.status === "error") {
           this.concurrencyManager.release(key);
           queue.shift();
           continue;
@@ -53188,6 +53299,38 @@ class BackgroundManager {
         log("[background-agent] Error in session.idle handler:", err);
       });
     }
+    if (event.type === "session.error") {
+      const sessionID = typeof props?.sessionID === "string" ? props.sessionID : undefined;
+      if (!sessionID)
+        return;
+      const task = this.findBySession(sessionID);
+      if (!task || task.status !== "running")
+        return;
+      const errorMessage = props ? this.getSessionErrorMessage(props) : undefined;
+      task.status = "error";
+      task.error = errorMessage ?? "Session error";
+      task.completedAt = new Date;
+      if (task.concurrencyKey) {
+        this.concurrencyManager.release(task.concurrencyKey);
+        task.concurrencyKey = undefined;
+      }
+      const completionTimer = this.completionTimers.get(task.id);
+      if (completionTimer) {
+        clearTimeout(completionTimer);
+        this.completionTimers.delete(task.id);
+      }
+      const idleTimer = this.idleDeferralTimers.get(task.id);
+      if (idleTimer) {
+        clearTimeout(idleTimer);
+        this.idleDeferralTimers.delete(task.id);
+      }
+      this.cleanupPendingByParent(task);
+      this.tasks.delete(task.id);
+      this.clearNotificationsForTask(task.id);
+      if (task.sessionID) {
+        subagentSessions.delete(task.sessionID);
+      }
+    }
     if (event.type === "session.deleted") {
       const info = props?.info;
       if (!info || typeof info.id !== "string")
@@ -53610,6 +53753,22 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
     }
     return "";
   }
+  isRecord(value) {
+    return typeof value === "object" && value !== null;
+  }
+  getSessionErrorMessage(properties) {
+    const errorRaw = properties["error"];
+    if (!this.isRecord(errorRaw))
+      return;
+    const dataRaw = errorRaw["data"];
+    if (this.isRecord(dataRaw)) {
+      const message2 = dataRaw["message"];
+      if (typeof message2 === "string")
+        return message2;
+    }
+    const message = errorRaw["message"];
+    return typeof message === "string" ? message : undefined;
+  }
   hasRunningTasks() {
     for (const task of this.tasks.values()) {
       if (task.status === "running")
@@ -53620,6 +53779,7 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
   pruneStaleTasksAndNotifications() {
     const now = Date.now();
     for (const [taskId, task] of this.tasks.entries()) {
+      const wasPending = task.status === "pending";
       const timestamp2 = task.status === "pending" ? task.queuedAt?.getTime() : task.startedAt?.getTime();
       if (!timestamp2) {
         continue;
@@ -53636,6 +53796,19 @@ Use \`background_output(task_id="${task.id}")\` to retrieve this result when rea
           task.concurrencyKey = undefined;
         }
         this.cleanupPendingByParent(task);
+        if (wasPending) {
+          const key = task.model ? `${task.model.providerID}/${task.model.modelID}` : task.agent;
+          const queue = this.queuesByKey.get(key);
+          if (queue) {
+            const index = queue.findIndex((item) => item.task.id === taskId);
+            if (index !== -1) {
+              queue.splice(index, 1);
+              if (queue.length === 0) {
+                this.queuesByKey.delete(key);
+              }
+            }
+          }
+        }
         this.clearNotificationsForTask(taskId);
         this.tasks.delete(taskId);
         if (task.sessionID) {
@@ -58082,7 +58255,7 @@ async function getOrRegisterClient(options) {
   }
 }
 function parseRegistrationResponse(data) {
-  if (!isRecord2(data))
+  if (!isRecord3(data))
     return null;
   const clientId = data.client_id;
   if (typeof clientId !== "string" || clientId.length === 0)
@@ -58093,7 +58266,7 @@ function parseRegistrationResponse(data) {
   }
   return { clientId };
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -63598,7 +63771,7 @@ function maybeCreateAtlasConfig(input) {
 function sanitizeMarkdownTableCell(value) {
   return value.replace(/\r?\n/g, " ").replace(/\|/g, "\\|").replace(/\s+/g, " ").trim();
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null;
 }
 function parseRegisteredAgentSummaries(input) {
@@ -63606,7 +63779,7 @@ function parseRegisteredAgentSummaries(input) {
     return [];
   const result = [];
   for (const item of input) {
-    if (!isRecord3(item))
+    if (!isRecord4(item))
       continue;
     const name = typeof item.name === "string" ? item.name : undefined;
     if (!name)
@@ -66894,11 +67067,11 @@ async function createTools(args) {
 }
 
 // src/plugin/chat-params.ts
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null;
 }
 function buildChatParamsInput(raw) {
-  if (!isRecord4(raw))
+  if (!isRecord5(raw))
     return null;
   const sessionID = raw.sessionID;
   const agent = raw.agent;
@@ -66909,11 +67082,11 @@ function buildChatParamsInput(raw) {
     return null;
   if (typeof agent !== "string")
     return null;
-  if (!isRecord4(model))
+  if (!isRecord5(model))
     return null;
-  if (!isRecord4(provider))
+  if (!isRecord5(provider))
     return null;
-  if (!isRecord4(message))
+  if (!isRecord5(message))
     return null;
   const providerID = model.providerID;
   const modelID = model.modelID;
@@ -66934,12 +67107,12 @@ function buildChatParamsInput(raw) {
   };
 }
 function isChatParamsOutput(raw) {
-  if (!isRecord4(raw))
+  if (!isRecord5(raw))
     return false;
-  if (!isRecord4(raw.options)) {
+  if (!isRecord5(raw.options)) {
     raw.options = {};
   }
-  return isRecord4(raw.options);
+  return isRecord5(raw.options);
 }
 function createChatParamsHandler(args) {
   return async (input, output) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "3.5.2",
+  "version": "3.5.3",
   "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",
@@ -74,13 +74,13 @@
     "typescript": "^5.7.3"
   },
   "optionalDependencies": {
-    "oh-my-opencode-darwin-arm64": "3.5.2",
-    "oh-my-opencode-darwin-x64": "3.5.2",
-    "oh-my-opencode-linux-arm64": "3.5.2",
-    "oh-my-opencode-linux-arm64-musl": "3.5.2",
-    "oh-my-opencode-linux-x64": "3.5.2",
-    "oh-my-opencode-linux-x64-musl": "3.5.2",
-    "oh-my-opencode-windows-x64": "3.5.2"
+    "oh-my-opencode-darwin-arm64": "3.5.3",
+    "oh-my-opencode-darwin-x64": "3.5.3",
+    "oh-my-opencode-linux-arm64": "3.5.3",
+    "oh-my-opencode-linux-arm64-musl": "3.5.3",
+    "oh-my-opencode-linux-x64": "3.5.3",
+    "oh-my-opencode-linux-x64-musl": "3.5.3",
+    "oh-my-opencode-windows-x64": "3.5.3"
   },
   "trustedDependencies": [
     "@ast-grep/cli",