@backendkit-labs/agent-core 0.14.0

package/dist/reflection/domains/audit-domain.js

@@ -0,0 +1,241 @@
+"use strict";
+/**
+ * @description AuditDomain — failureTypes específicos del dominio de auditoría QA.
+ *
+ * Define los tipos de fallos que el AuditReporter puede capturar y mapear
+ * a FailureRecord para el Reflection Engine.
+ *
+ * Cada failureType tiene:
+ * - Una expresión regular de detección (keywords en el hallazgo)
+ * - Una dimensión por defecto
+ * - Una severidad sugerida
+ * - Una recomendación genérica
+ *
+ * @example
+ * ```ts
+ * const failureType = detectAuditFailureType('QueryRunner sin release en finally block');
+ * // → 'connection_leak'
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUDIT_FAILURE_TYPES = void 0;
+exports.detectAuditFailureType = detectAuditFailureType;
+exports.getAuditFailureTypeMeta = getAuditFailureTypeMeta;
+exports.getAuditFailureTypeMetaFromHallazgo = getAuditFailureTypeMetaFromHallazgo;
+// ── Catálogo de failureTypes de auditoría ────────────────────────────────────
+exports.AUDIT_FAILURE_TYPES = [
+    {
+        failureType: 'connection_leak',
+        dimension: 'seguridad',
+        severity: 'high',
+        detectionPatterns: [
+            /QueryRunner/i,
+            /connection/i,
+            /release/i,
+            /pool/i,
+            /conexi[oó]n/i,
+            /leak/i,
+            /sin\s*close/i,
+            /sin\s*release/i,
+            /sin\s*cerrar/i,
+        ],
+        genericRecommendation: 'Agregar finally block con release()/close() para liberar la conexión en todos los casos (éxito y error)',
+    },
+    {
+        failureType: 'missing_rollback',
+        dimension: 'seguridad',
+        severity: 'critical',
+        detectionPatterns: [
+            /rollback/i,
+            /transacci[oó]n/i,
+            /transaction/i,
+            /sin\s*rollback/i,
+            /commit\s*sin\s*rollback/i,
+        ],
+        genericRecommendation: 'Implementar manejo de rollback explícito en caso de error dentro de la transacción',
+    },
+    {
+        failureType: 'security_vulnerability',
+        dimension: 'seguridad',
+        severity: 'critical',
+        detectionPatterns: [
+            /vulnerabilidad/i,
+            /vulnerability/i,
+            /brecha/i,
+            /exploit/i,
+            /inyecci[oó]n/i,
+            /injection/i,
+            /xss/i,
+            /csrf/i,
+            /sql\s*injection/i,
+            /autenticaci[oó]n/i,
+            /authentication/i,
+            /autorizaci[oó]n/i,
+            /authorization/i,
+            /privilegios/i,
+        ],
+        genericRecommendation: 'Realizar revisión de seguridad dedicada y aplicar parches según OWASP Top 10',
+    },
+    {
+        failureType: 'missing_test_coverage',
+        dimension: 'calidad',
+        severity: 'high',
+        detectionPatterns: [
+            /test/i,
+            /cobertura/i,
+            /coverage/i,
+            /sin\s*test/i,
+            /faltan\s*test/i,
+            /testing\s*faltante/i,
+            /sin\s*prueba/i,
+        ],
+        genericRecommendation: 'Agregar tests unitarios y de integración para cubrir el flujo modificado',
+    },
+    {
+        failureType: 'incomplete_error_handling',
+        dimension: 'resiliencia',
+        severity: 'medium',
+        detectionPatterns: [
+            /error\s*handling/i,
+            /manejo\s*de\s*errores/i,
+            /excepci[oó]n/i,
+            /exception/i,
+            /sin\s*try/i,
+            /sin\s*catch/i,
+            /edge\s*case/i,
+            /caso\s*borde/i,
+            /no\s*se\s*maneja/i,
+        ],
+        genericRecommendation: 'Implementar manejo de errores estructurado con try/catch y respuesta adecuada para cada caso',
+    },
+    {
+        failureType: 'missing_documentation',
+        dimension: 'documentación',
+        severity: 'low',
+        detectionPatterns: [
+            /documentaci[oó]n/i,
+            /documentation/i,
+            /sin\s*doc/i,
+            /faltan\s*docs/i,
+            /comentario/i,
+            /jsdoc/i,
+            /readme/i,
+        ],
+        genericRecommendation: 'Agregar documentación (JSDoc, README, ADR) explicando el propósito y uso del componente',
+    },
+    {
+        failureType: 'architecture_violation',
+        dimension: 'arquitectura',
+        severity: 'high',
+        detectionPatterns: [
+            /arquitectura/i,
+            /architecture/i,
+            /violaci[oó]n/i,
+            /violation/i,
+            /acoplamiento/i,
+            /coupling/i,
+            /responsabilidad/i,
+            /capa\s*(saltar|bypass)/i,
+            /clean\s*arch/i,
+            /hexagonal/i,
+            /ddd/i,
+        ],
+        genericRecommendation: 'Revisar la arquitectura del cambio: asegurar que respeta la separación de capas y bounded contexts',
+    },
+    {
+        failureType: 'missing_logging',
+        dimension: 'observabilidad',
+        severity: 'medium',
+        detectionPatterns: [
+            /log/i,
+            /logging/i,
+            /trazabilidad/i,
+            /trace/i,
+            /debug/i,
+            /sin\s*log/i,
+            /no\s*registra/i,
+        ],
+        genericRecommendation: 'Agregar logs estructurados para trazabilidad en los puntos clave del flujo',
+    },
+    {
+        failureType: 'unvalidated_input',
+        dimension: 'seguridad',
+        severity: 'high',
+        detectionPatterns: [
+            /input/i,
+            /validaci[oó]n/i,
+            /validation/i,
+            /sanitiz/i,
+            /sin\s*validar/i,
+            /no\s*se\s*valida/i,
+            /entrada\s*(sin|no)/i,
+        ],
+        genericRecommendation: 'Agregar validación de entrada (tipo, formato, rango) usando DTOs o clases validadoras',
+    },
+    {
+        failureType: 'hardcoded_secret',
+        dimension: 'seguridad',
+        severity: 'critical',
+        detectionPatterns: [
+            /hardcode/i,
+            /hardcoded/i,
+            /secreto/i,
+            /secret/i,
+            /api\s*key/i,
+            /token\s*hard/i,
+            /contraseña\s*en\s*código/i,
+            /password\s*in\s*code/i,
+            /\.env\b/i,
+        ],
+        genericRecommendation: 'Mover secretos a variables de entorno o gestor de secretos (Vault, AWS Secrets Manager)',
+    },
+];
+// ── Funciones helper ─────────────────────────────────────────────────────────
+const NEGATORS = ['no hay', 'sin ', 'no tiene', 'verificar', 'validar', 'evitar'];
+/**
+ * Verifica si un patron coincide en el texto pero NO esta precedido por un negador.
+ * Evita falsos positivos como "verificar que no hay secrets" → hardcoded_secret.
+ */
+function matchesWithoutNegation(text, pattern) {
+    const result = pattern.exec(text);
+    if (!result)
+        return false;
+    const prefix = text.slice(Math.max(0, result.index - 25), result.index);
+    return !NEGATORS.some(neg => prefix.includes(neg));
+}
+/**
+ * @description Detecta el failureType más probable basado en el contenido del hallazgo.
+ * Recorre los patrones de detección en orden y devuelve el primero que coincide.
+ * Si no hay coincidencia, devuelve un fallback genérico.
+ *
+ * @param hallazgo - Texto del hallazgo de auditoría
+ * @returns failureType detectado
+ */
+function detectAuditFailureType(hallazgo) {
+    const lower = hallazgo.toLowerCase();
+    let bestType = 'incomplete_error_handling';
+    let bestScore = 0;
+    for (const meta of exports.AUDIT_FAILURE_TYPES) {
+        const score = meta.detectionPatterns.filter(p => matchesWithoutNegation(lower, p)).length;
+        if (score > bestScore) {
+            bestScore = score;
+            bestType = meta.failureType;
+        }
+    }
+    return bestType;
+}
+/**
+ * @description Obtiene la metadata completa para un failureType.
+ */
+function getAuditFailureTypeMeta(failureType) {
+    return exports.AUDIT_FAILURE_TYPES.find(meta => meta.failureType === failureType);
+}
+/**
+ * @description Obtiene la metadata basada en el contenido del hallazgo.
+ * Útil cuando se quiere obtener dimensión y severidad sugerida.
+ */
+function getAuditFailureTypeMetaFromHallazgo(hallazgo) {
+    const failureType = detectAuditFailureType(hallazgo);
+    return getAuditFailureTypeMeta(failureType) ?? exports.AUDIT_FAILURE_TYPES[4]; // fallback a incomplete_error_handling
+}
+//# sourceMappingURL=audit-domain.js.map

