loadout-ai 0.7.0 → 0.9.0

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

@@ -1,539 +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) ---
-    {
-        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.2,
-        outputCostPer1M: 1.2,
-        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.5,
-        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.5,
-        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.1,
-        outputCostPer1M: 4.4,
-        nativeAgents: ["codex"],
-        current: true,
-        generation: "o4",
-    },
-    {
-        id: "o3-mini",
-        provider: "openai",
-        name: "o3-mini",
-        tier: "standard",
-        inputCostPer1M: 1.1,
-        outputCostPer1M: 4.4,
-        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];
-}
-/**
- * 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.
-    const runnable = checked
-        ? modelsRunnableBy(rec.models, available)
-        : rec.models;
-    const shown = (runnable.length ? runnable : 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 (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 send ${target} ${shellQuote(context.description)}`);
-        if (context.handoffReady === false)
-            lines.push(`  (run \`loadout handoff init\` once to enable)`);
-    }
-    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/ACTIVE_SET.md

@@ -1,53 +0,0 @@
-# Reviewed library and active-set contract
-
-Loadout separates four facts that package managers often collapse into one word:
-
-- **cache**: `missing` or `downloaded` says whether Loadout has a private byte-for-byte
-  library copy;
-- **review**: `unreviewed`, `reviewed`, or `quarantined` records evidence policy and
-  never follows popularity alone;
-- **installation**: `installed` or `removed` records whether Loadout still manages the
-  package; and
-- **activation**: `active` or `disabled` is per skill unit and per agent, because one
-  skill from a collection can be visible to Claude Code while another stays disabled
-  for Codex.
-
-Maximum Library starts reviewed skill units as `downloaded + reviewed + installed +
-disabled`. It can therefore hold hundreds of candidates without exposing hundreds of
-instructions to an agent. Power is an intentionally broader active profile; Stable is
-the smallest active foundation.
-
-An initial install is active and may have `cache:missing`. On the first disable,
-Loadout verifies that every managed file is unchanged and that no untracked file would
-be removed, copies the complete skill directories into its private library, verifies
-their hashes, and only then removes the agent-visible copies. This is the explicit
-migration boundary for older installations.
-
-`enable` verifies the private library hashes and refuses to overwrite any occupied
-agent target. It restores the exact cached bytes but keeps the library copy. Both
-commands are dry-run by default, can change several packages and agents under one
-snapshot, write a durable transaction journal before mutation, and can be reversed by
-`loadout rollback --snapshot <id>`.
-
-Only Loadout-managed skill directories participate. Existing unmanaged content is
-never silently adopted, moved, or deleted. MCP entries and other executable/configured
-components are deliberately outside active-set toggling; they retain their existing
-explicit configuration and removal workflows.
-
-A disabled package must be enabled before its tracked source can be updated. This
-prevents the update workflow from silently recreating agent-visible files and makes the
-activation transition explicit.
-
-## Commands
-
-```bash
-loadout library
-loadout disable <package-or-package/skill> [more-selectors] [--agents codex,claude-code]
-loadout disable <package-or-package/skill> --yes
-loadout enable <package-or-package/skill> --yes
-loadout activate --project . --limit 30
-loadout optimize --project .
-loadout rollback --snapshot <id>
-```
-
-Machine-readable planning and results are available with `--json`.

package/docs/COMPATIBILITY_POLICY.md

@@ -1,22 +0,0 @@
-# Compatibility policy
-
-Loadout uses the same adapter matrix in inspection and installation. Each
-agent/component cell is one of:
-
-- **native** — Loadout writes the documented component format to the
-  agent-owned location.
-- **adapted** — Loadout has a reviewed, tested mapping to an agent-specific
-  layout or explicit config writer. The plan warns about the adaptation.
-- **unsupported** — Loadout does not infer a location, convert the component,
-  or write anything.
-
-All supported platforms (Windows, macOS, and Linux) use this policy. WSL is
-Linux-side only: Loadout manages the POSIX home directory and never silently
-rewrites a Windows profile. Agent adapters are deliberately conservative:
-skills are native wherever a documented skill directory exists; commands,
-rules, and agents are native only where the adapter supplies a concrete
-directory; MCP is config-scoped and adapted only through its explicit JSON or
-Codex TOML planner; and plugin manifests are inspected/normalized but their
-runtime hooks are never converted or executed.
-
-Use `loadout capabilities --inspect` to view the matrix and local inventory.

package/docs/CONVERSION_AND_SANDBOX.md

@@ -1,27 +0,0 @@
-# Conversion loss reports and installer sandbox boundary
-
-## Cross-agent conversion
-
-The only safe initial conversion target is a static instruction file. A source skill
-can be copied to an agent's documented native skill directory when that adapter marks
-skills `native`. For a target that supports only commands, Loadout may create one
-explicit command wrapper pointing at the same static instructions.
-
-Every conversion emits a loss report containing source component, target component,
-preserved fields, dropped fields, and the reason. Hooks, subagents, lifecycle scripts,
-dynamic variables, permissions, and MCP servers are never silently converted. A loss
-report with dropped executable behavior requires user approval and defaults to no
-write.
-
-## Third-party installer threat model
-
-An installer can read secrets, write outside its target, alter shell startup files,
-open network connections, launch processes, or exploit the host. Therefore source
-repository scripts are never run on the host. Static package parsing is the normal
-path.
-
-If a future disposable sandbox runner is enabled, it must use a fresh filesystem,
-read-only source mount, no host home mount, no inherited environment variables, no
-Docker socket, restricted network disabled by default, bounded CPU/memory/time, and
-an exported file manifest. Its output is an untrusted proposal that still goes through
-the normal plan/safety/approval path. Failure or timeout discards the sandbox.