oh-my-opencode 3.5.6 → 3.7.0

package/dist/cli/run/event-handlers.d.ts

@@ -7,3 +7,4 @@ export declare function handleMessagePartUpdated(ctx: RunContext, payload: Event
 export declare function handleMessageUpdated(ctx: RunContext, payload: EventPayload, state: EventState): void;
 export declare function handleToolExecute(ctx: RunContext, payload: EventPayload, state: EventState): void;
 export declare function handleToolResult(ctx: RunContext, payload: EventPayload, state: EventState): void;
+export declare function handleTuiToast(_ctx: RunContext, payload: EventPayload, state: EventState): void;

package/dist/cli/run/opencode-bin-path.d.ts

@@ -0,0 +1,3 @@
+type EnvLike = Record<string, string | undefined>;
+export declare function prependResolvedOpencodeBinToPath(env?: EnvLike, resolve?: (id: string) => string): void;
+export {};

package/dist/cli/run/opencode-binary-resolver.d.ts

@@ -0,0 +1,5 @@
+export declare function collectCandidateBinaryPaths(pathEnv: string | undefined, which?: (command: string) => string | null | undefined, platform?: NodeJS.Platform): string[];
+export declare function canExecuteBinary(binaryPath: string): Promise<boolean>;
+export declare function findWorkingOpencodeBinary(pathEnv?: string | undefined, probe?: (binaryPath: string) => Promise<boolean>, which?: (command: string) => string | null | undefined, platform?: NodeJS.Platform): Promise<string | null>;
+export declare function buildPathWithBinaryFirst(pathEnv: string | undefined, binaryPath: string): string;
+export declare function withWorkingOpencodePath<T>(startServer: () => Promise<T>, finder?: (pathEnv: string | undefined) => Promise<string | null>): Promise<T>;

package/dist/cli/run/session-resolver.d.ts

@@ -2,4 +2,5 @@ import type { OpencodeClient } from "./types";
 export declare function resolveSession(options: {
     client: OpencodeClient;
     sessionId?: string;
+    directory: string;
 }): Promise<string>;

package/dist/cli/run/types.d.ts

@@ -29,7 +29,7 @@ export interface RunContext {
     abortController: AbortController;
 }
 export interface Todo {
-    id: string;
+    id?: string;
     content: string;
     status: string;
     priority: string;
@@ -46,9 +46,11 @@ export interface EventPayload {
 }
 export interface SessionIdleProps {
     sessionID?: string;
+    sessionId?: string;
 }
 export interface SessionStatusProps {
     sessionID?: string;
+    sessionId?: string;
     status?: {
         type?: string;
     };
@@ -56,6 +58,7 @@ export interface SessionStatusProps {
 export interface MessageUpdatedProps {
     info?: {
         sessionID?: string;
+        sessionId?: string;
         role?: string;
         modelID?: string;
         providerID?: string;
@@ -63,28 +66,54 @@ export interface MessageUpdatedProps {
     };
 }
 export interface MessagePartUpdatedProps {
+    /** @deprecated Legacy structure — current OpenCode puts sessionID inside part */
     info?: {
         sessionID?: string;
+        sessionId?: string;
         role?: string;
     };
     part?: {
+        id?: string;
+        sessionID?: string;
+        sessionId?: string;
+        messageID?: string;
         type?: string;
         text?: string;
+        /** Tool name (for part.type === "tool") */
+        tool?: string;
+        /** Tool state (for part.type === "tool") */
+        state?: {
+            status?: string;
+            input?: Record<string, unknown>;
+            output?: string;
+        };
         name?: string;
         input?: unknown;
+        time?: {
+            start?: number;
+            end?: number;
+        };
     };
 }
 export interface ToolExecuteProps {
     sessionID?: string;
+    sessionId?: string;
     name?: string;
     input?: Record<string, unknown>;
 }
 export interface ToolResultProps {
     sessionID?: string;
+    sessionId?: string;
     name?: string;
     output?: string;
 }
 export interface SessionErrorProps {
     sessionID?: string;
+    sessionId?: string;
     error?: unknown;
 }
+export interface TuiToastShowProps {
+    title?: string;
+    message?: string;
+    variant?: "info" | "success" | "warning" | "error";
+}

package/dist/config/schema/browser-automation.d.ts

@@ -3,12 +3,14 @@ export declare const BrowserAutomationProviderSchema: z.ZodEnum<{
     playwright: "playwright";
     "agent-browser": "agent-browser";
     "dev-browser": "dev-browser";
+    "playwright-cli": "playwright-cli";
 }>;
 export declare const BrowserAutomationConfigSchema: z.ZodObject<{
     provider: z.ZodDefault<z.ZodEnum<{
         playwright: "playwright";
         "agent-browser": "agent-browser";
         "dev-browser": "dev-browser";
+        "playwright-cli": "playwright-cli";
     }>>;
 }, z.core.$strip>;
 export type BrowserAutomationProvider = z.infer<typeof BrowserAutomationProviderSchema>;

package/dist/config/schema/experimental.d.ts

@@ -33,5 +33,6 @@ export declare const ExperimentalConfigSchema: z.ZodObject<{
     task_system: z.ZodOptional<z.ZodBoolean>;
     plugin_load_timeout_ms: z.ZodOptional<z.ZodNumber>;
     safe_hook_creation: z.ZodOptional<z.ZodBoolean>;
+    hashline_edit: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type ExperimentalConfig = z.infer<typeof ExperimentalConfigSchema>;

package/dist/config/schema/hooks.d.ts

@@ -42,5 +42,6 @@ export declare const HookNameSchema: z.ZodEnum<{
     "tasks-todowrite-disabler": "tasks-todowrite-disabler";
     "write-existing-file-guard": "write-existing-file-guard";
     "anthropic-effort": "anthropic-effort";
+    "hashline-read-enhancer": "hashline-read-enhancer";
 }>;
 export type HookName = z.infer<typeof HookNameSchema>;

package/dist/config/schema/oh-my-opencode-config.d.ts

@@ -66,6 +66,7 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         "tasks-todowrite-disabler": "tasks-todowrite-disabler";
         "write-existing-file-guard": "write-existing-file-guard";
         "anthropic-effort": "anthropic-effort";
+        "hashline-read-enhancer": "hashline-read-enhancer";
     }>>>;
     disabled_commands: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         "init-deep": "init-deep";
@@ -1211,6 +1212,7 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
         task_system: z.ZodOptional<z.ZodBoolean>;
         plugin_load_timeout_ms: z.ZodOptional<z.ZodNumber>;
         safe_hook_creation: z.ZodOptional<z.ZodBoolean>;
+        hashline_edit: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
     auto_update: z.ZodOptional<z.ZodBoolean>;
     skills: z.ZodOptional<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
@@ -1262,6 +1264,7 @@ export declare const OhMyOpenCodeConfigSchema: z.ZodObject<{
             playwright: "playwright";
             "agent-browser": "agent-browser";
             "dev-browser": "dev-browser";
+            "playwright-cli": "playwright-cli";
         }>>;
     }, z.core.$strip>>;
     websearch: z.ZodOptional<z.ZodObject<{

package/dist/create-hooks.d.ts

@@ -3,10 +3,12 @@ import type { HookName, OhMyOpenCodeConfig } from "./config";
 import type { LoadedSkill } from "./features/opencode-skill-loader/types";
 import type { BackgroundManager } from "./features/background-agent";
 import type { PluginContext } from "./plugin/types";
+import type { ModelCacheState } from "./plugin-state";
 export type CreatedHooks = ReturnType<typeof createHooks>;
 export declare function createHooks(args: {
     ctx: PluginContext;
     pluginConfig: OhMyOpenCodeConfig;
+    modelCacheState: ModelCacheState;
     backgroundManager: BackgroundManager;
     isHookEnabled: (hookName: HookName) => boolean;
     safeHookEnabled: boolean;
@@ -34,6 +36,7 @@ export declare function createHooks(args: {
     rulesInjector: ReturnType<typeof import("./hooks").createRulesInjectorHook> | null;
     tasksTodowriteDisabler: ReturnType<typeof import("./hooks").createTasksTodowriteDisablerHook> | null;
     writeExistingFileGuard: ReturnType<typeof import("./hooks").createWriteExistingFileGuardHook> | null;
+    hashlineReadEnhancer: ReturnType<typeof import("./hooks").createHashlineReadEnhancerHook> | null;
     contextWindowMonitor: ReturnType<typeof import("./hooks").createContextWindowMonitorHook> | null;
     preemptiveCompaction: ReturnType<typeof import("./hooks").createPreemptiveCompactionHook> | null;
     sessionRecovery: ReturnType<typeof import("./hooks").createSessionRecoveryHook> | null;

package/dist/create-managers.d.ts

@@ -16,4 +16,5 @@ export declare function createManagers(args: {
     pluginConfig: OhMyOpenCodeConfig;
     tmuxConfig: TmuxConfig;
     modelCacheState: ModelCacheState;
+    backgroundNotificationHookEnabled: boolean;
 }): Managers;

package/dist/features/background-agent/constants.d.ts

@@ -31,7 +31,7 @@ export interface Todo {
     content: string;
     status: string;
     priority: string;
-    id: string;
+    id?: string;
 }
 export interface QueueItem {
     task: BackgroundTask;

package/dist/features/background-agent/manager.d.ts

@@ -29,6 +29,7 @@ export declare class BackgroundManager {
     private client;
     private directory;
     private pollingInterval?;
+    private pollingInFlight;
     private concurrencyManager;
     private shutdownTriggered;
     private config?;
@@ -40,11 +41,13 @@ export declare class BackgroundManager {
     private completionTimers;
     private idleDeferralTimers;
     private notificationQueueByParent;
+    private enableParentSessionNotifications;
     readonly taskHistory: TaskHistory;
     constructor(ctx: PluginInput, config?: BackgroundTaskConfig, options?: {
         tmuxConfig?: TmuxConfig;
         onSubagentSessionCreated?: OnSubagentSessionCreated;
         onShutdown?: () => void;
+        enableParentSessionNotifications?: boolean;
     });
     launch(input: LaunchInput): Promise<BackgroundTask>;
     private processKey;

package/dist/features/background-agent/message-dir.d.ts

@@ -1 +1 @@
-export { getMessageDir } from "./message-storage-locator";
+export { getMessageDir } from "../../shared";

package/dist/features/background-agent/result-handler.d.ts

@@ -1,6 +1,6 @@
 export type { ResultHandlerContext } from "./result-handler-context";
 export { formatDuration } from "./duration-formatter";
-export { getMessageDir } from "./message-storage-locator";
+export { getMessageDir } from "../../shared";
 export { checkSessionTodos } from "./session-todo-checker";
 export { validateSessionHasOutput } from "./session-output-validator";
 export { tryCompleteTask } from "./background-task-completer";

package/dist/features/builtin-skills/skills/index.d.ts

@@ -1,4 +1,5 @@
 export { playwrightSkill, agentBrowserSkill } from "./playwright";
+export { playwrightCliSkill } from "./playwright-cli";
 export { frontendUiUxSkill } from "./frontend-ui-ux";
 export { gitMasterSkill } from "./git-master";
 export { devBrowserSkill } from "./dev-browser";

package/dist/features/builtin-skills/skills/playwright-cli.d.ts

@@ -0,0 +1,10 @@
+import type { BuiltinSkill } from "../types";
+/**
+ * Playwright CLI skill — token-efficient CLI alternative to the MCP-based playwright skill.
+ *
+ * Uses name "playwright" (not "playwright-cli") because agents hardcode "playwright" as the
+ * canonical browser skill name. The browserProvider config swaps the implementation behind
+ * the same name: "playwright" gives MCP, "playwright-cli" gives this CLI variant.
+ * The binary is still called `playwright-cli` (see allowedTools).
+ */
+export declare const playwrightCliSkill: BuiltinSkill;

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

@@ -1,4 +1,4 @@
 import type { LoadedMcpServer, McpLoadResult } from "./types";
 export declare function getSystemMcpServerNames(): Set<string>;
-export declare function loadMcpConfigs(): Promise<McpLoadResult>;
+export declare function loadMcpConfigs(disabledMcps?: string[]): Promise<McpLoadResult>;
 export declare function formatLoadedServersForToast(loadedServers: LoadedMcpServer[]): string;

package/dist/features/hook-message-injector/constants.d.ts

@@ -1,3 +1 @@
-export declare const OPENCODE_STORAGE: string;
-export declare const MESSAGE_STORAGE: string;
-export declare const PART_STORAGE: string;
+export { OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE } from "../../shared";

package/dist/features/hook-message-injector/index.d.ts

@@ -1,4 +1,4 @@
-export { injectHookMessage, findNearestMessageWithFields, findFirstMessageWithAgent } from "./injector";
+export { injectHookMessage, findNearestMessageWithFields, findFirstMessageWithAgent, findNearestMessageWithFieldsFromSDK, findFirstMessageWithAgentFromSDK, resolveMessageContext, } from "./injector";
 export type { StoredMessage } from "./injector";
 export type { MessageMeta, OriginalMessageContext, TextPart, ToolPermission } from "./types";
 export { MESSAGE_STORAGE } from "./constants";

package/dist/features/hook-message-injector/injector.d.ts

@@ -1,3 +1,4 @@
+import type { PluginInput } from "@opencode-ai/plugin";
 import type { OriginalMessageContext, ToolPermission } from "./types";
 export interface StoredMessage {
     agent?: string;
@@ -8,12 +9,59 @@ export interface StoredMessage {
     };
     tools?: Record<string, ToolPermission>;
 }
+type OpencodeClient = PluginInput["client"];
+/**
+ * Finds the nearest message with required fields using SDK (for beta/SQLite backend).
+ * Uses client.session.messages() to fetch message data from SQLite.
+ */
+export declare function findNearestMessageWithFieldsFromSDK(client: OpencodeClient, sessionID: string): Promise<StoredMessage | null>;
+/**
+ * Finds the FIRST (oldest) message with agent field using SDK (for beta/SQLite backend).
+ */
+export declare function findFirstMessageWithAgentFromSDK(client: OpencodeClient, sessionID: string): Promise<string | null>;
+/**
+ * Finds the nearest message with required fields (agent, model.providerID, model.modelID).
+ * Reads from JSON files - for stable (JSON) backend.
+ *
+ * **Version-gated behavior:**
+ * - On beta (SQLite backend): Returns null immediately (no JSON storage)
+ * - On stable (JSON backend): Reads from JSON files in messageDir
+ *
+ * @deprecated Use findNearestMessageWithFieldsFromSDK for beta/SQLite backend
+ */
 export declare function findNearestMessageWithFields(messageDir: string): StoredMessage | null;
 /**
  * Finds the FIRST (oldest) message in the session with agent field.
- * This is used to get the original agent that started the session,
- * avoiding issues where newer messages may have a different agent
- * due to OpenCode's internal agent switching.
+ * Reads from JSON files - for stable (JSON) backend.
+ *
+ * **Version-gated behavior:**
+ * - On beta (SQLite backend): Returns null immediately (no JSON storage)
+ * - On stable (JSON backend): Reads from JSON files in messageDir
+ *
+ * @deprecated Use findFirstMessageWithAgentFromSDK for beta/SQLite backend
  */
 export declare function findFirstMessageWithAgent(messageDir: string): string | null;
+/**
+ * Injects a hook message into the session storage.
+ *
+ * **Version-gated behavior:**
+ * - On beta (SQLite backend): Logs warning and skips injection (writes are invisible to SQLite)
+ * - On stable (JSON backend): Writes message and part JSON files
+ *
+ * Features degraded on beta:
+ * - Hook message injection (e.g., continuation prompts, context injection) won't persist
+ * - Atlas hook's injected messages won't be visible in SQLite backend
+ * - Todo continuation enforcer's injected prompts won't persist
+ * - Ralph loop's continuation prompts won't persist
+ *
+ * @param sessionID - Target session ID
+ * @param hookContent - Content to inject
+ * @param originalMessage - Context from the original message
+ * @returns true if injection succeeded, false otherwise
+ */
 export declare function injectHookMessage(sessionID: string, hookContent: string, originalMessage: OriginalMessageContext): boolean;
+export declare function resolveMessageContext(sessionID: string, client: OpencodeClient, messageDir: string | null): Promise<{
+    prevMessage: StoredMessage | null;
+    firstMessageAgent: string | null;
+}>;
+export {};

package/dist/features/tmux-subagent/action-executor-core.d.ts

@@ -0,0 +1,21 @@
+import type { TmuxConfig } from "../../config/schema";
+import type { applyLayout, closeTmuxPane, enforceMainPaneWidth, replaceTmuxPane, spawnTmuxPane } from "../../shared/tmux";
+import type { PaneAction, WindowState } from "./types";
+export interface ActionResult {
+    success: boolean;
+    paneId?: string;
+    error?: string;
+}
+export interface ExecuteContext {
+    config: TmuxConfig;
+    serverUrl: string;
+    windowState: WindowState;
+}
+export interface ActionExecutorDeps {
+    spawnTmuxPane: typeof spawnTmuxPane;
+    closeTmuxPane: typeof closeTmuxPane;
+    replaceTmuxPane: typeof replaceTmuxPane;
+    applyLayout: typeof applyLayout;
+    enforceMainPaneWidth: typeof enforceMainPaneWidth;
+}
+export declare function executeActionWithDeps(action: PaneAction, ctx: ExecuteContext, deps: ActionExecutorDeps): Promise<ActionResult>;

package/dist/features/tmux-subagent/action-executor.d.ts

@@ -1,10 +1,6 @@
-import type { TmuxConfig } from "../../config/schema";
-import type { PaneAction, WindowState } from "./types";
-export interface ActionResult {
-    success: boolean;
-    paneId?: string;
-    error?: string;
-}
+import type { PaneAction } from "./types";
+import type { ActionResult, ExecuteContext } from "./action-executor-core";
+export type { ActionExecutorDeps, ActionResult, ExecuteContext } from "./action-executor-core";
 export interface ExecuteActionsResult {
     success: boolean;
     spawnedPaneId?: string;
@@ -13,10 +9,5 @@ export interface ExecuteActionsResult {
         result: ActionResult;
     }>;
 }
-export interface ExecuteContext {
-    config: TmuxConfig;
-    serverUrl: string;
-    windowState: WindowState;
-}
 export declare function executeAction(action: PaneAction, ctx: ExecuteContext): Promise<ActionResult>;
 export declare function executeActions(actions: PaneAction[], ctx: ExecuteContext): Promise<ExecuteActionsResult>;

package/dist/features/tmux-subagent/grid-planning.d.ts

@@ -14,6 +14,6 @@ export interface GridPlan {
     slotWidth: number;
     slotHeight: number;
 }
-export declare function calculateCapacity(windowWidth: number, windowHeight: number, minPaneWidth?: number): GridCapacity;
-export declare function computeGridPlan(windowWidth: number, windowHeight: number, paneCount: number): GridPlan;
+export declare function calculateCapacity(windowWidth: number, windowHeight: number, minPaneWidth?: number, mainPaneWidth?: number): GridCapacity;
+export declare function computeGridPlan(windowWidth: number, windowHeight: number, paneCount: number, mainPaneWidth?: number, minPaneWidth?: number): GridPlan;
 export declare function mapPaneToSlot(pane: TmuxPaneInfo, plan: GridPlan, mainPaneWidth: number): GridSlot;

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

@@ -40,7 +40,6 @@ export declare class TmuxSessionManager {
     private getCapacityConfig;
     private getSessionMappings;
     private waitForSessionReady;
-    private pollSessions;
     onSessionCreated(event: SessionCreatedEvent): Promise<void>;
     onSessionDeleted(event: {
         sessionID: string;

package/dist/features/tmux-subagent/pane-split-availability.d.ts

@@ -4,5 +4,6 @@ export declare function getColumnWidth(agentAreaWidth: number, paneCount: number
 export declare function isSplittableAtCount(agentAreaWidth: number, paneCount: number, minPaneWidth?: number): boolean;
 export declare function findMinimalEvictions(agentAreaWidth: number, currentCount: number, minPaneWidth?: number): number | null;
 export declare function canSplitPane(pane: TmuxPaneInfo, direction: SplitDirection, minPaneWidth?: number): boolean;
-export declare function canSplitPaneAnyDirection(pane: TmuxPaneInfo): boolean;
-export declare function getBestSplitDirection(pane: TmuxPaneInfo): SplitDirection | null;
+export declare function canSplitPaneAnyDirection(pane: TmuxPaneInfo, minPaneWidth?: number): boolean;
+export declare function canSplitPaneAnyDirectionWithMinWidth(pane: TmuxPaneInfo, minPaneWidth?: number): boolean;
+export declare function getBestSplitDirection(pane: TmuxPaneInfo, minPaneWidth?: number): SplitDirection | null;

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

@@ -5,6 +5,7 @@ export declare class TmuxPollingManager {
     private sessions;
     private closeSessionById;
     private pollInterval?;
+    private pollingInFlight;
     constructor(client: OpencodeClient, sessions: Map<string, TrackedSession>, closeSessionById: (sessionId: string) => Promise<void>);
     startPolling(): void;
     stopPolling(): void;

package/dist/features/tmux-subagent/spawn-target-finder.d.ts

@@ -3,4 +3,4 @@ export interface SpawnTarget {
     targetPaneId: string;
     splitDirection: SplitDirection;
 }
-export declare function findSpawnTarget(state: WindowState): SpawnTarget | null;
+export declare function findSpawnTarget(state: WindowState, minPaneWidth?: number): SpawnTarget | null;

package/dist/hooks/agent-usage-reminder/constants.d.ts

@@ -1,4 +1,3 @@
-export declare const OPENCODE_STORAGE: string;
 export declare const AGENT_USAGE_REMINDER_STORAGE: string;
 export declare const TARGET_TOOLS: Set<string>;
 export declare const AGENT_TOOLS: Set<string>;

package/dist/hooks/anthropic-context-window-limit-recovery/client.d.ts

@@ -1,38 +1,7 @@
-export type Client = {
+import type { PluginInput } from "@opencode-ai/plugin";
+export type Client = PluginInput["client"] & {
     session: {
-        messages: (opts: {
-            path: {
-                id: string;
-            };
-            query?: {
-                directory?: string;
-            };
-        }) => Promise<unknown>;
-        summarize: (opts: {
-            path: {
-                id: string;
-            };
-            body: {
-                providerID: string;
-                modelID: string;
-            };
-            query: {
-                directory: string;
-            };
-        }) => Promise<unknown>;
-        revert: (opts: {
-            path: {
-                id: string;
-            };
-            body: {
-                messageID: string;
-                partID?: string;
-            };
-            query: {
-                directory: string;
-            };
-        }) => Promise<unknown>;
-        prompt_async: (opts: {
+        promptAsync: (opts: {
             path: {
                 id: string;
             };

package/dist/hooks/anthropic-context-window-limit-recovery/deduplication-recovery.d.ts

@@ -1,3 +1,6 @@
+import type { PluginInput } from "@opencode-ai/plugin";
 import type { ParsedTokenLimitError } from "./types";
 import type { ExperimentalConfig } from "../../config";
-export declare function attemptDeduplicationRecovery(sessionID: string, parsed: ParsedTokenLimitError, experimental: ExperimentalConfig | undefined): Promise<void>;
+type OpencodeClient = PluginInput["client"];
+export declare function attemptDeduplicationRecovery(sessionID: string, parsed: ParsedTokenLimitError, experimental: ExperimentalConfig | undefined, client?: OpencodeClient): Promise<void>;
+export {};

package/dist/hooks/anthropic-context-window-limit-recovery/empty-content-recovery-sdk.d.ts

@@ -0,0 +1,11 @@
+import type { Client } from "./client";
+export declare function fixEmptyMessagesWithSDK(params: {
+    sessionID: string;
+    client: Client;
+    placeholderText: string;
+    messageIndex?: number;
+}): Promise<{
+    fixed: boolean;
+    fixedMessageIds: string[];
+    scannedEmptyCount: number;
+}>;

package/dist/hooks/anthropic-context-window-limit-recovery/message-builder.d.ts

@@ -1,4 +1,7 @@
+import type { PluginInput } from "@opencode-ai/plugin";
 export declare const PLACEHOLDER_TEXT = "[user interrupted]";
-export declare function sanitizeEmptyMessagesBeforeSummarize(sessionID: string): number;
+type OpencodeClient = PluginInput["client"];
+export declare function sanitizeEmptyMessagesBeforeSummarize(sessionID: string, client?: OpencodeClient): Promise<number>;
 export declare function formatBytes(bytes: number): string;
 export declare function getLastAssistant(sessionID: string, client: any, directory: string): Promise<Record<string, unknown> | null>;
+export {};

package/dist/hooks/anthropic-context-window-limit-recovery/message-storage-directory.d.ts

@@ -1,2 +1,6 @@
-export declare function getMessageDir(sessionID: string): string;
+import type { PluginInput } from "@opencode-ai/plugin";
+import { getMessageDir } from "../../shared/opencode-message-dir";
+export { getMessageDir };
+type OpencodeClient = PluginInput["client"];
+export declare function getMessageIdsFromSDK(client: OpencodeClient, sessionID: string): Promise<string[]>;
 export declare function getMessageIds(sessionID: string): string[];

package/dist/hooks/anthropic-context-window-limit-recovery/pruning-deduplication.d.ts

@@ -1,7 +1,10 @@
+import type { PluginInput } from "@opencode-ai/plugin";
 import type { PruningState } from "./pruning-types";
+type OpencodeClient = PluginInput["client"];
 export interface DeduplicationConfig {
     enabled: boolean;
     protectedTools?: string[];
 }
 export declare function createToolSignature(toolName: string, input: unknown): string;
-export declare function executeDeduplication(sessionID: string, state: PruningState, config: DeduplicationConfig, protectedTools: Set<string>): number;
+export declare function executeDeduplication(sessionID: string, state: PruningState, config: DeduplicationConfig, protectedTools: Set<string>, client?: OpencodeClient): Promise<number>;
+export {};

package/dist/hooks/anthropic-context-window-limit-recovery/pruning-tool-output-truncation.d.ts

@@ -1,3 +1,6 @@
-export declare function truncateToolOutputsByCallId(sessionID: string, callIds: Set<string>): {
+import type { PluginInput } from "@opencode-ai/plugin";
+type OpencodeClient = PluginInput["client"];
+export declare function truncateToolOutputsByCallId(sessionID: string, callIds: Set<string>, client?: OpencodeClient): Promise<{
     truncatedCount: number;
-};
+}>;
+export {};

package/dist/hooks/anthropic-context-window-limit-recovery/storage-paths.d.ts

@@ -1,3 +1,3 @@
-export declare const MESSAGE_STORAGE_DIR: string;
-export declare const PART_STORAGE_DIR: string;
+import { MESSAGE_STORAGE, PART_STORAGE } from "../../shared";
+export { MESSAGE_STORAGE as MESSAGE_STORAGE_DIR, PART_STORAGE as PART_STORAGE_DIR };
 export declare const TRUNCATION_MESSAGE = "[TOOL RESULT TRUNCATED - Context limit exceeded. Original output was too large and has been truncated to recover the session. Please re-run this tool if you need the full output.]";

package/dist/hooks/anthropic-context-window-limit-recovery/storage.d.ts

@@ -1,3 +1,4 @@
 export type { AggressiveTruncateResult, ToolResultInfo } from "./tool-part-types";
 export { countTruncatedResults, findLargestToolResult, findToolResultsBySize, getTotalToolOutputSize, truncateToolResult, } from "./tool-result-storage";
+export { countTruncatedResultsFromSDK, findToolResultsBySizeFromSDK, getTotalToolOutputSizeFromSDK, truncateToolResultAsync, } from "./tool-result-storage-sdk";
 export { truncateUntilTargetTokens } from "./target-token-truncation";

package/dist/hooks/anthropic-context-window-limit-recovery/target-token-truncation.d.ts

@@ -1,2 +1,5 @@
+import type { PluginInput } from "@opencode-ai/plugin";
 import type { AggressiveTruncateResult } from "./tool-part-types";
-export declare function truncateUntilTargetTokens(sessionID: string, currentTokens: number, maxTokens: number, targetRatio?: number, charsPerToken?: number): AggressiveTruncateResult;
+type OpencodeClient = PluginInput["client"];
+export declare function truncateUntilTargetTokens(sessionID: string, currentTokens: number, maxTokens: number, targetRatio?: number, charsPerToken?: number, client?: OpencodeClient): Promise<AggressiveTruncateResult>;
+export {};

package/dist/hooks/anthropic-context-window-limit-recovery/tool-result-storage-sdk.d.ts

@@ -0,0 +1,29 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { ToolResultInfo } from "./tool-part-types";
+type OpencodeClient = PluginInput["client"];
+interface SDKToolPart {
+    id: string;
+    type: string;
+    callID?: string;
+    tool?: string;
+    state?: {
+        status?: string;
+        input?: Record<string, unknown>;
+        output?: string;
+        error?: string;
+        time?: {
+            start?: number;
+            end?: number;
+            compacted?: number;
+        };
+    };
+}
+export declare function findToolResultsBySizeFromSDK(client: OpencodeClient, sessionID: string): Promise<ToolResultInfo[]>;
+export declare function truncateToolResultAsync(client: OpencodeClient, sessionID: string, messageID: string, partId: string, part: SDKToolPart): Promise<{
+    success: boolean;
+    toolName?: string;
+    originalSize?: number;
+}>;
+export declare function countTruncatedResultsFromSDK(client: OpencodeClient, sessionID: string): Promise<number>;
+export declare function getTotalToolOutputSizeFromSDK(client: OpencodeClient, sessionID: string): Promise<number>;
+export {};

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

@@ -1 +1,4 @@
-export declare function getLastAgentFromSession(sessionID: string): string | null;
+import type { PluginInput } from "@opencode-ai/plugin";
+type OpencodeClient = PluginInput["client"];
+export declare function getLastAgentFromSession(sessionID: string, client?: OpencodeClient): Promise<string | null>;
+export {};

package/dist/hooks/atlas/tool-execute-before.d.ts

@@ -1,4 +1,6 @@
+import type { PluginInput } from "@opencode-ai/plugin";
 export declare function createToolExecuteBeforeHandler(input: {
+    ctx: PluginInput;
     pendingFilePaths: Map<string, string>;
 }): (toolInput: {
     tool: string;