nexus-agents 2.72.1 → 2.74.0

package/dist/{chunk-O4KUCF5S.js → chunk-Q3RFPJYK.js}

@@ -1,6 +1,9 @@
 import {
   isPersistenceEnabled
 } from "./chunk-I7ORMAO7.js";
+import {
+  nexusDataPath
+} from "./chunk-GOT7OAL5.js";
 import {
   __require
 } from "./chunk-UP2VWCW5.js";
@@ -631,6 +634,15 @@ var ErrorCode = {
   // Model errors
   MODEL_ERROR: "MODEL_ERROR",
   MODEL_UNAVAILABLE: "MODEL_UNAVAILABLE",
+  /**
+   * Model is reachable but the requested id no longer exists — typically a
+   * 404 from /v1/chat/completions, an Anthropic `model_not_found` error,
+   * or a vendor "this model has been deprecated" message. Distinct from
+   * MODEL_UNAVAILABLE (transient 502/503 service overload) — this one
+   * means the model is gone, retry won't help, route to a different id.
+   * See `withModelNotFoundFallback` for the retire-and-retry primitive.
+   */
+  MODEL_NOT_FOUND: "MODEL_NOT_FOUND",
   MODEL_RATE_LIMITED: "MODEL_RATE_LIMITED",
   MODEL_TIMEOUT: "MODEL_TIMEOUT",
   // Agent errors
@@ -776,134 +788,7 @@ function extractObjectMessage(error, fallback) {
   }
 }
 
