agentic-workflow-manager 2.0.0

package/dist/src/commands/init.js

@@ -0,0 +1,181 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderInitOutcome = renderInitOutcome;
+exports.runInit = runInit;
+exports.makeConfirmExtensions = makeConfirmExtensions;
+exports.registerInitCommand = registerInitCommand;
+// src/commands/init.ts
+const fs_1 = __importDefault(require("fs"));
+const picocolors_1 = __importDefault(require("picocolors"));
+const doctor_1 = require("./doctor");
+const context_1 = require("../core/diagnostics/context");
+const bundles_1 = require("../core/bundles");
+const registries_1 = require("../core/registries");
+const orchestrator_1 = require("../core/init/orchestrator");
+const steps_1 = require("../core/init/steps");
+// ---------------------------------------------------------------------------
+// Rendering
+// ---------------------------------------------------------------------------
+function stepGlyph(action) {
+    if (action === 'applied')
+        return picocolors_1.default.green('✔');
+    if (action === 'pending')
+        return picocolors_1.default.yellow('◷');
+    if (action === 'failed')
+        return picocolors_1.default.red('✖');
+    return picocolors_1.default.dim('·');
+}
+function renderInitOutcome(o) {
+    const lines = [];
+    lines.push(picocolors_1.default.bold('AWM · init'));
+    lines.push('');
+    // --- Estado inicial ---
+    lines.push(picocolors_1.default.bold('Estado inicial'));
+    lines.push((0, doctor_1.renderReport)(o.before));
+    lines.push('');
+    // --- Acciones ---
+    lines.push(picocolors_1.default.bold('Acciones'));
+    for (const s of o.steps) {
+        const det = s.detail ? picocolors_1.default.dim(` ${s.detail}`) : '';
+        const err = s.error ? picocolors_1.default.red(` [${s.error}]`) : '';
+        lines.push(`  ${stepGlyph(s.action)} ${s.id}${det}${err}`);
+    }
+    lines.push('');
+    // --- Estado final ---
+    lines.push(picocolors_1.default.bold('Estado final'));
+    lines.push((0, doctor_1.renderReport)(o.after));
+    lines.push('');
+    // --- Summary ---
+    const pendingCount = o.pending;
+    const estado = o.after.overall === 'healthy' ? picocolors_1.default.green('sano') : picocolors_1.default.red('degradado');
+    lines.push(`estado: ${estado} · ${pendingCount} pasos requieren un agente (skills arriba)`);
+    return lines.join('\n');
+}
+async function runInit(opts = {}) {
+    const cwd = opts.cwd ?? process.cwd();
+    const agent = opts.agent ?? 'claude-code';
+    let outcome;
+    try {
+        const mergedActions = {
+            ...steps_1.defaultActions,
+            ...(opts.actions ?? {}),
+        };
+        (0, registries_1.seedBaselineRegistry)();
+        if ((0, registries_1.listRegistries)().some((r) => !fs_1.default.existsSync(r.contentRoot))) {
+            await mergedActions.syncCache();
+        }
+        const bundles = (0, bundles_1.discoverAllBundles)();
+        const ctx = (0, context_1.gatherContext)({ cwd, bundles, agent });
+        // In machineOnly mode, null out the project context so project steps are skipped
+        const effectiveCtx = opts.machineOnly
+            ? { ...ctx, project: null }
+            : ctx;
+        const confirmExtensions = makeConfirmExtensions(!!opts.yes);
+        outcome = await (0, orchestrator_1.runInitSteps)({
+            cwd,
+            ctx: effectiveCtx,
+            bundles,
+            agent,
+            installMethod: 'symlink',
+            registryRoot: (0, registries_1.capabilityRoot)('hooks') ?? '',
+            contentDir: (0, registries_1.contentRoots)()[0] ?? '',
+            sensorPacksRoot: (0, registries_1.capabilityRoot)('sensor-packs') ?? '',
+            confirmExtensions,
+            actions: mergedActions,
+        });
+    }
+    catch (err) {
+        process.stderr.write(`awm init: error interno: ${err.message}\n`);
+        return 2;
+    }
+    if (opts.json) {
+        process.stdout.write(JSON.stringify(outcome, null, 2) + '\n');
+    }
+    else {
+        process.stdout.write(renderInitOutcome(outcome) + '\n');
+    }
+    return outcome.after.overall === 'healthy' ? 0 : 1;
+}
+// ---------------------------------------------------------------------------
+// Extension confirmation factory
+// ---------------------------------------------------------------------------
+/**
+ * Builds the extension-confirmation callback. The non-`--yes` path opens a clack
+ * `multiselect`; clack crashes ("Cannot read properties of undefined (reading
+ * 'disabled')") when handed an empty options array, so we short-circuit empty
+ * `proposed` BEFORE importing/invoking it (#1, greenfield dirs detect no signals).
+ */
+function makeConfirmExtensions(yes) {
+    if (yes)
+        return async (proposed) => proposed;
+    return async (proposed, signals) => {
+        if (proposed.length === 0)
+            return [];
+        const { multiselect, isCancel } = await Promise.resolve().then(() => __importStar(require('@clack/prompts')));
+        const choice = await multiselect({
+            message: `Extensiones detectadas (${signals.join(', ')}) — ¿activar?`,
+            options: proposed.map((p) => ({ value: p, label: p })),
+            initialValues: proposed,
+            required: false,
+        });
+        if (isCancel(choice))
+            return [];
+        return choice;
+    };
+}
+// ---------------------------------------------------------------------------
+// Commander registration
+// ---------------------------------------------------------------------------
+function registerInitCommand(program) {
+    program.command('init')
+        .description('Bootstrap the AWM harness on this machine / project (idempotent)')
+        .option('-y, --yes', 'Skip confirmation prompts')
+        .option('-a, --agent <agent>', 'Target agent (default: claude-code)')
+        .option('--machine-only', 'Only run machine-level steps (skip project steps)')
+        .option('--json', 'Emit the InitOutcome as JSON')
+        .action(async (options) => {
+        const code = await runInit({
+            yes: options.yes,
+            agent: options.agent,
+            machineOnly: options.machineOnly,
+            json: options.json,
+        });
+        process.exitCode = code;
+    });
+}

