oh-my-opencode 4.7.4 → 4.8.0

package/dist/oh-my-opencode.schema.json

@@ -5724,6 +5724,10 @@
           "additionalProperties": {
             "type": "boolean"
           }
+        },
+        "anthropic_provider": {
+          "type": "string",
+          "minLength": 1
         }
       },
       "additionalProperties": false

package/dist/openclaw/reply-listener-poll-loop.d.ts

@@ -0,0 +1,3 @@
+import { type ReplyListenerDaemonState } from "./reply-listener-state";
+export declare function shouldContinuePolling(state: ReplyListenerDaemonState): boolean;
+export declare function pollLoop(): Promise<void>;

package/dist/openclaw/reply-listener-signature.d.ts

@@ -0,0 +1,2 @@
+import type { OpenClawConfig } from "./types";
+export declare function getReplyListenerRuntimeSignature(config: Pick<OpenClawConfig, "replyListener"> | null): string;

package/dist/openclaw/reply-listener-sleep.d.ts

@@ -0,0 +1 @@
+export declare function sleep(ms: number): Promise<void>;

package/dist/openclaw/reply-listener-start.d.ts

@@ -0,0 +1,9 @@
+import { type ReplyListenerDaemonState } from "./reply-listener-state";
+import type { OpenClawConfig } from "./types";
+export declare function resolveReplyListenerDaemonScript(currentFileUrl: string): string;
+export declare function startReplyListener(config: OpenClawConfig): Promise<{
+    success: boolean;
+    message: string;
+    state?: ReplyListenerDaemonState;
+    error?: string;
+}>;

package/dist/openclaw/reply-listener-status.d.ts

@@ -0,0 +1,4 @@
+export declare function terminateReplyListenerProcess(pid: number): Promise<void>;
+export declare function isDaemonRunning(): Promise<boolean>;
+export declare function waitForDaemonToStop(timeoutMs: number): Promise<boolean>;
+export declare function waitForReplyListenerProcessExit(pid: number, timeoutMs: number): Promise<boolean>;

package/dist/openclaw/reply-listener-stop.d.ts

@@ -0,0 +1,7 @@
+import { type ReplyListenerDaemonState } from "./reply-listener-state";
+export declare function stopReplyListener(): Promise<{
+    success: boolean;
+    message: string;
+    state?: ReplyListenerDaemonState;
+    error?: string;
+}>;

package/dist/openclaw/reply-listener.d.ts

@@ -1,18 +1,5 @@
-import { logReplyListenerMessage } from "./reply-listener-log";
-import { type ReplyListenerDaemonState } from "./reply-listener-state";
-import type { OpenClawConfig } from "./types";
-export declare function isDaemonRunning(): Promise<boolean>;
-export declare function pollLoop(): Promise<void>;
-export declare function startReplyListener(config: OpenClawConfig): Promise<{
-    success: boolean;
-    message: string;
-    state?: ReplyListenerDaemonState;
-    error?: string;
-}>;
-export declare function stopReplyListener(): Promise<{
-    success: boolean;
-    message: string;
-    state?: ReplyListenerDaemonState;
-    error?: string;
-}>;
-export { logReplyListenerMessage };
+export { logReplyListenerMessage } from "./reply-listener-log";
+export { pollLoop } from "./reply-listener-poll-loop";
+export { startReplyListener } from "./reply-listener-start";
+export { isDaemonRunning } from "./reply-listener-status";
+export { stopReplyListener } from "./reply-listener-stop";

package/dist/openclaw/session-registry-lock.d.ts

@@ -0,0 +1,2 @@
+export declare function withRegistryLockOrWait<T>(onLocked: () => T, onLockUnavailable: () => T): T;
+export declare function withRegistryLock(onLocked: () => void, onLockUnavailable: () => void): void;

package/dist/openclaw/session-registry-paths.d.ts

