@hoilab/ada-cli 0.84.22 → 0.85.1

package/dist/core/capability/types.d.ts

@@ -0,0 +1,168 @@
+/**
+ * Tipos del capability registry multi-origen (B01).
+ *
+ * Inversión de control: cada fuente nueva de config es un provider
+ * registrado, no un `if` más repartido por el código. Patrón tomado de
+ * oh-my-pi `capability/types.ts` (~170 LOC) y `capability/index.ts` (~420 LOC)
+ * con fiel reproducción de: providers priorizados, filter vs suppress vs
+ * equivalent, dedup first-wins y validación post-dedup.
+ *
+ * No se copian antipatrones: sin doble subsistema plugins/eventos, sin compat
+ * layer pi, sin prioridades mágicas dispersas — aquí la prioridad es un número
+ * explícito por provider y la precedencia se documenta con su bug (issue #7654)
+ * tal cual en omp.
+ */
+/**
+ * Contexto que recibe cada provider al cargar.
+ */
+export interface LoadContext {
+    /** Directorio de trabajo del proyecto (cwd del proceso o del workspace). */
+    cwd: string;
+    /** Directorio home del usuario. */
+    home: string;
+    /**
+     * Raíz del repo git (directorio que contiene `.git`), o null si no hay repo.
+     * Útil para providers que buscan ficheros walk-up.
+     */
+    repoRoot: string | null;
+}
+/**
+ * Metadatos de procedencia que se adjuntan a cada item cargado.
+ * Es lo que permite `/status` y el diagnóstico de shadowing.
+ */
+export interface SourceMeta {
+    /** ID del provider que cargó el item (p.ej. "claude", "native"). */
+    provider: string;
+    /** Nombre legible del provider (para UI). */
+    providerName: string;
+    /** Ruta absoluta al fichero origen. */
+    path: string;
+    /** Nivel de donde vino: user (~/.claude) vs project (.claude/) vs native (.omp). */
+    level: "user" | "project" | "native";
+}
+/**
+ * Resultado que devuelve cada provider al cargar.
+ */
+export interface LoadResult<T> {
+    items: Array<T & {
+        _source: SourceMeta;
+    }>;
+    /** Warnings de parseo, ficheros rotos, etc. No abortan la carga. */
+    warnings?: string[];
+}
+/**
+ * Provider de una capability. Cada fuente de config (native, claude, codex,
+ * cursor, etc.) implementa esta interfaz para cada capability que soporta.
+ *
+ * La prioridad determina el orden de precedencia: mayor prioridad gana en el
+ * dedup (first-wins). Rangos sugeridos (igual que omp):
+ *   100+ : primarios (native/ada)
+ *   50-99: herramientas específicas (claude, codex, gemini)
+ *   1-49 : estándares compartidos (mcp-json, agents-md)
+ */
+export interface CapabilityProvider<T> {
+    /** ID único del provider (p.ej. "claude"). */
+    id: string;
+    /** Nombre legible para UI (p.ej. "Claude Code"). */
+    displayName: string;
+    /** Descripción corta para settings/UI. */
+    description: string;
+    /** Prioridad: mayor = se comprueba primero, gana en conflictos. */
+    priority: number;
+    /**
+     * Carga los items de este provider. Debe devolverlos en orden
+     * proyecto-antes-de-usuario para que un `enabled:false` de proyecto
+     * reclame la clave antes que el homónimo de usuario (bug #7654).
+     */
+    load(ctx: LoadContext): Promise<LoadResult<T>>;
+}
+/** Entrada ya cargada con su metadato de origen. */
+export type CapabilityEntry<T> = T & {
+    _source: SourceMeta;
+};
+/**
+ * Opciones de carga. Reproducen fielmente las semánticas de omp:
+ * - filter: el item es como si nunca hubiera existido (no reclama clave).
+ * - suppress: el item reclama clave y ensombrece homónimos de menor
+ *   prioridad, pero nunca sobrevive ni ensombrece por equivalencia semántica
+ *   a un survivor con clave distinta (un alias suprimido no puede starvear
+ *   una conexión equivalente habilitada).
+ * - equivalent: dedup semántico más allá de la clave (p.ej. dos MCP con
+ *   distinto nombre pero misma conexión).
+ */
+export interface LoadOptions<T = unknown> {
+    /**
+     * Descarta items antes del dedup como si nunca hubieran existido. Un item
+     * filtrado ni sobrevive ni reclama su clave, así que no puede hacer shadow.
+     */
+    filter?(item: T & {
+        _source: SourceMeta;
+    }): boolean;
+    /**
+     * Excluye del resultado pero deja que el item reclame su clave. Un item
+     * suprimido de mayor prioridad ensombrece homónimos de menor prioridad
+     * (un server de proyecto `enabled:false` mantiene apagado el homónimo de
+     * usuario), pero nunca hace equivalence-shadow a un survivor con clave
+     * distinta.
+     */
+    suppress?(item: T & {
+        _source: SourceMeta;
+    }): boolean;
+    /** Incluir items que fallan validate(). Default: false (se descartan). */
+    includeInvalid?: boolean;
+    /** Solo estos providers (por ID). Default: todos. */
+    providers?: string[];
+    /** Excluir estos providers (por ID). */
+    excludeProviders?: string[];
+    /** cwd custom. Si no se pasa, quien llama resuelve el cwd. */
+    cwd?: string;
+}
+/**
+ * Resultado agregado tras cargar una capability desde todos los providers.
+ */
+export interface CapabilityResult<T> {
+    /** Items deduplicados en orden de prioridad (first-wins). */
+    items: Array<T & {
+        _source: SourceMeta;
+    }>;
+    /** Todos los items incluyendo duplicados ensombrecidos (para diagnóstico). */
+    all: Array<T & {
+        _source: SourceMeta;
+        _shadowed?: boolean;
+    }>;
+    /** Warnings agregados de todos los providers. */
+    warnings: string[];
+    /** Qué providers aportaron al menos un item no filtrado/suprimido. */
+    providers: string[];
+}
+/**
+ * Definición de una capability: qué se busca y cómo se deduplica/valida.
+ */
+export interface CapabilityDefinition<T> {
+    /** ID de la capability (p.ej. "mcps", "skills"). */
+    id: string;
+    /** Nombre legible para UI. */
+    displayName: string;
+    /** Descripción corta. */
+    description: string;
+    /**
+     * Clave de dedup. Items con la misma clave: gana el primero (mayor
+     * prioridad). `undefined` = nunca deduplicar (todos se conservan).
+     */
+    key(item: T): string | undefined;
+    /**
+     * Equivalencia semántica entre items de claves distintas. Si dos items
+     * con claves diferentes son equivalentes, el primero gana y el segundo se
+     * marca como shadowed. Permite no duplicar conexiones MCP textualmente
+     * distintas pero conectivamente iguales.
+     */
+    equivalent?(left: T, right: T): boolean;
+    /** Validación. Devuelve mensaje de error si inválido, undefined si válido. */
+    validate?(item: T): string | undefined;
+    /**
+     * ID de extensión para filtrar por disabledExtensions. Cuando está presente,
+     * loadCapabilities puede ocultar items deshabilitados vía settings.
+     */
+    toExtensionId?(item: T): string | undefined;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/capability/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/core/capability/types.ts"],"names":[],"mappings":"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"}

package/dist/core/capability/types.js

@@ -0,0 +1,16 @@
+/**
+ * Tipos del capability registry multi-origen (B01).
+ *
+ * Inversión de control: cada fuente nueva de config es un provider
+ * registrado, no un `if` más repartido por el código. Patrón tomado de
+ * oh-my-pi `capability/types.ts` (~170 LOC) y `capability/index.ts` (~420 LOC)
+ * con fiel reproducción de: providers priorizados, filter vs suppress vs
+ * equivalent, dedup first-wins y validación post-dedup.
+ *
+ * No se copian antipatrones: sin doble subsistema plugins/eventos, sin compat
+ * layer pi, sin prioridades mágicas dispersas — aquí la prioridad es un número
+ * explícito por provider y la precedencia se documenta con su bug (issue #7654)
+ * tal cual en omp.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/capability/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/core/capability/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}

package/dist/core/carga-plugins/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Carga de plugins con import paralelo determinista + invalidación cruzada
+ * (auditoría omp B09). Consumidor real de `paralelo.ts` e `invalidacion.ts`.
+ *
+ * QUÉ AÑADE SOBRE `extensions/loader.ts` (upstream, NO se toca):
+ * 1. I/O PARALELO + REGISTRO DETERMINISTA: los imports se disparan todos a la
+ *    vez y el resultado respeta el orden de la lista (ver paralelo.ts).
+ * 2. MEMOIZACIÓN POR RUTA: recargar con las mismas rutas reusa los valores ya
+ *    cargados; solo se importan los nuevos o los fallados.
+ * 3. INVALIDACIÓN CRUZADA: cada raíz (directorio del plugin) queda registrada
+ *    en el registro de invalidadores; `invalidarRaiz(raiz)` vacía las entradas
+ *    de esa raíz —la siguiente carga re-importa—, ejecuta cualquier otro
+ *    invalidador registrado para ella y purga la caché global de fábricas de
+ *    extensión (`clearExtensionCache`, lo único que upstream expone: no hay
+ *    purga por raíz sin tocar loader.ts; sobre-invalidar es seguro porque una
+ *    caché de fábricas vacía solo fuerza re-import).
+ *
+ * El importador se inyecta: en producción será `jiti.import(ruta,
+ * { default: true })`; en tests, un loader fake. jiti real nunca es necesario
+ * para ejercitar este flujo.
+ */
+export { configurarPurgaModulos, invalidarRaiz, preloadRaices, registrarInvalidador } from "./invalidacion.ts";
+export { type ImportaResultado, importarEnParaleloDeterminista } from "./paralelo.ts";
+export interface PluginCargado<T> {
+    ruta: string;
+    /** Directorio del plugin: clave del registro de invalidadores. */
+    raiz: string;
+    valor: T;
+}
+export interface CargaPluginsResultado<T> {
+    /** Plugins en el orden exacto de `rutas` (determinismo last-wins intacto). */
+    plugins: Array<PluginCargado<T>>;
+    /** Fallos aislados por ruta; no afectan a los plugins que sí cargaron. */
+    errores: Array<{
+        ruta: string;
+        error: string;
+    }>;
+}
+/**
+ * Carga plugins desde `rutas`: importa en paralelo las que faltan en caché,
+ * registra su raíz para invalidación cruzada y devuelve TODO (cacheado y
+ * nuevo) en el orden de la lista. Un plugin que falla aparece en `errores`
+ * con su ruta y no impide a los demás; se reintentará en la próxima llamada.
+ *
+ * @param rutas rutas de plugins; el orden define el orden del resultado
+ * @param cargar importador individual inyectable (jiti en producción)
+ */
+export declare function cargarPlugins<T>(rutas: readonly string[], cargar: (ruta: string) => Promise<T>): Promise<CargaPluginsResultado<T>>;
+//# sourceMappingURL=index.d.ts.map

package/dist/core/carga-plugins/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/carga-plugins/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAOH,OAAO,EAAE,sBAAsB,EAAE,aAAa,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC/G,OAAO,EAAE,KAAK,gBAAgB,EAAE,8BAA8B,EAAE,MAAM,eAAe,CAAC;AAEtF,MAAM,WAAW,aAAa,CAAC,CAAC;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,CAAC,CAAC;CACT;AAED,MAAM,WAAW,qBAAqB,CAAC,CAAC;IACvC,8EAA8E;IAC9E,OAAO,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IACjC,0EAA0E;IAC1E,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAChD;AAmCD;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACpC,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAClC,OAAO,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAwBnC"}

package/dist/core/carga-plugins/index.js

@@ -0,0 +1,85 @@
+/**
+ * Carga de plugins con import paralelo determinista + invalidación cruzada
+ * (auditoría omp B09). Consumidor real de `paralelo.ts` e `invalidacion.ts`.
+ *
+ * QUÉ AÑADE SOBRE `extensions/loader.ts` (upstream, NO se toca):
+ * 1. I/O PARALELO + REGISTRO DETERMINISTA: los imports se disparan todos a la
+ *    vez y el resultado respeta el orden de la lista (ver paralelo.ts).
+ * 2. MEMOIZACIÓN POR RUTA: recargar con las mismas rutas reusa los valores ya
+ *    cargados; solo se importan los nuevos o los fallados.
+ * 3. INVALIDACIÓN CRUZADA: cada raíz (directorio del plugin) queda registrada
+ *    en el registro de invalidadores; `invalidarRaiz(raiz)` vacía las entradas
+ *    de esa raíz —la siguiente carga re-importa—, ejecuta cualquier otro
+ *    invalidador registrado para ella y purga la caché global de fábricas de
+ *    extensión (`clearExtensionCache`, lo único que upstream expone: no hay
+ *    purga por raíz sin tocar loader.ts; sobre-invalidar es seguro porque una
+ *    caché de fábricas vacía solo fuerza re-import).
+ *
+ * El importador se inyecta: en producción será `jiti.import(ruta,
+ * { default: true })`; en tests, un loader fake. jiti real nunca es necesario
+ * para ejercitar este flujo.
+ */
+import { dirname } from "node:path";
+import { configurarPurgaModulos, registrarInvalidador } from "./invalidacion.js";
+import { importarEnParaleloDeterminista } from "./paralelo.js";
+export { configurarPurgaModulos, invalidarRaiz, preloadRaices, registrarInvalidador } from "./invalidacion.js";
+export { importarEnParaleloDeterminista } from "./paralelo.js";
+const cachePorRuta = {};
+const raicesConInvalidador = {};
+/**
+ * Purga cruzada: al invalidar cualquier raíz se limpia también la caché de
+ * fábricas del extension loader (global; ver cabecera). Import DINÁMICO para
+ * no arrastrar el grafo completo de extensions/loader (jiti + índice del
+ * paquete) a cada consumidor de este módulo.
+ */
+configurarPurgaModulos(() => {
+    void import("../extensions/loader.js").then((loader) => loader.clearExtensionCache());
+});
+function asegurarInvalidadorDeRaiz(raiz) {
+    if (raicesConInvalidador[raiz]) {
+        return;
+    }
+    raicesConInvalidador[raiz] = true;
+    const invalidador = () => {
+        for (const ruta of Object.keys(cachePorRuta)) {
+            if (cachePorRuta[ruta].raiz === raiz) {
+                delete cachePorRuta[ruta];
+            }
+        }
+    };
+    registrarInvalidador(raiz, invalidador);
+}
+/**
+ * Carga plugins desde `rutas`: importa en paralelo las que faltan en caché,
+ * registra su raíz para invalidación cruzada y devuelve TODO (cacheado y
+ * nuevo) en el orden de la lista. Un plugin que falla aparece en `errores`
+ * con su ruta y no impide a los demás; se reintentará en la próxima llamada.
+ *
+ * @param rutas rutas de plugins; el orden define el orden del resultado
+ * @param cargar importador individual inyectable (jiti en producción)
+ */
+export async function cargarPlugins(rutas, cargar) {
+    const pendientes = rutas.filter((ruta) => !(ruta in cachePorRuta));
+    const resultados = await importarEnParaleloDeterminista(pendientes, cargar);
+    const errores = [];
+    for (const resultado of resultados) {
+        if (resultado.ok) {
+            const raiz = dirname(resultado.ruta);
+            cachePorRuta[resultado.ruta] = { raiz, valor: resultado.valor };
+            asegurarInvalidadorDeRaiz(raiz);
+        }
+        else {
+            // Sin cachear el fallo: la próxima llamada reintenta la carga.
+            errores.push({ ruta: resultado.ruta, error: resultado.error });
+        }
+    }
+    const plugins = [];
+    for (const ruta of rutas) {
+        const entrada = cachePorRuta[ruta];
+        if (entrada) {
+            plugins.push({ ruta, raiz: entrada.raiz, valor: entrada.valor });
+        }
+    }
+    return { plugins, errores };
+}
+//# sourceMappingURL=index.js.map

package/dist/core/carga-plugins/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/carga-plugins/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AACjF,OAAO,EAAE,8BAA8B,EAAE,MAAM,eAAe,CAAC;AAE/D,OAAO,EAAE,sBAAsB,EAAE,aAAa,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAC/G,OAAO,EAAyB,8BAA8B,EAAE,MAAM,eAAe,CAAC;AAqBtF,MAAM,YAAY,GAA0C,EAAE,CAAC;AAC/D,MAAM,oBAAoB,GAAyB,EAAE,CAAC;AAEtD;;;;;GAKG;AACH,sBAAsB,CAAC,GAAG,EAAE;IAC3B,KAAK,MAAM,CAAC,yBAAyB,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,mBAAmB,EAAE,CAAC,CAAC;AACvF,CAAC,CAAC,CAAC;AAEH,SAAS,yBAAyB,CAAC,IAAY;IAC9C,IAAI,oBAAoB,CAAC,IAAI,CAAC,EAAE,CAAC;QAChC,OAAO;IACR,CAAC;IACD,oBAAoB,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;IAClC,MAAM,WAAW,GAAgB,GAAG,EAAE;QACrC,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC;YAC9C,IAAI,YAAY,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;gBACtC,OAAO,YAAY,CAAC,IAAI,CAAC,CAAC;YAC3B,CAAC;QACF,CAAC;IACF,CAAC,CAAC;IACF,oBAAoB,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC;AACzC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAClC,KAAwB,EACxB,MAAoC;IAEpC,MAAM,UAAU,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,YAAY,CAAC,CAAC,CAAC;IACnE,MAAM,UAAU,GAAG,MAAM,8BAA8B,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IAE5E,MAAM,OAAO,GAA2C,EAAE,CAAC;IAC3D,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACpC,IAAI,SAAS,CAAC,EAAE,EAAE,CAAC;YAClB,MAAM,IAAI,GAAG,OAAO,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;YACrC,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,EAAE,CAAC;YAChE,yBAAyB,CAAC,IAAI,CAAC,CAAC;QACjC,CAAC;aAAM,CAAC;YACP,+DAA+D;YAC/D,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,IAAI,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC;QAChE,CAAC;IACF,CAAC;IAED,MAAM,OAAO,GAA4B,EAAE,CAAC;IAC5C,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QAC1B,MAAM,OAAO,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;QACnC,IAAI,OAAO,EAAE,CAAC;YACb,OAAO,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,KAAU,EAAE,CAAC,CAAC;QACvE,CAAC;IACF,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC;AAC7B,CAAC"}

package/dist/core/carga-plugins/invalidacion.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Invalidación cruzada de cachés por raíz de plugin (auditoría omp B09).
+ *
+ * omp expone `registerPluginCacheInvalidator` + `preloadPluginRoots` para que
+ * consumidores síncronos (comandos, UI) encadenen la recarga de un plugin con
+ * TODAS las cachés que dependen de él. Ada no tiene equivalente: cuando
+ * cambia un plugin, cada caché (fábricas de extensión, valores ya cargados)
+ * se entera por su cuenta o no se entera.
+ *
+ * DISEÑO: registro `raíz → invalidadores`. La raíz es el directorio del
+ * plugin; todo lo cargado desde ella comparte destino en la invalidación.
+ * `invalidarRaiz` ejecuta SOLO los invalidadores de esa raíz y después purga
+ * la caché de módulos asociada vía el gancho configurable.
+ *
+ * PURGA DE MÓDULOS: `extensions/loader.ts` NO expone una purga por raíz —
+ * su `jiti` se instancia con `moduleCache: false` y la caché de fábricas se
+ * limpia en bloque con `clearExtensionCache()`. Añadir una purga fina sería
+ * tocar upstream (prohibido). Por eso el gancho es inyectable:
+ * `configurarPurgaModulos(fn)` y quien tenga una purga real la registra. Si
+ * nadie registra ninguna, `invalidarRaiz` ejecuta igualmente los
+ * invalidadores registrados (la purga es un añadido, no una condición).
+ */
+/** Callback de invalidación; puede ser asíncrono. */
+export type Invalidador = () => void | Promise<void>;
+/** Purga de caché de módulos asociada a una raíz (inyectable). */
+export type PurgaModulos = (raiz: string) => void;
+/**
+ * Registra `fn` para que se ejecute cuando se invalide `raiz`.
+ * @returns función para dar de baja el registro.
+ */
+export declare function registrarInvalidador(raiz: string, fn: Invalidador): () => void;
+/**
+ * Inyecta la purga de caché de módulos que `invalidarRaiz` aplicará tras los
+ * invalidadores. Idempotente: la última llamada gana.
+ */
+export declare function configurarPurgaModulos(fn: PurgaModulos): void;
+export interface ResultadoInvalidacion {
+    /** Invalidadores de la raíz ejecutados. */
+    ejecutados: number;
+    /** Mensajes de error de los invalidadores que fallaron (aislados entre sí). */
+    errores: string[];
+}
+/**
+ * Ejecuta los invalidadores registrados para `raiz` (y solo ellos), luego
+ * aplica la purga de módulos si hay gancho. Los errores de cada invalidador
+ * se aíslan: uno que falla no impide a los demás ni a la purga.
+ */
+export declare function invalidarRaiz(raiz: string): Promise<ResultadoInvalidacion>;
+/**
+ * Pre-calienta imports de varias raíces EN BACKGROUND: dispara todas las
+ * cargas sin esperarlas y devuelve una promesa que resuelve cuando terminan
+ * (con éxito o fallo). El fallo de un pre-calentamiento es inocuo — solo
+ * puebla la caché del loader — y nunca propaga: el consumidor puede
+ * `await`arlo al arrancar u olvidarse de él.
+ *
+ * @param raices rutas/raíces a calentar
+ * @param cargar importador individual (el mismo que usaría la carga real)
+ */
+export declare function preloadRaices(raices: readonly string[], cargar: (raiz: string) => Promise<unknown>): Promise<void>;
+//# sourceMappingURL=invalidacion.d.ts.map

package/dist/core/carga-plugins/invalidacion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalidacion.d.ts","sourceRoot":"","sources":["../../../src/core/carga-plugins/invalidacion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,qDAAqD;AACrD,MAAM,MAAM,WAAW,GAAG,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;AAErD,kEAAkE;AAClE,MAAM,MAAM,YAAY,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;AAMlD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,WAAW,GAAG,MAAM,IAAI,CAiB9E;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,EAAE,YAAY,GAAG,IAAI,CAE7D;AAED,MAAM,WAAW,qBAAqB;IACrC,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,+EAA+E;IAC/E,OAAO,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAgBhF;AAED;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CAClC,MAAM,EAAE,SAAS,MAAM,EAAE,EACzB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,GACxC,OAAO,CAAC,IAAI,CAAC,CASf"}

package/dist/core/carga-plugins/invalidacion.js

@@ -0,0 +1,94 @@
+/**
+ * Invalidación cruzada de cachés por raíz de plugin (auditoría omp B09).
+ *
+ * omp expone `registerPluginCacheInvalidator` + `preloadPluginRoots` para que
+ * consumidores síncronos (comandos, UI) encadenen la recarga de un plugin con
+ * TODAS las cachés que dependen de él. Ada no tiene equivalente: cuando
+ * cambia un plugin, cada caché (fábricas de extensión, valores ya cargados)
+ * se entera por su cuenta o no se entera.
+ *
+ * DISEÑO: registro `raíz → invalidadores`. La raíz es el directorio del
+ * plugin; todo lo cargado desde ella comparte destino en la invalidación.
+ * `invalidarRaiz` ejecuta SOLO los invalidadores de esa raíz y después purga
+ * la caché de módulos asociada vía el gancho configurable.
+ *
+ * PURGA DE MÓDULOS: `extensions/loader.ts` NO expone una purga por raíz —
+ * su `jiti` se instancia con `moduleCache: false` y la caché de fábricas se
+ * limpia en bloque con `clearExtensionCache()`. Añadir una purga fina sería
+ * tocar upstream (prohibido). Por eso el gancho es inyectable:
+ * `configurarPurgaModulos(fn)` y quien tenga una purga real la registra. Si
+ * nadie registra ninguna, `invalidarRaiz` ejecuta igualmente los
+ * invalidadores registrados (la purga es un añadido, no una condición).
+ */
+const invalidadores = {};
+let purgaModulos;
+/**
+ * Registra `fn` para que se ejecute cuando se invalide `raiz`.
+ * @returns función para dar de baja el registro.
+ */
+export function registrarInvalidador(raiz, fn) {
+    const lista = invalidadores[raiz];
+    if (lista) {
+        lista.push(fn);
+    }
+    else {
+        invalidadores[raiz] = [fn];
+    }
+    return () => {
+        const actual = invalidadores[raiz];
+        if (!actual) {
+            return;
+        }
+        const indice = actual.indexOf(fn);
+        if (indice >= 0) {
+            actual.splice(indice, 1);
+        }
+    };
+}
+/**
+ * Inyecta la purga de caché de módulos que `invalidarRaiz` aplicará tras los
+ * invalidadores. Idempotente: la última llamada gana.
+ */
+export function configurarPurgaModulos(fn) {
+    purgaModulos = fn;
+}
+/**
+ * Ejecuta los invalidadores registrados para `raiz` (y solo ellos), luego
+ * aplica la purga de módulos si hay gancho. Los errores de cada invalidador
+ * se aíslan: uno que falla no impide a los demás ni a la purga.
+ */
+export async function invalidarRaiz(raiz) {
+    const lista = invalidadores[raiz];
+    let ejecutados = 0;
+    const errores = [];
+    if (lista) {
+        for (const fn of [...lista]) {
+            ejecutados++;
+            try {
+                await fn();
+            }
+            catch (err) {
+                errores.push(err instanceof Error ? err.message : String(err));
+            }
+        }
+    }
+    purgaModulos?.(raiz);
+    return { ejecutados, errores };
+}
+/**
+ * Pre-calienta imports de varias raíces EN BACKGROUND: dispara todas las
+ * cargas sin esperarlas y devuelve una promesa que resuelve cuando terminan
+ * (con éxito o fallo). El fallo de un pre-calentamiento es inocuo — solo
+ * puebla la caché del loader — y nunca propaga: el consumidor puede
+ * `await`arlo al arrancar u olvidarse de él.
+ *
+ * @param raices rutas/raíces a calentar
+ * @param cargar importador individual (el mismo que usaría la carga real)
+ */
+export async function preloadRaices(raices, cargar) {
+    await Promise.all(raices.map((raiz) => cargar(raiz).catch(() => {
+        // Pre-calentamiento best-effort: el fallo se re-detectará (con
+        // reporte) en la carga real.
+    })));
+}
+//# sourceMappingURL=invalidacion.js.map

package/dist/core/carga-plugins/invalidacion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalidacion.js","sourceRoot":"","sources":["../../../src/core/carga-plugins/invalidacion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAQH,MAAM,aAAa,GAAkC,EAAE,CAAC;AAExD,IAAI,YAAsC,CAAC;AAE3C;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAY,EAAE,EAAe;IACjE,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;IAClC,IAAI,KAAK,EAAE,CAAC;QACX,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAChB,CAAC;SAAM,CAAC;QACP,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC5B,CAAC;IACD,OAAO,GAAG,EAAE;QACX,MAAM,MAAM,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;QACnC,IAAI,CAAC,MAAM,EAAE,CAAC;YACb,OAAO;QACR,CAAC;QACD,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;QAClC,IAAI,MAAM,IAAI,CAAC,EAAE,CAAC;YACjB,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;QAC1B,CAAC;IACF,CAAC,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CAAC,EAAgB;IACtD,YAAY,GAAG,EAAE,CAAC;AACnB,CAAC;AASD;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAAC,IAAY;IAC/C,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;IAClC,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,IAAI,KAAK,EAAE,CAAC;QACX,KAAK,MAAM,EAAE,IAAI,CAAC,GAAG,KAAK,CAAC,EAAE,CAAC;YAC7B,UAAU,EAAE,CAAC;YACb,IAAI,CAAC;gBACJ,MAAM,EAAE,EAAE,CAAC;YACZ,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACd,OAAO,CAAC,IAAI,CAAC,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC;YAChE,CAAC;QACF,CAAC;IACF,CAAC;IACD,YAAY,EAAE,CAAC,IAAI,CAAC,CAAC;IACrB,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,CAAC;AAChC,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAClC,MAAyB,EACzB,MAA0C;IAE1C,MAAM,OAAO,CAAC,GAAG,CAChB,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CACnB,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE;QACvB,+DAA+D;QAC/D,6BAA6B;IAC9B,CAAC,CAAC,CACF,CACD,CAAC;AACH,CAAC"}

package/dist/core/carga-plugins/paralelo.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Import paralelo determinista de plugins (auditoría omp B09).
+ *
+ * EL PROBLEMA: `extensions/loader.ts` (upstream, presupuesto de fork agotado —
+ * 3 hunks, NO se toca) importa extensiones SECUENCIALMENTE en
+ * `loadExtensionsInternal`: cada `jiti.import` espera al anterior antes de
+ * disparar el siguiente. Con N plugins el coste de arranque es la SUMA de los
+ * tiempos de compilación/carga, cuando son I/O+transpile independientes que
+ * podrían solaparse.
+ *
+ * POR QUÉ NO SE PARALELIZA EN SITIO: el orden de REGISTRO es parte del
+ * contrato observable de las extensiones (última registra gana: comandos,
+ * tools y flags con el mismo nombre se pisan por orden de carga). Un
+ * `Promise.all` ingenuo mantiene el orden del ARRAY de promesas, pero si el
+ * consumidor resuelve "a medida que llegan" (reduce con await dentro del
+ * bucle sobre promesas ya disparadas, callbacks, etc.) el orden de llegada
+ * del I/O se filtraría al registro y el arranque sería no determinista.
+ *
+ * ESTE MÓDULO fija el patrón correcto: TODOS los imports se disparan en
+ * paralelo (el loader arranca para todas las rutas antes de que el primero
+ * termine) PERO los resultados se resuelven EN EL ORDEN DE LA LISTA, porque
+ * `Promise.all` conserva posiciones. El llamador itera el resultado ya
+ * ordenado y el registro es determinista pase lo que pase con el I/O.
+ *
+ * ERRORES AISLADOS: un plugin que falla al importar no tumba a los demás.
+ * Cada promesa captura su propio error y lo reporta junto a su ruta; nunca
+ * hay rechazo agregado.
+ */
+/** Resultado por ruta: exactamente uno de éxito o fallo con su mensaje. */
+export type ImportaResultado<T> = {
+    ruta: string;
+    ok: true;
+    valor: T;
+} | {
+    ruta: string;
+    ok: false;
+    error: string;
+};
+/**
+ * Dispara `cargar` para TODAS las rutas en paralelo y devuelve los resultados
+ * en el orden de `rutas`, independientemente del orden de resolución.
+ *
+ * @param rutas rutas de plugins a importar (el orden define el de registro)
+ * @param cargar importador individual (p. ej. `jiti.import(ruta)`); se llama
+ *   una vez por ruta, todas las llamadas sin esperar entre sí
+ */
+export declare function importarEnParaleloDeterminista<T>(rutas: readonly string[], cargar: (ruta: string) => Promise<T>): Promise<Array<ImportaResultado<T>>>;
+//# sourceMappingURL=paralelo.d.ts.map

package/dist/core/carga-plugins/paralelo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paralelo.d.ts","sourceRoot":"","sources":["../../../src/core/carga-plugins/paralelo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,2EAA2E;AAC3E,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpH;;;;;;;GAOG;AACH,wBAAsB,8BAA8B,CAAC,CAAC,EACrD,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAClC,OAAO,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,CAAC,CAcrC"}

package/dist/core/carga-plugins/paralelo.js

@@ -0,0 +1,47 @@
+/**
+ * Import paralelo determinista de plugins (auditoría omp B09).
+ *
+ * EL PROBLEMA: `extensions/loader.ts` (upstream, presupuesto de fork agotado —
+ * 3 hunks, NO se toca) importa extensiones SECUENCIALMENTE en
+ * `loadExtensionsInternal`: cada `jiti.import` espera al anterior antes de
+ * disparar el siguiente. Con N plugins el coste de arranque es la SUMA de los
+ * tiempos de compilación/carga, cuando son I/O+transpile independientes que
+ * podrían solaparse.
+ *
+ * POR QUÉ NO SE PARALELIZA EN SITIO: el orden de REGISTRO es parte del
+ * contrato observable de las extensiones (última registra gana: comandos,
+ * tools y flags con el mismo nombre se pisan por orden de carga). Un
+ * `Promise.all` ingenuo mantiene el orden del ARRAY de promesas, pero si el
+ * consumidor resuelve "a medida que llegan" (reduce con await dentro del
+ * bucle sobre promesas ya disparadas, callbacks, etc.) el orden de llegada
+ * del I/O se filtraría al registro y el arranque sería no determinista.
+ *
+ * ESTE MÓDULO fija el patrón correcto: TODOS los imports se disparan en
+ * paralelo (el loader arranca para todas las rutas antes de que el primero
+ * termine) PERO los resultados se resuelven EN EL ORDEN DE LA LISTA, porque
+ * `Promise.all` conserva posiciones. El llamador itera el resultado ya
+ * ordenado y el registro es determinista pase lo que pase con el I/O.
+ *
+ * ERRORES AISLADOS: un plugin que falla al importar no tumba a los demás.
+ * Cada promesa captura su propio error y lo reporta junto a su ruta; nunca
+ * hay rechazo agregado.
+ */
+/**
+ * Dispara `cargar` para TODAS las rutas en paralelo y devuelve los resultados
+ * en el orden de `rutas`, independientemente del orden de resolución.
+ *
+ * @param rutas rutas de plugins a importar (el orden define el de registro)
+ * @param cargar importador individual (p. ej. `jiti.import(ruta)`); se llama
+ *   una vez por ruta, todas las llamadas sin esperar entre sí
+ */
+export async function importarEnParaleloDeterminista(rutas, cargar) {
+    // El map dispara todos los imports AHORA; then/await aísla el error de cada
+    // uno; Promise.all resuelve posicionalmente (determinismo last-wins intacto).
+    const pendientes = rutas.map((ruta) => cargar(ruta).then((valor) => ({ ruta, ok: true, valor }), (err) => ({
+        ruta,
+        ok: false,
+        error: err instanceof Error ? err.message : String(err),
+    })));
+    return Promise.all(pendientes);
+}
+//# sourceMappingURL=paralelo.js.map

package/dist/core/carga-plugins/paralelo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paralelo.js","sourceRoot":"","sources":["../../../src/core/carga-plugins/paralelo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAKH;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,8BAA8B,CACnD,KAAwB,EACxB,MAAoC;IAEpC,4EAA4E;IAC5E,8EAA8E;IAC9E,MAAM,UAAU,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CACrC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAChB,CAAC,KAAK,EAAuB,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,EAC3D,CAAC,GAAY,EAAuB,EAAE,CAAC,CAAC;QACvC,IAAI;QACJ,EAAE,EAAE,KAAK;QACT,KAAK,EAAE,GAAG,YAAY,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC;KACvD,CAAC,CACF,CACD,CAAC;IACF,OAAO,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;AAChC,CAAC"}