-// src/config/model-capabilities-types.ts
-import { z as z2 } from "zod";
-var OUTPUT_MODALITIES = [
-  "text",
-  "image_png",
-  "image_jpeg",
-  "audio_pcm",
-  "audio_wav",
-  "audio_mp3",
-  "video_mp4",
-  "svg",
-  "structured_json",
-  "code"
-];
-var INPUT_MODALITIES = ["text", "image", "audio", "video", "pdf", "code"];
-var TOOL_CAPABILITIES = [
-  "mcp",
-  "function_calling",
-  "computer_use",
-  "code_execution_sandbox",
-  "web_search",
-  "file_operations",
-  "structured_output",
-  "apply_patch"
-];
-var SPECIAL_FEATURES = [
-  "extended_thinking",
-  "deep_research",
-  "streaming",
-  "grounding",
-  "citations",
-  "image_editing",
-  "voice_cloning",
-  "live_api",
-  "context_caching"
-];
-var PROVIDERS = ["anthropic", "google", "openai", "custom-openai", "openrouter"];
-var CLI_NAMES = ["claude", "gemini", "codex", "opencode"];
-var CliNameSchema = z2.enum(CLI_NAMES);
-var DEFAULT_CLI = "claude";
-var MODEL_IDS = [
-  "claude-opus",
-  "claude-sonnet",
-  "claude-haiku",
-  "gemini-3-pro",
-  "gemini-pro",
-  "gemini-3-flash",
-  "gemini-flash",
-  "codex-5.3",
-  "codex-5.2",
-  "codex-5.1-mini",
-  "opencode-default",
-  "opencode-custom-opus",
-  "opencode-custom-sonnet",
-  "openrouter-nemotron-super",
-  "openrouter-qwen-coder"
-];
-var QualityScoresSchema = z2.object({
-  reasoning: z2.number().min(0).max(10),
-  codeGeneration: z2.number().min(0).max(10),
-  speed: z2.number().min(0).max(10),
-  cost: z2.number().min(0).max(10)
-});
-var PricingSchema = z2.object({
-  inputPer1M: z2.number().nonnegative(),
-  outputPer1M: z2.number().nonnegative()
-});
-var ModelCapabilitySchema = z2.object({
-  /** Unique model identifier matching delegate_to_model model IDs */
-  id: z2.enum(MODEL_IDS),
-  /** Human-readable display name */
-  displayName: z2.string().min(1),
-  /** Provider/vendor */
-  provider: z2.enum(PROVIDERS),
-  /** Maximum context window in tokens */
-  contextWindow: z2.number().int().positive(),
-  /** Output modalities this model can produce */
-  outputModalities: z2.array(z2.enum(OUTPUT_MODALITIES)).min(1),
-  /** Input modalities this model can accept */
-  inputModalities: z2.array(z2.enum(INPUT_MODALITIES)).min(1),
-  /** Tool/integration capabilities */
-  toolCapabilities: z2.array(z2.enum(TOOL_CAPABILITIES)),
-  /** Special features beyond standard generation */
-  specialFeatures: z2.array(z2.enum(SPECIAL_FEATURES)),
-  /** Known constraints or limitations */
-  constraints: z2.array(z2.string()).optional(),
-  /** Notes about the model (e.g., beta features, pricing tier) */
-  notes: z2.string().optional(),
-  /** Pricing per 1M tokens (USD) */
-  pricing: PricingSchema.optional(),
-  /** Quality scores for routing (0-10 scale) */
-  qualityScores: QualityScoresSchema.optional(),
-  /** Maximum output tokens */
-  maxOutputTokens: z2.number().int().positive().optional(),
-  /** Which CLI tool this model belongs to */
-  cliName: z2.enum(CLI_NAMES).optional(),
-  /** Short alias used by the CLI (e.g., 'opus' for Claude CLI) */
-  cliAlias: z2.string().optional(),
-  /** Model name the CLI binary expects (e.g., 'gemini-2.5-pro') */
-  cliModelName: z2.string().optional(),
-  /**
-   * Legacy / version-suffixed names that resolve to this model. Used by
-   * adapters and routing to map historical user-facing names (e.g.,
-   * `claude-opus-4-5-20251101`, `gemini-2.5-pro`) to the current registry
-   * entry. Empty strings are rejected; uniqueness within the array is not
-   * enforced at schema level (caller responsibility).
-   *
-   * Added for issue #2199 Child 1; populated by the companion migration
-   * epic #2200.
-   */
-  aliases: z2.array(z2.string().min(1)).optional(),
-  /** Whether this model is deprecated and should receive a scoring penalty */
-  deprecated: z2.boolean().optional(),
-  /** ISO date when the model was deprecated (informational) */
-  deprecatedAt: z2.string().optional(),
-  /** Model ID to migrate to (informational guidance) */
-  replacedBy: z2.enum(MODEL_IDS).optional()
-});
-var ModelCapabilitiesMatrixSchema = z2.object({
-  /** Schema version for forward compatibility */
-  version: z2.number().int().positive(),
-  /** Last updated date (ISO 8601) */
-  updatedAt: z2.string(),
-  /** Model capability definitions */
-  models: z2.array(ModelCapabilitySchema).min(1)
-});
-
-// src/config/model-capabilities.ts
+// src/config/in-tree-data.ts
 var DEFAULT_MODEL_CAPABILITIES = {
   version: 3,
   updatedAt: "2026-03-14",
@@ -1225,38 +1110,994 @@ var DEFAULT_MODEL_CAPABILITIES = {
       cliName: "opencode",
       cliModelName: "qwen/qwen3-coder-480b-a35b:free"
     }
-  ]
-};
-var DEFAULT_MODEL_PER_CLI = {
-  claude: "claude-opus",
-  gemini: "gemini-3-pro",
-  codex: "codex-5.3",
-  opencode: "opencode-default"
+  ]
+};
+var DEFAULT_MODEL_PER_CLI = {
+  claude: "claude-opus",
+  gemini: "gemini-3-pro",
+  codex: "codex-5.3",
+  opencode: "opencode-default"
+};
+
+// src/config/model-derivation.ts
+var DEFAULT_ENTRY = {
+  parallelToolCalls: false,
+  promptCaching: "none",
+  toolDefinitionFormat: "openai",
+  maxRecommendedTurnBudget: 10,
+  strictJson: true,
+  quirks: []
+};
+var VENDOR_DEFAULTS = {
+  anthropic: {
+    profileId: "anthropic-default",
+    parallelToolCalls: true,
+    promptCaching: "ephemeral",
+    toolDefinitionFormat: "anthropic",
+    maxRecommendedTurnBudget: 15
+  },
+  openai: {
+    profileId: "openai-default",
+    parallelToolCalls: true,
+    toolDefinitionFormat: "openai",
+    maxRecommendedTurnBudget: 15
+  },
+  google: {
+    profileId: "google-default",
+    parallelToolCalls: true,
+    toolDefinitionFormat: "gemini",
+    maxRecommendedTurnBudget: 15
+  },
+  meta: {
+    profileId: "meta-default",
+    parallelToolCalls: false,
+    toolDefinitionFormat: "openai",
+    maxRecommendedTurnBudget: 8
+  },
+  qwen: {
+    profileId: "qwen-default",
+    parallelToolCalls: false,
+    toolDefinitionFormat: "openai",
+    maxRecommendedTurnBudget: 8
+  },
+  nvidia: {
+    profileId: "nvidia-nemotron-default",
+    parallelToolCalls: false,
+    toolDefinitionFormat: "openai",
+    maxRecommendedTurnBudget: 8
+  },
+  mistral: {
+    profileId: "mistral-default",
+    parallelToolCalls: false,
+    toolDefinitionFormat: "openai",
+    maxRecommendedTurnBudget: 8
+  },
+  cohere: {
+    profileId: "cohere-default",
+    parallelToolCalls: false,
+    toolDefinitionFormat: "openai",
+    maxRecommendedTurnBudget: 8
+  },
+  deepseek: {
+    profileId: "deepseek-default",
+    parallelToolCalls: false,
+    toolDefinitionFormat: "openai",
+    maxRecommendedTurnBudget: 10
+  }
+};
+var FAMILY_DEFAULTS = [
+  {
+    vendor: "anthropic",
+    family: "claude-opus",
+    override: { profileId: "claude-opus", maxRecommendedTurnBudget: 20 }
+  },
+  {
+    vendor: "anthropic",
+    family: "claude-haiku",
+    override: { profileId: "claude-haiku", maxRecommendedTurnBudget: 8 }
+  },
+  {
+    vendor: "openai",
+    family: "o-reasoning",
+    override: { profileId: "openai-o-reasoning", maxRecommendedTurnBudget: 25 }
+  },
+  {
+    vendor: "google",
+    family: "gemini-flash",
+    override: { profileId: "gemini-flash", maxRecommendedTurnBudget: 8 }
+  }
+];
+function deriveEntry(modelId, identity) {
+  const vendorOverride = VENDOR_DEFAULTS[identity.vendor] ?? {};
+  const familyOverride = FAMILY_DEFAULTS.find((f) => f.vendor === identity.vendor && f.family === identity.family)?.override ?? {};
+  const merged = {
+    ...DEFAULT_ENTRY,
+    profileId: "default",
+    ...vendorOverride,
+    ...familyOverride
+  };
+  const quirks = [.../* @__PURE__ */ new Set([...merged.quirks, ...identity.quirks])];
+  let budget = merged.maxRecommendedTurnBudget;
+  if (identity.quirks.includes("thinking")) {
+    budget = Math.ceil(budget * 1.5);
+  }
+  return {
+    id: modelId,
+    vendor: identity.vendor,
+    family: identity.family,
+    ...identity.version !== void 0 && { version: identity.version },
+    parallelToolCalls: merged.parallelToolCalls,
+    promptCaching: merged.promptCaching,
+    toolDefinitionFormat: merged.toolDefinitionFormat,
+    maxRecommendedTurnBudget: budget,
+    strictJson: merged.strictJson,
+    quirks,
+    profileId: merged.profileId,
+    source: "derived"
+  };
+}
+
+// src/config/model-identity.ts
+var VENDOR_PATTERNS = [
+  { vendor: "anthropic", regex: /\b(claude|anthropic)\b/ },
+  // OpenAI: gpt, o1-o9 reasoning, chatgpt, openai prefix
+  { vendor: "openai", regex: /\b(gpt|o[1-9]|chatgpt|openai)\b/ },
+  { vendor: "google", regex: /\b(gemini|bison|gecko|palm|google)\b/ },
+  { vendor: "meta", regex: /\b(llama|meta-llama|meta)\b/ },
+  { vendor: "qwen", regex: /\b(qwen)\b/ },
+  { vendor: "nvidia", regex: /\b(nemotron|nvidia)\b/ },
+  { vendor: "mistral", regex: /\b(mistral|mixtral|codestral)\b/ },
+  { vendor: "cohere", regex: /\b(command-r|command|cohere)\b/ },
+  { vendor: "deepseek", regex: /\b(deepseek)\b/ }
+];
+var FAMILY_PATTERNS = [
+  // Anthropic
+  { vendor: "anthropic", family: "claude-opus", regex: /\b(opus)\b/ },
+  { vendor: "anthropic", family: "claude-sonnet", regex: /\b(sonnet)\b/ },
+  { vendor: "anthropic", family: "claude-haiku", regex: /\b(haiku)\b/ },
+  // OpenAI
+  { vendor: "openai", family: "o-reasoning", regex: /\bo[1-9]\b/ },
+  { vendor: "openai", family: "gpt-4o", regex: /\b(gpt-4o|gpt4o|4o)\b/ },
+  { vendor: "openai", family: "gpt-4", regex: /\b(gpt-4)\b/ },
+  { vendor: "openai", family: "gpt-3.5", regex: /\b(gpt-3-5|gpt-3\.5|gpt35)\b/ },
+  // Google
+  { vendor: "google", family: "gemini-pro", regex: /\bgemini.*\bpro\b/ },
+  { vendor: "google", family: "gemini-flash", regex: /\bgemini.*\bflash\b/ },
+  { vendor: "google", family: "gemini", regex: /\bgemini\b/ },
+  // Meta
+  { vendor: "meta", family: "llama-3", regex: /\bllama-?3\b/ },
+  { vendor: "meta", family: "llama-2", regex: /\bllama-?2\b/ },
+  // Qwen — version is in the family name
+  { vendor: "qwen", family: "qwen-3", regex: /\bqwen-?3\b/ },
+  { vendor: "qwen", family: "qwen-2.5", regex: /\bqwen-?2-?5\b/ },
+  { vendor: "qwen", family: "qwen-2", regex: /\bqwen-?2\b/ },
+  // Mistral
+  { vendor: "mistral", family: "mixtral", regex: /\bmixtral\b/ },
+  { vendor: "mistral", family: "codestral", regex: /\bcodestral\b/ },
+  { vendor: "mistral", family: "mistral", regex: /\bmistral\b/ }
+];
+var QUIRK_PATTERNS = [
+  { regex: /\b(embedding|embed)\b/, quirk: "embedding" },
+  { regex: /\b(thinking|reasoning)\b/, quirk: "thinking" },
+  { regex: /\bvision\b/, quirk: "vision" },
+  { regex: /\b(coder|code)\b/, quirk: "coder" },
+  { regex: /\binstruct\b/, quirk: "instruct" },
+  { regex: /\b(mini|nano|tiny|small|lite)\b/, quirk: "small" },
+  { regex: /\b(large|xl|big|maxi)\b/, quirk: "large" },
+  { regex: /\bhigh\b/, quirk: "high-variant" },
+  { regex: /\b(\d+)b\b/, quirk: "sized-suffix" },
+  // 7b, 70b, 405b
+  { regex: /\b(?:\d{8}|\d{4}-\d{2}-\d{2}|\d{4}-\d{2})\b/, quirk: "dated" }
+  // 20240806 / 2024-08-06 / 2024-08
+];
+async function resolveModelIdentity(adapter, options = {}) {
+  const rawModelId = adapter.modelId;
+  const hints = options.hints ?? {};
+  let probe;
+  if (options.skipProbe !== true && typeof adapter.listModels === "function") {
+    probe = await runProbe(adapter, rawModelId);
+  }
+  const parsed = parseModelId(rawModelId);
+  return mergeIdentity({ rawModelId, hints, probe, parsed });
+}
+function resolveModelIdentitySync(modelId, hints) {
+  return mergeIdentity({
+    rawModelId: modelId,
+    hints: hints ?? {},
+    probe: void 0,
+    parsed: parseModelId(modelId)
+  });
+}
+function parseModelId(modelId) {
+  const normalised = normaliseModelId(modelId);
+  const vendor = detectVendor(normalised);
+  const family = vendor !== void 0 ? detectFamily(normalised, vendor) : void 0;
+  const version = vendor !== void 0 && family !== void 0 ? extractVersion(normalised, family) : void 0;
+  const quirks = detectQuirks(normalised);
+  return {
+    ...vendor !== void 0 && { vendor },
+    ...family !== void 0 && { family },
+    ...version !== void 0 && { version },
+    quirks
+  };
+}
+function normaliseModelId(modelId) {
+  return modelId.toLowerCase().replace(/[_/]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function detectVendor(normalised) {
+  for (const { vendor, regex } of VENDOR_PATTERNS) {
+    if (regex.test(normalised)) return vendor;
+  }
+  return void 0;
+}
+function detectFamily(normalised, vendor) {
+  for (const fp of FAMILY_PATTERNS) {
+    if (fp.vendor !== vendor) continue;
+    if (fp.regex.test(normalised)) return fp.family;
+  }
+  return void 0;
+}
+function extractVersion(normalised, family) {
+  const familyRoot = family.replace(/^claude-|^gemini-|^llama-|^qwen-|^gpt-/, "");
+  const idx = normalised.indexOf(familyRoot);
+  if (idx === -1) return void 0;
+  const tail = normalised.slice(idx + familyRoot.length);
+  const m = /^[-]?(\d[\d.\-]*)/.exec(tail);
+  if (m === null) return void 0;
+  return m[1]?.replace(/-+$/, "") ?? void 0;
+}
+function detectQuirks(normalised) {
+  const out = [];
+  for (const { regex, quirk } of QUIRK_PATTERNS) {
+    if (regex.test(normalised) && !out.includes(quirk)) out.push(quirk);
+  }
+  return out;
+}
+async function runProbe(adapter, modelId) {
+  try {
+    const capable = adapter;
+    const models = await capable.listModels();
+    const matched = models.find((m) => m.id === modelId);
+    if (matched === void 0) return void 0;
+    const result = { metadata: matched };
+    if (matched.ownedBy !== void 0) {
+      const vendor = vendorFromOwnedBy(matched.ownedBy);
+      if (vendor !== void 0) {
+        return { ...result, vendor };
+      }
+    }
+    return result;
+  } catch {
+    return void 0;
+  }
+}
+var OWNED_BY_PATTERNS = [
+  { substr: "anthropic", vendor: "anthropic" },
+  { substr: "openai", vendor: "openai" },
+  { substr: "google", vendor: "google" },
+  { substr: "meta", vendor: "meta" },
+  { substr: "alibaba", vendor: "qwen" },
+  { substr: "qwen", vendor: "qwen" },
+  { substr: "nvidia", vendor: "nvidia" },
+  { substr: "nemotron", vendor: "nvidia" },
+  { substr: "mistral", vendor: "mistral" },
+  { substr: "cohere", vendor: "cohere" },
+  { substr: "deepseek", vendor: "deepseek" }
+];
+function vendorFromOwnedBy(ownedBy) {
+  const lc = ownedBy.toLowerCase();
+  for (const { substr, vendor } of OWNED_BY_PATTERNS) {
+    if (lc.includes(substr)) return vendor;
+  }
+  return void 0;
+}
+function mergeIdentity(args) {
+  const { rawModelId, hints, probe, parsed } = args;
+  const version = pickVersion(hints, parsed);
+  return {
+    vendor: hints.vendor ?? probe?.vendor ?? parsed.vendor ?? "unknown",
+    family: hints.family ?? parsed.family ?? "unknown",
+    ...version !== void 0 && { version },
+    quirks: [.../* @__PURE__ */ new Set([...hints.quirks ?? [], ...parsed.quirks])],
+    source: pickSource(hints, probe, parsed),
+    rawModelId
+  };
+}
+function pickVersion(hints, parsed) {
+  return hints.version ?? parsed.version;
+}
+function pickSource(hints, probe, parsed) {
+  if (hints.vendor !== void 0) return "modelHints";
+  if (probe?.vendor !== void 0) return "probe";
+  if (parsed.vendor !== void 0) return "modelIdParse";
+  return "default";
+}
+
+// src/config/in-tree-entries.ts
+function providerToVendor(provider) {
+  switch (provider) {
+    case "anthropic":
+    case "google":
+    case "openai":
+      return provider;
+    default:
+      return "unknown";
+  }
+}
+function optionalFields(model) {
+  const out = {};
+  if (model.maxOutputTokens !== void 0) out.maxOutputTokens = model.maxOutputTokens;
+  if (model.pricing !== void 0) out.pricing = model.pricing;
+  if (model.qualityScores !== void 0) out.qualityScores = model.qualityScores;
+  if (model.notes !== void 0) out.notes = model.notes;
+  if (model.cliName !== void 0) out.cliName = model.cliName;
+  if (model.cliAlias !== void 0) out.cliAlias = model.cliAlias;
+  if (model.cliModelName !== void 0) out.cliModelName = model.cliModelName;
+  return out;
+}
+function toEntry(model) {
+  const vendorHint = providerToVendor(model.provider);
+  const identity = resolveModelIdentitySync(model.id, { vendor: vendorHint });
+  const derived = deriveEntry(model.id, identity);
+  const allAliases = new Set(model.aliases ?? []);
+  if (model.cliModelName !== void 0 && model.cliModelName !== model.id) {
+    allAliases.add(model.cliModelName);
+  }
+  return {
+    ...derived,
+    id: model.id,
+    ...allAliases.size > 0 && { aliases: [...allAliases] },
+    displayName: model.displayName,
+    contextWindow: model.contextWindow,
+    inputModalities: model.inputModalities,
+    outputModalities: model.outputModalities,
+    toolCapabilities: model.toolCapabilities,
+    specialFeatures: model.specialFeatures,
+    ...optionalFields(model),
+    source: "in-tree"
+  };
+}
+function buildInTreeEntries() {
+  return DEFAULT_MODEL_CAPABILITIES.models.map(toEntry);
+}
+
+// src/config/manifest-overlay.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import { parse as parseYaml } from "yaml";
+import { z as z3 } from "zod";
+
+// src/config/model-capabilities-types.ts
+import { z as z2 } from "zod";
+var OUTPUT_MODALITIES = [
+  "text",
+  "image_png",
+  "image_jpeg",
+  "audio_pcm",
+  "audio_wav",
+  "audio_mp3",
+  "video_mp4",
+  "svg",
+  "structured_json",
+  "code"
+];
+var INPUT_MODALITIES = ["text", "image", "audio", "video", "pdf", "code"];
+var TOOL_CAPABILITIES = [
+  "mcp",
+  "function_calling",
+  "computer_use",
+  "code_execution_sandbox",
+  "web_search",
+  "file_operations",
+  "structured_output",
+  "apply_patch"
+];
+var SPECIAL_FEATURES = [
+  "extended_thinking",
+  "deep_research",
+  "streaming",
+  "grounding",
+  "citations",
+  "image_editing",
+  "voice_cloning",
+  "live_api",
+  "context_caching"
+];
+var PROVIDERS = ["anthropic", "google", "openai", "custom-openai", "openrouter"];
+var CLI_NAMES = ["claude", "gemini", "codex", "opencode"];
+var CliNameSchema = z2.enum(CLI_NAMES);
+var DEFAULT_CLI = "claude";
+var MODEL_IDS = [
+  "claude-opus",
+  "claude-sonnet",
+  "claude-haiku",
+  "gemini-3-pro",
+  "gemini-pro",
+  "gemini-3-flash",
+  "gemini-flash",
+  "codex-5.3",
+  "codex-5.2",
+  "codex-5.1-mini",
+  "opencode-default",
+  "opencode-custom-opus",
+  "opencode-custom-sonnet",
+  "openrouter-nemotron-super",
+  "openrouter-qwen-coder"
+];
+var QualityScoresSchema = z2.object({
+  reasoning: z2.number().min(0).max(10),
+  codeGeneration: z2.number().min(0).max(10),
+  speed: z2.number().min(0).max(10),
+  cost: z2.number().min(0).max(10)
+});
+var PricingSchema = z2.object({
+  inputPer1M: z2.number().nonnegative(),
+  outputPer1M: z2.number().nonnegative()
+});
+var ModelCapabilitySchema = z2.object({
+  /** Unique model identifier matching delegate_to_model model IDs */
+  id: z2.enum(MODEL_IDS),
+  /** Human-readable display name */
+  displayName: z2.string().min(1),
+  /** Provider/vendor */
+  provider: z2.enum(PROVIDERS),
+  /** Maximum context window in tokens */
+  contextWindow: z2.number().int().positive(),
+  /** Output modalities this model can produce */
+  outputModalities: z2.array(z2.enum(OUTPUT_MODALITIES)).min(1),
+  /** Input modalities this model can accept */
+  inputModalities: z2.array(z2.enum(INPUT_MODALITIES)).min(1),
+  /** Tool/integration capabilities */
+  toolCapabilities: z2.array(z2.enum(TOOL_CAPABILITIES)),
+  /** Special features beyond standard generation */
+  specialFeatures: z2.array(z2.enum(SPECIAL_FEATURES)),
+  /** Known constraints or limitations */
+  constraints: z2.array(z2.string()).optional(),
+  /** Notes about the model (e.g., beta features, pricing tier) */
+  notes: z2.string().optional(),
+  /** Pricing per 1M tokens (USD) */
+  pricing: PricingSchema.optional(),
+  /** Quality scores for routing (0-10 scale) */
+  qualityScores: QualityScoresSchema.optional(),
+  /** Maximum output tokens */
+  maxOutputTokens: z2.number().int().positive().optional(),
+  /** Which CLI tool this model belongs to */
+  cliName: z2.enum(CLI_NAMES).optional(),
+  /** Short alias used by the CLI (e.g., 'opus' for Claude CLI) */
+  cliAlias: z2.string().optional(),
+  /** Model name the CLI binary expects (e.g., 'gemini-2.5-pro') */
+  cliModelName: z2.string().optional(),
+  /**
+   * Legacy / version-suffixed names that resolve to this model. Used by
+   * adapters and routing to map historical user-facing names (e.g.,
+   * `claude-opus-4-5-20251101`, `gemini-2.5-pro`) to the current registry
+   * entry. Empty strings are rejected; uniqueness within the array is not
+   * enforced at schema level (caller responsibility).
+   *
+   * Added for issue #2199 Child 1; populated by the companion migration
+   * epic #2200.
+   */
+  aliases: z2.array(z2.string().min(1)).optional(),
+  /** Whether this model is deprecated and should receive a scoring penalty */
+  deprecated: z2.boolean().optional(),
+  /** ISO date when the model was deprecated (informational) */
+  deprecatedAt: z2.string().optional(),
+  /** Model ID to migrate to (informational guidance) */
+  replacedBy: z2.enum(MODEL_IDS).optional()
+});
+var ModelCapabilitiesMatrixSchema = z2.object({
+  /** Schema version for forward compatibility */
+  version: z2.number().int().positive(),
+  /** Last updated date (ISO 8601) */
+  updatedAt: z2.string(),
+  /** Model capability definitions */
+  models: z2.array(ModelCapabilitySchema).min(1)
+});
+
+// src/config/manifest-overlay.ts
+var MANIFEST_ENV_VAR = "NEXUS_MODELS_OVERLAY_PATH";
+var MANIFEST_MAX_BYTES = 1 * 1024 * 1024;
+function defaultManifestPath() {
+  return nexusDataPath("models-manifest.yaml");
+}
+function resolveManifestPath(env = process.env) {
+  const override = env[MANIFEST_ENV_VAR];
+  if (override !== void 0 && override !== "") return override;
+  return defaultManifestPath();
+}
+var ModelVendorSchema = z3.enum([
+  "anthropic",
+  "openai",
+  "google",
+  "meta",
+  "qwen",
+  "nvidia",
+  "mistral",
+  "cohere",
+  "deepseek",
+  "unknown"
+]);
+var ToolDefinitionFormatSchema = z3.enum([
+  "openai",
+  "anthropic",
+  "gemini"
+]);
+var PromptCachingModeSchema = z3.enum([
+  "none",
+  "ephemeral",
+  "aggressive"
+]);
+var ManifestEntrySchema = z3.object({
+  // Identity (required)
+  id: z3.string().min(1).max(200),
+  vendor: ModelVendorSchema,
+  family: z3.string().min(1).max(80),
+  // Identity (optional)
+  aliases: z3.array(z3.string().min(1).max(200)).max(20).optional(),
+  version: z3.string().min(1).max(50).optional(),
+  displayName: z3.string().min(1).max(200).optional(),
+  // Capabilities (all optional)
+  contextWindow: z3.number().int().positive().max(2e7).optional(),
+  maxOutputTokens: z3.number().int().positive().max(2e7).optional(),
+  inputModalities: z3.array(z3.enum(INPUT_MODALITIES)).optional(),
+  outputModalities: z3.array(z3.enum(OUTPUT_MODALITIES)).optional(),
+  toolCapabilities: z3.array(z3.enum(TOOL_CAPABILITIES)).optional(),
+  specialFeatures: z3.array(z3.enum(SPECIAL_FEATURES)).optional(),
+  pricing: PricingSchema.optional(),
+  qualityScores: QualityScoresSchema.optional(),
+  notes: z3.string().max(2e3).optional(),
+  // Behaviour (all optional — defaults fill in)
+  parallelToolCalls: z3.boolean().optional(),
+  promptCaching: PromptCachingModeSchema.optional(),
+  toolDefinitionFormat: ToolDefinitionFormatSchema.optional(),
+  maxRecommendedTurnBudget: z3.number().int().positive().max(100).optional(),
+  strictJson: z3.boolean().optional(),
+  quirks: z3.array(z3.string().max(80)).max(20).optional(),
+  profileId: z3.string().min(1).max(80).optional(),
+  // Provenance (optional)
+  verifiedAt: z3.string().min(8).max(40).optional()
+});
+var ManifestSchema = z3.object({
+  version: z3.literal(1),
+  models: z3.array(z3.unknown())
+});
+function loadManifestOverlay(options) {
+  const logger11 = options?.logger ?? createLogger({ component: "manifest-overlay" });
+  const path2 = options?.path ?? resolveManifestPath(options?.env);
+  let exists = false;
+  try {
+    exists = existsSync(path2);
+  } catch {
+    return { entries: [], rejections: [], path: path2, status: "missing" };
+  }
+  if (!exists) {
+    return { entries: [], rejections: [], path: path2, status: "missing" };
+  }
+  const stat = statSync(path2);
+  if (stat.size === 0) {
+    return { entries: [], rejections: [], path: path2, status: "empty" };
+  }
+  if (stat.size > MANIFEST_MAX_BYTES) {
+    logger11.warn("Manifest overlay too large; skipping", {
+      path: path2,
+      size: stat.size,
+      max: MANIFEST_MAX_BYTES
+    });
+    return { entries: [], rejections: [], path: path2, status: "too-large" };
+  }
+  const raw = readFileSync(path2, "utf-8");
+  return parseManifest(raw, path2, logger11);
+}
+function parseManifest(raw, path2, logger11) {
+  let parsed;
+  try {
+    if (path2.endsWith(".json")) {
+      parsed = JSON.parse(raw);
+    } else {
+      parsed = parseYaml(raw);
+    }
+  } catch (e) {
+    logger11.warn("Manifest overlay parse failure; skipping", {
+      path: path2,
+      error: e instanceof Error ? e.message : String(e)
+    });
+    return { entries: [], rejections: [], path: path2, status: "malformed" };
+  }
+  const shape = ManifestSchema.safeParse(parsed);
+  if (!shape.success) {
+    logger11.warn("Manifest overlay schema mismatch at root; skipping", {
+      path: path2,
+      issues: shape.error.issues.slice(0, 5).map((i) => i.message)
+    });
+    return { entries: [], rejections: [], path: path2, status: "malformed" };
+  }
+  const entries = [];
+  const rejections = [];
+  shape.data.models.forEach((rawEntry, index) => {
+    const result = ManifestEntrySchema.safeParse(rawEntry);
+    if (!result.success) {
+      const candidateId = typeof rawEntry === "object" && rawEntry !== null && "id" in rawEntry && typeof rawEntry.id === "string" ? rawEntry.id : void 0;
+      const baseRejection = {
+        index,
+        reason: result.error.issues.slice(0, 3).map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")
+      };
+      if (candidateId !== void 0) baseRejection.id = candidateId;
+      rejections.push(baseRejection);
+      return;
+    }
+    entries.push(materializeEntry(result.data));
+  });
+  return { entries, rejections, path: path2, status: "loaded" };
+}
+function materializeEntry(input) {
+  return {
+    id: input.id,
+    vendor: input.vendor,
+    family: input.family,
+    // Behaviour with sensible defaults
+    parallelToolCalls: input.parallelToolCalls ?? false,
+    promptCaching: input.promptCaching ?? "none",
+    toolDefinitionFormat: input.toolDefinitionFormat ?? "openai",
+    maxRecommendedTurnBudget: input.maxRecommendedTurnBudget ?? 10,
+    strictJson: input.strictJson ?? true,
+    quirks: input.quirks ?? [],
+    profileId: input.profileId ?? `manifest-${input.vendor}`,
+    source: "manifest",
+    ...pickOptionalFields(input)
+  };
+}
+var OPTIONAL_PASSTHROUGH_KEYS = [
+  "aliases",
+  "version",
+  "displayName",
+  "contextWindow",
+  "maxOutputTokens",
+  "inputModalities",
+  "outputModalities",
+  "toolCapabilities",
+  "specialFeatures",
+  "pricing",
+  "qualityScores",
+  "notes",
+  "verifiedAt"
+];
+function pickOptionalFields(input) {
+  const out = {};
+  const inputRecord = input;
+  for (const key of OPTIONAL_PASSTHROUGH_KEYS) {
+    const value = inputRecord[key];
+    if (value !== void 0) out[key] = value;
+  }
+  return out;
+}
+
+// src/config/models-dev-snapshot-loader.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+function defaultSnapshotPath() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  return join(here, "models-dev-snapshot.json");
+}
+function loadModelsDevSnapshot(options) {
+  const logger11 = createLogger({ component: "models-dev-snapshot" });
+  const path2 = options?.path ?? defaultSnapshotPath();
+  let exists = false;
+  try {
+    exists = existsSync2(path2);
+  } catch {
+    return { entries: [], path: path2, status: "missing" };
+  }
+  if (!exists) {
+    return { entries: [], path: path2, status: "missing" };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(path2, "utf-8"));
+  } catch (e) {
+    logger11.warn("models.dev snapshot parse failure; skipping", {
+      path: path2,
+      error: e instanceof Error ? e.message : String(e)
+    });
+    return { entries: [], path: path2, status: "malformed" };
+  }
+  if (parsed.version !== 1) {
+    logger11.warn("models.dev snapshot version unsupported; skipping", {
+      path: path2,
+      version: parsed.version
+    });
+    return { entries: [], path: path2, status: "malformed" };
+  }
+  if (!Array.isArray(parsed.entries)) {
+    logger11.warn("models.dev snapshot missing entries array; skipping", { path: path2 });
+    return { entries: [], path: path2, status: "malformed" };
+  }
+  const entries = parsed.entries;
+  return {
+    entries,
+    path: path2,
+    status: "loaded",
+    ...typeof parsed.fetchedAt === "string" ? { fetchedAt: parsed.fetchedAt } : {}
+  };
+}
+
+// src/config/model-registry.ts
+var ModelRegistry = class {
+  byId = /* @__PURE__ */ new Map();
+  byAlias = /* @__PURE__ */ new Map();
+  // alias → canonical id
+  constructor(options = {}) {
+    if (options.modelsDevEntries !== void 0) {
+      this.loadEntries(options.modelsDevEntries);
+    }
+    if (options.inTreeEntries !== void 0) {
+      this.loadEntries(options.inTreeEntries);
+    }
+    if (options.manifestEntries !== void 0) {
+      this.loadEntries(options.manifestEntries);
+    }
+  }
+  /**
+   * Resolve a model id to its full metadata entry. Always returns —
+   * unknown models get a derived entry with sensible defaults.
+   */
+  getEntry(modelId, hints) {
+    const direct = this.lookupExact(modelId);
+    if (direct !== void 0 && direct.source !== "models-dev") return direct;
+    const identity = resolveModelIdentitySync(modelId, augmentHints(hints, direct));
+    const derived = deriveEntry(modelId, identity);
+    if (direct !== void 0 && identity.vendor !== "unknown") {
+      return mergeSnapshotWithDerived(direct, derived);
+    }
+    return direct ?? derived;
+  }
+  /**
+   * Has the registry got an authoritative entry for this id?
+   * Consumers use this to distinguish "we know X" from "we guessed."
+   */
+  hasAuthoritative(modelId) {
+    return this.lookupExact(modelId) !== void 0;
+  }
+  /** All authoritative entries (in-tree + models.dev + manifest, deduped). */
+  allEntries() {
+    return [...this.byId.values()];
+  }
+  /** Snapshot of canonical id → entry mapping. */
+  toMap() {
+    return new Map(this.byId);
+  }
+  lookupExact(modelId) {
+    const direct = this.byId.get(modelId);
+    if (direct !== void 0) return direct;
+    const canonical = this.byAlias.get(modelId);
+    if (canonical !== void 0) return this.byId.get(canonical);
+    return void 0;
+  }
+  loadEntries(entries) {
+    for (const entry of entries) {
+      this.byId.set(entry.id, entry);
+      if (entry.aliases !== void 0) {
+        for (const alias of entry.aliases) {
+          this.byAlias.set(alias, entry.id);
+        }
+      }
+    }
+  }
 };
