loadout-ai 0.8.0 → 0.9.1

package/dist/src/core/routing/route.js

@@ -1,411 +0,0 @@
-// 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) ---
-    // Haiku and the 4.x line are deliberately absent: for real coding work the
-    // choice is Opus or Sonnet, and offering a weaker tier invites picking it.
-    {
-        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",
-    },
-    // --- OpenAI (Codex) — the current GPT-5.6 tiers only ---
-    {
-        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.2,
-        outputCostPer1M: 1.2,
-        nativeAgents: ["codex"],
-        current: true,
-        generation: "5.6",
-    },
-];
-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];
-}
-/**
- * Narrow a recommendation to the agents actually present on this machine. A
- * recommendation that names an agent the user has not installed is noise, so
- * the resolved list drives both the printed advice and the handoff command.
- */
-export function resolveAvailableAgents(suggested, installed) {
-    const present = new Set(installed);
-    return {
-        available: suggested.filter((id) => present.has(id)),
-        missing: suggested.filter((id) => !present.has(id)),
-    };
-}
-/** Models in the recommended tier that the given agents can actually run. */
-export function modelsRunnableBy(models, agents) {
-    if (!agents.length)
-        return models;
-    const wanted = new Set(agents);
-    return models.filter((m) => m.nativeAgents.some((id) => wanted.has(id)));
-}
-// ---------------------------------------------------------------------------
-// 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 };
-}
-/** Shell-quote a task description for the suggested handoff command. */
-function shellQuote(value) {
-    return `'${value.replace(/'/g, `'\\''`)}'`;
-}
-export function formatRouteRecommendation(rec, context = {}) {
-    // `undefined` means detection never ran, so every suggested agent stands. An
-    // empty array means detection ran and found nothing, which must not be
-    // silently upgraded back to the full suggestion list.
-    const checked = context.installedAgents !== undefined;
-    const { available, missing } = checked
-        ? resolveAvailableAgents(rec.suggestedAgents, context.installedAgents)
-        : { available: rec.suggestedAgents, missing: [] };
-    // Only recommend models an available agent can actually run. Not every
-    // provider offers every tier — Claude Code has no fast tier — so when the
-    // recommended tier holds nothing the user can reach, step up to the nearest
-    // tier that does rather than naming a model they cannot run.
-    const runnable = checked
-        ? modelsRunnableBy(rec.models, available)
-        : rec.models;
-    const stepUp = {
-        fast: "standard",
-        standard: "frontier",
-    };
-    let effective = runnable;
-    let tier = rec.tier;
-    let substituted;
-    while (checked && available.length && !effective.length && stepUp[tier]) {
-        const next = stepUp[tier];
-        effective = modelsRunnableBy(modelsForTier(next), available);
-        if (effective.length)
-            substituted = { from: rec.tier, to: next };
-        tier = next;
-    }
-    const shown = (effective.length ? effective : rec.models).slice(0, 4);
-    const modelNames = shown.map((m) => `${m.name} ($${m.inputCostPer1M}/$${m.outputCostPer1M})`);
-    const lines = [
-        `Phase:    ${rec.phase}`,
-        `Tier:     ${rec.tierLabel}`,
-        `Models:   ${modelNames.join("\n          ")}`,
-        `Agents:   ${available.length ? available.join(", ") : "none detected"}${missing.length ? `  (not installed: ${missing.join(", ")})` : ""}`,
-        `Why:      ${rec.reason}`,
-    ];
-    if (substituted)
-        lines.push(`Note:     your agents have no ${substituted.from}-tier model, so this shows`, `          the ${substituted.to} tier instead.`);
-    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}`);
-    }
-    // Actionable next step: hand this task to a detected agent.
-    if (context.description && available.length) {
-        const target = available[0];
-        lines.push(``, `Hand off:`, `  loadout handoff ${target} ${shellQuote(context.description)}`);
-    }
-    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/skills/loadout-router/SKILL.md

@@ -1,85 +0,0 @@
----
-name: loadout-router
-description: Decide which model to use for a coding task and hand work to another agent. Use when the user asks which model to use, mentions running low on usage or cost, asks whether to switch to Opus or Sonnet or a GPT tier, or wants to delegate a task to Codex or Claude Code.
----
-
-# Loadout Router
-
-Pick the model that fits the work, using the user's own routing policy rather
-than your guess or mine.
-
-## The policy is the user's, not yours
-
-```bash
-loadout route
-```
-
-That prints three buckets and the model the user has chosen for each:
-
-- **hard** — architecture, security, migrations, tricky debugging, risky review
-- **normal** — most implementation, ordinary debugging, refactors
-- **cheap** — tests, docs, boilerplate, renames, mechanical edits
-
-Read the policy before advising. If the user disagrees with a recommendation,
-the fix is to change the policy, not to argue:
-
-```bash
-loadout route --set cheap=claude-sonnet-5
-```
-
-## Your job is the bucket, not the model
-
-The CLI can guess a bucket from wording, and it says so when it does. **You
-should do better**, because you have the conversation, the code, and the stakes.
-Decide the bucket yourself and state it:
-
-```bash
-loadout route --bucket hard
-```
-
-Judge by consequence, not vocabulary:
-
-- Anything touching auth, payments, migrations, or data deletion is **hard**,
-  however small the diff.
-- Unfamiliar code is harder than familiar code doing the same thing.
-- A one-line change in a hot path is not cheap.
-- Genuinely mechanical work — a rename, a docstring, a test for code you just
-  wrote — is **cheap**, and paying frontier prices for it is waste.
-
-Report the model and why that bucket. One or two sentences.
-
-## When cost matters
-
-If the user mentions running low, being rate limited, or wanting to spend less,
-say what a cheaper bucket would cost them in quality rather than presenting it
-as free. `loadout route` shows real per-million prices for the comparison.
-
-Neither Claude Code nor Codex exposes remaining quota programmatically, so never
-claim to know how much the user has left.
-
-## Handing work to the other agent
-
-One command sends a task; it sets up the shared log on first use:
-
-```bash
-loadout handoff codex "write vitest coverage for src/auth.ts" --context "zod schemas already exist"
-```
-
-Put everything the receiver needs into `--context` — file paths, decisions you
-already made, what you deliberately left out. It has none of this conversation.
-
-Sending writes to a shared file in the user's repository, so confirm first
-unless they asked for the handoff themselves.
-
-## Reading your own inbox
-
-At session start, and after finishing a task:
-
-```bash
-loadout handoff claude-code
-```
-
-Work anything listed in order, then run the `loadout handoff --done <id>`
-command it prints. If nothing is pending, say nothing and carry on.
-
-`loadout handoff` with no arguments shows every pending task, both directions.