loadout-ai 0.6.0 → 0.8.0

package/dist/src/cli.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 import { Command, CommanderError } from "commander";
-import { HIDDEN_FROM_FIRST_SCREEN } from "./core/cli-guide.js";
-import { recoverPendingTransactions } from "./core/transaction.js";
+import { HIDDEN_FROM_FIRST_SCREEN } from "./core/reporting/cli-guide.js";
+import { registerCompletionCommands } from "./core/reporting/completion.js";
+import { recoverPendingTransactions } from "./core/install/transaction.js";
 import { LOADOUT_VERSION, printBeginnerGuide, runWizard, } from "./commands/support.js";
 import { registerSetup } from "./commands/setup.js";
 import { registerSharing } from "./commands/sharing.js";
@@ -34,6 +35,10 @@ registerInventory(program);
 registerCatalog(program);
 registerMcp(program);
 registerLifecycle(program);
+registerCompletionCommands(program.commands.map((command) => ({
+    name: command.name(),
+    subcommands: command.commands.map((sub) => sub.name()),
+})));
 for (const command of program.commands)
     // Commander supports `hidden` when a command is created. These commands are
     // registered by separate feature blocks, so use the same runtime flag here

package/dist/src/commands/agents.js

@@ -1,13 +1,9 @@
-import { detectAgents, parseAgentSelection } from "../core/paths.js";
-import { DEFAULT_ACTIVE_SKILL_LIMIT } from "../core/active-limit.js";
-import { resolve } from "node:path";
-import { writeFileAtomically } from "../core/atomic-file.js";
-import { applyActivationChange, formatActivationPlan, planActivationChange, } from "../core/active-set.js";
-import { applyProjectActivation, formatProjectActivation, planProjectActivation, } from "../core/active-policy.js";
-import { applyNativeSchedulerBundle, formatNativeScheduler, planNativeScheduler, } from "../core/scheduler.js";
-import { REVIEWED_RUNTIME_TOOLS, applyRuntimeToolPlan, formatRuntimeToolPlan, planRuntimeTool, } from "../core/runtime-tools.js";
-import { buildLoadoutCard } from "../core/loadout-card.js";
-import { buildLoadoutBadge, formatLoadoutBadgeUsage, parseLoadoutBadgeMetric, } from "../core/loadout-badge.js";
+import { detectAgents, parseAgentSelection } from "../core/agents/paths.js";
+import { DEFAULT_ACTIVE_SKILL_LIMIT } from "../core/workspace/active-limit.js";
+import { applyActivationChange, formatActivationPlan, planActivationChange, } from "../core/workspace/active-set.js";
+import { applyProjectActivation, formatProjectActivation, planProjectActivation, } from "../core/workspace/active-policy.js";
+import { applyNativeSchedulerBundle, formatNativeScheduler, planNativeScheduler, } from "../core/runtime/scheduler.js";
+import { REVIEWED_RUNTIME_TOOLS, applyRuntimeToolPlan, formatRuntimeToolPlan, planRuntimeTool, } from "../core/agents/runtime-tools.js";
 import { collectOption, durableSchedulerLauncher } from "./support.js";
 export function registerAgents(program) {
     for (const workflow of ["activate", "optimize"]) {
@@ -108,19 +104,6 @@ export function registerAgents(program) {
             ? JSON.stringify({ action, plans, snapshotId }, null, 2)
             : `Loadout Autopilot ${options.remove ? "removed" : "enabled"}: daily update radar + multi-source candidate discovery.\nNo scheduled command can install, promote, or execute a candidate. Snapshot: ${snapshotId}`);
     });
-    program
-        .command("badge")
-        .description("Generate telemetry-free Shields endpoint JSON from the local privacy-safe card")
-        .option("--metric <metric>", "evidence, active-skills, managed-packages, or mcp", "evidence")
-        .option("--output <path>", "write endpoint JSON to this path")
-        .action(async (options) => {
-        const badge = buildLoadoutBadge(await buildLoadoutCard(), parseLoadoutBadgeMetric(options.metric));
-        if (!options.output)
-            return console.log(JSON.stringify(badge, null, 2));
-        const output = resolve(options.output);
-        await writeFileAtomically(output, `${JSON.stringify(badge, null, 2)}\n`);
-        console.log(formatLoadoutBadgeUsage(output));
-    });
     program
         .command("tool")
         .description("Preview, install, or remove an explicitly reviewed runtime-tool recipe")

