@wolfx/oh-my-openagent 3.17.15 → 4.1.1

package/dist/features/team-mode/tools/lifecycle-test-fixture.d.ts

@@ -0,0 +1,188 @@
+import type { ToolContext } from "@opencode-ai/plugin/tool";
+import type { OpencodeClient } from "../../../tools/delegate-task/types";
+import type { BackgroundManager } from "../../background-agent/manager";
+import type { RuntimeState, TeamSpec } from "../types";
+export declare function parseToolResult<TValue>(value: string): TValue;
+export declare function createToolContext(sessionID: string): ToolContext;
+export declare function getLatestShutdownRequest(runtimeState: RuntimeState, memberName: string): RuntimeState["shutdownRequests"][number] | undefined;
+export declare function createSpec(): TeamSpec;
+export declare function requireRuntime(teamRunId: string): RuntimeState;
+export declare const createTeamRunMock: import("bun:test").Mock<(spec: TeamSpec, leadSessionId: string) => Promise<{
+    version: 1;
+    teamRunId: string;
+    teamName: string;
+    specSource: "user" | "project";
+    createdAt: number;
+    status: "deleted" | "failed" | "active" | "creating" | "shutdown_requested" | "deleting" | "orphaned";
+    members: {
+        name: string;
+        agentType: "leader" | "general-purpose";
+        status: "pending" | "completed" | "running" | "idle" | "shutdown_approved" | "errored";
+        pendingInjectedMessageIds: string[];
+        sessionId?: string | undefined;
+        tmuxPaneId?: string | undefined;
+        tmuxGridPaneId?: string | undefined;
+        subagent_type?: string | undefined;
+        category?: string | undefined;
+        model?: {
+            providerID: string;
+            modelID: string;
+            variant?: string | undefined;
+            reasoningEffort?: string | undefined;
+            temperature?: number | undefined;
+            top_p?: number | undefined;
+            maxTokens?: number | undefined;
+            thinking?: {
+                type: "enabled" | "disabled";
+                budgetTokens?: number | undefined;
+            } | undefined;
+        } | undefined;
+        color?: string | undefined;
+        worktreePath?: string | undefined;
+        lastInjectedTurnMarker?: string | undefined;
+    }[];
+    shutdownRequests: {
+        memberId: string;
+        requesterName: string;
+        requestedAt: number;
+        approvedAt?: number | undefined;
+        rejectedReason?: string | undefined;
+        rejectedAt?: number | undefined;
+    }[];
+    bounds: {
+        maxMembers: number;
+        maxParallelMembers: number;
+        maxMessagesPerRun: number;
+        maxWallClockMinutes: number;
+        maxMemberTurns: number;
+    };
+    leadSessionId?: string | undefined;
+    tmuxLayout?: {
+        ownedSession: boolean;
+        targetSessionId: string;
+        focusWindowId?: string | undefined;
+        gridWindowId?: string | undefined;
+    } | undefined;
+}>>;
+export declare const deleteTeamMock: import("bun:test").Mock<(teamRunId: string, _config?: unknown, _tmuxMgr?: unknown, _bgMgr?: unknown, options?: {
+    force?: boolean;
+}) => Promise<{
+    removedWorktrees: never[];
+    removedLayout: boolean;
+}>>;
+export declare const requestShutdownOfMemberMock: import("bun:test").Mock<(teamRunId: string, targetMemberName: string, requesterName: string) => Promise<void>>;
+export declare const approveShutdownMock: import("bun:test").Mock<(teamRunId: string, memberName: string) => Promise<void>>;
+export declare const rejectShutdownMock: import("bun:test").Mock<(teamRunId: string, memberName: string, reason: string) => Promise<void>>;
+export declare const loadTeamSpecMock: import("bun:test").Mock<() => Promise<{
+    version: 1;
+    name: string;
+    createdAt: number;
+    members: ({
+        name: string;
+        backendType: "tmux" | "in-process";
+        isActive: boolean;
+        kind: "category";
+        category: string;
+        prompt: string;
+        cwd?: string | undefined;
+        worktreePath?: string | undefined;
+        subscriptions?: string[] | undefined;
+        color?: string | undefined;
+    } | {
+        name: string;
+        backendType: "tmux" | "in-process";
+        isActive: boolean;
+        kind: "subagent_type";
+        subagent_type: string;
+        cwd?: string | undefined;
+        worktreePath?: string | undefined;
+        subscriptions?: string[] | undefined;
+        color?: string | undefined;
+        prompt?: string | undefined;
+    })[];
+    description?: string | undefined;
+    leadAgentId?: string | undefined;
+    teamAllowedPaths?: string[] | undefined;
+    sessionPermission?: string | undefined;
+}>>;
+export declare const listActiveTeamsMock: import("bun:test").Mock<() => Promise<{
+    teamRunId: string;
+    teamName: string;
+    status: "deleted" | "failed" | "active" | "creating" | "shutdown_requested" | "deleting" | "orphaned";
+    memberCount: number;
+    scope: "user" | "project";
+}[]>>;
+export declare const loadRuntimeStateMock: import("bun:test").Mock<(teamRunId: string) => Promise<{
+    version: 1;
+    teamRunId: string;
+    teamName: string;
+    specSource: "user" | "project";
+    createdAt: number;
+    status: "deleted" | "failed" | "active" | "creating" | "shutdown_requested" | "deleting" | "orphaned";
+    members: {
+        name: string;
+        agentType: "leader" | "general-purpose";
+        status: "pending" | "completed" | "running" | "idle" | "shutdown_approved" | "errored";
+        pendingInjectedMessageIds: string[];
+        sessionId?: string | undefined;
+        tmuxPaneId?: string | undefined;
+        tmuxGridPaneId?: string | undefined;
+        subagent_type?: string | undefined;
+        category?: string | undefined;
+        model?: {
+            providerID: string;
+            modelID: string;
+            variant?: string | undefined;
+            reasoningEffort?: string | undefined;
+            temperature?: number | undefined;
+            top_p?: number | undefined;
+            maxTokens?: number | undefined;
+            thinking?: {
+                type: "enabled" | "disabled";
+                budgetTokens?: number | undefined;
+            } | undefined;
+        } | undefined;
+        color?: string | undefined;
+        worktreePath?: string | undefined;
+        lastInjectedTurnMarker?: string | undefined;
+    }[];
+    shutdownRequests: {
+        memberId: string;
+        requesterName: string;
+        requestedAt: number;
+        approvedAt?: number | undefined;
+        rejectedReason?: string | undefined;
+        rejectedAt?: number | undefined;
+    }[];
+    bounds: {
+        maxMembers: number;
+        maxParallelMembers: number;
+        maxMessagesPerRun: number;
+        maxWallClockMinutes: number;
+        maxMemberTurns: number;
+    };
+    leadSessionId?: string | undefined;
+    tmuxLayout?: {
+        ownedSession: boolean;
+        targetSessionId: string;
+        focusWindowId?: string | undefined;
+        gridWindowId?: string | undefined;
+    } | undefined;
+}>>;
+export declare const config: {
+    enabled: boolean;
+    tmux_visualization: boolean;
+    max_parallel_members: number;
+    max_members: number;
+    max_messages_per_run: number;
+    max_wall_clock_minutes: number;
+    max_member_turns: number;
+    message_payload_max_bytes: number;
+    recipient_unread_max_bytes: number;
+    mailbox_poll_interval_ms: number;
+    base_dir?: string | undefined;
+};
+export declare const mockClient: OpencodeClient;
+export declare const backgroundManager: BackgroundManager;
+export declare function resetLifecycleTestState(): void;
+export declare function hasRuntime(teamRunId: string): boolean;

