oh-my-opencode 3.4.0 → 3.5.0

package/dist/features/claude-code-plugin-loader/skill-loader.d.ts

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

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

@@ -1,8 +1,8 @@
 import { z } from "zod";
 export declare const TaskStatusSchema: z.ZodEnum<{
     pending: "pending";
-    completed: "completed";
     in_progress: "in_progress";
+    completed: "completed";
     deleted: "deleted";
 }>;
 export type TaskStatus = z.infer<typeof TaskStatusSchema>;
@@ -12,8 +12,8 @@ export declare const TaskSchema: z.ZodObject<{
     description: z.ZodString;
     status: z.ZodEnum<{
         pending: "pending";
-        completed: "completed";
         in_progress: "in_progress";
+        completed: "completed";
         deleted: "deleted";
     }>;
     activeForm: z.ZodOptional<z.ZodString>;

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

@@ -1 +1,3 @@
 export * from "./schema";
+export * from "./oauth-authorization-flow";
+export * from "./provider";

package/dist/features/mcp-oauth/oauth-authorization-flow.d.ts

@@ -0,0 +1,26 @@
+export type OAuthCallbackResult = {
+    code: string;
+    state: string;
+};
+export declare function generateCodeVerifier(): string;
+export declare function generateCodeChallenge(verifier: string): string;
+export declare function buildAuthorizationUrl(authorizationEndpoint: string, options: {
+    clientId: string;
+    redirectUri: string;
+    codeChallenge: string;
+    state: string;
+    scopes?: string[];
+    resource?: string;
+}): string;
+export declare function startCallbackServer(port: number): Promise<OAuthCallbackResult>;
+export declare function runAuthorizationCodeRedirect(options: {
+    authorizationEndpoint: string;
+    callbackPort: number;
+    clientId: string;
+    redirectUri: string;
+    scopes?: string[];
+    resource?: string;
+}): Promise<{
+    code: string;
+    verifier: string;
+}>;

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

@@ -1,26 +1,12 @@
 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[];
 };
-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;
@@ -35,7 +21,9 @@ export declare class McpOAuthProvider {
     redirectUrl(): string;
     saveCodeVerifier(verifier: string): void;
     codeVerifier(): string | null;
-    redirectToAuthorization(metadata: OAuthServerMetadata): Promise<CallbackResult>;
+    redirectToAuthorization(metadata: OAuthServerMetadata): Promise<{
+        code: string;
+    }>;
     login(): Promise<OAuthTokenData>;
 }
 export { generateCodeVerifier, generateCodeChallenge, buildAuthorizationUrl, startCallbackServer };

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/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

@@ -2,3 +2,13 @@ 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";

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/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,11 @@
+import type { SkillsConfig, SkillDefinition } from "../../../config/schema";
+export declare function normalizeSkillsConfig(config: SkillsConfig | undefined): {
+    sources: Array<string | {
+        path: string;
+        recursive?: boolean;
+        glob?: string;
+    }>;
+    enable: string[];
+    disable: string[];
+    entries: Record<string, boolean | SkillDefinition>;
+};

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

