oh-my-opencode 4.11.1 → 4.12.0

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

@@ -21,6 +21,7 @@ export declare class ParentWakeFlushRunner {
     private hasRecentParentSessionActivity;
     private isUserMessageInProgress;
     private shouldDeferParentWakeForSessionHistory;
+    private confirmParentWakeStillSafeForReply;
     private requeueWake;
 }
 export {};

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

@@ -2,4 +2,5 @@ import type { PendingParentWake } from "./parent-wake-dedupe";
 export declare function latestAssistantTurnIsCompletedEmptyNoProgress(messages: readonly unknown[]): boolean;
 export declare function latestAssistantTurnHasToolBlock(messages: readonly unknown[]): boolean;
 export declare function latestAssistantTurnHasFreshToolActivity(messages: readonly unknown[], now: number, maxAgeMs: number): boolean;
+export declare function latestAssistantTurnHasStaleUnknownSubstantiveOutput(messages: readonly unknown[], now: number, maxAgeMs: number): boolean;
 export declare function createEmptyAssistantTurnRetryDedupeKey(wake: PendingParentWake): string;

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

@@ -1,51 +1,5 @@
 import type { PendingParentWake } from "./parent-wake-dedupe";
-export type ParentWakeSessionMessage = {
-    readonly info?: {
-        readonly role?: string;
-        readonly finish?: string;
-        readonly error?: unknown;
-        readonly time?: {
-            readonly created?: unknown;
-            readonly updated?: unknown;
-            readonly completed?: unknown;
-            readonly start?: unknown;
-            readonly end?: unknown;
-        };
-    };
-    readonly role?: string;
-    readonly finish?: string;
-    readonly error?: unknown;
-    readonly time?: {
-        readonly created?: unknown;
-        readonly updated?: unknown;
-        readonly completed?: unknown;
-        readonly start?: unknown;
-        readonly end?: unknown;
-    };
-    readonly parts?: readonly {
-        readonly type?: string;
-        readonly text?: string;
-        readonly synthetic?: boolean;
-        readonly content?: unknown;
-        readonly time?: {
-            readonly created?: unknown;
-            readonly updated?: unknown;
-            readonly completed?: unknown;
-            readonly start?: unknown;
-            readonly end?: unknown;
-        };
-        readonly state?: {
-            readonly status?: unknown;
-            readonly time?: {
-                readonly created?: unknown;
-                readonly updated?: unknown;
-                readonly completed?: unknown;
-                readonly start?: unknown;
-                readonly end?: unknown;
-            };
-        };
-    }[];
-};
+import type { ParentWakeSessionMessage } from "./parent-wake-session-message";
 export type ToolWaitDeferralDecision = {
     readonly defer: boolean;
     readonly skipPromptGateToolStateCheck: boolean;

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

@@ -0,0 +1,47 @@
+export type ParentWakeSessionMessage = {
+    readonly info?: {
+        readonly role?: string;
+        readonly finish?: string;
+        readonly error?: unknown;
+        readonly time?: {
+            readonly created?: unknown;
+            readonly updated?: unknown;
+            readonly completed?: unknown;
+            readonly start?: unknown;
+            readonly end?: unknown;
+        };
+    };
+    readonly role?: string;
+    readonly finish?: string;
+    readonly error?: unknown;
+    readonly time?: {
+        readonly created?: unknown;
+        readonly updated?: unknown;
+        readonly completed?: unknown;
+        readonly start?: unknown;
+        readonly end?: unknown;
+    };
+    readonly parts?: readonly {
+        readonly type?: string;
+        readonly text?: string;
+        readonly synthetic?: boolean;
+        readonly content?: unknown;
+        readonly time?: {
+            readonly created?: unknown;
+            readonly updated?: unknown;
+            readonly completed?: unknown;
+            readonly start?: unknown;
+            readonly end?: unknown;
+        };
+        readonly state?: {
+            readonly status?: unknown;
+            readonly time?: {
+                readonly created?: unknown;
+                readonly updated?: unknown;
+                readonly completed?: unknown;
+                readonly start?: unknown;
+                readonly end?: unknown;
+            };
+        };
+    }[];
+};

package/dist/index.js

@@ -20989,6 +20989,11 @@ function isClaudeOpus47OrLaterModel(model) {
     return false;
   return major > 4 || major === 4 && minor >= 7;
 }
+var CLAUDE_FABLE_OR_MYTHOS_RE = /claude-(?:fable|mythos)-(?:\d+|preview)/;
+function isClaudeFableOrMythosModel(model) {
+  const modelName = extractModelName(model).toLowerCase().replaceAll(".", "-");
+  return CLAUDE_FABLE_OR_MYTHOS_RE.test(modelName);
+}
 function isKimiK2Model(model) {
   const modelName = extractModelName(model).toLowerCase();
   if (modelName.includes("kimi"))
@@ -23386,7 +23391,7 @@ var KIMI_CATEGORIES = [
 // packages/omo-opencode/src/agents/types.ts
 var CLAUDE_THINKING_BUDGET_TOKENS = 32000;
 function buildClaudeThinkingConfig(model) {
-  if (isClaudeOpus47OrLaterModel(model)) {
+  if (isClaudeOpus47OrLaterModel(model) || isClaudeFableOrMythosModel(model)) {
     return {};
   }
   return { thinking: { type: "enabled", budgetTokens: CLAUDE_THINKING_BUDGET_TOKENS } };
@@ -69992,7 +69997,7 @@ async function probe(registration) {
     registration.available = false;
     return false;
   }
-  const probeUrl = new URL("/session", registration.serverUrl);
+  const probeUrl = new URL("/global/health", registration.serverUrl);
   const authHeader = getServerBasicAuthHeader();
   const headers = authHeader ? { Authorization: authHeader } : {};
   try {
@@ -70026,12 +70031,17 @@ async function probe(registration) {
     return false;
   }
 }
-function hasFreshProbe(registration) {
-  return registration.available !== undefined && Date.now() - registration.probeTimestamp < PROBE_TTL_MS;
+function getFreshProbeAvailability(registration) {
+  const available = registration.available;
+  if (available === undefined || Date.now() - registration.probeTimestamp >= PROBE_TTL_MS) {
+    return;
+  }
+  return available;
 }
 async function resolveAvailability(registration) {
-  if (hasFreshProbe(registration)) {
-    return registration.available;
+  const freshAvailability = getFreshProbeAvailability(registration);
+  if (freshAvailability !== undefined) {
+    return freshAvailability;
   }
   if (!registration.inFlightProbe) {
     registration.inFlightProbe = probe(registration).finally(() => {
@@ -70066,10 +70076,11 @@ function tryResolveDispatchClientSync2(client3, sessionID) {
   if (!registration.serverUrl) {
     return { client: client3, route: "in-process", reason: "unavailable" };
   }
-  if (!hasFreshProbe(registration)) {
+  const freshAvailability = getFreshProbeAvailability(registration);
+  if (freshAvailability === undefined) {
     return;
   }
-  if (!registration.available) {
+  if (!freshAvailability) {
     return { client: client3, route: "in-process", reason: "unavailable" };
   }
   const resolvedLiveClient = getOrBuildLiveClient(registration);
@@ -70084,6 +70095,9 @@ async function resolveDispatchClient2(client3, sessionID) {
     return syncResult;
   }
   const registration = registrations.get(client3);
+  if (!registration) {
+    return { client: client3, route: "in-process", reason: "identity" };
+  }
   const isAvailable = await resolveAvailability(registration);
   if (!isAvailable) {
     return { client: client3, route: "in-process", reason: "unavailable" };
@@ -80669,7 +80683,7 @@ function getCachedVersion(options = {}) {
 // package.json
 var package_default = {
   name: "oh-my-opencode",
-  version: "4.11.1",
+  version: "4.12.0",
   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",
@@ -80839,18 +80853,18 @@ var package_default = {
     typescript: "^6.0.3"
   },
   optionalDependencies: {
-    "oh-my-opencode-darwin-arm64": "4.11.1",
-    "oh-my-opencode-darwin-x64": "4.11.1",
-    "oh-my-opencode-darwin-x64-baseline": "4.11.1",
-    "oh-my-opencode-linux-arm64": "4.11.1",
-    "oh-my-opencode-linux-arm64-musl": "4.11.1",
-    "oh-my-opencode-linux-x64": "4.11.1",
-    "oh-my-opencode-linux-x64-baseline": "4.11.1",
-    "oh-my-opencode-linux-x64-musl": "4.11.1",
-    "oh-my-opencode-linux-x64-musl-baseline": "4.11.1",
-    "oh-my-opencode-windows-arm64": "4.11.1",
-    "oh-my-opencode-windows-x64": "4.11.1",
-    "oh-my-opencode-windows-x64-baseline": "4.11.1"
+    "oh-my-opencode-darwin-arm64": "4.12.0",
+    "oh-my-opencode-darwin-x64": "4.12.0",
+    "oh-my-opencode-darwin-x64-baseline": "4.12.0",
+    "oh-my-opencode-linux-arm64": "4.12.0",
+    "oh-my-opencode-linux-arm64-musl": "4.12.0",
+    "oh-my-opencode-linux-x64": "4.12.0",
+    "oh-my-opencode-linux-x64-baseline": "4.12.0",
+    "oh-my-opencode-linux-x64-musl": "4.12.0",
+    "oh-my-opencode-linux-x64-musl-baseline": "4.12.0",
+    "oh-my-opencode-windows-arm64": "4.12.0",
+    "oh-my-opencode-windows-x64": "4.12.0",
+    "oh-my-opencode-windows-x64-baseline": "4.12.0"
   },
   overrides: {
     hono: "^4.12.18",
@@ -113764,10 +113778,60 @@ function getTimingConfig() {
   };
 }
 
-// packages/omo-opencode/src/tools/delegate-task/sync-session-poller.ts
-init_logger2();
+// packages/omo-opencode/src/tools/delegate-task/sync-session-turns.ts
 var NON_TERMINAL_FINISH_REASONS = new Set(["tool-calls", "unknown"]);
 var PENDING_TOOL_PART_TYPES = new Set(["tool", "tool_use", "tool-call"]);
+var ALL_BACKGROUND_TASKS_COMPLETE_MARKER = "[ALL BACKGROUND TASKS COMPLETE]";
+function getTextParts2(message) {
+  return (message.parts ?? []).filter((part) => part.type === "text").map((part) => part.text ?? "").join(`
+`);
+}
+function isInternalAllCompleteWake(message) {
+  return isTerminalNoReplyUserMessage(message) && getTextParts2(message).includes(ALL_BACKGROUND_TASKS_COMPLETE_MARKER);
+}
+function getLastSessionTurns(messages) {
+  let lastRelevantUser;
+  let lastAssistant;
+  for (let i = messages.length - 1;i >= 0; i--) {
+    const msg = messages[i];
+    if (msg === undefined)
+      continue;
+    if (!lastAssistant && msg.info?.role === "assistant")
+      lastAssistant = msg;
+    if (!lastRelevantUser && msg.info?.role === "user" && !isInternalAllCompleteWake(msg)) {
+      lastRelevantUser = msg;
+    }
+    if (lastRelevantUser && lastAssistant)
+      break;
+  }
+  return { lastAssistant, lastRelevantUser };
+}
+function isSessionComplete(messages) {
+  const { lastAssistant, lastRelevantUser } = getLastSessionTurns(messages);
+  if (!lastAssistant?.info?.finish)
+    return false;
+  if (NON_TERMINAL_FINISH_REASONS.has(lastAssistant.info.finish))
+    return false;
+  if (lastAssistant.parts?.some((part) => part.type && PENDING_TOOL_PART_TYPES.has(part.type)))
+    return false;
+  if (!lastRelevantUser?.info?.id || !lastAssistant?.info?.id)
+    return false;
+  return lastRelevantUser.info.id < lastAssistant.info.id;
+}
+function getTerminalSessionError(messages) {
+  const { lastAssistant, lastRelevantUser } = getLastSessionTurns(messages);
+  if (lastRelevantUser?.info?.id && lastAssistant?.info?.id && lastAssistant.info.id <= lastRelevantUser.info.id) {
+    return null;
+  }
+  if (!lastAssistant?.info || !("error" in lastAssistant.info)) {
+    return null;
+  }
+  const errorMessage = extractErrorMessage(lastAssistant.info.error);
+  return errorMessage && errorMessage.length > 0 ? errorMessage : "Session error";
+}
+
+// packages/omo-opencode/src/tools/delegate-task/sync-session-poller.ts
+init_logger2();
 var ACTIVE_SESSION_STATUSES2 = new Set(["busy", "retry", "running"]);
 var CHILD_WAKE_GRACE_MS = 5000;
 function wait(milliseconds) {
@@ -113794,40 +113858,6 @@ async function fetchSessionMessages(client3, sessionID) {
   const rawData = messagesResult?.data ?? messagesResult;
   return Array.isArray(rawData) ? rawData : [];
 }
-function getTerminalSessionError(messages) {
-  const lastAssistant = [...messages].reverse().find((msg) => msg.info?.role === "assistant");
-  const lastUser = [...messages].reverse().find((msg) => msg.info?.role === "user");
-  if (lastUser?.info?.id && lastAssistant?.info?.id && lastAssistant.info.id <= lastUser.info.id) {
-    return null;
-  }
-  if (!lastAssistant?.info || !("error" in lastAssistant.info)) {
-    return null;
-  }
-  const errorMessage = extractErrorMessage(lastAssistant.info.error);
-  return errorMessage && errorMessage.length > 0 ? errorMessage : "Session error";
-}
-function isSessionComplete(messages) {
-  let lastUser;
-  let lastAssistant;
-  for (let i = messages.length - 1;i >= 0; i--) {
-    const msg = messages[i];
-    if (!lastAssistant && msg.info?.role === "assistant")
-      lastAssistant = msg;
-    if (!lastUser && msg.info?.role === "user")
-      lastUser = msg;
-    if (lastUser && lastAssistant)
-      break;
-  }
-  if (!lastAssistant?.info?.finish)
-    return false;
-  if (NON_TERMINAL_FINISH_REASONS.has(lastAssistant.info.finish))
-    return false;
-  if (lastAssistant.parts?.some((part) => part.type && PENDING_TOOL_PART_TYPES.has(part.type)))
-    return false;
-  if (!lastUser?.info?.id || !lastAssistant?.info?.id)
-    return false;
-  return lastUser.info.id < lastAssistant.info.id;
-}
 var DEFAULT_MAX_ASSISTANT_TURNS = 300;
 async function pollSyncSession(ctx, client3, input, timeoutMs) {
   const syncTiming = getTimingConfig();
@@ -113870,11 +113900,12 @@ async function pollSyncSession(ctx, client3, input, timeoutMs) {
           finalMessages = await fetchSessionMessages(client3, input.sessionID);
           break;
         } catch (error) {
+          const errorMessage = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
           log2("[task] Final messages fetch failed after abort, retrying", {
             sessionID: input.sessionID,
             attempt,
             maxAttempts: abortFetchAttempts,
-            error: String(error)
+            error: errorMessage
           });
           if (attempt < abortFetchAttempts) {
             await wait(syncTiming.POLL_INTERVAL_MS);
@@ -113924,7 +113955,8 @@ Session ID: ${input.sessionID}`;
     try {
       messages = await fetchSessionMessages(client3, input.sessionID);
     } catch (error) {
-      log2("[task] Poll messages fetch failed, retrying", { sessionID: input.sessionID, error: String(error) });
+      const errorMessage = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+      log2("[task] Poll messages fetch failed, retrying", { sessionID: input.sessionID, error: errorMessage });
       continue;
     }
     if (input.anchorMessageCount !== undefined && messages.length <= input.anchorMessageCount) {
@@ -119356,9 +119388,38 @@ function timestampFromUnknown(value) {
   }
   return;
 }
+function latestTimestamp(...values) {
+  let latest;
+  for (const value of values) {
+    const timestamp = timestampFromUnknown(value);
+    if (timestamp === undefined) {
+      continue;
+    }
+    if (latest === undefined || timestamp > latest) {
+      latest = timestamp;
+    }
+  }
+  return latest;
+}
+function latestTimeActivity(time) {
+  if (!time) {
+    return;
+  }
+  return latestTimestamp(time.created, time.updated, time.completed, time.start, time.end);
+}
 function getParentWakeMessageCreatedAt(message) {
   return timestampFromUnknown(message.info?.time?.created ?? message.time?.created);
 }
+function getParentWakeMessageActivityAt(message) {
+  let latest = latestTimestamp(latestTimeActivity(message.info?.time), latestTimeActivity(message.time));
+  for (const part of message.parts ?? []) {
+    const partActivity = latestTimestamp(latestTimeActivity(part.time), latestTimeActivity(part.state?.time));
+    if (partActivity !== undefined && (latest === undefined || partActivity > latest)) {
+      latest = partActivity;
+    }
+  }
+  return latest;
+}
 
 // packages/omo-opencode/src/features/background-agent/parent-wake-history-state.ts
 function latestAssistantTurnIsCompletedEmptyNoProgress(messages) {
@@ -119408,6 +119469,20 @@ function latestAssistantTurnHasFreshToolActivity(messages, now, maxAgeMs) {
   }
   return false;
 }
+function latestAssistantTurnHasStaleUnknownSubstantiveOutput(messages, now, maxAgeMs) {
+  for (let index = messages.length - 1;index >= 0; index--) {
+    const message = messages[index];
+    const role = messageRole(message);
+    if (role === "assistant") {
+      const finish = messageFinish(message);
+      return (finish === undefined || finish === "unknown") && !messageCompleted(message) && messageHasSubstantiveAssistantOutput(message) && !messageHasFreshActivity(message, now, maxAgeMs);
+    }
+    if (role === "user" && !messageIsSyntheticOrInternalUser(message)) {
+      return false;
+    }
+  }
+  return false;
+}
 function createEmptyAssistantTurnRetryDedupeKey(wake) {
   return [
     "background-agent-parent-wake-empty-retry",
@@ -119422,6 +119497,13 @@ function partHasFreshToolActivity(part, now, maxAgeMs) {
   }
   return timeHasFreshActivity(part.time, now, maxAgeMs) || timeHasFreshActivity(isRecord(part.state) ? part.state.time : undefined, now, maxAgeMs);
 }
+function messageHasFreshActivity(message, now, maxAgeMs) {
+  if (!isRecord(message)) {
+    return false;
+  }
+  const activityAt = getParentWakeMessageActivityAt(message);
+  return activityAt !== undefined && now - activityAt <= maxAgeMs;
+}
 function timeHasFreshActivity(time, now, maxAgeMs) {
   if (!isRecord(time)) {
     return false;
@@ -119612,6 +119694,22 @@ class ParentWakeFlushRunner {
       });
       return;
     }
+    const finalToolWaitDecision = await this.confirmParentWakeStillSafeForReply(sessionID, latestWake, toolWaitDecision);
+    if (finalToolWaitDecision.defer) {
+      if (this.deferReplyWakeWhileUnsafe(sessionID, latestWake)) {
+        return;
+      }
+      await this.sendParentWakePrompt(sessionID, latestWake, {
+        emptyAssistantTurnRetry,
+        toolWaitDecision: { ...finalToolWaitDecision, skipPromptGateToolStateCheck: true },
+        forceNoReply: true,
+        retainPendingWake: latestWake.shouldReply
+      });
+      log2("[background-agent] Recorded admit-only parent wake because parent session history became unsafe:", {
+        sessionID
+      });
+      return;
+    }
     const dispatchedWake = this.deps.dispatchedTracker.getWake(sessionID);
     if (dispatchedWake && isRedundantParentWake(latestWake, dispatchedWake)) {
       this.deps.pendingQueue.deleteWake(sessionID);
@@ -119620,7 +119718,7 @@ class ParentWakeFlushRunner {
     }
     await this.sendParentWakePrompt(sessionID, latestWake, {
       emptyAssistantTurnRetry,
-      toolWaitDecision
+      toolWaitDecision: finalToolWaitDecision
     });
   }
   schedulePendingParentWakeFlush(sessionID, delayMs) {
@@ -119691,6 +119789,12 @@ class ParentWakeFlushRunner {
   async shouldDeferParentWakeForSessionHistory(sessionID, wake) {
     return this.deps.sessionInspector.shouldDeferForHistory(sessionID, wake);
   }
+  async confirmParentWakeStillSafeForReply(sessionID, wake, decision) {
+    if (!decision.skipPromptGateToolStateCheck) {
+      return decision;
+    }
+    return this.deps.sessionInspector.shouldDeferForHistory(sessionID, wake);
+  }
   requeueWake(sessionID, latestWake) {
     this.deps.pendingQueue.requeueWake(sessionID, latestWake);
   }
@@ -119858,6 +119962,12 @@ function getParentWakeSessionHistoryDeferralDecision(input) {
     log2("[background-agent] Holding parent wake during stale tool-call deferral:", { sessionID: input.sessionID });
     return { defer: true, skipPromptGateToolStateCheck: true };
   }
+  if (now - input.wake.toolCallDeferralStartedAt >= input.toolCallDeferMaxMs && latestAssistantTurnHasStaleUnknownSubstantiveOutput(messages, now, input.toolCallDeferMaxMs)) {
+    log2("[background-agent] Retrying parent wake after stale unknown-finish assistant output:", {
+      sessionID: input.sessionID
+    });
+    return { defer: false, skipPromptGateToolStateCheck: true };
+  }
   log2("[background-agent] Deferred parent wake because latest assistant turn blocks internal prompts:", {
     sessionID: input.sessionID
   });
@@ -144898,7 +145008,7 @@ async function loadPluginComponents(params) {
     const errorMessage = error instanceof Error ? error.message : String(error);
     log2("[config-handler] Plugin loading failed", { error: errorMessage });
     addConfigLoadError({ path: "plugin-loading", error: errorMessage });
-    return EMPTY_PLUGIN_COMPONENTS;
+    return { ...EMPTY_PLUGIN_COMPONENTS, retryableLoadFailure: true };
   }
 }
 
@@ -145037,8 +145147,38 @@ function collectTrustedVisionCapableModels(pluginConfig) {
   }
   return trusted;
 }
+function cloneConfigValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(cloneConfigValue);
+  }
+  if (typeof value === "object" && value !== null) {
+    return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, cloneConfigValue(entry)]));
+  }
+  return value;
+}
+function cloneAgentConfig(agents) {
+  return cloneConfigValue(agents);
+}
+function createAgentConfigCacheKey(config) {
+  return JSON.stringify({
+    agent: config.agent,
+    default_agent: config.default_agent,
+    model: config.model,
+    skills: config.skills
+  });
+}
+function replayAgentConfigSideEffects(params) {
+  if (params.configuredDefaultAgent && typeof params.defaultAgent === "string") {
+    setDefaultAgentForSort(params.defaultAgent);
+  }
+  clearRegisteredAgentNames();
+  for (const name of Object.keys(params.agentResult)) {
+    registerAgentName(name);
+  }
+}
 function createConfigHandler(deps) {
   const { ctx, pluginConfig, modelCacheState, runtimeSkillSourceUrl } = deps;
+  let agentConfigSnapshot;
   return async (config) => {
     const formatterConfig = config.formatter;
     setAdditionalAllowedMcpEnvVars(pluginConfig.mcp_env_allowlist ?? []);
@@ -145049,13 +145189,36 @@ function createConfigHandler(deps) {
     });
     clearFormatterCache();
     const pluginComponents = await loadPluginComponents({ pluginConfig });
+    const pluginComponentsLoadFailed = pluginComponents.retryableLoadFailure === true;
     applyHookConfig({ pluginComponents });
-    const agentResult = await applyAgentConfig({
-      config,
-      pluginConfig,
-      ctx,
-      pluginComponents
-    });
+    const agentCacheKey = createAgentConfigCacheKey(config);
+    let agentResult;
+    if (!pluginComponentsLoadFailed && agentConfigSnapshot?.cacheKey === agentCacheKey) {
+      config.agent = cloneAgentConfig(agentConfigSnapshot.agents);
+      if (agentConfigSnapshot.defaultAgent !== undefined) {
+        config.default_agent = agentConfigSnapshot.defaultAgent;
+      }
+      agentResult = config.agent;
+      replayAgentConfigSideEffects({
+        agentResult,
+        configuredDefaultAgent: agentConfigSnapshot.configuredDefaultAgent,
+        defaultAgent: config.default_agent
+      });
+    } else {
+      const configuredDefaultAgent = getConfiguredDefaultAgent(config);
+      agentResult = await applyAgentConfig({
+        config,
+        pluginConfig,
+        ctx,
+        pluginComponents
+      });
+      agentConfigSnapshot = pluginComponentsLoadFailed ? undefined : {
+        cacheKey: agentCacheKey,
+        configuredDefaultAgent,
+        defaultAgent: config.default_agent,
+        agents: cloneAgentConfig(agentResult)
+      };
+    }
     applyToolConfig({ config, pluginConfig, agentResult });
     await applyMcpConfig({ config, pluginConfig, ctx, pluginComponents });
     await applyCommandConfig({ config, pluginConfig, ctx, pluginComponents });
@@ -149975,6 +150138,15 @@ async function resolveSessionAgent(client3, sessionId) {
 // packages/omo-opencode/src/plugin/tool-execute-before.ts
 init_constants3();
 init_storage();
+var BACKGROUND_WAIT_BLOCK_MESSAGE = [
+  "Background task wait is already managed by the plugin.",
+  "End this response now and wait for the <system-reminder> completion notification.",
+  "After that reminder arrives, call background_output with the task_id from the launch result."
+].join(" ");
+function isPureSleepCommand(command) {
+  const commandLines = command.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#"));
+  return commandLines.length > 0 && commandLines.every((line) => /^sleep\s+\d+(?:\.\d+)?[smhd]?\s*$/i.test(line));
+}
 function getLoopCommandArguments(args, command) {
   const rawUserMessage = typeof args.user_message === "string" ? args.user_message.trim() : "";
   if (rawUserMessage) {
@@ -149984,7 +150156,7 @@ function getLoopCommandArguments(args, command) {
   return rawName.replace(new RegExp(`^/?(${command})\\s*`, "i"), "");
 }
 function createToolExecuteBeforeHandler3(args) {
-  const { ctx, hooks } = args;
+  const { ctx, hooks, backgroundManager } = args;
   function buildUltraworkOracleVerificationPrompt(prompt, originalTask, verificationAttemptId) {
     const verificationPrompt = [
       "You are verifying the active ULTRAWORK loop result for this session.",
@@ -150025,6 +150197,9 @@ function createToolExecuteBeforeHandler3(args) {
           callID: input.callID
         });
       }
+      if (isPureSleepCommand(output.args.command) && (backgroundManager?.hasActiveChildTasks(input.sessionID) === true || backgroundManager?.hasPendingParentWake(input.sessionID) === true)) {
+        throw new Error(BACKGROUND_WAIT_BLOCK_MESSAGE);
+      }
     }
     await hooks.writeExistingFileGuard?.["tool.execute.before"]?.(input, output);
     await hooks.notepadWriteGuard?.["tool.execute.before"]?.(input, output);
@@ -150192,7 +150367,8 @@ function createPluginInterface(args) {
     }),
     "tool.execute.before": createToolExecuteBeforeHandler3({
       ctx,
-      hooks
+      hooks,
+      backgroundManager: managers.backgroundManager
     }),
     "tool.execute.after": createToolExecuteAfterHandler3({
       ctx,

package/dist/plugin/tool-execute-before.d.ts

@@ -1,8 +1,10 @@
 import type { PluginContext } from "./types";
 import type { CreatedHooks } from "../create-hooks";
+import type { BackgroundManager } from "../features/background-agent";
 export declare function createToolExecuteBeforeHandler(args: {
     ctx: PluginContext;
     hooks: CreatedHooks;
+    backgroundManager?: Pick<BackgroundManager, "hasActiveChildTasks" | "hasPendingParentWake">;
 }): (input: {
     tool: string;
     sessionID: string;

package/dist/plugin-handlers/plugin-components-loader.d.ts

@@ -15,6 +15,7 @@ export type PluginComponents = {
         installPath: string;
         error: string;
     }>;
+    retryableLoadFailure?: true;
 };
 export declare function loadPluginComponents(params: {
     pluginConfig: OhMyOpenCodeConfig;

package/dist/skills/ulw-plan/SKILL.md

@@ -17,6 +17,7 @@ Outcome-first: explore a lot, ask few sharp questions - or none, when the intent
 
 After grounding, make ONE judgment and load ONE intent reference (you ALSO read `references/full-workflow.md` for the shared mechanics - see below). The test keys on whether the desired **OUTCOME** is clear, NOT on request length.
 
+- **OVERRIDE - explicit ask wins:** if the user explicitly asks to be questioned or interviewed ("ask me", "interview me", "why aren't you asking me" - in any language), route **CLEAR**, run the interview, and turn the adopt-default filter OFF: the user has claimed the forks, so every surviving one is ASKED, not defaulted. This beats the OUTCOME test below, even on a fuzzy brief.
 - **CLEAR** - the user knows the outcome; the only open items are preferences/tradeoffs the repo cannot answer (genuine owner-decisions). Read **`references/intent-clear.md`**: ask the surviving forks with WHY, run the normal approval gate, high-accuracy review is OPTIONAL (offered as one question).
 - **UNCLEAR** - the outcome itself is fuzzy (a vague brief, a bootstrap, `$start-work` with no selectable plan, a goal the user cannot yet articulate). Asking would offload your own job onto the user. Read **`references/intent-unclear.md`**: research maximally, adopt and ANNOUNCE best-practice defaults, do NOT ask the user extra questions, and run high-accuracy review AUTOMATICALLY (unless Classify sized the work Trivial).
 - **ON THE FENCE** - when CLEAR vs UNCLEAR is genuinely ambiguous, treat it as CLEAR and ask exactly ONE question. A user wrongly silenced is worse than one extra question. The dominant failure to guard against is mis-routing a CLEAR request to UNCLEAR, which silently applies defaults and overrides forks the user wanted to own.
@@ -42,7 +43,7 @@ Run it ONCE at plan generation. A plain re-run on an existing plan is a safe no-
 - **Decision-complete is the north star.** The executor has NO interview context - spell out exact paths, "every X in Y", and an explicit Must-NOT-Have. Leave the implementer ZERO judgment calls.
 - **Explore before asking.** Discoverable facts (repo/system/docs truth) -> research and cite, never ask. Preferences/tradeoffs -> the only things you bring to the user. When unsure which, treat it as a user-decision.
 - **CodeGraph first when present.** Use `codegraph_explore` for repo how/where/what/flow questions before wider reads; if codegraph_* tools are absent, inactive/uninitialized, or cold-start unavailable, continue with Read/Grep/Glob/LSP and the ast-grep skill.
-- **Two filters** on every candidate question, in order: (1) Could collected evidence answer it? -> explore instead. (2) Could the user's stated intent plus a defensible default answer it? -> adopt the default, record it, do not ask. Only a real fork survives.
+- **Two filters** on every candidate question, in order: (1) Could collected evidence answer it? -> explore instead. (2) Could the user's stated intent plus a defensible default answer it? -> adopt the default, record it, do not ask - UNLESS it is an owner-decision, which always survives as a question even when a default exists: anything irreversible / destructive / safety-critical, or a cross-cutting product choice the user lives with (public config surface, distribution / packaging, external dependency or pinned SHA, data / schema shape). Default the reversible internals; surface the owner-decisions.
 - **Explore to sufficiency, then STOP.** One research wave per open question; stop when the clearance check is answerable; never re-explore to double-check.
 - **Parallel-dispatch** independent research in ONE turn and keep working while it runs. Subagent outputs are CLAIMS until you independently verify them.
 - **Approval is not execution.** Approval authorizes writing the plan ONLY, never implementation. ONE request -> ONE plan, however large.