package/dist/features/team-mode/tools/lifecycle.d.ts

@@ -0,0 +1,37 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import type { CategoriesConfig, AgentOverrides } from "../../../config/schema";
+import type { OpencodeClient } from "../../../tools/delegate-task/types";
+import type { BackgroundManager } from "../../background-agent/manager";
+import type { TmuxSessionManager } from "../../tmux-subagent/manager";
+import { loadTeamSpec } from "../team-registry/loader";
+import { createTeamRun } from "../team-runtime/create";
+import { approveShutdown, deleteTeam, rejectShutdown, requestShutdownOfMember } from "../team-runtime/shutdown";
+import { listActiveTeams, loadRuntimeState } from "../team-state-store/store";
+type TeamRuntimeStoreDeps = {
+    listActiveTeams: typeof listActiveTeams;
+    loadRuntimeState: typeof loadRuntimeState;
+};
+type TeamShutdownToolDeps = TeamRuntimeStoreDeps & {
+    deleteTeam: typeof deleteTeam;
+    requestShutdownOfMember: typeof requestShutdownOfMember;
+    approveShutdown: typeof approveShutdown;
+    rejectShutdown: typeof rejectShutdown;
+};
+export type TeamCreateExecutorConfig = {
+    userCategories?: CategoriesConfig;
+    sisyphusJuniorModel?: string;
+    agentOverrides?: AgentOverrides;
+};
+type TeamCreateToolDeps = {
+    createTeamRun: typeof createTeamRun;
+    loadTeamSpec: typeof loadTeamSpec;
+    listActiveTeams: typeof listActiveTeams;
+    loadRuntimeState: typeof loadRuntimeState;
+};
+export declare function createTeamCreateTool(config: TeamModeConfig, client: OpencodeClient, bgMgr: BackgroundManager, tmuxMgr?: TmuxSessionManager, executorConfig?: TeamCreateExecutorConfig, deps?: TeamCreateToolDeps): ToolDefinition;
+export declare function createTeamDeleteTool(config: TeamModeConfig, client: OpencodeClient, backgroundManager: BackgroundManager, tmuxMgr?: TmuxSessionManager, deps?: TeamShutdownToolDeps): ToolDefinition;
+export declare function createTeamShutdownRequestTool(config: TeamModeConfig, client: OpencodeClient, deps?: TeamShutdownToolDeps): ToolDefinition;
+export declare function createTeamApproveShutdownTool(config: TeamModeConfig, client: OpencodeClient, deps?: TeamShutdownToolDeps): ToolDefinition;
+export declare function createTeamRejectShutdownTool(config: TeamModeConfig, client: OpencodeClient, deps?: TeamShutdownToolDeps): ToolDefinition;
+export {};

