loadout-ai 0.5.9 → 0.6.0

package/catalog/packages.json

@@ -208,7 +208,7 @@
     "description": "The open agent skills tool - npx skills.",
     "category": "skill-discovery",
     "tier": "stable",
-    "license": "NOASSERTION",
+    "license": "MIT",
     "components": ["skill"],
     "operatingSystems": ["windows", "macos", "linux"],
     "stars": 26124,
@@ -271,7 +271,7 @@
     "description": "An MCP server for interacting with Sentry via LLMs.",
     "category": "observability",
     "tier": "official",
-    "license": "NOASSERTION",
+    "license": "FSL-1.1-ALv2",
     "components": ["skill", "mcp"],
     "operatingSystems": ["windows", "macos", "linux"],
     "stars": 771,

package/dist/src/commands/catalog.js

@@ -1,13 +1,16 @@
-import { explainCatalogScore, loadEffectiveCatalog, loadCatalog, rankCatalog, refreshCatalog, } from "../core/catalog.js";
+import { explainCatalogScore, loadEffectiveCatalog, loadCatalog, promoteCatalogCandidate, rankCatalog, refreshCatalog, validateCatalog, } from "../core/catalog.js";
 import { parseAgentSelection } from "../core/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, mergeReviewQueue, readReviewQueue, setReviewDecision, } from "../core/review-queue.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";
@@ -199,6 +202,35 @@ export function registerCatalog(program) {
         else
             console.log(`Approved proposal written to ${output}.`);
     });
+    candidate
+        .command("promote")
+        .allowExcessArguments(false)
+        .description("Merge a reviewed proposal into the local catalog; requires --approve")
+        .argument("<proposal>", "proposal JSON file from `candidate propose --approve`")
+        .option("--approve", "confirm human review and write to catalog")
+        .option("--json", "emit machine-readable JSON")
+        .action(async (proposalPath, options) => {
+        const proposal = JSON.parse(await readFile(resolve(proposalPath), "utf8"));
+        validateCatalog([proposal], { requireEvidence: true });
+        if (!options.approve) {
+            if (options.json)
+                return console.log(JSON.stringify({ proposal, promoted: false, catalogMutated: false }, null, 2));
+            console.log(JSON.stringify(proposal, null, 2));
+            console.log("Preview only. Re-run with --approve to merge into the catalog.");
+            return;
+        }
+        const result = await promoteCatalogCandidate(proposal);
+        const item = await markPromoted(proposal.repository);
+        if (options.json)
+            return console.log(JSON.stringify({
+                proposal,
+                promoted: true,
+                catalogMutated: true,
+                ...result,
+                reviewQueue: item,
+            }, null, 2));
+        console.log(`Promoted '${proposal.id}' into ${result.catalogPath} (${result.totalRecords} records). Review queue: ${item.repository} marked promoted.`);
+    });
     program
         .command("discover")
         .description("Find public community leads; discovery never installs anything")
@@ -568,6 +600,104 @@ 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")
+        .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,
+        });
+        console.log(options.json
+            ? JSON.stringify(message, null, 2)
+            : `Sent ${message.type} ${message.id} → ${message.to}: ${message.description}`);
+    });
+    handoff
+        .command("done")
+        .description("Mark a handoff task as completed")
+        .argument("<id>", "message id to mark done")
+        .option("--json", "emit machine-readable JSON")
+        .action(async (id, options) => {
+        const message = await markDone(process.cwd(), id);
+        console.log(options.json
+            ? JSON.stringify(message, null, 2)
+            : `Marked ${id} as done`);
+    });
+    handoff
+        .command("status")
+        .description("Show pending and completed handoff tasks")
+        .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));
+    });
+    const route = program
+        .command("route")
+        .description("Recommend the right model tier and agent for a task — plan, implement, review, test, debug, or document");
+    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)")
+        .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,
+                }));
+            return;
+        }
+        if (options.cost) {
+            console.log(options.json
+                ? JSON.stringify((await import("../core/route.js")).estimateCostSavings(), null, 2)
+                : formatCostTable());
+            return;
+        }
+        const description = descriptionWords.join(" ").trim();
+        if (!description && !options.phase) {
+            console.log(options.json
+                ? JSON.stringify(allPhaseRoutes(options.conserve), null, 2)
+                : formatRoutingTable(options.conserve));
+            return;
+        }
+        const rec = options.phase
+            ? routePhase(options.phase, options.conserve)
+            : routeTask(description, options.conserve);
+        console.log(options.json
+            ? JSON.stringify(rec, null, 2)
+            : formatRouteRecommendation(rec));
+    });
     program
         .command("completion")
         .description("Print a shell-completion script; redirect it to your shell profile")

