loadout-ai 0.5.9 → 0.7.0

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

@@ -0,0 +1,539 @@
+// 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/dist/src/core/{api.js → runtime/api.js}

@@ -1,8 +1,8 @@
 import { createServer, } from "node:http";
-import { loadEffectiveCatalog, rankCatalog } from "./catalog.js";
-import { detectAgents } from "./paths.js";
-import { buildUpdatePlan } from "./update.js";
-import { buildHealthReport } from "./health.js";
+import { loadEffectiveCatalog, rankCatalog } from "../catalog/catalog.js";
+import { detectAgents } from "../agents/paths.js";
+import { buildUpdatePlan } from "../install/update.js";
+import { buildHealthReport } from "../reporting/health.js";
 function json(response, statusCode, body) {
     const payload = JSON.stringify(body);
     response.writeHead(statusCode, {

package/dist/src/core/{canary.js → runtime/canary.js}

@@ -1,4 +1,4 @@
-import { evaluatePackage } from "./evaluate.js";
+import { evaluatePackage, } from "../discovery/evaluate.js";
 /**
  * Run the policy gate for a candidate without mutating agent configuration.
  * Promotion is deliberately injected so callers can connect it to their

package/dist/src/core/{github.js → runtime/github.js}

@@ -1,7 +1,7 @@
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { join } from "node:path";
-import { loadoutHome } from "./paths.js";
+import { loadoutHome } from "../agents/paths.js";
 function normalizeRepository(input) {
     const value = input
         .trim()

package/dist/src/core/{mcp-recipes.js → runtime/mcp-recipes.js}

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import { createCredentialResolver } from "./credentials.js";
+import { createCredentialResolver } from "../routing/credentials.js";
 import { planMcpConfig } from "./mcp.js";
 /**
  * Small, source-linked recipes. These configure a connection only; authorizing

package/dist/src/core/{mcp.js → runtime/mcp.js}

@@ -1,8 +1,8 @@
 import { readFile, readdir, mkdir, rename, writeFile, rm, } from "node:fs/promises";
 import { join, resolve, dirname, basename } from "node:path";
 import { createHash, randomUUID } from "node:crypto";
-import { loadoutHome } from "./paths.js";
-import { runMutationTransaction, withMutationLock } from "./transaction.js";
+import { loadoutHome } from "../agents/paths.js";
+import { runMutationTransaction, withMutationLock, } from "../install/transaction.js";
 const missingConfigMarker = "loadout:mcp-config:missing";
 async function configFingerprint(path) {
     let content;

package/dist/src/core/{scheduler.js → runtime/scheduler.js}

@@ -2,10 +2,10 @@ import { execFile } from "node:child_process";
 import { rm } from "node:fs/promises";
 import { dirname, win32, join } from "node:path";
 import { promisify } from "node:util";
-import { writeFileAtomically } from "./atomic-file.js";
-import { ensureDirectory, loadoutHome, userHome } from "./paths.js";
-import { createSnapshot, recordSnapshotPostMutationState } from "./snapshot.js";
-import { beginTransaction, completeTransaction, markTransactionCommitting, recoverPendingTransactions, rollbackTransaction, } from "./transaction.js";
+import { writeFileAtomically } from "../install/atomic-file.js";
+import { ensureDirectory, loadoutHome, userHome } from "../agents/paths.js";
+import { createSnapshot, recordSnapshotPostMutationState, } from "../install/snapshot.js";
+import { beginTransaction, completeTransaction, markTransactionCommitting, recoverPendingTransactions, rollbackTransaction, } from "../install/transaction.js";
 const execFileAsync = promisify(execFile);
 function parseTime(value) {
     const match = /^(\d{2}):(\d{2})$/.exec(value);

package/dist/src/core/{active-policy.js → workspace/active-policy.js}

@@ -1,8 +1,8 @@
 import { applyActivationChange, formatActivationPlan, planActivationChange, } from "./active-set.js";
 import { DEFAULT_ACTIVE_SKILL_LIMIT } from "./active-limit.js";
-import { detectAgents } from "./paths.js";
+import { detectAgents } from "../agents/paths.js";
 import { formatDetectedSignals, scanProject } from "./recommend.js";
-import { scanInstalledSkills } from "./skill-inventory.js";
+import { scanInstalledSkills } from "../catalog/skill-inventory.js";
 import { readInstallState } from "./state.js";
 import { outcomeAdjustment, projectTaskFamilies, readLocalOutcomes, } from "./outcomes.js";
 const FOUNDATION = new Set([

package/dist/src/core/{active-set.js → workspace/active-set.js}

@@ -1,10 +1,10 @@
 import { createHash } from "node:crypto";
 import { cp, lstat, mkdir, readFile, readdir, rm } from "node:fs/promises";
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
-import { agentSkillsDirectory, ensureDirectory } from "./paths.js";
+import { agentSkillsDirectory, ensureDirectory } from "../agents/paths.js";
 import { activationLibraryPath, installStatePath, readInstallState, writeInstallState, } from "./state.js";
 import { inspectTargetOccupancy } from "./target-occupancy.js";
-import { runMutationTransaction } from "./transaction.js";
+import { runMutationTransaction } from "../install/transaction.js";
 /** Resolve a managed file to its active location or disabled library copy. */
 export function managedFileReadPath(packageId, filePath, activations) {
     const disabled = activations.find((activation) => activation.packageId === packageId &&

package/dist/src/core/{improve.js → workspace/improve.js}

@@ -1,9 +1,9 @@
-import { buildHealthReport } from "./health.js";
+import { buildHealthReport } from "../reporting/health.js";
 import { createHash } from "node:crypto";
 import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
-import { loadoutHome } from "./paths.js";
-import { detectSecretKinds } from "./safety.js";
+import { loadoutHome } from "../agents/paths.js";
+import { detectSecretKinds } from "../catalog/safety.js";
 export function proposeImprovements(report) {
     const proposals = [];
     if (report.driftedFiles)

package/dist/src/core/{manifest.js → workspace/manifest.js}

@@ -1,8 +1,8 @@
 import { readFile, writeFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import { formatSchemaError, loadoutManifestSchema } from "../shared/schemas.js";
+import { formatSchemaError, loadoutManifestSchema, } from "../../shared/schemas.js";
 import { readInstallState } from "./state.js";
-import { writeFileAtomically } from "./atomic-file.js";
+import { writeFileAtomically } from "../install/atomic-file.js";
 const AGENTS = new Set([
     "claude-code",
     "codex",

package/dist/src/core/{outcomes.js → workspace/outcomes.js}

@@ -1,9 +1,9 @@
 import { readFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import { dirname, join } from "node:path";
-import { writeFileAtomically } from "./atomic-file.js";
-import { ensureDirectory, loadoutHome } from "./paths.js";
-import { withFileLock } from "./file-lock.js";
+import { writeFileAtomically } from "../install/atomic-file.js";
+import { ensureDirectory, loadoutHome } from "../agents/paths.js";
+import { withFileLock } from "../install/file-lock.js";
 const outcomePath = () => join(loadoutHome(), "outcomes.json");
 const outcomeLockPath = () => join(loadoutHome(), "outcomes.lock");
 const RESULTS = new Set([