oh-my-opencode-slim 0.8.3 → 0.8.5

package/dist/index.js

@@ -3037,7 +3037,7 @@ var require_main = __commonJS((exports) => {
   var ril_1 = require_ril();
   ril_1.default.install();
   var path6 = __require("path");
-  var os4 = __require("os");
+  var os3 = __require("os");
   var crypto_1 = __require("crypto");
   var net_1 = __require("net");
   var api_1 = require_api();
@@ -3180,7 +3180,7 @@ var require_main = __commonJS((exports) => {
     if (XDG_RUNTIME_DIR) {
       result = path6.join(XDG_RUNTIME_DIR, `vscode-ipc-${randomSuffix}.sock`);
     } else {
-      result = path6.join(os4.tmpdir(), `vscode-${randomSuffix}.sock`);
+      result = path6.join(os3.tmpdir(), `vscode-${randomSuffix}.sock`);
     }
     const limit = safeIpcPathLengths.get(process.platform);
     if (limit !== undefined && result.length > limit) {
@@ -3277,6 +3277,242 @@ var require_main = __commonJS((exports) => {
   exports.createMessageConnection = createMessageConnection;
 });
 
+// node_modules/isexe/dist/commonjs/index.min.js
+var require_index_min = __commonJS((exports) => {
+  var a = (t, e) => () => (e || t((e = { exports: {} }).exports, e), e.exports);
+  var _ = a((i) => {
+    Object.defineProperty(i, "__esModule", { value: true });
+    i.sync = i.isexe = undefined;
+    var M = __require("fs"), x = __require("fs/promises"), q = async (t, e = {}) => {
+      let { ignoreErrors: r = false } = e;
+      try {
+        return d(await (0, x.stat)(t), e);
+      } catch (s) {
+        let n = s;
+        if (r || n.code === "EACCES")
+          return false;
+        throw n;
+      }
+    };
+    i.isexe = q;
+    var m = (t, e = {}) => {
+      let { ignoreErrors: r = false } = e;
+      try {
+        return d((0, M.statSync)(t), e);
+      } catch (s) {
+        let n = s;
+        if (r || n.code === "EACCES")
+          return false;
+        throw n;
+      }
+    };
+    i.sync = m;
+    var d = (t, e) => t.isFile() && A(t, e), A = (t, e) => {
+      let r = e.uid ?? process.getuid?.(), s = e.groups ?? process.getgroups?.() ?? [], n = e.gid ?? process.getgid?.() ?? s[0];
+      if (r === undefined || n === undefined)
+        throw new Error("cannot get uid or gid");
+      let u = new Set([n, ...s]), c = t.mode, S = t.uid, P = t.gid, f = parseInt("100", 8), l = parseInt("010", 8), j = parseInt("001", 8), C = f | l;
+      return !!(c & j || c & l && u.has(P) || c & f && S === r || c & C && r === 0);
+    };
+  });
+  var g = a((o) => {
+    Object.defineProperty(o, "__esModule", { value: true });
+    o.sync = o.isexe = undefined;
+    var T = __require("fs"), I = __require("fs/promises"), D = __require("path"), F = async (t, e = {}) => {
+      let { ignoreErrors: r = false } = e;
+      try {
+        return y(await (0, I.stat)(t), t, e);
+      } catch (s) {
+        let n = s;
+        if (r || n.code === "EACCES")
+          return false;
+        throw n;
+      }
+    };
+    o.isexe = F;
+    var L = (t, e = {}) => {
+      let { ignoreErrors: r = false } = e;
+      try {
+        return y((0, T.statSync)(t), t, e);
+      } catch (s) {
+        let n = s;
+        if (r || n.code === "EACCES")
+          return false;
+        throw n;
+      }
+    };
+    o.sync = L;
+    var B = (t, e) => {
+      let { pathExt: r = process.env.PATHEXT || "" } = e, s = r.split(D.delimiter);
+      if (s.indexOf("") !== -1)
+        return true;
+      for (let n of s) {
+        let u = n.toLowerCase(), c = t.substring(t.length - u.length).toLowerCase();
+        if (u && c === u)
+          return true;
+      }
+      return false;
+    }, y = (t, e, r) => t.isFile() && B(e, r);
+  });
+  var p = a((h) => {
+    Object.defineProperty(h, "__esModule", { value: true });
+  });
+  var v = exports && exports.__createBinding || (Object.create ? function(t, e, r, s) {
+    s === undefined && (s = r);
+    var n = Object.getOwnPropertyDescriptor(e, r);
+    (!n || ("get" in n ? !e.__esModule : n.writable || n.configurable)) && (n = { enumerable: true, get: function() {
+      return e[r];
+    } }), Object.defineProperty(t, s, n);
+  } : function(t, e, r, s) {
+    s === undefined && (s = r), t[s] = e[r];
+  });
+  var G = exports && exports.__setModuleDefault || (Object.create ? function(t, e) {
+    Object.defineProperty(t, "default", { enumerable: true, value: e });
+  } : function(t, e) {
+    t.default = e;
+  });
+  var w = exports && exports.__importStar || function() {
+    var t = function(e) {
+      return t = Object.getOwnPropertyNames || function(r) {
+        var s = [];
+        for (var n in r)
+          Object.prototype.hasOwnProperty.call(r, n) && (s[s.length] = n);
+        return s;
+      }, t(e);
+    };
+    return function(e) {
+      if (e && e.__esModule)
+        return e;
+      var r = {};
+      if (e != null)
+        for (var s = t(e), n = 0;n < s.length; n++)
+          s[n] !== "default" && v(r, e, s[n]);
+      return G(r, e), r;
+    };
+  }();
+  var X = exports && exports.__exportStar || function(t, e) {
+    for (var r in t)
+      r !== "default" && !Object.prototype.hasOwnProperty.call(e, r) && v(e, t, r);
+  };
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.sync = exports.isexe = exports.posix = exports.win32 = undefined;
+  var E = w(_());
+  exports.posix = E;
+  var O = w(g());
+  exports.win32 = O;
+  X(p(), exports);
+  var H = process.env._ISEXE_TEST_PLATFORM_ || process.platform;
+  var b = H === "win32" ? O : E;
+  exports.isexe = b.isexe;
+  exports.sync = b.sync;
+});
+
+// node_modules/which/lib/index.js
+var require_lib = __commonJS((exports, module) => {
+  var { isexe, sync: isexeSync } = require_index_min();
+  var { join: join9, delimiter, sep, posix } = __require("path");
+  var isWindows = process.platform === "win32";
+  var rSlash = new RegExp(`[${posix.sep}${sep === posix.sep ? "" : sep}]`.replace(/(\\)/g, "\\$1"));
+  var rRel = new RegExp(`^\\.${rSlash.source}`);
+  var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+  var getPathInfo = (cmd, {
+    path: optPath = process.env.PATH,
+    pathExt: optPathExt = process.env.PATHEXT,
+    delimiter: optDelimiter = delimiter
+  }) => {
+    const pathEnv = cmd.match(rSlash) ? [""] : [
+      ...isWindows ? [process.cwd()] : [],
+      ...(optPath || "").split(optDelimiter)
+    ];
+    if (isWindows) {
+      const pathExtExe = optPathExt || [".EXE", ".CMD", ".BAT", ".COM"].join(optDelimiter);
+      const pathExt = pathExtExe.split(optDelimiter).flatMap((item) => [item, item.toLowerCase()]);
+      if (cmd.includes(".") && pathExt[0] !== "") {
+        pathExt.unshift("");
+      }
+      return { pathEnv, pathExt, pathExtExe };
+    }
+    return { pathEnv, pathExt: [""] };
+  };
+  var getPathPart = (raw, cmd) => {
+    const pathPart = /^".*"$/.test(raw) ? raw.slice(1, -1) : raw;
+    const prefix = !pathPart && rRel.test(cmd) ? cmd.slice(0, 2) : "";
+    return prefix + join9(pathPart, cmd);
+  };
+  var which = async (cmd, opt = {}) => {
+    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+    const found = [];
+    for (const envPart of pathEnv) {
+      const p = getPathPart(envPart, cmd);
+      for (const ext of pathExt) {
+        const withExt = p + ext;
+        const is = await isexe(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+        if (is) {
+          if (!opt.all) {
+            return withExt;
+          }
+          found.push(withExt);
+        }
+      }
+    }
+    if (opt.all && found.length) {
+      return found;
+    }
+    if (opt.nothrow) {
+      return null;
+    }
+    throw getNotFoundError(cmd);
+  };
+  var whichSync = (cmd, opt = {}) => {
+    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+    const found = [];
+    for (const pathEnvPart of pathEnv) {
+      const p = getPathPart(pathEnvPart, cmd);
+      for (const ext of pathExt) {
+        const withExt = p + ext;
+        const is = isexeSync(withExt, { pathExt: pathExtExe, ignoreErrors: true });
+        if (is) {
+          if (!opt.all) {
+            return withExt;
+          }
+          found.push(withExt);
+        }
+      }
+    }
+    if (opt.all && found.length) {
+      return found;
+    }
+    if (opt.nothrow) {
+      return null;
+    }
+    throw getNotFoundError(cmd);
+  };
+  module.exports = which;
+  which.sync = whichSync;
+});
+
+// src/cli/paths.ts
+import { homedir } from "os";
+import { dirname, join } from "path";
+function getDefaultOpenCodeConfigDir() {
+  const userConfigDir = process.env.XDG_CONFIG_HOME ? process.env.XDG_CONFIG_HOME : join(homedir(), ".config");
+  return join(userConfigDir, "opencode");
+}
+function getCustomOpenCodeConfigDir() {
+  const configDir = process.env.OPENCODE_CONFIG_DIR?.trim();
+  return configDir || undefined;
+}
+function getConfigSearchDirs() {
+  const dirs = [getCustomOpenCodeConfigDir(), getDefaultOpenCodeConfigDir()];
+  return dirs.filter((dir, index) => {
+    return Boolean(dir) && dirs.indexOf(dir) === index;
+  });
+}
+function getOpenCodeConfigPaths() {
+  const configDir = getDefaultOpenCodeConfigDir();
+  return [join(configDir, "opencode.json"), join(configDir, "opencode.jsonc")];
+}
+
 // src/cli/custom-skills.ts
 var CUSTOM_SKILLS = [
   {
@@ -3363,86 +3599,53 @@ var SUBAGENT_NAMES = [
   "librarian",
   "oracle",
   "designer",
-  "fixer"
+  "fixer",
+  "council",
+  "councillor",
+  "council-master"
 ];
 var ORCHESTRATOR_NAME = "orchestrator";
 var ALL_AGENT_NAMES = [ORCHESTRATOR_NAME, ...SUBAGENT_NAMES];
+var ORCHESTRATABLE_AGENTS = [
+  "explorer",
+  "librarian",
+  "oracle",
+  "designer",
+  "fixer",
+  "council"
+];
 var SUBAGENT_DELEGATION_RULES = {
-  orchestrator: SUBAGENT_NAMES,
+  orchestrator: ORCHESTRATABLE_AGENTS,
   fixer: [],
   designer: [],
   explorer: [],
   librarian: [],
-  oracle: []
+  oracle: [],
+  council: [],
+  councillor: [],
+  "council-master": []
 };
 var DEFAULT_MODELS = {
   orchestrator: undefined,
   oracle: "openai/gpt-5.4",
-  librarian: "openai/gpt-5-codex",
-  explorer: "openai/gpt-5-codex",
-  designer: "kimi-for-coding/k2p5",
-  fixer: "openai/gpt-5-codex"
+  librarian: "openai/gpt-5.4-mini",
+  explorer: "openai/gpt-5.4-mini",
+  designer: "openai/gpt-5.4-mini",
+  fixer: "openai/gpt-5.4-mini",
+  council: "openai/gpt-5.4-mini",
+  councillor: "openai/gpt-5.4-mini",
+  "council-master": "openai/gpt-5.4-mini"
 };
 var POLL_INTERVAL_BACKGROUND_MS = 2000;
 var DEFAULT_TIMEOUT_MS = 2 * 60 * 1000;
 var MAX_POLL_TIME_MS = 5 * 60 * 1000;
 var FALLBACK_FAILOVER_TIMEOUT_MS = 15000;
-// src/config/loader.ts
-import * as fs from "fs";
-import * as os from "os";
-import * as path from "path";
-
-// src/cli/paths.ts
-import { homedir } from "os";
-import { join } from "path";
-function getConfigDir() {
-  const userConfigDir = process.env.XDG_CONFIG_HOME ? process.env.XDG_CONFIG_HOME : join(homedir(), ".config");
-  return join(userConfigDir, "opencode");
-}
-function getOpenCodeConfigPaths() {
-  const configDir = getConfigDir();
-  return [join(configDir, "opencode.json"), join(configDir, "opencode.jsonc")];
-}
-
-// src/config/agent-mcps.ts
-var DEFAULT_AGENT_MCPS = {
-  orchestrator: ["websearch"],
-  designer: [],
-  oracle: [],
-  librarian: ["websearch", "context7", "grep_app"],
-  explorer: [],
-  fixer: []
-};
-function parseList(items, allAvailable) {
-  if (!items || items.length === 0) {
-    return [];
-  }
-  const allow = items.filter((i) => !i.startsWith("!"));
-  const deny = items.filter((i) => i.startsWith("!")).map((i) => i.slice(1));
-  if (deny.includes("*")) {
-    return [];
-  }
-  if (allow.includes("*")) {
-    return allAvailable.filter((item) => !deny.includes(item));
-  }
-  return allow.filter((item) => !deny.includes(item));
-}
-function getAgentMcpList(agentName, config) {
-  const agentConfig = getAgentOverride(config, agentName);
-  if (agentConfig?.mcps !== undefined) {
-    return agentConfig.mcps;
-  }
-  const defaultMcps = DEFAULT_AGENT_MCPS[agentName];
-  return defaultMcps ?? [];
-}
-
-// src/cli/config-io.ts
-function stripJsonComments(json) {
-  const commentPattern = /\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g;
-  const trailingCommaPattern = /\\"|"(?:\\"|[^"])*"|(,)(\s*[}\]])/g;
-  return json.replace(commentPattern, (match, commentGroup) => commentGroup ? "" : match).replace(trailingCommaPattern, (match, comma, closing) => comma ? closing : match);
-}
-
+var DEFAULT_MAX_SUBAGENT_DEPTH = 3;
+var PHASE_REMINDER_TEXT = `Recall Workflow Rules:
+Understand \u2192 build the best path (delegated based on Agent rules, split and parallelized as much as possible) \u2192 execute \u2192 verify.
+If delegating, launch the specialist in the same turn you mention it.`;
+var TMUX_SPAWN_DELAY_MS = 500;
+var COUNCILLOR_STAGGER_MS = 250;
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -5682,7 +5885,7 @@ class Doc {
 var version = {
   major: 4,
   minor: 3,
-  patch: 5
+  patch: 6
 };
 
 // node_modules/zod/v4/core/schemas.js
@@ -6968,7 +7171,7 @@ var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
         if (keyResult instanceof Promise) {
           throw new Error("Async schemas not supported in object keys currently");
         }
-        const checkNumericKey = typeof key === "string" && number.test(key) && keyResult.issues.length && keyResult.issues.some((iss) => iss.code === "invalid_type" && iss.expected === "number");
+        const checkNumericKey = typeof key === "string" && number.test(key) && keyResult.issues.length;
         if (checkNumericKey) {
           const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
           if (retryResult instanceof Promise) {
@@ -14339,7 +14542,7 @@ function finalize(ctx, schema) {
           }
         }
       }
-      if (refSchema.$ref) {
+      if (refSchema.$ref && refSeen.def) {
         for (const key in schema2) {
           if (key === "$ref" || key === "allOf")
             continue;
@@ -16975,6 +17178,107 @@ function date4(params) {
 
 // node_modules/zod/v4/classic/external.js
 config(en_default());
+// src/config/council-schema.ts
+var ModelIdSchema = exports_external.string().regex(/^[^/\s]+\/[^\s]+$/, 'Expected provider/model format (e.g. "openai/gpt-5.4-mini")');
+var CouncillorConfigSchema = exports_external.object({
+  model: ModelIdSchema.describe('Model ID in provider/model format (e.g. "openai/gpt-5.4-mini")'),
+  variant: exports_external.string().optional(),
+  prompt: exports_external.string().optional().describe("Optional role/guidance injected into the councillor user prompt")
+});
+var PresetMasterOverrideSchema = exports_external.object({
+  model: ModelIdSchema.optional().describe("Override the master model for this preset"),
+  variant: exports_external.string().optional().describe("Override the master variant for this preset"),
+  prompt: exports_external.string().optional().describe("Override the master synthesis guidance for this preset")
+});
+var CouncilPresetSchema = exports_external.record(exports_external.string(), exports_external.record(exports_external.string(), exports_external.unknown())).transform((entries, ctx) => {
+  const councillors = {};
+  let masterOverride;
+  for (const [key, raw] of Object.entries(entries)) {
+    if (key === "master") {
+      const parsed = PresetMasterOverrideSchema.safeParse(raw);
+      if (!parsed.success) {
+        ctx.addIssue(`Invalid master override in preset: ${parsed.error.issues.map((i) => i.message).join(", ")}`);
+        return exports_external.NEVER;
+      }
+      masterOverride = parsed.data;
+    } else {
+      const parsed = CouncillorConfigSchema.safeParse(raw);
+      if (!parsed.success) {
+        ctx.addIssue(`Invalid councillor "${key}": ${parsed.error.issues.map((i) => i.message).join(", ")}`);
+        return exports_external.NEVER;
+      }
+      councillors[key] = parsed.data;
+    }
+  }
+  return { councillors, master: masterOverride };
+});
+var CouncilMasterConfigSchema = exports_external.object({
+  model: ModelIdSchema.describe('Model ID for the council master (e.g. "anthropic/claude-opus-4-6")'),
+  variant: exports_external.string().optional(),
+  prompt: exports_external.string().optional().describe("Optional role/guidance injected into the master synthesis prompt")
+});
+var CouncilConfigSchema = exports_external.object({
+  master: CouncilMasterConfigSchema,
+  presets: exports_external.record(exports_external.string(), CouncilPresetSchema),
+  master_timeout: exports_external.number().min(0).default(300000),
+  councillors_timeout: exports_external.number().min(0).default(180000),
+  default_preset: exports_external.string().default("default"),
+  master_fallback: exports_external.array(ModelIdSchema).optional().transform((val) => {
+    if (!val)
+      return val;
+    const unique = [...new Set(val)];
+    if (unique.length !== val.length) {
+      return unique;
+    }
+    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"]')
+});
+// src/config/loader.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// src/config/agent-mcps.ts
+var DEFAULT_AGENT_MCPS = {
+  orchestrator: ["websearch"],
+  designer: [],
+  oracle: [],
+  librarian: ["websearch", "context7", "grep_app"],
+  explorer: [],
+  fixer: [],
+  council: [],
+  councillor: [],
+  "council-master": []
+};
+function parseList(items, allAvailable) {
+  if (!items || items.length === 0) {
+    return [];
+  }
+  const allow = items.filter((i) => !i.startsWith("!"));
+  const deny = items.filter((i) => i.startsWith("!")).map((i) => i.slice(1));
+  if (deny.includes("*")) {
+    return [];
+  }
+  if (allow.includes("*")) {
+    return allAvailable.filter((item) => !deny.includes(item));
+  }
+  return allow.filter((item) => !deny.includes(item));
+}
+function getAgentMcpList(agentName, config2) {
+  const agentConfig = getAgentOverride(config2, agentName);
+  if (agentConfig?.mcps !== undefined) {
+    return agentConfig.mcps;
+  }
+  const defaultMcps = DEFAULT_AGENT_MCPS[agentName];
+  return defaultMcps ?? [];
+}
+
+// src/cli/config-io.ts
+function stripJsonComments(json2) {
+  const commentPattern = /\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g;
+  const trailingCommaPattern = /\\"|"(?:\\"|[^"])*"|(,)(\s*[}\]])/g;
+  return json2.replace(commentPattern, (match, commentGroup) => commentGroup ? "" : match).replace(trailingCommaPattern, (match, comma, closing) => comma ? closing : match);
+}
+
 // src/config/schema.ts
 var ProviderModelIdSchema = exports_external.string().regex(/^[^/\s]+\/[^\s]+$/, "Expected provider/model format (provider/.../model)");
 var ManualAgentPlanSchema = exports_external.object({
@@ -17049,10 +17353,12 @@ var BackgroundTaskConfigSchema = exports_external.object({
 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({})
 });
 var PluginConfigSchema = exports_external.object({
   preset: exports_external.string().optional(),
+  setDefaultAgent: exports_external.boolean().optional(),
   scoringEngineVersion: exports_external.enum(["v1", "v2-shadow", "v2"]).optional(),
   balanceProviderUsage: exports_external.boolean().optional(),
   manualPlan: ManualPlanSchema.optional(),
@@ -17061,14 +17367,12 @@ var PluginConfigSchema = exports_external.object({
   disabled_mcps: exports_external.array(exports_external.string()).optional(),
   tmux: TmuxConfigSchema.optional(),
   background: BackgroundTaskConfigSchema.optional(),
-  fallback: FailoverConfigSchema.optional()
+  fallback: FailoverConfigSchema.optional(),
+  council: CouncilConfigSchema.optional()
 });
 
 // src/config/loader.ts
 var PROMPTS_DIR_NAME = "oh-my-opencode-slim";
-function getUserConfigDir() {
-  return process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config");
-}
 function loadConfigFromPath(configPath) {
   try {
     const content = fs.readFileSync(configPath, "utf-8");
@@ -17098,6 +17402,15 @@ function findConfigPath(basePath) {
   }
   return null;
 }
+function findConfigPathInDirs(configDirs, baseName) {
+  for (const configDir of configDirs) {
+    const configPath = findConfigPath(path.join(configDir, baseName));
+    if (configPath) {
+      return configPath;
+    }
+  }
+  return null;
+}
 function deepMerge(base, override) {
   if (!base)
     return override;
@@ -17116,9 +17429,8 @@ function deepMerge(base, override) {
   return result;
 }
 function loadPluginConfig(directory) {
-  const userConfigBasePath = path.join(getUserConfigDir(), "opencode", "oh-my-opencode-slim");
+  const userConfigPath = findConfigPathInDirs(getConfigSearchDirs(), "oh-my-opencode-slim");
   const projectConfigBasePath = path.join(directory, ".opencode", "oh-my-opencode-slim");
-  const userConfigPath = findConfigPath(userConfigBasePath);
   const projectConfigPath = findConfigPath(projectConfigBasePath);
   let config2 = userConfigPath ? loadConfigFromPath(userConfigPath) ?? {} : {};
   const projectConfig = projectConfigPath ? loadConfigFromPath(projectConfigPath) : null;
@@ -17149,8 +17461,10 @@ function loadPluginConfig(directory) {
 }
 function loadAgentPrompt(agentName, preset) {
   const presetDirName = preset && /^[a-zA-Z0-9_-]+$/.test(preset) ? preset : undefined;
-  const promptsDir = path.join(getUserConfigDir(), "opencode", PROMPTS_DIR_NAME);
-  const promptSearchDirs = presetDirName ? [path.join(promptsDir, presetDirName), promptsDir] : [promptsDir];
+  const promptSearchDirs = getConfigSearchDirs().flatMap((configDir) => {
+    const promptsDir = path.join(configDir, PROMPTS_DIR_NAME);
+    return presetDirName ? [path.join(promptsDir, presetDirName), promptsDir] : [promptsDir];
+  });
   const result = {};
   const readFirstPrompt = (fileName, errorPrefix) => {
     for (const dir of promptSearchDirs) {
@@ -17175,49 +17489,461 @@ function getAgentOverride(config2, name) {
   const overrides = config2?.agents ?? {};
   return overrides[name] ?? overrides[Object.keys(AGENT_ALIASES).find((k) => AGENT_ALIASES[k] === name) ?? ""];
 }
-// src/agents/designer.ts
-var DESIGNER_PROMPT = `You are a Designer - a frontend UI/UX specialist who creates intentional, polished experiences.
-
-**Role**: Craft cohesive UI/UX that balances visual impact with usability.
+// src/utils/session.ts
+function shortModelLabel(model) {
+  return model.split("/").pop() ?? model;
+}
+function parseModelReference(model) {
+  const slashIndex = model.indexOf("/");
+  if (slashIndex <= 0 || slashIndex >= model.length - 1) {
+    return null;
+  }
+  return {
+    providerID: model.slice(0, slashIndex),
+    modelID: model.slice(slashIndex + 1)
+  };
+}
+async function promptWithTimeout(client, args, timeoutMs) {
+  if (timeoutMs <= 0) {
+    await client.session.prompt(args);
+    return;
+  }
+  const sessionId = args.path.id;
+  let timer;
+  try {
+    const promptPromise = client.session.prompt(args);
+    promptPromise.catch(() => {});
+    await Promise.race([
+      promptPromise,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          client.session.abort({ path: { id: sessionId } }).catch(() => {});
+          reject(new Error(`Prompt timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function extractSessionResult(client, sessionId, options) {
+  const includeReasoning = options?.includeReasoning ?? true;
+  const messagesResult = await client.session.messages({
+    path: { id: sessionId }
+  });
+  const messages = messagesResult.data ?? [];
+  const assistantMessages = messages.filter((m) => m.info?.role === "assistant");
+  const extractedContent = [];
+  for (const message of assistantMessages) {
+    for (const part of message.parts ?? []) {
+      const allowed = includeReasoning ? part.type === "text" || part.type === "reasoning" : part.type === "text";
+      if (allowed && part.text) {
+        extractedContent.push(part.text);
+      }
+    }
+  }
+  return extractedContent.filter((t) => t.length > 0).join(`
 
-## Design Principles
+`);
+}
 
-**Typography**
-- Choose distinctive, characterful fonts that elevate aesthetics
-- Avoid generic defaults (Arial, Inter)\u2014opt for unexpected, beautiful choices
-- Pair display fonts with refined body fonts for hierarchy
+// src/agents/orchestrator.ts
+function resolvePrompt(base, customPrompt, customAppendPrompt) {
+  if (customPrompt)
+    return customPrompt;
+  if (customAppendPrompt)
+    return `${base}
 
-**Color & Theme**
-- Commit to a cohesive aesthetic with clear color variables
-- Dominant colors with sharp accents > timid, evenly-distributed palettes
-- Create atmosphere through intentional color relationships
+${customAppendPrompt}`;
+  return base;
+}
+var ORCHESTRATOR_PROMPT = `<Role>
+You are an AI coding orchestrator that optimizes for quality, speed, cost, and reliability by delegating to specialists when it provides net efficiency gains.
+</Role>
 
-**Motion & Interaction**
-- Leverage framework animation utilities when available (Tailwind's transition/animation classes)
-- Focus on high-impact moments: orchestrated page loads with staggered reveals
-- Use scroll-triggers and hover states that surprise and delight
-- One well-timed animation > scattered micro-interactions
-- Drop to custom CSS/JS only when utilities can't achieve the vision
+<Agents>
 
-**Spatial Composition**
-- Break conventions: asymmetry, overlap, diagonal flow, grid-breaking
-- Generous negative space OR controlled density\u2014commit to the choice
-- Unexpected layouts that guide the eye
+@explorer
+- Role: Parallel search specialist for discovering unknowns across the codebase
+- Stats: 3x faster codebase search than orchestrator, 1/2 cost of orchestrator
+- Capabilities: Glob, grep, AST queries to locate files, symbols, patterns
+- **Delegate when:** Need to discover what exists before planning \u2022 Parallel searches speed discovery \u2022 Need summarized map vs full contents \u2022 Broad/uncertain scope
+- **Don't delegate when:** Know the path and need actual content \u2022 Need full file anyway \u2022 Single specific lookup \u2022 About to edit the file
 
-**Visual Depth**
-- Create atmosphere beyond solid colors: gradient meshes, noise textures, geometric patterns
-- Layer transparencies, dramatic shadows, decorative borders
-- Contextual effects that match the aesthetic (grain overlays, custom cursors)
+@librarian
+- Role: Authoritative source for current library docs and API references
+- Stats: 10x better finding up-to-date library docs than orchestrator, 1/2 cost of orchestrator
+- Capabilities: Fetches latest official docs, examples, API signatures, version-specific behavior via grep_app MCP
+- **Delegate when:** Libraries with frequent API changes (React, Next.js, AI SDKs) \u2022 Complex APIs needing official examples (ORMs, auth) \u2022 Version-specific behavior matters \u2022 Unfamiliar library \u2022 Edge cases or advanced features \u2022 Nuanced best practices
+- **Don't delegate when:** Standard usage you're confident about (\`Array.map()\`, \`fetch()\`) \u2022 Simple stable APIs \u2022 General programming knowledge \u2022 Info already in conversation \u2022 Built-in language features
+- **Rule of thumb:** "How does this library work?" \u2192 @librarian. "How does programming work?" \u2192 yourself.
 
-**Styling Approach**
-- Default to Tailwind CSS utility classes when available\u2014fast, maintainable, consistent
-- Use custom CSS when the vision requires it: complex animations, unique effects, advanced compositions
-- Balance utility-first speed with creative freedom where it matters
+@oracle
+- Role: Strategic advisor for high-stakes decisions and persistent problems
+- Stats: 10x better decisions maker, problem solver, investigator than orchestrator, 0.8x speed of orchestrator, same cost.
+- Capabilities: Deep architectural reasoning, system-level trade-offs, complex debugging
+- Tools/Constraints: Slow, expensive, high-quality\u2014use sparingly when thoroughness beats speed
+- **Delegate when:** Major architectural decisions with long-term impact \u2022 Problems persisting after 2+ fix attempts \u2022 High-risk multi-system refactors \u2022 Costly trade-offs (performance vs maintainability) \u2022 Complex debugging with unclear root cause \u2022 Security/scalability/data integrity decisions \u2022 Genuinely uncertain and cost of wrong choice is high
+- **Don't delegate when:** Routine decisions you're confident about \u2022 First bug fix attempt \u2022 Straightforward trade-offs \u2022 Tactical "how" vs strategic "should" \u2022 Time-sensitive good-enough decisions \u2022 Quick research/testing can answer
+- **Rule of thumb:** Need senior architect review? \u2192 @oracle. Just do it and PR? \u2192 yourself.
 
-**Match Vision to Execution**
-- Maximalist designs \u2192 elaborate implementation, extensive animations, rich effects
-- Minimalist designs \u2192 restraint, precision, careful spacing and typography
-- Elegance comes from executing the chosen vision fully, not halfway
+@designer
+- Role: UI/UX specialist for intentional, polished experiences
+- Stats: 10x better UI/UX than orchestrator
+- Capabilities: Visual direction, interactions, responsive layouts, design systems with aesthetic intent
+- **Delegate when:** User-facing interfaces needing polish \u2022 Responsive layouts \u2022 UX-critical components (forms, nav, dashboards) \u2022 Visual consistency systems \u2022 Animations/micro-interactions \u2022 Landing/marketing pages \u2022 Refining functional\u2192delightful
+- **Don't delegate when:** Backend/logic with no visual \u2022 Quick prototypes where design doesn't matter yet
+- **Rule of thumb:** Users see it and polish matters? \u2192 @designer. Headless/functional? \u2192 yourself.
+
+@fixer
+- Role: Fast execution specialist for well-defined tasks, which empowers orchestrator with parallel, speedy executions
+- Stats: 2x faster code edits, 1/2 cost of orchestrator, 0.8x quality of orchestrator
+- Tools/Constraints: Execution-focused\u2014no research, no architectural decisions
+- **Delegate when:** For implementation work, think and triage first. If the change is non-trivial or multi-file, hand bounded execution to @fixer
+- **Don't delegate when:** Needs discovery/research/decisions \u2022 Single small change (<20 lines, one file) \u2022 Unclear requirements needing iteration \u2022 Explaining to fixer > doing \u2022 Tight integration with your current work \u2022 Sequential dependencies
+- **Rule of thumb:** Explaining > doing? \u2192 yourself. Orchestrator paths selection is vastly improved by Fixer. eg it can reduce overall speed if Orchestrator splits what's usually a single task into multiple subtasks and parallelize it with fixer.
+
+@council
+- Role: Multi-LLM consensus engine for high-confidence answers
+- Stats: 3x slower than orchestrator, 3x or more cost of orchestrator
+- Capabilities: Runs multiple models in parallel, synthesizes their responses via a council master
+- **Delegate when:** Critical decisions needing diverse model perspectives \u2022 High-stakes architectural choices where consensus reduces risk \u2022 Ambiguous problems where multi-model disagreement is informative \u2022 Security-sensitive design reviews
+- **Don't delegate when:** Straightforward tasks you're confident about \u2022 Speed matters more than confidence \u2022 Single-model answer is sufficient \u2022 Routine implementation work
+- **Result handling:** Present the council's synthesized response verbatim. Do not re-summarize \u2014 the council master has already produced the final answer.
+- **Rule of thumb:** Need second/third opinions from different models? \u2192 @council. One good answer enough? \u2192 yourself.
+
+</Agents>
+
+<Workflow>
+
+## 1. Understand
+Parse request: explicit requirements + implicit needs.
+
+## 2. Path Selection
+Evaluate approach by: quality, speed, cost, reliability.
+Choose the path that optimizes all four.
+
+## 3. Delegation Check
+**STOP. Review specialists before acting.**
+
+!!! Review available agents and delegation rules. Decide whether to delegate or do it yourself. !!!
+
+**Delegation efficiency:**
+- Reference paths/lines, don't paste files (\`src/app.ts:42\` not full contents)
+- Provide context summaries, let specialists read what they need
+- Brief user on delegation goal before each call
+- Skip delegation if overhead \u2265 doing it yourself
+
+## 4. Split and Parallelize
+Can tasks be split into subtasks and run in parallel?
+- Multiple @explorer searches across different domains?
+- @explorer + @librarian research in parallel?
+- Multiple @fixer instances for faster, scoped implementation?
+
+Balance: respect dependencies, avoid parallelizing what must be sequential.
+
+## 5. Execute
+1. Break complex tasks into todos
+2. Fire parallel research/implementation
+3. Delegate to specialists or do it yourself based on step 3
+4. Integrate results
+5. Adjust if needed
+
+## 6. Verify
+- Run \`lsp_diagnostics\` for errors
+- Suggest \`simplify\` skill when applicable
+- Confirm specialists completed successfully
+- Verify solution meets requirements
+
+</Workflow>
+
+<Communication>
+
+## Clarity Over Assumptions
+- If request is vague or has multiple valid interpretations, ask a targeted question before proceeding
+- Don't guess at critical details (file paths, API choices, architectural decisions)
+- Do make reasonable assumptions for minor details and state them briefly
+
+## Concise Execution
+- Answer directly, no preamble
+- Don't summarize what you did unless asked
+- Don't explain code unless asked
+- One-word answers are fine when appropriate
+- Brief delegation notices: "Checking docs via @librarian..." not "I'm going to delegate to @librarian because..."
+
+## No Flattery
+Never: "Great question!" "Excellent idea!" "Smart choice!" or any praise of user input.
+
+## Honest Pushback
+When user's approach seems problematic:
+- State concern + alternative concisely
+- Ask if they want to proceed anyway
+- Don't lecture, don't blindly implement
+
+## Example
+**Bad:** "Great question! Let me think about the best approach here. I'm going to delegate to @librarian to check the latest Next.js documentation for the App Router, and then I'll implement the solution for you."
+
+**Good:** "Checking Next.js App Router docs via @librarian..."
+[proceeds with implementation]
+
+</Communication>
+`;
+function createOrchestratorAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = resolvePrompt(ORCHESTRATOR_PROMPT, customPrompt, customAppendPrompt);
+  const definition = {
+    name: "orchestrator",
+    description: "AI coding orchestrator that delegates tasks to specialist agents for optimal quality, speed, and cost",
+    config: {
+      temperature: 0.1,
+      prompt
+    }
+  };
+  if (Array.isArray(model)) {
+    definition._modelArray = model.map((m) => typeof m === "string" ? { id: m } : m);
+  } else if (typeof model === "string" && model) {
+    definition.config.model = model;
+  }
+  return definition;
+}
+
+// src/agents/council.ts
+var COUNCIL_AGENT_PROMPT = `You are the Council agent \u2014 a multi-LLM orchestration system that runs consensus across multiple models.
+
+**Tool**: You have access to the \`council_session\` tool.
+
+**When to use**:
+- When invoked by a user with a request
+- When you want multiple expert opinions on a complex problem
+- When higher confidence is needed through model consensus
+
+**Usage**:
+1. Call the \`council_session\` tool with the user's prompt
+2. Optionally specify a preset (default: "default")
+3. Receive the synthesized response from the council master
+4. Present the result to the user
+
+**Behavior**:
+- Delegate requests directly to council_session
+- Don't pre-analyze or filter the prompt
+- Present the synthesized result verbatim \u2014 do not re-summarize or condense
+- Briefly explain the consensus if requested`;
+function createCouncilAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = resolvePrompt(COUNCIL_AGENT_PROMPT, customPrompt, customAppendPrompt);
+  const definition = {
+    name: "council",
+    description: "Multi-LLM council agent that synthesizes responses from multiple models for higher-quality outputs",
+    config: {
+      temperature: 0.1,
+      prompt
+    }
+  };
+  if (model) {
+    definition.config.model = model;
+  }
+  return definition;
+}
+function formatCouncillorPrompt(userPrompt, councillorPrompt) {
+  if (!councillorPrompt)
+    return userPrompt;
+  return `${councillorPrompt}
+
+---
+
+${userPrompt}`;
+}
+function formatMasterSynthesisPrompt(originalPrompt, councillorResults, masterPrompt) {
+  const completedWithResults = councillorResults.filter((cr) => cr.status === "completed" && cr.result);
+  const councillorSection = completedWithResults.map((cr) => {
+    const shortModel = shortModelLabel(cr.model);
+    return `**${cr.name}** (${shortModel}):
+${cr.result}`;
+  }).join(`
+
+`);
+  const failedSection = councillorResults.filter((cr) => cr.status !== "completed").map((cr) => `**${cr.name}**: ${cr.status} \u2014 ${cr.error ?? "Unknown"}`).join(`
+`);
+  if (completedWithResults.length === 0) {
+    return `---
+
+**Original Prompt**:
+${originalPrompt}
+
+---
+
+**Councillor Responses**:
+All councillors failed to produce output. Please generate a response based on the original prompt alone.`;
+  }
+  let prompt = `---
+
+**Original Prompt**:
+${originalPrompt}
+
+---
+
+**Councillor Responses**:
+${councillorSection}`;
+  if (failedSection) {
+    prompt += `
+
+---
+
+**Failed/Timed-out Councillors**:
+${failedSection}`;
+  }
+  prompt += `
+
+---
+
+Synthesize the optimal response based on the above.`;
+  if (masterPrompt) {
+    prompt += `
+
+---
+
+**Master Guidance**:
+${masterPrompt}`;
+  }
+  return prompt;
+}
+
+// src/agents/council-master.ts
+var COUNCIL_MASTER_PROMPT = `You are the council master responsible for synthesizing responses from multiple AI models.
+
+**Role**: Review all councillor responses and create the optimal final answer.
+
+**Process**:
+1. Read the original user prompt
+2. Review each councillor's response carefully
+3. Identify the best elements from each response
+4. Resolve contradictions between councillors
+5. Synthesize a final, optimal response
+
+**Behavior**:
+- Each councillor had read-only access to the codebase \u2014 their responses may   reference specific files, functions, and line numbers
+- Clearly explain your reasoning for the chosen approach
+- Be transparent about trade-offs
+- Credit specific insights from individual councillors by name
+- If councillors disagree, explain your resolution
+- Don't just average responses \u2014 choose and improve
+
+**Output**:
+- Present the synthesized solution
+- Review, retain, and include relevant code examples, diagrams, and concrete   details from councillor responses
+- Explain your synthesis reasoning
+- Note any remaining uncertainties
+- Acknowledge if consensus was impossible`;
+function createCouncilMasterAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = resolvePrompt(COUNCIL_MASTER_PROMPT, customPrompt, customAppendPrompt);
+  return {
+    name: "council-master",
+    description: "Council synthesis engine. Receives councillor responses and produces the final answer. No tools, pure text synthesis.",
+    config: {
+      model,
+      temperature: 0.1,
+      prompt,
+      permission: {
+        "*": "deny",
+        question: "deny"
+      }
+    }
+  };
+}
+
+// src/agents/councillor.ts
+var COUNCILLOR_PROMPT = `You are a councillor in a multi-model council.
+
+**Role**: Provide your best independent analysis and solution to the given problem.
+
+**Capabilities**: You have read-only access to the codebase. You can:
+- Read files (read)
+- Search by name patterns (glob)
+- Search by content (grep)
+- Query language server (lsp_diagnostics, lsp_goto_definition, lsp_find_references)
+- Search code patterns (ast_grep_search)
+- Search external docs (if MCPs are configured for this agent)
+
+You CANNOT edit files, write files, run shell commands, or delegate to other agents. You are an advisor, not an implementer.
+
+**Behavior**:
+- **Examine the codebase** before answering \u2014 your read access is what makes   council valuable. Don't guess at code you can see.
+- Analyze the problem thoroughly
+- Provide a complete, well-reasoned response
+- Focus on the quality and correctness of your solution
+- Be direct and concise
+- Don't be influenced by what other councillors might say \u2014 you won't see   their responses
+
+**Output**:
+- Give your honest assessment
+- Reference specific files and line numbers when relevant
+- Include relevant reasoning
+- State any assumptions clearly
+- Note any uncertainties`;
+function createCouncillorAgent(model, customPrompt, customAppendPrompt) {
+  const prompt = resolvePrompt(COUNCILLOR_PROMPT, customPrompt, customAppendPrompt);
+  return {
+    name: "councillor",
+    description: "Read-only council advisor. Examines codebase and provides independent analysis. Spawned internally by the council system.",
+    config: {
+      model,
+      temperature: 0.2,
+      prompt,
+      permission: {
+        "*": "deny",
+        question: "deny",
+        read: "allow",
+        glob: "allow",
+        grep: "allow",
+        lsp: "allow",
+        list: "allow",
+        codesearch: "allow"
+      }
+    }
+  };
+}
+
+// src/agents/designer.ts
+var DESIGNER_PROMPT = `You are a Designer - a frontend UI/UX specialist who creates intentional, polished experiences.
+
+**Role**: Craft cohesive UI/UX that balances visual impact with usability.
+
+## Design Principles
+
+**Typography**
+- Choose distinctive, characterful fonts that elevate aesthetics
+- Avoid generic defaults (Arial, Inter)\u2014opt for unexpected, beautiful choices
+- Pair display fonts with refined body fonts for hierarchy
+
+**Color & Theme**
+- Commit to a cohesive aesthetic with clear color variables
+- Dominant colors with sharp accents > timid, evenly-distributed palettes
+- Create atmosphere through intentional color relationships
+
+**Motion & Interaction**
+- Leverage framework animation utilities when available (Tailwind's transition/animation classes)
+- Focus on high-impact moments: orchestrated page loads with staggered reveals
+- Use scroll-triggers and hover states that surprise and delight
+- One well-timed animation > scattered micro-interactions
+- Drop to custom CSS/JS only when utilities can't achieve the vision
+
+**Spatial Composition**
+- Break conventions: asymmetry, overlap, diagonal flow, grid-breaking
+- Generous negative space OR controlled density\u2014commit to the choice
+- Unexpected layouts that guide the eye
+
+**Visual Depth**
+- Create atmosphere beyond solid colors: gradient meshes, noise textures, geometric patterns
+- Layer transparencies, dramatic shadows, decorative borders
+- Contextual effects that match the aesthetic (grain overlays, custom cursors)
+
+**Styling Approach**
+- Default to Tailwind CSS utility classes when available\u2014fast, maintainable, consistent
+- Use custom CSS when the vision requires it: complex animations, unique effects, advanced compositions
+- Balance utility-first speed with creative freedom where it matters
+
+**Match Vision to Execution**
+- Maximalist designs \u2192 elaborate implementation, extensive animations, rich effects
+- Minimalist designs \u2192 restraint, precision, careful spacing and typography
+- Elegance comes from executing the chosen vision fully, not halfway
 
 ## Constraints
 - Respect existing design systems when present
@@ -17251,19 +17977,9 @@ var EXPLORER_PROMPT = `You are Explorer - a fast codebase navigation specialist.
 
 **Role**: Quick contextual grep for codebases. Answer "Where is X?", "Find Y", "Which file has Z".
 
-**Tools Available**:
-- **grep**: Fast regex content search (powered by ripgrep). Use for text patterns, function names, strings.
-  Example: grep(pattern="function handleClick", include="*.ts")
-- **glob**: File pattern matching. Use to find files by name/extension.
-- **ast_grep_search**: AST-aware structural search (25 languages). Use for code patterns.
-  - Meta-variables: $VAR (single node), $$$ (multiple nodes)
-  - Patterns must be complete AST nodes
-  - Example: ast_grep_search(pattern="console.log($MSG)", lang="typescript")
-  - Example: ast_grep_search(pattern="async function $NAME($$$) { $$$ }", lang="javascript")
-
-**When to use which**:
+**When to use which tools**:
 - **Text/regex patterns** (strings, comments, variable names): grep
-- **Structural patterns** (function shapes, class structures): ast_grep_search  
+- **Structural patterns** (function shapes, class structures): ast_grep_search
 - **File discovery** (find by name/extension): glob
 
 **Behavior**:
@@ -17448,165 +18164,6 @@ ${customAppendPrompt}`;
   };
 }
 
-// src/agents/orchestrator.ts
-var ORCHESTRATOR_PROMPT = `<Role>
-You are an AI coding orchestrator that optimizes for quality, speed, cost, and reliability by delegating to specialists when it provides net efficiency gains.
-</Role>
-
-<Agents>
-
-@explorer
-- Role: Parallel search specialist for discovering unknowns across the codebase
-- Capabilities: Glob, grep, AST queries to locate files, symbols, patterns
-- **Delegate when:** Need to discover what exists before planning \u2022 Parallel searches speed discovery \u2022 Need summarized map vs full contents \u2022 Broad/uncertain scope
-- **Don't delegate when:** Know the path and need actual content \u2022 Need full file anyway \u2022 Single specific lookup \u2022 About to edit the file
-
-@librarian
-- Role: Authoritative source for current library docs and API references
-- Capabilities: Fetches latest official docs, examples, API signatures, version-specific behavior via grep_app MCP
-- **Delegate when:** Libraries with frequent API changes (React, Next.js, AI SDKs) \u2022 Complex APIs needing official examples (ORMs, auth) \u2022 Version-specific behavior matters \u2022 Unfamiliar library \u2022 Edge cases or advanced features \u2022 Nuanced best practices
-- **Don't delegate when:** Standard usage you're confident about (\`Array.map()\`, \`fetch()\`) \u2022 Simple stable APIs \u2022 General programming knowledge \u2022 Info already in conversation \u2022 Built-in language features
-- **Rule of thumb:** "How does this library work?" \u2192 @librarian. "How does programming work?" \u2192 yourself.
-
-@oracle
-- Role: Strategic advisor for high-stakes decisions and persistent problems
-- Capabilities: Deep architectural reasoning, system-level trade-offs, complex debugging
-- Tools/Constraints: Slow, expensive, high-quality\u2014use sparingly when thoroughness beats speed
-- **Delegate when:** Major architectural decisions with long-term impact \u2022 Problems persisting after 2+ fix attempts \u2022 High-risk multi-system refactors \u2022 Costly trade-offs (performance vs maintainability) \u2022 Complex debugging with unclear root cause \u2022 Security/scalability/data integrity decisions \u2022 Genuinely uncertain and cost of wrong choice is high
-- **Don't delegate when:** Routine decisions you're confident about \u2022 First bug fix attempt \u2022 Straightforward trade-offs \u2022 Tactical "how" vs strategic "should" \u2022 Time-sensitive good-enough decisions \u2022 Quick research/testing can answer
-- **Rule of thumb:** Need senior architect review? \u2192 @oracle. Just do it and PR? \u2192 yourself.
-
-@designer
-- Role: UI/UX specialist for intentional, polished experiences
-- Capabilities: Visual direction, interactions, responsive layouts, design systems with aesthetic intent
-- **Delegate when:** User-facing interfaces needing polish \u2022 Responsive layouts \u2022 UX-critical components (forms, nav, dashboards) \u2022 Visual consistency systems \u2022 Animations/micro-interactions \u2022 Landing/marketing pages \u2022 Refining functional\u2192delightful
-- **Don't delegate when:** Backend/logic with no visual \u2022 Quick prototypes where design doesn't matter yet
-- **Rule of thumb:** Users see it and polish matters? \u2192 @designer. Headless/functional? \u2192 yourself.
-
-@fixer
-- Role: Fast, parallel execution specialist for well-defined tasks
-- Capabilities: Efficient implementation when spec and context are clear
-- Tools/Constraints: Execution-focused\u2014no research, no architectural decisions
-- **Delegate when:** Clearly specified with known approach \u2022 3+ independent parallel tasks \u2022 Straightforward but time-consuming \u2022 Solid plan needing execution \u2022 Repetitive multi-location changes \u2022 Overhead < time saved by parallelization
-- **Don't delegate when:** Needs discovery/research/decisions \u2022 Single small change (<20 lines, one file) \u2022 Unclear requirements needing iteration \u2022 Explaining > doing \u2022 Tight integration with your current work \u2022 Sequential dependencies
-- **Parallelization:** 3+ independent tasks \u2192 spawn multiple @fixers. 1-2 simple tasks \u2192 do yourself.
-- **Rule of thumb:** Explaining > doing? \u2192 yourself. Can split to parallel streams? \u2192 multiple @fixers.
-
-</Agents>
-
-<Workflow>
-
-## 1. Understand
-Parse request: explicit requirements + implicit needs.
-
-## 2. Path Analysis
-Evaluate approach by: quality, speed, cost, reliability.
-Choose the path that optimizes all four.
-
-## 3. Delegation Check
-**STOP. Review specialists before acting.**
-
-Each specialist delivers 10x results in their domain:
-- @explorer \u2192 Parallel discovery when you need to find unknowns, not read knowns
-- @librarian \u2192 Complex/evolving APIs where docs prevent errors, not basic usage
-- @oracle \u2192 High-stakes decisions where wrong choice is costly, not routine calls
-- @designer \u2192 User-facing experiences where polish matters, not internal logic
-- @fixer \u2192 Parallel execution of clear specs, not explaining trivial changes
-
-**Delegation efficiency:**
-- Reference paths/lines, don't paste files (\`src/app.ts:42\` not full contents)
-- Provide context summaries, let specialists read what they need
-- Brief user on delegation goal before each call
-- Skip delegation if overhead \u2265 doing it yourself
-
-**Fixer parallelization:**
-- 3+ independent tasks? Spawn multiple @fixers simultaneously
-- 1-2 simple tasks? Do it yourself
-- Sequential dependencies? Handle serially or do yourself
-
-## 4. Parallelize
-Can tasks run simultaneously?
-- Multiple @explorer searches across different domains?
-- @explorer + @librarian research in parallel?
-- Multiple @fixer instances for independent changes?
-
-Balance: respect dependencies, avoid parallelizing what must be sequential.
-
-## 5. Execute
-1. Break complex tasks into todos if needed
-2. Fire parallel research/implementation
-3. Delegate to specialists or do it yourself based on step 3
-4. Integrate results
-5. Adjust if needed
-
-## 6. Verify
-- Run \`lsp_diagnostics\` for errors
-- Suggest \`simplify\` skill when applicable
-- Confirm specialists completed successfully
-- Verify solution meets requirements
-
-## Agent Role Mapping
-When a workflow calls for an **implementer** subagent: dispatch \`@fixer\`. Fixer has enforced constraints (no research, no delegation, structured output) that match the implementer role exactly.
-When a workflow calls for a **reviewer** subagent: dispatch \`@oracle\`. Oracle has the depth for architectural review and access to code review skills.
-
-</Workflow>
-
-<Communication>
-
-## Clarity Over Assumptions
-- If request is vague or has multiple valid interpretations, ask a targeted question before proceeding
-- Don't guess at critical details (file paths, API choices, architectural decisions)
-- Do make reasonable assumptions for minor details and state them briefly
-
-## Concise Execution
-- Answer directly, no preamble
-- Don't summarize what you did unless asked
-- Don't explain code unless asked
-- One-word answers are fine when appropriate
-- Brief delegation notices: "Checking docs via @librarian..." not "I'm going to delegate to @librarian because..."
-
-## No Flattery
-Never: "Great question!" "Excellent idea!" "Smart choice!" or any praise of user input.
-
-## Honest Pushback
-When user's approach seems problematic:
-- State concern + alternative concisely
-- Ask if they want to proceed anyway
-- Don't lecture, don't blindly implement
-
-## Example
-**Bad:** "Great question! Let me think about the best approach here. I'm going to delegate to @librarian to check the latest Next.js documentation for the App Router, and then I'll implement the solution for you."
-
-**Good:** "Checking Next.js App Router docs via @librarian..."
-[proceeds with implementation]
-
-</Communication>
-`;
-function createOrchestratorAgent(model, customPrompt, customAppendPrompt) {
-  let prompt = ORCHESTRATOR_PROMPT;
-  if (customPrompt) {
-    prompt = customPrompt;
-  } else if (customAppendPrompt) {
-    prompt = `${ORCHESTRATOR_PROMPT}
-
-${customAppendPrompt}`;
-  }
-  const definition = {
-    name: "orchestrator",
-    description: "AI coding orchestrator that delegates tasks to specialist agents for optimal quality, speed, and cost",
-    config: {
-      temperature: 0.1,
-      prompt
-    }
-  };
-  if (Array.isArray(model)) {
-    definition._modelArray = model.map((m) => typeof m === "string" ? { id: m } : m);
-  } else if (typeof model === "string" && model) {
-    definition.config.model = model;
-  }
-  return definition;
-}
-
 // src/agents/index.ts
 function applyOverrides(agent, override) {
   if (override.model) {
@@ -17625,9 +18182,10 @@ function applyOverrides(agent, override) {
 function applyDefaultPermissions(agent, configuredSkills) {
   const existing = agent.config.permission ?? {};
   const skillPermissions = getSkillPermissionsForAgent(agent.name, configuredSkills);
+  const questionPerm = existing.question === "deny" ? "deny" : "allow";
   agent.config.permission = {
     ...existing,
-    question: "allow",
+    question: questionPerm,
     skill: {
       ...typeof existing.skill === "object" ? existing.skill : {},
       ...skillPermissions
@@ -17642,7 +18200,10 @@ var SUBAGENT_FACTORIES = {
   librarian: createLibrarianAgent,
   oracle: createOracleAgent,
   designer: createDesignerAgent,
-  fixer: createFixerAgent
+  fixer: createFixerAgent,
+  council: createCouncilAgent,
+  councillor: createCouncillorAgent,
+  "council-master": createCouncilMasterAgent
 };
 function createAgents(config2) {
   const getModelForAgent = (name) => {
@@ -17689,7 +18250,12 @@ function getAgentConfigs(config2) {
       description: a.description,
       mcps: getAgentMcpList(a.name, config2)
     };
-    if (isSubagent(a.name)) {
+    if (a.name === "council") {
+      sdkConfig.mode = "all";
+    } else if (a.name === "councillor" || a.name === "council-master") {
+      sdkConfig.mode = "subagent";
+      sdkConfig.hidden = true;
+    } else if (isSubagent(a.name)) {
       sdkConfig.mode = "subagent";
     } else if (a.name === "orchestrator") {
       sdkConfig.mode = "primary";
@@ -17700,9 +18266,9 @@ function getAgentConfigs(config2) {
 
 // src/utils/logger.ts
 import * as fs2 from "fs";
-import * as os2 from "os";
+import * as os from "os";
 import * as path2 from "path";
-var logFile = path2.join(os2.tmpdir(), "oh-my-opencode-slim.log");
+var logFile = path2.join(os.tmpdir(), "oh-my-opencode-slim.log");
 function log(message, data) {
   try {
     const timestamp = new Date().toISOString();
@@ -18077,17 +18643,48 @@ async function extractZip(archivePath, destDir) {
     throw new Error(`zip extraction failed (exit ${exitCode}): ${stderr}`);
   }
 }
-// src/background/background-manager.ts
-function parseModelReference(model) {
-  const slashIndex = model.indexOf("/");
-  if (slashIndex <= 0 || slashIndex >= model.length - 1) {
-    return null;
+// src/background/subagent-depth.ts
+class SubagentDepthTracker {
+  depthBySession = new Map;
+  _maxDepth;
+  constructor(maxDepth = DEFAULT_MAX_SUBAGENT_DEPTH) {
+    this._maxDepth = maxDepth;
+  }
+  get maxDepth() {
+    return this._maxDepth;
+  }
+  getDepth(sessionId) {
+    return this.depthBySession.get(sessionId) ?? 0;
+  }
+  registerChild(parentSessionId, childSessionId) {
+    const parentDepth = this.getDepth(parentSessionId);
+    const childDepth = parentDepth + 1;
+    if (childDepth > this.maxDepth) {
+      log("[subagent-depth] spawn blocked: max depth exceeded", {
+        parentSessionId,
+        parentDepth,
+        childDepth,
+        maxDepth: this.maxDepth
+      });
+      return false;
+    }
+    this.depthBySession.set(childSessionId, childDepth);
+    log("[subagent-depth] child registered", {
+      parentSessionId,
+      childSessionId,
+      childDepth
+    });
+    return true;
+  }
+  cleanup(sessionId) {
+    this.depthBySession.delete(sessionId);
+  }
+  cleanupAll() {
+    this.depthBySession.clear();
   }
-  return {
-    providerID: model.slice(0, slashIndex),
-    modelID: model.slice(slashIndex + 1)
-  };
 }
+
+// src/background/background-manager.ts
 function generateTaskId() {
   return `bg_${Math.random().toString(36).substring(2, 10)}`;
 }
@@ -18096,6 +18693,7 @@ class BackgroundTaskManager {
   tasks = new Map;
   tasksBySessionId = new Map;
   agentBySessionId = new Map;
+  depthTracker;
   client;
   directory;
   tmuxEnabled;
@@ -18114,6 +18712,7 @@ class BackgroundTaskManager {
       maxConcurrentStarts: 10
     };
     this.maxConcurrentStarts = this.backgroundConfig.maxConcurrentStarts;
+    this.depthTracker = new SubagentDepthTracker;
   }
   getSubagentRules(agentName) {
     return SUBAGENT_DELEGATION_RULES[agentName] ?? ["explorer"];
@@ -18186,20 +18785,6 @@ class BackgroundTaskManager {
     }
     return chain;
   }
-  async promptWithTimeout(args, timeoutMs) {
-    if (timeoutMs <= 0) {
-      await this.client.session.prompt(args);
-      return;
-    }
-    await Promise.race([
-      this.client.session.prompt(args),
-      new Promise((_, reject) => {
-        setTimeout(() => {
-          reject(new Error(`Prompt timed out after ${timeoutMs}ms`));
-        }, timeoutMs);
-      })
-    ]);
-  }
   calculateToolPermissions(agentName) {
     const allowedSubagents = this.getSubagentRules(agentName);
     if (allowedSubagents.length === 0) {
@@ -18215,20 +18800,31 @@ class BackgroundTaskManager {
       return;
     }
     try {
-      const session = await this.client.session.create({
+      const parentDepth = this.depthTracker.getDepth(task.parentSessionId);
+      if (parentDepth + 1 > this.depthTracker.maxDepth) {
+        log("[background-manager] spawn blocked: max depth exceeded", {
+          parentSessionId: task.parentSessionId,
+          parentDepth,
+          maxDepth: this.depthTracker.maxDepth
+        });
+        this.completeTask(task, "failed", "Subagent depth exceeded");
+        return;
+      }
+      const session2 = await this.client.session.create({
         body: {
           parentID: task.parentSessionId,
           title: `Background: ${task.description}`
         },
         query: { directory: this.directory }
       });
-      if (!session.data?.id) {
+      if (!session2.data?.id) {
         throw new Error("Failed to create background session");
       }
-      task.sessionId = session.data.id;
-      this.tasksBySessionId.set(session.data.id, task.id);
-      this.agentBySessionId.set(session.data.id, task.agent);
+      task.sessionId = session2.data.id;
+      this.tasksBySessionId.set(session2.data.id, task.id);
+      this.agentBySessionId.set(session2.data.id, task.agent);
       task.status = "running";
+      this.depthTracker.registerChild(task.parentSessionId, session2.data.id);
       if (this.tmuxEnabled) {
         await new Promise((r) => setTimeout(r, 500));
       }
@@ -18242,11 +18838,15 @@ class BackgroundTaskManager {
       });
       const fallbackEnabled = this.config?.fallback?.enabled ?? true;
       const timeoutMs = fallbackEnabled ? this.config?.fallback?.timeoutMs ?? FALLBACK_FAILOVER_TIMEOUT_MS : 0;
+      const retryDelayMs = this.config?.fallback?.retryDelayMs ?? 500;
       const chain = fallbackEnabled ? this.resolveFallbackChain(task.agent) : [];
       const attemptModels = chain.length > 0 ? chain : [undefined];
       const errors3 = [];
       let succeeded = false;
-      for (const model of attemptModels) {
+      const sessionId = session2.data.id;
+      for (let i = 0;i < attemptModels.length; i++) {
+        const model = attemptModels[i];
+        const modelLabel = model ?? "default-model";
         try {
           const body = {
             ...basePromptBody,
@@ -18259,8 +18859,11 @@ class BackgroundTaskManager {
             }
             body.model = ref;
           }
-          await this.promptWithTimeout({
-            path: { id: session.data.id },
+          if (i > 0) {
+            log(`[background-manager] fallback attempt ${i + 1}/${attemptModels.length}: ${modelLabel}`, { taskId: task.id });
+          }
+          await promptWithTimeout(this.client, {
+            path: { id: sessionId },
             body,
             query: promptQuery
           }, timeoutMs);
@@ -18268,10 +18871,17 @@ class BackgroundTaskManager {
           break;
         } catch (error48) {
           const msg = error48 instanceof Error ? error48.message : String(error48);
-          if (model) {
-            errors3.push(`${model}: ${msg}`);
-          } else {
-            errors3.push(`default-model: ${msg}`);
+          errors3.push(`${modelLabel}: ${msg}`);
+          log(`[background-manager] model failed: ${modelLabel} \u2014 ${msg}`, {
+            taskId: task.id
+          });
+          if (i < attemptModels.length - 1) {
+            try {
+              await this.client.session.abort({
+                path: { id: sessionId }
+              });
+              await new Promise((r) => setTimeout(r, retryDelayMs));
+            } catch {}
           }
         }
       }
@@ -18279,7 +18889,7 @@ class BackgroundTaskManager {
         throw new Error(`All fallback models failed. ${errors3.join(" | ")}`);
       }
       log(`[background-manager] task started: ${task.id}`, {
-        sessionId: session.data.id
+        sessionId: session2.data.id
       });
     } catch (error48) {
       const errorMessage = error48 instanceof Error ? error48.message : String(error48);
@@ -18324,6 +18934,7 @@ class BackgroundTaskManager {
       task.error = "Session deleted";
       this.tasksBySessionId.delete(sessionId);
       this.agentBySessionId.delete(sessionId);
+      this.depthTracker.cleanup(sessionId);
       const resolver = this.completionResolvers.get(taskId);
       if (resolver) {
         resolver(task);
@@ -18336,22 +18947,7 @@ class BackgroundTaskManager {
     if (!task.sessionId)
       return;
     try {
-      const messagesResult = await this.client.session.messages({
-        path: { id: task.sessionId }
-      });
-      const messages = messagesResult.data ?? [];
-      const assistantMessages = messages.filter((m) => m.info?.role === "assistant");
-      const extractedContent = [];
-      for (const message of assistantMessages) {
-        for (const part of message.parts ?? []) {
-          if ((part.type === "text" || part.type === "reasoning") && part.text) {
-            extractedContent.push(part.text);
-          }
-        }
-      }
-      const responseText = extractedContent.filter((t) => t.length > 0).join(`
-
-`);
+      const responseText = await extractSessionResult(this.client, task.sessionId);
       if (responseText) {
         this.completeTask(task, "completed", responseText);
       } else {
@@ -18467,6 +19063,10 @@ class BackgroundTaskManager {
     this.tasks.clear();
     this.tasksBySessionId.clear();
     this.agentBySessionId.clear();
+    this.depthTracker.cleanupAll();
+  }
+  getDepthTracker() {
+    return this.depthTracker;
   }
 }
 // src/background/tmux-session-manager.ts
@@ -18602,54 +19202,315 @@ class TmuxSessionManager {
       for (const sessionId of sessionsToClose) {
         await this.closeSession(sessionId);
       }
-    } catch (err) {
-      log("[tmux-session-manager] poll error", { error: String(err) });
-    }
-  }
-  async closeSession(sessionId) {
-    const tracked = this.sessions.get(sessionId);
-    if (!tracked)
-      return;
-    log("[tmux-session-manager] closing session pane", {
-      sessionId,
-      paneId: tracked.paneId
+    } catch (err) {
+      log("[tmux-session-manager] poll error", { error: String(err) });
+    }
+  }
+  async closeSession(sessionId) {
+    const tracked = this.sessions.get(sessionId);
+    if (!tracked)
+      return;
+    log("[tmux-session-manager] closing session pane", {
+      sessionId,
+      paneId: tracked.paneId
+    });
+    await closeTmuxPane(tracked.paneId);
+    this.sessions.delete(sessionId);
+    if (this.sessions.size === 0) {
+      this.stopPolling();
+    }
+  }
+  async cleanup() {
+    this.stopPolling();
+    if (this.sessions.size > 0) {
+      log("[tmux-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", {
+        paneId: s.paneId,
+        error: String(err)
+      })));
+      await Promise.all(closePromises);
+      this.sessions.clear();
+    }
+    log("[tmux-session-manager] cleanup complete");
+  }
+}
+// src/council/council-manager.ts
+class CouncilManager {
+  client;
+  directory;
+  config;
+  depthTracker;
+  tmuxEnabled;
+  constructor(ctx, config2, depthTracker, tmuxEnabled = false) {
+    this.client = ctx.client;
+    this.directory = ctx.directory;
+    this.config = config2;
+    this.depthTracker = depthTracker;
+    this.tmuxEnabled = tmuxEnabled;
+  }
+  async runCouncil(prompt, presetName, parentSessionId) {
+    if (this.depthTracker) {
+      const parentDepth = this.depthTracker.getDepth(parentSessionId);
+      if (parentDepth + 1 > this.depthTracker.maxDepth) {
+        log("[council-manager] spawn blocked: max depth exceeded", {
+          parentSessionId,
+          parentDepth,
+          maxDepth: this.depthTracker.maxDepth
+        });
+        return {
+          success: false,
+          error: "Subagent depth exceeded",
+          councillorResults: []
+        };
+      }
+    }
+    const councilConfig = this.config?.council;
+    if (!councilConfig) {
+      log("[council-manager] Council configuration not found");
+      return {
+        success: false,
+        error: "Council not configured",
+        councillorResults: []
+      };
+    }
+    const resolvedPreset = presetName ?? councilConfig.default_preset ?? "default";
+    const preset = councilConfig.presets[resolvedPreset];
+    if (!preset) {
+      log(`[council-manager] Preset "${resolvedPreset}" not found`);
+      return {
+        success: false,
+        error: `Preset "${resolvedPreset}" not found`,
+        councillorResults: []
+      };
+    }
+    if (Object.keys(preset.councillors).length === 0) {
+      log(`[council-manager] Preset "${resolvedPreset}" has no councillors`);
+      return {
+        success: false,
+        error: `Preset "${resolvedPreset}" has no councillors configured`,
+        councillorResults: []
+      };
+    }
+    const councillorsTimeout = councilConfig.councillors_timeout ?? 180000;
+    const masterTimeout = councilConfig.master_timeout ?? 300000;
+    const councillorCount = Object.keys(preset.councillors).length;
+    log(`[council-manager] Starting council with preset "${resolvedPreset}"`, {
+      councillors: Object.keys(preset.councillors)
+    });
+    this.sendStartNotification(parentSessionId, councillorCount).catch((err) => {
+      log("[council-manager] Failed to send start notification", {
+        error: err instanceof Error ? err.message : String(err)
+      });
+    });
+    const councillorResults = await this.runCouncillors(prompt, preset.councillors, parentSessionId, councillorsTimeout);
+    const completedCount = councillorResults.filter((r) => r.status === "completed").length;
+    log(`[council-manager] Councillors completed: ${completedCount}/${councillorResults.length}`);
+    if (completedCount === 0) {
+      return {
+        success: false,
+        error: "All councillors failed or timed out",
+        councillorResults
+      };
+    }
+    const masterResult = await this.runMaster(prompt, councillorResults, councilConfig, parentSessionId, masterTimeout, preset.master);
+    if (!masterResult.success) {
+      log("[council-manager] Master failed", {
+        error: masterResult.error
+      });
+      const bestResult = councillorResults.find((r) => r.status === "completed" && r.result);
+      return {
+        success: false,
+        error: masterResult.error ?? "Council master failed",
+        result: bestResult?.result ? `(Degraded \u2014 master failed, using ${bestResult.name}'s response)
+
+${bestResult.result}` : undefined,
+        councillorResults
+      };
+    }
+    log("[council-manager] Council completed successfully");
+    return {
+      success: true,
+      result: masterResult.result,
+      councillorResults
+    };
+  }
+  async sendStartNotification(parentSessionId, councillorCount) {
+    const message = [
+      `\u2394 Council starting \u2014 ${councillorCount} councillors launching \u2014 ctrl+x \u2193 to watch`,
+      "",
+      "[system status: continue without acknowledging this notification]"
+    ].join(`
+`);
+    await this.client.session.prompt({
+      path: { id: parentSessionId },
+      body: {
+        noReply: true,
+        parts: [{ type: "text", text: message }]
+      }
+    });
+  }
+  async runAgentSession(options) {
+    const modelRef = parseModelReference(options.model);
+    if (!modelRef) {
+      throw new Error(`Invalid model format: ${options.model}`);
+    }
+    let sessionId;
+    try {
+      const session2 = await this.client.session.create({
+        body: {
+          parentID: options.parentSessionId,
+          title: options.title
+        },
+        query: { directory: this.directory }
+      });
+      if (!session2.data?.id) {
+        throw new Error("Failed to create session");
+      }
+      sessionId = session2.data.id;
+      if (this.depthTracker) {
+        const registered = this.depthTracker.registerChild(options.parentSessionId, sessionId);
+        if (!registered) {
+          throw new Error("Subagent depth exceeded");
+        }
+      }
+      if (this.tmuxEnabled) {
+        await new Promise((r) => setTimeout(r, TMUX_SPAWN_DELAY_MS));
+      }
+      const body = {
+        agent: options.agent,
+        model: modelRef,
+        tools: { background_task: false, task: false },
+        parts: [{ type: "text", text: options.promptText }]
+      };
+      if (options.variant) {
+        body.variant = options.variant;
+      }
+      await promptWithTimeout(this.client, {
+        path: { id: sessionId },
+        body,
+        query: { directory: this.directory }
+      }, options.timeout);
+      const result = await extractSessionResult(this.client, sessionId, {
+        includeReasoning: options.includeReasoning
+      });
+      return result || "(No output)";
+    } finally {
+      if (sessionId) {
+        this.client.session.abort({ path: { id: sessionId } }).catch(() => {});
+        if (this.depthTracker) {
+          this.depthTracker.cleanup(sessionId);
+        }
+      }
+    }
+  }
+  async runCouncillors(prompt, councillors, parentSessionId, timeout) {
+    const entries = Object.entries(councillors);
+    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}`
+        };
+      }
+    })());
+    const settled = await Promise.allSettled(promises);
+    return settled.map((result, index) => {
+      const [name, cfg] = entries[index];
+      if (result.status === "fulfilled") {
+        return {
+          name,
+          model: cfg.model,
+          status: result.value.status,
+          result: result.value.result,
+          error: result.value.error
+        };
+      }
+      return {
+        name,
+        model: cfg.model,
+        status: "failed",
+        error: result.reason instanceof Error ? result.reason.message : String(result.reason)
+      };
     });
-    await closeTmuxPane(tracked.paneId);
-    this.sessions.delete(sessionId);
-    if (this.sessions.size === 0) {
-      this.stopPolling();
-    }
   }
-  async cleanup() {
-    this.stopPolling();
-    if (this.sessions.size > 0) {
-      log("[tmux-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", {
-        paneId: s.paneId,
-        error: String(err)
-      })));
-      await Promise.all(closePromises);
-      this.sessions.clear();
+  async runMaster(prompt, councillorResults, councilConfig, parentSessionId, timeout, presetMasterOverride) {
+    const masterConfig = councilConfig.master;
+    const fallbackModels = councilConfig.master_fallback ?? [];
+    const effectiveModel = presetMasterOverride?.model ?? masterConfig.model;
+    const effectiveVariant = presetMasterOverride?.variant ?? masterConfig.variant;
+    const effectivePrompt = presetMasterOverride?.prompt ?? masterConfig.prompt;
+    const attemptModels = [effectiveModel, ...fallbackModels];
+    const synthesisPrompt = formatMasterSynthesisPrompt(prompt, councillorResults, effectivePrompt);
+    const errors3 = [];
+    for (let i = 0;i < attemptModels.length; i++) {
+      const model = attemptModels[i];
+      const currentLabel = shortModelLabel(model);
+      try {
+        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
+        });
+        return { success: true, result };
+      } catch (error48) {
+        const msg = error48 instanceof Error ? error48.message : String(error48);
+        errors3.push(`${currentLabel}: ${msg}`);
+        log(`[council-manager] master model failed: ${currentLabel} \u2014 ${msg}`);
+      }
     }
-    log("[tmux-session-manager] cleanup complete");
+    return {
+      success: false,
+      error: `All master models failed. ${errors3.join(" | ")}`
+    };
   }
 }
 // src/hooks/auto-update-checker/cache.ts
 import * as fs3 from "fs";
 import * as path4 from "path";
 // src/hooks/auto-update-checker/constants.ts
-import * as os3 from "os";
+import * as os2 from "os";
 import * as path3 from "path";
 var PACKAGE_NAME = "oh-my-opencode-slim";
 var NPM_REGISTRY_URL = `https://registry.npmjs.org/-/package/${PACKAGE_NAME}/dist-tags`;
 var NPM_FETCH_TIMEOUT = 5000;
 function getCacheDir() {
   if (process.platform === "win32") {
-    return path3.join(process.env.LOCALAPPDATA ?? os3.homedir(), "opencode");
+    return path3.join(process.env.LOCALAPPDATA ?? os2.homedir(), "opencode");
   }
-  return path3.join(os3.homedir(), ".cache", "opencode");
+  return path3.join(os2.homedir(), ".cache", "opencode");
 }
 var CACHE_DIR = getCacheDir();
 var INSTALLED_PACKAGE_JSON = path3.join(CACHE_DIR, "node_modules", PACKAGE_NAME, "package.json");
@@ -19186,12 +20047,224 @@ ${buildRetryGuidance(detected)}`;
     }
   };
 }
+// src/hooks/foreground-fallback/index.ts
+var RATE_LIMIT_PATTERNS = [
+  /\b429\b/,
+  /rate.?limit/i,
+  /too many requests/i,
+  /quota.?exceeded/i,
+  /usage.?exceeded/i,
+  /usage limit/i,
+  /overloaded/i,
+  /resource.?exhausted/i,
+  /insufficient.?quota/i,
+  /high concurrency/i,
+  /reduce concurrency/i
+];
+function isRateLimitError(error48) {
+  if (!error48 || typeof error48 !== "object")
+    return false;
+  const err = error48;
+  const text = [
+    err.message ?? "",
+    String(err.data?.statusCode ?? ""),
+    err.data?.message ?? "",
+    err.data?.responseBody ?? ""
+  ].join(" ");
+  return RATE_LIMIT_PATTERNS.some((p) => p.test(text));
+}
+function parseModel(model) {
+  const slash = model.indexOf("/");
+  if (slash <= 0 || slash >= model.length - 1)
+    return null;
+  return { providerID: model.slice(0, slash), modelID: model.slice(slash + 1) };
+}
+var DEDUP_WINDOW_MS = 5000;
+
+class ForegroundFallbackManager {
+  client;
+  chains;
+  enabled;
+  sessionModel = new Map;
+  sessionAgent = new Map;
+  sessionTried = new Map;
+  inProgress = new Set;
+  lastTrigger = new Map;
+  constructor(client, chains, enabled) {
+    this.client = client;
+    this.chains = chains;
+    this.enabled = enabled;
+  }
+  async handleEvent(rawEvent) {
+    if (!this.enabled)
+      return;
+    const event = rawEvent;
+    if (!event?.type)
+      return;
+    switch (event.type) {
+      case "message.updated": {
+        const info = event.properties?.info;
+        if (!info)
+          break;
+        const sessionID = info.sessionID;
+        if (!sessionID)
+          break;
+        if (typeof info.agent === "string") {
+          this.sessionAgent.set(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)) {
+          await this.tryFallback(sessionID);
+        }
+        break;
+      }
+      case "session.error": {
+        const props = event.properties;
+        if (props?.sessionID && props.error && isRateLimitError(props.error)) {
+          await this.tryFallback(props.sessionID);
+        }
+        break;
+      }
+      case "session.status": {
+        const props = event.properties;
+        if (!props?.sessionID || props.status?.type !== "retry")
+          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("high concurrency") || msg.includes("reduce concurrency")) {
+          await this.tryFallback(props.sessionID);
+        }
+        break;
+      }
+      case "subagent.session.created": {
+        const props = event.properties;
+        if (props?.sessionID && typeof props.agentName === "string") {
+          this.sessionAgent.set(props.sessionID, props.agentName);
+        }
+        break;
+      }
+      case "session.deleted": {
+        const props = event.properties;
+        const id = props?.info?.id ?? props?.sessionID;
+        if (id) {
+          this.sessionModel.delete(id);
+          this.sessionAgent.delete(id);
+          this.sessionTried.delete(id);
+          this.inProgress.delete(id);
+          this.lastTrigger.delete(id);
+        }
+        break;
+      }
+    }
+  }
+  async tryFallback(sessionID) {
+    if (!sessionID)
+      return;
+    if (this.inProgress.has(sessionID))
+      return;
+    const now = Date.now();
+    if (now - (this.lastTrigger.get(sessionID) ?? 0) < DEDUP_WINDOW_MS)
+      return;
+    this.lastTrigger.set(sessionID, now);
+    this.inProgress.add(sessionID);
+    try {
+      const currentModel = this.sessionModel.get(sessionID);
+      const agentName = this.sessionAgent.get(sessionID);
+      const chain = this.resolveChain(agentName, currentModel);
+      if (!chain.length) {
+        log("[foreground-fallback] no chain configured", {
+          sessionID,
+          agentName
+        });
+        return;
+      }
+      if (!this.sessionTried.has(sessionID)) {
+        this.sessionTried.set(sessionID, new Set);
+      }
+      const tried = this.sessionTried.get(sessionID);
+      if (currentModel)
+        tried.add(currentModel);
+      const nextModel = chain.find((m) => !tried.has(m));
+      if (!nextModel) {
+        log("[foreground-fallback] fallback chain exhausted", {
+          sessionID,
+          agentName,
+          tried: [...tried]
+        });
+        return;
+      }
+      tried.add(nextModel);
+      const ref = parseModel(nextModel);
+      if (!ref) {
+        log("[foreground-fallback] invalid model format", {
+          sessionID,
+          nextModel
+        });
+        return;
+      }
+      const result = await this.client.session.messages({
+        path: { id: sessionID }
+      });
+      const messages = result.data ?? [];
+      const lastUser = [...messages].reverse().find((m) => m.info.role === "user");
+      if (!lastUser) {
+        log("[foreground-fallback] no user message found", { sessionID });
+        return;
+      }
+      try {
+        await this.client.session.abort({ path: { id: sessionID } });
+      } catch {}
+      await new Promise((r) => setTimeout(r, 500));
+      const sessionClient = this.client.session;
+      await sessionClient.promptAsync({
+        path: { id: sessionID },
+        body: { parts: lastUser.parts, model: ref }
+      });
+      this.sessionModel.set(sessionID, nextModel);
+      log("[foreground-fallback] switched to fallback model", {
+        sessionID,
+        agentName,
+        from: currentModel,
+        to: nextModel
+      });
+    } catch (err) {
+      log("[foreground-fallback] fallback attempt failed", {
+        sessionID,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    } finally {
+      this.inProgress.delete(sessionID);
+    }
+  }
+  resolveChain(agentName, currentModel) {
+    if (agentName) {
+      return this.chains[agentName] ?? [];
+    }
+    if (currentModel) {
+      for (const chain of Object.values(this.chains)) {
+        if (chain.includes(currentModel))
+          return chain;
+      }
+    }
+    const all = [];
+    const seen = new Set;
+    for (const chain of Object.values(this.chains)) {
+      for (const m of chain) {
+        if (!seen.has(m)) {
+          seen.add(m);
+          all.push(m);
+        }
+      }
+    }
+    return all;
+  }
+}
 // src/hooks/json-error-recovery/hook.ts
 var JSON_ERROR_TOOL_EXCLUDE_LIST = [
   "bash",
   "read",
   "glob",
-  "grep",
   "webfetch",
   "grep_app_searchgithub",
   "websearch_web_search_exa"
@@ -19239,9 +20312,7 @@ ${JSON_ERROR_REMINDER}`;
   };
 }
 // src/hooks/phase-reminder/index.ts
-var PHASE_REMINDER = `<reminder>Recall Workflow Rules:
-Understand \u2192 find the best path (delegate based on rules and parallelize independent work) \u2192 execute \u2192 verify.
-If delegating, launch the specialist in the same turn you mention it.</reminder>`;
+var PHASE_REMINDER = `<reminder>${PHASE_REMINDER_TEXT}</reminder>`;
 function createPhaseReminderHook() {
   return {
     "experimental.chat.messages.transform": async (_input, output) => {
@@ -19280,15 +20351,15 @@ ${originalText}`;
     }
   };
 }
-// src/hooks/post-read-nudge/index.ts
+// src/hooks/post-file-tool-nudge/index.ts
 var NUDGE = `
 
 ---
-Workflow Reminder: delegate based on rules; If mentioning a specialist, launch it in this same turn.`;
-function createPostReadNudgeHook() {
+${PHASE_REMINDER_TEXT}`;
+function createPostFileToolNudgeHook() {
   return {
     "tool.execute.after": async (input, output) => {
-      if (input.tool !== "Read" && input.tool !== "read") {
+      if (input.tool !== "Read" && input.tool !== "read" && input.tool !== "Write" && input.tool !== "write") {
         return;
       }
       output.output = output.output + NUDGE;
@@ -31656,12 +32727,12 @@ var {spawn: spawn3 } = 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 dirname2, join as join8 } from "path";
+import { dirname as dirname3, join as join8 } from "path";
 
 // src/tools/ast-grep/downloader.ts
 import { chmodSync, existsSync as existsSync4, mkdirSync, unlinkSync } from "fs";
 import { createRequire } from "module";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir3 } from "os";
 import { join as join7 } from "path";
 var REPO = "ast-grep/ast-grep";
 var DEFAULT_VERSION = "0.40.0";
@@ -31686,11 +32757,11 @@ var PLATFORM_MAP = {
 function getCacheDir2() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join7(homedir4(), "AppData", "Local");
+    const base2 = localAppData || join7(homedir3(), "AppData", "Local");
     return join7(base2, "oh-my-opencode-slim", "bin");
   }
   const xdgCache = process.env.XDG_CACHE_HOME;
-  const base = xdgCache || join7(homedir4(), ".cache");
+  const base = xdgCache || join7(homedir3(), ".cache");
   return join7(base, "oh-my-opencode-slim", "bin");
 }
 function getBinaryName() {
@@ -31713,8 +32784,8 @@ async function downloadAstGrep(version3 = DEFAULT_VERSION) {
   if (existsSync4(binaryPath)) {
     return binaryPath;
   }
-  const { arch, os: os4 } = platformInfo;
-  const assetName = `app-${arch}-${os4}.zip`;
+  const { arch, os: os3 } = platformInfo;
+  const assetName = `app-${arch}-${os3}.zip`;
   const downloadUrl = `https://github.com/${REPO}/releases/download/${version3}/${assetName}`;
   console.log(`[oh-my-opencode-slim] Downloading ast-grep binary...`);
   try {
@@ -31813,7 +32884,7 @@ function findSgCliPathSync() {
   try {
     const require2 = createRequire2(import.meta.url);
     const cliPkgPath = require2.resolve("@ast-grep/cli/package.json");
-    const cliDir = dirname2(cliPkgPath);
+    const cliDir = dirname3(cliPkgPath);
     const sgPath = join8(cliDir, binaryName);
     if (existsSync5(sgPath) && isValidBinary(sgPath)) {
       return sgPath;
@@ -31824,7 +32895,7 @@ function findSgCliPathSync() {
     try {
       const require2 = createRequire2(import.meta.url);
       const pkgPath = require2.resolve(`${platformPkg}/package.json`);
-      const pkgDir = dirname2(pkgPath);
+      const pkgDir = dirname3(pkgPath);
       const astGrepName = process.platform === "win32" ? "ast-grep.exe" : "ast-grep";
       const binaryPath = join8(pkgDir, astGrepName);
       if (existsSync5(binaryPath) && isValidBinary(binaryPath)) {
@@ -32269,380 +33340,146 @@ Returns: results if completed, error if failed, status if running.`,
  Duration: ${duration5}
 
  ---
-
- `;
-      if (task.status === "completed" && task.result != null) {
-        output += task.result;
-      } else if (task.status === "failed") {
-        output += `Error: ${task.error}`;
-      } else if (task.status === "cancelled") {
-        output += "(Task cancelled)";
-      } else {
-        output += "(Task still running)";
-      }
-      return output;
-    }
-  });
-  const background_cancel = tool({
-    description: `Cancel background task(s).
-
-task_id: cancel specific task
-all=true: cancel all running tasks
-
-Only cancels pending/starting/running tasks.`,
-    args: {
-      task_id: z2.string().optional().describe("Specific task to cancel"),
-      all: z2.boolean().optional().describe("Cancel all running tasks")
-    },
-    async execute(args) {
-      if (args.all === true) {
-        const count = manager.cancel();
-        return `Cancelled ${count} task(s).`;
-      }
-      if (typeof args.task_id === "string") {
-        const count = manager.cancel(args.task_id);
-        return count > 0 ? `Cancelled task ${args.task_id}.` : `Task ${args.task_id} not found or not running.`;
-      }
-      return "Specify task_id or use all=true.";
-    }
-  });
-  return { background_task, background_output, background_cancel };
-}
-// src/tools/grep/cli.ts
-var {spawn: spawn4 } = globalThis.Bun;
-
-// src/tools/grep/constants.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync8 } from "fs";
-import { dirname as dirname3, join as join10 } from "path";
-
-// src/tools/grep/downloader.ts
-import {
-  chmodSync as chmodSync2,
-  existsSync as existsSync7,
-  mkdirSync as mkdirSync2,
-  readdirSync,
-  unlinkSync as unlinkSync2
-} from "fs";
-import { join as join9 } from "path";
-function getInstallDir() {
-  const homeDir = process.env.HOME || process.env.USERPROFILE || ".";
-  return join9(homeDir, ".cache", "oh-my-opencode-slim", "bin");
-}
-function getRgPath() {
-  const isWindows = process.platform === "win32";
-  return join9(getInstallDir(), isWindows ? "rg.exe" : "rg");
-}
-function getInstalledRipgrepPath() {
-  const rgPath = getRgPath();
-  return existsSync7(rgPath) ? rgPath : null;
-}
-
-// src/tools/grep/constants.ts
-var cachedCli = null;
-function findExecutable(name) {
-  const isWindows = process.platform === "win32";
-  const cmd = isWindows ? "where" : "which";
-  try {
-    const result = spawnSync2(cmd, [name], { encoding: "utf-8", timeout: 5000 });
-    if (result.status === 0 && result.stdout.trim()) {
-      return result.stdout.trim().split(/\r?\n/)[0];
-    }
-  } catch {}
-  return null;
-}
-function getDataDir() {
-  if (process.platform === "win32") {
-    return process.env.LOCALAPPDATA || process.env.APPDATA || join10(process.env.USERPROFILE || ".", "AppData", "Local");
-  }
-  return process.env.XDG_DATA_HOME || join10(process.env.HOME || ".", ".local", "share");
-}
-function getOpenCodeBundledRg() {
-  const execPath = process.execPath;
-  const execDir = dirname3(execPath);
-  const isWindows = process.platform === "win32";
-  const rgName = isWindows ? "rg.exe" : "rg";
-  const candidates = [
-    join10(getDataDir(), "opencode", "bin", rgName),
-    join10(execDir, rgName),
-    join10(execDir, "bin", rgName),
-    join10(execDir, "..", "bin", rgName),
-    join10(execDir, "..", "libexec", rgName)
-  ];
-  for (const candidate of candidates) {
-    if (existsSync8(candidate)) {
-      return candidate;
-    }
-  }
-  return null;
-}
-function resolveGrepCli() {
-  if (cachedCli)
-    return cachedCli;
-  const bundledRg = getOpenCodeBundledRg();
-  if (bundledRg) {
-    cachedCli = { path: bundledRg, backend: "rg" };
-    return cachedCli;
-  }
-  const systemRg = findExecutable("rg");
-  if (systemRg) {
-    cachedCli = { path: systemRg, backend: "rg" };
-    return cachedCli;
-  }
-  const installedRg = getInstalledRipgrepPath();
-  if (installedRg) {
-    cachedCli = { path: installedRg, backend: "rg" };
-    return cachedCli;
-  }
-  const grep = findExecutable("grep");
-  if (grep) {
-    cachedCli = { path: grep, backend: "grep" };
-    return cachedCli;
-  }
-  cachedCli = { path: "rg", backend: "rg" };
-  return cachedCli;
-}
-var DEFAULT_MAX_DEPTH = 20;
-var DEFAULT_MAX_FILESIZE = "10M";
-var DEFAULT_MAX_COUNT = 500;
-var DEFAULT_MAX_COLUMNS = 1000;
-var DEFAULT_TIMEOUT_MS3 = 300000;
-var DEFAULT_MAX_OUTPUT_BYTES2 = 10 * 1024 * 1024;
-var RG_SAFETY_FLAGS = [
-  "--no-follow",
-  "--color=never",
-  "--no-heading",
-  "--line-number",
-  "--with-filename"
-];
-var GREP_SAFETY_FLAGS = ["-n", "-H", "--color=never"];
-
-// src/tools/grep/cli.ts
-function buildRgArgs(options) {
-  const args = [
-    ...RG_SAFETY_FLAGS,
-    `--max-depth=${Math.min(options.maxDepth ?? DEFAULT_MAX_DEPTH, DEFAULT_MAX_DEPTH)}`,
-    `--max-filesize=${options.maxFilesize ?? DEFAULT_MAX_FILESIZE}`,
-    `--max-count=${Math.min(options.maxCount ?? DEFAULT_MAX_COUNT, DEFAULT_MAX_COUNT)}`,
-    `--max-columns=${Math.min(options.maxColumns ?? DEFAULT_MAX_COLUMNS, DEFAULT_MAX_COLUMNS)}`
-  ];
-  if (options.context !== undefined && options.context > 0) {
-    args.push(`-C${Math.min(options.context, 10)}`);
-  }
-  if (options.caseSensitive) {
-    args.push("--case-sensitive");
-  } else {
-    args.push("-i");
-  }
-  if (options.wholeWord)
-    args.push("-w");
-  if (options.fixedStrings)
-    args.push("-F");
-  if (options.multiline)
-    args.push("-U");
-  if (options.hidden)
-    args.push("--hidden");
-  if (options.noIgnore)
-    args.push("--no-ignore");
-  if (options.fileType?.length) {
-    for (const type of options.fileType) {
-      args.push(`--type=${type}`);
-    }
-  }
-  if (options.globs) {
-    for (const glob of options.globs) {
-      args.push(`--glob=${glob}`);
-    }
-  }
-  if (options.excludeGlobs) {
-    for (const glob of options.excludeGlobs) {
-      args.push(`--glob=!${glob}`);
-    }
-  }
-  return args;
-}
-function buildGrepArgs(options) {
-  const args = [...GREP_SAFETY_FLAGS, "-r"];
-  if (options.context !== undefined && options.context > 0) {
-    args.push(`-C${Math.min(options.context, 10)}`);
-  }
-  if (!options.caseSensitive)
-    args.push("-i");
-  if (options.wholeWord)
-    args.push("-w");
-  if (options.fixedStrings)
-    args.push("-F");
-  if (options.globs?.length) {
-    for (const glob of options.globs) {
-      args.push(`--include=${glob}`);
-    }
-  }
-  if (options.excludeGlobs?.length) {
-    for (const glob of options.excludeGlobs) {
-      args.push(`--exclude=${glob}`);
-    }
-  }
-  args.push("--exclude-dir=.git", "--exclude-dir=node_modules");
-  return args;
-}
-function buildArgs(options, backend) {
-  return backend === "rg" ? buildRgArgs(options) : buildGrepArgs(options);
-}
-function parseOutput(output) {
-  if (!output.trim())
-    return [];
-  const matches = [];
-  const lines = output.trim().split(/\r?\n/);
-  for (const line of lines) {
-    if (!line.trim())
-      continue;
-    const match = line.match(/^(.+?):(\d+):(.*)$/);
-    if (match) {
-      matches.push({
-        file: match[1],
-        line: parseInt(match[2], 10),
-        text: match[3]
-      });
-    }
-  }
-  return matches;
-}
-async function runRg(options) {
-  const cli = resolveGrepCli();
-  const args = buildArgs(options, cli.backend);
-  const timeout = Math.min(options.timeout ?? DEFAULT_TIMEOUT_MS3, DEFAULT_TIMEOUT_MS3);
-  if (cli.backend === "rg") {
-    args.push("--", options.pattern);
-  } else {
-    args.push("-e", options.pattern);
-  }
-  const paths2 = options.paths?.length ? options.paths : ["."];
-  args.push(...paths2);
-  const proc = spawn4([cli.path, ...args], {
-    stdout: "pipe",
-    stderr: "pipe"
-  });
-  const timeoutPromise = new Promise((_, reject) => {
-    const id = setTimeout(() => {
-      proc.kill();
-      reject(new Error(`Search timeout after ${timeout}ms`));
-    }, timeout);
-    proc.exited.then(() => clearTimeout(id));
-  });
-  try {
-    const stdout = await Promise.race([
-      new Response(proc.stdout).text(),
-      timeoutPromise
-    ]);
-    const stderr = await new Response(proc.stderr).text();
-    const exitCode = await proc.exited;
-    const truncated = stdout.length >= DEFAULT_MAX_OUTPUT_BYTES2;
-    const outputToProcess = truncated ? stdout.substring(0, DEFAULT_MAX_OUTPUT_BYTES2) : stdout;
-    if (exitCode > 1 && stderr.trim()) {
-      return {
-        matches: [],
-        totalMatches: 0,
-        filesSearched: 0,
-        truncated: false,
-        error: stderr.trim()
-      };
-    }
-    const matches = parseOutput(outputToProcess);
-    const filesSearched = new Set(matches.map((m) => m.file)).size;
-    return {
-      matches,
-      totalMatches: matches.length,
-      filesSearched,
-      truncated
-    };
-  } catch (e) {
-    return {
-      matches: [],
-      totalMatches: 0,
-      filesSearched: 0,
-      truncated: false,
-      error: e instanceof Error ? e.message : String(e)
-    };
-  }
-}
-// src/tools/grep/utils.ts
-function formatGrepResult(result) {
-  if (result.error) {
-    return `Error: ${result.error}`;
-  }
-  if (result.matches.length === 0) {
-    return "No matches found.";
-  }
-  const lines = [];
-  const byFile = new Map;
-  for (const match of result.matches) {
-    const existing = byFile.get(match.file) || [];
-    existing.push({ line: match.line, text: match.text });
-    byFile.set(match.file, existing);
-  }
-  for (const [file3, matches] of byFile) {
-    lines.push(`
-${file3}:`);
-    for (const match of matches) {
-      lines.push(`  ${match.line}: ${match.text}`);
+
+ `;
+      if (task.status === "completed" && task.result != null) {
+        output += task.result;
+      } else if (task.status === "failed") {
+        output += `Error: ${task.error}`;
+      } else if (task.status === "cancelled") {
+        output += "(Task cancelled)";
+      } else {
+        output += "(Task still running)";
+      }
+      return output;
     }
-  }
-  const summary = `Found ${result.totalMatches} matches in ${result.filesSearched} files`;
-  if (result.truncated) {
-    lines.push(`
-${summary} (output truncated)`);
-  } else {
-    lines.push(`
-${summary}`);
-  }
-  return lines.join(`
-`);
+  });
+  const background_cancel = tool({
+    description: `Cancel background task(s).
+
+task_id: cancel specific task
+all=true: cancel all running tasks
+
+Only cancels pending/starting/running tasks.`,
+    args: {
+      task_id: z2.string().optional().describe("Specific task to cancel"),
+      all: z2.boolean().optional().describe("Cancel all running tasks")
+    },
+    async execute(args) {
+      if (args.all === true) {
+        const count = manager.cancel();
+        return `Cancelled ${count} task(s).`;
+      }
+      if (typeof args.task_id === "string") {
+        const count = manager.cancel(args.task_id);
+        return count > 0 ? `Cancelled task ${args.task_id}.` : `Task ${args.task_id} not found or not running.`;
+      }
+      return "Specify task_id or use all=true.";
+    }
+  });
+  return { background_task, background_output, background_cancel };
 }
+// src/tools/council.ts
+var z3 = tool.schema;
+function formatModelComposition(councillorResults) {
+  return councillorResults.map((cr) => {
+    const shortModel = shortModelLabel(cr.model ?? "");
+    return `${cr.name}: ${shortModel}`;
+  }).join(", ");
+}
+function createCouncilTool(_ctx, councilManager) {
+  const council_session = tool({
+    description: `Launch a multi-LLM council session for consensus-based analysis.
 
-// src/tools/grep/tools.ts
-var grep = tool({
-  description: "Fast content search tool with safety limits (60s timeout, 10MB output). " + "Searches file contents using regular expressions. " + 'Supports full regex syntax (eg. "log.*Error", "function\\s+\\w+", etc.). ' + 'Filter files by pattern with the include parameter (e.g. "*.js", "*.{ts,tsx}"). ' + "Returns file paths with matches sorted by modification time.",
-  args: {
-    pattern: tool.schema.string().describe("The regex pattern to search for in file contents"),
-    include: tool.schema.string().optional().describe('File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")'),
-    path: tool.schema.string().optional().describe("The directory to search in. Defaults to the current working directory."),
-    caseSensitive: tool.schema.boolean().optional().default(false).describe("Perform case-sensitive search (default: false)"),
-    wholeWord: tool.schema.boolean().optional().default(false).describe("Match whole words only (default: false)"),
-    fixedStrings: tool.schema.boolean().optional().default(false).describe("Treat pattern as literal string (default: false)")
-  },
-  execute: async (args) => {
-    try {
-      const globs = args.include ? [args.include] : undefined;
-      const paths2 = args.path ? [args.path] : undefined;
-      const result = await runRg({
-        pattern: args.pattern,
-        paths: paths2,
-        globs,
-        context: 0,
-        caseSensitive: args.caseSensitive ?? false,
-        wholeWord: args.wholeWord ?? false,
-        fixedStrings: args.fixedStrings ?? false
-      });
-      return formatGrepResult(result);
-    } catch (e) {
-      return `Error: ${e instanceof Error ? e.message : String(e)}`;
+Sends the prompt to multiple models (councillors) in parallel, then a council master synthesizes the best response.
+
+Returns the synthesized result with councillor summary.`,
+    args: {
+      prompt: z3.string().describe("The prompt to send to all councillors"),
+      preset: z3.string().optional().describe('Council preset to use (default: "default"). Must match a preset in the council config.')
+    },
+    async execute(args, toolContext) {
+      if (!toolContext || typeof toolContext !== "object" || !("sessionID" in toolContext)) {
+        throw new Error("Invalid toolContext: missing sessionID");
+      }
+      const allowedAgents = ["council", "orchestrator"];
+      const callingAgent = toolContext.agent;
+      if (callingAgent && !allowedAgents.includes(callingAgent)) {
+        throw new Error(`Council sessions can only be invoked by council or orchestrator agents. Current agent: ${callingAgent}`);
+      }
+      const prompt = String(args.prompt);
+      const preset = typeof args.preset === "string" ? args.preset : undefined;
+      const parentSessionId = toolContext.sessionID;
+      const result = await councilManager.runCouncil(prompt, preset, parentSessionId);
+      if (!result.success) {
+        if (result.result) {
+          const completed2 = result.councillorResults.filter((cr) => cr.status === "completed").length;
+          const total2 = result.councillorResults.length;
+          const composition2 = formatModelComposition(result.councillorResults);
+          return `${result.result}
+
+---
+*Council: ${completed2}/${total2} councillors responded (${composition2}) \u2014 degraded*`;
+        }
+        return `Council session failed: ${result.error}`;
+      }
+      let output = result.result ?? "(No output)";
+      const completed = result.councillorResults.filter((cr) => cr.status === "completed").length;
+      const total = result.councillorResults.length;
+      const composition = formatModelComposition(result.councillorResults);
+      output += `
+
+---
+*Council: ${completed}/${total} councillors responded (${composition})*`;
+      return output;
     }
-  }
-});
+  });
+  return { council_session };
+}
 // src/tools/lsp/client.ts
 var import_node = __toESM(require_main(), 1);
 import { readFileSync as readFileSync4 } from "fs";
-import { extname, resolve } from "path";
+import { extname, resolve as resolve2 } from "path";
 import { Readable, Writable } from "stream";
 import { pathToFileURL } from "url";
-var {spawn: spawn5 } = globalThis.Bun;
+var {spawn: spawn4 } = globalThis.Bun;
 
 // src/tools/lsp/config.ts
-import { existsSync as existsSync9 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join11 } from "path";
+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";
+
+// src/tools/lsp/config-store.ts
+var userConfig = new Map;
+function setUserLspConfig(config3) {
+  userConfig.clear();
+  if (config3) {
+    for (const [id, server] of Object.entries(config3)) {
+      if (server && typeof server === "object") {
+        const s = server;
+        userConfig.set(id, {
+          id,
+          command: s.command,
+          extensions: s.extensions,
+          disabled: s.disabled,
+          env: s.env,
+          initialization: s.initialization
+        });
+      }
+    }
+  }
+}
+function getAllUserLspConfigs() {
+  return new Map(userConfig);
+}
+function hasUserLspConfig() {
+  return userConfig.size > 0;
+}
 
 // src/tools/lsp/constants.ts
+import { existsSync as existsSync7, readdirSync, statSync as statSync3 } from "fs";
+import { dirname as dirname4, resolve } from "path";
 var SEVERITY_MAP = {
   1: "error",
   2: "warning",
@@ -32651,22 +33488,76 @@ var SEVERITY_MAP = {
 };
 var DEFAULT_MAX_REFERENCES = 200;
 var DEFAULT_MAX_DIAGNOSTICS = 200;
+var LOCK_FILE_PATTERNS = [
+  "package-lock.json",
+  "bun.lockb",
+  "bun.lock",
+  "pnpm-lock.yaml",
+  "yarn.lock"
+];
+function* walkUpDirectories(start, stop) {
+  let dir = resolve(start);
+  try {
+    if (!statSync3(dir).isDirectory()) {
+      dir = dirname4(dir);
+    }
+  } catch {
+    dir = dirname4(dir);
+  }
+  let prevDir = "";
+  while (dir !== prevDir && dir !== "/") {
+    yield dir;
+    prevDir = dir;
+    if (dir === stop)
+      break;
+    dir = dirname4(dir);
+  }
+}
+function NearestRoot(includePatterns, excludePatterns) {
+  return (file3) => {
+    const cwd = process.cwd();
+    if (excludePatterns) {
+      for (const dir of walkUpDirectories(file3, cwd)) {
+        for (const pattern of excludePatterns) {
+          if (existsSync7(`${dir}/${pattern}`)) {
+            return;
+          }
+        }
+      }
+    }
+    for (const dir of walkUpDirectories(file3, cwd)) {
+      for (const pattern of includePatterns) {
+        if (pattern.includes("*")) {
+          try {
+            const entries = readdirSync(dir);
+            const regex = new RegExp(`^${pattern.replace(/\./g, "\\.").replace(/\*/g, ".*")}$`);
+            if (entries.some((entry) => regex.test(entry))) {
+              return dir;
+            }
+          } catch {}
+        } else if (existsSync7(`${dir}/${pattern}`)) {
+          return dir;
+        }
+      }
+    }
+    return;
+  };
+}
 var BUILTIN_SERVERS = {
+  deno: {
+    command: ["deno", "lsp"],
+    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs"],
+    root: NearestRoot(["deno.json", "deno.jsonc"])
+  },
   typescript: {
     command: ["typescript-language-server", "--stdio"],
-    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"]
+    extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
+    root: NearestRoot(LOCK_FILE_PATTERNS, ["deno.json", "deno.jsonc"])
   },
   vue: {
     command: ["vue-language-server", "--stdio"],
-    extensions: [".vue"]
-  },
-  svelte: {
-    command: ["svelteserver", "--stdio"],
-    extensions: [".svelte"]
-  },
-  astro: {
-    command: ["astro-ls", "--stdio"],
-    extensions: [".astro"]
+    extensions: [".vue"],
+    root: NearestRoot(LOCK_FILE_PATTERNS)
   },
   eslint: {
     command: ["vscode-eslint-language-server", "--stdio"],
@@ -32677,54 +33568,316 @@ var BUILTIN_SERVERS = {
       ".jsx",
       ".mjs",
       ".cjs",
+      ".mts",
+      ".cts",
+      ".vue"
+    ],
+    root: NearestRoot(LOCK_FILE_PATTERNS)
+  },
+  oxlint: {
+    command: ["oxlint", "--lsp"],
+    extensions: [
+      ".ts",
+      ".tsx",
+      ".js",
+      ".jsx",
+      ".mjs",
+      ".cjs",
+      ".mts",
+      ".cts",
       ".vue",
+      ".astro",
       ".svelte"
-    ]
+    ],
+    root: NearestRoot([
+      ".oxlintrc.json",
+      ...LOCK_FILE_PATTERNS,
+      "package.json"
+    ])
   },
-  tailwindcss: {
-    command: ["tailwindcss-language-server", "--stdio"],
-    extensions: [".html", ".jsx", ".tsx", ".vue", ".svelte", ".astro"]
+  biome: {
+    command: ["biome", "lsp-proxy", "--stdio"],
+    extensions: [
+      ".ts",
+      ".tsx",
+      ".js",
+      ".jsx",
+      ".mjs",
+      ".cjs",
+      ".mts",
+      ".cts",
+      ".json",
+      ".jsonc",
+      ".vue",
+      ".astro",
+      ".svelte",
+      ".css",
+      ".graphql",
+      ".gql",
+      ".html"
+    ],
+    root: NearestRoot(["biome.json", "biome.jsonc", ...LOCK_FILE_PATTERNS])
   },
   gopls: {
     command: ["gopls"],
-    extensions: [".go"]
+    extensions: [".go"],
+    root: NearestRoot(["go.work", "go.mod", "go.sum"])
   },
-  rust: {
-    command: ["rust-analyzer"],
-    extensions: [".rs"]
+  ruby_lsp: {
+    command: ["rubocop", "--lsp"],
+    extensions: [".rb", ".rake", ".gemspec", ".ru"],
+    root: NearestRoot(["Gemfile"])
   },
-  basedpyright: {
-    command: ["basedpyright-langserver", "--stdio"],
-    extensions: [".py", ".pyi"]
+  ty: {
+    command: ["ty", "server"],
+    extensions: [".py", ".pyi"],
+    root: NearestRoot([
+      "pyproject.toml",
+      "ty.toml",
+      "setup.py",
+      "setup.cfg",
+      "requirements.txt",
+      "Pipfile",
+      "pyrightconfig.json"
+    ])
   },
   pyright: {
     command: ["pyright-langserver", "--stdio"],
-    extensions: [".py", ".pyi"]
+    extensions: [".py", ".pyi"],
+    root: NearestRoot([
+      "pyproject.toml",
+      "setup.py",
+      "setup.cfg",
+      "requirements.txt",
+      "Pipfile",
+      "pyrightconfig.json"
+    ])
   },
-  clangd: {
-    command: ["clangd", "--background-index"],
-    extensions: [".c", ".cpp", ".cc", ".cxx", ".h", ".hpp"]
+  elixir_ls: {
+    command: ["elixir-ls"],
+    extensions: [".ex", ".exs"],
+    root: NearestRoot(["mix.exs", "mix.lock"])
   },
   zls: {
     command: ["zls"],
-    extensions: [".zig"]
+    extensions: [".zig", ".zon"],
+    root: NearestRoot(["build.zig"])
+  },
+  csharp: {
+    command: ["csharp-ls"],
+    extensions: [".cs"],
+    root: NearestRoot([".slnx", ".sln", ".csproj", "global.json"])
+  },
+  fsharp: {
+    command: ["fsautocomplete"],
+    extensions: [".fs", ".fsi", ".fsx", ".fsscript"],
+    root: NearestRoot([".slnx", ".sln", ".fsproj", "global.json"])
+  },
+  sourcekit_lsp: {
+    command: ["sourcekit-lsp"],
+    extensions: [".swift", ".objc", ".objcpp"],
+    root: NearestRoot(["Package.swift", "*.xcodeproj", "*.xcworkspace"])
+  },
+  rust: {
+    command: ["rust-analyzer"],
+    extensions: [".rs"],
+    root: NearestRoot(["Cargo.toml", "Cargo.lock"])
+  },
+  clangd: {
+    command: ["clangd", "--background-index", "--clang-tidy"],
+    extensions: [
+      ".c",
+      ".cpp",
+      ".cc",
+      ".cxx",
+      ".c++",
+      ".h",
+      ".hpp",
+      ".hh",
+      ".hxx",
+      ".h++"
+    ],
+    root: NearestRoot([
+      "compile_commands.json",
+      "compile_flags.txt",
+      ".clangd",
+      "CMakeLists.txt",
+      "Makefile"
+    ])
+  },
+  svelte: {
+    command: ["svelteserver", "--stdio"],
+    extensions: [".svelte"],
+    root: NearestRoot(LOCK_FILE_PATTERNS)
+  },
+  astro: {
+    command: ["astro-ls", "--stdio"],
+    extensions: [".astro"],
+    root: NearestRoot(LOCK_FILE_PATTERNS)
+  },
+  jdtls: {
+    command: ["jdtls"],
+    extensions: [".java"],
+    root: NearestRoot([
+      "pom.xml",
+      "build.gradle",
+      "build.gradle.kts",
+      ".project",
+      ".classpath"
+    ])
+  },
+  kotlin_ls: {
+    command: ["kotlin-lsp", "--stdio"],
+    extensions: [".kt", ".kts"],
+    root: NearestRoot([
+      "settings.gradle.kts",
+      "settings.gradle",
+      "gradlew",
+      "build.gradle.kts",
+      "build.gradle",
+      "pom.xml"
+    ])
+  },
+  yaml_ls: {
+    command: ["yaml-language-server", "--stdio"],
+    extensions: [".yaml", ".yml"],
+    root: NearestRoot(LOCK_FILE_PATTERNS)
+  },
+  lua_ls: {
+    command: ["lua-language-server"],
+    extensions: [".lua"],
+    root: NearestRoot([
+      ".luarc.json",
+      ".luarc.jsonc",
+      ".luacheckrc",
+      "stylua.toml",
+      "selene.toml",
+      "selene.yml"
+    ])
+  },
+  php_intelephense: {
+    command: ["intelephense", "--stdio"],
+    extensions: [".php"],
+    root: NearestRoot(["composer.json", "composer.lock", ".php-version"])
+  },
+  prisma: {
+    command: ["prisma", "language-server"],
+    extensions: [".prisma"],
+    root: NearestRoot(["schema.prisma", "prisma/schema.prisma", "prisma"])
+  },
+  dart: {
+    command: ["dart", "language-server", "--lsp"],
+    extensions: [".dart"],
+    root: NearestRoot(["pubspec.yaml", "analysis_options.yaml"])
+  },
+  ocaml_lsp: {
+    command: ["ocamllsp"],
+    extensions: [".ml", ".mli"],
+    root: NearestRoot(["dune-project", "dune-workspace", ".merlin", "opam"])
+  },
+  bash: {
+    command: ["bash-language-server", "start"],
+    extensions: [".sh", ".bash", ".zsh", ".ksh"],
+    root: undefined
+  },
+  terraform_ls: {
+    command: ["terraform-ls", "serve"],
+    extensions: [".tf", ".tfvars"],
+    root: NearestRoot([".terraform.lock.hcl", "terraform.tfstate", "*.tf"])
+  },
+  texlab: {
+    command: ["texlab"],
+    extensions: [".tex", ".bib"],
+    root: NearestRoot([".latexmkrc", "latexmkrc", ".texlabroot", "texlabroot"])
+  },
+  dockerfile: {
+    command: ["docker-langserver", "--stdio"],
+    extensions: [".dockerfile", "Dockerfile"],
+    root: undefined
+  },
+  gleam: {
+    command: ["gleam", "lsp"],
+    extensions: [".gleam"],
+    root: NearestRoot(["gleam.toml"])
+  },
+  clojure_lsp: {
+    command: ["clojure-lsp", "listen"],
+    extensions: [".clj", ".cljs", ".cljc", ".edn"],
+    root: NearestRoot([
+      "deps.edn",
+      "project.clj",
+      "shadow-cljs.edn",
+      "bb.edn",
+      "build.boot"
+    ])
+  },
+  nixd: {
+    command: ["nixd"],
+    extensions: [".nix"],
+    root: NearestRoot(["flake.nix"])
+  },
+  tinymist: {
+    command: ["tinymist"],
+    extensions: [".typ", ".typc"],
+    root: NearestRoot(["typst.toml"])
+  },
+  haskell_language_server: {
+    command: ["haskell-language-server-wrapper", "--lsp"],
+    extensions: [".hs", ".lhs"],
+    root: NearestRoot(["stack.yaml", "cabal.project", "hie.yaml", "*.cabal"])
+  },
+  julials: {
+    command: [
+      "julia",
+      "--startup-file=no",
+      "--history-file=no",
+      "-e",
+      "using LanguageServer; runserver()"
+    ],
+    extensions: [".jl"],
+    root: NearestRoot(["Project.toml", "Manifest.toml", "*.jl"])
   }
 };
 var LSP_INSTALL_HINTS = {
+  deno: "Install Deno: https://deno.land/#installation",
   typescript: "npm install -g typescript-language-server typescript",
   vue: "npm install -g @vue/language-server",
-  svelte: "npm install -g svelte-language-server",
-  astro: "npm install -g @astrojs/language-server",
   eslint: "npm install -g vscode-langservers-extracted",
-  tailwindcss: "npm install -g @tailwindcss/language-server",
+  oxlint: "npm install -g oxlint or install via package manager",
+  biome: "npm install -g @biomejs/biome",
   gopls: "go install golang.org/x/tools/gopls@latest",
-  rust: "rustup component add rust-analyzer",
-  basedpyright: "pip install basedpyright",
+  ruby_lsp: "gem install rubocop (Ruby LSP runs via rubocop --lsp)",
+  ty: "pip install ty or see https://github.com/astral-sh/ty",
   pyright: "pip install pyright",
-  clangd: "See https://clangd.llvm.org/installation",
-  zls: "See https://github.com/zigtools/zls"
+  elixir_ls: "Download from https://github.com/elixir-lsp/elixir-ls/releases or build from source",
+  zls: "Install via your package manager or build from source: https://github.com/zigtools/zls",
+  csharp: "dotnet tool install --global csharp-ls",
+  fsharp: "dotnet tool install --global fsautocomplete",
+  sourcekit_lsp: "Install via Xcode or Swift toolchain (included with Xcode)",
+  rust: "rustup component add rust-analyzer",
+  clangd: "Install clangd via your system package manager or LLVM",
+  svelte: "npm install -g svelte-language-server",
+  astro: "npm install -g @astrojs/language-server",
+  jdtls: "See https://github.com/eclipse-jdtls/eclipse.jdt.ls for installation",
+  kotlin_ls: "Download from https://github.com/Kotlin/kotlin-lsp/releases",
+  yaml_ls: "npm install -g yaml-language-server",
+  lua_ls: "Download from https://github.com/LuaLS/lua-language-server/releases",
+  php_intelephense: "npm install -g intelephense",
+  prisma: "npm install -g @prisma/language-server or use npx",
+  dart: "dart pub global activate language_server",
+  ocaml_lsp: "opam install ocaml-lsp-server",
+  bash: "npm install -g bash-language-server",
+  terraform_ls: "Download from https://github.com/hashicorp/terraform-ls/releases or install via tfenv",
+  texlab: "Download from https://github.com/latex-lsp/texlab/releases",
+  dockerfile: "npm install -g dockerfile-language-server-nodejs",
+  gleam: "Install Gleam: https://gleam.run/getting-started/",
+  clojure_lsp: "Install via deps.edn, project.clj, or: clj -M -m clojure-lsp.main",
+  nixd: "Install via nix-env or your system package manager",
+  tinymist: "cargo install tinymist or download from releases",
+  haskell_language_server: "Install Haskell Tool Stack or Cabal, then language-server",
+  julials: "Install Julia: https://julialang.org/downloads/"
 };
-var EXT_TO_LANG = {
+var LANGUAGE_EXTENSIONS = {
   ".ts": "typescript",
   ".tsx": "typescriptreact",
   ".mts": "typescript",
@@ -32733,35 +33886,180 @@ var EXT_TO_LANG = {
   ".jsx": "javascriptreact",
   ".mjs": "javascript",
   ".cjs": "javascript",
+  ".ets": "typescript",
   ".vue": "vue",
   ".svelte": "svelte",
   ".astro": "astro",
   ".html": "html",
+  ".htm": "html",
+  ".xml": "xml",
+  ".xsl": "xsl",
   ".css": "css",
   ".scss": "scss",
+  ".sass": "sass",
   ".less": "less",
   ".json": "json",
+  ".jsonc": "json",
+  ".graphql": "graphql",
+  ".gql": "graphql",
+  ".dockerfile": "dockerfile",
+  ".sh": "shellscript",
+  ".bash": "shellscript",
+  ".zsh": "shellscript",
+  ".ksh": "shellscript",
   ".go": "go",
   ".rs": "rust",
   ".py": "python",
   ".pyi": "python",
+  ".rb": "ruby",
+  ".rake": "ruby",
+  ".gemspec": "ruby",
+  ".ru": "ruby",
   ".c": "c",
   ".cpp": "cpp",
   ".cc": "cpp",
   ".cxx": "cpp",
+  ".c++": "cpp",
   ".h": "c",
   ".hpp": "cpp",
-  ".zig": "zig"
+  ".hh": "cpp",
+  ".hxx": "cpp",
+  ".h++": "cpp",
+  ".java": "java",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  ".cs": "csharp",
+  ".fs": "fsharp",
+  ".fsi": "fsharp",
+  ".fsx": "fsharp",
+  ".fsscript": "fsharp",
+  ".swift": "swift",
+  ".m": "objective-c",
+  ".mm": "objective-cpp",
+  ".zig": "zig",
+  ".zon": "zig",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".clj": "clojure",
+  ".cljs": "clojure",
+  ".cljc": "clojure",
+  ".edn": "clojure",
+  ".hs": "haskell",
+  ".lhs": "haskell",
+  ".ml": "ocaml",
+  ".mli": "ocaml",
+  ".scala": "scala",
+  ".php": "php",
+  ".lua": "lua",
+  ".dart": "dart",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".tf": "terraform",
+  ".tfvars": "terraform-vars",
+  ".hcl": "hcl",
+  ".nix": "nix",
+  ".typ": "typst",
+  ".typc": "typst",
+  ".tex": "latex",
+  ".latex": "latex",
+  ".bib": "bibtex",
+  ".bibtex": "bibtex",
+  ".prisma": "prisma",
+  ".jl": "julia",
+  ".gleam": "gleam",
+  ".md": "markdown",
+  ".markdown": "markdown",
+  ".d": "d",
+  ".pas": "pascal",
+  ".pascal": "pascal",
+  ".diff": "diff",
+  ".patch": "diff",
+  ".erl": "erlang",
+  ".hrl": "erlang",
+  ".groovy": "groovy",
+  ".handlebars": "handlebars",
+  ".hbs": "handlebars",
+  ".ini": "ini",
+  ".makefile": "makefile",
+  makefile: "makefile",
+  ".pug": "jade",
+  ".jade": "jade",
+  ".r": "r",
+  ".cshtml": "razor",
+  ".razor": "razor",
+  ".erb": "erb",
+  ".html.erb": "erb",
+  ".js.erb": "erb",
+  ".css.erb": "erb",
+  ".json.erb": "erb",
+  ".shader": "shaderlab",
+  ".sql": "sql",
+  ".perl": "perl",
+  ".pl": "perl",
+  ".pm": "perl",
+  ".pm6": "perl6",
+  ".ps1": "powershell",
+  ".psm1": "powershell",
+  ".coffee": "coffeescript",
+  ".bat": "bat",
+  ".abap": "abap",
+  ".gitcommit": "git-commit",
+  ".gitrebase": "git-rebase"
 };
 
 // src/tools/lsp/config.ts
-function findServerForExtension(ext) {
+function buildMergedServers() {
+  const servers = new Map;
   for (const [id, config3] of Object.entries(BUILTIN_SERVERS)) {
+    servers.set(id, {
+      id,
+      command: config3.command,
+      extensions: config3.extensions,
+      root: config3.root,
+      env: config3.env,
+      initialization: config3.initialization
+    });
+  }
+  if (hasUserLspConfig()) {
+    for (const [id, userConfig2] of getAllUserLspConfigs()) {
+      if (userConfig2.disabled === true) {
+        servers.delete(id);
+        continue;
+      }
+      const existing = servers.get(id);
+      if (existing) {
+        servers.set(id, {
+          ...existing,
+          id,
+          command: userConfig2.command ?? existing.command,
+          extensions: userConfig2.extensions ?? existing.extensions,
+          root: existing.root,
+          env: userConfig2.env ?? existing.env,
+          initialization: userConfig2.initialization ?? existing.initialization
+        });
+      } else {
+        servers.set(id, {
+          id,
+          command: userConfig2.command ?? [],
+          extensions: userConfig2.extensions ?? [],
+          root: undefined,
+          env: userConfig2.env,
+          initialization: userConfig2.initialization
+        });
+      }
+    }
+  }
+  return servers;
+}
+function findServerForExtension(ext) {
+  const servers = buildMergedServers();
+  for (const [, config3] of servers) {
     if (config3.extensions.includes(ext)) {
       const server = {
-        id,
+        id: config3.id,
         command: config3.command,
         extensions: config3.extensions,
+        root: config3.root,
         env: config3.env,
         initialization: config3.initialization
       };
@@ -32771,39 +34069,37 @@ function findServerForExtension(ext) {
       return {
         status: "not_installed",
         server,
-        installHint: LSP_INSTALL_HINTS[id] || `Install '${config3.command[0]}' and add to PATH`
+        installHint: LSP_INSTALL_HINTS[config3.id] || `Install '${config3.command[0]}' and add to PATH`
       };
     }
   }
   return { status: "not_configured", extension: ext };
 }
 function getLanguageId(ext) {
-  return EXT_TO_LANG[ext] || "plaintext";
+  return LANGUAGE_EXTENSIONS[ext] || "plaintext";
 }
 function isServerInstalled(command) {
   if (command.length === 0)
     return false;
   const cmd = command[0];
   if (cmd.includes("/") || cmd.includes("\\")) {
-    return existsSync9(cmd);
+    return existsSync8(cmd);
   }
   const isWindows = process.platform === "win32";
   const ext = isWindows ? ".exe" : "";
-  const pathEnv = process.env.PATH || "";
-  const pathSeparator = isWindows ? ";" : ":";
-  const paths2 = pathEnv.split(pathSeparator);
-  for (const p of paths2) {
-    if (existsSync9(join11(p, cmd)) || existsSync9(join11(p, cmd + ext))) {
-      return true;
-    }
-  }
-  const cwd = process.cwd();
-  const localBin = join11(cwd, "node_modules", ".bin", cmd);
-  if (existsSync9(localBin) || existsSync9(localBin + ext)) {
+  const opencodeBin = join9(homedir4(), ".config", "opencode", "bin");
+  const searchPath = (process.env.PATH ?? "") + (isWindows ? ";" : ":") + opencodeBin;
+  const result = import_which.default.sync(cmd, {
+    path: searchPath,
+    pathExt: isWindows ? process.env.PATHEXT : undefined,
+    nothrow: true
+  });
+  if (result !== null) {
     return true;
   }
-  const globalBin = join11(homedir5(), ".config", "opencode", "bin", cmd);
-  if (existsSync9(globalBin) || existsSync9(globalBin + ext)) {
+  const cwd = process.cwd();
+  const localBin = join9(cwd, "node_modules", ".bin", cmd);
+  if (existsSync8(localBin) || existsSync8(localBin + ext)) {
     return true;
   }
   return false;
@@ -32816,6 +34112,7 @@ class LSPServerManager {
   cleanupInterval = null;
   IDLE_TIMEOUT = 5 * 60 * 1000;
   constructor() {
+    log("[lsp] manager initialized");
     this.startCleanupTimer();
     this.registerProcessCleanup();
   }
@@ -32872,16 +34169,31 @@ class LSPServerManager {
     const managed = this.clients.get(key);
     if (managed) {
       if (managed.initPromise) {
+        log("[lsp] getClient: waiting for init", { key, server: server.id });
         await managed.initPromise;
       }
       if (managed.client.isAlive()) {
         managed.refCount++;
         managed.lastUsedAt = Date.now();
+        log("[lsp] getClient: reuse pooled client", {
+          key,
+          server: server.id,
+          refCount: managed.refCount
+        });
         return managed.client;
       }
+      log("[lsp] getClient: client dead, recreating", {
+        key,
+        server: server.id
+      });
       await managed.client.stop();
       this.clients.delete(key);
     }
+    log("[lsp] getClient: creating new client", {
+      key,
+      server: server.id,
+      root
+    });
     const client = new LSPClient(root, server);
     const initPromise2 = (async () => {
       await client.start();
@@ -32901,7 +34213,13 @@ class LSPServerManager {
         m.initPromise = undefined;
         m.isInitializing = false;
       }
+      log("[lsp] getClient: client ready", { key, server: server.id });
     } catch (err) {
+      log("[lsp] getClient: init failed", {
+        key,
+        server: server.id,
+        error: String(err)
+      });
       this.clients.delete(key);
       throw err;
     }
@@ -32913,6 +34231,11 @@ class LSPServerManager {
     if (managed && managed.refCount > 0) {
       managed.refCount--;
       managed.lastUsedAt = Date.now();
+      log("[lsp] releaseClient", {
+        key,
+        server: serverId,
+        refCount: managed.refCount
+      });
     }
   }
   isServerInitializing(root, serverId) {
@@ -32921,14 +34244,19 @@ class LSPServerManager {
     return managed?.isInitializing ?? false;
   }
   async stopAll() {
-    for (const [, managed] of this.clients) {
+    log("[lsp] stopAll: shutting down all clients", {
+      count: this.clients.size
+    });
+    for (const [key, managed] of this.clients) {
       await managed.client.stop();
+      log("[lsp] stopAll: client stopped", { key });
     }
     this.clients.clear();
     if (this.cleanupInterval) {
       clearInterval(this.cleanupInterval);
       this.cleanupInterval = null;
     }
+    log("[lsp] stopAll: complete");
   }
 }
 var lspManager = LSPServerManager.getInstance();
@@ -32947,7 +34275,12 @@ class LSPClient {
     this.server = server;
   }
   async start() {
-    this.proc = spawn5(this.server.command, {
+    log("[lsp] LSPClient.start: spawning server", {
+      server: this.server.id,
+      command: this.server.command.join(" "),
+      root: this.root
+    });
+    this.proc = spawn4(this.server.command, {
       stdin: "pipe",
       stdout: "pipe",
       stderr: "pipe",
@@ -33016,13 +34349,19 @@ class LSPClient {
       this.processExited = true;
     });
     this.connection.listen();
-    await new Promise((resolve2) => setTimeout(resolve2, 100));
+    await new Promise((resolve3) => setTimeout(resolve3, 100));
     if (this.proc.exitCode !== null) {
       const stderr = this.stderrBuffer.join(`
 `);
+      log("[lsp] LSPClient.start: server exited immediately", {
+        server: this.server.id,
+        exitCode: this.proc.exitCode,
+        stderr: stderr.slice(0, 500)
+      });
       throw new Error(`LSP server exited immediately with code ${this.proc.exitCode}` + (stderr ? `
 stderr: ${stderr}` : ""));
     }
+    log("[lsp] LSPClient.start: server spawned", { server: this.server.id });
   }
   startStderrReading() {
     if (!this.proc)
@@ -33048,6 +34387,10 @@ stderr: ${stderr}` : ""));
   async initialize() {
     if (!this.connection)
       throw new Error("LSP connection not established");
+    log("[lsp] LSPClient.initialize: sending initialize request", {
+      server: this.server.id,
+      root: this.root
+    });
     const rootUri = pathToFileURL(this.root).href;
     await this.connection.sendRequest("initialize", {
       processId: process.pid,
@@ -33079,14 +34422,22 @@ stderr: ${stderr}` : ""));
     });
     this.connection.sendNotification("initialized");
     await new Promise((r) => setTimeout(r, 300));
+    log("[lsp] LSPClient.initialize: complete", { server: this.server.id });
   }
   async openFile(filePath) {
-    const absPath = resolve(filePath);
-    if (this.openedFiles.has(absPath))
+    const absPath = resolve2(filePath);
+    if (this.openedFiles.has(absPath)) {
+      log("[lsp] openFile: already open, skipping", { filePath: absPath });
       return;
+    }
     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,
@@ -33099,7 +34450,7 @@ stderr: ${stderr}` : ""));
     await new Promise((r) => setTimeout(r, 1000));
   }
   async definition(filePath, line, character) {
-    const absPath = resolve(filePath);
+    const absPath = resolve2(filePath);
     await this.openFile(absPath);
     return this.connection?.sendRequest("textDocument/definition", {
       textDocument: { uri: pathToFileURL(absPath).href },
@@ -33107,7 +34458,7 @@ stderr: ${stderr}` : ""));
     });
   }
   async references(filePath, line, character, includeDeclaration = true) {
-    const absPath = resolve(filePath);
+    const absPath = resolve2(filePath);
     await this.openFile(absPath);
     return this.connection?.sendRequest("textDocument/references", {
       textDocument: { uri: pathToFileURL(absPath).href },
@@ -33116,7 +34467,7 @@ stderr: ${stderr}` : ""));
     });
   }
   async diagnostics(filePath) {
-    const absPath = resolve(filePath);
+    const absPath = resolve2(filePath);
     const uri = pathToFileURL(absPath).href;
     await this.openFile(absPath);
     await new Promise((r) => setTimeout(r, 500));
@@ -33131,7 +34482,7 @@ stderr: ${stderr}` : ""));
     return { items: this.diagnosticsStore.get(uri) ?? [] };
   }
   async rename(filePath, line, character, newName) {
-    const absPath = resolve(filePath);
+    const absPath = resolve2(filePath);
     await this.openFile(absPath);
     return this.connection?.sendRequest("textDocument/rename", {
       textDocument: { uri: pathToFileURL(absPath).href },
@@ -33143,6 +34494,7 @@ stderr: ${stderr}` : ""));
     return this.proc !== null && !this.processExited && this.proc.exitCode === null;
   }
   async stop() {
+    log("[lsp] LSPClient.stop: stopping", { server: this.server.id });
     try {
       if (this.connection) {
         await this.connection.sendRequest("shutdown");
@@ -33155,45 +34507,24 @@ stderr: ${stderr}` : ""));
     this.connection = null;
     this.processExited = true;
     this.diagnosticsStore.clear();
+    log("[lsp] LSPClient.stop: complete", { server: this.server.id });
   }
 }
 // src/tools/lsp/utils.ts
 import {
-  existsSync as existsSync10,
+  existsSync as existsSync9,
   readFileSync as readFileSync5,
-  statSync as statSync3,
-  unlinkSync as unlinkSync3,
+  statSync as statSync4,
+  unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync3
 } from "fs";
-import { dirname as dirname4, extname as extname2, join as join12, resolve as resolve2 } from "path";
+import { dirname as dirname5, extname as extname2, join as join10, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-function findWorkspaceRoot(filePath) {
-  let dir = resolve2(filePath);
-  try {
-    if (!statSync3(dir).isDirectory()) {
-      dir = dirname4(dir);
-    }
-  } catch {
-    dir = dirname4(dir);
-  }
-  const markers = [
-    ".git",
-    "package.json",
-    "pyproject.toml",
-    "Cargo.toml",
-    "go.mod"
-  ];
-  let prevDir = "";
-  while (dir !== prevDir) {
-    for (const marker of markers) {
-      if (existsSync10(join12(dir, marker))) {
-        return dir;
-      }
-    }
-    prevDir = dir;
-    dir = dirname4(dir);
+function findServerProjectRoot(filePath, server) {
+  if (server.root) {
+    return server.root(filePath) ?? dirname5(resolve3(filePath));
   }
-  return dirname4(resolve2(filePath));
+  return dirname5(resolve3(filePath));
 }
 function uriToPath(uri) {
   return fileURLToPath2(uri);
@@ -33212,24 +34543,42 @@ function formatServerLookupError(result) {
   return `No LSP server configured for extension: ${result.extension}`;
 }
 async function withLspClient(filePath, fn) {
-  const absPath = resolve2(filePath);
+  const absPath = resolve3(filePath);
   const ext = extname2(absPath);
   const result = findServerForExtension(ext);
   if (result.status !== "found") {
+    log("[lsp] withLspClient: server not found", {
+      filePath: absPath,
+      extension: ext
+    });
     throw new Error(formatServerLookupError(result));
   }
   const server = result.server;
-  const root = findWorkspaceRoot(absPath);
+  const root = findServerProjectRoot(absPath, server) ?? dirname5(absPath);
+  log("[lsp] withLspClient: acquiring client", {
+    filePath: absPath,
+    server: server.id,
+    root
+  });
   const client = await lspManager.getClient(root, server);
   try {
-    return await fn(client);
+    const result2 = await fn(client);
+    log("[lsp] withLspClient: operation complete", { server: server.id });
+    return result2;
   } catch (e) {
     if (e instanceof Error && e.message.includes("timeout")) {
       const isInitializing = lspManager.isServerInitializing(root, server.id);
       if (isInitializing) {
+        log("[lsp] withLspClient: timeout during init", {
+          server: server.id
+        });
         throw new Error(`LSP server is still initializing. Please retry in a few seconds.`);
       }
     }
+    log("[lsp] withLspClient: operation failed", {
+      server: server.id,
+      error: String(e)
+    });
     throw e;
   } finally {
     lspManager.releaseClient(root, server.id);
@@ -33313,6 +34662,7 @@ function applyTextEditsToFile(filePath, edits) {
 }
 function applyWorkspaceEdit(edit) {
   if (!edit) {
+    log("[lsp] applyWorkspaceEdit: no edit provided");
     return {
       success: false,
       filesModified: [],
@@ -33320,6 +34670,8 @@ function applyWorkspaceEdit(edit) {
       errors: ["No edit provided"]
     };
   }
+  const changeCount = (edit.changes ? Object.keys(edit.changes).length : 0) + (edit.documentChanges ? edit.documentChanges.length : 0);
+  log("[lsp] applyWorkspaceEdit: applying", { changeCount });
   const result = {
     success: true,
     filesModified: [],
@@ -33357,7 +34709,7 @@ function applyWorkspaceEdit(edit) {
             const newPath = uriToPath(change.newUri);
             const content = readFileSync5(oldPath, "utf-8");
             writeFileSync3(newPath, content, "utf-8");
-            unlinkSync3(oldPath);
+            unlinkSync2(oldPath);
             result.filesModified.push(newPath);
           } catch (err) {
             result.success = false;
@@ -33366,7 +34718,7 @@ function applyWorkspaceEdit(edit) {
         } else if (change.kind === "delete") {
           try {
             const filePath = uriToPath(change.uri);
-            unlinkSync3(filePath);
+            unlinkSync2(filePath);
             result.filesModified.push(filePath);
           } catch (err) {
             result.success = false;
@@ -33386,6 +34738,12 @@ function applyWorkspaceEdit(edit) {
       }
     }
   }
+  log("[lsp] applyWorkspaceEdit: complete", {
+    success: result.success,
+    filesModified: result.filesModified.length,
+    totalEdits: result.totalEdits,
+    errors: result.errors.length
+  });
   return result;
 }
 function formatApplyResult(result) {
@@ -33534,6 +34892,28 @@ var OhMyOpenCodeLite = async (ctx) => {
       modelArrayMap[agentDef.name] = agentDef._modelArray;
     }
   }
+  const runtimeChains = {};
+  for (const agentDef of agentDefs) {
+    if (agentDef._modelArray?.length) {
+      runtimeChains[agentDef.name] = agentDef._modelArray.map((m) => m.id);
+    }
+  }
+  if (config3.fallback?.enabled !== false) {
+    const chains = config3.fallback?.chains ?? {};
+    for (const [agentName, chainModels] of Object.entries(chains)) {
+      if (!chainModels?.length)
+        continue;
+      const existing = runtimeChains[agentName] ?? [];
+      const seen = new Set(existing);
+      for (const m of chainModels) {
+        if (!seen.has(m)) {
+          seen.add(m);
+          existing.push(m);
+        }
+      }
+      runtimeChains[agentName] = existing;
+    }
+  }
   const tmuxConfig = {
     enabled: config3.tmux?.enabled ?? false,
     layout: config3.tmux?.layout ?? "main-vertical",
@@ -33549,6 +34929,7 @@ var OhMyOpenCodeLite = async (ctx) => {
   }
   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 autoUpdateChecker = createAutoUpdateCheckerHook(ctx, {
@@ -33556,26 +34937,31 @@ var OhMyOpenCodeLite = async (ctx) => {
     autoUpdate: true
   });
   const phaseReminderHook = createPhaseReminderHook();
-  const postReadNudgeHook = createPostReadNudgeHook();
+  const postFileToolNudgeHook = createPostFileToolNudgeHook();
   const chatHeadersHook = createChatHeadersHook(ctx);
   const delegateTaskRetryHook = createDelegateTaskRetryHook(ctx);
   const jsonErrorRecoveryHook = createJsonErrorRecoveryHook(ctx);
+  const foregroundFallback = new ForegroundFallbackManager(ctx.client, runtimeChains, config3.fallback?.enabled !== false && Object.keys(runtimeChains).length > 0);
   return {
     name: "oh-my-opencode-slim",
     agent: agents,
     tool: {
       ...backgroundTools,
+      ...councilTools,
       lsp_goto_definition,
       lsp_find_references,
       lsp_diagnostics,
       lsp_rename,
-      grep,
       ast_grep_search,
       ast_grep_replace
     },
     mcp: mcps,
     config: async (opencodeConfig) => {
-      opencodeConfig.default_agent = "orchestrator";
+      const lspConfig = opencodeConfig.lsp;
+      setUserLspConfig(lspConfig);
+      if (config3.setDefaultAgent !== false && !opencodeConfig.default_agent) {
+        opencodeConfig.default_agent = "orchestrator";
+      }
       if (!opencodeConfig.agent) {
         opencodeConfig.agent = { ...agents };
       } else {
@@ -33594,38 +34980,45 @@ var OhMyOpenCodeLite = async (ctx) => {
         }
       }
       const configAgent = opencodeConfig.agent;
-      if (Object.keys(modelArrayMap).length > 0) {
-        const providerConfig = opencodeConfig.provider ?? {};
-        const configuredProviders = Object.keys(providerConfig);
-        for (const [agentName, modelArray] of Object.entries(modelArrayMap)) {
-          let resolved = false;
-          for (const modelEntry of modelArray) {
-            const slashIdx = modelEntry.id.indexOf("/");
-            if (slashIdx === -1)
-              continue;
-            const providerID = modelEntry.id.slice(0, slashIdx);
-            if (configuredProviders.includes(providerID)) {
-              const entry = configAgent[agentName];
-              if (entry) {
-                entry.model = modelEntry.id;
-                if (modelEntry.variant) {
-                  entry.variant = modelEntry.variant;
-                }
-              }
-              log("[plugin] resolved model fallback", {
-                agent: agentName,
-                model: modelEntry.id,
-                variant: modelEntry.variant
-              });
-              resolved = true;
-              break;
-            }
+      const fallbackChainsEnabled = config3.fallback?.enabled !== false;
+      const fallbackChains = fallbackChainsEnabled ? config3.fallback?.chains ?? {} : {};
+      const effectiveArrays = {};
+      for (const [agentName, models] of Object.entries(modelArrayMap)) {
+        effectiveArrays[agentName] = [...models];
+      }
+      for (const [agentName, chainModels] of Object.entries(fallbackChains)) {
+        if (!chainModels || chainModels.length === 0)
+          continue;
+        if (!effectiveArrays[agentName]) {
+          const entry = configAgent[agentName];
+          const currentModel = typeof entry?.model === "string" ? entry.model : undefined;
+          effectiveArrays[agentName] = currentModel ? [{ id: currentModel }] : [];
+        }
+        const seen = new Set(effectiveArrays[agentName].map((m) => m.id));
+        for (const chainModel of chainModels) {
+          if (!seen.has(chainModel)) {
+            seen.add(chainModel);
+            effectiveArrays[agentName].push({ id: chainModel });
           }
-          if (!resolved) {
-            log("[plugin] no provider match for model array", {
-              agent: agentName
-            });
+        }
+      }
+      if (Object.keys(effectiveArrays).length > 0) {
+        for (const [agentName, modelArray] of Object.entries(effectiveArrays)) {
+          if (modelArray.length === 0)
+            continue;
+          const chosen = modelArray[0];
+          const entry = configAgent[agentName];
+          if (entry) {
+            entry.model = chosen.id;
+            if (chosen.variant) {
+              entry.variant = chosen.variant;
+            }
           }
+          log("[plugin] resolved model from array", {
+            agent: agentName,
+            model: chosen.id,
+            variant: chosen.variant
+          });
         }
       }
       const configMcp = opencodeConfig.mcp;
@@ -33657,6 +35050,7 @@ var OhMyOpenCodeLite = async (ctx) => {
       }
     },
     event: async (input) => {
+      await foregroundFallback.handleEvent(input.event);
       await autoUpdateChecker.event(input);
       await tmuxSessionManager.onSessionCreated(input.event);
       await backgroundManager.handleSessionStatus(input.event);
@@ -33669,7 +35063,7 @@ var OhMyOpenCodeLite = async (ctx) => {
     "tool.execute.after": async (input, output) => {
       await delegateTaskRetryHook["tool.execute.after"](input, output);
       await jsonErrorRecoveryHook["tool.execute.after"](input, output);
-      await postReadNudgeHook["tool.execute.after"](input, output);
+      await postFileToolNudgeHook["tool.execute.after"](input, output);
     }
   };
 };