@dsalazardev/ai-hub-cli 0.1.0 → 0.3.0

package/dist/cli/doctor.js

@@ -1,14 +1,17 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { readAiHubRc } from '../paths.js';
-import { ENGINE_COUNTS, ENGINE_LANES, ENGINE_SKILLS_DIR } from '../engine/engine.js';
-import { scanCoupling, scanLegacyArtifacts } from '../engine/gates.js';
+import { auditSelection } from '../catalog.js';
+import { ENGINE_COUNTS, ENGINE_LANES } from '../engine/engine.js';
+import { scanCoupling, scanLegacyArtifacts, scanReservedNamespace, scanRetiredStates } from '../engine/gates.js';
 import { checkInventory, loadManifestContext, } from '../manifest/manifest.js';
 import { checkLock, runSync } from '../sync/sync.js';
 import { CONTEXT_RELATIVE, contextHash } from './context.js';
 import { TARGETS, TOOL_IDS, isToolId } from '../sync/targets.js';
 import { sourceCheckout } from './source.js';
+import { speckitDoctorChecks, speckitNotApplicable } from '../speckit/doctor.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const COUPLING_FILE = path.join(__dirname, '..', '..', 'engine', 'coupling.json');
 async function couplingRules() {
@@ -24,6 +27,45 @@ async function couplingRules() {
 async function exists(file) {
     return fs.access(file).then(() => true, () => false);
 }
+function gitOutput(root, args) {
+    const result = spawnSync('git', args, {
+        cwd: root,
+        encoding: 'utf8',
+        shell: false,
+    });
+    return {
+        status: result.status ?? 1,
+        text: `${result.stdout ?? ''}${result.stderr ?? ''}`.trim(),
+    };
+}
+function versionedDestinations(root) {
+    const inside = gitOutput(root, ['rev-parse', '--is-inside-work-tree']);
+    if (inside.status !== 0 || inside.text !== 'true') {
+        return { applicable: false, tracked: [] };
+    }
+    const listed = gitOutput(root, [
+        'ls-files',
+        '--',
+        '.claude',
+        '.opencode',
+        '.pi',
+        '.cursor',
+        '.github/skills',
+        '.github/agents',
+        '.github/instructions',
+        '.mcp.json',
+        '.cursor/mcp.json',
+        '.vscode/mcp.json',
+        'opencode.json',
+    ]);
+    if (listed.status !== 0) {
+        return { applicable: false, tracked: [] };
+    }
+    return {
+        applicable: true,
+        tracked: listed.text.split(/\r?\n/).map((line) => line.trim()).filter((line) => line !== ''),
+    };
+}
 export async function diagnose(ctx) {
     const checks = [];
     const add = (id, ok, detail) => {
@@ -32,16 +74,18 @@ export async function diagnose(ctx) {
     const source = await sourceCheckout(ctx.root);
     let manifest = null;
     let engine = null;
+    let preset = null;
     try {
         const context = await loadManifestContext(ctx.root);
         manifest = context.manifest;
         engine = context.engine;
+        preset = context.preset;
         add('manifest', true, `manifest.yaml válido (proyecto ${manifest.project.id})`);
     }
     catch (error) {
         add('manifest', false, error instanceof Error ? error.message : String(error));
     }
-    if (manifest && engine) {
+    if (manifest && engine && preset) {
         add('preset', true, `${manifest.preset.id}@${manifest.preset.version} (${manifest.preset.source})`);
         add('engine:roles', engine.roles.length === ENGINE_COUNTS.roles, `${engine.roles.length}/${ENGINE_COUNTS.roles}`);
         add('engine:commands', engine.commands.length === ENGINE_COUNTS.commands, `${engine.commands.length}/${ENGINE_COUNTS.commands}`);
@@ -60,20 +104,49 @@ export async function diagnose(ctx) {
         add('policy:optOuts', true, manifest.policy.optOuts.length === 0
             ? 'ninguno'
             : `opt-outs activos: ${manifest.policy.optOuts.join(', ')}`);
-        const missingSkills = [];
-        for (const command of engine.commands) {
-            if (!(await exists(path.join(ENGINE_SKILLS_DIR, command.skill, 'SKILL.md')))) {
-                missingSkills.push(`${command.id} -> ${command.skill}`);
-            }
+        const audit = await auditSelection(ctx.root, manifest, preset, engine);
+        const missingProjectSkills = audit.missing
+            .filter((item) => item.startsWith('skill:'))
+            .map((item) => item.slice('skill:'.length));
+        add('skills', missingProjectSkills.length === 0, missingProjectSkills.length === 0
+            ? `${manifest.skills.publish.length} skills de proyecto + ${engine.commands.length} comandos Spec Kit (${audit.modes.skills})`
+            : missingProjectSkills.map((id) => `${id} -> ${manifest.skills.source}`).join(', '));
+        const missingAgents = audit.missing
+            .filter((item) => item.startsWith('agent:'))
+            .map((item) => item.slice('agent:'.length));
+        add('agents', missingAgents.length === 0, missingAgents.length === 0
+            ? `${manifest.agents.publish.length} agentes (${audit.modes.agents})`
+            : `faltan: ${missingAgents.join(', ')}`);
+        const missingRules = audit.missing
+            .filter((item) => item.startsWith('rule:'))
+            .map((item) => item.slice('rule:'.length));
+        add('rules', missingRules.length === 0, missingRules.length === 0
+            ? `${manifest.rules.publish.length + 1} reglas universales (${audit.modes.rules})`
+            : `faltan: ${missingRules.join(', ')}`);
+        const primaryError = audit.errors.find((error) => error.includes('publish editado')) ?? audit.errors[0];
+        add('completeness', audit.errors.length === 0, audit.errors.length === 0
+            ? `skills=${audit.modes.skills} agents=${audit.modes.agents} rules=${audit.modes.rules}`
+            : primaryError);
+        if (Object.values(audit.modes).includes('full')) {
+            add('full', true, audit.warnings.length > 0 ? audit.warnings.join('; ') : 'catálogo al día');
         }
-        for (const skill of manifest.skills.publish) {
-            if (!(await exists(path.join(ctx.root, manifest.skills.source, skill, 'SKILL.md')))) {
-                missingSkills.push(`${skill} -> ${manifest.skills.source}`);
-            }
+        if (!manifest.mcp) {
+            add('mcp', true, 'MCP: no configurado');
+        }
+        else {
+            const direct = path.join(ctx.root, manifest.mcp.source);
+            const project = path.join(ctx.root, '.ai-hub', path.basename(manifest.mcp.source));
+            const present = (await exists(direct)) || (await exists(project));
+            add('mcp', present, present ? `MCP configurado (${manifest.mcp.source})` : `MCP: falta ${manifest.mcp.source}`);
+        }
+        const speckitChecks = source.isSource
+            ? speckitNotApplicable()
+            : await speckitDoctorChecks(ctx.root, manifest, engine, ctx.exec);
+        for (const check of speckitChecks) {
+            add(check.id, check.ok, check.detail);
         }
-        add('skills', missingSkills.length === 0, missingSkills.length === 0 ? '17 skills nativas + extras' : missingSkills.join(', '));
         if (source.isSource) {
-            const required = ['dist', 'schema', 'manifest.json', 'engine', 'presets', 'agents', 'skills'];
+            const required = ['dist', 'schema', 'manifest.json', 'engine', 'presets', 'rules', 'agents', 'skills'];
             const missing = required.filter((entry) => !source.files.includes(entry));
             add('package:files', missing.length === 0, missing.length === 0 ? required.join(', ') : `faltan: ${missing.join(', ')}`);
             add('package:entry', await exists(path.join(ctx.root, 'core', 'dist', 'bin', 'ai-hub.js')), 'core/dist/bin/ai-hub.js');
@@ -94,6 +167,10 @@ export async function diagnose(ctx) {
             }
             add('hooks', missingHooks.length === 0, missingHooks.length === 0 ? 'superficies presentes' : missingHooks.join(', '));
         }
+        const reserved = await scanReservedNamespace();
+        add('catalog:reserved-namespace', reserved.length === 0, reserved.length === 0
+            ? 'ningún activo del catálogo usa el espacio speckit-*/speckit.* de Spec Kit'
+            : reserved.slice(0, 5).join('; ') + (reserved.length > 5 ? ` (+${reserved.length - 5})` : ''));
         const legacy = await scanLegacyArtifacts(ctx.root);
         add('engine:no-legacy-prefix', legacy.length === 0, legacy.length === 0
             ? source.isSource
@@ -169,8 +246,22 @@ export async function diagnose(ctx) {
         const ignored = ignore.split(/\r?\n/).includes('.worktrees/');
         add('worktrees:ignored', ignored, ignored ? '.worktrees/ ignorado' : 'añade .worktrees/ a .gitignore');
     }
+    const versioning = versionedDestinations(ctx.root);
+    if (!versioning.applicable) {
+        add('versionado', true, 'no aplica (sin repositorio git)');
+    }
+    else if (versioning.tracked.length === 0) {
+        add('versionado', true, 'sin destinos generados versionados');
+    }
+    else {
+        add('versionado', true, `aviso: destinos generados versionados: ${versioning.tracked.slice(0, 5).join(', ')}${versioning.tracked.length > 5 ? ` (+${versioning.tracked.length - 5})` : ''}`);
+    }
     const coupling = await couplingRules();
     if (source.isSource) {
+        const retired = await scanRetiredStates(undefined, ctx.root);
+        add('engine:retired-states', retired.length === 0, retired.length === 0
+            ? 'sin vocabulario de estados retirado (ROOT_CAUSE, FIXED, READY…)'
+            : retired.slice(0, 5).join('; ') + (retired.length > 5 ? ` (+${retired.length - 5})` : ''));
         const findings = await scanCoupling(ctx.root, coupling.terms);
         add('engine:no-coupling', findings.length === 0, findings.length === 0
             ? 'sin términos de dominio en el motor'

package/dist/cli/items.d.ts

@@ -1,5 +1,5 @@
 import type { ParsedArgs } from './types.js';
 export declare function splitItem(args: ParsedArgs): {
-    kind: 'skill' | 'agent' | null;
+    kind: 'skill' | 'agent' | 'rule' | null;
     id: string | null;
 };

package/dist/cli/items.js

@@ -3,7 +3,7 @@ export function splitItem(args) {
     if (!first) {
         return { kind: null, id: null };
     }
-    if (first === 'skill' || first === 'agent') {
+    if (first === 'skill' || first === 'agent' || first === 'rule') {
         return { kind: first, id: second ?? null };
     }
     return { kind: null, id: first };

package/dist/cli/maintenance.js

@@ -5,15 +5,29 @@ import { createBackup, listBackups, purgeGenerated, restoreBackup } from '../bac
 import { readAiHubRc } from '../paths.js';
 import { loadManifestContext, writeInventory } from '../manifest/manifest.js';
 import { findPresetAsset } from '../presets/resolve.js';
-import { ENGINE_AGENTS, readScaffold, SCAFFOLD_RELATIVE } from '../presets/materialize.js';
+import { ENGINE_AGENTS, materializeAgent, materializeSkill, removeOwned, SCAFFOLD_RELATIVE, } from '../presets/materialize.js';
 import { ENGINE_SKILLS_DIR } from '../engine/engine.js';
+import { catalogIndex, catalogSeal, hasFullDimension } from '../catalog.js';
 import { readLock } from '../sync/lock.js';
 import { runSync } from '../sync/sync.js';
-import { cliVersion, writeManifest } from './onboarding.js';
+import { cliVersion, cmdInstall, writeManifest } from './onboarding.js';
 import { splitItem } from './items.js';
 async function exists(file) {
     return fs.access(file).then(() => true, () => false);
 }
+/** Nombres del espacio de Spec Kit: sus comandos no se añaden ni se desinstalan desde ai-hub. */
+function isSpeckitCommandName(id) {
+    return id.startsWith('speckit-') || id.startsWith('speckit.');
+}
+function markCustom(manifest, dimension) {
+    manifest[dimension].selection = 'custom';
+    if (hasFullDimension(manifest)) {
+        manifest.catalog = catalogSeal(manifest);
+    }
+    else {
+        delete manifest.catalog;
+    }
+}
 export async function cmdList(args, ctx) {
     let context;
     try {
@@ -24,11 +38,18 @@ export async function cmdList(args, ctx) {
         return 1;
     }
     const { manifest, engine, preset } = context;
+    const mode = manifest.skills.selection ?? 'preset';
     const data = {
         project: manifest.project,
         preset: { id: preset.id, version: preset.version, chain: preset.chain },
         targets: manifest.targets,
+        selection: {
+            skills: manifest.skills.selection ?? 'preset',
+            agents: manifest.agents.selection ?? 'preset',
+            rules: manifest.rules.selection ?? 'preset',
+        },
         commands: engine.commands.map((command) => ({ id: command.id, lane: command.lane, role: command.role })),
+        speckitCommands: engine.commands.map((command) => command.speckit),
         skills: manifest.skills.publish,
         agents: manifest.agents.publish,
         rules: manifest.rules.publish,
@@ -40,10 +61,11 @@ export async function cmdList(args, ctx) {
     ctx.io.out(`project: ${manifest.project.id} (${manifest.project.name})`);
     ctx.io.out(`preset: ${preset.id}@${preset.version} [${preset.chain.join(' -> ')}]`);
     ctx.io.out(`targets: ${manifest.targets.join(', ')}`);
+    ctx.io.out(`selection: skills=${data.selection.skills} agents=${data.selection.agents} rules=${data.selection.rules}`);
     ctx.io.out(`commands (${data.commands.length}): ${data.commands.map((command) => command.id).join(', ')}`);
-    ctx.io.out(`skills (${data.skills.length}): ${data.skills.join(', ') || 'solo las 17 del motor'}`);
+    ctx.io.out(`skills: ${data.skills.length} de proyecto (${mode}) + ${data.speckitCommands.length} comandos Spec Kit`);
     ctx.io.out(`agents (${data.agents.length}): ${data.agents.join(', ')}`);
-    ctx.io.out(`rules (${data.rules.length}): ${data.rules.join(', ')}`);
+    ctx.io.out(`rules: ${data.rules.length + 1} universales (${data.rules.length} materializadas + preflight)`);
     return 0;
 }
 export async function cmdAdd(args, ctx) {
@@ -52,6 +74,10 @@ export async function cmdAdd(args, ctx) {
         ctx.io.err('uso: ai-hub add <skill|agent> <id>');
         return 2;
     }
+    if (parsed.kind === 'rule') {
+        ctx.io.err('las reglas universales se seleccionan con --exclude rule:<id> en init; no se añaden con add');
+        return 2;
+    }
     let context;
     try {
         context = await loadManifestContext(ctx.root);
@@ -62,18 +88,31 @@ export async function cmdAdd(args, ctx) {
     }
     const { manifest, preset } = context;
     const id = parsed.id;
-    const engineSkill = context.engine.commands.some((command) => command.skill === id);
-    const catalogSkill = await exists(path.join(ENGINE_SKILLS_DIR, id, 'SKILL.md'));
+    if (isSpeckitCommandName(id)) {
+        ctx.io.err(`"${id}" lo provee Spec Kit; ai-hub no añade ni desinstala sus comandos`);
+        return 1;
+    }
+    const catalogSkill = (await catalogIndex()).skills.includes(id);
+    const catalogAgent = await exists(path.join(ENGINE_AGENTS, `${id}.md`));
     const kind = parsed.kind ??
-        (preset.skills.includes(id) || engineSkill || catalogSkill ? 'skill' : 'agent');
+        (preset.skills.includes(id) || catalogSkill
+            ? 'skill'
+            : catalogAgent || preset.agents.includes(id)
+                ? 'agent'
+                : null);
+    if (kind === null) {
+        ctx.io.err(`no existe "${id}" en el preset ${preset.id} ni en el catálogo del motor`);
+        return 1;
+    }
     if (kind === 'skill') {
-        if (engineSkill) {
-            ctx.io.out(`"${id}" ya forma parte de las 17 skills del motor`);
-            return 0;
-        }
         const fromPreset = preset.skills.includes(id)
             ? await findPresetAsset(preset.chain, `skills/${id}`)
             : null;
+        if (fromPreset === null && !catalogSkill) {
+            // Una skill con `runtime: false` sigue en el paquete pero no es instalable.
+            ctx.io.err(`la skill "${id}" no pertenece al catálogo instalable (no existe o declara runtime: false)`);
+            return 1;
+        }
         const source = fromPreset ?? path.join(ENGINE_SKILLS_DIR, id);
         if (!(await exists(path.join(source, 'SKILL.md')))) {
             ctx.io.err(`no existe la skill "${id}" en ${preset.id} ni en el catálogo del motor`);
@@ -84,29 +123,25 @@ export async function cmdAdd(args, ctx) {
             ctx.io.out(JSON.stringify({ dryRun: true, action: 'add', kind, id, destination }, null, 2));
             return 0;
         }
-        if (!(await exists(destination))) {
-            await fs.cp(source, destination, { recursive: true });
-        }
+        await materializeSkill(ctx.root, id, source, fromPreset ? `@preset/${preset.id}/skills/${id}` : `@engine/skills/shared/${id}`);
         manifest.skills.publish = [...new Set([...manifest.skills.publish, id])];
     }
     else {
-        if (!preset.agents.includes(id)) {
-            ctx.io.err(`el agente "${id}" no pertenece al preset ${preset.id}`);
-            return 1;
-        }
         const fromPreset = await findPresetAsset(preset.chain, `agents/${id}.md`);
         const source = fromPreset ?? path.join(ENGINE_AGENTS, `${id}.md`);
+        if (!(await exists(source))) {
+            ctx.io.err(`no existe el agente "${id}" en el catálogo ${ENGINE_AGENTS}`);
+            return 1;
+        }
         const destination = path.join(ctx.root, manifest.agents.source, `${id}.md`);
         if (args.flags['dry-run']) {
             ctx.io.out(JSON.stringify({ dryRun: true, action: 'add', kind, id, destination }, null, 2));
             return 0;
         }
-        if (!(await exists(destination))) {
-            await fs.mkdir(path.dirname(destination), { recursive: true });
-            await fs.copyFile(source, destination);
-        }
+        await materializeAgent(ctx.root, id, source, fromPreset ? `@preset/${preset.id}/agents/${id}.md` : `@engine/agents/${id}.md`);
         manifest.agents.publish = [...new Set([...manifest.agents.publish, id])];
     }
+    markCustom(manifest, kind === 'agent' ? 'agents' : 'skills');
     await writeManifest(ctx.root, manifest);
     const sync = await runSync(ctx.root, { check: false });
     await writeInventory(ctx.root);
@@ -116,7 +151,7 @@ export async function cmdAdd(args, ctx) {
 export async function cmdUninstall(args, ctx) {
     const parsed = splitItem(args);
     if (!parsed.id) {
-        ctx.io.err('uso: ai-hub uninstall <skill|agent> <id>');
+        ctx.io.err('uso: ai-hub uninstall <skill|agent|rule> <id>');
         return 2;
     }
     let context;
@@ -129,9 +164,20 @@ export async function cmdUninstall(args, ctx) {
     }
     const { manifest } = context;
     const id = parsed.id;
-    const kind = parsed.kind ?? (manifest.skills.publish.includes(id) ? 'skill' : 'agent');
-    if (kind === 'skill' && context.engine.commands.some((command) => command.skill === id)) {
-        ctx.io.err(`"${id}" es una skill del motor y no se puede desinstalar`);
+    const kind = parsed.kind ??
+        (manifest.skills.publish.includes(id)
+            ? 'skill'
+            : manifest.agents.publish.includes(id)
+                ? 'agent'
+                : manifest.rules.publish.includes(id) || id === 'skill-quality'
+                    ? 'rule'
+                    : 'agent');
+    if (isSpeckitCommandName(id)) {
+        ctx.io.err(`"${id}" lo provee Spec Kit; ai-hub no añade ni desinstala sus comandos`);
+        return 1;
+    }
+    if (kind === 'rule' && (id === 'core' || id === 'preflight')) {
+        ctx.io.err(`la regla base "${id}" no se puede desinstalar`);
         return 1;
     }
     if (args.flags['dry-run']) {
@@ -142,10 +188,22 @@ export async function cmdUninstall(args, ctx) {
     if (kind === 'skill') {
         manifest.skills.publish = manifest.skills.publish.filter((skill) => skill !== id);
         await removeOwned(ctx.root, path.join(manifest.skills.source, id), true);
+        markCustom(manifest, 'skills');
     }
-    else {
+    else if (kind === 'agent') {
         manifest.agents.publish = manifest.agents.publish.filter((agent) => agent !== id);
         await removeOwned(ctx.root, path.join(manifest.agents.source, `${id}.md`), false);
+        markCustom(manifest, 'agents');
+    }
+    else {
+        const removed = id === 'skill-quality'
+            ? manifest.rules.publish.filter((rule) => rule.startsWith('skill-quality/'))
+            : manifest.rules.publish.filter((rule) => rule === id);
+        manifest.rules.publish = manifest.rules.publish.filter((rule) => !removed.includes(rule));
+        for (const rule of removed) {
+            await removeOwned(ctx.root, path.join(manifest.rules.source, `${rule}.md`), false);
+        }
+        markCustom(manifest, 'rules');
     }
     await writeManifest(ctx.root, manifest);
     const sync = await runSync(ctx.root, { check: false });
@@ -153,30 +211,6 @@ export async function cmdUninstall(args, ctx) {
     ctx.io.out(`uninstall: ${kind} "${id}" · ${sync.removed.length} archivos eliminados`);
     return 0;
 }
-async function removeOwned(root, relative, directory) {
-    const absolute = path.join(root, relative);
-    if (!(await exists(absolute))) {
-        return;
-    }
-    const record = await readScaffold(root);
-    if (directory) {
-        const files = record.files;
-        const prefix = `${relative.split(path.sep).join('/')}/`;
-        const owned = Object.entries(files).filter(([name]) => name.startsWith(prefix));
-        if (owned.length === 0) {
-            const marker = await fs.readFile(path.join(absolute, 'SKILL.md'), 'utf8').catch(() => '');
-            if (!marker.includes('GENERADO por ai-hub')) {
-                return;
-            }
-        }
-        await fs.rm(absolute, { recursive: true, force: true });
-        return;
-    }
-    const text = await fs.readFile(absolute, 'utf8').catch(() => null);
-    if (text === null || text.includes('GENERADO por ai-hub')) {
-        await fs.rm(absolute, { force: true });
-    }
-}
 export async function cmdBackups(args, ctx) {
     const snapshots = await listBackups(ctx.root);
     if (args.flags.json) {
@@ -256,6 +290,26 @@ export async function cmdUpgrade(args, ctx) {
             return 1;
         }
     }
+    let context;
+    try {
+        context = await loadManifestContext(ctx.root);
+    }
+    catch (error) {
+        ctx.io.err(error.message);
+        return 1;
+    }
+    const refreshFull = Boolean(args.flags.full) ||
+        (hasFullDimension(context.manifest) && !args.flags['preset-only']);
+    if (refreshFull) {
+        const code = await cmdInstall({
+            positionals: [],
+            flags: args.flags.full ? { full: true } : {},
+        }, ctx);
+        if (code === 0) {
+            ctx.io.out('upgrade: dimensiones full actualizadas y sello refrescado');
+        }
+        return code;
+    }
     const result = await runSync(ctx.root, { check: false });
     ctx.io.out(`upgrade: ${result.written.length} archivos regenerados`);
     return 0;

package/dist/cli/memory.js

@@ -1,4 +1,5 @@
 import { appendLedger, queryLedger, readLedger, resumeLedger, } from '../harness/memory/ledger.js';
+import { isEngineCheckout } from '../source-checkout.js';
 import { flagList, flagString } from './args.js';
 function numberFlag(args, name) {
     const raw = flagString(args, name);
@@ -9,6 +10,10 @@ function numberFlag(args, name) {
     return Number.isFinite(value) ? value : null;
 }
 export async function cmdMemory(args, ctx) {
+    if (!(await isEngineCheckout(ctx.root))) {
+        ctx.io.out('memory: no aplica en instalación');
+        return 0;
+    }
     const sub = args.positionals[0] ?? 'list';
     if (sub === 'add') {
         const sessionId = flagString(args, 'session') ?? process.env.AI_HUB_SESSION ?? 'local';
@@ -74,6 +79,10 @@ export async function cmdMemory(args, ctx) {
         ctx.io.out(`cambio activo: ${summary.activeChange ?? 'ninguno'}`);
         ctx.io.out(`fase: ${summary.phase}`);
         ctx.io.out(`tareas: ${summary.tasks.done}/${summary.tasks.total}`);
+        if (summary.feature !== null) {
+            ctx.io.out(`feature Spec Kit: ${summary.feature.dir} · ${summary.feature.pending} pendientes` +
+                (summary.feature.source === 'local' ? ' (puntero local .specify/feature.json, no versionado)' : ''));
+        }
         ctx.io.out(last === null
             ? 'ledger: sin eventos'
             : `último evento: ${last.event} ${last.timestamps.at} ${last.sessionId} (${last.branch ?? '-'})`);

package/dist/cli/onboarding.d.ts

@@ -1,15 +1,47 @@
 import { type ProjectManifest } from '../manifest/manifest.js';
+import { type SelectionMode } from '../catalog.js';
 import type { CliContext, ParsedArgs } from './types.js';
 export declare function cliVersion(): Promise<string>;
-export interface Plan {
+export interface AssetPlan {
+    selection: SelectionMode;
+    selections: {
+        skills: SelectionMode;
+        agents: SelectionMode;
+        rules: SelectionMode;
+    };
+    skills: string[];
+    agents: string[];
+    rules: string[];
+    destinations: number;
+    files: number;
+    bytes: number;
+}
+export interface Plan extends AssetPlan {
     command: 'init';
     project: string;
     preset: string;
     targets: string[];
+    skillCount: number;
+    speckitCommands: number;
+    agentCount: number;
+    ruleCount: number;
+    mcp: boolean;
     migrate: boolean;
     write: string[];
+    speckit: SpeckitPlan;
     hash: string;
 }
+/** Intención de Spec Kit dentro del hash del plan; el entorno (uv, shell) queda fuera. */
+export interface SpeckitPlan {
+    managed: boolean;
+    package: string;
+    version: string;
+    excludeNewer: string;
+    script: string;
+    defaultIntegration: string | null;
+    integrations: string[];
+    extensions: Record<string, string>;
+}
 export declare function writeManifest(root: string, manifest: ProjectManifest): Promise<void>;
 export declare function cmdInit(args: ParsedArgs, ctx: CliContext): Promise<number>;
 export declare function cmdInstall(args: ParsedArgs, ctx: CliContext): Promise<number>;