oh-my-parallel-agent-opencode 0.1.0 → 0.2.1

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

@@ -0,0 +1,41 @@
+import type { OAuthTokenData } from "./storage";
+import type { OAuthServerMetadata } from "./discovery";
+import type { ClientCredentials } from "./dcr";
+export type McpOAuthProviderOptions = {
+    serverUrl: string;
+    clientId?: string;
+    scopes?: string[];
+};
+type CallbackResult = {
+    code: string;
+    state: string;
+};
+declare function generateCodeVerifier(): string;
+declare function generateCodeChallenge(verifier: string): string;
+declare function buildAuthorizationUrl(authorizationEndpoint: string, options: {
+    clientId: string;
+    redirectUri: string;
+    codeChallenge: string;
+    state: string;
+    scopes?: string[];
+    resource?: string;
+}): string;
+declare function startCallbackServer(port: number): Promise<CallbackResult>;
+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<CallbackResult>;
+    login(): Promise<OAuthTokenData>;
+}
+export { generateCodeVerifier, generateCodeChallenge, buildAuthorizationUrl, startCallbackServer };

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

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

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/resource-indicator.test.d.ts

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

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/schema.test.d.ts

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

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/step-up.test.d.ts

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

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/mcp-oauth/storage.test.d.ts

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

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/async-loader.test.d.ts

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

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/blocking.test.d.ts

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

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

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

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

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./loader";
+export * from "./merger";
+export * from "./skill-content";

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

@@ -0,0 +1,16 @@
+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(): Promise<Record<string, CommandDefinition>>;
+export declare function loadOpencodeGlobalSkills(): Promise<Record<string, CommandDefinition>>;
+export declare function loadOpencodeProjectSkills(): Promise<Record<string, CommandDefinition>>;
+export interface DiscoverSkillsOptions {
+    includeClaudeCodePaths?: boolean;
+}
+export declare function discoverAllSkills(): 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(): Promise<LoadedSkill[]>;
+export declare function discoverOpencodeGlobalSkills(): Promise<LoadedSkill[]>;
+export declare function discoverOpencodeProjectSkills(): Promise<LoadedSkill[]>;

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

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

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, userClaudeSkills: LoadedSkill[], userOpencodeSkills: LoadedSkill[], projectClaudeSkills: LoadedSkill[], projectOpencodeSkills: LoadedSkill[], options?: MergeSkillsOptions): LoadedSkill[];

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

@@ -0,0 +1,21 @@
+import type { LoadedSkill } from "./types";
+import type { GitMasterConfig, BrowserAutomationProvider } from "../../config/schema";
+export interface SkillResolutionOptions {
+    gitMasterConfig?: GitMasterConfig;
+    browserProvider?: BrowserAutomationProvider;
+}
+declare function clearSkillCache(): void;
+declare function getAllSkills(options?: SkillResolutionOptions): Promise<LoadedSkill[]>;
+declare function extractSkillTemplate(skill: LoadedSkill): Promise<string>;
+export { clearSkillCache, getAllSkills, extractSkillTemplate };
+export declare function injectGitMasterConfig(template: string, config?: GitMasterConfig): string;
+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/skill-content.test.d.ts

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

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

@@ -0,0 +1,34 @@
+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;
+}

package/dist/features/sisyphus-swarm/mailbox/types.d.ts