package/dist/src/commands/ledger/index.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLedgerCommand = registerLedgerCommand;
+const store_1 = require("../../core/ledger/store");
+function archiveLabel() {
+    return new Date().toISOString().replace(/[-:]/g, '').replace(/\.\d+Z$/, '');
+}
+function registerLedgerCommand(program) {
+    const ledger = program.command('ledger').description('persistent per-branch findings ledger (working memory for harness-retro)');
+    ledger
+        .command('add')
+        .description('append a finding or win to the current branch ledger')
+        .requiredOption('--polarity <polarity>', 'win | finding')
+        .requiredOption('--class <class>', 'structural | logica | proceso | seguridad')
+        .requiredOption('--signature <slug>', 'dedup key for recurrence grouping')
+        .requiredOption('--severity <severity>', 'blocker | important | minor | info')
+        .requiredOption('--desc <text>', 'one-line description')
+        .option('--ref <ref>', 'file:line or PR/commit reference')
+        .option('--phase <phase>', 'lifecycle phase', 'unknown')
+        .option('--source-skill <skill>', 'emitting skill', 'unknown')
+        .option('--branch <branch>', 'override branch (default: git current branch)')
+        .action((opts) => {
+        const cwd = process.cwd();
+        const branch = opts.branch ?? (0, store_1.detectBranch)(cwd);
+        const entry = {
+            ts: new Date().toISOString(),
+            branch,
+            phase: opts.phase ?? 'unknown',
+            source_skill: opts.sourceSkill ?? 'unknown',
+            polarity: opts.polarity,
+            class: opts.class,
+            signature: opts.signature,
+            severity: opts.severity,
+            desc: opts.desc,
+            ref: opts.ref,
+        };
+        (0, store_1.addEntry)(cwd, entry);
+    });
+    ledger
+        .command('list')
+        .description('print the current branch ledger as JSON')
+        .option('--branch <branch>', 'override branch (default: git current branch)')
+        .action((opts) => {
+        const cwd = process.cwd();
+        const branch = opts.branch ?? (0, store_1.detectBranch)(cwd);
+        process.stdout.write(JSON.stringify((0, store_1.listEntries)(cwd, branch), null, 2) + '\n');
+    });
+    ledger
+        .command('recurring')
+        .description('print signature clusters with count >= min (recurrence signal)')
+        .option('--min <n>', 'minimum occurrences', '2')
+        .option('--branch <branch>', 'override branch (default: git current branch)')
+        .action((opts) => {
+        const cwd = process.cwd();
+        const branch = opts.branch ?? (0, store_1.detectBranch)(cwd);
+        const parsed = Number.parseInt(opts.min, 10);
+        const min = Number.isNaN(parsed) || parsed < 1 ? 2 : parsed;
+        process.stdout.write(JSON.stringify((0, store_1.recurring)(cwd, branch, min), null, 2) + '\n');
+    });
+    ledger
+        .command('archive')
+        .description('rotate the current branch ledger out of the active flow')
+        .option('--branch <branch>', 'override branch (default: git current branch)')
+        .action((opts) => {
+        const cwd = process.cwd();
+        const branch = opts.branch ?? (0, store_1.detectBranch)(cwd);
+        const moved = (0, store_1.archiveLedger)(cwd, branch, archiveLabel());
+        if (!moved) {
+            process.stderr.write(`awm ledger archive: no active ledger found for branch "${branch}" — nothing to archive\n`);
+        }
+        process.stdout.write(JSON.stringify({ archived: moved, branch }, null, 2) + '\n');
+    });
+}