-function getModelCapabilities(modelId, matrix = DEFAULT_MODEL_CAPABILITIES) {
-  return matrix.models.find((m) => m.id === modelId);
+function augmentHints(hints, direct) {
+  const h = hints ?? {};
+  if (direct === void 0) return h;
+  const out = {
+    vendor: h.vendor ?? direct.vendor,
+    family: h.family ?? direct.family
+  };
+  if (h.version !== void 0) out.version = h.version;
+  if (h.quirks !== void 0) out.quirks = h.quirks;
+  return out;
+}
+function mergeSnapshotWithDerived(snapshot, derived) {
+  return {
+    ...snapshot,
+    parallelToolCalls: derived.parallelToolCalls,
+    promptCaching: derived.promptCaching,
+    toolDefinitionFormat: derived.toolDefinitionFormat,
+    maxRecommendedTurnBudget: derived.maxRecommendedTurnBudget,
+    strictJson: derived.strictJson,
+    quirks: derived.quirks,
+    profileId: derived.profileId,
+    source: "derived"
+  };
+}
+var globalRegistry;
+function getDefaultRegistry() {
+  globalRegistry ??= buildDefaultRegistry();
+  return globalRegistry;
+}
+function buildDefaultRegistry() {
+  const overlay = loadManifestOverlay();
+  const snapshot = loadModelsDevSnapshot();
+  const inTree = buildInTreeEntries();
+  const options = { inTreeEntries: inTree };
+  if (overlay.status === "loaded" && overlay.entries.length > 0) {
+    options.manifestEntries = overlay.entries;
+  }
+  if (snapshot.status === "loaded" && snapshot.entries.length > 0) {
+    options.modelsDevEntries = snapshot.entries;
+  }
+  return new ModelRegistry(options);
+}
+function setDefaultRegistry(registry) {
+  globalRegistry = registry;
+}
+
+// src/config/model-config-helpers.ts
+function cliAvgLatency() {
+  return { claude: 800, gemini: 400, codex: 500, opencode: 600 };
+}
+function lookupInTree(modelId) {
+  const entry = getDefaultRegistry().getEntry(modelId);
+  return entry.source === "in-tree" ? entry : void 0;
+}
+function inTreeById() {
+  return new Map(buildInTreeEntries().map((e) => [e.id, e]));
+}
+function getModelContextWindow(modelId) {
+  return lookupInTree(modelId)?.contextWindow ?? 8192;
+}
+function getDefaultModelForCli(cli) {
+  return DEFAULT_MODEL_PER_CLI[cli];
+}
+function getCliModelName(modelId) {
+  const entry = lookupInTree(modelId);
+  return entry?.cliModelName ?? entry?.cliAlias ?? modelId;
+}
+function resolveCliAlias(alias) {
+  const match = getDefaultRegistry().allEntries().find(
+    (e) => e.source === "in-tree" && (e.cliAlias === alias || e.id === alias || (e.aliases?.includes(alias) ?? false))
+  );
+  return match?.id;
+}
+function buildCapabilityProfiles() {
+  const result = {};
+  for (const entry of buildInTreeEntries()) {
+    const q = entry.qualityScores;
+    if (q !== void 0 && entry.contextWindow !== void 0) {
+      result[entry.id] = {
+        reasoning: q.reasoning,
+        contextWindow: entry.contextWindow,
+        codeGeneration: q.codeGeneration,
+        speed: q.speed,
+        cost: q.cost
+      };
+    }
+  }
+  return result;
+}
+function buildCliCapabilityProfiles() {
+  const result = {};
+  const byId = inTreeById();
+  for (const [cli, modelId] of Object.entries(DEFAULT_MODEL_PER_CLI)) {
+    const entry = byId.get(modelId);
+    const q = entry?.qualityScores;
+    if (entry !== void 0 && q !== void 0 && entry.contextWindow !== void 0) {
+      result[cli] = {
+        reasoning: q.reasoning,
+        contextWindow: entry.contextWindow,
+        codeGeneration: q.codeGeneration,
+        speed: q.speed,
+        cost: q.cost
+      };
+    }
+  }
+  return result;
+}
+function buildTopsisProfiles() {
+  const profiles = [];
+  const byId = inTreeById();
+  for (const [cli, modelId] of Object.entries(DEFAULT_MODEL_PER_CLI)) {
+    const entry = byId.get(modelId);
+    const q = entry?.qualityScores;
+    const p = entry?.pricing;
+    if (entry === void 0 || q === void 0 || p === void 0) continue;
+    if (entry.contextWindow === void 0) continue;
+    profiles.push({
+      cliName: cli,
+      capabilities: {
+        reasoning: q.reasoning,
+        contextWindow: entry.contextWindow,
+        codeGeneration: q.codeGeneration,
+        speed: q.speed,
+        cost: q.cost
+      },
+      costPerMillionInput: p.inputPer1M,
+      costPerMillionOutput: p.outputPer1M,
+      averageLatencyMs: cliAvgLatency()[cli],
+      qualityScore: (q.reasoning + q.codeGeneration) / 2
+    });
+  }
+  return profiles;
+}
+function findCanonicalModel(cli, cliModelName) {
+  const entry = getDefaultRegistry().allEntries().find(
+    (e) => e.source === "in-tree" && e.cliName === cli && (e.cliModelName === cliModelName || e.cliAlias === cliModelName || e.id === cliModelName || (e.aliases?.includes(cliModelName) ?? false))
+  );
+  return entry !== void 0 ? entryToCapability(entry) : void 0;
+}
+function applyOptionalCapabilityFields(entry, target) {
+  if (entry.notes !== void 0) target.notes = entry.notes;
+  if (entry.pricing !== void 0) target.pricing = entry.pricing;
+  if (entry.qualityScores !== void 0) target.qualityScores = entry.qualityScores;
+  if (entry.maxOutputTokens !== void 0) target.maxOutputTokens = entry.maxOutputTokens;
+  if (entry.cliName !== void 0) target.cliName = entry.cliName;
+  if (entry.cliAlias !== void 0) target.cliAlias = entry.cliAlias;
+  if (entry.cliModelName !== void 0) target.cliModelName = entry.cliModelName;
+  if (entry.aliases !== void 0) target.aliases = [...entry.aliases];
+}
+function entryToCapability(entry) {
+  const cap = {
+    id: entry.id,
+    displayName: entry.displayName ?? entry.id,
+    provider: entry.vendor === "unknown" ? "openai" : entry.vendor,
+    contextWindow: entry.contextWindow ?? 0,
+    outputModalities: [...entry.outputModalities ?? ["text"]],
+    inputModalities: [...entry.inputModalities ?? ["text"]],
+    toolCapabilities: [...entry.toolCapabilities ?? []],
+    specialFeatures: [...entry.specialFeatures ?? []]
+  };
+  applyOptionalCapabilityFields(entry, cap);
+  return cap;
+}
+function buildModelInfo(cli, cliModelName) {
+  const cap = findCanonicalModel(cli, cliModelName);
+  if (cap === void 0) return void 0;
+  const info = {
+    id: cliModelName,
+    name: cap.displayName,
+    contextWindow: cap.contextWindow
+  };
+  if (cap.maxOutputTokens !== void 0) {
+    info.maxOutput = cap.maxOutputTokens;
+  }
+  if (cap.pricing !== void 0) {
+    info.costPerMillionInput = cap.pricing.inputPer1M;
+    info.costPerMillionOutput = cap.pricing.outputPer1M;
+  }
+  return info;
+}
+function getInTreeCapabilitiesMatrix() {
+  return {
+    version: DEFAULT_MODEL_CAPABILITIES.version,
+    updatedAt: DEFAULT_MODEL_CAPABILITIES.updatedAt,
+    models: buildInTreeEntries().map(entryToCapability)
+  };
+}
+function lookupInTreeCapability(modelId) {
+  const entry = lookupInTree(modelId);
+  return entry !== void 0 ? entryToCapability(entry) : void 0;
 }
-function findModelsByOutputModality(modality, matrix = DEFAULT_MODEL_CAPABILITIES) {
-  return matrix.models.filter((m) => m.outputModalities.includes(modality));
+function findInTreeByCli(cliName) {
+  return buildInTreeEntries().filter((e) => e.cliName === cliName).map(entryToCapability);
 }
-function findModelsByInputModality(modality, matrix = DEFAULT_MODEL_CAPABILITIES) {
-  return matrix.models.filter((m) => m.inputModalities.includes(modality));
+function inTreeModels() {
+  return buildInTreeEntries().map(entryToCapability);
 }
-function findModelsByToolCapability(capability, matrix = DEFAULT_MODEL_CAPABILITIES) {
-  return matrix.models.filter((m) => m.toolCapabilities.includes(capability));
+function findModelsByOutputModality(modality) {
+  return inTreeModels().filter((m) => m.outputModalities.includes(modality));
 }
-function findModelsByFeature(feature, matrix = DEFAULT_MODEL_CAPABILITIES) {
-  return matrix.models.filter((m) => m.specialFeatures.includes(feature));
+function findModelsByInputModality(modality) {
+  return inTreeModels().filter((m) => m.inputModalities.includes(modality));
 }
-function findModelsByCli(cliName, matrix = DEFAULT_MODEL_CAPABILITIES) {
-  return matrix.models.filter((m) => m.cliName === cliName);
+function findModelsByToolCapability(capability) {
+  return inTreeModels().filter((m) => m.toolCapabilities.includes(capability));
+}
+function findModelsByFeature(feature) {
+  return inTreeModels().filter((m) => m.specialFeatures.includes(feature));
 }
 function includesAll(haystack, required) {
   if (required === void 0) return true;
   return required.every((item) => haystack.includes(item));
 }
-function modelSupportsAll(modelId, requirements, matrix = DEFAULT_MODEL_CAPABILITIES) {
-  const model = getModelCapabilities(modelId, matrix);
+function modelSupportsAll(modelId, requirements) {
+  const model = lookupInTreeCapability(modelId);
   if (model === void 0) return false;
   const meetsContext = requirements.minContextWindow === void 0 || model.contextWindow >= requirements.minContextWindow;
   return meetsContext && includesAll(model.outputModalities, requirements.outputModalities) && includesAll(model.inputModalities, requirements.inputModalities) && includesAll(model.toolCapabilities, requirements.toolCapabilities) && includesAll(model.specialFeatures, requirements.specialFeatures);
@@ -1276,10 +2117,11 @@ function isPrefixMatch(entry, query) {
   return id.length > 0 && query.startsWith(id) || cliName.length > 0 && query.startsWith(cliName);
 }
 function lookupCanonicalPricing(model) {
-  for (const m of DEFAULT_MODEL_CAPABILITIES.models) {
+  const models = getInTreeCapabilitiesMatrix().models;
+  for (const m of models) {
     if (isExactMatch(m, model)) return toPricing(m.pricing);
   }
-  for (const m of DEFAULT_MODEL_CAPABILITIES.models) {
+  for (const m of models) {
     if (m.pricing !== void 0 && isPrefixMatch(m, model)) return toPricing(m.pricing);
   }
   return void 0;
@@ -1761,7 +2603,7 @@ function formatPercentage(value, decimals = 0) {
 
 // src/core/artifact.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var ArtifactType = {
   /** Planning documents and task breakdowns */
   PLAN: "plan",
@@ -1774,30 +2616,30 @@ var ArtifactType = {
   /** Intent declarations for policy authorization */
   INTENT: "intent"
 };
-var ArtifactTypeSchema = z3.enum([
+var ArtifactTypeSchema = z4.enum([
   ArtifactType.PLAN,
   ArtifactType.ANALYSIS,
   ArtifactType.DECISION,
   ArtifactType.RESULT,
   ArtifactType.INTENT
 ]);
-var ArtifactMetadataSchema = z3.object({
-  createdAt: z3.iso.datetime({ message: "createdAt must be ISO 8601 format" }),
-  createdBy: z3.string().min(1, "createdBy is required"),
-  parentId: z3.uuid().optional(),
-  taskId: z3.string().min(1, "taskId is required"),
-  traceId: z3.string().optional()
+var ArtifactMetadataSchema = z4.object({
+  createdAt: z4.iso.datetime({ message: "createdAt must be ISO 8601 format" }),
+  createdBy: z4.string().min(1, "createdBy is required"),
+  parentId: z4.uuid().optional(),
+  taskId: z4.string().min(1, "taskId is required"),
+  traceId: z4.string().optional()
 });
 function createArtifactSchema(dataSchema) {
-  return z3.object({
-    id: z3.uuid(),
+  return z4.object({
+    id: z4.uuid(),
     type: ArtifactTypeSchema,
-    schemaVersion: z3.string().regex(/^\d+\.\d+\.\d+$/, "schemaVersion must be semver"),
+    schemaVersion: z4.string().regex(/^\d+\.\d+\.\d+$/, "schemaVersion must be semver"),
     data: dataSchema,
     metadata: ArtifactMetadataSchema
   });
 }
-var BaseArtifactSchema = createArtifactSchema(z3.unknown());
+var BaseArtifactSchema = createArtifactSchema(z4.unknown());
 
 // src/core/metrics.ts
 var MAX_RECENT_ERRORS = 1e3;
@@ -2974,108 +3816,6 @@ function estimateTokens(text) {
   return getTokenEstimator().estimateText(text);
 }
 
-// src/config/model-config-helpers.ts
-function getModelContextWindow(modelId) {
-  return getModelCapabilities(modelId)?.contextWindow ?? 8192;
-}
-function getDefaultModelForCli(cli) {
-  return DEFAULT_MODEL_PER_CLI[cli];
-}
-function getCliModelName(modelId) {
-  const cap = getModelCapabilities(modelId);
-  return cap?.cliModelName ?? cap?.cliAlias ?? modelId;
-}
-function resolveCliAlias(alias) {
-  return DEFAULT_MODEL_CAPABILITIES.models.find(
-    (m) => m.cliAlias === alias || m.id === alias || (m.aliases?.includes(alias) ?? false)
-  )?.id;
-}
-function buildCapabilityProfiles() {
-  const result = {};
-  for (const model of DEFAULT_MODEL_CAPABILITIES.models) {
-    const q = model.qualityScores;
-    if (q !== void 0) {
-      result[model.id] = {
-        reasoning: q.reasoning,
-        contextWindow: model.contextWindow,
-        codeGeneration: q.codeGeneration,
-        speed: q.speed,
-        cost: q.cost
-      };
-    }
-  }
-  return result;
-}
-function buildCliCapabilityProfiles() {
-  const result = {};
-  for (const [cli, modelId] of Object.entries(DEFAULT_MODEL_PER_CLI)) {
-    const model = getModelCapabilities(modelId);
-    const q = model?.qualityScores;
-    if (model !== void 0 && q !== void 0) {
-      result[cli] = {
-        reasoning: q.reasoning,
-        contextWindow: model.contextWindow,
-        codeGeneration: q.codeGeneration,
-        speed: q.speed,
-        cost: q.cost
-      };
-    }
-  }
-  return result;
-}
-var CLI_AVG_LATENCY = {
-  claude: 800,
-  gemini: 400,
-  codex: 500,
-  opencode: 600
-};
-function buildTopsisProfiles() {
-  const profiles = [];
-  for (const [cli, modelId] of Object.entries(DEFAULT_MODEL_PER_CLI)) {
-    const model = getModelCapabilities(modelId);
-    const q = model?.qualityScores;
-    const p = model?.pricing;
-    if (model === void 0 || q === void 0 || p === void 0) continue;
-    profiles.push({
-      cliName: cli,
-      capabilities: {
-        reasoning: q.reasoning,
-        contextWindow: model.contextWindow,
-        codeGeneration: q.codeGeneration,
-        speed: q.speed,
-        cost: q.cost
-      },
-      costPerMillionInput: p.inputPer1M,
-      costPerMillionOutput: p.outputPer1M,
-      averageLatencyMs: CLI_AVG_LATENCY[cli],
-      qualityScore: (q.reasoning + q.codeGeneration) / 2
-    });
-  }
-  return profiles;
-}
-function findCanonicalModel(cli, cliModelName) {
-  return DEFAULT_MODEL_CAPABILITIES.models.find(
-    (m) => m.cliName === cli && (m.cliModelName === cliModelName || m.cliAlias === cliModelName || m.id === cliModelName || (m.aliases?.includes(cliModelName) ?? false))
-  );
-}
-function buildModelInfo(cli, cliModelName) {
-  const cap = findCanonicalModel(cli, cliModelName);
-  if (cap === void 0) return void 0;
-  const info = {
-    id: cliModelName,
-    name: cap.displayName,
-    contextWindow: cap.contextWindow
-  };
-  if (cap.maxOutputTokens !== void 0) {
-    info.maxOutput = cap.maxOutputTokens;
-  }
-  if (cap.pricing !== void 0) {
-    info.costPerMillionInput = cap.pricing.inputPer1M;
-    info.costPerMillionOutput = cap.pricing.outputPer1M;
-  }
-  return info;
-}
-
 // src/cli-adapters/types-capability.ts
 var CLI_VERSION_REQUIREMENTS = {
   claude: {
@@ -3845,19 +4585,19 @@ var TopsisRouter = class {
 };
 
 // src/cli-adapters/budget-router-types.ts
-import { z as z4 } from "zod";
-var BudgetConstraintSchema = z4.object({
-  maxTokens: z4.number().int().positive().optional(),
-  maxCostUSD: z4.number().positive().optional(),
-  maxLatencyMs: z4.number().positive().optional()
+import { z as z5 } from "zod";
+var BudgetConstraintSchema = z5.object({
+  maxTokens: z5.number().int().positive().optional(),
+  maxCostUSD: z5.number().positive().optional(),
+  maxLatencyMs: z5.number().positive().optional()
 });
-var SessionBudgetSchema = z4.object({
-  totalTokens: z4.number().int().positive(),
-  totalCostUSD: z4.number().positive(),
-  usedTokens: z4.number().int().min(0).default(0),
-  usedCostUSD: z4.number().min(0).default(0),
-  startTime: z4.number().int().positive(),
-  sessionId: z4.string().min(1)
+var SessionBudgetSchema = z5.object({
+  totalTokens: z5.number().int().positive(),
+  totalCostUSD: z5.number().positive(),
+  usedTokens: z5.number().int().min(0).default(0),
+  usedCostUSD: z5.number().min(0).default(0),
+  startTime: z5.number().int().positive(),
+  sessionId: z5.string().min(1)
 });
 var DEFAULT_LINUCB_CONFIG = {
   numArms: 4,
@@ -3865,11 +4605,11 @@ var DEFAULT_LINUCB_CONFIG = {
   alpha: 1,
   lambda: 1
 };
-var LinUCBConfigSchema = z4.object({
-  numArms: z4.number().int().positive().default(4),
-  featureDim: z4.number().int().positive().default(6),
-  alpha: z4.number().positive().default(1),
-  lambda: z4.number().positive().default(1)
+var LinUCBConfigSchema = z5.object({
+  numArms: z5.number().int().positive().default(4),
+  featureDim: z5.number().int().positive().default(6),
+  alpha: z5.number().positive().default(1),
+  lambda: z5.number().positive().default(1)
 });
 
 // src/cli-adapters/linucb-math.ts
@@ -4224,7 +4964,7 @@ var LinUCBBandit = class {
 import { randomUUID as randomUUID3 } from "crypto";
 
 // src/cli-adapters/preference-router-types.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var DEFAULT_PREFERENCE_ROUTER_CONFIG = {
   strongModel: {
     tier: "strong",
@@ -4245,24 +4985,24 @@ var DEFAULT_PREFERENCE_ROUTER_CONFIG = {
   maxDataPoints: 1e4,
   enableOnlineLearning: true
 };
-var PreferenceRouterConfigSchema = z5.object({
-  strongModel: z5.object({
-    tier: z5.literal("strong"),
-    cli: z5.enum(["claude", "gemini", "codex", "opencode"]),
-    costPerMillionTokens: z5.number().positive(),
-    qualityBaseline: z5.number().min(0).max(1)
+var PreferenceRouterConfigSchema = z6.object({
+  strongModel: z6.object({
+    tier: z6.literal("strong"),
+    cli: z6.enum(["claude", "gemini", "codex", "opencode"]),
+    costPerMillionTokens: z6.number().positive(),
+    qualityBaseline: z6.number().min(0).max(1)
   }),
-  weakModel: z5.object({
-    tier: z5.literal("weak"),
-    cli: z5.enum(["claude", "gemini", "codex", "opencode"]),
-    costPerMillionTokens: z5.number().positive(),
-    qualityBaseline: z5.number().min(0).max(1)
+  weakModel: z6.object({
+    tier: z6.literal("weak"),
+    cli: z6.enum(["claude", "gemini", "codex", "opencode"]),
+    costPerMillionTokens: z6.number().positive(),
+    qualityBaseline: z6.number().min(0).max(1)
   }),
-  routingThreshold: z5.number().min(0).max(1).default(0.5),
-  minDataPoints: z5.number().int().positive().default(10),
-  maxDataPoints: z5.number().int().positive().default(1e4),
-  enableOnlineLearning: z5.boolean().default(true),
-  domainThresholds: z5.record(z5.string(), z5.number().min(0).max(1)).optional()
+  routingThreshold: z6.number().min(0).max(1).default(0.5),
+  minDataPoints: z6.number().int().positive().default(10),
+  maxDataPoints: z6.number().int().positive().default(1e4),
+  enableOnlineLearning: z6.boolean().default(true),
+  domainThresholds: z6.record(z6.string(), z6.number().min(0).max(1)).optional()
 });
 
 // src/cli-adapters/preference-router-store.ts
@@ -4604,8 +5344,8 @@ function createPreferenceRouter(config, dataStore) {
 }
 
 // src/cli-adapters/zero-router-types.ts
-import { z as z6 } from "zod";
-var DifficultyDimensionSchema = z6.enum([
+import { z as z7 } from "zod";
+var DifficultyDimensionSchema = z7.enum([
   "reasoning",
   "knowledge",
   "creativity",
@@ -4619,17 +5359,17 @@ var DIFFICULTY_DIMENSIONS = [
   "precision",
   "context_length"
 ];
-var DifficultySpaceSchema = z6.object({
+var DifficultySpaceSchema = z7.object({
   /** Reasoning difficulty: logical complexity, multi-step inference (0-1) */
-  reasoning: z6.number().min(0).max(1),
+  reasoning: z7.number().min(0).max(1),
   /** Knowledge difficulty: domain expertise required (0-1) */
-  knowledge: z6.number().min(0).max(1),
+  knowledge: z7.number().min(0).max(1),
   /** Creativity difficulty: novel generation, open-endedness (0-1) */
-  creativity: z6.number().min(0).max(1),
+  creativity: z7.number().min(0).max(1),
   /** Precision difficulty: accuracy requirements, error tolerance (0-1) */
-  precision: z6.number().min(0).max(1),
+  precision: z7.number().min(0).max(1),
   /** Context length difficulty: amount of context to process (0-1) */
-  context_length: z6.number().min(0).max(1)
+  context_length: z7.number().min(0).max(1)
 });
 var DEFAULT_DIFFICULTY_THRESHOLDS = {
   easyUpperBound: 0.3,
@@ -4645,12 +5385,12 @@ var DEFAULT_TIER_TO_CLIS = {
   balanced: ["codex", "opencode", "gemini", "claude"],
   powerful: ["claude", "codex", "opencode", "gemini"]
 };
-var DifficultyWeightsSchema = z6.object({
-  reasoning: z6.number().min(0).max(1),
-  knowledge: z6.number().min(0).max(1),
-  creativity: z6.number().min(0).max(1),
-  precision: z6.number().min(0).max(1),
-  context_length: z6.number().min(0).max(1)
+var DifficultyWeightsSchema = z7.object({
+  reasoning: z7.number().min(0).max(1),
+  knowledge: z7.number().min(0).max(1),
+  creativity: z7.number().min(0).max(1),
+  precision: z7.number().min(0).max(1),
+  context_length: z7.number().min(0).max(1)
 });
 var DEFAULT_DIFFICULTY_WEIGHTS = {
   reasoning: 0.3,
@@ -4659,29 +5399,29 @@ var DEFAULT_DIFFICULTY_WEIGHTS = {
   precision: 0.25,
   context_length: 0.15
 };
-var ZeroRouterConfigSchema = z6.object({
+var ZeroRouterConfigSchema = z7.object({
   /** Difficulty thresholds for level classification */
-  thresholds: z6.object({
-    easyUpperBound: z6.number().min(0).max(1),
-    hardLowerBound: z6.number().min(0).max(1)
+  thresholds: z7.object({
+    easyUpperBound: z7.number().min(0).max(1),
+    hardLowerBound: z7.number().min(0).max(1)
   }).default(DEFAULT_DIFFICULTY_THRESHOLDS),
   /** Weights for difficulty aggregation */
   weights: DifficultyWeightsSchema.default(DEFAULT_DIFFICULTY_WEIGHTS),
   /** Mapping from difficulty level to model tier */
-  difficultyToTier: z6.record(z6.enum(["easy", "medium", "hard"]), z6.enum(["fast", "balanced", "powerful"])).default(DEFAULT_DIFFICULTY_TO_TIER),
+  difficultyToTier: z7.record(z7.enum(["easy", "medium", "hard"]), z7.enum(["fast", "balanced", "powerful"])).default(DEFAULT_DIFFICULTY_TO_TIER),
   /** Mapping from model tier to CLI preference order */
-  tierToClis: z6.record(
-    z6.enum(["fast", "balanced", "powerful"]),
-    z6.array(z6.enum(["claude", "gemini", "codex", "opencode"]))
+  tierToClis: z7.record(
+    z7.enum(["fast", "balanced", "powerful"]),
+    z7.array(z7.enum(["claude", "gemini", "codex", "opencode"]))
   ).default(DEFAULT_TIER_TO_CLIS),
   /** Enable adaptive calibration from outcomes */
-  enableCalibration: z6.boolean().default(true),
+  enableCalibration: z7.boolean().default(true),
   /** Maximum outcomes to store for calibration */
-  maxCalibrationOutcomes: z6.number().int().positive().default(1e3),
+  maxCalibrationOutcomes: z7.number().int().positive().default(1e3),
   /** Minimum outcomes before applying calibration adjustments */
-  minCalibrationOutcomes: z6.number().int().positive().default(50),
+  minCalibrationOutcomes: z7.number().int().positive().default(50),
   /** Verbose logging */
-  verbose: z6.boolean().default(false)
+  verbose: z7.boolean().default(false)
 });
 var DEFAULT_ZERO_ROUTER_CONFIG = {
   thresholds: DEFAULT_DIFFICULTY_THRESHOLDS,
@@ -5205,16 +5945,16 @@ var ZeroRouter = class {
 };
 
 // src/cli-adapters/latency-tracker-types.ts
-import { z as z7 } from "zod";
-var LatencyTrackerConfigSchema = z7.object({
+import { z as z8 } from "zod";
+var LatencyTrackerConfigSchema = z8.object({
   /** Maximum number of samples to keep per CLI (default: 100) */
-  windowSize: z7.number().int().positive().default(100),
+  windowSize: z8.number().int().positive().default(100),
   /** Time-weighted decay factor (0-1, higher = more weight to recent) (default: 0.95) */
-  decayFactor: z7.number().min(0).max(1).default(0.95),
+  decayFactor: z8.number().min(0).max(1).default(0.95),
   /** Maximum age of samples in milliseconds before forced eviction (default: 3600000 = 1 hour) */
-  maxSampleAgeMs: z7.number().int().positive().default(36e5),
+  maxSampleAgeMs: z8.number().int().positive().default(36e5),
   /** Percentiles to calculate (default: [50, 95, 99]) */
-  percentiles: z7.array(z7.number().min(0).max(100)).default([50, 95, 99])
+  percentiles: z8.array(z8.number().min(0).max(100)).default([50, 95, 99])
 });
 var EMPTY_LATENCY_STATS = {
   count: 0,
@@ -5621,19 +6361,19 @@ function createRoutingMemory(config, mobimem) {
 }
 
 // src/cli-adapters/routing/router-stage.ts
-import { z as z8 } from "zod";
-var StageConfigSchema = z8.object({
-  enabled: z8.boolean().default(true),
-  priority: z8.number().int().min(0).max(100).default(50),
-  options: z8.record(z8.string(), z8.unknown()).optional()
+import { z as z9 } from "zod";
+var StageConfigSchema = z9.object({
+  enabled: z9.boolean().default(true),
+  priority: z9.number().int().min(0).max(100).default(50),
+  options: z9.record(z9.string(), z9.unknown()).optional()
 });
-var RoutingOutcomeSchema = z8.object({
+var RoutingOutcomeSchema = z9.object({
   selectedCli: CliNameSchema,
-  task: z8.string(),
-  success: z8.boolean(),
-  qualityScore: z8.number().min(0).max(1).optional(),
-  latencyMs: z8.number().int().positive().optional(),
-  tokensUsed: z8.number().int().positive().optional()
+  task: z9.string(),
+  success: z9.boolean(),
+  qualityScore: z9.number().min(0).max(1).optional(),
+  latencyMs: z9.number().int().positive().optional(),
+  tokensUsed: z9.number().int().positive().optional()
 });
 function createRoutingContext(task, availableClis = ["claude", "gemini", "codex", "opencode"], metadata) {
   return {
@@ -5830,7 +6570,7 @@ var ConfidenceCascadeStage = class {
 };
 
 // src/config/task-specialization-types.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var TASK_CATEGORIES = [
   "architecture",
   "code_generation",
@@ -5843,8 +6583,8 @@ var TASK_CATEGORIES = [
   "devops",
   "exploration"
 ];
-var TaskCategorySchema = z9.enum(TASK_CATEGORIES);
-var TaskSpecializationSchema = z9.object({
+var TaskCategorySchema = z10.enum(TASK_CATEGORIES);
+var TaskSpecializationSchema = z10.object({
   /** Task category identifier */
   category: TaskCategorySchema,
   /** Primary CLI recommendation */
@@ -5852,11 +6592,11 @@ var TaskSpecializationSchema = z9.object({
   /** Secondary CLI fallback */
   secondaryCli: CliNameSchema,
   /** Why this CLI is preferred for this task type */
-  reasoning: z9.string(),
+  reasoning: z10.string(),
   /** Keywords that trigger this category detection */
-  keywords: z9.array(z9.string()).min(1),
+  keywords: z10.array(z10.string()).min(1),
   /** Bonus score applied when this category matches (0-20) */
-  bonus: z9.number().min(0).max(20)
+  bonus: z10.number().min(0).max(20)
 });
 
 // src/config/task-specialization.ts
@@ -7079,10 +7819,10 @@ function createPersistentDistillerOrFallback(outcomeStore, logger11) {
 }
 
 // src/orchestration/outcomes/outcome-types.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var logger6 = createLogger({ component: "outcome-error-taxonomy" });
-var OutcomeSourceSchema = z10.enum(["delegate", "consensus", "manual"]);
-var OutcomeFailureCategorySchema = z10.enum([
+var OutcomeSourceSchema = z11.enum(["delegate", "consensus", "manual"]);
+var OutcomeFailureCategorySchema = z11.enum([
   "timeout",
   "authentication",
   "rate_limit",
@@ -7095,37 +7835,41 @@ var OutcomeFailureCategorySchema = z10.enum([
   "generic",
   "unknown"
 ]);
-var TaskOutcomeSchema = z10.object({
-  id: z10.string().min(1),
+var TaskOutcomeSchema = z11.object({
+  id: z11.string().min(1),
   cli: CliNameSchema,
   category: TaskCategorySchema,
-  model: z10.string().min(1),
-  success: z10.boolean(),
-  durationMs: z10.number().nonnegative(),
-  timestamp: z10.string().min(1),
-  qualitySignals: z10.array(z10.string()).optional(),
+  model: z11.string().min(1),
+  success: z11.boolean(),
+  durationMs: z11.number().nonnegative(),
+  timestamp: z11.string().min(1),
+  qualitySignals: z11.array(z11.string()).optional(),
   failureCategory: OutcomeFailureCategorySchema.optional(),
-  errorMessage: z10.string().max(500).optional(),
+  errorMessage: z11.string().max(500).optional(),
   source: OutcomeSourceSchema,
   /** Whether this outcome came from a triage-initiated retry (#1506). */
-  wasRetried: z10.boolean().optional(),
+  wasRetried: z11.boolean().optional(),
   /** Triage action taken on the failure (#1506). */
-  triageAction: z10.string().max(30).optional(),
+  triageAction: z11.string().max(30).optional(),
   /** Routing stage that selected this CLI (#1785). */
-  routingStage: z10.string().max(50).optional(),
+  routingStage: z11.string().max(50).optional(),
   /** Number of retry attempts before this outcome (#1785). */
-  retryCount: z10.number().int().nonnegative().optional()
+  retryCount: z11.number().int().nonnegative().optional(),
+  /** Vendor resolved from `model` via ModelRegistry at write time (#2548). */
+  vendor: z11.string().min(1).max(40).optional(),
+  /** Family resolved from `model` via ModelRegistry at write time (#2548). */
+  family: z11.string().min(1).max(80).optional()
 });
-var OutcomeQuerySchema = z10.object({
+var OutcomeQuerySchema = z11.object({
   cli: CliNameSchema.optional(),
   category: TaskCategorySchema.optional(),
   source: OutcomeSourceSchema.optional(),
-  success: z10.boolean().optional(),
+  success: z11.boolean().optional(),
   failureCategory: OutcomeFailureCategorySchema.optional(),
-  since: z10.string().optional(),
-  limit: z10.number().int().positive().optional(),
+  since: z11.string().optional(),
+  limit: z11.number().int().positive().optional(),
   /** Exclude outcomes with any of these quality signals (#1680). */
-  excludeQualitySignals: z10.array(z10.string()).optional()
+  excludeQualitySignals: z11.array(z11.string()).optional()
 });
 var TIMEOUT_PATTERNS = ["timeout", "timed out", "deadline exceeded", "socket hang up", "aborted"];
 var AUTH_PATTERNS = [
@@ -7320,6 +8064,7 @@ function categorizeOutcomeErrorMessage(msg) {
 
 // src/orchestration/outcomes/outcome-store.ts
 var DEFAULT_MAX_ENTRIES = 1e4;
+var DEFAULT_FAMILY_FALLBACK_THRESHOLD = 5;
 function autoClassify(outcome) {
   if (outcome.success || outcome.failureCategory !== void 0) return outcome;
   if (typeof outcome.errorMessage === "string" && outcome.errorMessage.length > 0) {
@@ -7333,20 +8078,73 @@ function hasErrorMessage(o) {
 var OutcomeStore = class {
   entries = [];
   maxEntries;
+  registry;
   constructor(config) {
     this.maxEntries = config?.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    this.registry = config?.registry ?? getDefaultRegistry();
   }
-  /** Append a new outcome. Auto-classifies failures missing failureCategory (#1441). */
+  /**
+   * Append a new outcome. Auto-classifies failures missing failureCategory
+   * (#1441) and resolves the outcome's `vendor` / `family` via the
+   * ModelRegistry (#2548) so family-level retrieval can warm-start
+   * siblings after a model retirement.
+   */
   append(outcome) {
-    this.entries.push(autoClassify(outcome));
+    this.entries.push(this.enrich(autoClassify(outcome)));
     this.enforceLimit();
   }
+  /**
+   * Attach `vendor` and `family` to the outcome if they're not already
+   * set. Idempotent — pre-enriched outcomes pass through unchanged.
+   */
+  enrich(outcome) {
+    if (outcome.vendor !== void 0 && outcome.family !== void 0) return outcome;
+    const entry = this.registry.getEntry(outcome.model);
+    return {
+      ...outcome,
+      vendor: outcome.vendor ?? entry.vendor,
+      family: outcome.family ?? entry.family
+    };
+  }
   /** Query outcomes with optional filters. */
   query(filter) {
     if (filter === void 0) return [...this.entries];
     const filtered = applyFilters(this.entries, filter);
     return filter.limit !== void 0 ? filtered.slice(-filter.limit) : filtered;
   }
+  /**
+   * Query outcomes for a specific model with a family-level warm-start
+   * fallback (#2548). When the literal `modelId` has fewer than
+   * `threshold` samples in the store, broaden the result to the model's
+   * `{vendor, family}` siblings — siblings within a family share enough
+   * behavior profile that their outcomes are useful priors for cold
+   * starts after a retirement.
+   *
+   * Returns the outcomes and a `scope` flag so callers know whether
+   * they're consuming literal-id data or family-broadened data.
+   */
+  queryByModelWithFamilyFallback(modelId, options) {
+    const threshold = options?.threshold ?? DEFAULT_FAMILY_FALLBACK_THRESHOLD;
+    const base = options?.extraFilter ?? {};
+    const literal = applyFilters(this.entries, base).filter((o) => o.model === modelId);
+    if (literal.length >= threshold) {
+      const entry2 = this.registry.getEntry(modelId);
+      return { outcomes: literal, scope: "literal", vendor: entry2.vendor, family: entry2.family };
+    }
+    const entry = this.registry.getEntry(modelId);
+    const family = applyFilters(this.entries, base).filter(
+      (o) => (
+        // Cross-vendor transfer is out of scope (#2548) — vendor must match.
+        // Family must match too: an Anthropic claude-opus outcome shouldn't
+        // warm-start an Anthropic claude-haiku query.
+        o.vendor === entry.vendor && o.family === entry.family
+      )
+    );
+    if (family.length === 0) {
+      return { outcomes: literal, scope: "empty", vendor: entry.vendor, family: entry.family };
+    }
+    return { outcomes: family, scope: "family", vendor: entry.vendor, family: entry.family };
+  }
   /** Aggregate outcomes into a performance summary. */
   summarize(filter) {
     const outcomes = this.query(filter);
@@ -7690,52 +8488,52 @@ function runWarmUp(logger11) {
 }
 
 // src/cli-adapters/composite-router-types.ts
-import { z as z11 } from "zod";
-var CompositeRouterConfigSchema = z11.object({
+import { z as z12 } from "zod";
+var CompositeRouterConfigSchema = z12.object({
   /** Enable confidence cascade stage (default: false) (Issue #755, ADR-0005) */
-  enableConfidenceCascade: z11.boolean().default(false),
+  enableConfidenceCascade: z12.boolean().default(false),
   /** Enable budget filtering stage (default: true) */
-  enableBudgetFilter: z11.boolean().default(true),
+  enableBudgetFilter: z12.boolean().default(true),
   /** Enable capability match stage (default: false) (Issue #755, ADR-0005) */
-  enableCapabilityMatch: z11.boolean().default(false),
+  enableCapabilityMatch: z12.boolean().default(false),
   /** Enable ZeroRouter difficulty-based routing stage (default: true) (Issue #473) */
-  enableZeroRouter: z11.boolean().default(true),
+  enableZeroRouter: z12.boolean().default(true),
   /** Enable preference-trained routing stage (default: false) */
-  enablePreferenceRouting: z11.boolean().default(false),
+  enablePreferenceRouting: z12.boolean().default(false),
   /** Enable TOPSIS ranking stage (default: true) */
-  enableTopsisRanking: z11.boolean().default(true),
+  enableTopsisRanking: z12.boolean().default(true),
   /** Enable LinUCB selection stage (default: true) */
-  enableLinUCBSelection: z11.boolean().default(true),
+  enableLinUCBSelection: z12.boolean().default(true),
   /** Enable quality constraint stage (default: false) (Issue #755, ADR-0005) */
-  enableQualityConstraint: z11.boolean().default(false),
+  enableQualityConstraint: z12.boolean().default(false),
   /** Enable resource strategy stage for budget-aware oscillation (default: true) (Issue #998) */
-  enableResourceStrategy: z11.boolean().default(true),
+  enableResourceStrategy: z12.boolean().default(true),
   /** Enable strategy distillation for learned routing rules (default: false) (Issue #999) */
-  enableStrategyDistillation: z11.boolean().default(false),
+  enableStrategyDistillation: z12.boolean().default(false),
   /** Enable latency tracking for routing decisions (default: true) (Issue #361) */
-  enableLatencyTracking: z11.boolean().default(true),
+  enableLatencyTracking: z12.boolean().default(true),
   /** Enable routing memory for learned routing (default: false) (Issue #463, #461) */
-  enableRoutingMemory: z11.boolean().default(false),
+  enableRoutingMemory: z12.boolean().default(false),
   /** Enable KNN experience-based routing (default: false) (arXiv:2507.05370) */
-  enableKnnRouting: z11.boolean().default(false),
+  enableKnnRouting: z12.boolean().default(false),
   /** Weight for latency score in final routing (0-1, default: 0.2) */
-  latencyScoreWeight: z11.number().min(0).max(1).default(0.2),
+  latencyScoreWeight: z12.number().min(0).max(1).default(0.2),
   /** Budget constraints (optional) */
-  budgetConstraints: z11.object({
-    maxTokens: z11.number().positive(),
-    maxCostUsd: z11.number().positive(),
-    maxLatencyMs: z11.number().positive()
+  budgetConstraints: z12.object({
+    maxTokens: z12.number().positive(),
+    maxCostUsd: z12.number().positive(),
+    maxLatencyMs: z12.number().positive()
   }).partial().optional(),
   /** LinUCB exploration parameter (default: 1.0) */
-  linucbAlpha: z11.number().positive().default(1),
+  linucbAlpha: z12.number().positive().default(1),
   /** Billing mode: 'plan' zeroes cost weight, 'api' preserves current behavior (default: 'plan') */
-  billingMode: z11.enum(["plan", "api"]).default("plan"),
+  billingMode: z12.enum(["plan", "api"]).default("plan"),
   /** Enable capacity-aware load balancing (deprioritize exhausted CLIs) (default: true) (Issue #807) */
-  enableCapacityBalancing: z11.boolean().default(true),
+  enableCapacityBalancing: z12.boolean().default(true),
   /** Maximum routing decision time in ms (default: 50) */
-  maxDecisionTimeMs: z11.number().positive().default(50),
+  maxDecisionTimeMs: z12.number().positive().default(50),
   /** Minimum preference data points before using learned routing (default: 10) */
-  preferenceMinDataPoints: z11.number().int().positive().default(10)
+  preferenceMinDataPoints: z12.number().int().positive().default(10)
 });
 var DEFAULT_COMPOSITE_CONFIG = {
   enableConfidenceCascade: false,
@@ -8019,12 +8817,12 @@ async function fetchCapacityData(adapters) {
 }
 
 // src/mcp/tools/weather-report-types.ts
-import { z as z12 } from "zod";
-var WeatherReportInputSchema = z12.object({
+import { z as z13 } from "zod";
+var WeatherReportInputSchema = z13.object({
   /** Filter by CLI name. */
-  cli: z12.enum(CLI_NAMES).optional().describe("Filter by CLI"),
+  cli: z13.enum(CLI_NAMES).optional().describe("Filter by CLI"),
   /** Filter by task category. */
-  category: z12.enum([
+  category: z13.enum([
     "architecture",
     "code_generation",
     "code_review",
@@ -8037,22 +8835,22 @@ var WeatherReportInputSchema = z12.object({
     "exploration"
   ]).optional().describe("Filter by task category"),
   /** Include adaptive routing bonus data. */
-  includeAdaptive: z12.boolean().optional().default(true).describe("Include adaptive routing bonuses (default: true)")
+  includeAdaptive: z13.boolean().optional().default(true).describe("Include adaptive routing bonuses (default: true)")
 });
 var DEFAULT_OUTCOME_LOOKBACK_MS = 7 * 24 * 60 * 60 * 1e3;
-var WeatherReportConfigSchema = z12.object({
+var WeatherReportConfigSchema = z13.object({
   /** Minimum observations before adjusting bonuses (lowered for faster activation). */
-  coldStartThreshold: z12.number().int().min(1).max(1e3).default(3),
+  coldStartThreshold: z13.number().int().min(1).max(1e3).default(3),
   /** Exploration rate: fraction of random routing (0.0-1.0). */
-  explorationRate: z12.number().min(0).max(1).default(0.1),
+  explorationRate: z13.number().min(0).max(1).default(0.1),
   /** Max adaptive bonus adjustment (+/-). */
-  maxBonusAdjustment: z12.number().min(0).max(20).default(10),
+  maxBonusAdjustment: z13.number().min(0).max(20).default(10),
   /**
    * Lookback window for outcome queries (ms). Only outcomes within this
    * window are used for adaptive bonuses. Falls back to all history if
    * the window has fewer samples than coldStartThreshold. Default: 7 days.
    */
-  outcomeLookbackMs: z12.number().int().min(0).default(DEFAULT_OUTCOME_LOOKBACK_MS)
+  outcomeLookbackMs: z13.number().int().min(0).default(DEFAULT_OUTCOME_LOOKBACK_MS)
 });
 function createDefaultWeatherConfig() {
   return WeatherReportConfigSchema.parse({});
@@ -8437,47 +9235,47 @@ function createMetricsMiddleware() {
 import { randomBytes as randomBytes3 } from "crypto";
 
 // src/config/defaults-types.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 function isKnownCliName(cli) {
   return cli === "claude" || cli === "gemini" || cli === "codex" || cli === "opencode" || cli === "default";
 }
-var positiveInt = z13.number().int().positive();
-var nonNegativeInt = z13.number().int().nonnegative();
-var durationMs = z13.number().int().positive().describe("Duration in milliseconds");
-var TimeoutProfileSchema = z13.object({
+var positiveInt = z14.number().int().positive();
+var nonNegativeInt = z14.number().int().nonnegative();
+var durationMs = z14.number().int().positive().describe("Duration in milliseconds");
+var TimeoutProfileSchema = z14.object({
   simple: durationMs.describe("Timeout for simple tasks"),
   standard: durationMs.describe("Timeout for standard tasks"),
   complex: durationMs.describe("Timeout for complex tasks")
 });
-var RetryDefaultsSchema = z13.object({
+var RetryDefaultsSchema = z14.object({
   maxRetries: nonNegativeInt.max(10).describe("Maximum retry attempts"),
   baseDelayMs: durationMs.describe("Base delay between retries"),
   maxDelayMs: durationMs.describe("Maximum delay between retries"),
-  jitterFactor: z13.number().min(0).max(1).describe("Jitter factor (0-1)")
+  jitterFactor: z14.number().min(0).max(1).describe("Jitter factor (0-1)")
 });
-var RateLimitDefaultsSchema = z13.object({
+var RateLimitDefaultsSchema = z14.object({
   requestsPerMinute: positiveInt.max(1e3).describe("Max requests per minute"),
-  enabled: z13.boolean().describe("Whether rate limiting is enabled"),
+  enabled: z14.boolean().describe("Whether rate limiting is enabled"),
   maxConcurrent: positiveInt.max(100).describe("Max concurrent requests"),
   capacity: positiveInt.describe("Token bucket capacity"),
   refillRate: positiveInt.describe("Token refill rate"),
   refillIntervalMs: durationMs.describe("Token refill interval")
 });
-var CircuitBreakerDefaultsSchema = z13.object({
-  failureThreshold: z13.number().int().min(1).max(100).describe("Failures before opening"),
+var CircuitBreakerDefaultsSchema = z14.object({
+  failureThreshold: z14.number().int().min(1).max(100).describe("Failures before opening"),
   resetTimeoutMs: durationMs.describe("Time before attempting reset"),
-  halfOpenSuccessThreshold: z13.number().int().min(1).max(10).describe("Successes to close"),
-  countTimeoutsAsFailures: z13.boolean().describe("Count timeouts as failures"),
-  countAuthFailuresAsFailures: z13.boolean().describe("Count auth failures as failures"),
-  countRateLimitsAsFailures: z13.boolean().describe("Count rate limit errors as failures"),
+  halfOpenSuccessThreshold: z14.number().int().min(1).max(10).describe("Successes to close"),
+  countTimeoutsAsFailures: z14.boolean().describe("Count timeouts as failures"),
+  countAuthFailuresAsFailures: z14.boolean().describe("Count auth failures as failures"),
+  countRateLimitsAsFailures: z14.boolean().describe("Count rate limit errors as failures"),
   halfOpenMaxRequests: positiveInt.describe("Max requests in half-open state")
 });
-var ToolRateLimitConfigSchema = z13.object({
+var ToolRateLimitConfigSchema = z14.object({
   capacity: positiveInt.describe("Token bucket capacity"),
   refillRate: positiveInt.describe("Token refill rate"),
   refillIntervalMs: durationMs.describe("Token refill interval")
 });
-var WorkerDefaultsSchema = z13.object({
+var WorkerDefaultsSchema = z14.object({
   maxWorkers: positiveInt.max(32).describe("Maximum worker threads"),
   poolSize: positiveInt.max(32).describe("Worker pool size"),
   idleTimeoutMs: durationMs.describe("Worker idle timeout"),
@@ -8487,7 +9285,7 @@ var WorkerDefaultsSchema = z13.object({
   eventBusMaxHistory: nonNegativeInt.max(1e4).describe("Event bus history limit"),
   swarmObserverMaxEvents: nonNegativeInt.max(1e4).describe("Swarm observer event limit")
 });
-var TimeoutDefaultsSchema = z13.object({
+var TimeoutDefaultsSchema = z14.object({
   cliMs: durationMs.describe("Default CLI timeout"),
   cliSimpleMs: durationMs.describe("Simple CLI task timeout"),
   cliComplexMs: durationMs.describe("Complex CLI task timeout"),
@@ -8522,7 +9320,15 @@ var VOTE_TIMEOUTS = {
   /** Maximum allowed vote timeout (cap for env override). */
   maxMs: 6e5,
   /** Default max retries per agent. */
-  maxRetries: 2
+  maxRetries: 2,
+  /**
+   * Slack buffer added to the overall wall-clock deadline in
+   * `computeOverallConsensusDeadlineMs` (#1871). Acts as a safety net
+   * above per-vote × (retries+1) + stagger. Centralized so the formula
+   * can be tuned in one place.
+   * (Issue #2636 — was hardcoded `60_000` in voter-agents.ts:93)
+   */
+  overallDeadlineBufferMs: 6e4
 };
 var MCP_TIMEOUTS = {
   /** Default timeout for MCP tool handlers. */
@@ -8619,7 +9425,26 @@ var INTERNAL_TIMEOUTS = {
   /** Wave scheduler per-task timeout. */
   waveTaskMs: 6e4,
   /** Puppeteer orchestration timeout. */
-  puppeteerMs: 3e5
+  puppeteerMs: 3e5,
+  /**
+   * Initial cooldown before a disabled worker role can attempt recovery
+   * (Issue #1458). Used by `worker-dispatcher.ts` circuit-breaker logic.
+   * (Issue #2636 — re-homed from worker-dispatcher.ts:57)
+   */
+  workerRecoveryCooldownMs: 3e4,
+  /**
+   * Maximum cooldown after exponential backoff (Issue #1458). Caps the
+   * worker-dispatcher circuit-breaker backoff so a permanently-broken
+   * role doesn't hold the slot indefinitely.
+   * (Issue #2636 — re-homed from worker-dispatcher.ts:60)
+   */
+  workerMaxCooldownMs: 3e5,
+  /**
+   * Minimum spacing between requests to rate-limited worker roles
+   * (Issue #1458).
+   * (Issue #2636 — re-homed from worker-dispatcher.ts:63)
+   */
+  workerRateLimitSpacingMs: 2e3
 };
 var EXPERT_TIMEOUTS = {
   /** Complex reasoning tasks: architecture, security_review, planning. */
@@ -8630,6 +9455,14 @@ var EXPERT_TIMEOUTS = {
   minMs: 3e4,
   /** Maximum allowed expert timeout. */
   maxMs: 9e5,
+  /**
+   * Stricter floor for `execute_expert` specifically — LLM inference takes
+   * 20-90s minimum (#1163, #1330), so this caller-facing floor prevents
+   * configuring a timeout that's guaranteed to fail. The global `minMs`
+   * (30s) remains the absolute floor for non-execute paths.
+   * (Issue #2636 — was hardcoded `EXPERT_TIMEOUT_FLOOR_MS = 120_000` in execute-expert.ts:68)
+   */
+  executeFloorMs: 12e4,
   /** Categories considered complex (longer timeout).
    * Updated: Issue #1675 — devops (avg 54s) and documentation (avg 64s on gemini)
    * regularly exceed the 120s standard CLI timeout. */
@@ -9393,9 +10226,9 @@ function convertBonusesToScoreMap(bonuses, taskCategory) {
 }
 
 // src/cli-adapters/fallback-chains.ts
-import { z as z14 } from "zod";
-var FallbackChainSchema = z14.array(z14.enum(["claude", "gemini", "codex", "opencode"])).min(1).readonly();
-var FallbackChainRegistrySchema = z14.object({
+import { z as z15 } from "zod";
+var FallbackChainSchema = z15.array(z15.enum(["claude", "gemini", "codex", "opencode"])).min(1).readonly();
+var FallbackChainRegistrySchema = z15.object({
   code: FallbackChainSchema,
   research: FallbackChainSchema,
   documentation: FallbackChainSchema,
@@ -10113,6 +10946,12 @@ var CompositeRouter = class _CompositeRouter {
   /** Strategy distiller instance (Issue #999) */
   strategyDistiller;
   cliNames;
+  /**
+   * (#2540 PR 7) Optional harness-driven availability gate. When set,
+   * `executeRouting` filters the candidate CLI list to only those with
+   * ≥1 routable model per the cache. See `getCandidateCliNames`.
+   */
+  availableModelsCache;
   // Statistics tracking
   totalDecisions = 0;
   decisionsPerCli = {
@@ -10140,6 +10979,7 @@ var CompositeRouter = class _CompositeRouter {
       distilledRuleStageConfig,
       metricsCollector,
       orchestrationObserver,
+      availableModelsCache,
       ...baseConfig
     } = config ?? {};
     this.config = CompositeRouterConfigSchema.parse(baseConfig);
@@ -10153,6 +10993,10 @@ var CompositeRouter = class _CompositeRouter {
       this.orchestrationObserver = orchestrationObserver;
       this.logger.debug("OrchestrationObserver wired to CompositeRouter");
     }
+    if (availableModelsCache !== void 0) {
+      this.availableModelsCache = availableModelsCache;
+      this.logger.debug("AvailableModelsCache wired to CompositeRouter");
+    }
     this.initializeCoreRouters(
       adapters,
       preferenceRouterConfig,
@@ -10379,11 +11223,12 @@ var CompositeRouter = class _CompositeRouter {
     try {
       const taskProfile = analyzeTaskProfile(task, stagesExecuted);
       const deps = this.getStageDependencies();
+      const candidateCliNames = await this.getCandidateCliNames();
       const pipelineResult = await runPipeline(
         task,
         taskProfile,
         stagesExecuted,
-        this.cliNames,
+        candidateCliNames,
         deps
       );
       if (!pipelineResult.ok) {
@@ -10401,6 +11246,37 @@ var CompositeRouter = class _CompositeRouter {
       return this.handleRoutingError(error, stagesExecuted);
     }
   }
+  /**
+   * (#2540 PR 7) Returns the CLI candidate set for the routing pipeline,
+   * filtered by harness-driven availability when the cache is wired.
+   *
+   * Filtering rules:
+   *   - No cache configured → return all registered CLI names (prior behaviour).
+   *   - Cache configured → query getAll(); a CLI is excluded only if the
+   *     cache reports zero models for it. If the cache returns an empty union
+   *     (cold start, all sources failing), fall back to all registered CLIs
+   *     so the router never wedges on a transient cache miss.
+   *   - Errors in the cache do not block routing — log and fall through.
+   */
+  async getCandidateCliNames() {
+    if (this.availableModelsCache === void 0) return this.cliNames;
+    try {
+      const all = await this.availableModelsCache.getAll();
+      if (all.length === 0) return this.cliNames;
+      const sourcesWithModels = new Set(all.map((m) => m.source));
+      const filtered = this.cliNames.filter((name) => sourcesWithModels.has(name));
+      return filtered.length > 0 ? filtered : this.cliNames;
+    } catch (e) {
+      this.logger.warn("AvailableModelsCache query failed; falling back to all CLIs", {
+        error: e instanceof Error ? e.message : String(e)
+      });
+      return this.cliNames;
+    }
+  }
+  /** (#2540 PR 7) Public accessor for the wired cache (or undefined). */
+  getAvailableModelsCache() {
+    return this.availableModelsCache;
+  }
   getStageDependencies() {
     return {
       config: this.config,
@@ -11068,6 +11944,11 @@ export {
   RateLimitError,
   toError,
   getErrorMessage,
+  DEFAULT_MODEL_PER_CLI,
+  DEFAULT_ENTRY,
+  deriveEntry,
+  resolveModelIdentity,
+  resolveModelIdentitySync,
   OUTPUT_MODALITIES,
   INPUT_MODALITIES,
   TOOL_CAPABILITIES,
@@ -11076,14 +11957,23 @@ export {
   CliNameSchema,
   DEFAULT_CLI,
   ModelCapabilitySchema,
-  DEFAULT_MODEL_CAPABILITIES,
-  DEFAULT_MODEL_PER_CLI,
-  getModelCapabilities,
+  ModelRegistry,
+  getDefaultRegistry,
+  setDefaultRegistry,
+  getModelContextWindow,
+  getDefaultModelForCli,
+  getCliModelName,
+  resolveCliAlias,
+  buildCapabilityProfiles,
+  findCanonicalModel,
+  buildModelInfo,
+  getInTreeCapabilitiesMatrix,
+  lookupInTreeCapability,
+  findInTreeByCli,
   findModelsByOutputModality,
   findModelsByInputModality,
   findModelsByToolCapability,
   findModelsByFeature,
-  findModelsByCli,
   modelSupportsAll,
   calculateCost,
   colors,
@@ -11113,13 +12003,6 @@ export {
   getRandomProvider,
   getTokenEstimator,
   estimateTokens,
-  getModelContextWindow,
-  getDefaultModelForCli,
-  getCliModelName,
-  resolveCliAlias,
-  buildCapabilityProfiles,
-  findCanonicalModel,
-  buildModelInfo,
   CLI_VERSION_REQUIREMENTS,
   DEFAULT_CAPABILITIES,
   RoutingMemoryError,
@@ -11190,6 +12073,7 @@ export {
   API_TIMEOUTS,
   WORKER_TIMEOUTS,
   INTERNAL_TIMEOUTS,
+  EXPERT_TIMEOUTS,
   HEARTBEAT_TIMEOUTS,
   TIMEOUT_GUARD,
   REFLECTIVE_TIMEOUTS,
@@ -11216,4 +12100,4 @@ export {
   ParseError,
   OrchestratorError
 };
-//# sourceMappingURL=chunk-O4KUCF5S.js.map
+//# sourceMappingURL=chunk-Q3RFPJYK.js.map