package/dist/src/commands/catalog.js

@@ -1,23 +1,26 @@
-import { explainCatalogScore, loadEffectiveCatalog, loadCatalog, promoteCatalogCandidate, rankCatalog, refreshCatalog, validateCatalog, } from "../core/catalog.js";
-import { parseAgentSelection } from "../core/paths.js";
+import { explainCatalogScore, loadEffectiveCatalog, loadCatalog, promoteCatalogCandidate, rankCatalog, refreshCatalog, validateCatalog, } from "../core/catalog/catalog.js";
+import { detectAgents, parseAgentSelection } from "../core/agents/paths.js";
 import { resolve } from "node:path";
 import { readFile } from "node:fs/promises";
-import { allPhaseRoutes, formatCostTable, formatModelCatalog, formatRouteRecommendation, formatRoutingTable, routePhase, routeTask, } from "../core/route.js";
-import { formatHandoffStatus, getHandoffState, initHandoff, isHandoffInitialized, markDone, sendHandoff, } from "../core/handoff.js";
-import { catalogTrustStage, formatCatalogTrustStage, } from "../core/profiles.js";
-import { discoverHackerNewsRepositories } from "../core/community.js";
-import { discoverPrivateRepositories } from "../core/private-discovery.js";
-import { defaultGitHubDiscoveryQueries, discoverGitHubRepositories, } from "../core/github-discovery.js";
-import { formatStarHistory, readCatalogObservations, } from "../core/observations.js";
-import { writeFileAtomically } from "../core/atomic-file.js";
-import { formatReviewQueue, markPromoted, mergeReviewQueue, readReviewQueue, setReviewDecision, } from "../core/review-queue.js";
-import { applyProviderModelSelection, defaultModelConfigurationPath, formatProviderModelConfiguration, planProviderModelSelection, readProviderModelConfiguration, requestOpenRouter, } from "../core/model-config.js";
-import { parseCompletionShell, renderShellCompletion, } from "../core/completion.js";
-import { buildCatalogCoverage, formatCatalogCoverage, } from "../core/catalog-coverage.js";
-import { createCredentialResolver, createOsCredentialStore, } from "../core/credentials.js";
-import { buildCandidateDossier, buildCatalogProposal, formatCandidateDossier, formatCandidateSummaries, listDiscoveryCandidates, readCandidateDossier, verifyCandidateDossierSource, writeCandidateDossier, } from "../core/candidate-intelligence.js";
-import { discoverSkillsSh } from "../core/skills-sh-discovery.js";
-import { discoverOfficialMcpRegistry } from "../core/mcp-registry-discovery.js";
+import { formatModelCatalog, MODEL_CATALOG } from "../core/routing/route.js";
+import { BUCKETS, formatAnswer, formatPolicy, guessBucket, policyPath, readPolicy, resolveRoute, setRule, writePolicy, } from "../core/routing/policy.js";
+import { rm } from "node:fs/promises";
+import { applyFirstPartySkill, FIRST_PARTY_SKILLS, formatFirstPartySkillList, formatFirstPartySkillPlan, installedFirstPartySkills, planFirstPartySkill, removeFirstPartySkill, } from "../core/routing/first-party-skills.js";
+import { applyPickup, formatHandoffStatus, formatInbox, getHandoffState, initHandoff, isHandoffInitialized, isPickupTarget, markDone, planPickup, readInbox, sendHandoff, } from "../core/routing/handoff.js";
+import { catalogTrustStage, formatCatalogTrustStage, } from "../core/catalog/profiles.js";
+import { discoverHackerNewsRepositories } from "../core/discovery/community.js";
+import { discoverPrivateRepositories } from "../core/discovery/private-discovery.js";
+import { defaultGitHubDiscoveryQueries, discoverGitHubRepositories, } from "../core/discovery/github-discovery.js";
+import { formatStarHistory, readCatalogObservations, } from "../core/discovery/observations.js";
+import { writeFileAtomically } from "../core/install/atomic-file.js";
+import { formatReviewQueue, markPromoted, mergeReviewQueue, readReviewQueue, } from "../core/discovery/review-queue.js";
+import { applyProviderModelSelection, defaultModelConfigurationPath, formatProviderModelConfiguration, planProviderModelSelection, readProviderModelConfiguration, requestOpenRouter, } from "../core/routing/model-config.js";
+import { parseCompletionShell, renderShellCompletion, } from "../core/reporting/completion.js";
+import { buildCatalogCoverage, formatCatalogCoverage, } from "../core/catalog/catalog-coverage.js";
+import { createCredentialResolver, createOsCredentialStore, } from "../core/routing/credentials.js";
+import { buildCandidateDossier, buildCatalogProposal, formatCandidateDossier, formatCandidateSummaries, listDiscoveryCandidates, readCandidateDossier, verifyCandidateDossierSource, writeCandidateDossier, } from "../core/discovery/candidate-intelligence.js";
+import { discoverSkillsSh } from "../core/discovery/skills-sh-discovery.js";
+import { discoverOfficialMcpRegistry } from "../core/discovery/mcp-registry-discovery.js";
 import { readCredentialFromStdin } from "./support.js";
 export function registerCatalog(program) {
     program
@@ -444,17 +447,6 @@ export function registerCatalog(program) {
             ? JSON.stringify(filtered, null, 2)
             : formatReviewQueue(filtered));
     });