@@ -0,0 +1,9 @@
+export declare const SECURE_FILE_MODE = 384;
+export declare const MAX_AGE_MS: number;
+export declare const LOCK_TIMEOUT_MS = 2000;
+export declare const LOCK_WAIT_TIMEOUT_MS = 4000;
+export declare const LOCK_RETRY_MS = 20;
+export declare const LOCK_STALE_MS = 10000;
+export declare function getOpenClawStorageDir(): string;
+export declare function getRegistryPath(): string;
+export declare function getRegistryLockPath(): string;

package/dist/openclaw/session-registry-storage.d.ts

@@ -0,0 +1,4 @@
+import type { SessionMapping } from "./session-registry-types";
+export declare function ensureRegistryDir(): void;
+export declare function readAllMappingsUnsafe(): SessionMapping[];
+export declare function rewriteRegistryUnsafe(mappings: readonly SessionMapping[]): void;

package/dist/openclaw/session-registry-types.d.ts

@@ -0,0 +1,11 @@
+export interface SessionMapping {
+    sessionId: string;
+    tmuxSession: string;
+    tmuxPaneId: string;
+    projectPath: string;
+    platform: string;
+    messageId: string;
+    channelId?: string;
+    threadId?: string;
+    createdAt: string;
+}

package/dist/openclaw/session-registry.d.ts

@@ -1,14 +1,5 @@
-export interface SessionMapping {
-    sessionId: string;
-    tmuxSession: string;
-    tmuxPaneId: string;
-    projectPath: string;
-    platform: string;
-    messageId: string;
-    channelId?: string;
-    threadId?: string;
-    createdAt: string;
-}
+import type { SessionMapping } from "./session-registry-types";
+export type { SessionMapping } from "./session-registry-types";
 export declare function registerMessage(mapping: SessionMapping): boolean;
 export declare function loadAllMappings(): SessionMapping[];
 export declare function lookupByMessageId(platform: string, messageId: string): SessionMapping | null;

package/dist/plugin/chat-message/loop-commands.d.ts

@@ -0,0 +1,9 @@
+import type { OhMyOpenCodeConfig } from "../../config";
+import type { ChatMessageHooks, ChatMessageHandlerOutput, ChatMessageInput } from "./types";
+export declare function handleRalphLoopMessage(args: {
+    readonly hooks: ChatMessageHooks;
+    readonly input: ChatMessageInput;
+    readonly output: ChatMessageHandlerOutput;
+    readonly isFirstMessage: boolean;
+    readonly pluginConfig: OhMyOpenCodeConfig;
+}): void;

package/dist/plugin/chat-message/model-cache-warning.d.ts

@@ -0,0 +1,12 @@
+type TuiClient = {
+    readonly showToast: (input: {
+        readonly body: {
+            readonly title: string;
+            readonly message: string;
+            readonly variant: "warning";
+            readonly duration: number;
+        };
+    }) => Promise<unknown>;
+};
+export declare function notifyWhenModelCacheIsMissing(tui: TuiClient): void;
+export {};

package/dist/plugin/chat-message/prompt-text.d.ts

@@ -0,0 +1,2 @@
+import type { ChatMessagePart } from "./types";
+export declare function extractPromptText(parts: readonly ChatMessagePart[]): string;

package/dist/plugin/chat-message/session-model.d.ts

@@ -0,0 +1,4 @@
+import type { OhMyOpenCodeConfig } from "../../config";
+import type { ChatMessageHandlerOutput, ChatMessageInput, SessionModelOverride } from "./types";
+export declare function getStoredMainSessionModel(input: ChatMessageInput, pluginConfig: OhMyOpenCodeConfig, isFirstMessage: boolean): SessionModelOverride | undefined;
+export declare function recordSessionModel(input: ChatMessageInput, output: ChatMessageHandlerOutput): void;

package/dist/plugin/chat-message/start-work-message.d.ts