package/dist/src/commands/pin.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setPin = setPin;
+exports.removePin = removePin;
+exports.registerPinCommands = registerPinCommands;
+const picocolors_1 = __importDefault(require("picocolors"));
+const config_1 = require("../utils/config");
+const registries_1 = require("../core/registries");
+const versioning_1 = require("../core/versioning");
+const VERSION_RE = /^v?\d+\.\d+\.\d+$/;
+function knownRegistryNames() {
+    return ['base', ...(0, registries_1.readRegistriesConfig)().map((r) => r.name)];
+}
+function assertKnownRegistry(name) {
+    const known = knownRegistryNames();
+    if (!known.includes(name)) {
+        throw new Error(`Unknown registry "${name}". Valid names: ${known.join(', ')}.`);
+    }
+}
+/** Valida y persiste pins[name] = version (normalizada sin prefijo v). */
+function setPin(name, version) {
+    assertKnownRegistry(name);
+    if (!VERSION_RE.test(version)) {
+        throw new Error(`Invalid version "${version}" — expected X.Y.Z (e.g. 1.2.0).`);
+    }
+    const normalized = (0, versioning_1.normalizePin)(version);
+    const prefs = (0, config_1.getPreferences)();
+    prefs.pins = { ...(prefs.pins ?? {}), [name]: normalized };
+    (0, config_1.savePreferences)(prefs);
+    return normalized;
+}
+/** Borra pins[name]; devuelve true si existía. */
+function removePin(name) {
+    assertKnownRegistry(name);
+    const prefs = (0, config_1.getPreferences)();
+    if (!prefs.pins || !(name in prefs.pins))
+        return false;
+    delete prefs.pins[name];
+    (0, config_1.savePreferences)(prefs);
+    return true;
+}
+function registerPinCommands(program) {
+    program.command('pin <registry> <version>')
+        .description("Pin a registry ('base' or an additional registry name) to a version tag, e.g. awm pin base 1.2.0")
+        .action((registry, version) => {
+        try {
+            const normalized = setPin(registry, version);
+            console.log(picocolors_1.default.green(`✓ ${registry} pinned to v${normalized}.`) + picocolors_1.default.dim(' Run `awm update` to apply.'));
+        }
+        catch (e) {
+            console.error(picocolors_1.default.red(e instanceof Error ? e.message : String(e)));
+            process.exit(1);
+        }
+    });
+    program.command('unpin <registry>')
+        .description('Remove the version pin of a registry (it returns to the latest tag on the next update)')
+        .action((registry) => {
+        try {
+            const removed = removePin(registry);
+            if (removed) {
+                console.log(picocolors_1.default.green(`✓ ${registry} unpinned.`) + picocolors_1.default.dim(' Run `awm update` to move to the latest tag.'));
+            }
+            else {
+                console.log(picocolors_1.default.yellow(`${registry} had no pin — nothing to do.`));
+            }
+        }
+        catch (e) {
+            console.error(picocolors_1.default.red(e instanceof Error ? e.message : String(e)));
+            process.exit(1);
+        }
+    });
+}

