loadout-ai 0.5.9 → 0.6.0

package/dist/src/core/route.js

@@ -0,0 +1,248 @@
+// Sources:
+// Anthropic: https://allaboutclaude.com/models
+// OpenAI:    https://benchlm.ai/openai/api-pricing
+// Prices as of August 2026.
+export const MODEL_CATALOG = [
+    // --- Anthropic (Claude Code) ---
+    { id: "claude-fable-5", provider: "anthropic", name: "Claude Fable 5", tier: "frontier", inputCostPer1M: 10, outputCostPer1M: 50, nativeAgents: ["claude-code"], current: true, generation: "5" },
+    { id: "claude-opus-5", provider: "anthropic", name: "Claude Opus 5", tier: "frontier", inputCostPer1M: 5, outputCostPer1M: 25, nativeAgents: ["claude-code"], current: true, generation: "5" },
+    { id: "claude-sonnet-5", provider: "anthropic", name: "Claude Sonnet 5", tier: "standard", inputCostPer1M: 3, outputCostPer1M: 15, nativeAgents: ["claude-code"], current: true, generation: "5" },
+    { id: "claude-opus-4-8", provider: "anthropic", name: "Claude Opus 4.8", tier: "frontier", inputCostPer1M: 5, outputCostPer1M: 25, nativeAgents: ["claude-code"], current: false, generation: "4" },
+    { id: "claude-opus-4-6", provider: "anthropic", name: "Claude Opus 4.6", tier: "frontier", inputCostPer1M: 5, outputCostPer1M: 25, nativeAgents: ["claude-code"], current: false, generation: "4" },
+    { id: "claude-sonnet-4-6", provider: "anthropic", name: "Claude Sonnet 4.6", tier: "standard", inputCostPer1M: 3, outputCostPer1M: 15, nativeAgents: ["claude-code"], current: false, generation: "4" },
+    { id: "claude-haiku-4-5", provider: "anthropic", name: "Claude Haiku 4.5", tier: "fast", inputCostPer1M: 1, outputCostPer1M: 5, nativeAgents: ["claude-code"], current: true, generation: "4" },
+    // --- OpenAI (Codex) — GPT-5.6 family ---
+    { id: "gpt-5.6-sol", provider: "openai", name: "GPT-5.6 Sol", tier: "frontier", inputCostPer1M: 5, outputCostPer1M: 30, nativeAgents: ["codex"], current: true, generation: "5.6" },
+    { id: "gpt-5.6-terra", provider: "openai", name: "GPT-5.6 Terra", tier: "standard", inputCostPer1M: 2, outputCostPer1M: 12, nativeAgents: ["codex"], current: true, generation: "5.6" },
+    { id: "gpt-5.6-luna", provider: "openai", name: "GPT-5.6 Luna", tier: "fast", inputCostPer1M: 0.20, outputCostPer1M: 1.20, nativeAgents: ["codex"], current: true, generation: "5.6" },
+    // --- OpenAI — GPT-5.5 ---
+    { id: "gpt-5.5", provider: "openai", name: "GPT-5.5", tier: "frontier", inputCostPer1M: 5, outputCostPer1M: 30, nativeAgents: ["codex"], current: true, generation: "5.5" },
+    // --- OpenAI — GPT-5.4 family ---
+    { id: "gpt-5.4", provider: "openai", name: "GPT-5.4", tier: "standard", inputCostPer1M: 2.50, outputCostPer1M: 15, nativeAgents: ["codex"], current: true, generation: "5.4" },
+    { id: "gpt-5.4-mini", provider: "openai", name: "GPT-5.4 Mini", tier: "fast", inputCostPer1M: 0.75, outputCostPer1M: 4.50, nativeAgents: ["codex"], current: true, generation: "5.4" },
+    // --- OpenAI — Codex-specific ---
+    { id: "gpt-5.1-codex", provider: "openai", name: "GPT-5.1 Codex", tier: "standard", inputCostPer1M: 1.25, outputCostPer1M: 10, nativeAgents: ["codex"], current: true, generation: "5.1" },
+    // --- OpenAI — o-series reasoning ---
+    { id: "o3-pro", provider: "openai", name: "o3-pro", tier: "frontier", inputCostPer1M: 20, outputCostPer1M: 80, nativeAgents: ["codex"], current: true, generation: "o3" },
+    { id: "o3", provider: "openai", name: "o3", tier: "frontier", inputCostPer1M: 2, outputCostPer1M: 8, nativeAgents: ["codex"], current: true, generation: "o3" },
+    { id: "o4-mini", provider: "openai", name: "o4-mini", tier: "standard", inputCostPer1M: 1.10, outputCostPer1M: 4.40, nativeAgents: ["codex"], current: true, generation: "o4" },
+    { id: "o3-mini", provider: "openai", name: "o3-mini", tier: "standard", inputCostPer1M: 1.10, outputCostPer1M: 4.40, nativeAgents: ["codex"], current: true, generation: "o3" },
+];
+const TIER_LABELS = {
+    frontier: "Frontier (deep reasoning)",
+    standard: "Standard (balanced)",
+    fast: "Fast (high throughput)",
+};
+const PHASE_CONFIG = {
+    plan: {
+        tier: "frontier",
+        reason: "Architecture and decomposition need deep reasoning to avoid costly rework",
+        agents: ["claude-code"],
+        conserveTier: "standard",
+        conserveTradeoff: "Slightly shallower architectural reasoning; review the plan more carefully",
+    },
+    implement: {
+        tier: "standard",
+        reason: "Implementation is high-volume; standard models score within 5% of frontier on SWE-bench",
+        agents: ["claude-code", "codex"],
+        conserveTier: "fast",
+        conserveTradeoff: "May need more iterations on complex logic; fine for CRUD and boilerplate",
+    },
+    review: {
+        tier: "frontier",
+        reason: "Code review catches subtle bugs that cheaper models miss; worth the cost per-review",
+        agents: ["claude-code", "codex"],
+        conserveTier: "standard",
+        conserveTradeoff: "May miss edge-case bugs; pair with a linter",
+    },
+    test: {
+        tier: "fast",
+        reason: "Test generation is pattern-heavy; fast models produce equivalent coverage",
+        agents: ["claude-code", "codex"],
+    },
+    debug: {
+        tier: "standard",
+        reason: "Targeted debugging needs good reasoning but not frontier-level; standard balances cost and quality",
+        agents: ["claude-code", "codex"],
+        conserveTier: "fast",
+        conserveTradeoff: "Works for simple bugs; complex root-cause analysis may suffer",
+    },
+    document: {
+        tier: "fast",
+        reason: "Documentation and comments are well-suited to fast models; any decent model writes docs",
+        agents: ["claude-code", "codex"],
+    },
+};
+const PHASE_KEYWORDS = {
+    plan: ["plan", "design", "architect", "architecture", "rfc", "spec", "decompose", "strategy", "system design"],
+    implement: ["implement", "build", "code", "create", "add", "feature", "write", "develop", "make"],
+    review: ["review", "audit", "check", "inspect", "critique", "pr", "pull request", "diff"],
+    test: ["test", "spec", "coverage", "unit", "integration", "e2e", "assert", "vitest", "jest"],
+    debug: ["debug", "fix", "bug", "error", "crash", "broken", "investigate", "troubleshoot", "failing"],
+    document: ["document", "docs", "readme", "comment", "jsdoc", "changelog", "explain", "docstring"],
+};
+// ---------------------------------------------------------------------------
+// Classification
+// ---------------------------------------------------------------------------
+export function classifyTask(description) {
+    const lower = description.toLowerCase();
+    let best = "implement";
+    let bestScore = 0;
+    for (const [phase, keywords] of Object.entries(PHASE_KEYWORDS)) {
+        let score = 0;
+        for (const kw of keywords) {
+            if (lower.includes(kw))
+                score++;
+        }
+        if (score > bestScore) {
+            bestScore = score;
+            best = phase;
+        }
+    }
+    return best;
+}
+// ---------------------------------------------------------------------------
+// Model queries
+// ---------------------------------------------------------------------------
+export function modelsForTier(tier, currentOnly = true) {
+    return MODEL_CATALOG.filter((m) => m.tier === tier && (!currentOnly || m.current));
+}
+export function modelsByProvider(provider) {
+    return MODEL_CATALOG.filter((m) => m.provider === provider && m.current);
+}
+export function cheapestInTier(tier) {
+    const models = modelsForTier(tier);
+    return models.sort((a, b) => a.inputCostPer1M - b.inputCostPer1M)[0];
+}
+// ---------------------------------------------------------------------------
+// Routing
+// ---------------------------------------------------------------------------
+export function routeTask(description, conserve = false) {
+    return routePhase(classifyTask(description), conserve);
+}
+export function routePhase(phase, conserve = false) {
+    const config = PHASE_CONFIG[phase];
+    if (!config)
+        throw new Error(`Unknown phase '${phase}'. Valid: ${Object.keys(PHASE_CONFIG).join(", ")}`);
+    const effectiveTier = conserve && config.conserveTier ? config.conserveTier : config.tier;
+    const models = modelsForTier(effectiveTier);
+    const rec = {
+        phase: phase,
+        tier: effectiveTier,
+        tierLabel: TIER_LABELS[effectiveTier],
+        models,
+        reason: conserve && config.conserveTier
+            ? `Conserve mode: ${config.conserveTradeoff}`
+            : config.reason,
+        suggestedAgents: config.agents,
+    };
+    if (!conserve && config.conserveTier) {
+        rec.conserveAlternative = {
+            tier: config.conserveTier,
+            models: modelsForTier(config.conserveTier),
+            tradeoff: config.conserveTradeoff,
+        };
+    }
+    return rec;
+}
+export function allPhaseRoutes(conserve = false) {
+    return Object.keys(PHASE_CONFIG).map((p) => routePhase(p, conserve));
+}
+export function estimateCostSavings() {
+    const normal = allPhaseRoutes(false);
+    const conserved = allPhaseRoutes(true);
+    const estimates = normal.map((r) => {
+        const cheapest = cheapestInTier(r.tier);
+        return {
+            phase: r.phase,
+            tier: r.tier,
+            cheapestModel: cheapest?.name ?? "—",
+            inputCost: cheapest?.inputCostPer1M ?? 0,
+            outputCost: cheapest?.outputCostPer1M ?? 0,
+        };
+    });
+    const normalTotal = estimates.reduce((s, e) => s + e.inputCost, 0);
+    const conserveEstimates = conserved.map((r) => cheapestInTier(r.tier)?.inputCostPer1M ?? 0);
+    const conserveTotal = conserveEstimates.reduce((s, c) => s + c, 0);
+    return { estimates, normalTotal, conserveTotal };
+}
+// ---------------------------------------------------------------------------
+// Formatters
+// ---------------------------------------------------------------------------
+export function formatRouteRecommendation(rec) {
+    const modelNames = rec.models.slice(0, 4).map((m) => `${m.name} ($${m.inputCostPer1M}/$${m.outputCostPer1M})`);
+    const lines = [
+        `Phase:    ${rec.phase}`,
+        `Tier:     ${rec.tierLabel}`,
+        `Models:   ${modelNames.join("\n          ")}`,
+        `Agents:   ${rec.suggestedAgents.join(", ")}`,
+        `Why:      ${rec.reason}`,
+    ];
+    if (rec.conserveAlternative) {
+        const alt = rec.conserveAlternative;
+        const altCheapest = cheapestInTier(alt.tier);
+        lines.push(``, `Conserve: drop to ${alt.tier} tier (${altCheapest?.name ?? "—"} at $${altCheapest?.inputCostPer1M ?? "?"}/$${altCheapest?.outputCostPer1M ?? "?"})`, `          ${alt.tradeoff}`);
+    }
+    return lines.join("\n");
+}
+export function formatRoutingTable(conserve = false) {
+    const routes = allPhaseRoutes(conserve);
+    const header = `Phase        Tier        Cheapest model              $/M in   $/M out  Agents`;
+    const divider = "─".repeat(header.length);
+    const rows = routes.map((r) => {
+        const cheapest = cheapestInTier(r.tier);
+        const phase = r.phase.padEnd(12);
+        const tier = r.tier.padEnd(11);
+        const model = (cheapest?.name ?? "—").padEnd(27);
+        const inCost = `$${(cheapest?.inputCostPer1M ?? 0).toFixed(2)}`.padEnd(8);
+        const outCost = `$${(cheapest?.outputCostPer1M ?? 0).toFixed(2)}`.padEnd(8);
+        const agents = r.suggestedAgents.slice(0, 3).join(", ");
+        return `${phase} ${tier} ${model} ${inCost} ${outCost} ${agents}`;
+    });
+    return [
+        conserve ? "ROUTING TABLE (conserve mode — usage-saving tier for each phase)" : "ROUTING TABLE",
+        "", header, divider, ...rows,
+    ].join("\n");
+}
+export function formatCostTable() {
+    const { estimates, normalTotal, conserveTotal } = estimateCostSavings();
+    const header = "Phase        Tier        Cheapest model              $/M input";
+    const divider = "─".repeat(header.length);
+    const rows = estimates.map((e) => {
+        const phase = e.phase.padEnd(12);
+        const tier = e.tier.padEnd(11);
+        const model = e.cheapestModel.padEnd(27);
+        return `${phase} ${tier} ${model} $${e.inputCost.toFixed(2)}`;
+    });
+    const savings = Math.round((1 - conserveTotal / normalTotal) * 100);
+    return [
+        header, divider, ...rows, divider,
+        `Normal total: $${normalTotal.toFixed(2)}/M input across 6 phases`,
+        `Conserve total: $${conserveTotal.toFixed(2)}/M input (${savings}% cheaper)`,
+        "",
+        "Prices are per-million-token list rates. Actual cost depends on prompt length.",
+        "Use --conserve when you want to stretch remaining session quota.",
+    ].join("\n");
+}
+export function formatModelCatalog(filter) {
+    let models = MODEL_CATALOG;
+    if (filter?.provider)
+        models = models.filter((m) => m.provider === filter.provider);
+    if (filter?.tier)
+        models = models.filter((m) => m.tier === filter.tier);
+    if (filter?.current !== undefined)
+        models = models.filter((m) => m.current === filter.current);
+    const header = "Model                        Provider    Tier        $/M in   $/M out  Gen    Agents";
+    const divider = "─".repeat(header.length);
+    const rows = models.map((m) => {
+        const name = m.name.padEnd(28);
+        const provider = m.provider.padEnd(11);
+        const tier = m.tier.padEnd(11);
+        const inCost = `$${m.inputCostPer1M.toFixed(2)}`.padEnd(8);
+        const outCost = `$${m.outputCostPer1M.toFixed(2)}`.padEnd(8);
+        const gen = m.generation.padEnd(6);
+        const agents = m.nativeAgents.slice(0, 3).join(", ");
+        return `${name} ${provider} ${tier} ${inCost} ${outCost} ${gen} ${agents}`;
+    });
+    return [`${models.length} models${filter?.current === false ? " (including legacy)" : ""}`, "", header, divider, ...rows].join("\n");
+}

