loadout-ai 0.5.8 → 0.6.0

package/dist/src/core/catalog-install.js

@@ -1,3 +1,4 @@
+import { DEFAULT_ACTIVE_SKILL_LIMIT } from "./active-limit.js";
 import { loadEffectiveCatalog } from "./catalog.js";
 import { detectAgents } from "./paths.js";
 import { isStableSkillSelected, isPowerSkillSelected, resolveCatalogProfile, } from "./profiles.js";
@@ -6,7 +7,7 @@ import { fetchRepositorySnapshot, } from "./source.js";
 import { analyzeInstallPlanSafety, } from "./safety.js";
 import { formatModelApiAccess } from "./access.js";
 import { recordInstalledProfile } from "./profile-state.js";
-export const RECOMMENDED_ACTIVE_SKILL_LIMIT = 30;
+import { readInstallState } from "./state.js";
 async function parallelMap(values, concurrency, worker) {
     const results = new Array(values.length);
     let cursor = 0;
@@ -151,11 +152,40 @@ export async function prepareCatalogInstall(selection, options = {}) {
     // Broad collections frequently publish the same conventional skill name.
     // Resolution order is already deterministic and evidence-ranked, so keep
     // the first source for a target and defer only the lower-ranked duplicate
-    // instead of overwriting it or blocking every other useful skill.
+    // instead of overwriting it or blocking every other useful skill. Maximum
+    // must reserve targets already owned by active managed units before applying
+    // that ordinary ranking, or a higher-ranked overlapping package can remove
+    // the source needed to preserve the active unit.
+    const reservedTargets = new Map();
+    if (selection.mode === "maximum") {
+        const selectedPackages = new Set(entries.map((entry) => entry.plan.packageId));
+        const state = await readInstallState();
+        for (const activation of state.activations ?? []) {
+            if (!selectedPackages.has(activation.packageId) ||
+                activation.installationState !== "installed" ||
+                activation.activationState !== "active")
+                continue;
+            for (const target of activation.targets) {
+                const owner = reservedTargets.get(target.activePath);
+                if (owner && owner !== activation.packageId)
+                    throw new Error(`Maximum Library cannot reserve active target '${target.activePath}' because it is claimed by both '${owner}' and '${activation.packageId}'.`);
+                reservedTargets.set(target.activePath, activation.packageId);
+            }
+        }
+    }
     const claimedTargets = new Map();
     const collisions = [];
     for (const entry of entries) {
         entry.plan.files = entry.plan.files.filter((file) => {
+            const reservedPackageId = reservedTargets.get(file.target);
+            if (reservedPackageId && reservedPackageId !== entry.plan.packageId) {
+                collisions.push({
+                    target: file.target,
+                    keptPackageId: reservedPackageId,
+                    deferredPackageId: entry.plan.packageId,
+                });
+                return false;
+            }
             const keptPackageId = claimedTargets.get(file.target);
             if (!keptPackageId) {
                 claimedTargets.set(file.target, entry.plan.packageId);
@@ -209,19 +239,26 @@ export function formatPreparedCatalogInstall(prepared, options = {}) {
     const failures = prepared.skipped.filter((item) => item.kind === "preparation-failed");
     const quarantined = prepared.skipped.filter((item) => item.kind === "quarantined");
     const retired = prepared.reconciliation?.obsoleteUnits ?? [];
+    const modeLabel = prepared.selection.mode === "maximum"
+        ? "Maximum Library"
+        : prepared.selection.mode === "power"
+            ? "Power Boost"
+            : prepared.selection.mode === "stable"
+                ? "Stable Boost"
+                : "Custom";
     const lines = [
-        `Loadout: ${prepared.selection.mode === "maximum" ? "Maximum Library" : prepared.selection.mode === "power" ? "Power Boost" : prepared.selection.mode === "stable" ? "Stable Boost" : "Custom"}`,
+        `Loadout: ${modeLabel}`,
         `Detected agents: ${prepared.agents.map((agent) => agent.displayName).join(", ")}`,
-        `Catalog selection: ${prepared.resolution.packages.length} repositories`,
-        `Ready to install: ${prepared.entries.length} skill repositories (${targetDirectories} agent skill directories)`,
-        `Explicit setup later: ${explicit.length} repository/repositories`,
-        `Separately billed model API access: ${formatModelApiAccess(prepared.access)} (ChatGPT and Claude subscriptions do not count as API access)`,
-        "Automatic skill setup does not require an OpenAI, Anthropic, or OpenRouter API key; credentialed MCP/runtime integrations remain explicit and deferred.",
+        `Ready to install: ${prepared.entries.length} skill repositories (${targetDirectories} skill directories) from ${prepared.resolution.packages.length} reviewed source(s)`,
     ];
+    if (explicit.length)
+        lines.push(`Deferred to explicit setup: ${explicit.length} source(s)`);
+    if (prepared.access?.modelApis?.length)
+        lines.push(`Declared model API access: ${formatModelApiAccess(prepared.access)}`);
     if (prepared.additive)
         lines.push("Additive install: existing managed skills will stay active.");
-    if (directoriesPerAgent > RECOMMENDED_ACTIVE_SKILL_LIMIT)
-        lines.push(`Capacity notice: about ${directoriesPerAgent} skill directories per agent exceeds Stable's ${RECOMMENDED_ACTIVE_SKILL_LIMIT}-skill bound.${prepared.selection.mode === "maximum" ? " Maximum stores them in the disabled library; optimize or activate a project-relevant working set." : prepared.selection.mode === "power" ? " Power is the explicit larger active mode; choose Stable or project optimization when lower context use matters." : " Use project-aware activation for a smaller working set."}`);
+    if (directoriesPerAgent > DEFAULT_ACTIVE_SKILL_LIMIT)
+        lines.push(`Capacity notice: about ${directoriesPerAgent} skill directories per agent exceeds Stable's ${DEFAULT_ACTIVE_SKILL_LIMIT}-skill bound.${prepared.selection.mode === "maximum" ? " Maximum stores them in the disabled library; optimize or activate a project-relevant working set." : prepared.selection.mode === "power" ? " Power is the explicit larger active mode; choose Stable or project optimization when lower context use matters." : " Use project-aware activation for a smaller working set."}`);
     if (failures.length)
         lines.push(`Preparation failures (installation will remain blocked): ${failures.map((item) => item.packageId).join(", ")}`);
     if (quarantined.length)

package/dist/src/core/catalog.js

@@ -2,54 +2,13 @@ import { existsSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { createHash } from "node:crypto";
 import { catalogSchema, formatSchemaError } from "../shared/schemas.js";
 import { fetchGitHubMetadata } from "./github.js";
 import { loadoutHome } from "./paths.js";
 import { compareCatalogPackages, explainCatalogScore } from "./ranking.js";
 import { resolveCatalogProfile } from "./profiles.js";
 import { recordCatalogObservations } from "./observations.js";
-import { publicKeyFingerprint, verifyEnvelope, } from "./signing.js";
 const cachedCatalogPath = () => join(loadoutHome(), "catalog.json");
-export const trustedCatalogPath = () => join(loadoutHome(), "catalog-releases", "trusted.json");
-export const catalogTrustPath = () => join(loadoutHome(), "catalog-releases", "trust.json");
-export async function readCatalogTrustState() {
-    let value;
-    try {
-        value = JSON.parse(await readFile(catalogTrustPath(), "utf8"));
-    }
-    catch (error) {
-        if (error &&
-            typeof error === "object" &&
-            "code" in error &&
-            error.code === "ENOENT")
-            return undefined;
-        throw new Error(`Catalog trust anchor is unreadable at ${catalogTrustPath()}`);
-    }
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        throw new Error("Catalog trust anchor is invalid");
-    const state = value;
-    if (state.schemaVersion !== 1 ||
-        typeof state.fingerprint !== "string" ||
-        !/^sha256:[a-f0-9]{64}$/.test(state.fingerprint) ||
-        typeof state.publicKeyPem !== "string" ||
-        publicKeyFingerprint(state.publicKeyPem) !== state.fingerprint ||
-        !validDateString(state.highWaterCreatedAt) ||
-        !validDateString(state.pinnedAt) ||
-        (state.pendingCreatedAt !== undefined &&
-            !validDateString(state.pendingCreatedAt)) ||
-        (state.pendingEnvelopeSha256 !== undefined &&
-            !/^[a-f0-9]{64}$/.test(state.pendingEnvelopeSha256)) ||
-        (state.pendingCreatedAt !== undefined) !==
-            (state.pendingEnvelopeSha256 !== undefined) ||
-        (state.pendingFirstPin !== undefined &&
-            (state.pendingFirstPin !== true || state.pendingCreatedAt === undefined)))
-        throw new Error("Catalog trust anchor is invalid");
-    return state;
-}
-function validDateString(value) {
-    return typeof value === "string" && !Number.isNaN(Date.parse(value));
-}
 function bundledCatalogPath() {
     const moduleDirectory = dirname(fileURLToPath(import.meta.url));
     const candidates = [
@@ -186,62 +145,9 @@ export async function loadCatalog(path = bundledCatalogPath()) {
     validateCatalog(value, { requireEvidence: true });
     return value;
 }
-/** Re-verify persisted signed catalog state on every use; public keys are not secrets. */
-export async function readTrustedCatalogState() {
-    let value;
-    try {
-        value = JSON.parse(await readFile(trustedCatalogPath(), "utf8"));
-    }
-    catch (error) {
-        if (error &&
-            typeof error === "object" &&
-            "code" in error &&
-            error.code === "ENOENT")
-            return undefined;
-        throw new Error(`Trusted catalog state is unreadable at ${trustedCatalogPath()}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        throw new Error("Trusted catalog state is invalid");
-    const state = value;
-    if (state.schemaVersion !== 1 ||
-        typeof state.appliedAt !== "string" ||
-        Number.isNaN(Date.parse(state.appliedAt)) ||
-        typeof state.source !== "string" ||
-        typeof state.publicKeyPem !== "string" ||
-        (state.snapshotId !== undefined &&
-            !/^\d+-[a-f0-9]{12}$/.test(state.snapshotId)) ||
-        !state.envelope ||
-        typeof state.envelope !== "object" ||
-        typeof state.envelope.createdAt !== "string" ||
-        Number.isNaN(Date.parse(state.envelope.createdAt)))
-        throw new Error("Trusted catalog state is invalid");
-    const verification = verifyEnvelope(state.envelope, state.publicKeyPem);
-    if (!verification.valid)
-        throw new Error("Trusted catalog state has an invalid Ed25519 signature");
-    const trust = await readCatalogTrustState();
-    if (!trust)
-        throw new Error("Trusted catalog state has no pinned trust anchor");
-    const anchored = verifyEnvelope(state.envelope, trust.publicKeyPem);
-    if (!anchored.valid || anchored.fingerprint !== trust.fingerprint)
-        throw new Error("Trusted catalog state does not match the pinned signing key");
-    if (Date.parse(state.envelope.createdAt) > Date.parse(trust.highWaterCreatedAt)) {
-        const coordinatedPending = state.envelope.createdAt === trust.pendingCreatedAt &&
-            createHash("sha256").update(state.envelope.signature).digest("hex") ===
-                trust.pendingEnvelopeSha256;
-        const transactionStillPending = Boolean(state.snapshotId &&
-            existsSync(join(loadoutHome(), "staging", state.snapshotId)));
-        if (!coordinatedPending || transactionStillPending)
-            throw new Error(transactionStillPending
-                ? "Trusted catalog release is still pending transaction recovery"
-                : "Trusted catalog state is not coordinated with its trust anchor");
-    }
-    validateCatalog(state.envelope.payload, { requireEvidence: true });
-    return state;
-}
-/** Load the most recently refreshed catalog, falling back to the bundled catalog offline. */
+/** Load the bundled catalog, then overlay the local GitHub-freshness cache offline. */
 export async function loadEffectiveCatalog(path = bundledCatalogPath()) {
-    const trusted = await readTrustedCatalogState();
-    const base = trusted?.envelope.payload ?? (await loadCatalog(path));
+    const base = await loadCatalog(path);
     try {
         const raw = await readFile(cachedCatalogPath(), "utf8");
         const value = JSON.parse(raw);
@@ -312,6 +218,19 @@ export async function refreshCatalog(packages, options = {}) {
         observationFailures: observations.failures,
     };
 }
+/** Merge a human-approved proposal into the bundled catalog. */
+export async function promoteCatalogCandidate(proposal) {
+    const catalogPath = bundledCatalogPath();
+    const current = JSON.parse(await readFile(catalogPath, "utf8"));
+    if (current.some((pkg) => pkg.id === proposal.id))
+        throw new Error(`Catalog already contains id '${proposal.id}'`);
+    if (current.some((pkg) => pkg.repository.toLowerCase() === proposal.repository.toLowerCase()))
+        throw new Error(`Catalog already contains repository '${proposal.repository}'`);
+    const merged = [...current, proposal].sort((a, b) => a.id.localeCompare(b.id));
+    validateCatalog(merged, { requireEvidence: true });
+    await writeFile(catalogPath, `${JSON.stringify(merged, null, 2)}\n`);
+    return { catalogPath, totalRecords: merged.length };
+}
 export function rankCatalog(packages) {
     return [...packages].sort(compareCatalogPackages);
 }

package/dist/src/core/cli-guide.js

@@ -23,7 +23,7 @@ START HERE
 5. See reviewed MCP integrations and their credential needs
    loadout mcp-recipe
    loadout mcp-recipe --credential-free
-   loadout mcp-recipe playwright --agent codex
+   loadout mcp-recipe playwright --agent claude-code
 
 If you decide to install something, Loadout shows a preview first and creates a
 snapshot before changing managed files. Recover with: loadout rollback
@@ -41,17 +41,23 @@ loadout advanced
 export const ADVANCED_GUIDE = [
     "ADVANCED COMMANDS",
     "",
-    "These remain available, but are hidden from the first screen so daily use stays simple.",
+    "Hidden from the first screen so daily use stays focused.",
     "",
-    "Discovery and evidence: candidate, discover, review-queue, intelligence, compatibility, benchmark.",
-    "Packages and sharing: init, add, sync, lock, export, import, audit, create, pack, publish, registry-serve.",
-    "Integrations and safety: mcp-recipe, mcp-config, codex-mcp-config, credentials, models, sandbox-run, canary.",
-    "Automation and release: watch, schedule, unschedule, catalog-sign, catalog-verify, catalog-update, claims.",
+    "Discovery:    candidate, discover, review-queue, evaluate, skill-audit",
+    "Sharing:      init, lock, export, import, share, card, badge",
+    "Integrations: mcp-recipe, mcp-config, credentials, models, handoff, convert",
+    "Lifecycle:    plan, adopt, uninstall, profiles, autopilot, tool, watch",
     "",
-    "Use `loadout <command> --help` for exact options. Every mutation-capable command previews first or requires --yes.",
+    "`loadout <command> --help` for options. Mutations preview first or require --yes.",
 ].join("\n");
-/** Commands retained for specialist workflows but omitted from beginner help. */
+/**
+ * The first-screen help shows only the everyday core (~24 commands). Everything
+ * else stays fully available and runnable, just omitted from the default help so
+ * the surface reads as a focused product rather than a tool dump. `loadout
+ * advanced` lists the hidden surface; `loadout <command> --help` documents each.
+ */
 export const HIDDEN_FROM_FIRST_SCREEN = new Set([
+    // manifests, authoring, sharing
     "init",
     "lock",
     "export",
@@ -60,54 +66,54 @@ export const HIDDEN_FROM_FIRST_SCREEN = new Set([
     "create",
     "pack",
     "publish",
-    "registry-serve",
+    "add",
+    "unadd",
+    "share",
+    "card",
+    "badge",
+    "compare-loadouts",
     "search",
+    // analytics / evidence / discovery
     "report",
     "outcomes",
     "outcome",
-    "share",
-    "card",
-    "compare-loadouts",
-    "badge",
-    "claims",
-    "alert-ignore",
-    "alert-pin",
-    "alert-unpin",
-    "alert-pins",
     "improve",
     "improve-feedback",
-    "adopt",
-    "intelligence",
-    "compatibility",
+    "compare",
+    "versions",
     "skill-audit",
-    "interop",
-    "benchmark",
     "capabilities",
     "candidate",
-    "catalog-update",
     "discover",
     "review-queue",
     "review",
+    "inspect",
+    "propose",
+    "evaluate",
+    // integrations / credentials / runtime
     "credentials",
     "models",
-    "keygen",
-    "catalog-sign",
-    "catalog-verify",
+    "handoff",
     "completion",
     "mcp-recipe",
-    "mcp",
-    "inspect",
-    "evaluate",
-    "head-to-head",
-    "watch",
-    "schedule",
-    "unschedule",
-    "sandbox-run",
     "mcp-config",
     "codex-mcp-config",
-    "plan",
-    "install",
+    "sandbox-run",
     "convert",
     "canary",
     "serve",
+    // lifecycle extras
+    "plan",
+    "adopt",
+    "uninstall",
+    "profiles",
+    "autopilot",
+    "tool",
+    "watch",
+    "schedule",
+    "unschedule",
+    "alert-ignore",
+    "alert-pin",
+    "alert-unpin",
+    "alert-pins",
 ]);

package/dist/src/core/completion.js

@@ -11,7 +11,6 @@ const commands = [
     "create",
     "pack",
     "publish",
-    "registry-serve",
     "search",
     "add",
     "unadd",
@@ -20,11 +19,7 @@ const commands = [
     "reconcile",
     "status",
     "versions",
-    "intelligence",
-    "compatibility",
     "skill-audit",
-    "interop",
-    "benchmark",
     "doctor",
     "health",
     "compare",
@@ -59,12 +54,6 @@ const commands = [
     "card",
     "compare-loadouts",
     "badge",
-    "claims",
-    "head-to-head",
-    "keygen",
-    "catalog-sign",
-    "catalog-verify",
-    "catalog-update",
     "inspect",
     "evaluate",
     "watch",
@@ -91,7 +80,6 @@ const commands = [
 const modelCommands = ["status", "set", "verify"];
 const credentialCommands = ["status", "set", "check", "delete"];
 const candidateCommands = ["list", "inspect", "propose"];
-const benchmarkCommands = ["plan"];
 export function renderShellCompletion(shell) {
     const words = commands.join(" ");
     switch (shell) {
@@ -108,20 +96,17 @@ _loadout() {
     COMPREPLY=( $(compgen -W "${credentialCommands.join(" ")}" -- "$current") )
   elif [[ COMP_CWORD -eq 2 && "\${COMP_WORDS[1]}" == "candidate" ]]; then
     COMPREPLY=( $(compgen -W "${candidateCommands.join(" ")}" -- "$current") )
-  elif [[ COMP_CWORD -eq 2 && "\${COMP_WORDS[1]}" == "benchmark" ]]; then
-    COMPREPLY=( $(compgen -W "${benchmarkCommands.join(" ")}" -- "$current") )
   fi
 }
 complete -F _loadout loadout
 `;
         case "zsh":
             return `#compdef loadout
-typeset -a commands model_commands credential_commands candidate_commands benchmark_commands
+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(" ")})
-benchmark_commands=(${benchmarkCommands.map((command) => `'${command}'`).join(" ")})
 if (( CURRENT == 2 )); then
   _describe 'command' commands
 elif (( CURRENT == 3 )) && [[ $words[2] == models ]]; then
@@ -130,8 +115,6 @@ elif (( CURRENT == 3 )) && [[ $words[2] == credentials ]]; then
   _describe 'credentials command' credential_commands
 elif (( CURRENT == 3 )) && [[ $words[2] == candidate ]]; then
   _describe 'candidate command' candidate_commands
-elif (( CURRENT == 3 )) && [[ $words[2] == benchmark ]]; then
-  _describe 'benchmark command' benchmark_commands
 fi
 `;
         case "fish":
@@ -140,7 +123,6 @@ fi
                 ...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}`),
-                ...benchmarkCommands.map((command) => `complete -c loadout -f -n '__fish_seen_subcommand_from benchmark' -a ${command}`),
             ]
                 .join("\n")
                 .concat("\n");
@@ -148,7 +130,7 @@ 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(", ")}) } elseif ($elements.Count -ge 2 -and $elements[1] -eq 'benchmark') { @(${benchmarkCommands.map((command) => `'${command}'`).join(", ")}) } else { @(${commands.map((command) => `'${command}'`).join(", ")}) }
+  $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 | Where-Object { $_ -like "$wordToComplete*" } | ForEach-Object { [System.Management.Automation.CompletionResult]::new($_, $_, 'ParameterValue', $_) }
 }
 `;

package/dist/src/core/doctor.js

@@ -62,34 +62,83 @@ export async function runDoctor() {
         issues,
     };
 }
-export function formatDoctorReport(report) {
+export function formatDoctorReport(report, options = {}) {
+    const installed = report.agents.filter((a) => a.agent.installed);
+    const notInstalled = report.agents.filter((a) => !a.agent.installed);
+    const allIssues = [
+        ...report.issues,
+        ...installed.flatMap((a) => a.issues),
+    ];
+    const grade = allIssues.length === 0 && installed.length > 0
+        ? "HEALTHY"
+        : allIssues.length <= 2
+            ? "OK"
+            : "NEEDS ATTENTION";
     const lines = [
-        "Loadout doctor",
-        `Platform: ${report.platform}`,
-        `User home: ${report.userHome}`,
-        `State home: ${report.loadoutHome}`,
+        `loadout doctor — ${grade}`,
+        "",
+        `Platform:   ${report.platform}`,
+        `State:      ${report.loadoutHome} ${report.loadoutHomeExists ? "✓" : "⚠ not created"} ${report.loadoutHomeWritable ? "writable" : "⚠ not writable"}`,
+        `Agents:     ${installed.length} detected, ${notInstalled.length} available`,
+        "",
     ];
-    lines.push(`State status: ${report.loadoutHomeExists ? "present" : "not created"} (${report.loadoutHomeWritable ? "writable" : "not writable"})`, "", "Agents:");
-    for (const entry of report.agents) {
-        const status = entry.agent.installed ? "detected" : "not found";
-        lines.push(`  ${entry.agent.installed ? "✓" : "○"} ${entry.agent.displayName}: ${status}`, `    skills: ${entry.agent.skillsDirectory} (${entry.skillsRootExists ? "present" : "will be created"}, ${entry.writable ? "writable" : "not writable"})`);
-        for (const component of entry.inventory.components) {
-            const detail = component.scanned
-                ? `${component.directoryExists ? `${component.entries.length} filesystem item(s)` : "not created"}${component.directory ? ` at ${component.directory}` : ""}`
-                : (component.note ?? "not inspected");
-            lines.push(`    ${component.type}: ${component.compatibility}; ${detail}`);
+    // --- Detected agents: compact summary ---
+    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 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(", ")}`);
+            if (entry.issues.length) {
+                for (const issue of entry.issues)
+                    lines.push(`    ⚠ ${issue}`);
+            }
+            if (options.verbose) {
+                for (const component of entry.inventory.components) {
+                    if (component.compatibility === "unsupported")
+                        continue;
+                    const detail = component.scanned
+                        ? component.directoryExists
+                            ? `${component.entries.length} items`
+                            : "not created"
+                        : (component.note ?? "—");
+                    lines.push(`    ${component.type}: ${detail}`);
+                }
+            }
         }
-        for (const warning of entry.inventory.warnings)
-            lines.push(`    ! ${warning}`);
-        for (const issue of entry.issues)
-            lines.push(`    ! ${issue}`);
+        lines.push("");
+    }
+    // --- Not installed: one-liner ---
+    if (notInstalled.length) {
+        lines.push(`NOT DETECTED: ${notInstalled.map((a) => a.agent.displayName).join(", ")}`, "");
+    }
+    // --- Issues ---
+    if (allIssues.length) {
+        lines.push("ISSUES");
+        for (const issue of allIssues)
+            lines.push(`  ⚠ ${issue}`);
+        lines.push("");
     }
-    if (report.issues.length) {
-        lines.push("", "Recommendations:");
-        for (const issue of report.issues)
-            lines.push(`  ! ${issue}`);
+    // --- Next steps ---
+    lines.push("NEXT STEPS");
+    if (allIssues.length) {
+        lines.push("  Fix the issues above, then run `loadout doctor` again.");
+    }
+    else if (installed.length === 0) {
+        lines.push("  Install an AI coding agent (Claude Code, Codex, Cursor, etc.),", "  then run `loadout doctor` again.");
+    }
+    else {
+        lines.push("  loadout status        see what's managed", "  loadout setup         install a curated skill set", "  loadout route         find the right model for your task", "  loadout health        check for updates");
     }
-    else
-        lines.push("", "No global blocking issues found.");
     return lines.join("\n");
 }
+/**
+ * Legacy-compatible verbose format. Used when --verbose is passed.
+ */
+export function formatDoctorReportVerbose(report) {
+    return formatDoctorReport(report, { verbose: true });
+}

package/dist/src/core/github.js

@@ -1,4 +1,5 @@
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
 import { join } from "node:path";
 import { loadoutHome } from "./paths.js";
 function normalizeRepository(input) {
@@ -79,7 +80,7 @@ export async function fetchGitHubMetadata(input, options = {}) {
     await mkdir(join(loadoutHome(), "cache", "github-metadata"), {
         recursive: true,
     });
-    const temporary = `${path}.${process.pid}.tmp`;
+    const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
     await writeFile(temporary, JSON.stringify(metadata, null, 2), "utf8");
     await rename(temporary, path);
     return metadata;
@@ -141,7 +142,7 @@ export async function fetchGitHubReleaseMetadata(input, options = {}) {
     await mkdir(join(loadoutHome(), "cache", "github-releases"), {
         recursive: true,
     });
-    const temporary = `${path}.${process.pid}.tmp`;
+    const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
     await writeFile(temporary, JSON.stringify(metadata, null, 2), "utf8");
     await rename(temporary, path);
     return metadata;