@dsalazardev/ai-hub-cli 0.1.0 → 0.2.0

package/dist/cli/onboarding.js

@@ -4,14 +4,17 @@ import { stringify } from 'yaml';
 import { createBackup } from '../backup/snapshots.js';
 import { readAiHubRc, writeAiHubRc } from '../paths.js';
 import { detectPreset } from '../presets/detect.js';
-import { materializePreset } from '../presets/materialize.js';
+import { materializeCatalog, materializePreset, materializeUniversalRules, } from '../presets/materialize.js';
 import { resolvePreset } from '../presets/resolve.js';
 import { listPresetIds } from '../presets/schema.js';
 import { loadManifestContext, writeInventory } from '../manifest/manifest.js';
 import { emptyState, migrateLegacyState, readState, StateNotFoundError, writeState } from '../harness/memory/state.js';
 import { runSync } from '../sync/sync.js';
-import { TOOL_IDS, assertToolIds } from '../sync/targets.js';
+import { TOOL_IDS, assertToolIds, TARGETS } from '../sync/targets.js';
 import { sha256 } from '../sync/lock.js';
+import { isEngineCheckout } from '../source-checkout.js';
+import { ENGINE_AGENTS_DIR, ENGINE_RULES_DIR, catalogIndex, catalogSeal, expectedRuleIds, hasFullDimension, listCatalogAgents, listCatalogSkills, } from '../catalog.js';
+import { loadEngine } from '../engine/engine.js';
 import { flagList, flagString } from './args.js';
 const RC_NAME = '.ai-hubrc.json';
 export async function cliVersion() {
@@ -27,9 +30,103 @@ function projectId(root) {
 async function exists(file) {
     return fs.access(file).then(() => true, () => false);
 }
-function manifestFromPreset(id, preset, targets, profilePackageManager, guardMode, includeMcp) {
-    const rules = [...new Set(preset.rules.map((rule) => path.basename(rule, '.md')))];
+function overallMode(modes) {
+    return modes.skills === modes.agents && modes.agents === modes.rules ? modes.skills : 'custom';
+}
+function parseExclusions(args) {
+    const skills = new Set();
+    const agents = new Set();
+    const rules = new Set();
+    for (const item of flagList(args, 'exclude')) {
+        const separator = item.indexOf(':');
+        const kind = separator >= 0 ? item.slice(0, separator) : 'skill';
+        const id = separator >= 0 ? item.slice(separator + 1) : item;
+        if (id === '') {
+            continue;
+        }
+        if (kind === 'agent') {
+            agents.add(id);
+        }
+        else if (kind === 'rule') {
+            if (id === 'core' || id === 'preflight') {
+                throw new Error(`la regla base "${id}" no se puede excluir`);
+            }
+            rules.add(id);
+        }
+        else {
+            skills.add(id);
+        }
+    }
+    return { skills, agents, rules };
+}
+function filterRules(rules, exclusions) {
+    return rules.filter((id) => {
+        for (const excluded of exclusions) {
+            if (excluded === id || (excluded === 'skill-quality' && id.startsWith('skill-quality/'))) {
+                return false;
+            }
+        }
+        return true;
+    });
+}
+async function buildSelection(args, preset, engine, existing) {
+    const fullFlag = Boolean(args.flags.full);
+    const presetOnly = Boolean(args.flags['preset-only']);
+    if (fullFlag && presetOnly) {
+        throw new Error('--full y --preset-only son incompatibles');
+    }
+    const exclusions = parseExclusions(args);
+    const hasExclusions = exclusions.skills.size > 0 || exclusions.agents.size > 0 || exclusions.rules.size > 0;
+    if (existing && !fullFlag && !presetOnly && !hasExclusions) {
+        return {
+            modes: {
+                skills: existing.skills.selection ?? 'preset',
+                agents: existing.agents.selection ?? 'preset',
+                rules: existing.rules.selection ?? 'preset',
+            },
+            skills: [...existing.skills.publish],
+            agents: [...existing.agents.publish],
+            rules: [...existing.rules.publish],
+        };
+    }
+    const catalogSkills = await listCatalogSkills(engine);
+    const catalogAgents = await listCatalogAgents();
+    const defaultMode = presetOnly
+        ? 'preset'
+        : fullFlag
+            ? 'full'
+            : existing
+                ? (existing.skills.selection ?? 'preset')
+                : 'full';
+    const modes = {
+        skills: exclusions.skills.size > 0 ? 'custom' : defaultMode,
+        agents: exclusions.agents.size > 0 ? 'custom' : defaultMode,
+        rules: exclusions.rules.size > 0 ? 'custom' : defaultMode,
+    };
+    const skillsBase = modes.skills === 'preset'
+        ? [...preset.skills]
+        : modes.skills === 'custom' && existing
+            ? [...existing.skills.publish]
+            : [...catalogSkills];
+    const agentsBase = modes.agents === 'preset'
+        ? [...preset.agents]
+        : modes.agents === 'custom' && existing
+            ? [...existing.agents.publish]
+            : [...catalogAgents];
+    const rulesBase = modes.rules === 'preset'
+        ? expectedRuleIds('preset', preset)
+        : modes.rules === 'custom' && existing
+            ? [...existing.rules.publish]
+            : expectedRuleIds('full', preset);
     return {
+        modes,
+        skills: [...new Set(skillsBase.filter((id) => !exclusions.skills.has(id)))].sort(),
+        agents: [...new Set(agentsBase.filter((id) => !exclusions.agents.has(id)))].sort(),
+        rules: [...new Set(filterRules(rulesBase, exclusions.rules))].sort(),
+    };
+}
+function manifestFromSelection(id, preset, targets, profilePackageManager, guardMode, includeMcp, selection) {
+    const manifest = {
         version: 2,
         project: { id, name: id },
         preset: { id: preset.id, version: preset.version, source: 'package' },
@@ -49,22 +146,111 @@ function manifestFromPreset(id, preset, targets, profilePackageManager, guardMod
                 ? { dangerPatterns: preset.policy.dangerPatterns }
                 : {}),
         },
-        skills: { source: '.ai-hub/skills', publish: preset.skills },
-        agents: { source: '.ai-hub/agents', publish: preset.agents },
-        rules: { source: '.ai-hub/rules', publish: rules },
-        ...(includeMcp ? { mcp: { source: preset.mcp.source } } : {}),
+        skills: { source: '.ai-hub/skills', publish: selection.skills, selection: selection.modes.skills },
+        agents: { source: '.ai-hub/agents', publish: selection.agents, selection: selection.modes.agents },
+        rules: { source: '.ai-hub/rules', publish: selection.rules, selection: selection.modes.rules },
+        ...(includeMcp ? { mcp: { source: 'mcp-manifest.yaml' } } : {}),
+    };
+    if (hasFullDimension(manifest)) {
+        manifest.catalog = catalogSeal(manifest);
+    }
+    return manifest;
+}
+function mergeMaterialized(target, source) {
+    target.written.push(...source.written);
+    target.kept.push(...source.kept);
+    target.collisions.push(...source.collisions);
+}
+async function materializeSelection(root, preset, selection) {
+    const result = { written: [], kept: [], collisions: [] };
+    mergeMaterialized(result, await materializePreset(root, preset, selection.rules));
+    if (selection.modes.rules !== 'preset') {
+        mergeMaterialized(result, await materializeUniversalRules(root, preset, selection.rules));
+    }
+    if (selection.modes.skills !== 'preset' || selection.modes.agents !== 'preset') {
+        const presetSkills = new Set(preset.skills);
+        const presetAgents = new Set(preset.agents);
+        mergeMaterialized(result, await materializeCatalog(root, selection.modes.skills === 'preset'
+            ? []
+            : selection.skills.filter((id) => !presetSkills.has(id)), selection.modes.agents === 'preset'
+            ? []
+            : selection.agents.filter((id) => !presetAgents.has(id))));
+    }
+    return result;
+}
+async function buildAssetPlan(selection, engine, targets, includeMcp) {
+    const index = await catalogIndex();
+    const engineSkills = engine.commands.map((command) => command.skill);
+    const allSkills = [...new Set([...engineSkills, ...selection.skills])];
+    const projectSkillFiles = selection.skills.reduce((total, id) => total + (index.skillFiles[id]?.length ?? 0), 0);
+    const skillFiles = allSkills.reduce((total, id) => total + (index.skillFiles[id]?.length ?? 0), 0);
+    let destinations = 1; // opencode.json
+    for (const tool of targets) {
+        const target = TARGETS[tool];
+        destinations += target.skillShape === 'file' ? allSkills.length : skillFiles;
+        if (target.agents) {
+            destinations += selection.agents.length;
+        }
+        destinations += selection.rules.length + 1; // reglas materializadas + preflight
+    }
+    if (includeMcp) {
+        destinations += 3;
+    }
+    const materializedFiles = projectSkillFiles + selection.agents.length + selection.rules.length + 2;
+    const files = materializedFiles + destinations;
+    let bytes = 0;
+    const stat = async (file) => fs.stat(file).then((value) => value.size, () => 0);
+    for (const id of allSkills) {
+        for (const file of index.skillFiles[id] ?? []) {
+            bytes += await stat(file);
+        }
+    }
+    for (const id of selection.agents) {
+        bytes += await stat(path.join(ENGINE_AGENTS_DIR, `${id}.md`));
+    }
+    for (const id of selection.rules) {
+        if (id.startsWith('skill-quality/')) {
+            bytes += await stat(path.join(ENGINE_RULES_DIR, `${id}.md`));
+        }
+    }
+    return {
+        selection: overallMode(selection.modes),
+        selections: selection.modes,
+        skills: selection.skills,
+        agents: selection.agents,
+        rules: selection.rules,
+        destinations,
+        files,
+        bytes,
     };
 }
 export async function writeManifest(root, manifest) {
     await fs.writeFile(path.join(root, 'manifest.yaml'), stringify(manifest), 'utf8');
 }
+const GENERATED_IGNORES = [
+    '.worktrees/',
+    '.claude/',
+    '.opencode/',
+    '.pi/',
+    '.cursor/',
+    '.github/skills/',
+    '.github/agents/',
+    '.github/instructions/',
+    '.mcp.json',
+    '.cursor/mcp.json',
+    '.vscode/mcp.json',
+    'opencode.json',
+];
 async function ensureProjectIgnores(root) {
     const file = path.join(root, '.gitignore');
     const current = await fs.readFile(file, 'utf8').catch(() => '');
-    if (!current.split(/\r?\n/).includes('.worktrees/')) {
-        const next = current === '' ? '.worktrees/\n' : `${current.replace(/\s*$/, '')}\n.worktrees/\n`;
-        await fs.writeFile(file, next, 'utf8');
+    const present = new Set(current.split(/\r?\n/).map((line) => line.trim()));
+    const missing = GENERATED_IGNORES.filter((entry) => !present.has(entry));
+    if (missing.length === 0) {
+        return;
     }
+    const base = current === '' ? '' : `${current.replace(/\s*$/, '')}\n`;
+    await fs.writeFile(file, `${base}${missing.join('\n')}\n`, 'utf8');
 }
 async function installPostMergeHook(root) {
     if (!(await exists(path.join(root, '.git')))) {
@@ -102,9 +288,13 @@ async function resolveSelection(args, ctx) {
     };
 }
 export async function cmdInit(args, ctx) {
+    const sourceCheckout = await isEngineCheckout(ctx.root);
     let selection;
     try {
         selection = await resolveSelection(args, ctx);
+        if (selection.migrate && !sourceCheckout) {
+            throw new Error('--migrate solo aplica en el checkout de desarrollo; la instalación no tiene .planning/');
+        }
     }
     catch (error) {
         ctx.io.err(error.message);
@@ -118,7 +308,22 @@ export async function cmdInit(args, ctx) {
         targets: selection.targets,
         guardMode: 'shadow',
     };
-    const write = [RC_NAME, 'manifest.yaml', '.ai-hub/'];
+    const engine = await loadEngine();
+    let existing;
+    if (await exists(path.join(ctx.root, 'manifest.yaml'))) {
+        existing = (await loadManifestContext(ctx.root).catch(() => null))?.manifest;
+    }
+    let spec;
+    try {
+        spec = await buildSelection(args, selection.preset, engine, existing);
+    }
+    catch (error) {
+        ctx.io.err(error.message);
+        return 2;
+    }
+    const includeMcp = await exists(path.join(ctx.root, 'mcp-manifest.yaml'));
+    const assets = await buildAssetPlan(spec, engine, selection.targets, includeMcp);
+    const write = [RC_NAME, 'manifest.yaml', '.gitignore', '.ai-hub/'];
     if (selection.migrate) {
         write.push('.planning/state.json');
     }
@@ -127,6 +332,11 @@ export async function cmdInit(args, ctx) {
         project: id,
         preset: selection.preset.id,
         targets: selection.targets,
+        ...assets,
+        skillCount: 17 + spec.skills.length,
+        agentCount: spec.agents.length,
+        ruleCount: spec.rules.length + 1,
+        mcp: includeMcp,
         migrate: selection.migrate,
         write,
     };
@@ -138,44 +348,100 @@ export async function cmdInit(args, ctx) {
         }
         return 0;
     }
-    if (await exists(path.join(ctx.root, 'manifest.yaml'))) {
+    if (existing) {
         await createBackup(ctx.root, 'init');
     }
-    const materialized = await materializePreset(ctx.root, selection.preset);
-    const includeMcp = await exists(path.join(ctx.root, selection.preset.mcp.source));
-    const manifest = manifestFromPreset(id, selection.preset, selection.targets, selection.profilePackageManager, rc.guardMode ?? 'shadow', includeMcp);
+    const materialized = await materializeSelection(ctx.root, selection.preset, spec);
+    const manifest = manifestFromSelection(id, selection.preset, selection.targets, selection.profilePackageManager, rc.guardMode ?? 'shadow', includeMcp, spec);
     await writeManifest(ctx.root, manifest);
     await writeInventory(ctx.root);
+    const sync = await runSync(ctx.root, { check: false });
     const existingRc = readAiHubRc(ctx.cwd);
     if (!existingRc || existingRc.version === 1 || args.flags.force) {
         writeAiHubRc(ctx.cwd, rc);
     }
-    try {
-        await readState(ctx.root);
-    }
-    catch (error) {
-        if (error instanceof StateNotFoundError) {
-            await writeState(ctx.root, emptyState(id, selection.preset.id));
+    if (sourceCheckout) {
+        try {
+            await readState(ctx.root);
         }
-        else {
-            throw error;
+        catch (error) {
+            if (error instanceof StateNotFoundError) {
+                await writeState(ctx.root, emptyState(id, selection.preset.id));
+            }
+            else {
+                throw error;
+            }
+        }
+        if (selection.migrate) {
+            await migrateLegacyState(ctx.root, id, selection.preset.id);
         }
-    }
-    if (selection.migrate) {
-        await migrateLegacyState(ctx.root, id, selection.preset.id);
     }
     await ensureProjectIgnores(ctx.root);
     if (args.flags.hooks) {
         const hook = await installPostMergeHook(ctx.root);
         ctx.io.out(`hooks: ${hook.installed ? 'post-merge instalado' : hook.reason}`);
     }
-    ctx.io.out(`init: ${selection.preset.id} · ${selection.targets.join(', ')} · ${materialized.written.length} archivos nuevos, ${materialized.kept.length} conservados, ${materialized.collisions.length} colisiones`);
+    ctx.io.out(`init: ${selection.preset.id} · skills=${spec.modes.skills} agents=${spec.modes.agents} rules=${spec.modes.rules} · ${spec.skills.length + 17} skills · ${spec.agents.length} agentes · ${spec.rules.length + 1} reglas · ${assets.destinations} destinos · ${sync.written.length} sincronizados · ${materialized.written.length} nuevos, ${materialized.kept.length} conservados, ${materialized.collisions.length} colisiones`);
     if (materialized.collisions.length > 0) {
         ctx.io.err(`colisiones (no se sobrescribieron): ${materialized.collisions.join(', ')}`);
     }
     ctx.io.out(`plan: ${plan.hash}`);
     return 0;
 }
+async function selectionForInstall(args, manifest, preset, engine) {
+    const fullFlag = Boolean(args.flags.full);
+    const presetOnly = Boolean(args.flags['preset-only']);
+    if (fullFlag && presetOnly) {
+        throw new Error('--full y --preset-only son incompatibles');
+    }
+    const exclusions = parseExclusions(args);
+    const modes = {
+        skills: exclusions.skills.size > 0
+            ? 'custom'
+            : presetOnly
+                ? 'preset'
+                : fullFlag
+                    ? 'full'
+                    : (manifest.skills.selection ?? 'preset'),
+        agents: exclusions.agents.size > 0
+            ? 'custom'
+            : presetOnly
+                ? 'preset'
+                : fullFlag
+                    ? 'full'
+                    : (manifest.agents.selection ?? 'preset'),
+        rules: exclusions.rules.size > 0
+            ? 'custom'
+            : presetOnly
+                ? 'preset'
+                : fullFlag
+                    ? 'full'
+                    : (manifest.rules.selection ?? 'preset'),
+    };
+    const catalogSkills = await listCatalogSkills(engine);
+    const catalogAgents = await listCatalogAgents();
+    const skills = modes.skills === 'full'
+        ? catalogSkills
+        : modes.skills === 'preset'
+            ? [...preset.skills]
+            : [...manifest.skills.publish];
+    const agents = modes.agents === 'full'
+        ? catalogAgents
+        : modes.agents === 'preset'
+            ? [...preset.agents]
+            : [...manifest.agents.publish];
+    const rulesBase = modes.rules === 'full'
+        ? expectedRuleIds('full', preset)
+        : modes.rules === 'preset'
+            ? expectedRuleIds('preset', preset)
+            : [...manifest.rules.publish];
+    return {
+        modes,
+        skills: [...new Set(skills.filter((id) => !exclusions.skills.has(id)))].sort(),
+        agents: [...new Set(agents.filter((id) => !exclusions.agents.has(id)))].sort(),
+        rules: [...new Set(filterRules(rulesBase, exclusions.rules))].sort(),
+    };
+}
 export async function cmdInstall(args, ctx) {
     let context;
     try {
@@ -185,16 +451,50 @@ export async function cmdInstall(args, ctx) {
         ctx.io.err(error.message);
         return 1;
     }
+    let spec;
+    try {
+        spec = await selectionForInstall(args, context.manifest, context.preset, context.engine);
+    }
+    catch (error) {
+        ctx.io.err(error.message);
+        return 2;
+    }
+    const includeMcp = await exists(path.join(ctx.root, 'mcp-manifest.yaml'));
     if (args.flags['dry-run']) {
+        const assets = await buildAssetPlan(spec, context.engine, context.manifest.targets, includeMcp);
         ctx.io.out(JSON.stringify({
             dryRun: true,
             action: 'install',
             preset: context.preset.id,
             targets: context.manifest.targets,
+            selection: spec.modes,
+            skills: spec.skills.length,
+            agents: spec.agents.length,
+            rules: spec.rules.length + 1,
+            destinations: assets.destinations,
         }, null, 2));
         return 0;
     }
-    const materialized = await materializePreset(ctx.root, context.preset);
+    const materialized = await materializeSelection(ctx.root, context.preset, spec);
+    const next = {
+        ...context.manifest,
+        skills: { ...context.manifest.skills, publish: spec.skills, selection: spec.modes.skills },
+        agents: { ...context.manifest.agents, publish: spec.agents, selection: spec.modes.agents },
+        rules: { ...context.manifest.rules, publish: spec.rules, selection: spec.modes.rules },
+    };
+    if (includeMcp) {
+        next.mcp = { source: 'mcp-manifest.yaml' };
+    }
+    else {
+        delete next.mcp;
+    }
+    if (hasFullDimension(next)) {
+        next.catalog = catalogSeal(next);
+    }
+    else {
+        delete next.catalog;
+    }
+    await writeManifest(ctx.root, next);
     const sync = await runSync(ctx.root, { check: false });
     await writeInventory(ctx.root);
     await ensureProjectIgnores(ctx.root);
@@ -202,32 +502,14 @@ export async function cmdInstall(args, ctx) {
         const hook = await installPostMergeHook(ctx.root);
         ctx.io.out(`hooks: ${hook.installed ? 'post-merge instalado' : hook.reason}`);
     }
-    ctx.io.out(`install: ${materialized.written.length} nuevos · ${materialized.kept.length} conservados · ${sync.written.length} sincronizados`);
+    ctx.io.out(`install: skills=${spec.modes.skills} agents=${spec.modes.agents} rules=${spec.modes.rules} · ${spec.skills.length + 17} skills · ${spec.agents.length} agentes · ${spec.rules.length + 1} reglas · ${materialized.written.length} nuevos · ${materialized.kept.length} conservados · ${sync.written.length} sincronizados`);
+    if (!Object.values(spec.modes).includes('full')) {
+        ctx.io.out('full: no aplica; usa install --full para expandir el catálogo');
+    }
     return 0;
 }
 export async function cmdRepair(args, ctx) {
-    let context;
-    try {
-        context = await loadManifestContext(ctx.root);
-    }
-    catch (error) {
-        ctx.io.err(error.message);
-        return 1;
-    }
-    if (args.flags['dry-run']) {
-        ctx.io.out(JSON.stringify({
-            dryRun: true,
-            action: 'repair',
-            preset: context.preset.id,
-            targets: context.manifest.targets,
-        }, null, 2));
-        return 0;
-    }
-    const materialized = await materializePreset(ctx.root, context.preset);
-    const sync = await runSync(ctx.root, { check: false });
-    await writeInventory(ctx.root);
-    ctx.io.out(`repair: ${materialized.written.length} scaffold · ${sync.written.length} archivos · ${sync.removed.length} eliminados`);
-    return 0;
+    return cmdInstall(args, ctx);
 }
 export async function availablePresets() {
     return listPresetIds();

package/dist/cli/run.js

@@ -101,8 +101,8 @@ async function cmdCheck(_args, ctx) {
 }
 export const COMMANDS = {
     init: { summary: 'Detecta el stack, elige preset y aplica un plan reproducible', handler: cmdInit },
-    install: { summary: 'Materializa el preset y sincroniza los destinos', handler: cmdInstall },
-    add: { summary: 'Añade una skill o un agente del preset', handler: cmdAdd },
+    install: { summary: 'Materializa el catálogo o el preset según la selección y sincroniza', handler: cmdInstall },
+    add: { summary: 'Añade una skill o cualquier agente del catálogo', handler: cmdAdd },
     sync: { summary: 'Proyecta las fuentes a los destinos; --check informa deriva', handler: cmdSync },
     drift: { summary: 'Informa deriva de hash sin escribir', handler: cmdDrift },
     list: { summary: 'Lista preset, targets, comandos, skills y agentes', handler: cmdList },
@@ -110,7 +110,7 @@ export const COMMANDS = {
     check: { summary: 'Alias de doctor', handler: cmdCheck },
     backups: { summary: 'Lista los snapshots disponibles', handler: cmdBackups },
     restore: { summary: 'Restaura un snapshot', handler: cmdRestore },
-    uninstall: { summary: 'Elimina una skill o agente añadido', handler: cmdUninstall },
+    uninstall: { summary: 'Elimina una skill, agente o regla añadida', handler: cmdUninstall },
     purge: { summary: 'Elimina el arnés tras crear un snapshot', handler: cmdPurge },
     upgrade: { summary: 'Actualiza el paquete y re-sincroniza', handler: cmdUpgrade },
     repair: { summary: 'Reaplica solo lo que falta o está roto', handler: cmdRepair },
@@ -132,6 +132,8 @@ export function printHelp(io) {
         io.out(`  ${name.padEnd(10)} ${COMMANDS[name].summary}`);
     }
     io.out('');
+    io.out('add agent acepta cualquier agente del catálogo, no solo los del preset.');
+    io.out('Publicación: prepublishOnly ejecuta build, manifest:build y npm test (unit + integración).');
     io.out('Compatibilidad: verify, judge (fuera del catálogo).');
 }
 export async function createContext(cwd, io) {

package/dist/concurrency.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Ejecuta `fn` sobre `items` con un máximo de promesas en vuelo, preservando
+ * el orden de los resultados. Se usa para el I/O masivo de sync y materialización.
+ */
+export declare function mapLimit<T, R>(items: readonly T[], limit: number, fn: (item: T, index: number) => Promise<R>): Promise<R[]>;

package/dist/concurrency.js

@@ -0,0 +1,23 @@
+/**
+ * Ejecuta `fn` sobre `items` con un máximo de promesas en vuelo, preservando
+ * el orden de los resultados. Se usa para el I/O masivo de sync y materialización.
+ */
+export async function mapLimit(items, limit, fn) {
+    if (items.length === 0) {
+        return [];
+    }
+    const results = new Array(items.length);
+    let next = 0;
+    const workers = Array.from({ length: Math.min(Math.max(limit, 1), items.length) }, async () => {
+        for (;;) {
+            const index = next;
+            next += 1;
+            if (index >= items.length) {
+                return;
+            }
+            results[index] = await fn(items[index], index);
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}

package/dist/engine/gates.js

@@ -1,6 +1,8 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import { isEngineCheckout } from '../source-checkout.js';
+import { ENGINE_AGENTS_DIR, catalogIndex } from '../catalog.js';
+import { ENGINE_SKILLS_DIR } from './engine.js';
 const LEGACY_SOURCE_DIRS = ['core/presets', 'core/skills', 'core/agents'];
 const LEGACY_TARGET_DIRS = [
     '.claude',
@@ -16,6 +18,23 @@ const TEXT_FILE = /\.(md|mdc|ya?ml|json|ts|js|mjs|sh|ps1|txt)$/i;
 function isLegacyName(name) {
     return name === 'opsx' || name === 'openspec' || name.startsWith('opsx-') || name.startsWith('openspec-');
 }
+async function scanFile(file, relative, findings) {
+    const name = path.basename(file);
+    if (isLegacyName(name)) {
+        findings.push(`${relative} (nombre legacy)`);
+        return;
+    }
+    if (!TEXT_FILE.test(name)) {
+        return;
+    }
+    const text = await fs.readFile(file, 'utf8').catch(() => '');
+    for (const marker of LEGACY_CONTENT) {
+        if (text.includes(marker)) {
+            findings.push(`${relative} (contiene "${marker}")`);
+            break;
+        }
+    }
+}
 async function walk(dir, relative, findings) {
     const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => null);
     if (entries === null) {
@@ -31,27 +50,46 @@ async function walk(dir, relative, findings) {
             await walk(path.join(dir, entry.name), childRelative, findings);
             continue;
         }
-        if (!entry.isFile() || !TEXT_FILE.test(entry.name)) {
-            continue;
+        if (entry.isFile()) {
+            await scanFile(path.join(dir, entry.name), childRelative, findings);
         }
-        const text = await fs.readFile(path.join(dir, entry.name), 'utf8').catch(() => '');
-        for (const marker of LEGACY_CONTENT) {
-            if (text.includes(marker)) {
-                findings.push(`${childRelative} (contiene "${marker}")`);
-                break;
-            }
+    }
+}
+async function scanInstalledCatalog(findings) {
+    const index = await catalogIndex();
+    for (const id of index.skills) {
+        for (const file of index.skillFiles[id] ?? []) {
+            const relative = `@engine/skills/shared/${id}/${path
+                .relative(path.join(ENGINE_SKILLS_DIR, id), file)
+                .split(path.sep)
+                .join('/')}`;
+            await scanFile(file, relative, findings);
+        }
+    }
+    for (const id of index.agents) {
+        await scanFile(path.join(ENGINE_AGENTS_DIR, `${id}.md`), `@engine/agents/${id}.md`, findings);
+    }
+    for (const id of Object.keys(index.ruleFiles)) {
+        for (const file of index.ruleFiles[id] ?? []) {
+            await scanFile(file, `@engine/rules/${id}.md`, findings);
         }
     }
 }
 export async function scanLegacyArtifacts(root) {
     const findings = [];
-    // En el checkout del motor los destinos de agente son el taller del mantenedor,
-    // no salida de instalación: ahí OpenSpec es legítimo. En un consumidor sí se escanean.
-    const dirs = (await isEngineCheckout(root))
-        ? LEGACY_SOURCE_DIRS
-        : [...LEGACY_SOURCE_DIRS, ...LEGACY_TARGET_DIRS];
-    for (const relative of dirs) {
-        await walk(path.join(root, ...relative.split('/')), relative, findings);
+    const engineCheckout = await isEngineCheckout(root);
+    if (engineCheckout) {
+        // En el checkout del motor los destinos de agente son el taller del mantenedor.
+        for (const relative of LEGACY_SOURCE_DIRS) {
+            await walk(path.join(root, ...relative.split('/')), relative, findings);
+        }
+    }
+    else {
+        // En una instalación se escanean el proyecto, los destinos y el catálogo del paquete.
+        for (const relative of ['.ai-hub', ...LEGACY_TARGET_DIRS]) {
+            await walk(path.join(root, ...relative.split('/')), relative, findings);
+        }
+        await scanInstalledCatalog(findings);
     }
     return findings.sort();
 }