@@ -0,0 +1,5 @@
+import type { ChatMessageHooks, ChatMessageInput, ChatMessageHandlerOutput, StartWorkHookOutput, WorkStartingCommand } from "./types";
+export declare function isStartWorkHookOutput(value: unknown): value is StartWorkHookOutput;
+export declare function isStartWorkFallbackTemplate(promptText: string): boolean;
+export declare function clearStoppedContinuationBeforeWorkStart(hooks: ChatMessageHooks, sessionID: string, command: WorkStartingCommand): void;
+export declare function runStartWorkHookIfApplicable(hooks: ChatMessageHooks, input: ChatMessageInput, output: ChatMessageHandlerOutput): Promise<void>;

package/dist/plugin/chat-message/types.d.ts

@@ -0,0 +1,67 @@
+export type FirstMessageVariantGate = {
+    readonly shouldOverride: (sessionID: string) => boolean;
+    readonly markApplied: (sessionID: string) => void;
+};
+export type ChatMessagePart = {
+    readonly type: string;
+    readonly text?: string;
+    readonly [key: string]: unknown;
+};
+export type ChatMessageHandlerOutput = {
+    readonly message: Record<string, unknown>;
+    readonly parts: ChatMessagePart[];
+};
+export type ChatMessageInput = {
+    readonly sessionID: string;
+    readonly agent?: string;
+    readonly model?: {
+        readonly providerID: string;
+        readonly modelID: string;
+    };
+};
+export type StartWorkHookOutput = {
+    readonly parts: Array<{
+        readonly type: string;
+        readonly text?: string;
+    }>;
+};
+export type SessionModelOverride = {
+    readonly providerID: string;
+    readonly modelID: string;
+};
+export type WorkStartingCommand = "start-work" | "ralph-loop" | "ulw-loop";
+type ChatMessageHook = {
+    "chat.message"?: (input: ChatMessageInput, output: ChatMessageHandlerOutput) => Promise<void>;
+};
+type StopContinuationGuard = {
+    "chat.message"?: (input: ChatMessageInput) => Promise<void>;
+    stop?: (sessionID: string) => void;
+    isStopped: (sessionID: string) => boolean;
+    clear: (sessionID: string) => void;
+};
+type RalphLoopHook = {
+    startLoop: (sessionID: string, prompt: string, options?: {
+        readonly ultrawork?: boolean;
+        readonly maxIterations?: number;
+        readonly completionPromise?: string;
+        readonly strategy?: "continue" | "reset";
+    }) => boolean | void;
+    resumeLoop?: (sessionID: string) => boolean;
+    cancelLoop: (sessionID: string) => boolean | void;
+};
+export type ChatMessageHooks = {
+    modelFallback?: ChatMessageHook | null;
+    stopContinuationGuard?: StopContinuationGuard | null;
+    backgroundNotificationHook?: ChatMessageHook | null;
+    runtimeFallback?: ChatMessageHook | null;
+    keywordDetector?: ChatMessageHook | null;
+    thinkMode?: ChatMessageHook | null;
+    claudeCodeHooks?: ChatMessageHook | null;
+    autoSlashCommand?: ChatMessageHook | null;
+    noSisyphusGpt?: ChatMessageHook | null;
+    noHephaestusNonGpt?: ChatMessageHook | null;
+    hephaestusAgentsMdInjector?: ChatMessageHook | null;
+    startWork?: ChatMessageHook | null;
+    ralphLoop?: RalphLoopHook | null;
+};
+export {};

package/dist/plugin/chat-message.d.ts

@@ -1,31 +1,10 @@
 import type { OhMyOpenCodeConfig } from "../config";
-import type { CreatedHooks } from "../create-hooks";
 import type { PluginContext } from "./types";
