loadout-ai 0.7.0 → 0.9.0

package/catalog/packages.json

@@ -116,7 +116,7 @@
     "description": "Skills Catalog for Codex.",
     "category": "agent-skills",
     "tier": "official",
-    "license": "NOASSERTION",
+    "license": "MIT",
     "components": ["skill"],
     "operatingSystems": ["windows", "macos", "linux"],
     "stars": 23702,
@@ -139,7 +139,7 @@
     "description": "Public repository for Agent Skills.",
     "category": "agent-skills",
     "tier": "official",
-    "license": "NOASSERTION",
+    "license": "MIT",
     "components": ["skill"],
     "operatingSystems": ["windows", "macos", "linux"],
     "stars": 161108,
@@ -185,7 +185,7 @@
     "description": "Vercel's official collection of agent skills.",
     "category": "frontend-development",
     "tier": "official",
-    "license": "NOASSERTION",
+    "license": "Apache-2.0",
     "components": ["skill"],
     "operatingSystems": ["windows", "macos", "linux"],
     "stars": 29060,
@@ -810,7 +810,7 @@
     "description": "Official reference MCP servers for filesystem, Git, memory, fetching, time, and protocol testing.",
     "category": "mcp-reference",
     "tier": "official",
-    "license": "NOASSERTION",
+    "license": "MIT",
     "components": ["mcp"],
     "operatingSystems": ["windows", "macos", "linux"],
     "stars": 88530,

package/dist/src/cli.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { Command, CommanderError } from "commander";
 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";
@@ -11,6 +12,7 @@ import { registerInventory } from "./commands/inventory.js";
 import { registerCatalog } from "./commands/catalog.js";
 import { registerMcp } from "./commands/mcp.js";
 import { registerLifecycle } from "./commands/lifecycle.js";
+import { registerCoordinate } from "./commands/coordinate.js";
 const program = new Command();
 program
     .name("loadout")
@@ -34,6 +36,17 @@ registerInventory(program);
 registerCatalog(program);
 registerMcp(program);
 registerLifecycle(program);
+registerCoordinate(program);
+registerCompletionCommands(program.commands.flatMap((command) => {
+    const subcommands = command.commands.flatMap((subcommand) => [
+        subcommand.name(),
+        ...subcommand.aliases(),
+    ]);
+    return [command.name(), ...command.aliases()].map((name) => ({
+        name,
+        subcommands,
+    }));
+}));
 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

