@smart-coders-hq/opencode-model-fallback 1.0.3 → 1.0.5

package/dist/index.js

@@ -1,288 +1,10 @@
 // src/plugin.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, writeFileSync } from "fs";
-import { dirname as dirname2, join as join4 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
 import { homedir as homedir5 } from "os";
-
-// src/config/loader.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { basename as basename2, join as join3 } from "path";
-import { homedir as homedir4 } from "os";
-
-// src/config/schema.ts
-import { z } from "zod";
-import { homedir as homedir2 } from "os";
-import { isAbsolute, relative, resolve } from "path";
-
-// src/config/defaults.ts
-import { homedir } from "os";
-import { join } from "path";
-var DEFAULT_PATTERNS = [
-  "rate limit",
-  "usage limit",
-  "too many requests",
-  "quota exceeded",
-  "overloaded",
-  "capacity exceeded",
-  "credits exhausted",
-  "billing limit",
-  "429"
-];
-var DEFAULT_LOG_PATH = join(homedir(), ".local/share/opencode/logs/model-fallback.log");
-var DEFAULT_CONFIG = {
-  enabled: true,
-  defaults: {
-    fallbackOn: ["rate_limit", "quota_exceeded", "5xx", "timeout", "overloaded"],
-    cooldownMs: 300000,
-    retryOriginalAfterMs: 900000,
-    maxFallbackDepth: 3
-  },
-  agents: {
-    "*": {
-      fallbackModels: []
-    }
-  },
-  patterns: DEFAULT_PATTERNS,
-  logging: true,
-  logPath: DEFAULT_LOG_PATH,
-  agentDirs: []
-};
-
-// src/config/schema.ts
-var MODEL_KEY_RE = /^[a-zA-Z0-9_-]{1,100}\/[a-zA-Z0-9._-]{1,100}$/;
-var home = resolve(homedir2());
-function formatPath(path) {
-  return path.map((segment) => String(segment)).join(".");
-}
-function normalizeLogPath(path) {
-  if (path.startsWith("~/")) {
-    return resolve(home, path.slice(2));
-  }
-  return resolve(path);
-}
-function isPathWithinHome(path) {
-  const rel = relative(home, path);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
-}
-var modelKey = z.string().regex(MODEL_KEY_RE, "Model key must be 'providerID/modelID'");
-var agentConfig = z.object({
-  fallbackModels: z.array(modelKey).min(1)
-});
-var fallbackDefaults = z.object({
-  fallbackOn: z.array(z.enum(["rate_limit", "quota_exceeded", "5xx", "timeout", "overloaded"])).optional(),
-  cooldownMs: z.number().min(1e4).optional(),
-  retryOriginalAfterMs: z.number().min(1e4).optional(),
-  maxFallbackDepth: z.number().int().min(1).max(10).optional()
-});
-var logPathSchema = z.string().refine((p) => isPathWithinHome(normalizeLogPath(p)), "logPath must resolve within $HOME");
-var pluginConfigSchema = z.object({
-  enabled: z.boolean().optional(),
-  defaults: fallbackDefaults.optional(),
-  agents: z.record(z.string(), agentConfig).optional(),
-  patterns: z.array(z.string()).optional(),
-  logging: z.boolean().optional(),
-  logPath: logPathSchema.optional(),
-  agentDirs: z.array(z.string()).optional()
-}).strict();
-function parseConfig(raw) {
-  const warnings = [];
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
-    warnings.push("Config warning at root: expected object — using default");
-    return { config: {}, warnings };
-  }
-  const obj = raw;
-  const allowed = new Set([
-    "enabled",
-    "defaults",
-    "agents",
-    "patterns",
-    "logging",
-    "logPath",
-    "agentDirs"
-  ]);
-  for (const key of Object.keys(obj)) {
-    if (!allowed.has(key)) {
-      warnings.push(`Config warning at ${key}: unknown field — using default`);
-    }
-  }
-  const config = {};
-  const enabledResult = z.boolean().safeParse(obj.enabled);
-  if (obj.enabled !== undefined) {
-    if (enabledResult.success) {
-      config.enabled = enabledResult.data;
-    } else {
-      warnings.push(`Config warning at enabled: ${enabledResult.error.issues[0].message} — using default`);
-    }
-  }
-  if (obj.defaults !== undefined) {
-    if (!obj.defaults || typeof obj.defaults !== "object" || Array.isArray(obj.defaults)) {
-      warnings.push("Config warning at defaults: expected object — using default");
-    } else {
-      const defaultsObj = obj.defaults;
-      const parsedDefaults = {};
-      const fallbackOnResult = fallbackDefaults.shape.fallbackOn.safeParse(defaultsObj.fallbackOn);
-      if (defaultsObj.fallbackOn !== undefined) {
-        if (fallbackOnResult.success && fallbackOnResult.data !== undefined) {
-          parsedDefaults.fallbackOn = fallbackOnResult.data;
-        } else if (!fallbackOnResult.success) {
-          for (const issue of fallbackOnResult.error.issues) {
-            const suffix = issue.path.length > 0 ? `.${formatPath(issue.path)}` : "";
-            warnings.push(`Config warning at defaults.fallbackOn${suffix}: ${issue.message} — using default`);
-          }
-        }
-      }
-      const cooldownResult = fallbackDefaults.shape.cooldownMs.safeParse(defaultsObj.cooldownMs);
-      if (defaultsObj.cooldownMs !== undefined) {
-        if (cooldownResult.success && cooldownResult.data !== undefined) {
-          parsedDefaults.cooldownMs = cooldownResult.data;
-        } else if (!cooldownResult.success) {
-          for (const issue of cooldownResult.error.issues) {
-            const suffix = issue.path.length > 0 ? `.${formatPath(issue.path)}` : "";
-            warnings.push(`Config warning at defaults.cooldownMs${suffix}: ${issue.message} — using default`);
-          }
-        }
-      }
-      const retryResult = fallbackDefaults.shape.retryOriginalAfterMs.safeParse(defaultsObj.retryOriginalAfterMs);
-      if (defaultsObj.retryOriginalAfterMs !== undefined) {
-        if (retryResult.success && retryResult.data !== undefined) {
-          parsedDefaults.retryOriginalAfterMs = retryResult.data;
-        } else if (!retryResult.success) {
-          for (const issue of retryResult.error.issues) {
-            const suffix = issue.path.length > 0 ? `.${formatPath(issue.path)}` : "";
-            warnings.push(`Config warning at defaults.retryOriginalAfterMs${suffix}: ${issue.message} — using default`);
-          }
-        }
-      }
-      const depthResult = fallbackDefaults.shape.maxFallbackDepth.safeParse(defaultsObj.maxFallbackDepth);
-      if (defaultsObj.maxFallbackDepth !== undefined) {
-        if (depthResult.success && depthResult.data !== undefined) {
-          parsedDefaults.maxFallbackDepth = depthResult.data;
-        } else if (!depthResult.success) {
-          for (const issue of depthResult.error.issues) {
-            const suffix = issue.path.length > 0 ? `.${formatPath(issue.path)}` : "";
-            warnings.push(`Config warning at defaults.maxFallbackDepth${suffix}: ${issue.message} — using default`);
-          }
-        }
-      }
-      for (const key of Object.keys(defaultsObj)) {
-        if (!Object.hasOwn(fallbackDefaults.shape, key)) {
-          warnings.push(`Config warning at defaults.${key}: unknown field — using default`);
-        }
-      }
-      if (Object.keys(parsedDefaults).length > 0) {
-        config.defaults = parsedDefaults;
-      }
-    }
-  }
-  if (obj.agents !== undefined) {
-    if (!obj.agents || typeof obj.agents !== "object" || Array.isArray(obj.agents)) {
-      warnings.push("Config warning at agents: expected object — using default");
-    } else {
-      const parsedAgents = {};
-      for (const [agentName, agentValue] of Object.entries(obj.agents)) {
-        const agentResult = agentConfig.safeParse(agentValue);
-        if (agentResult.success) {
-          parsedAgents[agentName] = agentResult.data;
-          continue;
-        }
-        for (const issue of agentResult.error.issues) {
-          const suffix = issue.path.length > 0 ? `.${formatPath(issue.path)}` : "";
-          warnings.push(`Config warning at agents.${agentName}${suffix}: ${issue.message} — using default`);
-        }
-      }
-      config.agents = parsedAgents;
-    }
-  }
-  if (obj.patterns !== undefined) {
-    const patternsResult = z.array(z.string()).safeParse(obj.patterns);
-    if (patternsResult.success) {
-      config.patterns = patternsResult.data;
-    } else {
-      for (const issue of patternsResult.error.issues) {
-        const suffix = issue.path.length > 0 ? `.${formatPath(issue.path)}` : "";
-        warnings.push(`Config warning at patterns${suffix}: ${issue.message} — using default`);
-      }
-    }
-  }
-  if (obj.logging !== undefined) {
-    const loggingResult = z.boolean().safeParse(obj.logging);
-    if (loggingResult.success) {
-      config.logging = loggingResult.data;
-    } else {
-      warnings.push(`Config warning at logging: ${loggingResult.error.issues[0].message} — using default`);
-    }
-  }
-  if (obj.logPath !== undefined) {
-    const logPathResult = logPathSchema.safeParse(obj.logPath);
-    if (logPathResult.success) {
-      config.logPath = obj.logPath;
-    } else {
-      for (const issue of logPathResult.error.issues) {
-        const suffix = issue.path.length > 0 ? `.${formatPath(issue.path)}` : "";
-        warnings.push(`Config warning at logPath${suffix}: ${issue.message} — using default`);
-      }
-    }
-  }
-  if (obj.agentDirs !== undefined) {
-    const agentDirsResult = z.array(z.string()).safeParse(obj.agentDirs);
-    if (agentDirsResult.success) {
-      config.agentDirs = agentDirsResult.data;
-    } else {
-      for (const issue of agentDirsResult.error.issues) {
-        const suffix = issue.path.length > 0 ? `.${formatPath(issue.path)}` : "";
-        warnings.push(`Config warning at agentDirs${suffix}: ${issue.message} — using default`);
-      }
-    }
-  }
-  return { config, warnings };
-}
-function mergeWithDefaults(raw) {
-  const def = DEFAULT_CONFIG;
-  const logPath = raw.logPath ? normalizeLogPath(raw.logPath) : def.logPath;
-  return {
-    enabled: raw.enabled ?? def.enabled,
-    defaults: {
-      fallbackOn: raw.defaults?.fallbackOn ?? def.defaults.fallbackOn,
-      cooldownMs: raw.defaults?.cooldownMs ?? def.defaults.cooldownMs,
-      retryOriginalAfterMs: raw.defaults?.retryOriginalAfterMs ?? def.defaults.retryOriginalAfterMs,
-      maxFallbackDepth: raw.defaults?.maxFallbackDepth ?? def.defaults.maxFallbackDepth
-    },
-    agents: raw.agents ?? def.agents,
-    patterns: raw.patterns ?? def.patterns,
-    logging: raw.logging ?? def.logging,
-    logPath,
-    agentDirs: raw.agentDirs ?? def.agentDirs
-  };
-}
-
-// src/config/migrate.ts
-function isOldFormat(raw) {
-  if (typeof raw !== "object" || raw === null)
-    return false;
-  return "fallbackModel" in raw && typeof raw.fallbackModel === "string";
-}
-function migrateOldConfig(old) {
-  const migrated = {};
-  if (typeof old.enabled === "boolean")
-    migrated.enabled = old.enabled;
-  if (typeof old.logging === "boolean")
-    migrated.logging = old.logging;
-  if (Array.isArray(old.patterns))
-    migrated.patterns = old.patterns;
-  if (old.fallbackModel) {
-    migrated.agents = {
-      "*": { fallbackModels: [old.fallbackModel] }
-    };
-  }
-  if (typeof old.cooldownMs === "number") {
-    migrated.defaults = { cooldownMs: old.cooldownMs };
-  }
-  return migrated;
-}
+import { dirname as dirname2, join as join4 } from "path";
 
 // src/config/agent-loader.ts
