oh-my-opencode-slim 0.9.0 → 0.9.2

package/dist/index.js

@@ -17233,7 +17233,8 @@ var CouncilConfigSchema = exports_external.object({
     }
     return val;
   }).describe("Fallback models for the council master. Tried in order if the primary model fails. " + 'Example: ["anthropic/claude-sonnet-4-6", "openai/gpt-5.4"]'),
-  councillor_execution_mode: CouncillorExecutionModeSchema.describe('Execution mode for councillors. "serial" runs them one at a time (required for single-model systems). "parallel" runs them concurrently (default, faster for multi-model systems).')
+  councillor_execution_mode: CouncillorExecutionModeSchema.describe('Execution mode for councillors. "serial" runs them one at a time (required for single-model systems). "parallel" runs them concurrently (default, faster for multi-model systems).'),
+  councillor_retries: exports_external.number().int().min(0).max(5).default(3).describe("Number of retry attempts for councillors and master that return empty responses " + "(e.g. due to provider rate limiting). Default: 3 retries.")
 });
 // src/config/loader.ts
 import * as fs from "fs";
@@ -17241,7 +17242,7 @@ import * as path from "path";
 
 // src/config/agent-mcps.ts
 var DEFAULT_AGENT_MCPS = {
-  orchestrator: ["websearch"],
+  orchestrator: ["*"],
   designer: [],
   oracle: [],
   librarian: ["websearch", "context7", "grep_app"],
@@ -17263,7 +17264,7 @@ function parseList(items, allAvailable) {
   if (allow.includes("*")) {
     return allAvailable.filter((item) => !deny.includes(item));
   }
-  return allow.filter((item) => !deny.includes(item));
+  return allow.filter((item) => !deny.includes(item) && allAvailable.includes(item));
 }
 function getAgentMcpList(agentName, config2) {
   const agentConfig = getAgentOverride(config2, agentName);
@@ -17335,19 +17336,29 @@ var AgentOverrideConfigSchema = exports_external.object({
   skills: exports_external.array(exports_external.string()).optional(),
   mcps: exports_external.array(exports_external.string()).optional()
 });
-var TmuxLayoutSchema = exports_external.enum([
+var MultiplexerTypeSchema = exports_external.enum(["auto", "tmux", "zellij", "none"]);
+var MultiplexerLayoutSchema = exports_external.enum([
   "main-horizontal",
   "main-vertical",
   "tiled",
   "even-horizontal",
   "even-vertical"
 ]);
+var TmuxLayoutSchema = MultiplexerLayoutSchema;
+var MultiplexerConfigSchema = exports_external.object({
+  type: MultiplexerTypeSchema.default("none"),
+  layout: MultiplexerLayoutSchema.default("main-vertical"),
+  main_pane_size: exports_external.number().min(20).max(80).default(60)
+});
 var TmuxConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(false),
   layout: TmuxLayoutSchema.default("main-vertical"),
   main_pane_size: exports_external.number().min(20).max(80).default(60)
 });
 var PresetSchema = exports_external.record(exports_external.string(), AgentOverrideConfigSchema);
+var WebsearchConfigSchema = exports_external.object({
+  provider: exports_external.enum(["exa", "tavily"]).default("exa")
+});
 var McpNameSchema = exports_external.enum(["websearch", "context7", "grep_app"]);
 var BackgroundTaskConfigSchema = exports_external.object({
   maxConcurrentStarts: exports_external.number().min(1).max(50).default(10)
@@ -17356,7 +17367,8 @@ var FailoverConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(true),
   timeoutMs: exports_external.number().min(0).default(15000),
   retryDelayMs: exports_external.number().min(0).default(500),
-  chains: FallbackChainsSchema.default({})
+  chains: FallbackChainsSchema.default({}),
+  retry_on_empty: exports_external.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.")
 });
 var PluginConfigSchema = exports_external.object({
   preset: exports_external.string().optional(),
@@ -17367,7 +17379,9 @@ var PluginConfigSchema = exports_external.object({
   presets: exports_external.record(exports_external.string(), PresetSchema).optional(),
   agents: exports_external.record(exports_external.string(), AgentOverrideConfigSchema).optional(),
   disabled_mcps: exports_external.array(exports_external.string()).optional(),
+  multiplexer: MultiplexerConfigSchema.optional(),
   tmux: TmuxConfigSchema.optional(),
+  websearch: WebsearchConfigSchema.optional(),
   background: BackgroundTaskConfigSchema.optional(),
   fallback: FailoverConfigSchema.optional(),
   council: CouncilConfigSchema.optional()
@@ -17442,9 +17456,12 @@ function loadPluginConfig(directory) {
       ...projectConfig,
       agents: deepMerge(config2.agents, projectConfig.agents),
       tmux: deepMerge(config2.tmux, projectConfig.tmux),
-      fallback: deepMerge(config2.fallback, projectConfig.fallback)
+      multiplexer: deepMerge(config2.multiplexer, projectConfig.multiplexer),
+      fallback: deepMerge(config2.fallback, projectConfig.fallback),
+      council: deepMerge(config2.council, projectConfig.council)
     };
   }
+  config2 = migrateTmuxToMultiplexer(config2);
   const envPreset = process.env.OH_MY_OPENCODE_SLIM_PRESET;
   if (envPreset) {
     config2.preset = envPreset;
@@ -17486,6 +17503,22 @@ function loadAgentPrompt(agentName, preset) {
   result.appendPrompt = readFirstPrompt(`${agentName}_append.md`, "Error reading append prompt file");
   return result;
 }
+function migrateTmuxToMultiplexer(config2) {
+  if (config2.multiplexer?.type && config2.multiplexer.type !== "none") {
+    return config2;
+  }
+  if (config2.tmux?.enabled) {
+    return {
+      ...config2,
+      multiplexer: {
+        type: "tmux",
+        layout: config2.tmux.layout ?? "main-vertical",
+        main_pane_size: config2.tmux.main_pane_size ?? 60
+      }
+    };
+  }
+  return config2;
+}
 // src/config/utils.ts
 function getAgentOverride(config2, name) {
   const overrides = config2?.agents ?? {};
@@ -17544,9 +17577,10 @@ async function extractSessionResult(client, sessionId, options) {
       }
     }
   }
-  return extractedContent.filter((t) => t.length > 0).join(`
+  const text = extractedContent.filter((t) => t.length > 0).join(`
 
 `);
+  return { text, empty: text.length === 0 };
 }
 
 // src/agents/orchestrator.ts
@@ -18236,6 +18270,9 @@ function createAgents(config2) {
       }
       return librarianModel ?? DEFAULT_MODELS.librarian;
     }
+    if ((name === "council" || name === "council-master") && config2?.council?.master?.model) {
+      return config2.council.master.model;
+    }
     return DEFAULT_MODELS[name];
   };
   const protoSubAgents = Object.entries(SUBAGENT_FACTORIES).map(([name, factory]) => {
@@ -18286,7 +18323,10 @@ function getAgentConfigs(config2) {
 import * as fs2 from "fs";
 import * as os from "os";
 import * as path2 from "path";
-var logFile = path2.join(os.tmpdir(), "oh-my-opencode-slim.log");
+var logFile = path2.join(process.env.HOME || os.tmpdir(), ".local/share/opencode/oh-my-opencode-slim.log");
+try {
+  fs2.mkdirSync(path2.dirname(logFile), { recursive: true });
+} catch {}
 function log(message, data) {
   try {
     const timestamp = new Date().toISOString();
@@ -18296,293 +18336,608 @@ function log(message, data) {
   } catch {}
 }
 
-// src/utils/agent-variant.ts
-function normalizeAgentName(agentName) {
-  const trimmed = agentName.trim();
-  return trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
-}
-function resolveAgentVariant(config2, agentName) {
-  const normalized = normalizeAgentName(agentName);
-  const rawVariant = config2?.agents?.[normalized]?.variant;
-  if (typeof rawVariant !== "string") {
-    return;
-  }
-  const trimmed = rawVariant.trim();
-  if (trimmed.length === 0) {
-    return;
-  }
-  log(`[variant] resolved variant="${trimmed}" for agent "${normalized}"`);
-  return trimmed;
-}
-function applyAgentVariant(variant, body) {
-  if (!variant) {
-    return body;
-  }
-  if (body.variant) {
-    return body;
-  }
-  return { ...body, variant };
-}
-// src/utils/internal-initiator.ts
-var SLIM_INTERNAL_INITIATOR_MARKER = "<!-- SLIM_INTERNAL_INITIATOR -->";
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function createInternalAgentTextPart(text) {
-  return {
-    type: "text",
-    text: `${text}
-${SLIM_INTERNAL_INITIATOR_MARKER}`
-  };
-}
-function hasInternalInitiatorMarker(part) {
-  if (!isRecord(part) || part.type !== "text") {
-    return false;
-  }
-  if (typeof part.text !== "string") {
-    return false;
-  }
-  return part.text.includes(SLIM_INTERNAL_INITIATOR_MARKER);
-}
-// src/utils/tmux.ts
+// src/multiplexer/tmux/index.ts
 var {spawn } = globalThis.Bun;
-var tmuxPath = null;
-var tmuxChecked = false;
-var storedConfig = null;
-var serverAvailable = null;
-var serverCheckUrl = null;
-async function isServerRunning(serverUrl) {
-  if (serverCheckUrl === serverUrl && serverAvailable === true) {
-    return true;
-  }
-  const healthUrl = new URL("/health", serverUrl).toString();
-  const timeoutMs = 3000;
-  const maxAttempts = 2;
-  for (let attempt = 1;attempt <= maxAttempts; attempt++) {
-    const controller = new AbortController;
-    const timeout = setTimeout(() => controller.abort(), timeoutMs);
-    let response = null;
+class TmuxMultiplexer {
+  type = "tmux";
+  binaryPath = null;
+  hasChecked = false;
+  storedLayout;
+  storedMainPaneSize;
+  constructor(layout = "main-vertical", mainPaneSize = 60) {
+    this.storedLayout = layout;
+    this.storedMainPaneSize = mainPaneSize;
+  }
+  async isAvailable() {
+    if (this.hasChecked) {
+      return this.binaryPath !== null;
+    }
+    this.binaryPath = await this.findBinary();
+    this.hasChecked = true;
+    return this.binaryPath !== null;
+  }
+  isInsideSession() {
+    return !!process.env.TMUX;
+  }
+  async spawnPane(sessionId, description, serverUrl) {
+    const tmux = await this.getBinary();
+    if (!tmux) {
+      log("[tmux] spawnPane: tmux binary not found");
+      return { success: false };
+    }
     try {
-      response = await fetch(healthUrl, { signal: controller.signal }).catch(() => null);
-    } finally {
-      clearTimeout(timeout);
+      const opencodeCmd = `opencode attach ${serverUrl} --session ${sessionId}`;
+      const args = [
+        "split-window",
+        "-h",
+        "-d",
+        "-P",
+        "-F",
+        "#{pane_id}",
+        opencodeCmd
+      ];
+      log("[tmux] spawnPane: executing", { tmux, args });
+      const proc = spawn([tmux, ...args], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const exitCode = await proc.exited;
+      const stdout = await new Response(proc.stdout).text();
+      const stderr = await new Response(proc.stderr).text();
+      const paneId = stdout.trim();
+      log("[tmux] spawnPane: result", {
+        exitCode,
+        paneId,
+        stderr: stderr.trim()
+      });
+      if (exitCode === 0 && paneId) {
+        const renameProc = spawn([tmux, "select-pane", "-t", paneId, "-T", description.slice(0, 30)], { stdout: "ignore", stderr: "ignore" });
+        await renameProc.exited;
+        await this.applyLayout(this.storedLayout, this.storedMainPaneSize);
+        log("[tmux] spawnPane: SUCCESS", { paneId });
+        return { success: true, paneId };
+      }
+      return { success: false };
+    } catch (err) {
+      log("[tmux] spawnPane: exception", { error: String(err) });
+      return { success: false };
     }
-    const available = response?.ok ?? false;
-    if (available) {
-      serverCheckUrl = serverUrl;
-      serverAvailable = true;
-      log("[tmux] isServerRunning: checked", { serverUrl, available, attempt });
-      return true;
+  }
+  async closePane(paneId) {
+    if (!paneId) {
+      log("[tmux] closePane: no paneId provided");
+      return false;
     }
-    if (attempt < maxAttempts) {
+    const tmux = await this.getBinary();
+    if (!tmux) {
+      log("[tmux] closePane: tmux binary not found");
+      return false;
+    }
+    try {
+      log("[tmux] closePane: sending Ctrl+C", { paneId });
+      const ctrlCProc = spawn([tmux, "send-keys", "-t", paneId, "C-c"], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      await ctrlCProc.exited;
       await new Promise((r) => setTimeout(r, 250));
+      log("[tmux] closePane: killing pane", { paneId });
+      const proc = spawn([tmux, "kill-pane", "-t", paneId], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const exitCode = await proc.exited;
+      const stderr = await new Response(proc.stderr).text();
+      log("[tmux] closePane: result", { exitCode, stderr: stderr.trim() });
+      if (exitCode === 0) {
+        await this.applyLayout(this.storedLayout, this.storedMainPaneSize);
+        return true;
+      }
+      log("[tmux] closePane: failed (pane may already be closed)", { paneId });
+      return false;
+    } catch (err) {
+      log("[tmux] closePane: exception", { error: String(err) });
+      return false;
     }
   }
-  log("[tmux] isServerRunning: checked", { serverUrl, available: false });
-  return false;
-}
-async function findTmuxPath() {
-  const isWindows = process.platform === "win32";
-  const cmd = isWindows ? "where" : "which";
-  try {
-    const proc = spawn([cmd, "tmux"], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const exitCode = await proc.exited;
-    if (exitCode !== 0) {
-      log("[tmux] findTmuxPath: 'which tmux' failed", { exitCode });
-      return null;
-    }
-    const stdout = await new Response(proc.stdout).text();
-    const path3 = stdout.trim().split(`
-`)[0];
-    if (!path3) {
-      log("[tmux] findTmuxPath: no path in output");
-      return null;
-    }
-    const verifyProc = spawn([path3, "-V"], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const verifyExit = await verifyProc.exited;
-    if (verifyExit !== 0) {
-      log("[tmux] findTmuxPath: tmux -V failed", { path: path3, verifyExit });
-      return null;
+  async applyLayout(layout, mainPaneSize) {
+    const tmux = await this.getBinary();
+    if (!tmux)
+      return;
+    this.storedLayout = layout;
+    this.storedMainPaneSize = mainPaneSize;
+    try {
+      const layoutProc = spawn([tmux, "select-layout", layout], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      await layoutProc.exited;
+      if (layout === "main-horizontal" || layout === "main-vertical") {
+        const sizeOption = layout === "main-horizontal" ? "main-pane-height" : "main-pane-width";
+        const sizeProc = spawn([tmux, "set-window-option", sizeOption, `${mainPaneSize}%`], {
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        await sizeProc.exited;
+        const reapplyProc = spawn([tmux, "select-layout", layout], {
+          stdout: "pipe",
+          stderr: "pipe"
+        });
+        await reapplyProc.exited;
+      }
+      log("[tmux] applyLayout: applied", { layout, mainPaneSize });
+    } catch (err) {
+      log("[tmux] applyLayout: exception", { error: String(err) });
     }
-    log("[tmux] findTmuxPath: found tmux", { path: path3 });
-    return path3;
-  } catch (err) {
-    log("[tmux] findTmuxPath: exception", { error: String(err) });
-    return null;
   }
-}
-async function getTmuxPath() {
-  if (tmuxChecked) {
-    return tmuxPath;
+  async getBinary() {
+    await this.isAvailable();
+    return this.binaryPath;
   }
-  tmuxPath = await findTmuxPath();
-  tmuxChecked = true;
-  log("[tmux] getTmuxPath: initialized", { tmuxPath });
-  return tmuxPath;
-}
-function isInsideTmux() {
-  return !!process.env.TMUX;
-}
-async function applyLayout(tmux, layout, mainPaneSize) {
-  try {
-    const layoutProc = spawn([tmux, "select-layout", layout], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    await layoutProc.exited;
-    if (layout === "main-horizontal" || layout === "main-vertical") {
-      const sizeOption = layout === "main-horizontal" ? "main-pane-height" : "main-pane-width";
-      const sizeProc = spawn([tmux, "set-window-option", sizeOption, `${mainPaneSize}%`], {
+  async findBinary() {
+    const isWindows = process.platform === "win32";
+    const cmd = isWindows ? "where" : "which";
+    try {
+      const proc = spawn([cmd, "tmux"], {
         stdout: "pipe",
         stderr: "pipe"
       });
-      await sizeProc.exited;
-      const reapplyProc = spawn([tmux, "select-layout", layout], {
+      const exitCode = await proc.exited;
+      if (exitCode !== 0) {
+        log("[tmux] findBinary: 'which tmux' failed", { exitCode });
+        return null;
+      }
+      const stdout = await new Response(proc.stdout).text();
+      const path3 = stdout.trim().split(`
+`)[0];
+      if (!path3) {
+        log("[tmux] findBinary: no path in output");
+        return null;
+      }
+      const verifyProc = spawn([path3, "-V"], {
         stdout: "pipe",
         stderr: "pipe"
       });
-      await reapplyProc.exited;
+      const verifyExit = await verifyProc.exited;
+      if (verifyExit !== 0) {
+        log("[tmux] findBinary: tmux -V failed", { path: path3, verifyExit });
+        return null;
+      }
+      log("[tmux] findBinary: found", { path: path3 });
+      return path3;
+    } catch (err) {
+      log("[tmux] findBinary: exception", { error: String(err) });
+      return null;
     }
-    log("[tmux] applyLayout: applied", { layout, mainPaneSize });
-  } catch (err) {
-    log("[tmux] applyLayout: exception", { error: String(err) });
   }
 }
-async function spawnTmuxPane(sessionId, description, config2, serverUrl) {
-  log("[tmux] spawnTmuxPane called", {
-    sessionId,
-    description,
-    config: config2,
-    serverUrl
-  });
-  if (!config2.enabled) {
-    log("[tmux] spawnTmuxPane: config.enabled is false, skipping");
-    return { success: false };
+
+// src/multiplexer/zellij/index.ts
+var {spawn: spawn2 } = globalThis.Bun;
+
+class ZellijMultiplexer {
+  type = "zellij";
+  binaryPath = null;
+  hasChecked = false;
+  storedLayout;
+  storedMainPaneSize;
+  agentTabId = null;
+  firstPaneId = null;
+  firstPaneUsed = false;
+  constructor(layout = "main-vertical", mainPaneSize = 60) {
+    this.storedLayout = layout;
+    this.storedMainPaneSize = mainPaneSize;
   }
-  if (!isInsideTmux()) {
-    log("[tmux] spawnTmuxPane: not inside tmux, skipping");
-    return { success: false };
+  async isAvailable() {
+    if (this.hasChecked) {
+      return this.binaryPath !== null;
+    }
+    this.binaryPath = await this.findBinary();
+    this.hasChecked = true;
+    return this.binaryPath !== null;
   }
-  const serverRunning = await isServerRunning(serverUrl);
-  if (!serverRunning) {
-    const defaultPort = process.env.OPENCODE_PORT ?? "4096";
-    log("[tmux] spawnTmuxPane: OpenCode server not running, skipping", {
-      serverUrl,
-      hint: `Start opencode with --port ${defaultPort}`
-    });
-    return { success: false };
+  isInsideSession() {
+    return !!process.env.ZELLIJ;
   }
-  const tmux = await getTmuxPath();
-  if (!tmux) {
-    log("[tmux] spawnTmuxPane: tmux binary not found, skipping");
-    return { success: false };
+  async spawnPane(sessionId, description, serverUrl) {
+    const zellij = await this.getBinary();
+    if (!zellij)
+      return { success: false };
+    try {
+      if (!this.agentTabId) {
+        const result = await this.ensureAgentTab(zellij);
+        if (!result)
+          return { success: false };
+        this.agentTabId = result.tabId;
+        this.firstPaneId = result.firstPaneId;
+      }
+      if (!this.firstPaneUsed && this.firstPaneId) {
+        const success2 = await this.runInPane(zellij, this.firstPaneId, sessionId, serverUrl, description);
+        if (success2) {
+          this.firstPaneUsed = true;
+          return { success: true, paneId: this.firstPaneId };
+        }
+      }
+      return await this.createPaneInAgentTab(zellij, sessionId, serverUrl, description);
+    } catch {
+      return { success: false };
+    }
   }
-  storedConfig = config2;
-  try {
+  async createPaneInAgentTab(zellij, sessionId, serverUrl, description) {
     const opencodeCmd = `opencode attach ${serverUrl} --session ${sessionId}`;
+    const paneName = description.slice(0, 30).replace(/"/g, "\\\"");
+    const currentTabId = await this.getCurrentTabId(zellij);
+    const inAgentTab = currentTabId === this.agentTabId;
+    if (inAgentTab) {
+      const args2 = [
+        "action",
+        "new-pane",
+        "--name",
+        paneName,
+        "--close-on-exit",
+        "--",
+        "sh",
+        "-c",
+        opencodeCmd
+      ];
+      const proc2 = spawn2([zellij, ...args2], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const exitCode2 = await proc2.exited;
+      const stdout2 = await new Response(proc2.stdout).text();
+      const paneId2 = stdout2.trim();
+      if (exitCode2 === 0 && paneId2?.startsWith("terminal_")) {
+        return { success: true, paneId: paneId2 };
+      }
+      return { success: false };
+    }
+    if (!this.agentTabId) {
+      return { success: false };
+    }
+    const originalTab = await this.getCurrentTabId(zellij);
+    await spawn2([zellij, "action", "go-to-tab-by-id", this.agentTabId], {
+      stdout: "ignore",
+      stderr: "ignore"
+    }).exited;
     const args = [
-      "split-window",
-      "-h",
-      "-d",
-      "-P",
-      "-F",
-      "#{pane_id}",
+      "action",
+      "new-pane",
+      "--name",
+      paneName,
+      "--close-on-exit",
+      "--",
+      "sh",
+      "-c",
       opencodeCmd
     ];
-    log("[tmux] spawnTmuxPane: executing", { tmux, args, opencodeCmd });
-    const proc = spawn([tmux, ...args], {
+    const proc = spawn2([zellij, ...args], {
       stdout: "pipe",
       stderr: "pipe"
     });
     const exitCode = await proc.exited;
     const stdout = await new Response(proc.stdout).text();
-    const stderr = await new Response(proc.stderr).text();
     const paneId = stdout.trim();
-    log("[tmux] spawnTmuxPane: split result", {
-      exitCode,
-      paneId,
-      stderr: stderr.trim()
-    });
-    if (exitCode === 0 && paneId) {
-      const renameProc = spawn([tmux, "select-pane", "-t", paneId, "-T", description.slice(0, 30)], { stdout: "ignore", stderr: "ignore" });
-      await renameProc.exited;
-      const layout = config2.layout ?? "main-vertical";
-      const mainPaneSize = config2.main_pane_size ?? 60;
-      await applyLayout(tmux, layout, mainPaneSize);
-      log("[tmux] spawnTmuxPane: SUCCESS, pane created and layout applied", {
-        paneId,
-        layout
-      });
+    if (originalTab) {
+      await spawn2([zellij, "action", "go-to-tab-by-id", String(originalTab)], {
+        stdout: "ignore",
+        stderr: "ignore"
+      }).exited;
+    }
+    if (exitCode === 0 && paneId?.startsWith("terminal_")) {
       return { success: true, paneId };
     }
     return { success: false };
-  } catch (err) {
-    log("[tmux] spawnTmuxPane: exception", { error: String(err) });
-    return { success: false };
+  }
+  async runInPane(zellij, paneId, sessionId, serverUrl, description) {
+    try {
+      const opencodeCmd = `opencode attach ${serverUrl} --session ${sessionId}`;
+      await spawn2([zellij, "action", "focus-pane", "--pane-id", paneId], {
+        stdout: "ignore",
+        stderr: "ignore"
+      }).exited;
+      await spawn2([zellij, "action", "rename-pane", "--name", description.slice(0, 30)], { stdout: "ignore", stderr: "ignore" }).exited;
+      await spawn2([zellij, "action", "write-chars", opencodeCmd], {
+        stdout: "ignore",
+        stderr: "ignore"
+      }).exited;
+      await spawn2([zellij, "action", "write-chars", `
+`], {
+        stdout: "ignore",
+        stderr: "ignore"
+      }).exited;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async ensureAgentTab(zellij) {
+    try {
+      const existingTab = await this.findTabByName(zellij, "opencode-agents");
+      if (existingTab) {
+        const firstPane = await this.getFirstPaneInTab(zellij, existingTab.tabId);
+        return {
+          tabId: existingTab.tabId,
+          firstPaneId: firstPane || "terminal_0"
+        };
+      }
+      const beforePanes = await this.listPanes(zellij);
+      const createProc = spawn2([zellij, "action", "new-tab", "--name", "opencode-agents"], { stdout: "pipe", stderr: "pipe" });
+      const createExit = await createProc.exited;
+      if (createExit !== 0)
+        return null;
+      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" };
+    } catch {
+      return null;
+    }
+  }
+  async getFirstPaneInTab(zellij, tabId) {
+    const originalTab = await this.getCurrentTabId(zellij);
+    await spawn2([zellij, "action", "go-to-tab-by-id", tabId], {
+      stdout: "ignore",
+      stderr: "ignore"
+    }).exited;
+    const panes = await this.listPanes(zellij);
+    if (originalTab) {
+      await spawn2([zellij, "action", "go-to-tab-by-id", String(originalTab)], {
+        stdout: "ignore",
+        stderr: "ignore"
+      }).exited;
+    }
+    return panes[0] || null;
+  }
+  async findTabByName(zellij, name) {
+    try {
+      const proc = spawn2([zellij, "action", "list-tabs", "--json"], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const exitCode = await proc.exited;
+      if (exitCode !== 0)
+        return this.findTabByNameText(zellij, name);
+      const stdout = await new Response(proc.stdout).text();
+      try {
+        const tabs = JSON.parse(stdout);
+        for (const tab of tabs) {
+          if (tab.name === name) {
+            return { tabId: String(tab.tab_id), name: tab.name };
+          }
+        }
+      } catch {
+        return this.findTabByNameText(zellij, name);
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  async findTabByNameText(zellij, name) {
+    try {
+      const proc = spawn2([zellij, "action", "list-tabs"], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const exitCode = await proc.exited;
+      if (exitCode !== 0)
+        return null;
+      const stdout = await new Response(proc.stdout).text();
+      const lines = stdout.split(`
+`);
+      for (const line of lines) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length >= 3 && parts[2] === name) {
+          return { tabId: parts[0], name: parts[2] };
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  async getCurrentTabId(zellij) {
+    try {
+      const proc = spawn2([zellij, "action", "current-tab-info", "--json"], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const exitCode = await proc.exited;
+      if (exitCode !== 0)
+        return null;
+      const stdout = await new Response(proc.stdout).text();
+      try {
+        const info = JSON.parse(stdout);
+        return String(info.tab_id);
+      } catch {
+        return null;
+      }
+    } catch {
+      return null;
+    }
+  }
+  async listPanes(zellij) {
+    try {
+      const proc = spawn2([zellij, "action", "list-panes"], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const exitCode = await proc.exited;
+      if (exitCode !== 0)
+        return [];
+      const stdout = await new Response(proc.stdout).text();
+      return stdout.split(`
+`).slice(1).map((line) => line.trim().split(/\s+/)[0]).filter((id) => id?.startsWith("terminal_"));
+    } catch {
+      return [];
+    }
+  }
+  async closePane(paneId) {
+    if (!paneId || paneId === "unknown")
+      return true;
+    const zellij = await this.getBinary();
+    if (!zellij)
+      return false;
+    try {
+      await spawn2([zellij, "action", "write", "--pane-id", paneId, "\x03"], {
+        stdout: "ignore",
+        stderr: "ignore"
+      }).exited;
+      await new Promise((r) => setTimeout(r, 250));
+      const proc = spawn2([zellij, "action", "close-pane", "--pane-id", paneId], { stdout: "pipe", stderr: "pipe" });
+      const exitCode = await proc.exited;
+      return exitCode === 0 || exitCode === 1;
+    } catch {
+      return false;
+    }
+  }
+  async applyLayout(_layout, _mainPaneSize) {}
+  async getBinary() {
+    await this.isAvailable();
+    return this.binaryPath;
+  }
+  async findBinary() {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    try {
+      const proc = spawn2([cmd, "zellij"], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      if (await proc.exited !== 0)
+        return null;
+      const stdout = await new Response(proc.stdout).text();
+      return stdout.trim().split(`
+`)[0] || null;
+    } catch {
+      return null;
+    }
   }
 }
-async function closeTmuxPane(paneId) {
-  log("[tmux] closeTmuxPane called", { paneId });
-  if (!paneId) {
-    log("[tmux] closeTmuxPane: no paneId provided");
-    return false;
+
+// src/multiplexer/factory.ts
+var multiplexerCache = new Map;
+function getMultiplexer(config2) {
+  const { type } = config2;
+  if (type === "none") {
+    return null;
   }
-  const tmux = await getTmuxPath();
-  if (!tmux) {
-    log("[tmux] closeTmuxPane: tmux binary not found");
-    return false;
+  const cached2 = multiplexerCache.get(type);
+  if (cached2) {
+    return cached2;
   }
-  try {
-    log("[tmux] closeTmuxPane: sending Ctrl+C for graceful shutdown", {
-      paneId
-    });
-    const ctrlCProc = spawn([tmux, "send-keys", "-t", paneId, "C-c"], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    await ctrlCProc.exited;
-    await new Promise((r) => setTimeout(r, 250));
-    log("[tmux] closeTmuxPane: killing pane", { paneId });
-    const proc = spawn([tmux, "kill-pane", "-t", paneId], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const exitCode = await proc.exited;
-    const stderr = await new Response(proc.stderr).text();
-    log("[tmux] closeTmuxPane: result", { exitCode, stderr: stderr.trim() });
-    if (exitCode === 0) {
-      log("[tmux] closeTmuxPane: SUCCESS, pane closed", { paneId });
-      if (storedConfig) {
-        const layout = storedConfig.layout ?? "main-vertical";
-        const mainPaneSize = storedConfig.main_pane_size ?? 60;
-        await applyLayout(tmux, layout, mainPaneSize);
-        log("[tmux] closeTmuxPane: layout reapplied", { layout });
+  let multiplexer;
+  let actualType;
+  switch (type) {
+    case "tmux":
+      multiplexer = new TmuxMultiplexer(config2.layout, config2.main_pane_size);
+      actualType = "tmux";
+      break;
+    case "zellij":
+      multiplexer = new ZellijMultiplexer(config2.layout, config2.main_pane_size);
+      actualType = "zellij";
+      break;
+    case "auto": {
+      if (process.env.TMUX) {
+        multiplexer = new TmuxMultiplexer(config2.layout, config2.main_pane_size);
+        actualType = "tmux";
+      } else if (process.env.ZELLIJ) {
+        multiplexer = new ZellijMultiplexer(config2.layout, config2.main_pane_size);
+        actualType = "zellij";
+      } else {
+        log("[multiplexer] auto: not inside any session, disabling");
+        return null;
       }
+      break;
+    }
+    default:
+      log(`[multiplexer] Unknown type: ${type}`);
+      return null;
+  }
+  multiplexerCache.set(actualType, multiplexer);
+  log(`[multiplexer] Created ${actualType} instance`);
+  return multiplexer;
+}
+function startAvailabilityCheck(config2) {
+  const multiplexer = getMultiplexer(config2);
+  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;
     }
-    log("[tmux] closeTmuxPane: failed (pane may already be closed)", {
-      paneId
-    });
-    return false;
-  } catch (err) {
-    log("[tmux] closeTmuxPane: exception", { error: String(err) });
+    if (attempt < maxAttempts) {
+      await new Promise((r) => setTimeout(r, 250));
+    }
+  }
+  return false;
+}
+// src/utils/agent-variant.ts
+function normalizeAgentName(agentName) {
+  const trimmed = agentName.trim();
+  return trimmed.startsWith("@") ? trimmed.slice(1) : trimmed;
+}
+function resolveAgentVariant(config2, agentName) {
+  const normalized = normalizeAgentName(agentName);
+  const rawVariant = config2?.agents?.[normalized]?.variant;
+  if (typeof rawVariant !== "string") {
+    return;
+  }
+  const trimmed = rawVariant.trim();
+  if (trimmed.length === 0) {
+    return;
+  }
+  log(`[variant] resolved variant="${trimmed}" for agent "${normalized}"`);
+  return trimmed;
+}
+function applyAgentVariant(variant, body) {
+  if (!variant) {
+    return body;
+  }
+  if (body.variant) {
+    return body;
+  }
+  return { ...body, variant };
+}
+// src/utils/internal-initiator.ts
+var SLIM_INTERNAL_INITIATOR_MARKER = "<!-- SLIM_INTERNAL_INITIATOR -->";
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function createInternalAgentTextPart(text) {
+  return {
+    type: "text",
+    text: `${text}
+${SLIM_INTERNAL_INITIATOR_MARKER}`
+  };
+}
+function hasInternalInitiatorMarker(part) {
+  if (!isRecord(part) || part.type !== "text") {
     return false;
   }
-}
-function startTmuxCheck() {
-  if (!tmuxChecked) {
-    getTmuxPath().catch(() => {});
+  if (typeof part.text !== "string") {
+    return false;
   }
+  return part.text.includes(SLIM_INTERNAL_INITIATOR_MARKER);
 }
 // src/utils/zip-extractor.ts
 import { release } from "os";
-var {spawn: spawn2, spawnSync } = globalThis.Bun;
+var {spawn: spawn3, spawnSync } = globalThis.Bun;
 var WINDOWS_BUILD_WITH_TAR = 17134;
 function getWindowsBuildNumber() {
   if (process.platform !== "win32")
@@ -18623,13 +18978,13 @@ async function extractZip(archivePath, destDir) {
     const extractor = getWindowsZipExtractor();
     switch (extractor) {
       case "tar":
-        proc = spawn2(["tar", "-xf", archivePath, "-C", destDir], {
+        proc = spawn3(["tar", "-xf", archivePath, "-C", destDir], {
           stdout: "ignore",
           stderr: "pipe"
         });
         break;
       case "pwsh":
-        proc = spawn2([
+        proc = spawn3([
           "pwsh",
           "-Command",
           `Expand-Archive -Path '${escapePowerShellPath(archivePath)}' -DestinationPath '${escapePowerShellPath(destDir)}' -Force`
@@ -18639,7 +18994,7 @@ async function extractZip(archivePath, destDir) {
         });
         break;
       default:
-        proc = spawn2([
+        proc = spawn3([
           "powershell",
           "-Command",
           `Expand-Archive -Path '${escapePowerShellPath(archivePath)}' -DestinationPath '${escapePowerShellPath(destDir)}' -Force`
@@ -18650,7 +19005,7 @@ async function extractZip(archivePath, destDir) {
         break;
     }
   } else {
-    proc = spawn2(["unzip", "-o", archivePath, "-d", destDir], {
+    proc = spawn3(["unzip", "-o", archivePath, "-d", destDir], {
       stdout: "ignore",
       stderr: "pipe"
     });
@@ -18721,10 +19076,10 @@ class BackgroundTaskManager {
   activeStarts = 0;
   maxConcurrentStarts;
   completionResolvers = new Map;
-  constructor(ctx, tmuxConfig, config2) {
+  constructor(ctx, multiplexerConfig, config2) {
     this.client = ctx.client;
     this.directory = ctx.directory;
-    this.tmuxEnabled = tmuxConfig?.enabled ?? false;
+    this.tmuxEnabled = multiplexerConfig !== undefined && multiplexerConfig.type !== "none" && multiplexerConfig.type !== undefined && getMultiplexer(multiplexerConfig) !== null;
     this.config = config2;
     this.backgroundConfig = config2?.background ?? {
       maxConcurrentStarts: 10
@@ -18862,6 +19217,7 @@ class BackgroundTaskManager {
       const errors3 = [];
       let succeeded = false;
       const sessionId = session2.data.id;
+      const retryOnEmpty = this.config?.fallback?.retry_on_empty ?? true;
       for (let i = 0;i < attemptModels.length; i++) {
         const model = attemptModels[i];
         const modelLabel = model ?? "default-model";
@@ -18885,6 +19241,10 @@ class BackgroundTaskManager {
             body,
             query: promptQuery
           }, timeoutMs);
+          const extraction = await extractSessionResult(this.client, sessionId);
+          if (retryOnEmpty && extraction.empty) {
+            throw new Error("Empty response from provider");
+          }
           succeeded = true;
           break;
         } catch (error48) {
@@ -18964,12 +19324,13 @@ class BackgroundTaskManager {
   async extractAndCompleteTask(task) {
     if (!task.sessionId)
       return;
+    const retryOnEmpty = this.config?.fallback?.retry_on_empty ?? true;
     try {
-      const responseText = await extractSessionResult(this.client, task.sessionId);
-      if (responseText) {
-        this.completeTask(task, "completed", responseText);
+      const extraction = await extractSessionResult(this.client, task.sessionId);
+      if (extraction.empty && retryOnEmpty) {
+        this.completeTask(task, "failed", "Empty response from provider");
       } else {
-        this.completeTask(task, "completed", "(No output)");
+        this.completeTask(task, "completed", extraction.text);
       }
     } catch (error48) {
       this.completeTask(task, "failed", error48 instanceof Error ? error48.message : String(error48));
@@ -19087,31 +19448,31 @@ class BackgroundTaskManager {
     return this.depthTracker;
   }
 }
-// src/background/tmux-session-manager.ts
+// src/background/multiplexer-session-manager.ts
 var SESSION_TIMEOUT_MS = 10 * 60 * 1000;
 var SESSION_MISSING_GRACE_MS = POLL_INTERVAL_BACKGROUND_MS * 3;
 
-class TmuxSessionManager {
+class MultiplexerSessionManager {
   client;
-  tmuxConfig;
   serverUrl;
+  multiplexer = null;
   sessions = new Map;
   pollInterval;
   enabled = false;
-  constructor(ctx, tmuxConfig) {
+  constructor(ctx, config2) {
     this.client = ctx.client;
-    this.tmuxConfig = tmuxConfig;
     const defaultPort = process.env.OPENCODE_PORT ?? "4096";
     this.serverUrl = ctx.serverUrl?.toString() ?? `http://localhost:${defaultPort}`;
-    this.enabled = tmuxConfig.enabled && isInsideTmux();
-    log("[tmux-session-manager] initialized", {
+    this.multiplexer = getMultiplexer(config2);
+    this.enabled = config2.type !== "none" && this.multiplexer !== null && this.multiplexer.isInsideSession();
+    log("[multiplexer-session-manager] initialized", {
       enabled: this.enabled,
-      tmuxConfig: this.tmuxConfig,
+      type: config2.type,
       serverUrl: this.serverUrl
     });
   }
   async onSessionCreated(event) {
-    if (!this.enabled)
+    if (!this.enabled || !this.multiplexer)
       return;
     if (event.type !== "session.created")
       return;
@@ -19123,16 +19484,25 @@ class TmuxSessionManager {
     const parentId = info.parentID;
     const title = info.title ?? "Subagent";
     if (this.sessions.has(sessionId)) {
-      log("[tmux-session-manager] session already tracked", { sessionId });
+      log("[multiplexer-session-manager] session already tracked", {
+        sessionId
+      });
+      return;
+    }
+    const serverRunning = await isServerRunning(this.serverUrl);
+    if (!serverRunning) {
+      log("[multiplexer-session-manager] server not running, skipping", {
+        serverUrl: this.serverUrl
+      });
       return;
     }
-    log("[tmux-session-manager] child session created, spawning pane", {
+    log("[multiplexer-session-manager] child session created, spawning pane", {
       sessionId,
       parentId,
       title
     });
-    const paneResult = await spawnTmuxPane(sessionId, title, this.tmuxConfig, this.serverUrl).catch((err) => {
-      log("[tmux-session-manager] failed to spawn pane", {
+    const paneResult = await this.multiplexer.spawnPane(sessionId, title, this.serverUrl).catch((err) => {
+      log("[multiplexer-session-manager] failed to spawn pane", {
         error: String(err)
       });
       return { success: false, paneId: undefined };
@@ -19147,7 +19517,7 @@ class TmuxSessionManager {
         createdAt: now,
         lastSeenAt: now
       });
-      log("[tmux-session-manager] pane spawned", {
+      log("[multiplexer-session-manager] pane spawned", {
         sessionId,
         paneId: paneResult.paneId
       });
@@ -19174,7 +19544,7 @@ class TmuxSessionManager {
     const sessionId = event.properties?.sessionID;
     if (!sessionId)
       return;
-    log("[tmux-session-manager] session deleted, closing pane", {
+    log("[multiplexer-session-manager] session deleted, closing pane", {
       sessionId
     });
     await this.closeSession(sessionId);
@@ -19183,13 +19553,13 @@ class TmuxSessionManager {
     if (this.pollInterval)
       return;
     this.pollInterval = setInterval(() => this.pollSessions(), POLL_INTERVAL_BACKGROUND_MS);
-    log("[tmux-session-manager] polling started");
+    log("[multiplexer-session-manager] polling started");
   }
   stopPolling() {
     if (this.pollInterval) {
       clearInterval(this.pollInterval);
       this.pollInterval = undefined;
-      log("[tmux-session-manager] polling stopped");
+      log("[multiplexer-session-manager] polling stopped");
     }
   }
   async pollSessions() {
@@ -19221,18 +19591,18 @@ class TmuxSessionManager {
         await this.closeSession(sessionId);
       }
     } catch (err) {
-      log("[tmux-session-manager] poll error", { error: String(err) });
+      log("[multiplexer-session-manager] poll error", { error: String(err) });
     }
   }
   async closeSession(sessionId) {
     const tracked = this.sessions.get(sessionId);
-    if (!tracked)
+    if (!tracked || !this.multiplexer)
       return;
-    log("[tmux-session-manager] closing session pane", {
+    log("[multiplexer-session-manager] closing session pane", {
       sessionId,
       paneId: tracked.paneId
     });
-    await closeTmuxPane(tracked.paneId);
+    await this.multiplexer.closePane(tracked.paneId);
     this.sessions.delete(sessionId);
     if (this.sessions.size === 0) {
       this.stopPolling();
@@ -19240,18 +19610,19 @@ class TmuxSessionManager {
   }
   async cleanup() {
     this.stopPolling();
-    if (this.sessions.size > 0) {
-      log("[tmux-session-manager] closing all panes", {
+    if (this.sessions.size > 0 && this.multiplexer) {
+      log("[multiplexer-session-manager] closing all panes", {
         count: this.sessions.size
       });
-      const closePromises = Array.from(this.sessions.values()).map((s) => closeTmuxPane(s.paneId).catch((err) => log("[tmux-session-manager] cleanup error for pane", {
+      const multiplexer = this.multiplexer;
+      const closePromises = Array.from(this.sessions.values()).map((s) => multiplexer.closePane(s.paneId).catch((err) => log("[multiplexer-session-manager] cleanup error for pane", {
         paneId: s.paneId,
         error: String(err)
       })));
       await Promise.all(closePromises);
       this.sessions.clear();
     }
-    log("[tmux-session-manager] cleanup complete");
+    log("[multiplexer-session-manager] cleanup complete");
   }
 }
 // src/council/council-manager.ts
@@ -19296,10 +19667,11 @@ class CouncilManager {
     const resolvedPreset = presetName ?? councilConfig.default_preset ?? "default";
     const preset = councilConfig.presets[resolvedPreset];
     if (!preset) {
+      const available = Object.keys(councilConfig.presets).join(", ");
       log(`[council-manager] Preset "${resolvedPreset}" not found`);
       return {
         success: false,
-        error: `Preset "${resolvedPreset}" not found`,
+        error: `Preset "${resolvedPreset}" does not exist. Omit the preset parameter to use the default, or call again with one of: ${available}`,
         councillorResults: []
       };
     }
@@ -19314,6 +19686,7 @@ class CouncilManager {
     const councillorsTimeout = councilConfig.councillors_timeout ?? 180000;
     const masterTimeout = councilConfig.master_timeout ?? 300000;
     const executionMode = councilConfig.councillor_execution_mode ?? "parallel";
+    const maxRetries = councilConfig.councillor_retries ?? 3;
     const councillorCount = Object.keys(preset.councillors).length;
     log(`[council-manager] Starting council with preset "${resolvedPreset}"`, {
       councillors: Object.keys(preset.councillors)
@@ -19323,7 +19696,7 @@ class CouncilManager {
         error: err instanceof Error ? err.message : String(err)
       });
     });
-    const councillorResults = await this.runCouncillors(prompt, preset.councillors, parentSessionId, councillorsTimeout, executionMode);
+    const councillorResults = await this.runCouncillors(prompt, preset.councillors, parentSessionId, councillorsTimeout, executionMode, maxRetries);
     const completedCount = councillorResults.filter((r) => r.status === "completed").length;
     log(`[council-manager] Councillors completed: ${completedCount}/${councillorResults.length}`);
     if (completedCount === 0) {
@@ -19411,10 +19784,16 @@ ${bestResult.result}` : undefined,
         body,
         query: { directory: this.directory }
       }, options.timeout);
-      const result = await extractSessionResult(this.client, sessionId, {
+      const extraction = await extractSessionResult(this.client, sessionId, {
         includeReasoning: options.includeReasoning
       });
-      return result || "(No output)";
+      if (extraction.empty) {
+        const retryOnEmpty = this.config?.fallback?.retry_on_empty ?? true;
+        if (retryOnEmpty) {
+          throw new Error("Empty response from provider");
+        }
+      }
+      return extraction.text;
     } finally {
       if (sessionId) {
         this.client.session.abort({ path: { id: sessionId } }).catch(() => {});
@@ -19424,72 +19803,19 @@ ${bestResult.result}` : undefined,
       }
     }
   }
-  async runCouncillors(prompt, councillors, parentSessionId, timeout, executionMode = "parallel") {
+  async runCouncillors(prompt, councillors, parentSessionId, timeout, executionMode = "parallel", maxRetries = 1) {
     const entries = Object.entries(councillors);
     const results = [];
     if (executionMode === "serial") {
       for (const [name, config2] of entries) {
-        const modelLabel = shortModelLabel(config2.model);
-        log(`[council-manager] Running councillor "${name}" (${modelLabel}) serially`);
-        try {
-          const result = await this.runAgentSession({
-            parentSessionId,
-            title: `Council ${name} (${modelLabel})`,
-            agent: "councillor",
-            model: config2.model,
-            promptText: formatCouncillorPrompt(prompt, config2.prompt),
-            variant: config2.variant,
-            timeout,
-            includeReasoning: false
-          });
-          results.push({
-            name,
-            model: config2.model,
-            status: "completed",
-            result
-          });
-        } catch (error48) {
-          const msg = error48 instanceof Error ? error48.message : String(error48);
-          results.push({
-            name,
-            model: config2.model,
-            status: msg.includes("timed out") ? "timed_out" : "failed",
-            error: `Councillor "${name}": ${msg}`
-          });
-        }
+        results.push(await this.runCouncillorWithRetry(name, config2, prompt, parentSessionId, timeout, maxRetries));
       }
     } else {
       const promises = entries.map(([name, config2], index) => (async () => {
         if (index > 0) {
           await new Promise((r) => setTimeout(r, index * COUNCILLOR_STAGGER_MS));
         }
-        const modelLabel = shortModelLabel(config2.model);
-        try {
-          const result = await this.runAgentSession({
-            parentSessionId,
-            title: `Council ${name} (${modelLabel})`,
-            agent: "councillor",
-            model: config2.model,
-            promptText: formatCouncillorPrompt(prompt, config2.prompt),
-            variant: config2.variant,
-            timeout,
-            includeReasoning: false
-          });
-          return {
-            name,
-            model: config2.model,
-            status: "completed",
-            result
-          };
-        } catch (error48) {
-          const msg = error48 instanceof Error ? error48.message : String(error48);
-          return {
-            name,
-            model: config2.model,
-            status: msg.includes("timed out") ? "timed_out" : "failed",
-            error: `Councillor "${name}": ${msg}`
-          };
-        }
+        return this.runCouncillorWithRetry(name, config2, prompt, parentSessionId, timeout, maxRetries);
       })());
       const settled = await Promise.allSettled(promises);
       for (let index = 0;index < settled.length; index++) {
@@ -19515,6 +19841,78 @@ ${bestResult.result}` : undefined,
     }
     return results;
   }
+  async runCouncillorWithRetry(name, config2, prompt, parentSessionId, timeout, maxRetries) {
+    const modelLabel = shortModelLabel(config2.model);
+    const totalAttempts = 1 + maxRetries;
+    for (let attempt = 1;attempt <= totalAttempts; attempt++) {
+      if (attempt > 1) {
+        log(`[council-manager] Retrying councillor "${name}" (${modelLabel}), attempt ${attempt}/${totalAttempts}`);
+      }
+      try {
+        const result = await this.runAgentSession({
+          parentSessionId,
+          title: `Council ${name} (${modelLabel})`,
+          agent: "councillor",
+          model: config2.model,
+          promptText: formatCouncillorPrompt(prompt, config2.prompt),
+          variant: config2.variant,
+          timeout,
+          includeReasoning: false
+        });
+        return {
+          name,
+          model: config2.model,
+          status: "completed",
+          result
+        };
+      } catch (error48) {
+        const msg = error48 instanceof Error ? error48.message : String(error48);
+        const isEmptyResponse = msg.includes("Empty response from provider");
+        const canRetry = attempt < totalAttempts && isEmptyResponse;
+        if (!canRetry) {
+          return {
+            name,
+            model: config2.model,
+            status: msg.includes("timed out") ? "timed_out" : "failed",
+            error: `Councillor "${name}": ${msg}`
+          };
+        }
+      }
+    }
+    return {
+      name,
+      model: config2.model,
+      status: "failed",
+      error: `Councillor "${name}": max retries exhausted`
+    };
+  }
+  async runMasterModelWithRetry(parentSessionId, model, modelLabel, promptText, variant, timeout, maxRetries) {
+    const totalAttempts = 1 + maxRetries;
+    for (let attempt = 1;attempt <= totalAttempts; attempt++) {
+      if (attempt > 1) {
+        log(`[council-manager] Retrying master (${modelLabel}), attempt ${attempt}/${totalAttempts}`);
+      }
+      try {
+        return await this.runAgentSession({
+          parentSessionId,
+          title: `Council Master (${modelLabel})`,
+          agent: "council-master",
+          model,
+          promptText,
+          variant,
+          timeout
+        });
+      } catch (error48) {
+        const msg = error48 instanceof Error ? error48.message : String(error48);
+        const isEmptyResponse = msg.includes("Empty response from provider");
+        const canRetry = attempt < totalAttempts && isEmptyResponse;
+        if (!canRetry) {
+          throw error48;
+        }
+      }
+    }
+    throw new Error(`Master model ${modelLabel}: max retries exhausted`);
+  }
   async runMaster(prompt, councillorResults, councilConfig, parentSessionId, timeout, presetMasterOverride) {
     const masterConfig = councilConfig.master;
     const fallbackModels = councilConfig.master_fallback ?? [];
@@ -19523,6 +19921,7 @@ ${bestResult.result}` : undefined,
     const effectivePrompt = presetMasterOverride?.prompt ?? masterConfig.prompt;
     const attemptModels = [effectiveModel, ...fallbackModels];
     const synthesisPrompt = formatMasterSynthesisPrompt(prompt, councillorResults, effectivePrompt);
+    const maxRetries = councilConfig.councillor_retries ?? 3;
     const errors3 = [];
     for (let i = 0;i < attemptModels.length; i++) {
       const model = attemptModels[i];
@@ -19531,15 +19930,7 @@ ${bestResult.result}` : undefined,
         if (i > 0) {
           log(`[council-manager] master fallback ${i}/${attemptModels.length - 1}: ${currentLabel}`);
         }
-        const result = await this.runAgentSession({
-          parentSessionId,
-          title: `Council Master (${currentLabel})`,
-          agent: "council-master",
-          model,
-          promptText: synthesisPrompt,
-          variant: effectiveVariant,
-          timeout
-        });
+        const result = await this.runMasterModelWithRetry(parentSessionId, model, currentLabel, synthesisPrompt, effectiveVariant, timeout, maxRetries);
         return { success: true, result };
       } catch (error48) {
         const msg = error48 instanceof Error ? error48.message : String(error48);
@@ -19792,30 +20183,6 @@ function getCachedVersion() {
   }
   return null;
 }
-function updatePinnedVersion(configPath, oldEntry, newVersion) {
-  try {
-    if (!fs4.existsSync(configPath))
-      return false;
-    const content = fs4.readFileSync(configPath, "utf-8");
-    const newEntry = `${PACKAGE_NAME}@${newVersion}`;
-    const escapedOldEntry = oldEntry.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const entryRegex = new RegExp(`(["'])${escapedOldEntry}\\1`, "g");
-    if (!entryRegex.test(content)) {
-      log(`[auto-update-checker] Entry "${oldEntry}" not found in ${configPath}`);
-      return false;
-    }
-    const updatedContent = content.replace(entryRegex, `$1${newEntry}$1`);
-    if (updatedContent === content) {
-      return false;
-    }
-    fs4.writeFileSync(configPath, updatedContent, "utf-8");
-    log(`[auto-update-checker] Updated ${configPath}: ${oldEntry} \u2192 ${newEntry}`);
-    return true;
-  } catch (err) {
-    log(`[auto-update-checker] Failed to update config file ${configPath}:`, err);
-    return false;
-  }
-}
 async function getLatestVersion(channel = "latest") {
   const controller = new AbortController;
   const timeoutId = setTimeout(() => controller.abort(), NPM_FETCH_TIMEOUT);
@@ -19893,20 +20260,17 @@ async function runBackgroundUpdateCheck(ctx, autoUpdate) {
     return;
   }
   log(`[auto-update-checker] Update available (${channel}): ${currentVersion} \u2192 ${latestVersion}`);
+  if (pluginInfo.isPinned) {
+    showToast(ctx, `OMO-Slim ${latestVersion}`, `v${latestVersion} available.
+Version is pinned. Update your plugin config to apply.`, "info", 8000);
+    log(`[auto-update-checker] Version is pinned; skipping auto-update.`);
+    return;
+  }
   if (!autoUpdate) {
-    showToast(ctx, `OMO-Slim ${latestVersion}`, `v${latestVersion} available. Restart to apply.`, "info", 8000);
+    showToast(ctx, `OMO-Slim ${latestVersion}`, `v${latestVersion} available. Auto-update is disabled.`, "info", 8000);
     log("[auto-update-checker] Auto-update disabled, notification only");
     return;
   }
-  if (pluginInfo.isPinned) {
-    const updated = updatePinnedVersion(pluginInfo.configPath, pluginInfo.entry, latestVersion);
-    if (!updated) {
-      showToast(ctx, `OMO-Slim ${latestVersion}`, `v${latestVersion} available. Restart to apply.`, "info", 8000);
-      log("[auto-update-checker] Failed to update pinned version in config");
-      return;
-    }
-    log(`[auto-update-checker] Config updated: ${pluginInfo.entry} \u2192 ${PACKAGE_NAME}@${latestVersion}`);
-  }
   invalidatePackage(PACKAGE_NAME);
   const installSuccess = await runBunInstallSafe(ctx);
   if (installSuccess) {
@@ -20103,6 +20467,76 @@ ${buildRetryGuidance(detected)}`;
     }
   };
 }
+// src/hooks/filter-available-skills/index.ts
+var AVAILABLE_SKILLS_BLOCK_REGEX = /<available_skills>\s*([\s\S]*?)\s*<\/available_skills>/g;
+var SKILL_NAME_REGEX = /<name>([^<]+)<\/name>/;
+function getCurrentAgent(messages) {
+  for (let index = messages.length - 1;index >= 0; index -= 1) {
+    const message = messages[index];
+    if (message.info.role === "user") {
+      return message.info.agent ?? "orchestrator";
+    }
+  }
+  return "orchestrator";
+}
+function extractSkillEntries(blockContent) {
+  const entries = [];
+  const skillEntryRegex = /<skill>\s*([\s\S]*?)\s*<\/skill>/g;
+  for (const match of blockContent.matchAll(skillEntryRegex)) {
+    const block = match[0];
+    const nameMatch = block.match(SKILL_NAME_REGEX);
+    if (!nameMatch) {
+      continue;
+    }
+    entries.push({
+      name: nameMatch[1].trim(),
+      block
+    });
+  }
+  return entries;
+}
+function isSkillAllowed(skillName, permissionRules) {
+  const specificRule = permissionRules[skillName];
+  if (specificRule !== undefined) {
+    return specificRule === "allow";
+  }
+  return permissionRules["*"] === "allow";
+}
+function filterAvailableSkillsText(text, permissionRules) {
+  return text.replace(AVAILABLE_SKILLS_BLOCK_REGEX, (_fullMatch, blockContent) => {
+    const allowedEntries = extractSkillEntries(blockContent).filter((entry) => isSkillAllowed(entry.name, permissionRules));
+    if (allowedEntries.length === 0) {
+      return `<available_skills>
+No skills available.
+</available_skills>`;
+    }
+    return `<available_skills>
+${allowedEntries.map((entry) => entry.block).join(`
+`)}
+</available_skills>`;
+  });
+}
+function createFilterAvailableSkillsHook(_ctx, config2) {
+  return {
+    "experimental.chat.messages.transform": async (_input, output) => {
+      const { messages } = output;
+      if (messages.length === 0) {
+        return;
+      }
+      const agentName = getCurrentAgent(messages);
+      const configuredSkills = getAgentOverride(config2, agentName)?.skills;
+      const permissionRules = getSkillPermissionsForAgent(agentName, configuredSkills);
+      for (const message of messages) {
+        for (const part of message.parts) {
+          if (part.type !== "text" || !part.text || !part.text.includes("<available_skills>")) {
+            continue;
+          }
+          part.text = filterAvailableSkillsText(part.text, permissionRules);
+        }
+      }
+    }
+  };
+}
 // src/hooks/foreground-fallback/index.ts
 var RATE_LIMIT_PATTERNS = [
   /\b429\b/,
@@ -20438,12 +20872,31 @@ var grep_app = {
 };
 
 // src/mcp/websearch.ts
-var websearch = {
-  type: "remote",
-  url: "https://mcp.exa.ai/mcp?tools=web_search_exa",
-  headers: process.env.EXA_API_KEY ? { "x-api-key": process.env.EXA_API_KEY } : undefined,
-  oauth: false
-};
+function createWebsearchConfig(config2) {
+  const provider = config2?.provider || "exa";
+  if (provider === "tavily") {
+    const tavilyKey = process.env.TAVILY_API_KEY;
+    if (!tavilyKey) {
+      throw new Error("TAVILY_API_KEY environment variable is required for Tavily provider");
+    }
+    return {
+      type: "remote",
+      url: "https://mcp.tavily.com/mcp/",
+      headers: {
+        Authorization: `Bearer ${tavilyKey}`
+      },
+      oauth: false
+    };
+  }
+  const exaKey = process.env.EXA_API_KEY;
+  const exaUrl = exaKey ? `https://mcp.exa.ai/mcp?tools=web_search_exa&exaApiKey=${encodeURIComponent(exaKey)}` : "https://mcp.exa.ai/mcp?tools=web_search_exa";
+  return {
+    type: "remote",
+    url: exaUrl,
+    oauth: false
+  };
+}
+var websearch = createWebsearchConfig();
 
 // src/mcp/index.ts
 var allBuiltinMcps = {
@@ -20451,8 +20904,12 @@ var allBuiltinMcps = {
   context7,
   grep_app
 };
-function createBuiltinMcps(disabledMcps = []) {
-  return Object.fromEntries(Object.entries(allBuiltinMcps).filter(([name]) => !disabledMcps.includes(name)));
+function createBuiltinMcps(disabledMcps = [], websearchConfig) {
+  const mcps = Object.fromEntries(Object.entries(allBuiltinMcps).filter(([name]) => !disabledMcps.includes(name)));
+  if (!disabledMcps.includes("websearch")) {
+    mcps.websearch = createWebsearchConfig(websearchConfig);
+  }
+  return mcps;
 }
 
 // node_modules/@opencode-ai/plugin/node_modules/zod/v4/classic/external.js
@@ -32778,15 +33235,15 @@ tool.schema = exports_external2;
 
 // src/tools/ast-grep/cli.ts
 import { existsSync as existsSync6 } from "fs";
-var {spawn: spawn3 } = globalThis.Bun;
+var {spawn: spawn4 } = globalThis.Bun;
 
 // src/tools/ast-grep/constants.ts
 import { existsSync as existsSync5, statSync as statSync2 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import { dirname as dirname3, join as join8 } from "path";
+import { dirname as dirname4, join as join8 } from "path";
 
 // src/tools/ast-grep/downloader.ts
-import { chmodSync, existsSync as existsSync4, mkdirSync, unlinkSync } from "fs";
+import { chmodSync, existsSync as existsSync4, mkdirSync as mkdirSync2, unlinkSync } from "fs";
 import { createRequire } from "module";
 import { homedir as homedir3 } from "os";
 import { join as join7 } from "path";
@@ -32846,7 +33303,7 @@ async function downloadAstGrep(version3 = DEFAULT_VERSION) {
   console.log(`[oh-my-opencode-slim] Downloading ast-grep binary...`);
   try {
     if (!existsSync4(cacheDir)) {
-      mkdirSync(cacheDir, { recursive: true });
+      mkdirSync2(cacheDir, { recursive: true });
     }
     const response = await fetch(downloadUrl, { redirect: "follow" });
     if (!response.ok) {
@@ -32940,7 +33397,7 @@ function findSgCliPathSync() {
   try {
     const require2 = createRequire2(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
-    const cliDir = dirname3(cliPkgPath);
+    const cliDir = dirname4(cliPkgPath);
     const sgPath = join8(cliDir, binaryName);
     if (existsSync5(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
@@ -32951,7 +33408,7 @@ function findSgCliPathSync() {
     try {
       const require2 = createRequire2(import.meta.url);
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
-      const pkgDir = dirname3(pkgPath);
+      const pkgDir = dirname4(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
       const binaryPath = join8(pkgDir, astGrepName);
       if (existsSync5(binaryPath) && isValidBinary(binaryPath)) {
@@ -33045,7 +33502,7 @@ async function runSg(options) {
     }
   }
   const timeout = DEFAULT_TIMEOUT_MS2;
-  const proc = spawn3([cliPath, ...args], {
+  const proc = spawn4([cliPath, ...args], {
     stdout: "pipe",
     stderr: "pipe"
   });
@@ -33325,7 +33782,7 @@ var ast_grep_replace = tool({
 });
 // src/tools/background.ts
 var z2 = tool.schema;
-function createBackgroundTools(_ctx, manager, _tmuxConfig, _pluginConfig) {
+function createBackgroundTools(_ctx, manager, _multiplexerConfig, _pluginConfig) {
   const agentNames = SUBAGENT_NAMES.join(", ");
   const background_task = tool({
     description: `Launch background agent task. Returns task_id immediately.
@@ -33495,16 +33952,16 @@ Returns the synthesized result with councillor summary.`,
 // src/tools/lsp/client.ts
 var import_node = __toESM(require_main(), 1);
 import { readFileSync as readFileSync4 } from "fs";
-import { extname, resolve as resolve2 } from "path";
+import { extname, resolve as resolve3 } from "path";
 import { Readable, Writable } from "stream";
 import { pathToFileURL } from "url";
-var {spawn: spawn4 } = globalThis.Bun;
+var {spawn: spawn5 } = globalThis.Bun;
 
 // src/tools/lsp/config.ts
 var import_which = __toESM(require_lib(), 1);
 import { existsSync as existsSync8 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join9 } from "path";
+import { dirname as dirname6, join as join9, resolve as resolve2 } from "path";
 
 // src/tools/lsp/config-store.ts
 var userConfig = new Map;
@@ -33535,7 +33992,7 @@ function hasUserLspConfig() {
 
 // src/tools/lsp/constants.ts
 import { existsSync as existsSync7, readdirSync, statSync as statSync3 } from "fs";
-import { dirname as dirname4, resolve } from "path";
+import { dirname as dirname5, resolve } from "path";
 var SEVERITY_MAP = {
   1: "error",
   2: "warning",
@@ -33555,10 +34012,10 @@ function* walkUpDirectories(start, stop) {
   let dir = resolve(start);
   try {
     if (!statSync3(dir).isDirectory()) {
-      dir = dirname4(dir);
+      dir = dirname5(dir);
     }
   } catch {
-    dir = dirname4(dir);
+    dir = dirname5(dir);
   }
   let prevDir = "";
   while (dir !== prevDir && dir !== "/") {
@@ -33566,7 +34023,7 @@ function* walkUpDirectories(start, stop) {
     prevDir = dir;
     if (dir === stop)
       break;
-    dir = dirname4(dir);
+    dir = dirname5(dir);
   }
 }
 function NearestRoot(includePatterns, excludePatterns) {
@@ -34107,39 +34564,79 @@ function buildMergedServers() {
   }
   return servers;
 }
-function findServerForExtension(ext) {
-  const servers = buildMergedServers();
-  for (const [, config3] of servers) {
-    if (config3.extensions.includes(ext)) {
-      const server = {
-        id: config3.id,
-        command: config3.command,
-        extensions: config3.extensions,
-        root: config3.root,
-        env: config3.env,
-        initialization: config3.initialization
-      };
-      if (isServerInstalled(config3.command)) {
-        return { status: "found", server };
-      }
-      return {
+function getServerWorkspace(config3, filePath) {
+  if (!filePath) {
+    return;
+  }
+  if (!config3.root) {
+    return dirname6(resolve2(filePath));
+  }
+  return config3.root(filePath);
+}
+function shouldSkipServer(config3, filePath) {
+  if (!filePath) {
+    return false;
+  }
+  return config3.id === "deno" && getServerWorkspace(config3, filePath) === undefined;
+}
+function toResolvedServer(config3, command) {
+  return {
+    id: config3.id,
+    command: command ?? config3.command,
+    extensions: config3.extensions,
+    root: config3.root,
+    env: config3.env,
+    initialization: config3.initialization
+  };
+}
+function findInstalledServer(configs, filePath) {
+  let firstNotInstalled = null;
+  for (const config3 of configs) {
+    const workspace = getServerWorkspace(config3, filePath);
+    const resolvedCommand = resolveServerCommand(config3.command, workspace ?? (filePath ? dirname6(resolve2(filePath)) : undefined));
+    const server = toResolvedServer(config3, resolvedCommand ?? undefined);
+    log(`[LSP] Considering server for ${config3.extensions.join(", ")}: ${config3.id} with command ${config3.command.join(" ")}`);
+    if (resolvedCommand) {
+      return { status: "found", server };
+    }
+    if (!firstNotInstalled) {
+      log(`[LSP] Server ${config3.id} not found in PATH or local node_modules`);
+      firstNotInstalled = {
         status: "not_installed",
         server,
         installHint: LSP_INSTALL_HINTS[config3.id] || `Install '${config3.command[0]}' and add to PATH`
       };
     }
   }
+  return firstNotInstalled ?? undefined;
+}
+function findServerForExtension(ext, filePath) {
+  const servers = [...buildMergedServers().values()].filter((config3) => config3.extensions.includes(ext));
+  if (servers.length === 0) {
+    log(`[LSP] No server config found for ${ext}`);
+    return { status: "not_configured", extension: ext };
+  }
+  const candidateServers = servers.filter((config3) => !shouldSkipServer(config3, filePath));
+  if (candidateServers.length === 0) {
+    log(`[LSP] No applicable server config found for ${ext} at ${filePath}`);
+    return { status: "not_configured", extension: ext };
+  }
+  const result = findInstalledServer(candidateServers, filePath);
+  if (result) {
+    return result;
+  }
+  log(`[LSP] No applicable server config found for ${ext}`);
   return { status: "not_configured", extension: ext };
 }
 function getLanguageId(ext) {
   return LANGUAGE_EXTENSIONS[ext] || "plaintext";
 }
-function isServerInstalled(command) {
+function resolveServerCommand(command, cwd) {
   if (command.length === 0)
-    return false;
-  const cmd = command[0];
+    return null;
+  const [cmd, ...args] = command;
   if (cmd.includes("/") || cmd.includes("\\")) {
-    return existsSync8(cmd);
+    return existsSync8(cmd) ? command : null;
   }
   const isWindows = process.platform === "win32";
   const ext = isWindows ? ".exe" : "";
@@ -34151,17 +34648,94 @@ function isServerInstalled(command) {
     nothrow: true
   });
   if (result !== null) {
-    return true;
+    return [result, ...args];
   }
-  const cwd = process.cwd();
-  const localBin = join9(cwd, "node_modules", ".bin", cmd);
-  if (existsSync8(localBin) || existsSync8(localBin + ext)) {
-    return true;
+  const localBinRoot = cwd ?? process.cwd();
+  const localBin = join9(localBinRoot, "node_modules", ".bin", cmd);
+  if (existsSync8(localBin)) {
+    return [localBin, ...args];
   }
-  return false;
+  if (existsSync8(localBin + ext)) {
+    return [localBin + ext, ...args];
+  }
+  return null;
 }
 
 // src/tools/lsp/client.ts
+var START_TIMEOUT_MS = 5000;
+var REQUEST_TIMEOUT_MS = 5000;
+var OPEN_FILE_DELAY_MS = 250;
+var INITIALIZE_DELAY_MS = 100;
+var DIAGNOSTIC_SETTLE_DELAY_MS = 250;
+var LSP_TIMEOUTS = {
+  start: START_TIMEOUT_MS,
+  request: REQUEST_TIMEOUT_MS,
+  openFileDelay: OPEN_FILE_DELAY_MS,
+  initializeDelay: INITIALIZE_DELAY_MS,
+  diagnosticSettleDelay: DIAGNOSTIC_SETTLE_DELAY_MS
+};
+function getDiagnosticsCapabilitySummary({
+  diagnosticProvider,
+  publishDiagnosticsObserved = false,
+  workspaceConfigurationRequested = false
+}) {
+  const pull = Boolean(diagnosticProvider);
+  const workspaceDiagnostics = Boolean(diagnosticProvider?.workspaceDiagnostics);
+  const interFileDependencies = Boolean(diagnosticProvider?.interFileDependencies);
+  const availableModes = [
+    ...pull ? ["pull", "pull/full", "pull/unchanged"] : ["push"],
+    ...workspaceDiagnostics ? ["workspace-pull"] : [],
+    ...publishDiagnosticsObserved ? ["push"] : []
+  ];
+  return {
+    availableModes: Array.from(new Set(availableModes)),
+    preferredMode: pull ? "pull" : "push",
+    inferredTransport: pull && publishDiagnosticsObserved ? "hybrid" : pull ? "pull" : "push",
+    pull,
+    pushObserved: publishDiagnosticsObserved,
+    pullResultTracking: pull,
+    workspaceDiagnostics,
+    interFileDependencies,
+    workspaceConfiguration: workspaceConfigurationRequested
+  };
+}
+function withTimeout(promise3, ms, label, onTimeout) {
+  return new Promise((resolve4, reject) => {
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      Promise.resolve(onTimeout?.()).catch(() => {});
+      reject(new Error(`${label} timeout after ${ms}ms`));
+    }, ms);
+    promise3.then((value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      resolve4(value);
+    }, (error92) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      reject(error92);
+    });
+  });
+}
+function getWorkspaceConfiguration(items) {
+  return items.map((item) => {
+    if (item?.section === "json") {
+      return { validate: { enable: true } };
+    }
+    return null;
+  });
+}
+
 class LSPServerManager {
   static instance;
   clients = new Map;
@@ -34326,17 +34900,27 @@ class LSPClient {
   stderrBuffer = [];
   processExited = false;
   diagnosticsStore = new Map;
+  diagnosticResultIds = new Map;
+  documents = new Map;
+  diagnosticProvider = null;
+  publishDiagnosticsObserved = false;
+  supportsPullDiagnostics = false;
+  workspaceConfigurationRequested = false;
   constructor(root, server) {
     this.root = root;
     this.server = server;
   }
   async start() {
+    const command = resolveServerCommand(this.server.command, this.root);
+    if (!command) {
+      throw new Error(`Failed to resolve LSP server command: ${this.server.command.join(" ")}`);
+    }
     log("[lsp] LSPClient.start: spawning server", {
       server: this.server.id,
-      command: this.server.command.join(" "),
+      command: command.join(" "),
       root: this.root
     });
-    this.proc = spawn4(this.server.command, {
+    this.proc = spawn5(command, {
       stdin: "pipe",
       stdout: "pipe",
       stderr: "pipe",
@@ -34386,18 +34970,35 @@ class LSPClient {
     });
     this.connection = import_node.createMessageConnection(new import_node.StreamMessageReader(nodeReadable), new import_node.StreamMessageWriter(nodeWritable));
     this.connection.onNotification("textDocument/publishDiagnostics", (params) => {
+      if (!this.publishDiagnosticsObserved) {
+        this.publishDiagnosticsObserved = true;
+        log("[lsp] diagnostics capabilities: publishDiagnostics observed", {
+          server: this.server.id,
+          ...getDiagnosticsCapabilitySummary({
+            diagnosticProvider: this.diagnosticProvider,
+            publishDiagnosticsObserved: this.publishDiagnosticsObserved,
+            workspaceConfigurationRequested: this.workspaceConfigurationRequested
+          })
+        });
+      }
       if (params.uri) {
         this.diagnosticsStore.set(params.uri, params.diagnostics ?? []);
       }
     });
     this.connection.onRequest("workspace/configuration", (params) => {
-      const items = params.items ?? [];
-      return items.map((item) => {
-        const configItem = item;
-        if (configItem.section === "json")
-          return { validate: { enable: true } };
-        return {};
-      });
+      if (!this.workspaceConfigurationRequested) {
+        this.workspaceConfigurationRequested = true;
+        log("[lsp] diagnostics capabilities: workspace configuration requested", {
+          server: this.server.id,
+          sections: (params.items ?? []).map((item) => item && typeof item === "object" && ("section" in item) ? item.section ?? null : null),
+          ...getDiagnosticsCapabilitySummary({
+            diagnosticProvider: this.diagnosticProvider,
+            publishDiagnosticsObserved: this.publishDiagnosticsObserved,
+            workspaceConfigurationRequested: this.workspaceConfigurationRequested
+          })
+        });
+      }
+      return getWorkspaceConfiguration(params.items ?? []);
     });
     this.connection.onRequest("client/registerCapability", () => null);
     this.connection.onRequest("window/workDoneProgress/create", () => null);
@@ -34405,7 +35006,7 @@ class LSPClient {
       this.processExited = true;
     });
     this.connection.listen();
-    await new Promise((resolve3) => setTimeout(resolve3, 100));
+    await new Promise((resolve4) => setTimeout(resolve4, 100));
     if (this.proc.exitCode !== null) {
       const stderr = this.stderrBuffer.join(`
 `);
@@ -34448,13 +35049,14 @@ stderr: ${stderr}` : ""));
       root: this.root
     });
     const rootUri = pathToFileURL(this.root).href;
-    await this.connection.sendRequest("initialize", {
+    const result = await withTimeout(this.connection.sendRequest("initialize", {
       processId: process.pid,
       rootUri,
       rootPath: this.root,
       workspaceFolders: [{ uri: rootUri, name: "workspace" }],
       capabilities: {
         textDocument: {
+          diagnostic: {},
           hover: { contentFormat: ["markdown", "plaintext"] },
           definition: { linkSupport: true },
           references: {},
@@ -34475,76 +35077,163 @@ stderr: ${stderr}` : ""));
         }
       },
       ...this.server.initialization
+    }), LSP_TIMEOUTS.request, `LSP initialize (${this.server.id})`);
+    const capabilities = result && typeof result === "object" && "capabilities" in result && result.capabilities && typeof result.capabilities === "object" ? result.capabilities : undefined;
+    this.diagnosticProvider = capabilities && "diagnosticProvider" in capabilities ? capabilities.diagnosticProvider : null;
+    this.supportsPullDiagnostics = Boolean(this.diagnosticProvider);
+    log("[lsp] diagnostics capabilities negotiated", {
+      server: this.server.id,
+      diagnosticProvider: this.diagnosticProvider,
+      ...getDiagnosticsCapabilitySummary({
+        diagnosticProvider: this.diagnosticProvider,
+        publishDiagnosticsObserved: this.publishDiagnosticsObserved,
+        workspaceConfigurationRequested: this.workspaceConfigurationRequested
+      })
     });
-    this.connection.sendNotification("initialized");
-    await new Promise((r) => setTimeout(r, 300));
+    this.connection.sendNotification("initialized", {});
+    await new Promise((r) => setTimeout(r, LSP_TIMEOUTS.initializeDelay));
     log("[lsp] LSPClient.initialize: complete", { server: this.server.id });
   }
-  async openFile(filePath) {
-    const absPath = resolve2(filePath);
-    if (this.openedFiles.has(absPath)) {
-      log("[lsp] openFile: already open, skipping", { filePath: absPath });
-      return;
+  async waitForPublishedDiagnostics(uri, timeoutMs = LSP_TIMEOUTS.request) {
+    const cachedDiagnostics = this.diagnosticsStore.get(uri);
+    if (cachedDiagnostics) {
+      return cachedDiagnostics;
+    }
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+      await new Promise((r) => setTimeout(r, 100));
+      const diagnostics = this.diagnosticsStore.get(uri);
+      if (diagnostics) {
+        return diagnostics;
+      }
     }
+    return this.diagnosticsStore.get(uri);
+  }
+  async openFile(filePath) {
+    await this.ensureDocumentSynced(filePath);
+  }
+  async ensureDocumentSynced(filePath) {
+    const absPath = resolve3(filePath);
+    const uri = pathToFileURL(absPath).href;
     const text = readFileSync4(absPath, "utf-8");
     const ext = extname(absPath);
     const languageId = getLanguageId(ext);
-    log("[lsp] openFile: opening document", {
-      filePath: absPath,
-      languageId,
-      size: text.length
-    });
-    this.connection?.sendNotification("textDocument/didOpen", {
-      textDocument: {
-        uri: pathToFileURL(absPath).href,
+    const existing = this.documents.get(uri);
+    if (!existing) {
+      log("[lsp] ensureDocumentSynced: didOpen", {
+        filePath: absPath,
         languageId,
-        version: 1,
-        text
-      }
-    });
-    this.openedFiles.add(absPath);
-    await new Promise((r) => setTimeout(r, 1000));
+        size: text.length
+      });
+      this.connection?.sendNotification("textDocument/didOpen", {
+        textDocument: { uri, languageId, version: 1, text }
+      });
+      this.documents.set(uri, { version: 1, text, languageId });
+      this.openedFiles.add(absPath);
+      await new Promise((r) => setTimeout(r, LSP_TIMEOUTS.openFileDelay));
+      return;
+    }
+    if (existing.text !== text) {
+      const newVersion = existing.version + 1;
+      log("[lsp] ensureDocumentSynced: didChange", {
+        filePath: absPath,
+        languageId,
+        oldVersion: existing.version,
+        newVersion,
+        size: text.length
+      });
+      this.connection?.sendNotification("textDocument/didChange", {
+        textDocument: { uri, version: newVersion },
+        contentChanges: [{ text }]
+      });
+      this.documents.set(uri, { version: newVersion, text, languageId });
+      this.diagnosticsStore.delete(uri);
+      this.diagnosticResultIds.delete(uri);
+      await new Promise((r) => setTimeout(r, LSP_TIMEOUTS.openFileDelay));
+    } else {
+      log("[lsp] ensureDocumentSynced: already synced", { filePath: absPath });
+    }
   }
   async definition(filePath, line, character) {
-    const absPath = resolve2(filePath);
+    const absPath = resolve3(filePath);
     await this.openFile(absPath);
-    return this.connection?.sendRequest("textDocument/definition", {
+    return this.connection ? withTimeout(this.connection.sendRequest("textDocument/definition", {
       textDocument: { uri: pathToFileURL(absPath).href },
       position: { line: line - 1, character }
-    });
+    }), LSP_TIMEOUTS.request, `LSP definition (${this.server.id})`) : undefined;
   }
   async references(filePath, line, character, includeDeclaration = true) {
-    const absPath = resolve2(filePath);
+    const absPath = resolve3(filePath);
     await this.openFile(absPath);
-    return this.connection?.sendRequest("textDocument/references", {
+    return this.connection ? withTimeout(this.connection.sendRequest("textDocument/references", {
       textDocument: { uri: pathToFileURL(absPath).href },
       position: { line: line - 1, character },
       context: { includeDeclaration }
-    });
+    }), LSP_TIMEOUTS.request, `LSP references (${this.server.id})`) : undefined;
   }
   async diagnostics(filePath) {
-    const absPath = resolve2(filePath);
+    const absPath = resolve3(filePath);
     const uri = pathToFileURL(absPath).href;
     await this.openFile(absPath);
-    await new Promise((r) => setTimeout(r, 500));
-    try {
-      const result = await this.connection?.sendRequest("textDocument/diagnostic", {
-        textDocument: { uri }
-      });
-      if (result && typeof result === "object" && "items" in result) {
-        return result;
+    await new Promise((r) => setTimeout(r, LSP_TIMEOUTS.diagnosticSettleDelay));
+    log("[lsp] diagnostics mode selected", {
+      server: this.server.id,
+      filePath: absPath,
+      activeMode: this.supportsPullDiagnostics ? "pull" : "push",
+      ...getDiagnosticsCapabilitySummary({
+        diagnosticProvider: this.diagnosticProvider,
+        publishDiagnosticsObserved: this.publishDiagnosticsObserved,
+        workspaceConfigurationRequested: this.workspaceConfigurationRequested
+      })
+    });
+    if (this.supportsPullDiagnostics) {
+      try {
+        const result = this.connection ? await withTimeout(this.connection.sendRequest("textDocument/diagnostic", {
+          textDocument: { uri },
+          previousResultId: this.diagnosticResultIds.get(uri)
+        }), LSP_TIMEOUTS.request, `LSP diagnostics (${this.server.id})`) : undefined;
+        const report = result;
+        if (report?.kind === "full") {
+          if (report.resultId) {
+            this.diagnosticResultIds.set(uri, report.resultId);
+          } else {
+            this.diagnosticResultIds.delete(uri);
+          }
+          this.diagnosticsStore.set(uri, report.items);
+          return { items: report.items };
+        }
+        if (report?.kind === "unchanged") {
+          if (report.resultId) {
+            this.diagnosticResultIds.set(uri, report.resultId);
+          }
+          return { items: this.diagnosticsStore.get(uri) ?? [] };
+        }
+        if (result && typeof result === "object" && "items" in result) {
+          const legacyResult = result;
+          this.diagnosticsStore.set(uri, legacyResult.items);
+          return legacyResult;
+        }
+      } catch (error92) {
+        log("[lsp] diagnostics: falling back to cached publishDiagnostics", {
+          server: this.server.id,
+          error: String(error92)
+        });
       }
-    } catch {}
-    return { items: this.diagnosticsStore.get(uri) ?? [] };
+    }
+    const cachedDiagnostics = await this.waitForPublishedDiagnostics(uri);
+    if (cachedDiagnostics) {
+      return { items: cachedDiagnostics };
+    }
+    throw new Error(`Unable to retrieve diagnostics from ${this.server.id}: request timed out or is unsupported.`);
   }
   async rename(filePath, line, character, newName) {
-    const absPath = resolve2(filePath);
+    const absPath = resolve3(filePath);
     await this.openFile(absPath);
-    return this.connection?.sendRequest("textDocument/rename", {
+    return this.connection ? withTimeout(this.connection.sendRequest("textDocument/rename", {
       textDocument: { uri: pathToFileURL(absPath).href },
       position: { line: line - 1, character },
       newName
-    });
+    }), LSP_TIMEOUTS.request, `LSP rename (${this.server.id})`) : undefined;
   }
   isAlive() {
     return this.proc !== null && !this.processExited && this.proc.exitCode === null;
@@ -34553,7 +35242,7 @@ stderr: ${stderr}` : ""));
     log("[lsp] LSPClient.stop: stopping", { server: this.server.id });
     try {
       if (this.connection) {
-        await this.connection.sendRequest("shutdown");
+        await withTimeout(this.connection.sendRequest("shutdown"), 1000, `LSP shutdown (${this.server.id})`);
         this.connection.sendNotification("exit");
         this.connection.dispose();
       }
@@ -34562,7 +35251,13 @@ stderr: ${stderr}` : ""));
     this.proc = null;
     this.connection = null;
     this.processExited = true;
+    this.diagnosticProvider = null;
+    this.publishDiagnosticsObserved = false;
+    this.supportsPullDiagnostics = false;
+    this.workspaceConfigurationRequested = false;
     this.diagnosticsStore.clear();
+    this.diagnosticResultIds.clear();
+    this.documents.clear();
     log("[lsp] LSPClient.stop: complete", { server: this.server.id });
   }
 }
@@ -34574,13 +35269,13 @@ import {
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync3
 } from "fs";
-import { dirname as dirname5, extname as extname2, join as join10, resolve as resolve3 } from "path";
+import { dirname as dirname7, extname as extname2, join as join10, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function findServerProjectRoot(filePath, server) {
   if (server.root) {
-    return server.root(filePath) ?? dirname5(resolve3(filePath));
+    return server.root(filePath) ?? dirname7(resolve4(filePath));
   }
-  return dirname5(resolve3(filePath));
+  return dirname7(resolve4(filePath));
 }
 function uriToPath(uri) {
   return fileURLToPath2(uri);
@@ -34599,9 +35294,9 @@ function formatServerLookupError(result) {
   return `No LSP server configured for extension: ${result.extension}`;
 }
 async function withLspClient(filePath, fn) {
-  const absPath = resolve3(filePath);
+  const absPath = resolve4(filePath);
   const ext = extname2(absPath);
-  const result = findServerForExtension(ext);
+  const result = findServerForExtension(ext, absPath);
   if (result.status !== "found") {
     log("[lsp] withLspClient: server not found", {
       filePath: absPath,
@@ -34610,7 +35305,14 @@ async function withLspClient(filePath, fn) {
     throw new Error(formatServerLookupError(result));
   }
   const server = result.server;
-  const root = findServerProjectRoot(absPath, server) ?? dirname5(absPath);
+  const root = findServerProjectRoot(absPath, server) ?? dirname7(absPath);
+  log("[lsp] withLspClient: selected server", {
+    filePath: absPath,
+    extension: ext,
+    server: server.id,
+    command: server.command.join(" "),
+    root
+  });
   log("[lsp] withLspClient: acquiring client", {
     filePath: absPath,
     server: server.id,
@@ -34970,29 +35672,32 @@ var OhMyOpenCodeLite = async (ctx) => {
       runtimeChains[agentName] = existing;
     }
   }
-  const tmuxConfig = {
-    enabled: config3.tmux?.enabled ?? false,
-    layout: config3.tmux?.layout ?? "main-vertical",
-    main_pane_size: config3.tmux?.main_pane_size ?? 60
+  const multiplexerConfig = {
+    type: config3.multiplexer?.type ?? "none",
+    layout: config3.multiplexer?.layout ?? "main-vertical",
+    main_pane_size: config3.multiplexer?.main_pane_size ?? 60
   };
-  log("[plugin] initialized with tmux config", {
-    tmuxConfig,
-    rawTmuxConfig: config3.tmux,
+  const multiplexer = getMultiplexer(multiplexerConfig);
+  const multiplexerEnabled = multiplexerConfig.type !== "none" && multiplexer !== null;
+  log("[plugin] initialized with multiplexer config", {
+    multiplexerConfig,
+    enabled: multiplexerEnabled,
     directory: ctx.directory
   });
-  if (tmuxConfig.enabled) {
-    startTmuxCheck();
+  if (multiplexerEnabled) {
+    startAvailabilityCheck(multiplexerConfig);
   }
-  const backgroundManager = new BackgroundTaskManager(ctx, tmuxConfig, config3);
-  const backgroundTools = createBackgroundTools(ctx, backgroundManager, tmuxConfig, config3);
-  const councilTools = config3.council ? createCouncilTool(ctx, new CouncilManager(ctx, config3, backgroundManager.getDepthTracker(), tmuxConfig.enabled)) : {};
-  const mcps = createBuiltinMcps(config3.disabled_mcps);
-  const tmuxSessionManager = new TmuxSessionManager(ctx, tmuxConfig);
+  const backgroundManager = new BackgroundTaskManager(ctx, multiplexerConfig, config3);
+  const backgroundTools = createBackgroundTools(ctx, backgroundManager, multiplexerConfig, config3);
+  const councilTools = config3.council ? createCouncilTool(ctx, new CouncilManager(ctx, config3, backgroundManager.getDepthTracker(), multiplexerEnabled)) : {};
+  const mcps = createBuiltinMcps(config3.disabled_mcps, config3.websearch);
+  const multiplexerSessionManager = new MultiplexerSessionManager(ctx, multiplexerConfig);
   const autoUpdateChecker = createAutoUpdateCheckerHook(ctx, {
     showStartupToast: true,
     autoUpdate: true
   });
   const phaseReminderHook = createPhaseReminderHook();
+  const filterAvailableSkillsHook = createFilterAvailableSkillsHook(ctx, config3);
   const postFileToolNudgeHook = createPostFileToolNudgeHook();
   const chatHeadersHook = createChatHeadersHook(ctx);
   const delegateTaskRetryHook = createDelegateTaskRetryHook(ctx);
@@ -35083,7 +35788,8 @@ var OhMyOpenCodeLite = async (ctx) => {
       } else {
         Object.assign(configMcp, mcps);
       }
-      const allMcpNames = Object.keys(mcps);
+      const mergedMcpConfig = opencodeConfig.mcp;
+      const allMcpNames = Object.keys(mergedMcpConfig ?? mcps);
       for (const [agentName, agentConfig] of Object.entries(agents)) {
         const agentMcps = agentConfig?.mcps;
         if (!agentMcps)
@@ -35108,14 +35814,18 @@ var OhMyOpenCodeLite = async (ctx) => {
     event: async (input) => {
       await foregroundFallback.handleEvent(input.event);
       await autoUpdateChecker.event(input);
-      await tmuxSessionManager.onSessionCreated(input.event);
+      await multiplexerSessionManager.onSessionCreated(input.event);
       await backgroundManager.handleSessionStatus(input.event);
-      await tmuxSessionManager.onSessionStatus(input.event);
+      await multiplexerSessionManager.onSessionStatus(input.event);
       await backgroundManager.handleSessionDeleted(input.event);
-      await tmuxSessionManager.onSessionDeleted(input.event);
+      await multiplexerSessionManager.onSessionDeleted(input.event);
     },
     "chat.headers": chatHeadersHook["chat.headers"],
-    "experimental.chat.messages.transform": phaseReminderHook["experimental.chat.messages.transform"],
+    "experimental.chat.messages.transform": async (input, output) => {
+      const typedOutput = output;
+      await phaseReminderHook["experimental.chat.messages.transform"](input, typedOutput);
+      await filterAvailableSkillsHook["experimental.chat.messages.transform"](input, typedOutput);
+    },
     "tool.execute.after": async (input, output) => {
       await delegateTaskRetryHook["tool.execute.after"](input, output);
       await jsonErrorRecoveryHook["tool.execute.after"](input, output);