@dsalazardev/ai-hub-cli 0.1.0 → 0.3.0

package/dist/cli/onboarding.js

@@ -4,14 +4,20 @@ 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, removeOwned, } 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 { probeEnvironment, runSpeckitSequence, speckitPreflight, } from '../speckit/commands.js';
+import { effectiveSpeckit } from '../speckit/settings.js';
+import { checkExtensions, checkIntegrations, readSpeckitState } from '../speckit/state.js';
 import { flagList, flagString } from './args.js';
 const RC_NAME = '.ai-hubrc.json';
 export async function cliVersion() {
@@ -19,6 +25,71 @@ export async function cliVersion() {
     const pkg = JSON.parse(raw);
     return typeof pkg.version === 'string' ? pkg.version : '0.0.0';
 }
+function speckitPlan(settings) {
+    return {
+        managed: settings.managed,
+        package: settings.package,
+        version: settings.version,
+        excludeNewer: settings.excludeNewer,
+        script: settings.script,
+        defaultIntegration: settings.defaultIntegration,
+        integrations: settings.integrations,
+        extensions: settings.extensions,
+    };
+}
+/** Bloque `speckit` a escribir: conserva las restricciones del proyecto y fija `managed`. */
+function speckitBlock(existing, managed) {
+    return { ...(existing ?? {}), managed };
+}
+function speckitSettingsFor(targets, block, engine) {
+    return effectiveSpeckit({ targets, speckit: block }, engine);
+}
+async function environmentFor(settings, ctx) {
+    if (!settings.managed) {
+        return { skipped: 'Spec Kit no gestionado (--no-speckit)' };
+    }
+    return probeEnvironment(settings, ctx.exec, ctx.root);
+}
+/** Preflight de Spec Kit; devuelve `false` y explica el motivo si hay que salir con 2. */
+async function preflightOrReport(settings, ctx) {
+    const preflight = await speckitPreflight(settings, ctx.exec, ctx.root);
+    if (!preflight.ok) {
+        ctx.io.err('preflight de Spec Kit fallido; no se escribió nada:');
+        for (const problem of preflight.problems) {
+            ctx.io.err(`  - ${problem}`);
+        }
+    }
+    return preflight.ok;
+}
+/** Ejecuta la secuencia de Spec Kit; devuelve `false` y explica cómo restaurar si falla. */
+async function installSpeckit(settings, ctx, backupId) {
+    const result = await runSpeckitSequence(settings, ctx.exec, ctx.root);
+    const problems = [];
+    if (!result.ok) {
+        problems.push(result.failure ?? 'fallo desconocido');
+    }
+    else {
+        // Paso 9d: la secuencia solo cuenta si deja las integraciones y extensiones esperadas.
+        const state = await readSpeckitState(ctx.root);
+        problems.push(...checkIntegrations(settings, state), ...(await checkExtensions(ctx.root, settings, state)));
+    }
+    if (problems.length > 0) {
+        ctx.io.err('Spec Kit no quedó instalado como se esperaba:');
+        for (const problem of problems) {
+            ctx.io.err(`  - ${problem}`);
+        }
+        if (backupId !== null) {
+            ctx.io.err(`restaura el estado previo con: ai-hub restore ${backupId}`);
+        }
+        return false;
+    }
+    return true;
+}
+function speckitSummary(settings) {
+    return settings.managed
+        ? `Spec Kit ${settings.version} · script ${settings.script} · integraciones ${settings.integrations.join(', ')}`
+        : 'Spec Kit no gestionado (--no-speckit): el arnés queda degradado; ejecuta ai-hub install para activarlo';
+}
 function projectId(root) {
     const base = path.basename(path.resolve(root)).toLowerCase();
     const id = base.replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
@@ -27,9 +98,104 @@ 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) {
+        const retired = new Set(await retiredCatalogSkills(existing.skills.publish));
+        return {
+            modes: {
+                skills: existing.skills.selection ?? 'preset',
+                agents: existing.agents.selection ?? 'preset',
+                rules: existing.rules.selection ?? 'preset',
+            },
+            skills: existing.skills.publish.filter((id) => !retired.has(id)),
+            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, speckit) {
+    const manifest = {
         version: 2,
         project: { id, name: id },
         preset: { id: preset.id, version: preset.version, source: 'package' },
@@ -49,22 +215,113 @@ 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' } } : {}),
+        speckit,
+    };
+    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();
+    // Los 17 comandos los proyecta Spec Kit; AI-Hub solo proyecta las skills de proyecto.
+    void engine;
+    const allSkills = [...new Set(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 + 2; // reglas materializadas + preflight + regla de enlace de Spec Kit
+    }
+    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 +359,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 +379,29 @@ 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 speckit = speckitBlock(existing?.speckit, !args.flags['no-speckit']);
+    const speckitSettings = speckitSettingsFor(selection.targets, speckit, engine);
+    // El taller nunca ejecuta Spec Kit: su .specify/ es del mantenedor.
+    const runSpeckit = speckitSettings.managed && !sourceCheckout;
+    const write = [RC_NAME, 'manifest.yaml', '.gitignore', '.ai-hub/'];
+    if (runSpeckit) {
+        write.push('.specify/');
+    }
     if (selection.migrate) {
         write.push('.planning/state.json');
     }
@@ -127,55 +410,133 @@ export async function cmdInit(args, ctx) {
         project: id,
         preset: selection.preset.id,
         targets: selection.targets,
+        ...assets,
+        skillCount: spec.skills.length,
+        speckitCommands: engine.commands.length,
+        agentCount: spec.agents.length,
+        ruleCount: spec.rules.length + 1,
+        mcp: includeMcp,
         migrate: selection.migrate,
         write,
+        speckit: speckitPlan(speckitSettings),
     };
     const plan = { ...planBody, hash: sha256(JSON.stringify(planBody)) };
     if (!args.flags.yes || args.flags['dry-run']) {
-        ctx.io.out(JSON.stringify(plan, null, 2));
+        const environment = await environmentFor(speckitSettings, ctx);
+        ctx.io.out(JSON.stringify({ ...plan, environment }, null, 2));
         if (!args.flags['dry-run']) {
             ctx.io.out('Nada escrito. Repite con --yes para aplicar este plan.');
         }
         return 0;
     }
-    if (await exists(path.join(ctx.root, 'manifest.yaml'))) {
-        await createBackup(ctx.root, 'init');
+    if (runSpeckit && !(await preflightOrReport(speckitSettings, ctx))) {
+        return 2;
     }
-    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);
+    // Backup restaurable antes de que Spec Kit toque un proyecto existente (constitución incluida).
+    const backupId = existing || (await exists(path.join(ctx.root, '.specify')))
+        ? (await createBackup(ctx.root, 'init')).id
+        : null;
+    const materialized = await materializeSelection(ctx.root, selection.preset, spec);
+    const manifest = manifestFromSelection(id, selection.preset, selection.targets, selection.profilePackageManager, rc.guardMode ?? 'shadow', includeMcp, spec, speckit);
     await writeManifest(ctx.root, manifest);
     await writeInventory(ctx.root);
+    if (runSpeckit && !(await installSpeckit(speckitSettings, ctx, backupId))) {
+        return 1;
+    }
+    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} skills de proyecto + ${engine.commands.length} comandos Spec Kit · ${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(speckitSummary(speckitSettings));
     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];
+    const retired = new Set(await retiredCatalogSkills(skills));
+    return {
+        modes,
+        skills: [...new Set(skills.filter((id) => !exclusions.skills.has(id) && !retired.has(id)))].sort(),
+        agents: [...new Set(agents.filter((id) => !exclusions.agents.has(id)))].sort(),
+        rules: [...new Set(filterRules(rulesBase, exclusions.rules))].sort(),
+    };
+}
+/** Ids de `ids` que el catálogo publica con `runtime: false` (no instalables). */
+async function retiredCatalogSkills(ids) {
+    const retired = new Set((await catalogIndex()).retiredSkills);
+    return ids.filter((id) => retired.has(id));
+}
 export async function cmdInstall(args, ctx) {
     let context;
     try {
@@ -185,16 +546,68 @@ 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'));
+    // install sin --no-speckit reactiva Spec Kit en un arnés degradado; con la bandera lo mantiene apagado.
+    const speckit = speckitBlock(context.manifest.speckit, !args.flags['no-speckit']);
+    const speckitSettings = speckitSettingsFor(context.manifest.targets, speckit, context.engine);
+    const runSpeckit = speckitSettings.managed && !(await isEngineCheckout(ctx.root));
     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,
+            speckit: speckitPlan(speckitSettings),
         }, null, 2));
         return 0;
     }
