@ruvector/ruvllm 4.0.1 → 4.1.0

package/dist/esm/index.js

@@ -0,0 +1,84 @@
+/**
+ * @ruvector/ruvllm - Self-learning LLM orchestration
+ *
+ * RuvLLM combines SONA adaptive learning with HNSW memory,
+ * FastGRNN routing, and SIMD-optimized inference.
+ *
+ * @example
+ * ```typescript
+ * import { RuvLLM, SessionManager, SonaCoordinator } from '@ruvector/ruvllm';
+ *
+ * const llm = new RuvLLM({ learningEnabled: true });
+ * const sessions = new SessionManager(llm);
+ * const sona = new SonaCoordinator();
+ *
+ * // Query with session context
+ * const session = sessions.create();
+ * const response = sessions.chat(session.id, 'What is AI?');
+ *
+ * // Track learning trajectory
+ * const trajectory = new TrajectoryBuilder()
+ *   .startStep('query', 'What is AI?')
+ *   .endStep(response.text, response.confidence)
+ *   .complete('success');
+ *
+ * sona.recordTrajectory(trajectory);
+ * ```
+ *
+ * @example Federated Learning
+ * ```typescript
+ * import { EphemeralAgent, FederatedCoordinator } from '@ruvector/ruvllm';
+ *
+ * // Central coordinator
+ * const coordinator = new FederatedCoordinator('coord-1');
+ *
+ * // Ephemeral agents process tasks and export
+ * const agent = new EphemeralAgent('agent-1');
+ * agent.processTask(embedding, 0.9);
+ * const exportData = agent.exportState();
+ *
+ * // Aggregate learning
+ * coordinator.aggregate(exportData);
+ * ```
+ *
+ * @example LoRA Adapters
+ * ```typescript
+ * import { LoraAdapter, LoraManager } from '@ruvector/ruvllm';
+ *
+ * const adapter = new LoraAdapter({ rank: 8, alpha: 16 });
+ * const output = adapter.forward(input);
+ * ```
+ */
+// Core types
+export * from './types.js';
+// Main engine
+export * from './engine.js';
+// SIMD operations
+export * from './simd.js';
+// Session management
+export * from './session.js';
+// Streaming support
+export * from './streaming.js';
+// SONA learning system
+export * from './sona.js';
+// Federated learning
+export * from './federated.js';
+// LoRA adapters
+export * from './lora.js';
+// Export/serialization
+export * from './export.js';
+// Training pipeline
+export * from './training.js';
+// Contrastive fine-tuning
+export * from './contrastive.js';
+// Model downloader and registry
+export * from './models.js';
+// Benchmarks for Claude Code use cases
+export * from './benchmarks/index.js';
+// External Intelligence Providers (ADR-043)
+export * from './intelligence.js';
+// Native bindings utilities
+export { version, hasSimdSupport } from './native.js';
+// Default export
+export { RuvLLM as default } from './engine.js';
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/intelligence.d.ts