package/dist/reflection/domains/audit-domain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-domain.js","sourceRoot":"","sources":["../../../src/reflection/domains/audit-domain.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;GAiBG;;;AA+MH,wDAcC;AAKD,0DAEC;AAMD,kFAGC;AA/ND,gFAAgF;AAEnE,QAAA,mBAAmB,GAA2B;IACzD;QACE,WAAW,EAAE,iBAAiB;QAC9B,SAAS,EAAE,WAAW;QACtB,QAAQ,EAAE,MAAM;QAChB,iBAAiB,EAAE;YACjB,cAAc;YACd,aAAa;YACb,UAAU;YACV,OAAO;YACP,cAAc;YACd,OAAO;YACP,cAAc;YACd,gBAAgB;YAChB,eAAe;SAChB;QACD,qBAAqB,EAAE,yGAAyG;KACjI;IACD;QACE,WAAW,EAAE,kBAAkB;QAC/B,SAAS,EAAE,WAAW;QACtB,QAAQ,EAAE,UAAU;QACpB,iBAAiB,EAAE;YACjB,WAAW;YACX,iBAAiB;YACjB,cAAc;YACd,iBAAiB;YACjB,0BAA0B;SAC3B;QACD,qBAAqB,EAAE,oFAAoF;KAC5G;IACD;QACE,WAAW,EAAE,wBAAwB;QACrC,SAAS,EAAE,WAAW;QACtB,QAAQ,EAAE,UAAU;QACpB,iBAAiB,EAAE;YACjB,iBAAiB;YACjB,gBAAgB;YAChB,SAAS;YACT,UAAU;YACV,eAAe;YACf,YAAY;YACZ,MAAM;YACN,OAAO;YACP,kBAAkB;YAClB,mBAAmB;YACnB,iBAAiB;YACjB,kBAAkB;YAClB,gBAAgB;YAChB,cAAc;SACf;QACD,qBAAqB,EAAE,8EAA8E;KACtG;IACD;QACE,WAAW,EAAE,uBAAuB;QACpC,SAAS,EAAE,SAAS;QACpB,QAAQ,EAAE,MAAM;QAChB,iBAAiB,EAAE;YACjB,OAAO;YACP,YAAY;YACZ,WAAW;YACX,aAAa;YACb,gBAAgB;YAChB,qBAAqB;YACrB,eAAe;SAChB;QACD,qBAAqB,EAAE,0EAA0E;KAClG;IACD;QACE,WAAW,EAAE,2BAA2B;QACxC,SAAS,EAAE,aAAa;QACxB,QAAQ,EAAE,QAAQ;QAClB,iBAAiB,EAAE;YACjB,mBAAmB;YACnB,wBAAwB;YACxB,eAAe;YACf,YAAY;YACZ,YAAY;YACZ,cAAc;YACd,cAAc;YACd,eAAe;YACf,mBAAmB;SACpB;QACD,qBAAqB,EAAE,8FAA8F;KACtH;IACD;QACE,WAAW,EAAE,uBAAuB;QACpC,SAAS,EAAE,eAAe;QAC1B,QAAQ,EAAE,KAAK;QACf,iBAAiB,EAAE;YACjB,mBAAmB;YACnB,gBAAgB;YAChB,YAAY;YACZ,gBAAgB;YAChB,aAAa;YACb,QAAQ;YACR,SAAS;SACV;QACD,qBAAqB,EAAE,yFAAyF;KACjH;IACD;QACE,WAAW,EAAE,wBAAwB;QACrC,SAAS,EAAE,cAAc;QACzB,QAAQ,EAAE,MAAM;QAChB,iBAAiB,EAAE;YACjB,eAAe;YACf,eAAe;YACf,eAAe;YACf,YAAY;YACZ,eAAe;YACf,WAAW;YACX,kBAAkB;YAClB,yBAAyB;YACzB,eAAe;YACf,YAAY;YACZ,MAAM;SACP;QACD,qBAAqB,EAAE,oGAAoG;KAC5H;IACD;QACE,WAAW,EAAE,iBAAiB;QAC9B,SAAS,EAAE,gBAAgB;QAC3B,QAAQ,EAAE,QAAQ;QAClB,iBAAiB,EAAE;YACjB,MAAM;YACN,UAAU;YACV,eAAe;YACf,QAAQ;YACR,QAAQ;YACR,YAAY;YACZ,gBAAgB;SACjB;QACD,qBAAqB,EAAE,4EAA4E;KACpG;IACD;QACE,WAAW,EAAE,mBAAmB;QAChC,SAAS,EAAE,WAAW;QACtB,QAAQ,EAAE,MAAM;QAChB,iBAAiB,EAAE;YACjB,QAAQ;YACR,gBAAgB;YAChB,aAAa;YACb,UAAU;YACV,gBAAgB;YAChB,mBAAmB;YACnB,qBAAqB;SACtB;QACD,qBAAqB,EAAE,uFAAuF;KAC/G;IACD;QACE,WAAW,EAAE,kBAAkB;QAC/B,SAAS,EAAE,WAAW;QACtB,QAAQ,EAAE,UAAU;QACpB,iBAAiB,EAAE;YACjB,WAAW;YACX,YAAY;YACZ,UAAU;YACV,SAAS;YACT,YAAY;YACZ,eAAe;YACf,2BAA2B;YAC3B,uBAAuB;YACvB,UAAU;SACX;QACD,qBAAqB,EAAE,yFAAyF;KACjH;CACF,CAAC;AAEF,gFAAgF;AAEhF,MAAM,QAAQ,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ,CAAC,CAAC;AAElF;;;GAGG;AACH,SAAS,sBAAsB,CAAC,IAAY,EAAE,OAAe;IAC3D,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAClC,IAAI,CAAC,MAAM;QAAE,OAAO,KAAK,CAAC;IAC1B,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,GAAG,EAAE,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACxE,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;AACrD,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,sBAAsB,CAAC,QAAgB;IACrD,MAAM,KAAK,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC;IACrC,IAAI,QAAQ,GAAgB,2BAA0C,CAAC;IACvE,IAAI,SAAS,GAAG,CAAC,CAAC;IAElB,KAAK,MAAM,IAAI,IAAI,2BAAmB,EAAE,CAAC;QACvC,MAAM,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,sBAAsB,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;QAC1F,IAAI,KAAK,GAAG,SAAS,EAAE,CAAC;YACtB,SAAS,GAAG,KAAK,CAAC;YAClB,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC;QAC9B,CAAC;IACH,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC;AAED;;GAEG;AACH,SAAgB,uBAAuB,CAAC,WAAwB;IAC9D,OAAO,2BAAmB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,WAAW,KAAK,WAAW,CAAC,CAAC;AAC5E,CAAC;AAED;;;GAGG;AACH,SAAgB,mCAAmC,CAAC,QAAgB;IAClE,MAAM,WAAW,GAAG,sBAAsB,CAAC,QAAQ,CAAC,CAAC;IACrD,OAAO,uBAAuB,CAAC,WAAW,CAAC,IAAI,2BAAmB,CAAC,CAAC,CAAC,CAAC,CAAC,uCAAuC;AAChH,CAAC"}

