oh-my-opencode-slim 0.8.2 → 0.8.4

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,243 @@ 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: join11, 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 + join11(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 getConfigDir() {
+  const customConfigDir = getCustomOpenCodeConfigDir();
+  if (customConfigDir) {
+    return customConfigDir;
+  }
+  return getDefaultOpenCodeConfigDir();
+}
+function getOpenCodeConfigPaths() {
+  const configDir = getDefaultOpenCodeConfigDir();
+  return [join(configDir, "opencode.json"), join(configDir, "opencode.jsonc")];
+}
+
 // src/cli/custom-skills.ts
 var CUSTOM_SKILLS = [
   {
@@ -3377,11 +3614,11 @@ var SUBAGENT_DELEGATION_RULES = {
 };
 var DEFAULT_MODELS = {
   orchestrator: undefined,
-  oracle: "openai/gpt-5.2-codex",
-  librarian: "openai/gpt-5.1-codex-mini",
-  explorer: "openai/gpt-5.1-codex-mini",
-  designer: "kimi-for-coding/k2p5",
-  fixer: "openai/gpt-5.1-codex-mini"
+  oracle: "openai/gpt-5.4",
+  librarian: "openai/gpt-5.4-mini",
+  explorer: "openai/gpt-5.4-mini",
+  designer: "openai/gpt-5.4-mini",
+  fixer: "openai/gpt-5.4-mini"
 };
 var POLL_INTERVAL_BACKGROUND_MS = 2000;
 var DEFAULT_TIMEOUT_MS = 2 * 60 * 1000;
@@ -3389,21 +3626,8 @@ 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"],
@@ -5682,7 +5906,7 @@ class Doc {
 var version = {
   major: 4,
   minor: 3,
-  patch: 5
+  patch: 6
 };
 
 // node_modules/zod/v4/core/schemas.js
@@ -6968,7 +7192,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 +14563,7 @@ function finalize(ctx, schema) {
           }
         }
       }
-      if (refSchema.$ref) {
+      if (refSchema.$ref && refSeen.def) {
         for (const key in schema2) {
           if (key === "$ref" || key === "allOf")
             continue;
@@ -17049,10 +17273,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(),
@@ -17066,9 +17292,6 @@ var PluginConfigSchema = exports_external.object({
 
 // 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");
@@ -17116,7 +17339,7 @@ function deepMerge(base, override) {
   return result;
 }
 function loadPluginConfig(directory) {
-  const userConfigBasePath = path.join(getUserConfigDir(), "opencode", "oh-my-opencode-slim");
+  const userConfigBasePath = path.join(getConfigDir(), "oh-my-opencode-slim");
   const projectConfigBasePath = path.join(directory, ".opencode", "oh-my-opencode-slim");
   const userConfigPath = findConfigPath(userConfigBasePath);
   const projectConfigPath = findConfigPath(projectConfigBasePath);
@@ -17149,7 +17372,7 @@ 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 promptsDir = path.join(getConfigDir(), PROMPTS_DIR_NAME);
   const promptSearchDirs = presetDirName ? [path.join(promptsDir, presetDirName), promptsDir] : [promptsDir];
   const result = {};
   const readFirstPrompt = (fileName, errorPrefix) => {
@@ -17700,9 +17923,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();
@@ -18191,14 +18414,23 @@ class BackgroundTaskManager {
       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);
-      })
-    ]);
+    const sessionId = args.path.id;
+    let timer;
+    try {
+      const promptPromise = this.client.session.prompt(args);
+      promptPromise.catch(() => {});
+      await Promise.race([
+        promptPromise,
+        new Promise((_, reject) => {
+          timer = setTimeout(() => {
+            this.client.session.abort({ path: { id: sessionId } }).catch(() => {});
+            reject(new Error(`Prompt timed out after ${timeoutMs}ms`));
+          }, timeoutMs);
+        })
+      ]);
+    } finally {
+      clearTimeout(timer);
+    }
   }
   calculateToolPermissions(agentName) {
     const allowedSubagents = this.getSubagentRules(agentName);
@@ -18242,11 +18474,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 = session.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 +18495,11 @@ class BackgroundTaskManager {
             }
             body.model = ref;
           }
+          if (i > 0) {
+            log(`[background-manager] fallback attempt ${i + 1}/${attemptModels.length}: ${modelLabel}`, { taskId: task.id });
+          }
           await this.promptWithTimeout({
-            path: { id: session.data.id },
+            path: { id: sessionId },
             body,
             query: promptQuery
           }, timeoutMs);
@@ -18268,10 +18507,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 {}
           }
         }
       }
@@ -18639,19 +18885,17 @@ class TmuxSessionManager {
 // src/hooks/auto-update-checker/cache.ts
 import * as fs3 from "fs";
 import * as path4 from "path";
-// src/cli/dynamic-model-selection.ts
-var FREE_BIASED_PROVIDERS = new Set(["opencode"]);
 // 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");
@@ -19188,6 +19432,216 @@ ${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",
@@ -31658,12 +32112,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";
@@ -31688,11 +32142,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() {
@@ -31715,8 +32169,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 {
@@ -31815,7 +32269,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;
@@ -31826,7 +32280,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)) {
@@ -32316,7 +32770,7 @@ 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";
+import { dirname as dirname4, join as join10 } from "path";
 
 // src/tools/grep/downloader.ts
 import {
@@ -32361,7 +32815,7 @@ function getDataDir() {
 }
 function getOpenCodeBundledRg() {
   const execPath = process.execPath;
-  const execDir = dirname3(execPath);
+  const execDir = dirname4(execPath);
   const isWindows = process.platform === "win32";
   const rgName = isWindows ? "rg.exe" : "rg";
   const candidates = [
@@ -32634,17 +33088,47 @@ var grep = tool({
 // 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;
 
 // src/tools/lsp/config.ts
-import { existsSync as existsSync9 } from "fs";
-import { homedir as homedir5 } from "os";
+var import_which = __toESM(require_lib(), 1);
+import { existsSync as existsSync10 } from "fs";
+import { homedir as homedir4 } from "os";
 import { join as join11 } 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 existsSync9, readdirSync as readdirSync2, statSync as statSync3 } from "fs";
+import { dirname as dirname5, resolve } from "path";
 var SEVERITY_MAP = {
   1: "error",
   2: "warning",
@@ -32653,22 +33137,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 = dirname5(dir);
+    }
+  } catch {
+    dir = dirname5(dir);
+  }
+  let prevDir = "";
+  while (dir !== prevDir && dir !== "/") {
+    yield dir;
+    prevDir = dir;
+    if (dir === stop)
+      break;
+    dir = dirname5(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 (existsSync9(`${dir}/${pattern}`)) {
+            return;
+          }
+        }
+      }
+    }
+    for (const dir of walkUpDirectories(file3, cwd)) {
+      for (const pattern of includePatterns) {
+        if (pattern.includes("*")) {
+          try {
+            const entries = readdirSync2(dir);
+            const regex = new RegExp(`^${pattern.replace(/\./g, "\\.").replace(/\*/g, ".*")}$`);
+            if (entries.some((entry) => regex.test(entry))) {
+              return dir;
+            }
+          } catch {}
+        } else if (existsSync9(`${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"],
@@ -32679,54 +33217,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",
@@ -32735,35 +33535,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
       };
@@ -32773,39 +33718,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 existsSync10(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 opencodeBin = join11(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 cwd = process.cwd();
   const localBin = join11(cwd, "node_modules", ".bin", cmd);
-  if (existsSync9(localBin) || existsSync9(localBin + ext)) {
-    return true;
-  }
-  const globalBin = join11(homedir5(), ".config", "opencode", "bin", cmd);
-  if (existsSync9(globalBin) || existsSync9(globalBin + ext)) {
+  if (existsSync10(localBin) || existsSync10(localBin + ext)) {
     return true;
   }
   return false;
@@ -32818,6 +33761,7 @@ class LSPServerManager {
   cleanupInterval = null;
   IDLE_TIMEOUT = 5 * 60 * 1000;
   constructor() {
+    log("[lsp] manager initialized");
     this.startCleanupTimer();
     this.registerProcessCleanup();
   }
@@ -32874,16 +33818,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();
@@ -32903,7 +33862,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;
     }
@@ -32915,6 +33880,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) {
@@ -32923,14 +33893,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();
@@ -32949,6 +33924,11 @@ class LSPClient {
     this.server = server;
   }
   async start() {
+    log("[lsp] LSPClient.start: spawning server", {
+      server: this.server.id,
+      command: this.server.command.join(" "),
+      root: this.root
+    });
     this.proc = spawn5(this.server.command, {
       stdin: "pipe",
       stdout: "pipe",
@@ -33018,13 +33998,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)
@@ -33050,6 +34036,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,
@@ -33081,14 +34071,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,
@@ -33101,7 +34099,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 },
@@ -33109,7 +34107,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 },
@@ -33118,7 +34116,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));
@@ -33133,7 +34131,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 },
@@ -33145,6 +34143,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");
@@ -33157,45 +34156,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 existsSync11,
   readFileSync as readFileSync5,
-  statSync as statSync3,
+  statSync as statSync4,
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync3
 } from "fs";
-import { dirname as dirname4, extname as extname2, join as join12, resolve as resolve2 } from "path";
+import { dirname as dirname6, extname as extname2, join as join12, 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) ?? dirname6(resolve3(filePath));
   }
-  return dirname4(resolve2(filePath));
+  return dirname6(resolve3(filePath));
 }
 function uriToPath(uri) {
   return fileURLToPath2(uri);
@@ -33214,24 +34192,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) ?? dirname6(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);
@@ -33315,6 +34311,7 @@ function applyTextEditsToFile(filePath, edits) {
 }
 function applyWorkspaceEdit(edit) {
   if (!edit) {
+    log("[lsp] applyWorkspaceEdit: no edit provided");
     return {
       success: false,
       filesModified: [],
@@ -33322,6 +34319,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: [],
@@ -33388,6 +34387,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) {
@@ -33536,6 +34541,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",
@@ -33562,6 +34589,7 @@ var OhMyOpenCodeLite = async (ctx) => {
   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,
@@ -33577,43 +34605,96 @@ var OhMyOpenCodeLite = async (ctx) => {
     },
     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 {
-        Object.assign(opencodeConfig.agent, agents);
+        for (const [name, pluginAgent] of Object.entries(agents)) {
+          const existing = opencodeConfig.agent[name];
+          if (existing) {
+            opencodeConfig.agent[name] = {
+              ...pluginAgent,
+              ...existing
+            };
+          } else {
+            opencodeConfig.agent[name] = {
+              ...pluginAgent
+            };
+          }
+        }
       }
       const configAgent = opencodeConfig.agent;
-      if (Object.keys(modelArrayMap).length > 0) {
+      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 (Object.keys(effectiveArrays).length > 0) {
         const providerConfig = opencodeConfig.provider ?? {};
-        const configuredProviders = Object.keys(providerConfig);
-        for (const [agentName, modelArray] of Object.entries(modelArrayMap)) {
+        const hasProviderConfig = Object.keys(providerConfig).length > 0;
+        for (const [agentName, modelArray] of Object.entries(effectiveArrays)) {
+          if (modelArray.length === 0)
+            continue;
           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;
+          if (hasProviderConfig) {
+            const configuredProviders = Object.keys(providerConfig);
+            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;
               }
-              log("[plugin] resolved model fallback", {
-                agent: agentName,
-                model: modelEntry.id,
-                variant: modelEntry.variant
-              });
-              resolved = true;
-              break;
             }
           }
           if (!resolved) {
-            log("[plugin] no provider match for model array", {
-              agent: agentName
+            const firstModel = modelArray[0];
+            const entry = configAgent[agentName];
+            if (entry) {
+              entry.model = firstModel.id;
+              if (firstModel.variant) {
+                entry.variant = firstModel.variant;
+              }
+            }
+            log("[plugin] resolved model from array (no provider config)", {
+              agent: agentName,
+              model: firstModel.id,
+              variant: firstModel.variant
             });
           }
         }
@@ -33647,6 +34728,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);