@longarc/mdash 3.1.2 → 3.1.3

package/src/__tests__/sa-2026-009.test.ts

@@ -0,0 +1,86 @@
+/**
+ * SA-2026-009: ZK seal verification gap
+ * Verifies that verifyProof rejects documents with tampered seals.
+ * Prior to fix: expectedSeal was computed but never compared.
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import { CommitmentEngine } from '../core/commitment.js';
+import { ZKProofsEngine } from '../zk/engine.js';
+import type { Seal } from '../core/crypto.js';
+
+const TEST_KEY = 'test-seal-key-zk-verify-gap-minimum-32-chars';
+
+describe('SA-2026-009: ZK seal verification gap', () => {
+  let commitmentEngine: CommitmentEngine;
+  let zkEngine: ZKProofsEngine;
+
+  beforeAll(async () => {
+    commitmentEngine = new CommitmentEngine();
+    await commitmentEngine.initialize(TEST_KEY);
+    zkEngine = new ZKProofsEngine(commitmentEngine);
+    await zkEngine.initialize(TEST_KEY);
+  });
+
+  it('verifyProof accepts a validly sealed document', async () => {
+    const doc = await zkEngine.requestProof({
+      type: 'commitment_inclusion',
+      statement: {
+        description: 'SA-2026-009 valid seal test',
+        claim: { test: 'valid-seal' },
+      },
+    });
+
+    const completed = await zkEngine.waitForProof(doc.id, 5000);
+    const result = await zkEngine.verifyProof(completed);
+
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('verifyProof rejects a document with a tampered seal', async () => {
+    const doc = await zkEngine.requestProof({
+      type: 'commitment_inclusion',
+      statement: {
+        description: 'SA-2026-009 tampered seal test',
+        claim: { test: 'tampered-seal' },
+      },
+    });
+
+    const completed = await zkEngine.waitForProof(doc.id, 5000);
+
+    // Tamper with the seal
+    const tampered = { ...completed, seal: 'tampered-seal-value' as Seal };
+
+    const result = await zkEngine.verifyProof(tampered);
+
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('Seal verification failed');
+  });
+
+  it('verifyProof rejects a document with mutated content', async () => {
+    const doc = await zkEngine.requestProof({
+      type: 'commitment_inclusion',
+      statement: {
+        description: 'SA-2026-009 mutation test',
+        claim: { test: 'content-mutation' },
+      },
+    });
+
+    const completed = await zkEngine.waitForProof(doc.id, 5000);
+
+    // Mutate content without re-sealing
+    const mutated = {
+      ...completed,
+      statement: {
+        ...completed.statement,
+        description: 'ALTERED after sealing',
+      },
+    };
+
+    const result = await zkEngine.verifyProof(mutated);
+
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('Seal verification failed');
+  });
+});

package/src/__tests__/sa-2026-010.test.ts

@@ -0,0 +1,72 @@
+/**
+ * SA-2026-010: Checkpoint fire-and-forget error handling
+ * Verifies that L1 commitment failures are caught and surfaced
+ * via checkpoint status rather than silently swallowed.
+ */
+
+import { describe, it, expect, beforeAll, vi } from 'vitest';
+import { CommitmentEngine } from '../core/commitment.js';
+import { CheckpointEngine } from '../checkpoint/engine.js';
+
+const TEST_KEY = 'test-seal-key-checkpoint-catch-minimum-32-chars';
+
+describe('SA-2026-010: Checkpoint fire-and-forget error handling', () => {
+  let commitmentEngine: CommitmentEngine;
+  let checkpointEngine: CheckpointEngine;
+
+  beforeAll(async () => {
+    commitmentEngine = new CommitmentEngine();
+    await commitmentEngine.initialize(TEST_KEY);
+    checkpointEngine = new CheckpointEngine(commitmentEngine);
+    await checkpointEngine.initialize(TEST_KEY);
+  });
+
+  it('checkpoint status becomes failed when L1 commit rejects', async () => {
+    // Spy on commit and make it reject
+    const commitSpy = vi.spyOn(commitmentEngine, 'commit')
+      .mockRejectedValueOnce(new Error('Simulated L1 failure'));
+
+    // Suppress expected console.error
+    const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    const checkpoint = await checkpointEngine.createCheckpoint({
+      agent_id: 'test-agent-sa010',
+      trigger: 'action_start',
+      state: {
+        warrant_id: 'w-test-sa010' as any,
+        action_type: 'test',
+        context_hash: 'hash-test' as any,
+      },
+    });
+
+    // checkpoint is returned immediately (fire-and-forget)
+    expect(checkpoint.status).toBe('pending');
+
+    // Wait for the async .then/.catch to resolve
+    await new Promise(resolve => setTimeout(resolve, 50));
+
+    // After failure, status should be 'failed', not stuck on 'pending'
+    expect(checkpoint.status).toBe('failed');
+
+    commitSpy.mockRestore();
+    errorSpy.mockRestore();
+  });
+
+  it('checkpoint status becomes sealed on successful L1 commit', async () => {
+    const checkpoint = await checkpointEngine.createCheckpoint({
+      agent_id: 'test-agent-sa010-ok',
+      trigger: 'action_start',
+      state: {
+        warrant_id: 'w-test-sa010-ok' as any,
+        action_type: 'test',
+        context_hash: 'hash-test-ok' as any,
+      },
+    });
+
+    // Wait for async commit
+    await new Promise(resolve => setTimeout(resolve, 50));
+
+    expect(checkpoint.status).toBe('sealed');
+    expect(checkpoint.commitment_id).toBeTruthy();
+  });
+});

