@bohuyeshan/openagent-labforge-core 3.11.0

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

@@ -0,0 +1,29 @@
+import type { OAuthTokenData } from "./storage";
+import type { OAuthServerMetadata } from "./discovery";
+import type { ClientCredentials } from "./dcr";
+import { buildAuthorizationUrl, generateCodeChallenge, generateCodeVerifier, startCallbackServer } from "./oauth-authorization-flow";
+export type McpOAuthProviderOptions = {
+    serverUrl: string;
+    clientId?: string;
+    scopes?: string[];
+};
+export declare class McpOAuthProvider {
+    private readonly serverUrl;
+    private readonly configClientId;
+    private readonly scopes;
+    private storedCodeVerifier;
+    private storedClientInfo;
+    private callbackPort;
+    constructor(options: McpOAuthProviderOptions);
+    tokens(): OAuthTokenData | null;
+    saveTokens(tokenData: OAuthTokenData): boolean;
+    clientInformation(): ClientCredentials | null;
+    redirectUrl(): string;
+    saveCodeVerifier(verifier: string): void;
+    codeVerifier(): string | null;
+    redirectToAuthorization(metadata: OAuthServerMetadata): Promise<{
+        code: string;
+    }>;
+    login(): Promise<OAuthTokenData>;
+}
+export { generateCodeVerifier, generateCodeChallenge, buildAuthorizationUrl, startCallbackServer };

package/dist/features/mcp-oauth/resource-indicator.d.ts

