@wpro-eng/opencode-config 1.4.0 → 1.5.0

package/plugin/wpromote-orchestration.ts

@@ -7,8 +7,7 @@ import { parse as parseJsonc } from "jsonc-parser"
 
 type ProviderMode = "copilot" | "native"
 type TaskStatus = "queued" | "running" | "retrying" | "completed" | "failed" | "stopped"
-type TmuxLayout = "main-horizontal" | "main-vertical" | "tiled" | "even-horizontal" | "even-vertical"
-type TmuxState = "disabled" | "queued" | "attached" | "failed"
+type TmuxState = "disabled" | "attached" | "failed"
 
 interface OrchestrationConfig {
   providerMode: ProviderMode
@@ -52,10 +51,6 @@ interface OrchestrationConfig {
   }
   tmux: {
     enabled: boolean
-    layout: TmuxLayout
-    mainPaneSize: number
-    mainPaneMinWidth: number
-    agentPaneMinWidth: number
     sessionPrefix: string
   }
 }
@@ -81,7 +76,7 @@ interface TaskRecord {
   fallbackReason: string | null
   blockedBy: string[]
   blocks: string[]
-  tmuxPaneID: string | null
+  tmuxWindowID: string | null
   tmuxSessionName: string | null
   tmuxState: TmuxState
 }
