release: v0.4.1

package.json

@@ -1,6 +1,6 @@
 {
   "name": "oh-my-opencode",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "OpenCode plugin - custom agents (oracle, librarian) and enhanced features",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/agents/utils.ts

@@ -5,6 +5,7 @@ import { librarianAgent } from "./librarian"
 import { exploreAgent } from "./explore"
 import { frontendUiUxEngineerAgent } from "./frontend-ui-ux-engineer"
 import { documentWriterAgent } from "./document-writer"
+import { deepMerge } from "../shared"
 
 const allBuiltinAgents: Record<AgentName, AgentConfig> = {
   oracle: oracleAgent,
@@ -18,16 +19,7 @@ function mergeAgentConfig(
   base: AgentConfig,
   override: AgentOverrideConfig
 ): AgentConfig {
-  return {
-    ...base,
-    ...override,
-    tools: override.tools !== undefined
-      ? { ...(base.tools ?? {}), ...override.tools }
-      : base.tools,
-    permission: override.permission !== undefined
-      ? { ...(base.permission ?? {}), ...override.permission }
-      : base.permission,
-  }
+  return deepMerge(base, override as Partial<AgentConfig>)
 }
 
 export function createBuiltinAgents(

src/hooks/index.ts

@@ -1,7 +1,7 @@
-export { createTodoContinuationEnforcer } from "./todo-continuation-enforcer";
+export { createTodoContinuationEnforcer, type TodoContinuationEnforcer } from "./todo-continuation-enforcer";
 export { createContextWindowMonitorHook } from "./context-window-monitor";
 export { createSessionNotification } from "./session-notification";
-export { createSessionRecoveryHook } from "./session-recovery";
+export { createSessionRecoveryHook, type SessionRecoveryHook } from "./session-recovery";
 export { createCommentCheckerHooks } from "./comment-checker";
 export { createGrepOutputTruncatorHook } from "./grep-output-truncator";
 export { createDirectoryAgentsInjectorHook } from "./directory-agents-injector";

src/hooks/session-recovery/index.ts

@@ -216,14 +216,26 @@ async function recoverEmptyContentMessage(
 // All error types have dedicated recovery functions (recoverToolResultMissing,
 // recoverThinkingBlockOrder, recoverThinkingDisabledViolation, recoverEmptyContentMessage).
 
-export function createSessionRecoveryHook(ctx: PluginInput) {
+export interface SessionRecoveryHook {
+  handleSessionRecovery: (info: MessageInfo) => Promise<boolean>
+  isRecoverableError: (error: unknown) => boolean
+  setOnAbortCallback: (callback: (sessionID: string) => void) => void
+  setOnRecoveryCompleteCallback: (callback: (sessionID: string) => void) => void
+}
+
+export function createSessionRecoveryHook(ctx: PluginInput): SessionRecoveryHook {
   const processingErrors = new Set<string>()
   let onAbortCallback: ((sessionID: string) => void) | null = null
+  let onRecoveryCompleteCallback: ((sessionID: string) => void) | null = null
 
   const setOnAbortCallback = (callback: (sessionID: string) => void): void => {
     onAbortCallback = callback
   }
 
+  const setOnRecoveryCompleteCallback = (callback: (sessionID: string) => void): void => {
+    onRecoveryCompleteCallback = callback
+  }
+
   const isRecoverableError = (error: unknown): boolean => {
     return detectErrorType(error) !== null
   }
@@ -242,12 +254,12 @@ export function createSessionRecoveryHook(ctx: PluginInput) {
     processingErrors.add(assistantMsgID)
 
     try {
-      await ctx.client.session.abort({ path: { id: sessionID } }).catch(() => {})
-
       if (onAbortCallback) {
-        onAbortCallback(sessionID)
+        onAbortCallback(sessionID)  // Mark recovering BEFORE abort
       }
 
+      await ctx.client.session.abort({ path: { id: sessionID } }).catch(() => {})
+
       const messagesResp = await ctx.client.session.messages({
         path: { id: sessionID },
         query: { directory: ctx.directory },
@@ -301,6 +313,11 @@ export function createSessionRecoveryHook(ctx: PluginInput) {
     return false
   } finally {
     processingErrors.delete(assistantMsgID)
+
+    // Always notify recovery complete, regardless of success or failure
+    if (sessionID && onRecoveryCompleteCallback) {
+      onRecoveryCompleteCallback(sessionID)
+    }
   }
   }
 
@@ -308,5 +325,6 @@ export function createSessionRecoveryHook(ctx: PluginInput) {
     handleSessionRecovery,
     isRecoverableError,
     setOnAbortCallback,
+    setOnRecoveryCompleteCallback,
   }
 }

src/hooks/todo-continuation-enforcer.ts

@@ -1,5 +1,11 @@
 import type { PluginInput } from "@opencode-ai/plugin"
 
+export interface TodoContinuationEnforcer {
+  handler: (input: { event: { type: string; properties?: unknown } }) => Promise<void>
+  markRecovering: (sessionID: string) => void
+  markRecoveryComplete: (sessionID: string) => void
+}
+
 interface Todo {
   content: string
   status: string
@@ -32,13 +38,22 @@ function detectInterrupt(error: unknown): boolean {
   return false
 }
 
-export function createTodoContinuationEnforcer(ctx: PluginInput) {
+export function createTodoContinuationEnforcer(ctx: PluginInput): TodoContinuationEnforcer {
   const remindedSessions = new Set<string>()
   const interruptedSessions = new Set<string>()
   const errorSessions = new Set<string>()
+  const recoveringSessions = new Set<string>()
   const pendingTimers = new Map<string, ReturnType<typeof setTimeout>>()
 
-  return async ({ event }: { event: { type: string; properties?: unknown } }) => {
+  const markRecovering = (sessionID: string): void => {
+    recoveringSessions.add(sessionID)
+  }
+
+  const markRecoveryComplete = (sessionID: string): void => {
+    recoveringSessions.delete(sessionID)
+  }
+
+  const handler = async ({ event }: { event: { type: string; properties?: unknown } }): Promise<void> => {
     const props = event.properties as Record<string, unknown> | undefined
 
     if (event.type === "session.error") {
@@ -73,6 +88,11 @@ export function createTodoContinuationEnforcer(ctx: PluginInput) {
       const timer = setTimeout(async () => {
         pendingTimers.delete(sessionID)
 
+        // Check if session is in recovery mode - if so, skip entirely without clearing state
+        if (recoveringSessions.has(sessionID)) {
+          return
+        }
+
         const shouldBypass = interruptedSessions.has(sessionID) || errorSessions.has(sessionID)
         
         interruptedSessions.delete(sessionID)
@@ -111,7 +131,7 @@ export function createTodoContinuationEnforcer(ctx: PluginInput) {
         remindedSessions.add(sessionID)
 
         // Re-check if abort occurred during the delay/fetch
-        if (interruptedSessions.has(sessionID) || errorSessions.has(sessionID)) {
+        if (interruptedSessions.has(sessionID) || errorSessions.has(sessionID) || recoveringSessions.has(sessionID)) {
           remindedSessions.delete(sessionID)
           return
         }
@@ -158,6 +178,7 @@ export function createTodoContinuationEnforcer(ctx: PluginInput) {
         remindedSessions.delete(sessionInfo.id)
         interruptedSessions.delete(sessionInfo.id)
         errorSessions.delete(sessionInfo.id)
+        recoveringSessions.delete(sessionInfo.id)
         
         // Cancel pending continuation
         const timer = pendingTimers.get(sessionInfo.id)
@@ -168,4 +189,10 @@ export function createTodoContinuationEnforcer(ctx: PluginInput) {
       }
     }
   }
+
+  return {
+    handler,
+    markRecovering,
+    markRecoveryComplete,
+  }
 }

src/index.ts

@@ -42,7 +42,7 @@ import { builtinTools, createCallOmoAgent, createBackgroundTools } from "./tools
 import { BackgroundManager } from "./features/background-agent";
 import { createBuiltinMcps } from "./mcp";
 import { OhMyOpenCodeConfigSchema, type OhMyOpenCodeConfig } from "./config";
-import { log } from "./shared/logger";
+import { log, deepMerge } from "./shared";
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
@@ -89,10 +89,7 @@ function mergeConfigs(
   return {
     ...base,
     ...override,
-    agents:
-      override.agents !== undefined
-        ? { ...(base.agents ?? {}), ...override.agents }
-        : base.agents,
+    agents: deepMerge(base.agents, override.agents),
     disabled_agents: [
       ...new Set([
         ...(base.disabled_agents ?? []),
@@ -105,10 +102,7 @@ function mergeConfigs(
         ...(override.disabled_mcps ?? []),
       ]),
     ],
-    claude_code:
-      override.claude_code !== undefined || base.claude_code !== undefined
-        ? { ...(base.claude_code ?? {}), ...(override.claude_code ?? {}) }
-        : undefined,
+    claude_code: deepMerge(base.claude_code, override.claude_code),
   };
 }
 
@@ -151,6 +145,12 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
   const todoContinuationEnforcer = createTodoContinuationEnforcer(ctx);
   const contextWindowMonitor = createContextWindowMonitorHook(ctx);
   const sessionRecovery = createSessionRecoveryHook(ctx);
+
+  // Wire up recovery state tracking between session-recovery and todo-continuation-enforcer
+  // This prevents the continuation enforcer from injecting prompts during active recovery
+  sessionRecovery.setOnAbortCallback(todoContinuationEnforcer.markRecovering);
+  sessionRecovery.setOnRecoveryCompleteCallback(todoContinuationEnforcer.markRecoveryComplete);
+
   const commentChecker = createCommentCheckerHooks();
   const grepOutputTruncator = createGrepOutputTruncatorHook(ctx);
   const directoryAgentsInjector = createDirectoryAgentsInjectorHook(ctx);
@@ -248,7 +248,7 @@ const OhMyOpenCodePlugin: Plugin = async (ctx) => {
       await autoUpdateChecker.event(input);
       await claudeCodeHooks.event(input);
       await backgroundNotificationHook.event(input);
-      await todoContinuationEnforcer(input);
+      await todoContinuationEnforcer.handler(input);
       await contextWindowMonitor.event(input);
       await directoryAgentsInjector.event(input);
       await directoryReadmeInjector.event(input);

src/shared/deep-merge.ts

@@ -0,0 +1,53 @@
+const DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+const MAX_DEPTH = 50;
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    Object.prototype.toString.call(value) === "[object Object]"
+  );
+}
+
+/**
+ * Deep merges two objects, with override values taking precedence.
+ * - Objects are recursively merged
+ * - Arrays are replaced (not concatenated)
+ * - undefined values in override do not overwrite base values
+ *
+ * @example
+ * deepMerge({ a: 1, b: { c: 2, d: 3 } }, { b: { c: 10 }, e: 5 })
+ * // => { a: 1, b: { c: 10, d: 3 }, e: 5 }
+ */
+export function deepMerge<T extends Record<string, unknown>>(base: T, override: Partial<T>, depth?: number): T;
+export function deepMerge<T extends Record<string, unknown>>(base: T | undefined, override: T | undefined, depth?: number): T | undefined;
+export function deepMerge<T extends Record<string, unknown>>(
+  base: T | undefined,
+  override: T | undefined,
+  depth = 0
+): T | undefined {
+  if (!base && !override) return undefined;
+  if (!base) return override;
+  if (!override) return base;
+  if (depth > MAX_DEPTH) return override ?? base;
+
+  const result = { ...base } as Record<string, unknown>;
+
+  for (const key of Object.keys(override)) {
+    if (DANGEROUS_KEYS.has(key)) continue;
+
+    const baseValue = base[key];
+    const overrideValue = override[key];
+
+    if (overrideValue === undefined) continue;
+
+    if (isPlainObject(baseValue) && isPlainObject(overrideValue)) {
+      result[key] = deepMerge(baseValue, overrideValue, depth + 1);
+    } else {
+      result[key] = overrideValue;
+    }
+  }
+
+  return result as T;
+}

src/shared/index.ts

@@ -7,3 +7,4 @@ export * from "./snake-case"
 export * from "./tool-name"
 export * from "./pattern-matcher"
 export * from "./hook-disabled"
+export * from "./deep-merge"