-    program
-        .command("review")
-        .description("Record a human queue decision; shortlisting still does not promote or install")
-        .argument("<repository>", "owner/repository")
-        .requiredOption("--decision <value>", "pending, shortlisted, or ignored")
-        .action(async (repository, options) => {
-        if (!["pending", "shortlisted", "ignored"].includes(options.decision))
-            throw new Error("--decision must be pending, shortlisted, or ignored");
-        const item = await setReviewDecision(repository, options.decision);
-        console.log(`${item.repository}: ${item.decision}. No catalog or agent files changed.`);
-    });
     const credentials = program
         .command("credentials")
         .description("Store, inspect, or remove secrets in the native OS credential store");
@@ -600,103 +592,195 @@ export function registerCatalog(program) {
         });
         console.log(`Verified model selection '${id}'. No credential value was stored or printed.`);
     });
-    const handoff = program
-        .command("handoff")
-        .description("Cross-agent file-based task handoff — send work between Claude Code, Codex, and other agents");
-    handoff
-        .command("init")
-        .description("Create the .handoff/ protocol directory in the current project")
-        .action(async () => {
-        const projectRoot = process.cwd();
-        if (await isHandoffInitialized(projectRoot)) {
-            console.log("Handoff already initialized at .handoff/");
-            return;
-        }
-        const dir = await initHandoff(projectRoot);
-        console.log(`Initialized handoff protocol at ${dir}`);
-        console.log("Add .handoff/ to version control so both agents share the message log.");
-    });
-    handoff
-        .command("send")
-        .description("Send a task or message to another agent")
-        .argument("<agent>", "target agent (e.g. codex, claude-code)")
-        .argument("<description...>", "task description")
-        .option("--from <agent>", "sending agent", "user")
-        .option("--type <type>", "message type: task, handoff, question, status, error, cancel", "task")
-        .option("--context <text>", "additional context for the receiving agent")
+    const skills = program
+        .command("skills")
+        .description("Install the skills Loadout ships so your agents can use Loadout from inside a conversation");
+    skills
+        .command("list", { isDefault: true })
+        .description("Show the skills Loadout ships and whether they are installed")
         .option("--json", "emit machine-readable JSON")
