@dsalazardev/ai-hub-cli 0.1.0 → 0.3.0

package/dist/cli/run.js

@@ -14,6 +14,7 @@ import { cmdWorktrees } from './worktrees.js';
 import { cliVersion } from './onboarding.js';
 import { sourceCheckout } from './source.js';
 import { processIO } from './types.js';
+import { defaultRunner } from '../speckit/runner.js';
 function printLockCheck(result, ctx) {
     const header = `destinos esperados ${result.expectedCount} / actuales ${result.actualCount} · sources ${result.expectedSourceCount}/${result.actualSourceCount}`;
     const extraCategories = result.breakdown.other > 0 ? `, other ${result.breakdown.other}` : '';
@@ -101,8 +102,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 +111,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,16 +133,18 @@ 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) {
+export async function createContext(cwd, io, exec = defaultRunner) {
     try {
         const location = resolveAiHubDir(cwd);
-        return { cwd, root: location.dir, source: location.source, io };
+        return { cwd, root: location.dir, source: location.source, io, exec };
     }
     catch (error) {
         if (error instanceof AiHubDirNotFoundError) {
-            return { cwd, root: cwd, source: null, io };
+            return { cwd, root: cwd, source: null, io, exec };
         }
         throw error;
     }
@@ -150,7 +153,7 @@ export async function runCli(argv, options = {}) {
     const io = options.io ?? processIO;
     const cwd = options.cwd ?? process.cwd();
     const [command, ...rest] = argv;
-    const ctx = await createContext(cwd, io);
+    const ctx = await createContext(cwd, io, options.exec);
     if (!command) {
         printHelp(io);
         return 2;

package/dist/cli/types.d.ts

@@ -1,4 +1,5 @@
 import type { AiHubSource } from '../paths.js';
+import type { ProcessRunner } from '../speckit/runner.js';
 export interface CliIO {
     out(message: string): void;
     err(message: string): void;
@@ -8,6 +9,8 @@ export interface CliContext {
     root: string;
     source: AiHubSource | null;
     io: CliIO;
+    /** Ejecutor de procesos externos (uvx, bash); los tests lo sustituyen. */
+    exec: ProcessRunner;
 }
 export interface ParsedArgs {
     positionals: string[];

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/engine.d.ts

@@ -28,15 +28,33 @@ export interface EngineCommand {
     exit: string[];
     role: string;
     co_roles?: string[];
-    skill: string;
+    /** Id canónico del comando en Spec Kit, en notación con punto (`speckit.bug.assess`). */
+    speckit: string;
 }
+export type SpeckitScript = 'sh' | 'ps';
+/** Dependencia de Spec Kit fijada por el paquete; un proyecto solo puede restringirla. */
+export interface EngineSpeckit {
+    package: string;
+    pin: string;
+    supported: string;
+    excludeNewer: string;
+    script: SpeckitScript;
+    extensions: Record<string, string>;
+}
+/** Extensiones de Spec Kit que proveen los 8 comandos de assessment y bug fix. */
+export declare const REQUIRED_SPECKIT_EXTENSIONS: readonly ["assess", "bug"];
 export interface EngineManifest {
     version: 2;
     roles: EngineRole[];
     commands: EngineCommand[];
+    /** Efecto de cada estado de salida sobre las etiquetas; tabla única proyectada en la regla de enlace. */
+    exit_effects: Record<string, string>;
     labels: string[];
     targets: string[];
+    speckit: EngineSpeckit;
 }
+/** Estados de salida que el vocabulario normalizado de Spec Kit retiró. */
+export declare const RETIRED_EXIT_STATES: readonly ["ROOT_CAUSE", "NEEDS_DATA", "FIXED", "RESOLVED", "OPEN", "DRAFT", "READY"];
 export declare class EngineError extends Error {
     readonly errors: string[];
     constructor(errors: string[]);

package/dist/engine/engine.js

@@ -3,12 +3,17 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Ajv } from 'ajv';
 import { parse } from 'yaml';
+import { satisfiesRange } from '../speckit/version.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const ENGINE_PATH = path.join(__dirname, '..', '..', 'engine', 'engine.yaml');
 const SCHEMA_PATH = path.join(__dirname, '..', '..', 'schema', 'engine.schema.json');
 export const ENGINE_SKILLS_DIR = path.join(__dirname, '..', '..', 'skills', 'shared');
 export const ENGINE_COUNTS = { roles: 8, commands: 17, labels: 7 };
 export const ENGINE_LANES = { assessment: 5, feature: 9, bug: 3 };
+/** Extensiones de Spec Kit que proveen los 8 comandos de assessment y bug fix. */
+export const REQUIRED_SPECKIT_EXTENSIONS = ['assess', 'bug'];
+/** Estados de salida que el vocabulario normalizado de Spec Kit retiró. */
+export const RETIRED_EXIT_STATES = ['ROOT_CAUSE', 'NEEDS_DATA', 'FIXED', 'RESOLVED', 'OPEN', 'DRAFT', 'READY'];
 export class EngineError extends Error {
     errors;
     constructor(errors) {
@@ -104,6 +109,53 @@ export function crossValidate(engine) {
             errors.push(`lane "${lane}" debe tener ${count} comandos (tiene ${actual})`);
         }
     }
+    for (const id of findDuplicateIds(engine.commands.map((command) => command.speckit))) {
+        errors.push(`id de Spec Kit duplicado: ${id}`);
+    }
+    const retired = new Set(RETIRED_EXIT_STATES);
+    const states = new Set();
+    for (const command of engine.commands) {
+        for (const state of command.exit) {
+            states.add(state);
+            if (retired.has(state)) {
+                errors.push(`commands "${command.id}".exit usa el estado retirado ${state}`);
+            }
+        }
+    }
+    const effects = engine.exit_effects ?? {};
+    for (const state of [...states].sort()) {
+        if (!(state in effects)) {
+            errors.push(`exit_effects no define el efecto de ${state}`);
+        }
+    }
+    for (const state of Object.keys(effects).sort()) {
+        if (!states.has(state)) {
+            errors.push(`exit_effects.${state} no corresponde a ningún estado de salida`);
+        }
+    }
+    errors.push(...validateEngineSpeckit(engine.speckit));
+    return errors;
+}
+function validateEngineSpeckit(speckit) {
+    if (speckit === undefined) {
+        return ['falta el bloque speckit'];
+    }
+    const errors = [];
+    for (const field of ['package', 'pin', 'supported', 'excludeNewer', 'script']) {
+        if (typeof speckit[field] !== 'string' || speckit[field] === '') {
+            errors.push(`falta speckit.${field}`);
+        }
+    }
+    for (const extension of REQUIRED_SPECKIT_EXTENSIONS) {
+        if (typeof speckit.extensions?.[extension] !== 'string') {
+            errors.push(`falta speckit.extensions.${extension}`);
+        }
+    }
+    if (typeof speckit.pin === 'string' &&
+        typeof speckit.supported === 'string' &&
+        !satisfiesRange(speckit.pin, speckit.supported)) {
+        errors.push(`speckit.pin ${speckit.pin} está fuera de speckit.supported "${speckit.supported}"`);
+    }
     return errors;
 }
 export function commandById(engine, id) {

package/dist/engine/gates.d.ts

@@ -1,2 +1,18 @@
 export declare function scanLegacyArtifacts(root: string): Promise<string[]>;
 export declare function scanCoupling(root: string, terms: string[]): Promise<string[]>;
+/** Prefijos que Spec Kit reserva en los directorios de comandos de cada destino. */
+export declare const SPECKIT_RESERVED_PREFIXES: readonly ["speckit-", "speckit."];
+/**
+ * Gate del catálogo publicado: ninguna skill, agente o regla puede proyectarse con un nombre
+ * del espacio reservado de Spec Kit (`speckit-*` / `speckit.*`).
+ */
+export declare function scanReservedNamespace(dirs?: {
+    skills: string;
+    agents: string;
+    rules: string;
+}): Promise<string[]>;
+/**
+ * Gate del vocabulario de estados retirado (`ROOT_CAUSE`, `FIXED`, `READY`…): devuelve
+ * `ruta:línea vocabulario obsoleto "TOKEN"` relativo a `root`.
+ */
+export declare function scanRetiredStates(files: string[] | undefined, root: string): Promise<string[]>;

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, ENGINE_RULES_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();
 }
@@ -91,3 +129,104 @@ export async function scanCoupling(root, terms) {
     }
     return findings.sort();
 }
+/** Prefijos que Spec Kit reserva en los directorios de comandos de cada destino. */
+export const SPECKIT_RESERVED_PREFIXES = ['speckit-', 'speckit.'];
+function reservedName(name) {
+    return SPECKIT_RESERVED_PREFIXES.some((prefix) => name.startsWith(prefix));
+}
+/**
+ * Gate del catálogo publicado: ninguna skill, agente o regla puede proyectarse con un nombre
+ * del espacio reservado de Spec Kit (`speckit-*` / `speckit.*`).
+ */
+export async function scanReservedNamespace(dirs = {
+    skills: ENGINE_SKILLS_DIR,
+    agents: ENGINE_AGENTS_DIR,
+    rules: ENGINE_RULES_DIR,
+}) {
+    const findings = [];
+    for (const entry of await fs.readdir(dirs.skills, { withFileTypes: true }).catch(() => [])) {
+        if (entry.isDirectory() && reservedName(entry.name)) {
+            findings.push(`skills/shared/${entry.name} (espacio reservado de Spec Kit)`);
+        }
+    }
+    for (const [kind, dir] of [['agents', dirs.agents], ['rules', dirs.rules]]) {
+        for (const name of await listNames(dir)) {
+            if (reservedName(path.basename(name))) {
+                findings.push(`${kind}/${name} (espacio reservado de Spec Kit)`);
+            }
+        }
+    }
+    return findings.sort();
+}
+async function listNames(dir, prefix = '') {
+    const names = [];
+    for (const entry of await fs.readdir(dir, { withFileTypes: true }).catch(() => [])) {
+        const rel = prefix === '' ? entry.name : `${prefix}/${entry.name}`;
+        if (entry.isDirectory()) {
+            names.push(...(await listNames(path.join(dir, entry.name), rel)));
+        }
+        else if (entry.isFile()) {
+            names.push(rel);
+        }
+    }
+    return names;
+}
+/** Estados retirados que solo existían como estado de salida: se marcan en cualquier contexto. */
+const RETIRED_ALWAYS = ['ROOT_CAUSE', 'NEEDS_DATA'];
+/** Estados retirados que también son palabras corrientes: se marcan solo usados como estado. */
+const RETIRED_IN_STATE_CONTEXT = ['FIXED', 'RESOLVED', 'OPEN', 'DRAFT', 'READY'];
+const STATE_CONTEXT = /\b(estados?|exit|exits|termina(n)? en|ends? in|outcome|veredicto|verdict)\b/i;
+function retiredInLine(line) {
+    const found = [];
+    const words = new Set(line.split(/[^A-Za-z0-9_-]+/));
+    for (const token of RETIRED_ALWAYS) {
+        if (words.has(token)) {
+            found.push(token);
+        }
+    }
+    for (const token of RETIRED_IN_STATE_CONTEXT) {
+        const quoted = line.includes(`\`${token}\``);
+        const inContext = STATE_CONTEXT.test(line) && words.has(token);
+        if (quoted || inContext) {
+            found.push(token);
+        }
+    }
+    return found;
+}
+/** Archivos que el gate revisa en el checkout del motor: motor, documentación y catálogo publicado. */
+async function retiredStateFiles(root) {
+    const files = [
+        path.join(root, 'core', 'engine', 'engine.yaml'),
+        path.join(root, 'AGENTS.md'),
+        path.join(root, 'README.md'),
+        path.join(root, 'core', 'README.md'),
+    ];
+    for (const dir of ['core/rules', 'core/agents', 'core/skills/shared']) {
+        for (const rel of await listNames(path.join(root, ...dir.split('/')))) {
+            if (TEXT_FILE.test(rel)) {
+                files.push(path.join(root, ...dir.split('/'), ...rel.split('/')));
+            }
+        }
+    }
+    return files;
+}
+/**
+ * Gate del vocabulario de estados retirado (`ROOT_CAUSE`, `FIXED`, `READY`…): devuelve
+ * `ruta:línea vocabulario obsoleto "TOKEN"` relativo a `root`.
+ */
+export async function scanRetiredStates(files, root) {
+    const findings = [];
+    for (const file of files ?? (await retiredStateFiles(root))) {
+        const text = await fs.readFile(file, 'utf8').catch(() => null);
+        if (text === null) {
+            continue;
+        }
+        const rel = path.relative(root, file).split(path.sep).join('/');
+        text.split(/\r?\n/).forEach((line, index) => {
+            for (const token of retiredInLine(line)) {
+                findings.push(`${rel}:${index + 1} vocabulario obsoleto "${token}"`);
+            }
+        });
+    }
+    return findings;
+}

package/dist/harness/memory/ledger.d.ts

@@ -49,5 +49,11 @@ export interface ResumeSummary {
         done: number;
     };
     state: ProjectState | null;
+    /** Feature de Spec Kit activa y de dónde salió: `state` (versionado) o `local` (.specify/feature.json). */
+    feature: {
+        dir: string;
+        source: 'state' | 'local';
+        pending: number;
+    } | null;
 }
 export declare function resumeLedger(root: string): Promise<ResumeSummary>;

package/dist/harness/memory/ledger.js

@@ -114,6 +114,44 @@ export function queryLedger(events, filter) {
     return events.filter((event) => (filter.changeId === undefined || event.changeId === filter.changeId) &&
         (filter.sessionId === undefined || event.sessionId === filter.sessionId));
 }
+const FEATURE_PREFIX = 'specs/';
+/**
+ * Feature de Spec Kit: la nombra `.planning/state.json` (`activeChange: specs/<feature>`) o,
+ * si no, el puntero local `.specify/feature.json`. Solo se referencia la ruta; nunca se copia
+ * el contenido de la feature a `.planning/`.
+ */
+async function activeFeature(root, state) {
+    if (state?.activeChange?.startsWith(FEATURE_PREFIX)) {
+        return { dir: state.activeChange.replace(/\/+$/, ''), source: 'state' };
+    }
+    if (state?.activeChange) {
+        return null;
+    }
+    const raw = await fs.readFile(path.join(root, '.specify', 'feature.json'), 'utf8').catch(() => null);
+    if (raw === null) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        return typeof parsed.feature_directory === 'string' && parsed.feature_directory.startsWith(FEATURE_PREFIX)
+            ? { dir: parsed.feature_directory.replace(/\/+$/, ''), source: 'local' }
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function countTasks(root, dir) {
+    const text = await fs.readFile(path.join(root, ...dir.split('/'), 'tasks.md'), 'utf8').catch(() => null);
+    if (text === null) {
+        return null;
+    }
+    const lines = text.split(/\r?\n/);
+    return {
+        total: lines.filter((line) => /^\s*-\s*\[[ xX]\]/.test(line)).length,
+        done: lines.filter((line) => /^\s*-\s*\[[xX]\]/.test(line)).length,
+    };
+}
 export async function resumeLedger(root) {
     const events = await readLedger(root, 1);
     const last = events.length > 0 ? events[events.length - 1] : null;
@@ -126,11 +164,15 @@ export async function resumeLedger(root) {
             throw error;
         }
     }
+    const feature = await activeFeature(root, state);
+    const featureTasks = feature === null ? null : await countTasks(root, feature.dir);
+    const tasks = featureTasks ?? state?.tasks ?? { total: 0, done: 0 };
     return {
         last,
-        activeChange: state?.activeChange ?? null,
+        activeChange: state?.activeChange ?? feature?.dir ?? null,
         phase: state?.phase ?? 'idle',
-        tasks: state?.tasks ?? { total: 0, done: 0 },
+        tasks,
         state,
+        feature: feature === null ? null : { ...feature, pending: tasks.total - tasks.done },
     };
 }

package/dist/manifest/manifest.d.ts

@@ -1,6 +1,8 @@
 import { ENGINE_COUNTS, type EngineManifest } from '../engine/engine.js';
 import { type ResolvedPreset } from '../presets/resolve.js';
 import type { PresetDangerPattern } from '../presets/schema.js';
+import type { SelectionMode } from '../catalog.js';
+import { type ProjectSpeckit } from '../speckit/settings.js';
 export declare const MANIFEST_FILE = "manifest.yaml";
 export declare const INVENTORY_RELATIVE = "core/manifest.json";
 export { ENGINE_COUNTS };
@@ -38,18 +40,26 @@ export interface ProjectManifest {
     skills: {
         source: string;
         publish: string[];
+        selection?: SelectionMode;
     };
     agents: {
         source: string;
         publish: string[];
+        selection?: SelectionMode;
     };
     rules: {
         source: string;
         publish: string[];
+        selection?: SelectionMode;
+    };
+    catalog?: {
+        version: string;
+        hash: string;
     };
     mcp?: {
         source: string;
     };
+    speckit?: ProjectSpeckit;
 }
 export declare class ManifestError extends Error {
     readonly errors: string[];
@@ -86,10 +96,19 @@ export interface ManifestInventory {
         id: string;
         lane: string;
         role: string;
-        skill: string;
+        speckit: string;
     }>;
     labels: string[];
     targets: string[];
+    selection?: {
+        skills: SelectionMode;
+        agents: SelectionMode;
+        rules: SelectionMode;
+    };
+    catalog?: {
+        version: string;
+        hash: string;
+    } | null;
     agents: string[];
     skills: string[];
     rules: string[];

package/dist/manifest/manifest.js

@@ -1,12 +1,14 @@
 import fs from 'node:fs/promises';
+import { existsSync } from 'node:fs';
 import { PACKAGE_NAME } from '../package-info.js';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { Ajv } from 'ajv';
 import { parse } from 'yaml';
-import { ENGINE_COUNTS, ENGINE_SKILLS_DIR, loadEngine } from '../engine/engine.js';
+import { ENGINE_COUNTS, loadEngine } from '../engine/engine.js';
 import { frontmatterString, splitFrontmatter } from '../frontmatter.js';
 import { resolvePreset } from '../presets/resolve.js';
+import { validateProjectSpeckit } from '../speckit/settings.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const SCHEMA_PATH = path.join(__dirname, '..', '..', 'schema', 'manifest.schema.json');
 const ENGINE_AGENTS = path.join(__dirname, '..', '..', 'agents');
@@ -68,6 +70,18 @@ export async function loadManifestContext(root) {
     return validateManifestData(await readManifestFile(root), root);
 }
 export async function validateManifestData(data, root = process.cwd()) {
+    if (typeof data === 'object' && data !== null && 'speckit' in data) {
+        // Los campos del motor se explican antes del schema, que solo diría "additional property".
+        const record = data;
+        const targets = Array.isArray(record.targets)
+            ? record.targets.filter((item) => typeof item === 'string')
+            : [];
+        const block = record.speckit;
+        const speckitErrors = validateProjectSpeckit(block, targets, await loadEngine());
+        if (speckitErrors.length > 0) {
+            throw new ManifestError(speckitErrors);
+        }
+    }
     const validate = await validator();
     if (!validate(data)) {
         throw new ManifestError((validate.errors ?? []).map((error) => {
@@ -104,13 +118,6 @@ export async function validateManifestData(data, root = process.cwd()) {
             errors.push(`skills.publish "${skill}" no existe en ${manifest.skills.source}`);
         }
     }
-    for (const skill of new Set(engine.commands.map((command) => command.skill))) {
-        const file = path.join(ENGINE_SKILLS_DIR, skill, 'SKILL.md');
-        skillFiles.add(file);
-        if (!(await exists(file))) {
-            errors.push(`skill del motor "${skill}" no existe en ${ENGINE_SKILLS_DIR}`);
-        }
-    }
     for (const file of skillFiles) {
         if (await exists(file)) {
             await validateCatalogFile(file, errors);
@@ -148,15 +155,20 @@ export async function validateManifestData(data, root = process.cwd()) {
     return { manifest, engine, preset };
 }
 export function inventoryPath(root) {
-    return path.join(root, INVENTORY_RELATIVE);
+    // En el checkout del motor el inventario vive en core/ porque ese es el paquete que se publica.
+    // En un proyecto consumidor pertenece a .ai-hub/, junto al arnes instalado.
+    const engineMarker = path.join(root, 'core', 'src', 'paths.ts');
+    return existsSync(engineMarker)
+        ? path.join(root, INVENTORY_RELATIVE)
+        : path.join(root, '.ai-hub', 'manifest.json');
 }
 export function buildInventory(manifest, engine) {
     const roles = engine.roles.map((role) => role.id).sort();
     const commands = [...engine.commands]
         .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
-        .map((command) => ({ id: command.id, lane: command.lane, role: command.role, skill: command.skill }));
+        .map((command) => ({ id: command.id, lane: command.lane, role: command.role, speckit: command.speckit }));
     const labels = [...engine.labels].sort();
-    const skills = [...new Set([...engine.commands.map((command) => command.skill), ...manifest.skills.publish])].sort();
+    const skills = [...new Set(manifest.skills.publish)].sort();
     const agents = [...manifest.agents.publish].sort();
     const rules = [...manifest.rules.publish].sort();
     return {
@@ -169,6 +181,18 @@ export function buildInventory(manifest, engine) {
         commands,
         labels,
         targets: [...manifest.targets].sort(),
+        ...(manifest.skills.selection !== undefined ||
+            manifest.agents.selection !== undefined ||
+            manifest.rules.selection !== undefined
+            ? {
+                selection: {
+                    skills: manifest.skills.selection ?? 'preset',
+                    agents: manifest.agents.selection ?? 'preset',
+                    rules: manifest.rules.selection ?? 'preset',
+                },
+            }
+            : {}),
+        ...(manifest.catalog !== undefined ? { catalog: manifest.catalog } : {}),
         agents,
         skills,
         rules,