Merge pull request #1981 from VespianRex/fix/fallback-sync-model-ui

Fix model fallback retries for main, background, and sync subagents + show runtime fallback model in task UI

src/plugin/chat-message.ts

@@ -2,6 +2,7 @@ import type { OhMyOpenCodeConfig } from "../config"
 import type { PluginContext } from "./types"
 
 import { hasConnectedProvidersCache } from "../shared"
+import { setSessionModel } from "../shared/session-model-state"
 import { setSessionAgent } from "../features/claude-code-session-state"
 import { applyUltraworkModelOverrideOnMessage } from "./ultrawork-model-override"
 
@@ -13,7 +14,12 @@ type FirstMessageVariantGate = {
 }
 
 type ChatMessagePart = { type: string; text?: string; [key: string]: unknown }
-type ChatMessageHandlerOutput = { message: Record<string, unknown>; parts: ChatMessagePart[] }
+export type ChatMessageHandlerOutput = { message: Record<string, unknown>; parts: ChatMessagePart[] }
+export type ChatMessageInput = {
+  sessionID: string
+  agent?: string
+  model?: { providerID: string; modelID: string }
+}
 type StartWorkHookOutput = { parts: Array<{ type: string; text?: string }> }
 
 function isStartWorkHookOutput(value: unknown): value is StartWorkHookOutput {
@@ -34,13 +40,13 @@ export function createChatMessageHandler(args: {
   firstMessageVariantGate: FirstMessageVariantGate
   hooks: CreatedHooks
 }): (
-  input: { sessionID: string; agent?: string; model?: { providerID: string; modelID: string } },
+  input: ChatMessageInput,
   output: ChatMessageHandlerOutput
 ) => Promise<void> {
   const { ctx, pluginConfig, firstMessageVariantGate, hooks } = args
 
   return async (
-    input: { sessionID: string; agent?: string; model?: { providerID: string; modelID: string } },
+    input: ChatMessageInput,
     output: ChatMessageHandlerOutput
   ): Promise<void> => {
     if (input.agent) {
@@ -53,6 +59,22 @@ export function createChatMessageHandler(args: {
       firstMessageVariantGate.markApplied(input.sessionID)
     }
 
+    await hooks.modelFallback?.["chat.message"]?.(input, output)
+    const modelOverride = output.message["model"]
+    if (
+      modelOverride &&
+      typeof modelOverride === "object" &&
+      "providerID" in modelOverride &&
+      "modelID" in modelOverride
+    ) {
+      const providerID = (modelOverride as { providerID?: string }).providerID
+      const modelID = (modelOverride as { modelID?: string }).modelID
+      if (typeof providerID === "string" && typeof modelID === "string") {
+        setSessionModel(input.sessionID, { providerID, modelID })
+      }
+    } else if (input.model) {
+      setSessionModel(input.sessionID, input.model)
+    }
     await hooks.stopContinuationGuard?.["chat.message"]?.(input)
     await hooks.keywordDetector?.["chat.message"]?.(input, output)
     await hooks.claudeCodeHooks?.["chat.message"]?.(input, output)

src/plugin/chat-params.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "bun:test"
+
+import { createChatParamsHandler } from "./chat-params"
+
+describe("createChatParamsHandler", () => {
+  test("normalizes object-style agent payload and runs chat.params hooks", async () => {
+    //#given
+    let called = false
+    const handler = createChatParamsHandler({
+      anthropicEffort: {
+        "chat.params": async (input) => {
+          called = input.agent.name === "sisyphus"
+        },
+      },
+    })
+
+    const input = {
+      sessionID: "ses_chat_params",
+      agent: { name: "sisyphus" },
+      model: { providerID: "opencode", modelID: "claude-opus-4-6" },
+      provider: { id: "opencode" },
+      message: {},
+    }
+
+    const output = {
+      temperature: 0.1,
+      topP: 1,
+      topK: 1,
+      options: {},
+    }
+
+    //#when
+    await handler(input, output)
+
+    //#then
+    expect(called).toBe(true)
+  })
+})

src/plugin/chat-params.ts

@@ -1,4 +1,4 @@
-type ChatParamsInput = {
+export type ChatParamsInput = {
   sessionID: string
   agent: { name?: string }
   model: { providerID: string; modelID: string }
@@ -6,7 +6,7 @@ type ChatParamsInput = {
   message: { variant?: string }
 }
 
-type ChatParamsOutput = {
+export type ChatParamsOutput = {
   temperature?: number
   topP?: number
   topK?: number
@@ -27,11 +27,21 @@ function buildChatParamsInput(raw: unknown): ChatParamsInput | null {
   const message = raw.message
 
   if (typeof sessionID !== "string") return null
-  if (typeof agent !== "string") return null
   if (!isRecord(model)) return null
   if (!isRecord(provider)) return null
   if (!isRecord(message)) return null
 
+  let agentName: string | undefined
+  if (typeof agent === "string") {
+    agentName = agent
+  } else if (isRecord(agent)) {
+    const name = agent.name
+    if (typeof name === "string") {
+      agentName = name
+    }
+  }
+  if (!agentName) return null
+
   const providerID = model.providerID
   const modelID = model.modelID
   const providerId = provider.id
@@ -43,7 +53,7 @@ function buildChatParamsInput(raw: unknown): ChatParamsInput | null {
 
   return {
     sessionID,
-    agent: { name: agent },
+    agent: { name: agentName },
     model: { providerID, modelID },
     provider: { id: providerId },
     message: typeof variant === "string" ? { variant } : {},

src/plugin/event.model-fallback.test.ts

@@ -0,0 +1,343 @@
+import { afterEach, describe, expect, test } from "bun:test"
+
+import { createEventHandler } from "./event"
+import { createChatMessageHandler } from "./chat-message"
+import { _resetForTesting, setMainSession } from "../features/claude-code-session-state"
+import { createModelFallbackHook, clearPendingModelFallback } from "../hooks/model-fallback/hook"
+
+describe("createEventHandler - model fallback", () => {
+  const createHandler = (args?: { hooks?: any }) => {
+    const abortCalls: string[] = []
+    const promptCalls: string[] = []
+
+    const handler = createEventHandler({
+      ctx: {
+        directory: "/tmp",
+        client: {
+          session: {
+            abort: async ({ path }: { path: { id: string } }) => {
+              abortCalls.push(path.id)
+              return {}
+            },
+            prompt: async ({ path }: { path: { id: string } }) => {
+              promptCalls.push(path.id)
+              return {}
+            },
+          },
+        },
+      } as any,
+      pluginConfig: {} as any,
+      firstMessageVariantGate: {
+        markSessionCreated: () => {},
+        clear: () => {},
+      },
+      managers: {
+        tmuxSessionManager: {
+          onSessionCreated: async () => {},
+          onSessionDeleted: async () => {},
+        },
+        skillMcpManager: {
+          disconnectSession: async () => {},
+        },
+      } as any,
+      hooks: args?.hooks ?? ({} as any),
+    })
+
+    return { handler, abortCalls, promptCalls }
+  }
+
+  afterEach(() => {
+    _resetForTesting()
+  })
+
+  test("triggers retry prompt for assistant message.updated APIError payloads (headless resume)", async () => {
+    //#given
+    const sessionID = "ses_message_updated_fallback"
+    const { handler, abortCalls, promptCalls } = createHandler()
+
+    //#when
+    await handler({
+      event: {
+        type: "message.updated",
+        properties: {
+          info: {
+            id: "msg_err_1",
+            sessionID,
+            role: "assistant",
+            time: { created: 1, completed: 2 },
+            error: {
+              name: "APIError",
+              data: {
+                message:
+                  "Bad Gateway: {\"error\":{\"message\":\"unknown provider for model claude-opus-4-6-thinking\"}}",
+                isRetryable: true,
+              },
+            },
+            parentID: "msg_user_1",
+            modelID: "claude-opus-4-6-thinking",
+            providerID: "quotio",
+            mode: "Sisyphus (Ultraworker)",
+            agent: "Sisyphus (Ultraworker)",
+            path: { cwd: "/tmp", root: "/tmp" },
+            cost: 0,
+            tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
+          },
+        },
+      },
+    })
+
+    //#then
+    expect(abortCalls).toEqual([sessionID])
+    expect(promptCalls).toEqual([sessionID])
+  })
+
+  test("triggers retry prompt for nested model error payloads", async () => {
+    //#given
+    const sessionID = "ses_main_fallback_nested"
+    setMainSession(sessionID)
+    const { handler, abortCalls, promptCalls } = createHandler()
+
+    //#when
+    await handler({
+      event: {
+        type: "session.error",
+        properties: {
+          sessionID,
+          error: {
+            name: "UnknownError",
+            data: {
+              error: {
+                message:
+                  "Bad Gateway: {\"error\":{\"message\":\"unknown provider for model claude-opus-4-6-thinking\"}}",
+              },
+            },
+          },
+        },
+      },
+    })
+
+    //#then
+    expect(abortCalls).toEqual([sessionID])
+    expect(promptCalls).toEqual([sessionID])
+  })
+
+  test("triggers retry prompt on session.status retry events and applies fallback", async () => {
+    //#given
+    const sessionID = "ses_status_retry_fallback"
+    setMainSession(sessionID)
+    clearPendingModelFallback(sessionID)
+
+    const modelFallback = createModelFallbackHook()
+
+    const { handler, abortCalls, promptCalls } = createHandler({ hooks: { modelFallback } })
+
+    const chatMessageHandler = createChatMessageHandler({
+      ctx: {
+        client: {
+          tui: {
+            showToast: async () => ({}),
+          },
+        },
+      } as any,
+      pluginConfig: {} as any,
+      firstMessageVariantGate: {
+        shouldOverride: () => false,
+        markApplied: () => {},
+      },
+      hooks: {
+        modelFallback,
+        stopContinuationGuard: null,
+        keywordDetector: null,
+        claudeCodeHooks: null,
+        autoSlashCommand: null,
+        startWork: null,
+        ralphLoop: null,
+      } as any,
+    })
+
+    await handler({
+      event: {
+        type: "message.updated",
+        properties: {
+          info: {
+            id: "msg_user_status_1",
+            sessionID,
+            role: "user",
+            time: { created: 1 },
+            content: [],
+            modelID: "claude-opus-4-6-thinking",
+            providerID: "quotio",
+            agent: "Sisyphus (Ultraworker)",
+            path: { cwd: "/tmp", root: "/tmp" },
+          },
+        },
+      },
+    })
+
+    //#when
+    await handler({
+      event: {
+        type: "session.status",
+        properties: {
+          sessionID,
+          status: {
+            type: "retry",
+            attempt: 1,
+            message:
+              "Bad Gateway: {\"error\":{\"message\":\"unknown provider for model claude-opus-4-6-thinking\"}}",
+            next: 1234,
+          },
+        },
+      },
+    })
+
+    const output = { message: {}, parts: [] as Array<{ type: string; text?: string }> }
+    await chatMessageHandler(
+      {
+        sessionID,
+        agent: "sisyphus",
+        model: { providerID: "quotio", modelID: "claude-opus-4-6-thinking" },
+      },
+      output,
+    )
+
+    //#then
+    expect(abortCalls).toEqual([sessionID])
+    expect(promptCalls).toEqual([sessionID])
+    expect(output.message["model"]).toEqual({
+      providerID: "quotio",
+      modelID: "claude-opus-4-6",
+    })
+    expect(output.message["variant"]).toBe("max")
+  })
+
+  test("advances main-session fallback chain across repeated session.error retries end-to-end", async () => {
+    //#given
+    const abortCalls: string[] = []
+    const promptCalls: string[] = []
+    const toastCalls: string[] = []
+    const sessionID = "ses_main_fallback_chain"
+    setMainSession(sessionID)
+    clearPendingModelFallback(sessionID)
+
+    const modelFallback = createModelFallbackHook()
+
+    const eventHandler = createEventHandler({
+      ctx: {
+        directory: "/tmp",
+        client: {
+          session: {
+            abort: async ({ path }: { path: { id: string } }) => {
+              abortCalls.push(path.id)
+              return {}
+            },
+            prompt: async ({ path }: { path: { id: string } }) => {
+              promptCalls.push(path.id)
+              return {}
+            },
+          },
+        },
+      } as any,
+      pluginConfig: {} as any,
+      firstMessageVariantGate: {
+        markSessionCreated: () => {},
+        clear: () => {},
+      },
+      managers: {
+        tmuxSessionManager: {
+          onSessionCreated: async () => {},
+          onSessionDeleted: async () => {},
+        },
+        skillMcpManager: {
+          disconnectSession: async () => {},
+        },
+      } as any,
+      hooks: {
+        modelFallback,
+      } as any,
+    })
+
+    const chatMessageHandler = createChatMessageHandler({
+      ctx: {
+        client: {
+          tui: {
+            showToast: async ({ body }: { body: { title?: string } }) => {
+              if (body?.title) toastCalls.push(body.title)
+              return {}
+            },
+          },
+        },
+      } as any,
+      pluginConfig: {} as any,
+      firstMessageVariantGate: {
+        shouldOverride: () => false,
+        markApplied: () => {},
+      },
+      hooks: {
+        modelFallback,
+        stopContinuationGuard: null,
+        keywordDetector: null,
+        claudeCodeHooks: null,
+        autoSlashCommand: null,
+        startWork: null,
+        ralphLoop: null,
+      } as any,
+    })
+
+    const triggerRetryCycle = async () => {
+      await eventHandler({
+        event: {
+          type: "session.error",
+          properties: {
+            sessionID,
+            providerID: "quotio",
+            modelID: "claude-opus-4-6-thinking",
+            error: {
+              name: "UnknownError",
+              data: {
+                error: {
+                  message:
+                    "Bad Gateway: {\"error\":{\"message\":\"unknown provider for model claude-opus-4-6-thinking\"}}",
+                },
+              },
+            },
+          },
+        },
+      })
+
+      const output = { message: {}, parts: [] as Array<{ type: string; text?: string }> }
+      await chatMessageHandler(
+        {
+          sessionID,
+          agent: "sisyphus",
+          model: { providerID: "quotio", modelID: "claude-opus-4-6-thinking" },
+        },
+        output,
+      )
+      return output
+    }
+
+    //#when - first retry cycle
+    const first = await triggerRetryCycle()
+
+    //#then - first fallback entry applied (prefers current provider when available)
+    expect(first.message["model"]).toEqual({
+      providerID: "quotio",
+      modelID: "claude-opus-4-6",
+    })
+    expect(first.message["variant"]).toBe("max")
+
+    //#when - second retry cycle
+    const second = await triggerRetryCycle()
+
+    //#then - second fallback entry applied (chain advanced)
+    expect(second.message["model"]).toEqual({
+      providerID: "quotio",
+      modelID: "gpt-5.3-codex",
+    })
+    expect(second.message["variant"]).toBe("high")
+    expect(abortCalls).toEqual([sessionID, sessionID])
+    expect(promptCalls).toEqual([sessionID, sessionID])
+    expect(toastCalls.length).toBeGreaterThanOrEqual(0)
+  })
+})

src/plugin/event.ts

@@ -4,11 +4,17 @@ import type { PluginContext } from "./types"
 import {
   clearSessionAgent,
   getMainSessionID,
+  getSessionAgent,
+  subagentSessions,
+  syncSubagentSessions,
   setMainSession,
   updateSessionAgent,
 } from "../features/claude-code-session-state"
 import { resetMessageCursor } from "../shared"
 import { lspManager } from "../tools"
+import { shouldRetryError } from "../shared/model-error-classifier"
+import { clearPendingModelFallback, clearSessionFallbackChain, setPendingModelFallback } from "../hooks/model-fallback/hook"
+import { clearSessionModel, setSessionModel } from "../shared/session-model-state"
 
 import type { CreatedHooks } from "../create-hooks"
 import type { Managers } from "../create-managers"
@@ -20,6 +26,74 @@ type FirstMessageVariantGate = {
   clear: (sessionID: string) => void
 }
 
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null
+}
+
+function normalizeFallbackModelID(modelID: string): string {
+  return modelID
+    .replace(/-thinking$/i, "")
+    .replace(/-max$/i, "")
+    .replace(/-high$/i, "")
+}
+
+function extractErrorName(error: unknown): string | undefined {
+  if (isRecord(error) && typeof error.name === "string") return error.name
+  if (error instanceof Error) return error.name
+  return undefined
+}
+
+function extractErrorMessage(error: unknown): string {
+  if (!error) return ""
+  if (typeof error === "string") return error
+  if (error instanceof Error) return error.message
+
+  if (isRecord(error)) {
+    const candidates: unknown[] = [
+      error,
+      error.data,
+      error.error,
+      isRecord(error.data) ? error.data.error : undefined,
+      error.cause,
+    ]
+
+    for (const candidate of candidates) {
+      if (isRecord(candidate) && typeof candidate.message === "string" && candidate.message.length > 0) {
+        return candidate.message
+      }
+    }
+  }
+
+  try {
+    return JSON.stringify(error)
+  } catch {
+    return String(error)
+  }
+}
+
+function extractProviderModelFromErrorMessage(
+  message: string,
+): { providerID?: string; modelID?: string } {
+  const lower = message.toLowerCase()
+
+  const providerModel = lower.match(/model\s+not\s+found:\s*([a-z0-9_-]+)\s*\/\s*([a-z0-9._-]+)/i)
+  if (providerModel) {
+    return {
+      providerID: providerModel[1],
+      modelID: providerModel[2],
+    }
+  }
+
+  const modelOnly = lower.match(/unknown\s+provider\s+for\s+model\s+([a-z0-9._-]+)/i)
+  if (modelOnly) {
+    return {
+      modelID: modelOnly[1],
+    }
+  }
+
+  return {}
+}
+
 export function createEventHandler(args: {
   ctx: PluginContext
   pluginConfig: OhMyOpenCodeConfig
@@ -29,6 +103,11 @@ export function createEventHandler(args: {
 }): (input: { event: { type: string; properties?: Record<string, unknown> } }) => Promise<void> {
   const { ctx, firstMessageVariantGate, managers, hooks } = args
 
+  // Avoid triggering multiple abort+continue cycles for the same failing assistant message.
+  const lastHandledModelErrorMessageID = new Map<string, string>()
+  const lastHandledRetryStatusKey = new Map<string, string>()
+  const lastKnownModelBySession = new Map<string, { providerID: string; modelID: string }>()
+
   const dispatchToHooks = async (input: { event: { type: string; properties?: Record<string, unknown> } }): Promise<void> => {
     await Promise.resolve(hooks.autoUpdateChecker?.event?.(input))
     await Promise.resolve(hooks.claudeCodeHooks?.event?.(input))
@@ -56,6 +135,15 @@ export function createEventHandler(args: {
   const recentRealIdles = new Map<string, number>()
   const DEDUP_WINDOW_MS = 500
 
+  const shouldAutoRetrySession = (sessionID: string): boolean => {
+    if (syncSubagentSessions.has(sessionID)) return true
+    const mainSessionID = getMainSessionID()
+    if (mainSessionID) return sessionID === mainSessionID
+    // Headless runs (or resumed sessions) may not emit session.created, so mainSessionID can be unset.
+    // In that case, treat any non-subagent session as the "main" interactive session.
+    return !subagentSessions.has(sessionID)
+  }
+
   return async (input): Promise<void> => {
     pruneRecentSyntheticIdles({
       recentSyntheticIdles,
@@ -122,8 +210,15 @@ export function createEventHandler(args: {
 
       if (sessionInfo?.id) {
         clearSessionAgent(sessionInfo.id)
+        lastHandledModelErrorMessageID.delete(sessionInfo.id)
+        lastHandledRetryStatusKey.delete(sessionInfo.id)
+        lastKnownModelBySession.delete(sessionInfo.id)
+        clearPendingModelFallback(sessionInfo.id)
+        clearSessionFallbackChain(sessionInfo.id)
         resetMessageCursor(sessionInfo.id)
         firstMessageVariantGate.clear(sessionInfo.id)
+        clearSessionModel(sessionInfo.id)
+        syncSubagentSessions.delete(sessionInfo.id)
         await managers.skillMcpManager.disconnectSession(sessionInfo.id)
         await lspManager.cleanupTempDirectoryClients()
         await managers.tmuxSessionManager.onSessionDeleted({
@@ -137,8 +232,129 @@ export function createEventHandler(args: {
       const sessionID = info?.sessionID as string | undefined
       const agent = info?.agent as string | undefined
       const role = info?.role as string | undefined
-      if (sessionID && agent && role === "user") {
-        updateSessionAgent(sessionID, agent)
+      if (sessionID && role === "user") {
+        if (agent) {
+          updateSessionAgent(sessionID, agent)
+        }
+        const providerID = info?.providerID as string | undefined
+        const modelID = info?.modelID as string | undefined
+        if (providerID && modelID) {
+          lastKnownModelBySession.set(sessionID, { providerID, modelID })
+          setSessionModel(sessionID, { providerID, modelID })
+        }
+      }
+
+      // Model fallback: in practice, API/model failures often surface as assistant message errors.
+      // session.error events are not guaranteed for all providers, so we also observe message.updated.
+      if (sessionID && role === "assistant") {
+        const assistantMessageID = info?.id as string | undefined
+        const assistantError = info?.error
+        if (assistantMessageID && assistantError) {
+          const lastHandled = lastHandledModelErrorMessageID.get(sessionID)
+          if (lastHandled === assistantMessageID) {
+            return
+          }
+
+          const errorName = extractErrorName(assistantError)
+          const errorMessage = extractErrorMessage(assistantError)
+          const errorInfo = { name: errorName, message: errorMessage }
+
+          if (shouldRetryError(errorInfo)) {
+            // Prefer the agent/model/provider from the assistant message payload.
+            let agentName = agent ?? getSessionAgent(sessionID)
+            if (!agentName && sessionID === getMainSessionID()) {
+              if (errorMessage.includes("claude-opus") || errorMessage.includes("opus")) {
+                agentName = "sisyphus"
+              } else if (errorMessage.includes("gpt-5")) {
+                agentName = "hephaestus"
+              } else {
+                agentName = "sisyphus"
+              }
+            }
+
+            if (agentName) {
+              const currentProvider = (info?.providerID as string | undefined) ?? "opencode"
+              const rawModel = (info?.modelID as string | undefined) ?? "claude-opus-4-6"
+              const currentModel = normalizeFallbackModelID(rawModel)
+
+              const setFallback = setPendingModelFallback(
+                sessionID,
+                agentName,
+                currentProvider,
+                currentModel,
+              )
+
+              if (setFallback && shouldAutoRetrySession(sessionID) && !hooks.stopContinuationGuard?.isStopped(sessionID)) {
+                lastHandledModelErrorMessageID.set(sessionID, assistantMessageID)
+
+                await ctx.client.session.abort({ path: { id: sessionID } }).catch(() => {})
+                await ctx.client.session
+                  .prompt({
+                    path: { id: sessionID },
+                    body: { parts: [{ type: "text", text: "continue" }] },
+                    query: { directory: ctx.directory },
+                  })
+                  .catch(() => {})
+              }
+            }
+          }
+        }
+      }
+    }
+
+    if (event.type === "session.status") {
+      const sessionID = props?.sessionID as string | undefined
+      const status = props?.status as
+        | { type?: string; attempt?: number; message?: string; next?: number }
+        | undefined
+
+      if (sessionID && status?.type === "retry") {
+        const retryMessage = typeof status.message === "string" ? status.message : ""
+        const retryKey = `${status.attempt ?? "?"}:${status.next ?? "?"}:${retryMessage}`
+        if (lastHandledRetryStatusKey.get(sessionID) === retryKey) {
+          return
+        }
+        lastHandledRetryStatusKey.set(sessionID, retryKey)
+
+        const errorInfo = { name: undefined, message: retryMessage }
+        if (shouldRetryError(errorInfo)) {
+          let agentName = getSessionAgent(sessionID)
+          if (!agentName && sessionID === getMainSessionID()) {
+            if (retryMessage.includes("claude-opus") || retryMessage.includes("opus")) {
+              agentName = "sisyphus"
+            } else if (retryMessage.includes("gpt-5")) {
+              agentName = "hephaestus"
+            } else {
+              agentName = "sisyphus"
+            }
+          }
+
+          if (agentName) {
+            const parsed = extractProviderModelFromErrorMessage(retryMessage)
+            const lastKnown = lastKnownModelBySession.get(sessionID)
+            const currentProvider = parsed.providerID ?? lastKnown?.providerID ?? "opencode"
+            let currentModel = parsed.modelID ?? lastKnown?.modelID ?? "claude-opus-4-6"
+            currentModel = normalizeFallbackModelID(currentModel)
+
+            const setFallback = setPendingModelFallback(
+              sessionID,
+              agentName,
+              currentProvider,
+              currentModel,
+            )
+
+            if (setFallback && shouldAutoRetrySession(sessionID) && !hooks.stopContinuationGuard?.isStopped(sessionID)) {
+              await ctx.client.session.abort({ path: { id: sessionID } }).catch(() => {})
+              await ctx.client.session
+                .prompt({
+                  path: { id: sessionID },
+                  body: { parts: [{ type: "text", text: "continue" }] },
+                  query: { directory: ctx.directory },
+                })
+                .catch(() => {})
+            }
+          }
+        }
       }
     }
 
@@ -146,6 +362,11 @@ export function createEventHandler(args: {
       const sessionID = props?.sessionID as string | undefined
       const error = props?.error
 
+      const errorName = extractErrorName(error)
+      const errorMessage = extractErrorMessage(error)
+      const errorInfo = { name: errorName, message: errorMessage }
+
+      // First, try session recovery for internal errors (thinking blocks, tool results, etc.)
       if (hooks.sessionRecovery?.isRecoverableError(error)) {
         const messageInfo = {
           id: props?.messageID as string | undefined,
@@ -169,6 +390,52 @@ export function createEventHandler(args: {
             })
             .catch(() => {})
         }
+      } 
+      // Second, try model fallback for model errors (rate limit, quota, provider issues, etc.)
+      else if (sessionID && shouldRetryError(errorInfo)) {
+        // Get the current agent for this session, or default to "sisyphus" for main sessions
+        let agentName = getSessionAgent(sessionID)
+        
+        // For main sessions, if no agent is set, try to infer from the error or default to sisyphus
+        if (!agentName && sessionID === getMainSessionID()) {
+          // Try to infer agent from model in error message
+          if (errorMessage.includes("claude-opus") || errorMessage.includes("opus")) {
+            agentName = "sisyphus"
+          } else if (errorMessage.includes("gpt-5")) {
+            agentName = "hephaestus"
+          } else {
+            // Default to sisyphus for main session errors
+            agentName = "sisyphus"
+          }
+        }
+        
+        if (agentName) {
+          const parsed = extractProviderModelFromErrorMessage(errorMessage)
+          const currentProvider = props?.providerID as string || parsed.providerID || "opencode"
+          let currentModel = props?.modelID as string || parsed.modelID || "claude-opus-4-6"
+          currentModel = normalizeFallbackModelID(currentModel)
+
+          // Try to set pending model fallback
+          const setFallback = setPendingModelFallback(
+            sessionID,
+            agentName,
+            currentProvider,
+            currentModel,
+          )
+          
+          if (setFallback && shouldAutoRetrySession(sessionID) && !hooks.stopContinuationGuard?.isStopped(sessionID)) {
+            // Abort the current session and prompt with "continue" to trigger the fallback
+            await ctx.client.session.abort({ path: { id: sessionID } }).catch(() => {})
+            
+            await ctx.client.session
+              .prompt({
+                path: { id: sessionID },
+                body: { parts: [{ type: "text", text: "continue" }] },
+                query: { directory: ctx.directory },
+              })
+              .catch(() => {})
+          }
+        }
       }
     }
   }

src/plugin/hooks/create-session-hooks.ts

@@ -7,6 +7,7 @@ import {
   createSessionRecoveryHook,
   createSessionNotification,
   createThinkModeHook,
+  createModelFallbackHook,
   createAnthropicContextWindowLimitRecoveryHook,
   createAutoUpdateCheckerHook,
   createAgentUsageReminderHook,
@@ -30,6 +31,7 @@ import {
   detectExternalNotificationPlugin,
   getNotificationConflictWarning,
   log,
+  normalizeSDKResponse,
 } from "../../shared"
 import { safeCreateHook } from "../../shared/safe-create-hook"
 import { sessionExists } from "../../tools"
@@ -40,6 +42,7 @@ export type SessionHooks = {
   sessionRecovery: ReturnType<typeof createSessionRecoveryHook> | null
   sessionNotification: ReturnType<typeof createSessionNotification> | null
   thinkMode: ReturnType<typeof createThinkModeHook> | null
+  modelFallback: ReturnType<typeof createModelFallbackHook> | null
   anthropicContextWindowLimitRecovery: ReturnType<typeof createAnthropicContextWindowLimitRecoveryHook> | null
   autoUpdateChecker: ReturnType<typeof createAutoUpdateCheckerHook> | null
   agentUsageReminder: ReturnType<typeof createAgentUsageReminderHook> | null
@@ -102,6 +105,73 @@ export function createSessionHooks(args: {
     ? safeHook("think-mode", () => createThinkModeHook())
     : null
 
+  const enableFallbackTitle = pluginConfig.experimental?.model_fallback_title ?? false
+  const fallbackTitleMaxEntries = 200
+  const fallbackTitleState = new Map<string, { baseTitle?: string; lastKey?: string }>()
+  const updateFallbackTitle = async (input: {
+    sessionID: string
+    providerID: string
+    modelID: string
+    variant?: string
+  }) => {
+    if (!enableFallbackTitle) return
+    const key = `${input.providerID}/${input.modelID}${input.variant ? `:${input.variant}` : ""}`
+    const existing = fallbackTitleState.get(input.sessionID) ?? {}
+    if (existing.lastKey === key) return
+
+    if (!existing.baseTitle) {
+      const sessionResp = await ctx.client.session.get({ path: { id: input.sessionID } }).catch(() => null)
+      const sessionInfo = sessionResp
+        ? normalizeSDKResponse(sessionResp, null as { title?: string } | null, { preferResponseOnMissingData: true })
+        : null
+      const rawTitle = sessionInfo?.title
+      if (typeof rawTitle === "string" && rawTitle.length > 0) {
+        existing.baseTitle = rawTitle.replace(/\s*\[fallback:[^\]]+\]$/i, "").trim()
+      } else {
+        existing.baseTitle = "Session"
+      }
+    }
+
+    const variantLabel = input.variant ? ` ${input.variant}` : ""
+    const newTitle = `${existing.baseTitle} [fallback: ${input.providerID}/${input.modelID}${variantLabel}]`
+
+    await ctx.client.session
+      .update({
+        path: { id: input.sessionID },
+        body: { title: newTitle },
+        query: { directory: ctx.directory },
+      })
+      .catch(() => {})
+
+    existing.lastKey = key
+    fallbackTitleState.set(input.sessionID, existing)
+    if (fallbackTitleState.size > fallbackTitleMaxEntries) {
+      const oldestKey = fallbackTitleState.keys().next().value
+      if (oldestKey) fallbackTitleState.delete(oldestKey)
+    }
+  }
+
+  // Model fallback hook (configurable via disabled_hooks)
+  // This handles automatic model switching when model errors occur
+  const modelFallback = isHookEnabled("model-fallback")
+    ? safeHook("model-fallback", () =>
+      createModelFallbackHook({
+        toast: async ({ title, message, variant, duration }) => {
+          await ctx.client.tui
+            .showToast({
+              body: {
+                title,
+                message,
+                variant: variant ?? "warning",
+                duration: duration ?? 5000,
+              },
+            })
+            .catch(() => {})
+        },
+        onApplied: enableFallbackTitle ? updateFallbackTitle : undefined,
+      }))
+    : null
+
   const anthropicContextWindowLimitRecovery = isHookEnabled("anthropic-context-window-limit-recovery")
     ? safeHook("anthropic-context-window-limit-recovery", () =>
         createAnthropicContextWindowLimitRecoveryHook(ctx, { experimental: pluginConfig.experimental }))
@@ -181,6 +251,7 @@ export function createSessionHooks(args: {
     sessionRecovery,
     sessionNotification,
     thinkMode,
+    modelFallback,
     anthropicContextWindowLimitRecovery,
     autoUpdateChecker,
     agentUsageReminder,

src/plugin/hooks/create-transform-hooks.ts

@@ -5,6 +5,7 @@ import {
   createClaudeCodeHooksHook,
   createKeywordDetectorHook,
   createThinkingBlockValidatorHook,
+  createBeastModeSystemHook,
 } from "../../hooks"
 import {
   contextCollector,
@@ -17,6 +18,7 @@ export type TransformHooks = {
   keywordDetector: ReturnType<typeof createKeywordDetectorHook> | null
   contextInjectorMessagesTransform: ReturnType<typeof createContextInjectorMessagesTransformHook>
   thinkingBlockValidator: ReturnType<typeof createThinkingBlockValidatorHook> | null
+  beastModeSystem: ReturnType<typeof createBeastModeSystemHook> | null
 }
 
 export function createTransformHooks(args: {
@@ -56,10 +58,19 @@ export function createTransformHooks(args: {
       )
     : null
 
+  const beastModeSystem = isHookEnabled("beast-mode-system")
+    ? safeCreateHook(
+        "beast-mode-system",
+        () => createBeastModeSystemHook(),
+        { enabled: safeHookEnabled },
+      )
+    : null
+
   return {
     claudeCodeHooks,
     keywordDetector,
     contextInjectorMessagesTransform,
     thinkingBlockValidator,
+    beastModeSystem,
   }
 }

src/plugin/system-transform.ts

@@ -0,0 +1,12 @@
+import type { CreatedHooks } from "../create-hooks"
+
+export function createSystemTransformHandler(args: {
+  hooks: CreatedHooks
+}): (input: { sessionID: string }, output: { system: string[] }) => Promise<void> {
+  return async (input, output): Promise<void> => {
+    await args.hooks.beastModeSystem?.["experimental.chat.system.transform"]?.(
+      input,
+      output,
+    )
+  }
+}