oh-my-opencode 3.17.4 → 3.17.6

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>;

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

@@ -0,0 +1,53 @@
+export interface TokenInfo {
+    input: number;
+    output: number;
+    reasoning: number;
+    cache: {
+        read: number;
+        write: number;
+    };
+}
+export interface CachedCompactionState {
+    providerID: string;
+    modelID: string;
+    tokens: TokenInfo;
+}
+export interface PreemptiveCompactionClient {
+    session: {
+        messages: (input: {
+            path: {
+                id: string;
+            };
+            query?: {
+                directory: string;
+            };
+        }) => Promise<unknown>;
+        summarize: (input: {
+            path: {
+                id: string;
+            };
+            body: {
+                providerID: string;
+                modelID: string;
+                auto?: boolean;
+            };
+            query: {
+                directory: string;
+            };
+        }) => Promise<unknown>;
+    };
+    tui: {
+        showToast: (input: {
+            body: {
+                title: string;
+                message: string;
+                variant: "warning";
+                duration: number;
+            };
+        }) => Promise<unknown>;
+    };
+}
+export interface PreemptiveCompactionContext {
+    client: PreemptiveCompactionClient;
+    directory: string;
+}

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

@@ -1,18 +1,7 @@
 import type { OhMyOpenCodeConfig } from "../config";