-        .action(async (agent, descriptionWords, options) => {
-        const message = await sendHandoff(process.cwd(), agent, descriptionWords.join(" "), {
-            from: options.from,
-            type: options.type,
-            context: options.context,
-        });
+        .action(async (options) => {
+        const installed = await installedFirstPartySkills();
         console.log(options.json
-            ? JSON.stringify(message, null, 2)
-            : `Sent ${message.type} ${message.id} → ${message.to}: ${message.description}`);
+            ? JSON.stringify(FIRST_PARTY_SKILLS.map((skill) => ({
+                ...skill,
+                installed: installed.has(skill.id),
+            })), null, 2)
+            : formatFirstPartySkillList(installed));
     });
-    handoff
-        .command("done")
-        .description("Mark a handoff task as completed")
-        .argument("<id>", "message id to mark done")
-        .option("--json", "emit machine-readable JSON")
+    skills
+        .command("install")
+        .description("Preview or install one Loadout skill into detected agents")
+        .argument("<id>", "skill id, for example loadout-router")
+        .option("--agents <ids>", "comma-separated agent ids; defaults to all detected")
+        .option("--yes", "apply after previewing")
         .action(async (id, options) => {
-        const message = await markDone(process.cwd(), id);
-        console.log(options.json
-            ? JSON.stringify(message, null, 2)
-            : `Marked ${id} as done`);
+        const plan = await planFirstPartySkill(id, {
+            ...(options.agents
+                ? { agents: parseAgentSelection(options.agents) }
+                : {}),
+        });
+        console.log(formatFirstPartySkillPlan(plan));
+        if (!plan.targets.length)
+            return;
+        if (!options.yes) {
+            console.log("\nPreview only. Re-run with --yes to install.");
+            return;
+        }
+        await applyFirstPartySkill(plan);
+        console.log(`\nInstalled '${plan.skill.id}' for ${plan.targets.length} agent(s). Start a new agent session to pick it up.`);
     });
+    skills
+        .command("remove")
+        .description("Preview or remove one Loadout skill from detected agents")
+        .argument("<id>", "skill id")
+        .option("--agents <ids>", "comma-separated agent ids; defaults to all detected")
+        .option("--yes", "apply after previewing")
+        .action(async (id, options) => {
+        const plan = await planFirstPartySkill(id, {
+            ...(options.agents
+                ? { agents: parseAgentSelection(options.agents) }
+                : {}),
+        });
+        const present = plan.targets.filter((target) => target.replacing);
+        if (!present.length) {
+            console.log(`'${id}' is not installed for any detected agent.`);
+            return;
+        }
+        for (const target of present)
+            console.log(`  remove → ${target.destination}  [${target.displayName}]`);
+        if (!options.yes) {
+            console.log("\nPreview only. Re-run with --yes to remove.");
+            return;
+        }
+        await removeFirstPartySkill(plan);
+        console.log(`\nRemoved '${id}' from ${present.length} agent(s).`);
+    });
+    const handoff = program
+        .command("handoff")
+        .description("Hand a task to your other agent, or see what has been handed to you");
     handoff
-        .command("status")
-        .description("Show pending and completed handoff tasks")
+        .argument("[agent]", "who should do it, for example codex")
+        .argument("[task...]", "what they should do")
+        .option("--context <text>", "anything they need that is not in the task")
+        .option("--from <agent>", "who is sending", "user")
+        .option("--done <id>", "mark a task finished")
         .option("--json", "emit machine-readable JSON")
-        .action(async (options) => {
-        const state = await getHandoffState(process.cwd());
-        console.log(options.json
-            ? JSON.stringify(state, null, 2)
-            : formatHandoffStatus(state));
+        .action(async (agent, taskWords, options) => {
+        const cwd = process.cwd();
+        if (options.done) {
+            const message = await markDone(cwd, options.done);
+            console.log(options.json
+                ? JSON.stringify(message, null, 2)
+                : `Marked ${options.done} done.`);
+            return;
+        }
+        // No agent named: show what is waiting, for everyone.
+        if (!agent) {
+            const state = await getHandoffState(cwd);
+            console.log(options.json
+                ? JSON.stringify(state, null, 2)
+                : formatHandoffStatus(state));
+            return;
+        }
+        // An agent with no task means "show me my inbox".
+        const task = taskWords.join(" ").trim();
+        if (!task) {
+            const messages = await readInbox(cwd, agent);
+            console.log(options.json
+                ? JSON.stringify(messages, null, 2)
+                : formatInbox(agent, messages));
+            return;
+        }
+        // Sending is the common case, so it sets itself up rather than failing
+        // with instructions to run two other commands first.
+        const setup = [];
+        if (!(await isHandoffInitialized(cwd))) {
+            await initHandoff(cwd);
+            setup.push("created .handoff/");
+        }
+        for (const target of [options.from, agent]) {
+            if (!isPickupTarget(target))
+                continue;
+            const plan = await planPickup(cwd, target);
+            if (!plan.replacing) {
+                await applyPickup(plan);
+                setup.push(`told ${target} to check its inbox`);
+            }
+        }
+        const message = await sendHandoff(cwd, agent, task, {
+            from: options.from,
+            ...(options.context ? { context: options.context } : {}),
+        });
+        if (options.json) {
+            console.log(JSON.stringify({ message, setup }, null, 2));
+            return;
+        }
+        for (const line of setup)
+            console.log(`  ${line}`);
+        console.log(`Sent to ${agent}: ${task}`);
+        console.log(`It will pick this up next session, or now with: loadout handoff ${agent}`);
     });
     const route = program
         .command("route")
-        .description("Recommend the right model tier and agent for a task — plan, implement, review, test, debug, or document");
+        .description("Which model to use for a task, according to a routing policy you own");
     route
-        .argument("[description...]", "natural-language task description")
-        .option("--phase <phase>", "explicit phase instead of auto-classify")
-        .option("--conserve", "recommend cheaper tiers to stretch remaining session quota")
-        .option("--cost", "show cost comparison table across all phases")
-        .option("--models", "list the full model catalog Loadout knows about")
-        .option("--provider <name>", "filter models by provider (anthropic, openai, google, deepseek, meta)")
-        .option("--tier <tier>", "filter models by tier (frontier, standard, fast)")
+        .argument("[description...]", "what you are about to do")
+        .option("--bucket <bucket>", "state the bucket yourself: hard, normal, or cheap")
+        .option("--set <bucket=model>", "change the model for one bucket and save")
+        .option("--save", "write the current defaults to disk so you can edit them")
+        .option("--reset", "delete your policy and go back to the defaults")
+        .option("--models", "list the model ids you can name in a policy")
         .option("--json", "emit machine-readable JSON")
         .action(async (descriptionWords, options) => {
         if (options.models) {
             console.log(options.json
-                ? JSON.stringify((await import("../core/route.js")).MODEL_CATALOG, null, 2)
-                : formatModelCatalog({
-                    provider: options.provider,
-                    tier: options.tier,
-                }));
+                ? JSON.stringify(MODEL_CATALOG, null, 2)
+                : formatModelCatalog());
             return;
         }
-        if (options.cost) {
-            console.log(options.json
-                ? JSON.stringify((await import("../core/route.js")).estimateCostSavings(), null, 2)
-                : formatCostTable());
+        const detected = await detectAgents();
+        const installed = detected
+            .filter((agent) => agent.installed)
+            .map((agent) => agent.id);
+        if (options.reset) {
+            await rm(policyPath(), { force: true });
+            console.log("Removed your routing policy; defaults apply again.");
+            return;
+        }
+        if (options.set) {
+            const separator = options.set.indexOf("=");
+            if (separator <= 0)
+                throw new Error("--set expects <bucket>=<model>, for example normal=gpt-5.6-terra");
+            const bucket = options.set.slice(0, separator).trim();
+            if (!BUCKETS.includes(bucket))
+                throw new Error(`Unknown bucket '${bucket}'. Valid: ${BUCKETS.join(", ")}`);
+            const updated = await setRule(bucket, options.set.slice(separator + 1).trim(), installed);
+            console.log(formatPolicy(updated, "file"));
+            return;
+        }
+        const { policy, source } = await readPolicy(installed);
+        if (options.save) {
+            const path = await writePolicy(policy);
+            console.log(`Saved your routing policy to ${path}\n`);
+            console.log(formatPolicy(policy, "file"));
             return;
         }
         const description = descriptionWords.join(" ").trim();
-        if (!description && !options.phase) {
+        if (!description && !options.bucket) {
             console.log(options.json
-                ? JSON.stringify(allPhaseRoutes(options.conserve), null, 2)
-                : formatRoutingTable(options.conserve));
+                ? JSON.stringify({ policy, source }, null, 2)
+                : formatPolicy(policy, source));
             return;
         }
-        const rec = options.phase
-            ? routePhase(options.phase, options.conserve)
-            : routeTask(description, options.conserve);
+        const stated = options.bucket;
+        if (stated && !BUCKETS.includes(stated))
+            throw new Error(`Unknown bucket '${stated}'. Valid: ${BUCKETS.join(", ")}`);
+        const bucket = stated ?? guessBucket(description);
+        const answer = resolveRoute(policy, bucket, installed, !stated);
         console.log(options.json
-            ? JSON.stringify(rec, null, 2)
-            : formatRouteRecommendation(rec));
+            ? JSON.stringify(answer, null, 2)
+            : formatAnswer(answer, description || undefined));
     });
     program
         .command("completion")

package/dist/src/commands/health.js

@@ -1,9 +1,9 @@
-import { parseAgentSelection } from "../core/paths.js";
-import { buildUpdatePlan } from "../core/update.js";
-import { buildHealthReport, formatHealthReport } from "../core/health.js";
-import { buildFreshnessAlerts, formatFreshnessAlerts, ignoreFreshnessAlert, pinReplacement, readReplacementPins, unpinReplacement, } from "../core/freshness-alerts.js";
-import { formatAgentHealthScore } from "../core/agent-health-score.js";
-import { buildLocalAgentHealthScores } from "../core/health-score-evidence.js";
+import { parseAgentSelection } from "../core/agents/paths.js";
+import { buildUpdatePlan } from "../core/install/update.js";
+import { buildHealthReport, formatHealthReport, } from "../core/reporting/health.js";
+import { buildFreshnessAlerts, formatFreshnessAlerts, ignoreFreshnessAlert, pinReplacement, readReplacementPins, unpinReplacement, } from "../core/reporting/freshness-alerts.js";
+import { formatAgentHealthScore } from "../core/agents/agent-health-score.js";
+import { buildLocalAgentHealthScores } from "../core/agents/health-score-evidence.js";
 export function registerHealth(program) {
     program
         .command("health")

package/dist/src/commands/inventory.js

@@ -1,24 +1,21 @@
-import { loadEffectiveCatalog } from "../core/catalog.js";
-import { detectAgents, parseAgentSelection } from "../core/paths.js";
+import { loadEffectiveCatalog } from "../core/catalog/catalog.js";
+import { detectAgents, parseAgentSelection } from "../core/agents/paths.js";
 import { resolve } from "node:path";
-import { runDoctor, formatDoctorReport } from "../core/doctor.js";
-import { applyProfileToManifest } from "../core/manifest.js";
-import { buildHealthReport, formatStatusScreen, gradeHealth, } from "../core/health.js";
-import { applyRemove, planRemove } from "../core/remove.js";
-import { applyUninstall, buildUninstallPlan, formatUninstallPlan, uninstallGlobalCli, } from "../core/uninstall.js";
-import { formatRecommendations, personalizeRecommendations, profileManifestPackages, recommendPackages, RECOMMENDATION_BOUNDARY, scanProject, TESTED_PROFILES, } from "../core/recommend.js";
-import { buildImprovementCycle, formatImprovementCycle, recordImprovementOutcome, writeImprovementCycle, } from "../core/improve.js";
-import { applySyncPlan, buildSyncPlan } from "../core/sync.js";
-import { ADAPTER_CAPABILITIES, buildAdapterCapabilityGaps, formatAdapterCapabilityGaps, formatCapabilityMatrix, } from "../core/adapters.js";
-import { formatAgentInventory, inspectAgents, } from "../core/agent-inspection.js";
-import { formatInstalledSkillInventory, scanInstalledSkills, } from "../core/skill-inventory.js";
-import { enrichInventoryWithProvenance, formatProvenanceSummary, resolveCatalogSkillIndex, } from "../core/provenance.js";
-import { compareSkill, formatSkillComparison } from "../core/skill-compare.js";
-import { applySkillAdoption, formatAdoptionPlan, planSkillAdoption, } from "../core/adopt.js";
-import { applyReconcilePlan, buildReconcilePlan, formatReconcilePlan, } from "../core/reconcile.js";
-import { readLocalOutcomes } from "../core/outcomes.js";
-import { formatAgentVersions, inspectAgentVersions, } from "../core/agent-versions.js";
-import { scanSkillSecurity } from "../core/skill-security.js";
+import { runDoctor, formatDoctorReport } from "../core/reporting/doctor.js";
+import { applyProfileToManifest } from "../core/workspace/manifest.js";
+import { buildHealthReport, formatStatusScreen, gradeHealth, } from "../core/reporting/health.js";
+import { applyRemove, planRemove } from "../core/install/remove.js";
+import { applyUninstall, buildUninstallPlan, formatUninstallPlan, uninstallGlobalCli, } from "../core/install/uninstall.js";
+import { formatRecommendations, personalizeRecommendations, profileManifestPackages, recommendPackages, RECOMMENDATION_BOUNDARY, scanProject, TESTED_PROFILES, } from "../core/workspace/recommend.js";
+import { applySyncPlan, buildSyncPlan } from "../core/install/sync.js";
+import { formatAgentInventory, inspectAgents, } from "../core/agents/agent-inspection.js";
+import { formatInstalledSkillInventory, scanInstalledSkills, } from "../core/catalog/skill-inventory.js";
+import { enrichInventoryWithProvenance, formatProvenanceSummary, resolveCatalogSkillIndex, } from "../core/catalog/provenance.js";
+import { applySkillAdoption, formatAdoptionPlan, planSkillAdoption, } from "../core/install/adopt.js";
+import { applyReconcilePlan, buildReconcilePlan, formatReconcilePlan, } from "../core/install/reconcile.js";
+import { readLocalOutcomes } from "../core/workspace/outcomes.js";
+import { formatAgentVersions, inspectAgentVersions, } from "../core/agents/agent-versions.js";
+import { scanSkillSecurity } from "../core/catalog/skill-security.js";
 import { printProvenanceProgress } from "./support.js";
 export function registerInventory(program) {
     program
@@ -117,35 +114,6 @@ export function registerInventory(program) {
             ? JSON.stringify({ name, ...TESTED_PROFILES[name], packages }, null, 2)
             : `${name}: ${TESTED_PROFILES[name].description}\n${packages.map((pkg) => `  ${pkg.id} — ${pkg.repository}`).join("\n")}`);
     });
-    program
-        .command("improve")
-        .description("Propose the next evidence-backed improvement without changing anything")
-        .option("--json", "emit machine-readable JSON")
-        .option("--write", "persist the cycle record and reusable prompt locally")
-        .option("--output <directory>", "output directory; defaults to private Loadout state")
-        .action(async (options) => {
-        const cycle = await buildImprovementCycle();
-        console.log(options.json
-            ? JSON.stringify(cycle, null, 2)
-            : formatImprovementCycle(cycle));
-        if (options.write) {
-            const paths = await writeImprovementCycle(cycle, options.output);
-            console.log(`Cycle record: ${paths.json}\nLoop prompt: ${paths.prompt}`);
-        }
-    });
-    program
-        .command("improve-feedback")
-        .description("Record a human-reviewed outcome for a persisted improvement cycle")
-        .requiredOption("--id <id>", "cycle id")
-        .requiredOption("--outcome <outcome>", "success, failure, or partial")
-        .option("--note <text>", "short non-secret lesson")
-        .option("--directory <path>", "improvement history directory")
-        .action(async (options) => {
-        if (!["success", "failure", "partial"].includes(options.outcome))
-            throw new Error("--outcome must be success, failure, or partial");
-        await recordImprovementOutcome(options.id, options.outcome, options.note, options.directory);
-        console.log(`Recorded ${options.outcome} outcome for ${options.id}.`);
-    });
     program
         .command("sync")
         .description("Reproduce a loadout.json manifest as one safe transaction")
@@ -284,53 +252,10 @@ export function registerInventory(program) {
             ? JSON.stringify({ plan, snapshotId }, null, 2)
             : `${formatAdoptionPlan(plan)}\nAdopted without changing skill bytes. Snapshot: ${snapshotId}`);
     });
