loadout-ai 0.5.8 → 0.6.0

package/dist/src/core/handoff.js

@@ -0,0 +1,161 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+import { writeFileAtomically } from "./atomic-file.js";
+const HANDOFF_DIR = ".handoff";
+const MESSAGES_FILE = "messages.jsonl";
+const PROTOCOL_FILE = "PROTOCOL.md";
+function handoffDir(projectRoot) {
+    return join(projectRoot, HANDOFF_DIR);
+}
+function messagesPath(projectRoot) {
+    return join(handoffDir(projectRoot), MESSAGES_FILE);
+}
+export async function isHandoffInitialized(projectRoot) {
+    try {
+        await readFile(join(handoffDir(projectRoot), PROTOCOL_FILE), "utf8");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function initHandoff(projectRoot) {
+    const dir = handoffDir(projectRoot);
+    await mkdir(dir, { recursive: true });
+    const protocol = [
+        "# Handoff Protocol",
+        "",
+        "This directory enables asynchronous task handoff between AI coding agents.",
+        "Generated by `loadout handoff init`. Compatible with the JSONL handoff convention.",
+        "",
+        "## Message types",
+        "",
+        "- **task**: assign work to another agent",
+        "- **handoff**: transfer in-progress work with context",
+        "- **question**: ask another agent for input",
+        "- **done**: signal completion",
+        "- **status**: progress update",
+        "- **error**: report a failure",
+        "- **cancel**: withdraw a task",
+        "",
+        "## Files",
+        "",
+        "- `messages.jsonl` — append-only message log (one JSON object per line)",
+        "- `PROTOCOL.md` — this file",
+        "",
+        "## Usage",
+        "",
+        "```",
+        "loadout handoff send codex 'write unit tests for auth module'",
+        "loadout handoff send claude-code 'review the API changes' --context 'see PR #42'",
+        "loadout handoff status",
+        "loadout handoff done <message-id>",
+        "```",
+        "",
+        "Agents read this directory on wake. Loadout manages the message log;",
+        "each agent's own CLAUDE.md / AGENTS.md can reference .handoff/ for pickup.",
+        "",
+    ].join("\n");
+    await writeFileAtomically(join(dir, PROTOCOL_FILE), protocol);
+    // Create empty messages file if it doesn't exist
+    try {
+        await readFile(messagesPath(projectRoot));
+    }
+    catch {
+        await writeFile(messagesPath(projectRoot), "", "utf8");
+    }
+    return dir;
+}
+export async function sendHandoff(projectRoot, to, description, options = {}) {
+    if (!(await isHandoffInitialized(projectRoot))) {
+        throw new Error("Handoff not initialized. Run `loadout handoff init` first.");
+    }
+    const message = {
+        id: randomUUID().slice(0, 8),
+        type: options.type ?? "task",
+        from: options.from ?? "user",
+        to,
+        description,
+        ...(options.context ? { context: options.context } : {}),
+        timestamp: new Date().toISOString(),
+    };
+    const path = messagesPath(projectRoot);
+    const line = JSON.stringify(message) + "\n";
+    await writeFile(path, line, { flag: "a" });
+    return message;
+}
+export async function markDone(projectRoot, messageId) {
+    const messages = await readMessages(projectRoot);
+    const original = messages.find((m) => m.id === messageId);
+    if (!original)
+        throw new Error(`Message '${messageId}' not found`);
+    if (original.type === "done")
+        throw new Error(`Message '${messageId}' is already done`);
+    return sendHandoff(projectRoot, original.from, `Completed: ${original.description}`, {
+        from: original.to,
+        type: "done",
+        context: `Resolves ${messageId}`,
+    });
+}
+export async function readMessages(projectRoot) {
+    if (!(await isHandoffInitialized(projectRoot)))
+        return [];
+    try {
+        const content = await readFile(messagesPath(projectRoot), "utf8");
+        return content
+            .split("\n")
+            .filter(Boolean)
+            .map((line) => JSON.parse(line));
+    }
+    catch {
+        return [];
+    }
+}
+export async function getHandoffState(projectRoot) {
+    const initialized = await isHandoffInitialized(projectRoot);
+    const messages = initialized ? await readMessages(projectRoot) : [];
+    const doneIds = new Set(messages
+        .filter((m) => m.type === "done")
+        .flatMap((m) => {
+        const match = m.context?.match(/Resolves (\w+)/);
+        return match ? [match[1]] : [];
+    }));
+    const pending = messages.filter((m) => m.type === "task" && !doneIds.has(m.id));
+    const done = messages.filter((m) => m.type === "task" && doneIds.has(m.id));
+    return {
+        initialized,
+        directory: handoffDir(projectRoot),
+        messages,
+        pending,
+        done,
+    };
+}
+export function formatHandoffStatus(state) {
+    if (!state.initialized)
+        return "Handoff not initialized. Run `loadout handoff init`.";
+    if (state.messages.length === 0)
+        return "No handoff messages yet. Send one with `loadout handoff send <agent> <task>`.";
+    const lines = [];
+    if (state.pending.length) {
+        lines.push(`Pending (${state.pending.length}):`);
+        for (const m of state.pending) {
+            lines.push(`  ${m.id}  ${m.from} → ${m.to}  ${m.description}`);
+        }
+    }
+    if (state.done.length) {
+        if (lines.length)
+            lines.push("");
+        lines.push(`Done (${state.done.length}):`);
+        for (const m of state.done) {
+            lines.push(`  ${m.id}  ${m.from} → ${m.to}  ${m.description}`);
+        }
+    }
+    const other = state.messages.filter((m) => m.type !== "task" && m.type !== "done");
+    if (other.length) {
+        if (lines.length)
+            lines.push("");
+        lines.push(`Other messages: ${other.length}`);
+    }
+    return lines.join("\n");
+}

package/dist/src/core/health-score-evidence.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { readFile, readdir } from "node:fs/promises";
 import { buildAgentHealthScore, } from "./agent-health-score.js";
+import { DEFAULT_ACTIVE_SKILL_LIMIT } from "./active-limit.js";
 import { managedFileReadPath } from "./active-set.js";
 import { adapterCapabilities } from "./adapters.js";
 import { loadEffectiveCatalog } from "./catalog.js";
@@ -10,7 +11,6 @@ import { readSnapshot } from "./snapshot.js";
 import { scanInstalledSkills } from "./skill-inventory.js";
 import { readInstallState } from "./state.js";
 import { transactionRoot } from "./transaction.js";
-const ACTIVE_SET_CAPACITY = 30;
 function freshness(pkg, asOf) {
     const observed = pkg?.pushedAt ?? pkg?.lastUpdatedAt;
     if (!observed)
@@ -139,7 +139,7 @@ export async function collectLocalAgentHealthEvidence(options = {}) {
                     },
                     activeSet: {
                         active,
-                        capacity: ACTIVE_SET_CAPACITY,
+                        capacity: DEFAULT_ACTIVE_SKILL_LIMIT,
                         disabled: activations.filter((item) => item.activationState === "disabled").length,
                         quarantined: activations.filter((item) => item.reviewState === "quarantined").length,
                     },

package/dist/src/core/health.js

@@ -167,6 +167,89 @@ export async function buildHealthReport(options = {}) {
         findings,
     };
 }
+/**
+ * A one-glance grade derived from the same report the health command already
+ * builds. Drift (managed files changed outside Loadout) is an integrity
+ * violation and dominates; error findings are next; warnings cap at B. This is
+ * a legible summary, not a scored policy — the detailed dimensions live behind
+ * `loadout health --explain`.
+ */
+export function gradeHealth(report) {
+    const reasons = [];
+    const fixes = [];
+    const drift = report.driftedFiles + report.driftedMcpServers;
+    const errors = report.findings.filter((f) => f.level === "error");
+    const warnings = report.findings.filter((f) => f.level === "warning");
+    if (report.status === "not-configured")
+        return {
+            letter: "—",
+            headline: "Not set up yet",
+            reasons: [
+                "No Loadout-managed packages, MCP servers, or tools installed.",
+            ],
+            fixes: [
+                "Run `loadout setup --mode stable` (preview first, nothing changes).",
+            ],
+        };
+    let letter = "A";
+    if (drift > 0) {
+        letter = "F";
+        reasons.push(`${drift} managed item(s) changed or disappeared outside Loadout.`);
+        fixes.push("Run `loadout rollback` to restore the last snapshot, or `loadout reconcile` to re-adopt.");
+    }
+    for (const error of errors) {
+        if (letter !== "F")
+            letter = "D";
+        reasons.push(error.message);
+        if (error.fix)
+            fixes.push(error.fix);
+    }
+    if (letter !== "F" && letter !== "D") {
+        if (report.status === "library-only") {
+            letter = "C";
+            reasons.push("Skills are installed but none are active for any agent.");
+            fixes.push("Run `loadout optimize --project .` to activate a relevant set.");
+        }
+        else if (warnings.length) {
+            letter = "B";
+            for (const warning of warnings) {
+                reasons.push(warning.message);
+                if (warning.fix)
+                    fixes.push(warning.fix);
+            }
+        }
+    }
+    const headline = letter === "A"
+        ? "Healthy and up to date"
+        : letter === "B"
+            ? "Healthy, with items to review"
+            : letter === "C"
+                ? "Ready, but nothing active"
+                : letter === "D"
+                    ? "Needs attention"
+                    : "Integrity problem — managed files drifted";
+    return { letter, headline, reasons, fixes: [...new Set(fixes)] };
+}
+/** The `loadout status` home screen: a grade, per-agent lines, then fixes. */
+export function formatStatusScreen(report, agentLines) {
+    const grade = gradeHealth(report);
+    const lines = [
+        `Loadout — grade ${grade.letter}: ${grade.headline}`,
+        "",
+        ...agentLines,
+    ];
+    if (grade.reasons.length) {
+        lines.push("");
+        for (const reason of grade.reasons)
+            lines.push(`  • ${reason}`);
+    }
+    if (grade.fixes.length) {
+        lines.push("");
+        for (const fix of grade.fixes)
+            lines.push(`  → ${fix}`);
+    }
+    return lines.join("\n");
+}
 export function formatHealthReport(report) {
     const icon = report.status === "not-configured" || report.status === "library-only"
         ? "•"

package/dist/src/core/install.js

@@ -309,9 +309,14 @@ export async function applySkillLibraryBatch(entries, options = {}) {
                 current.resolvedCommit.toLowerCase() !==
                     incoming.metadata.resolvedCommit.toLowerCase())
                 throw new Error(`Maximum Library cannot preserve active '${activation.packageId}/${activation.unitId ?? "skill"}' because its reviewed revision differs or is unknown. Update or disable it explicitly first.`);
-            const includesActiveUnit = incoming.plan.files.some((file) => (file.targetAgent === activation.agent ||
-                (!file.targetAgent && incoming.plan.targetAgents.length === 1)) &&
-                basename(file.target) === activation.unitId);
+            const incomingActiveTargets = new Set(incoming.plan.files
+                .filter((file) => (file.targetAgent === activation.agent ||
+                (!file.targetAgent &&
+                    incoming.plan.targetAgents.length === 1)) &&
+                basename(file.target) === activation.unitId)
+                .map((file) => file.target));
+            const includesActiveUnit = activation.targets.length > 0 &&
+                activation.targets.every((target) => incomingActiveTargets.has(target.activePath));
             if (!includesActiveUnit)
                 throw new Error(`Maximum Library cannot preserve active '${activation.packageId}/${activation.unitId ?? "skill"}' because that unit is absent from the prepared library.`);
         }

package/dist/src/core/loadout-card.js

@@ -1,15 +1,19 @@
 import { buildLocalAgentHealthScores } from "./health-score-evidence.js";
+import { buildHealthReport, gradeHealth } from "./health.js";
 import { buildPrivacySafeReport, } from "./share-report.js";
 export async function buildLoadoutCard(options = {}) {
-    const [report, scores] = await Promise.all([
+    const [report, scores, healthReport] = await Promise.all([
         options.report ? Promise.resolve(options.report) : buildPrivacySafeReport(),
         options.scores
             ? Promise.resolve(options.scores)
             : buildLocalAgentHealthScores({ asOf: options.now }),
+        buildHealthReport({}),
     ]);
+    const grade = gradeHealth(healthReport);
     return {
         schemaVersion: 1,
         generatedAt: (options.now ?? new Date()).toISOString(),
+        grade: { letter: grade.letter, headline: grade.headline },
         agents: scores
             .map((score) => ({
             id: score.agent,
@@ -38,12 +42,20 @@ export function formatLoadoutCard(card) {
     return [
         "# My Loadout",
         "",
-        `**${card.totals.activeSkills} active skills · ${card.totals.managedPackages} managed packages · ${card.totals.mcpEntries} MCP entries**`,
+        `### Grade ${card.grade.letter} — ${card.grade.headline}`,
+        "",
+        `**${card.totals.activeSkills} active skills · ${card.totals.managedPackages} managed packages · ${card.totals.mcpEntries} MCP entries** across ${card.agents.length} agent(s)`,
         "",
         "| Agent | Evidence health | Rating | Evidence coverage |",
         "| --- | ---: | --- | ---: |",
         agentCells,
         "",
+        "Set up your own agents the same way — reviewed, previewed, and rollback-safe:",
+        "",
+        "```bash",
+        "npx loadout-ai",
+        "```",
+        "",
         `Updated: ${card.generatedAt}`,
         "",
         `> ${card.claimBoundary}`,

package/dist/src/core/review-queue.js

@@ -13,7 +13,7 @@ function isQueue(value) {
         record.items.every((item) => item &&
             typeof item === "object" &&
             typeof item.repository === "string" &&
-            ["pending", "shortlisted", "ignored"].includes(item.decision)));
+            ["pending", "shortlisted", "ignored", "promoted"].includes(item.decision)));
 }
 export async function readReviewQueue() {
     try {
@@ -102,7 +102,9 @@ function decisionPriority(decision) {
         return 0;
     if (decision === "pending")
         return 1;
-    return 2;
+    if (decision === "ignored")
+        return 2;
+    return 3;
 }
 function compareQueueItems(left, right) {
     return (Number(left.alreadyCataloged) - Number(right.alreadyCataloged) ||
@@ -191,6 +193,9 @@ export async function setReviewDecision(repository, decision) {
     await writeFileAtomically(queuePath(), `${JSON.stringify(queue, null, 2)}\n`);
     return item;
 }
+export async function markPromoted(repository) {
+    return setReviewDecision(repository, "promoted");
+}
 export function formatReviewQueue(queue) {
     const visible = queue.items.filter((item) => !item.alreadyCataloged);
     return [

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/dist/src/core/skill-inventory.js

@@ -1,10 +1,10 @@
 import { createHash } from "node:crypto";
 import { lstat, readFile, readdir } from "node:fs/promises";
 import { join, relative, resolve, sep } from "node:path";
+import { DEFAULT_ACTIVE_SKILL_LIMIT } from "./active-limit.js";
 import { readInstallState } from "./state.js";
 import { listInstalledRuntimeToolSkillTargets, } from "./runtime-tools.js";
 const MAX_SCAN_DEPTH = 6;
-export const RECOMMENDED_ACTIVE_SKILLS = 30;
 function cleanFrontmatterValue(value) {
     if (!value)
         return undefined;
@@ -197,7 +197,7 @@ export async function scanInstalledSkills(agents) {
             total: entries.length,
             managed,
             unmanaged: entries.length - managed,
-            overRecommendedLimit: entries.length > RECOMMENDED_ACTIVE_SKILLS,
+            overRecommendedLimit: entries.length > DEFAULT_ACTIVE_SKILL_LIMIT,
             runtimeToolTargets: runtimeTargets.filter((target) => target.agent === agent.id).length,
             ...(agent.additionalSkillsDirectories?.length
                 ? { additionalDirectories: [...agent.additionalSkillsDirectories] }
@@ -205,7 +205,7 @@ export async function scanInstalledSkills(agents) {
         };
     });
     for (const summary of summaries.filter((item) => item.overRecommendedLimit))
-        warnings.push(`${summary.displayName} exposes ${summary.total} skills; the recommended active set is at most ${RECOMMENDED_ACTIVE_SKILLS}.`);
+        warnings.push(`${summary.displayName} exposes ${summary.total} skills; the recommended active set is at most ${DEFAULT_ACTIVE_SKILL_LIMIT}.`);
     const managed = skills.filter((entry) => entry.managed).length;
     return {
         generatedAt: new Date().toISOString(),