@@ -0,0 +1,136 @@
+/**
+ * External Intelligence Providers for SONA Learning (ADR-043)
+ *
+ * TypeScript bindings for the IntelligenceProvider trait, enabling
+ * external systems to feed quality signals into RuvLLM's learning loops.
+ *
+ * @example
+ * ```typescript
+ * import { IntelligenceLoader, FileSignalProvider, QualitySignal } from '@ruvector/ruvllm';
+ *
+ * const loader = new IntelligenceLoader();
+ * loader.registerProvider(new FileSignalProvider('./signals.json'));
+ *
+ * const { signals, errors } = loader.loadAllSignals();
+ * console.log(`Loaded ${signals.length} signals`);
+ * ```
+ */
+/**
+ * A quality signal from an external system.
+ *
+ * Represents one completed task with quality assessment data
+ * that can feed into SONA trajectories, the embedding classifier,
+ * and model router calibration.
+ */
+export interface QualitySignal {
+    /** Unique identifier for this signal */
+    id: string;
+    /** Human-readable task description (used for embedding generation) */
+    taskDescription: string;
+    /** Execution outcome */
+    outcome: 'success' | 'partial_success' | 'failure';
+    /** Composite quality score (0.0 - 1.0) */
+    qualityScore: number;
+    /** Optional human verdict */
+    humanVerdict?: 'approved' | 'rejected';
+    /** Optional structured quality factors for detailed analysis */
+    qualityFactors?: QualityFactors;
+    /** ISO 8601 timestamp of task completion */
+    completedAt: string;
+}
+/**
+ * Granular quality factor breakdown.
+ *
+ * Not all providers will have all factors. Undefined fields mean
+ * "not assessed" (distinct from 0.0, which means "assessed as zero").
+ */
+export interface QualityFactors {
+    acceptanceCriteriaMet?: number;
+    testsPassing?: number;
+    noRegressions?: number;
+    lintClean?: number;
+    typeCheckClean?: number;
+    followsPatterns?: number;
+    contextRelevance?: number;
+    reasoningCoherence?: number;
+    executionEfficiency?: number;
+}
+/**
+ * Quality weight overrides from a provider.
+ *
+ * Weights should sum to approximately 1.0.
+ */
+export interface ProviderQualityWeights {
+    taskCompletion: number;
+    codeQuality: number;
+    process: number;
+}
+/**
+ * Error from a single provider during batch loading.
+ */
+export interface ProviderError {
+    providerName: string;
+    message: string;
+}
+/**
+ * Result from a single provider during grouped loading.
+ */
+export interface ProviderResult {
+    providerName: string;
+    signals: QualitySignal[];
+    weights?: ProviderQualityWeights;
+}
+/**
+ * Interface for external systems that supply quality signals to RuvLLM.
+ *
+ * Implement this interface and register with IntelligenceLoader.
+ */
+export interface IntelligenceProvider {
+    /** Human-readable name for this provider */
+    name(): string;
+    /** Load quality signals from this provider's data source */
+    loadSignals(): QualitySignal[];
+    /** Optional quality weight overrides */
+    qualityWeights?(): ProviderQualityWeights | undefined;
+}
+/**
+ * Built-in file-based intelligence provider.
+ *
+ * Reads quality signals from a JSON file. This is the default provider
+ * for non-Rust integrations that write signal files.
+ */
+export declare class FileSignalProvider implements IntelligenceProvider {
+    private readonly filePath;
+    constructor(filePath: string);
+    name(): string;
+    loadSignals(): QualitySignal[];
+    qualityWeights(): ProviderQualityWeights | undefined;
+}
+/**
+ * Aggregates quality signals from multiple registered providers.
+ *
+ * If no providers are registered, loadAllSignals returns empty arrays
+ * with zero overhead.
+ */
+export declare class IntelligenceLoader {
+    private providers;
+    /** Register an external intelligence provider */
+    registerProvider(provider: IntelligenceProvider): void;
+    /** Returns the number of registered providers */
+    get providerCount(): number;
+    /** Returns the names of all registered providers */
+    get providerNames(): string[];
+    /**
+     * Load signals from all registered providers.
+     *
+     * Non-fatal: if a provider fails, its error is captured but
+     * other providers continue loading.
+     */
+    loadAllSignals(): {
+        signals: QualitySignal[];
+        errors: ProviderError[];
+    };
+    /** Load signals grouped by provider with weight overrides */
+    loadGrouped(): ProviderResult[];
+}
+//# sourceMappingURL=intelligence.d.ts.map

package/dist/esm/intelligence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intelligence.d.ts","sourceRoot":"","sources":["../../src/intelligence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAiBH;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,wCAAwC;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,sEAAsE;IACtE,eAAe,EAAE,MAAM,CAAC;IACxB,wBAAwB;IACxB,OAAO,EAAE,SAAS,GAAG,iBAAiB,GAAG,SAAS,CAAC;IACnD,0CAA0C;IAC1C,YAAY,EAAE,MAAM,CAAC;IACrB,6BAA6B;IAC7B,YAAY,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;IACvC,gEAAgE;IAChE,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,4CAA4C;IAC5C,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,OAAO,CAAC,EAAE,sBAAsB,CAAC;CAClC;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,4CAA4C;IAC5C,IAAI,IAAI,MAAM,CAAC;IACf,4DAA4D;IAC5D,WAAW,IAAI,aAAa,EAAE,CAAC;IAC/B,wCAAwC;IACxC,cAAc,CAAC,IAAI,sBAAsB,GAAG,SAAS,CAAC;CACvD;AAuCD;;;;;GAKG;AACH,qBAAa,kBAAmB,YAAW,oBAAoB;IAC7D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAEtB,QAAQ,EAAE,MAAM;IAI5B,IAAI,IAAI,MAAM;IAId,WAAW,IAAI,aAAa,EAAE;IAwC9B,cAAc,IAAI,sBAAsB,GAAG,SAAS;CAerD;AAED;;;;;GAKG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,SAAS,CAA8B;IAE/C,iDAAiD;IACjD,gBAAgB,CAAC,QAAQ,EAAE,oBAAoB,GAAG,IAAI;IAItD,iDAAiD;IACjD,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,oDAAoD;IACpD,IAAI,aAAa,IAAI,MAAM,EAAE,CAE5B;IAED;;;;;OAKG;IACH,cAAc,IAAI;QAAE,OAAO,EAAE,aAAa,EAAE,CAAC;QAAC,MAAM,EAAE,aAAa,EAAE,CAAA;KAAE;IAmBvE,6DAA6D;IAC7D,WAAW,IAAI,cAAc,EAAE;CAehC"}

