@dsalazardev/ai-hub-cli 0.1.0 → 0.2.0

package/dist/catalog.d.ts

@@ -0,0 +1,76 @@
+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[];
+    agents: string[];
+    skillFiles: Record<string, string[]>;
+    ruleFiles: Record<string, string[]>;
+    walkCount: number;
+}
+/**
+ * Í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 de catálogo: todas las del paquete menos las 17 del motor. */
+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,321 @@
+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';
+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();
+}
+async function buildCatalogIndex() {
+    walkCount += 1;
+    const entries = await fs.readdir(ENGINE_SKILLS_DIR, { withFileTypes: true }).catch(() => []);
+    const skillFiles = {};
+    for (const entry of entries) {
+        if (!entry.isDirectory()) {
+            continue;
+        }
+        skillFiles[entry.name] = await walk(path.join(ENGINE_SKILLS_DIR, entry.name));
+    }
+    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(),
+        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,
+            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 de catálogo: todas las del paquete menos las 17 del motor. */
+export async function listCatalogSkills(engine) {
+    const index = await catalogIndex();
+    const engineSkills = new Set(engine.commands.map((command) => command.skill));
+    return index.skills.filter((skill) => !engineSkills.has(skill));
+}
+/** 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/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}`);

package/dist/cli/doctor.js

@@ -1,7 +1,9 @@
 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 { auditSelection } from '../catalog.js';
 import { ENGINE_COUNTS, ENGINE_LANES, ENGINE_SKILLS_DIR } from '../engine/engine.js';
 import { scanCoupling, scanLegacyArtifacts } from '../engine/gates.js';
 import { checkInventory, loadManifestContext, } from '../manifest/manifest.js';
@@ -24,6 +26,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 +73,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 +103,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 = [];
+        const missingEngineSkills = [];
         for (const command of engine.commands) {
             if (!(await exists(path.join(ENGINE_SKILLS_DIR, command.skill, 'SKILL.md')))) {
-                missingSkills.push(`${command.id} -> ${command.skill}`);
+                missingEngineSkills.push(`${command.id} -> ${command.skill}`);
             }
         }
-        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}`);
-            }
+        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', missingEngineSkills.length === 0 && missingProjectSkills.length === 0, missingEngineSkills.length === 0 && missingProjectSkills.length === 0
+            ? `17 nativas + ${manifest.skills.publish.length} de proyecto (${audit.modes.skills})`
+            : [...missingEngineSkills, ...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');
+        }
+        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}`);
         }
-        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');
@@ -169,6 +241,16 @@ 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 findings = await scanCoupling(ctx.root, coupling.terms);

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 };