-import { existsSync, readFileSync, readdirSync, realpathSync, statSync } from "fs";
-import { homedir as homedir3 } from "os";
-import { basename, extname, isAbsolute as isAbsolute2, join as join2, relative as relative2, resolve as resolve2 } from "path";
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "fs";
 
 // node_modules/js-yaml/dist/js-yaml.mjs
 /*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT */
@@ -2970,22 +2692,24 @@ var jsYaml = {
 };
 
 // src/config/agent-loader.ts
-var MODEL_KEY_RE2 = /^[a-zA-Z0-9_-]{1,100}\/[a-zA-Z0-9._-]{1,100}$/;
+import { homedir } from "os";
+import { basename, extname, isAbsolute, join, relative, resolve } from "path";
+var MODEL_KEY_RE = /^[a-zA-Z0-9_-]{1,100}\/[a-zA-Z0-9._-]{1,100}$/;
 function isPathInside(baseDir, targetPath) {
-  const rel = relative2(baseDir, targetPath);
-  return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
+  const rel = relative(baseDir, targetPath);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
 }
-function toRelativeAgentPath(absPath, projectDirectory, homeDir = homedir3()) {
-  const resolvedAbs = resolve2(absPath);
-  const configBase = resolve2(join2(homeDir, ".config", "opencode"));
-  const projectBase = resolve2(projectDirectory);
+function toRelativeAgentPath(absPath, projectDirectory, homeDir = homedir()) {
+  const resolvedAbs = resolve(absPath);
+  const configBase = resolve(join(homeDir, ".config", "opencode"));
+  const projectBase = resolve(projectDirectory);
   if (isPathInside(configBase, resolvedAbs)) {
-    const rel = relative2(configBase, resolvedAbs);
+    const rel = relative(configBase, resolvedAbs);
     if (rel)
       return rel;
   }
   if (isPathInside(projectBase, resolvedAbs)) {
-    const rel = relative2(projectBase, resolvedAbs);
+    const rel = relative(projectBase, resolvedAbs);
     if (rel)
       return rel;
   }
@@ -2999,7 +2723,7 @@ function stemName(filePath) {
 function collectFiles(dir, recursive) {
   if (!existsSync(dir))
     return [];
-  const baseDir = resolve2(dir);
+  const baseDir = resolve(dir);
   let baseRealPath = baseDir;
   try {
     baseRealPath = realpathSync(baseDir);
@@ -3014,7 +2738,7 @@ function collectFiles(dir, recursive) {
       entries = readdirSync(baseDir);
     }
     return entries.filter((e) => e.endsWith(".md") || e.endsWith(".json")).map((e) => {
-      const candidatePath = resolve2(join2(baseDir, e));
+      const candidatePath = resolve(join(baseDir, e));
       if (!isPathInside(baseDir, candidatePath))
         return null;
       try {
@@ -3066,8 +2790,8 @@ function parseAgentFile(filePath) {
       return null;
     const validModels = [];
     for (const m of models) {
-      if (typeof m !== "string" || !MODEL_KEY_RE2.test(m)) {
-        console.warn(`[model-fallback] agent-loader: skipping invalid model key ${JSON.stringify(m)} in ${filePath}`);
+      if (typeof m !== "string" || !MODEL_KEY_RE.test(m)) {
+        console.warn(`[model-fallback] agent-loader: skipping invalid model key ${JSON.stringify(m)} in ${basename(filePath)}`);
         continue;
       }
       validModels.push(m);
@@ -3077,16 +2801,16 @@ function parseAgentFile(filePath) {
     const name = typeof obj.name === "string" && obj.name.length > 0 ? obj.name : stemName(filePath);
     return { name, config: { fallbackModels: validModels } };
   } catch (err) {
-    console.warn(`[model-fallback] agent-loader: failed to parse ${filePath}:`, err);
+    console.warn(`[model-fallback] agent-loader: failed to parse ${basename(filePath)}:`, err);
     return null;
   }
 }
-function resolveAgentFile(agentName, projectDirectory, customDirs, homeDir = homedir3()) {
+function resolveAgentFile(agentName, projectDirectory, customDirs, homeDir = homedir()) {
   const scanDirs = customDirs && customDirs.length > 0 ? customDirs.map((d) => [d, false]) : [
-    [join2(homeDir, ".config", "opencode", "agents"), false],
-    [join2(homeDir, ".config", "opencode", "agent"), true],
-    [join2(projectDirectory, ".opencode", "agents"), false],
-    [join2(projectDirectory, ".opencode", "agent"), true]
+    [join(homeDir, ".config", "opencode", "agents"), false],
+    [join(homeDir, ".config", "opencode", "agent"), true],
+    [join(projectDirectory, ".opencode", "agents"), false],
+    [join(projectDirectory, ".opencode", "agent"), true]
   ];
   const allFiles = [];
   for (const [dir, recursive] of scanDirs) {
@@ -3107,12 +2831,12 @@ function resolveAgentFile(agentName, projectDirectory, customDirs, homeDir = hom
   }
   return null;
 }
-function loadAgentFallbackConfigs(projectDirectory, homeDir = homedir3()) {
+function loadAgentFallbackConfigs(projectDirectory, homeDir = homedir()) {
   const scanDirs = [
-    [join2(homeDir, ".config", "opencode", "agents"), false],
-    [join2(homeDir, ".config", "opencode", "agent"), true],
-    [join2(projectDirectory, ".opencode", "agents"), false],
-    [join2(projectDirectory, ".opencode", "agent"), true]
+    [join(homeDir, ".config", "opencode", "agents"), false],
+    [join(homeDir, ".config", "opencode", "agent"), true],
+    [join(projectDirectory, ".opencode", "agents"), false],
+    [join(projectDirectory, ".opencode", "agent"), true]
   ];
   const result = {};
   for (const [dir, recursive] of scanDirs) {
@@ -3127,6 +2851,292 @@ function loadAgentFallbackConfigs(projectDirectory, homeDir = homedir3()) {
   return result;
 }
 
+// src/config/loader.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { homedir as homedir4 } from "os";
+import { basename as basename2, join as join3 } from "path";
+
+// src/config/defaults.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var DEFAULT_PATTERNS = [
+  "rate limit",
+  "usage limit",
+  "too many requests",
+  "quota exceeded",
+  "overloaded",
+  "capacity exceeded",
+  "credits exhausted",
+  "billing limit",
+  "429"
+];
+var DEFAULT_LOG_PATH = join2(homedir2(), ".local/share/opencode/logs/model-fallback.log");
+var DEFAULT_CONFIG = {
+  enabled: true,
+  defaults: {
+    fallbackOn: ["rate_limit", "quota_exceeded", "5xx", "timeout", "overloaded"],
+    cooldownMs: 300000,
+    retryOriginalAfterMs: 900000,
+    maxFallbackDepth: 3
+  },
+  agents: {
+    "*": {
+      fallbackModels: []
+    }
+  },
+  patterns: DEFAULT_PATTERNS,
+  logging: true,
+  logLevel: "info",
+  logPath: DEFAULT_LOG_PATH,
+  agentDirs: []
+};
+
+// src/config/migrate.ts
+function isOldFormat(raw) {
+  if (typeof raw !== "object" || raw === null)
+    return false;
+  return "fallbackModel" in raw && typeof raw.fallbackModel === "string";
+}
+function migrateOldConfig(old) {
+  const migrated = {};
+  if (typeof old.enabled === "boolean")
+    migrated.enabled = old.enabled;
+  if (typeof old.logging === "boolean")
+    migrated.logging = old.logging;
+  if (Array.isArray(old.patterns))
+    migrated.patterns = old.patterns;
+  if (old.fallbackModel) {
+    migrated.agents = {
+      "*": { fallbackModels: [old.fallbackModel] }
+    };
+  }
+  if (typeof old.cooldownMs === "number") {
+    migrated.defaults = { cooldownMs: old.cooldownMs };
+  }
+  return migrated;
+}
+
+// src/config/schema.ts
+import { homedir as homedir3 } from "os";
+import { isAbsolute as isAbsolute2, relative as relative2, resolve as resolve2 } from "path";
+import { z } from "zod";
+var MODEL_KEY_RE2 = /^[a-zA-Z0-9_-]{1,100}\/[a-zA-Z0-9._-]{1,100}$/;
+var home = resolve2(homedir3());
+function formatPath(path) {
+  return path.map((segment) => String(segment)).join(".");
+}
+function normalizeLogPath(path) {
+  if (path.startsWith("~/")) {
+    return resolve2(home, path.slice(2));
+  }
+  return resolve2(path);
+}
+function isPathWithinHome(path) {
+  const rel = relative2(home, path);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
+}
+var modelKey = z.string().regex(MODEL_KEY_RE2, "Model key must be 'providerID/modelID'");
+var agentConfig = z.object({
+  fallbackModels: z.array(modelKey).min(1)
+});
+var fallbackDefaults = z.object({
+  fallbackOn: z.array(z.enum(["rate_limit", "quota_exceeded", "5xx", "timeout", "overloaded"])).optional(),
+  cooldownMs: z.number().min(1e4).optional(),
+  retryOriginalAfterMs: z.number().min(1e4).optional(),
+  maxFallbackDepth: z.number().int().min(1).max(10).optional()
+});
+var logPathSchema = z.string().refine((p) => isPathWithinHome(normalizeLogPath(p)), "logPath must resolve within $HOME");
+var pluginConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  defaults: fallbackDefaults.optional(),
+  agents: z.record(z.string(), agentConfig).optional(),
+  patterns: z.array(z.string()).optional(),
+  logging: z.boolean().optional(),
+  logLevel: z.enum(["debug", "info"]).optional(),
+  logPath: logPathSchema.optional(),
+  agentDirs: z.array(z.string()).optional()
+}).strict();
+function parseConfig(raw) {
+  const warnings = [];
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    warnings.push("Config warning at root: expected object — using default");
+    return { config: {}, warnings };
+  }
+  const obj = raw;
+  const allowed = new Set([
+    "enabled",
+    "defaults",
+    "agents",
+    "patterns",
+    "logging",
+    "logLevel",
+    "logPath",
+    "agentDirs"
+  ]);
+  for (const key of Object.keys(obj)) {
+    if (!allowed.has(key)) {
+      warnings.push(`Config warning at ${key}: unknown field — using default`);
+    }
+  }
+  const config = {};
+  const enabledResult = z.boolean().safeParse(obj.enabled);
+  if (obj.enabled !== undefined) {
+    if (enabledResult.success) {
+      config.enabled = enabledResult.data;
+    } else {
+      warnings.push(`Config warning at enabled: ${enabledResult.error.issues[0].message} — using default`);
+    }
+  }
+  if (obj.defaults !== undefined) {
+    if (!obj.defaults || typeof obj.defaults !== "object" || Array.isArray(obj.defaults)) {
+      warnings.push("Config warning at defaults: expected object — using default");
+    } else {
+      const defaultsObj = obj.defaults;
+      const parsedDefaults = {};
+      const fallbackOnResult = fallbackDefaults.shape.fallbackOn.safeParse(defaultsObj.fallbackOn);
+      if (defaultsObj.fallbackOn !== undefined) {
+        if (fallbackOnResult.success && fallbackOnResult.data !== undefined) {
+          parsedDefaults.fallbackOn = fallbackOnResult.data;
+        } else if (!fallbackOnResult.success) {
+          for (const issue of fallbackOnResult.error.issues) {
+            const suffix = issue.path.length > 0 ? `.${formatPath(issue.path)}` : "";
+            warnings.push(`Config warning at defaults.fallbackOn${suffix}: ${issue.message} — using default`);
+          }
+        }
+      }
+      const cooldownResult = fallbackDefaults.shape.cooldownMs.safeParse(defaultsObj.cooldownMs);
+      if (defaultsObj.cooldownMs !== undefined) {
+        if (cooldownResult.success && cooldownResult.data !== undefined) {
+          parsedDefaults.cooldownMs = cooldownResult.data;
+        } else if (!cooldownResult.success) {
+          for (const issue of cooldownResult.error.issues) {
+            const suffix = issue.path.length > 0 ? `.${formatPath(issue.path)}` : "";
+            warnings.push(`Config warning at defaults.cooldownMs${suffix}: ${issue.message} — using default`);
+          }
+        }
+      }
+      const retryResult = fallbackDefaults.shape.retryOriginalAfterMs.safeParse(defaultsObj.retryOriginalAfterMs);
+      if (defaultsObj.retryOriginalAfterMs !== undefined) {
+        if (retryResult.success && retryResult.data !== undefined) {
+          parsedDefaults.retryOriginalAfterMs = retryResult.data;
+        } else if (!retryResult.success) {
+          for (const issue of retryResult.error.issues) {
+            const suffix = issue.path.length > 0 ? `.${formatPath(issue.path)}` : "";
+            warnings.push(`Config warning at defaults.retryOriginalAfterMs${suffix}: ${issue.message} — using default`);
+          }
+        }
+      }
+      const depthResult = fallbackDefaults.shape.maxFallbackDepth.safeParse(defaultsObj.maxFallbackDepth);
+      if (defaultsObj.maxFallbackDepth !== undefined) {
+        if (depthResult.success && depthResult.data !== undefined) {
+          parsedDefaults.maxFallbackDepth = depthResult.data;
+        } else if (!depthResult.success) {
+          for (const issue of depthResult.error.issues) {
+            const suffix = issue.path.length > 0 ? `.${formatPath(issue.path)}` : "";
+            warnings.push(`Config warning at defaults.maxFallbackDepth${suffix}: ${issue.message} — using default`);
+          }
+        }
+      }
+      for (const key of Object.keys(defaultsObj)) {
+        if (!Object.hasOwn(fallbackDefaults.shape, key)) {
+          warnings.push(`Config warning at defaults.${key}: unknown field — using default`);
+        }
+      }
+      if (Object.keys(parsedDefaults).length > 0) {
+        config.defaults = parsedDefaults;
+      }
+    }
+  }
+  if (obj.agents !== undefined) {
+    if (!obj.agents || typeof obj.agents !== "object" || Array.isArray(obj.agents)) {
+      warnings.push("Config warning at agents: expected object — using default");
+    } else {
+      const parsedAgents = {};
+      for (const [agentName, agentValue] of Object.entries(obj.agents)) {
+        const agentResult = agentConfig.safeParse(agentValue);
+        if (agentResult.success) {
+          parsedAgents[agentName] = agentResult.data;
+          continue;
+        }
+        for (const issue of agentResult.error.issues) {
+          const suffix = issue.path.length > 0 ? `.${formatPath(issue.path)}` : "";
+          warnings.push(`Config warning at agents.${agentName}${suffix}: ${issue.message} — using default`);
+        }
+      }
+      config.agents = parsedAgents;
+    }
+  }
+  if (obj.patterns !== undefined) {
+    const patternsResult = z.array(z.string()).safeParse(obj.patterns);
+    if (patternsResult.success) {
+      config.patterns = patternsResult.data;
+    } else {
+      for (const issue of patternsResult.error.issues) {
+        const suffix = issue.path.length > 0 ? `.${formatPath(issue.path)}` : "";
+        warnings.push(`Config warning at patterns${suffix}: ${issue.message} — using default`);
+      }
+    }
+  }
+  if (obj.logging !== undefined) {
+    const loggingResult = z.boolean().safeParse(obj.logging);
+    if (loggingResult.success) {
+      config.logging = loggingResult.data;
+    } else {
+      warnings.push(`Config warning at logging: ${loggingResult.error.issues[0].message} — using default`);
+    }
+  }
+  if (obj.logLevel !== undefined) {
+    const logLevelResult = z.enum(["debug", "info"]).safeParse(obj.logLevel);
+    if (logLevelResult.success) {
+      config.logLevel = logLevelResult.data;
+    } else {
+      warnings.push(`Config warning at logLevel: ${logLevelResult.error.issues[0].message} — using default`);
+    }
+  }
+  if (obj.logPath !== undefined) {
+    const logPathResult = logPathSchema.safeParse(obj.logPath);
+    if (logPathResult.success) {
+      config.logPath = obj.logPath;
+    } else {
+      for (const issue of logPathResult.error.issues) {
+        const suffix = issue.path.length > 0 ? `.${formatPath(issue.path)}` : "";
+        warnings.push(`Config warning at logPath${suffix}: ${issue.message} — using default`);
+      }
+    }
+  }
+  if (obj.agentDirs !== undefined) {
+    const agentDirsResult = z.array(z.string()).safeParse(obj.agentDirs);
+    if (agentDirsResult.success) {
+      config.agentDirs = agentDirsResult.data;
+    } else {
+      for (const issue of agentDirsResult.error.issues) {
+        const suffix = issue.path.length > 0 ? `.${formatPath(issue.path)}` : "";
+        warnings.push(`Config warning at agentDirs${suffix}: ${issue.message} — using default`);
+      }
+    }
+  }
+  return { config, warnings };
+}
+function mergeWithDefaults(raw) {
+  const def = DEFAULT_CONFIG;
+  const logPath = raw.logPath ? normalizeLogPath(raw.logPath) : def.logPath;
+  return {
+    enabled: raw.enabled ?? def.enabled,
+    defaults: {
+      fallbackOn: raw.defaults?.fallbackOn ?? def.defaults.fallbackOn,
+      cooldownMs: raw.defaults?.cooldownMs ?? def.defaults.cooldownMs,
+      retryOriginalAfterMs: raw.defaults?.retryOriginalAfterMs ?? def.defaults.retryOriginalAfterMs,
+      maxFallbackDepth: raw.defaults?.maxFallbackDepth ?? def.defaults.maxFallbackDepth
+    },
+    agents: raw.agents ?? def.agents,
+    patterns: raw.patterns ?? def.patterns,
+    logging: raw.logging ?? def.logging,
+    logLevel: raw.logLevel ?? def.logLevel,
+    logPath,
+    agentDirs: raw.agentDirs ?? def.agentDirs
+  };
+}
+
 // src/config/loader.ts
 var CONFIG_FILENAME = "model-fallback.json";
 var OLD_CONFIG_FILENAME = "rate-limit-fallback.json";
@@ -3164,281 +3174,24 @@ function loadConfig(directory) {
       raw = migrateOldConfig(raw);
     }
     const { config: parsed, warnings } = parseConfig(raw);
-    const merged = mergeWithDefaults(parsed);
-    merged.agents = { ...agentFileConfigs, ...merged.agents };
-    return {
-      config: merged,
-      path: candidate,
-      warnings,
-      migrated: isOld
-    };
-  }
-  return {
-    config: {
-      ...DEFAULT_CONFIG,
-      agents: { ...agentFileConfigs, ...DEFAULT_CONFIG.agents }
-    },
-    path: null,
-    warnings: [],
-    migrated: false
-  };
-}
-
-// src/logging/logger.ts
-import { appendFileSync, mkdirSync } from "fs";
-import { dirname } from "path";
-
-class Logger {
-  client;
-  logPath;
-  enabled;
-  dirCreated = false;
-  constructor(client, logPath, enabled) {
-    this.client = client;
-    this.logPath = logPath;
-    this.enabled = enabled;
-  }
-  log(level, event, fields = {}) {
-    const entry = {
-      ts: new Date().toISOString(),
-      level,
-      event,
-      ...fields
-    };
-    if (this.enabled) {
-      this.writeToFile(entry);
-    }
-    if (level !== "debug") {
-      const message = `[model-fallback] ${event}${Object.keys(fields).length ? " " + JSON.stringify(fields) : ""}`;
-      this.client.app.log({
-        body: { service: "model-fallback", level, message }
-      }).catch(() => {});
-    }
-  }
-  info(event, fields) {
-    this.log("info", event, fields);
-  }
-  warn(event, fields) {
-    this.log("warn", event, fields);
-  }
-  error(event, fields) {
-    this.log("error", event, fields);
-  }
-  debug(event, fields) {
-    this.log("debug", event, fields);
-  }
-  writeToFile(entry) {
-    try {
-      if (!this.dirCreated) {
-        mkdirSync(dirname(this.logPath), { recursive: true });
-        this.dirCreated = true;
-      }
-      appendFileSync(this.logPath, JSON.stringify(entry) + `
-`, "utf-8");
-    } catch {}
-  }
-}
-
-// src/state/model-health.ts
-class ModelHealthStore {
-  store = new Map;
-  timer = null;
-  onTransition;
-  constructor(opts) {
-    this.onTransition = opts?.onTransition;
-    this.timer = setInterval(() => this.tick(), 30000);
-  }
-  get(modelKey2) {
-    return this.store.get(modelKey2) ?? this.newHealth(modelKey2);
-  }
-  markRateLimited(modelKey2, cooldownMs, retryOriginalAfterMs) {
-    const now = Date.now();
-    const existing = this.get(modelKey2);
-    const health = {
-      ...existing,
-      state: "rate_limited",
-      lastFailure: now,
-      failureCount: existing.failureCount + 1,
-      cooldownExpiresAt: now + cooldownMs,
-      retryOriginalAt: now + retryOriginalAfterMs
-    };
-    this.store.set(modelKey2, health);
-  }
-  isUsable(modelKey2) {
-    const h = this.get(modelKey2);
-    return h.state === "healthy" || h.state === "cooldown";
-  }
-  preferScore(modelKey2) {
-    const state = this.get(modelKey2).state;
-    if (state === "healthy")
-      return 2;
-    if (state === "cooldown")
-      return 1;
-    return 0;
-  }
-  getAll() {
-    return Array.from(this.store.values());
-  }
-  destroy() {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-  }
-  tick() {
-    const now = Date.now();
-    for (const [key, health] of this.store) {
-      if (health.state === "rate_limited" && health.cooldownExpiresAt && now >= health.cooldownExpiresAt) {
-        const next = { ...health, state: "cooldown" };
-        this.store.set(key, next);
-        this.onTransition?.(key, "rate_limited", "cooldown");
-      } else if (health.state === "cooldown" && health.retryOriginalAt && now >= health.retryOriginalAt) {
-        const next = {
-          ...health,
-          state: "healthy",
-          cooldownExpiresAt: null,
-          retryOriginalAt: null
-        };
-        this.store.set(key, next);
-        this.onTransition?.(key, "cooldown", "healthy");
-      }
-    }
-  }
-  newHealth(modelKey2) {
-    return {
-      modelKey: modelKey2,
-      state: "healthy",
-      lastFailure: null,
-      failureCount: 0,
-      cooldownExpiresAt: null,
-      retryOriginalAt: null
-    };
-  }
-}
-
-// src/state/session-state.ts
-class SessionStateStore {
-  store = new Map;
-  get(sessionId) {
-    if (!this.store.has(sessionId)) {
-      this.store.set(sessionId, this.newState(sessionId));
-    }
-    return this.store.get(sessionId);
-  }
-  acquireLock(sessionId) {
-    const state = this.get(sessionId);
-    if (state.isProcessing)
-      return false;
-    state.isProcessing = true;
-    return true;
-  }
-  releaseLock(sessionId) {
-    const state = this.store.get(sessionId);
-    if (state)
-      state.isProcessing = false;
-  }
-  isInDedupWindow(sessionId, windowMs = 3000) {
-    const state = this.get(sessionId);
-    if (!state.lastFallbackAt)
-      return false;
-    return Date.now() - state.lastFallbackAt < windowMs;
-  }
-  recordFallback(sessionId, fromModel, toModel, reason, agentName) {
-    const state = this.get(sessionId);
-    const event = {
-      at: Date.now(),
-      fromModel,
-      toModel,
-      reason,
-      sessionId,
-      trigger: "reactive",
-      agentName
-    };
-    state.currentModel = toModel;
-    state.fallbackDepth++;
-    state.lastFallbackAt = event.at;
-    state.recoveryNotifiedForModel = null;
-    state.fallbackHistory.push(event);
-    if (agentName)
-      state.agentName = agentName;
-  }
-  recordPreemptiveRedirect(sessionId, fromModel, toModel, agentName) {
-    const state = this.get(sessionId);
-    const event = {
-      at: Date.now(),
-      fromModel,
-      toModel,
-      reason: "rate_limit",
-      sessionId,
-      trigger: "preemptive",
-      agentName
-    };
-    state.currentModel = toModel;
-    state.recoveryNotifiedForModel = null;
-    state.fallbackHistory.push(event);
-    if (agentName)
-      state.agentName = agentName;
-  }
-  setOriginalModel(sessionId, model) {
-    const state = this.get(sessionId);
-    if (!state.originalModel) {
-      state.originalModel = model;
-      state.currentModel = model;
-    }
-  }
-  setAgentName(sessionId, agentName) {
-    const state = this.get(sessionId);
-    state.agentName = agentName;
-  }
-  setAgentFile(sessionId, agentFile) {
-    const state = this.get(sessionId);
-    state.agentFile = agentFile;
-  }
-  partialReset(sessionId) {
-    const state = this.store.get(sessionId);
-    if (!state)
-      return;
-    state.fallbackHistory = [];
-    state.lastFallbackAt = null;
-    state.isProcessing = false;
-  }
-  delete(sessionId) {
-    this.store.delete(sessionId);
-  }
-  getAll() {
-    return Array.from(this.store.values());
-  }
-  newState(sessionId) {
+    const merged = mergeWithDefaults(parsed);
+    merged.agents = { ...agentFileConfigs, ...merged.agents };
     return {
-      sessionId,
-      agentName: null,
-      agentFile: null,
-      originalModel: null,
-      currentModel: null,
-      fallbackDepth: 0,
-      isProcessing: false,
-      lastFallbackAt: null,
-      fallbackHistory: [],
-      recoveryNotifiedForModel: null
+      config: merged,
+      path: candidate,
+      warnings,
+      migrated: isOld
     };
   }
-}
-
-// src/state/store.ts
-class FallbackStore {
-  health;
-  sessions;
-  constructor(_config, logger) {
-    this.sessions = new SessionStateStore;
-    this.health = new ModelHealthStore({
-      onTransition: (modelKey2, from, to) => {
-        logger.info("health.transition", { modelKey: modelKey2, from, to });
-      }
-    });
-  }
-  destroy() {
-    this.health.destroy();
-  }
+  return {
+    config: {
+      ...DEFAULT_CONFIG,
+      agents: { ...agentFileConfigs, ...DEFAULT_CONFIG.agents }
+    },
+    path: null,
+    warnings: [],
+    migrated: false
+  };
 }
 
 // src/detection/patterns.ts
@@ -3494,6 +3247,107 @@ function classifyError(message, statusCode) {
   return "unknown";
 }
 
+// src/display/notifier.ts
+async function notifyFallback(client, from, to, reason) {
+  const fromLabel = from ? shortModelName(from) : "current model";
+  const message = `Model fallback: switched from ${fromLabel} to ${shortModelName(to)} (${reason})`;
+  await client.tui.showToast({
+    body: {
+      title: "Model Fallback",
+      message,
+      variant: "warning",
+      duration: 6000
+    }
+  }).catch(() => {});
+}
+async function notifyFallbackActive(client, originalModel, currentModel) {
+  const message = `Using ${shortModelName(currentModel)} (fallback from ${shortModelName(originalModel)})`;
+  await client.tui.showToast({
+    body: {
+      title: "Fallback Active",
+      message,
+      variant: "warning",
+      duration: 4000
+    }
+  }).catch(() => {});
+}
+async function notifyRecovery(client, originalModel) {
+  const message = `Original model ${shortModelName(originalModel)} is available again`;
+  await client.tui.showToast({
+    body: {
+      title: "Model Recovered",
+      message,
+      variant: "info",
+      duration: 5000
+    }
+  }).catch(() => {});
+}
+function shortModelName(key) {
+  const parts = key.split("/");
+  return parts.length > 1 ? parts.slice(1).join("/") : key;
+}
+
+// src/logging/logger.ts
+import { appendFileSync, existsSync as existsSync3, mkdirSync, writeFileSync } from "fs";
+import { dirname } from "path";
+
+class Logger {
+  client;
+  logPath;
+  enabled;
+  minLevel;
+  dirCreated = false;
+  constructor(client, logPath, enabled, minLevel = "info") {
+    this.client = client;
+    this.logPath = logPath;
+    this.enabled = enabled;
+    this.minLevel = minLevel;
+  }
+  log(level, event, fields = {}) {
+    const entry = {
+      ts: new Date().toISOString(),
+      level,
+      event,
+      ...fields
+    };
+    const shouldWrite = this.enabled && (this.minLevel === "debug" || level !== "debug");
+    if (shouldWrite) {
+      this.writeToFile(entry);
+    }
+    if (level !== "debug") {
+      const message = `[model-fallback] ${event}${Object.keys(fields).length ? " " + JSON.stringify(fields) : ""}`;
+      this.client.app.log({
+        body: { service: "model-fallback", level, message }
+      }).catch(() => {});
+    }
+  }
+  info(event, fields) {
+    this.log("info", event, fields);
+  }
+  warn(event, fields) {
+    this.log("warn", event, fields);
+  }
+  error(event, fields) {
+    this.log("error", event, fields);
+  }
+  debug(event, fields) {
+    this.log("debug", event, fields);
+  }
+  writeToFile(entry) {
+    try {
+      if (!this.dirCreated) {
+        mkdirSync(dirname(this.logPath), { recursive: true, mode: 448 });
+        this.dirCreated = true;
+      }
+      if (!existsSync3(this.logPath)) {
+        writeFileSync(this.logPath, "", { mode: 384 });
+      }
+      appendFileSync(this.logPath, JSON.stringify(entry) + `
+`, "utf-8");
+    } catch {}
+  }
+}
+
 // src/resolution/agent-resolver.ts
 async function resolveAgentName(client, sessionId, cachedName) {
   if (cachedName)
@@ -3533,10 +3387,53 @@ function resolveFallbackModel(chain, currentModel, health) {
   return null;
 }
 
+// src/preemptive.ts
+function tryPreemptiveRedirect(sessionId, modelKey2, agentName, store, config, logger) {
+  const sessionState = store.sessions.get(sessionId);
+  store.sessions.setOriginalModel(sessionId, modelKey2);
+  if (sessionState.currentModel !== modelKey2) {
+    const wasOnFallback = sessionState.currentModel !== null && sessionState.currentModel !== sessionState.originalModel;
+    sessionState.currentModel = modelKey2;
+    if (wasOnFallback && modelKey2 === sessionState.originalModel) {
+      sessionState.fallbackDepth = 0;
+      logger.debug("preemptive.depth.reset", { sessionId, modelKey: modelKey2 });
+    }
+  }
+  const health = store.health.get(modelKey2);
+  if (health.state !== "rate_limited") {
+    return { redirected: false };
+  }
+  const chain = resolveFallbackModels(config, agentName);
+  if (chain.length === 0) {
+    logger.debug("preemptive.no-chain", { sessionId, agentName });
+    return { redirected: false };
+  }
+  const fallbackModel = resolveFallbackModel(chain, modelKey2, store.health);
+  if (!fallbackModel) {
+    logger.debug("preemptive.all-exhausted", { sessionId });
+    return { redirected: false };
+  }
+  logger.info("preemptive.redirect", {
+    sessionId,
+    agentName,
+    agentFile: sessionState.agentFile,
+    from: modelKey2,
+    to: fallbackModel
+  });
+  store.sessions.recordPreemptiveRedirect(sessionId, modelKey2, fallbackModel, agentName);
+  return { redirected: true, fallbackModel };
+}
+
 // src/replay/message-converter.ts
 function convertPartsForPrompt(parts) {
   const result = [];
+  if (!parts || !Array.isArray(parts)) {
+    return result;
+  }
   for (const part of parts) {
+    if (!part || typeof part !== "object" || !("type" in part)) {
+      continue;
+    }
     if (part.type === "text") {
       if (part.synthetic || part.ignored)
         continue;
@@ -3689,86 +3586,250 @@ async function attemptFallback(sessionId, reason, client, store, config, logger,
     if (promptParts.length === 0) {
       promptParts.push({ type: "text", text: "" });
     }
-    const [providerID, ...rest] = fallbackModel.split("/");
-    const modelID = rest.join("/");
-    try {
-      await client.session.prompt({
-        path: { id: sessionId },
-        body: {
-          model: { providerID, modelID },
-          agent: agentName ?? undefined,
-          parts: promptParts
-        }
-      });
-      logger.debug("replay.prompt.ok", { sessionId, fallbackModel });
-    } catch (err) {
-      logger.error("replay.prompt.failed", {
-        sessionId,
-        fallbackModel,
-        err: String(err)
-      });
-      return { success: false, error: "prompt failed" };
+    const [providerID, ...rest] = fallbackModel.split("/");
+    const modelID = rest.join("/");
+    try {
+      await client.session.prompt({
+        path: { id: sessionId },
+        body: {
+          model: { providerID, modelID },
+          agent: agentName ?? undefined,
+          parts: promptParts
+        }
+      });
+      logger.debug("replay.prompt.ok", { sessionId, fallbackModel });
+    } catch (err) {
+      logger.error("replay.prompt.failed", {
+        sessionId,
+        fallbackModel,
+        err: String(err)
+      });
+      return { success: false, error: "prompt failed" };
+    }
+    const newDepth = sessionState.fallbackDepth + 1;
+    store.sessions.recordFallback(sessionId, currentModel ?? fallbackModel, fallbackModel, reason, agentName);
+    logger.info("fallback.success", {
+      sessionId,
+      agentName,
+      agentFile: store.sessions.get(sessionId).agentFile,
+      from: currentModel,
+      to: fallbackModel,
+      reason,
+      depth: newDepth
+    });
+    return { success: true, fallbackModel };
+  } finally {
+    store.sessions.releaseLock(sessionId);
+  }
+}
+function sanitizeParts(parts) {
+  if (!Array.isArray(parts))
+    return [];
+  return parts.filter((part) => typeof part === "object" && part !== null && ("type" in part));
+}
+
+// src/state/model-health.ts
+class ModelHealthStore {
+  store = new Map;
+  timer = null;
+  onTransition;
+  constructor(opts) {
+    this.onTransition = opts?.onTransition;
+    this.timer = setInterval(() => this.tick(), 30000);
+  }
+  get(modelKey2) {
+    return this.store.get(modelKey2) ?? this.newHealth(modelKey2);
+  }
+  markRateLimited(modelKey2, cooldownMs, retryOriginalAfterMs) {
+    const now = Date.now();
+    const existing = this.get(modelKey2);
+    const health = {
+      ...existing,
+      state: "rate_limited",
+      lastFailure: now,
+      failureCount: existing.failureCount + 1,
+      cooldownExpiresAt: now + cooldownMs,
+      retryOriginalAt: now + retryOriginalAfterMs
+    };
+    this.store.set(modelKey2, health);
+  }
+  isUsable(modelKey2) {
+    const h = this.get(modelKey2);
+    return h.state === "healthy" || h.state === "cooldown";
+  }
+  preferScore(modelKey2) {
+    const state = this.get(modelKey2).state;
+    if (state === "healthy")
+      return 2;
+    if (state === "cooldown")
+      return 1;
+    return 0;
+  }
+  getAll() {
+    return Array.from(this.store.values());
+  }
+  destroy() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  tick() {
+    const now = Date.now();
+    for (const [key, health] of this.store) {
+      if (health.state === "rate_limited" && health.cooldownExpiresAt && now >= health.cooldownExpiresAt) {
+        const next = { ...health, state: "cooldown" };
+        this.store.set(key, next);
+        this.onTransition?.(key, "rate_limited", "cooldown");
+      } else if (health.state === "cooldown" && health.retryOriginalAt && now >= health.retryOriginalAt) {
+        const next = {
+          ...health,
+          state: "healthy",
+          cooldownExpiresAt: null,
+          retryOriginalAt: null
+        };
+        this.store.set(key, next);
+        this.onTransition?.(key, "cooldown", "healthy");
+      }
     }
-    const newDepth = sessionState.fallbackDepth + 1;
-    store.sessions.recordFallback(sessionId, currentModel ?? fallbackModel, fallbackModel, reason, agentName);
-    logger.info("fallback.success", {
-      sessionId,
-      agentName,
-      agentFile: store.sessions.get(sessionId).agentFile,
-      from: currentModel,
-      to: fallbackModel,
-      reason,
-      depth: newDepth
-    });
-    return { success: true, fallbackModel };
-  } finally {
-    store.sessions.releaseLock(sessionId);
   }
-}
-function sanitizeParts(parts) {
-  if (!Array.isArray(parts))
-    return [];
-  return parts.filter((part) => typeof part === "object" && part !== null && ("type" in part));
+  newHealth(modelKey2) {
+    return {
+      modelKey: modelKey2,
+      state: "healthy",
+      lastFailure: null,
+      failureCount: 0,
+      cooldownExpiresAt: null,
+      retryOriginalAt: null
+    };
+  }
 }
 
-// src/display/notifier.ts
-async function notifyFallback(client, from, to, reason) {
-  const fromLabel = from ? shortModelName(from) : "current model";
-  const message = `Model fallback: switched from ${fromLabel} to ${shortModelName(to)} (${reason})`;
-  await client.tui.showToast({
-    body: {
-      title: "Model Fallback",
-      message,
-      variant: "warning",
-      duration: 6000
-    }
-  }).catch(() => {});
-}
-async function notifyFallbackActive(client, originalModel, currentModel) {
-  const message = `Using ${shortModelName(currentModel)} (fallback from ${shortModelName(originalModel)})`;
-  await client.tui.showToast({
-    body: {
-      title: "Fallback Active",
-      message,
-      variant: "warning",
-      duration: 4000
+// src/state/session-state.ts
+class SessionStateStore {
+  store = new Map;
+  get(sessionId) {
+    let state = this.store.get(sessionId);
+    if (!state) {
+      state = this.newState(sessionId);
+      this.store.set(sessionId, state);
     }
-  }).catch(() => {});
-}
-async function notifyRecovery(client, originalModel) {
-  const message = `Original model ${shortModelName(originalModel)} is available again`;
-  await client.tui.showToast({
-    body: {
-      title: "Model Recovered",
-      message,
-      variant: "info",
-      duration: 5000
+    return state;
+  }
+  acquireLock(sessionId) {
+    const state = this.get(sessionId);
+    if (state.isProcessing)
+      return false;
+    state.isProcessing = true;
+    return true;
+  }
+  releaseLock(sessionId) {
+    const state = this.store.get(sessionId);
+    if (state)
+      state.isProcessing = false;
+  }
+  isInDedupWindow(sessionId, windowMs = 3000) {
+    const state = this.get(sessionId);
+    if (!state.lastFallbackAt)
+      return false;
+    return Date.now() - state.lastFallbackAt < windowMs;
+  }
+  recordFallback(sessionId, fromModel, toModel, reason, agentName) {
+    const state = this.get(sessionId);
+    const event = {
+      at: Date.now(),
+      fromModel,
+      toModel,
+      reason,
+      sessionId,
+      trigger: "reactive",
+      agentName
+    };
+    state.currentModel = toModel;
+    state.fallbackDepth++;
+    state.lastFallbackAt = event.at;
+    state.recoveryNotifiedForModel = null;
+    state.fallbackHistory.push(event);
+    if (agentName)
+      state.agentName = agentName;
+  }
+  recordPreemptiveRedirect(sessionId, fromModel, toModel, agentName) {
+    const state = this.get(sessionId);
+    const event = {
+      at: Date.now(),
+      fromModel,
+      toModel,
+      reason: "rate_limit",
+      sessionId,
+      trigger: "preemptive",
+      agentName
+    };
+    state.currentModel = toModel;
+    state.recoveryNotifiedForModel = null;
+    state.fallbackHistory.push(event);
+    if (agentName)
+      state.agentName = agentName;
+  }
+  setOriginalModel(sessionId, model) {
+    const state = this.get(sessionId);
+    if (!state.originalModel) {
+      state.originalModel = model;
+      state.currentModel = model;
     }
-  }).catch(() => {});
+  }
+  setAgentName(sessionId, agentName) {
+    const state = this.get(sessionId);
+    state.agentName = agentName;
+  }
+  setAgentFile(sessionId, agentFile) {
+    const state = this.get(sessionId);
+    state.agentFile = agentFile;
+  }
+  partialReset(sessionId) {
+    const state = this.store.get(sessionId);
+    if (!state)
+      return;
+    state.fallbackHistory = [];
+    state.lastFallbackAt = null;
+    state.isProcessing = false;
+  }
+  delete(sessionId) {
+    this.store.delete(sessionId);
+  }
+  getAll() {
+    return Array.from(this.store.values());
+  }
+  newState(sessionId) {
+    return {
+      sessionId,
+      agentName: null,
+      agentFile: null,
+      originalModel: null,
+      currentModel: null,
+      fallbackDepth: 0,
+      isProcessing: false,
+      lastFallbackAt: null,
+      fallbackHistory: [],
+      recoveryNotifiedForModel: null
+    };
+  }
 }
-function shortModelName(key) {
-  const parts = key.split("/");
-  return parts.length > 1 ? parts.slice(1).join("/") : key;
+
+// src/state/store.ts
+class FallbackStore {
+  health;
+  sessions;
+  constructor(_config, logger) {
+    this.sessions = new SessionStateStore;
+    this.health = new ModelHealthStore({
+      onTransition: (modelKey2, from, to) => {
+        logger.info("health.transition", { modelKey: modelKey2, from, to });
+      }
+    });
+  }
+  destroy() {
+    this.health.destroy();
+  }
 }
 
 // src/tools/fallback-status.ts
@@ -3947,50 +4008,15 @@ function getLastUserModelAndAgent(data) {
   return null;
 }
 
-// src/preemptive.ts
-function tryPreemptiveRedirect(sessionId, modelKey2, agentName, store, config, logger) {
-  const sessionState = store.sessions.get(sessionId);
-  store.sessions.setOriginalModel(sessionId, modelKey2);
-  if (sessionState.currentModel !== modelKey2) {
-    const wasOnFallback = sessionState.currentModel !== null && sessionState.currentModel !== sessionState.originalModel;
-    sessionState.currentModel = modelKey2;
-    if (wasOnFallback && modelKey2 === sessionState.originalModel) {
-      sessionState.fallbackDepth = 0;
-      logger.debug("preemptive.depth.reset", { sessionId, modelKey: modelKey2 });
-    }
-  }
-  const health = store.health.get(modelKey2);
-  if (health.state !== "rate_limited") {
-    return { redirected: false };
-  }
-  const chain = resolveFallbackModels(config, agentName);
-  if (chain.length === 0) {
-    logger.debug("preemptive.no-chain", { sessionId, agentName });
-    return { redirected: false };
-  }
-  const fallbackModel = resolveFallbackModel(chain, modelKey2, store.health);
-  if (!fallbackModel) {
-    logger.debug("preemptive.all-exhausted", { sessionId });
-    return { redirected: false };
-  }
-  logger.info("preemptive.redirect", {
-    sessionId,
-    from: modelKey2,
-    to: fallbackModel
-  });
-  store.sessions.recordPreemptiveRedirect(sessionId, modelKey2, fallbackModel, agentName);
-  return { redirected: true, fallbackModel };
-}
-
 // src/plugin.ts
 var createPlugin = async ({ client, directory }) => {
   const { config, path: configPath, warnings, migrated } = loadConfig(directory);
-  const logger = new Logger(client, config.logPath, config.logging);
+  const logger = new Logger(client, config.logPath, config.logging, config.logLevel);
   const cmdPath = join4(homedir5(), ".config/opencode/commands/fallback-status.md");
   try {
-    if (!existsSync3(cmdPath)) {
+    if (!existsSync4(cmdPath)) {
       mkdirSync2(dirname2(cmdPath), { recursive: true });
-      writeFileSync(cmdPath, `Call the fallback-status tool and display the full output.
+      writeFileSync2(cmdPath, `Call the fallback-status tool and display the full output.
 `);
     }
   } catch (err) {
@@ -4060,6 +4086,7 @@ var createPlugin = async ({ client, directory }) => {
   return hooks;
 };
 async function handleEvent(event, client, store, config, logger, directory) {
+  logger.debug("event.received", { type: event.type });
   if (event.type === "session.status") {
     const { sessionID, status } = event.properties;
     if (status.type === "retry") {
@@ -4101,6 +4128,7 @@ async function handleEvent(event, client, store, config, logger, directory) {
 }
 async function handleRetry(sessionId, message, client, store, config, logger, directory) {
   if (!matchesAnyPattern(message, config.patterns)) {
+    logger.debug("retry.nomatch", { sessionId, message });
     return;
   }
   const category = classifyError(message);