oh-my-opencode 3.11.2 → 3.12.1

package/dist/features/tmux-subagent/types.d.ts

@@ -4,6 +4,8 @@ export interface TrackedSession {
     description: string;
     createdAt: Date;
     lastSeenAt: Date;
+    closePending: boolean;
+    closeRetryCount: number;
     lastMessageCount?: number;
     stableIdlePolls?: number;
 }

package/dist/hooks/atlas/boulder-session-lineage.d.ts

@@ -0,0 +1,6 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function isSessionInBoulderLineage(input: {
+    client: PluginInput["client"];
+    sessionID: string;
+    boulderSessionIDs: string[];
+}): Promise<boolean>;

package/dist/hooks/atlas/final-wave-approval-gate.d.ts

@@ -0,0 +1,6 @@
+import type { SessionState } from "./types";
+export declare function shouldPauseForFinalWaveApproval(input: {
+    planPath: string;
+    taskOutput: string;
+    sessionState: SessionState;
+}): boolean;

package/dist/hooks/atlas/final-wave-plan-state.d.ts

@@ -0,0 +1,5 @@
+export type FinalWavePlanState = {
+    pendingImplementationTaskCount: number;
+    pendingFinalWaveTaskCount: number;
+};
+export declare function readFinalWavePlanState(planPath: string): FinalWavePlanState | null;

package/dist/hooks/atlas/idle-event.d.ts

@@ -0,0 +1,8 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { AtlasHookOptions, SessionState } from "./types";
+export declare function handleAtlasSessionIdle(input: {
+    ctx: PluginInput;
+    options?: AtlasHookOptions;
+    getState: (sessionID: string) => SessionState;
+    sessionID: string;
+}): Promise<void>;

package/dist/hooks/atlas/resolve-active-boulder-session.d.ts

@@ -0,0 +1,11 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { BoulderState, PlanProgress } from "../../features/boulder-state";
+export declare function resolveActiveBoulderSession(input: {
+    client: PluginInput["client"];
+    directory: string;
+    sessionID: string;
+}): Promise<{
+    boulderState: BoulderState;
+    progress: PlanProgress;
+    appendedSession: boolean;
+} | null>;

package/dist/hooks/atlas/tool-execute-after.d.ts

@@ -1,7 +1,9 @@
 import type { PluginInput } from "@opencode-ai/plugin";
+import type { SessionState } from "./types";
 import type { ToolExecuteAfterInput, ToolExecuteAfterOutput } from "./types";
 export declare function createToolExecuteAfterHandler(input: {
     ctx: PluginInput;
     pendingFilePaths: Map<string, string>;
     autoCommit: boolean;
+    getState: (sessionID: string) => SessionState;
 }): (toolInput: ToolExecuteAfterInput, toolOutput: ToolExecuteAfterOutput) => Promise<void>;

package/dist/hooks/atlas/types.d.ts