@@ -89,6 +84,7 @@ interface TaskRecord {
 interface SessionState {
   loopEnabled: boolean
   tmuxMissingWarned: boolean
+  tmuxSessionCreated: boolean
   telemetry: {
     created: number
     resumed: number
@@ -104,7 +100,6 @@ interface SessionState {
     message: string
     taskID: string
   }[]
-  deferredTmuxQueue: string[]
 }
 
 const USER_HOME = process.env.HOME && process.env.HOME.trim().length > 0 ? process.env.HOME : homedir()
@@ -152,10 +147,6 @@ const DEFAULT_CONFIG: OrchestrationConfig = {
   },
   tmux: {
     enabled: false,
-    layout: "main-vertical",
-    mainPaneSize: 60,
-    mainPaneMinWidth: 120,
-    agentPaneMinWidth: 40,
     sessionPrefix: "wpo",
   },
 }
@@ -171,6 +162,7 @@ function getSessionState(sessionID: string): SessionState {
   const state: SessionState = {
     loopEnabled: false,
     tmuxMissingWarned: false,
+    tmuxSessionCreated: false,
     telemetry: {
       created: 0,
       resumed: 0,
@@ -181,7 +173,6 @@ function getSessionState(sessionID: string): SessionState {
       timedOut: 0,
     },
     notifications: [],
-    deferredTmuxQueue: [],
   }
   sessionStates.set(sessionID, state)
   return state
@@ -264,19 +255,6 @@ function parseCategoryConcurrency(value: unknown): Record<string, number> {
   return parsed
 }
 
-function parseTmuxLayout(value: unknown): TmuxLayout {
-  if (
-    value === "main-horizontal" ||
-    value === "main-vertical" ||
-    value === "tiled" ||
-    value === "even-horizontal" ||
-    value === "even-vertical"
-  ) {
-    return value
-  }
-  return DEFAULT_CONFIG.tmux.layout
-}
-
 function parseSessionPrefix(value: unknown): string {
   if (typeof value !== "string") return DEFAULT_CONFIG.tmux.sessionPrefix
   const trimmed = value.trim()
@@ -383,15 +361,6 @@ function parseConfigFromFile(): ConfigLoadResult {
           },
           tmux: {
             enabled: tmux.enabled === true,
-            layout: parseTmuxLayout(tmux.layout),
-            mainPaneSize: parseBoundedInt(tmux.mainPaneSize, DEFAULT_CONFIG.tmux.mainPaneSize, 20, 80),
-            mainPaneMinWidth: parseBoundedInt(tmux.mainPaneMinWidth, DEFAULT_CONFIG.tmux.mainPaneMinWidth, 40, 400),
-            agentPaneMinWidth: parseBoundedInt(
-              tmux.agentPaneMinWidth,
-              DEFAULT_CONFIG.tmux.agentPaneMinWidth,
-              20,
-              200,
-            ),
             sessionPrefix: parseSessionPrefix(tmux.sessionPrefix),
           },
         },
@@ -480,6 +449,10 @@ function getCategoryConcurrencyLimit(config: OrchestrationConfig, category: stri
   return config.categories.maxConcurrent[category] ?? config.limits.maxConcurrent
 }
 
+function isTerminalStatus(status: TaskStatus): boolean {
+  return status === "completed" || status === "failed" || status === "stopped"
+}
+
 function isActiveTaskStatus(status: TaskStatus): boolean {
   return status === "running" || status === "retrying" || status === "queued"
 }
@@ -515,12 +488,14 @@ function safeTaskRecord(value: unknown): TaskRecord | null {
   const blocks = Array.isArray(value.blocks)
     ? value.blocks.filter((item): item is string => typeof item === "string")
     : []
-  const tmuxPaneID = value.tmuxPaneID === null ? null : asString(value.tmuxPaneID) ?? null
+  // Accept both old "tmuxPaneID" and new "tmuxWindowID" for backward compat with persisted data
+  const tmuxWindowID = value.tmuxWindowID === null ? null
+    : asString(value.tmuxWindowID) ?? (value.tmuxPaneID === null ? null : asString(value.tmuxPaneID) ?? null)
   const tmuxSessionName = value.tmuxSessionName === null ? null : asString(value.tmuxSessionName) ?? null
   const tmuxState = asString(value.tmuxState)
 
   const validTmuxState =
-    tmuxState === "disabled" || tmuxState === "queued" || tmuxState === "attached" || tmuxState === "failed"
+    tmuxState === "disabled" || tmuxState === "attached" || tmuxState === "failed"
 
   const validStatus =
     status === "queued" ||
@@ -550,7 +525,7 @@ function safeTaskRecord(value: unknown): TaskRecord | null {
     fallbackReason,
     blockedBy,
     blocks,
-    tmuxPaneID,
+    tmuxWindowID,
     tmuxSessionName,
     tmuxState: validTmuxState ? tmuxState : "disabled",
   }
@@ -643,7 +618,7 @@ function recoverPersistedTasks(config: OrchestrationConfig): void {
       record.status = "queued"
       record.updatedAt = nowIso()
       record.details = "Recovered after restart; pending re-dispatch"
-      record.tmuxPaneID = null
+      record.tmuxWindowID = null
       record.tmuxSessionName = null
       record.tmuxState = "disabled"
       recovered += 1
@@ -675,7 +650,7 @@ function createTaskRecord(sessionID: string, title: string, agent: string, categ
     fallbackReason: null,
     blockedBy: [],
     blocks: [],
-    tmuxPaneID: null,
+    tmuxWindowID: null,
     tmuxSessionName: null,
     tmuxState: "disabled",
   }
@@ -706,6 +681,14 @@ function enforceTaskTimeouts(sessionID: string, config: OrchestrationConfig): nu
 
 function setTaskStatus(record: TaskRecord, status: TaskStatus, details?: string): void {
   const previousStatus = record.status
+
+  // Terminal states are sticky: once a task is completed/failed/stopped,
+  // it cannot transition back to any other state. This prevents
+  // tool.execute.after from overwriting a /stop command's "stopped" status.
+  if (isTerminalStatus(previousStatus) && previousStatus !== status) {
+    return
+  }
+
   record.status = status
   record.updatedAt = nowIso()
   if (details) record.details = details
@@ -764,6 +747,47 @@ function classifyFailure(output: string): { code: number | null; reason: string
   return { code: null, reason: "unknown" }
 }
 
+// Structural failure patterns that indicate the task tool itself failed,
+// not that the agent's analysis merely discusses failures.
+const FAILURE_SIGNAL_PATTERNS = [
+  /^error:/im,
+  /task failed/i,
+  /execution failed/i,
+  /provider.*error/i,
+  /\b(4\d\d|5\d\d)\s+(error|status|response)\b/i,
+  /rate limit/i,
+  /too many requests/i,
+  /api key/i,
+  /credential/i,
+  /timed?\s*out/i,
+  /connection refused/i,
+  /ECONNREFUSED/,
+  /ETIMEDOUT/,
+]
+
+// The max length of output we consider "short enough" to be an error message
+// rather than substantive agent analysis. Subagent responses with real work
+// are typically 500+ chars; provider errors are usually under 300.
+const FAILURE_OUTPUT_MAX_LENGTH = 300
+
+function isLikelyTaskFailure(output: string): boolean {
+  if (output.length === 0) return false
+
+  // Short outputs that contain "failed" are likely actual errors from the
+  // task tool or provider, not agent analysis that happens to mention failure.
+  if (output.length <= FAILURE_OUTPUT_MAX_LENGTH && output.toLowerCase().includes("failed")) {
+    return true
+  }
+
+  // Check for structural failure patterns regardless of output length.
+  // These are specific enough to not false-positive on agent analysis text.
+  for (const pattern of FAILURE_SIGNAL_PATTERNS) {
+    if (pattern.test(output)) return true
+  }
+
+  return false
+}
+
 function getNextProvider(config: OrchestrationConfig, current: ProviderMode): ProviderMode | null {
   const order = config.runtimeFallback.providerOrder
   const index = order.indexOf(current)
@@ -789,110 +813,102 @@ function runTmux(args: string[]): { ok: boolean; stdout: string; stderr: string
   }
 }
 
-function normalizeTaskToken(value: string): string {
-  return value.toLowerCase().replace(/[^a-z0-9_-]/g, "-").slice(0, 18)
+function normalizeTmuxToken(value: string): string {
+  return value.toLowerCase().replace(/[^a-z0-9_-]/g, "-")
 }
 
-function getTmuxSessionName(config: OrchestrationConfig, record: TaskRecord): string {
-  const prefix = normalizeTaskToken(config.tmux.sessionPrefix)
-  const token = normalizeTaskToken(record.id)
+// Builds the dedicated tmux session name for an OpenCode session.
+// All task windows for this session live inside this one tmux session.
+function getAgentSessionName(config: OrchestrationConfig, sessionID: string): string {
+  const prefix = normalizeTmuxToken(config.tmux.sessionPrefix)
+  const token = normalizeTmuxToken(sessionID).slice(0, 24)
   return `${prefix}-${token}`
 }
 
-function getSplitDirection(layout: TmuxLayout): "-h" | "-v" {
-  return layout === "main-horizontal" ? "-v" : "-h"
-}
+// Ensures the dedicated tmux session exists for this OpenCode session.
+// Creates it detached on first call, subsequent calls are no-ops.
+function ensureAgentSession(config: OrchestrationConfig, sessionID: string): { ok: boolean; sessionName: string; reason: string } {
+  const sessionName = getAgentSessionName(config, sessionID)
+  const state = getSessionState(sessionID)
 
-function applyTmuxLayout(config: OrchestrationConfig): void {
-  runTmux(["select-layout", config.tmux.layout])
-  if (config.tmux.layout === "main-horizontal") {
-    runTmux(["set-window-option", "main-pane-height", `${config.tmux.mainPaneSize}%`])
-  }
-  if (config.tmux.layout === "main-vertical") {
-    runTmux(["set-window-option", "main-pane-width", `${config.tmux.mainPaneSize}%`])
+  if (state.tmuxSessionCreated) {
+    // Verify it still exists (user might have killed it)
+    const check = runTmux(["has-session", "-t", sessionName])
+    if (check.ok) return { ok: true, sessionName, reason: "exists" }
+    // Session was killed externally, recreate it
+    state.tmuxSessionCreated = false
   }
-}
 
-function getWindowStats(): { width: number; height: number; paneCount: number } {
-  const info = runTmux(["display-message", "-p", "#{window_width},#{window_height},#{window_panes}"])
-  if (!info.ok) return { width: 0, height: 0, paneCount: 0 }
-  const [widthStr, heightStr, paneCountStr] = info.stdout.trim().split(",")
-  return {
-    width: Number.parseInt(widthStr ?? "0", 10) || 0,
-    height: Number.parseInt(heightStr ?? "0", 10) || 0,
-    paneCount: Number.parseInt(paneCountStr ?? "0", 10) || 0,
+  // Create a new detached session. The initial window is a placeholder
+  // that will be replaced by the first task window.
+  const create = runTmux(["new-session", "-d", "-s", sessionName, "-n", "agents"])
+  if (!create.ok) {
+    // Session might already exist from a previous run
+    const check = runTmux(["has-session", "-t", sessionName])
+    if (check.ok) {
+      state.tmuxSessionCreated = true
+      return { ok: true, sessionName, reason: "already-exists" }
+    }
+    return { ok: false, sessionName, reason: create.stderr.trim() || "new-session failed" }
   }
-}
 
-function estimateMaxAgentPanes(config: OrchestrationConfig): number {
-  const stats = getWindowStats()
-  if (stats.width <= 0 || stats.height <= 0) return 0
-  const divider = 1
-  const desiredMainWidth = Math.floor((stats.width - divider) * (config.tmux.mainPaneSize / 100))
-  const mainWidth = Math.max(config.tmux.mainPaneMinWidth, desiredMainWidth)
-  const rightWidth = Math.max(0, stats.width - mainWidth - divider)
-  if (rightWidth <= 0) return 0
-  const columns = Math.max(1, Math.floor((rightWidth + divider) / (config.tmux.agentPaneMinWidth + divider)))
-  const rows = Math.max(1, Math.floor((stats.height + divider) / (11 + divider)))
-  return columns * rows
+  state.tmuxSessionCreated = true
+  return { ok: true, sessionName, reason: "created" }
 }
 
-function attachTaskPane(record: TaskRecord, config: OrchestrationConfig): { attached: boolean; reason: string } {
+// Creates a new tmux window inside the agent session for a task.
+function attachTaskWindow(record: TaskRecord, config: OrchestrationConfig): { attached: boolean; reason: string } {
   if (!config.tmux.enabled) {
     record.tmuxState = "disabled"
-    record.tmuxPaneID = null
+    record.tmuxWindowID = null
     record.tmuxSessionName = null
     return { attached: false, reason: "tmux disabled" }
   }
   if (!isInsideTmux()) {
     record.tmuxState = "disabled"
-    record.tmuxPaneID = null
+    record.tmuxWindowID = null
     record.tmuxSessionName = null
     return { attached: false, reason: "not inside tmux" }
   }
   if (!hasTmuxBinary()) {
     record.tmuxState = "disabled"
-    record.tmuxPaneID = null
+    record.tmuxWindowID = null
     record.tmuxSessionName = null
     notifyTmuxMissingOnce(record.sessionID)
     return { attached: false, reason: "tmux binary unavailable" }
   }
 
-  const currentAttachedCount = getTasksForSession(record.sessionID).filter((task) => task.tmuxState === "attached").length
-  const maxAgentPanes = estimateMaxAgentPanes(config)
-  if (maxAgentPanes > 0 && currentAttachedCount >= maxAgentPanes) {
-    record.tmuxState = "queued"
-    return { attached: false, reason: `no pane capacity (${currentAttachedCount}/${maxAgentPanes})` }
+  const session = ensureAgentSession(config, record.sessionID)
+  if (!session.ok) {
+    record.tmuxState = "failed"
+    return { attached: false, reason: session.reason }
   }
 
-  const splitDirection = getSplitDirection(config.tmux.layout)
-  const split = runTmux(["split-window", splitDirection, "-d", "-P", "-F", "#{pane_id}"])
-  if (!split.ok) {
+  const windowName = `${normalizeTmuxToken(record.id)}:${record.title.slice(0, 20).replace(/[^a-zA-Z0-9_-]/g, "-")}`
+  const newWindow = runTmux(["new-window", "-t", session.sessionName, "-n", windowName, "-d", "-P", "-F", "#{window_id}"])
+  if (!newWindow.ok) {
     record.tmuxState = "failed"
-    return { attached: false, reason: split.stderr.trim() || "split-window failed" }
+    return { attached: false, reason: newWindow.stderr.trim() || "new-window failed" }
   }
 
-  const paneID = split.stdout.trim().split("\n")[0]?.trim()
-  if (!paneID) {
+  const windowID = newWindow.stdout.trim().split("\n")[0]?.trim()
+  if (!windowID) {
     record.tmuxState = "failed"
-    return { attached: false, reason: "split-window returned empty pane id" }
+    return { attached: false, reason: "new-window returned empty window id" }
   }
 
-  const sessionName = getTmuxSessionName(config, record)
-  const title = `${sessionName}:${record.title.slice(0, 24)}`
-  runTmux(["select-pane", "-t", paneID, "-T", title])
-  runTmux(["send-keys", "-t", paneID, `printf \"[${sessionName}] tracking ${record.id}\\n\"`, "Enter"])
-  applyTmuxLayout(config)
+  runTmux(["send-keys", "-t", `${session.sessionName}:${windowName}`, `printf \"[${session.sessionName}] tracking ${record.id}\\n\"`, "Enter"])
 
   record.tmuxState = "attached"
-  record.tmuxPaneID = paneID
-  record.tmuxSessionName = sessionName
-  return { attached: true, reason: paneID }
+  record.tmuxWindowID = windowID
+  record.tmuxSessionName = session.sessionName
+  return { attached: true, reason: windowID }
 }
 
-function closeTaskPane(record: TaskRecord, config: OrchestrationConfig): void {
-  if (!record.tmuxPaneID) {
-    record.tmuxPaneID = null
+// Closes a task's tmux window. If it's the last window, the session dies automatically.
+function closeTaskWindow(record: TaskRecord, config: OrchestrationConfig): void {
+  if (!record.tmuxWindowID) {
+    record.tmuxWindowID = null
     record.tmuxSessionName = null
     record.tmuxState = "disabled"
     persistSessionTasks(record.sessionID)
@@ -900,63 +916,30 @@ function closeTaskPane(record: TaskRecord, config: OrchestrationConfig): void {
   }
 
   if (!config.tmux.enabled || !isInsideTmux() || !hasTmuxBinary()) {
-    record.tmuxPaneID = null
+    record.tmuxWindowID = null
     record.tmuxSessionName = null
     record.tmuxState = "disabled"
     if (!hasTmuxBinary()) notifyTmuxMissingOnce(record.sessionID)
     persistSessionTasks(record.sessionID)
     return
   }
-  runTmux(["send-keys", "-t", record.tmuxPaneID, "C-c"])
-  runTmux(["kill-pane", "-t", record.tmuxPaneID])
-  record.tmuxPaneID = null
+  runTmux(["send-keys", "-t", record.tmuxWindowID, "C-c"])
+  runTmux(["kill-window", "-t", record.tmuxWindowID])
+  record.tmuxWindowID = null
   record.tmuxSessionName = null
   record.tmuxState = "disabled"
   persistSessionTasks(record.sessionID)
 }
 
-function enqueueDeferredTmuxTask(sessionID: string, taskID: string): void {
-  const state = getSessionState(sessionID)
-  if (!state.deferredTmuxQueue.includes(taskID)) state.deferredTmuxQueue.push(taskID)
-}
-
-function processDeferredTmuxQueue(sessionID: string, config: OrchestrationConfig): number {
-  if (!config.tmux.enabled) return 0
-  const state = getSessionState(sessionID)
-  if (state.deferredTmuxQueue.length === 0) return 0
-
-  let attached = 0
-  const remaining: string[] = []
-  for (const taskID of state.deferredTmuxQueue) {
-    const record = taskRecords.get(taskID)
-    if (!record || record.sessionID !== sessionID) continue
-    if (record.status === "completed" || record.status === "failed" || record.status === "stopped") continue
-    const result = attachTaskPane(record, config)
-    if (result.attached) {
-      attached += 1
-      pushNotification(sessionID, "info", `Tmux pane attached for ${record.title}`, record.id)
-      persistSessionTasks(sessionID)
-      continue
-    }
-    if (record.tmuxState === "queued") {
-      remaining.push(taskID)
-      break
-    }
-  }
-
-  state.deferredTmuxQueue = remaining
-  return attached
-}
-
-function verifyTaskPane(record: TaskRecord): boolean {
-  if (!record.tmuxPaneID) return false
-  const probe = runTmux(["display-message", "-p", "-t", record.tmuxPaneID, "#{pane_id}"])
+function verifyTaskWindow(record: TaskRecord): boolean {
+  if (!record.tmuxWindowID) return false
+  const probe = runTmux(["display-message", "-p", "-t", record.tmuxWindowID, "#{window_id}"])
   return probe.ok
 }
 
-function reconcileTmuxState(sessionID: string, config: OrchestrationConfig): { staleClosed: number; missing: number; queuedAttached: number } {
+function reconcileTmuxState(sessionID: string, config: OrchestrationConfig): { staleClosed: number; missing: number } {
   if (!config.tmux.enabled || !isInsideTmux() || !hasTmuxBinary()) {
-    return { staleClosed: 0, missing: 0, queuedAttached: 0 }
+    return { staleClosed: 0, missing: 0 }
   }
 
   let staleClosed = 0
@@ -964,31 +947,55 @@ function reconcileTmuxState(sessionID: string, config: OrchestrationConfig): { s
   const tasks = getTasksForSession(sessionID)
   for (const record of tasks) {
     const terminal = record.status === "completed" || record.status === "failed" || record.status === "stopped"
-    if (terminal && record.tmuxPaneID) {
-      closeTaskPane(record, config)
+    if (terminal && record.tmuxWindowID) {
+      closeTaskWindow(record, config)
       staleClosed += 1
       continue
     }
-    if (record.tmuxState === "attached" && record.tmuxPaneID && !verifyTaskPane(record)) {
+    if (record.tmuxState === "attached" && record.tmuxWindowID && !verifyTaskWindow(record)) {
       record.tmuxState = "failed"
-      record.tmuxPaneID = null
+      record.tmuxWindowID = null
       record.tmuxSessionName = null
       missing += 1
       persistSessionTasks(sessionID)
-      pushNotification(sessionID, "warn", `Tmux pane missing for ${record.title}`, record.id)
+      pushNotification(sessionID, "warn", `Tmux window missing for ${record.title}`, record.id)
     }
   }
-  const queuedAttached = processDeferredTmuxQueue(sessionID, config)
-  return { staleClosed, missing, queuedAttached }
+  if (staleClosed > 0 || missing > 0) {
+    maybeDestroyIdleAgentSession(config, sessionID)
+  }
+  return { staleClosed, missing }
+}
+
+// Kills the entire agent session for this OpenCode session.
+function destroyAgentSession(config: OrchestrationConfig, sessionID: string): void {
+  if (!hasTmuxBinary()) return
+  const sessionName = getAgentSessionName(config, sessionID)
+  runTmux(["kill-session", "-t", sessionName])
+  const state = getSessionState(sessionID)
+  state.tmuxSessionCreated = false
+}
+
+// Destroys the agent session if no tasks have attached windows remaining.
+// Called after a task window is closed to clean up when all work is done.
+function maybeDestroyIdleAgentSession(config: OrchestrationConfig, sessionID: string): void {
+  if (!config.tmux.enabled || !isInsideTmux() || !hasTmuxBinary()) return
+  const state = getSessionState(sessionID)
+  if (!state.tmuxSessionCreated) return
+
+  const hasAttachedWindows = getTasksForSession(sessionID).some((task) => task.tmuxState === "attached")
+  if (!hasAttachedWindows) {
+    destroyAgentSession(config, sessionID)
+  }
 }
 
 function formatTaskLine(record: TaskRecord): string {
   const bg = record.backgroundTaskID ? ` bg=${record.backgroundTaskID}` : ""
   const category = record.category ? ` category=${record.category}` : ""
   const deps = record.blockedBy.length > 0 ? ` blockedBy=${record.blockedBy.join(",")}` : ""
-  const pane = record.tmuxPaneID ? ` pane=${record.tmuxPaneID}` : ""
+  const window = record.tmuxWindowID ? ` window=${record.tmuxWindowID}` : ""
   const tmuxState = ` tmux=${record.tmuxState}`
-  return `- ${record.id} [${record.status}] ${record.agent} \"${record.title}\"${bg}${category}${deps}${pane}${tmuxState}`
+  return `- ${record.id} [${record.status}] ${record.agent} \"${record.title}\"${bg}${category}${deps}${window}${tmuxState}`
 }
 
 interface DiagnosticCheck {
@@ -1023,7 +1030,6 @@ function runDiagnostics(sessionID: string): string {
     return active > limit
   })
   const attachedTmuxTasks = tasks.filter((task) => task.tmuxState === "attached")
-  const queuedTmuxTasks = tasks.filter((task) => task.tmuxState === "queued")
   const state = getSessionState(sessionID)
 
   const requiredCommands = ["continue", "stop", "tasks", "task", "diagnostics", "look-at"]
@@ -1064,10 +1070,6 @@ function runDiagnostics(sessionID: string): string {
     diagnosticsCheck("notifications:maxItems", config.notifications.maxItems >= 10 && config.notifications.maxItems <= 500, "set orchestration.notifications.maxItems in range 10..500"),
     diagnosticsCheck("recovery:autoResumeOnStart", typeof config.recovery.autoResumeOnStart === "boolean", "set orchestration.recovery.autoResumeOnStart to true/false"),
     diagnosticsCheck("tmux:enabled", typeof config.tmux.enabled === "boolean", "set orchestration.tmux.enabled to true/false"),
-    diagnosticsCheck("tmux:layout", ["main-horizontal", "main-vertical", "tiled", "even-horizontal", "even-vertical"].includes(config.tmux.layout), "set orchestration.tmux.layout to a supported layout"),
-    diagnosticsCheck("tmux:mainPaneSize", config.tmux.mainPaneSize >= 20 && config.tmux.mainPaneSize <= 80, "set orchestration.tmux.mainPaneSize in range 20..80"),
-    diagnosticsCheck("tmux:mainPaneMinWidth", config.tmux.mainPaneMinWidth >= 40 && config.tmux.mainPaneMinWidth <= 400, "set orchestration.tmux.mainPaneMinWidth in range 40..400"),
-    diagnosticsCheck("tmux:agentPaneMinWidth", config.tmux.agentPaneMinWidth >= 20 && config.tmux.agentPaneMinWidth <= 200, "set orchestration.tmux.agentPaneMinWidth in range 20..200"),
     diagnosticsCheck("tmux:sessionPrefix", /^[a-zA-Z0-9_-]{2,20}$/.test(config.tmux.sessionPrefix), "set orchestration.tmux.sessionPrefix to 2..20 chars [a-zA-Z0-9_-]"),
     diagnosticsCheck("tmux:insideSession", !config.tmux.enabled || isInsideTmux(), "run inside tmux or disable orchestration.tmux.enabled"),
     diagnosticsCheck("tmux:binary", !config.tmux.enabled || hasTmuxBinary(), "install tmux and ensure it is on PATH"),
@@ -1081,6 +1083,11 @@ function runDiagnostics(sessionID: string): string {
   const passCount = allChecks.length - failedChecks.length
   const failCount = failedChecks.length
 
+  const agentSessionName = getAgentSessionName(config, sessionID)
+  const agentSessionExists = config.tmux.enabled && isInsideTmux() && hasTmuxBinary()
+    ? runTmux(["has-session", "-t", agentSessionName]).ok
+    : false
+
   const lines = [
     "# Wpromote Diagnostics (Full)",
     "",
@@ -1102,13 +1109,12 @@ function runDiagnostics(sessionID: string): string {
     `- Active task records in this session: ${tasks.length}`,
     `- Persisted task records across sessions: ${getPersistedTaskCount()}`,
     `- Active delegated tasks: ${activeTasks.length}/${config.limits.maxConcurrent}`,
-    `- Active tmux panes: ${attachedTmuxTasks.length}`,
-    `- Deferred tmux queue depth: ${state.deferredTmuxQueue.length}`,
+    `- Active tmux windows: ${attachedTmuxTasks.length}`,
+    `- Agent tmux session: ${agentSessionExists ? agentSessionName : "none"}`,
     `- Recovery auto-resume on startup: ${config.recovery.autoResumeOnStart ? "enabled" : "disabled"}`,
     `- Timed out tasks auto-marked failed in this pass: ${timedOutTasks}`,
-    `- Tmux stale pane cleanups in this pass: ${tmuxHealth.staleClosed}`,
-    `- Tmux missing pane detections in this pass: ${tmuxHealth.missing}`,
-    `- Deferred tmux attaches completed in this pass: ${tmuxHealth.queuedAttached}`,
+    `- Tmux stale window cleanups in this pass: ${tmuxHealth.staleClosed}`,
+    `- Tmux missing window detections in this pass: ${tmuxHealth.missing}`,
     `- Loop mode: ${getSessionState(sessionID).loopEnabled ? "enabled" : "disabled"}`,
     "",
     "## Hook Health",
@@ -1119,7 +1125,6 @@ function runDiagnostics(sessionID: string): string {
     `- telemetry: ${config.hooks.telemetry ? "enabled" : "disabled"}`,
     `- telemetry counters: created=${state.telemetry.created}, resumed=${state.telemetry.resumed}, completed=${state.telemetry.completed}, failed=${state.telemetry.failed}, retrying=${state.telemetry.retrying}, stopped=${state.telemetry.stopped}, timedOut=${state.telemetry.timedOut}`,
     `- notifications: ${config.notifications.enabled ? "enabled" : "disabled"} (buffer=${state.notifications.length}/${config.notifications.maxItems})`,
-    `- tmux queue: ${config.tmux.enabled ? "enabled" : "disabled"} (queued=${queuedTmuxTasks.length})`,
     "",
     "## Provider Routing",
     `- Current mode: ${config.providerMode}`,
@@ -1161,7 +1166,7 @@ function formatSingleTask(record: TaskRecord): string {
     `- Updated: ${record.updatedAt}`,
     `- Background ID: ${record.backgroundTaskID ?? "n/a"}`,
     `- Tmux State: ${record.tmuxState}`,
-    `- Tmux Pane ID: ${record.tmuxPaneID ?? "n/a"}`,
+    `- Tmux Window ID: ${record.tmuxWindowID ?? "n/a"}`,
     `- Tmux Session: ${record.tmuxSessionName ?? "n/a"}`,
     `- Blocked By: ${record.blockedBy.length > 0 ? record.blockedBy.join(", ") : "none"}`,
     `- Blocks: ${record.blocks.length > 0 ? record.blocks.join(", ") : "none"}`,
@@ -1195,11 +1200,11 @@ const orchestrationTool = tool({
         if (record.status === "queued" || record.status === "running" || record.status === "retrying") {
           setTaskStatus(record, "stopped", "Stopped by /stop command")
         }
-        if (record.tmuxPaneID) {
-          closeTaskPane(record, config)
+        if (record.tmuxWindowID) {
+          closeTaskWindow(record, config)
         }
       }
-      state.deferredTmuxQueue = []
+      destroyAgentSession(config, context.sessionID)
       return "Loop and queue processing halted for this session. Awaiting further instruction."
     }
 
@@ -1212,17 +1217,21 @@ const orchestrationTool = tool({
       const tasks = getTasksForSession(context.sessionID)
       if (tasks.length === 0) return "No tracked subagent tasks for this session yet."
 
+      const agentSessionName = getAgentSessionName(config, context.sessionID)
+      const agentSessionExists = config.tmux.enabled && isInsideTmux() && hasTmuxBinary()
+        ? runTmux(["has-session", "-t", agentSessionName]).ok
+        : false
+
       const lines = ["# Active Subagent Tasks", "", ...tasks.slice(0, 20).map(formatTaskLine)]
       lines.push(
         "",
         "# Tmux Runtime",
         "",
         `- enabled=${config.tmux.enabled}`,
-        `- attached=${tasks.filter((task) => task.tmuxState === "attached").length}`,
-        `- queued=${getSessionState(context.sessionID).deferredTmuxQueue.length}`,
+        `- agentSession=${agentSessionExists ? agentSessionName : "none"}`,
+        `- windows=${tasks.filter((task) => task.tmuxState === "attached").length}`,
         `- staleClosed=${tmuxHealth.staleClosed}`,
         `- missingDetected=${tmuxHealth.missing}`,
-        `- queuedAttached=${tmuxHealth.queuedAttached}`,
       )
       const notifications = getSessionState(context.sessionID).notifications.slice(0, 5)
       if (notifications.length > 0) {
@@ -1278,10 +1287,7 @@ const WpromoteOrchestrationPlugin: Plugin = async () => {
       record.blocks = deps.blocks
 
       if (config.tmux.enabled) {
-        const attach = attachTaskPane(record, config)
-        if (!attach.attached && record.tmuxState === "queued") {
-          enqueueDeferredTmuxTask(input.sessionID, record.id)
-        }
+        attachTaskWindow(record, config)
       }
 
       persistSessionTasks(input.sessionID)
@@ -1317,7 +1323,7 @@ const WpromoteOrchestrationPlugin: Plugin = async () => {
         const taskProvider = resolveTaskProvider(config, record.category)
         record.backgroundTaskID = bgID
         setTaskStatus(record, "running", `Background task launched with ${bgID}, provider=${taskProvider}`)
-      } else if (textOutput.toLowerCase().includes("failed")) {
+      } else if (isLikelyTaskFailure(textOutput)) {
         const failure = classifyFailure(textOutput)
         const taskProvider = resolveTaskProvider(config, record.category)
         const shouldFallback =
@@ -1347,9 +1353,9 @@ const WpromoteOrchestrationPlugin: Plugin = async () => {
       }
 
       if (record.status === "completed" || record.status === "failed" || record.status === "stopped") {
-        closeTaskPane(record, config)
+        closeTaskWindow(record, config)
+        maybeDestroyIdleAgentSession(config, input.sessionID)
       }
-      processDeferredTmuxQueue(input.sessionID, config)
       persistSessionTasks(input.sessionID)
 
       const activityLine = `\n[Subagent activity] ${record.status.toUpperCase()} ${record.agent} \"${record.title}\"`
@@ -1369,14 +1375,13 @@ const WpromoteOrchestrationPlugin: Plugin = async () => {
       if (!sessionID) return
 
       const config = parseConfigFromFile().config
-      const state = getSessionState(sessionID)
       for (const record of getTasksForSession(sessionID)) {
-        if (record.tmuxPaneID) closeTaskPane(record, config)
+        if (record.tmuxWindowID) closeTaskWindow(record, config)
         if (record.status === "running" || record.status === "retrying" || record.status === "queued") {
           setTaskStatus(record, "stopped", "Parent session deleted")
         }
       }
-      state.deferredTmuxQueue = []
+      destroyAgentSession(config, sessionID)
       persistSessionTasks(sessionID)
     },
   }