package/dist/features/team-mode/tools/messaging.d.ts

@@ -0,0 +1,31 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import { loadRuntimeState } from "../team-state-store/store";
+export type LiveDeliveryClient = {
+    session: {
+        promptAsync(input: {
+            path: {
+                id: string;
+            };
+            body: {
+                parts: Array<{
+                    type: "text";
+                    text: string;
+                }>;
+                agent?: string;
+                model?: {
+                    providerID: string;
+                    modelID: string;
+                };
+                variant?: string;
+            };
+            query?: {
+                directory: string;
+            };
+        }): Promise<unknown>;
+    };
+};
+export type TeamSendMessageToolDeps = {
+    loadRuntimeState: typeof loadRuntimeState;
+};
+export declare function createTeamSendMessageTool(config: TeamModeConfig, client: LiveDeliveryClient, deps?: TeamSendMessageToolDeps): ToolDefinition;

package/dist/features/team-mode/tools/query.d.ts

@@ -0,0 +1,16 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import type { OpencodeClient } from "../../../tools/delegate-task/types";
+import { loadTeamSpec } from "../team-registry/loader";
+import { aggregateStatus } from "../team-runtime/status";
+import { discoverTeamSpecs } from "../team-registry/paths";
+import { listActiveTeams } from "../team-state-store/store";
+type QueryToolDeps = {
+    aggregateStatus: typeof aggregateStatus;
+    discoverTeamSpecs: typeof discoverTeamSpecs;
+    loadTeamSpec: typeof loadTeamSpec;
+    listActiveTeams: typeof listActiveTeams;
+};
+export declare function createTeamStatusTool(config: TeamModeConfig, client: OpencodeClient, backgroundManager?: Parameters<typeof aggregateStatus>[2], deps?: QueryToolDeps): ToolDefinition;
+export declare function createTeamListTool(config: TeamModeConfig, client: OpencodeClient, deps?: QueryToolDeps): ToolDefinition;
+export {};

package/dist/features/team-mode/tools/tasks.d.ts

@@ -0,0 +1,18 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { TeamModeConfig } from "../../../config/schema/team-mode";
+import type { OpencodeClient } from "../../../tools/delegate-task/types";
+import { loadRuntimeState } from "../team-state-store";
+import { createTask, getTask, listTasks, updateTaskStatus, claimTask } from "../team-tasklist";
+type TeamTaskToolDeps = {
+    loadRuntimeState: typeof loadRuntimeState;
+    createTask: typeof createTask;
+    listTasks: typeof listTasks;
+    claimTask: typeof claimTask;
+    updateTaskStatus: typeof updateTaskStatus;
+    getTask: typeof getTask;
+};
+export declare function createTeamTaskCreateTool(config: TeamModeConfig, client: OpencodeClient, deps?: TeamTaskToolDeps): ToolDefinition;
+export declare function createTeamTaskListTool(config: TeamModeConfig, client: OpencodeClient, deps?: TeamTaskToolDeps): ToolDefinition;
+export declare function createTeamTaskUpdateTool(config: TeamModeConfig, client: OpencodeClient, deps?: TeamTaskToolDeps): ToolDefinition;
+export declare function createTeamTaskGetTool(config: TeamModeConfig, client: OpencodeClient, deps?: TeamTaskToolDeps): ToolDefinition;
+export {};