@@ -8,6 +8,7 @@ export interface AtlasHookOptions {
     directory: string;
     backgroundManager?: BackgroundManager;
     isContinuationStopped?: (sessionID: string) => boolean;
+    shouldSkipContinuation?: (sessionID: string) => boolean;
     agentOverrides?: AgentOverrides;
     /** Enable auto-commit after each atomic task completion (default: true) */
     autoCommit?: boolean;
@@ -28,4 +29,7 @@ export interface SessionState {
     promptFailureCount: number;
     lastFailureAt?: number;
     pendingRetryTimer?: ReturnType<typeof setTimeout>;
+    waitingForFinalWaveApproval?: boolean;
+    pendingFinalWaveTaskCount?: number;
+    approvedFinalWaveTaskCount?: number;
 }

package/dist/hooks/atlas/verification-reminders.d.ts

@@ -3,4 +3,8 @@ export declare function buildOrchestratorReminder(planName: string, progress: {
     total: number;
     completed: number;
 }, sessionId: string, autoCommit?: boolean, includeCompletionGate?: boolean): string;
+export declare function buildFinalWaveApprovalReminder(planName: string, progress: {
+    total: number;
+    completed: number;
+}, sessionId: string): string;
 export declare function buildStandaloneVerificationReminder(sessionId: string): string;

package/dist/hooks/auto-slash-command/executor.d.ts

@@ -4,6 +4,7 @@ export interface ExecutorOptions {
     skills?: LoadedSkill[];
     pluginsEnabled?: boolean;
     enabledPluginsOverride?: Record<string, boolean>;
+    agent?: string;
 }
 export interface ExecuteResult {
     success: boolean;

package/dist/hooks/auto-slash-command/hook.d.ts

@@ -8,4 +8,11 @@ export interface AutoSlashCommandHookOptions {
 export declare function createAutoSlashCommandHook(options?: AutoSlashCommandHookOptions): {
     "chat.message": (input: AutoSlashCommandHookInput, output: AutoSlashCommandHookOutput) => Promise<void>;
     "command.execute.before": (input: CommandExecuteBeforeInput, output: CommandExecuteBeforeOutput) => Promise<void>;
+    event: ({ event, }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+    dispose: () => void;
 };

package/dist/hooks/auto-slash-command/processed-command-store.d.ts

@@ -0,0 +1,7 @@
+export interface ProcessedCommandStore {
+    has(commandKey: string): boolean;
+    add(commandKey: string, ttlMs?: number): void;
+    cleanupSession(sessionID: string): void;
+    clear(): void;
+}
+export declare function createProcessedCommandStore(): ProcessedCommandStore;

package/dist/hooks/auto-slash-command/types.d.ts

@@ -29,6 +29,15 @@ export interface CommandExecuteBeforeInput {
     command: string;
     sessionID: string;
     arguments: string;
+    agent?: string;
+    messageID?: string;
+    messageId?: string;
+    eventID?: string;
+    eventId?: string;
+    invocationID?: string;
+    invocationId?: string;
+    commandID?: string;
+    commandId?: string;
 }
 export interface CommandExecuteBeforeOutput {
     parts: Array<{

package/dist/hooks/auto-update-checker/checker/sync-package-json.d.ts

@@ -0,0 +1,7 @@
+import type { PluginEntryInfo } from "./plugin-entry";
+export interface SyncResult {
+    synced: boolean;
+    error: "file_not_found" | "plugin_not_in_deps" | "parse_error" | "write_error" | null;
+    message?: string;
+}
+export declare function syncCachePackageJsonToIntent(pluginInfo: PluginEntryInfo): SyncResult;

package/dist/hooks/auto-update-checker/checker.d.ts

@@ -3,6 +3,8 @@ export { getLocalDevVersion } from "./checker/local-dev-version";
 export { findPluginEntry } from "./checker/plugin-entry";
 export type { PluginEntryInfo } from "./checker/plugin-entry";
 export { getCachedVersion } from "./checker/cached-version";
-export { updatePinnedVersion, revertPinnedVersion } from "./checker/pinned-version-updater";
+export { updatePinnedVersion } from "./checker/pinned-version-updater";
 export { getLatestVersion } from "./checker/latest-version";
 export { checkForUpdate } from "./checker/check-for-update";
+export { syncCachePackageJsonToIntent } from "./checker/sync-package-json";
+export type { SyncResult } from "./checker/sync-package-json";

package/dist/hooks/compaction-context-injector/compaction-context-prompt.d.ts

@@ -0,0 +1 @@
+export declare const COMPACTION_CONTEXT_PROMPT: string;

package/dist/hooks/compaction-context-injector/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const HOOK_NAME = "compaction-context-injector";
+export declare const AGENT_RECOVERY_PROMPT = "[restore checkpointed session agent configuration after compaction]";
+export declare const NO_TEXT_TAIL_THRESHOLD = 5;
+export declare const RECOVERY_COOLDOWN_MS = 60000;
+export declare const RECENT_COMPACTION_WINDOW_MS: number;

package/dist/hooks/compaction-context-injector/hook.d.ts

@@ -1,2 +1,6 @@
 import type { BackgroundManager } from "../../features/background-agent";
-export declare function createCompactionContextInjector(backgroundManager?: BackgroundManager): (sessionID?: string) => string;
+import type { CompactionContextClient, CompactionContextInjector } from "./types";
+export declare function createCompactionContextInjector(options?: {
+    ctx?: CompactionContextClient;
+    backgroundManager?: BackgroundManager;
+}): CompactionContextInjector;

package/dist/hooks/compaction-context-injector/recovery-prompt-config.d.ts

@@ -0,0 +1,6 @@
+import type { CompactionAgentConfigCheckpoint } from "../../shared/compaction-agent-config-checkpoint";
+export type RecoveryPromptConfig = CompactionAgentConfigCheckpoint & {
+    agent: string;
+};
+export declare function createExpectedRecoveryPromptConfig(checkpoint: Pick<RecoveryPromptConfig, "agent"> & CompactionAgentConfigCheckpoint, currentPromptConfig: CompactionAgentConfigCheckpoint): RecoveryPromptConfig;
+export declare function isPromptConfigRecovered(actualPromptConfig: CompactionAgentConfigCheckpoint, expectedPromptConfig: RecoveryPromptConfig): boolean;

package/dist/hooks/compaction-context-injector/recovery.d.ts

@@ -0,0 +1,6 @@
+import type { CompactionContextClient } from "./types";
+import type { TailMonitorState } from "./tail-monitor";
+export declare function createRecoveryLogic(ctx: CompactionContextClient | undefined, getTailState: (sessionID: string) => TailMonitorState): {
+    recoverCheckpointedAgentConfig: (sessionID: string, reason: "session.compacted" | "no-text-tail") => Promise<boolean>;
+    maybeWarnAboutNoTextTail: (sessionID: string) => Promise<void>;
+};

package/dist/hooks/compaction-context-injector/session-id.d.ts

@@ -0,0 +1,2 @@
+export declare function isCompactionAgent(agent: string | undefined): boolean;
+export declare function resolveSessionID(props?: Record<string, unknown>): string | undefined;

package/dist/hooks/compaction-context-injector/session-prompt-config-resolver.d.ts

@@ -0,0 +1,16 @@
+import type { CompactionAgentConfigCheckpoint } from "../../shared/compaction-agent-config-checkpoint";
+type ResolverContext = {
+    client: {
+        session: {
+            messages: (input: {
+                path: {
+                    id: string;
+                };
+            }) => Promise<unknown>;
+        };
+    };
+    directory: string;
+};
+export declare function resolveSessionPromptConfig(ctx: ResolverContext, sessionID: string): Promise<CompactionAgentConfigCheckpoint>;
+export declare function resolveLatestSessionPromptConfig(ctx: ResolverContext, sessionID: string): Promise<CompactionAgentConfigCheckpoint>;
+export {};

package/dist/hooks/compaction-context-injector/tail-monitor.d.ts

@@ -0,0 +1,13 @@
+export type TailMonitorState = {
+    currentMessageID?: string;
+    currentHasOutput: boolean;
+    consecutiveNoTextMessages: number;
+    lastCompactedAt?: number;
+    lastRecoveryAt?: number;
+};
+export declare function finalizeTrackedAssistantMessage(state: TailMonitorState): number;
+export declare function shouldTreatAssistantPartAsOutput(part: {
+    type?: string;
+    text?: string;
+}): boolean;
+export declare function trackAssistantOutput(state: TailMonitorState, messageID?: string): void;

package/dist/hooks/compaction-context-injector/types.d.ts

@@ -0,0 +1,43 @@
+export interface CompactionContextInjector {
+    capture: (sessionID: string) => Promise<void>;
+    inject: (sessionID?: string) => string;
+    event: (input: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+}
+export type CompactionContextClient = {
+    client: {
+        session: {
+            messages: (input: {
+                path: {
+                    id: string;
+                };
+            }) => Promise<unknown>;
+            promptAsync: (input: {
+                path: {
+                    id: string;
+                };
+                body: {
+                    noReply?: boolean;
+                    agent?: string;
+                    model?: {
+                        providerID: string;
+                        modelID: string;
+                    };
+                    tools?: Record<string, boolean>;
+                    parts: Array<{
+                        type: "text";
+                        text: string;
+                    }>;
+                };
+                query?: {
+                    directory: string;
+                };
+            }) => Promise<unknown>;
+        };
+    };
+    directory: string;
+};

package/dist/hooks/compaction-context-injector/validated-model.d.ts

@@ -0,0 +1,13 @@
+import type { CompactionAgentConfigCheckpoint } from "../../shared/compaction-agent-config-checkpoint";
+type PromptConfigInfo = {
+    agent?: string;
+    model?: {
+        providerID?: string;
+        modelID?: string;
+    };
+    providerID?: string;
+    modelID?: string;
+};
+export declare function resolveValidatedModel(info: PromptConfigInfo | undefined): CompactionAgentConfigCheckpoint["model"] | undefined;
+export declare function validateCheckpointModel(checkpointModel: CompactionAgentConfigCheckpoint["model"], currentModel: CompactionAgentConfigCheckpoint["model"]): CompactionAgentConfigCheckpoint["model"] | undefined;
+export {};

package/dist/hooks/context-window-monitor.d.ts

@@ -1,8 +1,6 @@
 import type { PluginInput } from "@opencode-ai/plugin";
-type ModelCacheStateLike = {
-    anthropicContext1MEnabled: boolean;
-};
-export declare function createContextWindowMonitorHook(_ctx: PluginInput, modelCacheState?: ModelCacheStateLike): {
+import { type ContextLimitModelCacheState } from "../shared/context-limit-resolver";
+export declare function createContextWindowMonitorHook(_ctx: PluginInput, modelCacheState?: ContextLimitModelCacheState): {
     "tool.execute.after": (input: {
         tool: string;
         sessionID: string;
@@ -19,4 +17,3 @@ export declare function createContextWindowMonitorHook(_ctx: PluginInput, modelC
         };
     }) => Promise<void>;
 };
-export {};

package/dist/hooks/gpt-permission-continuation/assistant-message.d.ts

@@ -0,0 +1,23 @@
+type TextPart = {
+    type?: string;
+    text?: string;
+};
+type MessageInfo = {
+    id?: string;
+    role?: string;
+    error?: unknown;
+    model?: {
+        providerID?: string;
+        modelID?: string;
+    };
+    providerID?: string;
+    modelID?: string;
+};
+export type SessionMessage = {
+    info?: MessageInfo;
+    parts?: TextPart[];
+};
+export declare function getLastAssistantMessage(messages: SessionMessage[]): SessionMessage | null;
+export declare function extractAssistantText(message: SessionMessage): string;
+export declare function isGptAssistantMessage(message: SessionMessage): boolean;
+export {};

package/dist/hooks/gpt-permission-continuation/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const HOOK_NAME = "gpt-permission-continuation";
+export declare const CONTINUATION_PROMPT = "continue";
+export declare const MAX_CONSECUTIVE_AUTO_CONTINUES = 3;
+export declare const DEFAULT_STALL_PATTERNS: readonly ["if you want", "would you like", "shall i", "do you want me to", "let me know if"];

package/dist/hooks/gpt-permission-continuation/detector.d.ts

@@ -0,0 +1 @@
+export declare function detectStallPattern(text: string, patterns?: readonly string[]): boolean;

package/dist/hooks/gpt-permission-continuation/handler.d.ts

@@ -0,0 +1,12 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { SessionStateStore } from "./session-state";
+export declare function createGptPermissionContinuationHandler(args: {
+    ctx: PluginInput;
+    sessionStateStore: SessionStateStore;
+    isContinuationStopped?: (sessionID: string) => boolean;
+}): (input: {
+    event: {
+        type: string;
+        properties?: unknown;
+    };
+}) => Promise<void>;

package/dist/hooks/gpt-permission-continuation/index.d.ts

@@ -0,0 +1,13 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export type GptPermissionContinuationHook = {
+    handler: (input: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+    wasRecentlyInjected: (sessionID: string) => boolean;
+};
+export declare function createGptPermissionContinuationHook(ctx: PluginInput, options?: {
+    isContinuationStopped?: (sessionID: string) => boolean;
+}): GptPermissionContinuationHook;

package/dist/hooks/gpt-permission-continuation/session-state.d.ts

@@ -0,0 +1,15 @@
+type SessionState = {
+    inFlight: boolean;
+    consecutiveAutoContinueCount: number;
+    awaitingAutoContinuationResponse: boolean;
+    lastHandledMessageID?: string;
+    lastAutoContinuePermissionPhrase?: string;
+    lastInjectedAt?: number;
+};
+export type SessionStateStore = ReturnType<typeof createSessionStateStore>;
+export declare function createSessionStateStore(): {
+    getState: (sessionID: string) => SessionState;
+    wasRecentlyInjected(sessionID: string, windowMs: number): boolean;
+    cleanup(sessionID: string): void;
+};
+export {};

package/dist/hooks/index.d.ts

@@ -27,6 +27,7 @@ export { createCategorySkillReminderHook } from "./category-skill-reminder";
 export { createRalphLoopHook, type RalphLoopHook } from "./ralph-loop";
 export { createNoSisyphusGptHook } from "./no-sisyphus-gpt";
 export { createNoHephaestusNonGptHook } from "./no-hephaestus-non-gpt";
+export { createGptPermissionContinuationHook, type GptPermissionContinuationHook } from "./gpt-permission-continuation";
 export { createAutoSlashCommandHook } from "./auto-slash-command";
 export { createEditErrorRecoveryHook } from "./edit-error-recovery";
 export { createPrometheusMdOnlyHook } from "./prometheus-md-only";
@@ -47,3 +48,4 @@ export { createWriteExistingFileGuardHook } from "./write-existing-file-guard";
 export { createHashlineReadEnhancerHook } from "./hashline-read-enhancer";
 export { createJsonErrorRecoveryHook, JSON_ERROR_TOOL_EXCLUDE_LIST, JSON_ERROR_PATTERNS, JSON_ERROR_REMINDER } from "./json-error-recovery";
 export { createReadImageResizerHook } from "./read-image-resizer";
+export { createTodoDescriptionOverrideHook } from "./todo-description-override";

package/dist/hooks/keyword-detector/hook.d.ts

@@ -9,6 +9,7 @@ export declare function createKeywordDetectorHook(ctx: PluginInput, _collector?:
             modelID: string;
         };
         messageID?: string;
+        variant?: string;
     }, output: {
         message: Record<string, unknown>;
         parts: Array<{

package/dist/hooks/preemptive-compaction.d.ts

@@ -1,8 +1,5 @@
 import type { OhMyOpenCodeConfig } from "../config";
-type ModelCacheStateLike = {
-    anthropicContext1MEnabled: boolean;
-    modelContextLimitsCache?: Map<string, number>;
-};
+import { type ContextLimitModelCacheState } from "../shared/context-limit-resolver";
 type PluginInput = {
     client: {
         session: {
@@ -15,7 +12,7 @@ type PluginInput = {
     };
     directory: string;
 };
-export declare function createPreemptiveCompactionHook(ctx: PluginInput, pluginConfig: OhMyOpenCodeConfig, modelCacheState?: ModelCacheStateLike): {
+export declare function createPreemptiveCompactionHook(ctx: PluginInput, pluginConfig: OhMyOpenCodeConfig, modelCacheState?: ContextLimitModelCacheState): {
     "tool.execute.after": (input: {
         tool: string;
         sessionID: string;

package/dist/hooks/ralph-loop/pending-verification-handler.d.ts

@@ -0,0 +1,17 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { RalphLoopState } from "./types";
+type LoopStateController = {
+    restartAfterFailedVerification: (sessionID: string, messageCountAtStart?: number) => RalphLoopState | null;
+    setVerificationSessionID: (sessionID: string, verificationSessionID: string) => RalphLoopState | null;
+};
+export declare function handlePendingVerification(ctx: PluginInput, input: {
+    sessionID: string;
+    state: RalphLoopState;
+    verificationSessionID?: string;
+    matchesParentSession: boolean;
+    matchesVerificationSession: boolean;
+    loopState: LoopStateController;
+    directory: string;
+    apiTimeoutMs: number;
+}): Promise<void>;
+export {};

package/dist/hooks/runtime-fallback/fallback-bootstrap-model.d.ts

@@ -0,0 +1,10 @@
+import type { OhMyOpenCodeConfig } from "../../config";
+type ResolveFallbackBootstrapModelOptions = {
+    sessionID: string;
+    source: string;
+    eventModel?: string;
+    resolvedAgent?: string;
+    pluginConfig?: OhMyOpenCodeConfig;
+};
+export declare function resolveFallbackBootstrapModel(options: ResolveFallbackBootstrapModelOptions): string | undefined;
+export {};

package/dist/hooks/runtime-fallback/fallback-retry-dispatcher.d.ts

@@ -0,0 +1,11 @@
+import type { AutoRetryHelpers } from "./auto-retry";
+import type { HookDeps, FallbackState } from "./types";
+type DispatchFallbackRetryOptions = {
+    sessionID: string;
+    state: FallbackState;
+    fallbackModels: string[];
+    resolvedAgent?: string;
+    source: string;
+};
+export declare function dispatchFallbackRetry(deps: HookDeps, helpers: AutoRetryHelpers, options: DispatchFallbackRetryOptions): Promise<void>;
+export {};

package/dist/hooks/runtime-fallback/hook.d.ts

@@ -1,3 +1,2 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-import type { RuntimeFallbackHook, RuntimeFallbackOptions } from "./types";
-export declare function createRuntimeFallbackHook(ctx: PluginInput, options?: RuntimeFallbackOptions): RuntimeFallbackHook;
+import type { RuntimeFallbackHook, RuntimeFallbackOptions, RuntimeFallbackPluginInput } from "./types";
+export declare function createRuntimeFallbackHook(ctx: RuntimeFallbackPluginInput, options?: RuntimeFallbackOptions): RuntimeFallbackHook;

package/dist/hooks/runtime-fallback/last-user-retry-parts.d.ts

@@ -0,0 +1,4 @@
+export declare function getLastUserRetryParts(messagesResponse: unknown): Array<{
+    type: "text";
+    text: string;
+}>;

package/dist/hooks/runtime-fallback/message-update-handler.d.ts

@@ -1,5 +1,4 @@
 import type { HookDeps } from "./types";
 import type { AutoRetryHelpers } from "./auto-retry";
-import { extractAutoRetrySignal } from "./error-classifier";
-export declare function hasVisibleAssistantResponse(extractAutoRetrySignalFn: typeof extractAutoRetrySignal): (ctx: HookDeps["ctx"], sessionID: string, _info: Record<string, unknown> | undefined) => Promise<boolean>;
+export { hasVisibleAssistantResponse } from "./visible-assistant-response";
 export declare function createMessageUpdateHandler(deps: HookDeps, helpers: AutoRetryHelpers): (props: Record<string, unknown> | undefined) => Promise<void>;

package/dist/hooks/runtime-fallback/retry-model-payload.d.ts

@@ -0,0 +1,7 @@
+export declare function buildRetryModelPayload(model: string): {
+    model: {
+        providerID: string;
+        modelID: string;
+    };
+    variant?: string;
+} | undefined;

package/dist/hooks/runtime-fallback/session-messages.d.ts

@@ -0,0 +1,9 @@
+export type SessionMessagePart = {
+    type?: string;
+    text?: string;
+};
+export type SessionMessage = {
+    info?: Record<string, unknown>;
+    parts?: SessionMessagePart[];
+};
+export declare function extractSessionMessages(messagesResponse: unknown): SessionMessage[] | undefined;

package/dist/hooks/runtime-fallback/session-status-handler.d.ts

@@ -0,0 +1,3 @@
+import type { HookDeps } from "./types";
+import type { AutoRetryHelpers } from "./auto-retry";
+export declare function createSessionStatusHandler(deps: HookDeps, helpers: AutoRetryHelpers, sessionStatusRetryKeys: Map<string, string>): (props: Record<string, unknown> | undefined) => Promise<void>;

package/dist/hooks/runtime-fallback/types.d.ts

@@ -1,5 +1,57 @@
-import type { PluginInput } from "@opencode-ai/plugin";
 import type { RuntimeFallbackConfig, OhMyOpenCodeConfig } from "../../config";
+export interface RuntimeFallbackInterval {
+    unref: () => void;
+}
+export type RuntimeFallbackTimeout = object | number;
+export interface RuntimeFallbackPluginInput {
+    client: {
+        session: {
+            abort: (input: {
+                path: {
+                    id: string;
+                };
+            }) => Promise<unknown>;
+            messages: (input: {
+                path: {
+                    id: string;
+                };
+                query: {
+                    directory: string;
+                };
+            }) => Promise<unknown>;
+            promptAsync: (input: {
+                path: {
+                    id: string;
+                };
+                body: {
+                    agent?: string;
+                    model: {
+                        providerID: string;
+                        modelID: string;
+                    };
+                    parts: Array<{
+                        type: "text";
+                        text: string;
+                    }>;
+                };
+                query: {
+                    directory: string;
+                };
+            }) => Promise<unknown>;
+        };
+        tui: {
+            showToast: (input: {
+                body: {
+                    title: string;
+                    message: string;
+                    variant: "success" | "error" | "info" | "warning";
+                    duration: number;
+                };
+            }) => Promise<unknown>;
+        };
+    };
+    directory: string;
+}
 export interface FallbackState {
     originalModel: string;
     currentModel: string;
@@ -45,9 +97,10 @@ export interface RuntimeFallbackHook {
             text?: string;
         }>;
     }) => Promise<void>;
+    dispose?: () => void;
 }
 export interface HookDeps {
-    ctx: PluginInput;
+    ctx: RuntimeFallbackPluginInput;
     config: Required<RuntimeFallbackConfig>;
     options: RuntimeFallbackOptions | undefined;
     pluginConfig: OhMyOpenCodeConfig | undefined;
@@ -55,5 +108,6 @@ export interface HookDeps {
     sessionLastAccess: Map<string, number>;
     sessionRetryInFlight: Set<string>;
     sessionAwaitingFallbackResult: Set<string>;
-    sessionFallbackTimeouts: Map<string, ReturnType<typeof setTimeout>>;
+    sessionFallbackTimeouts: Map<string, RuntimeFallbackTimeout>;
+    sessionStatusRetryKeys: Map<string, string>;
 }

package/dist/hooks/runtime-fallback/visible-assistant-response.d.ts

@@ -0,0 +1,3 @@
+import type { HookDeps } from "./types";
+import { extractAutoRetrySignal } from "./error-classifier";
+export declare function hasVisibleAssistantResponse(extractAutoRetrySignalFn: typeof extractAutoRetrySignal): (ctx: HookDeps["ctx"], sessionID: string, _info: Record<string, unknown> | undefined) => Promise<boolean>;

package/dist/hooks/session-notification-content.d.ts

@@ -0,0 +1,30 @@
+type ReadyNotificationContext = {
+    client: {
+        session: {
+            get?: (input: {
+                path: {
+                    id: string;
+                };
+            }) => Promise<unknown>;
+            messages?: (input: {
+                path: {
+                    id: string;
+                };
+                query: {
+                    directory: string;
+                };
+            }) => Promise<unknown>;
+        };
+    };
+    directory: string;
+};
+type ReadyNotificationInput = {
+    sessionID: string;
+    baseTitle: string;
+    baseMessage: string;
+};
+export declare function buildReadyNotificationContent(ctx: ReadyNotificationContext, input: ReadyNotificationInput): Promise<{
+    title: string;
+    message: string;
+}>;
+export {};