Merge remote-tracking branch 'origin/dev' into refactor/modular-code-enforcement

# Conflicts:
#	src/features/background-agent/manager.ts
#	src/features/background-agent/spawner.ts
#	src/features/tmux-subagent/manager.ts
#	src/shared/model-availability.test.ts
#	src/shared/model-availability.ts
#	src/shared/model-resolution-pipeline.ts
#	src/tools/delegate-task/executor.ts

src/features/background-agent/manager.test.ts

@@ -1412,14 +1412,14 @@ describe("BackgroundManager - Non-blocking Queue Integration", () => {
   let manager: BackgroundManager
   let mockClient: ReturnType<typeof createMockClient>
 
-   function createMockClient() {
-     return {
-       session: {
-         create: async () => ({ data: { id: `ses_${crypto.randomUUID()}` } }),
-         get: async () => ({ data: { directory: "/test/dir" } }),
-         prompt: async () => ({}),
-         promptAsync: async () => ({}),
-         messages: async () => ({ data: [] }),
+    function createMockClient() {
+      return {
+        session: {
+          create: async (_args?: any) => ({ data: { id: `ses_${crypto.randomUUID()}` } }),
+          get: async () => ({ data: { directory: "/test/dir" } }),
+          prompt: async () => ({}),
+          promptAsync: async () => ({}),
+          messages: async () => ({ data: [] }),
          todo: async () => ({ data: [] }),
          status: async () => ({ data: {} }),
          abort: async () => ({}),
@@ -1520,6 +1520,55 @@ describe("BackgroundManager - Non-blocking Queue Integration", () => {
   })
 
   describe("task transitions pending→running when slot available", () => {
+    test("should inherit parent session permission rules (and force deny question)", async () => {
+      // given
+      const createCalls: any[] = []
+      const parentPermission = [
+        { permission: "question", action: "allow" as const, pattern: "*" },
+        { permission: "plan_enter", action: "deny" as const, pattern: "*" },
+      ]
+
+      const customClient = {
+        session: {
+          create: async (args?: any) => {
+            createCalls.push(args)
+            return { data: { id: `ses_${crypto.randomUUID()}` } }
+          },
+          get: async () => ({ data: { directory: "/test/dir", permission: parentPermission } }),
+          prompt: async () => ({}),
+          promptAsync: async () => ({}),
+          messages: async () => ({ data: [] }),
+          todo: async () => ({ data: [] }),
+          status: async () => ({ data: {} }),
+          abort: async () => ({}),
+        },
+      }
+      manager.shutdown()
+      manager = new BackgroundManager({ client: customClient, directory: tmpdir() } as unknown as PluginInput, {
+        defaultConcurrency: 5,
+      })
+
+      const input = {
+        description: "Test task",
+        prompt: "Do something",
+        agent: "test-agent",
+        parentSessionID: "parent-session",
+        parentMessageID: "parent-message",
+      }
+
+      // when
+      await manager.launch(input)
+      await new Promise(resolve => setTimeout(resolve, 50))
+
+      // then
+      expect(createCalls).toHaveLength(1)
+      const permission = createCalls[0]?.body?.permission
+      expect(permission).toEqual([
+        { permission: "plan_enter", action: "deny", pattern: "*" },
+        { permission: "question", action: "deny", pattern: "*" },
+      ])
+    })
+
     test("should transition first task to running immediately", async () => {
       // given
       const config = { defaultConcurrency: 5 }

src/features/background-agent/spawner.test.ts

@@ -0,0 +1,65 @@
+import { describe, test, expect } from "bun:test"
+
+import { createTask, startTask } from "./spawner"
+
+describe("background-agent spawner.startTask", () => {
+  test("should inherit parent session permission rules (and force deny question)", async () => {
+    //#given
+    const createCalls: any[] = []
+    const parentPermission = [
+      { permission: "question", action: "allow" as const, pattern: "*" },
+      { permission: "plan_enter", action: "deny" as const, pattern: "*" },
+    ]
+
+    const client = {
+      session: {
+        get: async () => ({ data: { directory: "/parent/dir", permission: parentPermission } }),
+        create: async (args?: any) => {
+          createCalls.push(args)
+          return { data: { id: "ses_child" } }
+        },
+        promptAsync: async () => ({}),
+      },
+    }
+
+    const task = createTask({
+      description: "Test task",
+      prompt: "Do work",
+      agent: "explore",
+      parentSessionID: "ses_parent",
+      parentMessageID: "msg_parent",
+    })
+
+    const item = {
+      task,
+      input: {
+        description: task.description,
+        prompt: task.prompt,
+        agent: task.agent,
+        parentSessionID: task.parentSessionID,
+        parentMessageID: task.parentMessageID,
+        parentModel: task.parentModel,
+        parentAgent: task.parentAgent,
+        model: task.model,
+      },
+    }
+
+    const ctx = {
+      client,
+      directory: "/fallback",
+      concurrencyManager: { release: () => {} },
+      tmuxEnabled: false,
+      onTaskError: () => {},
+    }
+
+    //#when
+    await startTask(item as any, ctx as any)
+
+    //#then
+    expect(createCalls).toHaveLength(1)
+    expect(createCalls[0]?.body?.permission).toEqual([
+      { permission: "plan_enter", action: "deny", pattern: "*" },
+      { permission: "question", action: "deny", pattern: "*" },
+    ])
+  })
+})

src/features/background-agent/spawner.ts

@@ -1,4 +1,246 @@
-export type { SpawnerContext } from "./spawner/spawner-context"
-export { createTask } from "./spawner/task-factory"
-export { startTask } from "./spawner/task-starter"
-export { resumeTask } from "./spawner/task-resumer"
+import type { BackgroundTask, LaunchInput, ResumeInput } from "./types"
+import type { OpencodeClient, OnSubagentSessionCreated, QueueItem } from "./constants"
+import { TMUX_CALLBACK_DELAY_MS } from "./constants"
+import { log, getAgentToolRestrictions, promptWithModelSuggestionRetry } from "../../shared"
+import { subagentSessions } from "../claude-code-session-state"
+import { getTaskToastManager } from "../task-toast-manager"
+import { isInsideTmux } from "../../shared/tmux"
+import type { ConcurrencyManager } from "./concurrency"
+
+export interface SpawnerContext {
+  client: OpencodeClient
+  directory: string
+  concurrencyManager: ConcurrencyManager
+  tmuxEnabled: boolean
+  onSubagentSessionCreated?: OnSubagentSessionCreated
+  onTaskError: (task: BackgroundTask, error: Error) => void
+}
+
+export function createTask(input: LaunchInput): BackgroundTask {
+  return {
+    id: `bg_${crypto.randomUUID().slice(0, 8)}`,
+    status: "pending",
+    queuedAt: new Date(),
+    description: input.description,
+    prompt: input.prompt,
+    agent: input.agent,
+    parentSessionID: input.parentSessionID,
+    parentMessageID: input.parentMessageID,
+    parentModel: input.parentModel,
+    parentAgent: input.parentAgent,
+    model: input.model,
+  }
+}
+
+export async function startTask(
+  item: QueueItem,
+  ctx: SpawnerContext
+): Promise<void> {
+  const { task, input } = item
+  const { client, directory, concurrencyManager, tmuxEnabled, onSubagentSessionCreated, onTaskError } = ctx
+
+  log("[background-agent] Starting task:", {
+    taskId: task.id,
+    agent: input.agent,
+    model: input.model,
+  })
+
+  const concurrencyKey = input.model
+    ? `${input.model.providerID}/${input.model.modelID}`
+    : input.agent
+
+  const parentSession = await client.session.get({
+    path: { id: input.parentSessionID },
+  }).catch((err) => {
+    log(`[background-agent] Failed to get parent session: ${err}`)
+    return null
+  })
+  const parentDirectory = parentSession?.data?.directory ?? directory
+  log(`[background-agent] Parent dir: ${parentSession?.data?.directory}, using: ${parentDirectory}`)
+
+  const inheritedPermission = (parentSession as any)?.data?.permission
+  const permissionRules = Array.isArray(inheritedPermission)
+    ? inheritedPermission.filter((r: any) => r?.permission !== "question")
+    : []
+  permissionRules.push({ permission: "question", action: "deny" as const, pattern: "*" })
+
+  const createResult = await client.session.create({
+    body: {
+      parentID: input.parentSessionID,
+      title: `Background: ${input.description}`,
+      permission: permissionRules,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    } as any,
+    query: {
+      directory: parentDirectory,
+    },
+  }).catch((error) => {
+    concurrencyManager.release(concurrencyKey)
+    throw error
+  })
+
+  if (createResult.error) {
+    concurrencyManager.release(concurrencyKey)
+    throw new Error(`Failed to create background session: ${createResult.error}`)
+  }
+
+  const sessionID = createResult.data.id
+  subagentSessions.add(sessionID)
+
+  log("[background-agent] tmux callback check", {
+    hasCallback: !!onSubagentSessionCreated,
+    tmuxEnabled,
+    isInsideTmux: isInsideTmux(),
+    sessionID,
+    parentID: input.parentSessionID,
+  })
+
+  if (onSubagentSessionCreated && tmuxEnabled && isInsideTmux()) {
+    log("[background-agent] Invoking tmux callback NOW", { sessionID })
+    await onSubagentSessionCreated({
+      sessionID,
+      parentID: input.parentSessionID,
+      title: input.description,
+    }).catch((err) => {
+      log("[background-agent] Failed to spawn tmux pane:", err)
+    })
+    log("[background-agent] tmux callback completed, waiting")
+    await new Promise(r => setTimeout(r, TMUX_CALLBACK_DELAY_MS))
+  } else {
+    log("[background-agent] SKIP tmux callback - conditions not met")
+  }
+
+  task.status = "running"
+  task.startedAt = new Date()
+  task.sessionID = sessionID
+  task.progress = {
+    toolCalls: 0,
+    lastUpdate: new Date(),
+  }
+  task.concurrencyKey = concurrencyKey
+  task.concurrencyGroup = concurrencyKey
+
+  log("[background-agent] Launching task:", { taskId: task.id, sessionID, agent: input.agent })
+
+  const toastManager = getTaskToastManager()
+  if (toastManager) {
+    toastManager.updateTask(task.id, "running")
+  }
+
+  log("[background-agent] Calling prompt (fire-and-forget) for launch with:", {
+    sessionID,
+    agent: input.agent,
+    model: input.model,
+    hasSkillContent: !!input.skillContent,
+    promptLength: input.prompt.length,
+  })
+
+  const launchModel = input.model
+    ? { providerID: input.model.providerID, modelID: input.model.modelID }
+    : undefined
+  const launchVariant = input.model?.variant
+
+  promptWithModelSuggestionRetry(client, {
+    path: { id: sessionID },
+    body: {
+      agent: input.agent,
+      ...(launchModel ? { model: launchModel } : {}),
+      ...(launchVariant ? { variant: launchVariant } : {}),
+      system: input.skillContent,
+      tools: {
+        ...getAgentToolRestrictions(input.agent),
+        task: false,
+        call_omo_agent: true,
+        question: false,
+      },
+      parts: [{ type: "text", text: input.prompt }],
+    },
+  }).catch((error) => {
+    log("[background-agent] promptAsync error:", error)
+    onTaskError(task, error instanceof Error ? error : new Error(String(error)))
+  })
+}
+
+export async function resumeTask(
+  task: BackgroundTask,
+  input: ResumeInput,
+  ctx: Pick<SpawnerContext, "client" | "concurrencyManager" | "onTaskError">
+): Promise<void> {
+  const { client, concurrencyManager, onTaskError } = ctx
+
+  if (!task.sessionID) {
+    throw new Error(`Task has no sessionID: ${task.id}`)
+  }
+
+  if (task.status === "running") {
+    log("[background-agent] Resume skipped - task already running:", {
+      taskId: task.id,
+      sessionID: task.sessionID,
+    })
+    return
+  }
+
+  const concurrencyKey = task.concurrencyGroup ?? task.agent
+  await concurrencyManager.acquire(concurrencyKey)
+  task.concurrencyKey = concurrencyKey
+  task.concurrencyGroup = concurrencyKey
+
+  task.status = "running"
+  task.completedAt = undefined
+  task.error = undefined
+  task.parentSessionID = input.parentSessionID
+  task.parentMessageID = input.parentMessageID
+  task.parentModel = input.parentModel
+  task.parentAgent = input.parentAgent
+  task.startedAt = new Date()
+
+  task.progress = {
+    toolCalls: task.progress?.toolCalls ?? 0,
+    lastUpdate: new Date(),
+  }
+
+  subagentSessions.add(task.sessionID)
+
+  const toastManager = getTaskToastManager()
+  if (toastManager) {
+    toastManager.addTask({
+      id: task.id,
+      description: task.description,
+      agent: task.agent,
+      isBackground: true,
+    })
+  }
+
+  log("[background-agent] Resuming task:", { taskId: task.id, sessionID: task.sessionID })
+
+  log("[background-agent] Resuming task - calling prompt (fire-and-forget) with:", {
+    sessionID: task.sessionID,
+    agent: task.agent,
+    model: task.model,
+    promptLength: input.prompt.length,
+  })
+
+  const resumeModel = task.model
+    ? { providerID: task.model.providerID, modelID: task.model.modelID }
+    : undefined
+  const resumeVariant = task.model?.variant
+
+  client.session.promptAsync({
+    path: { id: task.sessionID },
+    body: {
+      agent: task.agent,
+      ...(resumeModel ? { model: resumeModel } : {}),
+      ...(resumeVariant ? { variant: resumeVariant } : {}),
+      tools: {
+        ...getAgentToolRestrictions(task.agent),
+        task: false,
+        call_omo_agent: true,
+        question: false,
+      },
+      parts: [{ type: "text", text: input.prompt }],
+    },
+  }).catch((error) => {
+    log("[background-agent] resume prompt error:", error)
+    onTaskError(task, error instanceof Error ? error : new Error(String(error)))
+  })
+}

src/features/tmux-subagent/manager.ts

@@ -4,20 +4,23 @@ import type { TrackedSession, CapacityConfig } from "./types"
 import {
   isInsideTmux as defaultIsInsideTmux,
   getCurrentPaneId as defaultGetCurrentPaneId,
+  POLL_INTERVAL_BACKGROUND_MS,
+  SESSION_MISSING_GRACE_MS,
+  SESSION_READY_POLL_INTERVAL_MS,
+  SESSION_READY_TIMEOUT_MS,
 } from "../../shared/tmux"
 import { log } from "../../shared"
-import type { SessionMapping } from "./decision-engine"
-import {
-  coerceSessionCreatedEvent,
-  handleSessionCreated,
-  handleSessionDeleted,
-  type SessionCreatedEvent,
-} from "./event-handlers"
-import { createSessionPollingController, type SessionPollingController } from "./polling"
-import { cleanupTmuxSessions } from "./cleanup"
-
+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"
 type OpencodeClient = PluginInput["client"]
 
+interface SessionCreatedEvent {
+  type: string
+  properties?: { info?: { id?: string; parentID?: string; title?: string } }
+}
+
 export interface TmuxUtilDeps {
   isInsideTmux: () => boolean
   getCurrentPaneId: () => string | undefined
@@ -28,6 +31,13 @@ const defaultTmuxDeps: TmuxUtilDeps = {
   getCurrentPaneId: defaultGetCurrentPaneId,
 }
 
+const SESSION_TIMEOUT_MS = 10 * 60 * 1000
+
+// Stability detection constants (prevents premature closure - see issue #1330)
+// Mirrors the proven pattern from background-agent/manager.ts
+const MIN_STABILITY_TIME_MS = 10 * 1000  // Must run at least 10s before stability detection kicks in
+const STABLE_POLLS_REQUIRED = 3          // 3 consecutive idle polls (~6s with 2s poll interval)
+
 /**
  * State-first Tmux Session Manager
  * 
@@ -48,8 +58,7 @@ export class TmuxSessionManager {
   private sessions = new Map<string, TrackedSession>()
   private pendingSessions = new Set<string>()
   private deps: TmuxUtilDeps
-  private polling: SessionPollingController
-
+  private pollingManager: TmuxPollingManager
   constructor(ctx: PluginInput, tmuxConfig: TmuxConfig, deps: TmuxUtilDeps = defaultTmuxDeps) {
     this.client = ctx.client
     this.tmuxConfig = tmuxConfig
@@ -57,15 +66,11 @@ export class TmuxSessionManager {
     const defaultPort = process.env.OPENCODE_PORT ?? "4096"
     this.serverUrl = ctx.serverUrl?.toString() ?? `http://localhost:${defaultPort}`
     this.sourcePaneId = deps.getCurrentPaneId()
-
-    this.polling = createSessionPollingController({
-      client: this.client,
-      tmuxConfig: this.tmuxConfig,
-      serverUrl: this.serverUrl,
-      sourcePaneId: this.sourcePaneId,
-      sessions: this.sessions,
-    })
-
+    this.pollingManager = new TmuxPollingManager(
+      this.client,
+      this.sessions,
+      this.closeSessionById.bind(this)
+    )
     log("[tmux-session-manager] initialized", {
       configEnabled: this.tmuxConfig.enabled,
       tmuxConfig: this.tmuxConfig,
@@ -73,7 +78,6 @@ export class TmuxSessionManager {
       sourcePaneId: this.sourcePaneId,
     })
   }
-
   private isEnabled(): boolean {
     return this.tmuxConfig.enabled && this.deps.isInsideTmux()
   }
@@ -93,58 +97,254 @@ export class TmuxSessionManager {
     }))
   }
 
+  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 = (statusResult.data ?? {}) 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
+  }
+
+  // NOTE: Exposed (via `as any`) for test stability checks.
+  // Actual polling is owned by TmuxPollingManager.
+  private async pollSessions(): Promise<void> {
+    await (this.pollingManager as any).pollSessions()
+  }
+
   async onSessionCreated(event: SessionCreatedEvent): Promise<void> {
-    await handleSessionCreated(
-      {
-        client: this.client,
-        tmuxConfig: this.tmuxConfig,
-        serverUrl: this.serverUrl,
-        sourcePaneId: this.sourcePaneId,
-        sessions: this.sessions,
-        pendingSessions: this.pendingSessions,
-        isInsideTmux: this.deps.isInsideTmux,
-        isEnabled: () => this.isEnabled(),
-        getCapacityConfig: () => this.getCapacityConfig(),
-        getSessionMappings: () => this.getSessionMappings(),
-        waitForSessionReady: (sessionId) => this.polling.waitForSessionReady(sessionId),
-        startPolling: () => this.polling.startPolling(),
-      },
-      event,
-    )
+    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.sessions.has(sessionId) || this.pendingSessions.has(sessionId)) {
+      log("[tmux-session-manager] session already tracked or pending", { sessionId })
+      return
+    }
+
+    if (!this.sourcePaneId) {
+      log("[tmux-session-manager] no source pane id")
+      return
+    }
+
+    this.pendingSessions.add(sessionId)
+
+    try {
+      const state = await queryWindowState(this.sourcePaneId)
+      if (!state) {
+        log("[tmux-session-manager] failed to query window state")
+        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 })
+        return
+      }
+
+      const result = await executeActions(
+        decision.actions,
+        { config: this.tmuxConfig, serverUrl: this.serverUrl, windowState: state }
+      )
+
+      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,
+          })
+        }
+        
+        const now = Date.now()
+        this.sessions.set(sessionId, {
+          sessionId,
+          paneId: result.spawnedPaneId,
+          description: title,
+          createdAt: new Date(now),
+          lastSeenAt: new Date(now),
+        })
+        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,
+          })),
+        })
+      }
+    } finally {
+      this.pendingSessions.delete(sessionId)
+    }
   }
 
   async onSessionDeleted(event: { sessionID: string }): Promise<void> {
-    await handleSessionDeleted(
-      {
-        tmuxConfig: this.tmuxConfig,
-        serverUrl: this.serverUrl,
-        sourcePaneId: this.sourcePaneId,
-        sessions: this.sessions,
-        isEnabled: () => this.isEnabled(),
-        getSessionMappings: () => this.getSessionMappings(),
-        stopPolling: () => this.polling.stopPolling(),
-      },
-      event,
-    )
+    if (!this.isEnabled()) return
+    if (!this.sourcePaneId) return
+
+    const tracked = this.sessions.get(event.sessionID)
+    if (!tracked) return
+
+    log("[tmux-session-manager] onSessionDeleted", { sessionId: event.sessionID })
+
+    const state = await queryWindowState(this.sourcePaneId)
+    if (!state) {
+      this.sessions.delete(event.sessionID)
+      return
+    }
+
+    const closeAction = decideCloseAction(state, event.sessionID, this.getSessionMappings())
+    if (closeAction) {
+      await executeAction(closeAction, { config: this.tmuxConfig, serverUrl: this.serverUrl, windowState: state })
+    }
+
+    this.sessions.delete(event.sessionID)
+
+    if (this.sessions.size === 0) {
+      this.pollingManager.stopPolling()
+    }
+  }
+
+
+  private async closeSessionById(sessionId: string): Promise<void> {
+    const tracked = this.sessions.get(sessionId)
+    if (!tracked) return
+
+    log("[tmux-session-manager] closing session pane", {
+      sessionId,
+      paneId: tracked.paneId,
+    })
+
+    const state = this.sourcePaneId ? await queryWindowState(this.sourcePaneId) : null
+    if (state) {
+      await executeAction(
+        { type: "close", paneId: tracked.paneId, sessionId },
+        { config: this.tmuxConfig, serverUrl: this.serverUrl, windowState: state }
+      )
+    }
+
+    this.sessions.delete(sessionId)
+
+    if (this.sessions.size === 0) {
+      this.pollingManager.stopPolling()
+    }
   }
 
   createEventHandler(): (input: { event: { type: string; properties?: unknown } }) => Promise<void> {
     return async (input) => {
-      await this.onSessionCreated(coerceSessionCreatedEvent(input.event))
+      await this.onSessionCreated(input.event as SessionCreatedEvent)
     }
   }
 
-  async pollSessions(): Promise<void> {
-    return this.polling.pollSessions()
-  }
-
   async cleanup(): Promise<void> {
-    await cleanupTmuxSessions({
-      tmuxConfig: this.tmuxConfig,
-      serverUrl: this.serverUrl,
-      sourcePaneId: this.sourcePaneId,
-      sessions: this.sessions,
-      stopPolling: () => this.polling.stopPolling(),
-    })
+    this.pollingManager.stopPolling()
+
+    if (this.sessions.size > 0) {
+      log("[tmux-session-manager] closing all panes", { count: this.sessions.size })
+      const state = this.sourcePaneId ? await queryWindowState(this.sourcePaneId) : null
+      
+      if (state) {
+        const closePromises = Array.from(this.sessions.values()).map((s) =>
+          executeAction(
+            { type: "close", paneId: s.paneId, sessionId: s.sessionId },
+            { config: this.tmuxConfig, serverUrl: this.serverUrl, windowState: state }
+          ).catch((err) =>
+            log("[tmux-session-manager] cleanup error for pane", {
+              paneId: s.paneId,
+              error: String(err),
+            }),
+          ),
+        )
+        await Promise.all(closePromises)
+      }
+      this.sessions.clear()
+    }
+
+    log("[tmux-session-manager] cleanup complete")
   }
 }