package/dist/src/commands/registry/add.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveRegistryName = deriveRegistryName;
+exports.addRegistry = addRegistry;
+// cli/src/commands/registry/add.ts
+// Logic for `awm registry add`, separated from commander wiring (testable without prompts).
+const fs_1 = __importDefault(require("fs"));
+const simple_git_1 = __importDefault(require("simple-git"));
+const registries_1 = require("../../core/registries");
+const discovery_1 = require("../../core/discovery");
+const bundles_1 = require("../../core/bundles");
+function deriveRegistryName(remote) {
+    const base = remote.replace(/\/+$/, '').split(/[/:]/).pop() ?? '';
+    return base.replace(/\.git$/, '');
+}
+async function addRegistry(remote, nameOverride) {
+    const name = nameOverride ?? deriveRegistryName(remote);
+    if (!name || name === '.' || /[/\\]/.test(name)) {
+        return { ok: false, error: `Invalid registry name "${name}" — use --name <simple-dir-name>` };
+    }
+    const existing = (0, registries_1.readRegistriesConfig)();
+    if (existing.some((r) => r.name === name)) {
+        return { ok: false, name, error: `Registry "${name}" already exists — remove it first with 'awm registry remove ${name}'` };
+    }
+    const dest = (0, registries_1.registryContentRoot)(name);
+    if (fs_1.default.existsSync(dest)) {
+        return { ok: false, name, error: `Destination already exists on disk: ${dest}` };
+    }
+    fs_1.default.mkdirSync(registries_1.REGISTRIES_DIR, { recursive: true });
+    try {
+        await (0, simple_git_1.default)().clone(remote, dest);
+    }
+    catch (e) {
+        fs_1.default.rmSync(dest, { recursive: true, force: true });
+        return { ok: false, name, error: `Clone failed: ${e instanceof Error ? e.message : String(e)}` };
+    }
+    if (!(0, registries_1.validateRegistryLayout)(dest)) {
+        fs_1.default.rmSync(dest, { recursive: true, force: true });
+        return {
+            ok: false,
+            name,
+            error: `Invalid registry layout: expected at least one of ${registries_1.CONTENT_DIR_NAMES.map((d) => `${d}/`).join(', ')} at the repo root of ${remote}`,
+        };
+    }
+    // Collision check against already-known content — BEFORE writing config.
+    try {
+        const roots = [...(0, registries_1.contentRoots)(), dest];
+        (0, discovery_1.discoverSkills)(roots);
+        (0, discovery_1.discoverWorkflows)(roots);
+        (0, discovery_1.discoverAgents)(roots);
+        (0, bundles_1.discoverAllBundles)(roots);
+    }
+    catch (e) {
+        fs_1.default.rmSync(dest, { recursive: true, force: true });
+        return { ok: false, name, error: e instanceof Error ? e.message : String(e) };
+    }
+    (0, registries_1.writeRegistriesConfig)([...existing, { name, remote }]);
+    return { ok: true, name, contentRoot: dest };
+}

