drizzy-agent 0.4.2 → 0.5.1

package/dist/index.js

@@ -16658,320 +16658,234 @@ function getAgentConfigKey(agentName) {
   return lower;
 }
 
-// src/shared/model-requirements.ts
-var AGENT_MODEL_REQUIREMENTS = {
+// src/shared/agent-model-defaults.ts
+var CLAUDE_PROVIDERS = ["anthropic", "github-copilot", "opencode"];
+var OPENAI_PROVIDERS = ["openai", "github-copilot", "opencode"];
+var OPENAI_NATIVE_PROVIDERS = ["openai", "opencode"];
+var GEMINI_PROVIDERS = ["google", "github-copilot", "opencode"];
+var KIMI_K25_PROVIDERS = ["opencode", "moonshotai", "moonshotai-cn", "firmware", "ollama-cloud", "aihubmix"];
+var AGENT_MODEL_DEFAULTS = {
   coder: {
-    fallbackChain: [
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-opus-4-6",
-        variant: "max"
-      },
+    chain: [
+      { providers: CLAUDE_PROVIDERS, model: "claude-opus-4-6", variant: "max" },
       { providers: ["kimi-for-coding"], model: "k2p5" },
-      {
-        providers: [
-          "opencode",
-          "moonshotai",
-          "moonshotai-cn",
-          "firmware",
-          "ollama-cloud",
-          "aihubmix"
-        ],
-        model: "kimi-k2.5"
-      },
-      { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.4", variant: "medium" },
+      { providers: KIMI_K25_PROVIDERS, model: "kimi-k2.5" },
+      { providers: OPENAI_PROVIDERS, model: "gpt-5.4", variant: "medium" },
       { providers: ["zai-coding-plan", "opencode"], model: "glm-5" },
-      { providers: ["opencode"], model: "big-pickle" }
+      { providers: ["opencode"], model: "big-pickle", alwaysAvailable: true }
     ],
-    requiresAnyModel: true
+    includeInInstall: true,
+    requiresAnyProvider: [
+      "anthropic",
+      "github-copilot",
+      "opencode",
+      "kimi-for-coding",
+      "moonshotai",
+      "moonshotai-cn",
+      "firmware",
+      "ollama-cloud",
+      "aihubmix",
+      "openai",
+      "zai-coding-plan"
+    ]
   },
   gptcoder: {
-    fallbackChain: [
-      {
-        providers: ["openai", "venice", "opencode"],
-        model: "gpt-5.4",
-        variant: "medium"
-      },
+    chain: [
+      { providers: ["openai", "venice", "opencode"], model: "gpt-5.4", variant: "medium" },
       { providers: ["github-copilot"], model: "gpt-5.4", variant: "medium" }
     ],
-    requiresProvider: ["openai", "github-copilot", "venice", "opencode"]
+    includeInInstall: true,
+    requiresAnyProvider: ["openai", "github-copilot", "venice", "opencode"]
+  },
+  planner: {
+    chain: [
+      { providers: CLAUDE_PROVIDERS, model: "claude-opus-4-6", variant: "max" },
+      { providers: ["kimi-for-coding"], model: "k2p5" },
+      { providers: OPENAI_PROVIDERS, model: "gpt-5.4", variant: "high" },
+      { providers: GEMINI_PROVIDERS, model: "gemini-3.1-pro" }
+    ],
+    includeInInstall: true
   },
   oracle: {
-    fallbackChain: [
-      {
-        providers: ["openai", "github-copilot", "opencode"],
-        model: "gpt-5.4",
-        variant: "high"
-      },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3.1-pro",
-        variant: "high"
-      },
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-opus-4-6",
-        variant: "max"
-      }
-    ]
+    chain: [
+      { providers: OPENAI_PROVIDERS, model: "gpt-5.4", variant: "high" },
+      { providers: KIMI_K25_PROVIDERS, model: "kimi-k2.5" },
+      { providers: GEMINI_PROVIDERS, model: "gemini-3.1-pro", variant: "high" },
+      { providers: CLAUDE_PROVIDERS, model: "claude-opus-4-6", variant: "max" },
+      { providers: ["opencode"], model: "big-pickle", alwaysAvailable: true }
+    ],
+    includeInInstall: true
   },
   librarian: {
-    fallbackChain: [
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3-flash"
-      },
-      { providers: ["opencode"], model: "minimax-m2.5-free" },
-      { providers: ["opencode"], model: "big-pickle" }
-    ]
+    chain: [
+      { providers: GEMINI_PROVIDERS, model: "gemini-3-flash" },
+      { providers: ["opencode"], model: "glm-4.7" },
+      { providers: CLAUDE_PROVIDERS, model: "claude-sonnet-4-5" },
+      { providers: ["opencode"], model: "minimax-m2.5-free", alwaysAvailable: true },
+      { providers: ["opencode"], model: "big-pickle", alwaysAvailable: true },
+      { providers: ["opencode"], model: "glm-4.7-free", alwaysAvailable: true }
+    ],
+    includeInInstall: true,
+    specialCases: { zaiOverride: { model: "zai-coding-plan/glm-4.7" }, openAiOnlyOverride: { model: "openai/gpt-5.4", variant: "medium" } }
   },
   explore: {
-    fallbackChain: [
+    chain: [
       { providers: ["github-copilot"], model: "grok-code-fast-1" },
-      { providers: ["opencode"], model: "minimax-m2.5-free" },
+      { providers: ["opencode"], model: "minimax-m2.5-free", alwaysAvailable: true },
       { providers: ["anthropic", "opencode"], model: "claude-haiku-4-5" },
-      { providers: ["opencode"], model: "gpt-5-nano" }
-    ]
+      { providers: ["opencode"], model: "gpt-5-nano", alwaysAvailable: true }
+    ],
+    includeInInstall: true,
+    specialCases: { customResolver: "explore-agent", openAiOnlyOverride: { model: "openai/gpt-5.4", variant: "medium" } }
   },
   "multimodal-looker": {
-    fallbackChain: [
-      {
-        providers: ["openai", "opencode"],
-        model: "gpt-5.4",
-        variant: "medium"
-      },
-      { providers: ["kimi-for-coding"], model: "k2p5" },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3-flash"
-      },
-      { providers: ["zai-coding-plan"], model: "glm-4.6v" },
-      {
-        providers: ["openai", "github-copilot", "opencode"],
-        model: "gpt-5-nano"
-      }
-    ]
-  },
-  planner: {
-    fallbackChain: [
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-opus-4-6",
-        variant: "max"
-      },
-      {
-        providers: ["openai", "github-copilot", "opencode"],
-        model: "gpt-5.4",
-        variant: "high"
-      },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3.1-pro"
-      }
-    ]
+    chain: [{ providers: OPENAI_NATIVE_PROVIDERS, model: "gpt-5.4", variant: "medium" }, { providers: ["kimi-for-coding"], model: "k2p5" }, { providers: GEMINI_PROVIDERS, model: "gemini-3-flash" }, { providers: ["zai-coding-plan"], model: "glm-4.6v" }, { providers: OPENAI_PROVIDERS, model: "gpt-5-nano" }],
+    includeInInstall: true
   },
   planConsultant: {
-    fallbackChain: [
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-opus-4-6",
-        variant: "max"
-      },
-      {
-        providers: ["openai", "github-copilot", "opencode"],
-        model: "gpt-5.4",
-        variant: "high"
-      },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3.1-pro",
-        variant: "high"
-      }
-    ]
+    chain: [{ providers: CLAUDE_PROVIDERS, model: "claude-opus-4-6", variant: "max" }, { providers: ["kimi-for-coding"], model: "k2p5" }, { providers: OPENAI_PROVIDERS, model: "gpt-5.4", variant: "high" }, { providers: GEMINI_PROVIDERS, model: "gemini-3.1-pro", variant: "high" }],
+    includeInInstall: true
   },
   planReviewer: {
-    fallbackChain: [
-      {
-        providers: ["openai", "github-copilot", "opencode"],
-        model: "gpt-5.4",
-        variant: "xhigh"
-      },
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-opus-4-6",
-        variant: "max"
-      },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3.1-pro",
-        variant: "high"
-      }
-    ]
+    chain: [
+      { providers: OPENAI_PROVIDERS, model: "gpt-5.4", variant: "xhigh" },
+      { providers: KIMI_K25_PROVIDERS, model: "kimi-k2.5" },
+      { providers: CLAUDE_PROVIDERS, model: "claude-opus-4-6", variant: "max" },
+      { providers: GEMINI_PROVIDERS, model: "gemini-3.1-pro", variant: "high" },
+      { providers: ["opencode"], model: "big-pickle", alwaysAvailable: true }
+    ],
+    includeInInstall: true
   },
   atlas: {
-    fallbackChain: [
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-sonnet-4-6"
-      },
-      { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.4", variant: "medium" }
-    ]
+    chain: [{ providers: ["kimi-for-coding"], model: "k2p5" }, { providers: CLAUDE_PROVIDERS, model: "claude-sonnet-4-6" }, { providers: CLAUDE_PROVIDERS, model: "claude-sonnet-4-5" }, { providers: OPENAI_PROVIDERS, model: "gpt-5.4", variant: "medium" }, { providers: GEMINI_PROVIDERS, model: "gemini-3.1-pro" }],
+    includeInInstall: true
   },
   "coder-junior": {
-    fallbackChain: [
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-sonnet-4-6"
-      },
-      { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.4", variant: "medium" },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3-flash"
-      }
-    ]
+    chain: [{ providers: CLAUDE_PROVIDERS, model: "claude-sonnet-4-6" }, { providers: OPENAI_PROVIDERS, model: "gpt-5.4", variant: "medium" }, { providers: GEMINI_PROVIDERS, model: "gemini-3-flash" }],
+    includeInInstall: false
   }
 };
