oh-my-opencode-slim 2.1.1 → 2.2.1

package/dist/index.js

@@ -18363,6 +18363,12 @@ var CUSTOM_SKILLS = [
     allowedAgents: ["orchestrator"],
     sourcePath: "src/skills/deepwork"
   },
+  {
+    name: "verification-planning",
+    description: "Plan credible, proportionate evidence before non-trivial implementation",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/verification-planning"
+  },
   {
     name: "reflect",
     description: "Review repeated work and suggest reusable workflow improvements",
@@ -18375,12 +18381,6 @@ var CUSTOM_SKILLS = [
     allowedAgents: ["orchestrator"],
     sourcePath: "src/skills/oh-my-opencode-slim"
   },
-  {
-    name: "release-smoke-test",
-    description: "Validate packed release candidates and bugfixes before public publish",
-    allowedAgents: ["orchestrator"],
-    sourcePath: "src/skills/release-smoke-test"
-  },
   {
     name: "worktrees",
     description: "Manage Git worktrees as OMO safe isolated coding lanes for complex/risky/parallel work",
@@ -18496,7 +18496,7 @@ var DEFAULT_MODELS = {
 var POLL_INTERVAL_BACKGROUND_MS = 2000;
 var MAX_POLL_TIME_MS = 5 * 60 * 1000;
 var DEFAULT_MAX_SUBAGENT_DEPTH = 3;
-var PHASE_REMINDER_TEXT = `!IMPORTANT! Scheduler workflow: plan lanes/dependencies → dispatch background specialists → track task IDs → wait for hook-driven completion → reconcile terminal results → verify. Do not poll running jobs, consume running-job output, or advance dependent work. !END!`;
+var PHASE_REMINDER_TEXT = `!IMPORTANT! Scheduler workflow: First choose the lightest workflow that fits the work. If direct execution is justified, complete it and verify proportionately. Otherwise: plan lanes/dependencies → dispatch background specialists → track task IDs → wait for hook-driven completion → reconcile terminal results → verify. Do not poll running jobs, consume running-job output, or advance dependent work. !END!`;
 function formatSystemReminder(text) {
   return `<system-reminder>
 ${text}
@@ -18521,6 +18521,13 @@ var NO_SHELL_READONLY_FILE_OPERATIONS_RULES = `**File Operations Rules**:
 var TMUX_SPAWN_DELAY_MS = 500;
 var COUNCILLOR_STAGGER_MS = 250;
 var DEFAULT_DISABLED_AGENTS = ["observer"];
+var DEFAULT_MAX_SESSIONS_PER_AGENT = 2;
+var DEFAULT_READ_CONTEXT_MIN_LINES = 10;
+var DEFAULT_READ_CONTEXT_MAX_FILES = 8;
+var DEFAULT_IMAGE_ROUTING = "auto";
+function resolveImageRouting(imageRouting) {
+  return imageRouting ?? DEFAULT_IMAGE_ROUTING;
+}
 // src/config/council-schema.ts
 import { z } from "zod";
 
@@ -18686,6 +18693,33 @@ var ManualPlanSchema = z2.object({
   librarian: ManualAgentPlanSchema,
   fixer: ManualAgentPlanSchema
 }).strict();
+var PermissionActionSchema = z2.enum(["ask", "allow", "deny"]);
+var PermissionRuleSchema = z2.union([
+  PermissionActionSchema,
+  z2.record(z2.string(), PermissionActionSchema)
+]);
+var PermissionObjectSchema = z2.object({
+  read: PermissionRuleSchema.optional(),
+  edit: PermissionRuleSchema.optional(),
+  glob: PermissionRuleSchema.optional(),
+  grep: PermissionRuleSchema.optional(),
+  list: PermissionRuleSchema.optional(),
+  bash: PermissionRuleSchema.optional(),
+  task: PermissionRuleSchema.optional(),
+  external_directory: PermissionRuleSchema.optional(),
+  lsp: PermissionRuleSchema.optional(),
+  skill: PermissionRuleSchema.optional(),
+  todowrite: PermissionActionSchema.optional(),
+  question: PermissionActionSchema.optional(),
+  webfetch: PermissionActionSchema.optional(),
+  websearch: PermissionActionSchema.optional(),
+  codesearch: PermissionActionSchema.optional(),
+  doom_loop: PermissionActionSchema.optional()
+}).catchall(PermissionRuleSchema);
+var PermissionConfigSchema = z2.union([
+  PermissionActionSchema,
+  PermissionObjectSchema
+]);
 var AgentOverrideConfigSchema = z2.object({
   model: z2.union([
     z2.string(),
@@ -18704,13 +18738,15 @@ var AgentOverrideConfigSchema = z2.object({
   prompt: z2.string().min(1).optional(),
   orchestratorPrompt: z2.string().min(1).optional(),
   options: z2.record(z2.string(), z2.unknown()).optional(),
-  displayName: z2.string().min(1).optional()
+  displayName: z2.string().min(1).optional(),
+  permission: PermissionConfigSchema.optional()
 }).strict();
 var MultiplexerTypeSchema = z2.enum([
   "auto",
   "tmux",
   "zellij",
   "herdr",
+  "cmux",
   "none"
 ]);
 var MultiplexerLayoutSchema = z2.enum([
@@ -18756,7 +18792,7 @@ var FailoverConfigSchema = z2.object({
   retryDelayMs: z2.number().min(0).default(500),
   maxRetries: z2.number().int().min(0).default(3).describe("Number of consecutive 429/rate-limit responses tolerated on the " + "same model before aborting (or swapping to the next fallback " + "model when a chain is configured)."),
   retry_on_empty: z2.boolean().default(true).describe("When true (default), empty provider responses are treated as failures, " + "triggering fallback/retry. Set to false to treat them as successes."),
-  runtimeOverride: z2.boolean().default(true).describe("When true (default), a runtime model selected via /model that is " + "outside the configured fallback chain will still trigger the chain " + "on rate-limit errors. When false, out-of-chain runtime picks are " + "respected and the error surfaces instead of silently falling back " + "to the chain. Models that are members of the chain always fall back " + "regardless of this setting.")
+  runtimeOverride: z2.boolean().optional().describe("DEPRECATED: no longer used. Previously controlled whether out-of-chain " + "runtime model picks triggered fallback. Fallback is now always " + "disabled when a user explicitly selects a model via /model.")
 }).strict();
 var CompanionConfigSchema = z2.object({
   enabled: z2.boolean().optional(),
@@ -18798,11 +18834,13 @@ var PluginConfigSchema = z2.object({
   preset: z2.string().optional(),
   setDefaultAgent: z2.boolean().optional(),
   compactSidebar: z2.boolean().optional().describe("Use the compact TUI sidebar layout. Defaults to true; set false to use the expanded layout."),
+  stripOrchestratorModel: z2.boolean().optional().describe("When true, omit orchestrator.model and orchestrator.variant from the SDK config so OpenCode uses the session model selected with /model after subagent dispatch. An explicitly selected preset that sets orchestrator.model is preserved. Defaults to false."),
   autoUpdate: z2.boolean().optional().describe("Disable automatic installation of plugin updates when false. Defaults to true."),
   presets: z2.record(z2.string(), PresetSchema).optional(),
   agents: z2.record(z2.string(), AgentOverrideConfigSchema).optional(),
   disabled_agents: z2.array(z2.string()).optional().describe("Agent names to disable completely. " + "Disabled agents are not instantiated and cannot be delegated to. " + "Orchestrator and council internal agents (councillor) cannot be disabled. " + "By default, 'observer' is disabled. Remove it from this list and configure a vision-capable model to enable."),
-  disabled_mcps: z2.array(z2.string()).optional(),
+  image_routing: z2.enum(["auto", "direct"]).optional().describe("How image attachments are handled. " + "When omitted, preserves legacy conditional behavior: intercept " + 'attachments only when observer is enabled. "auto": requires ' + "observer to be enabled and saves attachments to disk before " + 'nudging delegation to @observer. "direct": always passes ' + "attachments to the orchestrator untouched."),
+  disabled_mcps: z2.array(z2.string()).optional().describe("MCP server names to disable completely. Disabled servers are not " + "started and cannot be used by agents."),
   disabled_tools: z2.array(z2.string()).optional().describe("Tool names to disable completely. Disabled tools are not registered with OpenCode and cannot be used by agents."),
   disabled_skills: z2.array(z2.string()).optional().describe("Skill names to disable completely. Disabled skills are not granted to agents, even when referenced by presets or agent overrides."),
   multiplexer: MultiplexerConfigSchema.optional(),
@@ -18899,6 +18937,23 @@ function findConfigPathInDirs(configDirs, baseName) {
   }
   return null;
 }
+function validateFinalImageRouting(config, configPath, options) {
+  if (config.image_routing !== "auto")
+    return true;
+  const disabledAgents = config.disabled_agents ?? DEFAULT_DISABLED_AGENTS;
+  if (!disabledAgents.includes("observer"))
+    return true;
+  const message = 'image_routing "auto" requires observer to be enabled. ' + 'Remove "observer" from disabled_agents.';
+  options?.onWarning?.({
+    path: configPath,
+    kind: "invalid-schema",
+    message
+  });
+  if (!options?.silent) {
+    console.warn(`[oh-my-opencode-slim] Invalid config: ${message}`);
+  }
+  return false;
+}
 function findPluginConfigPaths(directory) {
   const userConfigPath = findConfigPathInDirs(getConfigSearchDirs(), "oh-my-opencode-slim");
   const projectConfigBasePath = path.join(directory, ".opencode", "oh-my-opencode-slim");
@@ -18980,6 +19035,7 @@ function loadPluginConfig(directory, options) {
       debug: config.companion.debug ?? false
     };
   }
+  validateFinalImageRouting(config, projectConfigPath ?? userConfigPath ?? "", options);
   return config;
 }
 function loadAgentPrompt(agentName, optionsOrPreset) {
@@ -19195,7 +19251,8 @@ var AGENT_DESCRIPTIONS = {
 - Permissions: read_files
 - Stats: 5x better decision maker, problem solver, investigator than orchestrator, 0.8x speed of orchestrator, same cost.
 - Capabilities: Deep architectural reasoning, system-level trade-offs, complex debugging, code review, simplification, maintainability review
-- **Delegate when:** Major architectural decisions with long-term impact • Problems persisting after 2+ fix attempts • High-risk multi-system refactors • Costly trade-offs (performance vs maintainability) • Complex debugging with unclear root cause • Security/scalability/data integrity decisions • Genuinely uncertain and cost of wrong choice is high • When a workflow calls for a **reviewer** subagent • Code needs simplification or YAGNI scrutiny
+- **Delegate when:** Major architectural decisions with long-term impact • Problems persisting after 2+ fix attempts • High-risk multi-system refactors • Costly trade-offs (performance vs maintainability) • Complex debugging with unclear root cause • Security/scalability/data integrity decisions • Genuinely uncertain and cost of wrong choice is high • Code needs simplification or YAGNI scrutiny
+- **Review use:** Oracle is an escalation, not a default verification step. Request independent Oracle review only when its analysis is expected to materially reduce risk or uncertainty.
 - **Don't delegate when:** Routine decisions you're confident about • First bug fix attempt • Straightforward trade-offs • Tactical "how" vs strategic "should" • Time-sensitive good-enough decisions • Quick research/testing can answer
 - **Rule of thumb:** Need senior architect review? → @oracle. Need code review or simplification? → @oracle. Routine coordination or final synthesis? → handle directly.`,
   designer: `@designer
@@ -19241,13 +19298,6 @@ var AGENT_DESCRIPTIONS = {
 - **Rule of thumb:** Even if your model supports vision, delegate visual analysis to @observer - it isolates large image/PDF bytes from your context window, returning only concise structured text. Need exact file contents for routing? → Read only the minimal context yourself.
 - **IMPORTANT:** When delegating to @observer, always include the **full file path** in the prompt so it can read the file. Example: "Analyze the screenshot at /path/to/file.png - describe the UI elements and error messages."`
 };
-var VALIDATION_ROUTING = [
-  "- Route UI/UX validation and review to @designer",
-  "- Route code review, code simplification and maintainability review checks to @oracle",
-  "- Route implementation to @fixer or multiple @fixer instances for maximum parallel execution",
-  "- Route visual/media analysis and interpretation to @observer",
-  "- If a request spans multiple lanes, delegate only the lanes that add clear value"
-];
 var PARALLEL_DELEGATION_EXAMPLES = [
   "- Multiple @explorer searches across different domains?",
   "- @explorer + @librarian research in parallel?",
@@ -19257,13 +19307,6 @@ var PARALLEL_DELEGATION_EXAMPLES = [
 function buildOrchestratorPrompt(disabledAgents) {
   const enabledAgents = Object.entries(AGENT_DESCRIPTIONS).filter(([name]) => !disabledAgents?.has(name)).map(([, desc]) => desc).join(`
 
-`);
-  const enabledValidationRouting = VALIDATION_ROUTING.filter((line) => {
-    const mentions = [...line.matchAll(/@(\w+)/g)].map((m) => m[1]);
-    if (mentions.length === 0)
-      return true;
-    return mentions.every((name) => !disabledAgents?.has(name));
-  }).join(`
 `);
   const enabledParallelExamples = PARALLEL_DELEGATION_EXAMPLES.filter((line) => {
     const mentions = [...line.matchAll(/@(\w+)/g)].map((m) => m[1]);
@@ -19275,6 +19318,10 @@ function buildOrchestratorPrompt(disabledAgents) {
   return `<Role>
 You are a workflow manager for coding work. Your job is to plan, schedule, delegate, monitor, reconcile, and verify specialist-agent work. You are not the default implementation worker.
 
+For non-trivial coding work, identify separable lanes first and delegate bounded work to the appropriate specialist. Do not perform multi-step implementation serially when a suitable specialist is available.
+
+Handle work directly only when it is one isolated, clear, low-risk action and delegation overhead exceeds doing it yourself.
+
 Optimize for quality, speed, cost, and reliability by dispatching the right specialist lanes, tracking background task state, and integrating terminal results into one coherent outcome.
 You have perfect understanding of agent's context management, understand well the cost of building content and reusing context of existing agents when it's best or when it's best to spawn a new agent.
 </Role>
@@ -19295,12 +19342,17 @@ Evaluate approach by: quality, speed and cost.
 Choose the path that optimizes all four.
 
 ## 3. Delegation Check
-Review available agents and lane rules.
+Review available agents and lane rules. Before beginning non-trivial work, identify which parts can proceed independently.
+
+**Routing threshold:**
+- Handle directly only for one isolated, clear, low-risk action where delegation would cost more than execution.
+- For multi-step implementation, broad discovery, external research, visual work, or complex debugging, delegate to the suitable specialist.
+- If two or more parts can proceed independently, dispatch them in parallel before starting dependent work.
+- Do not delegate merely because an agent exists. Do not keep substantive work entirely in the orchestrator merely because each individual step seems easy.
 
 **Dispatch efficiency:**
 - Reference paths/lines, don't paste files (\`src/app.ts:42\` not full contents)
 - Brief user on delegation goal before each call
-- For trivial conversational answers or tiny mechanical edits, direct execution is allowed when scheduling overhead would clearly dominate
 - Record task IDs, state, and advisory ownership/dependency labels
 - Do not immediately wait after spawning independent background tasks unless the next step truly depends on their result
 - Reconcile results, resolve conflicts, and gate dependent lanes
@@ -19308,7 +19360,7 @@ Review available agents and lane rules.
 ${WRITABLE_FILE_OPERATIONS_RULES}
 
 ## 4. Plan and Parallelize
-Build a short work graph before dispatching:
+When the routing threshold calls for delegation, build a short work graph before dispatching:
 - Independent lanes that can run now
 - Dependency-ordered lanes that must wait
 - Advisory ownership for write-capable lanes
@@ -19326,7 +19378,7 @@ Balance: respect dependencies, avoid parallelizing what must be sequential, and
 
 ### Background Task Discipline
 - Prefer \`task(..., background: true)\` for delegated work that can run independently.
-- Launch specialist agents in the background by default so the orchestrator stays unblocked and can reconcile results when they return.
+- For work already chosen for delegation, launch independent specialist lanes in the background so the orchestrator stays unblocked and can reconcile results when they return.
 - Track each task's specialist, objective, task/session ID, and file/topic ownership.
 - Continue orchestration only on non-overlapping work; otherwise briefly report what was launched and stop.
 - Before local edits or another writer task, compare against running task scopes.
@@ -19351,16 +19403,14 @@ Balance: respect dependencies, avoid parallelizing what must be sequential, and
 - If the Background Job Board lists \`fix-1 / ses_abc / fixer\`, call task with \`subagent_type: "fixer"\` and \`task_id: "fix-1"\` or \`task_id: "ses_abc"\`.
 - Do not leave \`task_id\` empty when intending to reuse; omitted or empty \`task_id\` creates a new specialist session.
 
-### Validation routing
-- Validation is a workflow stage owned by the Orchestrator, not a separate specialist
-${enabledValidationRouting}
-
 ## 6. Verify
-- Run relevant checks/diagnostics for the change
-- Use validation routing when applicable instead of doing all review work yourself
-- If test files are involved, prefer @fixer for bounded test changes and @oracle only for test strategy or quality review
-- Confirm specialists completed successfully
-- Verify solution meets requirements
+- Define the observable success criteria from the user's request.
+- Choose the minimum verification that produces meaningful evidence for the change's scope, risk, uncertainty, and potential impact.
+- Start with the narrowest relevant validation. Broaden verification only when integration scope, uncertainty, risk, or a failed focused check justifies it.
+- Do not run project-wide checks by habit or merely because files changed.
+- Do not treat verification as a fixed checklist; select evidence that can actually confirm the requested behavior.
+- Request independent review only when its expected risk reduction justifies its coordination cost.
+- Report what was verified and any material remaining uncertainty.
 
 </Workflow>
 
@@ -19376,6 +19426,8 @@ ${enabledValidationRouting}
 - Don't summarize what you did unless asked
 - Don't explain code unless asked
 - One-word answers are fine when appropriate
+- Default to the minimum response that fully resolves the user's request; expand only when detail is necessary or the user asks for it.
+- Do not restate the user's request or narrate routine work.
 - Brief delegation notices: "Checking docs via @librarian..." not "I'm going to delegate to @librarian because..."
 
 ## No Flattery
@@ -20045,6 +20097,9 @@ function applyOverrides(agent, override) {
   if (override.displayName) {
     agent.displayName = override.displayName;
   }
+  if (override.permission) {
+    agent.config.permission = override.permission;
+  }
 }
 function isKnownAgentName(name) {
   return ALL_AGENT_NAMES.includes(name);
@@ -20085,6 +20140,9 @@ function injectDisplayNames(orchestrator, nameMap) {
   orchestrator.config.prompt = prompt;
 }
 function applyDefaultPermissions(agent, configuredSkills, disabledSkills) {
+  if (typeof agent.config.permission === "string") {
+    return;
+  }
   const existing = agent.config.permission ?? {};
   const skillPermissions = getSkillPermissionsForAgent(agent.name, configuredSkills, disabledSkills);
   const questionPerm = existing.question === "deny" ? "deny" : "allow";
@@ -20231,10 +20289,10 @@ function createAgents(config, options) {
   const defaultOrchestratorPrompt = orchestrator.config.prompt ?? "";
   const baseOrchestratorPrompt = inlineOrchestratorPrompt !== undefined ? inlineOrchestratorPrompt : defaultOrchestratorPrompt;
   orchestrator.config.prompt = resolvePrompt(baseOrchestratorPrompt, orchestratorPrompts.prompt, orchestratorPrompts.appendPrompt);
-  applyDefaultPermissions(orchestrator, orchestratorOverride?.skills, config?.disabled_skills);
   if (orchestratorOverride) {
     applyOverrides(orchestrator, orchestratorOverride);
   }
+  applyDefaultPermissions(orchestrator, orchestratorOverride?.skills, config?.disabled_skills);
   const displayNameMap = new Map;
   if (orchestrator.displayName) {
     displayNameMap.set("orchestrator", orchestrator.displayName);
@@ -20488,7 +20546,9 @@ function acquirePidFileLock(file) {
       return () => {
         try {
           rmSync(lock, { recursive: true, force: true });
-        } catch {}
+        } catch (err) {
+          log("[companion] lock release failed", String(err));
+        }
       };
     } catch (err) {
       const code = err.code;
@@ -20516,10 +20576,13 @@ function pidFileLockHasLiveOwner(lock) {
     const owner = parsePidFile(readFileSync2(path3.join(lock, "owner"), "utf8"));
     if (owner !== null)
       return isProcessAlive(owner);
-  } catch {
+  } catch (err) {
+    log("[companion] lock owner check failed", String(err));
     try {
       return Date.now() - statSync2(lock).mtimeMs < 5000;
-    } catch {}
+    } catch (err2) {
+      log("[companion] lock owner check failed", String(err2));
+    }
   }
   return false;
 }
@@ -20541,7 +20604,9 @@ function readState() {
     if (parsed?.version === 1 && Array.isArray(parsed.sessions)) {
       return parsed;
     }
-  } catch {}
+  } catch (err) {
+    log("[companion] state load failed", String(err));
+  }
   return { version: 1, sessions: [] };
 }
 function writeState(mutator) {
@@ -20570,7 +20635,9 @@ function acquireStateLock(file) {
       return () => {
         try {
           rmSync(lock, { recursive: true, force: true });
-        } catch {}
+        } catch (err) {
+          log("[companion] lock release failed", String(err));
+        }
       };
     } catch (err) {
       const code = err.code;
@@ -20605,7 +20672,9 @@ class CompanionManager {
         writeState((state) => {
           state.sessions = state.sessions.filter((s) => s.session_id !== this.id);
         });
-      } catch {}
+      } catch (err) {
+        log("[companion] status update failed", String(err));
+      }
       return;
     }
     this.registerActiveManager();
@@ -20643,9 +20712,7 @@ class CompanionManager {
       return;
     }
     if (status === "busy") {
-      if (!agent)
-        return;
-      this.busyAgentSessions.set(sessionId, agent);
+      this.busyAgentSessions.set(sessionId, agent ?? sessionId);
     } else {
       this.busyAgentSessions.delete(sessionId);
     }
@@ -20677,7 +20744,9 @@ class CompanionManager {
     if (activeManagers.size === 0 && activeExitListener) {
       try {
         process.removeListener("exit", activeExitListener);
-      } catch {}
+      } catch (err) {
+        log("[companion] exit listener removal failed", String(err));
+      }
       activeExitListener = null;
     }
     if (this.config?.enabled !== true)
@@ -20835,7 +20904,9 @@ class CompanionManager {
       if (spawnedChild && !this.wasSpawner) {
         try {
           spawnedChild.kill();
-        } catch {}
+        } catch (killErr) {
+          log("[companion] spawn failed", String(killErr));
+        }
       }
       log("[companion] spawn guard failed", String(err));
     } finally {
@@ -20914,7 +20985,9 @@ function loadCompanionManifestFromPackageRoot(packageRoot) {
         checksums: parsed.checksums
       };
     }
-  } catch {}
+  } catch (err) {
+    log("[updater] manifest read failed", String(err));
+  }
   return null;
 }
 async function ensureCompanionVersion(options) {
@@ -21082,7 +21155,9 @@ async function installCompanionArchive(finalBinaryPath, target, manifest, downlo
     if (tempDir) {
       try {
         rmSync2(tempDir, { recursive: true, force: true });
-      } catch {}
+      } catch (err) {
+        log("[updater] install cleanup failed", String(err));
+      }
     }
   }
 }
@@ -21092,7 +21167,9 @@ function readInstallMetadata(binaryPath) {
     if (parsed?.version && parsed.tag && parsed.target) {
       return parsed;
     }
-  } catch {}
+  } catch (err) {
+    log("[updater] metadata read failed", String(err));
+  }
   return null;
 }
 function writeInstallMetadata(binaryPath, metadata) {
@@ -21114,7 +21191,9 @@ async function withCompanionInstallLock(binaryPath, timeoutMs, staleMs, run) {
       } finally {
         try {
           rmSync2(lock, { recursive: true, force: true });
-        } catch {}
+        } catch (err) {
+          log("[updater] lock release failed", String(err));
+        }
       }
     } catch (err) {
       const code = err.code;
@@ -21185,6 +21264,24 @@ function setActiveRuntimePresetWithPrevious(name) {
   activeRuntimePreset = name;
 }
 
+// src/config/strip-orchestrator-model.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stripOrchestratorModel(agents, enabled, preset) {
+  if (enabled !== true || preset?.orchestrator?.model !== undefined)
+    return;
+  const orchestrator = agents.orchestrator;
+  if (!isRecord(orchestrator))
+    return;
+  delete orchestrator.model;
+  delete orchestrator.variant;
+}
+function applyOrchestratorModelConfig(input) {
+  const presetName = input.runtimePreset ?? input.configPreset;
+  stripOrchestratorModel(input.agents, input.enabled, presetName ? input.presets?.[presetName] : undefined);
+}
+
 // src/council/council-manager.ts
 class CouncilManager {
   client;
@@ -24696,9 +24793,9 @@ class BackgroundJobBoard {
   readContextMinLines;
   readContextMaxFiles;
   constructor(options = {}) {
-    this.maxReusablePerAgent = options.maxReusablePerAgent ?? 2;
-    this.readContextMinLines = options.readContextMinLines ?? 10;
-    this.readContextMaxFiles = options.readContextMaxFiles ?? 8;
+    this.maxReusablePerAgent = options.maxReusablePerAgent ?? DEFAULT_MAX_SESSIONS_PER_AGENT;
+    this.readContextMinLines = options.readContextMinLines ?? DEFAULT_READ_CONTEXT_MIN_LINES;
+    this.readContextMaxFiles = options.readContextMaxFiles ?? DEFAULT_READ_CONTEXT_MAX_FILES;
   }
   addTerminalStateListener(listener) {
     this.terminalStateListeners.push(listener);
@@ -25239,7 +25336,7 @@ class BackgroundJobCoordinator {
   }
 }
 // src/utils/guards.ts
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null;
 }
 
@@ -25256,10 +25353,10 @@ ${SLIM_INTERNAL_INITIATOR_MARKER}`,
   };
 }
 function isInternalInitiatorPart(part) {
-  if (!isRecord(part) || part.type !== "text") {
+  if (!isRecord2(part) || part.type !== "text") {
     return false;
   }
-  if (part.synthetic !== true || !isRecord(part.metadata)) {
+  if (part.synthetic !== true || !isRecord2(part.metadata)) {
     return false;
   }
   return part.metadata[INTERNAL_INITIATOR_METADATA_KEY] === true;
@@ -25318,6 +25415,17 @@ function createChatHeadersHook(ctx) {
     }
   };
 }
+// src/hooks/command-hook-utils.ts
+function registerCommandHook(opencodeConfig, commandName, template, description) {
+  const cmdConfig = opencodeConfig.command;
+  if (cmdConfig?.[commandName])
+    return false;
+  if (!opencodeConfig.command)
+    opencodeConfig.command = {};
+  opencodeConfig.command[commandName] = { template, description };
+  return true;
+}
+
 // src/hooks/deepwork/index.ts
 var COMMAND_NAME = "deepwork";
 function activationPrompt(task2) {
@@ -25325,6 +25433,7 @@ function activationPrompt(task2) {
     "Use the deepwork skill for this task. Treat it as a heavy coding session.",
     "",
     "Deepwork requirements:",
+    "- before planning, delegation, or creating state, inspect existing `.gitignore` and `.ignore`; add only missing entries without duplicates: `.gitignore` must contain `.slim/deepwork/`, and `.ignore` must contain `!.slim/deepwork/` and `!.slim/deepwork/**`; this keeps state git-local yet OpenCode-readable;",
     "- create/update a `.slim/deepwork/` progress file;",
     "- keep OpenCode todos synced with the current phase;",
     "- draft a plan and get `@oracle` review before implementation;",
@@ -25342,15 +25451,7 @@ function activationPrompt(task2) {
 function createDeepworkCommandHook() {
   return {
     registerCommand: (opencodeConfig) => {
-      const commandConfig = opencodeConfig.command;
-      if (commandConfig?.[COMMAND_NAME])
-        return;
-      if (!opencodeConfig.command)
-        opencodeConfig.command = {};
-      opencodeConfig.command[COMMAND_NAME] = {
-        template: "Start a deepwork session for a complex coding task",
-        description: "Use the deepwork workflow for heavy multi-phase coding work"
-      };
+      registerCommandHook(opencodeConfig, COMMAND_NAME, "Start a deepwork session for a complex coding task", "Use the deepwork workflow for heavy multi-phase coding work");
     },
     handleCommandExecuteBefore: async (input, output) => {
       if (input.command !== COMMAND_NAME)
@@ -25565,7 +25666,7 @@ function createFilterAvailableSkillsHook(_ctx, config) {
   };
 }
 // src/hooks/foreground-fallback/index.ts
-var RATE_LIMIT_PATTERNS = [
+var RETRYABLE_ERROR_PATTERNS = [
   /\b429\b/,
   /rate.?limit/i,
   /too many requests/i,
@@ -25579,22 +25680,76 @@ var RATE_LIMIT_PATTERNS = [
   /insufficient.?(quota|balance)/i,
   /high concurrency/i,
   /reduce concurrency/i,
-  /service unavailable/i,
   /monthly usage limit/i,
   /5-hour usage limit/i,
-  /weekly usage limit/i
+  /weekly usage limit/i,
+  /\b403\b/,
+  /forbidden/i,
+  /blocked by gateway/i
+];
+var OUTAGE_STATUS_CODES = new Set([500, 502, 503, 504]);
+var TRANSPORT_CODES = new Set([
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "ENOTFOUND",
+  "ETIMEDOUT",
+  "EAI_AGAIN"
+]);
+var TRANSPORT_MESSAGE_PATTERNS = [
+  /^fetch failed$/i,
+  /^socket hang up$/i,
+  /^provider request timeout$/i,
+  /^request timeout$/i,
+  /^connect ECONNREFUSED\b/i,
+  /^getaddrinfo ENOTFOUND\b/i
 ];
-function isRateLimitError(error) {
-  if (!error || typeof error !== "object")
+var PROVIDER_OUTAGE_PATTERNS = [
+  /\binternal server error\b/i,
+  /\bbad gateway\b/i,
+  /\bgateway timeout\b/i,
+  /\bservice unavailable\b/i,
+  /\bupstream outage\b/i,
+  /\bprovider outage\b/i,
+  /\bprovider unavailable\b/i
+];
+function extractStatusCode(error) {
+  const value = error.statusCode ?? error.data?.statusCode;
+  return typeof value === "number" ? value : undefined;
+}
+function eventSessionID(props) {
+  return props.sessionID ?? props.info?.id;
+}
+function isFailoverError(error) {
+  if (!error)
+    return false;
+  if (typeof error === "string") {
+    return RETRYABLE_ERROR_PATTERNS.some((pattern) => pattern.test(error)) || PROVIDER_OUTAGE_PATTERNS.some((pattern) => pattern.test(error)) || TRANSPORT_MESSAGE_PATTERNS.some((pattern) => pattern.test(error));
+  }
+  if (typeof error !== "object")
     return false;
   const err = error;
+  const statusCode = extractStatusCode(err);
+  if (statusCode === 429 || statusCode === 403 || statusCode !== undefined && OUTAGE_STATUS_CODES.has(statusCode)) {
+    return true;
+  }
+  if ([err.code, err.cause?.code, err.data?.code].some((code) => typeof code === "string" && TRANSPORT_CODES.has(code))) {
+    return true;
+  }
+  const messages = [
+    err.message ?? "",
+    err.data?.message ?? "",
+    err.data?.responseBody ?? ""
+  ];
+  if (messages.some((message) => TRANSPORT_MESSAGE_PATTERNS.some((p) => p.test(message)))) {
+    return true;
+  }
   const text = [
     err.message ?? "",
-    String(err.data?.statusCode ?? ""),
     err.data?.message ?? "",
     err.data?.responseBody ?? ""
   ].join(" ");
-  return RATE_LIMIT_PATTERNS.some((p) => p.test(text));
+  const hasFailoverReason = RETRYABLE_ERROR_PATTERNS.some((p) => p.test(text)) || PROVIDER_OUTAGE_PATTERNS.some((p) => p.test(text));
+  return hasFailoverReason;
 }
 var DEDUP_WINDOW_MS = 5000;
 var REPROMPT_DELAY_MS = 500;
@@ -25604,7 +25759,6 @@ class ForegroundFallbackManager {
   chains;
   enabled;
   maxRetries;
-  runtimeOverride;
   sessionModel = new Map;
   sessionAgent = new Map;
   sessionTried = new Map;
@@ -25615,18 +25769,26 @@ class ForegroundFallbackManager {
   isFallbackInProgress(sessionID) {
     return this.inProgress.has(sessionID);
   }
-  constructor(client, chains, enabled, maxRetries = 3, coordinator, runtimeOverride = true) {
+  disableChain(agentName) {
+    this.chains[agentName] = [];
+  }
+  registerSessionAgent(sessionID, agentName) {
+    const normalizedAgentName = agentName.trim();
+    if (!sessionID || !normalizedAgentName || this.sessionAgent.has(sessionID)) {
+      return;
+    }
+    this.sessionAgent.set(sessionID, normalizedAgentName);
+  }
+  constructor(client, chains, enabled, maxRetries = 3, coordinator) {
     this.client = client;
     this.chains = chains;
     this.enabled = enabled;
     this.maxRetries = maxRetries;
-    this.runtimeOverride = runtimeOverride;
     if (coordinator) {
       coordinator.onSessionDeleted((id) => {
         this.sessionModel.delete(id);
         this.sessionAgent.delete(id);
         this.sessionTried.delete(id);
-        this.inProgress.delete(id);
         this.lastTrigger.delete(id);
         this.lastTriggerModel.delete(id);
         this.sessionRetries.delete(id);
@@ -25648,13 +25810,13 @@ class ForegroundFallbackManager {
         if (!sessionID)
           break;
         if (typeof info.agent === "string") {
-          this.sessionAgent.set(sessionID, info.agent);
+          this.registerSessionAgent(sessionID, info.agent);
         }
         if (typeof info.providerID === "string" && typeof info.modelID === "string") {
           this.sessionModel.set(sessionID, `${info.providerID}/${info.modelID}`);
         }
-        if (info.error && isRateLimitError(info.error)) {
-          if (this.shouldIntervene(sessionID)) {
+        if (info.error && isFailoverError(info.error)) {
+          if (this.shouldTriggerFallback(sessionID)) {
             await this.tryFallback(sessionID);
           }
         } else {
@@ -25664,29 +25826,46 @@ class ForegroundFallbackManager {
       }
       case "session.error": {
         const props = event.properties;
-        if (props?.sessionID && props.error && isRateLimitError(props.error) && this.shouldIntervene(props.sessionID)) {
-          await this.tryFallback(props.sessionID);
+        if (!props)
+          break;
+        const sessionID = eventSessionID(props);
+        if (sessionID && props.error && isFailoverError(props.error) && this.shouldTriggerFallback(sessionID)) {
+          await this.tryFallback(sessionID);
         }
         break;
       }
       case "session.status": {
         const props = event.properties;
-        if (!props?.sessionID || !props.status?.message)
+        if (!props)
           break;
-        const msg = props.status.message.toLowerCase();
-        if (msg.includes("rate limit") || msg.includes("usage limit") || msg.includes("usage exceeded") || msg.includes("quota exceeded") || msg.includes("exceededbudget") || msg.includes("over budget") || msg.includes("insufficient") || msg.includes("high concurrency") || msg.includes("reduce concurrency")) {
-          if (this.checkRetryBudget(props.sessionID)) {
-            await this.tryFallback(props.sessionID);
+        const sessionID = eventSessionID(props);
+        if (!sessionID)
+          break;
+        const isFailoverRetry = props.status?.type === "retry" && (isFailoverError(props.error) || props.status.message !== undefined && isFailoverError({ message: props.status.message }));
+        if (isFailoverRetry) {
+          const prevModel = this.lastTriggerModel.get(sessionID);
+          const curModel = this.sessionModel.get(sessionID);
+          const lastTriggerTime = this.lastTrigger.get(sessionID) ?? 0;
+          const attempt = props.status?.attempt ?? 1;
+          const modelChanged = prevModel !== undefined && curModel !== undefined && prevModel !== curModel;
+          const withinDedupWindow = Date.now() - lastTriggerTime < DEDUP_WINDOW_MS;
+          if (modelChanged && withinDedupWindow && attempt > 1) {
+            break;
           }
-        } else {
-          this.sessionRetries.delete(props.sessionID);
+          if (this.shouldTriggerFallback(sessionID)) {
+            await this.tryFallbackWithAbort(sessionID);
+          }
+          break;
+        }
+        if (this.isRecoveredStatus(props.status?.type)) {
+          this.sessionRetries.delete(sessionID);
         }
         break;
       }
       case "subagent.session.created": {
         const props = event.properties;
         if (props?.sessionID && typeof props.agentName === "string") {
-          this.sessionAgent.set(props.sessionID, props.agentName);
+          this.registerSessionAgent(props.sessionID, props.agentName);
         }
         break;
       }
@@ -25702,7 +25881,7 @@ class ForegroundFallbackManager {
       }
     }
   }
-  checkRetryBudget(sessionID) {
+  consumeRetryBudget(sessionID) {
     const tried = this.sessionRetries.get(sessionID) ?? 0;
     if (tried < this.maxRetries - 1) {
       this.sessionRetries.set(sessionID, tried + 1);
@@ -25716,27 +25895,57 @@ class ForegroundFallbackManager {
     this.sessionRetries.delete(sessionID);
     return true;
   }
-  shouldIntervene(sessionID) {
+  shouldTriggerFallback(sessionID) {
     const tried = this.sessionRetries.get(sessionID) ?? 0;
     if (tried === 0)
       return true;
-    return this.checkRetryBudget(sessionID);
+    return this.consumeRetryBudget(sessionID);
+  }
+  isRecoveredStatus(statusType) {
+    return statusType === "idle" || statusType === "complete" || statusType === "completed" || statusType === "success" || statusType === "terminal";
   }
   async tryFallback(sessionID) {
     if (!sessionID)
       return;
     if (this.inProgress.has(sessionID))
       return;
+    if (this.isDeduped(sessionID))
+      return;
+    this.inProgress.add(sessionID);
+    try {
+      await this.execFallback(sessionID);
+    } finally {
+      this.inProgress.delete(sessionID);
+    }
+  }
+  async tryFallbackWithAbort(sessionID) {
+    if (!sessionID)
+      return;
+    if (this.inProgress.has(sessionID))
+      return;
+    if (this.isDeduped(sessionID))
+      return;
+    this.inProgress.add(sessionID);
+    try {
+      await abortSessionWithTimeout(this.client, sessionID);
+      await this.execFallback(sessionID);
+    } finally {
+      this.inProgress.delete(sessionID);
+    }
+  }
+  isDeduped(sessionID) {
     const now = Date.now();
     const curModel = this.sessionModel.get(sessionID);
     const modelChanged = this.lastTriggerModel.has(sessionID) && this.lastTriggerModel.get(sessionID) !== curModel;
     if (!modelChanged && now - (this.lastTrigger.get(sessionID) ?? 0) < DEDUP_WINDOW_MS)
-      return;
+      return true;
     this.lastTrigger.set(sessionID, now);
     if (curModel !== undefined) {
       this.lastTriggerModel.set(sessionID, curModel);
     }
-    this.inProgress.add(sessionID);
+    return false;
+  }
+  async execFallback(sessionID) {
     try {
       let currentModel = this.sessionModel.get(sessionID);
       const agentName = this.sessionAgent.get(sessionID);
@@ -25751,16 +25960,6 @@ class ForegroundFallbackManager {
       if (!currentModel && agentName && chain.length > 0) {
         currentModel = chain[0];
       }
-      if (!this.runtimeOverride && currentModel && !chain.includes(currentModel)) {
-        log("[foreground-fallback] current model not in chain, skipping fallback (runtimeOverride=false)", {
-          sessionID,
-          agentName,
-          currentModel,
-          chain
-        });
-        await abortSessionWithTimeout(this.client, sessionID);
-        return;
-      }
       if (!this.sessionTried.has(sessionID)) {
         this.sessionTried.set(sessionID, new Set);
       }
@@ -25820,10 +26019,15 @@ class ForegroundFallbackManager {
         log("[foreground-fallback] promptAsync unavailable", { sessionID });
         return;
       }
+      const promptBody = {
+        parts: lastUser.parts,
+        model: ref,
+        ...agentName ? { agent: agentName } : {}
+      };
       try {
         await sessionClient.promptAsync({
           path: { id: sessionID },
-          body: { parts: lastUser.parts, model: ref }
+          body: promptBody
         });
       } catch (_promptErr) {
         log("[foreground-fallback] promptAsync on busy session, aborting", {
@@ -25833,7 +26037,7 @@ class ForegroundFallbackManager {
         await new Promise((r) => setTimeout(r, REPROMPT_DELAY_MS));
         await sessionClient.promptAsync({
           path: { id: sessionID },
-          body: { parts: lastUser.parts, model: ref }
+          body: promptBody
         });
       }
       this.sessionModel.set(sessionID, nextModel);
@@ -25848,8 +26052,6 @@ class ForegroundFallbackManager {
         sessionID,
         error: err instanceof Error ? err.message : String(err)
       });
-    } finally {
-      this.inProgress.delete(sessionID);
     }
   }
   resolveChain(agentName, currentModel) {
@@ -25857,8 +26059,7 @@ class ForegroundFallbackManager {
       const chain = this.chains[agentName];
       if (chain)
         return chain;
-      if (ALL_AGENT_NAMES.includes(agentName))
-        return [];
+      return [];
     }
     if (currentModel) {
       for (const chain of Object.values(this.chains)) {
@@ -25945,10 +26146,14 @@ function cleanupAllSessions(saveDir) {
         try {
           if (now - statSync5(fp).mtimeMs > maxAge)
             unlinkSync3(fp);
-        } catch {}
+        } catch (err) {
+          log("[image-hook] file cleanup failed", String(err));
+        }
       }
     }
-  } catch {}
+  } catch (err) {
+    log("[image-hook] directory scan failed", String(err));
+  }
   for (const dir of dirsToScan) {
     try {
       let isEmpty = true;
@@ -25962,16 +26167,21 @@ function cleanupAllSessions(saveDir) {
           } else {
             allRemoved = false;
           }
-        } catch {
+        } catch (err) {
+          log("[image-hook] file cleanup failed", String(err));
           allRemoved = false;
         }
       }
       if (!isEmpty && allRemoved) {
         try {
           rmdirSync(dir);
-        } catch {}
+        } catch (err) {
+          log("[image-hook] directory removal failed", String(err));
+        }
       }
-    } catch {}
+    } catch (err) {
+      log("[image-hook] session cleanup failed", String(err));
+    }
   }
 }
 function writeUniqueFile(dir, name, data, log2) {
@@ -26001,7 +26211,9 @@ function writeUniqueFile(dir, name, data, log2) {
   return null;
 }
 function processImageAttachments(args) {
-  const { messages, workDir, disabledAgents, log: log2 } = args;
+  const { messages, workDir, imageRouting, disabledAgents, log: log2 } = args;
+  if (imageRouting === "direct")
+    return;
   const observerEnabled = !disabledAgents.has("observer");
   if (!observerEnabled)
     return;
@@ -26039,6 +26251,7 @@ function processImageAttachments(args) {
       log2(`[image-hook] failed to create target image directory: ${e}`);
     }
     const savedPaths = [];
+    const savedImageParts = new Set;
     for (const p of imageParts) {
       const url = p.url;
       const filename = p.filename ?? p.name;
@@ -26051,14 +26264,21 @@ function processImageAttachments(args) {
           const ext = sanitizedFilename ? extname(sanitizedFilename) || extFromMime(decoded.mime) : extFromMime(decoded.mime);
           const name = `${baseName}-${hash}${ext}`;
           const filePath = writeUniqueFile(targetDir, name, decoded.data, log2);
-          if (filePath)
+          if (filePath) {
             savedPaths.push(filePath);
+            savedImageParts.add(p);
+          }
         }
       }
     }
-    const pathsText = savedPaths.length > 0 ? ` Saved to: ${savedPaths.join(", ")}` : "";
-    log2(`[image-hook] stripping image/file parts, saving to disk${pathsText}`);
-    msg.parts = msg.parts.filter((p) => !isImagePart(p)).concat([
+    if (savedPaths.length === 0) {
+      log2("[image-hook] no images saved; leaving original parts in message");
+      continue;
+    }
+    const pathsText = ` Saved to: ${savedPaths.join(", ")}`;
+    log2(`[image-hook] saved image/file parts to disk${pathsText}`);
+    log2(`[image-routing] auto mode: intercepted ${savedImageParts.size} image(s), delegating to @observer`);
+    msg.parts = msg.parts.filter((p) => !savedImageParts.has(p)).concat([
       {
         type: "text",
         text: `[Image attachment detected.${pathsText} Your model may not support image input. Delegate to @observer with the file path(s) above so it can read the file with its read tool.]`
@@ -26161,15 +26381,7 @@ function helpPrompt() {
 function createLoopCommandHook() {
   return {
     registerCommand: (opencodeConfig) => {
-      const cfg = opencodeConfig.command;
-      if (cfg?.[COMMAND_NAME2])
-        return;
-      if (!opencodeConfig.command)
-        opencodeConfig.command = {};
-      opencodeConfig.command[COMMAND_NAME2] = {
-        template: "Run an automated execute-verify loop",
-        description: "Dispatch fixer, verify, iterate with file-based history on disk."
-      };
+      registerCommandHook(opencodeConfig, COMMAND_NAME2, "Run an automated execute-verify loop", "Dispatch fixer, verify, iterate with file-based history on disk.");
     },
     handleCommandExecuteBefore: async (input, output) => {
       if (input.command !== COMMAND_NAME2)
@@ -26223,7 +26435,7 @@ function createPhaseReminderHook(coordinator) {
       if (isInternalInitiatorPart(originalPart)) {
         return;
       }
-      if (lastUserMessage.parts.some((part) => part.synthetic === true && isRecord(part.metadata) && part.metadata[PHASE_REMINDER_METADATA_KEY] === true)) {
+      if (lastUserMessage.parts.some((part) => part.synthetic === true && isRecord2(part.metadata) && part.metadata[PHASE_REMINDER_METADATA_KEY] === true)) {
         return;
       }
       lastUserMessage.parts.push({
@@ -26297,18 +26509,7 @@ function createReflectCommandHook() {
   let shouldHandleCommand = false;
   return {
     registerCommand: (opencodeConfig) => {
-      const commandConfig = opencodeConfig.command;
-      if (commandConfig?.[COMMAND_NAME3]) {
-        shouldHandleCommand = false;
-        return;
-      }
-      if (!opencodeConfig.command)
-        opencodeConfig.command = {};
-      opencodeConfig.command[COMMAND_NAME3] = {
-        template: "Review repeated work and suggest workflow improvements",
-        description: "Use reflect to learn from repeated workflows and suggest reusable improvements"
-      };
-      shouldHandleCommand = true;
+      shouldHandleCommand ||= registerCommandHook(opencodeConfig, COMMAND_NAME3, "Review repeated work and suggest workflow improvements", "Use reflect to learn from repeated workflows and suggest reusable improvements");
     },
     handleCommandExecuteBefore: async (input, output) => {
       if (input.command !== COMMAND_NAME3 || !shouldHandleCommand)
@@ -26534,8 +26735,10 @@ function createTaskSessionManagerHook(_ctx, options) {
   const terminalJobsInjectedByParent = new Map;
   if (options.coordinator) {
     options.coordinator.onSessionDeleted((sessionId) => {
-      backgroundJobBoard.drop(sessionId);
-      backgroundJobBoard.clearParent(sessionId);
+      if (!options.isFallbackInProgress?.(sessionId)) {
+        backgroundJobBoard.drop(sessionId);
+        backgroundJobBoard.clearParent(sessionId);
+      }
       terminalJobsInjectedByParent.delete(sessionId);
       taskContextTracker.clearSession(sessionId);
       taskContextTracker.prune(backgroundJobBoard);
@@ -26705,7 +26908,7 @@ function createTaskSessionManagerHook(_ctx, options) {
           sessionID: input.sessionID
         });
       }
-      if (!isRecord(output.args))
+      if (!isRecord2(output.args))
         return;
       const args = output.args;
       if (typeof args.subagent_type !== "string" || args.subagent_type.trim() === "") {
@@ -26890,7 +27093,7 @@ function createTaskSessionManagerHook(_ctx, options) {
         if (isInternalInitiatorPart(textPart)) {
           return;
         }
-        if (message.parts.some((part) => part.synthetic === true && isRecord(part.metadata) && part.metadata[BACKGROUND_JOB_BOARD_METADATA_KEY] === true)) {
+        if (message.parts.some((part) => part.synthetic === true && isRecord2(part.metadata) && part.metadata[BACKGROUND_JOB_BOARD_METADATA_KEY] === true)) {
           return;
         }
         rememberInjectedTerminalJobs(message.info.sessionID);
@@ -26964,7 +27167,7 @@ function createTaskSessionManagerHook(_ctx, options) {
         }
         if (sessionId2 && options.shouldManageSession(sessionId2)) {
           const props = input.event.properties;
-          if (!props?.error || !isRateLimitError(props.error)) {
+          if (!props?.error || !isFailoverError(props.error)) {
             terminalJobsInjectedByParent.delete(sessionId2);
           }
         }
@@ -27035,7 +27238,7 @@ function createTaskSessionManagerHook(_ctx, options) {
       result: status.result
     });
     output.output = formatCancelledTaskStatusOutput(status.taskID, backgroundJobBoard.getResultSummary(status.taskID));
-    if (isRecord(output) && isRecord(output.metadata)) {
+    if (isRecord2(output) && isRecord2(output.metadata)) {
       output.metadata.state = "cancelled";
     }
   }
@@ -27073,6 +27276,23 @@ import { URL as URL2 } from "node:url";
 import * as fsSync from "node:fs";
 import * as fs6 from "node:fs/promises";
 import * as path13 from "node:path";
+
+// src/utils/frontmatter.ts
+function parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  if (!match)
+    return null;
+  const result = {};
+  for (const line of match[1].split(/\r?\n/)) {
+    const kv = line.match(/^([A-Za-z0-9_-]+):\s*(.+?)\s*$/);
+    if (!kv)
+      continue;
+    result[kv[1]] = kv[2].replace(/^(['"])(.*)\1$/, "$2");
+  }
+  return result;
+}
+
+// src/interview/document.ts
 var DEFAULT_OUTPUT_FOLDER = "interview";
 function normalizeOutputFolder(outputFolder) {
   const normalized = outputFolder.trim().replace(/^\/+|\/+$/g, "");
@@ -27182,20 +27402,7 @@ function buildInterviewDocument(idea, summary, history, meta) {
   ].join(`
 `);
 }
-function parseFrontmatter(content) {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n/);
-  if (!match)
-    return null;
-  const result = {};
-  for (const line of match[1].split(`
-`)) {
-    const colonIdx = line.indexOf(":");
-    if (colonIdx > 0) {
-      result[line.slice(0, colonIdx).trim()] = line.slice(colonIdx + 1).trim();
-    }
-  }
-  return result;
-}
+var parseFrontmatter2 = parseFrontmatter;
 async function ensureInterviewFile(record) {
   await fs6.mkdir(path13.dirname(record.markdownPath), { recursive: true });
   try {
@@ -27333,11 +27540,13 @@ async function readJsonBody(request) {
   return raw ? JSON.parse(raw) : {};
 }
 
-// src/interview/ui.ts
-var BRAND_LOGO_URL = "https://ohmyopencodeslim.com/android-chrome-512x512.png";
+// src/utils/escape-html.ts
 function escapeHtml(value) {
-  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&#39;");
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }
+
+// src/interview/ui.ts
+var BRAND_LOGO_URL = "https://ohmyopencodeslim.com/android-chrome-512x512.png";
 function clipboardHelperJs() {
   return `
       function copyCommand(text, btn) {
@@ -29513,7 +29722,7 @@ data: ${JSON.stringify(formatSseState(entry))}
         const title = extractTitle(content) || entry.replace(/\.md$/, "");
         const summary = extractSummarySection(content);
         const baseName = entry.replace(/\.md$/, "");
-        const fm = parseFrontmatter(content);
+        const fm = parseFrontmatter2(content);
         items.push({
           fileName: entry,
           resumeCommand: `/interview ${baseName}`,
@@ -29548,7 +29757,7 @@ data: ${JSON.stringify(formatSseState(entry))}
         } catch {
           continue;
         }
-        const fm = parseFrontmatter(content);
+        const fm = parseFrontmatter2(content);
         if (!fm?.sessionID)
           continue;
         const title = extractTitle(content) || entry.replace(/\.md$/, "");
@@ -31301,6 +31510,14 @@ function createInterviewService(ctx, config, deps) {
     const interview = await createInterview(input.sessionID, idea);
     await notifyInterviewUrl(input.sessionID, interview);
     output.parts.push(createInternalAgentTextPart(buildKickoffPrompt(idea, maxQuestions)));
+    let sessionTitle = `Interview: ${idea}`;
+    if (sessionTitle.length > 50) {
+      sessionTitle = `${sessionTitle.slice(0, 49)}…`;
+    }
+    ctx.client.session.update?.({
+      path: { id: input.sessionID },
+      body: { title: sessionTitle }
+    })?.catch(() => {});
   }
   async function handleEvent(input) {
     const { event } = input;
@@ -32061,21 +32278,23 @@ function createBuiltinMcps(disabledMcps = [], websearchConfig) {
   return mcps;
 }
 
-// src/multiplexer/herdr/index.ts
+// src/multiplexer/cmux/index.ts
 init_compat();
 
 // src/multiplexer/shared.ts
 init_compat();
+import { existsSync as existsSync9 } from "node:fs";
+import { basename as basename6, isAbsolute as isAbsolute5 } from "node:path";
 function quoteShellArg(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function normalizePathForShell(directory) {
   return process.platform === "win32" ? directory.replace(/\\/g, "/") : directory;
 }
-function buildOpencodeAttachCommand(sessionId, serverUrl, directory) {
+function buildOpencodeAttachCommand(sessionId, serverUrl, directory, executable = "opencode") {
   const attachDir = normalizePathForShell(directory);
   return [
-    "opencode",
+    executable === "opencode" ? executable : quoteShellArg(executable),
     "attach",
     quoteShellArg(serverUrl),
     "--session",
@@ -32084,6 +32303,20 @@ function buildOpencodeAttachCommand(sessionId, serverUrl, directory) {
     quoteShellArg(attachDir)
   ].join(" ");
 }
+function resolveHostOpencodeBinary(options = {}) {
+  const pathExists = options.pathExists ?? existsSync9;
+  for (const candidate of [
+    options.override,
+    options.envOverride ?? process.env.OPENCODE_BIN,
+    options.execPath ?? process.execPath,
+    options.argv0 ?? process.argv[0]
+  ]) {
+    if (candidate && isAbsolute5(candidate) && /^opencode(?:\.exe)?$/i.test(basename6(candidate)) && pathExists(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
 async function findBinary(binaryName, options = {}) {
   const isWindows = process.platform === "win32";
   const cmd = isWindows ? "where" : "which";
@@ -32165,50 +32398,591 @@ async function gracefulClosePane(binary, paneId, options) {
   }
 }
 
-// src/multiplexer/herdr/index.ts
-class HerdrMultiplexer {
-  type = "herdr";
-  binaryPath = null;
-  hasChecked = false;
-  parentPaneId = process.env.HERDR_PANE_ID;
-  layout;
-  paneDirection;
-  agentAreaPaneId = null;
-  constructor(layout = "main-vertical", mainPaneSize = 60) {
-    this.layout = layout;
-    this.paneDirection = getPaneDirection(layout);
+// src/multiplexer/cmux/index.ts
+var MINIMUM_VERSION = "0.64.14";
+var READINESS_DELAYS_MS = [50, 100, 200, 400, 500, 500, 250];
+var registries = new Map;
+var mutationQueue = Promise.resolve();
+var mutationSequence = 0;
+
+class CmuxMultiplexer {
+  client;
+  type = "cmux";
+  versionAvailable = false;
+  availabilityError = "unavailable";
+  checkSessionReady;
+  delay;
+  readinessAttemptTimeoutMs;
+  opencodeBinary;
+  constructor(client = new CliCmuxClient, options = {}) {
+    this.client = client;
+    this.checkSessionReady = options.checkSessionReady ?? defaultSessionReady;
+    this.delay = options.delay ?? defaultDelay;
+    this.readinessAttemptTimeoutMs = options.readinessAttemptTimeoutMs ?? 1000;
+    this.opencodeBinary = resolveHostOpencodeBinary({
+      override: options.opencodeBinary,
+      pathExists: options.pathExists
+    });
   }
   async isAvailable() {
-    if (this.hasChecked) {
-      return this.binaryPath !== null;
+    if (this.versionAvailable)
+      return true;
+    const version = await this.client.version().catch(() => null);
+    if (version && compareVersions2(version, MINIMUM_VERSION) >= 0) {
+      this.versionAvailable = true;
+      return true;
     }
-    this.binaryPath = await findBinary("herdr");
-    this.hasChecked = true;
-    return this.binaryPath !== null;
+    this.availabilityError = version ? "hard" : this.client.getVersionError?.() ?? "unavailable";
+    return false;
   }
   isInsideSession() {
-    return !!(process.env.HERDR_ENV || process.env.HERDR_PANE_ID);
-  }
-  async spawnPane(sessionId, description, serverUrl, directory) {
-    const herdr = await this.getBinary();
-    if (!herdr) {
-      log("[herdr] spawnPane: herdr binary not found");
-      return { success: false };
+    return Boolean(process.env.CMUX_SOCKET_PATH && process.env.CMUX_WORKSPACE_ID && process.env.CMUX_SURFACE_ID);
+  }
+  async spawnPane(sessionId, _description, serverUrl, directory) {
+    if (!this.opencodeBinary)
+      return { success: false, error: "hard" };
+    const opencodeBinary = this.opencodeBinary;
+    const statusUrl = new URL("/session/status", serverUrl);
+    if (!await this.waitForSession(statusUrl, sessionId)) {
+      log("[cmux] spawnPane failed", {
+        stage: "readinessTimeout",
+        sessionId
+      });
+      return { success: false, error: "unavailable" };
     }
-    try {
-      const attachDir = normalizePathForShell(directory);
-      let paneId = null;
-      let lastRawOutput = "";
-      if (this.layout === "main-vertical" && this.agentAreaPaneId) {
-        const result = await this.runSplit([this.agentAreaPaneId], "down", attachDir);
-        paneId = result.paneId;
-        if (!paneId) {
-          log("[herdr] agent area split failed, falling back to parent", {
-            agentAreaPaneId: this.agentAreaPaneId
-          });
-          this.agentAreaPaneId = null;
-        }
-      }
+    return enqueueMutation("spawn", async (sequence) => {
+      if (!await this.isAvailable()) {
+        log("[cmux] spawnPane failed", {
+          sequence,
+          stage: "version",
+          sessionId
+        });
+        return {
+          success: false,
+          error: this.availabilityError
+        };
+      }
+      const root = await this.client.identify();
+      if (!root) {
+        log("[cmux] spawnPane failed", {
+          sequence,
+          stage: "identify",
+          sessionId
+        });
+        return {
+          success: false,
+          error: this.client.getIdentifyError?.() ?? "unavailable"
+        };
+      }
+      const key = registryKey(root.socketPath, root.workspaceId);
+      const registry = registries.get(key) ?? { root, agents: [] };
+      registries.set(key, registry);
+      const previous = registry.agents.at(-1);
+      const targetSurfaceId = previous?.surfaceId ?? registry.root.surfaceId;
+      const direction = previous ? "down" : "right";
+      const created = await this.client.createSurface({
+        workspaceId: root.workspaceId,
+        targetSurfaceId,
+        direction,
+        focus: false
+      }, root.socketPath);
+      if (!created) {
+        log("[cmux] spawnPane failed", {
+          sequence,
+          stage: "createSurface",
+          sessionId,
+          workspaceId: root.workspaceId,
+          targetSurfaceId,
+          direction
+        });
+        return {
+          success: false,
+          error: this.client.getCreateError?.() ?? "hard"
+        };
+      }
+      const handle = {
+        v: 1,
+        socketPath: root.socketPath,
+        workspaceId: root.workspaceId,
+        paneId: created.paneId,
+        surfaceId: created.surfaceId
+      };
+      const encodedHandle = encodeHandle(handle);
+      const command = buildOpencodeAttachCommand(sessionId, serverUrl, directory, opencodeBinary);
+      try {
+        const started = await this.client.respawnSurface(root.workspaceId, created.surfaceId, command, root.socketPath);
+        if (!started) {
+          log("[cmux] spawnPane failed", {
+            sequence,
+            stage: "respawn",
+            sessionId,
+            workspaceId: root.workspaceId,
+            targetSurfaceId,
+            direction
+          });
+          throw new Error("cmux respawn-pane failed");
+        }
+      } catch (error) {
+        log("[cmux] spawnPane respawn exception", {
+          sequence,
+          stage: "respawn",
+          sessionId,
+          workspaceId: root.workspaceId,
+          targetSurfaceId,
+          direction,
+          errorType: errorName(error)
+        });
+        const cleaned = await this.cleanupPane(root.workspaceId, created.surfaceId, root.socketPath);
+        return cleaned ? { success: false, error: "unavailable" } : {
+          success: false,
+          error: "unavailable",
+          orphanPaneId: encodedHandle
+        };
+      }
+      registry.agents.push(handle);
+      await this.equalize(root.workspaceId, root.socketPath);
+      return { success: true, paneId: encodeHandle(handle) };
+    });
+  }
+  closePane(paneId) {
+    const handle = decodeHandle(paneId);
+    if (!handle)
+      return Promise.resolve(false);
+    return enqueueMutation("close", async () => {
+      if (!await this.isAvailable())
+        return false;
+      const result = await this.client.closeSurface(handle.workspaceId, handle.surfaceId, handle.socketPath);
+      if (result === "failed")
+        return false;
+      const key = registryKey(handle.socketPath, handle.workspaceId);
+      const registry = registries.get(key);
+      if (registry) {
+        const index = registry.agents.findIndex((agent) => agent.surfaceId === handle.surfaceId);
+        if (index >= 0)
+          registry.agents.splice(index, 1);
+        if (registry.agents.length === 0)
+          registries.delete(key);
+      }
+      await this.equalize(handle.workspaceId, handle.socketPath);
+      return true;
+    });
+  }
+  async applyLayout(_layout, _mainPaneSize) {}
+  async cleanupPane(workspaceId, surfaceId, socketPath) {
+    try {
+      const result = await this.client.closeSurface(workspaceId, surfaceId, socketPath);
+      if (result === "failed") {
+        log("[cmux] failed to close pre-respawn surface", {
+          workspaceId,
+          surfaceId
+        });
+        return false;
+      }
+      return true;
+    } catch (error) {
+      log("[cmux] failed to close pre-respawn surface", {
+        workspaceId,
+        surfaceId,
+        errorType: errorName(error)
+      });
+      return false;
+    }
+  }
+  async waitForSession(url, sessionId) {
+    for (let attempt = 0;attempt <= READINESS_DELAYS_MS.length; attempt++) {
+      const controller = new AbortController;
+      const timeout = setTimeout(() => controller.abort(), this.readinessAttemptTimeoutMs);
+      timeout.unref?.();
+      try {
+        if (await Promise.race([
+          this.checkSessionReady(url, sessionId, controller.signal),
+          new Promise((resolve4) => controller.signal.addEventListener("abort", () => resolve4(false), {
+            once: true
+          }))
+        ])) {
+          return true;
+        }
+      } catch {} finally {
+        clearTimeout(timeout);
+      }
+      const delay2 = READINESS_DELAYS_MS[attempt];
+      if (delay2 === undefined)
+        return false;
+      await this.delay(delay2);
+    }
+    return false;
+  }
+  async equalize(workspaceId, socketPath) {
+    try {
+      const success = await this.client.equalizeSplits({
+        workspace_id: workspaceId,
+        orientation: "vertical"
+      }, socketPath);
+      if (!success)
+        log("[cmux] workspace.equalize_splits failed", { workspaceId });
+    } catch (error) {
+      log("[cmux] workspace.equalize_splits failed", {
+        workspaceId,
+        error: String(error)
+      });
+    }
+  }
+}
+
+class SpawnCommandRunner {
+  timeoutMs;
+  spawn;
+  constructor(timeoutMs = 5000, spawn3 = crossSpawn) {
+    this.timeoutMs = timeoutMs;
+    this.spawn = spawn3;
+  }
+  async run(argv) {
+    const proc = this.spawn(argv, { stdout: "pipe", stderr: "pipe" });
+    let timeout;
+    try {
+      return await Promise.race([
+        Promise.all([proc.exited, proc.stdout(), proc.stderr()]).then(([exitCode, stdout, stderr]) => ({ exitCode, stdout, stderr })),
+        new Promise((resolve4) => {
+          timeout = setTimeout(() => {
+            proc.kill("SIGTERM");
+            resolve4({
+              exitCode: 124,
+              stdout: "",
+              stderr: "unavailable: cmux command timed out"
+            });
+          }, this.timeoutMs);
+          timeout.unref?.();
+        })
+      ]);
+    } finally {
+      if (timeout)
+        clearTimeout(timeout);
+    }
+  }
+}
+
+class CliCmuxClient {
+  runner;
+  binary = null;
+  versionError = "unavailable";
+  identifyError = "unavailable";
+  lastRunThrew = false;
+  createError = "hard";
+  constructor(runner = new SpawnCommandRunner, binary) {
+    this.runner = runner;
+    this.binary = binary ?? null;
+  }
+  async version() {
+    this.versionError = "unavailable";
+    const result = await this.run(["--version"]);
+    if (!result || result.exitCode !== 0) {
+      this.versionError = "unavailable";
+      return null;
+    }
+    const version = result.stdout.match(/\d+\.\d+\.\d+/)?.[0] ?? null;
+    this.versionError = "hard";
+    return version;
+  }
+  getVersionError() {
+    return this.versionError;
+  }
+  async identify() {
+    this.identifyError = "unavailable";
+    const result = await this.run(["--id-format", "uuids", "identify"]);
+    if (!result || result.exitCode !== 0) {
+      this.identifyError = "unavailable";
+      return null;
+    }
+    const value = asRecord(parseJson(result.stdout));
+    const caller = asRecord(value?.caller);
+    const focused = asRecord(value?.focused);
+    const workspaceId = stringField(caller, "workspace_id") ?? stringField(focused, "workspace_id");
+    const paneId = stringField(caller, "pane_id") ?? stringField(focused, "pane_id");
+    const surfaceId = stringField(caller, "surface_id") ?? stringField(focused, "surface_id");
+    const socketPath = stringField(value, "socket_path");
+    if (workspaceId && paneId && surfaceId && socketPath) {
+      return { workspaceId, paneId, surfaceId, socketPath };
+    }
+    log("[cmux] response parse failed", {
+      operation: "identify",
+      reason: value ? "missing_fields" : "invalid_json",
+      stdoutLength: result.stdout.length
+    });
+    this.identifyError = "hard";
+    return null;
+  }
+  getIdentifyError() {
+    return this.identifyError;
+  }
+  async createSurface(input, socketPath) {
+    this.createError = "hard";
+    const result = await this.run(withSocket(socketPath, [
+      "--json",
+      "--id-format",
+      "uuids",
+      "new-split",
+      input.direction,
+      "--workspace",
+      input.workspaceId,
+      "--surface",
+      input.targetSurfaceId,
+      "--focus",
+      "false"
+    ]));
+    if (!result || result.exitCode !== 0) {
+      this.createError = this.lastRunThrew ? "unavailable" : classifyCreateError(result?.stderr ?? "");
+      return null;
+    }
+    const value = asRecord(parseJson(result.stdout));
+    const resultValue = asRecord(value?.result);
+    const pane = asRecord(resultValue?.pane);
+    const paneId = stringField(value, "pane_id") ?? stringField(resultValue, "pane_id") ?? stringField(pane, "pane_id");
+    const surfaceId = stringField(value, "surface_id") ?? stringField(resultValue, "surface_id") ?? stringField(pane, "surface_id");
+    if (paneId && surfaceId)
+      return { paneId, surfaceId };
+    log("[cmux] response parse failed", {
+      operation: "new-split",
+      reason: value ? "missing_fields" : "invalid_json",
+      stdoutLength: result.stdout.length
+    });
+    return null;
+  }
+  getCreateError() {
+    return this.createError;
+  }
+  async respawnSurface(workspaceId, surfaceId, command, socketPath) {
+    const result = await this.run(withSocket(socketPath, [
+      "respawn-pane",
+      "--workspace",
+      workspaceId,
+      "--surface",
+      surfaceId,
+      "--command",
+      command
+    ]));
+    return result?.exitCode === 0;
+  }
+  async closeSurface(workspaceId, surfaceId, socketPath) {
+    const result = await this.run(withSocket(socketPath, [
+      "close-surface",
+      "--workspace",
+      workspaceId,
+      "--surface",
+      surfaceId
+    ]));
+    if (result?.exitCode === 0)
+      return "closed";
+    return result?.stderr.toLowerCase().includes("not_found") || result?.stderr.toLowerCase().includes("not found") ? "not_found" : "failed";
+  }
+  async equalizeSplits(params, socketPath) {
+    const result = await this.run(withSocket(socketPath, [
+      "rpc",
+      "workspace.equalize_splits",
+      JSON.stringify(params)
+    ]));
+    return result?.exitCode === 0;
+  }
+  async run(args) {
+    this.lastRunThrew = false;
+    this.binary ??= await findBinary("cmux");
+    if (!this.binary)
+      return null;
+    let result;
+    try {
+      result = await this.runner.run([this.binary, ...args]);
+    } catch (error) {
+      this.lastRunThrew = true;
+      log("[cmux] command threw", {
+        operation: commandOperation(args),
+        errorType: errorName(error)
+      });
+      return null;
+    }
+    if (result.exitCode !== 0) {
+      const operation = commandOperation(args);
+      log("[cmux] command failed", {
+        operation,
+        exitCode: result.exitCode,
+        stderr: operation === "respawn-pane" ? "[redacted: may contain attach command]" : safeSummary(result.stderr)
+      });
+    }
+    return result;
+  }
+}
+function enqueueMutation(operation, mutation) {
+  const sequence = ++mutationSequence;
+  log("[cmux] mutation enqueue", {
+    sequence,
+    operation,
+    agentCount: registryAgentCount()
+  });
+  const run = async () => {
+    log("[cmux] mutation start", {
+      sequence,
+      operation,
+      agentCount: registryAgentCount()
+    });
+    try {
+      return await mutation(sequence);
+    } finally {
+      log("[cmux] mutation end", {
+        sequence,
+        operation,
+        agentCount: registryAgentCount()
+      });
+    }
+  };
+  const result = mutationQueue.then(run, run);
+  mutationQueue = result.then(() => {
+    return;
+  }, () => {
+    return;
+  });
+  return result;
+}
+function registryAgentCount() {
+  let count = 0;
+  for (const registry of registries.values())
+    count += registry.agents.length;
+  return count;
+}
+function commandOperation(args) {
+  return args.find((arg) => [
+    "identify",
+    "new-split",
+    "respawn-pane",
+    "close-surface",
+    "rpc"
+  ].includes(arg)) ?? "version";
+}
+function withSocket(socketPath, args) {
+  return socketPath ? ["--socket", socketPath, ...args] : args;
+}
+function safeSummary(value) {
+  const trimmed = value.trim();
+  return trimmed.length > 300 ? `${trimmed.slice(0, 300)}…` : trimmed;
+}
+function classifyCreateError(stderr) {
+  const normalized = stderr.toLowerCase();
+  if (normalized.includes("not_found") || normalized.includes("not found")) {
+    return "not_found";
+  }
+  if (normalized.includes("unavailable"))
+    return "unavailable";
+  if (normalized.includes("invalid_state") || normalized.includes("invalid state")) {
+    return "invalid_state";
+  }
+  return "hard";
+}
+function errorName(error) {
+  return error instanceof Error ? error.name : typeof error;
+}
+async function defaultSessionReady(url, sessionId, signal) {
+  const response = await fetch(url, { signal });
+  if (!response.ok)
+    return false;
+  const statuses = await response.json();
+  return ["idle", "running", "busy", "retry"].includes(statuses[sessionId]?.type ?? "");
+}
+function defaultDelay(milliseconds) {
+  return new Promise((resolve4) => setTimeout(resolve4, milliseconds));
+}
+function registryKey(socketPath, workspaceId) {
+  return `${socketPath}\x00${workspaceId}`;
+}
+function encodeHandle(handle) {
+  return `cmux:v1:${Buffer.from(JSON.stringify(handle)).toString("base64url")}`;
+}
+function decodeHandle(value) {
+  if (!value.startsWith("cmux:v1:"))
+    return null;
+  try {
+    const parsed = JSON.parse(Buffer.from(value.slice("cmux:v1:".length), "base64url").toString());
+    return parsed.v === 1 && typeof parsed.socketPath === "string" && typeof parsed.workspaceId === "string" && typeof parsed.paneId === "string" && typeof parsed.surfaceId === "string" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function compareVersions2(left, right) {
+  const a = left.split(".").map(Number);
+  const b = right.split(".").map(Number);
+  for (let index = 0;index < 3; index++) {
+    if (a[index] !== b[index])
+      return (a[index] ?? 0) - (b[index] ?? 0);
+  }
+  return 0;
+}
+function parseJson(stdout) {
+  try {
+    return JSON.parse(stdout);
+  } catch {
+    return null;
+  }
+}
+function asRecord(value) {
+  return value && typeof value === "object" ? value : null;
+}
+function stringField(value, field) {
+  const candidate = value?.[field];
+  return typeof candidate === "string" ? candidate : null;
+}
+// src/multiplexer/herdr/index.ts
+init_compat();
+class HerdrMultiplexer {
+  type = "herdr";
+  binaryPath = null;
+  hasChecked = false;
+  parentPaneId = process.env.HERDR_PANE_ID;
+  layout;
+  paneDirection;
+  agentAreaPaneId = null;
+  spawnMutex = Promise.resolve();
+  constructor(layout = "main-vertical", mainPaneSize = 60) {
+    this.layout = layout;
+    this.paneDirection = getPaneDirection(layout);
+  }
+  async isAvailable() {
+    if (this.hasChecked) {
+      return this.binaryPath !== null;
+    }
+    this.binaryPath = await findBinary("herdr");
+    this.hasChecked = true;
+    return this.binaryPath !== null;
+  }
+  isInsideSession() {
+    return !!(process.env.HERDR_ENV || process.env.HERDR_PANE_ID);
+  }
+  async spawnPane(sessionId, description, serverUrl, directory) {
+    const prev = this.spawnMutex;
+    let release2;
+    this.spawnMutex = new Promise((r) => release2 = r);
+    await prev;
+    try {
+      return await this.doSpawn(sessionId, description, serverUrl, directory);
+    } finally {
+      release2();
+    }
+  }
+  async doSpawn(sessionId, description, serverUrl, directory) {
+    const herdr = await this.getBinary();
+    if (!herdr) {
+      log("[herdr] spawnPane: herdr binary not found");
+      return { success: false };
+    }
+    try {
+      const attachDir = normalizePathForShell(directory);
+      let paneId = null;
+      let lastRawOutput = "";
+      if (this.layout === "main-vertical" && this.agentAreaPaneId) {
+        const result = await this.runSplit([this.agentAreaPaneId], "down", attachDir);
+        paneId = result.paneId;
+        if (!paneId) {
+          log("[herdr] agent area split failed, falling back to parent", {
+            agentAreaPaneId: this.agentAreaPaneId
+          });
+          this.agentAreaPaneId = null;
+        }
+      }
       if (!this.agentAreaPaneId) {
         const result = await this.runSplit(this.targetPaneArg(), this.paneDirection, attachDir);
         paneId = result.paneId;
@@ -32560,6 +33334,7 @@ class ZellijMultiplexer {
           this.firstPaneUsed = true;
           return { success: true, paneId: this.firstPaneId };
         }
+        this.firstPaneUsed = true;
       }
       return await this.createPaneInAgentTab(zellij, sessionId, serverUrl, directory, description);
     } catch {
@@ -32689,13 +33464,12 @@ class ZellijMultiplexer {
     try {
       const existingTab = await this.findTabByName(zellij, "opencode-agents");
       if (existingTab) {
-        const firstPane = await this.getFirstPaneInTab(zellij, existingTab.tabId);
+        const firstPane2 = await this.getFirstPaneInTab(zellij, existingTab.tabId);
         return {
           tabId: existingTab.tabId,
-          firstPaneId: firstPane || "terminal_0"
+          firstPaneId: firstPane2
         };
       }
-      const beforePanes = await this.listPanes(zellij);
       const createProc = crossSpawn([zellij, "action", "new-tab", "--name", "opencode-agents"], { stdout: "pipe", stderr: "pipe" });
       const createExit = await createProc.exited;
       if (createExit !== 0)
@@ -32703,27 +33477,33 @@ class ZellijMultiplexer {
       const newTab = await this.findTabByName(zellij, "opencode-agents");
       if (!newTab)
         return null;
-      const afterPanes = await this.listPanes(zellij);
-      const newPane = afterPanes.find((p) => !beforePanes.includes(p));
-      return { tabId: newTab.tabId, firstPaneId: newPane || "terminal_0" };
+      const firstPane = await this.getFirstPaneInTab(zellij, newTab.tabId);
+      return { tabId: newTab.tabId, firstPaneId: firstPane };
+    } catch {
+      return null;
+    }
+  }
+  async listPanesJson(zellij) {
+    try {
+      const proc = crossSpawn([zellij, "action", "list-panes", "--json", "--tab", "--all"], { stdout: "pipe", stderr: "pipe" });
+      if (await proc.exited !== 0)
+        return null;
+      const stdout = await proc.stdout();
+      return JSON.parse(stdout);
     } catch {
       return null;
     }
   }
   async getFirstPaneInTab(zellij, tabId) {
-    const originalTab = await this.getCurrentTabId(zellij);
-    await crossSpawn([zellij, "action", "go-to-tab-by-id", tabId], {
-      stdout: "ignore",
-      stderr: "ignore"
-    }).exited;
-    const panes = await this.listPanes(zellij);
-    if (originalTab) {
-      await crossSpawn([zellij, "action", "go-to-tab-by-id", String(originalTab)], {
-        stdout: "ignore",
-        stderr: "ignore"
-      }).exited;
+    try {
+      const panes = await this.listPanesJson(zellij);
+      if (!panes)
+        return null;
+      const pane = panes.find((candidate) => !candidate.is_plugin && candidate.tab_id === Number(tabId));
+      return pane ? `terminal_${pane.id}` : null;
+    } catch {
+      return null;
     }
-    return panes[0] || null;
   }
   async findTabByName(zellij, name) {
     try {
@@ -32793,142 +33573,814 @@ class ZellijMultiplexer {
       return null;
     }
   }
-  async listPanes(zellij) {
+  async closePane(paneId) {
+    const zellij = await this.getBinary();
+    return gracefulClosePane(zellij, paneId, {
+      ctrlC: ["action", "write", "--pane-id", paneId, "\x03"],
+      close: ["action", "close-pane", "--pane-id", paneId],
+      acceptExitCode1: true,
+      emptyPaneReturnsTrue: true
+    });
+  }
+  async applyLayout(_layout, _mainPaneSize) {}
+  directionArgs() {
+    return this.paneDirection ? ["--direction", this.paneDirection] : [];
+  }
+  tabIdArgs(tabId) {
+    return tabId ? ["--tab-id", tabId] : [];
+  }
+  async getParentTabId(zellij) {
+    if (this.parentTabId)
+      return this.parentTabId;
+    if (this.parentPaneId) {
+      const tabId = await this.findTabIdForPane(zellij, this.parentPaneId);
+      if (tabId) {
+        this.parentTabId = tabId;
+        return tabId;
+      }
+    }
+    this.parentTabId = await this.getCurrentTabId(zellij);
+    return this.parentTabId;
+  }
+  async findTabIdForPane(zellij, paneId) {
+    try {
+      const panes = await this.listPanesJson(zellij);
+      if (!panes)
+        return null;
+      const normalizedPaneId = normalizePaneId(paneId);
+      const pane = panes.find((candidate) => !candidate.is_plugin && String(candidate.id) === normalizedPaneId);
+      return pane?.tab_id === undefined ? null : String(pane.tab_id);
+    } catch {
+      return null;
+    }
+  }
+  async getBinary() {
+    await this.isAvailable();
+    return this.binaryPath;
+  }
+}
+function normalizePaneId(paneId) {
+  return paneId.replace(/^terminal_/, "");
+}
+function getPaneDirection2(layout) {
+  switch (layout) {
+    case "main-vertical":
+      return "right";
+    case "main-horizontal":
+      return "down";
+    case "even-horizontal":
+    case "even-vertical":
+    case "tiled":
+      return null;
+  }
+}
+function buildShellLaunchCommand(command) {
+  return ["sh", "-lc", quoteShellArg(command)].join(" ");
+}
+
+// src/multiplexer/factory.ts
+function getMultiplexer(config) {
+  const { type } = config;
+  if (type === "none") {
+    return null;
+  }
+  let multiplexer;
+  let actualType;
+  switch (type) {
+    case "tmux":
+      multiplexer = new TmuxMultiplexer(config.layout, config.main_pane_size);
+      actualType = "tmux";
+      break;
+    case "zellij":
+      multiplexer = new ZellijMultiplexer(config.layout, config.main_pane_size, config.zellij_pane_mode);
+      actualType = "zellij";
+      break;
+    case "herdr":
+      multiplexer = new HerdrMultiplexer(config.layout, config.main_pane_size);
+      actualType = "herdr";
+      break;
+    case "cmux":
+      multiplexer = new CmuxMultiplexer;
+      actualType = "cmux";
+      break;
+    case "auto": {
+      if (process.env.CMUX_SOCKET_PATH && process.env.CMUX_WORKSPACE_ID && process.env.CMUX_SURFACE_ID) {
+        multiplexer = new CmuxMultiplexer;
+        actualType = "cmux";
+      } else if (process.env.TMUX) {
+        multiplexer = new TmuxMultiplexer(config.layout, config.main_pane_size);
+        actualType = "tmux";
+      } else if (process.env.ZELLIJ) {
+        multiplexer = new ZellijMultiplexer(config.layout, config.main_pane_size, config.zellij_pane_mode);
+        actualType = "zellij";
+      } else if (process.env.HERDR_ENV || process.env.HERDR_PANE_ID) {
+        multiplexer = new HerdrMultiplexer(config.layout, config.main_pane_size);
+        actualType = "herdr";
+      } else {
+        log("[multiplexer] auto: not inside any session, disabling");
+        return null;
+      }
+      break;
+    }
+    default:
+      log(`[multiplexer] Unknown type: ${type}`);
+      return null;
+  }
+  log(`[multiplexer] Created ${actualType} instance`);
+  return multiplexer;
+}
+function startAvailabilityCheck(config) {
+  const multiplexer = getMultiplexer(config);
+  if (multiplexer) {
+    multiplexer.isAvailable().catch(() => {});
+  }
+}
+// src/multiplexer/types.ts
+async function isServerRunning(serverUrl, timeoutMs = 3000, maxAttempts = 2) {
+  const healthUrl = new URL("/health", serverUrl).toString();
+  for (let attempt = 1;attempt <= maxAttempts; attempt++) {
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    let response = null;
+    try {
+      response = await fetch(healthUrl, { signal: controller.signal }).catch(() => null);
+    } finally {
+      clearTimeout(timeout);
+    }
+    if (response?.ok) {
+      return true;
+    }
+    if (attempt < maxAttempts) {
+      await new Promise((r) => setTimeout(r, 250));
+    }
+  }
+  return false;
+}
+
+// src/multiplexer/cmux/close-policy.ts
+class CmuxClosePolicy {
+  budgetMs;
+  maxAttempts;
+  constructor(budgetMs = 30000, maxAttempts = 4) {
+    this.budgetMs = budgetMs;
+    this.maxAttempts = maxAttempts;
+  }
+  request(reason, version, now, current) {
+    if (!current || reason === "deleted" && current.reason === "idle") {
+      return {
+        reason,
+        expectedActivityVersion: version,
+        attempts: 0,
+        deadline: now + this.budgetMs,
+        phase: "pending",
+        nextAttemptAt: now,
+        cooldowns: 0
+      };
+    }
+    return current;
+  }
+  activity(intent) {
+    return intent?.reason === "idle" ? undefined : intent;
+  }
+  failed(intent, now) {
+    const attempts = intent.attempts + 1;
+    if (attempts >= this.maxAttempts || now >= intent.deadline) {
+      const cooldowns = intent.cooldowns + 1;
+      const delay2 = cooldowns === 1 ? 30000 : cooldowns === 2 ? 60000 : Infinity;
+      return {
+        ...intent,
+        attempts,
+        phase: "cooldown",
+        nextAttemptAt: now + delay2,
+        cooldowns
+      };
+    }
+    return { ...intent, attempts, nextAttemptAt: now + 1000 };
+  }
+  resume(intent, now) {
+    if (intent.phase !== "cooldown" || now < intent.nextAttemptAt)
+      return intent;
+    return {
+      ...intent,
+      attempts: 0,
+      deadline: now + this.budgetMs,
+      phase: "pending",
+      nextAttemptAt: now
+    };
+  }
+  complete() {
+    return;
+  }
+}
+
+// src/multiplexer/cmux/session-state.ts
+var STORE_KEY = Symbol.for("oh-my-opencode-slim.cmux-session-store");
+function records() {
+  const globalStore = globalThis;
+  globalStore[STORE_KEY] ??= new Map;
+  return globalStore[STORE_KEY];
+}
+
+class CmuxSessionStore {
+  claimCreated(record) {
+    const existing = records().get(record.session);
+    if (existing) {
+      if (existing.directory !== record.directory || existing.lifecycle !== "orphaned" && existing.lifecycle !== "deleted")
+        return false;
+      existing.closeTimer?.cancel();
+      Object.assign(record, existing, {
+        owner: record.owner,
+        closeTimer: undefined
+      });
+    }
+    records().set(record.session, record);
+    return true;
+  }
+  get(session2) {
+    return records().get(session2);
+  }
+  ownedBy(owner) {
+    return [...records().values()].filter((record) => record.owner === owner);
+  }
+  claimOrphans(owner, directory) {
+    const claimed = [...records().values()].filter((record) => record.directory === directory && Boolean(record.paneId) && (record.lifecycle === "orphaned" || record.lifecycle === "deleted"));
+    for (const record of claimed) {
+      record.closeTimer?.cancel();
+      record.closeTimer = undefined;
+      record.owner = owner;
+    }
+    return claimed;
+  }
+  markAttached(session2, paneId, now) {
+    const record = records().get(session2);
+    if (!record)
+      return;
+    Object.assign(record, {
+      paneId,
+      attachedAt: now,
+      lastActivityAt: now,
+      spawnState: "attached",
+      deferredSpawn: undefined
+    });
+  }
+  markActivity(session2, now) {
+    const record = records().get(session2);
+    if (!record)
+      return;
+    record.lastActivityAt = now;
+    record.activityVersion += 1;
+    record.idleConsecutive = 0;
+    record.statusMissingSince = undefined;
+  }
+  markDeleted(session2) {
+    const record = records().get(session2);
+    if (record)
+      record.lifecycle = "deleted";
+  }
+  markOrphaned(session2) {
+    const record = records().get(session2);
+    if (record)
+      record.lifecycle = "orphaned";
+  }
+  removeAfterConfirmedClose(session2) {
+    const record = records().get(session2);
+    return record?.paneId ? records().delete(session2) : false;
+  }
+  removeWithoutPane(session2) {
+    const record = records().get(session2);
+    return record && !record.paneId ? records().delete(session2) : false;
+  }
+  resetForTests() {
+    for (const record of records().values()) {
+      record.deferredSpawn?.timer?.cancel();
+      record.closeTimer?.cancel();
+    }
+    records().clear();
+  }
+}
+
+// src/multiplexer/cmux/session-lifecycle.ts
+var ACTIVITY_EVENTS = new Set([
+  "message.updated",
+  "message.removed",
+  "message.part.updated",
+  "message.part.delta",
+  "message.part.removed"
+]);
+var MIN_LIFETIME_MS = 1e4;
+var IDLE_CONFIRMATIONS = 3;
+
+class ServerUrlUnavailableError extends Error {
+  constructor() {
+    super("OpenCode server URL is unavailable");
+    this.name = "ServerUrlUnavailableError";
+  }
+}
+
+class CmuxSessionLifecycle {
+  owner;
+  multiplexer;
+  resolveServerUrl;
+  defaultDirectory;
+  backgroundJobs;
+  store = new CmuxSessionStore;
+  policy;
+  now;
+  delay;
+  injectedDelay;
+  deferredRetryMs;
+  deferredTtlMs;
+  missingGraceMs;
+  closeRetryMs;
+  shutdownTimeoutMs;
+  serverCheck;
+  fetchStatuses;
+  pollTimer;
+  polling = false;
+  cleanupPromise;
+  disposed = false;
+  spawnGeneration = 0;
+  constructor(owner, multiplexer, resolveServerUrl, defaultDirectory, backgroundJobs, options = {}) {
+    this.owner = owner;
+    this.multiplexer = multiplexer;
+    this.resolveServerUrl = resolveServerUrl;
+    this.defaultDirectory = defaultDirectory;
+    this.backgroundJobs = backgroundJobs;
+    this.now = options.now ?? Date.now;
+    this.injectedDelay = Boolean(options.delay);
+    this.delay = options.delay ?? ((milliseconds) => new Promise((resolve4) => setTimeout(resolve4, milliseconds)));
+    this.deferredRetryMs = options.deferredRetryMs ?? 2000;
+    this.deferredTtlMs = options.deferredTtlMs ?? 300000;
+    this.missingGraceMs = options.missingGraceMs ?? 30000;
+    this.closeRetryMs = options.closeRetryMs ?? 1000;
+    this.shutdownTimeoutMs = options.shutdownTimeoutMs ?? 5000;
+    this.policy = new CmuxClosePolicy(options.closeRetryTtlMs, options.closeRetryMaxAttempts);
+    this.serverCheck = options.isServerRunning ?? isServerRunning;
+    this.fetchStatuses = options.fetchStatuses ?? (() => this.loadStatuses());
+    for (const orphan of this.store.claimOrphans(owner, defaultDirectory)) {
+      if (orphan.closeIntent?.phase === "cooldown" && Number.isFinite(orphan.closeIntent.nextAttemptAt)) {
+        this.scheduleCooldown(orphan);
+      } else {
+        orphan.closeIntent = undefined;
+        this.requestClose(orphan, "cleanup");
+      }
+    }
+  }
+  async onSessionCreated(event) {
+    if (this.disposed)
+      return;
+    if (event.type !== "session.created")
+      return;
+    const info = event.properties?.info;
+    if (!info?.id || !info.parentID)
+      return;
+    const now = this.now();
+    const record = {
+      session: info.id,
+      owner: this.owner,
+      parent: info.parentID,
+      title: info.title ?? "Subagent",
+      directory: info.directory ?? this.defaultDirectory,
+      spawnState: "known",
+      lifecycle: "active",
+      lastActivityAt: now,
+      activityVersion: 0,
+      idleConsecutive: 0
+    };
+    if (!this.store.claimCreated(record))
+      return;
+    if (record.paneId && record.lifecycle !== "active") {
+      record.closeIntent = undefined;
+      await this.requestClose(record, "cleanup");
+      return;
+    }
+    await this.spawn(record);
+  }
+  async onSessionStatus(event) {
+    if (this.disposed)
+      return;
+    const session2 = this.eventSession(event);
+    if (!session2)
+      return;
+    const owned = this.store.get(session2);
+    if (!owned || owned.owner !== this.owner)
+      return;
+    if (ACTIVITY_EVENTS.has(event.type)) {
+      this.activity(session2);
+      return;
+    }
+    const status = event.type === "session.idle" ? "idle" : event.type === "session.status" ? event.properties?.status?.type : undefined;
+    if (!status)
+      return;
+    if (status !== "idle") {
+      this.activity(session2);
+      this.backgroundJobs?.clearDeferredClose(session2);
+      const record = this.store.get(session2);
+      if (status === "busy" && record && !record.paneId)
+        await this.spawn(record);
+    }
+    if (owned.paneId)
+      this.startPolling();
+  }
+  async onSessionDeleted(event) {
+    if (event.type !== "session.deleted")
+      return;
+    const session2 = this.eventSession(event);
+    if (!session2)
+      return;
+    const record = this.store.get(session2);
+    if (!record)
+      return;
+    if (record.owner !== this.owner)
+      return;
+    this.store.markDeleted(session2);
+    this.cancelDeferred(record);
+    this.backgroundJobs?.clearDeferredClose(session2);
+    if (!record.paneId) {
+      if (!record.spawnPromise)
+        this.store.removeWithoutPane(session2);
+      return;
+    }
+    await this.requestClose(record, "deleted");
+  }
+  async closeSessionFromCoordinator(session2) {
+    if (this.disposed)
+      return;
+    const record = this.store.get(session2);
+    if (record?.paneId && record.owner === this.owner)
+      this.startPolling();
+  }
+  cleanup() {
+    this.cleanupPromise ??= this.runCleanup();
+    return this.cleanupPromise;
+  }
+  pollOnce() {
+    return this.poll();
+  }
+  async spawn(record, deferred = false) {
+    if (this.disposed || record.owner !== this.owner)
+      return;
+    if (record.spawnState === "spawning" || record.paneId)
+      return;
+    const generation = this.spawnGeneration;
+    const token = record.deferredSpawn?.generation;
+    record.spawnState = "spawning";
+    const operation = this.spawnOperation(record);
+    record.spawnPromise = operation;
+    const result = await operation;
+    if (record.spawnPromise === operation)
+      record.spawnPromise = undefined;
+    const current = this.store.get(record.session);
+    if (this.disposed || generation !== this.spawnGeneration) {
+      const latePane = result.paneId ?? result.orphanPaneId;
+      if (latePane)
+        await this.closeLatePane(record, latePane);
+      else if (current && !current.paneId)
+        this.store.removeWithoutPane(record.session);
+      return;
+    }
+    if (!current) {
+      if (result.success && result.paneId)
+        await this.adoptAndClose(record, result.paneId);
+      if (result.orphanPaneId)
+        await this.adoptAndClose(record, result.orphanPaneId);
+      return;
+    }
+    if (deferred && token !== undefined && current.deferredSpawn?.generation !== token) {
+      const stalePane = result.paneId ?? result.orphanPaneId;
+      if (stalePane)
+        await this.adoptAndClose(current, stalePane);
+      return;
+    }
+    const paneId = result.paneId ?? result.orphanPaneId;
+    if (paneId) {
+      this.store.markAttached(record.session, paneId, this.now());
+      if (result.orphanPaneId)
+        this.store.markOrphaned(record.session);
+      if (current.lifecycle !== "active" || result.orphanPaneId) {
+        await this.requestClose(current, current.lifecycle === "active" ? "cleanup" : "deleted");
+      } else
+        this.startPolling();
+      return;
+    }
+    current.spawnState = "failed";
+    if (current.lifecycle !== "active") {
+      this.store.removeWithoutPane(current.session);
+    } else if (result.error === "unavailable" || result.error === "not_found" || result.error === "invalid_state") {
+      this.deferSpawn(current);
+    }
+  }
+  async spawnOperation(record) {
+    const serverUrl = this.resolveServerUrl();
+    if (!serverUrl) {
+      log("[cmux-session-lifecycle] no valid server URL; skipping spawn");
+      return { success: false, error: "unavailable" };
+    }
+    if (!await this.serverCheck(serverUrl)) {
+      return { success: false, error: "unavailable" };
+    }
+    try {
+      return await this.multiplexer.spawnPane(record.session, record.title, serverUrl, record.directory);
+    } catch {
+      return { success: false, error: "hard" };
+    }
+  }
+  deferSpawn(record) {
+    if (this.disposed || record.owner !== this.owner)
+      return;
+    const existing = record.deferredSpawn;
+    const deferred = existing ?? {
+      deadline: this.now() + this.deferredTtlMs,
+      generation: 0
+    };
+    deferred.generation += 1;
+    deferred.timer?.cancel();
+    record.deferredSpawn = deferred;
+    if (this.now() >= deferred.deadline) {
+      this.cancelDeferred(record);
+      return;
+    }
+    deferred.timer = this.timer(async () => {
+      deferred.timer = undefined;
+      if (this.disposed || this.store.get(record.session) !== record || record.lifecycle !== "active" || record.owner !== this.owner)
+        return;
+      await this.spawn(record, true);
+    }, this.deferredRetryMs);
+  }
+  cancelDeferred(record) {
+    record.deferredSpawn?.timer?.cancel();
+    record.deferredSpawn = undefined;
+  }
+  activity(session2) {
+    const record = this.store.get(session2);
+    if (!record || record.owner !== this.owner || this.disposed)
+      return;
+    this.store.markActivity(session2, this.now());
+    const next = this.policy.activity(record.closeIntent);
+    if (!next && record.closeIntent)
+      record.closeTimer?.cancel();
+    record.closeIntent = next;
+    if (!next)
+      record.closeTimer = undefined;
+  }
+  async requestClose(record, reason) {
+    if (!record.paneId || record.owner !== this.owner)
+      return;
+    if (reason === "idle" && !(this.backgroundJobs?.deferIfRunning(record.session) ?? true))
+      return;
+    const previous = record.closeIntent;
+    record.closeIntent = this.policy.request(reason, record.activityVersion, this.now(), previous);
+    if (previous !== record.closeIntent)
+      record.closeTimer?.cancel();
+    await this.attemptClose(record);
+  }
+  async attemptClose(record) {
+    const intent = record.closeIntent;
+    if (!intent || !record.paneId || record.owner !== this.owner || this.store.get(record.session) !== record)
+      return;
+    if (intent.phase === "cooldown" && this.now() < intent.nextAttemptAt) {
+      this.scheduleCooldown(record);
+      return;
+    }
+    record.closeIntent = this.policy.resume(intent, this.now());
+    if (record.closeIntent !== intent)
+      return this.attemptClose(record);
+    if (intent.reason === "idle" && intent.expectedActivityVersion !== record.activityVersion) {
+      record.closeIntent = this.policy.activity(intent);
+      return;
+    }
+    let closed = false;
     try {
-      const proc = crossSpawn([zellij, "action", "list-panes"], {
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      const exitCode = await proc.exited;
-      if (exitCode !== 0)
-        return [];
-      const stdout = await proc.stdout();
-      return stdout.split(`
-`).slice(1).map((line) => line.trim().split(/\s+/)[0]).filter((id) => id?.startsWith("terminal_"));
-    } catch {
-      return [];
+      closed = await this.multiplexer.closePane(record.paneId);
+    } catch {}
+    if (this.disposed || this.store.get(record.session) !== record || record.owner !== this.owner || record.closeIntent !== intent)
+      return;
+    const intentStillCurrent = record.closeIntent === intent;
+    const idleStillCurrent = intent.reason !== "idle" || intent.expectedActivityVersion === record.activityVersion;
+    if (closed) {
+      record.closeTimer?.cancel();
+      record.closeTimer = undefined;
+      if (record.lifecycle !== "active") {
+        this.store.removeAfterConfirmedClose(record.session);
+      } else {
+        record.paneId = undefined;
+        record.spawnState = "known";
+        if (intentStillCurrent)
+          record.closeIntent = this.policy.complete();
+        if (intent.reason === "idle" && record.owner === this.owner && !this.disposed && record.activityVersion !== intent.expectedActivityVersion) {
+          await this.spawn(record);
+        }
+      }
+      this.updatePolling();
+      return;
     }
+    if (!intentStillCurrent || !idleStillCurrent)
+      return;
+    record.closeIntent = this.policy.failed(intent, this.now());
+    if (record.closeIntent.phase === "cooldown") {
+      if (!Number.isFinite(record.closeIntent.nextAttemptAt))
+        this.store.markOrphaned(record.session);
+      this.scheduleCooldown(record);
+      return;
+    }
+    record.closeTimer?.cancel();
+    record.closeTimer = this.timer(() => this.attemptClose(record), this.closeRetryMs);
   }
-  async closePane(paneId) {
-    const zellij = await this.getBinary();
-    return gracefulClosePane(zellij, paneId, {
-      ctrlC: ["action", "write", "--pane-id", paneId, "\x03"],
-      close: ["action", "close-pane", "--pane-id", paneId],
-      acceptExitCode1: true,
-      emptyPaneReturnsTrue: true
-    });
+  scheduleCooldown(record) {
+    record.closeTimer?.cancel();
+    record.closeTimer = undefined;
+    const intent = record.closeIntent;
+    if (!intent || !Number.isFinite(intent.nextAttemptAt) || this.disposed)
+      return;
+    record.closeTimer = this.timer(() => this.attemptClose(record), Math.max(0, intent.nextAttemptAt - this.now()));
   }
-  async applyLayout(_layout, _mainPaneSize) {}
-  directionArgs() {
-    return this.paneDirection ? ["--direction", this.paneDirection] : [];
+  async poll() {
+    if (this.polling || this.disposed)
+      return;
+    this.polling = true;
+    try {
+      const statuses = await this.fetchStatuses();
+      for (const record of this.store.ownedBy(this.owner)) {
+        if (!record.paneId || record.lifecycle !== "active")
+          continue;
+        const status = statuses[record.session];
+        if (!status) {
+          record.statusMissingSince ??= this.now();
+          if (this.now() - record.statusMissingSince < this.missingGraceMs) {
+            record.idleConsecutive = 0;
+            continue;
+          }
+        }
+        if (status)
+          record.statusMissingSince = undefined;
+        if (status && status.type !== "idle") {
+          this.activity(record.session);
+          continue;
+        }
+        if (this.now() - (record.attachedAt ?? this.now()) < MIN_LIFETIME_MS || this.now() - record.lastActivityAt < MIN_LIFETIME_MS) {
+          record.idleConsecutive = 0;
+          continue;
+        }
+        record.idleConsecutive += 1;
+        if (record.idleConsecutive < IDLE_CONFIRMATIONS)
+          continue;
+        const version = record.activityVersion;
+        const final = await this.fetchStatuses();
+        if ((final[record.session]?.type === "idle" || !final[record.session] && record.statusMissingSince !== undefined && this.now() - record.statusMissingSince >= this.missingGraceMs) && version === record.activityVersion)
+          await this.requestClose(record, "idle");
+        else
+          this.activity(record.session);
+      }
+    } catch {} finally {
+      this.polling = false;
+    }
   }
-  tabIdArgs(tabId) {
-    return tabId ? ["--tab-id", tabId] : [];
+  startPolling() {
+    if (this.pollTimer || this.disposed)
+      return;
+    this.pollTimer = setInterval(() => void this.poll().catch(() => {
+      return;
+    }), POLL_INTERVAL_BACKGROUND_MS);
+    this.pollTimer.unref?.();
   }
-  async getParentTabId(zellij) {
-    if (this.parentTabId)
-      return this.parentTabId;
-    if (this.parentPaneId) {
-      const tabId = await this.findTabIdForPane(zellij, this.parentPaneId);
-      if (tabId) {
-        this.parentTabId = tabId;
-        return tabId;
+  updatePolling() {
+    if (this.store.ownedBy(this.owner).some((record) => record.paneId))
+      this.startPolling();
+    else if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = undefined;
+    }
+  }
+  async runCleanup() {
+    this.disposed = true;
+    this.spawnGeneration += 1;
+    if (this.pollTimer)
+      clearInterval(this.pollTimer);
+    this.pollTimer = undefined;
+    const records2 = this.store.ownedBy(this.owner);
+    for (const record of records2)
+      this.cancelDeferred(record);
+    const pending = records2.flatMap((record) => record.spawnPromise ? [record.spawnPromise] : []);
+    if (pending.length) {
+      await Promise.race([
+        Promise.allSettled(pending),
+        this.delay(this.shutdownTimeoutMs)
+      ]);
+    }
+    for (const record of this.store.ownedBy(this.owner)) {
+      if (!record.paneId) {
+        if (!record.spawnPromise)
+          this.store.removeWithoutPane(record.session);
+        continue;
+      }
+      record.closeTimer?.cancel();
+      record.closeTimer = undefined;
+      record.closeIntent = this.policy.request("cleanup", record.activityVersion, this.now());
+      while (record.closeIntent?.phase === "pending" && this.store.get(record.session) === record && record.owner === this.owner) {
+        await this.attemptCloseWithoutTimer(record);
+        if (record.closeIntent?.phase === "pending")
+          await this.delay(this.closeRetryMs);
       }
+      if (record.closeIntent && this.store.get(record.session) === record && record.owner === this.owner)
+        this.store.markOrphaned(record.session);
     }
-    this.parentTabId = await this.getCurrentTabId(zellij);
-    return this.parentTabId;
   }
-  async findTabIdForPane(zellij, paneId) {
+  async attemptCloseWithoutTimer(record) {
+    const intent = record.closeIntent;
+    if (!intent || !record.paneId)
+      return;
+    const paneId = record.paneId;
+    let closed = false;
     try {
-      const proc = crossSpawn([zellij, "action", "list-panes", "--json", "--tab", "--all"], {
-        stdout: "pipe",
-        stderr: "pipe"
-      });
-      if (await proc.exited !== 0)
-        return null;
-      const stdout = await proc.stdout();
-      const panes = JSON.parse(stdout);
-      const normalizedPaneId = normalizePaneId(paneId);
-      const pane = panes.find((candidate) => !candidate.is_plugin && String(candidate.id) === normalizedPaneId);
-      return pane?.tab_id === undefined ? null : String(pane.tab_id);
-    } catch {
-      return null;
+      closed = await this.multiplexer.closePane(paneId);
+    } catch {}
+    if (this.store.get(record.session) !== record || record.owner !== this.owner || record.closeIntent !== intent || record.paneId !== paneId)
+      return;
+    if (closed) {
+      record.closeIntent = undefined;
+      this.store.removeAfterConfirmedClose(record.session);
+    } else
+      record.closeIntent = this.policy.failed(intent, this.now());
+  }
+  async adoptAndClose(record, paneId) {
+    if (!this.store.get(record.session))
+      this.store.claimCreated(record);
+    this.store.markAttached(record.session, paneId, this.now());
+    this.store.markOrphaned(record.session);
+    await this.requestClose(record, "cleanup");
+  }
+  async closeLatePane(source, paneId) {
+    const existing = this.store.get(source.session);
+    if (existing && existing.owner !== this.owner) {
+      let closed = false;
+      try {
+        closed = await this.multiplexer.closePane(paneId);
+      } catch {}
+      if (!closed)
+        this.trackStalePane(source, paneId);
+      return;
     }
+    const record = existing ?? source;
+    if (!existing)
+      this.store.claimCreated(record);
+    record.paneId = paneId;
+    record.spawnState = "attached";
+    record.lifecycle = "orphaned";
+    record.closeIntent = this.policy.request("cleanup", record.activityVersion, this.now());
+    while (record.closeIntent?.phase === "pending") {
+      await this.attemptCloseWithoutTimer(record);
+      if (record.closeIntent?.phase === "pending")
+        await this.delay(this.closeRetryMs);
+    }
+  }
+  trackStalePane(source, paneId) {
+    const session2 = `${source.session}\x00late\x00${paneId}`;
+    this.store.claimCreated({
+      session: session2,
+      owner: this.owner,
+      parent: source.parent,
+      title: source.title,
+      directory: source.directory,
+      paneId,
+      spawnState: "attached",
+      lifecycle: "orphaned",
+      attachedAt: this.now(),
+      lastActivityAt: source.lastActivityAt,
+      activityVersion: source.activityVersion,
+      idleConsecutive: 0
+    });
   }
-  async getBinary() {
-    await this.isAvailable();
-    return this.binaryPath;
-  }
-}
-function normalizePaneId(paneId) {
-  return paneId.replace(/^terminal_/, "");
-}
-function getPaneDirection2(layout) {
-  switch (layout) {
-    case "main-vertical":
-      return "right";
-    case "main-horizontal":
-      return "down";
-    case "even-horizontal":
-    case "even-vertical":
-    case "tiled":
-      return null;
-  }
-}
-function buildShellLaunchCommand(command) {
-  return ["sh", "-lc", quoteShellArg(command)].join(" ");
-}
-
-// src/multiplexer/factory.ts
-function getMultiplexer(config) {
-  const { type } = config;
-  if (type === "none") {
-    return null;
+  eventSession(event) {
+    return event.properties?.sessionID ?? event.properties?.info?.sessionID ?? event.properties?.part?.sessionID ?? event.properties?.info?.id;
   }
-  let multiplexer;
-  let actualType;
-  switch (type) {
-    case "tmux":
-      multiplexer = new TmuxMultiplexer(config.layout, config.main_pane_size);
-      actualType = "tmux";
-      break;
-    case "zellij":
-      multiplexer = new ZellijMultiplexer(config.layout, config.main_pane_size, config.zellij_pane_mode);
-      actualType = "zellij";
-      break;
-    case "herdr":
-      multiplexer = new HerdrMultiplexer(config.layout, config.main_pane_size);
-      actualType = "herdr";
-      break;
-    case "auto": {
-      if (process.env.TMUX) {
-        multiplexer = new TmuxMultiplexer(config.layout, config.main_pane_size);
-        actualType = "tmux";
-      } else if (process.env.ZELLIJ) {
-        multiplexer = new ZellijMultiplexer(config.layout, config.main_pane_size, config.zellij_pane_mode);
-        actualType = "zellij";
-      } else if (process.env.HERDR_ENV || process.env.HERDR_PANE_ID) {
-        multiplexer = new HerdrMultiplexer(config.layout, config.main_pane_size);
-        actualType = "herdr";
-      } else {
-        log("[multiplexer] auto: not inside any session, disabling");
-        return null;
-      }
-      break;
+  timer(callback, milliseconds) {
+    let cancelled = false;
+    if (this.injectedDelay) {
+      this.delay(milliseconds).then(() => {
+        if (!cancelled)
+          callback();
+      });
+      return { cancel: () => cancelled = true };
     }
-    default:
-      log(`[multiplexer] Unknown type: ${type}`);
-      return null;
+    const timer = setTimeout(() => void callback(), milliseconds);
+    timer.unref?.();
+    return { cancel: () => clearTimeout(timer) };
   }
-  log(`[multiplexer] Created ${actualType} instance`);
-  return multiplexer;
-}
-function startAvailabilityCheck(config) {
-  const multiplexer = getMultiplexer(config);
-  if (multiplexer) {
-    multiplexer.isAvailable().catch(() => {});
+  async loadStatuses() {
+    const serverUrl = this.resolveServerUrl();
+    if (!serverUrl) {
+      log("[cmux-session-lifecycle] no valid server URL; skipping poll");
+      throw new ServerUrlUnavailableError;
+    }
+    const response = await fetch(new URL("/session/status", serverUrl), {
+      signal: AbortSignal.timeout(2000)
+    });
+    if (!response.ok)
+      throw new Error(`session status failed: ${response.status}`);
+    return await response.json();
   }
 }
+
 // src/multiplexer/session-manager.ts
 var SHARED_STATE_KEY = Symbol.for("oh-my-opencode-slim.multiplexer-session-manager.state");
 function getSharedState() {
@@ -32941,10 +34393,53 @@ function getSharedState() {
   };
   return globalWithState[SHARED_STATE_KEY];
 }
+function validServerUrl(value) {
+  if (typeof value !== "string" && !(value instanceof URL))
+    return null;
+  try {
+    const url = new URL(value.toString());
+    return url.protocol === "http:" || url.protocol === "https:" ? url.toString() : null;
+  } catch {
+    return null;
+  }
+}
+function clientBaseUrl(client) {
+  try {
+    if (!client || typeof client !== "object" || !("_client" in client))
+      return null;
+    const internal = client._client;
+    if (!internal || typeof internal !== "object" || !("getConfig" in internal))
+      return null;
+    const getConfig = internal.getConfig;
+    if (typeof getConfig !== "function")
+      return null;
+    const config = getConfig.call(internal);
+    if (!config || typeof config !== "object" || !("baseUrl" in config))
+      return null;
+    return validServerUrl(config.baseUrl);
+  } catch {
+    return null;
+  }
+}
+function createServerUrlResolver(ctx) {
+  return () => {
+    try {
+      const serverUrl = validServerUrl(ctx.serverUrl);
+      if (serverUrl)
+        return serverUrl;
+    } catch {}
+    try {
+      return clientBaseUrl(ctx.client);
+    } catch {
+      return null;
+    }
+  };
+}
+
 class MultiplexerSessionManager {
   backgroundJobBoard;
   instanceId = Math.random().toString(36).slice(2, 8);
-  serverUrl;
+  resolveServerUrl;
   directory;
   multiplexer = null;
   sessions;
@@ -32953,7 +34448,8 @@ class MultiplexerSessionManager {
   closingSessions;
   pollInterval;
   enabled = false;
-  constructor(ctx, config, backgroundJobBoard) {
+  cmuxLifecycle;
+  constructor(ctx, config, backgroundJobBoard, options = {}) {
     this.backgroundJobBoard = backgroundJobBoard;
     const sharedState = getSharedState();
     this.sessions = sharedState.sessions;
@@ -32961,20 +34457,24 @@ class MultiplexerSessionManager {
     this.spawningSessions = sharedState.spawningSessions;
     this.closingSessions = sharedState.closingSessions;
     this.directory = ctx.directory;
-    const defaultPort = process.env.OPENCODE_PORT ?? "4096";
-    this.serverUrl = ctx.serverUrl?.toString() ?? `http://localhost:${defaultPort}`;
+    this.resolveServerUrl = createServerUrlResolver(ctx);
     this.multiplexer = getMultiplexer(config);
     this.enabled = config.type !== "none" && this.multiplexer !== null && this.multiplexer.isInsideSession();
+    if (this.enabled && this.multiplexer?.type === "cmux") {
+      this.cmuxLifecycle = new CmuxSessionLifecycle(this.instanceId, this.multiplexer, this.resolveServerUrl, this.directory, this.backgroundJobBoard, options);
+    }
     log("[multiplexer-session-manager] initialized", {
       instanceId: this.instanceId,
       enabled: this.enabled,
       type: config.type,
-      serverUrl: this.serverUrl,
+      serverUrl: "dynamic",
       trackedSessions: this.sessions.size,
       knownSessions: this.knownSessions.size
     });
   }
   async onSessionCreated(event) {
+    if (this.cmuxLifecycle)
+      return this.cmuxLifecycle.onSessionCreated(event);
     if (!this.enabled || !this.multiplexer)
       return;
     if (event.type !== "session.created")
@@ -33006,11 +34506,19 @@ class MultiplexerSessionManager {
     });
     this.spawningSessions.add(sessionId);
     try {
-      const serverRunning = await isServerRunning(this.serverUrl);
+      const serverUrl = this.resolveServerUrl();
+      if (!serverUrl) {
+        log("[multiplexer-session-manager] no valid server URL, skipping spawn", {
+          instanceId: this.instanceId,
+          sessionId
+        });
+        return;
+      }
+      const serverRunning = await isServerRunning(serverUrl);
       if (!serverRunning) {
         log("[multiplexer-session-manager] server not running, skipping", {
           instanceId: this.instanceId,
-          serverUrl: this.serverUrl
+          serverUrl
         });
         return;
       }
@@ -33023,7 +34531,7 @@ class MultiplexerSessionManager {
         title,
         instanceId: this.instanceId
       });
-      const paneResult = await this.multiplexer.spawnPane(sessionId, title, this.serverUrl, directory).catch((err) => {
+      const paneResult = await this.multiplexer.spawnPane(sessionId, title, serverUrl, directory).catch((err) => {
         log("[multiplexer-session-manager] failed to spawn pane", {
           instanceId: this.instanceId,
           error: String(err)
@@ -33060,6 +34568,8 @@ class MultiplexerSessionManager {
     }
   }
   async onSessionStatus(event) {
+    if (this.cmuxLifecycle)
+      return this.cmuxLifecycle.onSessionStatus(event);
     if (!this.enabled)
       return;
     if (event.type === "session.idle") {
@@ -33112,6 +34622,8 @@ class MultiplexerSessionManager {
     }
   }
   async onSessionDeleted(event) {
+    if (this.cmuxLifecycle)
+      return this.cmuxLifecycle.onSessionDeleted(event);
     if (!this.enabled)
       return;
     if (event.type !== "session.deleted")
@@ -33147,6 +34659,8 @@ class MultiplexerSessionManager {
     }
   }
   async pollSessions() {
+    if (this.cmuxLifecycle)
+      return this.cmuxLifecycle.pollOnce();
     if (this.sessions.size === 0) {
       this.stopPolling();
       return;
@@ -33181,7 +34695,14 @@ class MultiplexerSessionManager {
     }
   }
   async fetchSessionStatuses() {
-    const url = new URL("/session/status", this.serverUrl);
+    const serverUrl = this.resolveServerUrl();
+    if (!serverUrl) {
+      log("[multiplexer-session-manager] no valid server URL, skipping poll", {
+        instanceId: this.instanceId
+      });
+      return {};
+    }
+    const url = new URL("/session/status", serverUrl);
     const response = await fetch(url, { signal: AbortSignal.timeout(2000) });
     if (!response.ok) {
       throw new Error(`session status request failed: ${response.status} ${response.statusText}`);
@@ -33283,11 +34804,19 @@ class MultiplexerSessionManager {
       return;
     this.spawningSessions.add(sessionId);
     try {
-      const serverRunning = await isServerRunning(this.serverUrl);
+      const serverUrl = this.resolveServerUrl();
+      if (!serverUrl) {
+        log("[multiplexer-session-manager] no valid server URL, skipping respawn", {
+          instanceId: this.instanceId,
+          sessionId
+        });
+        return;
+      }
+      const serverRunning = await isServerRunning(serverUrl);
       if (!serverRunning) {
         log("[multiplexer-session-manager] server not running, skipping busy respawn", {
           instanceId: this.instanceId,
-          serverUrl: this.serverUrl,
+          serverUrl,
           sessionId
         });
         return;
@@ -33301,7 +34830,7 @@ class MultiplexerSessionManager {
         parentId: known.parentId,
         title: known.title
       });
-      const paneResult = await this.multiplexer.spawnPane(sessionId, known.title, this.serverUrl, known.directory).catch((err) => {
+      const paneResult = await this.multiplexer.spawnPane(sessionId, known.title, serverUrl, known.directory).catch((err) => {
         log("[multiplexer-session-manager] failed to respawn pane", {
           instanceId: this.instanceId,
           error: String(err)
@@ -33358,11 +34887,15 @@ class MultiplexerSessionManager {
     return this.backgroundJobBoard?.deferIfRunning(sessionId) ?? true;
   }
   async closeSessionFromCoordinator(sessionId) {
+    if (this.cmuxLifecycle)
+      return this.cmuxLifecycle.closeSessionFromCoordinator(sessionId);
     if (!this.enabled)
       return;
     await this.closeSession(sessionId, "idle", true);
   }
   async cleanup() {
+    if (this.cmuxLifecycle)
+      return this.cmuxLifecycle.cleanup();
     this.stopPolling();
     if (this.closingSessions.size > 0) {
       await Promise.all(this.closingSessions.values());
@@ -33384,27 +34917,10 @@ class MultiplexerSessionManager {
     this.closingSessions.clear();
     log("[multiplexer-session-manager] cleanup complete");
   }
-}
-// src/multiplexer/types.ts
-async function isServerRunning(serverUrl, timeoutMs = 3000, maxAttempts = 2) {
-  const healthUrl = new URL("/health", serverUrl).toString();
-  for (let attempt = 1;attempt <= maxAttempts; attempt++) {
-    const controller = new AbortController;
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    let response = null;
-    try {
-      response = await fetch(healthUrl, { signal: controller.signal }).catch(() => null);
-    } finally {
-      clearTimeout(timeout);
-    }
-    if (response?.ok) {
-      return true;
-    }
-    if (attempt < maxAttempts) {
-      await new Promise((r) => setTimeout(r, 250));
-    }
+  async cleanupOnInstanceDisposed() {
+    if (this.cmuxLifecycle)
+      await this.cmuxLifecycle.cleanup();
   }
-  return false;
 }
 // src/tools/acp-run.ts
 import { spawn as spawn3 } from "node:child_process";
@@ -33605,7 +35121,7 @@ class AcpClient {
       return;
     this.lastUpdate = Date.now();
     const update = message.params?.update;
-    if (!isRecord2(update))
+    if (!isRecord3(update))
       return;
     collectText(update, this.chunks);
   }
@@ -33685,16 +35201,16 @@ function createAcpRunTool(agents = {}) {
   });
 }
 function readSessionId(value) {
-  if (!isRecord2(value) || typeof value.sessionId !== "string") {
+  if (!isRecord3(value) || typeof value.sessionId !== "string") {
     throw new Error("ACP agent did not return a sessionId");
   }
   return value.sessionId;
 }
 function readAuthMethods(value) {
-  if (!isRecord2(value) || !Array.isArray(value.authMethods))
+  if (!isRecord3(value) || !Array.isArray(value.authMethods))
     return [];
   const methods = value.authMethods;
-  return methods.filter(isRecord2);
+  return methods.filter(isRecord3);
 }
 function rpcError(error) {
   const err = new Error(error.message ?? "ACP request failed");
@@ -33708,11 +35224,11 @@ function isAuthError(error) {
   const meta = error;
   return meta.code === -32001 || error.message.toLowerCase().includes("auth_required") || error.message.toLowerCase().includes("auth required");
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function readPermissionTitle(params) {
-  const tool2 = isRecord2(params?.toolCall) ? params.toolCall : undefined;
+  const tool2 = isRecord3(params?.toolCall) ? params.toolCall : undefined;
   if (typeof tool2?.title === "string")
     return tool2.title;
   if (typeof params?.permission === "string")
@@ -33721,7 +35237,7 @@ function readPermissionTitle(params) {
 }
 function selectPermissionOption(params, mode) {
   const options = Array.isArray(params?.options) ? params.options : [];
-  const choices = options.filter(isRecord2).filter((item) => typeof item.optionId === "string");
+  const choices = options.filter(isRecord3).filter((item) => typeof item.optionId === "string");
   const reject = choices.find((item) => typeof item.kind === "string" && item.kind.startsWith("reject"));
   if (mode === "reject")
     return reject?.optionId;
@@ -33738,7 +35254,7 @@ function collectText(update, chunks) {
 function readText(value) {
   if (typeof value === "string")
     return value;
-  if (isRecord2(value) && typeof value.text === "string")
+  if (isRecord3(value) && typeof value.text === "string")
     return value.text;
   return;
 }
@@ -33747,15 +35263,15 @@ import { tool as tool2 } from "@opencode-ai/plugin";
 
 // src/tools/ast-grep/cli.ts
 init_compat();
-import { existsSync as existsSync11 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 
 // src/tools/ast-grep/constants.ts
-import { existsSync as existsSync10, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync11, statSync as statSync6 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { dirname as dirname10, join as join15 } from "node:path";
 
 // src/tools/ast-grep/downloader.ts
-import { chmodSync as chmodSync2, existsSync as existsSync9, mkdirSync as mkdirSync7, unlinkSync as unlinkSync5 } from "node:fs";
+import { chmodSync as chmodSync2, existsSync as existsSync10, mkdirSync as mkdirSync7, unlinkSync as unlinkSync5 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { homedir as homedir6 } from "node:os";
 import { join as join14 } from "node:path";
@@ -33795,7 +35311,7 @@ function getBinaryName() {
 }
 function getCachedBinaryPath() {
   const binaryPath = join14(getCacheDir2(), getBinaryName());
-  return existsSync9(binaryPath) ? binaryPath : null;
+  return existsSync10(binaryPath) ? binaryPath : null;
 }
 async function downloadAstGrep(version = DEFAULT_VERSION) {
   const platformKey = `${process.platform}-${process.arch}`;
@@ -33807,7 +35323,7 @@ async function downloadAstGrep(version = DEFAULT_VERSION) {
   const cacheDir = getCacheDir2();
   const binaryName = getBinaryName();
   const binaryPath = join14(cacheDir, binaryName);
-  if (existsSync9(binaryPath)) {
+  if (existsSync10(binaryPath)) {
     return binaryPath;
   }
   const { arch, os: os6 } = platformInfo;
@@ -33815,7 +35331,7 @@ async function downloadAstGrep(version = DEFAULT_VERSION) {
   const downloadUrl = `https://github.com/${REPO}/releases/download/${version}/${assetName}`;
   console.log(`[oh-my-opencode-slim] Downloading ast-grep binary...`);
   try {
-    if (!existsSync9(cacheDir)) {
+    if (!existsSync10(cacheDir)) {
       mkdirSync7(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
@@ -33826,10 +35342,10 @@ async function downloadAstGrep(version = DEFAULT_VERSION) {
     const arrayBuffer = await response.arrayBuffer();
     await crossWrite(archivePath, arrayBuffer);
     await extractZip(archivePath, cacheDir);
-    if (existsSync9(archivePath)) {
+    if (existsSync10(archivePath)) {
       unlinkSync5(archivePath);
     }
-    if (process.platform !== "win32" && existsSync9(binaryPath)) {
+    if (process.platform !== "win32" && existsSync10(binaryPath)) {
       chmodSync2(binaryPath, 493);
     }
     console.log(`[oh-my-opencode-slim] ast-grep binary ready.`);
@@ -33912,7 +35428,7 @@ function findSgCliPathSync() {
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
     const cliDir = dirname10(cliPkgPath);
     const sgPath = join15(cliDir, binaryName);
-    if (existsSync10(sgPath) && isValidBinary(sgPath)) {
+    if (existsSync11(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
     }
   } catch {}
@@ -33924,7 +35440,7 @@ function findSgCliPathSync() {
       const pkgDir = dirname10(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
       const binaryPath = join15(pkgDir, astGrepName);
-      if (existsSync10(binaryPath) && isValidBinary(binaryPath)) {
+      if (existsSync11(binaryPath) && isValidBinary(binaryPath)) {
         return binaryPath;
       }
     } catch {}
@@ -33932,7 +35448,7 @@ function findSgCliPathSync() {
   if (process.platform === "darwin") {
     const homebrewPaths = ["/opt/homebrew/bin/sg", "/usr/local/bin/sg"];
     for (const path18 of homebrewPaths) {
-      if (existsSync10(path18) && isValidBinary(path18)) {
+      if (existsSync11(path18) && isValidBinary(path18)) {
         return path18;
       }
     }
@@ -33961,7 +35477,7 @@ var DEFAULT_MAX_MATCHES = 500;
 var initPromise = null;
 async function getAstGrepPath() {
   const currentPath = getSgCliPath();
-  if (currentPath !== "sg" && existsSync11(currentPath)) {
+  if (currentPath !== "sg" && existsSync12(currentPath)) {
     return currentPath;
   }
   if (initPromise) {
@@ -33969,7 +35485,7 @@ async function getAstGrepPath() {
   }
   initPromise = (async () => {
     const syncPath = findSgCliPathSync();
-    if (syncPath && existsSync11(syncPath)) {
+    if (syncPath && existsSync12(syncPath)) {
       setSgCliPath(syncPath);
       return syncPath;
     }
@@ -34008,7 +35524,7 @@ async function runSg(options) {
   const paths2 = options.paths && options.paths.length > 0 ? options.paths : ["."];
   args.push(...paths2);
   let cliPath = getSgCliPath();
-  if (!existsSync11(cliPath) && cliPath !== "sg") {
+  if (!existsSync12(cliPath) && cliPath !== "sg") {
     const downloadedPath = await getAstGrepPath();
     if (downloadedPath) {
       cliPath = downloadedPath;
@@ -34620,7 +36136,7 @@ async function getSessionStatus(client, taskID) {
   try {
     const result = await client.session.status();
     const data = result.data;
-    if (!isRecord(data)) {
+    if (!isRecord2(data)) {
       return { status: undefined, source: "invalid-data", keys: [] };
     }
     const keys = Object.keys(data).slice(0, 20);
@@ -34628,14 +36144,14 @@ async function getSessionStatus(client, taskID) {
     if (item === undefined) {
       return { status: "idle", source: "missing-from-map", keys };
     }
-    if (isRecord(item) && typeof item.type === "string") {
+    if (isRecord2(item) && typeof item.type === "string") {
       return { status: item.type, source: "task-map-entry", keys };
     }
     if (typeof data.type === "string") {
       return { status: data.type, source: "legacy-data-type", keys };
     }
     const nested = data.status;
-    if (isRecord(nested) && typeof nested.type === "string") {
+    if (isRecord2(nested) && typeof nested.type === "string") {
       return { status: nested.type, source: "legacy-data-status", keys };
     }
     return { status: undefined, source: "unknown-shape", keys };
@@ -34664,7 +36180,7 @@ async function getSessionParentID(client, taskID) {
   try {
     const response = await session2.get({ path: { id: taskID } });
     const data = response.data;
-    if (!isRecord(data))
+    if (!isRecord2(data))
       return;
     const parentID = data.parentID;
     return typeof parentID === "string" ? parentID : undefined;
@@ -34757,6 +36273,7 @@ Returns the councillor responses with a summary footer.`,
 import * as fs10 from "node:fs";
 
 // src/tui-state.ts
+import { createHash as createHash4 } from "node:crypto";
 import * as fs9 from "node:fs";
 import * as os6 from "node:os";
 import * as path18 from "node:path";
@@ -34765,8 +36282,11 @@ var STATE_FILE = "tui-state.json";
 function dataDir() {
   return process.env.XDG_DATA_HOME ?? path18.join(os6.homedir(), ".local", "share");
 }
-function getTuiStatePath() {
-  return path18.join(dataDir(), "opencode", "storage", STATE_DIR, STATE_FILE);
+function projectScope(projectDir) {
+  return createHash4("sha256").update(path18.resolve(projectDir)).digest("hex").slice(0, 12);
+}
+function getTuiStatePath(projectDir) {
+  return path18.join(dataDir(), "opencode", "storage", STATE_DIR, projectScope(projectDir), STATE_FILE);
 }
 function emptySnapshot() {
   return {
@@ -34787,42 +36307,42 @@ function parseSnapshot(value) {
     agentVariants: parsed.agentVariants ?? {}
   };
 }
-function readTuiSnapshot() {
+function readTuiSnapshot(projectDir) {
   try {
-    return parseSnapshot(fs9.readFileSync(getTuiStatePath(), "utf8"));
+    return parseSnapshot(fs9.readFileSync(getTuiStatePath(projectDir), "utf8"));
   } catch {
     return emptySnapshot();
   }
 }
-async function readTuiSnapshotAsync() {
+async function readTuiSnapshotAsync(projectDir) {
   try {
-    return parseSnapshot(await fs9.promises.readFile(getTuiStatePath(), "utf8"));
+    return parseSnapshot(await fs9.promises.readFile(getTuiStatePath(projectDir), "utf8"));
   } catch {
     return emptySnapshot();
   }
 }
-function writeTuiSnapshot(snapshot) {
+function writeTuiSnapshot(snapshot, projectDir) {
   try {
-    const filePath = getTuiStatePath();
+    const filePath = getTuiStatePath(projectDir);
     fs9.mkdirSync(path18.dirname(filePath), { recursive: true });
     fs9.writeFileSync(filePath, `${JSON.stringify(snapshot)}
 `);
   } catch {}
 }
-function updateSnapshot(mutator) {
-  const snapshot = readTuiSnapshot();
+function updateSnapshot(projectDir, mutator) {
+  const snapshot = readTuiSnapshot(projectDir);
   mutator(snapshot);
   snapshot.updatedAt = Date.now();
-  writeTuiSnapshot(snapshot);
+  writeTuiSnapshot(snapshot, projectDir);
 }
-function recordTuiAgentModels(input) {
-  updateSnapshot((snapshot) => {
+function recordTuiAgentModels(input, projectDir) {
+  updateSnapshot(projectDir, (snapshot) => {
     snapshot.agentModels = { ...input.agentModels };
     snapshot.agentVariants = { ...input.agentVariants ?? {} };
   });
 }
-function recordTuiAgentModel(input) {
-  updateSnapshot((snapshot) => {
+function recordTuiAgentModel(input, projectDir) {
+  updateSnapshot(projectDir, (snapshot) => {
     snapshot.agentModels[input.agentName] = input.model;
     if (input.variant !== undefined) {
       if (input.variant === null) {
@@ -34900,7 +36420,7 @@ function createPresetManager(ctx, config) {
 `);
       }
     } catch {}
-    const snapshot = readTuiSnapshot();
+    const snapshot = readTuiSnapshot(ctx.directory);
     const agentModels = { ...snapshot.agentModels };
     const agentVariants = { ...snapshot.agentVariants };
     for (const [agentName, agentConfig] of Object.entries(agentUpdates)) {
@@ -34913,7 +36433,7 @@ function createPresetManager(ctx, config) {
         delete agentVariants[agentName];
       }
     }
-    recordTuiAgentModels({ agentModels, agentVariants });
+    recordTuiAgentModels({ agentModels, agentVariants }, ctx.directory);
     activePreset = presetName;
     const summaryParts = [];
     for (const [name, cfg] of Object.entries(agentUpdates)) {
@@ -35878,9 +37398,6 @@ function cleanFetchedMarkdown(input) {
 function cleanFetchedText(input) {
   return trimBlankRuns(input);
 }
-function escapeHtml2(input) {
-  return input.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
-}
 function withTruncationMarker(content, format, truncated) {
   if (!truncated)
     return content;
@@ -35919,7 +37436,7 @@ ${content}`;
 }
 function renderMessageForFormat(content, format) {
   if (format === "html")
-    return `<pre>${escapeHtml2(content)}</pre>`;
+    return `<pre>${escapeHtml(content)}</pre>`;
   return content;
 }
 function buildRedirectResultMessage(originalUrl, redirectUrl, statusCode) {
@@ -36016,22 +37533,9 @@ async function extractFromHtml(html, finalUrl, extractMain) {
     headings
   };
 }
-function parseFrontmatterBlock(content) {
-  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
-  if (!match)
-    return;
-  const result = {};
-  for (const line of match[1].split(/\r?\n/)) {
-    const kv = line.match(/^([A-Za-z0-9_-]+):\s*(.+?)\s*$/);
-    if (!kv)
-      continue;
-    result[kv[1]] = kv[2].replace(/^(['"])(.*)\1$/, "$2");
-  }
-  return result;
-}
 function inferCanonicalUrlFromText(content, finalUrl) {
-  const frontmatter2 = parseFrontmatterBlock(content);
-  const raw = frontmatter2?.url;
+  const frontmatterData = parseFrontmatter(content);
+  const raw = frontmatterData?.url;
   if (!raw)
     return;
   try {
@@ -36598,7 +38102,7 @@ function isInvalidLlmsResult(fetchResult) {
 }
 
 // src/tools/smartfetch/secondary-model.ts
-import { existsSync as existsSync12 } from "node:fs";
+import { existsSync as existsSync13 } from "node:fs";
 import { readFile as readFile4 } from "node:fs/promises";
 import path21 from "node:path";
 function parseModelRef(value) {
@@ -36627,7 +38131,7 @@ function pickAgentModelRef(value) {
 function findPreferredOpenCodeConfigPath(baseDir) {
   for (const file of ["opencode.jsonc", "opencode.json"]) {
     const fullPath = path21.join(baseDir, file);
-    if (existsSync12(fullPath))
+    if (existsSync13(fullPath))
       return fullPath;
   }
   return;
@@ -36743,7 +38247,7 @@ async function deleteSessionSafely(client, sessionId, directory) {
         console.warn(`[smartfetch] Failed to clean up secondary session ${sessionId} ` + `after ${SESSION_DELETE_RETRIES} attempts: ` + (error instanceof Error ? error.message : String(error)));
         return;
       }
-      await new Promise((resolve4) => setTimeout(resolve4, _testConfig.deleteRetryDelayMs));
+      await new Promise((resolve5) => setTimeout(resolve5, _testConfig.deleteRetryDelayMs));
     }
   }
 }
@@ -37297,7 +38801,7 @@ function createWebfetchTool(pluginCtx, options = {}) {
           secondary_model: `${secondaryRun.model.providerID}/${secondaryRun.model.modelID}`
         }) : "";
         const secondaryRaw = secondaryRun.text || "No response from secondary model.";
-        const secondaryContent = args.format === "html" ? withTruncationMarker(`<pre>${escapeHtml2(secondaryRaw)}</pre>`, "html", false) : withTruncationMarker(secondaryRaw, args.format, false);
+        const secondaryContent = args.format === "html" ? withTruncationMarker(`<pre>${escapeHtml(secondaryRaw)}</pre>`, "html", false) : withTruncationMarker(secondaryRaw, args.format, false);
         return joinRenderedContent(metadataWithSecondary, secondaryContent, args.format);
       } finally {
         clearTimeout(timeout);
@@ -37416,6 +38920,7 @@ var OhMyOpenCodeLite = async (ctx) => {
   let agents;
   let mcps;
   let modelArrayMap;
+  let everModelSwitched;
   let runtimeChains;
   let multiplexerConfig;
   let multiplexerEnabled;
@@ -37423,6 +38928,7 @@ var OhMyOpenCodeLite = async (ctx) => {
   let multiplexerSessionManager;
   let autoUpdateChecker;
   let sessionAgentMap;
+  const sessionDirectories = new Map;
   let sessionLifecycle;
   let chatHeadersHook;
   let foregroundFallback;
@@ -37466,6 +38972,7 @@ var OhMyOpenCodeLite = async (ctx) => {
     agentDefs = createAgents(config, { projectDirectory: ctx.directory });
     agents = getAgentConfigs(config, { projectDirectory: ctx.directory });
     modelArrayMap = {};
+    everModelSwitched = new Set;
     runtimeChains = {};
     for (const agentDef of agentDefs) {
       if (agentDef._modelArray?.length) {
@@ -37495,9 +39002,9 @@ var OhMyOpenCodeLite = async (ctx) => {
     acpRunTools = Object.keys(config.acpAgents ?? {}).length > 0 ? { acp_run: createAcpRunTool(config.acpAgents) } : {};
     webfetch = createWebfetchTool(ctx);
     backgroundJobBoard = new BackgroundJobBoard({
-      maxReusablePerAgent: config.backgroundJobs?.maxSessionsPerAgent ?? 2,
-      readContextMinLines: config.backgroundJobs?.readContextMinLines ?? 10,
-      readContextMaxFiles: config.backgroundJobs?.readContextMaxFiles ?? 8
+      maxReusablePerAgent: config.backgroundJobs?.maxSessionsPerAgent ?? DEFAULT_MAX_SESSIONS_PER_AGENT,
+      readContextMinLines: config.backgroundJobs?.readContextMinLines ?? DEFAULT_READ_CONTEXT_MIN_LINES,
+      readContextMaxFiles: config.backgroundJobs?.readContextMaxFiles ?? DEFAULT_READ_CONTEXT_MAX_FILES
     });
     const backgroundJobCoordinator = new BackgroundJobCoordinator(backgroundJobBoard);
     multiplexerSessionManager = new MultiplexerSessionManager(ctx, multiplexerConfig, backgroundJobCoordinator);
@@ -37511,14 +39018,14 @@ var OhMyOpenCodeLite = async (ctx) => {
     });
     sessionAgentMap = new Map;
     chatHeadersHook = createChatHeadersHook(ctx);
-    foregroundFallback = new ForegroundFallbackManager(ctx.client, runtimeChains, config.fallback?.enabled !== false, config.fallback?.maxRetries ?? 3, sessionLifecycle, config.fallback?.runtimeOverride ?? true);
+    foregroundFallback = new ForegroundFallbackManager(ctx.client, runtimeChains, config.fallback?.enabled !== false, config.fallback?.maxRetries ?? 3, sessionLifecycle);
     deepworkCommandHook = createDeepworkCommandHook();
     reflectCommandHook = createReflectCommandHook();
     loopCommandHook = createLoopCommandHook();
     taskSessionManagerHook = createTaskSessionManagerHook(ctx, {
-      maxSessionsPerAgent: config.backgroundJobs?.maxSessionsPerAgent ?? 2,
-      readContextMinLines: config.backgroundJobs?.readContextMinLines ?? 10,
-      readContextMaxFiles: config.backgroundJobs?.readContextMaxFiles ?? 8,
+      maxSessionsPerAgent: config.backgroundJobs?.maxSessionsPerAgent ?? DEFAULT_MAX_SESSIONS_PER_AGENT,
+      readContextMinLines: config.backgroundJobs?.readContextMinLines ?? DEFAULT_READ_CONTEXT_MIN_LINES,
+      readContextMaxFiles: config.backgroundJobs?.readContextMaxFiles ?? DEFAULT_READ_CONTEXT_MAX_FILES,
       backgroundJobBoard: backgroundJobCoordinator,
       shouldManageSession: (sessionID) => sessionAgentMap.get(sessionID) === "orchestrator",
       registerSessionAsOrchestrator: (sessionID) => {
@@ -37658,6 +39165,15 @@ var OhMyOpenCodeLite = async (ctx) => {
       } else {
         for (const [name, pluginAgent] of Object.entries(agents)) {
           const existing = opencodeConfig.agent[name];
+          if (existing && typeof existing.model === "string") {
+            const primary = modelArrayMap[name]?.[0]?.id;
+            if (primary && existing.model !== primary) {
+              everModelSwitched.add(name);
+            }
+            if (everModelSwitched.has(name)) {
+              foregroundFallback.disableChain(name);
+            }
+          }
           if (existing) {
             opencodeConfig.agent[name] = {
               ...pluginAgent,
@@ -37790,6 +39306,13 @@ var OhMyOpenCodeLite = async (ctx) => {
       recordTuiAgentModels({
         agentModels: tuiAgentModels,
         agentVariants: tuiAgentVariants
+      }, ctx.directory);
+      applyOrchestratorModelConfig({
+        agents: configAgent,
+        enabled: config.stripOrchestratorModel,
+        presets: config.presets,
+        configPreset: config.preset,
+        runtimePreset: runtimePresetName
       });
       const configMcp = opencodeConfig.mcp;
       if (!configMcp) {
@@ -37839,7 +39362,7 @@ var OhMyOpenCodeLite = async (ctx) => {
             agentName,
             model,
             variant: variant ?? null
-          });
+          }, (info?.sessionID && sessionDirectories.get(info.sessionID)) ?? ctx.directory);
         }
       }
       if (event.type === "session.created") {
@@ -37848,10 +39371,18 @@ var OhMyOpenCodeLite = async (ctx) => {
         if (depthTracker && childSessionId && parentSessionId) {
           depthTracker.registerChild(parentSessionId, childSessionId);
         }
+        const createdSessionId = event.properties?.info?.id;
+        const createdSessionDir = event.properties?.info?.directory;
+        if (createdSessionId && createdSessionDir) {
+          sessionDirectories.set(createdSessionId, createdSessionDir);
+        }
       }
       await multiplexerSessionManager.onSessionCreated(event);
       await multiplexerSessionManager.onSessionStatus(event);
       await multiplexerSessionManager.onSessionDeleted(event);
+      if (event.type === "server.instance.disposed") {
+        await multiplexerSessionManager.cleanupOnInstanceDisposed();
+      }
       await foregroundFallback.handleEvent(input.event);
       await autoUpdateChecker.event(input);
       await interviewManager.handleEvent(input);
@@ -37883,6 +39414,7 @@ var OhMyOpenCodeLite = async (ctx) => {
         }
         if (sessionID) {
           sessionAgentMap.delete(sessionID);
+          sessionDirectories.delete(sessionID);
         }
       }
     },
@@ -37905,6 +39437,7 @@ var OhMyOpenCodeLite = async (ctx) => {
         output.message.agent = agent;
       }
       if (agent) {
+        foregroundFallback.registerSessionAgent(input.sessionID, agent);
         sessionAgentMap.set(input.sessionID, agent);
         companionManager.onSessionStatus({
           sessionId: input.sessionID,
@@ -37931,6 +39464,9 @@ ${output.system[0]}` : "");
     "experimental.chat.messages.transform": async (input, output) => {
       const typedOutput = output;
       for (const message of typedOutput.messages) {
+        if (!isMessageWithParts(message)) {
+          continue;
+        }
         if (message.info.role !== "user") {
           continue;
         }
@@ -37944,6 +39480,7 @@ ${output.system[0]}` : "");
       processImageAttachments({
         messages: typedOutput.messages,
         workDir: ctx.directory,
+        imageRouting: resolveImageRouting(config.image_routing),
         disabledAgents,
         log
       });