@@ -0,0 +1,191 @@
+import { z } from "zod";
+export declare const MailboxMessageSchema: z.ZodObject<{
+    from: z.ZodString;
+    text: z.ZodString;
+    timestamp: z.ZodString;
+    color: z.ZodOptional<z.ZodString>;
+    read: z.ZodBoolean;
+}, z.core.$strip>;
+export type MailboxMessage = z.infer<typeof MailboxMessageSchema>;
+export declare const PermissionRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"permission_request">;
+    requestId: z.ZodString;
+    toolName: z.ZodString;
+    input: z.ZodUnknown;
+    agentId: z.ZodString;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export type PermissionRequest = z.infer<typeof PermissionRequestSchema>;
+export declare const PermissionResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"permission_response">;
+    requestId: z.ZodString;
+    decision: z.ZodEnum<{
+        rejected: "rejected";
+        approved: "approved";
+    }>;
+    updatedInput: z.ZodOptional<z.ZodUnknown>;
+    feedback: z.ZodOptional<z.ZodString>;
+    permissionUpdates: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>;
+export type PermissionResponse = z.infer<typeof PermissionResponseSchema>;
+export declare const ShutdownRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"shutdown_request">;
+}, z.core.$strip>;
+export type ShutdownRequest = z.infer<typeof ShutdownRequestSchema>;
+export declare const ShutdownApprovedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"shutdown_approved">;
+}, z.core.$strip>;
+export type ShutdownApproved = z.infer<typeof ShutdownApprovedSchema>;
+export declare const ShutdownRejectedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"shutdown_rejected">;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ShutdownRejected = z.infer<typeof ShutdownRejectedSchema>;
+export declare const TaskAssignmentSchema: z.ZodObject<{
+    type: z.ZodLiteral<"task_assignment">;
+    taskId: z.ZodString;
+    subject: z.ZodString;
+    description: z.ZodString;
+    assignedBy: z.ZodString;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export type TaskAssignment = z.infer<typeof TaskAssignmentSchema>;
+export declare const TaskCompletedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"task_completed">;
+    taskId: z.ZodString;
+    agentId: z.ZodString;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>;
+export type TaskCompleted = z.infer<typeof TaskCompletedSchema>;
+export declare const IdleNotificationSchema: z.ZodObject<{
+    type: z.ZodLiteral<"idle_notification">;
+}, z.core.$strip>;
+export type IdleNotification = z.infer<typeof IdleNotificationSchema>;
+export declare const JoinRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"join_request">;
+    agentName: z.ZodString;
+    sessionId: z.ZodString;
+}, z.core.$strip>;
+export type JoinRequest = z.infer<typeof JoinRequestSchema>;
+export declare const JoinApprovedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"join_approved">;
+    agentName: z.ZodString;
+    teamName: z.ZodString;
+}, z.core.$strip>;
+export type JoinApproved = z.infer<typeof JoinApprovedSchema>;
+export declare const JoinRejectedSchema: z.ZodObject<{
+    type: z.ZodLiteral<"join_rejected">;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type JoinRejected = z.infer<typeof JoinRejectedSchema>;
+export declare const PlanApprovalRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"plan_approval_request">;
+    requestId: z.ZodString;
+    plan: z.ZodString;
+    agentId: z.ZodString;
+}, z.core.$strip>;
+export type PlanApprovalRequest = z.infer<typeof PlanApprovalRequestSchema>;
+export declare const PlanApprovalResponseSchema: z.ZodObject<{
+    type: z.ZodLiteral<"plan_approval_response">;
+    requestId: z.ZodString;
+    decision: z.ZodEnum<{
+        rejected: "rejected";
+        approved: "approved";
+    }>;
+    feedback: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type PlanApprovalResponse = z.infer<typeof PlanApprovalResponseSchema>;
+export declare const ModeSetRequestSchema: z.ZodObject<{
+    type: z.ZodLiteral<"mode_set_request">;
+    mode: z.ZodEnum<{
+        default: "default";
+        plan: "plan";
+        acceptEdits: "acceptEdits";
+        bypassPermissions: "bypassPermissions";
+        delegate: "delegate";
+        dontAsk: "dontAsk";
+    }>;
+}, z.core.$strip>;
+export type ModeSetRequest = z.infer<typeof ModeSetRequestSchema>;
+export declare const TeamPermissionUpdateSchema: z.ZodObject<{
+    type: z.ZodLiteral<"team_permission_update">;
+    permissions: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export type TeamPermissionUpdate = z.infer<typeof TeamPermissionUpdateSchema>;
+export declare const ProtocolMessageSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"permission_request">;
+    requestId: z.ZodString;
+    toolName: z.ZodString;
+    input: z.ZodUnknown;
+    agentId: z.ZodString;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"permission_response">;
+    requestId: z.ZodString;
+    decision: z.ZodEnum<{
+        rejected: "rejected";
+        approved: "approved";
+    }>;
+    updatedInput: z.ZodOptional<z.ZodUnknown>;
+    feedback: z.ZodOptional<z.ZodString>;
+    permissionUpdates: z.ZodOptional<z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"shutdown_request">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"shutdown_approved">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"shutdown_rejected">;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"task_assignment">;
+    taskId: z.ZodString;
+    subject: z.ZodString;
+    description: z.ZodString;
+    assignedBy: z.ZodString;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"task_completed">;
+    taskId: z.ZodString;
+    agentId: z.ZodString;
+    timestamp: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"idle_notification">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"join_request">;
+    agentName: z.ZodString;
+    sessionId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"join_approved">;
+    agentName: z.ZodString;
+    teamName: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"join_rejected">;
+    reason: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"plan_approval_request">;
+    requestId: z.ZodString;
+    plan: z.ZodString;
+    agentId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"plan_approval_response">;
+    requestId: z.ZodString;
+    decision: z.ZodEnum<{
+        rejected: "rejected";
+        approved: "approved";
+    }>;
+    feedback: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"mode_set_request">;
+    mode: z.ZodEnum<{
+        default: "default";
+        plan: "plan";
+        acceptEdits: "acceptEdits";
+        bypassPermissions: "bypassPermissions";
+        delegate: "delegate";
+        dontAsk: "dontAsk";
+    }>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"team_permission_update">;
+    permissions: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>], "type">;
+export type ProtocolMessage = z.infer<typeof ProtocolMessageSchema>;

package/dist/features/sisyphus-swarm/mailbox/types.test.d.ts

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

package/dist/features/sisyphus-tasks/storage.d.ts

@@ -0,0 +1,9 @@
+import type { z } from "zod";
+import type { OhMyOpenCodeConfig } from "../../config/schema";
+export declare function getTaskDir(listId: string, config: Partial<OhMyOpenCodeConfig>): string;
+export declare function getTaskPath(listId: string, taskId: string, config: Partial<OhMyOpenCodeConfig>): string;
+export declare function getTeamDir(teamName: string, config: Partial<OhMyOpenCodeConfig>): string;
+export declare function getInboxPath(teamName: string, agentName: string, config: Partial<OhMyOpenCodeConfig>): string;
+export declare function ensureDir(dirPath: string): void;
+export declare function readJsonSafe<T>(filePath: string, schema: z.ZodType<T>): T | null;
+export declare function writeJsonAtomic(filePath: string, data: unknown): void;

package/dist/features/sisyphus-tasks/storage.test.d.ts

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

package/dist/features/sisyphus-tasks/types.d.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+export declare const TaskStatusSchema: z.ZodEnum<{
+    pending: "pending";
+    completed: "completed";
+    in_progress: "in_progress";
+}>;
+export type TaskStatus = z.infer<typeof TaskStatusSchema>;
+export declare const TaskSchema: z.ZodObject<{
+    id: z.ZodString;
+    subject: z.ZodString;
+    description: z.ZodString;
+    activeForm: z.ZodOptional<z.ZodString>;
+    owner: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        completed: "completed";
+        in_progress: "in_progress";
+    }>;
+    blocks: z.ZodArray<z.ZodString>;
+    blockedBy: z.ZodArray<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type Task = z.infer<typeof TaskSchema>;
+export declare const TaskCreateInputSchema: z.ZodObject<{
+    subject: z.ZodString;
+    description: z.ZodString;
+    activeForm: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type TaskCreateInput = z.infer<typeof TaskCreateInputSchema>;
+export declare const TaskUpdateInputSchema: z.ZodObject<{
+    taskId: z.ZodString;
+    subject: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    activeForm: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodEnum<{
+        pending: "pending";
+        completed: "completed";
+        in_progress: "in_progress";
+        deleted: "deleted";
+    }>>;
+    addBlocks: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    addBlockedBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    owner: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type TaskUpdateInput = z.infer<typeof TaskUpdateInputSchema>;

package/dist/features/sisyphus-tasks/types.test.d.ts

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

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/env-cleaner.test.d.ts

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

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,50 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { Tool, Resource, Prompt } 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 clients;
+    private pendingConnections;
+    private authProviders;
+    private cleanupRegistered;
+    private cleanupInterval;
+    private cleanupHandlers;
+    private readonly IDLE_TIMEOUT;
+    private getClientKey;
+    /**
+     * Get or create an McpOAuthProvider for a given server URL + oauth config.
+     * Providers are cached by server URL to reuse tokens across reconnections.
+     */
+    private getOrCreateAuthProvider;
+    private registerProcessCleanup;
+    private unregisterProcessCleanup;
+    getOrCreateClient(info: SkillMcpClientInfo, config: ClaudeCodeMcpServer): Promise<Client>;
+    private createClient;
+    /**
+     * Create an HTTP-based MCP client using StreamableHTTPClientTransport.
+     * Supports remote MCP servers with optional authentication headers.
+     */
+    private createHttpClient;
+    /**
+     * Create a stdio-based MCP client using StdioClientTransport.
+     * Spawns a local process and communicates via stdin/stdout.
+     */
+    private createStdioClient;
+    disconnectSession(sessionID: string): Promise<void>;
+    disconnectAll(): Promise<void>;
+    private startCleanupTimer;
+    private stopCleanupTimer;
+    private cleanupIdleClients;
+    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 handleStepUpIfNeeded;
+    private forceReconnect;
+    private getOrCreateClientWithRetry;
+    getConnectedServers(): string[];
+    isConnected(info: SkillMcpClientInfo): boolean;
+}

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

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

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

@@ -0,0 +1,11 @@
+import type { ClaudeCodeMcpServer } from "../claude-code-mcp-loader/types";
+export type SkillMcpConfig = Record<string, ClaudeCodeMcpServer>;
+export interface SkillMcpClientInfo {
+    serverName: string;
+    skillName: string;
+    sessionID: string;
+}
+export interface SkillMcpServerContext {
+    config: ClaudeCodeMcpServer;
+    skillName: string;
+}

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,58 @@
+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;
+        description: string;
+        agent: string;
+        isBackground: boolean;
+        status?: TaskStatus;
+        category?: string;
+        skills?: string[];
+        modelInfo?: ModelFallbackInfo;
+    }): void;
+    /**
+     * Update task status
+     */
+    updateTask(id: string, status: TaskStatus): 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 {};

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

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

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

@@ -0,0 +1,24 @@
+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";
+    source?: ModelSource;
+}
+export interface TrackedTask {
+    id: 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;
+}