@longarc/mdash 3.0.0

package/src/__tests__/phase2-4.test.ts

@@ -0,0 +1,898 @@
+/**
+ * mdash v3.0 - Phase 2-4 Test Suite
+ * 
+ * Tests for:
+ * - L2 TEE Attestation Engine
+ * - L3 ZK Proofs Engine
+ * - MCCA v3 Engine
+ * 
+ * @version 3.0.0
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { CommitmentEngine } from '../core/commitment.js';
+import { TEEAttestationEngine, TEEVerifier, AttestationBridge, PLATFORM_CAPABILITIES } from '../tee/engine.js';
+import { ZKProofsEngine, ClaimBuilder, InsuranceClaimProof, CIRCUIT_CONFIGS } from '../zk/engine.js';
+import { MCCAEngine, ContextWindowManager, DEFAULT_INFLUENCE_BUDGET } from '../mcca/engine.js';
+import { generateTimestamp } from '../core/crypto.js';
+
+const TEST_SEAL_KEY = 'test-seal-key-phase-2-4-v3.0.0';
+
+// ============================================================================
+// L2 TEE ATTESTATION TESTS
+// ============================================================================
+
+describe('L2 TEE Attestation Engine', () => {
+  let commitmentEngine: CommitmentEngine;
+  let teeEngine: TEEAttestationEngine;
+
+  beforeAll(async () => {
+    commitmentEngine = new CommitmentEngine();
+    await commitmentEngine.initialize(TEST_SEAL_KEY);
+    
+    teeEngine = new TEEAttestationEngine(commitmentEngine, {
+      platform: 'simulated',
+      attestationTTL: 60000,
+      enableCache: true,
+      cacheTTL: 30000,
+      rateLimit: 1000,
+    });
+    await teeEngine.initialize(TEST_SEAL_KEY);
+  });
+
+  describe('Platform Capabilities', () => {
+    it('should define capabilities for all platforms', () => {
+      expect(PLATFORM_CAPABILITIES.nitro).toBeDefined();
+      expect(PLATFORM_CAPABILITIES.sgx).toBeDefined();
+      expect(PLATFORM_CAPABILITIES.simulated).toBeDefined();
+    });
+
+    it('should report correct capabilities for simulated platform', () => {
+      const caps = teeEngine.getCapabilities();
+      expect(caps.remoteAttestation).toBe(true);
+      expect(caps.keySealing).toBe(true);
+    });
+
+    it('nitro should support PCR', () => {
+      expect(PLATFORM_CAPABILITIES.nitro.pcrSupport).toBe(true);
+    });
+
+    it('sgx should support quote generation', () => {
+      expect(PLATFORM_CAPABILITIES.sgx.quoteGeneration).toBe(true);
+    });
+  });
+
+  describe('Attestation Generation', () => {
+    it('should generate attestation document', async () => {
+      const data = { action: 'transfer', amount: 100 };
+      const commitmentId = 'test-commitment-001';
+
+      const attestation = await teeEngine.attest(data, commitmentId);
+
+      expect(attestation.id).toBeTruthy();
+      expect(attestation.platform).toBe('simulated');
+      expect(attestation.status).toBe('verified');
+      expect(attestation.attested_data).toBeTruthy();
+      expect(attestation.measurement).toBeTruthy();
+      expect(attestation.seal).toBeTruthy();
+    });
+
+    it('should attest within 10ms target (simulated)', async () => {
+      const data = { test: 'latency', timestamp: Date.now() };
+      const commitmentId = 'latency-test-001';
+
+      const startTime = performance.now();
+      await teeEngine.attest(data, commitmentId);
+      const elapsed = performance.now() - startTime;
+
+      // Simulated should be very fast
+      expect(elapsed).toBeLessThan(50); // Allow some margin
+    });
+
+    it('should use cache for identical attestations', async () => {
+      const data = { cacheTest: true, value: 42 };
+      const commitmentId = 'cache-test-001';
+
+      // First attestation
+      await teeEngine.attest(data, commitmentId);
+      const statsAfterFirst = teeEngine.getStats();
+
+      // Second attestation (should hit cache)
+      await teeEngine.attest(data, commitmentId);
+      const statsAfterSecond = teeEngine.getStats();
+
+      expect(statsAfterSecond.cacheHits).toBe(statsAfterFirst.cacheHits + 1);
+    });
+
+    it('should include platform-specific attestation', async () => {
+      const attestation = await teeEngine.attest(
+        { test: 'platform' },
+        'platform-test-001'
+      );
+
+      expect(attestation.platform_attestation).toBeDefined();
+      // Simulated attestation structure
+      const simAttest = attestation.platform_attestation as any;
+      expect(simAttest.type).toBe('simulated');
+      expect(simAttest.simulated_pcrs).toBeDefined();
+    });
+  });
+
+  describe('Attestation Verification', () => {
+    it('should verify valid attestation', async () => {
+      const attestation = await teeEngine.attest(
+        { verify: 'test' },
+        'verify-test-001'
+      );
+
+      const result = await teeEngine.verify(attestation);
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should detect expired attestation', async () => {
+      const attestation = await teeEngine.attest(
+        { expire: 'test' },
+        'expire-test-001'
+      );
+
+      // Manually expire the attestation
+      (attestation as any).expires_at = new Date(Date.now() - 1000).toISOString();
+
+      const result = await teeEngine.verify(attestation);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Attestation document expired');
+    });
+  });
+
+  describe('TEE Verifier (Remote Attestation)', () => {
+    it('should verify trusted measurements', async () => {
+      const verifier = new TEEVerifier();
+      
+      const attestation = await teeEngine.attest(
+        { remote: 'test' },
+        'remote-test-001'
+      );
+
+      // Trust the measurement
+      verifier.trustMeasurement(attestation.measurement);
+
+      const result = await verifier.verifyRemote(attestation);
+
+      expect(result.trusted).toBe(true);
+    });
+
+    it('should reject unknown measurements', async () => {
+      const verifier = new TEEVerifier();
+      
+      const attestation = await teeEngine.attest(
+        { unknown: 'measurement' },
+        'unknown-test-001'
+      );
+
+      // Don't trust any measurements
+
+      const result = await verifier.verifyRemote(attestation);
+
+      expect(result.trusted).toBe(false);
+      expect(result.reasons.some(r => r.includes('Unknown enclave measurement'))).toBe(true);
+    });
+  });
+
+  describe('Attestation Bridge (L1 <-> L2)', () => {
+    it('should commit and attest in one operation', async () => {
+      const bridge = new AttestationBridge(teeEngine, commitmentEngine);
+      const data = { bridgeTest: true, value: 'hello' };
+
+      const { commitment, attestation } = await bridge.commitAndAttest(
+        data,
+        'bridge-test-001'
+      );
+
+      expect(commitment).toBeTruthy();
+      expect(commitment.merkleRoot).toBeTruthy();
+      expect(attestation).toBeTruthy();
+      expect(attestation.commitment_id).toBe('bridge-test-001');
+    });
+
+    it('should verify both layers', async () => {
+      const bridge = new AttestationBridge(teeEngine, commitmentEngine);
+      const data = { verifyBoth: true, timestamp: Date.now() };
+
+      const { commitment, attestation } = await bridge.commitAndAttest(
+        data,
+        'verify-both-001'
+      );
+
+      const result = await bridge.verifyBoth(commitment, attestation);
+
+      expect(result.l1Valid).toBe(true);
+      expect(result.l2Valid).toBe(true);
+      expect(result.crossLayerValid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+  });
+
+  describe('Statistics', () => {
+    it('should track attestation metrics', () => {
+      const stats = teeEngine.getStats();
+
+      expect(stats.platform).toBe('simulated');
+      expect(stats.attestations).toBeGreaterThan(0);
+      expect(stats.avgLatencyMs).toBeGreaterThan(0);
+    });
+  });
+});
+
+// ============================================================================
+// L3 ZK PROOFS TESTS
+// ============================================================================
+
+describe('L3 ZK Proofs Engine', () => {
+  let commitmentEngine: CommitmentEngine;
+  let zkEngine: ZKProofsEngine;
+
+  beforeAll(async () => {
+    commitmentEngine = new CommitmentEngine();
+    await commitmentEngine.initialize(TEST_SEAL_KEY);
+    
+    zkEngine = new ZKProofsEngine(commitmentEngine, 4);
+    await zkEngine.initialize(TEST_SEAL_KEY);
+  });
+
+  afterAll(() => {
+    zkEngine.stopProcessing();
+  });
+
+  describe('Circuit Configurations', () => {
+    it('should define all circuit types', () => {
+      expect(CIRCUIT_CONFIGS.commitment_inclusion).toBeDefined();
+      expect(CIRCUIT_CONFIGS.warrant_validity).toBeDefined();
+      expect(CIRCUIT_CONFIGS.checkpoint_chain).toBeDefined();
+      expect(CIRCUIT_CONFIGS.action_compliance).toBeDefined();
+      expect(CIRCUIT_CONFIGS.audit_trail).toBeDefined();
+      expect(CIRCUIT_CONFIGS.custom).toBeDefined();
+    });
+
+    it('should have valid circuit configurations', () => {
+      for (const [type, config] of Object.entries(CIRCUIT_CONFIGS)) {
+        expect(config.name).toBeTruthy();
+        expect(config.numPublicInputs).toBeGreaterThan(0);
+        expect(config.estimatedGates).toBeGreaterThan(0);
+        expect(config.estimatedProvingTimeMs).toBeGreaterThan(0);
+      }
+    });
+  });
+
+  describe('Proof Request', () => {
+    it('should queue proof request', async () => {
+      const request = {
+        type: 'commitment_inclusion' as const,
+        statement: {
+          description: 'Prove data inclusion',
+          claim: { data: 'test', root: 'merkle-root' },
+        },
+        priority: 'normal' as const,
+      };
+
+      const document = await zkEngine.requestProof(request);
+
+      expect(document.id).toBeTruthy();
+      expect(document.status).toBe('queued');
+      expect(document.type).toBe('commitment_inclusion');
+      expect(document.statement.claim_hash).toBeTruthy();
+    });
+
+    it('should process proof in background', async () => {
+      const request = {
+        type: 'warrant_validity' as const,
+        statement: {
+          description: 'Prove warrant was valid',
+          claim: {
+            warrant: { id: 'w-12345678' },
+            timestamp: generateTimestamp(),
+            agent_id: 'agent-001',
+            action: 'transfer',
+          },
+        },
+        priority: 'high' as const,
+      };
+
+      const document = await zkEngine.requestProof(request);
+      
+      // Wait for processing
+      const completed = await zkEngine.waitForProof(document.id, 5000);
+
+      expect(completed.status).toBe('verified');
+      expect(completed.proof).toBeTruthy();
+      expect(completed.proof!.proof).toBeTruthy();
+      expect(completed.proof!.public_inputs.length).toBeGreaterThan(0);
+    });
+
+    it('should handle high priority proofs first', async () => {
+      // Queue low priority
+      const lowPriority = await zkEngine.requestProof({
+        type: 'custom',
+        statement: { description: 'Low priority', claim: { priority: 'low' } },
+        priority: 'low',
+      });
+
+      // Queue high priority
+      const highPriority = await zkEngine.requestProof({
+        type: 'custom',
+        statement: { description: 'High priority', claim: { priority: 'high' } },
+        priority: 'high',
+      });
+
+      // High priority should be queued with higher priority value
+      const completed1 = await zkEngine.waitForProof(highPriority.id, 5000);
+      const completed2 = await zkEngine.waitForProof(lowPriority.id, 5000);
+
+      expect(completed1.status).toBe('verified');
+      expect(completed2.status).toBe('verified');
+    });
+  });
+
+  describe('Claim Builder', () => {
+    it('should build proof request fluently', () => {
+      const request = new ClaimBuilder('action_compliance')
+        .withDescription('Test action compliance')
+        .withClaim('action', 'transfer')
+        .withClaim('amount', 1000)
+        .withClaim('constraints', { maxAmount: 5000 })
+        .withCommitments('cp-001', 'cp-002')
+        .withAttestations('att-001')
+        .build('high');
+
+      expect(request.type).toBe('action_compliance');
+      expect(request.statement.description).toBe('Test action compliance');
+      expect(request.statement.claim.action).toBe('transfer');
+      expect(request.commitmentIds).toContain('cp-001');
+      expect(request.attestationIds).toContain('att-001');
+      expect(request.priority).toBe('high');
+    });
+  });
+
+  describe('Proof Verification', () => {
+    it('should verify completed proof', async () => {
+      const request = {
+        type: 'commitment_inclusion' as const,
+        statement: {
+          description: 'Verify test',
+          claim: { test: 'verify' },
+        },
+      };
+
+      const document = await zkEngine.requestProof(request);
+      const completed = await zkEngine.waitForProof(document.id, 5000);
+
+      const result = await zkEngine.verifyProof(completed);
+
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should reject expired proof', async () => {
+      const request = {
+        type: 'custom' as const,
+        statement: {
+          description: 'Expire test',
+          claim: { test: 'expire' },
+        },
+      };
+
+      const document = await zkEngine.requestProof(request);
+      const completed = await zkEngine.waitForProof(document.id, 5000);
+
+      // Manually expire
+      (completed as any).expires_at = new Date(Date.now() - 1000).toISOString();
+
+      const result = await zkEngine.verifyProof(completed);
+
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Proof expired');
+    });
+  });
+
+  describe('Insurance Claim Helper', () => {
+    it('should generate insurance claim proof', async () => {
+      const helper = new InsuranceClaimProof(zkEngine);
+
+      const document = await helper.generateClaim({
+        claimId: 'CLM-2026-001',
+        policyId: 'POL-ENTERPRISE-001',
+        incidentDescription: 'Unauthorized transaction detected',
+        warrantId: 'w-12345678',
+        checkpointIds: ['cp-001', 'cp-002', 'cp-003'],
+        actionDetails: {
+          type: 'transfer',
+          amount: 50000,
+          destination: 'unknown-account',
+        },
+        amount: 50000,
+        currency: 'USD',
+      });
+
+      expect(document.type).toBe('action_compliance');
+      expect(document.statement.claim.claim_id).toBe('CLM-2026-001');
+      expect(document.statement.claim.amount).toBe(50000);
+
+      // Wait for processing
+      const completed = await zkEngine.waitForProof(document.id, 5000);
+      expect(completed.status).toBe('verified');
+    });
+  });
+
+  describe('Statistics', () => {
+    it('should track proof metrics', () => {
+      const stats = zkEngine.getStats();
+
+      expect(stats.proofsGenerated).toBeGreaterThan(0);
+      expect(stats.avgProvingTimeMs).toBeGreaterThan(0);
+    });
+
+    it('should report queue statistics', () => {
+      const queueStats = zkEngine.getQueueStats();
+
+      expect(queueStats.queued).toBeGreaterThanOrEqual(0);
+      expect(queueStats.processing).toBeGreaterThanOrEqual(0);
+    });
+  });
+});
+
+// ============================================================================
+// MCCA v3 TESTS
+// ============================================================================
+
+describe('MCCA v3 Engine', () => {
+  let commitmentEngine: CommitmentEngine;
+  let mccaEngine: MCCAEngine;
+
+  beforeAll(async () => {
+    commitmentEngine = new CommitmentEngine();
+    await commitmentEngine.initialize(TEST_SEAL_KEY);
+    
+    mccaEngine = new MCCAEngine(commitmentEngine, {
+      budget: DEFAULT_INFLUENCE_BUDGET,
+      maxFragments: 100,
+      maxTokens: 10000,
+      driftThreshold: 0.3,
+      autoPrune: true,
+    });
+    await mccaEngine.initialize(TEST_SEAL_KEY);
+  });
+
+  describe('Influence Budget', () => {
+    it('should have valid default budget', () => {
+      const total = Object.values(DEFAULT_INFLUENCE_BUDGET).reduce((a, b) => a + b, 0);
+      expect(total).toBeCloseTo(1.0, 5);
+    });
+
+    it('should prioritize system and user influence', () => {
+      expect(DEFAULT_INFLUENCE_BUDGET.system).toBeGreaterThan(DEFAULT_INFLUENCE_BUDGET.external);
+      expect(DEFAULT_INFLUENCE_BUDGET.user).toBeGreaterThan(DEFAULT_INFLUENCE_BUDGET.agent);
+    });
+  });
+
+  describe('Fragment Management', () => {
+    it('should add fragment to manifold', async () => {
+      const fragment = await mccaEngine.addFragment({
+        content: { message: 'Hello, world!' },
+        source_class: 'user',
+        region: 'task',
+        token_count: 50,
+      });
+
+      expect(fragment.id).toBeTruthy();
+      expect(fragment.source_class).toBe('user');
+      expect(fragment.region).toBe('task');
+      expect(fragment.content_hash).toBeTruthy();
+      expect(fragment.seal).toBeTruthy();
+    });
+
+    it('should calculate position in manifold', async () => {
+      const fragment = await mccaEngine.addFragment({
+        content: 'Test positioning',
+        source_class: 'system',
+        region: 'core',
+        token_count: 100,
+      });
+
+      expect(fragment.position.x).toBeGreaterThan(0);
+      expect(fragment.position.y).toBeGreaterThan(0);
+      expect(fragment.position.z).toBeGreaterThan(0);
+      expect(fragment.position.x).toBeLessThanOrEqual(1);
+      expect(fragment.position.y).toBeLessThanOrEqual(1);
+      expect(fragment.position.z).toBeLessThanOrEqual(1);
+    });
+
+    it('should retrieve fragment by ID', async () => {
+      const fragment = await mccaEngine.addFragment({
+        content: 'Retrieve test',
+        source_class: 'agent',
+        region: 'history',
+        token_count: 30,
+      });
+
+      const retrieved = mccaEngine.getFragment(fragment.id);
+
+      expect(retrieved).not.toBeNull();
+      expect(retrieved!.id).toBe(fragment.id);
+    });
+
+    it('should get fragments by region', async () => {
+      await mccaEngine.addFragment({
+        content: 'Reference content',
+        source_class: 'memory',
+        region: 'reference',
+        token_count: 40,
+      });
+
+      const fragments = mccaEngine.getRegionFragments('reference');
+
+      expect(fragments.length).toBeGreaterThan(0);
+      expect(fragments.every(f => f.region === 'reference')).toBe(true);
+    });
+
+    it('should get fragments by source', async () => {
+      await mccaEngine.addFragment({
+        content: 'Tool output',
+        source_class: 'tool',
+        region: 'task',
+        token_count: 25,
+      });
+
+      const fragments = mccaEngine.getSourceFragments('tool');
+
+      expect(fragments.length).toBeGreaterThan(0);
+      expect(fragments.every(f => f.source_class === 'tool')).toBe(true);
+    });
+
+    it('should track state correctly', async () => {
+      const stateBefore = mccaEngine.getState();
+
+      await mccaEngine.addFragment({
+        content: 'State test',
+        source_class: 'external',
+        region: 'ephemeral',
+        token_count: 20,
+      });
+
+      const stateAfter = mccaEngine.getState();
+
+      expect(stateAfter.totalFragments).toBe(stateBefore.totalFragments + 1);
+      expect(stateAfter.totalTokens).toBe(stateBefore.totalTokens + 20);
+    });
+  });
+
+  describe('Commitment Proofs', () => {
+    it('should generate manifold commitment proof', async () => {
+      const proof = await mccaEngine.generateCommitmentProof();
+
+      expect(proof.id).toBeTruthy();
+      expect(proof.merkle_root).toBeTruthy();
+      expect(proof.fragment_count).toBeGreaterThan(0);
+      expect(proof.influence_distribution).toBeDefined();
+      expect(proof.commitment_id).toBeTruthy();
+      expect(proof.seal).toBeTruthy();
+    });
+
+    it('should track influence distribution', async () => {
+      const proof = await mccaEngine.generateCommitmentProof();
+
+      const totalDistribution = Object.values(proof.influence_distribution)
+        .reduce((a, b) => a + b, 0);
+
+      // Should sum to ~1.0 (normalized)
+      expect(totalDistribution).toBeCloseTo(1.0, 1);
+    });
+  });
+
+  describe('Budget Compliance', () => {
+    it('should check budget compliance', () => {
+      const result = mccaEngine.checkBudgetCompliance();
+
+      expect(typeof result.compliant).toBe('boolean');
+      expect(Array.isArray(result.violations)).toBe(true);
+    });
+  });
+
+  describe('Drift Analysis', () => {
+    it('should analyze drift', async () => {
+      const analysis = await mccaEngine.analyzeDrift();
+
+      expect(analysis.score).toBeGreaterThanOrEqual(0);
+      expect(analysis.score).toBeLessThanOrEqual(1);
+      expect(['none', 'low', 'medium', 'high', 'critical']).toContain(analysis.severity);
+      expect(analysis.by_source).toBeDefined();
+      expect(Array.isArray(analysis.violations)).toBe(true);
+      expect(Array.isArray(analysis.recommendations)).toBe(true);
+    });
+
+    it('should classify severity correctly', async () => {
+      const analysis = await mccaEngine.analyzeDrift();
+
+      if (analysis.score < 0.1) {
+        expect(analysis.severity).toBe('none');
+      } else if (analysis.score < 0.25) {
+        expect(analysis.severity).toBe('low');
+      }
+    });
+  });
+
+  describe('Context Window Manager', () => {
+    it('should manage context window', async () => {
+      const manager = new ContextWindowManager(mccaEngine, 50000);
+
+      // Add system prompt
+      const systemFragment = await manager.addSystemPrompt(
+        'You are a helpful assistant.',
+        10
+      );
+      expect(systemFragment.source_class).toBe('system');
+      expect(systemFragment.region).toBe('core');
+
+      // Add user message
+      const userFragment = await manager.addUserMessage(
+        'Hello, can you help me?',
+        8
+      );
+      expect(userFragment.source_class).toBe('user');
+      expect(userFragment.region).toBe('task');
+
+      // Add agent response
+      const agentFragment = await manager.addAgentResponse(
+        'Of course! How can I assist you today?',
+        12
+      );
+      expect(agentFragment.source_class).toBe('agent');
+      expect(agentFragment.region).toBe('history');
+    });
+
+    it('should check context health', async () => {
+      const manager = new ContextWindowManager(mccaEngine, 50000);
+      
+      const health = await manager.getHealth();
+
+      expect(typeof health.healthy).toBe('boolean');
+      expect(health.drift).toBeDefined();
+      expect(health.utilization).toBeGreaterThanOrEqual(0);
+      expect(health.utilization).toBeLessThanOrEqual(1);
+    });
+  });
+
+  describe('Statistics', () => {
+    it('should report engine statistics', () => {
+      const stats = mccaEngine.getStats();
+
+      expect(stats.fragments).toBeGreaterThan(0);
+      expect(stats.tokens).toBeGreaterThan(0);
+      expect(stats.config).toBeDefined();
+      expect(stats.budgetCompliance).toBeDefined();
+    });
+  });
+});
+
+// ============================================================================
+// INTEGRATION TESTS (L1 + L2 + L3 + MCCA)
+// ============================================================================
+
+describe('Three-Layer Attestation Integration', () => {
+  let commitmentEngine: CommitmentEngine;
+  let teeEngine: TEEAttestationEngine;
+  let zkEngine: ZKProofsEngine;
+  let mccaEngine: MCCAEngine;
+
+  beforeAll(async () => {
+    commitmentEngine = new CommitmentEngine();
+    await commitmentEngine.initialize(TEST_SEAL_KEY);
+
+    teeEngine = new TEEAttestationEngine(commitmentEngine);
+    await teeEngine.initialize(TEST_SEAL_KEY);
+
+    zkEngine = new ZKProofsEngine(commitmentEngine);
+    await zkEngine.initialize(TEST_SEAL_KEY);
+
+    mccaEngine = new MCCAEngine(commitmentEngine);
+    await mccaEngine.initialize(TEST_SEAL_KEY);
+  });
+
+  afterAll(() => {
+    zkEngine.stopProcessing();
+  });
+
+  it('should chain L1 -> L2 -> L3 attestations', async () => {
+    const actionData = {
+      action: 'high-value-transfer',
+      amount: 1000000,
+      timestamp: generateTimestamp(),
+    };
+
+    // L1: Commitment (<1ms)
+    const l1Start = performance.now();
+    const commitment = await commitmentEngine.commit(actionData, 'chain-test-001');
+    const l1Elapsed = performance.now() - l1Start;
+    expect(l1Elapsed).toBeLessThan(5); // Should be <1ms, allow margin
+
+    // L2: TEE Attestation (<10ms)
+    const l2Start = performance.now();
+    const attestation = await teeEngine.attest(actionData, 'chain-test-001');
+    const l2Elapsed = performance.now() - l2Start;
+    expect(l2Elapsed).toBeLessThan(50); // Should be <10ms, allow margin
+
+    // L3: ZK Proof (async)
+    const zkRequest = new ClaimBuilder('action_compliance')
+      .withDescription('Chain test proof')
+      .withClaim('action', actionData)
+      .withClaim('commitment', commitment.merkleRoot)
+      .withClaim('attestation', attestation.id)
+      .withCommitments('chain-test-001')
+      .withAttestations(attestation.id)
+      .build('high');
+
+    const zkDocument = await zkEngine.requestProof(zkRequest);
+    const zkCompleted = await zkEngine.waitForProof(zkDocument.id, 10000);
+
+    expect(zkCompleted.status).toBe('verified');
+    expect(zkCompleted.references.commitments).toContain('chain-test-001');
+    expect(zkCompleted.references.attestations).toContain(attestation.id);
+  });
+
+  it('should integrate MCCA with attestation layers', async () => {
+    // Add context fragment
+    const fragment = await mccaEngine.addFragment({
+      content: { integration: 'test', value: 42 },
+      source_class: 'user',
+      region: 'task',
+      token_count: 50,
+    });
+
+    // Generate MCCA proof
+    const mccaProof = await mccaEngine.generateCommitmentProof();
+
+    // Attest MCCA state with TEE
+    const attestation = await teeEngine.attest(
+      { mcca_proof: mccaProof.id, fragment_count: mccaProof.fragment_count },
+      mccaProof.commitment_id
+    );
+
+    expect(attestation.status).toBe('verified');
+
+    // Generate ZK proof of MCCA state
+    const zkRequest = new ClaimBuilder('audit_trail')
+      .withDescription('MCCA state proof')
+      .withClaim('mcca_merkle_root', mccaProof.merkle_root)
+      .withClaim('fragment_count', mccaProof.fragment_count)
+      .withClaim('influence_distribution', mccaProof.influence_distribution)
+      .withCommitments(mccaProof.commitment_id)
+      .withAttestations(attestation.id)
+      .build('normal');
+
+    const zkDocument = await zkEngine.requestProof(zkRequest);
+    const zkCompleted = await zkEngine.waitForProof(zkDocument.id, 15000);
+
+    expect(zkCompleted.status).toBe('verified');
+  });
+
+  it('should provide complete audit trail', async () => {
+    // Simulate a complete agent action flow
+    const agentId = 'test-agent-001';
+    const action = {
+      type: 'api-call',
+      endpoint: '/process-payment',
+      params: { amount: 500 },
+    };
+
+    // 1. Context setup (MCCA)
+    await mccaEngine.addFragment({
+      content: { system_prompt: 'Process payments safely' },
+      source_class: 'system',
+      region: 'core',
+      token_count: 100,
+    });
+
+    await mccaEngine.addFragment({
+      content: { user_request: 'Process $500 payment' },
+      source_class: 'user',
+      region: 'task',
+      token_count: 50,
+    });
+
+    const mccaProof = await mccaEngine.generateCommitmentProof();
+
+    // 2. L1 Commitment
+    const commitment = await commitmentEngine.commit(
+      { action, context: mccaProof.merkle_root },
+      `action:${agentId}:${Date.now()}`
+    );
+
+    // 3. L2 TEE Attestation
+    const attestation = await teeEngine.attest(
+      { action, commitment: commitment.operationId },
+      commitment.operationId
+    );
+
+    // 4. L3 ZK Proof for audit
+    const auditProof = await zkEngine.requestProof(
+      new ClaimBuilder('audit_trail')
+        .withDescription('Complete action audit trail')
+        .withClaim('agent_id', agentId)
+        .withClaim('action', action)
+        .withClaim('context_proof', mccaProof.id)
+        .withClaim('events', [
+          { type: 'context_setup', timestamp: mccaProof.timestamp },
+          { type: 'commitment', timestamp: commitment.timestamp },
+          { type: 'attestation', timestamp: attestation.timestamp },
+        ])
+        .withClaim('num_events', 3)
+        .withClaim('start_time', mccaProof.timestamp)
+        .withClaim('end_time', attestation.timestamp)
+        .withCommitments(commitment.operationId, mccaProof.commitment_id)
+        .withAttestations(attestation.id)
+        .build('high')
+    );
+
+    const completedAudit = await zkEngine.waitForProof(auditProof.id, 20000);
+
+    expect(completedAudit.status).toBe('verified');
+    expect(completedAudit.proof).toBeTruthy();
+
+    // Verify the complete chain
+    const verifyResult = await zkEngine.verifyProof(completedAudit);
+    expect(verifyResult.valid).toBe(true);
+  });
+});
+
+// ============================================================================
+// LATENCY SLA TESTS
+// ============================================================================
+
+describe('Latency SLA Compliance', () => {
+  let commitmentEngine: CommitmentEngine;
+  let teeEngine: TEEAttestationEngine;
+
+  beforeAll(async () => {
+    commitmentEngine = new CommitmentEngine();
+    await commitmentEngine.initialize(TEST_SEAL_KEY);
+    
+    teeEngine = new TEEAttestationEngine(commitmentEngine);
+    await teeEngine.initialize(TEST_SEAL_KEY);
+  });
+
+  it('L1 commitment should complete in <1ms (P99)', async () => {
+    const latencies: number[] = [];
+
+    for (let i = 0; i < 100; i++) {
+      const start = performance.now();
+      await commitmentEngine.commit({ iteration: i }, `latency-l1-${i}`);
+      latencies.push(performance.now() - start);
+    }
+
+    // Sort and get P99
+    latencies.sort((a, b) => a - b);
+    const p99 = latencies[98];
+
+    // Note: In Node.js environment, actual latency may vary
+    // Target is <1ms, we allow 5ms for test stability
+    expect(p99).toBeLessThan(5);
+  });
+
+  it('L2 attestation should complete in <10ms (P99)', async () => {
+    const latencies: number[] = [];
+
+    for (let i = 0; i < 50; i++) {
+      const start = performance.now();
+      await teeEngine.attest({ iteration: i }, `latency-l2-${i}`);
+      latencies.push(performance.now() - start);
+    }
+
+    // Sort and get P99
+    latencies.sort((a, b) => a - b);
+    const p99 = latencies[Math.floor(latencies.length * 0.99)];
+
+    // Target is <10ms, we allow 50ms for test stability
+    expect(p99).toBeLessThan(50);
+  });
+});