oh-my-opencode-slim 0.6.4 → 0.8.0

package/dist/cli/index.js

@@ -14,6 +14,70 @@ var __export = (target, all) => {
 // src/cli/install.ts
 import * as readline from "readline/promises";
 
+// src/cli/model-selection.ts
+function defaultTieBreaker(left, right) {
+  return left.model.localeCompare(right.model);
+}
+function rankModels(models, scoreFn, options = {}) {
+  const excluded = new Set(options.excludeModels ?? []);
+  const tieBreaker = options.tieBreaker ?? defaultTieBreaker;
+  return models.filter((model) => !excluded.has(model.model)).map((candidate) => ({
+    candidate,
+    score: scoreFn(candidate)
+  })).sort((left, right) => {
+    if (left.score !== right.score)
+      return right.score - left.score;
+    return tieBreaker(left.candidate, right.candidate);
+  });
+}
+function pickBestModel(models, scoreFn, options = {}) {
+  return rankModels(models, scoreFn, options)[0]?.candidate ?? null;
+}
+function pickPrimaryAndSupport(models, scoring, preferredPrimaryModel) {
+  if (models.length === 0)
+    return { primary: null, support: null };
+  const preferredPrimary = preferredPrimaryModel ? models.find((candidate) => candidate.model === preferredPrimaryModel) : undefined;
+  const primary = preferredPrimary ?? pickBestModel(models, scoring.primary);
+  if (!primary)
+    return { primary: null, support: null };
+  const support = pickBestModel(models, scoring.support, {
+    excludeModels: [primary.model]
+  }) ?? pickBestModel(models, scoring.support);
+  return { primary, support };
+}
+
+// src/cli/chutes-selection.ts
+function speedBonus(modelName) {
+  const lower = modelName.toLowerCase();
+  let score = 0;
+  if (lower.includes("nano"))
+    score += 60;
+  if (lower.includes("flash"))
+    score += 45;
+  if (lower.includes("mini"))
+    score += 30;
+  if (lower.includes("lite"))
+    score += 20;
+  if (lower.includes("small"))
+    score += 15;
+  return score;
+}
+var scoreChutesPrimaryForCoding = (model) => {
+  return (model.reasoning ? 120 : 0) + (model.toolcall ? 80 : 0) + (model.attachment ? 20 : 0) + Math.min(model.contextLimit, 1e6) / 9000 + Math.min(model.outputLimit, 300000) / 1e4 + (model.status === "active" ? 10 : 0);
+};
+var scoreChutesSupportForCoding = (model) => {
+  return (model.toolcall ? 90 : 0) + (model.reasoning ? 35 : 0) + speedBonus(model.model) + Math.min(model.contextLimit, 400000) / 20000 + (model.status === "active" ? 8 : 0);
+};
+function pickBestCodingChutesModel(models) {
+  return pickBestModel(models, scoreChutesPrimaryForCoding);
+}
+function pickSupportChutesModel(models, primaryModel) {
+  const { support } = pickPrimaryAndSupport(models, {
+    primary: scoreChutesPrimaryForCoding,
+    support: scoreChutesSupportForCoding
+  }, primaryModel);
+  return support;
+}
 // src/cli/config-io.ts
 import {
   copyFileSync,
@@ -13602,6 +13666,43 @@ function date4(params) {
 // node_modules/zod/v4/classic/external.js
 config(en_default());
 // src/config/schema.ts
+var ProviderModelIdSchema = exports_external.string().regex(/^[^/\s]+\/[^\s]+$/, "Expected provider/model format (provider/.../model)");
+var ManualAgentPlanSchema = exports_external.object({
+  primary: ProviderModelIdSchema,
+  fallback1: ProviderModelIdSchema,
+  fallback2: ProviderModelIdSchema,
+  fallback3: ProviderModelIdSchema
+}).superRefine((value, ctx) => {
+  const unique = new Set([
+    value.primary,
+    value.fallback1,
+    value.fallback2,
+    value.fallback3
+  ]);
+  if (unique.size !== 4) {
+    ctx.addIssue({
+      code: exports_external.ZodIssueCode.custom,
+      message: "primary and fallbacks must be unique per agent"
+    });
+  }
+});
+var ManualPlanSchema = exports_external.object({
+  orchestrator: ManualAgentPlanSchema,
+  oracle: ManualAgentPlanSchema,
+  designer: ManualAgentPlanSchema,
+  explorer: ManualAgentPlanSchema,
+  librarian: ManualAgentPlanSchema,
+  fixer: ManualAgentPlanSchema
+}).strict();
+var AgentModelChainSchema = exports_external.array(exports_external.string()).min(1);
+var FallbackChainsSchema = exports_external.object({
+  orchestrator: AgentModelChainSchema.optional(),
+  oracle: AgentModelChainSchema.optional(),
+  designer: AgentModelChainSchema.optional(),
+  explorer: AgentModelChainSchema.optional(),
+  librarian: AgentModelChainSchema.optional(),
+  fixer: AgentModelChainSchema.optional()
+}).catchall(AgentModelChainSchema);
 var AgentOverrideConfigSchema = exports_external.object({
   model: exports_external.string().optional(),
   temperature: exports_external.number().min(0).max(2).optional(),
@@ -13626,13 +13727,22 @@ var McpNameSchema = exports_external.enum(["websearch", "context7", "grep_app"])
 var BackgroundTaskConfigSchema = exports_external.object({
   maxConcurrentStarts: exports_external.number().min(1).max(50).default(10)
 });
+var FailoverConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  timeoutMs: exports_external.number().min(1000).max(120000).default(15000),
+  chains: FallbackChainsSchema.default({})
+});
 var PluginConfigSchema = exports_external.object({
   preset: exports_external.string().optional(),
+  scoringEngineVersion: exports_external.enum(["v1", "v2-shadow", "v2"]).optional(),
+  balanceProviderUsage: exports_external.boolean().optional(),
+  manualPlan: ManualPlanSchema.optional(),
   presets: exports_external.record(exports_external.string(), PresetSchema).optional(),
   agents: exports_external.record(exports_external.string(), AgentOverrideConfigSchema).optional(),
   disabled_mcps: exports_external.array(exports_external.string()).optional(),
   tmux: TmuxConfigSchema.optional(),
-  background: BackgroundTaskConfigSchema.optional()
+  background: BackgroundTaskConfigSchema.optional(),
+  fallback: FailoverConfigSchema.optional()
 });
 // src/config/agent-mcps.ts
 var DEFAULT_AGENT_MCPS = {
@@ -13702,6 +13812,14 @@ function installSkill(skill) {
 }
 
 // src/cli/providers.ts
+var AGENT_NAMES = [
+  "orchestrator",
+  "oracle",
+  "designer",
+  "explorer",
+  "librarian",
+  "fixer"
+];
 var MODEL_MAPPINGS = {
   kimi: {
     orchestrator: { model: "kimi-for-coding/k2p5" },
@@ -13712,13 +13830,62 @@ var MODEL_MAPPINGS = {
     fixer: { model: "kimi-for-coding/k2p5", variant: "low" }
   },
   openai: {
-    orchestrator: { model: "openai/gpt-5.2-codex" },
-    oracle: { model: "openai/gpt-5.2-codex", variant: "high" },
+    orchestrator: { model: "openai/gpt-5.3-codex" },
+    oracle: { model: "openai/gpt-5.3-codex", variant: "high" },
     librarian: { model: "openai/gpt-5.1-codex-mini", variant: "low" },
     explorer: { model: "openai/gpt-5.1-codex-mini", variant: "low" },
     designer: { model: "openai/gpt-5.1-codex-mini", variant: "medium" },
     fixer: { model: "openai/gpt-5.1-codex-mini", variant: "low" }
   },
+  anthropic: {
+    orchestrator: { model: "anthropic/claude-opus-4-6" },
+    oracle: { model: "anthropic/claude-opus-4-6", variant: "high" },
+    librarian: { model: "anthropic/claude-sonnet-4-5", variant: "low" },
+    explorer: { model: "anthropic/claude-haiku-4-5", variant: "low" },
+    designer: { model: "anthropic/claude-sonnet-4-5", variant: "medium" },
+    fixer: { model: "anthropic/claude-sonnet-4-5", variant: "low" }
+  },
+  copilot: {
+    orchestrator: { model: "github-copilot/grok-code-fast-1" },
+    oracle: { model: "github-copilot/grok-code-fast-1", variant: "high" },
+    librarian: { model: "github-copilot/grok-code-fast-1", variant: "low" },
+    explorer: { model: "github-copilot/grok-code-fast-1", variant: "low" },
+    designer: { model: "github-copilot/grok-code-fast-1", variant: "medium" },
+    fixer: { model: "github-copilot/grok-code-fast-1", variant: "low" }
+  },
+  "zai-plan": {
+    orchestrator: { model: "zai-coding-plan/glm-4.7" },
+    oracle: { model: "zai-coding-plan/glm-4.7", variant: "high" },
+    librarian: { model: "zai-coding-plan/glm-4.7", variant: "low" },
+    explorer: { model: "zai-coding-plan/glm-4.7", variant: "low" },
+    designer: { model: "zai-coding-plan/glm-4.7", variant: "medium" },
+    fixer: { model: "zai-coding-plan/glm-4.7", variant: "low" }
+  },
+  antigravity: {
+    orchestrator: { model: "google/antigravity-gemini-3-flash" },
+    oracle: { model: "google/antigravity-gemini-3-pro" },
+    librarian: {
+      model: "google/antigravity-gemini-3-flash",
+      variant: "low"
+    },
+    explorer: {
+      model: "google/antigravity-gemini-3-flash",
+      variant: "low"
+    },
+    designer: {
+      model: "google/antigravity-gemini-3-flash",
+      variant: "medium"
+    },
+    fixer: { model: "google/antigravity-gemini-3-flash", variant: "low" }
+  },
+  chutes: {
+    orchestrator: { model: "chutes/kimi-k2.5" },
+    oracle: { model: "chutes/kimi-k2.5", variant: "high" },
+    librarian: { model: "chutes/minimax-m2.1", variant: "low" },
+    explorer: { model: "chutes/minimax-m2.1", variant: "low" },
+    designer: { model: "chutes/kimi-k2.5", variant: "medium" },
+    fixer: { model: "chutes/minimax-m2.1", variant: "low" }
+  },
   "zen-free": {
     orchestrator: { model: "opencode/big-pickle" },
     oracle: { model: "opencode/big-pickle", variant: "high" },
@@ -13728,16 +13895,145 @@ var MODEL_MAPPINGS = {
     fixer: { model: "opencode/big-pickle", variant: "low" }
   }
 };
+function generateAntigravityMixedPreset(config2, existingPreset) {
+  const result = existingPreset ? { ...existingPreset } : {};
+  const createAgentConfig = (agentName, modelInfo) => {
+    const isOrchestrator = agentName === "orchestrator";
+    const skills = isOrchestrator ? ["*"] : RECOMMENDED_SKILLS.filter((s) => s.allowedAgents.includes("*") || s.allowedAgents.includes(agentName)).map((s) => s.skillName);
+    if (agentName === "designer" && !skills.includes("agent-browser")) {
+      skills.push("agent-browser");
+    }
+    return {
+      model: modelInfo.model,
+      variant: modelInfo.variant,
+      skills,
+      mcps: DEFAULT_AGENT_MCPS[agentName] ?? []
+    };
+  };
+  const antigravityFlash = {
+    model: "google/antigravity-gemini-3-flash"
+  };
+  const chutesPrimary = config2.selectedChutesPrimaryModel ?? MODEL_MAPPINGS.chutes.orchestrator.model;
+  const chutesSupport = config2.selectedChutesSecondaryModel ?? MODEL_MAPPINGS.chutes.explorer.model;
+  if (config2.hasKimi) {
+    result.orchestrator = createAgentConfig("orchestrator", MODEL_MAPPINGS.kimi.orchestrator);
+  } else if (config2.hasChutes) {
+    result.orchestrator = createAgentConfig("orchestrator", {
+      model: chutesPrimary
+    });
+  } else if (!result.orchestrator) {
+    result.orchestrator = createAgentConfig("orchestrator", MODEL_MAPPINGS.antigravity.orchestrator);
+  }
+  if (config2.hasOpenAI) {
+    result.oracle = createAgentConfig("oracle", MODEL_MAPPINGS.openai.oracle);
+  } else if (!result.oracle) {
+    result.oracle = createAgentConfig("oracle", MODEL_MAPPINGS.antigravity.oracle);
+  }
+  result.explorer = createAgentConfig("explorer", {
+    ...antigravityFlash,
+    variant: "low"
+  });
+  if (config2.hasChutes) {
+    result.librarian = createAgentConfig("librarian", {
+      model: chutesSupport,
+      variant: "low"
+    });
+    result.designer = createAgentConfig("designer", {
+      model: chutesPrimary,
+      variant: "medium"
+    });
+  } else {
+    result.librarian = createAgentConfig("librarian", {
+      ...antigravityFlash,
+      variant: "low"
+    });
+    result.designer = createAgentConfig("designer", {
+      ...antigravityFlash,
+      variant: "medium"
+    });
+  }
+  if (config2.hasOpenAI) {
+    result.fixer = createAgentConfig("fixer", {
+      ...MODEL_MAPPINGS.openai.oracle,
+      variant: "low"
+    });
+  } else if (config2.hasChutes) {
+    result.fixer = createAgentConfig("fixer", {
+      model: chutesSupport,
+      variant: "low"
+    });
+  } else {
+    result.fixer = createAgentConfig("fixer", {
+      ...antigravityFlash,
+      variant: "low"
+    });
+  }
+  return result;
+}
 function generateLiteConfig(installConfig) {
   const config2 = {
     preset: "zen-free",
-    presets: {}
-  };
+    presets: {},
+    balanceProviderUsage: installConfig.balanceProviderUsage ?? false
+  };
+  if (installConfig.setupMode === "manual" && installConfig.manualAgentConfigs) {
+    config2.preset = "manual";
+    const manualPreset = {};
+    const chains = {};
+    for (const agentName of AGENT_NAMES) {
+      const manualConfig = installConfig.manualAgentConfigs[agentName];
+      if (manualConfig) {
+        manualPreset[agentName] = {
+          model: manualConfig.primary,
+          skills: agentName === "orchestrator" ? ["*"] : RECOMMENDED_SKILLS.filter((s) => s.allowedAgents.includes("*") || s.allowedAgents.includes(agentName)).map((s) => s.skillName),
+          mcps: DEFAULT_AGENT_MCPS[agentName] ?? []
+        };
+        const fallbackChain = [
+          manualConfig.primary,
+          manualConfig.fallback1,
+          manualConfig.fallback2,
+          manualConfig.fallback3
+        ].filter((m, i, arr) => m && arr.indexOf(m) === i);
+        chains[agentName] = fallbackChain;
+      }
+    }
+    config2.presets.manual = manualPreset;
+    config2.fallback = {
+      enabled: true,
+      timeoutMs: 15000,
+      chains
+    };
+    if (installConfig.hasTmux) {
+      config2.tmux = {
+        enabled: true,
+        layout: "main-vertical",
+        main_pane_size: 60
+      };
+    }
+    return config2;
+  }
   let activePreset = "zen-free";
-  if (installConfig.hasKimi)
+  if (installConfig.hasAntigravity && installConfig.hasKimi && installConfig.hasOpenAI) {
+    activePreset = "antigravity-mixed-both";
+  } else if (installConfig.hasAntigravity && installConfig.hasKimi) {
+    activePreset = "antigravity-mixed-kimi";
+  } else if (installConfig.hasAntigravity && installConfig.hasOpenAI) {
+    activePreset = "antigravity-mixed-openai";
+  } else if (installConfig.hasAntigravity) {
+    activePreset = "antigravity";
+  } else if (installConfig.hasKimi) {
     activePreset = "kimi";
-  else if (installConfig.hasOpenAI)
+  } else if (installConfig.hasOpenAI) {
     activePreset = "openai";
+  } else if (installConfig.hasAnthropic) {
+    activePreset = "anthropic";
+  } else if (installConfig.hasCopilot) {
+    activePreset = "copilot";
+  } else if (installConfig.hasZaiPlan) {
+    activePreset = "zai-plan";
+  } else if (installConfig.hasChutes) {
+    activePreset = "chutes";
+  }
   config2.preset = activePreset;
   const createAgentConfig = (agentName, modelInfo) => {
     const isOrchestrator = agentName === "orchestrator";
@@ -13752,6 +14048,121 @@ function generateLiteConfig(installConfig) {
       mcps: DEFAULT_AGENT_MCPS[agentName] ?? []
     };
   };
+  if (installConfig.dynamicModelPlan) {
+    const dynamicPreset = Object.fromEntries(Object.entries(installConfig.dynamicModelPlan.agents).map(([agentName, assignment]) => [
+      agentName,
+      createAgentConfig(agentName, assignment)
+    ]));
+    config2.preset = "dynamic";
+    config2.presets.dynamic = dynamicPreset;
+    config2.fallback = {
+      enabled: true,
+      timeoutMs: 15000,
+      chains: installConfig.dynamicModelPlan.chains
+    };
+    if (installConfig.hasTmux) {
+      config2.tmux = {
+        enabled: true,
+        layout: "main-vertical",
+        main_pane_size: 60
+      };
+    }
+    return config2;
+  }
+  const applyOpenCodeFreeAssignments = (presetAgents, hasExternalProviders) => {
+    if (!installConfig.useOpenCodeFreeModels)
+      return;
+    const primaryModel = installConfig.selectedOpenCodePrimaryModel;
+    const secondaryModel = installConfig.selectedOpenCodeSecondaryModel ?? primaryModel;
+    if (!primaryModel || !secondaryModel)
+      return;
+    const setAgent = (agentName, model) => {
+      presetAgents[agentName] = createAgentConfig(agentName, { model });
+    };
+    if (!hasExternalProviders) {
+      setAgent("orchestrator", primaryModel);
+      setAgent("oracle", primaryModel);
+      setAgent("designer", primaryModel);
+    }
+    setAgent("librarian", secondaryModel);
+    setAgent("explorer", secondaryModel);
+    setAgent("fixer", secondaryModel);
+  };
+  const applyChutesAssignments = (presetAgents) => {
+    if (!installConfig.hasChutes)
+      return;
+    const hasExternalProviders = installConfig.hasKimi || installConfig.hasOpenAI || installConfig.hasAnthropic || installConfig.hasCopilot || installConfig.hasZaiPlan || installConfig.hasAntigravity;
+    if (hasExternalProviders && activePreset !== "chutes")
+      return;
+    const primaryModel = installConfig.selectedChutesPrimaryModel;
+    const secondaryModel = installConfig.selectedChutesSecondaryModel ?? primaryModel;
+    if (!primaryModel || !secondaryModel)
+      return;
+    const setAgent = (agentName, model) => {
+      presetAgents[agentName] = createAgentConfig(agentName, { model });
+    };
+    setAgent("orchestrator", primaryModel);
+    setAgent("oracle", primaryModel);
+    setAgent("designer", primaryModel);
+    setAgent("librarian", secondaryModel);
+    setAgent("explorer", secondaryModel);
+    setAgent("fixer", secondaryModel);
+  };
+  const dedupeModels = (models) => {
+    const seen = new Set;
+    const result = [];
+    for (const model of models) {
+      if (!model || seen.has(model))
+        continue;
+      seen.add(model);
+      result.push(model);
+    }
+    return result;
+  };
+  const getOpenCodeFallbackForAgent = (agentName) => {
+    if (!installConfig.useOpenCodeFreeModels)
+      return;
+    const isSupport = agentName === "explorer" || agentName === "librarian" || agentName === "fixer";
+    if (isSupport) {
+      return installConfig.selectedOpenCodeSecondaryModel ?? installConfig.selectedOpenCodePrimaryModel;
+    }
+    return installConfig.selectedOpenCodePrimaryModel;
+  };
+  const getChutesFallbackForAgent = (agentName) => {
+    if (!installConfig.hasChutes)
+      return;
+    const isSupport = agentName === "explorer" || agentName === "librarian" || agentName === "fixer";
+    if (isSupport) {
+      return installConfig.selectedChutesSecondaryModel ?? installConfig.selectedChutesPrimaryModel ?? MODEL_MAPPINGS.chutes[agentName].model;
+    }
+    return installConfig.selectedChutesPrimaryModel ?? MODEL_MAPPINGS.chutes[agentName].model;
+  };
+  const attachFallbackConfig = (presetAgents) => {
+    const chains = {};
+    for (const agentName of AGENT_NAMES) {
+      const currentModel = presetAgents[agentName]?.model;
+      const chain = dedupeModels([
+        currentModel,
+        installConfig.hasOpenAI ? MODEL_MAPPINGS.openai[agentName].model : undefined,
+        installConfig.hasAnthropic ? MODEL_MAPPINGS.anthropic[agentName].model : undefined,
+        installConfig.hasCopilot ? MODEL_MAPPINGS.copilot[agentName].model : undefined,
+        installConfig.hasZaiPlan ? MODEL_MAPPINGS["zai-plan"][agentName].model : undefined,
+        installConfig.hasKimi ? MODEL_MAPPINGS.kimi[agentName].model : undefined,
+        installConfig.hasAntigravity ? MODEL_MAPPINGS.antigravity[agentName].model : undefined,
+        getChutesFallbackForAgent(agentName),
+        getOpenCodeFallbackForAgent(agentName),
+        MODEL_MAPPINGS["zen-free"][agentName].model
+      ]);
+      if (chain.length > 0) {
+        chains[agentName] = chain;
+      }
+    }
+    config2.fallback = {
+      enabled: true,
+      timeoutMs: 15000,
+      chains
+    };
+  };
   const buildPreset = (mappingName) => {
     const mapping = MODEL_MAPPINGS[mappingName];
     return Object.fromEntries(Object.entries(mapping).map(([agentName, modelInfo]) => {
@@ -13762,7 +14173,17 @@ function generateLiteConfig(installConfig) {
       return [agentName, createAgentConfig(agentName, activeModelInfo)];
     }));
   };
-  config2.presets[activePreset] = buildPreset(activePreset);
+  if (activePreset === "antigravity-mixed-both" || activePreset === "antigravity-mixed-kimi" || activePreset === "antigravity-mixed-openai") {
+    config2.presets[activePreset] = generateAntigravityMixedPreset(installConfig);
+    applyOpenCodeFreeAssignments(config2.presets[activePreset], installConfig.hasKimi || installConfig.hasOpenAI || installConfig.hasAnthropic || installConfig.hasCopilot || installConfig.hasZaiPlan || installConfig.hasAntigravity || installConfig.hasChutes === true);
+    applyChutesAssignments(config2.presets[activePreset]);
+    attachFallbackConfig(config2.presets[activePreset]);
+  } else {
+    config2.presets[activePreset] = buildPreset(activePreset);
+    applyOpenCodeFreeAssignments(config2.presets[activePreset], installConfig.hasKimi || installConfig.hasOpenAI || installConfig.hasAnthropic || installConfig.hasCopilot || installConfig.hasZaiPlan || installConfig.hasAntigravity || installConfig.hasChutes === true);
+    applyChutesAssignments(config2.presets[activePreset]);
+    attachFallbackConfig(config2.presets[activePreset]);
+  }
   if (installConfig.hasTmux) {
     config2.tmux = {
       enabled: true,
@@ -13904,11 +14325,155 @@ function disableDefaultAgents() {
     };
   }
 }
+function addAntigravityPlugin() {
+  const configPath = getExistingConfigPath();
+  try {
+    const { config: parsedConfig, error: error48 } = parseConfig(configPath);
+    if (error48) {
+      return {
+        success: false,
+        configPath,
+        error: `Failed to parse config: ${error48}`
+      };
+    }
+    const config2 = parsedConfig ?? {};
+    const plugins = config2.plugin ?? [];
+    const pluginName = "opencode-antigravity-auth@latest";
+    if (!plugins.includes(pluginName)) {
+      plugins.push(pluginName);
+    }
+    config2.plugin = plugins;
+    writeConfig(configPath, config2);
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to add antigravity plugin: ${err}`
+    };
+  }
+}
+function addGoogleProvider() {
+  const configPath = getExistingConfigPath();
+  try {
+    const { config: parsedConfig, error: error48 } = parseConfig(configPath);
+    if (error48) {
+      return {
+        success: false,
+        configPath,
+        error: `Failed to parse config: ${error48}`
+      };
+    }
+    const config2 = parsedConfig ?? {};
+    const providers = config2.provider ?? {};
+    providers.google = {
+      models: {
+        "antigravity-gemini-3-pro": {
+          name: "Gemini 3 Pro (Antigravity)",
+          limit: { context: 1048576, output: 65535 },
+          modalities: { input: ["text", "image", "pdf"], output: ["text"] },
+          variants: {
+            low: { thinkingLevel: "low" },
+            high: { thinkingLevel: "high" }
+          }
+        },
+        "antigravity-gemini-3-flash": {
+          name: "Gemini 3 Flash (Antigravity)",
+          limit: { context: 1048576, output: 65536 },
+          modalities: { input: ["text", "image", "pdf"], output: ["text"] },
+          variants: {
+            minimal: { thinkingLevel: "minimal" },
+            low: { thinkingLevel: "low" },
+            medium: { thinkingLevel: "medium" },
+            high: { thinkingLevel: "high" }
+          }
+        },
+        "antigravity-claude-sonnet-4-5": {
+          name: "Claude Sonnet 4.5 (Antigravity)",
+          limit: { context: 200000, output: 64000 },
+          modalities: { input: ["text", "image", "pdf"], output: ["text"] }
+        },
+        "antigravity-claude-sonnet-4-5-thinking": {
+          name: "Claude Sonnet 4.5 Thinking (Antigravity)",
+          limit: { context: 200000, output: 64000 },
+          modalities: { input: ["text", "image", "pdf"], output: ["text"] },
+          variants: {
+            low: { thinkingConfig: { thinkingBudget: 8192 } },
+            max: { thinkingConfig: { thinkingBudget: 32768 } }
+          }
+        },
+        "antigravity-claude-opus-4-5-thinking": {
+          name: "Claude Opus 4.5 Thinking (Antigravity)",
+          limit: { context: 200000, output: 64000 },
+          modalities: { input: ["text", "image", "pdf"], output: ["text"] },
+          variants: {
+            low: { thinkingConfig: { thinkingBudget: 8192 } },
+            max: { thinkingConfig: { thinkingBudget: 32768 } }
+          }
+        },
+        "gemini-2.5-flash": {
+          name: "Gemini 2.5 Flash (Gemini CLI)",
+          limit: { context: 1048576, output: 65536 },
+          modalities: { input: ["text", "image", "pdf"], output: ["text"] }
+        },
+        "gemini-2.5-pro": {
+          name: "Gemini 2.5 Pro (Gemini CLI)",
+          limit: { context: 1048576, output: 65536 },
+          modalities: { input: ["text", "image", "pdf"], output: ["text"] }
+        },
+        "gemini-3-flash-preview": {
+          name: "Gemini 3 Flash Preview (Gemini CLI)",
+          limit: { context: 1048576, output: 65536 },
+          modalities: { input: ["text", "image", "pdf"], output: ["text"] }
+        },
+        "gemini-3-pro-preview": {
+          name: "Gemini 3 Pro Preview (Gemini CLI)",
+          limit: { context: 1048576, output: 65535 },
+          modalities: { input: ["text", "image", "pdf"], output: ["text"] }
+        }
+      }
+    };
+    config2.provider = providers;
+    writeConfig(configPath, config2);
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to add google provider: ${err}`
+    };
+  }
+}
+function addChutesProvider() {
+  const configPath = getExistingConfigPath();
+  try {
+    const { error: error48 } = parseConfig(configPath);
+    if (error48) {
+      return {
+        success: false,
+        configPath,
+        error: `Failed to parse config: ${error48}`
+      };
+    }
+    return { success: true, configPath };
+  } catch (err) {
+    return {
+      success: false,
+      configPath,
+      error: `Failed to validate chutes provider config: ${err}`
+    };
+  }
+}
 function detectCurrentConfig() {
   const result = {
     isInstalled: false,
     hasKimi: false,
     hasOpenAI: false,
+    hasAnthropic: false,
+    hasCopilot: false,
+    hasZaiPlan: false,
+    hasAntigravity: false,
+    hasChutes: false,
     hasOpencodeZen: false,
     hasTmux: false
   };
@@ -13917,8 +14482,15 @@ function detectCurrentConfig() {
     return result;
   const plugins = config2.plugin ?? [];
   result.isInstalled = plugins.some((p) => p.startsWith(PACKAGE_NAME));
+  result.hasAntigravity = plugins.some((p) => p.startsWith("opencode-antigravity-auth"));
   const providers = config2.provider;
   result.hasKimi = !!providers?.kimi;
+  result.hasAnthropic = !!providers?.anthropic;
+  result.hasCopilot = !!providers?.["github-copilot"];
+  result.hasZaiPlan = !!providers?.["zai-coding-plan"];
+  result.hasChutes = !!providers?.chutes;
+  if (providers?.google)
+    result.hasAntigravity = true;
   const { config: liteConfig } = parseConfig(getLiteConfig());
   if (liteConfig && typeof liteConfig === "object") {
     const configObj = liteConfig;
@@ -13928,7 +14500,16 @@ function detectCurrentConfig() {
     if (agents) {
       const models = Object.values(agents).map((a) => a?.model).filter(Boolean);
       result.hasOpenAI = models.some((m) => m?.startsWith("openai/"));
+      result.hasAnthropic = models.some((m) => m?.startsWith("anthropic/"));
+      result.hasCopilot = models.some((m) => m?.startsWith("github-copilot/"));
+      result.hasZaiPlan = models.some((m) => m?.startsWith("zai-coding-plan/"));
       result.hasOpencodeZen = models.some((m) => m?.startsWith("opencode/"));
+      if (models.some((m) => m?.startsWith("google/"))) {
+        result.hasAntigravity = true;
+      }
+      if (models.some((m) => m?.startsWith("chutes/"))) {
+        result.hasChutes = true;
+      }
     }
     if (configObj.tmux && typeof configObj.tmux === "object") {
       const tmuxConfig = configObj.tmux;
@@ -13937,101 +14518,1580 @@ function detectCurrentConfig() {
   }
   return result;
 }
-// src/cli/system.ts
-async function isOpenCodeInstalled() {
-  try {
-    const proc = Bun.spawn(["opencode", "--version"], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    await proc.exited;
-    return proc.exitCode === 0;
-  } catch {
-    return false;
-  }
+// src/cli/model-key-normalization.ts
+function cleanupAlias(input, preserveSlash) {
+  let value = input.toLowerCase().trim();
+  value = value.replace(/\bfp[a-z0-9.-]*\b/g, " ");
+  value = value.replace(/\btee\b/g, " ");
+  if (preserveSlash) {
+    value = value.replace(/[_\s]+/g, "-");
+    value = value.replace(/-+/g, "-");
+    value = value.replace(/\/+/g, "/");
+    value = value.replace(/\/-+/g, "/");
+    value = value.replace(/-+\//g, "/");
+    value = value.replace(/^\/+|\/+$/g, "");
+    value = value.replace(/^-+|-+$/g, "");
+    return value;
+  }
+  value = value.replace(/[/_\s]+/g, "-");
+  value = value.replace(/-+/g, "-");
+  value = value.replace(/^-+|-+$/g, "");
+  return value;
 }
-async function getOpenCodeVersion() {
-  try {
-    const proc = Bun.spawn(["opencode", "--version"], {
-      stdout: "pipe",
-      stderr: "pipe"
-    });
-    const output = await new Response(proc.stdout).text();
-    await proc.exited;
-    return proc.exitCode === 0 ? output.trim() : null;
-  } catch {
-    return null;
-  }
+function addDerivedAliases(seed, aliases) {
+  const slashAlias = cleanupAlias(seed, true);
+  const flatAlias = cleanupAlias(seed, false);
+  if (slashAlias)
+    aliases.add(slashAlias);
+  if (flatAlias)
+    aliases.add(flatAlias);
+  if (slashAlias) {
+    aliases.add(slashAlias.replace(/-(free|flash)$/i, ""));
+  }
+  if (flatAlias) {
+    aliases.add(flatAlias.replace(/-(free|flash)$/i, ""));
+  }
+  if (slashAlias.includes("/")) {
+    aliases.add(cleanupAlias(slashAlias.replace(/\//g, " "), false));
+    aliases.add(cleanupAlias(slashAlias.replace(/\//g, "-"), false));
+    const lastPart = slashAlias.split("/").at(-1);
+    if (lastPart) {
+      addDerivedAliases(lastPart, aliases);
+    }
+  }
+}
+function buildModelKeyAliases(input) {
+  const normalized = input.trim().toLowerCase();
+  if (!normalized)
+    return [];
+  const aliases = new Set;
+  const slashIndex = normalized.indexOf("/");
+  const afterProvider = slashIndex >= 0 ? normalized.slice(slashIndex + 1) : normalized;
+  addDerivedAliases(normalized, aliases);
+  addDerivedAliases(afterProvider, aliases);
+  return [...aliases].filter((alias) => alias.length > 0);
 }
-// src/cli/custom-skills.ts
-import {
-  copyFileSync as copyFileSync2,
-  existsSync as existsSync3,
-  mkdirSync as mkdirSync2,
-  readdirSync,
-  statSync as statSync2
-} from "fs";
-import { homedir as homedir2 } from "os";
-import { dirname, join as join2 } from "path";
-import { fileURLToPath } from "url";
-var CUSTOM_SKILLS = [
-  {
-    name: "cartography",
-    description: "Repository understanding and hierarchical codemap generation",
-    allowedAgents: ["orchestrator"],
-    sourcePath: "src/skills/cartography"
+
+// src/cli/precedence-resolver.ts
+function dedupe(models) {
+  const seen = new Set;
+  const result = [];
+  for (const model of models) {
+    if (!model || seen.has(model))
+      continue;
+    seen.add(model);
+    result.push(model);
   }
-];
-function getCustomSkillsDir() {
-  return join2(homedir2(), ".config", "opencode", "skills");
+  return result;
 }
-function copyDirRecursive(src, dest) {
-  if (!existsSync3(dest)) {
-    mkdirSync2(dest, { recursive: true });
-  }
-  const entries = readdirSync(src);
-  for (const entry of entries) {
-    const srcPath = join2(src, entry);
-    const destPath = join2(dest, entry);
-    const stat = statSync2(srcPath);
-    if (stat.isDirectory()) {
-      copyDirRecursive(srcPath, destPath);
-    } else {
-      const destDir = dirname(destPath);
-      if (!existsSync3(destDir)) {
-        mkdirSync2(destDir, { recursive: true });
-      }
-      copyFileSync2(srcPath, destPath);
+function buildLayerOrder(input) {
+  return [
+    {
+      layer: "opencode-direct-override",
+      models: input.openCodeDirectOverride ? [input.openCodeDirectOverride] : []
+    },
+    {
+      layer: "manual-user-plan",
+      models: input.manualUserPlan ?? []
+    },
+    {
+      layer: "pinned-model",
+      models: input.pinnedModel ? [input.pinnedModel] : []
+    },
+    {
+      layer: "dynamic-recommendation",
+      models: input.dynamicRecommendation ?? []
+    },
+    {
+      layer: "provider-fallback-policy",
+      models: input.providerFallbackPolicy ?? []
+    },
+    {
+      layer: "system-default",
+      models: input.systemDefault
     }
-  }
+  ];
 }
-function installCustomSkill(skill) {
-  try {
-    const packageRoot = fileURLToPath(new URL("../..", import.meta.url));
-    const sourcePath = join2(packageRoot, skill.sourcePath);
-    const targetPath = join2(getCustomSkillsDir(), skill.name);
-    if (!existsSync3(sourcePath)) {
-      console.error(`Custom skill source not found: ${sourcePath}`);
-      return false;
+function resolveAgentWithPrecedence(input) {
+  const ordered = buildLayerOrder(input);
+  const firstWinningIndex = ordered.findIndex((layer) => layer.models.length > 0);
+  const winnerIndex = firstWinningIndex >= 0 ? firstWinningIndex : ordered.length - 1;
+  const winnerLayer = ordered[winnerIndex];
+  const chain = dedupe(ordered.slice(winnerIndex).flatMap((layer) => layer.models).concat(input.systemDefault));
+  const model = chain[0] ?? input.systemDefault[0] ?? "opencode/big-pickle";
+  return {
+    model,
+    chain,
+    provenance: {
+      winnerLayer: winnerLayer?.layer ?? "system-default",
+      winnerModel: model
     }
-    copyDirRecursive(sourcePath, targetPath);
-    return true;
-  } catch (error48) {
-    console.error(`Failed to install custom skill: ${skill.name}`, error48);
-    return false;
-  }
+  };
 }
 
-// src/cli/install.ts
-var GREEN = "\x1B[32m";
-var BLUE = "\x1B[34m";
-var YELLOW = "\x1B[33m";
-var RED = "\x1B[31m";
-var BOLD = "\x1B[1m";
-var DIM = "\x1B[2m";
-var RESET = "\x1B[0m";
-var SYMBOLS = {
-  check: `${GREEN}\u2713${RESET}`,
+// src/cli/scoring-v2/features.ts
+function modelLookupKeys(model) {
+  return buildModelKeyAliases(model.model);
+}
+function findSignal(model, externalSignals) {
+  if (!externalSignals)
+    return;
+  return modelLookupKeys(model).map((key) => externalSignals[key]).find((item) => item !== undefined);
+}
+function statusValue(status) {
+  if (status === "active")
+    return 1;
+  if (status === "beta")
+    return 0.4;
+  if (status === "alpha")
+    return -0.25;
+  return -1;
+}
+function capability(value) {
+  return value ? 1 : 0;
+}
+function blendedPrice(signal) {
+  if (!signal)
+    return 0;
+  if (signal.inputPricePer1M !== undefined && signal.outputPricePer1M !== undefined) {
+    return signal.inputPricePer1M * 0.75 + signal.outputPricePer1M * 0.25;
+  }
+  return signal.inputPricePer1M ?? signal.outputPricePer1M ?? 0;
+}
+function kimiVersionBonus(agent, model) {
+  const lowered = `${model.model} ${model.name}`.toLowerCase();
+  const isChutes = model.providerID === "chutes";
+  const isQwen3 = isChutes && /qwen3/.test(lowered);
+  const isKimiK25 = /kimi-k2\.5|k2\.5/.test(lowered);
+  const isMinimaxM21 = isChutes && /minimax[-_ ]?m2\.1/.test(lowered);
+  const qwenPenalty = {
+    orchestrator: -6,
+    oracle: -6,
+    designer: -8,
+    explorer: -6,
+    librarian: -12,
+    fixer: -12
+  };
+  const kimiBonus = {
+    orchestrator: 1,
+    oracle: 1,
+    designer: 3,
+    explorer: 2,
+    librarian: 2,
+    fixer: 3
+  };
+  const minimaxBonus = {
+    orchestrator: 1,
+    oracle: 1,
+    designer: 2,
+    explorer: 4,
+    librarian: 4,
+    fixer: 4
+  };
+  if (isQwen3)
+    return qwenPenalty[agent];
+  if (isKimiK25)
+    return kimiBonus[agent];
+  if (isMinimaxM21)
+    return minimaxBonus[agent];
+  return 0;
+}
+function extractFeatureVector(model, agent, externalSignals) {
+  const signal = findSignal(model, externalSignals);
+  const latency = signal?.latencySeconds ?? 0;
+  const normalizedContext = Math.min(model.contextLimit, 1e6) / 1e5;
+  const normalizedOutput = Math.min(model.outputLimit, 300000) / 30000;
+  const designerOutputScore = model.outputLimit < 64000 ? -1 : 0;
+  const versionBonus = kimiVersionBonus(agent, model);
+  const quality = (signal?.qualityScore ?? 0) / 100;
+  const coding = (signal?.codingScore ?? 0) / 100;
+  const pricePenalty = Math.min(blendedPrice(signal), 50) / 10;
+  const explorerLatencyMultiplier = agent === "explorer" ? 1.4 : 1;
+  return {
+    status: statusValue(model.status),
+    context: normalizedContext,
+    output: agent === "designer" ? designerOutputScore : normalizedOutput,
+    versionBonus,
+    reasoning: capability(model.reasoning),
+    toolcall: capability(model.toolcall),
+    attachment: capability(model.attachment),
+    quality,
+    coding,
+    latencyPenalty: Math.min(latency, 20) * explorerLatencyMultiplier,
+    pricePenalty
+  };
+}
+
+// src/cli/scoring-v2/weights.ts
+var BASE_WEIGHTS = {
+  status: 22,
+  context: 6,
+  output: 6,
+  versionBonus: 8,
+  reasoning: 10,
+  toolcall: 16,
+  attachment: 2,
+  quality: 14,
+  coding: 18,
+  latencyPenalty: -3,
+  pricePenalty: -2
+};
+var AGENT_WEIGHT_OVERRIDES = {
+  orchestrator: {
+    reasoning: 22,
+    toolcall: 22,
+    quality: 16,
+    coding: 16,
+    latencyPenalty: -2
+  },
+  oracle: {
+    reasoning: 26,
+    quality: 20,
+    coding: 18,
+    latencyPenalty: -2,
+    output: 7
+  },
+  designer: {
+    attachment: 12,
+    output: 10,
+    quality: 16,
+    coding: 10
+  },
+  explorer: {
+    latencyPenalty: -8,
+    toolcall: 24,
+    reasoning: 2,
+    context: 4,
+    output: 4
+  },
+  librarian: {
+    context: 14,
+    output: 10,
+    quality: 18,
+    coding: 14
+  },
+  fixer: {
+    coding: 28,
+    toolcall: 22,
+    reasoning: 12,
+    output: 10
+  }
+};
+function getFeatureWeights(agent) {
+  return {
+    ...BASE_WEIGHTS,
+    ...AGENT_WEIGHT_OVERRIDES[agent]
+  };
+}
+
+// src/cli/scoring-v2/engine.ts
+function weightedFeatures(features, weights) {
+  return {
+    status: features.status * weights.status,
+    context: features.context * weights.context,
+    output: features.output * weights.output,
+    versionBonus: features.versionBonus * weights.versionBonus,
+    reasoning: features.reasoning * weights.reasoning,
+    toolcall: features.toolcall * weights.toolcall,
+    attachment: features.attachment * weights.attachment,
+    quality: features.quality * weights.quality,
+    coding: features.coding * weights.coding,
+    latencyPenalty: features.latencyPenalty * weights.latencyPenalty,
+    pricePenalty: features.pricePenalty * weights.pricePenalty
+  };
+}
+function sumFeatures(features) {
+  return features.status + features.context + features.output + features.versionBonus + features.reasoning + features.toolcall + features.attachment + features.quality + features.coding + features.latencyPenalty + features.pricePenalty;
+}
+function withStableTieBreak(left, right) {
+  if (left.totalScore !== right.totalScore) {
+    return right.totalScore - left.totalScore;
+  }
+  const providerDelta = left.model.providerID.localeCompare(right.model.providerID);
+  if (providerDelta !== 0) {
+    return providerDelta;
+  }
+  return left.model.model.localeCompare(right.model.model);
+}
+function scoreCandidateV2(model, agent, externalSignals) {
+  const features = extractFeatureVector(model, agent, externalSignals);
+  const weights = getFeatureWeights(agent);
+  const weighted = weightedFeatures(features, weights);
+  return {
+    model,
+    totalScore: Math.round(sumFeatures(weighted) * 1000) / 1000,
+    scoreBreakdown: {
+      features,
+      weighted
+    }
+  };
+}
+function rankModelsV2(models, agent, externalSignals) {
+  return models.map((model) => scoreCandidateV2(model, agent, externalSignals)).sort(withStableTieBreak);
+}
+// src/cli/dynamic-model-selection.ts
+var AGENTS = [
+  "orchestrator",
+  "oracle",
+  "designer",
+  "explorer",
+  "librarian",
+  "fixer"
+];
+var FREE_BIASED_PROVIDERS = new Set(["opencode"]);
+var PRIMARY_ASSIGNMENT_ORDER = [
+  "oracle",
+  "orchestrator",
+  "fixer",
+  "designer",
+  "librarian",
+  "explorer"
+];
+var ROLE_VARIANT = {
+  orchestrator: undefined,
+  oracle: "high",
+  designer: "medium",
+  explorer: "low",
+  librarian: "low",
+  fixer: "low"
+};
+function getEnabledProviders(config2) {
+  const providers = [];
+  if (config2.hasOpenAI)
+    providers.push("openai");
+  if (config2.hasAnthropic)
+    providers.push("anthropic");
+  if (config2.hasCopilot)
+    providers.push("github-copilot");
+  if (config2.hasZaiPlan)
+    providers.push("zai-coding-plan");
+  if (config2.hasKimi)
+    providers.push("kimi-for-coding");
+  if (config2.hasAntigravity)
+    providers.push("google");
+  if (config2.hasChutes)
+    providers.push("chutes");
+  if (config2.useOpenCodeFreeModels)
+    providers.push("opencode");
+  return providers;
+}
+function tokenScore(name, re, points) {
+  return re.test(name) ? points : 0;
+}
+function statusScore(status) {
+  if (status === "active")
+    return 20;
+  if (status === "beta")
+    return 8;
+  if (status === "alpha")
+    return -5;
+  return -40;
+}
+function toVersionTuple(major, minor, patch) {
+  return [
+    Number.parseInt(major, 10) || 0,
+    Number.parseInt(minor ?? "0", 10) || 0,
+    Number.parseInt(patch ?? "0", 10) || 0
+  ];
+}
+function compareVersionTuple(a, b) {
+  if (a[0] !== b[0])
+    return a[0] - b[0];
+  if (a[1] !== b[1])
+    return a[1] - b[1];
+  return a[2] - b[2];
+}
+function extractVersionFamily(model) {
+  const text = `${model.model} ${model.name}`.toLowerCase();
+  const gpt = text.match(/\bgpt[-_ ]?(\d+)(?:[.-](\d+))?(?:[.-](\d+))?\b/);
+  if (gpt) {
+    return {
+      family: "gpt",
+      version: toVersionTuple(gpt[1] ?? "0", gpt[2], gpt[3]),
+      confidence: 1,
+      prereleasePenalty: /preview|experimental|exp|\brc\b/.test(text) ? -2 : 0
+    };
+  }
+  const gemini = text.match(/\bgemini[-_ ]?(\d+)(?:[.-](\d+))?(?:[.-](\d+))?\b/);
+  if (gemini) {
+    return {
+      family: "gemini",
+      version: toVersionTuple(gemini[1] ?? "0", gemini[2], gemini[3]),
+      confidence: 1,
+      prereleasePenalty: /preview|experimental|exp|\brc\b/.test(text) ? -2 : 0
+    };
+  }
+  const kimi = text.match(/\bkimi[-_ ]?k(\d+)(?:[.-]?(\d+))?(?:[.-](\d+))?\b/);
+  if (kimi) {
+    return {
+      family: "kimi-k",
+      version: toVersionTuple(kimi[1] ?? "0", kimi[2], kimi[3]),
+      confidence: 1,
+      prereleasePenalty: /preview|experimental|exp|\brc\b/.test(text) ? -2 : 0
+    };
+  }
+  const generic = text.match(/\b([a-z][a-z0-9-]{1,20})[-_ ](\d+)(?:[.-](\d+))?(?:[.-](\d+))?\b/);
+  if (generic) {
+    return {
+      family: generic[1] ?? "generic",
+      version: toVersionTuple(generic[2] ?? "0", generic[3], generic[4]),
+      confidence: 0.7,
+      prereleasePenalty: /preview|experimental|exp|\brc\b/.test(text) ? -2 : 0
+    };
+  }
+  return null;
+}
+function getVersionRecencyMap(models) {
+  const familyVersions = new Map;
+  const modelInfo = new Map;
+  for (const model of models) {
+    const info = extractVersionFamily(model);
+    if (!info)
+      continue;
+    modelInfo.set(model.model, info);
+    const current = familyVersions.get(info.family) ?? [];
+    current.push(info.version);
+    familyVersions.set(info.family, current);
+  }
+  const recencyMap = {};
+  for (const model of models) {
+    const info = modelInfo.get(model.model);
+    if (!info) {
+      recencyMap[model.model] = 0;
+      continue;
+    }
+    const versions2 = familyVersions.get(info.family) ?? [];
+    const unique = versions2.map((tuple2) => `${tuple2[0]}.${tuple2[1]}.${tuple2[2]}`).filter((value, index2, arr) => arr.indexOf(value) === index2).map((value) => {
+      const [major, minor, patch] = value.split(".").map((v) => Number.parseInt(v, 10) || 0);
+      return [major, minor, patch];
+    }).sort(compareVersionTuple);
+    if (unique.length === 0) {
+      recencyMap[model.model] = 0;
+      continue;
+    }
+    const index = unique.findIndex((tuple2) => compareVersionTuple(tuple2, info.version) === 0);
+    const percentile = unique.length === 1 ? 0.5 : index / (unique.length - 1);
+    const raw = -3 + percentile * (12 - -3);
+    const final = Math.max(-3, Math.min(12, raw * info.confidence + info.prereleasePenalty));
+    recencyMap[model.model] = final;
+  }
+  return recencyMap;
+}
+function baseScore(model, versionRecencyBoost = 0) {
+  const lowered = `${model.model} ${model.name}`.toLowerCase();
+  const context = Math.min(model.contextLimit, 1e6) / 50000;
+  const output = Math.min(model.outputLimit, 300000) / 30000;
+  const deep = tokenScore(lowered, /(opus|pro|thinking|reason|r1|gpt-5|k2\.5)/i, 12);
+  const fast = tokenScore(lowered, /(nano|flash|mini|lite|fast|turbo|haiku|small)/i, 4);
+  const code = tokenScore(lowered, /(codex|coder|code|dev|program)/i, 12);
+  return statusScore(model.status) + context + output + deep + fast + code + versionRecencyBoost + (model.toolcall ? 25 : 0);
+}
+function hasFlashToken(model) {
+  return /flash/i.test(`${model.model} ${model.name}`);
+}
+function isZai47Model(model) {
+  return model.providerID === "zai-coding-plan" && /glm-4\.7/i.test(`${model.model} ${model.name}`);
+}
+function isKimiK25Model(model) {
+  return /kimi-k2\.?5|k2\.?5/i.test(`${model.model} ${model.name}`);
+}
+function geminiPreferenceAdjustment(_agent, model) {
+  const lowered = `${model.model} ${model.name}`.toLowerCase();
+  const isGemini25Pro = /gemini-2\.5-pro/.test(lowered);
+  return isGemini25Pro ? -14 : 0;
+}
+function chutesPreferenceAdjustment(agent, model) {
+  if (model.providerID !== "chutes")
+    return 0;
+  const lowered = `${model.model} ${model.name}`.toLowerCase();
+  const isQwen3 = /qwen3/.test(lowered);
+  const isKimiK25 = /kimi-k2\.5|k2\.5/.test(lowered);
+  const isMinimaxM21 = /minimax[-_ ]?m2\.1/.test(lowered);
+  const qwenPenalty = {
+    oracle: -12,
+    orchestrator: -10,
+    fixer: -22,
+    designer: -14,
+    librarian: -18,
+    explorer: -10
+  };
+  const kimiBonus = {
+    oracle: 0,
+    orchestrator: 0,
+    fixer: 8,
+    designer: 6,
+    librarian: 5,
+    explorer: 4
+  };
+  const minimaxBonus = {
+    oracle: 0,
+    orchestrator: 0,
+    fixer: 10,
+    designer: 3,
+    librarian: 9,
+    explorer: 12
+  };
+  return (isQwen3 ? qwenPenalty[agent] : 0) + (isKimiK25 ? kimiBonus[agent] : 0) + (isMinimaxM21 ? minimaxBonus[agent] : 0);
+}
+function modelLookupKeys2(model) {
+  return buildModelKeyAliases(model.model);
+}
+function roleScore(agent, model, versionRecencyBoost = 0) {
+  const lowered = `${model.model} ${model.name}`.toLowerCase();
+  const reasoning = model.reasoning ? 1 : 0;
+  const toolcall = model.toolcall ? 1 : 0;
+  const attachment = model.attachment ? 1 : 0;
+  const context = Math.min(model.contextLimit, 1e6) / 60000;
+  const output = Math.min(model.outputLimit, 300000) / 40000;
+  const deep = tokenScore(lowered, /(opus|pro|thinking|reason|r1|gpt-5|k2\.5)/i, 1);
+  const fast = tokenScore(lowered, /(nano|flash|mini|lite|fast|turbo|haiku|small)/i, 1);
+  const code = tokenScore(lowered, /(codex|coder|code|dev|program)/i, 1);
+  if ((agent === "orchestrator" || agent === "explorer" || agent === "librarian" || agent === "fixer") && !model.toolcall) {
+    return -1e4;
+  }
+  if (model.status === "deprecated") {
+    return -5000;
+  }
+  const score = baseScore(model, versionRecencyBoost);
+  const flash = hasFlashToken(model);
+  const isZai47 = isZai47Model(model);
+  const zai47Flash = isZai47 && flash;
+  const zai47NonFlash = isZai47 && !flash;
+  const providerBias = model.providerID === "openai" ? 3 : model.providerID === "anthropic" ? 3 : model.providerID === "kimi-for-coding" ? 2 : model.providerID === "google" ? 2 : model.providerID === "github-copilot" ? 1 : model.providerID === "zai-coding-plan" ? 0 : model.providerID === "chutes" ? 2 : model.providerID === "opencode" ? -2 : 0;
+  const geminiAdjustment = geminiPreferenceAdjustment(agent, model);
+  const chutesAdjustment = chutesPreferenceAdjustment(agent, model);
+  if (agent === "orchestrator") {
+    const flashAdjustment2 = flash ? -22 : 0;
+    const zaiAdjustment2 = zai47NonFlash ? 16 : zai47Flash ? -18 : 0;
+    const nonReasoningFlashPenalty2 = flash && !model.reasoning ? -16 : 0;
+    return score + reasoning * 40 + toolcall * 25 + deep * 10 + code * 8 + context + flashAdjustment2 + zaiAdjustment2 + nonReasoningFlashPenalty2 + geminiAdjustment + chutesAdjustment + providerBias;
+  }
+  if (agent === "oracle") {
+    const flashAdjustment2 = flash ? -34 : 0;
+    const zaiAdjustment2 = zai47NonFlash ? 16 : zai47Flash ? -18 : 0;
+    const nonReasoningFlashPenalty2 = flash && !model.reasoning ? -16 : 0;
+    return score + reasoning * 55 + deep * 18 + context * 1.2 + toolcall * 10 + flashAdjustment2 + zaiAdjustment2 + nonReasoningFlashPenalty2 + geminiAdjustment + chutesAdjustment + providerBias;
+  }
+  if (agent === "designer") {
+    const flashAdjustment2 = flash ? -8 : 0;
+    const zaiAdjustment2 = zai47NonFlash ? 10 : zai47Flash ? -8 : 0;
+    return score + attachment * 25 + reasoning * 18 + toolcall * 15 + context * 0.8 + output + flashAdjustment2 + zaiAdjustment2 + geminiAdjustment + chutesAdjustment + providerBias;
+  }
+  if (agent === "explorer") {
+    const flashAdjustment2 = flash ? 26 : -10;
+    const zaiAdjustment2 = zai47NonFlash ? 2 : zai47Flash ? 6 : 0;
+    const deepPenalty = deep * -18;
+    return score + fast * 68 + toolcall * 28 + reasoning * 2 + context * 0.2 + flashAdjustment2 + zaiAdjustment2 + deepPenalty + geminiAdjustment + chutesAdjustment + providerBias;
+  }
+  if (agent === "librarian") {
+    const flashAdjustment2 = flash ? -12 : 0;
+    const zaiAdjustment2 = zai47NonFlash ? 16 : zai47Flash ? -18 : 0;
+    return score + context * 30 + toolcall * 22 + reasoning * 15 + output * 10 + flashAdjustment2 + zaiAdjustment2 + geminiAdjustment + chutesAdjustment + providerBias;
+  }
+  const flashAdjustment = flash ? -18 : 0;
+  const zaiAdjustment = zai47NonFlash ? 16 : zai47Flash ? -18 : 0;
+  const nonReasoningFlashPenalty = flash && !model.reasoning ? -16 : 0;
+  return score + code * 28 + toolcall * 24 + fast * 18 + reasoning * 14 + output * 8 + flashAdjustment + zaiAdjustment + nonReasoningFlashPenalty + geminiAdjustment + chutesAdjustment + providerBias;
+}
+function getExternalSignalBoost(agent, model, externalSignals) {
+  if (!externalSignals)
+    return 0;
+  const signal = modelLookupKeys2(model).map((key) => externalSignals[key]).find((item) => item !== undefined);
+  if (!signal)
+    return 0;
+  const qualityScore = signal.qualityScore ?? 0;
+  const codingScore = signal.codingScore ?? 0;
+  const latencySeconds = signal.latencySeconds;
+  const blendedPrice2 = signal.inputPricePer1M !== undefined && signal.outputPricePer1M !== undefined ? signal.inputPricePer1M * 0.75 + signal.outputPricePer1M * 0.25 : signal.inputPricePer1M ?? signal.outputPricePer1M ?? 0;
+  if (agent === "explorer") {
+    const qualityBoost2 = qualityScore * 0.05;
+    const codingBoost2 = codingScore * 0.08;
+    const latencyPenalty2 = typeof latencySeconds === "number" && Number.isFinite(latencySeconds) ? Math.min(latencySeconds, 12) * 3.2 + (latencySeconds > 7 ? 16 : latencySeconds > 4 ? 10 : 0) : 0;
+    const pricePenalty2 = Math.min(blendedPrice2, 30) * 0.03;
+    const qualityFloorPenalty = qualityScore > 0 && qualityScore < 35 ? (35 - qualityScore) * 0.8 : 0;
+    const boost2 = qualityBoost2 + codingBoost2 - latencyPenalty2 - pricePenalty2 - qualityFloorPenalty;
+    return Math.max(-90, Math.min(25, boost2));
+  }
+  const qualityBoost = qualityScore * 0.16;
+  const codingBoost = codingScore * 0.24;
+  const latencyPenalty = typeof latencySeconds === "number" && Number.isFinite(latencySeconds) ? Math.min(latencySeconds, 25) * 0.22 : 0;
+  const pricePenalty = Math.min(blendedPrice2, 30) * 0.08;
+  const boost = qualityBoost + codingBoost - latencyPenalty - pricePenalty;
+  return Math.max(-30, Math.min(45, boost));
+}
+function rankModels2(models, agent, externalSignals) {
+  const versionRecencyMap = getVersionRecencyMap(models);
+  return [...models].sort((a, b) => {
+    const scoreA = roleScore(agent, a, versionRecencyMap[a.model] ?? 0) + getExternalSignalBoost(agent, a, externalSignals);
+    const scoreB = roleScore(agent, b, versionRecencyMap[b.model] ?? 0) + getExternalSignalBoost(agent, b, externalSignals);
+    const scoreDelta = scoreB - scoreA;
+    if (scoreDelta !== 0)
+      return scoreDelta;
+    const providerTieBreak = a.providerID.localeCompare(b.providerID);
+    if (providerTieBreak !== 0)
+      return providerTieBreak;
+    return a.model.localeCompare(b.model);
+  });
+}
+function combinedScore(agent, model, externalSignals, versionRecencyMap) {
+  return roleScore(agent, model, versionRecencyMap?.[model.model] ?? 0) + getExternalSignalBoost(agent, model, externalSignals);
+}
+function effectiveEngine(engineVersion) {
+  return engineVersion === "v2" ? "v2" : "v1";
+}
+function scoreForEngine(engineVersion, agent, model, externalSignals, versionRecencyMap) {
+  if (effectiveEngine(engineVersion) === "v2") {
+    return scoreCandidateV2(model, agent, externalSignals).totalScore;
+  }
+  return combinedScore(agent, model, externalSignals, versionRecencyMap);
+}
+function selectTopModelsPerProvider(models, engineVersion, externalSignals, versionRecencyMap) {
+  const byProvider = new Map;
+  for (const model of models) {
+    const current = byProvider.get(model.providerID) ?? [];
+    current.push(model);
+    byProvider.set(model.providerID, current);
+  }
+  const selected = [];
+  for (const providerModels of byProvider.values()) {
+    if (providerModels.length <= 2) {
+      selected.push(...providerModels);
+      continue;
+    }
+    const ranked = [...providerModels].map((model) => {
+      const total = AGENTS.reduce((sum, agent) => {
+        return sum + scoreForEngine(engineVersion, agent, model, externalSignals, versionRecencyMap);
+      }, 0);
+      return {
+        model,
+        score: total / AGENTS.length
+      };
+    }).sort((a, b) => {
+      if (a.score !== b.score)
+        return b.score - a.score;
+      return a.model.model.localeCompare(b.model.model);
+    }).slice(0, 2).map((entry) => entry.model);
+    selected.push(...ranked);
+  }
+  return selected;
+}
+function countProviderUsage(agents) {
+  const counts = new Map;
+  for (const assignment of Object.values(agents)) {
+    const provider = assignment.model.split("/")[0];
+    if (!provider)
+      continue;
+    counts.set(provider, (counts.get(provider) ?? 0) + 1);
+  }
+  return counts;
+}
+function rebalanceForSubscriptionMode(agents, chains, provenance, paidProviders, getRankedModels, getPinnedModelForProvider, targetByProvider, externalSignals, versionRecencyMap, engineVersion) {
+  if (paidProviders.length <= 1)
+    return;
+  const MAX_ALLOWED_SCORE_LOSS = 20;
+  while (true) {
+    const providerUsage = countProviderUsage(agents);
+    const underProviders = paidProviders.filter((providerID) => (providerUsage.get(providerID) ?? 0) < (targetByProvider[providerID] ?? 0));
+    const overProviders = paidProviders.filter((providerID) => (providerUsage.get(providerID) ?? 0) > (targetByProvider[providerID] ?? 0));
+    if (underProviders.length === 0 || overProviders.length === 0)
+      break;
+    let bestSwap;
+    for (const agent of PRIMARY_ASSIGNMENT_ORDER) {
+      const currentModelID = agents[agent]?.model;
+      if (!currentModelID)
+        continue;
+      const currentProvider = currentModelID.split("/")[0];
+      if (!currentProvider || !overProviders.includes(currentProvider))
+        continue;
+      const ranked = getRankedModels(agent);
+      const currentModel = ranked.find((model) => model.model === currentModelID) ?? ranked.find((model) => model.providerID === currentProvider);
+      if (!currentModel)
+        continue;
+      const currentScore = scoreForEngine(engineVersion, agent, currentModel, externalSignals, versionRecencyMap);
+      for (const underProvider of underProviders) {
+        const pinned = getPinnedModelForProvider(agent, underProvider);
+        const candidate = ranked.find((model) => model.model === pinned) ?? ranked.find((model) => model.providerID === underProvider);
+        if (!candidate)
+          continue;
+        const candidateScore = scoreForEngine(engineVersion, agent, candidate, externalSignals, versionRecencyMap);
+        const loss = currentScore - candidateScore;
+        if (loss > MAX_ALLOWED_SCORE_LOSS)
+          continue;
+        if (!bestSwap || loss < bestSwap.loss) {
+          bestSwap = { agent, candidate, loss };
+        }
+      }
+    }
+    if (!bestSwap)
+      break;
+    agents[bestSwap.agent].model = bestSwap.candidate.model;
+    chains[bestSwap.agent] = dedupe2([
+      bestSwap.candidate.model,
+      ...chains[bestSwap.agent] ?? []
+    ]).slice(0, 10);
+    provenance[bestSwap.agent] = {
+      winnerLayer: "provider-fallback-policy",
+      winnerModel: bestSwap.candidate.model
+    };
+  }
+}
+function chooseProviderRepresentative(providerModels, agent, externalSignals, versionRecencyMap) {
+  if (providerModels.length === 0)
+    return null;
+  const flashBest = providerModels.find((model) => hasFlashToken(model));
+  const nonFlashBest = providerModels.find((model) => !hasFlashToken(model));
+  if (!nonFlashBest)
+    return providerModels[0] ?? null;
+  if (!flashBest)
+    return nonFlashBest;
+  const flashScore = combinedScore(agent, flashBest, externalSignals, versionRecencyMap);
+  const nonFlashScore = combinedScore(agent, nonFlashBest, externalSignals, versionRecencyMap);
+  const threshold = agent === "explorer" ? -6 : 12;
+  return flashScore >= nonFlashScore + threshold ? flashBest : nonFlashBest;
+}
+function getQualityWindow(agent) {
+  if (agent === "oracle" || agent === "orchestrator")
+    return 12;
+  if (agent === "fixer")
+    return 15;
+  if (agent === "designer")
+    return 16;
+  if (agent === "librarian")
+    return 18;
+  return 22;
+}
+function getProviderBundle(providerModels, agent, externalSignals, versionRecencyMap) {
+  if (providerModels.length === 0)
+    return [];
+  const representative = chooseProviderRepresentative(providerModels, agent, externalSignals, versionRecencyMap);
+  if (!representative)
+    return [];
+  const second = providerModels.find((m) => m.model !== representative.model);
+  if (!second)
+    return [representative.model];
+  const score1 = combinedScore(agent, representative, externalSignals, versionRecencyMap);
+  const score2 = combinedScore(agent, second, externalSignals, versionRecencyMap);
+  const gap = Math.abs(score1 - score2);
+  const includeSecond = representative.providerID === "chutes" || gap <= (agent === "oracle" || agent === "orchestrator" ? 8 : agent === "designer" || agent === "librarian" ? 12 : agent === "fixer" ? 15 : 18);
+  return includeSecond ? [representative.model, second.model] : [representative.model];
+}
+function selectPrimaryWithDiversity(candidates, agent, providerUsage, targetByProvider, remainingSlots, externalSignals, versionRecencyMap) {
+  if (candidates.length === 0)
+    return null;
+  const candidateScores = candidates.map((model) => {
+    const usage = providerUsage.get(model.providerID) ?? 0;
+    const target = targetByProvider[model.providerID] ?? 1;
+    const softCap = target;
+    const hardCap = Math.min(target + 1, 4);
+    const deficit = Math.max(0, target - usage);
+    const softOverflow = Math.max(0, usage + 1 - softCap);
+    const hardOverflow = Math.max(0, usage + 1 - hardCap);
+    const rawScore = combinedScore(agent, model, externalSignals, versionRecencyMap);
+    const adjustedScore = rawScore + deficit * 14 - softOverflow * 18 - hardOverflow * 100;
+    return {
+      model,
+      usage,
+      target,
+      rawScore,
+      adjustedScore: Math.round(adjustedScore * 1000) / 1000
+    };
+  });
+  const bestRaw = Math.max(...candidateScores.map((item) => item.rawScore));
+  const window = getQualityWindow(agent);
+  let eligible = candidateScores.filter((item) => item.rawScore >= bestRaw - window);
+  const mustFillProviders = Object.entries(targetByProvider).filter(([providerID, target]) => {
+    const usage = providerUsage.get(providerID) ?? 0;
+    return Math.max(0, target - usage) >= remainingSlots;
+  }).map(([providerID]) => providerID);
+  if (mustFillProviders.length > 0) {
+    const forced = eligible.filter((item) => mustFillProviders.includes(item.model.providerID));
+    if (forced.length > 0)
+      eligible = forced;
+  }
+  eligible.sort((a, b) => {
+    const delta = b.adjustedScore - a.adjustedScore;
+    if (delta !== 0)
+      return delta;
+    const ratioA = a.target > 0 ? a.usage / a.target : a.usage;
+    const ratioB = b.target > 0 ? b.usage / b.target : b.usage;
+    if (ratioA !== ratioB)
+      return ratioA - ratioB;
+    if (a.rawScore !== b.rawScore)
+      return b.rawScore - a.rawScore;
+    const providerTie = a.model.providerID.localeCompare(b.model.providerID);
+    if (providerTie !== 0)
+      return providerTie;
+    return a.model.model.localeCompare(b.model.model);
+  });
+  let chosen = eligible[0] ?? candidateScores[0];
+  if (!chosen)
+    return null;
+  if (chosen.usage >= 2) {
+    const bestUnused = candidateScores.find((item) => item.usage === 0);
+    if (bestUnused && bestUnused.adjustedScore >= chosen.adjustedScore - 9) {
+      chosen = bestUnused;
+    }
+  }
+  if (agent !== "explorer" && isZai47Model(chosen.model) && hasFlashToken(chosen.model)) {
+    const kimiCandidate = candidateScores.find((item) => isKimiK25Model(item.model));
+    if (kimiCandidate && kimiCandidate.rawScore >= chosen.rawScore - 2) {
+      chosen = kimiCandidate;
+    }
+  }
+  return chosen.model;
+}
+function dedupe2(models) {
+  const seen = new Set;
+  const result = [];
+  for (const model of models) {
+    if (!model || seen.has(model))
+      continue;
+    seen.add(model);
+    result.push(model);
+  }
+  return result;
+}
+function finalizeChainWithTail(prefix, preferredTail) {
+  if (!preferredTail) {
+    return dedupe2([...prefix, "opencode/big-pickle"]).slice(0, 10);
+  }
+  const withoutTail = prefix.filter((model) => model !== preferredTail).slice(0, 9);
+  return [...withoutTail, preferredTail];
+}
+function ensureSyntheticModel(models, fullModelID) {
+  if (!fullModelID)
+    return models;
+  if (models.some((model) => model.model === fullModelID))
+    return models;
+  const [providerID, modelID] = fullModelID.split("/");
+  if (!providerID || !modelID)
+    return models;
+  return [
+    ...models,
+    {
+      providerID,
+      model: fullModelID,
+      name: modelID,
+      status: "active",
+      contextLimit: 200000,
+      outputLimit: 32000,
+      reasoning: true,
+      toolcall: true,
+      attachment: false
+    }
+  ];
+}
+function buildDynamicModelPlan(catalog, config2, externalSignals, options) {
+  const catalogWithSelectedModels = [
+    config2.selectedChutesPrimaryModel,
+    config2.selectedChutesSecondaryModel,
+    config2.selectedOpenCodePrimaryModel,
+    config2.selectedOpenCodeSecondaryModel
+  ].reduce((acc, modelID) => ensureSyntheticModel(acc, modelID), catalog);
+  const enabledProviders = new Set(getEnabledProviders(config2));
+  const providerUniverse = catalogWithSelectedModels.filter((m) => {
+    if (!enabledProviders.has(m.providerID))
+      return false;
+    if (m.providerID === "chutes" && /qwen/i.test(m.model)) {
+      return false;
+    }
+    return true;
+  });
+  const engineVersion = options?.scoringEngineVersion ?? config2.scoringEngineVersion ?? "v1";
+  const versionRecencyMap = getVersionRecencyMap(providerUniverse);
+  const providerCandidates = selectTopModelsPerProvider(providerUniverse, engineVersion, externalSignals, versionRecencyMap);
+  if (providerCandidates.length === 0) {
+    return null;
+  }
+  const hasPaidProviderEnabled = config2.hasOpenAI || config2.hasAnthropic || config2.hasCopilot || config2.hasZaiPlan || config2.hasKimi || config2.hasAntigravity;
+  const paidProviders = dedupe2(providerCandidates.map((model) => model.providerID).filter((providerID) => providerID !== "opencode")).sort((a, b) => a.localeCompare(b));
+  const targetByProvider = {};
+  if (paidProviders.length > 0) {
+    const baseTarget = Math.floor(AGENTS.length / paidProviders.length);
+    const extra = AGENTS.length % paidProviders.length;
+    for (const [index, providerID] of paidProviders.entries()) {
+      targetByProvider[providerID] = baseTarget + (index < extra ? 1 : 0);
+    }
+  }
+  const providerUsage = new Map;
+  const rankCache = new Map;
+  const shadowDiffs = {};
+  const agents = {};
+  const chains = {};
+  const provenance = {};
+  const getSelectedChutesForAgent = (agent) => {
+    if (!config2.hasChutes)
+      return;
+    return agent === "explorer" || agent === "librarian" || agent === "fixer" ? config2.selectedChutesSecondaryModel ?? config2.selectedChutesPrimaryModel : config2.selectedChutesPrimaryModel;
+  };
+  const getSelectedOpenCodeForAgent = (agent) => {
+    if (!config2.useOpenCodeFreeModels)
+      return;
+    return agent === "explorer" || agent === "librarian" || agent === "fixer" ? config2.selectedOpenCodeSecondaryModel ?? config2.selectedOpenCodePrimaryModel : config2.selectedOpenCodePrimaryModel;
+  };
+  const getPinnedModelForProvider = (agent, providerID) => {
+    if (providerID === "chutes")
+      return getSelectedChutesForAgent(agent);
+    if (providerID === "opencode")
+      return getSelectedOpenCodeForAgent(agent);
+    return;
+  };
+  const getRankedModels = (agent) => {
+    const cached2 = rankCache.get(agent);
+    if (cached2)
+      return cached2;
+    const rankedV1 = rankModels2(providerCandidates, agent, externalSignals);
+    if (engineVersion === "v1") {
+      rankCache.set(agent, rankedV1);
+      return rankedV1;
+    }
+    const rankedV2 = rankModelsV2(providerCandidates, agent, externalSignals).map((candidate) => candidate.model);
+    if (engineVersion === "v2-shadow") {
+      shadowDiffs[agent] = {
+        v1TopModel: rankedV1[0]?.model,
+        v2TopModel: rankedV2[0]?.model
+      };
+      rankCache.set(agent, rankedV1);
+      return rankedV1;
+    }
+    rankCache.set(agent, rankedV2);
+    return rankedV2;
+  };
+  for (const [agentIndex, agent] of PRIMARY_ASSIGNMENT_ORDER.entries()) {
+    const ranked = getRankedModels(agent);
+    const primaryPool = hasPaidProviderEnabled ? ranked.filter((model) => !FREE_BIASED_PROVIDERS.has(model.providerID)) : ranked;
+    const remainingSlots = PRIMARY_ASSIGNMENT_ORDER.length - agentIndex;
+    const primary = selectPrimaryWithDiversity(primaryPool.length > 0 ? primaryPool : ranked, agent, providerUsage, targetByProvider, remainingSlots, externalSignals, versionRecencyMap) ?? ranked[0];
+    if (!primary)
+      continue;
+    providerUsage.set(primary.providerID, (providerUsage.get(primary.providerID) ?? 0) + 1);
+    const providerOrder = dedupe2(ranked.map((m) => m.providerID));
+    const perProviderBest = providerOrder.flatMap((providerID) => {
+      const providerModels = ranked.filter((m) => m.providerID === providerID);
+      const pinned = getPinnedModelForProvider(agent, providerID);
+      if (pinned && providerModels.some((m) => m.model === pinned)) {
+        return [pinned];
+      }
+      return getProviderBundle(providerModels, agent, externalSignals, versionRecencyMap);
+    });
+    const nonFreePerProviderBest = perProviderBest.filter((model) => !model.startsWith("opencode/"));
+    const freePerProviderBest = perProviderBest.filter((model) => model.startsWith("opencode/"));
+    const selectedOpencode = getSelectedOpenCodeForAgent(agent);
+    const selectedChutes = getSelectedChutesForAgent(agent);
+    const chain = dedupe2([
+      primary.model,
+      ...nonFreePerProviderBest,
+      selectedChutes,
+      selectedOpencode,
+      ...freePerProviderBest
+    ]);
+    const deterministicFreeTail = selectedOpencode ?? freePerProviderBest[0] ?? ranked.find((model) => model.model.startsWith("opencode/"))?.model;
+    const finalizedChain = finalizeChainWithTail(chain, deterministicFreeTail);
+    const providerPolicyChain = dedupe2([selectedChutes, selectedOpencode]);
+    const systemDefaultModel = selectedOpencode ?? "opencode/big-pickle";
+    const resolved = resolveAgentWithPrecedence({
+      agentName: agent,
+      dynamicRecommendation: finalizedChain,
+      providerFallbackPolicy: providerPolicyChain,
+      systemDefault: [systemDefaultModel]
+    });
+    let finalModel = resolved.model;
+    let finalChain = resolved.chain;
+    const selectedChutesForAgent = getSelectedChutesForAgent(agent);
+    const selectedOpenCodeForAgent = getSelectedOpenCodeForAgent(agent);
+    const forceChutes = finalModel.startsWith("chutes/") && Boolean(selectedChutesForAgent);
+    const forceOpenCode = finalModel.startsWith("opencode/") && Boolean(selectedOpenCodeForAgent);
+    if (forceOpenCode && selectedOpenCodeForAgent) {
+      finalModel = selectedOpenCodeForAgent;
+      finalChain = dedupe2([selectedOpenCodeForAgent, ...finalChain]);
+    }
+    if (forceChutes && selectedChutesForAgent) {
+      finalModel = selectedChutesForAgent;
+      finalChain = dedupe2([selectedChutesForAgent, ...finalChain]);
+    }
+    const wasForced = forceChutes || forceOpenCode;
+    agents[agent] = {
+      model: finalModel,
+      variant: ROLE_VARIANT[agent]
+    };
+    chains[agent] = finalChain;
+    provenance[agent] = {
+      winnerLayer: wasForced ? "manual-user-plan" : resolved.provenance.winnerLayer,
+      winnerModel: finalModel
+    };
+  }
+  if (hasPaidProviderEnabled) {
+    for (const providerID of paidProviders) {
+      if ((providerUsage.get(providerID) ?? 0) > 0)
+        continue;
+      let bestSwap;
+      for (const agent of PRIMARY_ASSIGNMENT_ORDER) {
+        const currentModel = agents[agent]?.model;
+        if (!currentModel)
+          continue;
+        const ranked = getRankedModels(agent);
+        const pinned = getPinnedModelForProvider(agent, providerID);
+        const candidate = ranked.find((model) => model.model === pinned) ?? ranked.find((model) => model.providerID === providerID);
+        const current = ranked.find((model) => model.model === currentModel);
+        if (!candidate || !current)
+          continue;
+        const currentScore = combinedScore(agent, current, externalSignals, versionRecencyMap);
+        const candidateScore = combinedScore(agent, candidate, externalSignals, versionRecencyMap);
+        const loss = currentScore - candidateScore;
+        if (!bestSwap || loss < bestSwap.loss) {
+          bestSwap = {
+            agent,
+            candidateModel: candidate.model,
+            loss
+          };
+        }
+      }
+      if (!bestSwap)
+        continue;
+      const existingProvider = agents[bestSwap.agent]?.model.split("/")[0] ?? providerID;
+      agents[bestSwap.agent].model = bestSwap.candidateModel;
+      chains[bestSwap.agent] = dedupe2([
+        bestSwap.candidateModel,
+        ...chains[bestSwap.agent] ?? []
+      ]).slice(0, 10);
+      provenance[bestSwap.agent] = {
+        winnerLayer: "provider-fallback-policy",
+        winnerModel: bestSwap.candidateModel
+      };
+      providerUsage.set(providerID, (providerUsage.get(providerID) ?? 0) + 1);
+      providerUsage.set(existingProvider, Math.max(0, (providerUsage.get(existingProvider) ?? 1) - 1));
+    }
+  }
+  if (config2.balanceProviderUsage && hasPaidProviderEnabled) {
+    rebalanceForSubscriptionMode(agents, chains, provenance, paidProviders, getRankedModels, getPinnedModelForProvider, targetByProvider, externalSignals, versionRecencyMap, engineVersion);
+  }
+  if (Object.keys(agents).length === 0) {
+    return null;
+  }
+  return {
+    agents,
+    chains,
+    provenance,
+    scoring: {
+      engineVersionApplied: engineVersion === "v2" ? "v2" : "v1",
+      shadowCompared: engineVersion === "v2-shadow",
+      diffs: engineVersion === "v2-shadow" ? shadowDiffs : undefined
+    }
+  };
+}
+// src/utils/logger.ts
+import * as os from "os";
+import * as path from "path";
+var logFile = path.join(os.tmpdir(), "oh-my-opencode-slim.log");
+// src/utils/env.ts
+function getEnv(name) {
+  const bunValue = globalThis.Bun?.env?.[name];
+  if (typeof bunValue === "string" && bunValue.length > 0)
+    return bunValue;
+  const processValue = globalThis.process?.env?.[name];
+  return typeof processValue === "string" && processValue.length > 0 ? processValue : undefined;
+}
+// src/cli/external-rankings.ts
+function normalizeKey(input) {
+  return input.trim().toLowerCase();
+}
+function baseAliases(key) {
+  return buildModelKeyAliases(normalizeKey(key));
+}
+function providerScopedAlias(alias, providerPrefix) {
+  if (!providerPrefix || alias.includes("/"))
+    return alias;
+  return `${providerPrefix}/${alias}`;
+}
+function mergeSignal(existing, incoming) {
+  if (!existing)
+    return incoming;
+  return {
+    qualityScore: incoming.qualityScore ?? existing.qualityScore,
+    codingScore: incoming.codingScore ?? existing.codingScore,
+    latencySeconds: incoming.latencySeconds ?? existing.latencySeconds,
+    inputPricePer1M: incoming.inputPricePer1M ?? existing.inputPricePer1M,
+    outputPricePer1M: incoming.outputPricePer1M ?? existing.outputPricePer1M,
+    source: "merged"
+  };
+}
+function providerPrefixFromCreator(creatorSlug) {
+  if (!creatorSlug)
+    return;
+  const slug = creatorSlug.toLowerCase();
+  if (slug.includes("openai"))
+    return "openai";
+  if (slug.includes("anthropic"))
+    return "anthropic";
+  if (slug.includes("google"))
+    return "google";
+  if (slug.includes("chutes"))
+    return "chutes";
+  if (slug.includes("copilot") || slug.includes("github"))
+    return "github-copilot";
+  if (slug.includes("zai") || slug.includes("z-ai"))
+    return "zai-coding-plan";
+  if (slug.includes("kimi"))
+    return "kimi-for-coding";
+  if (slug.includes("opencode"))
+    return "opencode";
+  return;
+}
+function parseOpenRouterPrice(value) {
+  if (!value)
+    return;
+  const parsed = Number.parseFloat(value);
+  if (!Number.isFinite(parsed))
+    return;
+  return parsed * 1e6;
+}
+async function fetchJsonWithTimeout(url2, init, timeoutMs) {
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url2, {
+      ...init,
+      signal: controller.signal
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function fetchArtificialAnalysisSignals(apiKey) {
+  const response = await fetchJsonWithTimeout("https://artificialanalysis.ai/api/v2/data/llms/models", {
+    headers: {
+      "x-api-key": apiKey
+    }
+  }, 8000);
+  if (!response.ok) {
+    throw new Error(`Artificial Analysis request failed (${response.status} ${response.statusText})`);
+  }
+  const parsed = await response.json();
+  const map2 = {};
+  for (const model of parsed.data ?? []) {
+    const baseSignal = {
+      qualityScore: model.evaluations?.artificial_analysis_intelligence_index,
+      codingScore: model.evaluations?.artificial_analysis_coding_index ?? model.evaluations?.livecodebench,
+      latencySeconds: model.median_time_to_first_token_seconds,
+      inputPricePer1M: model.pricing?.price_1m_input_tokens ?? model.pricing?.price_1m_blended_3_to_1,
+      outputPricePer1M: model.pricing?.price_1m_output_tokens ?? model.pricing?.price_1m_blended_3_to_1,
+      source: "artificial-analysis"
+    };
+    const id = model.id ? normalizeKey(model.id) : undefined;
+    const slug = model.slug ? normalizeKey(model.slug) : undefined;
+    const name = model.name ? normalizeKey(model.name) : undefined;
+    const providerPrefix = providerPrefixFromCreator(model.model_creator?.slug);
+    for (const key of [id, slug, name]) {
+      if (!key)
+        continue;
+      for (const alias of baseAliases(key)) {
+        if (!providerPrefix || alias.includes("/")) {
+          map2[alias] = mergeSignal(map2[alias], baseSignal);
+        }
+        const scopedAlias = providerScopedAlias(alias, providerPrefix);
+        map2[scopedAlias] = mergeSignal(map2[scopedAlias], baseSignal);
+      }
+    }
+  }
+  return map2;
+}
+async function fetchOpenRouterSignals(apiKey) {
+  const response = await fetchJsonWithTimeout("https://openrouter.ai/api/v1/models", {
+    headers: {
+      Authorization: `Bearer ${apiKey}`
+    }
+  }, 8000);
+  if (!response.ok) {
+    throw new Error(`OpenRouter request failed (${response.status} ${response.statusText})`);
+  }
+  const parsed = await response.json();
+  const map2 = {};
+  for (const model of parsed.data ?? []) {
+    if (!model.id)
+      continue;
+    const key = normalizeKey(model.id);
+    const providerPrefix = key.split("/")[0];
+    const signal = {
+      inputPricePer1M: parseOpenRouterPrice(model.pricing?.prompt),
+      outputPricePer1M: parseOpenRouterPrice(model.pricing?.completion),
+      source: "openrouter"
+    };
+    for (const alias of baseAliases(key)) {
+      if (alias.includes("/")) {
+        map2[alias] = mergeSignal(map2[alias], signal);
+      }
+      const scopedAlias = providerScopedAlias(alias, providerPrefix);
+      map2[scopedAlias] = mergeSignal(map2[scopedAlias], signal);
+    }
+  }
+  return map2;
+}
+async function fetchExternalModelSignals(options) {
+  const warnings = [];
+  const aggregate = {};
+  const aaKey = options?.artificialAnalysisApiKey ?? getEnv("ARTIFICIAL_ANALYSIS_API_KEY");
+  const orKey = options?.openRouterApiKey ?? getEnv("OPENROUTER_API_KEY");
+  const aaPromise = aaKey ? fetchArtificialAnalysisSignals(aaKey) : Promise.resolve({});
+  const orPromise = orKey ? fetchOpenRouterSignals(orKey) : Promise.resolve({});
+  const [aaResult, orResult] = await Promise.allSettled([aaPromise, orPromise]);
+  if (aaResult.status === "fulfilled") {
+    for (const [key, signal] of Object.entries(aaResult.value)) {
+      aggregate[key] = mergeSignal(aggregate[key], signal);
+    }
+  } else if (aaKey) {
+    warnings.push(`Artificial Analysis unavailable: ${aaResult.reason instanceof Error ? aaResult.reason.message : String(aaResult.reason)}`);
+  }
+  if (orResult.status === "fulfilled") {
+    for (const [key, signal] of Object.entries(orResult.value)) {
+      aggregate[key] = mergeSignal(aggregate[key], signal);
+    }
+  } else if (orKey) {
+    warnings.push(`OpenRouter unavailable: ${orResult.reason instanceof Error ? orResult.reason.message : String(orResult.reason)}`);
+  }
+  return { signals: aggregate, warnings };
+}
+// src/cli/system.ts
+import { statSync as statSync2 } from "fs";
+var cachedOpenCodePath = null;
+function getOpenCodePaths() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  return [
+    "opencode",
+    `${home}/.local/bin/opencode`,
+    `${home}/.opencode/bin/opencode`,
+    `${home}/bin/opencode`,
+    "/usr/local/bin/opencode",
+    "/opt/opencode/bin/opencode",
+    "/usr/bin/opencode",
+    "/bin/opencode",
+    "/Applications/OpenCode.app/Contents/MacOS/opencode",
+    `${home}/Applications/OpenCode.app/Contents/MacOS/opencode`,
+    "/opt/homebrew/bin/opencode",
+    "/home/linuxbrew/.linuxbrew/bin/opencode",
+    `${home}/homebrew/bin/opencode`,
+    `${home}/Library/Application Support/opencode/bin/opencode`,
+    "/snap/bin/opencode",
+    "/var/snap/opencode/current/bin/opencode",
+    "/var/lib/flatpak/exports/bin/ai.opencode.OpenCode",
+    `${home}/.local/share/flatpak/exports/bin/ai.opencode.OpenCode`,
+    "/nix/store/opencode/bin/opencode",
+    `${home}/.nix-profile/bin/opencode`,
+    "/run/current-system/sw/bin/opencode",
+    `${home}/.cargo/bin/opencode`,
+    `${home}/.npm-global/bin/opencode`,
+    "/usr/local/lib/node_modules/opencode/bin/opencode",
+    `${home}/.yarn/bin/opencode`,
+    `${home}/.pnpm-global/bin/opencode`
+  ];
+}
+function resolveOpenCodePath() {
+  if (cachedOpenCodePath) {
+    return cachedOpenCodePath;
+  }
+  const paths = getOpenCodePaths();
+  for (const opencodePath of paths) {
+    if (opencodePath === "opencode")
+      continue;
+    try {
+      const stat = statSync2(opencodePath);
+      if (stat.isFile()) {
+        cachedOpenCodePath = opencodePath;
+        return opencodePath;
+      }
+    } catch {}
+  }
+  return "opencode";
+}
+async function isOpenCodeInstalled() {
+  const paths = getOpenCodePaths();
+  for (const opencodePath of paths) {
+    try {
+      const proc = Bun.spawn([opencodePath, "--version"], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      await proc.exited;
+      if (proc.exitCode === 0) {
+        cachedOpenCodePath = opencodePath;
+        return true;
+      }
+    } catch {}
+  }
+  return false;
+}
+async function getOpenCodeVersion() {
+  const opencodePath = resolveOpenCodePath();
+  try {
+    const proc = Bun.spawn([opencodePath, "--version"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const output = await new Response(proc.stdout).text();
+    await proc.exited;
+    if (proc.exitCode === 0) {
+      return output.trim();
+    }
+  } catch {}
+  return null;
+}
+function getOpenCodePath() {
+  const path2 = resolveOpenCodePath();
+  return path2 === "opencode" ? null : path2;
+}
+
+// src/cli/opencode-models.ts
+function isFreeModel(record2) {
+  const inputCost = record2.cost?.input ?? 0;
+  const outputCost = record2.cost?.output ?? 0;
+  const cacheReadCost = record2.cost?.cache?.read ?? 0;
+  const cacheWriteCost = record2.cost?.cache?.write ?? 0;
+  return inputCost === 0 && outputCost === 0 && cacheReadCost === 0 && cacheWriteCost === 0;
+}
+function parseDailyRequestLimit(record2) {
+  const explicitLimit = record2.quota?.requestsPerDay ?? record2.meta?.requestsPerDay ?? record2.meta?.dailyLimit;
+  if (typeof explicitLimit === "number" && Number.isFinite(explicitLimit)) {
+    return explicitLimit;
+  }
+  const source = `${record2.id} ${record2.name ?? ""}`.toLowerCase();
+  const match = source.match(/\b(300|2000|5000)\b(?:\s*(?:req|requests|rpd|\/day))?/);
+  if (!match)
+    return;
+  const parsed = Number.parseInt(match[1], 10);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+function normalizeDiscoveredModel(record2, providerFilter) {
+  if (providerFilter && record2.providerID !== providerFilter)
+    return null;
+  const fullModel = `${record2.providerID}/${record2.id}`;
+  return {
+    providerID: record2.providerID,
+    model: fullModel,
+    name: record2.name ?? record2.id,
+    status: record2.status ?? "active",
+    contextLimit: record2.limit?.context ?? 0,
+    outputLimit: record2.limit?.output ?? 0,
+    reasoning: record2.capabilities?.reasoning === true,
+    toolcall: record2.capabilities?.toolcall === true,
+    attachment: record2.capabilities?.attachment === true,
+    dailyRequestLimit: parseDailyRequestLimit(record2),
+    costInput: record2.cost?.input,
+    costOutput: record2.cost?.output
+  };
+}
+function parseOpenCodeModelsVerboseOutput(output, providerFilter, freeOnly = true) {
+  const lines = output.split(/\r?\n/);
+  const models = [];
+  const modelHeaderPattern = /^[a-z0-9-]+\/.+$/i;
+  for (let index = 0;index < lines.length; index++) {
+    const line = lines[index]?.trim();
+    if (!line || !line.includes("/"))
+      continue;
+    if (!modelHeaderPattern.test(line))
+      continue;
+    let jsonStart = -1;
+    for (let search = index + 1;search < lines.length; search++) {
+      if (lines[search]?.trim().startsWith("{")) {
+        jsonStart = search;
+        break;
+      }
+      if (modelHeaderPattern.test(lines[search]?.trim() ?? "")) {
+        break;
+      }
+    }
+    if (jsonStart === -1)
+      continue;
+    let braceDepth = 0;
+    const jsonLines = [];
+    let jsonEnd = -1;
+    for (let cursor = jsonStart;cursor < lines.length; cursor++) {
+      const current = lines[cursor] ?? "";
+      jsonLines.push(current);
+      for (const char of current) {
+        if (char === "{")
+          braceDepth++;
+        if (char === "}")
+          braceDepth--;
+      }
+      if (braceDepth === 0 && jsonLines.length > 0) {
+        jsonEnd = cursor;
+        break;
+      }
+    }
+    if (jsonEnd === -1)
+      continue;
+    try {
+      const parsed = JSON.parse(jsonLines.join(`
+`));
+      const normalized = normalizeDiscoveredModel(parsed, providerFilter);
+      if (!normalized)
+        continue;
+      if (freeOnly && !isFreeModel(parsed))
+        continue;
+      if (normalized)
+        models.push(normalized);
+    } catch {}
+    index = jsonEnd;
+  }
+  return models;
+}
+async function discoverModelsByProvider(providerID, freeOnly = true) {
+  try {
+    const opencodePath = resolveOpenCodePath();
+    const proc = Bun.spawn([opencodePath, "models", "--refresh", "--verbose"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    await proc.exited;
+    if (proc.exitCode !== 0) {
+      return {
+        models: [],
+        error: stderr.trim() || "Failed to fetch OpenCode models."
+      };
+    }
+    return {
+      models: parseOpenCodeModelsVerboseOutput(stdout, providerID, freeOnly)
+    };
+  } catch {
+    return {
+      models: [],
+      error: "Unable to run `opencode models --refresh --verbose`."
+    };
+  }
+}
+async function discoverModelCatalog() {
+  try {
+    const opencodePath = resolveOpenCodePath();
+    const proc = Bun.spawn([opencodePath, "models", "--refresh", "--verbose"], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    await proc.exited;
+    if (proc.exitCode !== 0) {
+      return {
+        models: [],
+        error: stderr.trim() || "Failed to fetch OpenCode models."
+      };
+    }
+    return {
+      models: parseOpenCodeModelsVerboseOutput(stdout, undefined, false)
+    };
+  } catch {
+    return {
+      models: [],
+      error: "Unable to run `opencode models --refresh --verbose`."
+    };
+  }
+}
+async function discoverOpenCodeFreeModels() {
+  const result = await discoverModelsByProvider("opencode", true);
+  return { models: result.models, error: result.error };
+}
+async function discoverProviderModels(providerID) {
+  return discoverModelsByProvider(providerID, false);
+}
+// src/cli/opencode-selection.ts
+var scoreOpenCodePrimaryForCoding = (model) => {
+  return (model.reasoning ? 100 : 0) + (model.toolcall ? 80 : 0) + (model.attachment ? 20 : 0) + Math.min(model.contextLimit, 1e6) / 1e4 + Math.min(model.outputLimit, 300000) / 1e4 + (model.status === "active" ? 10 : 0);
+};
+function speedBonus2(modelName) {
+  const lower = modelName.toLowerCase();
+  let score = 0;
+  if (lower.includes("nano"))
+    score += 60;
+  if (lower.includes("flash"))
+    score += 45;
+  if (lower.includes("mini"))
+    score += 25;
+  if (lower.includes("preview"))
+    score += 10;
+  return score;
+}
+var scoreOpenCodeSupportForCoding = (model) => {
+  return (model.toolcall ? 90 : 0) + (model.reasoning ? 50 : 0) + speedBonus2(model.model) + Math.min(model.contextLimit, 400000) / 20000 + (model.status === "active" ? 5 : 0);
+};
+function pickBestCodingOpenCodeModel(models) {
+  return pickBestModel(models, scoreOpenCodePrimaryForCoding);
+}
+function pickSupportOpenCodeModel(models, primaryModel) {
+  const { support } = pickPrimaryAndSupport(models, {
+    primary: scoreOpenCodePrimaryForCoding,
+    support: scoreOpenCodeSupportForCoding
+  }, primaryModel);
+  return support;
+}
+// src/cli/custom-skills.ts
+import {
+  copyFileSync as copyFileSync2,
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  statSync as statSync3
+} from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname, join as join3 } from "path";
+import { fileURLToPath } from "url";
+var CUSTOM_SKILLS = [
+  {
+    name: "cartography",
+    description: "Repository understanding and hierarchical codemap generation",
+    allowedAgents: ["orchestrator"],
+    sourcePath: "src/skills/cartography"
+  }
+];
+function getCustomSkillsDir() {
+  return join3(homedir2(), ".config", "opencode", "skills");
+}
+function copyDirRecursive(src, dest) {
+  if (!existsSync3(dest)) {
+    mkdirSync2(dest, { recursive: true });
+  }
+  const entries = readdirSync(src);
+  for (const entry of entries) {
+    const srcPath = join3(src, entry);
+    const destPath = join3(dest, entry);
+    const stat = statSync3(srcPath);
+    if (stat.isDirectory()) {
+      copyDirRecursive(srcPath, destPath);
+    } else {
+      const destDir = dirname(destPath);
+      if (!existsSync3(destDir)) {
+        mkdirSync2(destDir, { recursive: true });
+      }
+      copyFileSync2(srcPath, destPath);
+    }
+  }
+}
+function installCustomSkill(skill) {
+  try {
+    const packageRoot = fileURLToPath(new URL("../..", import.meta.url));
+    const sourcePath = join3(packageRoot, skill.sourcePath);
+    const targetPath = join3(getCustomSkillsDir(), skill.name);
+    if (!existsSync3(sourcePath)) {
+      console.error(`Custom skill source not found: ${sourcePath}`);
+      return false;
+    }
+    copyDirRecursive(sourcePath, targetPath);
+    return true;
+  } catch (error48) {
+    console.error(`Failed to install custom skill: ${skill.name}`, error48);
+    return false;
+  }
+}
+
+// src/cli/install.ts
+var GREEN = "\x1B[32m";
+var BLUE = "\x1B[34m";
+var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var RESET = "\x1B[0m";
+var SYMBOLS = {
+  check: `${GREEN}\u2713${RESET}`,
   cross: `${RED}\u2717${RESET}`,
   arrow: `${BLUE}\u2192${RESET}`,
   bullet: `${DIM}\u2022${RESET}`,
@@ -14066,11 +16126,16 @@ async function checkOpenCodeInstalled() {
     printError("OpenCode is not installed on this system.");
     printInfo("Install it with:");
     console.log(`     ${BLUE}curl -fsSL https://opencode.ai/install | bash${RESET}`);
+    console.log();
+    printInfo("Or if already installed, add it to your PATH:");
+    console.log(`     ${BLUE}export PATH="$HOME/.local/bin:$PATH"${RESET}`);
+    console.log(`     ${BLUE}export PATH="$HOME/.opencode/bin:$PATH"${RESET}`);
     return { ok: false };
   }
   const version2 = await getOpenCodeVersion();
-  printSuccess(`OpenCode ${version2 ?? ""} detected`);
-  return { ok: true, version: version2 ?? undefined };
+  const path2 = getOpenCodePath();
+  printSuccess(`OpenCode ${version2 ?? ""} detected${path2 ? ` (${DIM}${path2}${RESET})` : ""}`);
+  return { ok: true, version: version2 ?? undefined, path: path2 ?? undefined };
 }
 function handleStepResult(result, successMsg) {
   if (!result.success) {
@@ -14089,7 +16154,25 @@ function formatConfigSummary(config2) {
   lines.push(`  ${BOLD}Preset:${RESET} ${BLUE}${preset}${RESET}`);
   lines.push(`  ${config2.hasKimi ? SYMBOLS.check : `${DIM}\u25CB${RESET}`} Kimi`);
   lines.push(`  ${config2.hasOpenAI ? SYMBOLS.check : `${DIM}\u25CB${RESET}`} OpenAI`);
-  lines.push(`  ${SYMBOLS.check} Opencode Zen (Big Pickle)`);
+  lines.push(`  ${config2.hasAnthropic ? SYMBOLS.check : `${DIM}\u25CB${RESET}`} Anthropic`);
+  lines.push(`  ${config2.hasCopilot ? SYMBOLS.check : `${DIM}\u25CB${RESET}`} GitHub Copilot`);
+  lines.push(`  ${config2.hasZaiPlan ? SYMBOLS.check : `${DIM}\u25CB${RESET}`} ZAI Coding Plan`);
+  lines.push(`  ${config2.hasAntigravity ? SYMBOLS.check : `${DIM}\u25CB${RESET}`} Antigravity (Google)`);
+  lines.push(`  ${config2.hasChutes ? SYMBOLS.check : `${DIM}\u25CB${RESET}`} Chutes`);
+  lines.push(`  ${SYMBOLS.check} Opencode Zen`);
+  lines.push(`  ${config2.balanceProviderUsage ? SYMBOLS.check : `${DIM}\u25CB${RESET}`} Balanced provider spend`);
+  if (config2.useOpenCodeFreeModels && config2.selectedOpenCodePrimaryModel) {
+    lines.push(`  ${SYMBOLS.check} OpenCode Free Primary: ${BLUE}${config2.selectedOpenCodePrimaryModel}${RESET}`);
+  }
+  if (config2.useOpenCodeFreeModels && config2.selectedOpenCodeSecondaryModel) {
+    lines.push(`  ${SYMBOLS.check} OpenCode Free Support: ${BLUE}${config2.selectedOpenCodeSecondaryModel}${RESET}`);
+  }
+  if (config2.hasChutes && config2.selectedChutesPrimaryModel) {
+    lines.push(`  ${SYMBOLS.check} Chutes Primary: ${BLUE}${config2.selectedChutesPrimaryModel}${RESET}`);
+  }
+  if (config2.hasChutes && config2.selectedChutesSecondaryModel) {
+    lines.push(`  ${SYMBOLS.check} Chutes Support: ${BLUE}${config2.selectedChutesSecondaryModel}${RESET}`);
+  }
   lines.push(`  ${config2.hasTmux ? SYMBOLS.check : `${DIM}\u25CB${RESET}`} Tmux Integration`);
   return lines.join(`
 `);
@@ -14115,11 +16198,42 @@ function argsToConfig(args) {
   return {
     hasKimi: args.kimi === "yes",
     hasOpenAI: args.openai === "yes",
+    hasAnthropic: args.anthropic === "yes",
+    hasCopilot: args.copilot === "yes",
+    hasZaiPlan: args.zaiPlan === "yes",
+    hasAntigravity: args.antigravity === "yes",
+    hasChutes: args.chutes === "yes",
     hasOpencodeZen: true,
+    useOpenCodeFreeModels: args.opencodeFree === "yes",
+    preferredOpenCodeModel: args.opencodeFreeModel && args.opencodeFreeModel !== "auto" ? args.opencodeFreeModel : undefined,
+    artificialAnalysisApiKey: args.aaKey,
+    openRouterApiKey: args.openrouterKey,
+    balanceProviderUsage: args.balancedSpend === "yes",
     hasTmux: args.tmux === "yes",
     installSkills: args.skills === "yes",
-    installCustomSkills: args.skills === "yes"
-  };
+    installCustomSkills: args.skills === "yes",
+    setupMode: "quick",
+    dryRun: args.dryRun,
+    modelsOnly: args.modelsOnly
+  };
+}
+async function askModelSelection(rl, models, defaultModel, prompt) {
+  const defaultIndex = Math.max(0, models.findIndex((model) => model.model === defaultModel));
+  for (const [index, model] of models.entries()) {
+    const marker = model.model === defaultModel ? `${BOLD}(recommended)${RESET}` : "";
+    console.log(`  ${DIM}${index + 1}.${RESET} ${BLUE}${model.model}${RESET} ${DIM}${model.name}${RESET} ${marker}`);
+  }
+  const answer = (await rl.question(`${BLUE}${prompt}${RESET} ${DIM}[default: ${defaultIndex + 1}]${RESET}: `)).trim().toLowerCase();
+  if (!answer)
+    return defaultModel;
+  const asNumber = Number.parseInt(answer, 10);
+  if (Number.isFinite(asNumber)) {
+    const chosen = models[asNumber - 1];
+    if (chosen)
+      return chosen.model;
+  }
+  const byId = models.find((model) => model.model.toLowerCase() === answer);
+  return byId?.model ?? defaultModel;
 }
 async function askYesNo(rl, prompt, defaultValue = "no") {
   const hint = defaultValue === "yes" ? "[Y/n]" : "[y/N]";
@@ -14132,104 +16246,630 @@ async function askYesNo(rl, prompt, defaultValue = "no") {
     return "no";
   return defaultValue;
 }
-async function runInteractiveMode(detected) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  const totalQuestions = 2;
-  try {
-    console.log(`${BOLD}Question 1/${totalQuestions}:${RESET}`);
-    const kimi = await askYesNo(rl, "Do you want to use Kimi For Coding?", detected.hasKimi ? "yes" : "no");
+async function askOptionalApiKey(rl, prompt, fromEnv) {
+  const hint = fromEnv ? "[optional, Enter keeps env value]" : "[optional]";
+  const answer = (await rl.question(`${BLUE}${prompt}${RESET} ${DIM}${hint}${RESET}: `)).trim();
+  if (!answer)
+    return fromEnv;
+  return answer;
+}
+async function askSetupMode(rl) {
+  console.log(`${BOLD}Choose setup mode:${RESET}`);
+  console.log(`  ${DIM}1.${RESET} Quick setup - you choose providers, we auto-pick models`);
+  console.log(`  ${DIM}2.${RESET} Manual setup - you choose providers and models per agent`);
+  console.log();
+  const answer = (await rl.question(`${BLUE}Selection${RESET} ${DIM}[default: 1]${RESET}: `)).trim().toLowerCase();
+  if (answer === "2" || answer === "manual")
+    return "manual";
+  return "quick";
+}
+async function askModelByNumber(rl, models, prompt, allowEmpty = false) {
+  let showAll = false;
+  while (true) {
+    console.log(`${BOLD}${prompt}${RESET}`);
+    console.log(`${DIM}Available models:${RESET}`);
+    const modelsToShow = showAll ? models : models.slice(0, 5);
+    const remainingCount = models.length - modelsToShow.length;
+    for (const [index, model] of modelsToShow.entries()) {
+      const displayIndex = showAll ? index + 1 : index + 1;
+      const name = model.name ? ` ${DIM}(${model.name})${RESET}` : "";
+      console.log(`  ${DIM}${displayIndex}.${RESET} ${BLUE}${model.model}${RESET}${name}`);
+    }
+    if (!showAll && remainingCount > 0) {
+      console.log(`${DIM}  ... and ${remainingCount} more${RESET}`);
+      console.log(`${DIM}  (type "all" to show the full list)${RESET}`);
+    }
+    console.log(`${DIM}  (or type any model ID directly)${RESET}`);
     console.log();
-    console.log(`${BOLD}Question 2/${totalQuestions}:${RESET}`);
-    const openai = await askYesNo(rl, "Do you have access to OpenAI API?", detected.hasOpenAI ? "yes" : "no");
+    const answer = (await rl.question(`${BLUE}Selection${RESET}: `)).trim().toLowerCase();
+    if (!answer) {
+      if (allowEmpty)
+        return;
+      return models[0]?.model;
+    }
+    if (answer === "all") {
+      showAll = true;
+      console.log();
+      continue;
+    }
+    const asNumber = Number.parseInt(answer, 10);
+    if (Number.isFinite(asNumber) && asNumber >= 1 && asNumber <= models.length) {
+      return models[asNumber - 1]?.model;
+    }
+    const byId = models.find((m) => m.model.toLowerCase() === answer);
+    if (byId)
+      return byId.model;
+    if (answer.includes("/"))
+      return answer;
+    printWarning(`Invalid selection: "${answer}". Using first available model.`);
+    return models[0]?.model;
+  }
+}
+async function configureAgentManually(rl, agentName, allModels) {
+  console.log();
+  console.log(`${BOLD}Configure ${agentName}:${RESET}`);
+  console.log();
+  const selectedModels = new Set;
+  const primary = await askModelByNumber(rl, allModels, "Primary model") ?? allModels[0]?.model ?? "opencode/big-pickle";
+  selectedModels.add(primary);
+  const availableForFallback1 = allModels.filter((m) => !selectedModels.has(m.model));
+  const fallback1 = availableForFallback1.length > 0 ? await askModelByNumber(rl, availableForFallback1, "Fallback 1 (optional, press Enter to skip)", true) ?? primary : primary;
+  if (fallback1 !== primary)
+    selectedModels.add(fallback1);
+  const availableForFallback2 = allModels.filter((m) => !selectedModels.has(m.model));
+  const fallback2 = availableForFallback2.length > 0 ? await askModelByNumber(rl, availableForFallback2, "Fallback 2 (optional, press Enter to skip)", true) ?? fallback1 : fallback1;
+  if (fallback2 !== fallback1)
+    selectedModels.add(fallback2);
+  const availableForFallback3 = allModels.filter((m) => !selectedModels.has(m.model));
+  const fallback3 = availableForFallback3.length > 0 ? await askModelByNumber(rl, availableForFallback3, "Fallback 3 (optional, press Enter to skip)", true) ?? fallback2 : fallback2;
+  return {
+    primary,
+    fallback1,
+    fallback2,
+    fallback3
+  };
+}
+async function runManualSetupMode(rl, detected, modelsOnly = false) {
+  console.log();
+  console.log(`${BOLD}Manual Setup Mode${RESET}`);
+  console.log("=".repeat(20));
+  console.log();
+  const existingAaKey = getEnv("ARTIFICIAL_ANALYSIS_API_KEY");
+  const existingOpenRouterKey = getEnv("OPENROUTER_API_KEY");
+  const artificialAnalysisApiKey = await askOptionalApiKey(rl, "Artificial Analysis API key for better ranking signals", existingAaKey);
+  if (existingAaKey && !artificialAnalysisApiKey) {
+    printInfo("Using existing ARTIFICIAL_ANALYSIS_API_KEY from environment.");
+  }
+  console.log();
+  const openRouterApiKey = await askOptionalApiKey(rl, "OpenRouter API key for pricing/metadata signals", existingOpenRouterKey);
+  if (existingOpenRouterKey && !openRouterApiKey) {
+    printInfo("Using existing OPENROUTER_API_KEY from environment.");
+  }
+  console.log();
+  const useOpenCodeFree = await askYesNo(rl, "Use Opencode Free models (opencode/*)?", "yes");
+  console.log();
+  let availableOpenCodeFreeModels;
+  let availableChutesModels;
+  if (useOpenCodeFree === "yes") {
+    printInfo("Refreshing models with: opencode models --refresh --verbose");
+    const discovery = await discoverOpenCodeFreeModels();
+    if (discovery.models.length === 0) {
+      printWarning(discovery.error ?? "No OpenCode free models found. Continuing without OpenCode free-model assignment.");
+    } else {
+      availableOpenCodeFreeModels = discovery.models;
+      printSuccess(`Found ${discovery.models.length} OpenCode free models`);
+    }
     console.log();
+  }
+  const kimi = await askYesNo(rl, "Enable Kimi provider?", detected.hasKimi ? "yes" : "no");
+  console.log();
+  const openai = await askYesNo(rl, "Enable OpenAI provider?", detected.hasOpenAI ? "yes" : "no");
+  console.log();
+  const anthropic = await askYesNo(rl, "Enable Anthropic provider?", detected.hasAnthropic ? "yes" : "no");
+  console.log();
+  const copilot = await askYesNo(rl, "Enable GitHub Copilot provider?", detected.hasCopilot ? "yes" : "no");
+  console.log();
+  const zaiPlan = await askYesNo(rl, "Enable ZAI Coding Plan provider?", detected.hasZaiPlan ? "yes" : "no");
+  console.log();
+  const antigravity = await askYesNo(rl, "Enable Antigravity (Google) provider?", detected.hasAntigravity ? "yes" : "no");
+  console.log();
+  const chutes = await askYesNo(rl, "Enable Chutes provider?", detected.hasChutes ? "yes" : "no");
+  console.log();
+  if (chutes === "yes") {
+    printInfo("Refreshing Chutes model list with: opencode models --refresh --verbose");
+    const discovery = await discoverProviderModels("chutes");
+    if (discovery.models.length === 0) {
+      printWarning(discovery.error ?? "No Chutes models found. Continuing without Chutes dynamic assignment.");
+    } else {
+      availableChutesModels = discovery.models;
+      printSuccess(`Found ${discovery.models.length} Chutes models`);
+    }
+    console.log();
+  }
+  const availableModels = [];
+  if (useOpenCodeFree === "yes" && availableOpenCodeFreeModels) {
+    for (const model of availableOpenCodeFreeModels) {
+      availableModels.push({ model: model.model, name: model.name });
+    }
+  }
+  if (kimi === "yes") {
+    availableModels.push({ model: "kimi-for-coding/k2p5", name: "Kimi K2.5" });
+  }
+  if (openai === "yes") {
+    availableModels.push({
+      model: "openai/gpt-5.3-codex",
+      name: "GPT-5.3 Codex"
+    });
+    availableModels.push({
+      model: "openai/gpt-5.1-codex-mini",
+      name: "GPT-5.1 Codex Mini"
+    });
+  }
+  if (anthropic === "yes") {
+    availableModels.push({
+      model: "anthropic/claude-opus-4-6",
+      name: "Claude Opus 4.6"
+    });
+    availableModels.push({
+      model: "anthropic/claude-sonnet-4-5",
+      name: "Claude Sonnet 4.5"
+    });
+    availableModels.push({
+      model: "anthropic/claude-haiku-4-5",
+      name: "Claude Haiku 4.5"
+    });
+  }
+  if (copilot === "yes") {
+    availableModels.push({
+      model: "github-copilot/grok-code-fast-1",
+      name: "Grok Code Fast"
+    });
+  }
+  if (zaiPlan === "yes") {
+    availableModels.push({ model: "zai-coding-plan/glm-4.7", name: "GLM 4.7" });
+  }
+  if (antigravity === "yes") {
+    availableModels.push({
+      model: "google/antigravity-gemini-3-pro",
+      name: "Gemini 3 Pro"
+    });
+    availableModels.push({
+      model: "google/antigravity-gemini-3-flash",
+      name: "Gemini 3 Flash"
+    });
+  }
+  if (chutes === "yes" && availableChutesModels) {
+    for (const model of availableChutesModels) {
+      availableModels.push({ model: model.model, name: model.name });
+    }
+  }
+  availableModels.push({
+    model: "opencode/big-pickle",
+    name: "OpenCode Big Pickle"
+  });
+  if (availableModels.length === 0) {
+    printWarning("No models available. Please enable at least one provider.");
+    availableModels.push({
+      model: "opencode/big-pickle",
+      name: "OpenCode Big Pickle"
+    });
+  }
+  const manualAgentConfigs = {};
+  const agentNames = [
+    "orchestrator",
+    "oracle",
+    "designer",
+    "explorer",
+    "librarian",
+    "fixer"
+  ];
+  for (const agentName of agentNames) {
+    manualAgentConfigs[agentName] = await configureAgentManually(rl, agentName, availableModels);
+  }
+  const balancedSpend = await askYesNo(rl, "Do you have subscriptions or pay per API? If yes, we will distribute assignments evenly across selected providers so your subscriptions last longer.", "no");
+  console.log();
+  let skills = "no";
+  let customSkills = "no";
+  if (!modelsOnly) {
     console.log(`${BOLD}Recommended Skills:${RESET}`);
     for (const skill of RECOMMENDED_SKILLS) {
       console.log(`  ${SYMBOLS.bullet} ${BOLD}${skill.name}${RESET}: ${skill.description}`);
     }
     console.log();
-    const skills = await askYesNo(rl, "Install recommended skills?", "yes");
+    skills = await askYesNo(rl, "Install recommended skills?", "yes");
     console.log();
     console.log(`${BOLD}Custom Skills:${RESET}`);
     for (const skill of CUSTOM_SKILLS) {
       console.log(`  ${SYMBOLS.bullet} ${BOLD}${skill.name}${RESET}: ${skill.description}`);
     }
     console.log();
-    const customSkills = await askYesNo(rl, "Install custom skills?", "yes");
+    customSkills = await askYesNo(rl, "Install custom skills?", "yes");
+    console.log();
+  } else {
+    printInfo("Models-only mode: skipping plugin/auth setup and skills prompts.");
+    console.log();
+  }
+  return {
+    hasKimi: kimi === "yes",
+    hasOpenAI: openai === "yes",
+    hasAnthropic: anthropic === "yes",
+    hasCopilot: copilot === "yes",
+    hasZaiPlan: zaiPlan === "yes",
+    hasAntigravity: antigravity === "yes",
+    hasChutes: chutes === "yes",
+    hasOpencodeZen: true,
+    useOpenCodeFreeModels: useOpenCodeFree === "yes" && availableOpenCodeFreeModels !== undefined,
+    availableOpenCodeFreeModels,
+    availableChutesModels,
+    artificialAnalysisApiKey,
+    openRouterApiKey,
+    balanceProviderUsage: balancedSpend === "yes",
+    hasTmux: false,
+    installSkills: skills === "yes",
+    installCustomSkills: customSkills === "yes",
+    setupMode: "manual",
+    manualAgentConfigs,
+    modelsOnly
+  };
+}
+async function runInteractiveMode(detected, modelsOnly = false) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    console.log();
+    console.log(`${BOLD}oh-my-opencode-slim Setup${RESET}`);
+    console.log("=".repeat(25));
+    console.log();
+    const setupMode = await askSetupMode(rl);
+    if (setupMode === "manual") {
+      const config2 = await runManualSetupMode(rl, detected, modelsOnly);
+      rl.close();
+      return config2;
+    }
+    const totalQuestions = 11;
+    const existingAaKey = getEnv("ARTIFICIAL_ANALYSIS_API_KEY");
+    const existingOpenRouterKey = getEnv("OPENROUTER_API_KEY");
+    console.log(`${BOLD}Question 1/${totalQuestions}:${RESET}`);
+    const artificialAnalysisApiKey = await askOptionalApiKey(rl, "Artificial Analysis API key for better ranking signals", existingAaKey);
+    if (existingAaKey && !artificialAnalysisApiKey) {
+      printInfo("Using existing ARTIFICIAL_ANALYSIS_API_KEY from environment.");
+    }
+    console.log();
+    console.log(`${BOLD}Question 2/${totalQuestions}:${RESET}`);
+    const openRouterApiKey = await askOptionalApiKey(rl, "OpenRouter API key for pricing/metadata signals", existingOpenRouterKey);
+    if (existingOpenRouterKey && !openRouterApiKey) {
+      printInfo("Using existing OPENROUTER_API_KEY from environment.");
+    }
+    console.log();
+    console.log(`${BOLD}Question 3/${totalQuestions}:${RESET}`);
+    const useOpenCodeFree = await askYesNo(rl, "Use Opencode Free models (opencode/*)?", "yes");
     console.log();
+    let availableOpenCodeFreeModels;
+    let selectedOpenCodePrimaryModel;
+    let selectedOpenCodeSecondaryModel;
+    let availableChutesModels;
+    let selectedChutesPrimaryModel;
+    let selectedChutesSecondaryModel;
+    if (useOpenCodeFree === "yes") {
+      printInfo("Refreshing models with: opencode models --refresh --verbose");
+      const discovery = await discoverOpenCodeFreeModels();
+      if (discovery.models.length === 0) {
+        printWarning(discovery.error ?? "No OpenCode free models found. Continuing without OpenCode free-model assignment.");
+      } else {
+        availableOpenCodeFreeModels = discovery.models;
+        const recommendedPrimary = pickBestCodingOpenCodeModel(discovery.models)?.model ?? discovery.models[0]?.model;
+        if (recommendedPrimary) {
+          printInfo("This step configures only OpenCode Free primary/support models.");
+          console.log(`${BOLD}OpenCode Free Models:${RESET}`);
+          selectedOpenCodePrimaryModel = await askModelSelection(rl, discovery.models, recommendedPrimary, "Choose primary model for orchestrator/oracle");
+        }
+        if (selectedOpenCodePrimaryModel) {
+          const recommendedSecondary = pickSupportOpenCodeModel(discovery.models, selectedOpenCodePrimaryModel)?.model ?? selectedOpenCodePrimaryModel;
+          const openCodeSupportList = discovery.models.filter((model) => model.model !== selectedOpenCodePrimaryModel);
+          const openCodeSupportDefault = recommendedSecondary === selectedOpenCodePrimaryModel ? openCodeSupportList[0]?.model ?? recommendedSecondary : recommendedSecondary;
+          selectedOpenCodeSecondaryModel = await askModelSelection(rl, openCodeSupportList, openCodeSupportDefault, "Choose support model for explorer/librarian/fixer");
+        }
+        console.log();
+      }
+    }
+    console.log(`${BOLD}Question 4/${totalQuestions}:${RESET}`);
+    const kimi = await askYesNo(rl, "Enable Kimi provider?", detected.hasKimi ? "yes" : "no");
+    console.log();
+    console.log(`${BOLD}Question 5/${totalQuestions}:${RESET}`);
+    const openai = await askYesNo(rl, "Enable OpenAI provider?", detected.hasOpenAI ? "yes" : "no");
+    console.log();
+    console.log(`${BOLD}Question 6/${totalQuestions}:${RESET}`);
+    const anthropic = await askYesNo(rl, "Enable Anthropic provider?", detected.hasAnthropic ? "yes" : "no");
+    console.log();
+    console.log(`${BOLD}Question 7/${totalQuestions}:${RESET}`);
+    const copilot = await askYesNo(rl, "Enable GitHub Copilot provider?", detected.hasCopilot ? "yes" : "no");
+    console.log();
+    console.log(`${BOLD}Question 8/${totalQuestions}:${RESET}`);
+    const zaiPlan = await askYesNo(rl, "Enable ZAI Coding Plan provider?", detected.hasZaiPlan ? "yes" : "no");
+    console.log();
+    console.log(`${BOLD}Question 9/${totalQuestions}:${RESET}`);
+    const antigravity = await askYesNo(rl, "Enable Antigravity (Google) provider?", detected.hasAntigravity ? "yes" : "no");
+    console.log();
+    console.log(`${BOLD}Question 10/${totalQuestions}:${RESET}`);
+    const chutes = await askYesNo(rl, "Enable Chutes provider?", detected.hasChutes ? "yes" : "no");
+    console.log();
+    if (chutes === "yes") {
+      printInfo("Refreshing Chutes model list with: opencode models --refresh --verbose");
+      const discovery = await discoverProviderModels("chutes");
+      if (discovery.models.length === 0) {
+        printWarning(discovery.error ?? "No Chutes models found. Continuing without Chutes dynamic assignment.");
+      } else {
+        availableChutesModels = discovery.models;
+        const recommendedPrimary = pickBestCodingChutesModel(discovery.models)?.model ?? discovery.models[0]?.model;
+        if (recommendedPrimary) {
+          console.log(`${BOLD}Chutes Models:${RESET}`);
+          selectedChutesPrimaryModel = await askModelSelection(rl, discovery.models, recommendedPrimary, "Choose Chutes primary model for orchestrator/oracle/designer");
+        }
+        if (selectedChutesPrimaryModel) {
+          const recommendedSecondary = pickSupportChutesModel(discovery.models, selectedChutesPrimaryModel)?.model ?? selectedChutesPrimaryModel;
+          const chutesSupportList = discovery.models.filter((model) => model.model !== selectedChutesPrimaryModel);
+          const chutesSupportDefault = recommendedSecondary === selectedChutesPrimaryModel ? chutesSupportList[0]?.model ?? recommendedSecondary : recommendedSecondary;
+          selectedChutesSecondaryModel = await askModelSelection(rl, chutesSupportList, chutesSupportDefault, "Choose Chutes support model for explorer/librarian/fixer");
+        }
+        console.log();
+      }
+    }
+    console.log(`${BOLD}Question 11/${totalQuestions}:${RESET}`);
+    const balancedSpend = await askYesNo(rl, "Do you have subscriptions or pay per API? If yes, we will distribute assignments evenly across selected providers so your subscriptions last longer.", "no");
+    console.log();
+    let skills = "no";
+    let customSkills = "no";
+    if (!modelsOnly) {
+      console.log(`${BOLD}Recommended Skills:${RESET}`);
+      for (const skill of RECOMMENDED_SKILLS) {
+        console.log(`  ${SYMBOLS.bullet} ${BOLD}${skill.name}${RESET}: ${skill.description}`);
+      }
+      console.log();
+      skills = await askYesNo(rl, "Install recommended skills?", "yes");
+      console.log();
+      console.log(`${BOLD}Custom Skills:${RESET}`);
+      for (const skill of CUSTOM_SKILLS) {
+        console.log(`  ${SYMBOLS.bullet} ${BOLD}${skill.name}${RESET}: ${skill.description}`);
+      }
+      console.log();
+      customSkills = await askYesNo(rl, "Install custom skills?", "yes");
+      console.log();
+    } else {
+      printInfo("Models-only mode: skipping plugin/auth setup and skills prompts.");
+      console.log();
+    }
     return {
       hasKimi: kimi === "yes",
       hasOpenAI: openai === "yes",
+      hasAnthropic: anthropic === "yes",
+      hasCopilot: copilot === "yes",
+      hasZaiPlan: zaiPlan === "yes",
+      hasAntigravity: antigravity === "yes",
+      hasChutes: chutes === "yes",
       hasOpencodeZen: true,
+      useOpenCodeFreeModels: useOpenCodeFree === "yes" && selectedOpenCodePrimaryModel !== undefined,
+      selectedOpenCodePrimaryModel,
+      selectedOpenCodeSecondaryModel,
+      availableOpenCodeFreeModels,
+      selectedChutesPrimaryModel,
+      selectedChutesSecondaryModel,
+      availableChutesModels,
+      artificialAnalysisApiKey,
+      openRouterApiKey,
+      balanceProviderUsage: balancedSpend === "yes",
       hasTmux: false,
       installSkills: skills === "yes",
-      installCustomSkills: customSkills === "yes"
+      installCustomSkills: customSkills === "yes",
+      setupMode: "quick",
+      modelsOnly
     };
   } finally {
     rl.close();
   }
 }
 async function runInstall(config2) {
+  const resolvedConfig = {
+    ...config2
+  };
   const detected = detectCurrentConfig();
   const isUpdate = detected.isInstalled;
   printHeader(isUpdate);
-  let totalSteps = 4;
-  if (config2.installSkills)
+  const hasAnyEnabledProvider = resolvedConfig.hasKimi || resolvedConfig.hasOpenAI || resolvedConfig.hasAnthropic || resolvedConfig.hasCopilot || resolvedConfig.hasZaiPlan || resolvedConfig.hasAntigravity || resolvedConfig.hasChutes || resolvedConfig.useOpenCodeFreeModels;
+  const modelsOnly = resolvedConfig.modelsOnly === true;
+  let totalSteps = modelsOnly ? 2 : 4;
+  if (resolvedConfig.useOpenCodeFreeModels)
+    totalSteps += 1;
+  if (!modelsOnly && resolvedConfig.hasAntigravity)
+    totalSteps += 2;
+  if (!modelsOnly && resolvedConfig.hasChutes)
+    totalSteps += 1;
+  if (hasAnyEnabledProvider)
+    totalSteps += 1;
+  if (!modelsOnly && resolvedConfig.installSkills)
     totalSteps += 1;
-  if (config2.installCustomSkills)
+  if (!modelsOnly && resolvedConfig.installCustomSkills)
     totalSteps += 1;
   let step = 1;
+  if (modelsOnly) {
+    printInfo("Models-only mode: updating model assignments without reinstalling plugins/skills.");
+  }
   printStep(step++, totalSteps, "Checking OpenCode installation...");
-  const { ok } = await checkOpenCodeInstalled();
-  if (!ok)
-    return 1;
-  printStep(step++, totalSteps, "Adding oh-my-opencode-slim plugin...");
-  const pluginResult = await addPluginToOpenCodeConfig();
-  if (!handleStepResult(pluginResult, "Plugin added"))
-    return 1;
-  printStep(step++, totalSteps, "Disabling OpenCode default agents...");
-  const agentResult = disableDefaultAgents();
-  if (!handleStepResult(agentResult, "Default agents disabled"))
-    return 1;
+  if (resolvedConfig.dryRun) {
+    printInfo("Dry run mode - skipping OpenCode check");
+  } else {
+    const { ok } = await checkOpenCodeInstalled();
+    if (!ok)
+      return 1;
+  }
+  if (resolvedConfig.useOpenCodeFreeModels && (resolvedConfig.availableOpenCodeFreeModels?.length ?? 0) === 0) {
+    printStep(step++, totalSteps, "Refreshing OpenCode free models (opencode/*)...");
+    const discovery = await discoverOpenCodeFreeModels();
+    if (discovery.models.length === 0) {
+      printWarning(discovery.error ?? "No OpenCode free models found. Continuing without dynamic OpenCode assignment.");
+      resolvedConfig.useOpenCodeFreeModels = false;
+    } else {
+      resolvedConfig.availableOpenCodeFreeModels = discovery.models;
+      const selectedPrimary = resolvedConfig.preferredOpenCodeModel && discovery.models.some((model) => model.model === resolvedConfig.preferredOpenCodeModel) ? resolvedConfig.preferredOpenCodeModel : resolvedConfig.selectedOpenCodePrimaryModel ?? pickBestCodingOpenCodeModel(discovery.models)?.model;
+      resolvedConfig.selectedOpenCodePrimaryModel = selectedPrimary ?? discovery.models[0]?.model;
+      resolvedConfig.selectedOpenCodeSecondaryModel = resolvedConfig.selectedOpenCodeSecondaryModel ?? pickSupportOpenCodeModel(discovery.models, resolvedConfig.selectedOpenCodePrimaryModel)?.model ?? resolvedConfig.selectedOpenCodePrimaryModel;
+      printSuccess(`OpenCode free models ready (${discovery.models.length} models found)`);
+    }
+  } else if (resolvedConfig.useOpenCodeFreeModels && (resolvedConfig.availableOpenCodeFreeModels?.length ?? 0) > 0) {
+    const availableModels = resolvedConfig.availableOpenCodeFreeModels ?? [];
+    resolvedConfig.selectedOpenCodePrimaryModel = resolvedConfig.selectedOpenCodePrimaryModel ?? pickBestCodingOpenCodeModel(availableModels)?.model;
+    resolvedConfig.selectedOpenCodeSecondaryModel = resolvedConfig.selectedOpenCodeSecondaryModel ?? pickSupportOpenCodeModel(availableModels, resolvedConfig.selectedOpenCodePrimaryModel)?.model ?? resolvedConfig.selectedOpenCodePrimaryModel;
+    printStep(step++, totalSteps, "Using previously refreshed OpenCode free model list...");
+    printSuccess(`OpenCode free models ready (${availableModels.length} models found)`);
+  }
+  if (resolvedConfig.hasChutes && (resolvedConfig.availableChutesModels?.length ?? 0) === 0) {
+    printStep(step++, totalSteps, "Refreshing Chutes models (chutes/*)...");
+    const discovery = await discoverProviderModels("chutes");
+    if (discovery.models.length === 0) {
+      printWarning(discovery.error ?? "No Chutes models found. Continuing with fallback Chutes mapping.");
+    } else {
+      resolvedConfig.availableChutesModels = discovery.models;
+      resolvedConfig.selectedChutesPrimaryModel = resolvedConfig.selectedChutesPrimaryModel ?? pickBestCodingChutesModel(discovery.models)?.model ?? discovery.models[0]?.model;
+      resolvedConfig.selectedChutesSecondaryModel = resolvedConfig.selectedChutesSecondaryModel ?? pickSupportChutesModel(discovery.models, resolvedConfig.selectedChutesPrimaryModel)?.model ?? resolvedConfig.selectedChutesPrimaryModel;
+      printSuccess(`Chutes models ready (${discovery.models.length} models found)`);
+    }
+  } else if (resolvedConfig.hasChutes && (resolvedConfig.availableChutesModels?.length ?? 0) > 0) {
+    const availableChutes = resolvedConfig.availableChutesModels ?? [];
+    resolvedConfig.selectedChutesPrimaryModel = resolvedConfig.selectedChutesPrimaryModel ?? pickBestCodingChutesModel(availableChutes)?.model;
+    resolvedConfig.selectedChutesSecondaryModel = resolvedConfig.selectedChutesSecondaryModel ?? pickSupportChutesModel(availableChutes, resolvedConfig.selectedChutesPrimaryModel)?.model ?? resolvedConfig.selectedChutesPrimaryModel;
+    printStep(step++, totalSteps, "Using previously refreshed Chutes model list...");
+    printSuccess(`Chutes models ready (${availableChutes.length} models found)`);
+  }
+  if (!modelsOnly) {
+    printStep(step++, totalSteps, "Adding oh-my-opencode-slim plugin...");
+    if (resolvedConfig.dryRun) {
+      printInfo("Dry run mode - skipping plugin installation");
+    } else {
+      const pluginResult = await addPluginToOpenCodeConfig();
+      if (!handleStepResult(pluginResult, "Plugin added"))
+        return 1;
+    }
+  }
+  if (!modelsOnly && resolvedConfig.hasAntigravity) {
+    printStep(step++, totalSteps, "Adding Antigravity plugin...");
+    if (resolvedConfig.dryRun) {
+      printInfo("Dry run mode - skipping Antigravity plugin");
+    } else {
+      const antigravityPluginResult = addAntigravityPlugin();
+      if (!handleStepResult(antigravityPluginResult, "Antigravity plugin added"))
+        return 1;
+    }
+    printStep(step++, totalSteps, "Configuring Google Provider...");
+    if (resolvedConfig.dryRun) {
+      printInfo("Dry run mode - skipping Google Provider setup");
+    } else {
+      const googleProviderResult = addGoogleProvider();
+      if (!handleStepResult(googleProviderResult, "Google Provider configured"))
+        return 1;
+    }
+  }
+  if (!modelsOnly && resolvedConfig.hasChutes) {
+    printStep(step++, totalSteps, "Enabling Chutes auth flow...");
+    if (resolvedConfig.dryRun) {
+      printInfo("Dry run mode - skipping Chutes auth flow");
+    } else {
+      const chutesProviderResult = addChutesProvider();
+      if (!handleStepResult(chutesProviderResult, "Chutes auth flow ready"))
+        return 1;
+    }
+  }
+  if (hasAnyEnabledProvider) {
+    printStep(step++, totalSteps, "Resolving dynamic model assignments...");
+    const catalogDiscovery = await discoverModelCatalog();
+    if (catalogDiscovery.models.length === 0) {
+      printWarning(catalogDiscovery.error ?? "Unable to discover model catalog. Falling back to static mappings.");
+    } else {
+      const { signals, warnings } = await fetchExternalModelSignals({
+        artificialAnalysisApiKey: resolvedConfig.artificialAnalysisApiKey,
+        openRouterApiKey: resolvedConfig.openRouterApiKey
+      });
+      for (const warning of warnings) {
+        printInfo(warning);
+      }
+      const dynamicPlan = buildDynamicModelPlan(catalogDiscovery.models, resolvedConfig, signals);
+      if (!dynamicPlan) {
+        printWarning("Dynamic planner found no suitable models. Using static mappings.");
+      } else {
+        resolvedConfig.dynamicModelPlan = dynamicPlan;
+        printSuccess(`Dynamic assignments ready (${Object.keys(dynamicPlan.agents).length} agents)`);
+      }
+    }
+  }
+  if (!modelsOnly) {
+    printStep(step++, totalSteps, "Disabling OpenCode default agents...");
+    if (resolvedConfig.dryRun) {
+      printInfo("Dry run mode - skipping agent disabling");
+    } else {
+      const agentResult = disableDefaultAgents();
+      if (!handleStepResult(agentResult, "Default agents disabled"))
+        return 1;
+    }
+  }
   printStep(step++, totalSteps, "Writing oh-my-opencode-slim configuration...");
-  const liteResult = writeLiteConfig(config2);
-  if (!handleStepResult(liteResult, "Config written"))
-    return 1;
-  if (config2.installSkills) {
+  if (resolvedConfig.dryRun) {
+    const liteConfig = generateLiteConfig(resolvedConfig);
+    printInfo("Dry run mode - configuration that would be written:");
+    console.log(`
+${JSON.stringify(liteConfig, null, 2)}
+`);
+  } else {
+    const liteResult = writeLiteConfig(resolvedConfig);
+    if (!handleStepResult(liteResult, "Config written"))
+      return 1;
+  }
+  if (!modelsOnly && resolvedConfig.installSkills) {
     printStep(step++, totalSteps, "Installing recommended skills...");
-    let skillsInstalled = 0;
-    for (const skill of RECOMMENDED_SKILLS) {
-      printInfo(`Installing ${skill.name}...`);
-      if (installSkill(skill)) {
-        printSuccess(`Installed: ${skill.name}`);
-        skillsInstalled++;
-      } else {
-        printWarning(`Failed to install: ${skill.name}`);
+    if (resolvedConfig.dryRun) {
+      printInfo("Dry run mode - would install skills:");
+      for (const skill of RECOMMENDED_SKILLS) {
+        printInfo(`  - ${skill.name}`);
+      }
+    } else {
+      let skillsInstalled = 0;
+      for (const skill of RECOMMENDED_SKILLS) {
+        printInfo(`Installing ${skill.name}...`);
+        if (installSkill(skill)) {
+          printSuccess(`Installed: ${skill.name}`);
+          skillsInstalled++;
+        } else {
+          printWarning(`Failed to install: ${skill.name}`);
+        }
       }
+      printSuccess(`${skillsInstalled}/${RECOMMENDED_SKILLS.length} skills installed`);
     }
-    printSuccess(`${skillsInstalled}/${RECOMMENDED_SKILLS.length} skills installed`);
   }
-  if (config2.installCustomSkills) {
+  if (!modelsOnly && resolvedConfig.installCustomSkills) {
     printStep(step++, totalSteps, "Installing custom skills...");
-    let customSkillsInstalled = 0;
-    for (const skill of CUSTOM_SKILLS) {
-      printInfo(`Installing ${skill.name}...`);
-      if (installCustomSkill(skill)) {
-        printSuccess(`Installed: ${skill.name}`);
-        customSkillsInstalled++;
-      } else {
-        printWarning(`Failed to install: ${skill.name}`);
+    if (resolvedConfig.dryRun) {
+      printInfo("Dry run mode - would install custom skills:");
+      for (const skill of CUSTOM_SKILLS) {
+        printInfo(`  - ${skill.name}`);
+      }
+    } else {
+      let customSkillsInstalled = 0;
+      for (const skill of CUSTOM_SKILLS) {
+        printInfo(`Installing ${skill.name}...`);
+        if (installCustomSkill(skill)) {
+          printSuccess(`Installed: ${skill.name}`);
+          customSkillsInstalled++;
+        } else {
+          printWarning(`Failed to install: ${skill.name}`);
+        }
       }
+      printSuccess(`${customSkillsInstalled}/${CUSTOM_SKILLS.length} custom skills installed`);
     }
-    printSuccess(`${customSkillsInstalled}/${CUSTOM_SKILLS.length} custom skills installed`);
   }
   console.log();
-  console.log(formatConfigSummary(config2));
+  console.log(formatConfigSummary(resolvedConfig));
   console.log();
-  printAgentModels(config2);
-  if (!config2.hasKimi && !config2.hasOpenAI) {
+  printAgentModels(resolvedConfig);
+  if (!resolvedConfig.hasKimi && !resolvedConfig.hasOpenAI && !resolvedConfig.hasAnthropic && !resolvedConfig.hasCopilot && !resolvedConfig.hasZaiPlan && !resolvedConfig.hasAntigravity && !resolvedConfig.hasChutes) {
     printWarning("No providers configured. Zen Big Pickle models will be used as fallback.");
   }
   console.log(`${SYMBOLS.star} ${BOLD}${GREEN}${isUpdate ? "Configuration updated!" : "Installation complete!"}${RESET}`);
@@ -14237,13 +16877,33 @@ async function runInstall(config2) {
   console.log(`${BOLD}Next steps:${RESET}`);
   console.log();
   let nextStep = 1;
-  if (config2.hasKimi || config2.hasOpenAI) {
+  if (resolvedConfig.hasKimi || resolvedConfig.hasOpenAI || resolvedConfig.hasAnthropic || resolvedConfig.hasCopilot || resolvedConfig.hasZaiPlan || resolvedConfig.hasAntigravity || resolvedConfig.hasChutes) {
     console.log(`  ${nextStep++}. Authenticate with your providers:`);
     console.log(`     ${BLUE}$ opencode auth login${RESET}`);
-    if (config2.hasKimi) {
+    if (resolvedConfig.hasKimi) {
       console.log();
       console.log(`     Then select ${BOLD}Kimi For Coding${RESET} provider.`);
     }
+    if (resolvedConfig.hasAntigravity) {
+      console.log();
+      console.log(`     Then select ${BOLD}google${RESET} provider.`);
+    }
+    if (resolvedConfig.hasAnthropic) {
+      console.log();
+      console.log(`     Then select ${BOLD}anthropic${RESET} provider.`);
+    }
+    if (resolvedConfig.hasCopilot) {
+      console.log();
+      console.log(`     Then select ${BOLD}github-copilot${RESET} provider.`);
+    }
+    if (resolvedConfig.hasZaiPlan) {
+      console.log();
+      console.log(`     Then select ${BOLD}zai-coding-plan${RESET} provider.`);
+    }
+    if (resolvedConfig.hasChutes) {
+      console.log();
+      console.log(`     Then select ${BOLD}chutes${RESET} provider.`);
+    }
     console.log();
   }
   console.log(`  ${nextStep++}. Start OpenCode:`);
@@ -14253,7 +16913,16 @@ async function runInstall(config2) {
 }
 async function install(args) {
   if (!args.tui) {
-    const requiredArgs = ["kimi", "openai", "tmux"];
+    const requiredArgs = [
+      "kimi",
+      "openai",
+      "anthropic",
+      "copilot",
+      "zaiPlan",
+      "antigravity",
+      "chutes",
+      "tmux"
+    ];
     const errors3 = requiredArgs.filter((key) => {
       const value = args[key];
       return value === undefined || !["yes", "no"].includes(value);
@@ -14262,23 +16931,31 @@ async function install(args) {
       printHeader(false);
       printError("Missing or invalid arguments:");
       for (const key of errors3) {
-        console.log(`  ${SYMBOLS.bullet} --${key}=<yes|no>`);
+        const flagName = key === "zaiPlan" ? "zai-plan" : key;
+        console.log(`  ${SYMBOLS.bullet} --${flagName}=<yes|no>`);
       }
       console.log();
-      printInfo("Usage: bunx oh-my-opencode-slim install --no-tui --kimi=<yes|no> --openai=<yes|no> --tmux=<yes|no>");
+      printInfo("Usage: bunx oh-my-opencode-slim install --no-tui --kimi=<yes|no> --openai=<yes|no> --anthropic=<yes|no> --copilot=<yes|no> --zai-plan=<yes|no> --antigravity=<yes|no> --chutes=<yes|no> --balanced-spend=<yes|no> --tmux=<yes|no>");
       console.log();
       return 1;
     }
-    return runInstall(argsToConfig(args));
+    const nonInteractiveConfig = argsToConfig(args);
+    return runInstall(nonInteractiveConfig);
   }
   const detected = detectCurrentConfig();
   printHeader(detected.isInstalled);
   printStep(1, 1, "Checking OpenCode installation...");
-  const { ok } = await checkOpenCodeInstalled();
-  if (!ok)
-    return 1;
+  if (args.dryRun) {
+    printInfo("Dry run mode - skipping OpenCode check");
+  } else {
+    const { ok } = await checkOpenCodeInstalled();
+    if (!ok)
+      return 1;
+  }
   console.log();
-  const config2 = await runInteractiveMode(detected);
+  const config2 = await runInteractiveMode(detected, args.modelsOnly === true);
+  config2.dryRun = args.dryRun;
+  config2.modelsOnly = args.modelsOnly;
   return runInstall(config2);
 }
 
@@ -14294,8 +16971,34 @@ function parseArgs(args) {
       result.kimi = arg.split("=")[1];
     } else if (arg.startsWith("--openai=")) {
       result.openai = arg.split("=")[1];
+    } else if (arg.startsWith("--anthropic=")) {
+      result.anthropic = arg.split("=")[1];
+    } else if (arg.startsWith("--copilot=")) {
+      result.copilot = arg.split("=")[1];
+    } else if (arg.startsWith("--zai-plan=")) {
+      result.zaiPlan = arg.split("=")[1];
+    } else if (arg.startsWith("--antigravity=")) {
+      result.antigravity = arg.split("=")[1];
+    } else if (arg.startsWith("--chutes=")) {
+      result.chutes = arg.split("=")[1];
     } else if (arg.startsWith("--tmux=")) {
       result.tmux = arg.split("=")[1];
+    } else if (arg.startsWith("--skills=")) {
+      result.skills = arg.split("=")[1];
+    } else if (arg.startsWith("--opencode-free=")) {
+      result.opencodeFree = arg.split("=")[1];
+    } else if (arg.startsWith("--balanced-spend=")) {
+      result.balancedSpend = arg.split("=")[1];
+    } else if (arg.startsWith("--opencode-free-model=")) {
+      result.opencodeFreeModel = arg.split("=")[1];
+    } else if (arg.startsWith("--aa-key=")) {
+      result.aaKey = arg.slice("--aa-key=".length);
+    } else if (arg.startsWith("--openrouter-key=")) {
+      result.openrouterKey = arg.slice("--openrouter-key=".length);
+    } else if (arg === "--dry-run") {
+      result.dryRun = true;
+    } else if (arg === "--models-only") {
+      result.modelsOnly = true;
     } else if (arg === "-h" || arg === "--help") {
       printHelp();
       process.exit(0);
@@ -14308,23 +17011,42 @@ function printHelp() {
 oh-my-opencode-slim installer
 
 Usage: bunx oh-my-opencode-slim install [OPTIONS]
+       bunx oh-my-opencode-slim models [OPTIONS]
 
 Options:
   --kimi=yes|no          Kimi API access (yes/no)
   --openai=yes|no        OpenAI API access (yes/no)
+  --anthropic=yes|no     Anthropic access (yes/no)
+  --copilot=yes|no       GitHub Copilot access (yes/no)
+  --zai-plan=yes|no      ZAI Coding Plan access (yes/no)
+  --antigravity=yes|no   Antigravity/Google models (yes/no)
+  --chutes=yes|no        Chutes models (yes/no)
+  --opencode-free=yes|no Use OpenCode free models (opencode/*)
+  --balanced-spend=yes|no Evenly spread usage across selected providers when score gaps are within tolerance
+  --opencode-free-model  Preferred OpenCode model id or "auto"
+  --aa-key               Artificial Analysis API key (optional)
+  --openrouter-key       OpenRouter API key (optional)
   --tmux=yes|no          Enable tmux integration (yes/no)
+  --skills=yes|no        Install recommended skills (yes/no)
   --no-tui               Non-interactive mode (requires all flags)
+  --dry-run              Simulate install without writing files or requiring OpenCode
+  --models-only          Update model assignments only (skip plugin/auth/skills)
   -h, --help             Show this help message
 
 Examples:
   bunx oh-my-opencode-slim install
-  bunx oh-my-opencode-slim install --no-tui --kimi=yes --openai=yes --tmux=no
+  bunx oh-my-opencode-slim models
+  bunx oh-my-opencode-slim install --no-tui --kimi=yes --openai=yes --anthropic=yes --copilot=no --zai-plan=no --antigravity=yes --chutes=no --opencode-free=yes --balanced-spend=yes --opencode-free-model=auto --aa-key=YOUR_AA_KEY --openrouter-key=YOUR_OR_KEY --tmux=no --skills=yes
 `);
 }
 async function main() {
   const args = process.argv.slice(2);
-  if (args.length === 0 || args[0] === "install") {
-    const installArgs = parseArgs(args.slice(args[0] === "install" ? 1 : 0));
+  if (args.length === 0 || args[0] === "install" || args[0] === "models") {
+    const hasSubcommand = args[0] === "install" || args[0] === "models";
+    const installArgs = parseArgs(args.slice(hasSubcommand ? 1 : 0));
+    if (args[0] === "models") {
+      installArgs.modelsOnly = true;
+    }
     const exitCode = await install(installArgs);
     process.exit(exitCode);
   } else if (args[0] === "-h" || args[0] === "--help") {