package/dist/esm/intelligence.js

@@ -0,0 +1,188 @@
+/**
+ * External Intelligence Providers for SONA Learning (ADR-043)
+ *
+ * TypeScript bindings for the IntelligenceProvider trait, enabling
+ * external systems to feed quality signals into RuvLLM's learning loops.
+ *
+ * @example
+ * ```typescript
+ * import { IntelligenceLoader, FileSignalProvider, QualitySignal } from '@ruvector/ruvllm';
+ *
+ * const loader = new IntelligenceLoader();
+ * loader.registerProvider(new FileSignalProvider('./signals.json'));
+ *
+ * const { signals, errors } = loader.loadAllSignals();
+ * console.log(`Loaded ${signals.length} signals`);
+ * ```
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+/** Maximum signal file size (10 MiB) */
+const MAX_SIGNAL_FILE_SIZE = 10 * 1024 * 1024;
+/** Maximum number of signals per file */
+const MAX_SIGNALS_PER_FILE = 10000;
+/** Valid outcome values */
+const VALID_OUTCOMES = new Set(['success', 'partial_success', 'failure']);
+/** Valid human verdict values */
+const VALID_VERDICTS = new Set(['approved', 'rejected']);
+function asOptionalNumber(val) {
+    if (val === undefined || val === null)
+        return undefined;
+    const n = Number(val);
+    return Number.isFinite(n) && n >= 0 && n <= 1 ? n : undefined;
+}
+function validateOutcome(val) {
+    const s = String(val ?? 'failure');
+    return VALID_OUTCOMES.has(s) ? s : 'failure';
+}
+function validateVerdict(val) {
+    if (val === undefined || val === null)
+        return undefined;
+    const s = String(val);
+    return VALID_VERDICTS.has(s) ? s : undefined;
+}
+function validateScore(val) {
+    const n = Number(val ?? 0);
+    if (!Number.isFinite(n) || n < 0 || n > 1)
+        return 0;
+    return n;
+}
+function mapQualityFactors(raw) {
+    return {
+        acceptanceCriteriaMet: asOptionalNumber(raw.acceptance_criteria_met),
+        testsPassing: asOptionalNumber(raw.tests_passing),
+        noRegressions: asOptionalNumber(raw.no_regressions),
+        lintClean: asOptionalNumber(raw.lint_clean),
+        typeCheckClean: asOptionalNumber(raw.type_check_clean),
+        followsPatterns: asOptionalNumber(raw.follows_patterns),
+        contextRelevance: asOptionalNumber(raw.context_relevance),
+        reasoningCoherence: asOptionalNumber(raw.reasoning_coherence),
+        executionEfficiency: asOptionalNumber(raw.execution_efficiency),
+    };
+}
+/**
+ * Built-in file-based intelligence provider.
+ *
+ * Reads quality signals from a JSON file. This is the default provider
+ * for non-Rust integrations that write signal files.
+ */
+export class FileSignalProvider {
+    constructor(filePath) {
+        this.filePath = path.resolve(filePath);
+    }
+    name() {
+        return 'file-signals';
+    }
+    loadSignals() {
+        if (!fs.existsSync(this.filePath)) {
+            return [];
+        }
+        // Check file size before reading (prevent OOM)
+        const stat = fs.statSync(this.filePath);
+        if (stat.size > MAX_SIGNAL_FILE_SIZE) {
+            throw new Error(`Signal file exceeds max size (${stat.size} bytes, limit ${MAX_SIGNAL_FILE_SIZE})`);
+        }
+        const raw = fs.readFileSync(this.filePath, 'utf-8');
+        const data = JSON.parse(raw);
+        if (!Array.isArray(data)) {
+            return [];
+        }
+        // Check signal count
+        if (data.length > MAX_SIGNALS_PER_FILE) {
+            throw new Error(`Signal file contains ${data.length} signals, max is ${MAX_SIGNALS_PER_FILE}`);
+        }
+        return data.map((item) => {
+            const qfRaw = (item.quality_factors ?? item.qualityFactors);
+            return {
+                id: String(item.id ?? ''),
+                taskDescription: String(item.task_description ?? item.taskDescription ?? ''),
+                outcome: validateOutcome(item.outcome),
+                qualityScore: validateScore(item.quality_score ?? item.qualityScore),
+                humanVerdict: validateVerdict(item.human_verdict ?? item.humanVerdict),
+                qualityFactors: qfRaw ? mapQualityFactors(qfRaw) : undefined,
+                completedAt: String(item.completed_at ?? item.completedAt ?? new Date().toISOString()),
+            };
+        });
+    }
+    qualityWeights() {
+        try {
+            const weightsPath = path.join(path.dirname(this.filePath), 'quality-weights.json');
+            if (!fs.existsSync(weightsPath))
+                return undefined;
+            const raw = fs.readFileSync(weightsPath, 'utf-8');
+            const data = JSON.parse(raw);
+            return {
+                taskCompletion: Number(data.task_completion ?? data.taskCompletion ?? 0.5),
+                codeQuality: Number(data.code_quality ?? data.codeQuality ?? 0.3),
+                process: Number(data.process ?? 0.2),
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+/**
+ * Aggregates quality signals from multiple registered providers.
+ *
+ * If no providers are registered, loadAllSignals returns empty arrays
+ * with zero overhead.
+ */
+export class IntelligenceLoader {
+    constructor() {
+        this.providers = [];
+    }
+    /** Register an external intelligence provider */
+    registerProvider(provider) {
+        this.providers.push(provider);
+    }
+    /** Returns the number of registered providers */
+    get providerCount() {
+        return this.providers.length;
+    }
+    /** Returns the names of all registered providers */
+    get providerNames() {
+        return this.providers.map(p => p.name());
+    }
+    /**
+     * Load signals from all registered providers.
+     *
+     * Non-fatal: if a provider fails, its error is captured but
+     * other providers continue loading.
+     */
+    loadAllSignals() {
+        const signals = [];
+        const errors = [];
+        for (const provider of this.providers) {
+            try {
+                const providerSignals = provider.loadSignals();
+                signals.push(...providerSignals);
+            }
+            catch (e) {
+                errors.push({
+                    providerName: provider.name(),
+                    message: e instanceof Error ? e.message : String(e),
+                });
+            }
+        }
+        return { signals, errors };
+    }
+    /** Load signals grouped by provider with weight overrides */
+    loadGrouped() {
+        return this.providers.map(provider => {
+            let providerSignals = [];
+            try {
+                providerSignals = provider.loadSignals();
+            }
+            catch {
+                // Non-fatal
+            }
+            return {
+                providerName: provider.name(),
+                signals: providerSignals,
+                weights: provider.qualityWeights?.(),
+            };
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"intelligence.js","sourceRoot":"","sources":["../../src/intelligence.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * External Intelligence Providers for SONA Learning (ADR-043)\n *\n * TypeScript bindings for the IntelligenceProvider trait, enabling\n * external systems to feed quality signals into RuvLLM's learning loops.\n *\n * @example\n * ```typescript\n * import { IntelligenceLoader, FileSignalProvider, QualitySignal } from '@ruvector/ruvllm';\n *\n * const loader = new IntelligenceLoader();\n * loader.registerProvider(new FileSignalProvider('./signals.json'));\n *\n * const { signals, errors } = loader.loadAllSignals();\n * console.log(`Loaded ${signals.length} signals`);\n * ```\n */\n\nimport * as fs from 'fs';\nimport * as path from 'path';\n\n/** Maximum signal file size (10 MiB) */\nconst MAX_SIGNAL_FILE_SIZE = 10 * 1024 * 1024;\n\n/** Maximum number of signals per file */\nconst MAX_SIGNALS_PER_FILE = 10_000;\n\n/** Valid outcome values */\nconst VALID_OUTCOMES = new Set(['success', 'partial_success', 'failure']);\n\n/** Valid human verdict values */\nconst VALID_VERDICTS = new Set(['approved', 'rejected']);\n\n/**\n * A quality signal from an external system.\n *\n * Represents one completed task with quality assessment data\n * that can feed into SONA trajectories, the embedding classifier,\n * and model router calibration.\n */\nexport interface QualitySignal {\n  /** Unique identifier for this signal */\n  id: string;\n  /** Human-readable task description (used for embedding generation) */\n  taskDescription: string;\n  /** Execution outcome */\n  outcome: 'success' | 'partial_success' | 'failure';\n  /** Composite quality score (0.0 - 1.0) */\n  qualityScore: number;\n  /** Optional human verdict */\n  humanVerdict?: 'approved' | 'rejected';\n  /** Optional structured quality factors for detailed analysis */\n  qualityFactors?: QualityFactors;\n  /** ISO 8601 timestamp of task completion */\n  completedAt: string;\n}\n\n/**\n * Granular quality factor breakdown.\n *\n * Not all providers will have all factors. Undefined fields mean\n * \"not assessed\" (distinct from 0.0, which means \"assessed as zero\").\n */\nexport interface QualityFactors {\n  acceptanceCriteriaMet?: number;\n  testsPassing?: number;\n  noRegressions?: number;\n  lintClean?: number;\n  typeCheckClean?: number;\n  followsPatterns?: number;\n  contextRelevance?: number;\n  reasoningCoherence?: number;\n  executionEfficiency?: number;\n}\n\n/**\n * Quality weight overrides from a provider.\n *\n * Weights should sum to approximately 1.0.\n */\nexport interface ProviderQualityWeights {\n  taskCompletion: number;\n  codeQuality: number;\n  process: number;\n}\n\n/**\n * Error from a single provider during batch loading.\n */\nexport interface ProviderError {\n  providerName: string;\n  message: string;\n}\n\n/**\n * Result from a single provider during grouped loading.\n */\nexport interface ProviderResult {\n  providerName: string;\n  signals: QualitySignal[];\n  weights?: ProviderQualityWeights;\n}\n\n/**\n * Interface for external systems that supply quality signals to RuvLLM.\n *\n * Implement this interface and register with IntelligenceLoader.\n */\nexport interface IntelligenceProvider {\n  /** Human-readable name for this provider */\n  name(): string;\n  /** Load quality signals from this provider's data source */\n  loadSignals(): QualitySignal[];\n  /** Optional quality weight overrides */\n  qualityWeights?(): ProviderQualityWeights | undefined;\n}\n\nfunction asOptionalNumber(val: unknown): number | undefined {\n  if (val === undefined || val === null) return undefined;\n  const n = Number(val);\n  return Number.isFinite(n) && n >= 0 && n <= 1 ? n : undefined;\n}\n\nfunction validateOutcome(val: unknown): QualitySignal['outcome'] {\n  const s = String(val ?? 'failure');\n  return VALID_OUTCOMES.has(s) ? s as QualitySignal['outcome'] : 'failure';\n}\n\nfunction validateVerdict(val: unknown): QualitySignal['humanVerdict'] | undefined {\n  if (val === undefined || val === null) return undefined;\n  const s = String(val);\n  return VALID_VERDICTS.has(s) ? s as QualitySignal['humanVerdict'] : undefined;\n}\n\nfunction validateScore(val: unknown): number {\n  const n = Number(val ?? 0);\n  if (!Number.isFinite(n) || n < 0 || n > 1) return 0;\n  return n;\n}\n\nfunction mapQualityFactors(raw: Record<string, unknown>): QualityFactors {\n  return {\n    acceptanceCriteriaMet: asOptionalNumber(raw.acceptance_criteria_met),\n    testsPassing: asOptionalNumber(raw.tests_passing),\n    noRegressions: asOptionalNumber(raw.no_regressions),\n    lintClean: asOptionalNumber(raw.lint_clean),\n    typeCheckClean: asOptionalNumber(raw.type_check_clean),\n    followsPatterns: asOptionalNumber(raw.follows_patterns),\n    contextRelevance: asOptionalNumber(raw.context_relevance),\n    reasoningCoherence: asOptionalNumber(raw.reasoning_coherence),\n    executionEfficiency: asOptionalNumber(raw.execution_efficiency),\n  };\n}\n\n/**\n * Built-in file-based intelligence provider.\n *\n * Reads quality signals from a JSON file. This is the default provider\n * for non-Rust integrations that write signal files.\n */\nexport class FileSignalProvider implements IntelligenceProvider {\n  private readonly filePath: string;\n\n  constructor(filePath: string) {\n    this.filePath = path.resolve(filePath);\n  }\n\n  name(): string {\n    return 'file-signals';\n  }\n\n  loadSignals(): QualitySignal[] {\n    if (!fs.existsSync(this.filePath)) {\n      return [];\n    }\n\n    // Check file size before reading (prevent OOM)\n    const stat = fs.statSync(this.filePath);\n    if (stat.size > MAX_SIGNAL_FILE_SIZE) {\n      throw new Error(\n        `Signal file exceeds max size (${stat.size} bytes, limit ${MAX_SIGNAL_FILE_SIZE})`\n      );\n    }\n\n    const raw = fs.readFileSync(this.filePath, 'utf-8');\n    const data: unknown = JSON.parse(raw);\n    if (!Array.isArray(data)) {\n      return [];\n    }\n\n    // Check signal count\n    if (data.length > MAX_SIGNALS_PER_FILE) {\n      throw new Error(\n        `Signal file contains ${data.length} signals, max is ${MAX_SIGNALS_PER_FILE}`\n      );\n    }\n\n    return data.map((item: Record<string, unknown>) => {\n      const qfRaw = (item.quality_factors ?? item.qualityFactors) as Record<string, unknown> | undefined;\n      return {\n        id: String(item.id ?? ''),\n        taskDescription: String(item.task_description ?? item.taskDescription ?? ''),\n        outcome: validateOutcome(item.outcome),\n        qualityScore: validateScore(item.quality_score ?? item.qualityScore),\n        humanVerdict: validateVerdict(item.human_verdict ?? item.humanVerdict),\n        qualityFactors: qfRaw ? mapQualityFactors(qfRaw) : undefined,\n        completedAt: String(item.completed_at ?? item.completedAt ?? new Date().toISOString()),\n      };\n    });\n  }\n\n  qualityWeights(): ProviderQualityWeights | undefined {\n    try {\n      const weightsPath = path.join(path.dirname(this.filePath), 'quality-weights.json');\n      if (!fs.existsSync(weightsPath)) return undefined;\n      const raw = fs.readFileSync(weightsPath, 'utf-8');\n      const data = JSON.parse(raw) as Record<string, unknown>;\n      return {\n        taskCompletion: Number(data.task_completion ?? data.taskCompletion ?? 0.5),\n        codeQuality: Number(data.code_quality ?? data.codeQuality ?? 0.3),\n        process: Number(data.process ?? 0.2),\n      };\n    } catch {\n      return undefined;\n    }\n  }\n}\n\n/**\n * Aggregates quality signals from multiple registered providers.\n *\n * If no providers are registered, loadAllSignals returns empty arrays\n * with zero overhead.\n */\nexport class IntelligenceLoader {\n  private providers: IntelligenceProvider[] = [];\n\n  /** Register an external intelligence provider */\n  registerProvider(provider: IntelligenceProvider): void {\n    this.providers.push(provider);\n  }\n\n  /** Returns the number of registered providers */\n  get providerCount(): number {\n    return this.providers.length;\n  }\n\n  /** Returns the names of all registered providers */\n  get providerNames(): string[] {\n    return this.providers.map(p => p.name());\n  }\n\n  /**\n   * Load signals from all registered providers.\n   *\n   * Non-fatal: if a provider fails, its error is captured but\n   * other providers continue loading.\n   */\n  loadAllSignals(): { signals: QualitySignal[]; errors: ProviderError[] } {\n    const signals: QualitySignal[] = [];\n    const errors: ProviderError[] = [];\n\n    for (const provider of this.providers) {\n      try {\n        const providerSignals = provider.loadSignals();\n        signals.push(...providerSignals);\n      } catch (e) {\n        errors.push({\n          providerName: provider.name(),\n          message: e instanceof Error ? e.message : String(e),\n        });\n      }\n    }\n\n    return { signals, errors };\n  }\n\n  /** Load signals grouped by provider with weight overrides */\n  loadGrouped(): ProviderResult[] {\n    return this.providers.map(provider => {\n      let providerSignals: QualitySignal[] = [];\n      try {\n        providerSignals = provider.loadSignals();\n      } catch {\n        // Non-fatal\n      }\n      return {\n        providerName: provider.name(),\n        signals: providerSignals,\n        weights: provider.qualityWeights?.(),\n      };\n    });\n  }\n}\n"]}