@wpro-eng/opencode-config 1.4.0 → 1.4.1

package/README.md

@@ -67,10 +67,19 @@ Create `~/.config/opencode/wpromote.json` or `~/.config/opencode/wpromote.jsonc`
 
 ### Orchestration Runtime Configuration
 
+All fields below show their **defaults**. You only need to include fields you want to override.
+
 ```json
 {
   "orchestration": {
     "providerMode": "copilot",
+    "features": {
+      "delegation": true,
+      "diagnostics": true,
+      "lookAt": true,
+      "continuousLoop": true,
+      "selfHealing": true
+    },
     "limits": {
       "maxConcurrent": 3,
       "maxRetries": 2,
@@ -88,7 +97,7 @@ Create `~/.config/opencode/wpromote.json` or `~/.config/opencode/wpromote.jsonc`
       "providerOrder": ["copilot", "native"]
     },
     "hooks": {
-      "disabled": ["activity-feed"],
+      "disabled": [],
       "telemetry": true
     },
     "notifications": {
@@ -96,31 +105,25 @@ Create `~/.config/opencode/wpromote.json` or `~/.config/opencode/wpromote.jsonc`
       "maxItems": 100
     },
     "categories": {
-      "routing": {
-        "quick": "native"
-      },
-      "maxConcurrent": {
-        "quick": 1
-      }
+      "routing": {},
+      "maxConcurrent": {}
     },
     "recovery": {
       "autoResumeOnStart": true
     },
     "tmux": {
       "enabled": false,
-      "layout": "main-vertical",
-      "mainPaneSize": 60,
-      "mainPaneMinWidth": 120,
-      "agentPaneMinWidth": 40,
       "sessionPrefix": "wpo"
     }
   }
 }
 ```
 
-Tmux support is optional and only active when `orchestration.tmux.enabled` is `true` and OpenCode is running inside a tmux session. When enabled, task launches can attach a live pane, queue attachment when pane capacity is full, and auto-clean up panes when tasks complete, fail, stop, or parent sessions end.
+Tmux support is optional and only active when `orchestration.tmux.enabled` is `true` and OpenCode is running inside a tmux session. When enabled, a dedicated tmux session (`{sessionPrefix}-{opencode-session-id}`) is created for each OpenCode session, and each subagent task gets its own window inside that session. Windows are automatically cleaned up when tasks complete, fail, stop, or parent sessions end. Use `tmux switch-client -t wpo-*` to peek at agent work.
+
+Feature flags (`orchestration.features`) toggle individual orchestration capabilities. Set any to `false` to disable that feature while keeping the rest active.
 
-Category policies are optional. Use `orchestration.categories.routing` to override provider mode per task category (for example, `quick` -> `native`) and `orchestration.categories.maxConcurrent` to cap active tasks per category.
+Category policies are optional. Use `orchestration.categories.routing` to override provider mode per task category (for example, `"quick": "native"`) and `orchestration.categories.maxConcurrent` to cap active tasks per category (for example, `"quick": 1`).
 
 Recovery policies are optional. `orchestration.recovery.autoResumeOnStart` controls whether queued/running/retrying task records from prior sessions are automatically restored into `queued` state on startup.
 
@@ -246,28 +249,86 @@ EOF
 
 ## What's Included
 
-### Skills (`skill/`)
-Reusable skill files that agents can load. Each skill is a directory containing `SKILL.md` with YAML frontmatter.
-
 ### Agents (`agent/`)