@@ -1,22 +1,5 @@
-import type { LoadedSkill } from "./types";
-import type { GitMasterConfig, BrowserAutomationProvider } from "../../config/schema";
-export interface SkillResolutionOptions {
-    gitMasterConfig?: GitMasterConfig;
-    browserProvider?: BrowserAutomationProvider;
-    disabledSkills?: Set<string>;
-}
-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[];
-}>;
+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,6 @@
+import type { BrowserAutomationProvider, GitMasterConfig } from "../../config/schema";
+export interface SkillResolutionOptions {
+    gitMasterConfig?: GitMasterConfig;
+    browserProvider?: BrowserAutomationProvider;
+    disabledSkills?: Set<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/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/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/manager.d.ts

@@ -1,40 +1,13 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import type { Tool, Resource, Prompt } from "@modelcontextprotocol/sdk/types.js";
+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 clients;
-    private pendingConnections;
-    private authProviders;
-    private cleanupRegistered;
-    private cleanupInterval;
-    private cleanupHandlers;
-    private readonly IDLE_TIMEOUT;
+    private readonly state;
     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[]>;
@@ -42,8 +15,6 @@ export declare class SkillMcpManager {
     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/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

@@ -1,4 +1,8 @@
+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;
@@ -9,3 +13,43 @@ 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/manager.d.ts

@@ -55,4 +55,5 @@ export declare class TaskToastManager {
 }
 export declare function getTaskToastManager(): TaskToastManager | null;
 export declare function initTaskToastManager(client: OpencodeClient, concurrencyManager?: ConcurrencyManager): TaskToastManager;
+export declare function _resetTaskToastManagerForTesting(): void;
 export {};

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>;

package/dist/features/tmux-subagent/decision-engine.d.ts

@@ -1,38 +1,7 @@
-import type { WindowState, PaneAction, SpawnDecision, CapacityConfig, TmuxPaneInfo, SplitDirection } from "./types";
-export interface SessionMapping {
-    sessionId: string;
-    paneId: string;
-    createdAt: Date;
-}
-export interface GridCapacity {
-    cols: number;
-    rows: number;
-    total: number;
-}
-export interface GridSlot {
-    row: number;
-    col: number;
-}
-export interface GridPlan {
-    cols: number;
-    rows: number;
-    slotWidth: number;
-    slotHeight: number;
-}
-export interface SpawnTarget {
-    targetPaneId: string;
-    splitDirection: SplitDirection;
-}
-export declare function getColumnCount(paneCount: number): number;
-export declare function getColumnWidth(agentAreaWidth: number, paneCount: number): number;
-export declare function isSplittableAtCount(agentAreaWidth: number, paneCount: number): boolean;
-export declare function findMinimalEvictions(agentAreaWidth: number, currentCount: number): number | null;
-export declare function canSplitPane(pane: TmuxPaneInfo, direction: SplitDirection): boolean;
-export declare function canSplitPaneAnyDirection(pane: TmuxPaneInfo): boolean;
-export declare function getBestSplitDirection(pane: TmuxPaneInfo): SplitDirection | null;
-export declare function calculateCapacity(windowWidth: number, windowHeight: number): GridCapacity;
-export declare function computeGridPlan(windowWidth: number, windowHeight: number, paneCount: number): GridPlan;
-export declare function mapPaneToSlot(pane: TmuxPaneInfo, plan: GridPlan, mainPaneWidth: number): GridSlot;
-export declare function findSpawnTarget(state: WindowState): SpawnTarget | null;
-export declare function decideSpawnActions(state: WindowState, sessionId: string, description: string, _config: CapacityConfig, sessionMappings: SessionMapping[]): SpawnDecision;
-export declare function decideCloseAction(state: WindowState, sessionId: string, sessionMappings: SessionMapping[]): PaneAction | null;
+export type { SessionMapping } from "./oldest-agent-pane";
+export type { GridCapacity, GridPlan, GridSlot } from "./grid-planning";
+export type { SpawnTarget } from "./spawn-target-finder";
+export { calculateCapacity, computeGridPlan, mapPaneToSlot, } from "./grid-planning";
+export { canSplitPane, canSplitPaneAnyDirection, findMinimalEvictions, getBestSplitDirection, getColumnCount, getColumnWidth, isSplittableAtCount, } from "./pane-split-availability";
+export { findSpawnTarget } from "./spawn-target-finder";
+export { decideCloseAction, decideSpawnActions } from "./spawn-action-decider";

package/dist/features/tmux-subagent/event-handlers.d.ts

@@ -0,0 +1,6 @@
+export { coerceSessionCreatedEvent } from "./session-created-event";
+export type { SessionCreatedEvent } from "./session-created-event";
+export { handleSessionCreated } from "./session-created-handler";
+export type { SessionCreatedHandlerDeps } from "./session-created-handler";
+export { handleSessionDeleted } from "./session-deleted-handler";
+export type { SessionDeletedHandlerDeps } from "./session-deleted-handler";

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

@@ -0,0 +1,19 @@
+import type { TmuxPaneInfo } from "./types";
+export interface GridCapacity {
+    cols: number;
+    rows: number;
+    total: number;
+}
+export interface GridSlot {
+    row: number;
+    col: number;
+}
+export interface GridPlan {
+    cols: number;
+    rows: number;
+    slotWidth: number;
+    slotHeight: number;
+}
+export declare function calculateCapacity(windowWidth: number, windowHeight: number): GridCapacity;
+export declare function computeGridPlan(windowWidth: number, windowHeight: number, paneCount: number): GridPlan;
+export declare function mapPaneToSlot(pane: TmuxPaneInfo, plan: GridPlan, mainPaneWidth: number): GridSlot;

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

@@ -1,4 +1,14 @@
 export * from "./manager";
+export * from "./event-handlers";
+export * from "./polling";
+export * from "./cleanup";
+export * from "./session-created-event";
+export * from "./session-created-handler";
+export * from "./session-deleted-handler";
+export * from "./polling-constants";
+export * from "./session-status-parser";
+export * from "./session-message-count";
+export * from "./session-ready-waiter";
 export * from "./types";
 export * from "./pane-state-querier";
 export * from "./decision-engine";

package/dist/features/tmux-subagent/oldest-agent-pane.d.ts

@@ -0,0 +1,7 @@
+import type { TmuxPaneInfo } from "./types";
+export interface SessionMapping {
+    sessionId: string;
+    paneId: string;
+    createdAt: Date;
+}
+export declare function findOldestAgentPane(agentPanes: TmuxPaneInfo[], sessionMappings: SessionMapping[]): TmuxPaneInfo | null;

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

@@ -0,0 +1,8 @@
+import type { SplitDirection, TmuxPaneInfo } from "./types";
+export declare function getColumnCount(paneCount: number): number;
+export declare function getColumnWidth(agentAreaWidth: number, paneCount: number): number;
+export declare function isSplittableAtCount(agentAreaWidth: number, paneCount: number): boolean;
+export declare function findMinimalEvictions(agentAreaWidth: number, currentCount: number): number | null;
+export declare function canSplitPane(pane: TmuxPaneInfo, direction: SplitDirection): boolean;
+export declare function canSplitPaneAnyDirection(pane: TmuxPaneInfo): boolean;
+export declare function getBestSplitDirection(pane: TmuxPaneInfo): SplitDirection | null;

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

@@ -0,0 +1,3 @@
+export declare const SESSION_TIMEOUT_MS: number;
+export declare const MIN_STABILITY_TIME_MS: number;
+export declare const STABLE_POLLS_REQUIRED = 3;

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

@@ -0,0 +1,19 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { TmuxConfig } from "../../config/schema";
+import type { TrackedSession } from "./types";
+type OpencodeClient = PluginInput["client"];
+export interface SessionPollingController {
+    startPolling: () => void;
+    stopPolling: () => void;
+    closeSessionById: (sessionId: string) => Promise<void>;
+    waitForSessionReady: (sessionId: string) => Promise<boolean>;
+    pollSessions: () => Promise<void>;
+}
+export declare function createSessionPollingController(params: {
+    client: OpencodeClient;
+    tmuxConfig: TmuxConfig;
+    serverUrl: string;
+    sourcePaneId: string | undefined;
+    sessions: Map<string, TrackedSession>;
+}): SessionPollingController;
+export {};

package/dist/features/tmux-subagent/session-created-event.d.ts

@@ -0,0 +1,14 @@
+export interface SessionCreatedEvent {
+    type: string;
+    properties?: {
+        info?: {
+            id?: string;
+            parentID?: string;
+            title?: string;
+        };
+    };
+}
+export declare function coerceSessionCreatedEvent(input: {
+    type: string;
+    properties?: unknown;
+}): SessionCreatedEvent;

package/dist/features/tmux-subagent/session-created-handler.d.ts

@@ -0,0 +1,22 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { TmuxConfig } from "../../config/schema";
+import type { CapacityConfig, TrackedSession } from "./types";
+import { type SessionMapping } from "./decision-engine";
+import type { SessionCreatedEvent } from "./session-created-event";
+type OpencodeClient = PluginInput["client"];
+export interface SessionCreatedHandlerDeps {
+    client: OpencodeClient;
+    tmuxConfig: TmuxConfig;
+    serverUrl: string;
+    sourcePaneId: string | undefined;
+    sessions: Map<string, TrackedSession>;
+    pendingSessions: Set<string>;
+    isInsideTmux: () => boolean;
+    isEnabled: () => boolean;
+    getCapacityConfig: () => CapacityConfig;
+    getSessionMappings: () => SessionMapping[];
+    waitForSessionReady: (sessionId: string) => Promise<boolean>;
+    startPolling: () => void;
+}
+export declare function handleSessionCreated(deps: SessionCreatedHandlerDeps, event: SessionCreatedEvent): Promise<void>;
+export {};

package/dist/features/tmux-subagent/session-deleted-handler.d.ts

@@ -0,0 +1,15 @@
+import type { TmuxConfig } from "../../config/schema";
+import type { TrackedSession } from "./types";
+import { type SessionMapping } from "./decision-engine";
+export interface SessionDeletedHandlerDeps {
+    tmuxConfig: TmuxConfig;
+    serverUrl: string;
+    sourcePaneId: string | undefined;
+    sessions: Map<string, TrackedSession>;
+    isEnabled: () => boolean;
+    getSessionMappings: () => SessionMapping[];
+    stopPolling: () => void;
+}
+export declare function handleSessionDeleted(deps: SessionDeletedHandlerDeps, event: {
+    sessionID: string;
+}): Promise<void>;

package/dist/features/tmux-subagent/session-message-count.d.ts

@@ -0,0 +1 @@
+export declare function getMessageCount(data: unknown): number;

package/dist/features/tmux-subagent/session-ready-waiter.d.ts

@@ -0,0 +1,7 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+type OpencodeClient = PluginInput["client"];
+export declare function waitForSessionReady(params: {
+    client: OpencodeClient;
+    sessionId: string;
+}): Promise<boolean>;
+export {};