@dsalazardev/ai-hub-cli 0.1.0 → 0.3.0

package/README.md

@@ -7,6 +7,11 @@ el proyecto ya usa, sin acoplarse a un lenguaje ni a un dominio concreto.
 ## Requisitos
 
 - Node.js >= 22
+- [uv](https://docs.astral.sh/uv/getting-started/installation/) con `uvx` en el PATH: `init` e `install`
+  ejecutan Spec Kit con `uvx --from specify-cli==<versión fijada>`, sin `uv tool install`.
+- `bash` para los scripts `sh` de Spec Kit (por defecto en todas las plataformas). En Windows,
+  Git for Windows (Git Bash) en el PATH; el lanzador `bash` de WSL sin distribución no sirve.
+  Alternativa: `speckit.script: ps` en `manifest.yaml` (requiere PowerShell).
 
 ## Uso rápido
 
@@ -19,8 +24,40 @@ npx @dsalazardev/ai-hub-cli doctor
 ```
 
 `init` detecta el preset según el stack del repositorio y materializa `.ai-hub/`,
-que es obligatoria. `install` proyecta reglas, agentes y skills a los destinos
-declarados en `targets`. `doctor` valida motor, preset, manifiesto y deriva.
+que es obligatoria, e instala Spec Kit en la raíz con las extensiones `bug` y `assess`.
+`install` proyecta reglas, agentes y skills a los destinos declarados en `targets` y
+repite la instalación de Spec Kit. `doctor` valida motor, preset, manifiesto, deriva y
+Spec Kit.
+
+## Spec Kit
+
+Spec Kit ejecuta los 17 comandos de la metodología; AI-Hub define roles, estados y
+etiquetas. El paquete fija la versión de `specify-cli`, la de las extensiones y una
+fecha `--exclude-newer` para las dependencias de `uvx`. Esa fecha se mueve solo en un
+release, nunca automáticamente. `manifest.yaml` puede restringir la versión dentro del rango
+soportado (`speckit.version`), elegir el script (`speckit.script: sh | ps`) y la integración
+por defecto (`speckit.defaultTarget`), pero no ampliar la versión ni cambiar las extensiones.
+
+- Spec Kit se instala en `claude`, `opencode`, `pi` y `cursor` (`cursor-agent`). **Copilot
+  no recibe Spec Kit**: recibe agentes, reglas y la regla `ai-hub-speckit`.
+- Sin `uv`, sin red y sin caché para la versión fijada, o sin `bash` con `script: sh`,
+  `init` sale con código 2 **antes de escribir nada** y dice qué falta.
+- `init --no-speckit` instala sin Spec Kit y deja el arnés **degradado** (`doctor` sale 1).
+  Un `ai-hub install` posterior sin la bandera lo reactiva.
+- `.specify/` y `specs/` se versionan; las copias de los comandos en las carpetas de los
+  asistentes no, y `install` las regenera en un clon nuevo.
+
+### CI
+
+`doctor` no necesita Python, pero un clon nuevo no tiene las copias de los comandos de
+Spec Kit en las carpetas de los asistentes, que están ignoradas. El job instala `uv`,
+regenera con `install` y verifica:
+
+```yaml
+- uses: astral-sh/setup-uv@v6
+- run: npx @dsalazardev/ai-hub-cli install
+- run: npx @dsalazardev/ai-hub-cli doctor
+```
 
 Si la detección es ambigua, el preset se elige explícitamente:
 
@@ -48,14 +85,36 @@ npx @dsalazardev/ai-hub-cli install --targets claude
 | `context` | Regenera `.planning/context-next.md` |
 | `purge` | Retira los destinos generados, con snapshot previo |
 
+## Checks de Spec Kit en `doctor`
+
+`doctor` verifica la instalación de Spec Kit leyendo `.specify/` y calculando hashes; no
+ejecuta Python ni `uvx`. En el checkout del motor todos informan `no aplica`.
+
+| Check | Criterio | Reparación |
+|---|---|---|
+| `speckit:managed` | `speckit.managed` no es `false`; un arnés con `--no-speckit` es **degradado** y `doctor` sale 1 | `ai-hub install` (sin `--no-speckit`) |
+| `speckit:installed` | Existe `.specify/init-options.json` | `ai-hub install` |
+| `speckit:version` | `speckit_version` coincide con la versión fijada (o la que restrinja `speckit.version`) | `ai-hub install` |
+| `speckit:shell` | El shell del script declarado ejecuta `echo ok` (`bash` para `sh`, PowerShell para `ps`) | Instalar Git Bash/bash, o declarar `speckit.script: ps` |
+| `speckit:integrations` | `.specify/integration.json` tiene exactamente las integraciones de los destinos con Spec Kit, sin `copilot`, y la integración por defecto declarada | `ai-hub install`; si aparece `copilot`, `specify integration uninstall copilot` |
+| `speckit:targets` | Informativo: `copilot: sin Spec Kit` (recibe agentes y reglas, no comandos) | — |
+| `speckit:extensions` | `bug` y `assess` instalados en la versión fijada, registrados y presentes en cada destino con Spec Kit | `ai-hub install` |
+| `speckit:integrity` | Cada archivo de `.specify/integrations/*.manifest.json` existe; si su hash difiere solo avisa (el próximo `init` lo sobrescribe) | `ai-hub install`; personalizar con overrides de Spec Kit, no editando plantillas |
+| `speckit:collision` | Ninguna ruta de `sync.lock.json` pertenece a Spec Kit | `ai-hub sync`; no publicar skills con nombre `speckit-*` |
+| `speckit:constitution` | Aviso si `.specify/memory/constitution.md` sigue siendo la plantilla | Ejecutar `/speckit.constitution` (o `/speckit-constitution`) |
+| `speckit:versioning` | En un repositorio git no se ignoran la constitución, `init-options.json` ni `specs/` | Quitar esas rutas de `.gitignore` |
+
 ## Estructura instalada
 
 ```
 .ai-hub/            preset materializado, manifiesto y configuración (obligatoria)
-.planning/          estado, hallazgos y ledger de la sesión
-.claude/ .opencode/ .pi/ .cursor/ .github/   destinos generados según targets
+.specify/           Spec Kit: constitución, plantillas, scripts, assessments y bugs (versionado)
+specs/              features de Spec Kit: spec.md, plan.md, tasks.md (versionado)
+.claude/ .opencode/ .pi/ .cursor/ .github/   destinos generados según targets (ignorados)
 ```
 
+Una instalación no crea `.planning/`: es estado del checkout de desarrollo del motor.
+
 ## Procedencia de activos
 
 Ver `NOTICE.md` para el origen de skills y agentes reutilizados.

package/dist/backup/snapshots.js

@@ -38,6 +38,11 @@ async function walkRelative(root, relative) {
     }
     return files;
 }
+const SPECKIT_CONFIG_FILES = [
+    '.specify/init-options.json',
+    '.specify/integration.json',
+    '.specify/extensions.yml',
+];
 async function managedFiles(root) {
     const files = new Set([
         'sync.lock.json',
@@ -52,6 +57,13 @@ async function managedFiles(root) {
     for (const rel of await walkRelative(root, '.ai-hub')) {
         files.add(rel);
     }
+    // Estado de Spec Kit que un nuevo `specify init` podría tocar: constitución y configuración.
+    for (const rel of await walkRelative(root, '.specify/memory')) {
+        files.add(rel);
+    }
+    for (const rel of SPECKIT_CONFIG_FILES) {
+        files.add(rel);
+    }
     const result = [];
     for (const rel of [...files].sort()) {
         if (await exists(path.join(root, rel))) {

package/dist/catalog.d.ts

@@ -0,0 +1,83 @@
+import { type EngineManifest } from './engine/engine.js';
+import type { ProjectManifest } from './manifest/manifest.js';
+import type { ResolvedPreset } from './presets/resolve.js';
+/** Directorio de agentes dentro del paquete (core/agents). */
+export declare const ENGINE_AGENTS_DIR: string;
+/** Directorio de reglas universales dentro del paquete (core/rules). */
+export declare const ENGINE_RULES_DIR: string;
+export declare const RUBRIC_RULE_IDS: readonly ["skill-quality/skill-rubric", "skill-quality/skill-behavior-rubric", "skill-quality/skill-harden-rubric", "skill-quality/skill-migration-brief"];
+export declare const BASELINE_RULE_IDS: readonly ["core"];
+export declare const UNIVERSAL_RULE_IDS: readonly ["core", "skill-quality/skill-rubric", "skill-quality/skill-behavior-rubric", "skill-quality/skill-harden-rubric", "skill-quality/skill-migration-brief"];
+export declare const PREFLIGHT_RULE_ID = "preflight";
+export declare const UNIVERSAL_TARGET_RULE_IDS: readonly ["core", "skill-quality/skill-rubric", "skill-quality/skill-behavior-rubric", "skill-quality/skill-harden-rubric", "skill-quality/skill-migration-brief", "preflight"];
+export type SelectionMode = 'full' | 'preset' | 'custom';
+export interface SelectionScope {
+    selection?: SelectionMode;
+}
+export interface CatalogIndex {
+    skills: string[];
+    /** Skills del paquete que declaran `runtime: false`: siguen publicadas pero no son instalables. */
+    retiredSkills: string[];
+    agents: string[];
+    skillFiles: Record<string, string[]>;
+    ruleFiles: Record<string, string[]>;
+    walkCount: number;
+}
+/**
+ * Índice de las skills instalables de un directorio de catálogo. Las skills con
+ * `runtime: false` siguen en el paquete pero no se listan, materializan ni proyectan.
+ */
+export declare function buildCatalogIndexFrom(skillsDir: string): Promise<Pick<CatalogIndex, 'skills' | 'skillFiles' | 'retiredSkills'>>;
+/**
+ * Índice memoizado por proceso. En tests, `AI_HUB_CATALOG_INDEX_FILE` apunta al
+ * índice que construye `globalSetup`, de modo que todos los workers comparten un
+ * único barrido. En producción se construye desde el paquete en ejecución.
+ */
+export declare function catalogIndex(): Promise<CatalogIndex>;
+/** Reconstruye el índice ignorando la caché de archivo; lo usa el globalSetup. */
+export declare function rebuildCatalogIndex(): Promise<CatalogIndex>;
+export declare function catalogWalkCount(): number;
+export declare function resetCatalogIndex(): void;
+/** Skills instalables del catálogo; los 17 comandos los provee Spec Kit, no el catálogo. */
+export declare function listCatalogSkills(engine: EngineManifest): Promise<string[]>;
+/** Agentes de catálogo publicados en el paquete. */
+export declare function listCatalogAgents(): Promise<string[]>;
+/** Archivos de una skill del catálogo. */
+export declare function catalogSkillFiles(id: string): Promise<string[]>;
+/** Archivos de una rúbrica universal. */
+export declare function universalRuleFiles(id: string): Promise<string[]>;
+export declare function normalizeRuleId(rule: string): string;
+export declare function presetRuleIds(preset: ResolvedPreset): string[];
+export declare function expectedRuleIds(mode: SelectionMode, preset: ResolvedPreset): string[];
+export declare function selectionMode(scope: SelectionScope | undefined): SelectionMode;
+export declare function sameSelection(left: SelectionMode, right: SelectionMode): boolean;
+export declare function hasFullDimension(manifest: ProjectManifest): boolean;
+export declare function catalogHash(manifest: ProjectManifest): string;
+export declare function catalogSeal(manifest: ProjectManifest): {
+    version: string;
+    hash: string;
+};
+export declare function expectedSkills(mode: SelectionMode, preset: ResolvedPreset, engine: EngineManifest, catalog: string[]): string[] | null;
+export declare function expectedAgents(mode: SelectionMode, preset: ResolvedPreset, catalog: string[]): string[] | null;
+export declare function expectedRulesFor(mode: SelectionMode, preset: ResolvedPreset): string[] | null;
+export declare function difference(expected: string[], actual: string[]): {
+    missing: string[];
+    extra: string[];
+};
+export interface SelectionAudit {
+    mode: SelectionMode;
+    modes: {
+        skills: SelectionMode;
+        agents: SelectionMode;
+        rules: SelectionMode;
+    };
+    expectedSkills: string[] | null;
+    expectedAgents: string[] | null;
+    expectedRules: string[] | null;
+    missing: string[];
+    extra: string[];
+    errors: string[];
+    warnings: string[];
+    newAssets: number;
+}
+export declare function auditSelection(root: string, manifest: ProjectManifest, preset: ResolvedPreset, engine: EngineManifest): Promise<SelectionAudit>;

package/dist/catalog.js

@@ -0,0 +1,350 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ENGINE_SKILLS_DIR } from './engine/engine.js';
+import { PACKAGE_VERSION } from './package-info.js';
+import { sha256 } from './sync/lock.js';
+import { splitFrontmatter } from './frontmatter.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+/** Directorio de agentes dentro del paquete (core/agents). */
+export const ENGINE_AGENTS_DIR = path.join(__dirname, '..', 'agents');
+/** Directorio de reglas universales dentro del paquete (core/rules). */
+export const ENGINE_RULES_DIR = path.join(__dirname, '..', 'rules');
+export const RUBRIC_RULE_IDS = [
+    'skill-quality/skill-rubric',
+    'skill-quality/skill-behavior-rubric',
+    'skill-quality/skill-harden-rubric',
+    'skill-quality/skill-migration-brief',
+];
+export const BASELINE_RULE_IDS = ['core'];
+export const UNIVERSAL_RULE_IDS = [...BASELINE_RULE_IDS, ...RUBRIC_RULE_IDS];
+export const PREFLIGHT_RULE_ID = 'preflight';
+export const UNIVERSAL_TARGET_RULE_IDS = [...UNIVERSAL_RULE_IDS, PREFLIGHT_RULE_ID];
+let indexPromise = null;
+let walkCount = 0;
+async function walk(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => null);
+    if (entries === null) {
+        return [];
+    }
+    const files = [];
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await walk(full)));
+        }
+        else if (entry.isFile()) {
+            files.push(full);
+        }
+    }
+    return files.sort();
+}
+/** `true` si el frontmatter de la skill declara `runtime: false` (no instalable). */
+async function isRuntimeSkill(skillDir) {
+    const text = await fs.readFile(path.join(skillDir, 'SKILL.md'), 'utf8').catch(() => null);
+    if (text === null) {
+        return true;
+    }
+    try {
+        return splitFrontmatter(text, skillDir).data.runtime !== false;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Índice de las skills instalables de un directorio de catálogo. Las skills con
+ * `runtime: false` siguen en el paquete pero no se listan, materializan ni proyectan.
+ */
+export async function buildCatalogIndexFrom(skillsDir) {
+    const entries = await fs.readdir(skillsDir, { withFileTypes: true }).catch(() => []);
+    const skillFiles = {};
+    const retiredSkills = [];
+    for (const entry of entries.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        const dir = path.join(skillsDir, entry.name);
+        if (!(await isRuntimeSkill(dir))) {
+            retiredSkills.push(entry.name);
+            continue;
+        }
+        skillFiles[entry.name] = await walk(dir);
+    }
+    return { skills: Object.keys(skillFiles).sort(), skillFiles, retiredSkills: retiredSkills.sort() };
+}
+async function buildCatalogIndex() {
+    walkCount += 1;
+    const { skillFiles, retiredSkills } = await buildCatalogIndexFrom(ENGINE_SKILLS_DIR);
+    const ruleFiles = {};
+    for (const id of RUBRIC_RULE_IDS) {
+        const file = path.join(ENGINE_RULES_DIR, `${id}.md`);
+        ruleFiles[id] = (await fs.access(file).then(() => true, () => false)) ? [file] : [];
+    }
+    const agentFiles = await walk(ENGINE_AGENTS_DIR);
+    return {
+        skills: Object.keys(skillFiles).sort(),
+        agents: agentFiles
+            .filter((file) => file.endsWith('.md'))
+            .map((file) => path.basename(file, '.md'))
+            .sort(),
+        retiredSkills,
+        skillFiles,
+        ruleFiles,
+        walkCount,
+    };
+}
+async function readIndexFile(file) {
+    try {
+        const parsed = JSON.parse(await fs.readFile(file, 'utf8'));
+        if (!Array.isArray(parsed.skills) ||
+            !Array.isArray(parsed.agents) ||
+            typeof parsed.skillFiles !== 'object' ||
+            parsed.skillFiles === null ||
+            typeof parsed.ruleFiles !== 'object' ||
+            parsed.ruleFiles === null) {
+            return null;
+        }
+        return {
+            skills: parsed.skills,
+            retiredSkills: Array.isArray(parsed.retiredSkills) ? parsed.retiredSkills : [],
+            agents: parsed.agents,
+            skillFiles: parsed.skillFiles,
+            ruleFiles: parsed.ruleFiles,
+            walkCount: typeof parsed.walkCount === 'number' ? parsed.walkCount : 1,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Índice memoizado por proceso. En tests, `AI_HUB_CATALOG_INDEX_FILE` apunta al
+ * índice que construye `globalSetup`, de modo que todos los workers comparten un
+ * único barrido. En producción se construye desde el paquete en ejecución.
+ */
+export async function catalogIndex() {
+    if (indexPromise === null) {
+        indexPromise = (async () => {
+            const cacheFile = process.env.AI_HUB_CATALOG_INDEX_FILE;
+            if (cacheFile !== undefined && cacheFile !== '') {
+                const cached = await readIndexFile(cacheFile);
+                if (cached !== null) {
+                    walkCount = Math.max(walkCount, cached.walkCount);
+                    return cached;
+                }
+            }
+            return buildCatalogIndex();
+        })();
+    }
+    return indexPromise;
+}
+/** Reconstruye el índice ignorando la caché de archivo; lo usa el globalSetup. */
+export async function rebuildCatalogIndex() {
+    indexPromise = buildCatalogIndex();
+    return indexPromise;
+}
+export function catalogWalkCount() {
+    return walkCount;
+}
+export function resetCatalogIndex() {
+    indexPromise = null;
+    walkCount = 0;
+}
+/** Skills instalables del catálogo; los 17 comandos los provee Spec Kit, no el catálogo. */
+export async function listCatalogSkills(engine) {
+    void engine;
+    return (await catalogIndex()).skills;
+}
+/** Agentes de catálogo publicados en el paquete. */
+export async function listCatalogAgents() {
+    return (await catalogIndex()).agents;
+}
+/** Archivos de una skill del catálogo. */
+export async function catalogSkillFiles(id) {
+    return (await catalogIndex()).skillFiles[id] ?? [];
+}
+/** Archivos de una rúbrica universal. */
+export async function universalRuleFiles(id) {
+    return (await catalogIndex()).ruleFiles[id] ?? [];
+}
+export function normalizeRuleId(rule) {
+    return rule
+        .replace(/\\/g, '/')
+        .replace(/^\.?\//, '')
+        .replace(/^rules\//, '')
+        .replace(/\.md$/i, '');
+}
+export function presetRuleIds(preset) {
+    return [...new Set(preset.rules.map(normalizeRuleId))].sort();
+}
+export function expectedRuleIds(mode, preset) {
+    if (mode === 'preset') {
+        return presetRuleIds(preset);
+    }
+    return [...new Set([...UNIVERSAL_RULE_IDS, ...presetRuleIds(preset)])].sort();
+}
+export function selectionMode(scope) {
+    return scope?.selection ?? 'preset';
+}
+export function sameSelection(left, right) {
+    return left === right;
+}
+export function hasFullDimension(manifest) {
+    return (selectionMode(manifest.skills) === 'full' ||
+        selectionMode(manifest.agents) === 'full' ||
+        selectionMode(manifest.rules) === 'full');
+}
+export function catalogHash(manifest) {
+    const payload = {};
+    if (selectionMode(manifest.skills) === 'full') {
+        payload.skills = [...manifest.skills.publish].sort();
+    }
+    if (selectionMode(manifest.agents) === 'full') {
+        payload.agents = [...manifest.agents.publish].sort();
+    }
+    if (selectionMode(manifest.rules) === 'full') {
+        payload.rules = [...manifest.rules.publish].sort();
+    }
+    return sha256(JSON.stringify(payload));
+}
+export function catalogSeal(manifest) {
+    return { version: PACKAGE_VERSION, hash: catalogHash(manifest) };
+}
+export function expectedSkills(mode, preset, engine, catalog) {
+    if (mode === 'full') {
+        return [...catalog].sort();
+    }
+    if (mode === 'preset') {
+        return [...preset.skills].sort();
+    }
+    void engine;
+    return null;
+}
+export function expectedAgents(mode, preset, catalog) {
+    if (mode === 'full') {
+        return [...catalog].sort();
+    }
+    if (mode === 'preset') {
+        return [...preset.agents].sort();
+    }
+    return null;
+}
+export function expectedRulesFor(mode, preset) {
+    if (mode === 'custom') {
+        return null;
+    }
+    return expectedRuleIds(mode, preset);
+}
+export function difference(expected, actual) {
+    const expectedSet = new Set(expected);
+    const actualSet = new Set(actual);
+    return {
+        missing: expected.filter((id) => !actualSet.has(id)).sort(),
+        extra: actual.filter((id) => !expectedSet.has(id)).sort(),
+    };
+}
+async function fileExists(file) {
+    return fs.access(file).then(() => true, () => false);
+}
+export async function auditSelection(root, manifest, preset, engine) {
+    const modes = {
+        skills: selectionMode(manifest.skills),
+        agents: selectionMode(manifest.agents),
+        rules: selectionMode(manifest.rules),
+    };
+    const mode = modes.skills === modes.agents && modes.agents === modes.rules ? modes.skills : 'custom';
+    const errors = [];
+    const warnings = [];
+    const missing = [];
+    const extra = [];
+    const catalogSkills = await listCatalogSkills(engine);
+    const catalogAgents = await listCatalogAgents();
+    const expectedSkills = expectedSkillsFor(modes.skills, preset, engine, catalogSkills);
+    const expectedAgents = expectedAgentsFor(modes.agents, preset, catalogAgents);
+    const expectedRules = expectedRulesFor(modes.rules, preset);
+    let newAssets = 0;
+    const compare = (dimension, expected, actual) => {
+        if (expected === null) {
+            return;
+        }
+        const diff = difference(expected, actual);
+        missing.push(...diff.missing.map((id) => `${dimension}:${id}`));
+        extra.push(...diff.extra.map((id) => `${dimension}:${id}`));
+        if (diff.missing.length > 0) {
+            errors.push(`${dimension}s.publish incompleto: faltan ${diff.missing.join(', ')}`);
+        }
+        if (diff.extra.length > 0) {
+            errors.push(`${dimension}s.publish contiene ids fuera de la selección: ${diff.extra.join(', ')}`);
+        }
+    };
+    compare('skill', expectedSkills, manifest.skills.publish);
+    compare('agent', expectedAgents, manifest.agents.publish);
+    compare('rule', expectedRules, manifest.rules.publish);
+    const anyFull = Object.values(modes).includes('full');
+    if (anyFull) {
+        if (manifest.catalog === undefined) {
+            errors.push('selección full sin catalog.version/catalog.hash; ejecuta install --full o init');
+        }
+        else {
+            const currentHash = catalogHash(manifest);
+            if (currentHash !== manifest.catalog.hash) {
+                errors.push('full incompleto: publish editado; ejecuta install --full o restaura el manifest');
+            }
+            else if (manifest.catalog.version !== PACKAGE_VERSION) {
+                const expectedFull = [
+                    ...(modes.skills === 'full' ? (expectedSkills ?? []) : []),
+                    ...(modes.agents === 'full' ? (expectedAgents ?? []) : []),
+                    ...(modes.rules === 'full' ? (expectedRules ?? []) : []),
+                ];
+                const actualFull = [
+                    ...(modes.skills === 'full' ? manifest.skills.publish : []),
+                    ...(modes.agents === 'full' ? manifest.agents.publish : []),
+                    ...(modes.rules === 'full' ? manifest.rules.publish : []),
+                ];
+                newAssets = difference(expectedFull, actualFull).missing.length;
+                warnings.push(`full desactualizado: ${newAssets} activos nuevos; ejecuta upgrade`);
+            }
+        }
+    }
+    for (const skill of manifest.skills.publish) {
+        const file = path.join(root, manifest.skills.source, skill, 'SKILL.md');
+        if (!(await fileExists(file))) {
+            missing.push(`skill:${skill}`);
+            errors.push(`skills.publish "${skill}" no existe en ${manifest.skills.source}`);
+        }
+    }
+    for (const agent of manifest.agents.publish) {
+        const file = path.join(root, manifest.agents.source, `${agent}.md`);
+        if (!(await fileExists(file))) {
+            missing.push(`agent:${agent}`);
+            errors.push(`agents.publish "${agent}" no existe en ${manifest.agents.source}`);
+        }
+    }
+    for (const rule of manifest.rules.publish) {
+        const file = path.join(root, manifest.rules.source, `${rule}.md`);
+        if (!(await fileExists(file))) {
+            missing.push(`rule:${rule}`);
+            errors.push(`rules.publish "${rule}" no existe en ${manifest.rules.source}`);
+        }
+    }
+    return {
+        mode,
+        modes,
+        expectedSkills,
+        expectedAgents,
+        expectedRules,
+        missing: [...new Set(missing)].sort(),
+        extra: [...new Set(extra)].sort(),
+        errors,
+        warnings,
+        newAssets,
+    };
+}
+// Nombres internos para evitar colisión con las funciones exportadas de expectativas.
+function expectedSkillsFor(mode, preset, engine, catalog) {
+    return expectedSkills(mode, preset, engine, catalog);
+}
+function expectedAgentsFor(mode, preset, catalog) {
+    return expectedAgents(mode, preset, catalog);
+}

package/dist/cli/args.js

@@ -13,6 +13,7 @@ const BOOLEAN_FLAGS = new Set([
     'prune',
     'auto',
     'migrate',
+    'no-speckit',
 ]);
 export function parseArgs(argv) {
     const positionals = [];

package/dist/cli/context.js

@@ -3,6 +3,7 @@ import fs from 'node:fs/promises';
 import path from 'node:path';
 import { loadManifestContext } from '../manifest/manifest.js';
 import { readLedger, resumeLedger } from '../harness/memory/ledger.js';
+import { isEngineCheckout } from '../source-checkout.js';
 export const CONTEXT_RELATIVE = '.planning/context-next.md';
 export const CONTEXT_EVENTS = 5;
 async function stateText(root) {
@@ -62,6 +63,10 @@ export async function buildContext(root) {
     return content;
 }
 export async function cmdContext(_args, ctx) {
+    if (!(await isEngineCheckout(ctx.root))) {
+        ctx.io.out('context: no aplica en instalación');
+        return 0;
+    }
     try {
         await buildContext(ctx.root);
         ctx.io.out(`[OK]    Contexto generado: ${CONTEXT_RELATIVE}`);