package/dist/src/commands/registry/index.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRegistryCommand = registerRegistryCommand;
+// cli/src/commands/registry/index.ts
+const fs_1 = __importDefault(require("fs"));
+const prompts_1 = require("@clack/prompts");
+const picocolors_1 = __importDefault(require("picocolors"));
+const registries_1 = require("../../core/registries");
+const discovery_1 = require("../../core/discovery");
+const bundles_1 = require("../../core/bundles");
+const skill_integrity_1 = require("../../core/skill-integrity");
+const regenerate_1 = require("../../core/context/regenerate");
+const add_1 = require("./add");
+const remove_1 = require("./remove");
+const status_1 = require("./status");
+const config_1 = require("../../utils/config");
+const profile_1 = require("../../core/profile");
+const providers_1 = require("../../providers");
+const install_bundles_1 = require("./install-bundles");
+function registerRegistryCommand(program) {
+    const reg = program.command('registry').description('manage additional content registries (team/personal)');
+    reg.command('add <remote>')
+        .description('clone an additional registry (git URL or local path) and register it')
+        .option('--name <name>', 'registry name (default: repo basename)')
+        .option('--install-all', 'install every bundle from the new registry for the default agent')
+        .option('--no-install', 'skip the bundle install offer')
+        .action(async (remote, options) => {
+        (0, prompts_1.intro)(picocolors_1.default.bgCyan(picocolors_1.default.black(' AWM - Add Registry ')));
+        const s = (0, prompts_1.spinner)();
+        s.start('Cloning and validating registry...');
+        const result = await (0, add_1.addRegistry)(remote, options.name);
+        if (!result.ok) {
+            s.stop('Failed.');
+            console.error(picocolors_1.default.red(result.error));
+            process.exit(1);
+        }
+        s.stop(`Registry ${picocolors_1.default.cyan(result.name)} added at ${result.contentRoot}`);
+        try {
+            (0, regenerate_1.regenerateGlobalContext)();
+        }
+        catch {
+            // context regeneration must not abort a successful add
+        }
+        // Bundle install offer — failure NEVER reverts the add.
+        try {
+            const available = (0, install_bundles_1.bundlesInRegistry)(result.contentRoot);
+            if (available.length > 0) {
+                const prefs = (0, config_1.getPreferences)();
+                const projectRoot = (0, profile_1.findProjectRoot)(process.cwd()) ?? process.cwd();
+                const interactive = process.stdout.isTTY && process.stdin.isTTY;
+                let selection = null;
+                let agents = [prefs.defaultAgent];
+                if (options.install === false) {
+                    selection = null;
+                }
+                else if (options.installAll) {
+                    selection = 'all';
+                }
+                else if (interactive) {
+                    const picked = await (0, prompts_1.multiselect)({
+                        message: `Install bundles from ${result.name}?`,
+                        options: available.map((b) => ({ value: b, label: b })),
+                        required: false,
+                    });
+                    if (!(0, prompts_1.isCancel)(picked) && picked.length > 0) {
+                        selection = picked;
+                        const agentPick = await (0, prompts_1.select)({
+                            message: 'Target agent',
+                            initialValue: prefs.defaultAgent,
+                            options: Object.keys(providers_1.PROVIDERS).map((a) => ({ value: a, label: a })),
+                        });
+                        if (!(0, prompts_1.isCancel)(agentPick))
+                            agents = [agentPick];
+                        else
+                            selection = null;
+                    }
+                }
+                if (selection) {
+                    for (const r of (0, install_bundles_1.installBundlesFromRegistry)(result.contentRoot, selection, agents, projectRoot)) {
+                        for (const line of r.installed)
+                            console.log(picocolors_1.default.green(`  ✓ ${line}`));
+                        for (const sk of r.skipped)
+                            console.log(picocolors_1.default.yellow(`  ⚠  Skipped: ${sk}`));
+                    }
+                }
+                else if (options.install !== false && !interactive) {
+                    console.log(picocolors_1.default.dim(`  Bundles available: ${available.join(', ')}`));
+                    console.log(picocolors_1.default.dim(`  Install with: awm add <bundle> --agent <agent>`));
+                }
+            }
+        }
+        catch (e) {
+            console.warn(picocolors_1.default.yellow(`  ⚠  Bundle install failed (registry add is intact): ${e instanceof Error ? e.message : String(e)}`));
+        }
+        (0, prompts_1.outro)(`✅ Run ${picocolors_1.default.cyan('awm list')} to see the new content.`);
+    });
+    reg.command('list')
+        .description('list configured additional registries')
+        .action(() => {
+        const regs = (0, registries_1.listRegistries)();
+        if (regs.length === 0) {
+            console.log(picocolors_1.default.dim('No additional registries. Add one with `awm registry add <git-url>`.'));
+            return;
+        }
+        const earlier = [];
+        for (const r of regs) {
+            if (!fs_1.default.existsSync(r.contentRoot)) {
+                console.log(`${picocolors_1.default.cyan(r.name)}  ${r.remote}  ${picocolors_1.default.yellow("missing on disk — run 'awm update'")}`);
+                // Push before continue so overrides declared against this missing registry
+                // are correctly shown as "sin efecto" (orphan) rather than "active".
+                earlier.push(r.contentRoot);
+                continue;
+            }
+            try {
+                const counts = [
+                    `${(0, discovery_1.discoverSkills)([r.contentRoot]).length} skills`,
+                    `${(0, bundles_1.discoverAllBundles)([r.contentRoot]).length} bundles`,
+                    `${(0, discovery_1.discoverWorkflows)([r.contentRoot]).length} workflows`,
+                    `${(0, discovery_1.discoverAgents)([r.contentRoot]).length} agents`,
+                ].join(', ');
+                console.log(`${picocolors_1.default.cyan(r.name)}  ${r.remote}  ${picocolors_1.default.dim(counts)}`);
+                for (const o of (0, status_1.overrideStatus)(r.contentRoot, earlier)) {
+                    console.log(o.active
+                        ? picocolors_1.default.yellow(`    ↑ override activo: ${o.name}`)
+                        : picocolors_1.default.dim(`    ∅ override sin efecto: ${o.name}`));
+                }
+            }
+            catch (e) {
+                console.log(`${picocolors_1.default.cyan(r.name)}  ${r.remote}  ${picocolors_1.default.yellow(`⚠  Error reading registry: ${e instanceof Error ? e.message : String(e)}`)}`);
+            }
+            earlier.push(r.contentRoot);
+        }
+    });
+    reg.command('remove <name>')
+        .description('remove an additional registry (config + clone)')
+        .option('-y, --yes', 'skip confirmation')
+        .action(async (name, options) => {
+        (0, prompts_1.intro)(picocolors_1.default.bgCyan(picocolors_1.default.black(' AWM - Remove Registry ')));
+        if (!options.yes) {
+            const sure = await (0, prompts_1.confirm)({ message: `Remove registry "${name}" and its local clone?` });
+            if ((0, prompts_1.isCancel)(sure) || !sure) {
+                (0, prompts_1.outro)('Cancelled.');
+                return;
+            }
+        }
+        const result = (0, remove_1.removeRegistry)(name);
+        if (!result.ok) {
+            console.error(picocolors_1.default.red(result.error));
+            process.exit(1);
+        }
+        try {
+            for (const { agent, result: r } of (0, skill_integrity_1.reconcileAllSkillLinks)((0, registries_1.contentRoots)())) {
+                if (r.pruned.length > 0) {
+                    console.log(picocolors_1.default.yellow(`  ⚠  Pruned ${r.pruned.length} dead skill link(s) for ${agent}`));
+                }
+            }
+        }
+        catch {
+            // reconciliation must not abort a successful remove
+        }
+        (0, prompts_1.outro)(`✅ Registry ${picocolors_1.default.cyan(name)} removed.`);
+    });
+}