-    const materialized = await materializePreset(ctx.root, context.preset);
+    if (runSpeckit && !(await preflightOrReport(speckitSettings, ctx))) {
+        return 2;
+    }
+    const backupId = runSpeckit ? (await createBackup(ctx.root, 'install')).id : null;
+    const materialized = await materializeSelection(ctx.root, context.preset, spec);
+    // Migración: las skills `runtime: false` salen de .ai-hub/ si las escribió ai-hub;
+    // sync retira después sus copias de los destinos.
+    for (const id of await retiredCatalogSkills(context.manifest.skills.publish)) {
+        await removeOwned(ctx.root, path.join(context.manifest.skills.source, id), true);
+    }
+    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;
+    }
+    next.speckit = speckit;
+    await writeManifest(ctx.root, next);
+    if (runSpeckit && !(await installSpeckit(speckitSettings, ctx, backupId))) {
+        return 1;
+    }
     const sync = await runSync(ctx.root, { check: false });
     await writeInventory(ctx.root);
     await ensureProjectIgnores(ctx.root);
@@ -202,32 +615,15 @@ 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} skills de proyecto + ${context.engine.commands.length} comandos Spec Kit · ${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');
+    }
+    ctx.io.out(speckitSummary(speckitSettings));
     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.d.ts

@@ -1,4 +1,5 @@
 import type { CliContext, CliIO, CommandHandler } from './types.js';
+import { type ProcessRunner } from '../speckit/runner.js';
 interface CommandSpec {
     summary: string;
     handler: CommandHandler;
@@ -6,10 +7,11 @@ interface CommandSpec {
 export declare const COMMANDS: Record<string, CommandSpec>;
 export declare const COMMAND_NAMES: string[];
 export declare function printHelp(io: CliIO): void;
-export declare function createContext(cwd: string, io: CliIO): Promise<CliContext>;
+export declare function createContext(cwd: string, io: CliIO, exec?: ProcessRunner): Promise<CliContext>;
 export interface RunCliOptions {
     cwd?: string;
     io?: CliIO;
+    exec?: ProcessRunner;
 }
 export declare function runCli(argv: string[], options?: RunCliOptions): Promise<number>;
 export {};