package/dist/features/team-mode/types.d.ts

@@ -62,12 +62,12 @@ export declare const MemberSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     subagent_type: z.ZodString;
     prompt: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>], "kind">;
-export declare const TeamSpecSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
+export declare const TeamSpecSchema: z.ZodPipe<z.ZodObject<{
+    version: z.ZodDefault<z.ZodLiteral<1>>;
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
-    createdAt: z.ZodNumber;
-    leadAgentId: z.ZodString;
+    createdAt: z.ZodDefault<z.ZodNumber>;
+    leadAgentId: z.ZodOptional<z.ZodString>;
     teamAllowedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
     sessionPermission: z.ZodOptional<z.ZodString>;
     members: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -99,7 +99,69 @@ export declare const TeamSpecSchema: z.ZodObject<{
         subagent_type: z.ZodString;
         prompt: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>], "kind">>;
-}, z.core.$strip>;
+}, z.core.$strip>, z.ZodTransform<{
+    version: 1;
+    name: string;
+    createdAt: number;
+    members: ({
+        name: string;
+        backendType: "tmux" | "in-process";
+        isActive: boolean;
+        kind: "category";
+        category: string;
+        prompt: string;
+        cwd?: string | undefined;
+        worktreePath?: string | undefined;
+        subscriptions?: string[] | undefined;
+        color?: string | undefined;
+    } | {
+        name: string;
+        backendType: "tmux" | "in-process";
+        isActive: boolean;
+        kind: "subagent_type";
+        subagent_type: string;
+        cwd?: string | undefined;
+        worktreePath?: string | undefined;
+        subscriptions?: string[] | undefined;
+        color?: string | undefined;
+        prompt?: string | undefined;
+    })[];
+    description?: string | undefined;
+    leadAgentId?: string | undefined;
+    teamAllowedPaths?: string[] | undefined;
+    sessionPermission?: string | undefined;
+}, {
+    version: 1;
+    name: string;
+    createdAt: number;
+    members: ({
+        name: string;
+        backendType: "tmux" | "in-process";
+        isActive: boolean;
+        kind: "category";
+        category: string;
+        prompt: string;
+        cwd?: string | undefined;
+        worktreePath?: string | undefined;
+        subscriptions?: string[] | undefined;
+        color?: string | undefined;
+    } | {
+        name: string;
+        backendType: "tmux" | "in-process";
+        isActive: boolean;
+        kind: "subagent_type";
+        subagent_type: string;
+        cwd?: string | undefined;
+        worktreePath?: string | undefined;
+        subscriptions?: string[] | undefined;
+        color?: string | undefined;
+        prompt?: string | undefined;
+    })[];
+    description?: string | undefined;
+    leadAgentId?: string | undefined;
+    teamAllowedPaths?: string[] | undefined;
+    sessionPermission?: string | undefined;
+}>>;
 export declare const MessageSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     messageId: z.ZodString;