@@ -0,0 +1,2 @@
+export declare function getResourceIndicator(url: string): string;
+export declare function addResourceToParams(params: URLSearchParams, resource: string): void;

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

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export declare const McpOauthSchema: z.ZodObject<{
+    clientId: z.ZodOptional<z.ZodString>;
+    scopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type McpOauth = z.infer<typeof McpOauthSchema>;

package/dist/features/mcp-oauth/step-up.d.ts

@@ -0,0 +1,8 @@
+export interface StepUpInfo {
+    requiredScopes: string[];
+    error?: string;
+    errorDescription?: string;
+}
+export declare function parseWwwAuthenticate(header: string): StepUpInfo | null;
+export declare function mergeScopes(existing: string[], required: string[]): string[];
+export declare function isStepUpRequired(statusCode: number, headers: Record<string, string>): StepUpInfo | null;

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

@@ -0,0 +1,17 @@
+export interface OAuthTokenData {
+    accessToken: string;
+    refreshToken?: string;
+    expiresAt?: number;
+    clientInfo?: {
+        clientId: string;
+        clientSecret?: string;
+    };
+}
+type TokenStore = Record<string, OAuthTokenData>;
+export declare function getMcpOauthStoragePath(): string;
+export declare function loadToken(serverHost: string, resource: string): OAuthTokenData | null;
+export declare function saveToken(serverHost: string, resource: string, token: OAuthTokenData): boolean;
+export declare function deleteToken(serverHost: string, resource: string): boolean;
+export declare function listTokensByHost(serverHost: string): TokenStore;
+export declare function listAllTokens(): TokenStore;
+export {};

package/dist/features/model-governor/index.d.ts

@@ -0,0 +1 @@
+export * from "./model-governor";

package/dist/features/model-governor/model-governor.d.ts

@@ -0,0 +1,2 @@
+import type { OhMyOpenCodeConfig } from "../../config";
+export declare function applyModelGovernor(pluginConfig: OhMyOpenCodeConfig): void;

package/dist/features/opencode-skill-loader/allowed-tools-parser.d.ts

@@ -0,0 +1 @@
+export declare function parseAllowedTools(allowedTools: string | string[] | undefined): string[] | undefined;

package/dist/features/opencode-skill-loader/async-loader.d.ts

@@ -0,0 +1,6 @@
+import type { SkillScope, LoadedSkill } from "./types";
+import type { SkillMcpConfig } from "../skill-mcp-manager/types";
+export declare function mapWithConcurrency<T, R>(items: T[], mapper: (item: T) => Promise<R>, concurrency: number): Promise<R[]>;
+export declare function loadMcpJsonFromDirAsync(skillDir: string): Promise<SkillMcpConfig | undefined>;
+export declare function loadSkillFromPathAsync(skillPath: string, resolvedPath: string, defaultName: string, scope: SkillScope): Promise<LoadedSkill | null>;
+export declare function discoverSkillsInDirAsync(skillsDir: string): Promise<LoadedSkill[]>;

package/dist/features/opencode-skill-loader/blocking.d.ts

@@ -0,0 +1,2 @@
+import type { LoadedSkill, SkillScope } from "./types";
+export declare function discoverAllSkillsBlocking(dirs: string[], scopes: SkillScope[]): LoadedSkill[];

package/dist/features/opencode-skill-loader/config-source-discovery.d.ts

@@ -0,0 +1,7 @@
+import type { SkillsConfig } from "../../config/schema";
+import type { LoadedSkill } from "./types";
+export declare function normalizePathForGlob(path: string): string;
+export declare function discoverConfigSourceSkills(options: {
+    config: SkillsConfig | undefined;
+    configDir: string;
+}): Promise<LoadedSkill[]>;

package/dist/features/opencode-skill-loader/discover-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/features/opencode-skill-loader/git-master-template-injection.d.ts

@@ -0,0 +1,2 @@
+import type { GitMasterConfig } from "../../config/schema";
+export declare function injectGitMasterConfig(template: string, config?: GitMasterConfig): string;

package/dist/features/opencode-skill-loader/index.d.ts

@@ -0,0 +1,15 @@
+export * from "./types";
+export * from "./loader";
+export * from "./merger";
+export * from "./skill-content";
+export * from "./skill-directory-loader";
+export * from "./loaded-skill-from-path";
+export * from "./skill-mcp-config";
+export * from "./skill-deduplication";
+export * from "./skill-definition-record";
+export * from "./git-master-template-injection";
+export * from "./skill-discovery";
+export * from "./skill-resolution-options";
+export * from "./loaded-skill-template-extractor";
+export * from "./skill-template-resolver";
+export * from "./config-source-discovery";

package/dist/features/opencode-skill-loader/loaded-skill-from-path.d.ts

@@ -0,0 +1,9 @@
+import type { SkillScope, LoadedSkill } from "./types";
+export declare function loadSkillFromPath(options: {
+    skillPath: string;
+    resolvedPath: string;
+    defaultName: string;
+    scope: SkillScope;
+    namePrefix?: string;
+}): Promise<LoadedSkill | null>;
+export declare function inferSkillNameFromFileName(filePath: string): string;

package/dist/features/opencode-skill-loader/loaded-skill-template-extractor.d.ts

@@ -0,0 +1,2 @@
+import type { LoadedSkill } from "./types";
+export declare function extractSkillTemplate(skill: LoadedSkill): string;

package/dist/features/opencode-skill-loader/loader.d.ts

@@ -0,0 +1,19 @@
+import type { CommandDefinition } from "../claude-code-command-loader/types";
+import type { LoadedSkill } from "./types";
+export declare function loadUserSkills(): Promise<Record<string, CommandDefinition>>;
+export declare function loadProjectSkills(directory?: string): Promise<Record<string, CommandDefinition>>;
+export declare function loadOpencodeGlobalSkills(): Promise<Record<string, CommandDefinition>>;
+export declare function loadOpencodeProjectSkills(directory?: string): Promise<Record<string, CommandDefinition>>;
+export interface DiscoverSkillsOptions {
+    includeClaudeCodePaths?: boolean;
+    directory?: string;
+}
+export declare function discoverAllSkills(directory?: string): Promise<LoadedSkill[]>;
+export declare function discoverSkills(options?: DiscoverSkillsOptions): Promise<LoadedSkill[]>;
+export declare function getSkillByName(name: string, options?: DiscoverSkillsOptions): Promise<LoadedSkill | undefined>;
+export declare function discoverUserClaudeSkills(): Promise<LoadedSkill[]>;
+export declare function discoverProjectClaudeSkills(directory?: string): Promise<LoadedSkill[]>;
+export declare function discoverOpencodeGlobalSkills(): Promise<LoadedSkill[]>;
+export declare function discoverOpencodeProjectSkills(directory?: string): Promise<LoadedSkill[]>;
+export declare function discoverProjectAgentsSkills(directory?: string): Promise<LoadedSkill[]>;
+export declare function discoverGlobalAgentsSkills(): Promise<LoadedSkill[]>;

package/dist/features/opencode-skill-loader/merger/builtin-skill-converter.d.ts

@@ -0,0 +1,3 @@
+import type { BuiltinSkill } from "../../builtin-skills/types";
+import type { LoadedSkill } from "../types";
+export declare function builtinToLoadedSkill(builtin: BuiltinSkill): LoadedSkill;

package/dist/features/opencode-skill-loader/merger/config-skill-entry-loader.d.ts

@@ -0,0 +1,3 @@
+import type { LoadedSkill } from "../types";
+import type { SkillDefinition } from "../../../config/schema";
+export declare function configEntryToLoadedSkill(name: string, entry: SkillDefinition, configDir?: string): LoadedSkill | null;

package/dist/features/opencode-skill-loader/merger/scope-priority.d.ts

@@ -0,0 +1,2 @@
+import type { SkillScope } from "../types";
+export declare const SCOPE_PRIORITY: Record<SkillScope, number>;

package/dist/features/opencode-skill-loader/merger/skill-definition-merger.d.ts

@@ -0,0 +1,3 @@
+import type { LoadedSkill } from "../types";
+import type { SkillDefinition } from "../../../config/schema";
+export declare function mergeSkillDefinitions(base: LoadedSkill, patch: SkillDefinition): LoadedSkill;

package/dist/features/opencode-skill-loader/merger/skills-config-normalizer.d.ts

@@ -0,0 +1,12 @@
+import type { SkillsConfig, SkillDefinition } from "../../../config/schema";
+export declare function normalizeSkillsConfig(config: SkillsConfig | undefined): {
+    bundle?: "full" | "paper";
+    sources: Array<string | {
+        path: string;
+        recursive?: boolean;
+        glob?: string;
+    }>;
+    enable: string[];
+    disable: string[];
+    entries: Record<string, boolean | SkillDefinition>;
+};

package/dist/features/opencode-skill-loader/merger.d.ts

@@ -0,0 +1,7 @@
+import type { LoadedSkill } from "./types";
+import type { SkillsConfig } from "../../config/schema";
+import type { BuiltinSkill } from "../builtin-skills/types";
+export interface MergeSkillsOptions {
+    configDir?: string;
+}
+export declare function mergeSkills(builtinSkills: BuiltinSkill[], config: SkillsConfig | undefined, configSourceSkills: LoadedSkill[], userClaudeSkills: LoadedSkill[], userOpencodeSkills: LoadedSkill[], projectClaudeSkills: LoadedSkill[], projectOpencodeSkills: LoadedSkill[], options?: MergeSkillsOptions): LoadedSkill[];

package/dist/features/opencode-skill-loader/skill-content.d.ts

@@ -0,0 +1,5 @@
+export type { SkillResolutionOptions } from "./skill-resolution-options";
+export { clearSkillCache, getAllSkills } from "./skill-discovery";
+export { extractSkillTemplate } from "./loaded-skill-template-extractor";
+export { injectGitMasterConfig } from "./git-master-template-injection";
+export { resolveSkillContent, resolveMultipleSkills, resolveSkillContentAsync, resolveMultipleSkillsAsync, } from "./skill-template-resolver";

package/dist/features/opencode-skill-loader/skill-deduplication.d.ts

@@ -0,0 +1,2 @@
+import type { LoadedSkill } from "./types";
+export declare function deduplicateSkillsByName(skills: LoadedSkill[]): LoadedSkill[];

package/dist/features/opencode-skill-loader/skill-definition-record.d.ts

@@ -0,0 +1,3 @@
+import type { CommandDefinition } from "../claude-code-command-loader/types";
+import type { LoadedSkill } from "./types";
+export declare function skillsToCommandDefinitionRecord(skills: LoadedSkill[]): Record<string, CommandDefinition>;

package/dist/features/opencode-skill-loader/skill-directory-loader.d.ts

@@ -0,0 +1,8 @@
+import type { LoadedSkill, SkillScope } from "./types";
+export declare function loadSkillsFromDir(options: {
+    skillsDir: string;
+    scope: SkillScope;
+    namePrefix?: string;
+    depth?: number;
+    maxDepth?: number;
+}): Promise<LoadedSkill[]>;

package/dist/features/opencode-skill-loader/skill-discovery.d.ts

@@ -0,0 +1,4 @@
+import type { LoadedSkill } from "./types";
+import type { SkillResolutionOptions } from "./skill-resolution-options";
+export declare function clearSkillCache(): void;
+export declare function getAllSkills(options?: SkillResolutionOptions): Promise<LoadedSkill[]>;

package/dist/features/opencode-skill-loader/skill-mcp-config.d.ts

@@ -0,0 +1,3 @@
+import type { SkillMcpConfig } from "../skill-mcp-manager/types";
+export declare function parseSkillMcpConfigFromFrontmatter(content: string): SkillMcpConfig | undefined;
+export declare function loadMcpJsonFromDir(skillDir: string): Promise<SkillMcpConfig | undefined>;

package/dist/features/opencode-skill-loader/skill-resolution-options.d.ts

@@ -0,0 +1,8 @@
+import type { BrowserAutomationProvider, GitMasterConfig } from "../../config/schema";
+export interface SkillResolutionOptions {
+    gitMasterConfig?: GitMasterConfig;
+    browserProvider?: BrowserAutomationProvider;
+    disabledSkills?: Set<string>;
+    /** Project directory to discover project-level skills from. Falls back to process.cwd() if not provided. */
+    directory?: string;
+}

package/dist/features/opencode-skill-loader/skill-template-resolver.d.ts

@@ -0,0 +1,11 @@
+import type { SkillResolutionOptions } from "./skill-resolution-options";
+export declare function resolveSkillContent(skillName: string, options?: SkillResolutionOptions): string | null;
+export declare function resolveMultipleSkills(skillNames: string[], options?: SkillResolutionOptions): {
+    resolved: Map<string, string>;
+    notFound: string[];
+};
+export declare function resolveSkillContentAsync(skillName: string, options?: SkillResolutionOptions): Promise<string | null>;
+export declare function resolveMultipleSkillsAsync(skillNames: string[], options?: SkillResolutionOptions): Promise<{
+    resolved: Map<string, string>;
+    notFound: string[];
+}>;

package/dist/features/opencode-skill-loader/types.d.ts

@@ -0,0 +1,35 @@
+import type { CommandDefinition } from "../claude-code-command-loader/types";
+import type { SkillMcpConfig } from "../skill-mcp-manager/types";
+export type SkillScope = "builtin" | "config" | "user" | "project" | "opencode" | "opencode-project";
+export interface SkillMetadata {
+    name?: string;
+    description?: string;
+    model?: string;
+    "argument-hint"?: string;
+    agent?: string;
+    subtask?: boolean;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+    "allowed-tools"?: string | string[];
+    mcp?: SkillMcpConfig;
+}
+export interface LazyContentLoader {
+    loaded: boolean;
+    content?: string;
+    load: () => Promise<string>;
+}
+export interface LoadedSkill {
+    name: string;
+    path?: string;
+    resolvedPath?: string;
+    definition: CommandDefinition;
+    scope: SkillScope;
+    license?: string;
+    compatibility?: string;
+    metadata?: Record<string, string>;
+    allowedTools?: string[];
+    mcpConfig?: SkillMcpConfig;
+    lazyContent?: LazyContentLoader;
+    previewCategory?: string;
+}

package/dist/features/run-continuation-state/constants.d.ts

@@ -0,0 +1 @@
+export declare const CONTINUATION_MARKER_DIR = ".sisyphus/run-continuation";

package/dist/features/run-continuation-state/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./constants";
+export * from "./storage";

package/dist/features/run-continuation-state/storage.d.ts

@@ -0,0 +1,6 @@
+import type { ContinuationMarker, ContinuationMarkerSource, ContinuationMarkerState } from "./types";
+export declare function readContinuationMarker(directory: string, sessionID: string): ContinuationMarker | null;
+export declare function setContinuationMarkerSource(directory: string, sessionID: string, source: ContinuationMarkerSource, state: ContinuationMarkerState, reason?: string): ContinuationMarker;
+export declare function clearContinuationMarker(directory: string, sessionID: string): void;
+export declare function isContinuationMarkerActive(marker: ContinuationMarker | null): boolean;
+export declare function getActiveContinuationMarkerReason(marker: ContinuationMarker | null): string | null;

package/dist/features/run-continuation-state/types.d.ts

@@ -0,0 +1,12 @@
+export type ContinuationMarkerSource = "todo" | "stop";
+export type ContinuationMarkerState = "idle" | "active" | "stopped";
+export interface ContinuationMarkerSourceEntry {
+    state: ContinuationMarkerState;
+    reason?: string;
+    updatedAt: string;
+}
+export interface ContinuationMarker {
+    sessionID: string;
+    updatedAt: string;
+    sources: Partial<Record<ContinuationMarkerSource, ContinuationMarkerSourceEntry>>;
+}

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

@@ -0,0 +1,8 @@
+import type { SkillMcpManagerState } from "./types";
+export declare function registerProcessCleanup(state: SkillMcpManagerState): void;
+export declare function unregisterProcessCleanup(state: SkillMcpManagerState): void;
+export declare function startCleanupTimer(state: SkillMcpManagerState): void;
+export declare function stopCleanupTimer(state: SkillMcpManagerState): void;
+export declare function disconnectSession(state: SkillMcpManagerState, sessionID: string): Promise<void>;
+export declare function disconnectAll(state: SkillMcpManagerState): Promise<void>;
+export declare function forceReconnect(state: SkillMcpManagerState, clientKey: string): Promise<boolean>;

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

@@ -0,0 +1,7 @@
+import type { ClaudeCodeMcpServer } from "../claude-code-mcp-loader/types";
+import type { ConnectionType } from "./types";
+/**
+ * Determines connection type from MCP server configuration.
+ * Priority: explicit type field > url presence > command presence
+ */
+export declare function getConnectionType(config: ClaudeCodeMcpServer): ConnectionType | null;

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

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

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

@@ -0,0 +1,2 @@
+export declare const EXCLUDED_ENV_PATTERNS: RegExp[];
+export declare function createCleanMcpEnvironment(customEnv?: Record<string, string>): Record<string, string>;

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

@@ -0,0 +1,3 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { SkillMcpClientConnectionParams } from "./types";
+export declare function createHttpClient(params: SkillMcpClientConnectionParams): Promise<Client>;

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

@@ -0,0 +1,2 @@
+export * from "./types";
+export { SkillMcpManager } from "./manager";

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

@@ -0,0 +1,21 @@
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { Prompt, Resource, Tool } from "@modelcontextprotocol/sdk/types.js";
+import type { ClaudeCodeMcpServer } from "../claude-code-mcp-loader/types";
+import type { SkillMcpClientInfo, SkillMcpServerContext } from "./types";
+export declare class SkillMcpManager {
+    private readonly state;
+    private getClientKey;
+    getOrCreateClient(info: SkillMcpClientInfo, config: ClaudeCodeMcpServer): Promise<Client>;
+    disconnectSession(sessionID: string): Promise<void>;
+    disconnectAll(): Promise<void>;
+    listTools(info: SkillMcpClientInfo, context: SkillMcpServerContext): Promise<Tool[]>;
+    listResources(info: SkillMcpClientInfo, context: SkillMcpServerContext): Promise<Resource[]>;
+    listPrompts(info: SkillMcpClientInfo, context: SkillMcpServerContext): Promise<Prompt[]>;
+    callTool(info: SkillMcpClientInfo, context: SkillMcpServerContext, name: string, args: Record<string, unknown>): Promise<unknown>;
+    readResource(info: SkillMcpClientInfo, context: SkillMcpServerContext, uri: string): Promise<unknown>;
+    getPrompt(info: SkillMcpClientInfo, context: SkillMcpServerContext, name: string, args: Record<string, string>): Promise<unknown>;
+    private withOperationRetry;
+    private getOrCreateClientWithRetry;
+    getConnectedServers(): string[];
+    isConnected(info: SkillMcpClientInfo): boolean;
+}

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

@@ -0,0 +1,9 @@
+import type { ClaudeCodeMcpServer } from "../claude-code-mcp-loader/types";
+import { McpOAuthProvider } from "../mcp-oauth/provider";
+export declare function getOrCreateAuthProvider(authProviders: Map<string, McpOAuthProvider>, serverUrl: string, oauth: NonNullable<ClaudeCodeMcpServer["oauth"]>): McpOAuthProvider;
+export declare function buildHttpRequestInit(config: ClaudeCodeMcpServer, authProviders: Map<string, McpOAuthProvider>): Promise<RequestInit | undefined>;
+export declare function handleStepUpIfNeeded(params: {
+    error: Error;
+    config: ClaudeCodeMcpServer;
+    authProviders: Map<string, McpOAuthProvider>;
+}): Promise<boolean>;

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

@@ -0,0 +1,3 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { SkillMcpClientConnectionParams } from "./types";
+export declare function createStdioClient(params: SkillMcpClientConnectionParams): Promise<Client>;

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

@@ -0,0 +1,55 @@
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import type { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import type { ClaudeCodeMcpServer } from "../claude-code-mcp-loader/types";
+import type { McpOAuthProvider } from "../mcp-oauth/provider";
+export type SkillMcpConfig = Record<string, ClaudeCodeMcpServer>;
+export interface SkillMcpClientInfo {
+    serverName: string;
+    skillName: string;
+    sessionID: string;
+}
+export interface SkillMcpServerContext {
+    config: ClaudeCodeMcpServer;
+    skillName: string;
+}
+/**
+ * Connection type for a managed MCP client.
+ * - "stdio": Local process via stdin/stdout
+ * - "http": Remote server via HTTP (Streamable HTTP transport)
+ */
+export type ConnectionType = "stdio" | "http";
+export interface ManagedClientBase {
+    client: Client;
+    skillName: string;
+    lastUsedAt: number;
+    connectionType: ConnectionType;
+}
+export interface ManagedStdioClient extends ManagedClientBase {
+    connectionType: "stdio";
+    transport: StdioClientTransport;
+}
+export interface ManagedHttpClient extends ManagedClientBase {
+    connectionType: "http";
+    transport: StreamableHTTPClientTransport;
+}
+export type ManagedClient = ManagedStdioClient | ManagedHttpClient;
+export interface ProcessCleanupHandler {
+    signal: NodeJS.Signals;
+    listener: () => void;
+}
+export interface SkillMcpManagerState {
+    clients: Map<string, ManagedClient>;
+    pendingConnections: Map<string, Promise<Client>>;
+    authProviders: Map<string, McpOAuthProvider>;
+    cleanupRegistered: boolean;
+    cleanupInterval: ReturnType<typeof setInterval> | null;
+    cleanupHandlers: ProcessCleanupHandler[];
+    idleTimeoutMs: number;
+}
+export interface SkillMcpClientConnectionParams {
+    state: SkillMcpManagerState;
+    clientKey: string;
+    info: SkillMcpClientInfo;
+    config: ClaudeCodeMcpServer;
+}

package/dist/features/task-toast-manager/index.d.ts

@@ -0,0 +1,2 @@
+export { TaskToastManager, getTaskToastManager, initTaskToastManager } from "./manager";
+export type { TrackedTask, TaskStatus, TaskToastOptions, ModelFallbackInfo } from "./types";

package/dist/features/task-toast-manager/manager.d.ts

@@ -0,0 +1,64 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { TrackedTask, TaskStatus, ModelFallbackInfo } from "./types";
+import type { ConcurrencyManager } from "../background-agent/concurrency";
+type OpencodeClient = PluginInput["client"];
+export declare class TaskToastManager {
+    private tasks;
+    private client;
+    private concurrencyManager?;
+    constructor(client: OpencodeClient, concurrencyManager?: ConcurrencyManager);
+    setConcurrencyManager(manager: ConcurrencyManager): void;
+    addTask(task: {
+        id: string;
+        sessionID?: string;
+        description: string;
+        agent: string;
+        isBackground: boolean;
+        status?: TaskStatus;
+        category?: string;
+        skills?: string[];
+        modelInfo?: ModelFallbackInfo;
+    }): void;
+    /**
+     * Update task status
+     */
+    updateTask(id: string, status: TaskStatus): void;
+    /**
+     * Update model info for a task by session ID
+     */
+    updateTaskModelBySession(sessionID: string, modelInfo: ModelFallbackInfo): void;
+    /**
+     * Remove completed/error task
+     */
+    removeTask(id: string): void;
+    /**
+     * Get all running tasks (newest first)
+     */
+    getRunningTasks(): TrackedTask[];
+    /**
+     * Get all queued tasks
+     */
+    getQueuedTasks(): TrackedTask[];
+    /**
+     * Format duration since task started
+     */
+    private formatDuration;
+    private getConcurrencyInfo;
+    private buildTaskListMessage;
+    /**
+     * Show consolidated toast with all running/queued tasks
+     */
+    private showTaskListToast;
+    /**
+     * Show task completion toast
+     */
+    showCompletionToast(task: {
+        id: string;
+        description: string;
+        duration: string;
+    }): void;
+}
+export declare function getTaskToastManager(): TaskToastManager | null;
+export declare function initTaskToastManager(client: OpencodeClient, concurrencyManager?: ConcurrencyManager): TaskToastManager;
+export declare function _resetTaskToastManagerForTesting(): void;
+export {};

package/dist/features/task-toast-manager/types.d.ts

@@ -0,0 +1,25 @@
+import type { ModelSource } from "../../shared/model-resolver";
+export type TaskStatus = "running" | "queued" | "completed" | "error";
+export interface ModelFallbackInfo {
+    model: string;
+    type: "user-defined" | "inherited" | "category-default" | "system-default" | "runtime-fallback";
+    source?: ModelSource;
+}
+export interface TrackedTask {
+    id: string;
+    sessionID?: string;
+    description: string;
+    agent: string;
+    status: TaskStatus;
+    startedAt: Date;
+    isBackground: boolean;
+    category?: string;
+    skills?: string[];
+    modelInfo?: ModelFallbackInfo;
+}
+export interface TaskToastOptions {
+    title: string;
+    message: string;
+    variant: "info" | "success" | "warning" | "error";
+    duration?: number;
+}

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

@@ -0,0 +1,20 @@
+import type { TmuxConfig } from "../../config/schema";
+import type { PaneAction, WindowState } from "./types";
+import type { ActionResult } from "./action-executor-core";
+export type { ActionExecutorDeps, ActionResult } from "./action-executor-core";
+export interface ExecuteActionsResult {
+    success: boolean;
+    spawnedPaneId?: string;
+    results: Array<{
+        action: PaneAction;
+        result: ActionResult;
+    }>;
+}
+export interface ExecuteContext {
+    config: TmuxConfig;
+    serverUrl: string;
+    windowState: WindowState;
+    sourcePaneId?: string;
+}
+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/cleanup.d.ts

@@ -0,0 +1,9 @@
+import type { TmuxConfig } from "../../config/schema";
+import type { TrackedSession } from "./types";
+export declare function cleanupTmuxSessions(params: {
+    tmuxConfig: TmuxConfig;
+    serverUrl: string;
+    sourcePaneId: string | undefined;
+    sessions: Map<string, TrackedSession>;
+    stopPolling: () => void;
+}): Promise<void>;