-    program
-        .command("compare")
-        .description("Compare an installed or reviewed skill with evidence-related catalog alternatives without changing anything")
-        .argument("<skill>", "installed skill name, directory name, or catalog package id")
-        .option("--agent <id>", "select one installed agent when names are ambiguous")
-        .option("--refresh", "rebuild the inspected catalog skill index")
-        .option("--offline", "never fetch; use the existing local index only")
-        .option("--limit <count>", "maximum alternatives to show", "10")
-        .option("--json", "emit the complete machine-readable comparison")
-        .action(async (skill, options) => {
-        if (options.refresh && options.offline)
-            throw new Error("--refresh and --offline cannot be used together");
-        const limit = Number(options.limit);
-        if (!Number.isInteger(limit) || limit < 1 || limit > 50)
-            throw new Error("--limit must be an integer from 1 to 50");
-        const detected = await detectAgents();
-        const agent = options.agent;
-        if (agent && !detected.some((item) => item.id === agent))
-            throw new Error(`Unknown agent id: ${options.agent}`);
-        const selected = detected.filter((item) => item.installed);
-        if (!selected.length)
-            throw new Error("No detected agent profile is available to compare");
-        const catalog = await loadEffectiveCatalog();
-        const resolved = await resolveCatalogSkillIndex({
-            refresh: options.refresh,
-            offline: options.offline,
-            build: {
-                catalog,
-                onProgress: options.offline ? undefined : printProvenanceProgress,
-            },
-        });
-        if (!resolved.index)
-            throw new Error("No local catalog skill index exists. Re-run without --offline or use --refresh.");
-        const inventory = enrichInventoryWithProvenance(await scanInstalledSkills(selected), resolved.index, resolved.source);
-        const comparison = compareSkill(skill, inventory, resolved.index.records, catalog, {
-            ...(agent ? { agent } : {}),
-            limit,
-            indexGeneratedAt: resolved.index.generatedAt,
-            failures: resolved.index.failures,
-        });
-        console.log(options.json
-            ? JSON.stringify(comparison, null, 2)
-            : formatSkillComparison(comparison));
-    });
     program
         .command("status")
         .description("Home screen: a health grade, detected agents, and the next thing to do")