package/dist/src/commands/inventory.js

@@ -406,11 +406,12 @@ export function registerInventory(program) {
     program
         .command("doctor")
         .description("Check agents, skill directories, permissions, and Loadout setup")
+        .option("--verbose", "show per-component detail for each agent")
         .option("--json", "print a machine-readable report")
         .action(async (options) => {
         const report = await runDoctor();
         console.log(options.json
             ? JSON.stringify(report, null, 2)
-            : formatDoctorReport(report));
+            : formatDoctorReport(report, { verbose: options.verbose }));
     });
 }

package/dist/src/commands/support.js

@@ -1,6 +1,8 @@
 import { createInterface } from "node:readline/promises";
+import { createRequire } from "node:module";
 import { detectAgents, parseAgentSelection } from "../core/paths.js";
-import { dirname, join } from "node:path";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
 import { applyPreparedCatalogInstall, formatCatalogApplyGuidance, formatPreparedCatalogInstall, prepareCatalogInstall, } from "../core/catalog-install.js";
 import { formatInstalledSkillInventory, scanInstalledSkills, } from "../core/skill-inventory.js";
 import { interactiveModelApiAccess, parseModelApiAccess, } from "../core/access.js";
@@ -213,7 +215,25 @@ export async function runWizard() {
     console.log("\nPreview first — nothing changes until you approve, and every change is snapshotted for rollback.\n");
     await runSetup({ package: [] });
 }
-export const LOADOUT_VERSION = "0.5.9";
+const _require = createRequire(import.meta.url);
+function findPackageJson() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 5; i++) {
+        const candidate = join(dir, "package.json");
+        try {
+            const pkg = _require(candidate);
+            if (pkg.name === "loadout-ai")
+                return candidate;
+        }
+        catch {
+            // not found, keep walking
+        }
+        dir = dirname(dir);
+    }
+    // ponytail: fallback for dist layout — 3 levels up from dist/src/commands/
+    return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "package.json");
+}
+export const LOADOUT_VERSION = _require(findPackageJson()).version;
 export function durableSchedulerLauncher() {
     return [
         join(dirname(process.execPath), process.platform === "win32" ? "npx.cmd" : "npx"),

package/dist/src/core/catalog.js

@@ -218,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,14 +41,14 @@ 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, compare, evaluate, capabilities, skill-audit.",
-    "Manifests and sharing: init, add, unadd, lock, export, import, audit, create, pack, publish, share, card, badge.",
-    "Integrations and safety: mcp-recipe, mcp-config, codex-mcp-config, credentials, models, sandbox-run, canary, convert.",
-    "Lifecycle extras: plan, adopt, uninstall, profiles, versions, outcomes, improve, autopilot, tool, watch, schedule, unschedule, serve.",
+    "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");
 /**
  * The first-screen help shows only the everyday core (~24 commands). Everything
@@ -93,6 +93,7 @@ export const HIDDEN_FROM_FIRST_SCREEN = new Set([
     // integrations / credentials / runtime
     "credentials",
     "models",
+    "handoff",
     "completion",
     "mcp-recipe",
     "mcp-config",

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/handoff.js

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

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

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