package/dist/reflection/domains/bootstrap-domain.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @description BootstrapDomain — failureTypes específicos del dominio de bootstrap.
+ *
+ * Define los tipos de fallos que el proceso de inicialización puede capturar
+ * y mapear a FailureRecord para el Reflection Engine.
+ *
+ * Cada failureType tiene:
+ * - Una expresión regular de detección (keywords en el hallazgo)
+ * - Una dimensión por defecto
+ * - Una severidad sugerida
+ * - Una recomendación genérica
+ *
+ * @example
+ * ```ts
+ * const failureType = detectBootstrapFailureType('manifest.yaml corrupto');
+ * // → 'manifest_corrupt'
+ * ```
+ */
+import { FailureType } from '../types';
+export interface BootstrapFailureTypeMeta {
+    failureType: FailureType;
+    dimension: string;
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    detectionPatterns: RegExp[];
+    genericRecommendation: string;
+}
+export declare const BOOTSTRAP_FAILURE_TYPES: BootstrapFailureTypeMeta[];
+/**
+ * @description Detecta el failureType más probable basado en el contenido del hallazgo.
+ */
+export declare function detectBootstrapFailureType(hallazgo: string): FailureType;
+/**
+ * @description Obtiene la metadata completa para un failureType.
+ */
+export declare function getBootstrapFailureTypeMeta(failureType: FailureType): BootstrapFailureTypeMeta | undefined;
+/**
+ * @description Obtiene la metadata basada en el contenido del hallazgo.
+ */
+export declare function getBootstrapFailureTypeMetaFromHallazgo(hallazgo: string): BootstrapFailureTypeMeta;
+//# sourceMappingURL=bootstrap-domain.d.ts.map