-var CATEGORY_MODEL_REQUIREMENTS = {
+var CATEGORY_MODEL_DEFAULTS = {
   "visual-engineering": {
-    fallbackChain: [
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3.1-pro",
-        variant: "high"
-      },
+    chain: [
+      { providers: GEMINI_PROVIDERS, model: "gemini-3.1-pro", variant: "high" },
       { providers: ["zai-coding-plan", "opencode"], model: "glm-5" },
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-opus-4-6",
-        variant: "max"
-      }
-    ]
+      { providers: CLAUDE_PROVIDERS, model: "claude-opus-4-6", variant: "max" },
+      { providers: ["kimi-for-coding"], model: "k2p5" }
+    ],
+    includeInInstall: true,
+    specialCases: { openAiOnlyOverride: { model: "openai/gpt-5.4", variant: "high" } }
   },
   ultrabrain: {
-    fallbackChain: [
-      {
-        providers: ["openai", "opencode"],
-        model: "gpt-5.4",
-        variant: "xhigh"
-      },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3.1-pro",
-        variant: "high"
-      },
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-opus-4-6",
-        variant: "max"
-      }
-    ]
+    chain: [
+      { providers: OPENAI_NATIVE_PROVIDERS, model: "gpt-5.4", variant: "xhigh" },
+      { providers: GEMINI_PROVIDERS, model: "gemini-3.1-pro", variant: "high" },
+      { providers: CLAUDE_PROVIDERS, model: "claude-opus-4-6", variant: "max" },
+      { providers: KIMI_K25_PROVIDERS, model: "kimi-k2.5" },
+      { providers: ["opencode"], model: "big-pickle", alwaysAvailable: true }
+    ],
+    includeInInstall: true
   },
   deep: {
-    fallbackChain: [
-      {
-        providers: ["openai", "opencode"],
-        model: "gpt-5.4",
-        variant: "medium"
-      },
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-opus-4-6",
-        variant: "max"
-      },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3.1-pro",
-        variant: "high"
-      }
+    chain: [
+      { providers: OPENAI_NATIVE_PROVIDERS, model: "gpt-5.4", variant: "medium" },
+      { providers: CLAUDE_PROVIDERS, model: "claude-opus-4-6", variant: "max" },
+      { providers: GEMINI_PROVIDERS, model: "gemini-3.1-pro", variant: "high" },
+      { providers: KIMI_K25_PROVIDERS, model: "kimi-k2.5" },
+      { providers: ["opencode"], model: "big-pickle", alwaysAvailable: true }
     ],