package/docs/CATALOG.md

@@ -27,10 +27,10 @@ The machine-readable catalog remains the source of truth. Run `loadout catalog -
 | [Anthropic Skills](https://github.com/anthropics/skills)                          | `anthropic-skills`               | agent-skills             | `skill`                    | **Review required** | [`9d2f1ae18723`](https://github.com/anthropics/skills/tree/9d2f1ae187231d8199c64b5b762e1bdf2244733d)                    |
 | [Agent Skills Marketplace](https://github.com/wshobson/agents)                    | `wshobson-agents`                | agent-skills             | `skill`, `plugin`          | `MIT`               | [`b6af37110581`](https://github.com/wshobson/agents/tree/b6af3711058190e4b5c5274b9758498fe626ec5a)                      |
 | [Vercel Agent Skills](https://github.com/vercel-labs/agent-skills)                | `vercel-agent-skills`            | frontend-development     | `skill`                    | **Review required** | [`f8a72b960372`](https://github.com/vercel-labs/agent-skills/tree/f8a72b9603728bb92a217a879b7e62e43ad76c81)             |
-| [Vercel Skills](https://github.com/vercel-labs/skills)                            | `vercel-skills`                  | skill-discovery          | `skill`                    | **Review required** | [`5527c09adc36`](https://github.com/vercel-labs/skills/tree/5527c09adc367612b0bffd9c80e3bc28a6b01b6d)                   |
+| [Vercel Skills](https://github.com/vercel-labs/skills)                            | `vercel-skills`                  | skill-discovery          | `skill`                    | `MIT`               | [`5527c09adc36`](https://github.com/vercel-labs/skills/tree/5527c09adc367612b0bffd9c80e3bc28a6b01b6d)                   |
 | [Cloudflare MCP Server](https://github.com/cloudflare/mcp-server-cloudflare)      | `cloudflare-mcp-server`          | cloud-platform           | `mcp`                      | `Apache-2.0`        | [`52c633e37684`](https://github.com/cloudflare/mcp-server-cloudflare/tree/52c633e37684fadb94ae236f74909b9bbefc0db8)     |
 | [Supabase MCP](https://github.com/supabase/mcp)                                   | `supabase-mcp`                   | database                 | `mcp`                      | `Apache-2.0`        | [`9f0396a1b367`](https://github.com/supabase/mcp/tree/9f0396a1b367dfa6a424f4686a21701c8f05b1c3)                         |
-| [Sentry MCP](https://github.com/getsentry/sentry-mcp)                             | `sentry-mcp`                     | observability            | `skill`, `mcp`             | **Review required** | [`ce099fd25197`](https://github.com/getsentry/sentry-mcp/tree/ce099fd251973774116749016847b78a6049ba0a)                 |
+| [Sentry MCP](https://github.com/getsentry/sentry-mcp)                             | `sentry-mcp`                     | observability            | `skill`, `mcp`             | `FSL-1.1-ALv2`      | [`ce099fd25197`](https://github.com/getsentry/sentry-mcp/tree/ce099fd251973774116749016847b78a6049ba0a)                 |
 | [Exa MCP Server](https://github.com/exa-labs/exa-mcp-server)                      | `exa-mcp-server`                 | web-research             | `skill`, `mcp`, `plugin`   | `MIT`               | [`8823cbea80b6`](https://github.com/exa-labs/exa-mcp-server/tree/8823cbea80b6ec5999c6217cccd91660fe953b97)              |
 | [Firecrawl MCP Server](https://github.com/firecrawl/firecrawl-mcp-server)         | `firecrawl-mcp-server`           | web-research             | `mcp`                      | `MIT`               | [`3eb1115b1f28`](https://github.com/firecrawl/firecrawl-mcp-server/tree/3eb1115b1f2883ff2fb74e61b5c4acf5a9ac0fb0)       |
 | [Azure DevOps MCP](https://github.com/microsoft/azure-devops-mcp)                 | `azure-devops-mcp`               | devops                   | `mcp`                      | `MIT`               | [`0a08dc649c95`](https://github.com/microsoft/azure-devops-mcp/tree/0a08dc649c951208eda942154c66187dec9985bd)           |