+        .option("--details", "show per-component adapter compatibility for each agent")
         .option("--json", "emit machine-readable status")
         .action(async (options) => {
         const agents = await detectAgents();
@@ -340,7 +265,7 @@ export function registerInventory(program) {
         ]);
         if (options.json)
             return console.log(JSON.stringify({ grade: gradeHealth(report), report, inventory }, null, 2));
-        console.log(formatStatusScreen(report, inventory.map((item) => formatAgentInventory(item))));
+        console.log(formatStatusScreen(report, inventory.map((item) => formatAgentInventory(item, { details: options.details }))));
     });
     program
         .command("versions")
@@ -377,32 +302,6 @@ export function registerInventory(program) {
         if (report.verdict === "blocked")
             process.exitCode = 2;
     });
-    program
-        .command("capabilities")
-        .description("Show honest native, adapted, and unsupported adapter capabilities")
-        .option("--json", "emit machine-readable JSON")
-        .option("--inspect", "also inspect managed component directories on this machine")
-        .option("--gaps", "show the evidence-gated backlog for unsupported adapter combinations")
-        .action(async (options) => {
-        if (options.gaps) {
-            if (options.inspect)
-                throw new Error("Choose either --inspect or --gaps");
-            const gaps = buildAdapterCapabilityGaps();
-            return console.log(options.json
-                ? JSON.stringify(gaps, null, 2)
-                : formatAdapterCapabilityGaps());
-        }
-        if (!options.inspect)
-            return console.log(options.json
-                ? JSON.stringify(ADAPTER_CAPABILITIES, null, 2)
-                : formatCapabilityMatrix());
-        const inventory = await inspectAgents(await detectAgents());
-        if (options.json)
-            return console.log(JSON.stringify({ capabilities: ADAPTER_CAPABILITIES, inventory }, null, 2));
-        console.log(`${formatCapabilityMatrix()}\n\nLocal managed-component inventory:`);
-        for (const item of inventory)
-            console.log(formatAgentInventory(item));
-    });
     program
         .command("doctor")
         .description("Check agents, skill directories, permissions, and Loadout setup")