-    requiresModel: "gpt-5.4"
+    includeInInstall: true
   },
   artistry: {
-    fallbackChain: [
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3.1-pro",
-        variant: "high"
-      },
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-opus-4-6",
-        variant: "max"
-      },
-      { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.4" }
+    chain: [
+      { providers: GEMINI_PROVIDERS, model: "gemini-3.1-pro", variant: "high" },
+      { providers: CLAUDE_PROVIDERS, model: "claude-opus-4-6", variant: "max" },
+      { providers: OPENAI_PROVIDERS, model: "gpt-5.4" },
+      { providers: KIMI_K25_PROVIDERS, model: "kimi-k2.5" },
+      { providers: ["opencode"], model: "minimax-m2.5-free", alwaysAvailable: true }
     ],
-    requiresModel: "gemini-3.1-pro"
+    includeInInstall: true,
+    specialCases: { openAiOnlyOverride: { model: "openai/gpt-5.4", variant: "xhigh" } }
   },
   quick: {
-    fallbackChain: [
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-haiku-4-5"
-      },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3-flash"
-      },
-      { providers: ["opencode"], model: "gpt-5-nano" }
-    ]
+    chain: [
+      { providers: CLAUDE_PROVIDERS, model: "claude-haiku-4-5" },
+      { providers: GEMINI_PROVIDERS, model: "gemini-3-flash" },
+      { providers: OPENAI_NATIVE_PROVIDERS, model: "gpt-5.1-codex-mini", variant: "low" },
+      { providers: ["opencode"], model: "gpt-5-nano", alwaysAvailable: true }
+    ],
+    includeInInstall: true,
+    specialCases: { openAiOnlyOverride: { model: "openai/gpt-5.4", variant: "low" } }
   },
   "unspecified-low": {
-    fallbackChain: [
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-sonnet-4-6"
-      },
-      {
-        providers: ["openai", "opencode"],
-        model: "gpt-5.4",
-        variant: "medium"
-      },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3-flash"
-      }
-    ]
+    chain: [
+      { providers: CLAUDE_PROVIDERS, model: "claude-sonnet-4-6" },
+      { providers: KIMI_K25_PROVIDERS, model: "kimi-k2.5" },
+      { providers: OPENAI_NATIVE_PROVIDERS, model: "gpt-5.4", variant: "medium" },
+      { providers: GEMINI_PROVIDERS, model: "gemini-3-flash" },
+      { providers: ["opencode"], model: "minimax-m2.5-free", alwaysAvailable: true }
+    ],
+    includeInInstall: true
   },
   "unspecified-high": {
-    fallbackChain: [
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-opus-4-6",
-        variant: "max"
-      },
-      {
-        providers: ["openai", "github-copilot", "opencode"],
-        model: "gpt-5.4",
-        variant: "high"
-      },
-      { providers: ["zai-coding-plan", "opencode"], model: "glm-5" },
-      { providers: ["kimi-for-coding"], model: "k2p5" },
-      {
-        providers: [
-          "opencode",
-          "moonshotai",
-          "moonshotai-cn",
-          "firmware",
-          "ollama-cloud",
-          "aihubmix"
-        ],
-        model: "kimi-k2.5"
-      }
-    ]
+    chain: [{ providers: CLAUDE_PROVIDERS, model: "claude-opus-4-6", variant: "max" }, { providers: OPENAI_PROVIDERS, model: "gpt-5.4", variant: "high" }, { providers: ["zai-coding-plan", "opencode"], model: "glm-5" }, { providers: ["kimi-for-coding"], model: "k2p5" }, { providers: KIMI_K25_PROVIDERS, model: "kimi-k2.5" }],
+    includeInInstall: true
   },
   writing: {
-    fallbackChain: [
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3-flash"
-      },
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-sonnet-4-6"
-      }
-    ]
+    chain: [{ providers: GEMINI_PROVIDERS, model: "gemini-3-flash" }, { providers: ["kimi-for-coding"], model: "k2p5" }, { providers: CLAUDE_PROVIDERS, model: "claude-sonnet-4-6" }],
+    includeInInstall: true,
+    specialCases: { openAiOnlyOverride: { model: "openai/gpt-5.4", variant: "medium" } }
   }
 };