package/dist/reflection/domains/bootstrap-domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap-domain.d.ts","sourceRoot":"","sources":["../../../src/reflection/domains/bootstrap-domain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAIvC,MAAM,WAAW,wBAAwB;IACvC,WAAW,EAAE,WAAW,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACjD,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,qBAAqB,EAAE,MAAM,CAAC;CAC/B;AAID,eAAO,MAAM,uBAAuB,EAAE,wBAAwB,EAsG7D,CAAC;AAIF;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,CAWxE;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,WAAW,EAAE,WAAW,GAAG,wBAAwB,GAAG,SAAS,CAE1G;AAED;;GAEG;AACH,wBAAgB,uCAAuC,CAAC,QAAQ,EAAE,MAAM,GAAG,wBAAwB,CAGlG"}

package/dist/reflection/domains/bootstrap-domain.js

@@ -0,0 +1,156 @@
+"use strict";
+/**
+ * @description BootstrapDomain — failureTypes específicos del dominio de bootstrap.
+ *
+ * Define los tipos de fallos que el proceso de inicialización puede capturar
+ * y mapear a FailureRecord para el Reflection Engine.
+ *
+ * Cada failureType tiene:
+ * - Una expresión regular de detección (keywords en el hallazgo)
+ * - Una dimensión por defecto
+ * - Una severidad sugerida
+ * - Una recomendación genérica
+ *
+ * @example
+ * ```ts
+ * const failureType = detectBootstrapFailureType('manifest.yaml corrupto');
+ * // → 'manifest_corrupt'
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BOOTSTRAP_FAILURE_TYPES = void 0;
+exports.detectBootstrapFailureType = detectBootstrapFailureType;
+exports.getBootstrapFailureTypeMeta = getBootstrapFailureTypeMeta;
+exports.getBootstrapFailureTypeMetaFromHallazgo = getBootstrapFailureTypeMetaFromHallazgo;
+// ── Catálogo de failureTypes de bootstrap ────────────────────────────────────
+exports.BOOTSTRAP_FAILURE_TYPES = [
+    {
+        failureType: 'missing_config_yaml',
+        dimension: 'configuración',
+        severity: 'high',
+        detectionPatterns: [
+            /missing\s*config/i,
+            /config.*(not\s*found|faltante|no\s*existe)/i,
+            /config\.yaml\s*(no|not)/i,
+            /(no|not)\s*se\s*(encontr[oó]|encuentra)\s*.*config/i,
+            /sin\s*archivo\s*de\s*configuraci[oó]n/i,
+            /configuraci[oó]n\s*(no|faltante)/i,
+            /yaml\s*no\s*encontrado/i,
+        ],
+        genericRecommendation: 'Crear el archivo de configuración faltante (.ai-assistant/config.yaml) o ejecutar el seed automático',
+    },
+    {
+        failureType: 'wrong_project_type_detected',
+        dimension: 'configuración',
+        severity: 'medium',
+        detectionPatterns: [
+            /wrong\s*project\s*type/i,
+            /tipo\s*de\s*proyecto\s*incorrecto/i,
+            /no\s*se\s*pudo\s*detectar/i,
+            /project\s*type.*(wrong|incorrect)/i,
+            /detecci[oó]n\s*(fallida|incorrecta)/i,
+            /tipo\s*err[oó]neo/i,
+        ],
+        genericRecommendation: 'Revisar la configuración del proyecto: verificar archivos de detección (package.json, .csproj, pom.xml, etc.)',
+    },
+    {
+        failureType: 'memory_load_failure',
+        dimension: 'persistencia',
+        severity: 'critical',
+        detectionPatterns: [
+            /memory\s*load/i,
+            /carga\s*de\s*memoria/i,
+            /no\s*se\s*pudo\s*cargar\s*la\s*memoria/i,
+            /memory.*fail/i,
+            /memoria.*fall[oó]/i,
+            /sesió?n.*no\s*cargada/i,
+            /contexto.*no\s*cargado/i,
+        ],
+        genericRecommendation: 'Verificar la integridad de los archivos de memoria (~/.deepseek-code/projects/{hash}/memory/) y regenerar si es necesario',
+    },
+    {
+        failureType: 'manifest_corrupt',
+        dimension: 'configuración',
+        severity: 'critical',
+        detectionPatterns: [
+            /manifest.*(corrupt|malformed|inv[aá]lido|broken)/i,
+            /yaml.*parse/i,
+            /error\s*al\s*parsear/i,
+            /manifest\.yaml.*(error|fall[oó])/i,
+            /archivo\s*manifest.*inv[aá]lido/i,
+            /corrupto/i,
+            /estructura.*inv[aá]lida/i,
+        ],
+        genericRecommendation: 'Ejecutar regenerateConfigFile() para recuperar el manifest.yaml o restaurar desde backup',
+    },
+    {
+        failureType: 'seed_config_failed',
+        dimension: 'configuración',
+        severity: 'high',
+        detectionPatterns: [
+            /seed.*(fail|error|fall[oó])/i,
+            /configuraci[oó]n\s*inicial\s*fallida/i,
+            /no\s*se\s*pudo\s*sembrar/i,
+            /seed.*config.*error/i,
+            /bootstrap.*(fail|fall[oó])/i,
+            /config\s*seed.*fail/i,
+        ],
+        genericRecommendation: 'Revisar logs de bootstrap y ejecutar seedConfig() manualmente, verificando permisos de escritura',
+    },
+    {
+        failureType: 'agent_profile_load_failed',
+        dimension: 'configuración',
+        severity: 'high',
+        detectionPatterns: [
+            /agent\s*profile.*(fail|load|error)/i,
+            /perfil\s*de\s*agente.*(fail|error)/i,
+            /no\s*se\s*pudo\s*cargar\s*el\s*perfil/i,
+            /profile.*load.*fail/i,
+            /agente.*no\s*encontrado/i,
+            /agente.*carga.*fall[oó]/i,
+        ],
+        genericRecommendation: 'Verificar que los archivos de perfil de agente existen en agents/*.md y tienen formato YAML válido',
+    },
+    {
+        failureType: 'vault_sync_failed',
+        dimension: 'persistencia',
+        severity: 'medium',
+        detectionPatterns: [
+            /vault.*(sync|fail|error)/i,
+            /sincronizaci[oó]n.*vault.*fall[oó]/i,
+            /no\s*se\s*pudo\s*sincronizar/i,
+            /vault.*not\s*found/i,
+            /b[oó]veda.*(fail|error)/i,
+            /obsidian.*sync.*fail/i,
+        ],
+        genericRecommendation: 'Verificar que la ruta del vault de Obsidian es correcta y que el directorio existe',
+    },
+];
+// ── Funciones helper ─────────────────────────────────────────────────────────
+/**
+ * @description Detecta el failureType más probable basado en el contenido del hallazgo.
+ */
+function detectBootstrapFailureType(hallazgo) {
+    const lower = hallazgo.toLowerCase();
+    for (const meta of exports.BOOTSTRAP_FAILURE_TYPES) {
+        const matches = meta.detectionPatterns.some(pattern => pattern.test(lower));
+        if (matches) {
+            return meta.failureType;
+        }
+    }
+    return 'unknown_bootstrap';
+}
+/**
+ * @description Obtiene la metadata completa para un failureType.
+ */
+function getBootstrapFailureTypeMeta(failureType) {
+    return exports.BOOTSTRAP_FAILURE_TYPES.find(meta => meta.failureType === failureType);
+}
+/**
+ * @description Obtiene la metadata basada en el contenido del hallazgo.
+ */
+function getBootstrapFailureTypeMetaFromHallazgo(hallazgo) {
+    const failureType = detectBootstrapFailureType(hallazgo);
+    return getBootstrapFailureTypeMeta(failureType) ?? exports.BOOTSTRAP_FAILURE_TYPES[4]; // fallback a seed_config_failed
+}
+//# sourceMappingURL=bootstrap-domain.js.map

