@warmdrift/kgauto-compiler 2.0.0-alpha.10

package/dist/profiles.d.mts

@@ -0,0 +1,2 @@
+export { g as ALIASES, h as CacheStrategy, k as CliffRule, L as LoweringSpec, M as ModelProfile, q as RecoveryRule, S as StructuredOutputCapability, r as SystemPromptMode, t as allProfiles, u as getProfile, v as profilesByProvider, w as tryGetProfile } from './profiles-DO6R9moS.mjs';
+import './dialect.mjs';

package/dist/profiles.d.ts

@@ -0,0 +1,2 @@
+export { g as ALIASES, h as CacheStrategy, k as CliffRule, L as LoweringSpec, M as ModelProfile, q as RecoveryRule, S as StructuredOutputCapability, r as SystemPromptMode, t as allProfiles, u as getProfile, v as profilesByProvider, w as tryGetProfile } from './profiles-Bgri1pe7.js';
+import './dialect.js';

package/dist/profiles.js

@@ -0,0 +1,685 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/profiles.ts
+var profiles_exports = {};
+__export(profiles_exports, {
+  ALIASES: () => ALIASES,
+  allProfiles: () => allProfiles,
+  getProfile: () => getProfile,
+  profilesByProvider: () => profilesByProvider,
+  tryGetProfile: () => tryGetProfile
+});
+module.exports = __toCommonJS(profiles_exports);
+var ANTHROPIC_LOWERING_BASE = {
+  system: { mode: "inline" },
+  cache: {
+    strategy: "cache_control",
+    minTokens: 1024,
+    discount: 0.1,
+    ttlSeconds: 300
+  },
+  tools: { format: "anthropic" }
+};
+var GOOGLE_LOWERING_BASE = {
+  system: { mode: "separate", field: "systemInstruction" },
+  cache: {
+    strategy: "cachedContent",
+    minTokens: 4096,
+    discount: 0.25,
+    ttlSeconds: 3600
+  },
+  tools: { format: "google" }
+};
+var PROFILES_RAW = [
+  // ── Anthropic ──
+  {
+    id: "claude-opus-4-7",
+    verifiedAgainstDocs: "2026-05-08",
+    provider: "anthropic",
+    status: "current",
+    maxContextTokens: 1e6,
+    maxOutputTokens: 128e3,
+    maxTools: 64,
+    parallelToolCalls: true,
+    structuredOutput: "grammar",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [],
+    costInputPer1m: 5,
+    costOutputPer1m: 25,
+    lowering: ANTHROPIC_LOWERING_BASE,
+    recovery: [
+      {
+        signal: "rate_limit",
+        action: "escalate",
+        reason: "429 from Anthropic \u2014 escalate to fallback chain"
+      },
+      {
+        signal: "model_not_found",
+        action: "escalate",
+        reason: "Model deprecated/renamed \u2014 escalate (L-061)"
+      }
+    ],
+    strengths: ["reasoning", "agentic_coding", "long_context", "reliable_tool_use", "structured_output"],
+    weaknesses: ["cost", "latency"],
+    notes: "Frontier (2026-05). Step-change improvement over 4.6 in agentic coding. Adaptive thinking only \u2014 no extended-thinking toggle. 1M context, 128k max output.",
+    // Frontier perf. Drops on archetypes where parallel-tool throughput
+    // (hunt) or low-budget cost-sensitivity (classify/summarize) matters
+    // more than reasoning depth.
+    archetypePerf: {
+      critique: 10,
+      plan: 10,
+      generate: 9,
+      ask: 9,
+      extract: 9,
+      transform: 9,
+      hunt: 8,
+      // strong but Flash dominates parallel tool throughput
+      summarize: 8,
+      // overkill for tolerant archetype; cost-out of frontier
+      classify: 8
+      // overkill; brain-validated cheaper models cover this
+    }
+  },
+  {
+    id: "claude-opus-4-6",
+    verifiedAgainstDocs: "2026-05-08",
+    provider: "anthropic",
+    status: "legacy",
+    maxContextTokens: 1e6,
+    maxOutputTokens: 128e3,
+    maxTools: 64,
+    parallelToolCalls: true,
+    structuredOutput: "grammar",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [],
+    costInputPer1m: 5,
+    costOutputPer1m: 25,
+    lowering: ANTHROPIC_LOWERING_BASE,
+    recovery: [
+      {
+        signal: "rate_limit",
+        action: "escalate",
+        reason: "429 from Anthropic \u2014 escalate to fallback chain"
+      },
+      {
+        signal: "model_not_found",
+        action: "escalate",
+        reason: "Model deprecated/renamed \u2014 escalate (L-061)"
+      }
+    ],
+    strengths: ["reasoning", "long_context", "reliable_tool_use", "structured_output", "extended_thinking"],
+    weaknesses: ["cost", "latency"],
+    notes: "Predecessor to 4.7. Still current in Anthropic legacy table. Same pricing as 4.7 \u2014 choose 4.7 unless you need extended-thinking budget control (4.7 is adaptive-only).",
+    // One notch below 4.7 across the board — extended-thinking edge does
+    // not flip any archetype ranking. Legacy: chains should prefer 4.7.
+    archetypePerf: {
+      critique: 9,
+      plan: 9,
+      generate: 9,
+      ask: 9,
+      extract: 9,
+      transform: 9,
+      hunt: 7,
+      summarize: 8,
+      classify: 8
+    }
+  },
+  {
+    id: "claude-sonnet-4-6",
+    verifiedAgainstDocs: "2026-05-08",
+    provider: "anthropic",
+    status: "current",
+    maxContextTokens: 1e6,
+    maxOutputTokens: 64e3,
+    maxTools: 64,
+    parallelToolCalls: true,
+    structuredOutput: "grammar",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [],
+    costInputPer1m: 3,
+    costOutputPer1m: 15,
+    lowering: ANTHROPIC_LOWERING_BASE,
+    recovery: [
+      { signal: "rate_limit", action: "escalate", reason: "429 \u2014 escalate" },
+      { signal: "model_not_found", action: "escalate", reason: "Deprecated \u2014 escalate (L-061)" }
+    ],
+    strengths: ["quality", "tool_use", "long_context", "cache_friendly", "extended_thinking"],
+    weaknesses: [],
+    notes: "Workhorse. Best price/quality for most multi-turn agentic work. 1M context, 64k max output.",
+    // Master plan §6.2 anchor. Tier 0 for plan/generate/ask/extract/transform
+    // in starter chains; tier 1 cross-provider for hunt/summarize/classify.
+    archetypePerf: {
+      ask: 9,
+      generate: 9,
+      plan: 9,
+      critique: 9,
+      extract: 9,
+      transform: 9,
+      hunt: 7,
+      // strong but Flash beats on parallel tool throughput
+      summarize: 8,
+      // overkill for tolerant archetype
+      classify: 8
+      // overkill
+    }
+  },
+  {
+    id: "claude-haiku-4-5",
+    verifiedAgainstDocs: "2026-05-08",
+    provider: "anthropic",
+    status: "current",
+    maxContextTokens: 2e5,
+    maxOutputTokens: 64e3,
+    maxTools: 32,
+    parallelToolCalls: true,
+    structuredOutput: "grammar",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "tool_count",
+        threshold: 16,
+        action: "drop_to_top_relevant",
+        reason: "Haiku reliability degrades above ~16 tools"
+      }
+    ],
+    costInputPer1m: 1,
+    costOutputPer1m: 5,
+    lowering: ANTHROPIC_LOWERING_BASE,
+    recovery: [
+      { signal: "rate_limit", action: "escalate", reason: "429 \u2014 escalate to Sonnet" }
+    ],
+    strengths: ["speed", "cost", "classification", "cache_friendly", "extended_thinking"],
+    weaknesses: ["complex_reasoning", "large_tool_sets"],
+    notes: "Cheapest Anthropic. Great for classify, summarize, ask shapes. 200k context, 64k max output. API alias `claude-haiku-4-5` resolves to dated snapshot `claude-haiku-4-5-20251001`.",
+    // Tier 1 cross-provider anchor for short-output chains (classify/
+    // summarize/extract/transform). Falls off on plan/critique where
+    // reasoning depth matters; competes with Pro on cost+latency.
+    archetypePerf: {
+      classify: 8,
+      summarize: 8,
+      ask: 7,
+      transform: 7,
+      extract: 7,
+      hunt: 6,
+      // tool reliability drops at 16 — cliff guard fires
+      generate: 6,
+      plan: 5,
+      critique: 4
+      // reasoning depth gap vs Sonnet/Opus
+    }
+  },
+  // ── Google ──
+  {
+    id: "gemini-2.5-flash",
+    verifiedAgainstDocs: "2026-05-08",
+    provider: "google",
+    status: "current",
+    maxContextTokens: 1048576,
+    maxOutputTokens: 65535,
+    maxTools: 128,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "separate",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "input_tokens",
+        threshold: 8e3,
+        action: "downgrade_quality_warning",
+        reason: "Quality degrades significantly above ~8K context tokens"
+      },
+      {
+        metric: "tool_count",
+        threshold: 20,
+        action: "drop_to_top_relevant",
+        reason: "Tool reliability drops above ~20 tools (despite 128 hard limit)"
+      },
+      {
+        metric: "thinking_with_short_output",
+        threshold: 1,
+        action: "force_thinking_budget_zero",
+        reason: "Thinking tokens consume maxOutputTokens \u2014 empty response if drained"
+      },
+      {
+        // s11 trust artifact (2026-05-02): brain showed 5/5 empty rate on
+        // tt-intelligence/summarize/gemini-2.5-flash with tools offered.
+        // v1's disable_thinking_for_short_output already fired and didn't
+        // help — disabling thinking is necessary but not sufficient. Tools
+        // present + summarize intent confuses Flash into a no-output state
+        // (likely tool-decision purgatory). Strip tools entirely for this
+        // archetype on this model.
+        metric: "tool_count",
+        threshold: 1,
+        whenIntent: "summarize",
+        action: "strip_tools",
+        reason: "Gemini Flash returns empty when summarize intent has tools offered (5/5 empty rate observed in v1 prod 2026-04-19, replayed into v2 brain 2026-04-29)"
+      }
+    ],
+    costInputPer1m: 0.3,
+    costOutputPer1m: 2.5,
+    lowering: {
+      ...GOOGLE_LOWERING_BASE,
+      thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
+    },
+    recovery: [
+      {
+        signal: "empty_response_after_tool",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Known: empty after tool result \u2014 retry with thinking off"
+      },
+      {
+        signal: "empty_response",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Empty response \u2014 try with thinking off"
+      },
+      {
+        signal: "malformed_function_call",
+        action: "escalate",
+        reason: "MALFORMED_FUNCTION_CALL maps to stop \u2014 escalate to next target"
+      }
+    ],
+    strengths: ["speed", "volume", "classification", "1m_context", "cost"],
+    weaknesses: ["complex_schemas", "large_tool_sets", "high_context_quality"],
+    notes: "Fast and cheap with 1M context. Quality cliffs at 8K context and 20 tools \u2014 guard with cliffs.",
+    // Master plan §6.2 anchor. Tier 0 for hunt (parallel tool throughput
+    // 15-75 calls/step beats Sonnet — L-040), summarize, classify.
+    archetypePerf: {
+      hunt: 9,
+      // L-040: parallel tool throughput 15-75/step
+      classify: 7,
+      // brain-validated, 218 rows
+      summarize: 7,
+      // brain-validated; cliff strips tools when present
+      transform: 7,
+      ask: 7,
+      generate: 6,
+      plan: 5,
+      extract: 6,
+      // alpha.8 MAX_TOKENS history on structured output
+      critique: 4
+      // reasoning shallower than Sonnet/Opus
+    }
+  },
+  {
+    // ── Gemini 2.5 Flash-Lite ──
+    // Onboarded 2026-05-13 (s22) after the model-release watcher surfaced
+    // it as a UNREGISTERED + NEW candidate. Released by Google July 2025,
+    // stable. Positioned BELOW Flash on the cost/perf frontier:
+    //   input  $0.10/M (Flash $0.30/M)   — 3× cheaper
+    //   output $0.40/M (Flash $2.50/M)   — 6× cheaper
+    //   cache  $0.01/M                    — 1/10 of input (vs Flash 0.25 discount)
+    // Cliffs are HYPOTHESIZED from Flash's known failure modes — Flash-Lite
+    // is a smaller sibling, so we inherit Flash's cliffs at equal-or-tighter
+    // thresholds. The brain will validate/relax these as evidence accumulates
+    // per (archetype, model) tuple. Currently ZERO brain rows for this model.
+    id: "gemini-2.5-flash-lite",
+    verifiedAgainstDocs: "2026-05-13",
+    provider: "google",
+    status: "current",
+    maxContextTokens: 1048576,
+    maxOutputTokens: 65536,
+    maxTools: 128,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "separate",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "input_tokens",
+        threshold: 8e3,
+        action: "downgrade_quality_warning",
+        reason: "Inherited from Flash: quality degrades above ~8K. Smaller model \u2014 likely degrades faster. Re-tune from brain after n\u226520."
+      },
+      {
+        metric: "tool_count",
+        threshold: 10,
+        action: "drop_to_top_relevant",
+        reason: "Conservative: Flash drops at 20, Flash-Lite is smaller \u2014 assume tighter ceiling until brain proves otherwise."
+      },
+      {
+        metric: "thinking_with_short_output",
+        threshold: 1,
+        action: "force_thinking_budget_zero",
+        reason: "Thinking enabled per Google API (thinking: true). Same drain risk as Flash \u2014 thinking tokens consume maxOutputTokens."
+      },
+      {
+        // Strong prior: Flash hit 5/5 empty rate on summarize+tools (s11
+        // trust artifact, kgauto commit 3872832). Flash-Lite shares the
+        // same architectural family — almost certainly inherits this cliff.
+        // Ship the guard preemptively; brain telemetry confirms or relaxes.
+        metric: "tool_count",
+        threshold: 1,
+        whenIntent: "summarize",
+        action: "strip_tools",
+        reason: "Inherited from Flash s11 cliff: summarize+tools \u2192 empty response. Preemptive guard until brain evidence on Flash-Lite specifically."
+      }
+    ],
+    costInputPer1m: 0.1,
+    costOutputPer1m: 0.4,
+    lowering: {
+      ...GOOGLE_LOWERING_BASE,
+      // Cache discount 10× (vs Flash 4×) — Google's spec is $0.01/M cache vs
+      // $0.10/M input. Material for repeat-prompt workloads (classify shape).
+      cache: { ...GOOGLE_LOWERING_BASE.cache, discount: 0.1 },
+      thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
+    },
+    recovery: [
+      {
+        signal: "empty_response_after_tool",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Known on Flash family: empty after tool result \u2014 retry with thinking off."
+      },
+      {
+        signal: "empty_response",
+        action: "retry_with_params",
+        retryParams: { "generationConfig.thinkingConfig.thinkingBudget": 0 },
+        maxRetries: 1,
+        reason: "Empty response \u2014 try with thinking off."
+      },
+      {
+        signal: "malformed_function_call",
+        action: "escalate",
+        reason: "MALFORMED_FUNCTION_CALL maps to stop \u2014 escalate to next target."
+      }
+    ],
+    strengths: ["lowest_cost", "speed", "volume", "classification", "summarize", "1m_context", "cache_friendly"],
+    weaknesses: ["complex_reasoning", "large_tool_sets", "complex_schemas", "structured_output_unproven", "long_context_quality"],
+    notes: "Bottom-frontier anchor on cost: $0.10/$0.40 per 1M tokens, 1M context, 65K max output. Released July 2025 (stable). Positioned for classify / summarize / transform archetypes where quality bar is forgiving. Cliffs inherited from Flash at equal-or-tighter thresholds \u2014 re-tune per (archetype) once brain has n\u226520 rows. Alpha.8 contract layer handles MAX_TOKENS-on-structured-output via fallback chain, so structuredOutput=native is safe to declare even though Flash had alpha.8 history. Cache discount in spec: $0.01/M = 1/10 of input (richer than Flash 25%) \u2014 meaningful for repeat-prompt workloads.",
+    // Tier 3 emergency floor for summarize/classify chains. ZERO brain
+    // rows — all values are starter hypotheses anchored to "smaller
+    // sibling of Flash, at-or-below Flash perf on every archetype." The
+    // first 50 brain rows per archetype will validate or relax these.
+    archetypePerf: {
+      classify: 6,
+      // starter hypothesis — verify (Flash is 7, lite likely ≤)
+      summarize: 6,
+      // starter hypothesis — verify; cliff strips tools
+      transform: 6,
+      // starter hypothesis — verify
+      ask: 5,
+      hunt: 5,
+      generate: 4,
+      extract: 4,
+      plan: 3,
+      critique: 3
+    }
+  },
+  {
+    id: "gemini-2.5-pro",
+    verifiedAgainstDocs: "2026-05-08",
+    provider: "google",
+    status: "current",
+    maxContextTokens: 1048576,
+    maxOutputTokens: 65535,
+    maxTools: 128,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "separate",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "input_tokens",
+        threshold: 2e5,
+        action: "downgrade_quality_warning",
+        reason: "Pricing doubles above 200K: input $1.25\u2192$2.50/M, output $10\u2192$15/M"
+      }
+    ],
+    costInputPer1m: 1.25,
+    costOutputPer1m: 10,
+    lowering: {
+      ...GOOGLE_LOWERING_BASE,
+      thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
+    },
+    recovery: [
+      {
+        signal: "malformed_function_call",
+        action: "escalate",
+        reason: "MALFORMED_FUNCTION_CALL \u2014 escalate"
+      }
+    ],
+    strengths: ["reasoning", "1m_context", "structured_output", "tool_use"],
+    weaknesses: ["pricing_above_200k"],
+    // Master plan §3.3 anchor: tier-2 cross-provider in almost every chain.
+    // Sits on the frontier at perf-9 — close to Sonnet but cheaper input.
+    archetypePerf: {
+      critique: 9,
+      plan: 9,
+      ask: 8,
+      generate: 8,
+      extract: 8,
+      transform: 8,
+      hunt: 8,
+      // tier 1 cross-provider for hunt chain
+      summarize: 7,
+      classify: 7
+    }
+  },
+  {
+    id: "gemini-3.1-pro-preview",
+    verifiedAgainstDocs: "2026-05-08",
+    provider: "google",
+    status: "preview",
+    maxContextTokens: 1048576,
+    maxOutputTokens: 65535,
+    maxTools: 128,
+    parallelToolCalls: true,
+    structuredOutput: "native",
+    systemPromptMode: "separate",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "input_tokens",
+        threshold: 2e5,
+        action: "downgrade_quality_warning",
+        reason: "Pricing doubles above 200K: input $2\u2192$4/M, output $12\u2192$18/M"
+      }
+    ],
+    costInputPer1m: 2,
+    costOutputPer1m: 12,
+    lowering: {
+      ...GOOGLE_LOWERING_BASE,
+      cache: { ...GOOGLE_LOWERING_BASE.cache, discount: 0.1 },
+      thinking: { field: "generationConfig.thinkingConfig.thinkingBudget", default: "auto" }
+    },
+    recovery: [
+      {
+        signal: "malformed_function_call",
+        action: "escalate",
+        reason: "MALFORMED_FUNCTION_CALL \u2014 escalate"
+      }
+    ],
+    strengths: ["reasoning", "1m_context", "agentic_coding", "structured_output", "tool_use"],
+    weaknesses: ["cost", "preview_status", "pricing_above_200k"],
+    notes: "Frontier Gemini (preview, 2026-Q2). Step-change agentic coding per Google. Cache discount 10\xD7 (vs 4\xD7 for 2.5 Pro). Use status=preview to flag rollback path until GA.",
+    // Frontier-Gemini preview — bumped one notch over 2.5 Pro on agentic
+    // coding / reasoning per Google's release notes. Preview status:
+    // chains should stay on 2.5 Pro until GA. Starter hypothesis.
+    archetypePerf: {
+      critique: 10,
+      // Google claims step-change on reasoning
+      plan: 10,
+      ask: 9,
+      generate: 9,
+      extract: 9,
+      transform: 8,
+      hunt: 9,
+      // step-change agentic per Google
+      summarize: 8,
+      classify: 7
+    }
+  },
+  // ── DeepSeek ──
+  // 2026-05-08 audit (L-073): DeepSeek's `deepseek-chat` was silently aliased
+  // to `deepseek-v4-flash` non-thinking mode. Old kgauto profile claimed 64k
+  // context + $0.27/$1.10 — actual is 1M context + $0.14/$0.28. Now modeled
+  // as: V4-Flash + V4-Pro as canonical profiles; deepseek-chat and
+  // deepseek-reasoner registered as aliases (see ALIASES below).
+  {
+    id: "deepseek-v4-flash",
+    verifiedAgainstDocs: "2026-05-08",
+    provider: "deepseek",
+    status: "current",
+    maxContextTokens: 1e6,
+    maxOutputTokens: 384e3,
+    maxTools: 16,
+    parallelToolCalls: false,
+    structuredOutput: "native",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "tool_count",
+        threshold: 1,
+        action: "drop_to_top_relevant",
+        reason: "Sequential tool calls only \u2014 L-040"
+      }
+    ],
+    costInputPer1m: 0.14,
+    costOutputPer1m: 0.28,
+    lowering: {
+      system: { mode: "inline" },
+      cache: { strategy: "unsupported" },
+      tools: { format: "deepseek" }
+    },
+    recovery: [
+      { signal: "rate_limit", action: "escalate", reason: "429 \u2014 escalate" }
+    ],
+    strengths: ["cost", "1m_context", "json_output", "code", "reasoning"],
+    weaknesses: ["parallel_tools", "large_tool_sets"],
+    notes: "Cheap workhorse. 1M context, 384k max output. Cache-hit input $0.0028/M (1/50\xD7 of miss). Aliased as `deepseek-chat` (non-thinking) and `deepseek-reasoner` (thinking) \u2014 see ALIASES.",
+    // Master plan §6.2 anchor. Brain-validated tier 1 cross-provider for
+    // classify (169 rows, 0% empty). Tier 0 for summarize-with-no-tools.
+    // Falls off on hunt (sequential tools — L-040) and reasoning depth.
+    archetypePerf: {
+      classify: 7,
+      // brain-validated, 169 rows
+      summarize: 7,
+      // archetype-tolerant, no brain evidence yet
+      ask: 6,
+      transform: 6,
+      generate: 5,
+      plan: 5,
+      extract: 5,
+      critique: 4,
+      hunt: 4
+      // sequential tool calls only — L-040
+    }
+  },
+  {
+    id: "deepseek-v4-pro",
+    verifiedAgainstDocs: "2026-05-08",
+    provider: "deepseek",
+    status: "current",
+    maxContextTokens: 1e6,
+    maxOutputTokens: 384e3,
+    maxTools: 16,
+    parallelToolCalls: false,
+    structuredOutput: "native",
+    systemPromptMode: "inline",
+    streaming: true,
+    cliffs: [
+      {
+        metric: "tool_count",
+        threshold: 1,
+        action: "drop_to_top_relevant",
+        reason: "Sequential tool calls only \u2014 L-040"
+      }
+    ],
+    // Profile carries REGULAR pricing, not the 75%-off promo (ends 2026-05-31).
+    // Under-estimating cost is worse than over-estimating for budget caps.
+    costInputPer1m: 1.74,
+    costOutputPer1m: 3.48,
+    lowering: {
+      system: { mode: "inline" },
+      cache: { strategy: "unsupported" },
+      tools: { format: "deepseek" }
+    },
+    recovery: [
+      { signal: "rate_limit", action: "escalate", reason: "429 \u2014 escalate" }
+    ],
+    strengths: ["quality", "reasoning", "1m_context", "json_output", "code", "extended_thinking"],
+    weaknesses: ["parallel_tools", "large_tool_sets"],
+    notes: "Pro tier. 1M context, 384k max output. Regular pricing $1.74/$3.48; 75% promo through 2026-05-31 ($0.435/$0.87). Default mode = thinking.",
+    // Master plan §3.3: tier 3 cross-provider for plan chain. Reasoning
+    // bumped one notch over V4-Flash; same parallel-tool ceiling.
+    archetypePerf: {
+      plan: 7,
+      // §3.3 tier 3 for plan
+      critique: 6,
+      ask: 7,
+      generate: 6,
+      classify: 7,
+      summarize: 7,
+      extract: 6,
+      transform: 6,
+      hunt: 4
+      // sequential tools — same as V4-Flash
+    }
+  }
+];
+var ALIASES = {
+  // DeepSeek's own model routing — both names served by V4-Flash.
+  "deepseek-chat": "deepseek-v4-flash",
+  "deepseek-reasoner": "deepseek-v4-flash",
+  // Legacy kgauto typo — actual API alias is dash-form (alpha.1 had dot).
+  "claude-haiku-4.5": "claude-haiku-4-5"
+};
+function canonicalId(id) {
+  return ALIASES[id] ?? id;
+}
+var PROFILE_INDEX = new Map(
+  PROFILES_RAW.map((p) => [p.id, p])
+);
+function getProfile(id) {
+  const canonical = canonicalId(id);
+  const p = PROFILE_INDEX.get(canonical);
+  if (!p) {
+    const known = [...PROFILE_INDEX.keys(), ...Object.keys(ALIASES)].join(", ");
+    throw new Error(`Unknown model id: "${id}". Known: ${known}`);
+  }
+  return p;
+}
+function tryGetProfile(id) {
+  return PROFILE_INDEX.get(canonicalId(id));
+}
+function allProfiles() {
+  return PROFILES_RAW;
+}
+function profilesByProvider(provider) {
+  return PROFILES_RAW.filter((p) => p.provider === provider);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALIASES,
+  allProfiles,
+  getProfile,
+  profilesByProvider,
+  tryGetProfile
+});