+
+// src/shared/model-requirements.ts
+var LEGACY_AGENT_REQUIREMENT_OVERRIDES = {
+  coder: {
+    requiresAnyModel: true
+  },
+  gptcoder: {
+    requiresProvider: AGENT_MODEL_DEFAULTS.gptcoder.requiresAnyProvider
+  },
+  atlas: {
+    fallbackChain: pickFallbackEntries(AGENT_MODEL_DEFAULTS.atlas.chain, ["claude-sonnet-4-6", "gpt-5.4"])
+  }
+};
+var LEGACY_CATEGORY_REQUIREMENT_OVERRIDES = {
+  "visual-engineering": {
+    fallbackChain: excludeFallbackEntries(CATEGORY_MODEL_DEFAULTS["visual-engineering"].chain, ["k2p5"])
+  },
+  deep: {
+    requiresModel: "gpt-5.4"
+  },
+  artistry: {
+    requiresModel: "gemini-3.1-pro"
+  },
+  writing: {
+    fallbackChain: excludeFallbackEntries(CATEGORY_MODEL_DEFAULTS.writing.chain, ["k2p5"])
+  }
+};
+var AGENT_MODEL_REQUIREMENTS = toModelRequirements(AGENT_MODEL_DEFAULTS, LEGACY_AGENT_REQUIREMENT_OVERRIDES);
+var CATEGORY_MODEL_REQUIREMENTS = toModelRequirements(CATEGORY_MODEL_DEFAULTS, LEGACY_CATEGORY_REQUIREMENT_OVERRIDES);
+function toModelRequirements(defaults, overrides) {
+  return Object.fromEntries(Object.entries(defaults).map(([name, def]) => {
+    const override = overrides[name];
+    return [
+      name,
+      {
+        fallbackChain: def.chain,
+        ...override
+      }
+    ];
+  }));
+}
+function pickFallbackEntries(chain, models) {
+  const allowedModels = new Set(models);
+  return chain.filter((entry) => allowedModels.has(entry.model));
+}
+function excludeFallbackEntries(chain, models) {
+  const excludedModels = new Set(models);
+  return chain.filter((entry) => !excludedModels.has(entry.model));
+}
 // src/shared/session-cursor.ts
 var sessionCursors = new Map;
 function buildMessageKey(message, index) {
@@ -18855,7 +18769,7 @@ function resolveInheritedPromptTools(sessionID, fallbackTools) {
   return normalizePromptTools(fallbackTools);
 }
 // src/shared/internal-initiator-marker.ts
-var OMO_INTERNAL_INITIATOR_MARKER = "<!-- OMO_INTERNAL_INITIATOR -->";
+var OMO_INTERNAL_INITIATOR_MARKER = "<!-- Drizzy Agent Internal Initiator -->";
 function createInternalAgentTextPart(text) {
   return {
     type: "text",
@@ -19405,291 +19319,18 @@ function discoverPluginCommandDefinitions(options) {
 // src/shared/install-defaults-contract.ts
 var INSTALL_DEFAULTS_SNAPSHOT_VERSION = 1;
 // src/cli/model-fallback-requirements.ts
-var CLI_AGENT_MODEL_REQUIREMENTS = {
-  coder: {
-    fallbackChain: [
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-opus-4-6",
-        variant: "max"
-      },
-      { providers: ["kimi-for-coding"], model: "k2p5" },
-      { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.4", variant: "medium" },
-      { providers: ["zai-coding-plan", "opencode"], model: "glm-5" }
-    ],
-    requiresAnyModel: true
-  },
-  gptcoder: {
-    fallbackChain: [
-      {
-        providers: ["openai", "opencode"],
-        model: "gpt-5.4",
-        variant: "medium"
-      }
-    ],
-    requiresProvider: ["openai", "opencode"]
-  },
-  oracle: {
-    fallbackChain: [
-      {
-        providers: ["openai", "github-copilot", "opencode"],
-        model: "gpt-5.4",
-        variant: "high"
-      },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3.1-pro",
-        variant: "high"
-      },
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-opus-4-6",
-        variant: "max"
-      }
-    ]
-  },
-  librarian: {
-    fallbackChain: [
-      { providers: ["zai-coding-plan"], model: "glm-4.7" },
-      { providers: ["opencode"], model: "glm-4.7-free" },
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-sonnet-4-5"
-      }
-    ]
-  },
-  explore: {
-    fallbackChain: [
-      { providers: ["github-copilot"], model: "grok-code-fast-1" },
-      { providers: ["anthropic", "opencode"], model: "claude-haiku-4-5" },
-      { providers: ["opencode"], model: "gpt-5-nano" }
-    ]
-  },
-  "multimodal-looker": {
-    fallbackChain: [
-      {
-        providers: ["openai", "opencode"],
-        model: "gpt-5.4",
-        variant: "medium"
-      },
-      { providers: ["kimi-for-coding"], model: "k2p5" },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3-flash"
-      },
-      { providers: ["zai-coding-plan"], model: "glm-4.6v" },
-      { providers: ["opencode"], model: "gpt-5-nano" }
-    ]
-  },
-  planner: {
-    fallbackChain: [
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-opus-4-6",
-        variant: "max"
-      },
-      { providers: ["kimi-for-coding"], model: "k2p5" },
-      {
-        providers: ["openai", "github-copilot", "opencode"],
-        model: "gpt-5.4",
-        variant: "high"
-      },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3.1-pro"
-      }
-    ]
-  },
-  planConsultant: {
-    fallbackChain: [
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-opus-4-6",
-        variant: "max"
-      },
-      { providers: ["kimi-for-coding"], model: "k2p5" },
-      {
-        providers: ["openai", "github-copilot", "opencode"],
-        model: "gpt-5.4",
-        variant: "high"
-      },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3.1-pro",
-        variant: "high"
-      }
-    ]
-  },
-  planReviewer: {
-    fallbackChain: [
-      {
-        providers: ["openai", "github-copilot", "opencode"],
-        model: "gpt-5.4",
-        variant: "xhigh"
-      },
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-opus-4-6",
-        variant: "max"
-      },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3.1-pro",
-        variant: "high"
-      }
-    ]
-  },
-  atlas: {
-    fallbackChain: [
-      { providers: ["kimi-for-coding"], model: "k2p5" },
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-sonnet-4-5"
-      },
-      { providers: ["openai", "github-copilot", "opencode"], model: "gpt-5.4", variant: "medium" },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3.1-pro"
-      }
-    ]
-  }
-};
-var CLI_CATEGORY_MODEL_REQUIREMENTS = {
-  "visual-engineering": {
-    fallbackChain: [
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3.1-pro",
-        variant: "high"
-      },
-      { providers: ["zai-coding-plan", "opencode"], model: "glm-5" },
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-opus-4-6",
-        variant: "max"
-      },
-      { providers: ["kimi-for-coding"], model: "k2p5" }
-    ]
-  },
-  ultrabrain: {
-    fallbackChain: [
-      {
-        providers: ["openai", "opencode"],
-        model: "gpt-5.4",
-        variant: "xhigh"
-      },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3.1-pro",
-        variant: "high"
-      },
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-opus-4-6",
-        variant: "max"
-      }
-    ]
-  },
-  deep: {
-    fallbackChain: [
-      {
-        providers: ["openai", "opencode"],
-        model: "gpt-5.4",
-        variant: "medium"
-      },
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-opus-4-6",
-        variant: "max"
-      },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3.1-pro",
-        variant: "high"
-      }
-    ],
-    requiresModel: "gpt-5.4"
-  },
-  artistry: {
-    fallbackChain: [
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3.1-pro",
-        variant: "high"
-      },
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-opus-4-6",
-        variant: "max"
-      },
-      {
-        providers: ["openai", "github-copilot", "opencode"],
-        model: "gpt-5.4"
-      }
-    ],
-    requiresModel: "gemini-3.1-pro"
-  },
-  quick: {
-    fallbackChain: [
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-haiku-4-5"
-      },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3-flash"
-      },
-      { providers: ["opencode"], model: "gpt-5-nano" }
-    ]
-  },
-  "unspecified-low": {
-    fallbackChain: [
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-sonnet-4-5"
-      },
-      {
-        providers: ["openai", "opencode"],
-        model: "gpt-5.4",
-        variant: "medium"
-      },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3-flash"
-      }
-    ]
-  },
-  "unspecified-high": {
-    fallbackChain: [
-      {
-        providers: ["openai", "github-copilot", "opencode"],
-        model: "gpt-5.4",
-        variant: "high"
-      },
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-opus-4-6",
-        variant: "max"
-      },
-      { providers: ["zai-coding-plan", "opencode"], model: "glm-5" },
-      { providers: ["kimi-for-coding"], model: "k2p5" },
-      { providers: ["opencode"], model: "kimi-k2.5" }
-    ]
-  },
-  writing: {
-    fallbackChain: [
-      { providers: ["kimi-for-coding"], model: "k2p5" },
-      {
-        providers: ["google", "github-copilot", "opencode"],
-        model: "gemini-3-flash"
-      },
-      {
-        providers: ["anthropic", "github-copilot", "opencode"],
-        model: "claude-sonnet-4-5"
-      }
-    ]
-  }
-};
+var CLI_AGENT_MODEL_REQUIREMENTS = toCliModelRequirements(AGENT_MODEL_DEFAULTS, { includeProviderRequirements: true });
+var CLI_CATEGORY_MODEL_REQUIREMENTS = toCliModelRequirements(CATEGORY_MODEL_DEFAULTS);
+function toCliModelRequirements(defaults, options = {}) {
+  return Object.fromEntries(Object.entries(defaults).filter(([, def]) => def.includeInInstall).map(([name, def]) => [
+    name,
+    {
+      fallbackChain: def.chain,
+      requiresAnyModel: options.includeProviderRequirements && def.requiresAnyProvider?.length ? true : undefined,
+      requiresProvider: options.includeProviderRequirements ? def.requiresAnyProvider : undefined
+    }
+  ]));
+}
 
 // src/cli/provider-availability.ts
 function toInstallDefaultsProviders(config) {
@@ -19718,6 +19359,14 @@ function isProviderAvailable(provider, availability) {
 // src/cli/fallback-chain-resolution.ts
 function resolveModelFromChain(fallbackChain, availability) {
   for (const entry of fallbackChain) {
+    if (entry.alwaysAvailable) {
+      const provider = entry.providers[0];
+      const transformedModel = transformModelForProvider(provider, entry.model);
+      return {
+        model: `${provider}/${transformedModel}`,
+        variant: entry.variant
+      };
+    }
     for (const provider of entry.providers) {
       if (isProviderAvailable(provider, availability)) {
         const transformedModel = transformModelForProvider(provider, entry.model);
@@ -19733,13 +19382,12 @@ function resolveModelFromChain(fallbackChain, availability) {
 function getCoderFallbackChain() {
   return CLI_AGENT_MODEL_REQUIREMENTS.coder.fallbackChain;
 }
-function isAnyFallbackEntryAvailable(fallbackChain, availability) {
-  return fallbackChain.some((entry) => entry.providers.some((provider) => isProviderAvailable(provider, availability)));
-}
 function isRequiredModelAvailable(requiresModel, fallbackChain, availability) {
   const matchingEntry = fallbackChain.find((entry) => entry.model === requiresModel);
   if (!matchingEntry)
     return false;
+  if (matchingEntry.alwaysAvailable)
+    return true;
   return matchingEntry.providers.some((provider) => isProviderAvailable(provider, availability));
 }
 function isRequiredProviderAvailable(requiredProviders, availability) {
@@ -19747,8 +19395,8 @@ function isRequiredProviderAvailable(requiredProviders, availability) {
 }
 
 // src/shared/computed-install-defaults.ts
-var ZAI_MODEL = "zai-coding-plan/glm-4.7";
-var ULTIMATE_FALLBACK = "opencode/glm-4.7-free";
+var ZAI_MODEL = AGENT_MODEL_DEFAULTS.librarian.specialCases?.zaiOverride?.model ?? "zai-coding-plan/glm-4.7";
+var GLOBAL_ULTIMATE_FALLBACK = getFallbackModelFromChain(AGENT_MODEL_DEFAULTS.librarian.chain) ?? "opencode/glm-4.7-free";
 function toComputedProviderAvailability(providers, options) {
   return {
     native: {
@@ -19765,26 +19413,22 @@ function toComputedProviderAvailability(providers, options) {
 }
 function computeDefaultsFromProviders(providers, options) {
   const availability = toComputedProviderAvailability(providers, options);
-  if (!hasAnyProvider(availability)) {
-    return {
-      agents: Object.fromEntries(Object.entries(CLI_AGENT_MODEL_REQUIREMENTS).filter(([role, requirement]) => !(role === "coder" && requirement.requiresAnyModel)).map(([role]) => [role, { model: ULTIMATE_FALLBACK }])),
-      categories: Object.fromEntries(Object.keys(CLI_CATEGORY_MODEL_REQUIREMENTS).map((category) => [category, { model: ULTIMATE_FALLBACK }]))
-    };
-  }
+  const hasAnyUsableFallback = (chain) => chain?.some((entry) => entry.alwaysAvailable || entry.providers.some((p) => isProviderAvailable(p, availability)));
+  const canUseCoder = !CLI_AGENT_MODEL_REQUIREMENTS.coder.requiresAnyModel || hasAnyUsableFallback(getCoderFallbackChain());
   const agents = {};
   const categories = {};
   for (const [role, requirement] of Object.entries(CLI_AGENT_MODEL_REQUIREMENTS)) {
-    if (role === "librarian" && availability.zai) {
+    if (role === "librarian" && availability.zai && AGENT_MODEL_DEFAULTS.librarian.specialCases?.zaiOverride) {
       agents[role] = { model: ZAI_MODEL };
       continue;
     }
-    if (role === "explore") {
+    if (role === "explore" && AGENT_MODEL_DEFAULTS.explore.specialCases?.customResolver === "explore-agent") {
       agents[role] = resolveExploreAgent(availability);
       continue;
     }
     if (role === "coder") {
       const fallbackChain = getCoderFallbackChain();
-      if (requirement.requiresAnyModel && !isAnyFallbackEntryAvailable(fallbackChain, availability)) {
+      if (requirement.requiresAnyModel && !canUseCoder) {
         continue;
       }
       const resolvedCoder = resolveModelFromChain(fallbackChain, availability);
@@ -19793,23 +19437,20 @@ function computeDefaultsFromProviders(providers, options) {
       }
       continue;
     }
-    const resolved = resolveRequirementDefault(requirement, availability);
+    const resolved = resolveRequirementDefault(requirement, availability, requirement.fallbackChain, getUltimateFallback(role));
     if (resolved) {
       agents[role] = resolved;
     }
   }
   for (const [category, requirement] of Object.entries(CLI_CATEGORY_MODEL_REQUIREMENTS)) {
     const fallbackChain = category === "unspecified-high" && !availability.isMaxPlan ? CLI_CATEGORY_MODEL_REQUIREMENTS["unspecified-low"].fallbackChain : requirement.fallbackChain;
-    const resolved = resolveRequirementDefault(requirement, availability, fallbackChain);
+    const resolved = resolveRequirementDefault(requirement, availability, fallbackChain, getCategoryUltimateFallback(category));
     if (resolved) {
       categories[category] = resolved;
     }
   }
   return { agents, categories };
 }
-function hasAnyProvider(availability) {
-  return availability.native.claude || availability.native.openai || availability.native.gemini || availability.opencodeZen || availability.copilot || availability.zai || availability.kimiForCoding;
-}
 function resolveExploreAgent(availability) {
   if (availability.native.claude) {
     return { model: "anthropic/claude-haiku-4-5" };
@@ -19822,7 +19463,7 @@ function resolveExploreAgent(availability) {
   }
   return { model: "opencode/gpt-5-nano" };
 }
-function resolveRequirementDefault(requirement, availability, fallbackChain = requirement.fallbackChain) {
+function resolveRequirementDefault(requirement, availability, fallbackChain = requirement.fallbackChain, ultimateFallback = GLOBAL_ULTIMATE_FALLBACK) {
   if (requirement.requiresModel && !isRequiredModelAvailable(requirement.requiresModel, requirement.fallbackChain, availability)) {
     return;
   }
@@ -19831,10 +19472,24 @@ function resolveRequirementDefault(requirement, availability, fallbackChain = re
   }
   const resolved = resolveModelFromChain(fallbackChain, availability);
   if (!resolved) {
-    return { model: ULTIMATE_FALLBACK };
+    return { model: ultimateFallback };
   }
   return withVariant(resolved.model, resolved.variant ?? requirement.variant);
 }
+function getUltimateFallback(agentName) {
+  return getFallbackModelFromChain(AGENT_MODEL_DEFAULTS[agentName]?.chain) ?? GLOBAL_ULTIMATE_FALLBACK;
+}
+function getCategoryUltimateFallback(categoryName) {
+  return getFallbackModelFromChain(CATEGORY_MODEL_DEFAULTS[categoryName]?.chain) ?? GLOBAL_ULTIMATE_FALLBACK;
+}
+function getFallbackModelFromChain(fallbackChain) {
+  const lastEntry = fallbackChain?.[fallbackChain.length - 1];
+  const provider = lastEntry?.providers[0];
+  if (!provider) {
+    return;
+  }
+  return `${provider}/${lastEntry.model}`;
+}
 function withVariant(model, variant) {
   return variant ? { model, variant } : { model };
 }
@@ -41330,9 +40985,9 @@ function isGpt5_3CodexModel(model) {
   const modelName = extractModelName(model).toLowerCase();
   return modelName.includes("gpt-5.3-codex") || modelName.includes("gpt-5-3-codex");
 }
-var GEMINI_PROVIDERS = ["google/", "google-vertex/"];
+var GEMINI_PROVIDERS2 = ["google/", "google-vertex/"];
 function isGeminiModel(model) {
-  if (GEMINI_PROVIDERS.some((prefix) => model.startsWith(prefix)))
+  if (GEMINI_PROVIDERS2.some((prefix) => model.startsWith(prefix)))
     return true;
   if (model.startsWith("github-copilot/") && extractModelName(model).toLowerCase().startsWith("gemini"))
     return true;
@@ -52034,16 +51689,14 @@ import * as fs18 from "fs";
 import * as path11 from "path";
 
 // src/cli/openai-only-model-catalog.ts
-var OPENAI_ONLY_AGENT_OVERRIDES = {
-  explore: { model: "openai/gpt-5.4", variant: "medium" },
-  librarian: { model: "openai/gpt-5.4", variant: "medium" }
-};
-var OPENAI_ONLY_CATEGORY_OVERRIDES = {
-  artistry: { model: "openai/gpt-5.4", variant: "xhigh" },
-  quick: { model: "openai/gpt-5.4", variant: "low" },
-  "visual-engineering": { model: "openai/gpt-5.4", variant: "high" },
-  writing: { model: "openai/gpt-5.4", variant: "medium" }
-};
+var OPENAI_ONLY_AGENT_OVERRIDES = Object.fromEntries(Object.entries(AGENT_MODEL_DEFAULTS).filter(([, def]) => def.specialCases?.openAiOnlyOverride).map(([name, def]) => {
+  const override = def.specialCases.openAiOnlyOverride;
+  return [name, { model: override.model, variant: override.variant }];
+}));
+var OPENAI_ONLY_CATEGORY_OVERRIDES = Object.fromEntries(Object.entries(CATEGORY_MODEL_DEFAULTS).filter(([, def]) => def.specialCases?.openAiOnlyOverride).map(([name, def]) => {
+  const override = def.specialCases.openAiOnlyOverride;
+  return [name, { model: override.model, variant: override.variant }];
+}));
 function isOpenAiOnlyAvailability(availability) {
   return availability.native.openai && !availability.native.claude && !availability.native.gemini && !availability.opencodeZen && !availability.copilot && !availability.zai && !availability.kimiForCoding;
 }
@@ -52099,6 +51752,45 @@ function synthesizeComputedDefaultsConfig(snapshot) {
     categories: generatedConfig.categories
   };
 }
+// src/shared/config-provenance.ts
+var explicitAgentOverridesStore = new WeakMap;
+var explicitCategoryConfigsStore = new WeakMap;
+function registerConfigProvenance(input) {
+  const {
+    effectiveAgents,
+    effectiveCategories,
+    explicitAgents,
+    explicitCategories
+  } = input;
+  if (effectiveAgents) {
+    explicitAgentOverridesStore.set(effectiveAgents, explicitAgents ?? {});
+  }
+  if (effectiveCategories) {
+    explicitCategoryConfigsStore.set(effectiveCategories, explicitCategories ?? {});
+  }
+}
+function getExplicitAgentOverride(agentOverrides, agentName) {
+  return getValueByKey(explicitAgentOverridesStore.get(agentOverrides ?? {}) ?? agentOverrides, agentName);
+}
+function hasExplicitAgentOverride(agentOverrides, agentName) {
+  return getExplicitAgentOverride(agentOverrides, agentName) !== undefined;
+}
+function getExplicitCategoryConfig(userCategories, categoryName) {
+  return getValueByKey(explicitCategoryConfigsStore.get(userCategories ?? {}) ?? userCategories, categoryName);
+}
+function hasExplicitCategoryConfig(userCategories, categoryName) {
+  return getExplicitCategoryConfig(userCategories, categoryName) !== undefined;
+}
+function getEffectiveCategoryConfig(userCategories, categoryName) {
+  return getValueByKey(userCategories, categoryName);
+}
+function getValueByKey(config2, key) {
+  if (!config2) {
+    return;
+  }
+  return config2[key] ?? Object.entries(config2).find(([entryKey]) => entryKey.toLowerCase() === key.toLowerCase())?.[1];
+}
+
 // src/plugin-config.ts
 var PARTIAL_STRING_ARRAY_KEYS = new Set([
   "disabled_mcps",
@@ -52262,11 +51954,20 @@ function loadPluginConfig(directory, ctx) {
   const projectConfigPath = projectDetected.format !== "none" ? projectDetected.path : projectBasePath + ".json";
   const rawUserConfig = loadConfigFromPath2(userConfigPath, ctx) ?? {};
   const userConfig = stripInvalidUserInstallDefaults(rawUserConfig, userConfigPath);
-  let config2 = mergeConfigs(synthesizeComputedDefaultsConfig(userConfig._install_defaults), userConfig);
+  const computedDefaultsConfig = synthesizeComputedDefaultsConfig(userConfig._install_defaults);
+  let explicitConfig = userConfig;
+  let config2 = mergeConfigs(computedDefaultsConfig, userConfig);
   const projectConfig = stripProjectInstallDefaults(loadConfigFromPath2(projectConfigPath, ctx), projectConfigPath);
   if (projectConfig) {
+    explicitConfig = mergeConfigs(explicitConfig, projectConfig);
     config2 = mergeConfigs(config2, projectConfig);
   }
+  registerConfigProvenance({
+    effectiveAgents: config2.agents,
+    effectiveCategories: config2.categories,
+    explicitAgents: explicitConfig.agents,
+    explicitCategories: explicitConfig.categories
+  });
   config2 = {
     ...config2
   };
@@ -72014,8 +71715,8 @@ function resolveFallbackChainForCallOmoAgent(args) {
   const { subagentType, agentOverrides, userCategories } = args;
   const agentConfigKey = getAgentConfigKey(subagentType);
   const agentRequirement = AGENT_MODEL_REQUIREMENTS[agentConfigKey];
-  const agentOverride = agentOverrides?.[agentConfigKey] ?? (agentOverrides ? Object.entries(agentOverrides).find(([key]) => key.toLowerCase() === agentConfigKey)?.[1] : undefined);
-  const normalizedFallbackModels = normalizeFallbackModels(agentOverride?.fallback_models ?? (agentOverride?.category ? userCategories?.[agentOverride.category]?.fallback_models : undefined));
+  const agentOverride = getExplicitAgentOverride(agentOverrides, agentConfigKey);
+  const normalizedFallbackModels = normalizeFallbackModels(agentOverride?.fallback_models ?? (agentOverride?.category ? getEffectiveCategoryConfig(userCategories, agentOverride.category)?.fallback_models : undefined));
   const defaultProviderID = agentRequirement?.fallbackChain?.[0]?.providers?.[0] ?? "opencode";
   const configuredFallbackChain = buildFallbackChainFromModels(normalizedFallbackModels, defaultProviderID);
   return configuredFallbackChain ?? agentRequirement?.fallbackChain;
@@ -74368,8 +74069,9 @@ init_logger();
 function resolveCategoryConfig(categoryName, options) {
   const { userCategories, inheritedModel: _inheritedModel, systemDefaultModel, availableModels } = options;
   const defaultConfig = DEFAULT_CATEGORIES[categoryName];
-  const userConfig = userCategories?.[categoryName];
-  const hasExplicitUserConfig = userConfig !== undefined;
+  const userConfig = getEffectiveCategoryConfig(userCategories, categoryName);
+  const explicitUserConfig = getExplicitCategoryConfig(userCategories, categoryName);
+  const hasExplicitUserConfig = hasExplicitCategoryConfig(userCategories, categoryName);
   if (userConfig?.disable) {
     return null;
   }
@@ -74385,15 +74087,15 @@ function resolveCategoryConfig(categoryName, options) {
     return null;
   }
   const model = resolveModel({
-    userModel: userConfig?.model,
-    inheritedModel: defaultConfig?.model,
+    userModel: explicitUserConfig?.model,
+    inheritedModel: userConfig?.model ?? defaultConfig?.model,
     systemDefault: systemDefaultModel
   });
   const config4 = {
     ...defaultConfig,
     ...userConfig,
     model,
-    variant: userConfig?.variant ?? defaultConfig?.variant
+    variant: explicitUserConfig?.variant ?? userConfig?.variant ?? defaultConfig?.variant
   };
   let promptAppend = defaultPromptAppend;
   if (userConfig?.prompt_append) {
@@ -74603,7 +74305,8 @@ Available categories: ${allCategoryNames}`
   let modelInfo;
   let categoryModel;
   const overrideModel = coderJuniorModel;
-  const explicitCategoryModel = userCategories?.[args.category]?.model;
+  const explicitCategoryConfig = getExplicitCategoryConfig(userCategories, args.category);
+  const explicitCategoryModel = explicitCategoryConfig?.model;
   if (!requirement) {
     actualModel = explicitCategoryModel ?? overrideModel ?? resolved.model;
     if (actualModel) {
@@ -74637,7 +74340,7 @@ Available categories: ${allCategoryNames}`
       const source = type2 === "user-defined" ? "override" : type2 === "system-default" ? "system-default" : "category-default";
       modelInfo = { model: actualModel, type: type2, source };
       const parsedModel = parseModelString(actualModel);
-      const variantToUse = userCategories?.[args.category]?.variant ?? resolvedVariant ?? resolved.config.variant;
+      const variantToUse = explicitCategoryConfig?.variant ?? resolvedVariant ?? resolved.config.variant;
       categoryModel = parsedModel ? variantToUse ? { ...parsedModel, variant: variantToUse } : parsedModel : undefined;
     }
   }
@@ -74738,9 +74441,9 @@ Create the work plan directly - that's your job as the planning agent.`
     }
     agentToUse = matchedAgent.name;
     const agentConfigKey = getAgentConfigKey(agentToUse);
-    const agentOverride = agentOverrides?.[agentConfigKey] ?? (agentOverrides ? Object.entries(agentOverrides).find(([key]) => key.toLowerCase() === agentConfigKey)?.[1] : undefined);
+    const agentOverride = getExplicitAgentOverride(agentOverrides, agentConfigKey);
     const agentRequirement = AGENT_MODEL_REQUIREMENTS[agentConfigKey];
-    const normalizedAgentFallbackModels = normalizeFallbackModels(agentOverride?.fallback_models ?? (agentOverride?.category ? userCategories?.[agentOverride.category]?.fallback_models : undefined));
+    const normalizedAgentFallbackModels = normalizeFallbackModels(agentOverride?.fallback_models ?? (agentOverride?.category ? getEffectiveCategoryConfig(userCategories, agentOverride.category)?.fallback_models : undefined));
     if (agentOverride?.model || agentRequirement || matchedAgent.model) {
       const availableModels = await getAvailableModelsForDelegateTask(client2);
       const normalizedMatchedModel = matchedAgent.model ? normalizeModelFormat(matchedAgent.model) : undefined;
@@ -92343,7 +92046,7 @@ function collectPendingBuiltinAgents(input) {
     if (disabledAgents.some((name2) => name2.toLowerCase() === agentName.toLowerCase()))
       continue;
     const agentConfigKey = getAgentConfigKey(agentName);
-    const override = agentOverrides[agentConfigKey] ?? Object.entries(agentOverrides).find(([key]) => key.toLowerCase() === agentConfigKey.toLowerCase())?.[1];
+    const override = getExplicitAgentOverride(agentOverrides, agentConfigKey);
     const requirement = AGENT_MODEL_REQUIREMENTS[agentConfigKey];
     if (requirement?.requiresModel && availableModels) {
       if (!isModelAvailable(requirement.requiresModel, availableModels)) {
@@ -92402,9 +92105,9 @@ function maybeCreateCoderConfig(input) {
     useTaskSystem,
     disableOmoEnv = false
   } = input;
-  const coderOverride = agentOverrides["coder"];
+  const coderOverride = getExplicitAgentOverride(agentOverrides, "coder");
   const coderRequirement = AGENT_MODEL_REQUIREMENTS["coder"];
-  const hasCoderExplicitConfig = coderOverride !== undefined;
+  const hasCoderExplicitConfig = hasExplicitAgentOverride(agentOverrides, "coder");
   const meetsCoderAnyModelRequirement = !coderRequirement?.requiresAnyModel || hasCoderExplicitConfig || isFirstRunNoCache || isAnyFallbackModelAvailable(coderRequirement.fallbackChain, availableModels);
   if (disabledAgents.includes("coder") || !meetsCoderAnyModelRequirement)
     return;
@@ -92450,9 +92153,9 @@ function maybeCreateGptcoderConfig(input) {
   } = input;
   if (disabledAgents.includes("gptcoder"))
     return;
-  const gptcoderOverride = agentOverrides["gptcoder"];
+  const gptcoderOverride = getExplicitAgentOverride(agentOverrides, "gptcoder");
   const gptcoderRequirement = AGENT_MODEL_REQUIREMENTS["gptcoder"];
-  const hasGptcoderExplicitConfig = gptcoderOverride !== undefined;
+  const hasGptcoderExplicitConfig = hasExplicitAgentOverride(agentOverrides, "gptcoder");
   const hasRequiredProvider = !gptcoderRequirement?.requiresProvider || hasGptcoderExplicitConfig || isFirstRunNoCache || isAnyProviderConnected(gptcoderRequirement.requiresProvider, availableModels);
   if (!hasRequiredProvider)
     return;
@@ -92497,7 +92200,7 @@ function maybeCreateAtlasConfig(input) {
   } = input;
   if (disabledAgents.includes("atlas"))
     return;
-  const orchestratorOverride = agentOverrides["atlas"];
+  const orchestratorOverride = getExplicitAgentOverride(agentOverrides, "atlas");
   const atlasRequirement = AGENT_MODEL_REQUIREMENTS["atlas"];
   const atlasResolution = applyModelResolution({
     uiSelectedModel: orchestratorOverride?.model ? undefined : uiSelectedModel,
@@ -94967,6 +94670,8 @@ function resolveCategoryConfig2(categoryName, userCategories) {
 // src/plugin-handlers/planner-agent-config-builder.ts
 async function buildPlannerAgentConfig(params) {
   const categoryConfig = params.pluginPlannerOverride?.category ? resolveCategoryConfig2(params.pluginPlannerOverride.category, params.userCategories) : undefined;
+  const explicitCategoryConfig = params.pluginPlannerOverride?.category ? getExplicitCategoryConfig(params.userCategories, params.pluginPlannerOverride.category) : undefined;
+  const effectiveCategoryConfig = params.pluginPlannerOverride?.category ? getEffectiveCategoryConfig(params.userCategories, params.pluginPlannerOverride.category) : undefined;
   const requirement = AGENT_MODEL_REQUIREMENTS["planner"];
   const connectedProviders = readConnectedProvidersCache();
   const availableModels = await fetchAvailableModels(undefined, {
@@ -94975,7 +94680,8 @@ async function buildPlannerAgentConfig(params) {
   const modelResolution = resolveModelPipeline({
     intent: {
       uiSelectedModel: params.currentModel,
-      userModel: params.pluginPlannerOverride?.model ?? categoryConfig?.model
+      userModel: params.pluginPlannerOverride?.model ?? explicitCategoryConfig?.model,
+      categoryDefaultModel: effectiveCategoryConfig?.model
     },
     constraints: { availableModels },
     policy: {