-type FirstMessageVariantGate = {
-    shouldOverride: (sessionID: string) => boolean;
-    markApplied: (sessionID: string) => void;
-};
-type ChatMessagePart = {
-    type: string;
-    text?: string;
-    [key: string]: unknown;
-};
-export type ChatMessageHandlerOutput = {
-    message: Record<string, unknown>;
-    parts: ChatMessagePart[];
-};
-export type ChatMessageInput = {
-    sessionID: string;
-    agent?: string;
-    model?: {
-        providerID: string;
-        modelID: string;
-    };
-};
+import type { ChatMessageHandlerOutput, ChatMessageHooks, ChatMessageInput, FirstMessageVariantGate } from "./chat-message/types";
+export type { ChatMessageHandlerOutput, ChatMessageInput } from "./chat-message/types";
 export declare function createChatMessageHandler(args: {
     ctx: PluginContext;
     pluginConfig: OhMyOpenCodeConfig;
     firstMessageVariantGate: FirstMessageVariantGate;
-    hooks: CreatedHooks;
+    hooks: ChatMessageHooks;
 }): (input: ChatMessageInput, output: ChatMessageHandlerOutput) => Promise<void>;
-export {};

package/dist/plugin/event-error-utils.d.ts

@@ -0,0 +1,14 @@
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function normalizeFallbackModelID(modelID: string): string;
+export declare function extractErrorName(error: unknown): string | undefined;
+export declare function extractErrorMessage(error: unknown): string;
+export declare function extractProviderModelFromErrorMessage(message: string): {
+    providerID?: string;
+    modelID?: string;
+};
+export declare function resolveFallbackAgentName(params: {
+    currentAgent?: string;
+    sessionID: string;
+    mainSessionID?: string;
+    message: string;
+}): string | undefined;

package/dist/plugin/event-hook-dispatcher.d.ts

@@ -0,0 +1,5 @@
+import type { CreatedHooks } from "../create-hooks";
+import type { EventInput, EventHookRunner } from "./event-types";
+export declare function getEventSessionID(input: EventInput): string | undefined;
+export declare function createEventHookRunner(): EventHookRunner;
+export declare function createEventHookDispatcher(hooks: CreatedHooks, runEventHookSafely: EventHookRunner): (input: EventInput) => Promise<void>;

package/dist/plugin/event-model-fallback-state.d.ts

@@ -0,0 +1,30 @@
+import type { OhMyOpenCodeConfig } from "../config";
+import type { ModelFallbackHook } from "../hooks/model-fallback/hook";
+import type { PluginEventContext } from "./event-types";
+export type FallbackContinuationContext = {
+    agentName?: string;
+    providerID?: string;
+    dedupeProviderID?: string;
+    modelID?: string;
+};
+type FallbackContinuationDedupeState = {
+    modelKeys: Set<string>;
+    providerModelKeys: Set<string>;
+    providerlessModelKeys: Set<string>;
+};
+export declare function applyUserConfiguredFallbackChain(modelFallback: Pick<ModelFallbackHook, "setSessionFallbackChain"> | null | undefined, sessionID: string, agentName: string, currentProviderID: string, pluginConfig: OhMyOpenCodeConfig): void;
+export declare function createModelFallbackContinuationController(args: {
+    pluginConfig: OhMyOpenCodeConfig;
+    pluginContext: PluginEventContext;
+    lastKnownModelBySession: Map<string, {
+        providerID: string;
+        modelID: string;
+    }>;
+    continuationsInFlight: Set<string>;
+    lastDispatchedContinuationKeys: Map<string, FallbackContinuationDedupeState>;
+}): {
+    autoContinueAfterFallback: (sessionID: string, source: string, fallbackContext?: FallbackContinuationContext) => Promise<void>;
+    resolveFallbackProviderID: (sessionID: string, providerHint?: string) => string;
+    shouldSkipFallbackContinuation: (sessionID: string, source: string, fallbackContext?: FallbackContinuationContext) => boolean;
+};
+export {};

package/dist/plugin/event-model-fallback.d.ts