@@ -37,7 +37,9 @@ export function registerAgents(program) {
             const snapshotId = await applyProjectActivation(plan);
             console.log(options.json
                 ? JSON.stringify({ plan, snapshotId }, null, 2)
-                : `${formatProjectActivation(plan)}\nApplied and verified. Snapshot: ${snapshotId}\nRollback: loadout rollback --snapshot ${snapshotId}`);
+                : snapshotId
+                    ? `${formatProjectActivation(plan)}\nApplied and verified. Snapshot: ${snapshotId}\nRollback: loadout rollback --snapshot ${snapshotId}`
+                    : `${formatProjectActivation(plan)}\nAlready within the requested active-set limit. No changes or snapshot were needed.`);
         });
     }
     for (const action of [

package/dist/src/commands/catalog-candidate.js

@@ -0,0 +1,150 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { loadEffectiveCatalog, promoteCatalogCandidate, validateCatalog, } from "../core/catalog/catalog.js";
+import { buildCandidateDossier, buildCatalogProposal, formatCandidateDossier, formatCandidateSummaries, listDiscoveryCandidates, readCandidateDossier, verifyCandidateDossierSource, writeCandidateDossier, } from "../core/discovery/candidate-intelligence.js";
+import { markPromoted } from "../core/discovery/review-queue.js";
+import { writeFileAtomically } from "../core/install/atomic-file.js";
+export function registerCandidateCommands(program) {
+    const candidate = program
+        .command("candidate")
+        .description("Triage and statically inspect daily discovery candidates; never auto-promotes");
+    candidate
+        .command("list")
+        .allowExcessArguments(false)
+        .description("Rank discovery leads for human triage, not as universal quality")
+        .option("--limit <count>", "maximum candidates", "20")
+        .option("--query <words>", "require all search words")
+        .option("--include-reviewed", "include repositories already in the catalog")
+        .option("--feed <path>", "alternate discovered.json evidence feed")
+        .option("--json", "emit machine-readable JSON")
+        .action(async (options) => {
+        const limit = Number(options.limit);
+        if (!Number.isInteger(limit) || limit < 1 || limit > 500)
+            throw new Error("--limit must be an integer from 1 to 500");
+        const result = await listDiscoveryCandidates({
+            limit,
+            query: options.query,
+            includeReviewed: options.includeReviewed,
+            path: options.feed,
+        });
+        console.log(options.json
+            ? JSON.stringify(result, null, 2)
+            : formatCandidateSummaries(result));
+    });
+    candidate
+        .command("inspect")
+        .allowExcessArguments(false)
+        .description("Clone one lead at an immutable commit and build a static evidence dossier")
+        .argument("<repository>", "owner/repository present in the discovery feed")
+        .option("--feed <path>", "alternate discovered.json evidence feed")
+        .option("--write", "persist the dossier in private Loadout state")
+        .option("--output <path>", "persist at an explicit path (implies --write)")
+        .option("--json", "emit the complete dossier as JSON")
+        .action(async (repository, options) => {
+        const dossier = await buildCandidateDossier(repository, {
+            discoveryPath: options.feed,
+        });
+        const path = options.write || options.output
+            ? await writeCandidateDossier(dossier, options.output)
+            : undefined;
+        if (options.json)
+            return console.log(JSON.stringify({
+                dossier,
+                persisted: Boolean(path),
+                ...(path ? { path } : {}),
+            }, null, 2));
+        console.log(formatCandidateDossier(dossier));
+        if (path)
+            console.log(`Dossier: ${path}`);
+        else {
+            console.log("Preview only. Re-run with --write to persist this dossier.");
+        }
+    });
+    candidate
+        .command("propose")
+        .allowExcessArguments(false)
+        .description("Convert a reviewed dossier into a catalog-record proposal; never edits the catalog")
+        .argument("<dossier>", "persisted candidate dossier JSON")
+        .requiredOption("--id <id>", "lowercase kebab-case catalog id")
+        .requiredOption("--category <category>", "inspected catalog category")
+        .requiredOption("--platforms <ids>", "explicitly reviewed comma-separated platforms: windows,macos,linux")
+        .option("--display-name <name>", "reviewed display name")
+        .option("--description <text>", "reviewed description")
+        .option("--license <spdx>", "human-reviewed license override")
+        .option("--tier <tier>", "official, stable, trending, or community", "community")
+        .option("--approve", "confirm human review and write the proposal")
+        .option("--output <path>", "proposal JSON output path; required with --approve")
+        .option("--json", "emit machine-readable JSON")
+        .action(async (dossierPath, options) => {
+        const platforms = options.platforms
+            .split(",")
+            .map((item) => item.trim())
+            .filter(Boolean);
+        const knownPlatforms = new Set(["windows", "macos", "linux"]);
+        if (platforms.some((item) => !knownPlatforms.has(item)))
+            throw new Error("--platforms supports only windows, macos, and linux");
+        const knownTiers = new Set([
+            "official",
+            "stable",
+            "trending",
+            "community",
+        ]);
+        if (!knownTiers.has(options.tier))
+            throw new Error("--tier is invalid");
+        if (options.approve && !options.output)
+            throw new Error("--approve requires --output so catalog mutation stays separate");
+        const proposal = buildCatalogProposal(await verifyCandidateDossierSource(await readCandidateDossier(dossierPath)), {
+            id: options.id,
+            category: options.category,
+            operatingSystems: platforms,
+            tier: options.tier,
+            displayName: options.displayName,
+            description: options.description,
+            license: options.license,
+        }, await loadEffectiveCatalog());
+        const output = options.approve ? resolve(options.output) : undefined;
+        if (output)
+            await writeFileAtomically(output, `${JSON.stringify(proposal, null, 2)}\n`);
+        if (options.json)
+            return console.log(JSON.stringify({
+                proposal,
+                approved: Boolean(output),
+                catalogMutated: false,
+                ...(output ? { output } : {}),
+            }, null, 2));
+        console.log(JSON.stringify(proposal, null, 2));
+        if (!output)
+            console.log("Proposal preview only. Human review is still required; use --approve --output <path> to persist it.");
+        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.`);
+    });
+}

package/dist/src/commands/catalog-workflows.js

@@ -0,0 +1,147 @@
+import { parseAgentSelection } from "../core/agents/paths.js";
+import { applyFirstPartySkill, FIRST_PARTY_SKILLS, formatFirstPartySkillList, formatFirstPartySkillPlan, installedFirstPartySkills, planFirstPartySkill, removeFirstPartySkill, } from "../core/delegation/first-party-skills.js";
+import { applyPickup, formatHandoffStatus, formatInbox, getHandoffState, initHandoff, isHandoffInitialized, isPickupTarget, markDone, planPickup, readInbox, sendHandoff, } from "../core/delegation/handoff.js";
+import { completionCommandPaths, parseCompletionShell, renderShellCompletion, } from "../core/reporting/completion.js";
+export function registerWorkflowCommands(program) {
+    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 (options) => {
+        const installed = await installedFirstPartySkills();
+        console.log(options.json
+            ? JSON.stringify(FIRST_PARTY_SKILLS.map((skill) => ({
+                ...skill,
+                installed: installed.has(skill.id),
+            })), null, 2)
+            : formatFirstPartySkillList(installed));
+    });
+    skills
+        .command("install")
+        .description("Preview or install one Loadout skill into detected agents")
+        .argument("<id>", "skill id, for example loadout-handoff")
+        .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) }
+                : {}),
+        });
+        console.log(formatFirstPartySkillPlan(plan));
+        if (!plan.targets.length)
+            return;
+        if (!options.yes) {
+            console.log("\nPreview only. Re-run with --yes to install.");
+            return;
+        }
+        const snapshotId = await applyFirstPartySkill(plan);
+        console.log(`\nInstalled '${plan.skill.id}' for ${plan.targets.length} agent(s). Snapshot: ${snapshotId}\nStart 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;
+        }
+        const snapshotId = await removeFirstPartySkill(plan);
+        console.log(`\nRemoved '${id}' from ${present.length} agent(s). Snapshot: ${snapshotId}`);
+    });
+    const handoff = program
+        .command("handoff")
+        .description("Hand a task to your other agent, or see what has been handed to you");
+    handoff
+        .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 (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}`);
+    });
+    program
+        .command("completion")
+        .description("Print a shell-completion script; redirect it to your shell profile")
+        .argument("[shell]", "bash, zsh, fish, or powershell")
+        .option("--commands-json", "print registered command paths as JSON for tooling")
+        .action((shell, options) => {
+        if (options.commandsJson) {
+            console.log(JSON.stringify(completionCommandPaths(), null, 2));
+            return;
+        }
+        process.stdout.write(renderShellCompletion(parseCompletionShell(shell ?? "")));
+    });
+}