oh-my-opencode 3.15.3 → 3.17.0

package/dist/cli/minimum-opencode-version.d.ts

@@ -0,0 +1 @@
+export declare function getUnsupportedOpenCodeVersionMessage(openCodeVersion: string | null): string | null;

package/dist/cli/model-fallback-types.d.ts

@@ -1,3 +1,4 @@
+import type { FallbackModelObject } from "../config/schema/fallback-models";
 export interface ProviderAvailability {
     native: {
         claude: boolean;
@@ -14,10 +15,12 @@ export interface ProviderAvailability {
 export interface AgentConfig {
     model: string;
     variant?: string;
+    fallback_models?: FallbackModelObject[];
 }
 export interface CategoryConfig {
     model: string;
     variant?: string;
+    fallback_models?: FallbackModelObject[];
 }
 export interface GeneratedOmoConfig {
     $schema: string;

package/dist/cli/types.d.ts

@@ -30,6 +30,7 @@ export interface ConfigMergeResult {
 }
 export interface DetectedConfig {
     isInstalled: boolean;
+    installedVersion: string | null;
     hasClaude: boolean;
     isMax20: boolean;
     hasOpenAI: boolean;

package/dist/create-managers.d.ts

@@ -3,8 +3,20 @@ import type { ModelCacheState } from "./plugin-state";
 import type { PluginContext, TmuxConfig } from "./plugin/types";
 import { BackgroundManager } from "./features/background-agent";
 import { SkillMcpManager } from "./features/skill-mcp-manager";
+import { initTaskToastManager } from "./features/task-toast-manager";
 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";
+type CreateManagersDeps = {
+    BackgroundManagerClass: typeof BackgroundManager;
+    SkillMcpManagerClass: typeof SkillMcpManager;
+    TmuxSessionManagerClass: typeof TmuxSessionManager;
+    initTaskToastManagerFn: typeof initTaskToastManager;
+    registerManagerForCleanupFn: typeof registerManagerForCleanup;
+    createConfigHandlerFn: typeof createConfigHandler;
+    markServerRunningInProcessFn: typeof markServerRunningInProcess;
+};
 export type Managers = {
     tmuxSessionManager: TmuxSessionManager;
     backgroundManager: BackgroundManager;
@@ -17,4 +29,6 @@ export declare function createManagers(args: {
     tmuxConfig: TmuxConfig;
     modelCacheState: ModelCacheState;
     backgroundNotificationHookEnabled: boolean;
+    deps?: Partial<CreateManagersDeps>;
 }): Managers;
+export {};

package/dist/features/background-agent/compaction-aware-message-resolver.d.ts

@@ -1,5 +1,7 @@
 import type { StoredMessage } from "../hook-message-injector";
+export { isCompactionAgent } from "../../shared/compaction-marker";
 type SessionMessage = {
+    id?: string;
     info?: {
         agent?: string;
         model?: {
@@ -11,8 +13,9 @@ type SessionMessage = {
         modelID?: string;
         tools?: StoredMessage["tools"];
     };
+    parts?: Array<{
+        type?: string;
+    }>;
 };
-export declare function isCompactionAgent(agent: string | undefined): boolean;
 export declare function resolvePromptContextFromSessionMessages(messages: SessionMessage[], sessionID?: string): StoredMessage | null;
 export declare function findNearestMessageExcludingCompaction(messageDir: string, sessionID?: string): StoredMessage | null;
-export {};

package/dist/features/boulder-state/storage.d.ts

@@ -25,6 +25,13 @@ export declare function upsertTaskSessionState(directory: string, input: {
 export declare function findPrometheusPlans(directory: string): string[];
 /**
  * Parse a plan file and count checkbox progress.
+ *
+ * Only top-level (zero-indent) checkboxes under `## TODOs` and
+ * `## Final Verification Wave` sections are counted. The checkbox
+ * body must carry a valid task label (`N.` for TODOs, `FN.` for
+ * Final Verification Wave). Nested acceptance-criteria checkboxes
+ * and checkboxes in other sections are intentionally ignored so
+ * that progress tracking stays aligned with `readCurrentTopLevelTask`.
  */
 export declare function getPlanProgress(planPath: string): PlanProgress;
 /**

package/dist/features/builtin-commands/templates/ralph-loop.d.ts

@@ -1,3 +1,3 @@
 export declare const RALPH_LOOP_TEMPLATE = "You are starting a Ralph Loop - a self-referential development loop that runs until task completion.\n\n## How Ralph Loop Works\n\n1. You will work on the task continuously\n2. When you believe the task is FULLY complete, output: `<promise>{{COMPLETION_PROMISE}}</promise>`\n3. If you don't output the promise, the loop will automatically inject another prompt to continue\n4. Maximum iterations: Configurable (default 100)\n\n## Rules\n\n- Focus on completing the task fully, not partially\n- Don't output the completion promise until the task is truly done\n- Each iteration should make meaningful progress toward the goal\n- If stuck, try different approaches\n- Use todos to track your progress\n\n## Exit Conditions\n\n1. **Completion**: Output your completion promise tag when fully complete\n2. **Max Iterations**: Loop stops automatically at limit\n3. **Cancel**: User runs `/cancel-ralph` command\n\n## Your Task\n\nParse the arguments below and begin working on the task. The format is:\n`\"task description\" [--completion-promise=TEXT] [--max-iterations=N] [--strategy=reset|continue]`\n\nDefault completion promise is \"DONE\" and default max iterations is 100.";
-export declare const ULW_LOOP_TEMPLATE = "You are starting an ULTRAWORK Loop - a self-referential development loop that runs until verified completion.\n\n## How ULTRAWORK Loop Works\n\n1. You will work on the task continuously\n2. When you believe the work is complete, output: `<promise>{{COMPLETION_PROMISE}}</promise>`\n3. That does NOT finish the loop yet. The system will require Oracle verification\n4. The loop only ends after the system confirms Oracle verified the result\n5. There is no iteration limit\n\n## Rules\n\n- Focus on finishing the task completely\n- After you emit the completion promise, run Oracle verification when instructed\n- Do not treat DONE as final completion until Oracle verifies it\n\n## Exit Conditions\n\n1. **Verified Completion**: Oracle verifies the result and the system confirms it\n2. **Cancel**: User runs `/cancel-ralph`\n\n## Your Task\n\nParse the arguments below and begin working on the task. The format is:\n`\"task description\" [--completion-promise=TEXT] [--strategy=reset|continue]`\n\nDefault completion promise is \"DONE\".";
+export declare const ULW_LOOP_TEMPLATE = "You are starting an ULTRAWORK Loop - a self-referential development loop that runs until verified completion.\n\n## How ULTRAWORK Loop Works\n\n1. You will work on the task continuously\n2. When you believe the work is complete, output: `<promise>{{COMPLETION_PROMISE}}</promise>`\n3. That does NOT finish the loop yet. The system will require Oracle verification\n4. The loop only ends after the system confirms Oracle verified the result\n5. The iteration limit is 500 for ultrawork mode, 100 for normal mode\n\n## Rules\n\n- Focus on finishing the task completely\n- After you emit the completion promise, run Oracle verification when instructed\n- Do not treat DONE as final completion until Oracle verifies it\n\n## Exit Conditions\n\n1. **Verified Completion**: Oracle verifies the result and the system confirms it\n2. **Cancel**: User runs `/cancel-ralph`\n\n## Your Task\n\nParse the arguments below and begin working on the task. The format is:\n`\"task description\" [--completion-promise=TEXT] [--strategy=reset|continue]`\n\nDefault completion promise is \"DONE\".";
 export declare const CANCEL_RALPH_TEMPLATE = "Cancel the currently active Ralph Loop.\n\nThis will:\n1. Stop the loop from continuing\n2. Clear the loop state file\n3. Allow the session to end normally\n\nCheck if a loop is active and cancel it. Inform the user of the result.";

package/dist/features/claude-code-mcp-loader/env-expander.d.ts

@@ -1,2 +1,5 @@
-export declare function expandEnvVars(value: string): string;
-export declare function expandEnvVarsInObject<T>(obj: T): T;
+export interface ExpandEnvVarsOptions {
+    trusted?: boolean;
+}
+export declare function expandEnvVars(value: string, options?: ExpandEnvVarsOptions): string;
+export declare function expandEnvVarsInObject<T>(obj: T, options?: ExpandEnvVarsOptions): T;

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

@@ -2,6 +2,12 @@ import type { CommandDefinition } from "../claude-code-command-loader/types";
 import type { McpServerConfig } from "../claude-code-mcp-loader/types";
 import type { ClaudeCodeAgentConfig } from "../claude-code-agent-loader/types";
 import type { HooksConfig, LoadedPlugin, PluginLoadError, PluginLoaderOptions } from "./types";
+import { discoverInstalledPlugins } from "./discovery";
+import { loadPluginCommands } from "./command-loader";
+import { loadPluginSkillsAsCommands } from "./skill-loader";
+import { loadPluginAgents } from "./agent-loader";
+import { loadPluginMcpServers } from "./mcp-server-loader";
+import { loadPluginHooksConfigs } from "./hook-loader";
 export { discoverInstalledPlugins } from "./discovery";
 export { loadPluginCommands } from "./command-loader";
 export { loadPluginSkillsAsCommands } from "./skill-loader";
@@ -17,5 +23,14 @@ export interface PluginComponentsResult {
     plugins: LoadedPlugin[];
     errors: PluginLoadError[];
 }
+export interface PluginComponentLoadDeps {
+    discoverInstalledPlugins: typeof discoverInstalledPlugins;
+    loadPluginCommands: typeof loadPluginCommands;
+    loadPluginSkillsAsCommands: typeof loadPluginSkillsAsCommands;
+    loadPluginAgents: typeof loadPluginAgents;
+    loadPluginMcpServers: typeof loadPluginMcpServers;
+    loadPluginHooksConfigs: typeof loadPluginHooksConfigs;
+}
 export declare function clearPluginComponentsCache(): void;
 export declare function loadAllPluginComponents(options?: PluginLoaderOptions): Promise<PluginComponentsResult>;
+export declare function loadAllPluginComponentsWithDeps(options: PluginLoaderOptions | undefined, deps: PluginComponentLoadDeps): Promise<PluginComponentsResult>;

package/dist/features/claude-code-plugin-loader/scope-filter.d.ts

@@ -0,0 +1,2 @@
+import type { PluginInstallation } from "./types";
+export declare function shouldLoadPluginForCwd(installation: Pick<PluginInstallation, "scope" | "projectPath">, cwd?: string): boolean;

package/dist/features/claude-code-plugin-loader/types.d.ts

@@ -16,6 +16,12 @@ export interface PluginInstallation {
     lastUpdated: string;
     gitCommitSha?: string;
     isLocal?: boolean;
+    /**
+     * Claude Code records this on project/local-scoped installations.
+     * Absolute path (or `~`-prefixed) of the project the plugin was installed for.
+     * Used to filter project/local plugins that do not belong to the current cwd.
+     */
+    projectPath?: string;
 }
 /**
  * Installed plugins database v1 (legacy)
@@ -46,6 +52,11 @@ export interface InstalledPluginEntryV3 {
     installPath: string;
     lastUpdated: string;
     gitCommitSha?: string;
+    /**
+     * Claude Code records this on project/local-scoped installations.
+     * Absolute path (or `~`-prefixed) of the project the plugin was installed for.
+     */
+    projectPath?: string;
 }
 /**
  * Installed plugins database structure

package/dist/features/claude-code-session-state/state.d.ts

@@ -4,6 +4,7 @@ export declare function setMainSession(id: string | undefined): void;
 export declare function getMainSessionID(): string | undefined;
 export declare function registerAgentName(name: string): void;
 export declare function isAgentRegistered(name: string): boolean;
+export declare function resolveRegisteredAgentName(name: string | undefined): string | undefined;
 /** @internal For testing only */
 export declare function _resetForTesting(): void;
 export declare function setSessionAgent(sessionID: string, agent: string): void;

package/dist/features/mcp-oauth/provider.d.ts

@@ -25,5 +25,6 @@ export declare class McpOAuthProvider {
         code: string;
     }>;
     login(): Promise<OAuthTokenData>;
+    refresh(refreshToken: string): Promise<OAuthTokenData>;
 }
 export { generateCodeVerifier, generateCodeChallenge, buildAuthorizationUrl, startCallbackServer };

package/dist/features/mcp-oauth/refresh-mutex.d.ts

@@ -0,0 +1,26 @@
+import type { OAuthTokenData } from "./storage";
+/**
+ * Execute a token refresh with per-server mutual exclusion.
+ *
+ * If a refresh is already in progress for the given server, this will
+ * return the same promise to all concurrent callers. Once the refresh
+ * completes (success or failure), the lock is released.
+ *
+ * @param serverUrl - The OAuth server URL (used as mutex key)
+ * @param refreshFn - The actual refresh operation to execute
+ * @returns Promise that resolves to the new token data
+ */
+export declare function withRefreshMutex(serverUrl: string, refreshFn: () => Promise<OAuthTokenData>): Promise<OAuthTokenData>;
+/**
+ * Check if a refresh is currently in progress for a server.
+ *
+ * @param serverUrl - The OAuth server URL
+ * @returns true if a refresh operation is active
+ */
+export declare function isRefreshInProgress(serverUrl: string): boolean;
+/**
+ * Get the number of servers currently undergoing token refresh.
+ *
+ * @returns Number of active refresh operations
+ */
+export declare function getActiveRefreshCount(): number;

package/dist/features/skill-mcp-manager/connection.d.ts

@@ -1,15 +1,14 @@
-import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { ClaudeCodeMcpServer } from "../claude-code-mcp-loader/types";
-import type { SkillMcpClientInfo, SkillMcpManagerState } from "./types";
+import type { McpClient, SkillMcpClientInfo, SkillMcpManagerState } from "./types";
 export declare function getOrCreateClient(params: {
     state: SkillMcpManagerState;
     clientKey: string;
     info: SkillMcpClientInfo;
     config: ClaudeCodeMcpServer;
-}): Promise<Client>;
+}): Promise<McpClient>;
 export declare function getOrCreateClientWithRetryImpl(params: {
     state: SkillMcpManagerState;
     clientKey: string;
     info: SkillMcpClientInfo;
     config: ClaudeCodeMcpServer;
-}): Promise<Client>;
+}): Promise<McpClient>;

package/dist/features/skill-mcp-manager/error-redaction.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Redacts sensitive tokens from a string.
+ * Used for error messages that may contain command-line arguments or environment info.
+ */
+export declare function redactSensitiveData(input: string): string;
+/**
+ * Redacts sensitive data from an Error object, returning a new Error.
+ * Preserves the stack trace but redacts the message.
+ */
+export declare function redactErrorSensitiveData(error: Error): Error;

package/dist/features/skill-mcp-manager/http-client.d.ts

@@ -1,3 +1,17 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import type { SkillMcpClientConnectionParams } from "./types";
-export declare function createHttpClient(params: SkillMcpClientConnectionParams): Promise<Client>;
+import type { McpClient, McpTransport, SkillMcpClientConnectionParams } from "./types";
+type HttpClientFactory = (clientInfo: {
+    name: string;
+    version: string;
+}, options: {
+    capabilities: Record<string, never>;
+}) => McpClient;
+type HttpTransportFactory = (url: URL, options?: {
+    requestInit?: RequestInit;
+}) => McpTransport;
+interface HttpClientDependencies {
+    createClient: HttpClientFactory;
+    createTransport: HttpTransportFactory;
+}
+export declare function setHttpClientDependenciesForTesting(dependencies?: Partial<HttpClientDependencies>): void;
+export declare function createHttpClient(params: SkillMcpClientConnectionParams): Promise<McpClient>;
+export {};

package/dist/features/skill-mcp-manager/manager.d.ts

@@ -1,14 +1,13 @@
-import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import type { Prompt, Resource, Tool } from "@modelcontextprotocol/sdk/types.js";
 import type { ClaudeCodeMcpServer } from "../claude-code-mcp-loader/types";
-import type { OAuthProviderFactory, SkillMcpClientInfo, SkillMcpServerContext } from "./types";
+import type { McpClient, OAuthProviderFactory, SkillMcpClientInfo, SkillMcpServerContext } from "./types";
 export declare class SkillMcpManager {
     private readonly state;
     constructor(options?: {
         createOAuthProvider?: OAuthProviderFactory;
     });
     private getClientKey;
-    getOrCreateClient(info: SkillMcpClientInfo, config: ClaudeCodeMcpServer): Promise<Client>;
+    getOrCreateClient(info: SkillMcpClientInfo, config: ClaudeCodeMcpServer): Promise<McpClient>;
     disconnectSession(sessionID: string): Promise<void>;
     disconnectAll(): Promise<void>;
     listTools(info: SkillMcpClientInfo, context: SkillMcpServerContext): Promise<Tool[]>;

package/dist/features/skill-mcp-manager/oauth-handler.d.ts

@@ -8,3 +8,10 @@ export declare function handleStepUpIfNeeded(params: {
     authProviders: Map<string, OAuthProviderLike>;
     createOAuthProvider?: OAuthProviderFactory;
 }): Promise<boolean>;
+export declare function handlePostRequestAuthError(params: {
+    error: Error;
+    config: ClaudeCodeMcpServer;
+    authProviders: Map<string, OAuthProviderLike>;
+    createOAuthProvider?: OAuthProviderFactory;
+    refreshAttempted?: Set<string>;
+}): Promise<boolean>;

package/dist/features/skill-mcp-manager/stdio-client.d.ts

@@ -1,3 +1,16 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import type { SkillMcpClientConnectionParams } from "./types";
-export declare function createStdioClient(params: SkillMcpClientConnectionParams): Promise<Client>;
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import type { McpClient, McpTransport, SkillMcpClientConnectionParams } from "./types";
+type StdioClientFactory = (clientInfo: {
+    name: string;
+    version: string;
+}, options: {
+    capabilities: Record<string, never>;
+}) => McpClient;
+type StdioTransportFactory = (options: ConstructorParameters<typeof StdioClientTransport>[0]) => McpTransport;
+interface StdioClientDependencies {
+    createClient: StdioClientFactory;
+    createTransport: StdioTransportFactory;
+}
+export declare function setStdioClientDependenciesForTesting(dependencies?: Partial<StdioClientDependencies>): void;
+export declare function createStdioClient(params: SkillMcpClientConnectionParams): Promise<McpClient>;
+export {};

package/dist/features/skill-mcp-manager/types.d.ts

@@ -1,13 +1,25 @@
 import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import type { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import type { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
 import type { ClaudeCodeMcpServer } from "../claude-code-mcp-loader/types";
 import type { McpOAuthProvider } from "../mcp-oauth/provider";
+import type { SkillScope } from "../opencode-skill-loader/types";
 export type SkillMcpConfig = Record<string, ClaudeCodeMcpServer>;
+export type McpTransport = Transport;
+export interface McpClient {
+    connect: Client["connect"];
+    close: Client["close"];
+    listTools: Client["listTools"];
+    listResources: Client["listResources"];
+    listPrompts: Client["listPrompts"];
+    callTool: Client["callTool"];
+    readResource: Client["readResource"];
+    getPrompt: Client["getPrompt"];
+}
 export interface SkillMcpClientInfo {
     serverName: string;
     skillName: string;
     sessionID: string;
+    scope?: SkillScope | "local";
 }
 export interface SkillMcpServerContext {
     config: ClaudeCodeMcpServer;
@@ -20,25 +32,25 @@ export interface SkillMcpServerContext {
  */
 export type ConnectionType = "stdio" | "http";
 export interface ManagedClientBase {
-    client: Client;
+    client: McpClient;
     skillName: string;
     lastUsedAt: number;
     connectionType: ConnectionType;
 }
 export interface ManagedStdioClient extends ManagedClientBase {
     connectionType: "stdio";
-    transport: StdioClientTransport;
+    transport: McpTransport;
 }
 export interface ManagedHttpClient extends ManagedClientBase {
     connectionType: "http";
-    transport: StreamableHTTPClientTransport;
+    transport: McpTransport;
 }
 export type ManagedClient = ManagedStdioClient | ManagedHttpClient;
 export interface ProcessCleanupHandler {
     signal: NodeJS.Signals;
     listener: () => void;
 }
-export type OAuthProviderLike = Pick<McpOAuthProvider, "tokens" | "login">;
+export type OAuthProviderLike = Pick<McpOAuthProvider, "tokens" | "login" | "refresh">;
 export type OAuthProviderFactory = (options: {
     serverUrl: string;
     clientId?: string;
@@ -46,7 +58,7 @@ export type OAuthProviderFactory = (options: {
 }) => OAuthProviderLike;
 export interface SkillMcpManagerState {
     clients: Map<string, ManagedClient>;
-    pendingConnections: Map<string, Promise<Client>>;
+    pendingConnections: Map<string, Promise<McpClient>>;
     disconnectedSessions: Map<string, number>;
     authProviders: Map<string, McpOAuthProvider>;
     cleanupRegistered: boolean;

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

@@ -39,6 +39,7 @@ export declare class TmuxSessionManager {
     private spawnInIsolatedContainer;
     private getCapacityConfig;
     private getSessionMappings;
+    getTrackedPaneId(sessionId: string): string | undefined;
     private removeTrackedSession;
     private reassignIsolatedContainerAnchor;
     private cleanupIsolatedContainerAfterSessionDeletion;

package/dist/hooks/atlas/session-last-agent.d.ts

@@ -1,3 +1,12 @@
+import { getMessageDir, isSqliteBackend, normalizeSDKResponse } from "../../shared";
+import { hasCompactionPartInStorage, isCompactionMessage } from "../../shared/compaction-marker";
+type SessionLastAgentDeps = {
+    getMessageDir: typeof getMessageDir;
+    isSqliteBackend: typeof isSqliteBackend;
+    normalizeSDKResponse: typeof normalizeSDKResponse;
+    hasCompactionPartInStorage: typeof hasCompactionPartInStorage;
+    isCompactionMessage: typeof isCompactionMessage;
+};
 type SessionMessagesClient = {
     session: {
         messages: (input: {
@@ -7,5 +16,5 @@ type SessionMessagesClient = {
         }) => Promise<unknown>;
     };
 };
-export declare function getLastAgentFromSession(sessionID: string, client?: SessionMessagesClient): Promise<string | null>;
+export declare function getLastAgentFromSession(sessionID: string, client?: SessionMessagesClient, deps?: Partial<SessionLastAgentDeps>): Promise<string | null>;
 export {};

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

@@ -4,6 +4,7 @@ import type { TopLevelTaskRef } from "../../features/boulder-state";
 export type ModelInfo = {
     providerID: string;
     modelID: string;
+    variant?: string;
 };
 export interface AtlasHookOptions {
     directory: string;

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

@@ -1,5 +1,15 @@
-export declare const PACKAGE_NAME = "oh-my-openagent";
-export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org/-/package/oh-my-openagent/dist-tags";
+export declare const PACKAGE_NAME = "oh-my-opencode";
+/**
+ * All package names the canonical plugin may be published under.
+ *
+ * The package is published to npm as both `oh-my-opencode` (legacy canonical)
+ * and `oh-my-openagent` (current canonical). Any code that *reads* an
+ * installed package.json or walks up from an import path must accept both,
+ * because the installed name depends on which package the user added to
+ * their config. Code that *writes* continues to use {@link PACKAGE_NAME}.
+ */
+export declare const ACCEPTED_PACKAGE_NAMES: readonly ["oh-my-opencode", "oh-my-openagent"];
+export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org/-/package/oh-my-opencode/dist-tags";
 export declare const NPM_FETCH_TIMEOUT = 5000;
 export declare const CACHE_ROOT_DIR: string;
 export declare const CACHE_DIR: string;
@@ -9,3 +19,8 @@ export declare function getUserConfigDir(): string;
 export declare function getUserOpencodeConfig(): string;
 export declare function getUserOpencodeConfigJsonc(): string;
 export declare const INSTALLED_PACKAGE_JSON: string;
+/**
+ * Candidate paths where the installed package.json may live, in priority order.
+ * Readers should try each path in order and stop on the first success.
+ */
+export declare const INSTALLED_PACKAGE_JSON_CANDIDATES: string[];

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

@@ -1,6 +1,26 @@
 import type { PluginInput } from "@opencode-ai/plugin";
+import { log } from "../../shared/logger";
 import type { AutoUpdateCheckerOptions } from "./types";
-export declare function createAutoUpdateCheckerHook(ctx: PluginInput, options?: AutoUpdateCheckerOptions): {
+import { getCachedVersion, getLocalDevVersion } from "./checker";
+import { runBackgroundUpdateCheck } from "./hook/background-update-check";
+import { showConfigErrorsIfAny } from "./hook/config-errors-toast";
+import { updateAndShowConnectedProvidersCacheStatus } from "./hook/connected-providers-status";
+import { refreshModelCapabilitiesOnStartup } from "./hook/model-capabilities-status";
+import { showModelCacheWarningIfNeeded } from "./hook/model-cache-warning";
+import { showLocalDevToast, showVersionToast } from "./hook/startup-toasts";
+interface AutoUpdateCheckerDeps {
+    getCachedVersion: typeof getCachedVersion;
+    getLocalDevVersion: typeof getLocalDevVersion;
+    showConfigErrorsIfAny: typeof showConfigErrorsIfAny;
+    updateAndShowConnectedProvidersCacheStatus: typeof updateAndShowConnectedProvidersCacheStatus;
+    refreshModelCapabilitiesOnStartup: typeof refreshModelCapabilitiesOnStartup;
+    showModelCacheWarningIfNeeded: typeof showModelCacheWarningIfNeeded;
+    showLocalDevToast: typeof showLocalDevToast;
+    showVersionToast: typeof showVersionToast;
+    runBackgroundUpdateCheck: typeof runBackgroundUpdateCheck;
+    log: typeof log;
+}
+export declare function createAutoUpdateCheckerHook(ctx: PluginInput, options?: AutoUpdateCheckerOptions, deps?: AutoUpdateCheckerDeps): {
     event: ({ event }: {
         event: {
             type: string;
@@ -8,3 +28,4 @@ export declare function createAutoUpdateCheckerHook(ctx: PluginInput, options?:
         };
     }) => void;
 };
+export {};

package/dist/hooks/comment-checker/cli-runner.d.ts

@@ -1,4 +1,5 @@
 import type { PendingCall } from "./types";
+import { runCommentChecker } from "./cli";
 export declare function initializeCommentCheckerCli(debugLog: (...args: unknown[]) => void): void;
 export declare function getCommentCheckerCliPathPromise(): Promise<string | null> | null;
 export declare function processWithCli(input: {
@@ -7,7 +8,9 @@ export declare function processWithCli(input: {
     callID: string;
 }, pendingCall: PendingCall, output: {
     output: string;
-}, cliPath: string, customPrompt: string | undefined, debugLog: (...args: unknown[]) => void): Promise<void>;
+}, cliPath: string, customPrompt: string | undefined, debugLog: (...args: unknown[]) => void, deps?: {
+    runCommentChecker?: typeof runCommentChecker;
+}): Promise<void>;
 export interface ApplyPatchEdit {
     filePath: string;
     before: string;

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

@@ -1,6 +1,7 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { ContextCollector } from "../../features/context-injector";
-export declare function createKeywordDetectorHook(ctx: PluginInput, _collector?: ContextCollector): {
+import type { RalphLoopHook } from "../ralph-loop";
+export declare function createKeywordDetectorHook(ctx: PluginInput, _collector?: ContextCollector, _ralphLoop?: Pick<RalphLoopHook, "startLoop">): {
     "chat.message": (input: {
         sessionID: string;
         agent?: string;

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

@@ -2,5 +2,6 @@ export declare const HOOK_NAME = "ralph-loop";
 export declare const DEFAULT_STATE_FILE = ".sisyphus/ralph-loop.local.md";
 export declare const COMPLETION_TAG_PATTERN: RegExp;
 export declare const DEFAULT_MAX_ITERATIONS = 100;
+export declare const ULTRAWORK_MAX_ITERATIONS = 500;
 export declare const DEFAULT_COMPLETION_PROMISE = "DONE";
 export declare const ULTRAWORK_VERIFICATION_PROMISE = "VERIFIED";

package/dist/hooks/ralph-loop/oracle-verification-detector.d.ts

@@ -0,0 +1,8 @@
+export interface OracleVerificationEvidence {
+    agent: string;
+    promise: string;
+    sessionID?: string;
+}
+export declare function parseOracleVerificationEvidence(text: string): OracleVerificationEvidence | undefined;
+export declare function isOracleVerified(text: string): boolean;
+export declare function extractOracleSessionID(text: string): string | undefined;

package/dist/hooks/read-image-resizer/image-resizer.d.ts

@@ -1,3 +1,5 @@
 import type { ImageDimensions, ResizeResult } from "./types";
 export declare function calculateTargetDimensions(width: number, height: number, maxLongEdge?: number): ImageDimensions | null;
-export declare function resizeImage(base64DataUrl: string, mimeType: string, target: ImageDimensions): Promise<ResizeResult | null>;
+export declare function resizeImage(base64DataUrl: string, mimeType: string, target: ImageDimensions, deps?: {
+    loadSharpModule?: () => Promise<unknown | null>;
+}): Promise<ResizeResult | null>;

package/dist/hooks/read-image-resizer/png-fallback-resizer.d.ts

@@ -0,0 +1,2 @@
+import type { ImageDimensions, ResizeResult } from "./types";
+export declare function resizeImageFallback(base64DataUrl: string, mimeType: string, target: ImageDimensions): ResizeResult | null;

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

@@ -1,4 +1,8 @@
+import { readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
 import type { FindRuleFilesOptions } from "./rule-file-finder";
+import { createContentHash, isDuplicateByContentHash, isDuplicateByRealPath, shouldApplyRule } from "./matcher";
+import { saveInjectedRules } from "./storage";
 import type { SessionInjectedRulesCache } from "./cache";
 type ToolExecuteOutput = {
     title: string;
@@ -16,6 +20,14 @@ export declare function createRuleInjectionProcessor(deps: {
     truncator: DynamicTruncator;
     getSessionCache: (sessionID: string) => SessionInjectedRulesCache;
     ruleFinderOptions?: FindRuleFilesOptions;
+    readFileSync?: typeof readFileSync;
+    statSync?: typeof statSync;
+    homedir?: typeof homedir;
+    shouldApplyRule?: typeof shouldApplyRule;
+    isDuplicateByRealPath?: typeof isDuplicateByRealPath;
+    createContentHash?: typeof createContentHash;
+    isDuplicateByContentHash?: typeof isDuplicateByContentHash;
+    saveInjectedRules?: typeof saveInjectedRules;
 }): {
     processFilePathForInjection: (filePath: string, sessionID: string, output: ToolExecuteOutput) => Promise<void>;
 };

package/dist/hooks/runtime-fallback/auto-retry-signal.d.ts

@@ -0,0 +1,4 @@
+export interface AutoRetrySignal {
+    signal: string;
+}
+export declare function extractAutoRetrySignal(info: Record<string, unknown> | undefined): AutoRetrySignal | undefined;

package/dist/hooks/runtime-fallback/error-classifier.d.ts

@@ -1,12 +1,8 @@
+export { extractAutoRetrySignal } from "./auto-retry-signal";
 export declare function getErrorMessage(error: unknown): string;
 export declare function extractStatusCode(error: unknown, retryOnErrors?: number[]): number | undefined;
 export declare function extractErrorName(error: unknown): string | undefined;
 export declare function classifyErrorType(error: unknown): string | undefined;
-export interface AutoRetrySignal {
-    signal: string;
-}
-export declare const AUTO_RETRY_PATTERNS: Array<(combined: string) => boolean>;
-export declare function extractAutoRetrySignal(info: Record<string, unknown> | undefined): AutoRetrySignal | undefined;
 export declare function containsErrorContent(parts: Array<{
     type?: string;
     text?: string;

package/dist/hooks/session-recovery/types.d.ts

@@ -66,6 +66,7 @@ export interface MessageData {
         model?: {
             providerID: string;
             modelID: string;
+            variant?: string;
         };
         system?: string;
         tools?: Record<string, boolean>;
@@ -86,6 +87,7 @@ export interface ResumeConfig {
     model?: {
         providerID: string;
         modelID: string;
+        variant?: string;
     };
     tools?: Record<string, boolean>;
 }

package/dist/hooks/todo-continuation-enforcer/pending-question-detection.d.ts

@@ -1,5 +1,5 @@
 interface MessagePart {
-    type: string;
+    type?: string;
     name?: string;
     toolName?: string;
 }

package/dist/hooks/todo-continuation-enforcer/token-limit-detection.d.ts

@@ -0,0 +1,4 @@
+export declare function isTokenLimitError(error: {
+    name?: string;
+    message?: string;
+} | undefined): boolean;