evil-omo 3.17.4 → 3.17.6

package/dist/config/schema/background-task.d.ts

@@ -4,7 +4,6 @@ export declare const BackgroundTaskConfigSchema: z.ZodObject<{
     providerConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     modelConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     maxDepth: z.ZodOptional<z.ZodNumber>;
-    maxDescendants: z.ZodOptional<z.ZodNumber>;
     staleTimeoutMs: z.ZodOptional<z.ZodNumber>;
     messageStalenessTimeoutMs: z.ZodOptional<z.ZodNumber>;
     taskTtlMs: z.ZodOptional<z.ZodNumber>;

package/dist/config/schema/evil-omo-config.d.ts

@@ -1996,7 +1996,6 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         providerConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
         modelConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
         maxDepth: z.ZodOptional<z.ZodNumber>;
-        maxDescendants: z.ZodOptional<z.ZodNumber>;
         staleTimeoutMs: z.ZodOptional<z.ZodNumber>;
         messageStalenessTimeoutMs: z.ZodOptional<z.ZodNumber>;
         taskTtlMs: z.ZodOptional<z.ZodNumber>;

package/dist/create-hooks.d.ts

@@ -2,6 +2,7 @@ import type { AvailableSkill } from "./agents/dynamic-agent-prompt-builder";
 import type { HookName, OhMyOpenCodeConfig } from "./config";
 import type { LoadedSkill } from "./features/opencode-skill-loader/types";
 import type { BackgroundManager } from "./features/background-agent";
+import type { ModelFallbackControllerAccessor } from "./hooks/model-fallback";
 import type { PluginContext } from "./plugin/types";
 import type { ModelCacheState } from "./plugin-state";
 export type CreatedHooks = ReturnType<typeof createHooks>;
@@ -22,6 +23,7 @@ export declare function createHooks(args: {
     pluginConfig: OhMyOpenCodeConfig;
     modelCacheState: ModelCacheState;
     backgroundManager: BackgroundManager;
+    modelFallbackControllerAccessor?: ModelFallbackControllerAccessor;
     isHookEnabled: (hookName: HookName) => boolean;
     safeHookEnabled: boolean;
     mergedSkills: LoadedSkill[];

package/dist/create-managers.d.ts

@@ -8,6 +8,7 @@ import { TmuxSessionManager } from "./features/tmux-subagent";
 import { registerManagerForCleanup } from "./features/background-agent/process-cleanup";
 import { createConfigHandler } from "./plugin-handlers";
 import { markServerRunningInProcess } from "./shared/tmux/tmux-utils/server-health";
+import type { ModelFallbackControllerAccessor } from "./hooks/model-fallback";
 type CreateManagersDeps = {
     BackgroundManagerClass: typeof BackgroundManager;
     SkillMcpManagerClass: typeof SkillMcpManager;
@@ -22,6 +23,7 @@ export type Managers = {
     backgroundManager: BackgroundManager;
     skillMcpManager: SkillMcpManager;
     configHandler: ReturnType<typeof createConfigHandler>;
+    modelFallbackControllerAccessor: ModelFallbackControllerAccessor;
 };
 export declare function createManagers(args: {
     ctx: PluginContext;

package/dist/create-tools.d.ts

@@ -16,6 +16,6 @@ type CreateToolsResult = {
 export declare function createTools(args: {
     ctx: PluginContext;
     pluginConfig: OhMyOpenCodeConfig;
-    managers: Pick<Managers, "backgroundManager" | "tmuxSessionManager" | "skillMcpManager">;
+    managers: Pick<Managers, "backgroundManager" | "tmuxSessionManager" | "skillMcpManager" | "modelFallbackControllerAccessor">;
 }): Promise<CreateToolsResult>;
 export {};

package/dist/evil-omo.schema.json

@@ -5638,11 +5638,6 @@
           "minimum": 1,
           "maximum": 9007199254740991
         },
-        "maxDescendants": {
-          "type": "integer",
-          "minimum": 1,
-          "maximum": 9007199254740991
-        },
         "staleTimeoutMs": {
           "type": "number",
           "minimum": 60000

package/dist/features/background-agent/process-cleanup.test-helpers.d.ts

@@ -0,0 +1,4 @@
+type ProcessCleanupEvent = NodeJS.Signals | "beforeExit" | "exit" | "uncaughtException" | "unhandledRejection";
+export declare function getNewListener(signal: ProcessCleanupEvent, existingListeners: Function[]): () => void;
+export declare function flushMicrotasks(): Promise<void>;
+export {};

package/dist/features/background-agent/subagent-spawn-limits.d.ts

@@ -1,14 +1,12 @@
 import type { BackgroundTaskConfig } from "../../config/schema";
 import type { OpencodeClient } from "./constants";
 export declare const DEFAULT_MAX_SUBAGENT_DEPTH = 3;
-export declare const DEFAULT_MAX_ROOT_SESSION_SPAWN_BUDGET = 50;
 export interface SubagentSpawnContext {
     rootSessionID: string;
     parentDepth: number;
     childDepth: number;
 }
 export declare function getMaxSubagentDepth(config?: BackgroundTaskConfig): number;
-export declare function getMaxRootSessionSpawnBudget(config?: BackgroundTaskConfig): number;
 export declare function resolveSubagentSpawnContext(client: OpencodeClient, parentSessionID: string, directory?: string): Promise<SubagentSpawnContext>;
 export declare function createSubagentDepthLimitError(input: {
     childDepth: number;
@@ -16,8 +14,3 @@ export declare function createSubagentDepthLimitError(input: {
     parentSessionID: string;
     rootSessionID: string;
 }): Error;
-export declare function createSubagentDescendantLimitError(input: {
-    rootSessionID: string;
-    descendantCount: number;
-    maxDescendants: number;
-}): Error;

package/dist/features/claude-code-command-loader/loader-cache.d.ts

@@ -0,0 +1,6 @@
+import type { CommandDefinition } from "./types";
+export declare function getCommandLoaderCacheKey(directory?: string): Promise<string>;
+export declare function getCachedCommands(cacheKey: string): Promise<Record<string, CommandDefinition>> | undefined;
+export declare function setCachedCommands(cacheKey: string, commands: Promise<Record<string, CommandDefinition>>): void;
+export declare function deleteCachedCommands(cacheKey: string): void;
+export declare function clearCommandLoaderCache(): void;

package/dist/features/claude-code-command-loader/loader.d.ts

@@ -1,4 +1,6 @@
+import { clearCommandLoaderCache } from "./loader-cache";
 import type { CommandDefinition } from "./types";
+export { clearCommandLoaderCache };
 export declare function loadUserCommands(): Promise<Record<string, CommandDefinition>>;
 export declare function loadProjectCommands(directory?: string): Promise<Record<string, CommandDefinition>>;
 export declare function loadOpencodeGlobalCommands(): Promise<Record<string, CommandDefinition>>;

package/dist/features/team-mode/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export * from "./team-worktree";

package/dist/features/team-mode/team-layout-tmux/index.d.ts

@@ -0,0 +1 @@
+export { canVisualize, createTeamLayout, removeTeamLayout } from "./layout";

package/dist/features/team-mode/team-layout-tmux/layout.d.ts

@@ -0,0 +1,15 @@
+import type { TmuxSessionManager } from "../../tmux-subagent/manager";
+type TeamLayoutMember = {
+    name: string;
+    sessionId: string;
+    color?: string;
+};
+type TeamLayoutResult = {
+    focusWindowId: string;
+    gridWindowId: string;
+    panesByMember: Record<string, string>;
+};
+export declare function canVisualize(): boolean;
+export declare function createTeamLayout(teamRunId: string, members: Array<TeamLayoutMember>, tmuxMgr: TmuxSessionManager): Promise<TeamLayoutResult | null>;
+export declare function removeTeamLayout(teamRunId: string, tmuxMgr: TmuxSessionManager): Promise<void>;
+export {};

package/dist/features/team-mode/team-worktree/cleanup.d.ts

@@ -0,0 +1,3 @@
+import type { TeamModeConfig } from "./manager";
+export declare function removeWorktree(worktreePath: string): Promise<void>;
+export declare function findOrphanWorktrees(baseDir: string, _config: TeamModeConfig): Promise<string[]>;

package/dist/features/team-mode/team-worktree/index.d.ts

@@ -0,0 +1,2 @@
+export { GitUnavailableError, createWorktree, isGitAvailable, validateWorktreeSpec } from "./manager";
+export { findOrphanWorktrees, removeWorktree } from "./cleanup";

package/dist/features/team-mode/team-worktree/manager.d.ts

@@ -0,0 +1,15 @@
+export type TeamModeConfig = {
+    worktreeBaseDir?: string;
+};
+export declare class GitUnavailableError extends Error {
+    constructor();
+}
+declare function runGit(args: string[], cwd?: string): Promise<{
+    code: number;
+    stderr: string;
+}>;
+export declare function setGitCommandRunnerForTests(runner: typeof runGit): void;
+export declare function isGitAvailable(): Promise<boolean>;
+export declare function validateWorktreeSpec(spec: string): void;
+export declare function createWorktree(repoRoot: string, _teamRunId: string, _memberName: string, worktreePath: string, _config: TeamModeConfig): Promise<string>;
+export {};

package/dist/features/team-mode/types.d.ts

@@ -0,0 +1,210 @@
+import { z } from "zod";
+export declare const MESSAGE_KINDS: readonly ["message", "shutdown_request", "shutdown_approved", "shutdown_rejected", "announcement"];
+export declare const MEMBER_KINDS: readonly ["category", "subagent_type"];
+export declare const TASK_STATUSES: readonly ["pending", "claimed", "in_progress", "completed", "deleted"];
+export declare const RUNTIME_STATUSES: readonly ["creating", "active", "shutdown_requested", "deleting", "deleted", "failed", "orphaned"];
+export declare const CategoryMemberSchema: z.ZodObject<{
+    name: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    worktreePath: z.ZodOptional<z.ZodString>;
+    subscriptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    backendType: z.ZodDefault<z.ZodEnum<{
+        tmux: "tmux";
+        "in-process": "in-process";
+    }>>;
+    color: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+    kind: z.ZodLiteral<"category">;
+    category: z.ZodString;
+    prompt: z.ZodString;
+}, z.core.$strict>;
+export declare const SubagentMemberSchema: z.ZodObject<{
+    name: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    worktreePath: z.ZodOptional<z.ZodString>;
+    subscriptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    backendType: z.ZodDefault<z.ZodEnum<{
+        tmux: "tmux";
+        "in-process": "in-process";
+    }>>;
+    color: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+    kind: z.ZodLiteral<"subagent_type">;
+    subagent_type: z.ZodString;
+    prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const MemberSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    name: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    worktreePath: z.ZodOptional<z.ZodString>;
+    subscriptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    backendType: z.ZodDefault<z.ZodEnum<{
+        tmux: "tmux";
+        "in-process": "in-process";
+    }>>;
+    color: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+    kind: z.ZodLiteral<"category">;
+    category: z.ZodString;
+    prompt: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    name: z.ZodString;
+    cwd: z.ZodOptional<z.ZodString>;
+    worktreePath: z.ZodOptional<z.ZodString>;
+    subscriptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    backendType: z.ZodDefault<z.ZodEnum<{
+        tmux: "tmux";
+        "in-process": "in-process";
+    }>>;
+    color: z.ZodOptional<z.ZodString>;
+    isActive: z.ZodDefault<z.ZodBoolean>;
+    kind: z.ZodLiteral<"subagent_type">;
+    subagent_type: z.ZodString;
+    prompt: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "kind">;
+export declare const TeamSpecSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodNumber;
+    leadAgentId: z.ZodString;
+    teamAllowedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sessionPermission: z.ZodOptional<z.ZodString>;
+    members: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        name: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        worktreePath: z.ZodOptional<z.ZodString>;
+        subscriptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        backendType: z.ZodDefault<z.ZodEnum<{
+            tmux: "tmux";
+            "in-process": "in-process";
+        }>>;
+        color: z.ZodOptional<z.ZodString>;
+        isActive: z.ZodDefault<z.ZodBoolean>;
+        kind: z.ZodLiteral<"category">;
+        category: z.ZodString;
+        prompt: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        name: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        worktreePath: z.ZodOptional<z.ZodString>;
+        subscriptions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        backendType: z.ZodDefault<z.ZodEnum<{
+            tmux: "tmux";
+            "in-process": "in-process";
+        }>>;
+        color: z.ZodOptional<z.ZodString>;
+        isActive: z.ZodDefault<z.ZodBoolean>;
+        kind: z.ZodLiteral<"subagent_type">;
+        subagent_type: z.ZodString;
+        prompt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>], "kind">>;
+}, z.core.$strip>;
+export declare const MessageSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    messageId: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodString;
+    kind: z.ZodEnum<{
+        message: "message";
+        shutdown_request: "shutdown_request";
+        shutdown_approved: "shutdown_approved";
+        shutdown_rejected: "shutdown_rejected";
+        announcement: "announcement";
+    }>;
+    body: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    references: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    timestamp: z.ZodNumber;
+    correlationId: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const TaskSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    id: z.ZodString;
+    subject: z.ZodString;
+    description: z.ZodString;
+    activeForm: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        in_progress: "in_progress";
+        completed: "completed";
+        deleted: "deleted";
+        claimed: "claimed";
+    }>;
+    owner: z.ZodOptional<z.ZodString>;
+    blocks: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    blockedBy: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    claimedAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const RuntimeStateSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    teamRunId: z.ZodString;
+    teamName: z.ZodString;
+    specSource: z.ZodEnum<{
+        user: "user";
+        project: "project";
+    }>;
+    createdAt: z.ZodNumber;
+    status: z.ZodEnum<{
+        deleted: "deleted";
+        failed: "failed";
+        active: "active";
+        creating: "creating";
+        shutdown_requested: "shutdown_requested";
+        deleting: "deleting";
+        orphaned: "orphaned";
+    }>;
+    leadSessionId: z.ZodOptional<z.ZodString>;
+    members: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        sessionId: z.ZodOptional<z.ZodString>;
+        tmuxPaneId: z.ZodOptional<z.ZodString>;
+        agentType: z.ZodEnum<{
+            leader: "leader";
+            "general-purpose": "general-purpose";
+        }>;
+        status: z.ZodEnum<{
+            pending: "pending";
+            completed: "completed";
+            running: "running";
+            idle: "idle";
+            errored: "errored";
+            shutdown_approved: "shutdown_approved";
+        }>;
+        color: z.ZodOptional<z.ZodString>;
+        worktreePath: z.ZodOptional<z.ZodString>;
+        lastInjectedTurnMarker: z.ZodOptional<z.ZodString>;
+        pendingInjectedMessageIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    shutdownRequests: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        memberId: z.ZodString;
+        requestedAt: z.ZodNumber;
+        approvedAt: z.ZodOptional<z.ZodNumber>;
+        rejectedReason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+    bounds: z.ZodObject<{
+        maxMembers: z.ZodDefault<z.ZodNumber>;
+        maxParallelMembers: z.ZodDefault<z.ZodNumber>;
+        maxMessagesPerRun: z.ZodDefault<z.ZodNumber>;
+        maxWallClockMinutes: z.ZodDefault<z.ZodNumber>;
+        maxMemberTurns: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>;
+}, z.core.$strip>;
+export declare const AGENT_ELIGIBILITY_REGISTRY: Readonly<Record<string, {
+    verdict: "eligible" | "conditional" | "hard-reject";
+    rejectionMessage?: string;
+}>>;
+export type TeamSpec = z.infer<typeof TeamSpecSchema>;
+export type Member = z.infer<typeof MemberSchema>;
+export type CategoryMember = z.infer<typeof CategoryMemberSchema>;
+export type SubagentMember = z.infer<typeof SubagentMemberSchema>;
+export type Message = z.infer<typeof MessageSchema>;
+export type Task = z.infer<typeof TaskSchema>;
+export type RuntimeState = z.infer<typeof RuntimeStateSchema>;

package/dist/features/tmux-subagent/event-handlers.d.ts

@@ -1,6 +1,2 @@
 export { coerceSessionCreatedEvent } from "./session-created-event";
 export type { SessionCreatedEvent } from "./session-created-event";
-export { handleSessionCreated } from "./session-created-handler";
-export type { SessionCreatedHandlerDeps } from "./session-created-handler";
-export { handleSessionDeleted } from "./session-deleted-handler";
-export type { SessionDeletedHandlerDeps } from "./session-deleted-handler";

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

@@ -1,10 +1,7 @@
 export * from "./manager";
 export * from "./event-handlers";
 export * from "./polling";
-export * from "./cleanup";
 export * from "./session-created-event";
-export * from "./session-created-handler";
-export * from "./session-deleted-handler";
 export * from "./polling-constants";
 export * from "./session-status-parser";
 export * from "./session-message-count";

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

@@ -32,6 +32,8 @@ export declare class TmuxSessionManager {
     private isolatedContainerPaneId;
     private isolatedWindowPaneId;
     private isolatedContainerNullStateCount;
+    private staleSweepCompleted;
+    private staleSweepInProgress;
     constructor(ctx: PluginInput, tmuxConfig: TmuxConfig, deps?: TmuxUtilDeps);
     private isEnabled;
     private isIsolated;
@@ -54,6 +56,7 @@ export declare class TmuxSessionManager {
     private startDeferredAttachLoop;
     private stopDeferredAttachLoop;
     private tryAttachDeferredSession;
+    private logSessionReadinessInBackground;
     private waitForSessionReady;
     onSessionCreated(event: SessionCreatedEvent): Promise<void>;
     private enqueueSpawn;
@@ -72,5 +75,6 @@ export declare class TmuxSessionManager {
         };
     }) => Promise<void>;
     cleanup(): Promise<void>;
+    private sweepStaleIsolatedSessionsOnce;
 }
 export {};

package/dist/features/tmux-subagent/polling-manager.d.ts

@@ -4,9 +4,10 @@ export declare class TmuxPollingManager {
     private client;
     private sessions;
     private closeSessionById;
+    private retryPendingCloses?;
     private pollInterval?;
     private pollingInFlight;
-    constructor(client: OpencodeClient, sessions: Map<string, TrackedSession>, closeSessionById: (sessionId: string) => Promise<void>);
+    constructor(client: OpencodeClient, sessions: Map<string, TrackedSession>, closeSessionById: (sessionId: string) => Promise<void>, retryPendingCloses?: (() => Promise<void>) | undefined);
     handleEvent(event: {
         type: string;
         properties?: Record<string, unknown>;

package/dist/hooks/auto-update-checker/hook/deferred-startup-check.d.ts

@@ -0,0 +1 @@
+export declare function scheduleDeferredStartupCheck(runCheck: () => void): void;

package/dist/hooks/comment-checker/initialization-gate.d.ts

@@ -0,0 +1 @@
+export declare function ensureCommentCheckerInitialization(initializer: () => void): void;

package/dist/hooks/directory-agents-injector/finder.d.ts

@@ -2,4 +2,4 @@ export declare function resolveFilePath(rootDirectory: string, path: string): st
 export declare function findAgentsMdUp(input: {
     startDir: string;
     rootDir: string;
-}): string[];
+}): Promise<string[]>;

package/dist/hooks/directory-readme-injector/finder.d.ts

@@ -2,4 +2,4 @@ export declare function resolveFilePath(rootDirectory: string, path: string): st
 export declare function findReadmeMdUp(input: {
     startDir: string;
     rootDir: string;
-}): string[];
+}): Promise<string[]>;

package/dist/hooks/index.d.ts

@@ -13,7 +13,7 @@ export { createDirectoryReadmeInjectorHook } from "./directory-readme-injector";
 export { createEmptyTaskResponseDetectorHook } from "./empty-task-response-detector";
 export { createAnthropicContextWindowLimitRecoveryHook, type AnthropicContextWindowLimitRecoveryOptions } from "./anthropic-context-window-limit-recovery";
 export { createThinkModeHook } from "./think-mode";
-export { createModelFallbackHook, setPendingModelFallback, clearPendingModelFallback, type ModelFallbackState } from "./model-fallback/hook";
+export { createModelFallbackHook, setPendingModelFallback, clearPendingModelFallback, type ModelFallbackHook, type ModelFallbackState, } from "./model-fallback/hook";
 export { createClaudeCodeHooksHook } from "./claude-code-hooks";
 export { createRulesInjectorHook } from "./rules-injector";
 export { createBackgroundNotificationHook } from "./background-notification";

package/dist/hooks/model-fallback/controller-accessor.d.ts

@@ -0,0 +1,8 @@
+import type { FallbackEntry } from "../../shared/model-requirements";
+import type { ModelFallbackStateController } from "./fallback-state-controller";
+export type ModelFallbackControllerAccessor = {
+    register: (controller: ModelFallbackStateController) => void;
+    setSessionFallbackChain: (sessionID: string, fallbackChain: FallbackEntry[] | undefined) => void;
+    clearSessionFallbackChain: (sessionID: string) => void;
+};
+export declare function createModelFallbackControllerAccessor(): ModelFallbackControllerAccessor;

package/dist/hooks/model-fallback/fallback-state-controller.d.ts

@@ -0,0 +1,26 @@
+import type { FallbackEntry } from "../../shared/model-requirements";
+import { getNextReachableFallback } from "./next-fallback";
+type ModelFallbackStateLike = {
+    providerID: string;
+    modelID: string;
+    fallbackChain: FallbackEntry[];
+    attemptCount: number;
+    pending: boolean;
+};
+export type ModelFallbackStateController = {
+    lastToastKey: Map<string, string>;
+    setSessionFallbackChain: (sessionID: string, fallbackChain: FallbackEntry[] | undefined) => void;
+    clearSessionFallbackChain: (sessionID: string) => void;
+    setPendingModelFallback: (sessionID: string, agentName: string, currentProviderID: string, currentModelID: string) => boolean;
+    getNextFallback: (sessionID: string) => ReturnType<typeof getNextReachableFallback>;
+    clearPendingModelFallback: (sessionID: string) => void;
+    hasPendingModelFallback: (sessionID: string) => boolean;
+    getFallbackState: (sessionID: string) => ModelFallbackStateLike | undefined;
+    reset: () => void;
+};
+export declare function createModelFallbackStateController(input: {
+    pendingModelFallbacks: Map<string, ModelFallbackStateLike>;
+    lastToastKey: Map<string, string>;
+    sessionFallbackChains: Map<string, FallbackEntry[]>;
+}): ModelFallbackStateController;
+export {};

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

@@ -1,5 +1,7 @@
 import type { FallbackEntry } from "../../shared/model-requirements";
 import type { ChatMessageInput, ChatMessageHandlerOutput } from "../../plugin/chat-message";
+import { type ModelFallbackStateController } from "./fallback-state-controller";
+import type { ModelFallbackControllerAccessor } from "./controller-accessor";
 type FallbackToast = (input: {
     title: string;
     message: string;
@@ -19,18 +21,27 @@ export type ModelFallbackState = {
     attemptCount: number;
     pending: boolean;
 };
-export declare function setSessionFallbackChain(sessionID: string, fallbackChain: FallbackEntry[] | undefined): void;
-export declare function clearSessionFallbackChain(sessionID: string): void;
+type ModelFallbackControllerWithState = Pick<ModelFallbackStateController, "lastToastKey" | "setSessionFallbackChain" | "clearSessionFallbackChain" | "setPendingModelFallback" | "getNextFallback" | "clearPendingModelFallback" | "hasPendingModelFallback" | "getFallbackState" | "reset">;
+export type ModelFallbackHook = ModelFallbackControllerWithState & {
+    "chat.message": (input: ChatMessageInput, output: ChatMessageHandlerOutput) => Promise<void>;
+};
+type ModelFallbackHookArgs = {
+    toast?: FallbackToast;
+    onApplied?: FallbackCallback;
+    controllerAccessor?: ModelFallbackControllerAccessor;
+};
+export declare function setSessionFallbackChain(controller: Pick<ModelFallbackStateController, "setSessionFallbackChain">, sessionID: string, fallbackChain: FallbackEntry[] | undefined): void;
+export declare function clearSessionFallbackChain(controller: Pick<ModelFallbackStateController, "clearSessionFallbackChain">, sessionID: string): void;
 /**
  * Sets a pending model fallback for a session.
  * Called when a model error is detected in session.error handler.
  */
-export declare function setPendingModelFallback(sessionID: string, agentName: string, currentProviderID: string, currentModelID: string): boolean;
+export declare function setPendingModelFallback(controller: Pick<ModelFallbackStateController, "setPendingModelFallback">, sessionID: string, agentName: string, currentProviderID: string, currentModelID: string): boolean;
 /**
  * Gets the next fallback model for a session.
  * Increments attemptCount each time called.
  */
-export declare function getNextFallback(sessionID: string): {
+export declare function getNextFallback(controller: Pick<ModelFallbackStateController, "getNextFallback">, sessionID: string): {
     providerID: string;
     modelID: string;
     variant?: string;
@@ -39,27 +50,21 @@ export declare function getNextFallback(sessionID: string): {
  * Clears the pending fallback for a session.
  * Called after fallback is successfully applied.
  */
-export declare function clearPendingModelFallback(sessionID: string): void;
+export declare function clearPendingModelFallback(controller: Pick<ModelFallbackStateController, "clearPendingModelFallback">, sessionID: string): void;
 /**
  * Checks if there's a pending fallback for a session.
  */
-export declare function hasPendingModelFallback(sessionID: string): boolean;
+export declare function hasPendingModelFallback(controller: Pick<ModelFallbackStateController, "hasPendingModelFallback">, sessionID: string): boolean;
 /**
  * Gets the current fallback state for a session (for debugging).
  */
-export declare function getFallbackState(sessionID: string): ModelFallbackState | undefined;
+export declare function getFallbackState(controller: Pick<ModelFallbackStateController, "getFallbackState">, sessionID: string): ModelFallbackState | undefined;
 /**
  * Creates a chat.message hook that applies model fallbacks when pending.
  */
-export declare function createModelFallbackHook(args?: {
-    toast?: FallbackToast;
-    onApplied?: FallbackCallback;
-}): {
-    "chat.message": (input: ChatMessageInput, output: ChatMessageHandlerOutput) => Promise<void>;
-};
+export declare function createModelFallbackHook(args?: ModelFallbackHookArgs): ModelFallbackHook;
 /**
- * Resets all module-global state for testing.
- * Clears pending fallbacks, toast keys, and session chains.
+ * Resets hook-owned state for testing.
  */
-export declare function _resetForTesting(): void;
+export declare function _resetForTesting(controller?: Pick<ModelFallbackStateController, "reset">): void;
 export {};

package/dist/hooks/model-fallback/index.d.ts

@@ -0,0 +1,2 @@
+export { createModelFallbackControllerAccessor } from "./controller-accessor";
+export type { ModelFallbackControllerAccessor } from "./controller-accessor";

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

@@ -0,0 +1,13 @@
+import type { OhMyOpenCodeConfig } from "../config";
+import { type ContextLimitModelCacheState } from "../shared/context-limit-resolver";
+import type { CachedCompactionState, PreemptiveCompactionContext } from "./preemptive-compaction-types";
+export declare function runPreemptiveCompactionIfNeeded(args: {
+    ctx: PreemptiveCompactionContext;
+    pluginConfig: OhMyOpenCodeConfig;
+    modelCacheState?: ContextLimitModelCacheState;
+    sessionID: string;
+    tokenCache: Map<string, CachedCompactionState>;
+    compactionInProgress: Set<string>;
+    compactedSessions: Set<string>;
+    lastCompactionTime: Map<string, number>;
+}): Promise<void>;