@@ -0,0 +1,39 @@
+import type { OhMyOpenCodeConfig } from "../config";
+import { type ModelFallbackHook } from "../hooks/model-fallback/hook";
+import type { PluginEventContext } from "./event-types";
+export declare function createModelFallbackEventHandler(args: {
+    pluginConfig: OhMyOpenCodeConfig;
+    pluginContext: PluginEventContext;
+    modelFallback: ModelFallbackHook | null | undefined;
+    isModelFallbackEnabled: boolean;
+    isRuntimeFallbackEnabled: boolean;
+    shouldAutoRetrySession: (sessionID: string) => boolean;
+    isSessionStopped: (sessionID: string) => boolean;
+}): {
+    clearRetryDedupeAfterIdle: (sessionID: string) => void;
+    clearSession: (sessionID: string) => void;
+    handleAssistantMessageUpdated: (params: {
+        sessionID: string;
+        info: Record<string, unknown>;
+        agent?: string;
+    }) => Promise<boolean>;
+    handleSessionError: (params: {
+        sessionID: string;
+        errorMessage: string;
+        errorName?: string;
+        props?: Record<string, unknown>;
+    }) => Promise<void>;
+    handleSessionStatus: (params: {
+        sessionID: string;
+        status?: {
+            type?: string;
+            attempt?: number;
+            message?: string;
+            next?: number;
+        };
+    }) => Promise<boolean>;
+    setLastKnownModel: (sessionID: string, model: {
+        providerID: string;
+        modelID: string;
+    }) => void;
+};

package/dist/plugin/event-session-lifecycle.d.ts

@@ -0,0 +1,49 @@
+import type { OhMyOpenCodeConfig } from "../config";
+import type { Managers } from "../create-managers";
+import type { FirstMessageVariantGate, PluginEventContext } from "./event-types";
+export declare const TMUX_ACTIVITY_EVENT_TYPES: ReadonlySet<string>;
+export declare function isCompactionAgent(agent: string): boolean;
+export declare function dispatchOpenClawSessionEvent(args: {
+    pluginConfig: OhMyOpenCodeConfig;
+    pluginContext: PluginEventContext;
+    managers: Managers;
+    rawEvent: string;
+    sessionID: string;
+}): Promise<void>;
+export declare function handleSessionCreatedEvent(args: {
+    event: {
+        type: string;
+        properties?: unknown;
+    };
+    props?: Record<string, unknown>;
+    tmuxIntegrationEnabled: boolean;
+    pluginConfig: OhMyOpenCodeConfig;
+    pluginContext: PluginEventContext;
+    managers: Managers;
+    firstMessageVariantGate: FirstMessageVariantGate;
+}): Promise<void>;
+export declare function handleSessionDeletedEvent(args: {
+    props?: Record<string, unknown>;
+    tmuxIntegrationEnabled: boolean;
+    pluginConfig: OhMyOpenCodeConfig;
+    pluginContext: PluginEventContext;
+    managers: Managers;
+    firstMessageVariantGate: FirstMessageVariantGate;
+    clearModelFallbackSession: (sessionID: string) => void;
+    clearUserAbortRecovery: (sessionID: string) => void;
+}): Promise<void>;
+export declare function handleMessageRemovedEvent(props?: Record<string, unknown>): void;
+export declare function handleMessageUpdatedSessionState(args: {
+    props?: Record<string, unknown>;
+    noteSessionModel: (sessionID: string, model: {
+        providerID: string;
+        modelID: string;
+    }) => void;
+    clearUserAbortRecovery: (sessionID: string) => void;
+    noteAssistantError: (sessionID: string, error: unknown) => void;
+}): {
+    info: Record<string, unknown> | undefined;
+    sessionID: string | undefined;
+    agent: string | undefined;
+    role: string | undefined;
+};

package/dist/plugin/event-session-recovery.d.ts

@@ -0,0 +1,9 @@
+import type { CreatedHooks } from "../create-hooks";
+import type { PluginEventContext } from "./event-types";
+export declare function handleRecoverableSessionError(args: {
+    hooks: CreatedHooks;
+    pluginContext: PluginEventContext;
+    sessionID?: string;
+    messageID?: string;
+    error: unknown;
+}): Promise<boolean>;

