oh-my-opencode-slim 0.7.0 → 0.8.0

package/dist/cli/index.js

@@ -13666,6 +13666,34 @@ 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(),
@@ -13674,7 +13702,7 @@ var FallbackChainsSchema = exports_external.object({
   explorer: AgentModelChainSchema.optional(),
   librarian: AgentModelChainSchema.optional(),
   fixer: AgentModelChainSchema.optional()
-}).strict();
+}).catchall(AgentModelChainSchema);
 var AgentOverrideConfigSchema = exports_external.object({
   model: exports_external.string().optional(),
   temperature: exports_external.number().min(0).max(2).optional(),
@@ -13706,6 +13734,9 @@ var FailoverConfigSchema = exports_external.object({
 });
 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(),
@@ -13942,8 +13973,45 @@ function generateAntigravityMixedPreset(config2, existingPreset) {
 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.hasAntigravity && installConfig.hasKimi && installConfig.hasOpenAI) {
     activePreset = "antigravity-mixed-both";
@@ -14023,7 +14091,7 @@ function generateLiteConfig(installConfig) {
   const applyChutesAssignments = (presetAgents) => {
     if (!installConfig.hasChutes)
       return;
-    const hasExternalProviders = installConfig.hasKimi || installConfig.hasOpenAI || installConfig.hasAntigravity;
+    const hasExternalProviders = installConfig.hasKimi || installConfig.hasOpenAI || installConfig.hasAnthropic || installConfig.hasCopilot || installConfig.hasZaiPlan || installConfig.hasAntigravity;
     if (hasExternalProviders && activePreset !== "chutes")
       return;
     const primaryModel = installConfig.selectedChutesPrimaryModel;
@@ -14379,7 +14447,7 @@ function addGoogleProvider() {
 function addChutesProvider() {
   const configPath = getExistingConfigPath();
   try {
-    const { config: parsedConfig, error: error48 } = parseConfig(configPath);
+    const { error: error48 } = parseConfig(configPath);
     if (error48) {
       return {
         success: false,
@@ -14387,24 +14455,12 @@ function addChutesProvider() {
         error: `Failed to parse config: ${error48}`
       };
     }
-    const config2 = parsedConfig ?? {};
-    const providers = config2.provider ?? {};
-    providers.chutes = {
-      npm: "@ai-sdk/openai-compatible",
-      name: "Chutes",
-      options: {
-        baseURL: "https://llm.chutes.ai/v1",
-        apiKey: "{env:CHUTES_API_KEY}"
-      }
-    };
-    config2.provider = providers;
-    writeConfig(configPath, config2);
     return { success: true, configPath };
   } catch (err) {
     return {
       success: false,
       configPath,
-      error: `Failed to add chutes provider: ${err}`
+      error: `Failed to validate chutes provider config: ${err}`
     };
   }
 }
@@ -14462,6 +14518,317 @@ function detectCurrentConfig() {
   }
   return result;
 }
+// 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;
+}
+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/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);
+  }
+  return result;
+}
+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 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
+    }
+  };
+}
+
+// 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",
@@ -14471,6 +14838,15 @@ var AGENTS = [
   "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",
@@ -14511,17 +14887,156 @@ function statusScore(status) {
     return -5;
   return -40;
 }
-function baseScore(model) {
+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, 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);
-  const versionBoost = tokenScore(lowered, /gpt-5\.3/i, 12) + tokenScore(lowered, /gpt-5\.2/i, 8) + tokenScore(lowered, /k2\.5/i, 6);
-  return statusScore(model.status) + context + output + deep + fast + code + versionBoost + (model.toolcall ? 25 : 0);
+  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 roleScore(agent, model) {
+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;
@@ -14537,28 +15052,295 @@ function roleScore(agent, model) {
   if (model.status === "deprecated") {
     return -5000;
   }
-  const score = baseScore(model);
+  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") {
-    return score + reasoning * 40 + toolcall * 25 + deep * 10 + code * 8 + context;
+    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") {
-    return score + reasoning * 55 + deep * 18 + context * 1.2 + toolcall * 10;
+    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") {
-    return score + attachment * 25 + reasoning * 18 + toolcall * 15 + context * 0.8 + output;
+    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") {
-    return score + fast * 35 + toolcall * 28 + reasoning * 8 + context * 0.7;
+    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") {
-    return score + context * 30 + toolcall * 22 + reasoning * 15 + output * 10;
+    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 score + code * 28 + toolcall * 24 + fast * 18 + reasoning * 14 + output * 8;
+  return counts;
 }
-function rankModels2(models, agent) {
-  return [...models].sort((a, b) => roleScore(agent, b) - roleScore(agent, a));
+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 dedupe(models) {
+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) {
@@ -14569,41 +15351,494 @@ function dedupe(models) {
   }
   return result;
 }
-function buildDynamicModelPlan(catalog, config2) {
+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 providerCandidates = catalog.filter((m) => enabledProviders.has(m.providerID));
+  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 = {};
-  for (const agent of AGENTS) {
-    const ranked = rankModels2(providerCandidates, agent);
-    const primary = ranked[0];
+  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;
-    const providerOrder = dedupe(ranked.map((m) => m.providerID));
-    const perProviderBest = providerOrder.map((providerID) => ranked.find((m) => m.providerID === providerID)?.model).filter((m) => Boolean(m));
-    const selectedOpencode = agent === "explorer" || agent === "librarian" || agent === "fixer" ? config2.selectedOpenCodeSecondaryModel ?? config2.selectedOpenCodePrimaryModel : config2.selectedOpenCodePrimaryModel;
-    const selectedChutes = agent === "explorer" || agent === "librarian" || agent === "fixer" ? config2.selectedChutesSecondaryModel ?? config2.selectedChutesPrimaryModel : config2.selectedChutesPrimaryModel;
-    const chain = dedupe([
+    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,
-      ...perProviderBest,
+      ...nonFreePerProviderBest,
       selectedChutes,
       selectedOpencode,
-      "opencode/big-pickle"
-    ]).slice(0, 7);
+      ...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: chain[0] ?? primary.model,
+      model: finalModel,
       variant: ROLE_VARIANT[agent]
     };
-    chains[agent] = chain;
+    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 };
+  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;
@@ -14646,12 +15881,12 @@ function normalizeDiscoveredModel(record2, providerFilter) {
 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;
-    const isModelHeader = /^[a-z0-9-]+\/[a-z0-9._-]+$/i.test(line);
-    if (!isModelHeader)
+    if (!modelHeaderPattern.test(line))
       continue;
     let jsonStart = -1;
     for (let search = index + 1;search < lines.length; search++) {
@@ -14659,7 +15894,7 @@ function parseOpenCodeModelsVerboseOutput(output, providerFilter, freeOnly = tru
         jsonStart = search;
         break;
       }
-      if (/^[a-z0-9-]+\/[a-z0-9._-]+$/i.test(lines[search]?.trim() ?? "")) {
+      if (modelHeaderPattern.test(lines[search]?.trim() ?? "")) {
         break;
       }
     }
@@ -14699,9 +15934,10 @@ function parseOpenCodeModelsVerboseOutput(output, providerFilter, freeOnly = tru
   }
   return models;
 }
-async function discoverFreeModelsByProvider(providerID) {
+async function discoverModelsByProvider(providerID, freeOnly = true) {
   try {
-    const proc = Bun.spawn(["opencode", "models", "--refresh", "--verbose"], {
+    const opencodePath = resolveOpenCodePath();
+    const proc = Bun.spawn([opencodePath, "models", "--refresh", "--verbose"], {
       stdout: "pipe",
       stderr: "pipe"
     });
@@ -14715,7 +15951,7 @@ async function discoverFreeModelsByProvider(providerID) {
       };
     }
     return {
-      models: parseOpenCodeModelsVerboseOutput(stdout, providerID, true)
+      models: parseOpenCodeModelsVerboseOutput(stdout, providerID, freeOnly)
     };
   } catch {
     return {
@@ -14726,7 +15962,8 @@ async function discoverFreeModelsByProvider(providerID) {
 }
 async function discoverModelCatalog() {
   try {
-    const proc = Bun.spawn(["opencode", "models", "--refresh", "--verbose"], {
+    const opencodePath = resolveOpenCodePath();
+    const proc = Bun.spawn([opencodePath, "models", "--refresh", "--verbose"], {
       stdout: "pipe",
       stderr: "pipe"
     });
@@ -14750,10 +15987,11 @@ async function discoverModelCatalog() {
   }
 }
 async function discoverOpenCodeFreeModels() {
-  return discoverFreeModelsByProvider("opencode");
+  const result = await discoverModelsByProvider("opencode", true);
+  return { models: result.models, error: result.error };
 }
-async function discoverProviderFreeModels(providerID) {
-  return discoverFreeModelsByProvider(providerID);
+async function discoverProviderModels(providerID) {
+  return discoverModelsByProvider(providerID, false);
 }
 // src/cli/opencode-selection.ts
 var scoreOpenCodePrimaryForCoding = (model) => {
@@ -14785,42 +16023,16 @@ function pickSupportOpenCodeModel(models, primaryModel) {
   }, primaryModel);
   return support;
 }
-// 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;
-  }
-}
-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;
-  }
-}
 // src/cli/custom-skills.ts
 import {
   copyFileSync as copyFileSync2,
   existsSync as existsSync3,
   mkdirSync as mkdirSync2,
   readdirSync,
-  statSync as statSync2
+  statSync as statSync3
 } from "fs";
 import { homedir as homedir2 } from "os";
-import { dirname, join as join2 } from "path";
+import { dirname, join as join3 } from "path";
 import { fileURLToPath } from "url";
 var CUSTOM_SKILLS = [
   {
@@ -14831,7 +16043,7 @@ var CUSTOM_SKILLS = [
   }
 ];
 function getCustomSkillsDir() {
-  return join2(homedir2(), ".config", "opencode", "skills");
+  return join3(homedir2(), ".config", "opencode", "skills");
 }
 function copyDirRecursive(src, dest) {
   if (!existsSync3(dest)) {
@@ -14839,9 +16051,9 @@ function copyDirRecursive(src, dest) {
   }
   const entries = readdirSync(src);
   for (const entry of entries) {
-    const srcPath = join2(src, entry);
-    const destPath = join2(dest, entry);
-    const stat = statSync2(srcPath);
+    const srcPath = join3(src, entry);
+    const destPath = join3(dest, entry);
+    const stat = statSync3(srcPath);
     if (stat.isDirectory()) {
       copyDirRecursive(srcPath, destPath);
     } else {
@@ -14856,8 +16068,8 @@ function copyDirRecursive(src, dest) {
 function installCustomSkill(skill) {
   try {
     const packageRoot = fileURLToPath(new URL("../..", import.meta.url));
-    const sourcePath = join2(packageRoot, skill.sourcePath);
-    const targetPath = join2(getCustomSkillsDir(), skill.name);
+    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;
@@ -14914,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) {
@@ -14943,6 +16160,7 @@ function formatConfigSummary(config2) {
   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}`);
   }
@@ -14988,9 +16206,15 @@ function argsToConfig(args) {
     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) {
@@ -15022,20 +16246,310 @@ async function askYesNo(rl, prompt, defaultValue = "no") {
     return "no";
   return defaultValue;
 }
-async function runInteractiveMode(detected) {
+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();
+    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();
+    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" && 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
   });
-  const totalQuestions = 8;
   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 useOpenCodeFree = await askYesNo(rl, "Use only OpenCode free models (opencode/*) with live refresh?", "yes");
+    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 availableChutesFreeModels;
+    let availableChutesModels;
     let selectedChutesPrimaryModel;
     let selectedChutesSecondaryModel;
     if (useOpenCodeFree === "yes") {
@@ -15047,70 +16561,85 @@ async function runInteractiveMode(detected) {
         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;
-          selectedOpenCodeSecondaryModel = await askModelSelection(rl, discovery.models, recommendedSecondary, "Choose support model for explorer/librarian/fixer");
+          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 2/${totalQuestions}:${RESET}`);
-    const kimi = await askYesNo(rl, "Do you want to use Kimi For Coding?", detected.hasKimi ? "yes" : "no");
-    console.log();
-    console.log(`${BOLD}Question 3/${totalQuestions}:${RESET}`);
-    const openai = await askYesNo(rl, "Do you have access to OpenAI API?", detected.hasOpenAI ? "yes" : "no");
-    console.log();
     console.log(`${BOLD}Question 4/${totalQuestions}:${RESET}`);
-    const anthropic = await askYesNo(rl, "Do you have access to Anthropic models?", detected.hasAnthropic ? "yes" : "no");
+    const kimi = await askYesNo(rl, "Enable Kimi provider?", detected.hasKimi ? "yes" : "no");
     console.log();
     console.log(`${BOLD}Question 5/${totalQuestions}:${RESET}`);
-    const copilot = await askYesNo(rl, "Do you have access to GitHub Copilot models?", detected.hasCopilot ? "yes" : "no");
+    const openai = await askYesNo(rl, "Enable OpenAI provider?", detected.hasOpenAI ? "yes" : "no");
     console.log();
     console.log(`${BOLD}Question 6/${totalQuestions}:${RESET}`);
-    const zaiPlan = await askYesNo(rl, "Do you have access to ZAI Coding Plan models?", detected.hasZaiPlan ? "yes" : "no");
+    const anthropic = await askYesNo(rl, "Enable Anthropic provider?", detected.hasAnthropic ? "yes" : "no");
     console.log();
     console.log(`${BOLD}Question 7/${totalQuestions}:${RESET}`);
-    const antigravity = await askYesNo(rl, "Enable Antigravity authentication for Google models?", detected.hasAntigravity ? "yes" : "no");
+    const copilot = await askYesNo(rl, "Enable GitHub Copilot provider?", detected.hasCopilot ? "yes" : "no");
     console.log();
     console.log(`${BOLD}Question 8/${totalQuestions}:${RESET}`);
-    const chutes = await askYesNo(rl, "Enable Chutes provider with free daily capped models?", detected.hasChutes ? "yes" : "no");
+    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 discoverProviderFreeModels("chutes");
+      const discovery = await discoverProviderModels("chutes");
       if (discovery.models.length === 0) {
-        printWarning(discovery.error ?? "No free Chutes models found. Continuing without Chutes dynamic assignment.");
+        printWarning(discovery.error ?? "No Chutes models found. Continuing without Chutes dynamic assignment.");
       } else {
-        availableChutesFreeModels = discovery.models;
+        availableChutesModels = discovery.models;
         const recommendedPrimary = pickBestCodingChutesModel(discovery.models)?.model ?? discovery.models[0]?.model;
         if (recommendedPrimary) {
-          console.log(`${BOLD}Chutes Free Models:${RESET}`);
+          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;
-          selectedChutesSecondaryModel = await askModelSelection(rl, discovery.models, recommendedSecondary, "Choose Chutes support model for explorer/librarian/fixer");
+          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}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");
+    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();
-    console.log(`${BOLD}Custom Skills:${RESET}`);
-    for (const skill of CUSTOM_SKILLS) {
-      console.log(`  ${SYMBOLS.bullet} ${BOLD}${skill.name}${RESET}: ${skill.description}`);
+    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();
     }
-    console.log();
-    const customSkills = await askYesNo(rl, "Install custom skills?", "yes");
-    console.log();
     return {
       hasKimi: kimi === "yes",
       hasOpenAI: openai === "yes",
@@ -15126,10 +16655,15 @@ async function runInteractiveMode(detected) {
       availableOpenCodeFreeModels,
       selectedChutesPrimaryModel,
       selectedChutesSecondaryModel,
-      availableChutesFreeModels,
+      availableChutesModels,
+      artificialAnalysisApiKey,
+      openRouterApiKey,
+      balanceProviderUsage: balancedSpend === "yes",
       hasTmux: false,
       installSkills: skills === "yes",
-      installCustomSkills: customSkills === "yes"
+      installCustomSkills: customSkills === "yes",
+      setupMode: "quick",
+      modelsOnly
     };
   } finally {
     rl.close();
@@ -15143,24 +16677,32 @@ async function runInstall(config2) {
   const isUpdate = detected.isInstalled;
   printHeader(isUpdate);
   const hasAnyEnabledProvider = resolvedConfig.hasKimi || resolvedConfig.hasOpenAI || resolvedConfig.hasAnthropic || resolvedConfig.hasCopilot || resolvedConfig.hasZaiPlan || resolvedConfig.hasAntigravity || resolvedConfig.hasChutes || resolvedConfig.useOpenCodeFreeModels;
-  let totalSteps = 4;
+  const modelsOnly = resolvedConfig.modelsOnly === true;
+  let totalSteps = modelsOnly ? 2 : 4;
   if (resolvedConfig.useOpenCodeFreeModels)
     totalSteps += 1;
-  if (resolvedConfig.hasAntigravity)
+  if (!modelsOnly && resolvedConfig.hasAntigravity)
     totalSteps += 2;
-  if (resolvedConfig.hasChutes)
+  if (!modelsOnly && resolvedConfig.hasChutes)
     totalSteps += 1;
   if (hasAnyEnabledProvider)
     totalSteps += 1;
-  if (resolvedConfig.installSkills)
+  if (!modelsOnly && resolvedConfig.installSkills)
     totalSteps += 1;
-  if (resolvedConfig.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;
+  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();
@@ -15181,43 +16723,61 @@ async function runInstall(config2) {
     printStep(step++, totalSteps, "Using previously refreshed OpenCode free model list...");
     printSuccess(`OpenCode free models ready (${availableModels.length} models found)`);
   }
-  if (resolvedConfig.hasChutes && (resolvedConfig.availableChutesFreeModels?.length ?? 0) === 0) {
-    printStep(step++, totalSteps, "Refreshing Chutes free models (chutes/*)...");
-    const discovery = await discoverProviderFreeModels("chutes");
+  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 free Chutes models found. Continuing with fallback Chutes mapping.");
+      printWarning(discovery.error ?? "No Chutes models found. Continuing with fallback Chutes mapping.");
     } else {
-      resolvedConfig.availableChutesFreeModels = discovery.models;
+      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.availableChutesFreeModels?.length ?? 0) > 0) {
-    const availableChutes = resolvedConfig.availableChutesFreeModels ?? [];
+  } 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 free model list...");
+    printStep(step++, totalSteps, "Using previously refreshed Chutes model list...");
     printSuccess(`Chutes models ready (${availableChutes.length} models found)`);
   }
-  printStep(step++, totalSteps, "Adding oh-my-opencode-slim plugin...");
-  const pluginResult = await addPluginToOpenCodeConfig();
-  if (!handleStepResult(pluginResult, "Plugin added"))
-    return 1;
-  if (resolvedConfig.hasAntigravity) {
+  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...");
-    const antigravityPluginResult = addAntigravityPlugin();
-    if (!handleStepResult(antigravityPluginResult, "Antigravity plugin added"))
-      return 1;
+    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...");
-    const googleProviderResult = addGoogleProvider();
-    if (!handleStepResult(googleProviderResult, "Google Provider configured"))
-      return 1;
+    if (resolvedConfig.dryRun) {
+      printInfo("Dry run mode - skipping Google Provider setup");
+    } else {
+      const googleProviderResult = addGoogleProvider();
+      if (!handleStepResult(googleProviderResult, "Google Provider configured"))
+        return 1;
+    }
   }
-  if (resolvedConfig.hasChutes) {
-    printStep(step++, totalSteps, "Configuring Chutes Provider...");
-    const chutesProviderResult = addChutesProvider();
-    if (!handleStepResult(chutesProviderResult, "Chutes 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...");
@@ -15225,7 +16785,14 @@ async function runInstall(config2) {
     if (catalogDiscovery.models.length === 0) {
       printWarning(catalogDiscovery.error ?? "Unable to discover model catalog. Falling back to static mappings.");
     } else {
-      const dynamicPlan = buildDynamicModelPlan(catalogDiscovery.models, resolvedConfig);
+      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 {
@@ -15234,41 +16801,69 @@ async function runInstall(config2) {
       }
     }
   }
-  printStep(step++, totalSteps, "Disabling OpenCode default agents...");
-  const agentResult = disableDefaultAgents();
-  if (!handleStepResult(agentResult, "Default agents disabled"))
-    return 1;
+  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(resolvedConfig);
-  if (!handleStepResult(liteResult, "Config written"))
-    return 1;
-  if (resolvedConfig.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 (resolvedConfig.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(resolvedConfig));
@@ -15307,7 +16902,7 @@ async function runInstall(config2) {
     }
     if (resolvedConfig.hasChutes) {
       console.log();
-      console.log(`     Then set ${BOLD}CHUTES_API_KEY${RESET} in your shell.`);
+      console.log(`     Then select ${BOLD}chutes${RESET} provider.`);
     }
     console.log();
   }
@@ -15340,20 +16935,27 @@ async function install(args) {
         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> --anthropic=<yes|no> --copilot=<yes|no> --zai-plan=<yes|no> --antigravity=<yes|no> --chutes=<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);
 }
 
@@ -15385,8 +16987,18 @@ function parseArgs(args) {
       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);
@@ -15399,6 +17011,7 @@ 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)
@@ -15409,21 +17022,31 @@ Options:
   --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 --anthropic=yes --copilot=no --zai-plan=no --antigravity=yes --chutes=no --opencode-free=yes --opencode-free-model=auto --tmux=no --skills=yes
+  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") {