@@ -143,6 +205,46 @@ export declare const TaskSchema: z.ZodObject<{
     updatedAt: z.ZodNumber;
     claimedAt: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
+declare const RuntimeStateMemberSchema: z.ZodObject<{
+    name: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    tmuxPaneId: z.ZodOptional<z.ZodString>;
+    tmuxGridPaneId: z.ZodOptional<z.ZodString>;
+    agentType: z.ZodEnum<{
+        leader: "leader";
+        "general-purpose": "general-purpose";
+    }>;
+    subagent_type: z.ZodOptional<z.ZodString>;
+    category: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodObject<{
+        providerID: z.ZodString;
+        modelID: z.ZodString;
+        variant: z.ZodOptional<z.ZodString>;
+        reasoningEffort: z.ZodOptional<z.ZodString>;
+        temperature: z.ZodOptional<z.ZodNumber>;
+        top_p: z.ZodOptional<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+        thinking: z.ZodOptional<z.ZodObject<{
+            type: z.ZodEnum<{
+                enabled: "enabled";
+                disabled: "disabled";
+            }>;
+            budgetTokens: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strict>>;
+    status: z.ZodEnum<{
+        pending: "pending";
+        completed: "completed";
+        running: "running";
+        idle: "idle";
+        shutdown_approved: "shutdown_approved";
+        errored: "errored";
+    }>;
+    color: z.ZodOptional<z.ZodString>;
+    worktreePath: z.ZodOptional<z.ZodString>;
+    lastInjectedTurnMarker: z.ZodOptional<z.ZodString>;
+    pendingInjectedMessageIds: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
 export declare const RuntimeStateSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     teamRunId: z.ZodString;
@@ -162,14 +264,39 @@ export declare const RuntimeStateSchema: z.ZodObject<{
         orphaned: "orphaned";
     }>;
     leadSessionId: z.ZodOptional<z.ZodString>;
+    tmuxLayout: z.ZodOptional<z.ZodObject<{
+        ownedSession: z.ZodBoolean;
+        targetSessionId: z.ZodString;
+        focusWindowId: z.ZodOptional<z.ZodString>;
+        gridWindowId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
     members: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         sessionId: z.ZodOptional<z.ZodString>;
         tmuxPaneId: z.ZodOptional<z.ZodString>;
+        tmuxGridPaneId: z.ZodOptional<z.ZodString>;
         agentType: z.ZodEnum<{
             leader: "leader";
             "general-purpose": "general-purpose";
         }>;
+        subagent_type: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        model: z.ZodOptional<z.ZodObject<{
+            providerID: z.ZodString;
+            modelID: z.ZodString;
+            variant: z.ZodOptional<z.ZodString>;
+            reasoningEffort: z.ZodOptional<z.ZodString>;
+            temperature: z.ZodOptional<z.ZodNumber>;
+            top_p: z.ZodOptional<z.ZodNumber>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            thinking: z.ZodOptional<z.ZodObject<{
+                type: z.ZodEnum<{
+                    enabled: "enabled";
+                    disabled: "disabled";
+                }>;
+                budgetTokens: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strict>>;
         status: z.ZodEnum<{
             pending: "pending";
             completed: "completed";
@@ -185,9 +312,11 @@ export declare const RuntimeStateSchema: z.ZodObject<{
     }, z.core.$strict>>;
     shutdownRequests: z.ZodDefault<z.ZodArray<z.ZodObject<{
         memberId: z.ZodString;
+        requesterName: z.ZodString;
         requestedAt: z.ZodNumber;
         approvedAt: z.ZodOptional<z.ZodNumber>;
         rejectedReason: z.ZodOptional<z.ZodString>;
+        rejectedAt: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>>;
     bounds: z.ZodObject<{
         maxMembers: z.ZodDefault<z.ZodNumber>;
@@ -201,10 +330,13 @@ export declare const AGENT_ELIGIBILITY_REGISTRY: Readonly<Record<string, {
     verdict: "eligible" | "conditional" | "hard-reject";
     rejectionMessage?: string;
 }>>;
+export declare function parseMember(input: unknown): Member;
 export type TeamSpec = z.infer<typeof TeamSpecSchema>;
 export type Member = z.infer<typeof MemberSchema>;
 export type CategoryMember = z.infer<typeof CategoryMemberSchema>;
 export type SubagentMember = z.infer<typeof SubagentMemberSchema>;
 export type Message = z.infer<typeof MessageSchema>;
 export type Task = z.infer<typeof TaskSchema>;
+export type RuntimeStateMember = z.infer<typeof RuntimeStateMemberSchema>;
 export type RuntimeState = z.infer<typeof RuntimeStateSchema>;
+export {};

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

@@ -8,6 +8,7 @@ export interface ActionResult {
 }
 export interface ExecuteContext {
     config: TmuxConfig;
+    directory: string;
     serverUrl: string;
     windowState: WindowState;
 }

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

@@ -12,6 +12,7 @@ export interface ExecuteActionsResult {
 }
 export interface ExecuteContext {
     config: TmuxConfig;
+    directory: string;
     serverUrl: string;
     windowState: WindowState;
     sourcePaneId?: string;

package/dist/features/tmux-subagent/attachable-session-status.d.ts

@@ -0,0 +1,4 @@
+declare const ATTACHABLE_SESSION_STATUSES: readonly ["idle", "running"];
+export type AttachableSessionStatus = (typeof ATTACHABLE_SESSION_STATUSES)[number];
+export declare function isAttachableSessionStatus(status: string | undefined): status is AttachableSessionStatus;
+export {};

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

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

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

@@ -1,5 +1,8 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { TmuxConfig } from "../../config/schema";
+import type { WindowState } from "./types";
+import * as sharedModule from "../../shared";
+type OpencodeClient = PluginInput["client"];
 interface SessionCreatedEvent {
     type: string;
     properties?: {
@@ -13,14 +16,24 @@ interface SessionCreatedEvent {
 export interface TmuxUtilDeps {
     isInsideTmux: () => boolean;
     getCurrentPaneId: () => string | undefined;
+    queryWindowState: (paneId: string) => Promise<WindowState | null>;
+    waitForSessionReady: (params: {
+        client: OpencodeClient;
+        sessionId: string;
+    }) => Promise<boolean>;
+    log: typeof sharedModule.log;
 }
 export declare class TmuxSessionManager {
     private client;
     private tmuxConfig;
+    private projectDirectory;
     private serverUrl;
     private sourcePaneId;
     private sessions;
     private pendingSessions;
+    private failedReadinessSessions;
+    private closedByPolling;
+    private failedReadinessSweepInterval?;
     private spawnQueue;
     private deferredSessions;
     private deferredQueue;
@@ -34,7 +47,7 @@ export declare class TmuxSessionManager {
     private isolatedContainerNullStateCount;
     private staleSweepCompleted;
     private staleSweepInProgress;
-    constructor(ctx: PluginInput, tmuxConfig: TmuxConfig, deps?: TmuxUtilDeps);
+    constructor(ctx: PluginInput, tmuxConfig: TmuxConfig, deps?: Partial<TmuxUtilDeps>);
     private isEnabled;
     private isIsolated;
     private getEffectiveSourcePaneId;
@@ -42,11 +55,14 @@ export declare class TmuxSessionManager {
     private getCapacityConfig;
     private getSessionMappings;
     getTrackedPaneId(sessionId: string): string | undefined;
+    getServerUrl(): string;
     private removeTrackedSession;
     private reassignIsolatedContainerAnchor;
     private cleanupIsolatedContainerAfterSessionDeletion;
     private markSessionClosePending;
     private queryWindowStateSafely;
+    private windowStateContainsPane;
+    private finalizeForceRemoveCandidate;
     private closeTrackedSessionPane;
     private finalizeTrackedSessionClose;
     private closeTrackedSession;
@@ -55,15 +71,28 @@ export declare class TmuxSessionManager {
     private removeDeferredSession;
     private startDeferredAttachLoop;
     private stopDeferredAttachLoop;
+    private beginPendingSession;
+    private ensureSessionReadyBeforeSpawn;
+    private getSessionStatusType;
+    private rememberFailedReadinessSession;
+    private clearFailedReadinessSession;
+    private startFailedReadinessSweep;
+    private stopFailedReadinessSweep;
+    private isFailedReadinessSessionExpired;
+    private sweepExpiredFailedReadinessSessions;
+    private getFailedReadinessSession;
+    private spawnPendingSession;
+    private getEventSessionId;
+    private retryFailedReadinessSession;
     private tryAttachDeferredSession;
-    private logSessionReadinessInBackground;
-    private waitForSessionReady;
     onSessionCreated(event: SessionCreatedEvent): Promise<void>;
     private enqueueSpawn;
     onSessionDeleted(event: {
         sessionID: string;
     }): Promise<void>;
     private closeSessionById;
+    private closeSessionFromPolling;
+    private shouldSkipRespawnAfterPollingClose;
     onEvent(event: {
         type: string;
         properties?: Record<string, unknown>;

package/dist/features/tmux-subagent/pane-state-querier.d.ts

@@ -1,2 +1,12 @@
 import type { WindowState } from "./types";
+import { getTmuxPath } from "../../tools/interactive-bash/tmux-path-resolver";
+import { log } from "../../shared";
+import type { TmuxCommandResult } from "../../shared/tmux";
+type QueryWindowStateDeps = {
+    getTmuxPath: typeof getTmuxPath;
+    runTmuxCommand: (tmuxPath: string, args: string[]) => Promise<TmuxCommandResult>;
+    log: typeof log;
+};
+export declare function queryWindowStateWithDeps(sourcePaneId: string, deps: QueryWindowStateDeps): Promise<WindowState | null>;
 export declare function queryWindowState(sourcePaneId: string): Promise<WindowState | null>;
+export {};

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

@@ -12,6 +12,7 @@ export interface SessionPollingController {
 export declare function createSessionPollingController(params: {
     client: OpencodeClient;
     tmuxConfig: TmuxConfig;
+    directory: string;
     serverUrl: string;
     sourcePaneId: string | undefined;
     sessions: Map<string, TrackedSession>;

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

@@ -0,0 +1,23 @@
+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;
+    directory: string;
+    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 {};