package/dist/plugin/event-team-handlers.d.ts

@@ -0,0 +1,13 @@
+import type { OhMyOpenCodeConfig } from "../config";
+import type { Managers } from "../create-managers";
+import type { PluginEventContext } from "./event-types";
+export declare function createEventTeamHandlers(args: {
+    pluginConfig: OhMyOpenCodeConfig;
+    pluginContext: PluginEventContext;
+    managers: Managers;
+}): {
+    teamIdleWakeHint: import("../hooks/team-session-events/team-idle-wake-hint").HookImpl | undefined;
+    teamLeadOrphanHandler: import("../hooks/team-session-events/team-lead-orphan-handler").HookImpl | undefined;
+    teamMemberErrorHandler: import("../hooks/team-session-events/team-member-error-handler").HookImpl | undefined;
+    teamMemberStatusHandler: import("../hooks/team-session-events/team-member-status-handler").HookImpl | undefined;
+};

package/dist/plugin/event-types.d.ts

@@ -0,0 +1,78 @@
+import type { Event } from "@opencode-ai/sdk";
+import type { PluginContext } from "./types";
+export type FirstMessageVariantGate = {
+    markSessionCreated: (sessionInfo: {
+        id?: string;
+        title?: string;
+        parentID?: string;
+    } | undefined) => void;
+    clear: (sessionID: string) => void;
+};
+export type EventInput = {
+    event: Event;
+};
+type InternalTextPart = {
+    type: "text";
+    text: string;
+    synthetic?: boolean;
+    metadata?: Record<string, unknown>;
+};
+type InternalPromptInput = {
+    path: {
+        id: string;
+    };
+    body: {
+        parts: InternalTextPart[];
+        agent?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+        variant?: string;
+    };
+    query: {
+        directory: string;
+    };
+};
+export type PluginEventContext = PluginContext & {
+    directory: string;
+    client: {
+        session: {
+            abort: (input: {
+                path: {
+                    id: string;
+                };
+            }) => Promise<unknown>;
+            promptAsync?: (input: InternalPromptInput) => Promise<unknown>;
+            prompt: (input: InternalPromptInput) => Promise<unknown>;
+            summarize: {
+                (input: {
+                    path: {
+                        id: string;
+                    };
+                    body: {
+                        providerID: string;
+                        modelID: string;
+                        auto?: boolean;
+                    };
+                    query: {
+                        directory: string;
+                    };
+                }): Promise<unknown>;
+                (input: {
+                    path: {
+                        id: string;
+                    };
+                    body: {
+                        auto: boolean;
+                    };
+                    query: {
+                        directory: string;
+                    };
+                }): Promise<unknown>;
+            };
+        };
+    };
+};
+export type EventHookRunner = (hookName: string, handler: ((input: EventInput) => unknown | Promise<unknown>) | null | undefined, input: EventInput) => Promise<void>;
+export {};

package/dist/plugin/event.d.ts

@@ -1,17 +1,9 @@
 import type { OhMyOpenCodeConfig } from "../config";
-import type { PluginContext } from "./types";
 import type { CreatedHooks } from "../create-hooks";
 import type { Managers } from "../create-managers";