package/src/__tests__/sa-2026-012.test.ts

@@ -0,0 +1,65 @@
+/**
+ * SA-2026-012: Influence budget underflow protection
+ * Verifies that influence and token counts never go negative
+ * after fragment removal.
+ */
+
+import { describe, it, expect, beforeAll } from 'vitest';
+import { CommitmentEngine } from '../core/commitment.js';
+import { MCCAEngine } from '../mcca/engine.js';
+
+const TEST_KEY = 'test-seal-key-mcca-underflow-minimum-32-chars';
+
+describe('SA-2026-012: Influence budget underflow protection', () => {
+  let commitmentEngine: CommitmentEngine;
+  let engine: MCCAEngine;
+
+  beforeAll(async () => {
+    commitmentEngine = new CommitmentEngine();
+    await commitmentEngine.initialize(TEST_KEY);
+    engine = new MCCAEngine(commitmentEngine);
+    await engine.initialize(TEST_KEY);
+  });
+
+  it('influence never goes negative after fragment removal', async () => {
+    // Add a fragment
+    const fragment = await engine.addFragment({
+      content: { test: 'underflow-influence' },
+      source_class: 'user',
+      region: 'task',
+      token_count: 50,
+      influence: 0.05,
+    });
+
+    // Remove it once
+    await engine.removeFragment(fragment.id);
+
+    // Remove it again (simulating race or double-remove)
+    await engine.removeFragment(fragment.id);
+
+    // influenceBySource is private; access via cast to verify the floor guard
+    const influenceBySource = (engine as any).influenceBySource as Record<string, number>;
+    expect(influenceBySource.user).toBeGreaterThanOrEqual(0);
+  });
+
+  it('token count never goes negative after double removal', async () => {
+    // Add a fragment
+    const fragment = await engine.addFragment({
+      content: { test: 'underflow-tokens' },
+      source_class: 'system',
+      region: 'task',
+      token_count: 100,
+      influence: 0.1,
+    });
+
+    // Remove it once
+    await engine.removeFragment(fragment.id);
+
+    // Remove again
+    await engine.removeFragment(fragment.id);
+
+    // stats.tokens maps to the internal totalTokens field
+    const stats = engine.getStats();
+    expect(stats.tokens).toBeGreaterThanOrEqual(0);
+  });
+});

package/src/__tests__/sa-2026-nfc.test.ts

@@ -0,0 +1,40 @@
+/**
+ * SA-2026-NFC: Unicode normalization in deterministicStringify
+ * Verifies that decomposed and precomposed Unicode codepoints
+ * produce identical hashes.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { sha256Object, deterministicStringify } from '../core/crypto.js';
+
+describe('SA-2026-NFC: Unicode normalization', () => {
+  it('NFD and NFC representations hash identically', async () => {
+    // U+00E9 (precomposed e-acute) vs U+0065 + U+0301 (e + combining acute)
+    const nfc = { name: '\u00E9' };   // e with acute (precomposed)
+    const nfd = { name: '\u0065\u0301' }; // e + combining acute (decomposed)
+
+    const hashNFC = await sha256Object(nfc);
+    const hashNFD = await sha256Object(nfd);
+
+    expect(hashNFC).toBe(hashNFD);
+  });
+
+  it('deterministicStringify normalizes strings to NFC', () => {
+    const nfd = '\u0065\u0301'; // decomposed
+    const nfc = '\u00E9';       // precomposed
+
+    const resultNFD = deterministicStringify({ val: nfd });
+    const resultNFC = deterministicStringify({ val: nfc });
+
+    expect(resultNFD).toBe(resultNFC);
+  });
+
+  it('non-string values are unaffected', () => {
+    const result = deterministicStringify({ num: 42, bool: true, nil: null });
+    const parsed = JSON.parse(result);
+
+    expect(parsed.num).toBe(42);
+    expect(parsed.bool).toBe(true);
+    expect(parsed.nil).toBeNull();
+  });
+});