package/dist/reflection/domains/bootstrap-domain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bootstrap-domain.js","sourceRoot":"","sources":["../../../src/reflection/domains/bootstrap-domain.ts"],"names":[],"mappings":"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"}

package/dist/reflection/domains/commit-domain.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @description CommitDomain — failureTypes específicos del dominio de commits.
+ *
+ * Define los tipos de fallos que el commit-workflow puede capturar y mapear
+ * a FailureRecord para el Reflection Engine.
+ *
+ * Cada failureType tiene:
+ * - Una expresión regular de detección (keywords en el hallazgo)
+ * - Una dimensión por defecto
+ * - Una severidad sugerida
+ * - Una recomendación genérica
+ *
+ * @example
+ * ```ts
+ * const failureType = detectCommitFailureType('mensaje sin tipo: "arreglos varios"');
+ * // → 'missing_type'
+ * ```
+ */
+import { FailureType } from '../types';
+export interface CommitFailureTypeMeta {
+    failureType: FailureType;
+    dimension: string;
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    detectionPatterns: RegExp[];
+    genericRecommendation: string;
+}
+export declare const COMMIT_FAILURE_TYPES: CommitFailureTypeMeta[];
+/**
+ * @description Detecta el failureType más probable basado en el contenido del hallazgo.
+ */
+export declare function detectCommitFailureType(hallazgo: string): FailureType;
+/**
+ * @description Obtiene la metadata completa para un failureType.
+ */
+export declare function getCommitFailureTypeMeta(failureType: FailureType): CommitFailureTypeMeta | undefined;
+/**
+ * @description Obtiene la metadata basada en el contenido del hallazgo.
+ */
+export declare function getCommitFailureTypeMetaFromHallazgo(hallazgo: string): CommitFailureTypeMeta;
+//# sourceMappingURL=commit-domain.d.ts.map