-Pre-configured agent definitions with model, temperature, and system prompts.
+
+Pre-configured agent definitions with model, temperature, and system prompts. There are two **primary** agents (you talk to them directly) and seven **subagents** (they run in the background, delegated by the primary agent).
+
+#### Primary Agents
+
+| Agent | Model | What it does |
+|-------|-------|--------------|
+| `gandalf` | Claude Opus 4 | The default orchestrator. Classifies your request, breaks it into tasks, delegates to the right subagents in parallel, and assembles the final result. Handles everything from quick fixes to multi-step projects. |
+| `samwise` | Claude Opus 4 | A higher-rigor variant of Gandalf for long-running complex work. Runs a sustained execution loop with tighter milestone verification, aggressive parallelism, and continuous health monitoring. Use when a task needs hours of autonomous work without hand-holding. |
+
+#### Subagents
+
+| Agent | Model | When Gandalf calls it | What it does |
+|-------|-------|-----------------------|--------------|
+| `legolas` | Claude Sonnet 4.6 | "Where is X in the codebase?" | Searches the repo fast. Uses LSP, grep, glob, and git to find files, symbols, call paths, and code patterns. Returns structured results with absolute paths and a direct answer, not just a file list. Read-only by default. |
+| `radagast` | GPT-5.2 | "How does library X work?" | Researches external docs, OSS repos, and the web. Classifies the question (conceptual, implementation, history, or comprehensive), fetches official sources, and returns evidence-backed recommendations with links. |
+| `treebeard` | GPT-5.2 | "Is this plan solid?" | Reviews plans for ambiguity, risk, and executability before implementation starts. Surfaces hidden assumptions, produces concrete acceptance criteria, and gives a clear OKAY or REJECT verdict with at most 3 blocking issues. |
+| `celebrimbor` | GPT-5.2 Codex | "Build this end-to-end." | The workhorse implementation agent. Operates like a senior staff engineer: explores context, plans edits, executes changes, runs tests, and iterates until done. Does not stop at partial progress or ask permission for normal engineering work. |
+| `elrond` | GPT-5.2 | "What's the right architecture?" | Read-only strategic advisor. Analyzes codebases, evaluates tradeoffs, and returns a bottom-line recommendation with an action plan and effort estimate. Biases toward simplicity and existing patterns over speculative complexity. |
+| `galadriel` | Gemini 3.1 Pro | "What's in this image/PDF?" | Multimodal analysis specialist. Handles PDFs, images, diagrams, and charts that other agents cannot process as plain text. Extracts targeted information and returns concise findings with confidence notes. |
+| `aragorn` | GPT-5.2 Codex | "Write tests for this." | Strict TDD specialist following Red-Green-Refactor. Writes a failing test first, makes it pass with minimal code, then refactors under green. Produces a test plan, TDD log, execution results, and a quality scorecard. Never writes production code without a failing test. |
 
 ### Commands (`command/`)
+
 Slash commands available to all team members.
 
+| Command | Description |
+|---------|-------------|
+| `/continue` | Enable continuous deepwork loop for current session |
+| `/stop` | Stop continuous loop and halt queued orchestration work |
+| `/tasks` | List active and recent subagent orchestration tasks |
+| `/task` | Show details for one subagent orchestration task |
+| `/diagnostics` | Run orchestration diagnostics with live delegation probes |
+| `/doctor` | Run deep orchestration doctor checks with actionable remediation |
+| `/look-at` | Normalize multimodal request and execute look_at analysis |
+| `/test-orchestration` | Run a parallel subagent delegation torture test audit |
+| `/wpromote-status` | Show status for wpromote team config |
+| `/wpromote-list` | List all team assets from wpromote config |
+| `/wpromote-cleanup` | Remove stale cache files, broken symlinks, and unused plugins |
+| `/example` | Example command demonstrating the expected format |
+
+### Skills (`skill/`)
+
+Reusable skill files that agents can load. Each skill is a directory containing `SKILL.md` with YAML frontmatter.
+
+| Skill | Description |
+|-------|-------------|
+| `orchestration-core` | Continuous loop orchestration, delegation visibility, and diagnostics workflow |
+| `readme-editor` | Craft professional README.md files for GitHub open source projects |
+| `example` | Example skill demonstrating the expected format |
+
 ### Plugins (`plugin/`)
+
 OpenCode hook plugins for team-wide automation.
 
+| Plugin | Description |
+|--------|-------------|
+| `wpromote-orchestration` | Orchestration runtime: task tracking, tmux sessions, provider fallback, recovery |
+| `wpromote-look-at` | Multimodal analysis wrapper for the look_at workflow |
+
 ### Instructions (`instruction/`)
-Markdown files automatically appended to agent context (like AGENTS.md).
+
+Markdown files automatically appended to agent context (registered in `manifest.json`).
+
+| Instruction | Description |
+|-------------|-------------|
+| `getting-started` | Quick start guide for Wpromote OpenCode |
+| `team-conventions` | Code style, git workflow, and contribution conventions |
+| `orchestration-runtime` | Orchestration controls, delegation discipline, tmux runtime |
 
 ### MCPs (`mcp/`)
