@wolfx/oh-my-openagent 4.1.1 → 4.2.0-patch.1

package/dist/mcp/index.d.ts

@@ -1,3 +1,4 @@
+import { type LocalMcpConfig } from "./lsp";
 import type { OhMyOpenCodeConfig } from "../config/schema";
 export { McpNameSchema, type McpName } from "./types";
 type RemoteMcpConfig = {
@@ -7,4 +8,5 @@ type RemoteMcpConfig = {
     headers?: Record<string, string>;
     oauth?: false;
 };
-export declare function createBuiltinMcps(disabledMcps?: string[], config?: OhMyOpenCodeConfig): Record<string, RemoteMcpConfig>;
+type BuiltinMcpConfig = RemoteMcpConfig | LocalMcpConfig;
+export declare function createBuiltinMcps(disabledMcps?: string[], config?: OhMyOpenCodeConfig): Record<string, BuiltinMcpConfig>;

package/dist/mcp/lsp.d.ts

@@ -0,0 +1,13 @@
+type LspMcpConfigOptions = {
+    readonly cwd?: string;
+    readonly moduleUrl?: string;
+    readonly exists?: (path: string) => boolean;
+};
+export type LocalMcpConfig = {
+    type: "local";
+    command: string[];
+    enabled: boolean;
+    environment?: Record<string, string>;
+};
+export declare function createLspMcpConfig(options?: LspMcpConfigOptions): LocalMcpConfig;
+export {};

package/dist/mcp/types.d.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 export declare const McpNameSchema: z.ZodEnum<{
+    lsp: "lsp";
     websearch: "websearch";
     context7: "context7";
     grep_app: "grep_app";

package/dist/plugin/build-team-idle-wake-hint-client.d.ts

@@ -0,0 +1,12 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+type SdkSession = PluginInput["client"]["session"];
+type SdkPromptAsync = SdkSession["promptAsync"];
+type SdkStatus = SdkSession["status"];
+export type TeamIdleWakeHintNarrowClient = {
+    session: {
+        promptAsync?: SdkPromptAsync;
+        status?: SdkStatus;
+    };
+};
+export declare function buildTeamIdleWakeHintClient(client: PluginInput["client"]): TeamIdleWakeHintNarrowClient;
+export {};

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

@@ -1,6 +1,6 @@
 import type { OhMyOpenCodeConfig } from "../config";
-import type { PluginContext } from "./types";
 import type { CreatedHooks } from "../create-hooks";
+import type { PluginContext } from "./types";
 type FirstMessageVariantGate = {
     shouldOverride: (sessionID: string) => boolean;
     markApplied: (sessionID: string) => void;

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

@@ -5,11 +5,10 @@ import { createTeamSendMessageTool } from "../features/team-mode/tools/messaging
 import { createTeamListTool, createTeamStatusTool } from "../features/team-mode/tools/query";
 import { createTeamTaskCreateTool, createTeamTaskGetTool, createTeamTaskListTool, createTeamTaskUpdateTool } from "../features/team-mode/tools/tasks";
 import type { PluginContext, ToolsRecord } from "./types";
-import { builtinTools, createBackgroundTools, createCallOmoAgent, createLookAt, createSkillMcpTool, createSkillTool, createGrepTools, createGlobTools, createAstGrepTools, createSessionManagerTools, createDelegateTask, discoverCommandsSync, interactive_bash, createTaskCreateTool, createTaskGetTool, createTaskList, createTaskUpdateTool, createHashlineEditTool } from "../tools";
+import { createBackgroundTools, createCallOmoAgent, createLookAt, createSkillMcpTool, createSkillTool, createGrepTools, createGlobTools, createAstGrepTools, createSessionManagerTools, createDelegateTask, discoverCommandsSync, interactive_bash, createTaskCreateTool, createTaskGetTool, createTaskList, createTaskUpdateTool, createHashlineEditTool } from "../tools";
 import type { Managers } from "../create-managers";
 import type { SkillContext } from "./skill-context";
 type ToolRegistryFactories = {
-    builtinTools: typeof builtinTools;
     createBackgroundTools: typeof createBackgroundTools;
     createCallOmoAgent: typeof createCallOmoAgent;
     createLookAt: typeof createLookAt;

package/dist/plugin-dispose.d.ts

@@ -6,8 +6,5 @@ export declare function createPluginDispose(args: {
     skillMcpManager: {
         disconnectAll: () => Promise<void>;
     };
-    lspManager: {
-        stopAll: () => Promise<void>;
-    };
     disposeHooks: () => void;
 }): PluginDispose;

package/dist/shared/agent-sort-shim.d.ts

@@ -25,4 +25,5 @@
  * (sst/opencode#19127).
  */
 export declare function setAgentSortOrder(agentOrder: readonly string[] | undefined): void;
+export declare function setDefaultAgentForSort(agentName: string | undefined): void;
 export declare function installAgentSortShim(): void;

package/dist/shared/delegated-child-session-bootstrap.d.ts

@@ -0,0 +1,25 @@
+import type { ModelFallbackControllerAccessor } from "../hooks/model-fallback";
+import type { FallbackEntry } from "./model-requirements";
+export type DelegatedChildSessionRetryPart = {
+    type: "text";
+    text: string;
+};
+export type DelegatedChildSessionBootstrap = {
+    retryParts: DelegatedChildSessionRetryPart[];
+    fallbackChain?: FallbackEntry[];
+    category?: string;
+    system?: string;
+    tools?: Record<string, boolean>;
+};
+export declare function registerDelegatedChildSessionBootstrap(_args: {
+    sessionID: string;
+    promptText: string;
+    fallbackChain?: FallbackEntry[];
+    category?: string;
+    system?: string;
+    tools?: Record<string, boolean>;
+    modelFallbackControllerAccessor?: ModelFallbackControllerAccessor;
+}): void;
+export declare function getDelegatedChildSessionBootstrap(_sessionID: string): DelegatedChildSessionBootstrap | undefined;
+export declare function clearDelegatedChildSessionBootstrap(_sessionID: string): void;
+export declare function clearAllDelegatedChildSessionBootstrap(): void;

package/dist/shared/dynamic-truncator.d.ts

@@ -1,10 +1,12 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import { type ContextLimitModelCacheState } from "./context-limit-resolver";
+export declare const DEFAULT_CONTEXT_WINDOW_USAGE_FETCH_TIMEOUT_MS = 5000;
 type ContextWindowUsage = {
     usedTokens: number;
     remainingTokens: number;
     usagePercentage: number;
 };
+export declare function _setContextWindowUsageFetchTimeoutMsForTesting(ms: number | undefined): void;
 export declare function invalidateContextWindowUsageCache(ctx: PluginInput, sessionID?: string): void;
 export interface TruncationResult {
     result: string;

package/dist/shared/host-skill-config.d.ts

@@ -0,0 +1,2 @@
+import type { SkillsConfig } from "../config/schema/skills";
+export declare function adaptHostSkillConfig(value: unknown): SkillsConfig | undefined;

package/dist/shared/index.d.ts

@@ -71,7 +71,9 @@ export * from "./plugin-command-discovery";
 export { SessionCategoryRegistry } from "./session-category-registry";
 export * from "./plugin-identity";
 export * from "./log-legacy-plugin-startup-warning";
+export * from "./legacy-workspace-migration";
 export * from "./task-system-enabled";
 export * from "./parse-tools-config";
 export { parseModelString } from "./model-string-parser";
 export { EXCLUDED_DIRS } from "./excluded-dirs";
+export * from "./replace-tool-args";

package/dist/shared/internal-initiator-marker.d.ts

@@ -1,4 +1,29 @@
 export declare const OMO_INTERNAL_INITIATOR_MARKER = "<!-- OMO_INTERNAL_INITIATOR -->";
+export type InternalInitiatorTextPartLike = {
+    type?: string;
+    text?: string;
+    synthetic?: boolean;
+};
+export type InternalInitiatorMessageLike = {
+    role?: string;
+    info?: {
+        role?: string;
+    };
+    parts?: readonly InternalInitiatorTextPartLike[];
+};
+export declare function hasInternalInitiatorMarker(text: string): boolean;
+export declare function isTextPartLike(part: InternalInitiatorTextPartLike): part is InternalInitiatorTextPartLike & {
+    type: "text";
+    text: string;
+};
+export declare function isSyntheticOrInternalTextPart(part: InternalInitiatorTextPartLike): boolean;
+export declare function isRealUserTextPart(part: InternalInitiatorTextPartLike): part is InternalInitiatorTextPartLike & {
+    type: "text";
+    text: string;
+};
+export declare function isSyntheticOrInternalOnlyTextParts(parts: readonly InternalInitiatorTextPartLike[] | undefined): boolean;
+export declare function isSyntheticOrInternalUserMessage(message: InternalInitiatorMessageLike): boolean;
+export declare function isRealUserMessage(message: InternalInitiatorMessageLike): boolean;
 export declare function stripInternalInitiatorMarkers(text: string): string;
 export declare function createInternalAgentTextPart(text: string): {
     type: "text";

package/dist/shared/legacy-workspace-migration.d.ts

@@ -0,0 +1,5 @@
+export type LegacyWorkspaceMigrationResult = {
+    migrated: boolean;
+    skipped: string[];
+};
+export declare function migrateLegacyWorkspaceDirectory(directory: string): LegacyWorkspaceMigrationResult;

package/dist/shared/logger.d.ts

@@ -1,2 +1,14 @@
 export declare function log(message: string, data?: unknown): void;
 export declare function getLogFilePath(): string;
+interface LoggerTestOverrides {
+    filePath?: string;
+    maxSizeBytes?: number;
+    maxBackups?: number;
+}
+/** @internal test-only seam */
+export declare function _setLoggerForTesting(overrides: LoggerTestOverrides): void;
+/** @internal test-only seam */
+export declare function _resetLoggerForTesting(): void;
+/** @internal test-only seam: synchronously flush the buffer */
+export declare function _flushForTesting(): void;
+export {};

package/dist/shared/model-error-classifier.d.ts

@@ -2,6 +2,8 @@ import type { FallbackEntry } from "./model-requirements";
 export interface ErrorInfo {
     name?: string;
     message?: string;
+    /** HTTP status code from the provider response (e.g., 429 for rate limit) */
+    statusCode?: number;
 }
 /**
  * Determines if an error is a retryable model error.

package/dist/shared/model-resolution-pipeline.d.ts

@@ -1,4 +1,7 @@
+import { log as writeLog } from "./logger";
 import type { FallbackEntry } from "./model-requirements";
+type LogImplementation = typeof writeLog;
+export declare function _setModelResolutionLogImplementationForTesting(logImplementation: LogImplementation | undefined): void;
 export type ModelResolutionRequest = {
     intent?: {
         uiSelectedModel?: string;
@@ -24,3 +27,4 @@ export type ModelResolutionResult = {
     reason?: string;
 };
 export declare function resolveModelPipeline(request: ModelResolutionRequest): ModelResolutionResult | undefined;
+export {};

package/dist/shared/opencode-http-api.d.ts

@@ -1,3 +1,12 @@
+import { getServerBasicAuthHeader as resolveServerBasicAuthHeader } from "./opencode-server-auth";
+import { log as writeLog } from "./logger";
+type FetchImplementation = typeof fetch;
+type LogImplementation = typeof writeLog;
+type ServerBasicAuthHeaderResolver = typeof resolveServerBasicAuthHeader;
+export declare function _setFetchImplementationForTesting(fetchImplementation: FetchImplementation | undefined): void;
+export declare function _setLogImplementationForTesting(logImplementation: LogImplementation | undefined): void;
+export declare function _setServerBasicAuthHeaderResolverForTesting(resolver: ServerBasicAuthHeaderResolver | undefined): void;
 export declare function getServerBaseUrl(client: unknown): string | null;
 export declare function patchPart(client: unknown, sessionID: string, messageID: string, partID: string, body: Record<string, unknown>): Promise<boolean>;
 export declare function deletePart(client: unknown, sessionID: string, messageID: string, partID: string): Promise<boolean>;
+export {};

package/dist/shared/prompt-async-gate.d.ts

@@ -0,0 +1,82 @@
+export declare const DEFAULT_PROMPT_ASYNC_POST_DISPATCH_HOLD_MS = 250;
+export declare const DEFAULT_PROMPT_DISPATCH_TIMEOUT_MS = 30000;
+export declare const DEFAULT_PROMPT_GATE_MESSAGES_FETCH_TIMEOUT_MS = 5000;
+type PromptAsyncInput = {
+    path?: {
+        id?: string;
+    };
+    body?: unknown;
+    query?: unknown;
+    signal?: unknown;
+    [key: string]: unknown;
+};
+type PromptMessagesQuery = {
+    directory: string;
+    limit?: number;
+};
+type PromptAsyncClient<TInput> = {
+    session?: {
+        status?: () => Promise<unknown>;
+        messages?: (input: {
+            path: {
+                id: string;
+            };
+            query: PromptMessagesQuery;
+        }) => Promise<unknown>;
+        promptAsync?: (input: TInput) => Promise<unknown>;
+    };
+};
+type PromptClient<TInput> = {
+    session?: {
+        status?: () => Promise<unknown>;
+        messages?: (input: {
+            path: {
+                id: string;
+            };
+            query: PromptMessagesQuery;
+        }) => Promise<unknown>;
+        prompt?: (input: TInput) => Promise<unknown>;
+    };
+};
+export type InternalPromptDispatchMode = "async" | "sync";
+type InternalPromptDispatchCommonArgs<TInput> = {
+    sessionID: string;
+    input: TInput;
+    source: string;
+    settleMs?: number;
+    postDispatchHoldMs?: number;
+    dispatchTimeoutMs?: number;
+    checkStatus?: boolean;
+    checkToolState?: boolean;
+};
+export type InternalPromptDispatchArgs<TInput = PromptAsyncInput> = InternalPromptDispatchCommonArgs<TInput> & ({
+    mode: "async";
+    client: PromptAsyncClient<TInput>;
+} | {
+    mode: "sync";
+    client: PromptClient<TInput>;
+});
+export type InternalPromptDispatchResult = {
+    status: "dispatched";
+    response: unknown;
+} | {
+    status: "active";
+} | {
+    status: "reserved";
+    reservedBy: string;
+} | {
+    status: "unavailable";
+} | {
+    status: "failed";
+    error: unknown;
+};
+export type PromptAsyncGateResult = InternalPromptDispatchResult;
+type PromptAsyncReservationReleaseOptions = {
+    reservedBy?: string | readonly string[];
+    reservedByPrefix?: string | readonly string[];
+};
+export declare function _setPromptGateMessagesFetchTimeoutMsForTesting(value: number | undefined): void;
+export declare function dispatchInternalPrompt<TInput = PromptAsyncInput>(args: InternalPromptDispatchArgs<TInput>): Promise<InternalPromptDispatchResult>;
+export declare function releaseAllPromptAsyncReservationsForTesting(): void;
+export declare function releasePromptAsyncReservation(sessionID: string, source: string, options?: PromptAsyncReservationReleaseOptions): boolean;
+export {};

package/dist/shared/replace-tool-args.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Safely replace tool arguments without mutating frozen objects.
+ *
+ * opencode >=1.14 may freeze `output.args` via Immer before plugin hooks run.
+ * Direct property assignment (`output.args.key = value`) or `Object.assign(output.args, patch)`
+ * throws `TypeError: Attempted to assign to readonly property` on a frozen object.
+ *
+ * This helper replaces `output.args` with a shallow clone containing the patch,
+ * which works regardless of whether the original args object is frozen.
+ */
+export declare function replaceToolArgs(output: {
+    args: Record<string, unknown>;
+}, patch: Record<string, unknown>): void;

package/dist/shared/session-idle-settle.d.ts

@@ -0,0 +1,11 @@
+export declare const DEFAULT_SESSION_IDLE_SETTLE_MS = 150;
+export declare function settleAfterSessionIdle(ms?: number): Promise<void>;
+type SessionStatusClient = {
+    session?: {
+        status?: () => Promise<unknown>;
+    };
+};
+export declare function isActiveSessionStatusType(statusType: string): boolean;
+export declare function isSessionActive(client: SessionStatusClient, sessionID: string): Promise<boolean>;
+export declare function shouldPromptAfterSessionIdle(client: SessionStatusClient, sessionID: string, settleMs?: number): Promise<boolean>;
+export {};

package/dist/shared/tmux/tmux-utils/pane-activate.d.ts

@@ -0,0 +1 @@
+export declare function activateTmuxPane(paneId: string, sessionId: string, serverUrl: string, directory: string): Promise<boolean>;

package/dist/shared/tmux/tmux-utils/pane-close.d.ts

@@ -1 +1,11 @@
+import type { TmuxCommandResult } from "../runner";
+type CloseTmuxPaneDependencies = {
+    readonly isInsideTmux: () => boolean;
+    readonly getTmuxPath: () => Promise<string | null | undefined>;
+    readonly runTmuxCommand: (tmuxPath: string, args: string[]) => Promise<TmuxCommandResult>;
+    readonly log: (message: string, data?: unknown) => void;
+    readonly delay: (milliseconds: number) => Promise<void>;
+};
 export declare function closeTmuxPane(paneId: string): Promise<boolean>;
+export declare function closeTmuxPaneWithDependencies(paneId: string, dependencies: CloseTmuxPaneDependencies): Promise<boolean>;
+export {};

package/dist/shared/tmux/tmux-utils/pane-command.d.ts

@@ -0,0 +1,2 @@
+export declare function buildTmuxAttachCommand(serverUrl: string, sessionId: string, directory?: string): string;
+export declare function buildTmuxPlaceholderCommand(description: string): string;

package/dist/shared/tmux/tmux-utils/pane-replace.d.ts

@@ -1,3 +1,13 @@
 import type { TmuxConfig } from "../../../config/schema";
+import { getTmuxPath } from "../../../tools/interactive-bash/tmux-path-resolver";
 import type { SpawnPaneResult } from "../types";
-export declare function replaceTmuxPane(paneId: string, sessionId: string, description: string, config: TmuxConfig, serverUrl: string, directory: string): Promise<SpawnPaneResult>;
+import type { runTmuxCommand as RunTmuxCommand } from "../runner";
+import { isInsideTmux } from "./environment";
+type ReplaceTmuxPaneDeps = {
+    log: (message: string, data?: unknown) => void;
+    runTmuxCommand: typeof RunTmuxCommand;
+    isInsideTmux: typeof isInsideTmux;
+    getTmuxPath: typeof getTmuxPath;
+};
+export declare function replaceTmuxPane(paneId: string, sessionId: string, description: string, config: TmuxConfig, _serverUrl: string, _directory: string, depsInput?: Partial<ReplaceTmuxPaneDeps>): Promise<SpawnPaneResult>;
+export {};

package/dist/shared/tmux/tmux-utils/pane-spawn.d.ts

@@ -12,5 +12,5 @@ type SpawnTmuxPaneDeps = {
     isServerRunning: typeof isServerRunning;
     getTmuxPath: typeof getTmuxPath;
 };
-export declare function spawnTmuxPane(sessionId: string, description: string, config: TmuxConfig, serverUrl: string, directory: string, targetPaneId?: string, splitDirection?: SplitDirection, depsInput?: Partial<SpawnTmuxPaneDeps>): Promise<SpawnPaneResult>;
+export declare function spawnTmuxPane(sessionId: string, description: string, config: TmuxConfig, serverUrl: string, _directory: string, targetPaneId?: string, splitDirection?: SplitDirection, depsInput?: Partial<SpawnTmuxPaneDeps>): Promise<SpawnPaneResult>;
 export {};

package/dist/shared/tmux/tmux-utils/server-health.d.ts

@@ -1,3 +1,14 @@
+export type ServerHealthState = {
+    serverAvailable: boolean | null;
+    serverCheckUrl: string | null;
+    serverRunningInProcess: boolean;
+};
+type IsServerRunningOptions = {
+    fetchImplementation?: typeof fetch;
+    state?: ServerHealthState;
+};
 export declare function markServerRunningInProcess(): void;
-export declare function isServerRunning(serverUrl: string): Promise<boolean>;
+export declare function createServerHealthStateForTesting(): ServerHealthState;
+export declare function isServerRunning(serverUrl: string, options?: IsServerRunningOptions): Promise<boolean>;
 export declare function resetServerCheck(): void;
+export {};

package/dist/shared/tmux/tmux-utils/session-spawn.d.ts

@@ -11,6 +11,6 @@ type SpawnTmuxSessionDeps = {
     isServerRunning: typeof isServerRunning;
     getTmuxPath: typeof getTmuxPath;
 };
-export declare function getIsolatedSessionName(pid?: number): string;
-export declare function spawnTmuxSession(sessionId: string, description: string, config: TmuxConfig, serverUrl: string, directory: string, sourcePaneId?: string, depsInput?: Partial<SpawnTmuxSessionDeps>): Promise<SpawnPaneResult>;
+export declare function getIsolatedSessionName(pid?: number, managerId?: string): string;
+export declare function spawnTmuxSession(sessionId: string, description: string, config: TmuxConfig, serverUrl: string, _directory: string, sourcePaneId?: string, depsInput?: Partial<SpawnTmuxSessionDeps>, managerId?: string): Promise<SpawnPaneResult>;
 export {};

package/dist/shared/tmux/tmux-utils/window-spawn.d.ts

@@ -11,5 +11,5 @@ type SpawnTmuxWindowDeps = {
     isServerRunning: typeof isServerRunning;
     getTmuxPath: typeof getTmuxPath;
 };
-export declare function spawnTmuxWindow(sessionId: string, description: string, config: TmuxConfig, serverUrl: string, directory: string, depsInput?: Partial<SpawnTmuxWindowDeps>): Promise<SpawnPaneResult>;
+export declare function spawnTmuxWindow(sessionId: string, description: string, config: TmuxConfig, serverUrl: string, _directory: string, depsInput?: Partial<SpawnTmuxWindowDeps>): Promise<SpawnPaneResult>;
 export {};

package/dist/shared/tmux/tmux-utils.d.ts

@@ -6,8 +6,10 @@ export type { PaneDimensions } from "./tmux-utils/pane-dimensions";
 export { spawnTmuxPane } from "./tmux-utils/pane-spawn";
 export { closeTmuxPane } from "./tmux-utils/pane-close";
 export { replaceTmuxPane } from "./tmux-utils/pane-replace";
+export { activateTmuxPane } from "./tmux-utils/pane-activate";
 export { spawnTmuxWindow } from "./tmux-utils/window-spawn";
 export { spawnTmuxSession, getIsolatedSessionName } from "./tmux-utils/session-spawn";
 export { killTmuxSessionIfExists } from "./tmux-utils/session-kill";
 export { sweepStaleOmoAgentSessions, sweepTmuxSessionsWith } from "./tmux-utils/stale-session-sweep";
+export { buildTmuxAttachCommand, buildTmuxPlaceholderCommand } from "./tmux-utils/pane-command";
 export { applyLayout, enforceMainPaneWidth } from "./tmux-utils/layout";

package/dist/testing/create-plugin-module.d.ts

@@ -0,0 +1,41 @@
+import type { PluginModule } from "@opencode-ai/plugin";
+import { initConfigContext } from "../shared/config-context";
+import { createHooks } from "../create-hooks";
+import { createManagers } from "../create-managers";
+import { createRuntimeTmuxConfig, isTmuxIntegrationEnabled } from "../create-runtime-tmux-config";
+import { createTools } from "../create-tools";
+import { initializeOpenClaw } from "../openclaw";
+import { createPluginInterface } from "../plugin-interface";
+import { loadPluginConfig } from "../plugin-config";
+import { createModelCacheState } from "../plugin-state";
+import { installAgentSortShim, setAgentSortOrder } from "../shared/agent-sort-shim";
+import { detectExternalSkillPlugin, getSkillPluginConflictWarning } from "../shared/external-plugin-detector";
+import { createFirstMessageVariantGate } from "../shared/first-message-variant";
+import { log } from "../shared/logger";
+import { logLegacyPluginStartupWarning } from "../shared/log-legacy-plugin-startup-warning";
+import { migrateLegacyWorkspaceDirectory } from "../shared/legacy-workspace-migration";
+import { injectServerAuthIntoClient } from "../shared/opencode-server-auth";
+import { startBackgroundCheck as startTmuxCheck } from "../tools/interactive-bash";
+export type PluginModuleDeps = {
+    initConfigContext: typeof initConfigContext;
+    installAgentSortShim: typeof installAgentSortShim;
+    setAgentSortOrder: typeof setAgentSortOrder;
+    log: typeof log;
+    logLegacyPluginStartupWarning: typeof logLegacyPluginStartupWarning;
+    migrateLegacyWorkspaceDirectory: typeof migrateLegacyWorkspaceDirectory;
+    detectExternalSkillPlugin: typeof detectExternalSkillPlugin;
+    getSkillPluginConflictWarning: typeof getSkillPluginConflictWarning;
+    injectServerAuthIntoClient: typeof injectServerAuthIntoClient;
+    loadPluginConfig: typeof loadPluginConfig;
+    initializeOpenClaw: typeof initializeOpenClaw;
+    isTmuxIntegrationEnabled: typeof isTmuxIntegrationEnabled;
+    startTmuxCheck: typeof startTmuxCheck;
+    createFirstMessageVariantGate: typeof createFirstMessageVariantGate;
+    createRuntimeTmuxConfig: typeof createRuntimeTmuxConfig;
+    createModelCacheState: typeof createModelCacheState;
+    createManagers: typeof createManagers;
+    createTools: typeof createTools;
+    createHooks: typeof createHooks;
+    createPluginInterface: typeof createPluginInterface;
+};
+export declare function createPluginModule(overrides?: Partial<PluginModuleDeps>): PluginModule;

package/dist/tools/background-task/constants.d.ts

@@ -1,3 +1,3 @@
-export declare const BACKGROUND_TASK_DESCRIPTION = "Run agent task in background. Returns task_id immediately; notifies on completion.\n\nUse `background_output` to get results. Prompts MUST be in English.";
+export declare const BACKGROUND_TASK_DESCRIPTION = "Run agent task in background. Returns a background task ID (`bg_...`) immediately; notifies on completion.\n\nUse `background_output` to get results. Prompts MUST be in English.";
 export declare const BACKGROUND_OUTPUT_DESCRIPTION = "Get output from background task. Use full_session=true to fetch session messages with filters. System notifies on completion, so block=true rarely needed. - Timeout values are in milliseconds (ms), NOT seconds.\n\nIMPORTANT: ONLY call this tool AFTER receiving a <system-reminder> notification for the task. Do NOT call immediately after launching a background task - wait for the notification first.";
 export declare const BACKGROUND_CANCEL_DESCRIPTION = "Cancel running background task(s). Use all=true to cancel ALL before final answer.";

package/dist/tools/background-task/with-sdk-call-timeout.d.ts

@@ -0,0 +1,7 @@
+export declare const DEFAULT_BACKGROUND_OUTPUT_FETCH_TIMEOUT_MS = 5000;
+export declare function _setBackgroundOutputFetchTimeoutMsForTesting(value: number | undefined): void;
+export declare function getBackgroundOutputFetchTimeoutMs(): number;
+export declare class BackgroundOutputFetchTimeoutError extends Error {
+    constructor(timeoutMs: number);
+}
+export declare function withSdkCallTimeout<T>(operation: Promise<T>, timeoutMs: number): Promise<T>;

package/dist/tools/call-omo-agent/session-creator.d.ts

@@ -1,5 +1,6 @@
 import type { CallOmoAgentArgs } from "./types";
 import type { PluginInput } from "@opencode-ai/plugin";
+import type { DelegatedModelConfig } from "../../shared/model-resolution-types";
 export declare function createOrGetSession(args: CallOmoAgentArgs, toolContext: {
     sessionID: string;
     messageID: string;
@@ -9,7 +10,7 @@ export declare function createOrGetSession(args: CallOmoAgentArgs, toolContext:
         title?: string;
         metadata?: Record<string, unknown>;
     }) => void;
-}, ctx: PluginInput): Promise<{
+}, ctx: PluginInput, model?: DelegatedModelConfig): Promise<{
     sessionID: string;
     isNew: boolean;
 }>;

package/dist/tools/call-omo-agent/sync-executor.d.ts

@@ -1,10 +1,10 @@
-import type { CallOmoAgentArgs } from "./types";
 import type { PluginInput } from "@opencode-ai/plugin";
-import type { DelegatedModelConfig } from "../../shared/model-resolution-types";
 import type { FallbackEntry } from "../../shared/model-requirements";
+import type { DelegatedModelConfig } from "../../shared/model-resolution-types";
 import { waitForCompletion } from "./completion-poller";
 import { processMessages } from "./message-processor";
 import { createOrGetSession } from "./session-creator";
+import type { CallOmoAgentArgs } from "./types";
 type ExecuteSyncDeps = {
     createOrGetSession: typeof createOrGetSession;
     waitForCompletion: typeof waitForCompletion;

package/dist/tools/delegate-task/subagent-discovery.d.ts

@@ -2,6 +2,7 @@ export type AgentMode = "subagent" | "primary" | "all" | undefined;
 export type AgentInfo = {
     name: string;
     mode?: "subagent" | "primary" | "all";
+    hidden?: boolean;
     model?: string | {
         providerID: string;
         modelID: string;
@@ -10,6 +11,7 @@ export type AgentInfo = {
 export declare function sanitizeSubagentType(subagentType: string): string;
 export declare function mergeWithClaudeCodeAgents(serverAgents: AgentInfo[], directory: string | undefined): AgentInfo[];
 export declare function isTaskCallableAgentMode(mode: AgentMode): boolean;
+export declare function isDemotedPlanAgent(agent: AgentInfo): boolean;
 export declare function findPrimaryAgentMatch(agents: AgentInfo[], requestedAgentName: string): AgentInfo | undefined;
 export declare function findCallableAgentMatch(agents: AgentInfo[], requestedAgentName: string): AgentInfo | undefined;
 export declare function listCallableAgentNames(agents: AgentInfo[]): string;

package/dist/tools/delegate-task/sync-prompt-sender.d.ts

@@ -1,10 +1,11 @@
-import type { DelegateTaskArgs, OpencodeClient, DelegatedModelConfig } from "./types";
 import type { SisyphusAgentConfig } from "../../config/schema";
 import { promptSyncWithModelSuggestionRetry, promptWithModelSuggestionRetry } from "../../shared/model-suggestion-retry";
+import type { DelegatedModelConfig, DelegateTaskArgs, OpencodeClient } from "./types";
 type SendSyncPromptDeps = {
     promptWithModelSuggestionRetry: typeof promptWithModelSuggestionRetry;
     promptSyncWithModelSuggestionRetry: typeof promptSyncWithModelSuggestionRetry;
 };
+export declare function buildSyncPromptTools(agentToUse: string): Record<string, boolean>;
 export declare function sendSyncPrompt(client: OpencodeClient, input: {
     sessionID: string;
     agentToUse: string;

package/dist/tools/delegate-task/sync-session-creator.d.ts

@@ -1,9 +1,11 @@
 import type { OpencodeClient } from "./types";
+import type { DelegatedModelConfig } from "../../shared/model-resolution-types";
 export declare function createSyncSession(client: OpencodeClient, input: {
     parentSessionID: string;
     agentToUse: string;
     description: string;
     defaultDirectory: string;
+    categoryModel?: DelegatedModelConfig;
 }): Promise<{
     ok: true;
     sessionID: string;

package/dist/tools/delegate-task/sync-task.d.ts

@@ -1,5 +1,5 @@
 import type { ModelFallbackInfo } from "../../features/task-toast-manager/types";
-import type { DelegateTaskArgs, ToolContextWithMetadata, DelegatedModelConfig } from "./types";
 import type { ExecutorContext, ParentContext } from "./executor-types";
 import { type SyncTaskDeps } from "./sync-task-deps";
+import type { DelegatedModelConfig, DelegateTaskArgs, ToolContextWithMetadata } from "./types";
 export declare function executeSyncTask(args: DelegateTaskArgs, ctx: ToolContextWithMetadata, executorCtx: ExecutorContext, parentContext: ParentContext, agentToUse: string, categoryModel: DelegatedModelConfig | undefined, systemContent: string | undefined, modelInfo?: ModelFallbackInfo, fallbackChain?: import("../../shared/model-requirements").FallbackEntry[], deps?: SyncTaskDeps): Promise<string>;

package/dist/tools/index.d.ts

@@ -1,5 +1,3 @@
-import { lspManager } from "./lsp";
-export { lspManager };
 export { createAstGrepTools } from "./ast-grep";
 export { createGrepTools } from "./grep";
 export { createGlobTools } from "./glob";
@@ -19,4 +17,3 @@ export { createTaskCreateTool, createTaskGetTool, createTaskList, createTaskUpda
 export { createHashlineEditTool } from "./hashline-edit";
 export { createTeamSendMessageTool } from "../features/team-mode/tools/messaging";
 export declare function createBackgroundTools(manager: BackgroundManager, client: OpencodeClient): Record<string, ToolDefinition>;
-export declare const builtinTools: Record<string, ToolDefinition>;

package/dist/tools/interactive-bash/tools.d.ts

@@ -4,4 +4,9 @@ import { type ToolDefinition } from "@opencode-ai/plugin/tool";
  * Handles single/double quotes and backslash escapes without external dependencies
  */
 export declare function tokenizeCommand(cmd: string): string[];
+type InteractiveBashArgs = {
+    tmux_command: string;
+};
+export declare function executeInteractiveBash(args: InteractiveBashArgs): Promise<string>;
 export declare const interactive_bash: ToolDefinition;
+export {};