package/dist/src/commands/registry/install-bundles.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bundlesInRegistry = bundlesInRegistry;
+exports.installBundlesFromRegistry = installBundlesFromRegistry;
+// cli/src/commands/registry/install-bundles.ts
+// Instalación de bundles de un registry recién agregado (flujo post-add).
+// Separado del wiring de commander para ser testeable sin prompts.
+const bundles_1 = require("../../core/bundles");
+const bundle_install_1 = require("../../core/bundle-install");
+/** Bundles disponibles en un content root concreto (candidatos a instalar tras el add).
+ * Uses single-root discovery to avoid surfacing cross-registry collision errors here. */
+function bundlesInRegistry(contentRoot) {
+    return (0, bundles_1.discoverBundles)(contentRoot).map((b) => b.name);
+}
+/**
+ * Instala bundles del registry `contentRoot` para los agentes dados.
+ * `selection` = 'all' instala todos los del registry; una lista instala solo esos.
+ * Las dependencias se resuelven contra TODOS los roots (pueden vivir en el base).
+ */
+function installBundlesFromRegistry(contentRoot, selection, agents, projectRoot) {
+    const allBundles = (0, bundles_1.discoverAllBundles)();
+    const candidates = allBundles.filter((b) => b.contentRoot === contentRoot);
+    const wanted = selection === 'all' ? candidates : candidates.filter((b) => selection.includes(b.name));
+    const results = [];
+    for (const b of wanted) {
+        const summary = (0, bundle_install_1.addBundle)({
+            bundleName: b.name,
+            bundles: allBundles,
+            agents,
+            method: 'symlink',
+            projectRoot,
+        });
+        results.push({ bundle: b.name, installed: summary.installed, skipped: summary.skipped });
+    }
+    return results;
+}