+
 Model Context Protocol server configurations.
 
-Current team MCP configs include:
-- `chrome-devtools` (`https://www.npmjs.com/package/chrome-devtools-mcp` via `npx`)
-- `context7` (`https://mcp.context7.com/mcp`)
-- `exa` (`https://mcp.exa.ai/mcp`)
+| MCP | Type | Endpoint |
+|-----|------|----------|
+| `chrome-devtools` | local | `npx chrome-devtools-mcp@latest` |
+| `context7` | remote | `https://mcp.context7.com/mcp` |
+| `exa` | remote | `https://mcp.exa.ai/mcp` |
 
 ## Development
 

package/command/diagnostics.md

@@ -1,38 +1,99 @@
 ---
-description: Run orchestration diagnostics with explicit delegation and task visibility checks
+description: Run orchestration diagnostics with live delegation probes and task visibility checks
 ---
-Run full diagnostics for orchestration configuration and runtime health.
+Run full diagnostics for orchestration configuration, runtime health, and live delegation verification.
 
 Instructions:
+
+## Phase 1: Tool & Config Health
+
 1. Check tool availability first:
    - If `wpromote_orchestration` is unavailable, report `FAIL: Tool Unavailable` and stop.
    - Include short remediation steps (install/sync/restart).
 2. Call `wpromote_orchestration` with `action="diagnostics"`.
-3. Call `wpromote_orchestration` with `action="tasks"`.
-4. Enumerate enabled assets:
+3. Call `wpromote_orchestration` with `action="tasks"` to capture pre-probe baseline.
+
+## Phase 2: Live Delegation Probe
+
+4. Spawn 4 subagent probes in parallel using the `task` tool. Each probe must be a trivial, fast, read-only task that proves the delegation pipeline works end-to-end. Do NOT run destructive or write operations.
+
+   **Probe A — legolas (codebase exploration)**:
+   - Task: "List the top-level directories and count of files in this repo. Return the directory listing."
+   - Expected: completes with a directory listing.
+
+   **Probe B — radagast (external research)**:
+   - Task: "What license does the tmux terminal multiplexer use? Search the web and return the license name (e.g. MIT, BSD, ISC, GPL)."
+   - Expected: completes with a license name (ISC).
+
+   **Probe C — treebeard (planning)**:
+   - Task: "Review this single-sentence plan and identify one risk: 'We will migrate all configs to YAML next sprint.' Return your risk assessment in 2-3 sentences."
+   - Expected: completes with a short risk assessment.
+
+   **Probe D — general (general-purpose)**:
+   - Task: "Read the file manifest.json in the repo root and return its contents."
+   - Expected: completes with JSON content.
+
+5. Wait for all 4 probes to complete (or timeout after 120 seconds each).
+
+6. For each probe, record:
+   - task_id
+   - subagent type
+   - status (completed / failed / timed out)
+   - round-trip wall time (note when dispatched vs when result returned)
+   - whether the result was non-empty and plausible
+
+## Phase 3: Post-Probe Verification
+
+7. Call `wpromote_orchestration` with `action="tasks"` again to verify:
+   - All 4 probe tasks appear in the task list.
+   - Task statuses are correctly tracked.
+   - If tmux is enabled, note whether windows were attached/detached during probes.
+
+## Phase 4: Asset Enumeration
+
+8. Enumerate enabled assets:
    - `tools`: list enabled tools, each with a short description.
    - `commands`: use `glob("command/*.md")`; report `/name` + frontmatter description.
    - `agents`: use `glob("agent/*.md")`; report name + frontmatter description.
    - `subagents`: report available Task subagent types + short purpose.
    - `skills`: report available skills + each skill description.
    - `instructions`: read `manifest.json`; include entries and currently loaded AGENTS/instructions visible in session context.
