drizzy-agent 0.3.1 → 0.4.0

package/dist/cli/index.js

@@ -3421,6 +3421,10 @@ var init_add_plugin_to_opencode_config = __esm(() => {
   init_plugin_name_with_version();
 });
 
+// src/shared/install-defaults-contract.ts
+var INSTALL_DEFAULTS_SNAPSHOT_VERSION = 1;
+var init_install_defaults_contract = () => {};
+
 // src/cli/model-fallback-requirements.ts
 var CLI_AGENT_MODEL_REQUIREMENTS, CLI_CATEGORY_MODEL_REQUIREMENTS;
 var init_model_fallback_requirements = __esm(() => {
@@ -3711,65 +3715,6 @@ var init_model_fallback_requirements = __esm(() => {
   };
 });
 
-// src/cli/openai-only-model-catalog.ts
-function isOpenAiOnlyAvailability(availability) {
-  return availability.native.openai && !availability.native.claude && !availability.native.gemini && !availability.opencodeZen && !availability.copilot && !availability.zai && !availability.kimiForCoding;
-}
-function applyOpenAiOnlyModelCatalog(config) {
-  return {
-    ...config,
-    agents: {
-      ...config.agents,
-      ...OPENAI_ONLY_AGENT_OVERRIDES
-    },
-    categories: {
-      ...config.categories,
-      ...OPENAI_ONLY_CATEGORY_OVERRIDES
-    }
-  };
-}
-var OPENAI_ONLY_AGENT_OVERRIDES, OPENAI_ONLY_CATEGORY_OVERRIDES;
-var init_openai_only_model_catalog = __esm(() => {
-  OPENAI_ONLY_AGENT_OVERRIDES = {
-    explore: { model: "openai/gpt-5.4", variant: "medium" },
-    librarian: { model: "openai/gpt-5.4", variant: "medium" }
-  };
-  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" }
-  };
-});
-
-// src/cli/provider-availability.ts
-function toProviderAvailability(config) {
-  return {
-    native: {
-      claude: config.hasClaude,
-      openai: config.hasOpenAI,
-      gemini: config.hasGemini
-    },
-    opencodeZen: config.hasOpencodeZen,
-    copilot: config.hasCopilot,
-    zai: config.hasZaiCodingPlan,
-    kimiForCoding: config.hasKimiForCoding,
-    isMaxPlan: config.isMax20
-  };
-}
-function isProviderAvailable(provider, availability) {
-  const mapping = {
-    anthropic: availability.native.claude,
-    openai: availability.native.openai,
-    google: availability.native.gemini,
-    "github-copilot": availability.copilot,
-    opencode: availability.opencodeZen,
-    "zai-coding-plan": availability.zai,
-    "kimi-for-coding": availability.kimiForCoding
-  };
-  return mapping[provider] ?? false;
-}
-
 // src/shared/provider-model-id-transform.ts
 function transformModelForProvider(provider, model) {
   if (provider === "github-copilot") {
@@ -3816,101 +3761,150 @@ function isRequiredProviderAvailable(requiredProviders, availability) {
 }
 var init_fallback_chain_resolution = __esm(() => {
   init_model_fallback_requirements();
+  init_provider_availability();
   init_provider_model_id_transform();
 });
 
-// src/cli/model-fallback.ts
-function generateModelConfig(config) {
-  const avail = toProviderAvailability(config);
-  const hasAnyProvider = avail.native.claude || avail.native.openai || avail.native.gemini || avail.opencodeZen || avail.copilot || avail.zai || avail.kimiForCoding;
-  if (!hasAnyProvider) {
+// src/shared/computed-install-defaults.ts
+function toComputedProviderAvailability(providers, options) {
+  return {
+    native: {
+      claude: providers.claude !== "no",
+      openai: providers.openai,
+      gemini: providers.gemini
+    },
+    opencodeZen: providers.opencode_zen,
+    copilot: providers.copilot,
+    zai: providers.zai_coding_plan,
+    kimiForCoding: providers.kimi_for_coding,
+    isMaxPlan: options?.isMaxPlan ?? providers.claude === "max20"
+  };
+}
+function computeDefaultsFromProviders(providers, options) {
+  const availability = toComputedProviderAvailability(providers, options);
+  if (!hasAnyProvider(availability)) {
     return {
-      $schema: SCHEMA_URL,
-      agents: Object.fromEntries(Object.entries(CLI_AGENT_MODEL_REQUIREMENTS).filter(([role, req]) => !(role === "coder" && req.requiresAnyModel)).map(([role]) => [role, { model: ULTIMATE_FALLBACK }])),
-      categories: Object.fromEntries(Object.keys(CLI_CATEGORY_MODEL_REQUIREMENTS).map((cat) => [cat, { model: ULTIMATE_FALLBACK }]))
+      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 agents = {};
   const categories = {};
-  for (const [role, req] of Object.entries(CLI_AGENT_MODEL_REQUIREMENTS)) {
-    if (role === "librarian" && avail.zai) {
+  for (const [role, requirement] of Object.entries(CLI_AGENT_MODEL_REQUIREMENTS)) {
+    if (role === "librarian" && availability.zai) {
       agents[role] = { model: ZAI_MODEL };
       continue;
     }
     if (role === "explore") {
-      if (avail.native.claude) {
-        agents[role] = { model: "anthropic/claude-haiku-4-5" };
-      } else if (avail.opencodeZen) {
-        agents[role] = { model: "opencode/claude-haiku-4-5" };
-      } else if (avail.copilot) {
-        agents[role] = { model: "github-copilot/gpt-5-mini" };
-      } else {
-        agents[role] = { model: "opencode/gpt-5-nano" };
-      }
+      agents[role] = resolveExploreAgent(availability);
       continue;
     }
     if (role === "coder") {
       const fallbackChain = getCoderFallbackChain();
-      if (req.requiresAnyModel && !isAnyFallbackEntryAvailable(fallbackChain, avail)) {
+      if (requirement.requiresAnyModel && !isAnyFallbackEntryAvailable(fallbackChain, availability)) {
         continue;
       }
-      const resolved2 = resolveModelFromChain(fallbackChain, avail);
-      if (resolved2) {
-        const variant = resolved2.variant ?? req.variant;
-        agents[role] = variant ? { model: resolved2.model, variant } : { model: resolved2.model };
+      const resolvedCoder = resolveModelFromChain(fallbackChain, availability);
+      if (resolvedCoder) {
+        agents[role] = withVariant(resolvedCoder.model, resolvedCoder.variant ?? requirement.variant);
       }
       continue;
     }
-    if (req.requiresModel && !isRequiredModelAvailable(req.requiresModel, req.fallbackChain, avail)) {
-      continue;
-    }
-    if (req.requiresProvider && !isRequiredProviderAvailable(req.requiresProvider, avail)) {
-      continue;
-    }
-    const resolved = resolveModelFromChain(req.fallbackChain, avail);
+    const resolved = resolveRequirementDefault(requirement, availability);
     if (resolved) {
-      const variant = resolved.variant ?? req.variant;
-      agents[role] = variant ? { model: resolved.model, variant } : { model: resolved.model };
-    } else {
-      agents[role] = { model: ULTIMATE_FALLBACK };
+      agents[role] = resolved;
     }
   }
-  for (const [cat, req] of Object.entries(CLI_CATEGORY_MODEL_REQUIREMENTS)) {
-    const fallbackChain = cat === "unspecified-high" && !avail.isMaxPlan ? CLI_CATEGORY_MODEL_REQUIREMENTS["unspecified-low"].fallbackChain : req.fallbackChain;
-    if (req.requiresModel && !isRequiredModelAvailable(req.requiresModel, req.fallbackChain, avail)) {
-      continue;
-    }
-    if (req.requiresProvider && !isRequiredProviderAvailable(req.requiresProvider, avail)) {
-      continue;
-    }
-    const resolved = resolveModelFromChain(fallbackChain, avail);
+  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);
     if (resolved) {
-      const variant = resolved.variant ?? req.variant;
-      categories[cat] = variant ? { model: resolved.model, variant } : { model: resolved.model };
-    } else {
-      categories[cat] = { model: ULTIMATE_FALLBACK };
+      categories[category] = resolved;
     }
   }
-  const generatedConfig = {
-    $schema: SCHEMA_URL,
-    agents,
-    categories
-  };
-  return isOpenAiOnlyAvailability(avail) ? applyOpenAiOnlyModelCatalog(generatedConfig) : generatedConfig;
+  return { agents, categories };
 }
-var ZAI_MODEL = "zai-coding-plan/glm-4.7", ULTIMATE_FALLBACK = "opencode/glm-4.7-free", SCHEMA_URL = "https://raw.githubusercontent.com/AndreDalwin/DrizzyAgent/dev/assets/drizzy-agent.schema.json";
-var init_model_fallback = __esm(() => {
-  init_model_fallback_requirements();
-  init_openai_only_model_catalog();
+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" };
+  }
+  if (availability.opencodeZen) {
+    return { model: "opencode/claude-haiku-4-5" };
+  }
+  if (availability.copilot) {
+    return { model: "github-copilot/gpt-5-mini" };
+  }
+  return { model: "opencode/gpt-5-nano" };
+}
+function resolveRequirementDefault(requirement, availability, fallbackChain = requirement.fallbackChain) {
+  if (requirement.requiresModel && !isRequiredModelAvailable(requirement.requiresModel, requirement.fallbackChain, availability)) {
+    return;
+  }
+  if (requirement.requiresProvider && !isRequiredProviderAvailable(requirement.requiresProvider, availability)) {
+    return;
+  }
+  const resolved = resolveModelFromChain(fallbackChain, availability);
+  if (!resolved) {
+    return { model: ULTIMATE_FALLBACK };
+  }
+  return withVariant(resolved.model, resolved.variant ?? requirement.variant);
+}
+function withVariant(model, variant) {
+  return variant ? { model, variant } : { model };
+}
+var ZAI_MODEL = "zai-coding-plan/glm-4.7", ULTIMATE_FALLBACK = "opencode/glm-4.7-free";
+var init_computed_install_defaults = __esm(() => {
   init_fallback_chain_resolution();
+  init_model_fallback_requirements();
+});
+
+// src/cli/provider-availability.ts
+function toInstallDefaultsProviders(config) {
+  return {
+    claude: config.hasClaude ? config.isMax20 ? "max20" : "yes" : "no",
+    openai: config.hasOpenAI,
+    gemini: config.hasGemini,
+    copilot: config.hasCopilot,
+    opencode_zen: config.hasOpencodeZen,
+    zai_coding_plan: config.hasZaiCodingPlan,
+    kimi_for_coding: config.hasKimiForCoding
+  };
+}
+function isProviderAvailable(provider, availability) {
+  const mapping = {
+    anthropic: availability.native.claude,
+    openai: availability.native.openai,
+    google: availability.native.gemini,
+    "github-copilot": availability.copilot,
+    opencode: availability.opencodeZen,
+    "zai-coding-plan": availability.zai,
+    "kimi-for-coding": availability.kimiForCoding
+  };
+  return mapping[provider] ?? false;
+}
+var init_provider_availability = __esm(() => {
+  init_computed_install_defaults();
 });
 
 // src/cli/config-manager/generate-drizzy-config.ts
 function generateDrizzyConfig(installConfig) {
-  return generateModelConfig(installConfig);
+  const providers = toInstallDefaultsProviders(installConfig);
+  const installDefaults = {
+    snapshot_version: INSTALL_DEFAULTS_SNAPSHOT_VERSION,
+    providers
+  };
+  const schemaUrl = "https://raw.githubusercontent.com/AndreDalwin/DrizzyAgent/dev/assets/drizzy-agent.schema.json";
+  return {
+    $schema: schemaUrl,
+    _install_defaults: installDefaults
+  };
 }
 var init_generate_drizzy_config = __esm(() => {
-  init_model_fallback();
+  init_install_defaults_contract();
+  init_provider_availability();
 });
 
 // src/cli/config-manager/write-drizzy-config.ts
@@ -3918,19 +3912,11 @@ import { existsSync as existsSync5, readFileSync as readFileSync4, statSync as s
 function isEmptyOrWhitespace2(content) {
   return content.trim().length === 0;
 }
-function mergeGeneratedConfigWithExisting(generated, existing) {
-  const result = { ...existing };
-  for (const [key, generatedValue] of Object.entries(generated)) {
-    if (key === "__proto__" || key === "constructor" || key === "prototype")
-      continue;
-    const existingValue = existing[key];
-    if (generatedValue !== null && typeof generatedValue === "object" && !Array.isArray(generatedValue) && existingValue !== null && typeof existingValue === "object" && !Array.isArray(existingValue)) {
-      result[key] = mergeGeneratedConfigWithExisting(generatedValue, existingValue);
-      continue;
-    }
-    result[key] = generatedValue;
-  }
-  return result;
+function mergeSnapshotConfigWithExisting(generated, existing) {
+  return {
+    ...existing,
+    ...generated
+  };
 }
 function writeDrizzyConfig(installConfig) {
   try {
@@ -3943,13 +3929,12 @@ function writeDrizzyConfig(installConfig) {
     };
   }
   const drizzyConfigPath = getDrizzyConfigPath();
-  const existingConfigPath = drizzyConfigPath;
   try {
     const newConfig = generateDrizzyConfig(installConfig);
-    if (existsSync5(existingConfigPath)) {
+    if (existsSync5(drizzyConfigPath)) {
       try {
-        const stat = statSync2(existingConfigPath);
-        const content = readFileSync4(existingConfigPath, "utf-8");
+        const stat = statSync2(drizzyConfigPath);
+        const content = readFileSync4(drizzyConfigPath, "utf-8");
         if (stat.size === 0 || isEmptyOrWhitespace2(content)) {
           writeFileSync2(drizzyConfigPath, JSON.stringify(newConfig, null, 2) + `
 `);
@@ -3961,7 +3946,7 @@ function writeDrizzyConfig(installConfig) {
 `);
           return { success: true, configPath: drizzyConfigPath };
         }
-        const merged = mergeGeneratedConfigWithExisting(newConfig, existing);
+        const merged = mergeSnapshotConfigWithExisting(newConfig, existing);
         writeFileSync2(drizzyConfigPath, JSON.stringify(merged, null, 2) + `
 `);
       } catch (parseErr) {
@@ -4095,70 +4080,41 @@ function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function detectProvidersFromDrizzyConfig(deps) {
-  const drizzyConfigPath = deps.getDrizzyConfigPath();
-  const configPath = existsSync6(drizzyConfigPath) ? drizzyConfigPath : join2(deps.getConfigDir(), "drizzy-agent.json");
-  if (!existsSync6(configPath)) {
-    return {
-      hasClaude: false,
-      isMax20: false,
-      hasOpenAI: true,
-      hasGemini: false,
-      hasCopilot: false,
-      hasOpencodeZen: true,
-      hasZaiCodingPlan: false,
-      hasKimiForCoding: false
-    };
-  }
+  const configPath = existsSync6(deps.getDrizzyConfigPath()) && deps.getDrizzyConfigPath() ? deps.getDrizzyConfigPath() : join2(deps.getConfigDir(), "drizzy-agent.json");
+  if (!existsSync6(configPath))
+    return DEFAULT_PROVIDER_DETECTION;
   try {
-    const content = readFileSync5(configPath, "utf-8");
-    const drizzyConfig = deps.parseJsonc(content);
-    if (!isRecord(drizzyConfig)) {
+    const drizzyConfig = deps.parseJsonc(readFileSync5(configPath, "utf-8"));
+    if (!isRecord(drizzyConfig))
+      return DEFAULT_PROVIDER_DETECTION;
+    const installDefaults = drizzyConfig._install_defaults;
+    if (isRecord(installDefaults) && isRecord(installDefaults.providers)) {
+      const p = installDefaults.providers;
       return {
-        hasClaude: false,
-        isMax20: false,
-        hasOpenAI: true,
-        hasGemini: false,
-        hasCopilot: false,
-        hasOpencodeZen: true,
-        hasZaiCodingPlan: false,
-        hasKimiForCoding: false
+        hasClaude: p.claude !== "no",
+        isMax20: p.claude === "max20",
+        hasOpenAI: p.openai === true,
+        hasGemini: p.gemini === true,
+        hasCopilot: p.copilot === true,
+        hasOpencodeZen: p.opencode_zen === true,
+        hasZaiCodingPlan: p.zai_coding_plan === true,
+        hasKimiForCoding: p.kimi_for_coding === true
       };
     }
-    const configStr = JSON.stringify(drizzyConfig);
-    const hasClaude = configStr.includes('"anthropic/');
-    const hasOpenAI = configStr.includes('"openai/');
-    const hasGemini = configStr.includes('"google/');
-    const hasCopilot = configStr.includes('"github-copilot/');
-    const hasOpencodeZen = configStr.includes('"opencode/');
-    const hasZaiCodingPlan = configStr.includes('"zai-coding-plan/');
-    const hasKimiForCoding = configStr.includes('"kimi-for-coding/');
-    const categories = drizzyConfig.categories;
-    const unspecifiedHigh = isRecord(categories) ? categories["unspecified-high"] : undefined;
-    const isMax20 = hasClaude && isRecord(unspecifiedHigh) && unspecifiedHigh.model === "anthropic/claude-opus-4-6" && unspecifiedHigh.variant === "max";
-    return {
-      hasClaude,
-      isMax20,
-      hasOpenAI,
-      hasGemini,
-      hasCopilot,
-      hasOpencodeZen,
-      hasZaiCodingPlan,
-      hasKimiForCoding
-    };
+    return DEFAULT_PROVIDER_DETECTION;
   } catch {
-    return {
-      hasClaude: false,
-      isMax20: false,
-      hasOpenAI: true,
-      hasGemini: false,
-      hasCopilot: false,
-      hasOpencodeZen: true,
-      hasZaiCodingPlan: false,
-      hasKimiForCoding: false
-    };
+    return DEFAULT_PROVIDER_DETECTION;
   }
 }
 function detectCurrentConfig(deps = defaultDependencies) {
+  const { format: format2, path } = deps.detectConfigFormat();
+  if (format2 === "none") {
+    return { isInstalled: false, ...DEFAULT_PROVIDER_DETECTION };
+  }
+  const parseResult = deps.parseOpenCodeConfigFileWithError(path);
+  if (!parseResult.config) {
+    return { isInstalled: false, ...DEFAULT_PROVIDER_DETECTION };
+  }
   const result = {
     isInstalled: false,
     hasClaude: false,
@@ -4170,14 +4126,6 @@ function detectCurrentConfig(deps = defaultDependencies) {
     hasZaiCodingPlan: false,
     hasKimiForCoding: false
   };
-  const { format: format2, path } = deps.detectConfigFormat();
-  if (format2 === "none") {
-    return result;
-  }
-  const parseResult = deps.parseOpenCodeConfigFileWithError(path);
-  if (!parseResult.config) {
-    return result;
-  }
   const openCodeConfig = parseResult.config;
   const plugins = openCodeConfig.plugin ?? [];
   result.isInstalled = plugins.some((p) => p.startsWith("drizzy-agent"));
@@ -4205,7 +4153,7 @@ function detectCurrentConfig(deps = defaultDependencies) {
   result.hasKimiForCoding = hasKimiForCoding;
   return result;
 }
-var defaultDependencies;
+var defaultDependencies, DEFAULT_PROVIDER_DETECTION;
 var init_detect_current_config = __esm(() => {
   init_jsonc_parser();
   init_config_context();
@@ -4218,6 +4166,16 @@ var init_detect_current_config = __esm(() => {
     parseJsonc,
     parseOpenCodeConfigFileWithError
   };
+  DEFAULT_PROVIDER_DETECTION = {
+    hasClaude: false,
+    isMax20: false,
+    hasOpenAI: true,
+    hasGemini: false,
+    hasCopilot: false,
+    hasOpencodeZen: true,
+    hasZaiCodingPlan: false,
+    hasKimiForCoding: false
+  };
 });
 
 // src/shared/data-path.ts
@@ -4700,6 +4658,7 @@ var init_model_availability = __esm(() => {
   init_data_path();
   init_connected_providers_cache();
 });
+
 // src/hooks/auto-update-checker/constants.ts
 import * as path4 from "path";
 import * as os3 from "os";
@@ -5531,7 +5490,7 @@ var {
 // package.json
 var package_default = {
   name: "drizzy-agent",
-  version: "0.3.1",
+  version: "0.4.0",
   description: "DrizzyAgent - AI agent plugin for OpenCode",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -5607,17 +5566,17 @@ var package_default = {
     typescript: "^5.7.3"
   },
   optionalDependencies: {
-    "drizzy-agent-darwin-arm64": "0.3.1",
-    "drizzy-agent-darwin-x64": "0.3.1",
-    "drizzy-agent-darwin-x64-baseline": "0.3.1",
-    "drizzy-agent-linux-arm64": "0.3.1",
-    "drizzy-agent-linux-arm64-musl": "0.3.1",
-    "drizzy-agent-linux-x64": "0.3.1",
-    "drizzy-agent-linux-x64-baseline": "0.3.1",
-    "drizzy-agent-linux-x64-musl": "0.3.1",
-    "drizzy-agent-linux-x64-musl-baseline": "0.3.1",
-    "drizzy-agent-windows-x64": "0.3.1",
-    "drizzy-agent-windows-x64-baseline": "0.3.1"
+    "drizzy-agent-darwin-arm64": "0.4.0",
+    "drizzy-agent-darwin-x64": "0.4.0",
+    "drizzy-agent-darwin-x64-baseline": "0.4.0",
+    "drizzy-agent-linux-arm64": "0.4.0",
+    "drizzy-agent-linux-arm64-musl": "0.4.0",
+    "drizzy-agent-linux-x64": "0.4.0",
+    "drizzy-agent-linux-x64-baseline": "0.4.0",
+    "drizzy-agent-linux-x64-musl": "0.4.0",
+    "drizzy-agent-linux-x64-musl-baseline": "0.4.0",
+    "drizzy-agent-windows-x64": "0.4.0",
+    "drizzy-agent-windows-x64-baseline": "0.4.0"
   },
   overrides: {
     "@opencode-ai/sdk": "^1.2.24"
@@ -7440,6 +7399,75 @@ async function processEvents(ctx, stream, state) {
 import * as fs3 from "fs";
 import * as path3 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" }
+};
+function isOpenAiOnlyAvailability(availability) {
+  return availability.native.openai && !availability.native.claude && !availability.native.gemini && !availability.opencodeZen && !availability.copilot && !availability.zai && !availability.kimiForCoding;
+}
+function applyOpenAiOnlyModelCatalog(config) {
+  return {
+    ...config,
+    agents: {
+      ...config.agents,
+      ...OPENAI_ONLY_AGENT_OVERRIDES
+    },
+    categories: {
+      ...config.categories,
+      ...OPENAI_ONLY_CATEGORY_OVERRIDES
+    }
+  };
+}
+
+// src/cli/model-fallback.ts
+init_computed_install_defaults();
+init_provider_availability();
+var SCHEMA_URL = "https://raw.githubusercontent.com/AndreDalwin/DrizzyAgent/dev/assets/drizzy-agent.schema.json";
+function generateModelConfig(config) {
+  const providers = toInstallDefaultsProviders(config);
+  const availability = toComputedProviderAvailability(providers, { isMaxPlan: config.isMax20 });
+  const { agents, categories } = computeDefaultsFromProviders(providers, { isMaxPlan: config.isMax20 });
+  const generatedConfig = {
+    $schema: SCHEMA_URL,
+    agents,
+    categories
+  };
+  return isOpenAiOnlyAvailability(availability) ? applyOpenAiOnlyModelCatalog(generatedConfig) : generatedConfig;
+}
+
+// src/computed-install-defaults.ts
+function toInstallConfig(snapshot) {
+  return {
+    hasClaude: snapshot.providers.claude !== "no",
+    isMax20: snapshot.providers.claude === "max20",
+    hasOpenAI: snapshot.providers.openai,
+    hasGemini: snapshot.providers.gemini,
+    hasCopilot: snapshot.providers.copilot,
+    hasOpencodeZen: snapshot.providers.opencode_zen,
+    hasZaiCodingPlan: snapshot.providers.zai_coding_plan,
+    hasKimiForCoding: snapshot.providers.kimi_for_coding
+  };
+}
+function synthesizeComputedDefaultsConfig(snapshot) {
+  if (!snapshot) {
+    return {};
+  }
+  const generatedConfig = generateModelConfig(toInstallConfig(snapshot));
+  return {
+    _install_defaults: snapshot,
+    agents: generatedConfig.agents,
+    categories: generatedConfig.categories
+  };
+}
+
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
 __export(exports_external, {
@@ -21272,6 +21300,22 @@ var HookNameSchema = exports_external.enum([
   "hashline-read-enhancer",
   "read-image-resizer"
 ]);
+// src/config/schema/install-defaults.ts
+init_install_defaults_contract();
+var InstallDefaultsClaudeProviderSchema = exports_external.enum(["no", "yes", "max20"]);
+var InstallDefaultsProvidersSchema = exports_external.object({
+  claude: InstallDefaultsClaudeProviderSchema,
+  openai: exports_external.boolean(),
+  gemini: exports_external.boolean(),
+  copilot: exports_external.boolean(),
+  opencode_zen: exports_external.boolean(),
+  zai_coding_plan: exports_external.boolean(),
+  kimi_for_coding: exports_external.boolean()
+}).strict();
+var InstallDefaultsSnapshotSchema = exports_external.object({
+  snapshot_version: exports_external.literal(INSTALL_DEFAULTS_SNAPSHOT_VERSION),
+  providers: InstallDefaultsProvidersSchema
+}).strict();
 // src/config/schema/notification.ts
 var NotificationConfigSchema = exports_external.object({
   force_enable: exports_external.boolean().optional()
@@ -21408,6 +21452,7 @@ var DrizzyAgentConfigSchema = exports_external.object({
   tmux: TmuxConfigSchema.optional(),
   coder: CoderConfigSchema.optional(),
   start_work: StartWorkConfigSchema.optional(),
+  _install_defaults: InstallDefaultsSnapshotSchema.optional(),
   _migrations: exports_external.array(exports_external.string()).optional()
 });
 // node_modules/js-yaml/dist/js-yaml.mjs
@@ -24272,7 +24317,8 @@ function migrateModelVersions(configs, appliedMigrations) {
 // src/shared/migration/config-migration.ts
 init_logger();
 import * as fs2 from "fs";
-function migrateConfigFile(configPath, rawConfig) {
+function migrateConfigFile(configPath, rawConfig, options) {
+  const { writeToDisk = true } = options ?? {};
   const copy = structuredClone(rawConfig);
   let needsWrite = false;
   const existingMigrations = Array.isArray(copy._migrations) ? new Set(copy._migrations) : new Set;
@@ -24352,31 +24398,33 @@ function migrateConfigFile(configPath, rawConfig) {
     }
   }
   if (needsWrite) {
-    const timestamp2 = new Date().toISOString().replace(/[:.]/g, "-");
-    const backupPath = `${configPath}.bak.${timestamp2}`;
-    let backupSucceeded = false;
-    try {
-      fs2.copyFileSync(configPath, backupPath);
-      backupSucceeded = true;
-    } catch {}
-    let writeSucceeded = false;
-    try {
-      fs2.writeFileSync(configPath, JSON.stringify(copy, null, 2) + `
-`, "utf-8");
-      writeSucceeded = true;
-    } catch (err) {
-      log(`Failed to write migrated config to ${configPath}:`, err);
-    }
     for (const key of Object.keys(rawConfig)) {
       delete rawConfig[key];
     }
     Object.assign(rawConfig, copy);
-    if (writeSucceeded) {
-      const backupMessage = backupSucceeded ? ` (backup: ${backupPath})` : "";
-      log(`Migrated config file: ${configPath}${backupMessage}`);
-    } else {
-      const backupMessage = backupSucceeded ? ` (backup: ${backupPath})` : "";
-      log(`Applied migrated config in-memory for: ${configPath}${backupMessage}`);
+    if (writeToDisk) {
+      const timestamp2 = new Date().toISOString().replace(/[:.]/g, "-");
+      const backupPath = `${configPath}.bak.${timestamp2}`;
+      let backupSucceeded = false;
+      try {
+        fs2.copyFileSync(configPath, backupPath);
+        backupSucceeded = true;
+      } catch {}
+      let writeSucceeded = false;
+      try {
+        fs2.writeFileSync(configPath, JSON.stringify(copy, null, 2) + `
+`, "utf-8");
+        writeSucceeded = true;
+      } catch (err) {
+        log(`Failed to write migrated config to ${configPath}:`, err);
+      }
+      if (writeSucceeded) {
+        const backupMessage = backupSucceeded ? ` (backup: ${backupPath})` : "";
+        log(`Migrated config file: ${configPath}${backupMessage}`);
+      } else {
+        const backupMessage = backupSucceeded ? ` (backup: ${backupPath})` : "";
+        log(`Applied migrated config in-memory for: ${configPath}${backupMessage}`);
+      }
     }
   }
   return needsWrite;
@@ -24854,6 +24902,10 @@ init_logger();
 
 // src/features/claude-code-plugin-loader/hook-loader.ts
 init_logger();
+// src/shared/index.ts
+init_install_defaults_contract();
+init_computed_install_defaults();
+
 // src/shared/session-category-registry.ts
 var sessionCategoryMap = new Map;
 // src/plugin-config.ts
@@ -24903,7 +24955,7 @@ function loadConfigFromPath(configPath, _ctx) {
     if (fs3.existsSync(configPath)) {
       const content = fs3.readFileSync(configPath, "utf-8");
       const rawConfig = parseJsonc(content);
-      migrateConfigFile(configPath, rawConfig);
+      migrateConfigFile(configPath, rawConfig, { writeToDisk: false });
       const result = DrizzyAgentConfigSchema.safeParse(rawConfig);
       if (result.success) {
         log(`Config loaded from ${configPath}`, { agents: result.data.agents });
@@ -24933,6 +24985,7 @@ function mergeConfigs(base, override) {
   return {
     ...base,
     ...override,
+    _install_defaults: override._install_defaults ?? base._install_defaults,
     agents: deepMerge(base.agents, override.agents),
     categories: deepMerge(base.categories, override.categories),
     disabled_agents: [
@@ -24968,6 +25021,46 @@ function mergeConfigs(base, override) {
     claude_code: deepMerge(base.claude_code, override.claude_code)
   };
 }
+function isValidUserSnapshot(snapshot) {
+  if (typeof snapshot !== "object" || snapshot === null) {
+    return false;
+  }
+  const s = snapshot;
+  if (s.snapshot_version !== 1) {
+    return false;
+  }
+  if (typeof s.providers !== "object" || s.providers === null) {
+    return false;
+  }
+  return true;
+}
+function stripInvalidUserInstallDefaults(config2, configPath) {
+  if (!config2._install_defaults) {
+    return config2;
+  }
+  if (isValidUserSnapshot(config2._install_defaults)) {
+    return config2;
+  }
+  log(`Ignoring invalid _install_defaults from ${configPath}`);
+  addConfigLoadError({
+    path: configPath,
+    error: "Ignoring invalid _install_defaults section, falling back to built-in defaults"
+  });
+  const { _install_defaults: _ignored, ...explicitConfig } = config2;
+  return explicitConfig;
+}
+function stripProjectInstallDefaults(config2, configPath) {
+  if (!config2?._install_defaults) {
+    return config2;
+  }
+  log(`Ignoring project _install_defaults from ${configPath}`);
+  addConfigLoadError({
+    path: configPath,
+    error: "Ignoring project _install_defaults, snapshot defaults are user-config only"
+  });
+  const { _install_defaults: _ignored, ...explicitConfig } = config2;
+  return explicitConfig;
+}
 function loadPluginConfig(directory, ctx) {
   const configDir = getOpenCodeConfigDir({ binary: "opencode" });
   const userBasePath = path3.join(configDir, "drizzy-agent");
@@ -24976,8 +25069,10 @@ function loadPluginConfig(directory, ctx) {
   const projectBasePath = path3.join(directory, ".opencode", "drizzy-agent");
   const projectDetected = detectConfigFile(projectBasePath);
   const projectConfigPath = projectDetected.format !== "none" ? projectDetected.path : projectBasePath + ".json";
-  let config2 = loadConfigFromPath(userConfigPath, ctx) ?? {};
-  const projectConfig = loadConfigFromPath(projectConfigPath, ctx);
+  const rawUserConfig = loadConfigFromPath(userConfigPath, ctx) ?? {};
+  const userConfig = stripInvalidUserInstallDefaults(rawUserConfig, userConfigPath);
+  let config2 = mergeConfigs(synthesizeComputedDefaultsConfig(userConfig._install_defaults), userConfig);
+  const projectConfig = stripProjectInstallDefaults(loadConfigFromPath(projectConfigPath, ctx), projectConfigPath);
   if (projectConfig) {
     config2 = mergeConfigs(config2, projectConfig);
   }