package/dist/src/commands/registry/remove.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeRegistry = removeRegistry;
+// cli/src/commands/registry/remove.ts
+const fs_1 = __importDefault(require("fs"));
+const registries_1 = require("../../core/registries");
+function removeRegistry(name) {
+    const existing = (0, registries_1.readRegistriesConfig)();
+    if (!existing.some((r) => r.name === name)) {
+        return { ok: false, error: `Registry "${name}" not found — see 'awm registry list'` };
+    }
+    (0, registries_1.writeRegistriesConfig)(existing.filter((r) => r.name !== name));
+    fs_1.default.rmSync((0, registries_1.registryContentRoot)(name), { recursive: true, force: true });
+    return { ok: true };
+}

package/dist/src/commands/registry/status.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.overrideStatus = overrideStatus;
+// Estado de los overrides declarados por un registry: activo (tapa un artifact
+// de un root anterior) o sin efecto (huérfano — el nombre ya no existe upstream).
+const registries_1 = require("../../core/registries");
+const discovery_1 = require("../../core/discovery");
+const bundles_1 = require("../../core/bundles");
+function artifactNamesInRoot(root) {
+    const names = new Set();
+    for (const s of (0, discovery_1.discoverSkills)([root]))
+        names.add(s.name);
+    for (const w of (0, discovery_1.discoverWorkflows)([root]))
+        names.add(w.name);
+    for (const a of (0, discovery_1.discoverAgents)([root]))
+        names.add(a.name);
+    for (const b of (0, bundles_1.discoverAllBundles)([root]))
+        names.add(b.name);
+    return names;
+}
+function overrideStatus(contentRoot, earlierRoots) {
+    const declared = Array.from((0, registries_1.readRegistryManifest)(contentRoot).overrides);
+    if (declared.length === 0)
+        return [];
+    const earlier = new Set();
+    for (const root of earlierRoots) {
+        for (const n of artifactNamesInRoot(root))
+            earlier.add(n);
+    }
+    return declared.map((name) => ({ name, active: earlier.has(name) }));
+}