@bohuyeshan/openagent-labforge-core 3.11.2 → 3.11.3

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,5 +1,5 @@
-export declare const PACKAGE_NAME = "oh-my-opencode";
-export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org/-/package/oh-my-opencode/dist-tags";
+export declare const PACKAGE_NAME = "openagent-labforge";
+export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org/-/package/openagent-labforge/dist-tags";
 export declare const NPM_FETCH_TIMEOUT = 5000;
 export declare const CACHE_DIR: string;
 export declare const VERSION_FILE: string;

package/dist/hooks/comment-checker/downloader.d.ts

@@ -1,5 +1,5 @@
 /**
- * Get the cache directory for oh-my-opencode binaries.
+ * Get the cache directory for openagent-labforge binaries.
  * On Windows: Uses %LOCALAPPDATA% or %APPDATA% (Windows conventions)
  * On Unix: Follows XDG Base Directory Specification
  */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/hooks/delegate-task-english-directive/hook.d.ts

@@ -0,0 +1,14 @@
+export declare const TARGET_SUBAGENT_TYPES: readonly ["explore", "librarian", "oracle", "plan"];
+export declare const ENGLISH_DIRECTIVE = "**YOU MUST ALWAYS THINK, REASON, AND RESPOND IN ENGLISH REGARDLESS OF THE USER'S QUERY LANGUAGE.**";
+export declare function createDelegateTaskEnglishDirectiveHook(): {
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+        input: Record<string, unknown>;
+    }, _output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+};

package/dist/hooks/delegate-task-english-directive/index.d.ts

@@ -0,0 +1 @@
+export { createDelegateTaskEnglishDirectiveHook, TARGET_SUBAGENT_TYPES, ENGLISH_DIRECTIVE } from "./hook";

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

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

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

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

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

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

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

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

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

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

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

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

package/dist/hooks/index.d.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,20 +1,22 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { Platform } from "./session-notification-sender";
 type SessionNotificationConfig = {
-    title: string;
-    message: string;
+    title?: string;
+    message?: string;
     playSound: boolean;
     soundPath: string;
     idleConfirmationDelay: number;
     skipIfIncompleteTodos: boolean;
     maxTrackedSessions: number;
+    /** Grace period in ms to ignore late-arriving activity events after scheduling (default: 100) */
+    activityGracePeriodMs?: number;
 };
 export declare function createIdleNotificationScheduler(options: {
     ctx: PluginInput;
     platform: Platform;
     config: SessionNotificationConfig;
     hasIncompleteTodos: (ctx: PluginInput, sessionID: string) => Promise<boolean>;
-    send: (ctx: PluginInput, platform: Platform, title: string, message: string) => Promise<void>;
+    send: (ctx: PluginInput, platform: Platform, sessionID: string) => Promise<void>;
     playSound: (ctx: PluginInput, platform: Platform, soundPath: string) => Promise<void>;
 }): {
     markSessionActivity: (sessionID: string) => void;

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

@@ -8,6 +8,8 @@ interface SessionNotificationConfig {
     soundPath?: string;
     /** Delay in ms before sending notification to confirm session is still idle (default: 1500) */
     idleConfirmationDelay?: number;
+    /** Ignore activity events within grace period after idle (default: 100) */
+    activityGracePeriodMs?: number;
     /** Skip notification if there are incomplete todos (default: true) */
     skipIfIncompleteTodos?: boolean;
     /** Maximum number of sessions to track before cleanup (default: 100) */

package/dist/hooks/start-work/index.d.ts

@@ -1,4 +1,4 @@
 export { HOOK_NAME, createStartWorkHook } from "./start-work-hook";
-export { detectWorktreePath } from "./worktree-detector";
+export { detectWorktreePath, listWorktrees, parseWorktreeListPorcelain } from "./worktree-detector";
 export type { ParsedUserRequest } from "./parse-user-request";
 export { parseUserRequest } from "./parse-user-request";

package/dist/hooks/start-work/worktree-detector.d.ts

@@ -1 +1,8 @@
+export type WorktreeEntry = {
+    path: string;
+    branch: string | undefined;
+    bare: boolean;
+};
+export declare function parseWorktreeListPorcelain(output: string): WorktreeEntry[];
+export declare function listWorktrees(directory: string): WorktreeEntry[];
 export declare function detectWorktreePath(directory: string): string | null;