-import { type ContextLimitModelCacheState } from "../shared/context-limit-resolver";
-type PluginInput = {
-    client: {
-        session: {
-            messages: (...args: any[]) => any;
-            summarize: (...args: any[]) => any;
-        };
-        tui: {
-            showToast: (...args: any[]) => any;
-        };
-    };
-    directory: string;
-};
-export declare function createPreemptiveCompactionHook(ctx: PluginInput, pluginConfig: OhMyOpenCodeConfig, modelCacheState?: ContextLimitModelCacheState): {
+import type { ContextLimitModelCacheState } from "../shared/context-limit-resolver";
+import type { PreemptiveCompactionContext } from "./preemptive-compaction-types";
+export declare function createPreemptiveCompactionHook(ctx: PreemptiveCompactionContext, pluginConfig: OhMyOpenCodeConfig, modelCacheState?: ContextLimitModelCacheState): {
     "tool.execute.after": (input: {
         tool: string;
         sessionID: string;
@@ -29,4 +18,3 @@ export declare function createPreemptiveCompactionHook(ctx: PluginInput, pluginC
         };
     }) => Promise<void>;
 };
-export {};

package/dist/hooks/ralph-loop/ralph-loop-event-handler.d.ts

@@ -1,10 +1,5 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { RalphLoopOptions, RalphLoopState } from "./types";
-type SessionRecovery = {
-    isRecovering: (sessionID: string) => boolean;
-    markRecovering: (sessionID: string) => void;
-    clear: (sessionID: string) => void;
-};
 type LoopStateController = {
     getState: () => RalphLoopState | null;
     clear: () => boolean;
@@ -19,7 +14,7 @@ type RalphLoopEventHandlerOptions = {
     apiTimeoutMs: number;
     getTranscriptPath: (sessionID: string) => string | undefined;
     checkSessionExists?: RalphLoopOptions["checkSessionExists"];
-    sessionRecovery: SessionRecovery;
+    backgroundManager?: RalphLoopOptions["backgroundManager"];
     loopState: LoopStateController;
 };
 export declare function createRalphLoopEventHandler(ctx: PluginInput, options: RalphLoopEventHandlerOptions): ({ event }: {

package/dist/hooks/ralph-loop/session-event-handler.d.ts

@@ -3,10 +3,6 @@ type LoopStateController = {
     getState: () => RalphLoopState | null;
     clear: () => boolean;
 };
-type SessionRecovery = {
-    clear: (sessionID: string) => void;
-    markRecovering: (sessionID: string) => void;
-};
-export declare function handleDeletedLoopSession(props: Record<string, unknown> | undefined, loopState: LoopStateController, sessionRecovery: SessionRecovery): boolean;
-export declare function handleErroredLoopSession(props: Record<string, unknown> | undefined, loopState: LoopStateController, sessionRecovery: SessionRecovery): boolean;
+export declare function handleDeletedLoopSession(props: Record<string, unknown> | undefined, loopState: LoopStateController): boolean;
+export declare function handleErroredLoopSession(props: Record<string, unknown> | undefined, loopState: LoopStateController): boolean;
 export {};

package/dist/hooks/ralph-loop/types.d.ts

@@ -20,4 +20,9 @@ export interface RalphLoopOptions {
     getTranscriptPath?: (sessionId: string) => string;
     apiTimeout?: number;
     checkSessionExists?: (sessionId: string) => Promise<boolean>;
+    backgroundManager?: {
+        getTasksByParentSession: (sessionId: string) => Array<{
+            status: string;
+        }>;
+    };
 }

package/dist/hooks/rules-injector/cache.d.ts

@@ -1,3 +1,4 @@
+import type { RuleScanCache } from "./rule-scan-cache";
 export type SessionInjectedRulesCache = {
     contentHashes: Set<string>;
     realPaths: Set<string>;
@@ -6,3 +7,7 @@ export declare function createSessionCacheStore(): {
     getSessionCache: (sessionID: string) => SessionInjectedRulesCache;
     clearSessionCache: (sessionID: string) => void;
 };
+export declare function createSessionRuleScanCacheStore(): {
+    getSessionRuleScanCache: (sessionID: string) => RuleScanCache;
+    clearSessionRuleScanCache: (sessionID: string) => void;
+};

package/dist/hooks/rules-injector/injector.d.ts

@@ -4,6 +4,7 @@ import type { FindRuleFilesOptions } from "./rule-file-finder";
 import { createContentHash, isDuplicateByContentHash, isDuplicateByRealPath, shouldApplyRule } from "./matcher";
 import { saveInjectedRules } from "./storage";
 import type { SessionInjectedRulesCache } from "./cache";
+import type { RuleScanCache } from "./rule-scan-cache";
 type ToolExecuteOutput = {
     title: string;
     output: string;
@@ -19,6 +20,7 @@ export declare function createRuleInjectionProcessor(deps: {
     workspaceDirectory: string;
     truncator: DynamicTruncator;
     getSessionCache: (sessionID: string) => SessionInjectedRulesCache;
+    getSessionRuleScanCache?: (sessionID: string) => RuleScanCache;
     ruleFinderOptions?: FindRuleFilesOptions;
     readFileSync?: typeof readFileSync;
     statSync?: typeof statSync;

package/dist/hooks/rules-injector/project-root-finder.d.ts

@@ -1,3 +1,4 @@
+export declare function clearProjectRootCache(): void;
 /**
  * Find project root by walking up from startPath.
  * Checks for PROJECT_MARKERS (.git, pyproject.toml, package.json, etc.)

package/dist/hooks/rules-injector/rule-file-finder.d.ts

@@ -1,23 +1,6 @@
+import type { RuleScanCache } from "./rule-scan-cache";
 import type { RuleFileCandidate } from "./types";
 export interface FindRuleFilesOptions {
-    /**
-     * When true, skip loading rules from ~/.claude/rules/.
-     * Use when claude_code integration is disabled to prevent
-     * Claude Code-specific instructions from leaking into non-Claude agents.
-     */
     skipClaudeUserRules?: boolean;
 }
-/**
- * Find all rule files for a given context.
- * Searches from currentFile upward to projectRoot for rule directories,
- * then user-level directory (~/.claude/rules).
- *
- * IMPORTANT: This searches EVERY directory from file to project root.
- * Not just the project root itself.
- *
- * @param projectRoot - Project root path (or null if outside any project)
- * @param homeDir - User home directory
- * @param currentFile - Current file being edited (for distance calculation)
- * @returns Array of rule file candidates sorted by distance
- */
-export declare function findRuleFiles(projectRoot: string | null, homeDir: string, currentFile: string, options?: FindRuleFilesOptions): RuleFileCandidate[];
+export declare function findRuleFiles(projectRoot: string | null, homeDir: string, currentFile: string, options?: FindRuleFilesOptions, cache?: RuleScanCache): RuleFileCandidate[];

package/dist/hooks/rules-injector/rule-scan-cache.d.ts

@@ -0,0 +1,6 @@
+export type RuleScanCache = {
+    get: (key: string) => string[] | undefined;
+    set: (key: string, value: string[]) => void;
+    clear: () => void;
+};
+export declare function createRuleScanCache(): RuleScanCache;

package/dist/hooks/session-notification-event-properties.d.ts

@@ -0,0 +1,5 @@
+type EventProperties = Record<string, unknown> | undefined;
+export declare function getSessionID(properties: EventProperties): string | undefined;
+export declare function getEventToolName(properties: EventProperties): string | undefined;
+export declare function getQuestionText(properties: EventProperties): string;
+export {};

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

@@ -0,0 +1,7 @@
+import type { Platform } from "./session-notification-sender";
+export declare function createSessionNotificationInit(): {
+    initialize: () => {
+        platform: Platform;
+        defaultSoundPath: string;
+    };
+};

package/dist/hooks/todo-continuation-enforcer/session-state.d.ts

@@ -9,6 +9,7 @@ export interface ContinuationProgressUpdate {
 export interface SessionStateStore {
     getState: (sessionID: string) => SessionState;
     getExistingState: (sessionID: string) => SessionState | undefined;
+    startPruneInterval: () => void;
     recordActivity: (sessionID: string) => void;
     trackContinuationProgress: (sessionID: string, incompleteCount: number, todos?: Todo[], options?: ContinuationProgressOptions) => ContinuationProgressUpdate;
     resetContinuationProgress: (sessionID: string) => void;

package/dist/hooks/write-existing-file-guard/tool-execute-before-handler.d.ts

@@ -10,6 +10,6 @@ export declare function handleWriteExistingFileGuardToolExecuteBefore(params: {
     };
     readPermissionsBySession: Map<string, Set<string>>;
     sessionLastAccess: Map<string, number>;
-    canonicalSessionRoot: string;
+    getCanonicalSessionRoot: () => string;
     maxTrackedSessions: number;
 }): Promise<void>;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import type { Plugin } from "@opencode-ai/plugin";
-declare const OhMyOpenCodePlugin: Plugin;
-export default OhMyOpenCodePlugin;
+import type { PluginModule } from "@opencode-ai/plugin";
+declare const pluginModule: PluginModule;
+export default pluginModule;
 export type { OhMyOpenCodeConfig, AgentName, AgentOverrideConfig, AgentOverrides, McpName, HookName, BuiltinCommandName, } from "./config";
 export type { ConfigLoadError } from "./shared/config-errors";