-5. Present diagnostics PASS/FAIL first.
-6. Add **Delegation & Task Health** with:
-   - subagent delegation availability
-   - total tracked tasks (active + recent)
-   - active task count
-   - recent completion/failure/cancel counts (if available)
-    - whether task visibility looks healthy
-    - tmux pane health (attached/queued/missing counts if tmux is enabled)
-7. If tasks exist, list up to 5 recent tasks (id, status, short title).
-8. Always include these sections in this exact order (even when empty):
-   - PASS/FAIL Findings
-   - Runtime Health
-   - Delegation & Task Health
-   - Enabled Tools
-   - Enabled Commands
-   - Enabled Agents
-   - Enabled Subagents
-   - Enabled Skills
-   - Enabled Instructions
-9. If any checks fail, include short remediation steps.
+
+## Phase 5: Report
+
+9. Present the report with these sections in this exact order (even when empty):
+
+   **PASS/FAIL Findings**
+   - All config/runtime checks from Phase 1.
+   - Each probe result as its own PASS/FAIL line.
+   - Overall verdict.
+
+   **Runtime Health**
+   - Provider mode, fallback chain, loop mode, max concurrent, hooks, recovery state.
+
+   **Live Delegation Probe Results**
+   - Table with columns: Probe, Subagent, Status, Round-Trip, Result Summary.
+   - Overall delegation verdict (all passed / partial / all failed).
+   - If any probe failed, include the error or timeout details.
+
+   **Delegation & Task Health**
+   - Subagent delegation availability (proven by probes, not just config).
+   - Total tracked tasks (active + recent), including the 4 probes.
+   - Active task count.
+   - Recent completion/failure/cancel counts.
+   - Whether task visibility looks healthy (do the 4 probes show up in `/tasks`?).
+   - Tmux window health (attached/missing counts, agent session status if tmux is enabled).
+
+   **Enabled Tools**
+
+   **Enabled Commands**
+
+   **Enabled Agents**
+
+   **Enabled Subagents**
+
+   **Enabled Skills**
+
+   **Enabled Instructions**
+
+10. If any checks or probes fail, include short remediation steps at the end of each relevant section.

package/dist/index.js

@@ -8389,16 +8389,6 @@ var UserConfigSchema = exports_external.object({
     }).default({}),
     tmux: exports_external.object({
       enabled: exports_external.boolean().default(false),
-      layout: exports_external.enum([
-        "main-horizontal",
-        "main-vertical",
-        "tiled",
-        "even-horizontal",
-        "even-vertical"
-      ]).default("main-vertical"),
-      mainPaneSize: exports_external.number().int().min(20).max(80).default(60),
-      mainPaneMinWidth: exports_external.number().int().min(40).max(400).default(120),
-      agentPaneMinWidth: exports_external.number().int().min(20).max(200).default(40),
       sessionPrefix: exports_external.string().min(2).max(20).regex(/^[a-zA-Z0-9_-]+$/).default("wpo")
     }).default({})
   }).default({})
@@ -8449,10 +8439,6 @@ var DEFAULT_CONFIG = {
     },
     tmux: {
       enabled: false,
-      layout: "main-vertical",
-      mainPaneSize: 60,
-      mainPaneMinWidth: 120,
-      agentPaneMinWidth: 40,
       sessionPrefix: "wpo"
     }
   }

package/instruction/orchestration-runtime.md

@@ -57,23 +57,21 @@ When using delegated execution:
 
 ## Tmux Runtime
 
-- Enable tmux pane management with `orchestration.tmux.enabled`.
-- Recommended defaults:
+- Enable tmux session management with `orchestration.tmux.enabled`.
+- When enabled, a dedicated tmux session (`{sessionPrefix}-{opencode-session-id}`) is created for each OpenCode session.
+- Each subagent task gets its own window inside that session, keeping your working window clean.
+- Use `tmux switch-client -t wpo-*` to peek at agent work.
 
 ```json
 {
   "orchestration": {
     "tmux": {
       "enabled": true,
-      "layout": "main-vertical",
-      "mainPaneSize": 60,
-      "mainPaneMinWidth": 120,
-      "agentPaneMinWidth": 40,
       "sessionPrefix": "wpo"
     }
   }
 }
 ```
 
-- `/tasks` reports tmux pane attachment state and deferred queue health.
-- `/diagnostics` checks tmux wiring, binary availability, queue health, and pane reconciliation.
+- `/tasks` reports the agent session name and active window count.
+- `/diagnostics` checks tmux wiring, binary availability, and window reconciliation.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wpro-eng/opencode-config",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "Wpromote OpenCode plugin to sync team config assets on startup",
   "repository": {
     "type": "git",

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)
     },
   }