agentic-flow 2.0.1-alpha → 2.0.1-alpha.3

package/dist/agentdb/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * AgentDB Re-exports for Backwards Compatibility
+ *
+ * This module provides backwards-compatible exports for code that previously
+ * used embedded AgentDB controllers. Now proxies to agentdb npm package.
+ *
+ * @deprecated Import directly from specific agentdb paths for better tree-shaking
+ * @since v1.7.0 - Integrated agentdb as proper dependency
+ *
+ * Example migration:
+ * ```typescript
+ * // Old (still works)
+ * import { ReflexionMemory } from 'agentic-flow/agentdb';
+ *
+ * // New (recommended)
+ * import { ReflexionMemory } from 'agentdb/controllers/ReflexionMemory';
+ * ```
+ */
+export { ReflexionMemory } from 'agentdb';
+export { SkillLibrary } from 'agentdb';
+export { EmbeddingService } from 'agentdb';
+export { CausalMemoryGraph } from 'agentdb';
+export { CausalRecall } from 'agentdb';
+export { NightlyLearner } from 'agentdb';
+export { ExplainableRecall } from 'agentdb';
+//# sourceMappingURL=index.d.ts.map

package/dist/agentdb/tests/frontier-features.test.js

@@ -0,0 +1,665 @@
+/**
+ * Comprehensive Tests for Frontier Features
+ *
+ * Validates:
+ * 1. CausalMemoryGraph - causal inference, uplift calculation, A/B testing
+ * 2. ExplainableRecall - minimal hitting sets, Merkle proofs, provenance
+ *
+ * NO MOCKING - Real SQLite database, real algorithms, real results
+ */
+import Database from 'better-sqlite3';
+import * as fs from 'fs';
+import * as path from 'path';
+import { CausalMemoryGraph } from '../controllers/CausalMemoryGraph';
+import { ExplainableRecall } from '../controllers/ExplainableRecall';
+describe('Frontier Features - CausalMemoryGraph', () => {
+    let db;
+    let causalGraph;
+    beforeEach(() => {
+        // Create in-memory database
+        db = new Database(':memory:');
+        // Load core schema
+        const coreSchema = fs.readFileSync(path.join(__dirname, '../schemas/schema.sql'), 'utf-8');
+        db.exec(coreSchema);
+        // Load frontier schema
+        const frontierSchema = fs.readFileSync(path.join(__dirname, '../schemas/frontier-schema.sql'), 'utf-8');
+        db.exec(frontierSchema);
+        causalGraph = new CausalMemoryGraph(db);
+        // Insert test episodes
+        const episodes = [
+            { session_id: 'session1', task: 'code_review', reward: 0.8, success: 1 },
+            { session_id: 'session1', task: 'bug_fix', reward: 0.9, success: 1 },
+            { session_id: 'session2', task: 'feature_impl', reward: 0.7, success: 1 },
+            { session_id: 'session2', task: 'testing', reward: 0.85, success: 1 },
+            { session_id: 'session3', task: 'refactoring', reward: 0.75, success: 1 },
+        ];
+        const stmt = db.prepare(`
+      INSERT INTO episodes (session_id, task, reward, success)
+      VALUES (?, ?, ?, ?)
+    `);
+        episodes.forEach(ep => {
+            stmt.run(ep.session_id, ep.task, ep.reward, ep.success);
+        });
+    });
+    afterEach(() => {
+        db.close();
+    });
+    test('should add causal edge with all properties', () => {
+        const edge = {
+            fromMemoryId: 1,
+            fromMemoryType: 'episode',
+            toMemoryId: 2,
+            toMemoryType: 'episode',
+            similarity: 0.85,
+            uplift: 0.15,
+            confidence: 0.9,
+            sampleSize: 100,
+            evidenceIds: ['exp1', 'exp2'],
+            mechanism: 'code_review improves bug_fix success'
+        };
+        const edgeId = causalGraph.addCausalEdge(edge);
+        expect(edgeId).toBeGreaterThan(0);
+        // Verify stored correctly
+        const stored = db.prepare('SELECT * FROM causal_edges WHERE id = ?').get(edgeId);
+        expect(stored.from_memory_id).toBe(1);
+        expect(stored.to_memory_id).toBe(2);
+        expect(stored.similarity).toBe(0.85);
+        expect(stored.uplift).toBe(0.15);
+        expect(stored.confidence).toBe(0.9);
+        expect(stored.sample_size).toBe(100);
+        expect(JSON.parse(stored.evidence_ids)).toEqual(['exp1', 'exp2']);
+        expect(stored.mechanism).toBe('code_review improves bug_fix success');
+    });
+    test('should create and track A/B experiment', () => {
+        const experiment = {
+            name: 'Test Code Review Impact',
+            hypothesis: 'Code review reduces bugs',
+            treatmentId: 1,
+            treatmentType: 'episode',
+            controlId: 3,
+            startTime: Date.now(),
+            sampleSize: 0,
+            status: 'running'
+        };
+        const expId = causalGraph.createExperiment(experiment);
+        expect(expId).toBeGreaterThan(0);
+        // Verify stored
+        const stored = db.prepare('SELECT * FROM causal_experiments WHERE id = ?').get(expId);
+        expect(stored.name).toBe('Test Code Review Impact');
+        expect(stored.status).toBe('running');
+        expect(stored.sample_size).toBe(0);
+    });
+    test('should record observations and update sample size', () => {
+        const expId = causalGraph.createExperiment({
+            name: 'Test Experiment',
+            hypothesis: 'Treatment improves outcome',
+            treatmentId: 1,
+            treatmentType: 'episode',
+            startTime: Date.now(),
+            sampleSize: 0,
+            status: 'running'
+        });
+        // Record treatment observation
+        causalGraph.recordObservation({
+            experimentId: expId,
+            episodeId: 1,
+            isTreatment: true,
+            outcomeValue: 0.9,
+            outcomeType: 'reward'
+        });
+        // Record control observation
+        causalGraph.recordObservation({
+            experimentId: expId,
+            episodeId: 2,
+            isTreatment: false,
+            outcomeValue: 0.7,
+            outcomeType: 'reward'
+        });
+        // Check sample size updated
+        const experiment = db.prepare('SELECT * FROM causal_experiments WHERE id = ?').get(expId);
+        expect(experiment.sample_size).toBe(2);
+        // Check observations stored
+        const observations = db.prepare('SELECT * FROM causal_observations WHERE experiment_id = ?').all(expId);
+        expect(observations).toHaveLength(2);
+    });
+    test('should calculate uplift with statistical significance', () => {
+        const expId = causalGraph.createExperiment({
+            name: 'Uplift Test',
+            hypothesis: 'Treatment increases reward',
+            treatmentId: 1,
+            treatmentType: 'episode',
+            startTime: Date.now(),
+            sampleSize: 0,
+            status: 'running'
+        });
+        // Record 50 treatment observations (mean ~0.8)
+        for (let i = 0; i < 50; i++) {
+            causalGraph.recordObservation({
+                experimentId: expId,
+                episodeId: 1,
+                isTreatment: true,
+                outcomeValue: 0.75 + Math.random() * 0.1, // 0.75-0.85
+                outcomeType: 'reward'
+            });
+        }
+        // Record 50 control observations (mean ~0.6)
+        for (let i = 0; i < 50; i++) {
+            causalGraph.recordObservation({
+                experimentId: expId,
+                episodeId: 2,
+                isTreatment: false,
+                outcomeValue: 0.55 + Math.random() * 0.1, // 0.55-0.65
+                outcomeType: 'reward'
+            });
+        }
+        const result = causalGraph.calculateUplift(expId);
+        // Validate results
+        expect(result.uplift).toBeGreaterThan(0.1); // Treatment > Control
+        expect(result.uplift).toBeLessThan(0.3); // Reasonable range
+        expect(result.pValue).toBeLessThan(0.05); // Statistically significant
+        expect(result.confidenceInterval[0]).toBeLessThan(result.uplift);
+        expect(result.confidenceInterval[1]).toBeGreaterThan(result.uplift);
+        // Verify experiment updated
+        const experiment = db.prepare('SELECT * FROM causal_experiments WHERE id = ?').get(expId);
+        expect(experiment.status).toBe('completed');
+        expect(experiment.uplift).toBeCloseTo(result.uplift, 5);
+        expect(experiment.p_value).toBeCloseTo(result.pValue, 5);
+    });
+    test('should query causal effects by confidence and uplift', () => {
+        // Add multiple causal edges
+        causalGraph.addCausalEdge({
+            fromMemoryId: 1,
+            fromMemoryType: 'episode',
+            toMemoryId: 2,
+            toMemoryType: 'episode',
+            similarity: 0.8,
+            uplift: 0.2,
+            confidence: 0.9,
+            sampleSize: 100
+        });
+        causalGraph.addCausalEdge({
+            fromMemoryId: 1,
+            fromMemoryType: 'episode',
+            toMemoryId: 3,
+            toMemoryType: 'episode',
+            similarity: 0.7,
+            uplift: 0.05, // Low uplift
+            confidence: 0.95,
+            sampleSize: 80
+        });
+        causalGraph.addCausalEdge({
+            fromMemoryId: 1,
+            fromMemoryType: 'episode',
+            toMemoryId: 4,
+            toMemoryType: 'episode',
+            similarity: 0.85,
+            uplift: 0.25,
+            confidence: 0.4, // Low confidence
+            sampleSize: 50
+        });
+        // Query with filters
+        const effects = causalGraph.queryCausalEffects({
+            interventionMemoryId: 1,
+            interventionMemoryType: 'episode',
+            minConfidence: 0.8,
+            minUplift: 0.1
+        });
+        // Should only return first edge (high confidence + high uplift)
+        expect(effects).toHaveLength(1);
+        expect(effects[0].toMemoryId).toBe(2);
+        expect(effects[0].confidence).toBe(0.9);
+        expect(effects[0].uplift).toBe(0.2);
+    });
+    test('should find multi-hop causal chains', () => {
+        // Create chain: 1 -> 2 -> 3
+        causalGraph.addCausalEdge({
+            fromMemoryId: 1,
+            fromMemoryType: 'episode',
+            toMemoryId: 2,
+            toMemoryType: 'episode',
+            similarity: 0.8,
+            uplift: 0.1,
+            confidence: 0.9,
+            sampleSize: 100
+        });
+        causalGraph.addCausalEdge({
+            fromMemoryId: 2,
+            fromMemoryType: 'episode',
+            toMemoryId: 3,
+            toMemoryType: 'episode',
+            similarity: 0.75,
+            uplift: 0.15,
+            confidence: 0.85,
+            sampleSize: 80
+        });
+        // Also add direct edge 1 -> 3 (lower uplift)
+        causalGraph.addCausalEdge({
+            fromMemoryId: 1,
+            fromMemoryType: 'episode',
+            toMemoryId: 3,
+            toMemoryType: 'episode',
+            similarity: 0.7,
+            uplift: 0.05,
+            confidence: 0.8,
+            sampleSize: 60
+        });
+        const chains = causalGraph.getCausalChain(1, 3, 5);
+        // Should find both paths
+        expect(chains.length).toBeGreaterThanOrEqual(1);
+        // The 2-hop path should have higher total uplift
+        const twoHopChain = chains.find(c => c.path.length === 3); // [1, 2, 3]
+        expect(twoHopChain).toBeDefined();
+        expect(twoHopChain.path).toEqual([1, 2, 3]);
+        expect(twoHopChain.totalUplift).toBeCloseTo(0.25, 1); // 0.1 + 0.15
+        expect(twoHopChain.confidence).toBeGreaterThanOrEqual(0.85); // Min of chain
+    });
+    test('should detect potential confounders', () => {
+        // Create scenario where episode 3 might be a confounder
+        // for the relationship between episode 1 and episode 2
+        const edgeId = causalGraph.addCausalEdge({
+            fromMemoryId: 1,
+            fromMemoryType: 'episode',
+            toMemoryId: 2,
+            toMemoryType: 'episode',
+            similarity: 0.8,
+            uplift: 0.2,
+            confidence: 0.9,
+            sampleSize: 100
+        });
+        const result = causalGraph.detectConfounders(edgeId);
+        // Should return confounders array (may be empty in test data)
+        expect(result).toHaveProperty('confounders');
+        expect(Array.isArray(result.confounders)).toBe(true);
+        // Each confounder should have required properties
+        result.confounders.forEach(conf => {
+            expect(conf).toHaveProperty('memoryId');
+            expect(conf).toHaveProperty('correlationWithTreatment');
+            expect(conf).toHaveProperty('correlationWithOutcome');
+            expect(conf).toHaveProperty('confounderScore');
+            expect(conf.confounderScore).toBeGreaterThan(0.3);
+        });
+    });
+    test('should calculate causal gain vs baseline', () => {
+        // Add causal edges from treatment (episode 1) to outcomes
+        causalGraph.addCausalEdge({
+            fromMemoryId: 1,
+            fromMemoryType: 'episode',
+            toMemoryId: 2,
+            toMemoryType: 'episode',
+            similarity: 0.85,
+            uplift: 0.2,
+            confidence: 0.9,
+            mechanism: 'improves outcome'
+        });
+        const result = causalGraph.calculateCausalGain(1, 'reward');
+        // Should calculate difference between treated and untreated episodes
+        expect(result).toHaveProperty('causalGain');
+        expect(result).toHaveProperty('confidence');
+        expect(result).toHaveProperty('mechanism');
+        expect(result.confidence).toBeGreaterThanOrEqual(0);
+        expect(result.confidence).toBeLessThanOrEqual(1);
+        expect(typeof result.causalGain).toBe('number');
+    });
+});
+describe('Frontier Features - ExplainableRecall', () => {
+    let db;
+    let explainableRecall;
+    beforeEach(() => {
+        db = new Database(':memory:');
+        const coreSchema = fs.readFileSync(path.join(__dirname, '../schemas/schema.sql'), 'utf-8');
+        db.exec(coreSchema);
+        const frontierSchema = fs.readFileSync(path.join(__dirname, '../schemas/frontier-schema.sql'), 'utf-8');
+        db.exec(frontierSchema);
+        explainableRecall = new ExplainableRecall(db);
+        // Insert test episodes
+        for (let i = 1; i <= 10; i++) {
+            db.prepare(`
+        INSERT INTO episodes (session_id, task, reward, success)
+        VALUES (?, ?, ?, ?)
+      `).run(`session${i}`, `task${i}`, 0.8, 1);
+        }
+    });
+    afterEach(() => {
+        db.close();
+    });
+    test('should create recall certificate with minimal hitting set', () => {
+        const chunks = [
+            { id: '1', type: 'episode', content: 'Implement authentication', relevance: 0.9 },
+            { id: '2', type: 'episode', content: 'Add JWT tokens', relevance: 0.85 },
+            { id: '3', type: 'episode', content: 'Hash passwords', relevance: 0.8 },
+            { id: '4', type: 'episode', content: 'Setup database', relevance: 0.7 }
+        ];
+        const requirements = [
+            'authentication',
+            'security',
+            'tokens'
+        ];
+        const certificate = explainableRecall.createCertificate({
+            queryId: 'q1',
+            queryText: 'How to implement secure authentication?',
+            chunks,
+            requirements,
+            accessLevel: 'internal'
+        });
+        // Validate certificate structure
+        expect(certificate).toHaveProperty('id');
+        expect(certificate.queryId).toBe('q1');
+        expect(certificate.chunkIds).toEqual(['1', '2', '3', '4']);
+        expect(certificate.chunkTypes).toEqual(['episode', 'episode', 'episode', 'episode']);
+        // Validate minimal hitting set
+        expect(certificate.minimalWhy).toBeDefined();
+        expect(certificate.minimalWhy.length).toBeGreaterThan(0);
+        expect(certificate.minimalWhy.length).toBeLessThanOrEqual(chunks.length);
+        // Redundancy ratio should be >= 1
+        expect(certificate.redundancyRatio).toBeGreaterThanOrEqual(1);
+        expect(certificate.redundancyRatio).toBe(chunks.length / certificate.minimalWhy.length);
+        // Completeness should be 0-1
+        expect(certificate.completenessScore).toBeGreaterThanOrEqual(0);
+        expect(certificate.completenessScore).toBeLessThanOrEqual(1);
+        // Merkle root should exist
+        expect(certificate.merkleRoot).toBeDefined();
+        expect(certificate.merkleRoot.length).toBeGreaterThan(0);
+        // Source hashes should match chunks
+        expect(certificate.sourceHashes).toHaveLength(chunks.length);
+        // Access level
+        expect(certificate.accessLevel).toBe('internal');
+        // Latency tracking
+        expect(certificate.latencyMs).toBeGreaterThan(0);
+    });
+    test('should verify certificate integrity', () => {
+        const chunks = [
+            { id: '1', type: 'episode', content: 'Test content 1', relevance: 0.9 },
+            { id: '2', type: 'episode', content: 'Test content 2', relevance: 0.8 }
+        ];
+        const certificate = explainableRecall.createCertificate({
+            queryId: 'q2',
+            queryText: 'Test query',
+            chunks,
+            requirements: ['test'],
+            accessLevel: 'public'
+        });
+        // Verify the certificate
+        const verification = explainableRecall.verifyCertificate(certificate.id);
+        expect(verification.valid).toBe(true);
+        expect(verification.issues).toHaveLength(0);
+    });
+    test('should detect tampered certificate', () => {
+        const chunks = [
+            { id: '1', type: 'episode', content: 'Original content', relevance: 0.9 }
+        ];
+        const certificate = explainableRecall.createCertificate({
+            queryId: 'q3',
+            queryText: 'Test query',
+            chunks,
+            requirements: ['test'],
+            accessLevel: 'internal'
+        });
+        // Tamper with the certificate in database
+        db.prepare(`
+      UPDATE recall_certificates
+      SET chunk_ids = ?
+      WHERE id = ?
+    `).run(JSON.stringify(['1', '999']), certificate.id);
+        // Verification should fail
+        const verification = explainableRecall.verifyCertificate(certificate.id);
+        expect(verification.valid).toBe(false);
+        expect(verification.issues.length).toBeGreaterThan(0);
+        expect(verification.issues[0]).toContain('Merkle root');
+    });
+    test('should provide justification for each chunk', () => {
+        const chunks = [
+            { id: '1', type: 'episode', content: 'Setup API endpoint', relevance: 0.9 },
+            { id: '2', type: 'episode', content: 'Add validation', relevance: 0.85 }
+        ];
+        const certificate = explainableRecall.createCertificate({
+            queryId: 'q4',
+            queryText: 'How to create API?',
+            chunks,
+            requirements: ['api', 'validation'],
+            accessLevel: 'internal'
+        });
+        // Get justification for first chunk
+        const justification = explainableRecall.getJustification(certificate.id, '1');
+        expect(justification).toBeDefined();
+        expect(justification.chunkId).toBe('1');
+        expect(justification.chunkType).toBe('episode');
+        expect(justification.reason).toBeDefined();
+        expect(justification.necessityScore).toBeGreaterThanOrEqual(0);
+        expect(justification.necessityScore).toBeLessThanOrEqual(1);
+        expect(justification.pathElements).toBeDefined();
+        expect(Array.isArray(justification.pathElements)).toBe(true);
+    });
+    test('should track provenance lineage', () => {
+        // Create source with provenance
+        const sourceId = explainableRecall.createProvenance({
+            sourceType: 'episode',
+            sourceId: 1,
+            creator: 'test_user'
+        });
+        expect(sourceId).toBeGreaterThan(0);
+        // Get the content hash
+        const source = db.prepare('SELECT * FROM provenance_sources WHERE id = ?').get(sourceId);
+        expect(source).toBeDefined();
+        expect(source.content_hash).toBeDefined();
+        // Track lineage
+        const lineage = explainableRecall.getProvenanceLineage(source.content_hash);
+        expect(lineage).toHaveLength(1);
+        expect(lineage[0].sourceType).toBe('episode');
+        expect(lineage[0].sourceId).toBe(1);
+        expect(lineage[0].creator).toBe('test_user');
+    });
+    test('should audit certificate for quality metrics', () => {
+        const chunks = [
+            { id: '1', type: 'episode', content: 'Content 1', relevance: 0.95 },
+            { id: '2', type: 'episode', content: 'Content 2', relevance: 0.9 },
+            { id: '3', type: 'episode', content: 'Content 3', relevance: 0.85 },
+            { id: '4', type: 'episode', content: 'Content 4', relevance: 0.5 } // Low relevance
+        ];
+        const certificate = explainableRecall.createCertificate({
+            queryId: 'q5',
+            queryText: 'Test audit query',
+            chunks,
+            requirements: ['req1', 'req2'],
+            accessLevel: 'internal'
+        });
+        const audit = explainableRecall.auditCertificate(certificate.id);
+        // Validate audit structure
+        expect(audit).toHaveProperty('certificateId');
+        expect(audit).toHaveProperty('queryText');
+        expect(audit).toHaveProperty('totalChunks');
+        expect(audit).toHaveProperty('minimalSetSize');
+        expect(audit).toHaveProperty('redundancyRatio');
+        expect(audit).toHaveProperty('completenessScore');
+        expect(audit).toHaveProperty('avgNecessityScore');
+        expect(audit).toHaveProperty('provenanceVerified');
+        expect(audit).toHaveProperty('qualityScore');
+        expect(audit.certificateId).toBe(certificate.id);
+        expect(audit.totalChunks).toBe(4);
+        expect(audit.minimalSetSize).toBeGreaterThan(0);
+        expect(audit.redundancyRatio).toBeGreaterThanOrEqual(1);
+        expect(audit.qualityScore).toBeGreaterThanOrEqual(0);
+        expect(audit.qualityScore).toBeLessThanOrEqual(1);
+        expect(audit.provenanceVerified).toBe(true);
+    });
+    test('should handle empty chunks gracefully', () => {
+        const certificate = explainableRecall.createCertificate({
+            queryId: 'q6',
+            queryText: 'Empty query',
+            chunks: [],
+            requirements: ['test'],
+            accessLevel: 'public'
+        });
+        expect(certificate.chunkIds).toHaveLength(0);
+        expect(certificate.minimalWhy).toHaveLength(0);
+        expect(certificate.redundancyRatio).toBe(0);
+        expect(certificate.completenessScore).toBe(0);
+    });
+    test('should calculate correct minimal hitting set', () => {
+        // Test case: Each chunk covers different requirements
+        const chunks = [
+            { id: '1', type: 'episode', content: 'auth implementation', relevance: 0.9 },
+            { id: '2', type: 'episode', content: 'database setup', relevance: 0.85 },
+            { id: '3', type: 'episode', content: 'API endpoints', relevance: 0.8 }
+        ];
+        const requirements = ['auth', 'database', 'api'];
+        const certificate = explainableRecall.createCertificate({
+            queryId: 'q7',
+            queryText: 'Full stack implementation',
+            chunks,
+            requirements,
+            accessLevel: 'internal'
+        });
+        // All chunks should be in minimal set (each covers unique requirement)
+        expect(certificate.minimalWhy.length).toBe(3);
+        expect(certificate.redundancyRatio).toBe(1.0);
+    });
+    test('should generate valid Merkle proofs', () => {
+        const chunks = Array.from({ length: 8 }, (_, i) => ({
+            id: `${i + 1}`,
+            type: 'episode',
+            content: `Content ${i + 1}`,
+            relevance: 0.9 - i * 0.05
+        }));
+        const certificate = explainableRecall.createCertificate({
+            queryId: 'q8',
+            queryText: 'Merkle test',
+            chunks,
+            requirements: ['test'],
+            accessLevel: 'internal'
+        });
+        // Merkle root should be deterministic
+        expect(certificate.merkleRoot).toBeDefined();
+        expect(certificate.merkleRoot.length).toBe(64); // SHA-256 hex = 64 chars
+        // Source hashes should match chunks
+        expect(certificate.sourceHashes).toHaveLength(8);
+        certificate.sourceHashes.forEach(hash => {
+            expect(hash.length).toBe(64);
+        });
+    });
+});
+describe('Frontier Features - Integration Tests', () => {
+    let db;
+    let causalGraph;
+    let explainableRecall;
+    beforeEach(() => {
+        db = new Database(':memory:');
+        const coreSchema = fs.readFileSync(path.join(__dirname, '../schemas/schema.sql'), 'utf-8');
+        db.exec(coreSchema);
+        const frontierSchema = fs.readFileSync(path.join(__dirname, '../schemas/frontier-schema.sql'), 'utf-8');
+        db.exec(frontierSchema);
+        causalGraph = new CausalMemoryGraph(db);
+        explainableRecall = new ExplainableRecall(db);
+    });
+    afterEach(() => {
+        db.close();
+    });
+    test('should combine causal reasoning with explainable recall', () => {
+        // 1. Insert episodes
+        for (let i = 1; i <= 5; i++) {
+            db.prepare(`
+        INSERT INTO episodes (session_id, task, reward, success)
+        VALUES (?, ?, ?, ?)
+      `).run(`session${i}`, `task${i}`, 0.7 + i * 0.05, 1);
+        }
+        // 2. Add causal edges
+        causalGraph.addCausalEdge({
+            fromMemoryId: 1,
+            fromMemoryType: 'episode',
+            toMemoryId: 2,
+            toMemoryType: 'episode',
+            similarity: 0.85,
+            uplift: 0.15,
+            confidence: 0.9,
+            mechanism: 'task1 improves task2'
+        });
+        // 3. Create retrieval with provenance
+        const chunks = [
+            { id: '1', type: 'episode', content: 'First task', relevance: 0.9 },
+            { id: '2', type: 'episode', content: 'Second task', relevance: 0.85 }
+        ];
+        const certificate = explainableRecall.createCertificate({
+            queryId: 'integrated_q1',
+            queryText: 'Show me tasks with causal relationships',
+            chunks,
+            requirements: ['causal', 'evidence'],
+            accessLevel: 'internal'
+        });
+        // 4. Verify we can query both systems
+        const causalEffects = causalGraph.queryCausalEffects({
+            interventionMemoryId: 1,
+            interventionMemoryType: 'episode',
+            minConfidence: 0.8
+        });
+        expect(causalEffects.length).toBeGreaterThan(0);
+        expect(certificate).toBeDefined();
+        expect(certificate.minimalWhy.length).toBeGreaterThan(0);
+        // 5. Audit the certificate
+        const audit = explainableRecall.auditCertificate(certificate.id);
+        expect(audit.provenanceVerified).toBe(true);
+    });
+    test('should handle large-scale causal experiments efficiently', () => {
+        // Create experiment with many observations
+        const expId = causalGraph.createExperiment({
+            name: 'Large Scale Test',
+            hypothesis: 'Treatment improves outcome at scale',
+            treatmentId: 1,
+            treatmentType: 'episode',
+            startTime: Date.now(),
+            sampleSize: 0,
+            status: 'running'
+        });
+        const startTime = Date.now();
+        // Record 1000 observations
+        for (let i = 0; i < 1000; i++) {
+            causalGraph.recordObservation({
+                experimentId: expId,
+                episodeId: i % 10 + 1,
+                isTreatment: i % 2 === 0,
+                outcomeValue: (i % 2 === 0 ? 0.8 : 0.6) + Math.random() * 0.1,
+                outcomeType: 'reward'
+            });
+        }
+        const recordTime = Date.now() - startTime;
+        // Calculate uplift
+        const calcStart = Date.now();
+        const result = causalGraph.calculateUplift(expId);
+        const calcTime = Date.now() - calcStart;
+        // Performance assertions
+        expect(recordTime).toBeLessThan(1000); // < 1 second to record 1000 observations
+        expect(calcTime).toBeLessThan(100); // < 100ms to calculate uplift
+        // Result assertions
+        expect(result.uplift).toBeGreaterThan(0.1);
+        expect(result.pValue).toBeLessThan(0.05);
+    });
+    test('should handle concurrent certificate creation', () => {
+        const chunks = Array.from({ length: 10 }, (_, i) => ({
+            id: `${i + 1}`,
+            type: 'episode',
+            content: `Content ${i + 1}`,
+            relevance: 0.9 - i * 0.05
+        }));
+        // Create multiple certificates concurrently
+        const certificates = [];
+        for (let i = 0; i < 10; i++) {
+            const cert = explainableRecall.createCertificate({
+                queryId: `concurrent_q${i}`,
+                queryText: `Concurrent query ${i}`,
+                chunks: chunks.slice(0, i + 1),
+                requirements: ['test'],
+                accessLevel: 'internal'
+            });
+            certificates.push(cert);
+        }
+        // All should succeed
+        expect(certificates).toHaveLength(10);
+        certificates.forEach((cert, idx) => {
+            expect(cert.queryId).toBe(`concurrent_q${idx}`);
+            expect(cert.chunkIds.length).toBe(idx + 1);
+        });
+        // All should be verifiable
+        certificates.forEach(cert => {
+            const verification = explainableRecall.verifyCertificate(cert.id);
+            expect(verification.valid).toBe(true);
+        });
+    });
+});