loadout-ai 0.7.0 → 0.8.0

package/dist/src/core/reporting/completion.js

@@ -1,87 +1,18 @@
-const commands = [
-    "guide",
-    "advanced",
-    "setup",
-    "upgrade",
-    "init",
-    "lock",
-    "export",
-    "import",
-    "audit",
-    "create",
-    "pack",
-    "publish",
-    "search",
-    "add",
-    "unadd",
-    "list",
-    "scan",
-    "reconcile",
-    "status",
-    "versions",
-    "skill-audit",
-    "doctor",
-    "health",
-    "compare",
-    "optimize",
-    "activate",
-    "enable",
-    "disable",
-    "adopt",
-    "library",
-    "update",
-    "rollback",
-    "discover",
-    "candidate",
-    "review-queue",
-    "review",
-    "alerts",
-    "alert-ignore",
-    "alert-pin",
-    "alert-unpin",
-    "alert-pins",
-    "mcp",
-    "mcp-recipe",
-    "mcp-config",
-    "models",
-    "credentials",
-    "schedule",
-    "unschedule",
-    "autopilot",
-    "tool",
-    "report",
-    "share",
-    "card",
-    "compare-loadouts",
-    "badge",
-    "inspect",
-    "evaluate",
-    "watch",
-    "sandbox-run",
-    "codex-mcp-config",
-    "plan",
-    "install",
-    "convert",
-    "canary",
-    "capabilities",
-    "catalog",
-    "profiles",
-    "recommend",
-    "improve",
-    "improve-feedback",
-    "sync",
-    "outcome",
-    "outcomes",
-    "remove",
-    "uninstall",
-    "serve",
-    "completion",
-];
-const modelCommands = ["status", "set", "verify"];
-const credentialCommands = ["status", "set", "check", "delete"];
-const candidateCommands = ["list", "inspect", "propose"];
+let registry = [];
+/** Called once at startup with the assembled program. */
+export function registerCompletionCommands(tree) {
+    registry = tree
+        .filter((entry) => entry.name && entry.name !== "help")
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+export function completionCommands() {
+    return registry.map((entry) => entry.name);
+}
+export function completionSubcommands(name) {
+    return registry.find((entry) => entry.name === name)?.subcommands ?? [];
+}
 export function renderShellCompletion(shell) {
-    const words = commands.join(" ");
+    const words = completionCommands().join(" ");
     switch (shell) {
         case "bash":
             return `# Loadout command completion
@@ -91,11 +22,11 @@ _loadout() {
   if [[ COMP_CWORD -eq 1 ]]; then
     COMPREPLY=( $(compgen -W "$commands" -- "$current") )
   elif [[ COMP_CWORD -eq 2 && "\${COMP_WORDS[1]}" == "models" ]]; then
-    COMPREPLY=( $(compgen -W "${modelCommands.join(" ")}" -- "$current") )
+    COMPREPLY=( $(compgen -W "${completionSubcommands("models").join(" ")}" -- "$current") )
   elif [[ COMP_CWORD -eq 2 && "\${COMP_WORDS[1]}" == "credentials" ]]; then
-    COMPREPLY=( $(compgen -W "${credentialCommands.join(" ")}" -- "$current") )
+    COMPREPLY=( $(compgen -W "${completionSubcommands("credentials").join(" ")}" -- "$current") )
   elif [[ COMP_CWORD -eq 2 && "\${COMP_WORDS[1]}" == "candidate" ]]; then
-    COMPREPLY=( $(compgen -W "${candidateCommands.join(" ")}" -- "$current") )
+    COMPREPLY=( $(compgen -W "${completionSubcommands("candidate").join(" ")}" -- "$current") )
   fi
 }
 complete -F _loadout loadout
@@ -103,10 +34,18 @@ complete -F _loadout loadout
         case "zsh":
             return `#compdef loadout
 typeset -a commands model_commands credential_commands candidate_commands
-commands=(${commands.map((command) => `'${command}'`).join(" ")})
-model_commands=(${modelCommands.map((command) => `'${command}'`).join(" ")})
-credential_commands=(${credentialCommands.map((command) => `'${command}'`).join(" ")})
-candidate_commands=(${candidateCommands.map((command) => `'${command}'`).join(" ")})
+commands=(${completionCommands()
+                .map((command) => `'${command}'`)
+                .join(" ")})
+model_commands=(${completionSubcommands("models")
+                .map((command) => `'${command}'`)
+                .join(" ")})
+credential_commands=(${completionSubcommands("credentials")
+                .map((command) => `'${command}'`)
+                .join(" ")})
+candidate_commands=(${completionSubcommands("candidate")
+                .map((command) => `'${command}'`)
+                .join(" ")})
 if (( CURRENT == 2 )); then
   _describe 'command' commands
 elif (( CURRENT == 3 )) && [[ $words[2] == models ]]; then
@@ -119,10 +58,10 @@ fi
 `;
         case "fish":
             return [
-                ...commands.map((command) => `complete -c loadout -f -n '__fish_use_subcommand' -a ${command}`),
-                ...modelCommands.map((command) => `complete -c loadout -f -n '__fish_seen_subcommand_from models' -a ${command}`),
-                ...credentialCommands.map((command) => `complete -c loadout -f -n '__fish_seen_subcommand_from credentials' -a ${command}`),
-                ...candidateCommands.map((command) => `complete -c loadout -f -n '__fish_seen_subcommand_from candidate' -a ${command}`),
+                ...completionCommands().map((command) => `complete -c loadout -f -n '__fish_use_subcommand' -a ${command}`),
+                ...completionSubcommands("models").map((command) => `complete -c loadout -f -n '__fish_seen_subcommand_from models' -a ${command}`),
+                ...completionSubcommands("credentials").map((command) => `complete -c loadout -f -n '__fish_seen_subcommand_from credentials' -a ${command}`),
+                ...completionSubcommands("candidate").map((command) => `complete -c loadout -f -n '__fish_seen_subcommand_from candidate' -a ${command}`),
             ]
                 .join("\n")
                 .concat("\n");
@@ -130,7 +69,15 @@ fi
             return `Register-ArgumentCompleter -Native -CommandName loadout -ScriptBlock {
   param($wordToComplete, $commandAst, $cursorPosition)
   $elements = @($commandAst.CommandElements | ForEach-Object { $_.Extent.Text })
-  $candidates = if ($elements.Count -ge 2 -and $elements[1] -eq 'models') { @(${modelCommands.map((command) => `'${command}'`).join(", ")}) } elseif ($elements.Count -ge 2 -and $elements[1] -eq 'credentials') { @(${credentialCommands.map((command) => `'${command}'`).join(", ")}) } elseif ($elements.Count -ge 2 -and $elements[1] -eq 'candidate') { @(${candidateCommands.map((command) => `'${command}'`).join(", ")}) } else { @(${commands.map((command) => `'${command}'`).join(", ")}) }
+  $candidates = if ($elements.Count -ge 2 -and $elements[1] -eq 'models') { @(${completionSubcommands("models")
+                .map((command) => `'${command}'`)
+                .join(", ")}) } elseif ($elements.Count -ge 2 -and $elements[1] -eq 'credentials') { @(${completionSubcommands("credentials")
+                .map((command) => `'${command}'`)
+                .join(", ")}) } elseif ($elements.Count -ge 2 -and $elements[1] -eq 'candidate') { @(${completionSubcommands("candidate")
+                .map((command) => `'${command}'`)
+                .join(", ")}) } else { @(${completionCommands()
+                .map((command) => `'${command}'`)
+                .join(", ")}) }
   $candidates | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object { [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_) }
 }
 `;

package/dist/src/core/reporting/doctor.js

@@ -1,7 +1,7 @@
 import { access, constants } from "node:fs/promises";
 import { dirname } from "node:path";
 import { detectAgents, directoryExists, loadoutHome, userHome, } from "../agents/paths.js";
-import { inspectAgents } from "../agents/agent-inspection.js";
+import { countComponentUnits, inspectAgents, } from "../agents/agent-inspection.js";
 async function writable(path) {
     // A not-yet-created directory is healthy when any existing ancestor is
     // writable; this handles first-run paths such as ~/.agents/skills.
@@ -83,13 +83,11 @@ export function formatDoctorReport(report, options = {}) {
     if (installed.length) {
         lines.push("DETECTED AGENTS");
         for (const entry of installed) {
-            const skillCount = entry.inventory.components
-                .filter((c) => c.scanned && c.directoryExists)
-                .reduce((sum, c) => sum + c.entries.length, 0);
+            const skillCount = entry.inventory.components.reduce((sum, component) => sum + countComponentUnits(component), 0);
             const supported = entry.inventory.components
                 .filter((c) => c.compatibility === "native" || c.compatibility === "adapted")
                 .map((c) => c.type);
-            lines.push(`  ✓ ${entry.agent.displayName}`, `    ${entry.agent.skillsDirectory}`, `    ${skillCount} items | supports: ${supported.join(", ")}`);
+            lines.push(`  ✓ ${entry.agent.displayName}`, `    ${entry.agent.skillsDirectory}`, `    ${skillCount} skills | supports: ${supported.join(", ")}`);
             if (entry.issues.length) {
                 for (const issue of entry.issues)
                     lines.push(`    ⚠ ${issue}`);

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

@@ -2,6 +2,8 @@ import { readFile, writeFile, mkdir } from "node:fs/promises";
 import { join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { writeFileAtomically } from "../install/atomic-file.js";
+/** Message types that settle a task, so it stops appearing in an inbox. */
+const TERMINAL_TYPES = new Set(["done", "error", "cancel"]);
 const HANDOFF_DIR = ".handoff";
 const MESSAGES_FILE = "messages.jsonl";
 const PROTOCOL_FILE = "PROTOCOL.md";
@@ -24,46 +26,30 @@ export async function initHandoff(projectRoot) {
     const dir = handoffDir(projectRoot);
     await mkdir(dir, { recursive: true });
     const protocol = [
-        "# Handoff Protocol",
+        "# Handoff",
         "",
-        "This directory enables asynchronous task handoff between AI coding agents.",
-        "Generated by `loadout handoff init`. Compatible with the JSONL handoff convention.",
+        "A shared task log so two AI coding agents can pass work between them.",
+        "Created by `loadout handoff`. Append-only JSONL; no server, no daemon.",
         "",
-        "## 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",
+        "## Using it",
         "",
         "```",
-        "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>",
+        "loadout handoff codex 'write unit tests for auth' --context 'see src/auth.ts'",
+        "loadout handoff codex          # what is waiting for codex",
+        "loadout handoff                # everything pending, both directions",
+        "loadout handoff --done <id>    # finished",
         "```",
         "",
-        "## Making agents read this",
+        "Sending sets this directory up on first use and adds a short block to",
+        "CLAUDE.md and AGENTS.md telling each agent to check its inbox at session",
+        "start. Only the text between the loadout:handoff markers is managed.",
         "",
-        "A message log only helps if the other agent checks it. Run:",
+        "## Files",
         "",
-        "```",
-        "loadout handoff pickup --yes",
-        "```",
+        "- `messages.jsonl` — the log, one JSON object per line",
+        "- `PROTOCOL.md` — this file",
         "",
-        "That adds a managed block to CLAUDE.md and AGENTS.md telling each agent to",
-        "run `loadout handoff inbox <agent>` at session start and act on what it finds.",
-        "Only the block between the loadout:handoff markers is managed.",
+        "Commit both if you want the log shared across machines.",
         "",
     ].join("\n");
     await writeFileAtomically(join(dir, PROTOCOL_FILE), protocol);
@@ -78,7 +64,7 @@ export async function initHandoff(projectRoot) {
 }
 export async function sendHandoff(projectRoot, to, description, options = {}) {
     if (!(await isHandoffInitialized(projectRoot))) {
-        throw new Error("Handoff not initialized. Run `loadout handoff init` first.");
+        throw new Error("Handoff is not set up here. Send a task and it will create itself: loadout handoff <agent> '<task>'");
     }
     const message = {
         id: randomUUID().slice(0, 8),
@@ -87,6 +73,7 @@ export async function sendHandoff(projectRoot, to, description, options = {}) {
         to,
         description,
         ...(options.context ? { context: options.context } : {}),
+        ...(options.resolves ? { resolves: options.resolves } : {}),
         timestamp: new Date().toISOString(),
     };
     const path = messagesPath(projectRoot);
@@ -104,40 +91,72 @@ export async function markDone(projectRoot, messageId) {
     return sendHandoff(projectRoot, original.from, `Completed: ${original.description}`, {
         from: original.to,
         type: "done",
-        context: `Resolves ${messageId}`,
+        resolves: messageId,
     });
 }
-export async function readMessages(projectRoot) {
+/**
+ * Parse the log one line at a time. A single truncated write previously made
+ * the whole inbox look empty, which is the worst possible failure for a queue:
+ * silent and total. Bad lines are collected and reported instead.
+ */
+export async function readMessagesDetailed(projectRoot) {
     if (!(await isHandoffInitialized(projectRoot)))
-        return [];
+        return { messages: [], corrupt: [] };
+    let content;
     try {
-        const content = await readFile(messagesPath(projectRoot), "utf8");
-        return content
-            .split("\n")
-            .filter(Boolean)
-            .map((line) => JSON.parse(line));
+        content = await readFile(messagesPath(projectRoot), "utf8");
     }
     catch {
-        return [];
+        return { messages: [], corrupt: [] };
     }
+    const messages = [];
+    const corrupt = [];
+    content.split("\n").forEach((raw, index) => {
+        if (!raw.trim())
+            return;
+        try {
+            const parsed = JSON.parse(raw);
+            if (!parsed || typeof parsed.id !== "string" || !parsed.type)
+                throw new Error("missing id or type");
+            messages.push(parsed);
+        }
+        catch (error) {
+            corrupt.push({
+                line: index + 1,
+                reason: error instanceof Error ? error.message : "unparseable",
+            });
+        }
+    });
+    return { messages, corrupt };
+}
+export async function readMessages(projectRoot) {
+    return (await readMessagesDetailed(projectRoot)).messages;
 }
 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")
+    const { messages, corrupt } = initialized
+        ? await readMessagesDetailed(projectRoot)
+        : { messages: [], corrupt: [] };
+    // A task is settled by completion, failure, or withdrawal. Treating only
+    // `done` as terminal left failed tasks pending forever.
+    const resolvedIds = new Set(messages
+        .filter((m) => TERMINAL_TYPES.has(m.type))
         .flatMap((m) => {
+        if (m.resolves)
+            return [m.resolves];
+        // Logs written before `resolves` existed encode it in the context.
         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));
+    const pending = messages.filter((m) => m.type === "task" && !resolvedIds.has(m.id));
+    const done = messages.filter((m) => m.type === "task" && resolvedIds.has(m.id));
     return {
         initialized,
         directory: handoffDir(projectRoot),
         messages,
         pending,
         done,
+        corrupt,
     };
 }
 // ---------------------------------------------------------------------------
@@ -150,7 +169,7 @@ export async function readInbox(projectRoot, agent) {
 }
 /**
  * Render an agent's inbox as instructions the agent itself can act on. This is
- * what `loadout handoff inbox` prints, and what the generated pickup block
+ * what `loadout handoff <agent>` prints, and what the generated pickup block
  * tells each agent to run, so the message log is consumed rather than merely
  * written.
  */
@@ -166,7 +185,7 @@ export function formatInbox(agent, messages) {
         lines.push(`  ${m.description}`);
         if (m.context)
             lines.push(`  context: ${m.context}`);
-        lines.push(`  when finished: loadout handoff done ${m.id}`);
+        lines.push(`  when finished: loadout handoff --done ${m.id}`);
         lines.push("");
     }
     lines.push("Work these in order. Mark each done as you complete it so the sender sees progress.");
@@ -184,10 +203,10 @@ export function pickupBlock(agent) {
         `At the start of a session, and whenever you finish a task, run:`,
         "",
         "```bash",
-        `loadout handoff inbox ${agent}`,
+        `loadout handoff ${agent}`,
         "```",
         "",
-        "If it lists pending tasks, work them in order and run the `loadout handoff done`",
+        "If it lists pending tasks, work them in order and run the `loadout handoff --done`",
         "command it prints for each one. If it reports none, continue as normal.",
         "",
         PICKUP_END,
@@ -198,6 +217,10 @@ const AGENT_CONTEXT_FILES = {
     "claude-code": "CLAUDE.md",
     codex: "AGENTS.md",
 };
+/** True when this agent has a context file Loadout knows how to write. */
+export function isPickupTarget(agent) {
+    return agent in AGENT_CONTEXT_FILES;
+}
 export function agentContextFile(agent) {
     const file = AGENT_CONTEXT_FILES[agent];
     if (!file)
@@ -225,12 +248,16 @@ export async function planPickup(projectRoot, agent) {
     const start = existing.indexOf(PICKUP_START);
     const end = existing.indexOf(PICKUP_END);
     const replacing = start !== -1 && end !== -1 && end > start;
+    // A block written by an older release still tells the agent to run commands
+    // that no longer exist, so a rewrite is a migration, not a no-op.
+    const stale = replacing &&
+        /loadout handoff (?:inbox|send|init|status|done)\b/.test(existing.slice(start, end));
     const content = replacing
         ? existing.slice(0, start) + block + existing.slice(end + PICKUP_END.length)
         : exists
             ? `${existing.replace(/\s*$/, "")}\n\n${block}\n`
             : `${block}\n`;
-    return { path, agent, exists, replacing, content };
+    return { path, agent, exists, replacing, stale, content };
 }
 export async function applyPickup(plan) {
     await writeFileAtomically(plan.path, plan.content);
@@ -238,11 +265,13 @@ export async function applyPickup(plan) {
 export function formatPickupPlan(plans) {
     const lines = ["Handoff pickup instructions:", ""];
     for (const plan of plans) {
-        const action = plan.replacing
-            ? "refresh managed block in"
-            : plan.exists
-                ? "append managed block to"
-                : "create";
+        const action = plan.stale
+            ? "migrate outdated block in"
+            : plan.replacing
+                ? "refresh managed block in"
+                : plan.exists
+                    ? "append managed block to"
+                    : "create";
         lines.push(`  ${action} ${plan.path}`);
     }
     lines.push("", "This teaches each agent to check its handoff inbox at session start.", "Only the block between the loadout:handoff markers is managed; the rest of", "each file is preserved.");
@@ -250,9 +279,9 @@ export function formatPickupPlan(plans) {
 }
 export function formatHandoffStatus(state) {
     if (!state.initialized)
-        return "Handoff not initialized. Run `loadout handoff init`.";
+        return "No handoff log here yet. Send a task and it creates itself: loadout handoff <agent> '<task>'";
     if (state.messages.length === 0)
-        return "No handoff messages yet. Send one with `loadout handoff send <agent> <task>`.";
+        return "No handoff messages yet. Send one with `loadout handoff <agent> '<task>'`.";
     const lines = [];
     if (state.pending.length) {
         lines.push(`Pending (${state.pending.length}):`);
@@ -268,6 +297,13 @@ export function formatHandoffStatus(state) {
             lines.push(`  ${m.id}  ${m.from} → ${m.to}  ${m.description}`);
         }
     }
+    if (state.corrupt.length) {
+        if (lines.length)
+            lines.push("");
+        lines.push(`Warning: ${state.corrupt.length} unreadable line(s) in the log — ${state.corrupt
+            .map((entry) => `line ${entry.line}`)
+            .join(", ")}.`, "The other messages are shown; repair or delete those lines to clear this.");
+    }
     const other = state.messages.filter((m) => m.type !== "task" && m.type !== "done");
     if (other.length) {
         if (lines.length)

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

@@ -0,0 +1,147 @@
+import { readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { writeFileAtomically } from "../install/atomic-file.js";
+import { ensureDirectory, loadoutHome } from "../agents/paths.js";
+import { MODEL_CATALOG } from "./route.js";
+export const BUCKETS = ["hard", "normal", "cheap"];
+export const BUCKET_MEANING = {
+    hard: "architecture, security, migrations, tricky debugging, risky review",
+    normal: "most implementation, ordinary debugging, refactors",
+    cheap: "tests, docs, boilerplate, renames, mechanical edits",
+};
+export const policyPath = () => join(loadoutHome(), "routing.json");
+/**
+ * Defaults reflect a deliberate stance: on Claude the real choice is Opus or
+ * Sonnet, and the cheapest useful tier lives on Codex. Anyone who disagrees
+ * edits the file rather than arguing with a hardcoded table.
+ */
+export function defaultPolicy(installed = []) {
+    const hasCodex = installed.length === 0 || installed.includes("codex");
+    return {
+        version: 1,
+        rules: {
+            hard: "claude-opus-5",
+            normal: "claude-sonnet-5",
+            // Without Codex there is no fast tier to fall back to.
+            cheap: hasCodex ? "gpt-5.6-luna" : "claude-sonnet-5",
+        },
+    };
+}
+export function findModel(id) {
+    return MODEL_CATALOG.find((model) => model.id === id);
+}
+export function validatePolicy(value) {
+    const candidate = value;
+    if (!candidate || candidate.version !== 1)
+        throw new Error("Routing policy must have version 1");
+    const rules = candidate.rules;
+    if (!rules)
+        throw new Error("Routing policy has no rules");
+    for (const bucket of BUCKETS) {
+        const id = rules[bucket];
+        if (typeof id !== "string" || !id)
+            throw new Error(`Routing policy is missing a model for '${bucket}'`);
+        if (!findModel(id))
+            throw new Error(`Routing policy names unknown model '${id}' for '${bucket}'. Run 'loadout route --models' to list valid ids.`);
+    }
+    return { version: 1, rules: { ...rules } };
+}
+export async function readPolicy(installed = []) {
+    try {
+        const raw = await readFile(policyPath(), "utf8");
+        return { policy: validatePolicy(JSON.parse(raw)), source: "file" };
+    }
+    catch (error) {
+        if (error &&
+            typeof error === "object" &&
+            error.code === "ENOENT")
+            return { policy: defaultPolicy(installed), source: "default" };
+        throw error;
+    }
+}
+export async function writePolicy(policy) {
+    const path = policyPath();
+    await ensureDirectory(dirname(path));
+    await writeFileAtomically(path, `${JSON.stringify(policy, null, 2)}\n`);
+    return path;
+}
+export async function setRule(bucket, modelId, installed = []) {
+    if (!findModel(modelId))
+        throw new Error(`Unknown model '${modelId}'. Run 'loadout route --models' to list valid ids.`);
+    const { policy } = await readPolicy(installed);
+    const next = validatePolicy({
+        version: 1,
+        rules: { ...policy.rules, [bucket]: modelId },
+    });
+    await writePolicy(next);
+    return next;
+}
+/**
+ * A deliberately small classifier. It exists so the CLI can answer without an
+ * agent present, and it says plainly that it is guessing — the skill, which has
+ * the conversation and the code, is expected to do better.
+ */
+export function guessBucket(description) {
+    const text = description.toLowerCase();
+    const hard = /\b(architect|design|migrat|security|secure|auth|login|session|crypto|signature|signing|token|secret|credential|permission|payment|billing|checkout|stripe|webhook|invoice|concurren|race condition|deadlock|schema|rollout|rollback|encrypt|sanitiz|inject)\w*/;
+    const cheap = /\b(test|tests|spec|doc|docs|docstring|comment|readme|changelog|rename|typo|format|lint|boilerplate|scaffold)\w*/;
+    if (hard.test(text))
+        return "hard";
+    if (cheap.test(text))
+        return "cheap";
+    return "normal";
+}
+export function resolveRoute(policy, bucket, installed, guessed) {
+    const model = findModel(policy.rules[bucket]);
+    const answer = { bucket, model, guessed };
+    if (!installed.length)
+        return answer;
+    const runnable = model.nativeAgents.some((id) => installed.includes(id));
+    if (runnable)
+        return answer;
+    // Prefer a model of the same tier the user can actually run; otherwise the
+    // closest one by price, so the advice stays actionable.
+    const reachable = MODEL_CATALOG.filter((candidate) => candidate.nativeAgents.some((id) => installed.includes(id)));
+    const fallback = reachable.find((candidate) => candidate.tier === model.tier) ??
+        reachable.sort((a, b) => Math.abs(a.inputCostPer1M - model.inputCostPer1M) -
+            Math.abs(b.inputCostPer1M - model.inputCostPer1M))[0];
+    answer.unavailable = {
+        reason: `${model.name} needs ${model.nativeAgents.join(" or ")}, which is not installed`,
+        ...(fallback ? { fallback } : {}),
+    };
+    return answer;
+}
+function price(model) {
+    return `$${model.inputCostPer1M}/$${model.outputCostPer1M} per M`;
+}
+export function formatPolicy(policy, source) {
+    const lines = [
+        source === "file"
+            ? `Your routing policy — ${policyPath()}`
+            : "Default routing policy (not saved yet)",
+        "",
+    ];
+    for (const bucket of BUCKETS) {
+        const model = findModel(policy.rules[bucket]);
+        lines.push(`  ${bucket.padEnd(7)} ${model.name.padEnd(16)} ${price(model)}`);
+        lines.push(`  ${"".padEnd(7)} ${BUCKET_MEANING[bucket]}`);
+    }
+    lines.push("", "Change it:  loadout route --set normal=gpt-5.6-terra", source === "default"
+        ? "Save it:    loadout route --save"
+        : "Reset it:   loadout route --reset");
+    return lines.join("\n");
+}
+export function formatAnswer(answer, task) {
+    const lines = [];
+    if (task)
+        lines.push(`Task:   ${task}`, "");
+    lines.push(`Bucket: ${answer.bucket} — ${BUCKET_MEANING[answer.bucket]}`, `Use:    ${answer.model.name}  (${price(answer.model)})`);
+    if (answer.unavailable) {
+        lines.push("", `Note:   ${answer.unavailable.reason}.`);
+        if (answer.unavailable.fallback)
+            lines.push(`        Reachable alternative: ${answer.unavailable.fallback.name} (${price(answer.unavailable.fallback)}).`);
+    }
+    if (answer.guessed)
+        lines.push("", "This bucket was guessed from wording alone. If the work is riskier than it", "reads — payments, auth, migrations — treat it as hard and move up.");
+    return lines.join("\n");
+}