package/dist/reflection/domains/commit-domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit-domain.d.ts","sourceRoot":"","sources":["../../../src/reflection/domains/commit-domain.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAIvC,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,WAAW,CAAC;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACjD,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,qBAAqB,EAAE,MAAM,CAAC;CAC/B;AAID,eAAO,MAAM,oBAAoB,EAAE,qBAAqB,EAwHvD,CAAC;AAIF;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,CAWrE;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CAAC,WAAW,EAAE,WAAW,GAAG,qBAAqB,GAAG,SAAS,CAEpG;AAED;;GAEG;AACH,wBAAgB,oCAAoC,CAAC,QAAQ,EAAE,MAAM,GAAG,qBAAqB,CAG5F"}

package/dist/reflection/domains/commit-domain.js

@@ -0,0 +1,174 @@
+"use strict";
+/**
+ * @description CommitDomain — failureTypes específicos del dominio de commits.
+ *
+ * Define los tipos de fallos que el commit-workflow puede capturar y mapear
+ * a FailureRecord para el Reflection Engine.
+ *
+ * Cada failureType tiene:
+ * - Una expresión regular de detección (keywords en el hallazgo)
+ * - Una dimensión por defecto
+ * - Una severidad sugerida
+ * - Una recomendación genérica
+ *
+ * @example
+ * ```ts
+ * const failureType = detectCommitFailureType('mensaje sin tipo: "arreglos varios"');
+ * // → 'missing_type'
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMMIT_FAILURE_TYPES = void 0;
+exports.detectCommitFailureType = detectCommitFailureType;
+exports.getCommitFailureTypeMeta = getCommitFailureTypeMeta;
+exports.getCommitFailureTypeMetaFromHallazgo = getCommitFailureTypeMetaFromHallazgo;
+// ── Catálogo de failureTypes de commits ──────────────────────────────────────
+exports.COMMIT_FAILURE_TYPES = [
+    {
+        failureType: 'missing_type',
+        dimension: 'convenciones',
+        severity: 'medium',
+        detectionPatterns: [
+            /sin\s*tipo/i,
+            /missing\s*type/i,
+            /no\s*sigue\s*conventional\s*commits/i,
+            /formato\s*inv[aá]lido/i,
+            /no\s*empieza\s*con/i,
+            /mensaje\s*sin\s*tipo/i,
+            /commit\s*sin\s*tipo/i,
+            /missing\s*conventional\s*commit/i,
+        ],
+        genericRecommendation: 'Usar formato Conventional Commits: <tipo>(<ámbito>): <descripción imperativa>',
+    },
+    {
+        failureType: 'wrong_scope',
+        dimension: 'convenciones',
+        severity: 'low',
+        detectionPatterns: [
+            /wrong\s*scope/i,
+            /scop.*\s*incorrecto/i,
+            /[aà]mbito.*\s*incorrecto/i,
+            /scop.*\s*inv[aá]lido/i,
+            /no\s*coincide\s*con\s*el\s*dominio/i,
+            /scop.*\s*no\s*v[aá]lido/i,
+        ],
+        genericRecommendation: 'Corregir el scope del commit para que coincida con el módulo afectado (cli, core, api, config, etc.)',
+    },
+    {
+        failureType: 'message_too_long',
+        dimension: 'convenciones',
+        severity: 'low',
+        detectionPatterns: [
+            /mensaje\s*(demasiado|muy)\s*largo/i,
+            /message\s*too\s*long/i,
+            /excede\s*los\s*(72|50)\s*caracteres/i,
+            /exceeds\s*(72|50)\s*characters/i,
+            /long\s*subject/i,
+            /asunto\s*muy\s*largo/i,
+        ],
+        genericRecommendation: 'Acortar el asunto del commit a ≤50 caracteres (o ≤72 si es el cuerpo)',
+    },
+    {
+        failureType: 'missing_issue_reference',
+        dimension: 'trazabilidad',
+        severity: 'medium',
+        detectionPatterns: [
+            /missing\s*issue/i,
+            /sin\s*referencia/i,
+            /sin\s*issue/i,
+            /no\s*menciona\s*ticket/i,
+            /falta\s*\#\d+/i,
+            /missing\s*ticket/i,
+            /sin\s*enlace/i,
+            /sin\s*tarea/i,
+        ],
+        genericRecommendation: 'Agregar referencia al issue/ticket en el footer del commit (ej: "Closes #42")',
+    },
+    {
+        failureType: 'coverage_not_run',
+        dimension: 'calidad',
+        severity: 'high',
+        detectionPatterns: [
+            /coverage\s*not\s*run/i,
+            /tests\s*no\s*ejecutados/i,
+            /sin\s*correr\s*test/i,
+            /no\s*se\s*ejecutaron\s*los\s*test/i,
+            /tests\s*skipped/i,
+            /omitir\s*test/i,
+            /saltar\s*test/i,
+        ],
+        genericRecommendation: 'Ejecutar tests (coverage) antes del commit: make test o jest --coverage',
+    },
+    {
+        failureType: 'typecheck_failed_before_commit',
+        dimension: 'calidad',
+        severity: 'critical',
+        detectionPatterns: [
+            /typecheck\s*failed/i,
+            /type.?check.*fall[oó]/i,
+            /tsc.*error/i,
+            /fall[oó]\s*type.?check/i,
+            /error\s*de\s*tipado/i,
+            /compilaci[oó]n\s*fallida/i,
+        ],
+        genericRecommendation: 'Corregir errores de tipo TypeScript y ejecutar make typecheck antes de reintentar el commit',
+    },
+    {
+        failureType: 'test_failed_before_commit',
+        dimension: 'calidad',
+        severity: 'critical',
+        detectionPatterns: [
+            /test\s*failed/i,
+            /test.*fall[oói]/i,
+            /pruebas?\s*fallidas/i,
+            /tests\s*rojos/i,
+            /red\s*tests/i,
+            /fall[oó]\s*el\s*test/i,
+            /tests\s*not\s*passing/i,
+        ],
+        genericRecommendation: 'Corregir los tests fallidos antes de reintentar el commit (make test)',
+    },
+    {
+        failureType: 'branch_naming_invalid',
+        dimension: 'convenciones',
+        severity: 'medium',
+        detectionPatterns: [
+            /branch\s*naming/i,
+            /nombre\s*de\s*rama/i,
+            /branch\s*name.*invalid/i,
+            /rama\s*inv[aá]lida/i,
+            /no\s*sigue\s*git\s*flow/i,
+            /formato\s*de\s*rama/i,
+            /branch.*pattern/i,
+        ],
+        genericRecommendation: 'Usar Git Flow: feature/<siglas>_<descripcion>_<YYYYMMDD> o fix/<siglas>_<descripcion>_<YYYYMMDD>',
+    },
+];
+// ── Funciones helper ─────────────────────────────────────────────────────────
+/**
+ * @description Detecta el failureType más probable basado en el contenido del hallazgo.
+ */
+function detectCommitFailureType(hallazgo) {
+    const lower = hallazgo.toLowerCase();
+    for (const meta of exports.COMMIT_FAILURE_TYPES) {
+        const matches = meta.detectionPatterns.some(pattern => pattern.test(lower));
+        if (matches) {
+            return meta.failureType;
+        }
+    }
+    return 'unknown_failure';
+}
+/**
+ * @description Obtiene la metadata completa para un failureType.
+ */
+function getCommitFailureTypeMeta(failureType) {
+    return exports.COMMIT_FAILURE_TYPES.find(meta => meta.failureType === failureType);
+}
+/**
+ * @description Obtiene la metadata basada en el contenido del hallazgo.
+ */
+function getCommitFailureTypeMetaFromHallazgo(hallazgo) {
+    const failureType = detectCommitFailureType(hallazgo);
+    return getCommitFailureTypeMeta(failureType) ?? exports.COMMIT_FAILURE_TYPES[0]; // fallback a unknown_failure (primer elemento del array)
+}
+//# sourceMappingURL=commit-domain.js.map