@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/features/tmux-subagent/manager.ts

@@ -1,969 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { TmuxConfig } from "../../config/schema"
-import type { TrackedSession, CapacityConfig, WindowState } from "./types"
-import { log, normalizeSDKResponse } from "../../shared"
-import {
-  isInsideTmux as defaultIsInsideTmux,
-  getCurrentPaneId as defaultGetCurrentPaneId,
-  POLL_INTERVAL_BACKGROUND_MS,
-  SESSION_READY_POLL_INTERVAL_MS,
-  SESSION_READY_TIMEOUT_MS,
-  spawnTmuxWindow,
-  spawnTmuxSession,
-} from "../../shared/tmux"
-import { queryWindowState } from "./pane-state-querier"
-import { decideSpawnActions, decideCloseAction, type SessionMapping } from "./decision-engine"
-import { executeActions, executeAction } from "./action-executor"
-import { TmuxPollingManager } from "./polling-manager"
-import { createTrackedSession, markTrackedSessionClosePending } from "./tracked-session-state"
-type OpencodeClient = PluginInput["client"]
-
-interface SessionCreatedEvent {
-  type: string
-  properties?: { info?: { id?: string; parentID?: string; title?: string } }
-}
-
-interface DeferredSession {
-  sessionId: string
-  title: string
-  queuedAt: Date
-  retryIsolatedContainer: boolean
-}
-
-export interface TmuxUtilDeps {
-  isInsideTmux: () => boolean
-  getCurrentPaneId: () => string | undefined
-}
-
-const defaultTmuxDeps: TmuxUtilDeps = {
-  isInsideTmux: defaultIsInsideTmux,
-  getCurrentPaneId: defaultGetCurrentPaneId,
-}
-
-const DEFERRED_SESSION_TTL_MS = 5 * 60 * 1000
-const MAX_DEFERRED_QUEUE_SIZE = 20
-const MAX_CLOSE_RETRY_COUNT = 3
-const MAX_ISOLATED_CONTAINER_NULL_STATE_COUNT = 2
-
-export class TmuxSessionManager {
-  private client: OpencodeClient
-  private tmuxConfig: TmuxConfig
-  private serverUrl: string
-  private sourcePaneId: string | undefined
-  private sessions = new Map<string, TrackedSession>()
-  private pendingSessions = new Set<string>()
-  private spawnQueue: Promise<void> = Promise.resolve()
-  private deferredSessions = new Map<string, DeferredSession>()
-  private deferredQueue: string[] = []
-  private deferredAttachInterval?: ReturnType<typeof setInterval>
-  private deferredAttachTickScheduled = false
-  private nullStateCount = 0
-  private deps: TmuxUtilDeps
-  private pollingManager: TmuxPollingManager
-  private isolatedContainerPaneId: string | undefined
-  private isolatedWindowPaneId: string | undefined
-  private isolatedContainerNullStateCount = 0
-  constructor(ctx: PluginInput, tmuxConfig: TmuxConfig, deps: TmuxUtilDeps = defaultTmuxDeps) {
-    this.client = ctx.client
-    this.tmuxConfig = tmuxConfig
-    this.deps = deps
-    const defaultPort = process.env.OPENCODE_PORT ?? "4096"
-    const fallbackUrl = `http://localhost:${defaultPort}`
-    const rawServerUrl = ctx.serverUrl?.toString()
-    try {
-      if (rawServerUrl) {
-        const parsed = new URL(rawServerUrl)
-        const port = parsed.port || (parsed.protocol === 'https:' ? '443' : '80')
-        this.serverUrl = port === '0' ? fallbackUrl : rawServerUrl
-      } else {
-        this.serverUrl = fallbackUrl
-      }
-    } catch (error) {
-      log("[tmux-session-manager] failed to parse server URL, using fallback", {
-        serverUrl: rawServerUrl,
-        error: String(error),
-      })
-      this.serverUrl = fallbackUrl
-    }
-    this.sourcePaneId = deps.getCurrentPaneId()
-    this.pollingManager = new TmuxPollingManager(
-      this.client,
-      this.sessions,
-      this.closeSessionById.bind(this)
-    )
-    log("[tmux-session-manager] initialized", {
-      configEnabled: this.tmuxConfig.enabled,
-      tmuxConfig: this.tmuxConfig,
-      serverUrl: this.serverUrl,
-      sourcePaneId: this.sourcePaneId,
-    })
-  }
-  private isEnabled(): boolean {
-    return this.tmuxConfig.enabled && this.deps.isInsideTmux()
-  }
-
-  private isIsolated(): boolean {
-    return this.tmuxConfig.isolation === "window" || this.tmuxConfig.isolation === "session"
-  }
-
-  private getEffectiveSourcePaneId(): string | undefined {
-    if (this.isIsolated() && this.isolatedWindowPaneId) {
-      return this.isolatedWindowPaneId
-    }
-    return this.sourcePaneId
-  }
-
-  private async spawnInIsolatedContainer(
-    sessionId: string,
-    title: string,
-  ): Promise<string | null> {
-    if (!this.isIsolated()) return null
-    if (this.isolatedWindowPaneId) {
-      const state = await queryWindowState(this.isolatedWindowPaneId).catch((error) => {
-        log("[tmux-session-manager] failed to query isolated window state", {
-          paneId: this.isolatedWindowPaneId,
-          error: String(error),
-        })
-        return null
-      })
-      if (state) {
-        this.isolatedContainerNullStateCount = 0
-        return null
-      }
-      this.isolatedContainerNullStateCount += 1
-      log("[tmux-session-manager] isolated container state query returned null", {
-        paneId: this.isolatedWindowPaneId,
-        nullStateCount: this.isolatedContainerNullStateCount,
-        maxNullStateCount: MAX_ISOLATED_CONTAINER_NULL_STATE_COUNT,
-      })
-      if (this.isolatedContainerNullStateCount < MAX_ISOLATED_CONTAINER_NULL_STATE_COUNT) {
-        return null
-      }
-      this.isolatedContainerPaneId = undefined
-      this.isolatedWindowPaneId = undefined
-      this.isolatedContainerNullStateCount = 0
-    }
-
-    const isolation = this.tmuxConfig.isolation
-    log("[tmux-session-manager] creating isolated tmux container", { isolation, sessionId, title })
-
-    const result = isolation === "session"
-      ? await spawnTmuxSession(sessionId, title, this.tmuxConfig, this.serverUrl, this.sourcePaneId)
-      : await spawnTmuxWindow(sessionId, title, this.tmuxConfig, this.serverUrl)
-
-    if (result.success && result.paneId) {
-      this.isolatedContainerPaneId = result.paneId
-      this.isolatedWindowPaneId = result.paneId
-      this.isolatedContainerNullStateCount = 0
-      log("[tmux-session-manager] isolated container created", {
-        isolation,
-        paneId: result.paneId,
-      })
-      return result.paneId
-    }
-    log("[tmux-session-manager] failed to create isolated container", { isolation, sessionId })
-    return null
-  }
-
-  private getCapacityConfig(): CapacityConfig {
-    return {
-      layout: this.tmuxConfig.layout,
-      mainPaneSize: this.tmuxConfig.main_pane_size,
-      mainPaneMinWidth: this.tmuxConfig.main_pane_min_width,
-      agentPaneWidth: this.tmuxConfig.agent_pane_min_width,
-    }
-  }
-
-  private getSessionMappings(): SessionMapping[] {
-    return Array.from(this.sessions.values()).map((s) => ({
-      sessionId: s.sessionId,
-      paneId: s.paneId,
-      createdAt: s.createdAt,
-    }))
-  }
-
-  getTrackedPaneId(sessionId: string): string | undefined {
-    return this.sessions.get(sessionId)?.paneId
-  }
-
-  private removeTrackedSession(sessionId: string): void {
-    this.sessions.delete(sessionId)
-
-    if (this.sessions.size === 0) {
-      this.pollingManager.stopPolling()
-    }
-  }
-
-  private reassignIsolatedContainerAnchor(): void {
-    const nextAnchor = this.sessions.values().next().value
-    if (!nextAnchor) {
-      return
-    }
-
-    this.isolatedContainerNullStateCount = 0
-    this.isolatedWindowPaneId = nextAnchor.paneId
-    log("[tmux-session-manager] reassigned isolated container anchor pane", {
-      sessionId: nextAnchor.sessionId,
-      paneId: nextAnchor.paneId,
-    })
-  }
-
-  private async cleanupIsolatedContainerAfterSessionDeletion(
-    tracked: TrackedSession,
-    isolatedPaneAlreadyClosed: boolean,
-    state: WindowState,
-  ): Promise<void> {
-    if (tracked.paneId !== this.isolatedWindowPaneId) {
-      return
-    }
-
-    if (this.sessions.size > 0) {
-      this.reassignIsolatedContainerAnchor()
-      return
-    }
-
-    const isolatedContainerPaneId = this.isolatedContainerPaneId
-    this.isolatedContainerNullStateCount = 0
-    this.isolatedContainerPaneId = undefined
-    this.isolatedWindowPaneId = undefined
-
-    if (!isolatedContainerPaneId) {
-      return
-    }
-
-    if (isolatedPaneAlreadyClosed && tracked.paneId === isolatedContainerPaneId) {
-      return
-    }
-
-    try {
-      const result = await executeAction(
-        { type: "close", paneId: isolatedContainerPaneId, sessionId: tracked.sessionId },
-        {
-          config: this.tmuxConfig,
-          serverUrl: this.serverUrl,
-          windowState: state,
-          sourcePaneId: this.sourcePaneId ?? tracked.paneId,
-        },
-      )
-
-      if (!result.success) {
-        log("[tmux-session-manager] failed to close isolated container pane after anchor session deletion", {
-          sessionId: tracked.sessionId,
-          paneId: isolatedContainerPaneId,
-        })
-      }
-    } catch (error) {
-      log("[tmux-session-manager] failed to cleanup isolated container pane after anchor session deletion", {
-        sessionId: tracked.sessionId,
-        paneId: isolatedContainerPaneId,
-        error: String(error),
-      })
-    }
-  }
-
-  private markSessionClosePending(sessionId: string): void {
-    const tracked = this.sessions.get(sessionId)
-    if (!tracked) return
-
-    this.sessions.set(sessionId, markTrackedSessionClosePending(tracked))
-    log("[tmux-session-manager] marked session close pending", {
-      sessionId,
-      paneId: tracked.paneId,
-      closeRetryCount: tracked.closeRetryCount,
-    })
-  }
-
-  private async queryWindowStateSafely(): Promise<WindowState | null> {
-    const paneId = this.getEffectiveSourcePaneId()
-    if (!paneId) return null
-
-    try {
-      return await queryWindowState(paneId)
-    } catch (error) {
-      log("[tmux-session-manager] failed to query window state for close", {
-        error: String(error),
-      })
-      return null
-    }
-  }
-
-  private async closeTrackedSessionPane(args: {
-    tracked: TrackedSession
-    state: WindowState
-  }): Promise<boolean> {
-    const { tracked, state } = args
-
-    try {
-      const result = await executeAction(
-        { type: "close", paneId: tracked.paneId, sessionId: tracked.sessionId },
-        {
-          config: this.tmuxConfig,
-          serverUrl: this.serverUrl,
-          windowState: state,
-          sourcePaneId: this.getEffectiveSourcePaneId(),
-        }
-      )
-
-      return result.success
-    } catch (error) {
-      log("[tmux-session-manager] close session pane failed", {
-        sessionId: tracked.sessionId,
-        paneId: tracked.paneId,
-        error: String(error),
-      })
-      return false
-    }
-  }
-
-  private async finalizeTrackedSessionClose(args: {
-    tracked: TrackedSession
-    state: WindowState
-    isolatedPaneAlreadyClosed: boolean
-  }): Promise<void> {
-    const { tracked, state, isolatedPaneAlreadyClosed } = args
-    this.removeTrackedSession(tracked.sessionId)
-    await this.cleanupIsolatedContainerAfterSessionDeletion(
-      tracked,
-      isolatedPaneAlreadyClosed,
-      state,
-    )
-  }
-
-  private async closeTrackedSession(tracked: TrackedSession): Promise<boolean> {
-    const state = await this.queryWindowStateSafely()
-    if (!state) return false
-
-    const closed = await this.closeTrackedSessionPane({ tracked, state })
-    if (!closed) {
-      return false
-    }
-
-    await this.finalizeTrackedSessionClose({
-      tracked,
-      state,
-      isolatedPaneAlreadyClosed: true,
-    })
-    return true
-  }
-
-  private async retryPendingCloses(): Promise<void> {
-    const pendingSessions = Array.from(this.sessions.values()).filter(
-      (tracked) => tracked.closePending,
-    )
-
-    for (const tracked of pendingSessions) {
-      if (!this.sessions.has(tracked.sessionId)) continue
-
-      if (tracked.closeRetryCount >= MAX_CLOSE_RETRY_COUNT) {
-        log("[tmux-session-manager] force removing close-pending session after max retries", {
-          sessionId: tracked.sessionId,
-          paneId: tracked.paneId,
-          closeRetryCount: tracked.closeRetryCount,
-        })
-        this.removeTrackedSession(tracked.sessionId)
-        continue
-      }
-
-      const closed = await this.closeTrackedSession(tracked)
-      if (closed) {
-        log("[tmux-session-manager] retried close succeeded", {
-          sessionId: tracked.sessionId,
-          paneId: tracked.paneId,
-          closeRetryCount: tracked.closeRetryCount,
-        })
-        continue
-      }
-
-      const currentTracked = this.sessions.get(tracked.sessionId)
-      if (!currentTracked || !currentTracked.closePending) {
-        continue
-      }
-
-      const nextRetryCount = currentTracked.closeRetryCount + 1
-      if (nextRetryCount >= MAX_CLOSE_RETRY_COUNT) {
-        log("[tmux-session-manager] force removing close-pending session after failed retry", {
-          sessionId: currentTracked.sessionId,
-          paneId: currentTracked.paneId,
-          closeRetryCount: nextRetryCount,
-        })
-        this.removeTrackedSession(currentTracked.sessionId)
-        continue
-      }
-
-      this.sessions.set(currentTracked.sessionId, {
-        ...currentTracked,
-        closePending: true,
-        closeRetryCount: nextRetryCount,
-      })
-      log("[tmux-session-manager] retried close failed", {
-        sessionId: currentTracked.sessionId,
-        paneId: currentTracked.paneId,
-        closeRetryCount: nextRetryCount,
-      })
-    }
-  }
-
-  private enqueueDeferredSession(
-    sessionId: string,
-    title: string,
-    retryIsolatedContainer = false,
-  ): void {
-    const existingDeferredSession = this.deferredSessions.get(sessionId)
-    if (existingDeferredSession) {
-      if (retryIsolatedContainer && !existingDeferredSession.retryIsolatedContainer) {
-        this.deferredSessions.set(sessionId, {
-          ...existingDeferredSession,
-          retryIsolatedContainer: true,
-        })
-      }
-      return
-    }
-    if (this.deferredQueue.length >= MAX_DEFERRED_QUEUE_SIZE) {
-      log("[tmux-session-manager] deferred queue full, dropping session", {
-        sessionId,
-        queueLength: this.deferredQueue.length,
-        maxQueueSize: MAX_DEFERRED_QUEUE_SIZE,
-      })
-      return
-    }
-    this.deferredSessions.set(sessionId, {
-      sessionId,
-      title,
-      queuedAt: new Date(),
-      retryIsolatedContainer,
-    })
-    this.deferredQueue.push(sessionId)
-    log("[tmux-session-manager] deferred session queued", {
-      sessionId,
-      queueLength: this.deferredQueue.length,
-    })
-    this.startDeferredAttachLoop()
-  }
-
-  private removeDeferredSession(sessionId: string): void {
-    if (!this.deferredSessions.delete(sessionId)) return
-    this.deferredQueue = this.deferredQueue.filter((id) => id !== sessionId)
-    log("[tmux-session-manager] deferred session removed", {
-      sessionId,
-      queueLength: this.deferredQueue.length,
-    })
-    if (this.deferredQueue.length === 0) {
-      this.stopDeferredAttachLoop()
-    }
-  }
-
-  private startDeferredAttachLoop(): void {
-    if (this.deferredAttachInterval) return
-    this.nullStateCount = 0
-    this.deferredAttachInterval = setInterval(() => {
-      if (this.deferredAttachTickScheduled) return
-      this.deferredAttachTickScheduled = true
-      void this.enqueueSpawn(async () => {
-        try {
-          await this.tryAttachDeferredSession()
-        } finally {
-          this.deferredAttachTickScheduled = false
-        }
-      })
-    }, POLL_INTERVAL_BACKGROUND_MS)
-    log("[tmux-session-manager] deferred attach polling started", {
-      intervalMs: POLL_INTERVAL_BACKGROUND_MS,
-    })
-  }
-
-  private stopDeferredAttachLoop(): void {
-    if (!this.deferredAttachInterval) return
-    clearInterval(this.deferredAttachInterval)
-    this.deferredAttachInterval = undefined
-    this.deferredAttachTickScheduled = false
-    this.nullStateCount = 0
-    log("[tmux-session-manager] deferred attach polling stopped")
-  }
-
-  private async tryAttachDeferredSession(): Promise<void> {
-    const sessionId = this.deferredQueue[0]
-    if (!sessionId) {
-      this.stopDeferredAttachLoop()
-      return
-    }
-
-    const deferred = this.deferredSessions.get(sessionId)
-    if (!deferred) {
-      this.deferredQueue.shift()
-      return
-    }
-
-    if (Date.now() - deferred.queuedAt.getTime() > DEFERRED_SESSION_TTL_MS) {
-      this.deferredQueue.shift()
-      this.deferredSessions.delete(sessionId)
-      log("[tmux-session-manager] deferred session expired", {
-        sessionId,
-        queuedAt: deferred.queuedAt.toISOString(),
-        ttlMs: DEFERRED_SESSION_TTL_MS,
-        queueLength: this.deferredQueue.length,
-      })
-      if (this.deferredQueue.length === 0) {
-        this.stopDeferredAttachLoop()
-      }
-      return
-    }
-
-    if (deferred.retryIsolatedContainer) {
-      const isolatedPaneId = await this.spawnInIsolatedContainer(sessionId, deferred.title)
-      if (isolatedPaneId) {
-        const sessionReady = await this.waitForSessionReady(sessionId)
-        this.sessions.set(
-          sessionId,
-          createTrackedSession({
-            sessionId,
-            paneId: isolatedPaneId,
-            description: deferred.title,
-          }),
-        )
-        this.removeDeferredSession(sessionId)
-        this.pollingManager.startPolling()
-        log("[tmux-session-manager] deferred session attached in isolated window", {
-          sessionId,
-          paneId: isolatedPaneId,
-          sessionReady,
-        })
-        return
-      }
-    }
-
-    const effectiveSourcePaneId = this.getEffectiveSourcePaneId()
-    if (!effectiveSourcePaneId) return
-
-    const state = await queryWindowState(effectiveSourcePaneId)
-    if (!state) {
-      this.nullStateCount += 1
-      log("[tmux-session-manager] deferred attach window state is null", {
-        nullStateCount: this.nullStateCount,
-      })
-      if (this.nullStateCount >= 3) {
-        log("[tmux-session-manager] stopping deferred attach loop after consecutive null states", {
-          nullStateCount: this.nullStateCount,
-        })
-        this.stopDeferredAttachLoop()
-      }
-      return
-    }
-    this.nullStateCount = 0
-
-    const decision = decideSpawnActions(
-      state,
-      sessionId,
-      deferred.title,
-      this.getCapacityConfig(),
-      this.getSessionMappings(),
-    )
-
-    if (!decision.canSpawn || decision.actions.length === 0) {
-      log("[tmux-session-manager] deferred session still waiting for capacity", {
-        sessionId,
-        reason: decision.reason,
-      })
-      return
-    }
-
-    const result = await executeActions(decision.actions, {
-      config: this.tmuxConfig,
-      serverUrl: this.serverUrl,
-      windowState: state,
-      sourcePaneId: effectiveSourcePaneId,
-    })
-
-    if (!result.success || !result.spawnedPaneId) {
-      log("[tmux-session-manager] deferred session attach failed", {
-        sessionId,
-        results: result.results.map((r) => ({
-          type: r.action.type,
-          success: r.result.success,
-          error: r.result.error,
-        })),
-      })
-      return
-    }
-
-    const sessionReady = await this.waitForSessionReady(sessionId)
-    if (!sessionReady) {
-      log("[tmux-session-manager] deferred session not ready after timeout", {
-        sessionId,
-        paneId: result.spawnedPaneId,
-      })
-    }
-
-    this.sessions.set(
-      sessionId,
-      createTrackedSession({
-        sessionId,
-        paneId: result.spawnedPaneId,
-        description: deferred.title,
-      }),
-    )
-    this.removeDeferredSession(sessionId)
-    this.pollingManager.startPolling()
-    log("[tmux-session-manager] deferred session attached", {
-      sessionId,
-      paneId: result.spawnedPaneId,
-      sessionReady,
-    })
-  }
-
-  private async waitForSessionReady(sessionId: string): Promise<boolean> {
-    const startTime = Date.now()
-    
-    while (Date.now() - startTime < SESSION_READY_TIMEOUT_MS) {
-      try {
-        const statusResult = await this.client.session.status({ path: undefined })
-        const allStatuses = normalizeSDKResponse(statusResult, {} as Record<string, { type: string }>)
-        
-        if (allStatuses[sessionId]) {
-          log("[tmux-session-manager] session ready", {
-            sessionId,
-            status: allStatuses[sessionId].type,
-            waitedMs: Date.now() - startTime,
-          })
-          return true
-        }
-      } catch (err) {
-        log("[tmux-session-manager] session status check error", { error: String(err) })
-      }
-      
-      await new Promise((resolve) => setTimeout(resolve, SESSION_READY_POLL_INTERVAL_MS))
-    }
-    
-    log("[tmux-session-manager] session ready timeout", {
-      sessionId,
-      timeoutMs: SESSION_READY_TIMEOUT_MS,
-    })
-    return false
-  }
-
-  async onSessionCreated(event: SessionCreatedEvent): Promise<void> {
-    const enabled = this.isEnabled()
-    log("[tmux-session-manager] onSessionCreated called", {
-      enabled,
-      tmuxConfigEnabled: this.tmuxConfig.enabled,
-      isInsideTmux: this.deps.isInsideTmux(),
-      eventType: event.type,
-      infoId: event.properties?.info?.id,
-      infoParentID: event.properties?.info?.parentID,
-    })
-
-    if (!enabled) return
-    if (event.type !== "session.created") return
-
-    const info = event.properties?.info
-    if (!info?.id || !info?.parentID) return
-
-    const sessionId = info.id
-    const title = info.title ?? "Subagent"
-
-    if (!this.sourcePaneId) {
-      log("[tmux-session-manager] no source pane id")
-      return
-    }
-
-    await this.retryPendingCloses()
-
-    if (
-      this.sessions.has(sessionId) ||
-      this.pendingSessions.has(sessionId) ||
-      this.deferredSessions.has(sessionId)
-    ) {
-      log("[tmux-session-manager] session already tracked or pending", { sessionId })
-      return
-    }
-
-    this.pendingSessions.add(sessionId)
-
-    await this.enqueueSpawn(async () => {
-      try {
-        const isolatedPaneId = await this.spawnInIsolatedContainer(sessionId, title)
-        if (isolatedPaneId) {
-          const sessionReady = await this.waitForSessionReady(sessionId)
-          this.sessions.set(
-            sessionId,
-            createTrackedSession({ sessionId, paneId: isolatedPaneId, description: title }),
-          )
-          this.pollingManager.startPolling()
-          log("[tmux-session-manager] first subagent spawned in isolated window", {
-            sessionId,
-            paneId: isolatedPaneId,
-            sessionReady,
-          })
-          return
-        }
-
-        if (this.isIsolated() && !this.isolatedWindowPaneId) {
-          log("[tmux-session-manager] isolated container failed, deferring session for retry", { sessionId })
-          this.enqueueDeferredSession(sessionId, title, true)
-          return
-        }
-        const sourcePaneId = this.getEffectiveSourcePaneId()
-        if (!sourcePaneId) {
-          log("[tmux-session-manager] no effective source pane id")
-          return
-        }
-
-        const state = await queryWindowState(sourcePaneId)
-        if (!state) {
-          log("[tmux-session-manager] failed to query window state, deferring session")
-          this.enqueueDeferredSession(sessionId, title)
-          return
-        }
-
-      log("[tmux-session-manager] window state queried", {
-        windowWidth: state.windowWidth,
-        mainPane: state.mainPane?.paneId,
-        agentPaneCount: state.agentPanes.length,
-        agentPanes: state.agentPanes.map((p) => p.paneId),
-      })
-
-        const decision = decideSpawnActions(
-          state,
-          sessionId,
-          title,
-          this.getCapacityConfig(),
-          this.getSessionMappings()
-        )
-
-      log("[tmux-session-manager] spawn decision", {
-        canSpawn: decision.canSpawn,
-        reason: decision.reason,
-        actionCount: decision.actions.length,
-        actions: decision.actions.map((a) => {
-          if (a.type === "close") return { type: "close", paneId: a.paneId }
-          if (a.type === "replace") return { type: "replace", paneId: a.paneId, newSessionId: a.newSessionId }
-          return { type: "spawn", sessionId: a.sessionId }
-        }),
-      })
-
-        if (!decision.canSpawn) {
-          log("[tmux-session-manager] cannot spawn", { reason: decision.reason })
-          this.enqueueDeferredSession(sessionId, title)
-          return
-        }
-
-        const result = await executeActions(
-          decision.actions,
-          {
-            config: this.tmuxConfig,
-            serverUrl: this.serverUrl,
-            windowState: state,
-            sourcePaneId,
-          }
-        )
-
-        for (const { action, result: actionResult } of result.results) {
-          if (action.type === "close" && actionResult.success) {
-            this.sessions.delete(action.sessionId)
-            log("[tmux-session-manager] removed closed session from cache", {
-              sessionId: action.sessionId,
-            })
-          }
-          if (action.type === "replace" && actionResult.success) {
-            this.sessions.delete(action.oldSessionId)
-            log("[tmux-session-manager] removed replaced session from cache", {
-              oldSessionId: action.oldSessionId,
-              newSessionId: action.newSessionId,
-            })
-          }
-        }
-
-        if (result.success && result.spawnedPaneId) {
-          const sessionReady = await this.waitForSessionReady(sessionId)
-
-          if (!sessionReady) {
-            log("[tmux-session-manager] session not ready after timeout, tracking anyway", {
-              sessionId,
-              paneId: result.spawnedPaneId,
-            })
-          }
-
-          this.sessions.set(
-            sessionId,
-            createTrackedSession({
-              sessionId,
-              paneId: result.spawnedPaneId,
-              description: title,
-            }),
-          )
-          log("[tmux-session-manager] pane spawned and tracked", {
-            sessionId,
-            paneId: result.spawnedPaneId,
-            sessionReady,
-          })
-          this.pollingManager.startPolling()
-        } else {
-          log("[tmux-session-manager] spawn failed", {
-            success: result.success,
-            results: result.results.map((r) => ({
-              type: r.action.type,
-              success: r.result.success,
-              error: r.result.error,
-            })),
-          })
-
-          log("[tmux-session-manager] re-queueing deferred session after spawn failure", {
-            sessionId,
-          })
-          this.enqueueDeferredSession(sessionId, title)
-
-          if (result.spawnedPaneId) {
-            await executeAction(
-              { type: "close", paneId: result.spawnedPaneId, sessionId },
-              { config: this.tmuxConfig, serverUrl: this.serverUrl, windowState: state }
-            )
-          }
-
-          return
-        }
-      } finally {
-        this.pendingSessions.delete(sessionId)
-      }
-    })
-  }
-
-  private async enqueueSpawn(run: () => Promise<void>): Promise<void> {
-    this.spawnQueue = this.spawnQueue
-      .catch((error) => {
-        log("[tmux-session-manager] recovering spawn queue after previous failure", {
-          error: String(error),
-        })
-      })
-      .then(run)
-      .catch((err) => {
-        log("[tmux-session-manager] spawn queue task failed", {
-          error: String(err),
-        })
-      })
-    await this.spawnQueue
-  }
-
-  async onSessionDeleted(event: { sessionID: string }): Promise<void> {
-    if (!this.isEnabled()) return
-    if (!this.getEffectiveSourcePaneId()) return
-
-    this.removeDeferredSession(event.sessionID)
-
-    const tracked = this.sessions.get(event.sessionID)
-    if (!tracked) return
-
-    log("[tmux-session-manager] onSessionDeleted", { sessionId: event.sessionID })
-
-    const state = await this.queryWindowStateSafely()
-    if (!state) {
-      this.markSessionClosePending(event.sessionID)
-      return
-    }
-
-    const closeAction = decideCloseAction(state, event.sessionID, this.getSessionMappings())
-    if (!closeAction) {
-      await this.finalizeTrackedSessionClose({
-        tracked,
-        state,
-        isolatedPaneAlreadyClosed: false,
-      })
-      return
-    }
-
-    const isolatedPaneAlreadyClosed =
-      closeAction.type === "close" && closeAction.paneId === tracked.paneId
-
-    try {
-      const result = await executeAction(closeAction, {
-        config: this.tmuxConfig,
-        serverUrl: this.serverUrl,
-        windowState: state,
-        sourcePaneId: this.getEffectiveSourcePaneId(),
-      })
-
-      if (!result.success) {
-        this.markSessionClosePending(event.sessionID)
-        return
-      }
-    } catch (error) {
-      log("[tmux-session-manager] failed to close pane for deleted session", {
-        sessionId: event.sessionID,
-        error: String(error),
-      })
-      this.markSessionClosePending(event.sessionID)
-      return
-    }
-
-    await this.finalizeTrackedSessionClose({
-      tracked,
-      state,
-      isolatedPaneAlreadyClosed,
-    })
-  }
-
-
-  private async closeSessionById(sessionId: string): Promise<void> {
-    const tracked = this.sessions.get(sessionId)
-    if (!tracked) return
-
-    if (tracked.closePending && tracked.closeRetryCount >= MAX_CLOSE_RETRY_COUNT) {
-      log("[tmux-session-manager] force removing close-pending session after max retries", {
-        sessionId,
-        paneId: tracked.paneId,
-        closeRetryCount: tracked.closeRetryCount,
-      })
-      this.removeTrackedSession(sessionId)
-      return
-    }
-
-    log("[tmux-session-manager] closing session pane", {
-      sessionId,
-      paneId: tracked.paneId,
-    })
-
-    const closed = await this.closeTrackedSession(tracked)
-    if (!closed) {
-      this.markSessionClosePending(sessionId)
-      return
-    }
-  }
-
-  onEvent(event: { type: string; properties?: Record<string, unknown> }): void {
-    this.pollingManager.handleEvent(event)
-  }
-
-  createEventHandler(): (input: { event: { type: string; properties?: unknown } }) => Promise<void> {
-    return async (input) => {
-      await this.onSessionCreated(input.event as SessionCreatedEvent)
-    }
-  }
-
-  async cleanup(): Promise<void> {
-    this.stopDeferredAttachLoop()
-    this.deferredQueue = []
-    this.deferredSessions.clear()
-    this.pollingManager.stopPolling()
-
-    if (this.sessions.size > 0) {
-      log("[tmux-session-manager] closing all panes", { count: this.sessions.size })
-
-      const sessionIds = Array.from(this.sessions.keys())
-      for (const sessionId of sessionIds) {
-        try {
-          await this.closeSessionById(sessionId)
-        } catch (error) {
-          log("[tmux-session-manager] cleanup error for pane", {
-            sessionId,
-            error: String(error),
-          })
-        }
-      }
-    }
-
-    await this.retryPendingCloses()
-    this.isolatedContainerNullStateCount = 0
-    this.isolatedContainerPaneId = undefined
-    this.isolatedWindowPaneId = undefined
-
-    log("[tmux-session-manager] cleanup complete")
-  }
-}