-type FirstMessageVariantGate = {
-    markSessionCreated: (sessionInfo: {
-        id?: string;
-        title?: string;
-        parentID?: string;
-    } | undefined) => void;
-    clear: (sessionID: string) => void;
-};
-export declare function extractErrorMessage(error: unknown): string;
-type EventInput = Parameters<NonNullable<NonNullable<CreatedHooks["writeExistingFileGuard"]>["event"]>>[0];
+import type { PluginContext } from "./types";
+import type { EventInput, FirstMessageVariantGate } from "./event-types";
+export { extractErrorMessage } from "./event-error-utils";
 export declare function createEventHandler(args: {
     ctx: PluginContext;
     pluginConfig: OhMyOpenCodeConfig;
@@ -19,4 +11,3 @@ export declare function createEventHandler(args: {
     managers: Managers;
     hooks: CreatedHooks;
 }): (input: EventInput) => Promise<void>;
-export {};

package/dist/plugin/hooks/create-core-hooks.d.ts

@@ -55,6 +55,7 @@ export declare function createCoreHooks(args: {
     sisyphusJuniorNotepad: ReturnType<typeof import("../../hooks").createSisyphusJuniorNotepadHook> | null;
     noSisyphusGpt: ReturnType<typeof import("../../hooks").createNoSisyphusGptHook> | null;
     noHephaestusNonGpt: ReturnType<typeof import("../../hooks").createNoHephaestusNonGptHook> | null;
+    hephaestusAgentsMdInjector: ReturnType<typeof import("../../hooks").createHephaestusAgentsMdInjectorHook> | null;
     questionLabelTruncator: ReturnType<typeof import("../../hooks").createQuestionLabelTruncatorHook> | null;
     taskResumeInfo: ReturnType<typeof import("../../hooks").createTaskResumeInfoHook> | null;
     anthropicEffort: ReturnType<typeof import("../../hooks/anthropic-effort").createAnthropicEffortHook> | null;

package/dist/plugin/hooks/create-session-hooks.d.ts

@@ -3,7 +3,7 @@ import type { BackgroundManager } from "../../features/background-agent";
 import type { ModelFallbackControllerAccessor } from "../../hooks/model-fallback";
 import type { ModelCacheState } from "../../plugin-state";
 import type { PluginContext } from "../types";
-import { createSessionRecoveryHook, createSessionNotification, createThinkModeHook, createModelFallbackHook, createAnthropicContextWindowLimitRecoveryHook, createAutoUpdateCheckerHook, createAgentUsageReminderHook, createNonInteractiveEnvHook, createInteractiveBashSessionHook, createRalphLoopHook, createEditErrorRecoveryHook, createDelegateTaskRetryHook, createTaskResumeInfoHook, createStartWorkHook, createPrometheusMdOnlyHook, createSisyphusJuniorNotepadHook, createNoSisyphusGptHook, createNoHephaestusNonGptHook, createQuestionLabelTruncatorHook, createPreemptiveCompactionHook, createRuntimeFallbackHook, createLegacyPluginToastHook } from "../../hooks";
+import { createSessionRecoveryHook, createSessionNotification, createThinkModeHook, createModelFallbackHook, createAnthropicContextWindowLimitRecoveryHook, createAutoUpdateCheckerHook, createAgentUsageReminderHook, createNonInteractiveEnvHook, createInteractiveBashSessionHook, createRalphLoopHook, createEditErrorRecoveryHook, createDelegateTaskRetryHook, createTaskResumeInfoHook, createStartWorkHook, createPrometheusMdOnlyHook, createSisyphusJuniorNotepadHook, createNoSisyphusGptHook, createNoHephaestusNonGptHook, createHephaestusAgentsMdInjectorHook, createQuestionLabelTruncatorHook, createPreemptiveCompactionHook, createRuntimeFallbackHook, createLegacyPluginToastHook } from "../../hooks";
 import { createAnthropicEffortHook } from "../../hooks/anthropic-effort";
 export type SessionHooks = {
     preemptiveCompaction: ReturnType<typeof createPreemptiveCompactionHook> | null;
@@ -24,6 +24,7 @@ export type SessionHooks = {
     sisyphusJuniorNotepad: ReturnType<typeof createSisyphusJuniorNotepadHook> | null;
     noSisyphusGpt: ReturnType<typeof createNoSisyphusGptHook> | null;
     noHephaestusNonGpt: ReturnType<typeof createNoHephaestusNonGptHook> | null;
+    hephaestusAgentsMdInjector: ReturnType<typeof createHephaestusAgentsMdInjectorHook> | null;
     questionLabelTruncator: ReturnType<typeof createQuestionLabelTruncatorHook> | null;
     taskResumeInfo: ReturnType<typeof createTaskResumeInfoHook> | null;
     anthropicEffort: ReturnType<typeof createAnthropicEffortHook> | null;

package/dist/plugin/hooks/model-fallback-title-updater.d.ts

@@ -0,0 +1,8 @@
+import type { PluginContext } from "../types";
+export type ModelFallbackTitleInput = {
+    readonly sessionID: string;
+    readonly providerID: string;
+    readonly modelID: string;
+    readonly variant?: string;
+};
+export declare function createModelFallbackTitleUpdater(ctx: PluginContext): (input: ModelFallbackTitleInput) => Promise<void>;

package/dist/plugin/session-compacting.d.ts

@@ -12,6 +12,9 @@ export type CompactionAutocontinueOutput = {
     enabled: boolean;
 };
 export type CompactionAutocontinueHook = (input: CompactionAutocontinueInput, output: CompactionAutocontinueOutput) => Promise<void>;
+type CompactionAutocontinueHandlerOptions = {
+    readonly duplicateGuardMs?: number;
+};
 type CompactionHookDependencies = {
     compactionContextInjector?: {
         capture?: (sessionID: string) => Promise<void>;
@@ -27,5 +30,5 @@ type CompactionHookDependencies = {
     } | null;
 };
 export declare function createSessionCompactingHandler(hooks: CompactionHookDependencies): SessionCompactingHook;
-export declare function createCompactionAutocontinueHandler(hooks: CompactionHookDependencies): CompactionAutocontinueHook;
+export declare function createCompactionAutocontinueHandler(hooks: CompactionHookDependencies, options?: CompactionAutocontinueHandlerOptions): CompactionAutocontinueHook;
 export {};

package/dist/plugin/system-transform.d.ts

@@ -1,5 +1,5 @@
 import type { DefaultModeConfig } from "../config/schema/default-mode";
-export declare function createSystemTransformHandler(defaultMode?: DefaultModeConfig, getUltraworkMessage?: (agentName?: string, modelID?: string) => string): (input: {
+export declare function createSystemTransformHandler(defaultMode?: DefaultModeConfig, getUltraworkMessage?: (agentName?: string, modelID?: string) => string, env?: Readonly<Record<string, string | undefined>>): (input: {
     sessionID?: string;
     model: {
         id: string;

package/dist/plugin/tool-execute-after.d.ts

@@ -1,4 +1,5 @@
 import type { CreatedHooks } from "../create-hooks";
+import { log as defaultLog } from "../shared/logger";
 import type { PluginContext } from "./types";
 type ToolExecuteAfterInput = {
     readonly tool: string;
@@ -16,5 +17,6 @@ type ToolExecuteAfterOutput = {
 export declare function createToolExecuteAfterHandler(args: {
     ctx: PluginContext;
     hooks: CreatedHooks;
+    log?: typeof defaultLog;
 }): (input: ToolExecuteAfterInput, output: ToolExecuteAfterOutput | undefined) => Promise<void>;
 export {};

package/dist/plugin/tool-registry-core-tools.d.ts

@@ -0,0 +1,15 @@
+import type { ToolDefinition } from "@opencode-ai/plugin";
+import type { AvailableCategory } from "../agents/dynamic-agent-prompt-builder";
+import type { OhMyOpenCodeConfig } from "../config";
+import type { Managers } from "../create-managers";
+import type { SkillContext } from "./skill-context";
+import type { PluginContext } from "./types";
+import type { ToolRegistryFactories } from "./tool-registry-factories";
+export declare function createCoreTools(args: {
+    readonly ctx: PluginContext;
+    readonly pluginConfig: OhMyOpenCodeConfig;
+    readonly managers: Pick<Managers, "backgroundManager" | "tmuxSessionManager" | "skillMcpManager" | "modelFallbackControllerAccessor">;
+    readonly skillContext: SkillContext;
+    readonly availableCategories: AvailableCategory[];
+    readonly factories: ToolRegistryFactories;
+}): Record<string, ToolDefinition>;