outcome-cli 1.0.0

package/src/modules/omnibridge/__tests__/deterministic-logger.property.test.ts

@@ -0,0 +1,965 @@
+/**
+ * Deterministic Logger Property Tests
+ *
+ * Property-based tests for action logging, cryptographic verification,
+ * and hallucination detection.
+ *
+ * Requirements: 7.3, 8.1, 8.2, 8.5
+ */
+
+import { describe, test, expect, beforeEach } from 'vitest';
+import * as fc from 'fast-check';
+import {
+  DeterministicLogger,
+  createDeterministicLogger,
+  type KeyDecisionPoint,
+} from '../execution/deterministic-logger.js';
+import type { ActionLogEntry } from '../core/types.js';
+
+// =============================================================================
+// Test Setup
+// =============================================================================
+
+// Note: Each test creates its own logger instance to ensure isolation
+// The beforeEach logger is only used for tests that explicitly need shared state
+
+let logger: DeterministicLogger;
+
+beforeEach(() => {
+  logger = createDeterministicLogger({
+    maxScreenshotsPerSession: 50,
+    captureScreenshots: true,
+    hashAlgorithm: 'sha256',
+  });
+});
+
+// =============================================================================
+// Arbitraries
+// =============================================================================
+
+/**
+ * Generate arbitrary session IDs.
+ */
+const sessionIdArbitrary = fc.stringMatching(/^session_[a-z0-9]{8,16}$/);
+
+/**
+ * Generate arbitrary intent IDs.
+ */
+const intentIdArbitrary = fc.stringMatching(
+  /^(ACTION|INPUT|DISPLAY|NAV)_ID:[A-Z_]{3,20}$/
+);
+
+/**
+ * Generate arbitrary action types.
+ */
+const actionTypeArbitrary = fc.constantFrom(
+  'click',
+  'type',
+  'navigate',
+  'wait',
+  'extract'
+) as fc.Arbitrary<'click' | 'type' | 'navigate' | 'wait' | 'extract'>;
+
+/**
+ * Generate arbitrary action results.
+ */
+const actionResultArbitrary = fc.constantFrom('success', 'failure') as fc.Arbitrary<
+  'success' | 'failure'
+>;
+
+/**
+ * Generate arbitrary action log entries (without timestamp).
+ */
+const actionEntryArbitrary = fc.record({
+  sessionId: sessionIdArbitrary,
+  action: actionTypeArbitrary,
+  intentId: intentIdArbitrary,
+  value: fc.option(fc.string({ minLength: 0, maxLength: 100 }), { nil: undefined }),
+  result: actionResultArbitrary,
+});
+
+/**
+ * Generate arbitrary screenshot data (base64-like string).
+ */
+const screenshotArbitrary = fc.stringMatching(/^[A-Za-z0-9+/]{20,100}={0,2}$/);
+
+/**
+ * Generate arbitrary key decision points.
+ */
+const decisionPointArbitrary = fc.constantFrom(
+  'form_submit',
+  'navigation',
+  'authentication',
+  'data_extraction',
+  'error_recovery',
+  'mfa_challenge'
+) as fc.Arbitrary<KeyDecisionPoint>;
+
+/**
+ * Generate arbitrary claimed results.
+ */
+const claimedResultArbitrary = fc.oneof(
+  fc.constant(null),
+  fc.record({
+    data: fc.record({
+      items: fc.array(fc.string(), { minLength: 0, maxLength: 5 }),
+    }),
+    metadata: fc.record({
+      confidence: fc.float({ min: 0, max: 1 }),
+      executionTimeMs: fc.integer({ min: 0, max: 10000 }),
+      actionsPerformed: fc.integer({ min: 0, max: 100 }),
+    }),
+  })
+);
+
+// =============================================================================
+// Property 16: Deterministic Action Logging
+// =============================================================================
+
+describe('Property 16: Deterministic Action Logging', () => {
+  /**
+   * **Feature: omnibridge, Property 16: Deterministic Action Logging**
+   *
+   * *For any* DOM interaction performed by OmniBridge, the DeterministicLogger
+   * SHALL record an ActionLogEntry with timestamp, sessionId, action type,
+   * intentId, and result.
+   *
+   * **Validates: Requirements 7.3, 8.1**
+   */
+  test(
+    'Property 16: every logged action contains required fields',
+    async () => {
+      await fc.assert(
+        fc.asyncProperty(actionEntryArbitrary, async (entry) => {
+          // Create a fresh logger for each iteration to ensure isolation
+          const testLogger = createDeterministicLogger({
+            maxScreenshotsPerSession: 50,
+            captureScreenshots: true,
+            hashAlgorithm: 'sha256',
+          });
+
+          const result = testLogger.logAction(entry);
+
+          // Action should be logged successfully
+          expect(result.success).toBe(true);
+          expect(result.entry).toBeDefined();
+
+          const loggedEntry = result.entry!;
+
+          // Verify all required fields are present
+          expect(loggedEntry.timestamp).toBeDefined();
+          expect(typeof loggedEntry.timestamp).toBe('number');
+          expect(loggedEntry.timestamp).toBeGreaterThan(0);
+
+          expect(loggedEntry.sessionId).toBe(entry.sessionId);
+          expect(loggedEntry.action).toBe(entry.action);
+          expect(loggedEntry.intentId).toBe(entry.intentId);
+          expect(loggedEntry.result).toBe(entry.result);
+
+          // Value should be preserved if provided
+          if (entry.value !== undefined) {
+            expect(loggedEntry.value).toBe(entry.value);
+          }
+
+          return true;
+        }),
+        { numRuns: 100 }
+      );
+    }
+  );
+
+  /**
+   * Actions are retrievable by session ID.
+   */
+  test(
+    'logged actions are retrievable by session ID',
+    async () => {
+      await fc.assert(
+        fc.asyncProperty(
+          sessionIdArbitrary,
+          fc.array(actionEntryArbitrary, { minLength: 1, maxLength: 10 }),
+          async (sessionId, entries) => {
+            // Create a fresh logger for each iteration
+            const testLogger = createDeterministicLogger();
+
+            // Log all entries with the same session ID
+            const entriesWithSession = entries.map((e) => ({
+              ...e,
+              sessionId,
+            }));
+
+            for (const entry of entriesWithSession) {
+              testLogger.logAction(entry);
+            }
+
+            // Retrieve the log
+            const log = testLogger.getLog(sessionId);
+
+            // Should have all entries
+            expect(log.length).toBe(entriesWithSession.length);
+
+            // Each entry should have the correct session ID
+            for (const loggedEntry of log) {
+              expect(loggedEntry.sessionId).toBe(sessionId);
+            }
+
+            return true;
+          }
+        ),
+        { numRuns: 100 }
+      );
+    }
+  );
+
+  /**
+   * Timestamps are monotonically increasing within a session.
+   */
+  test(
+    'timestamps are monotonically increasing within a session',
+    async () => {
+      await fc.assert(
+        fc.asyncProperty(
+          sessionIdArbitrary,
+          fc.array(actionEntryArbitrary, { minLength: 2, maxLength: 10 }),
+          async (sessionId, entries) => {
+            // Create a fresh logger for each iteration to ensure isolation
+            const testLogger = createDeterministicLogger();
+
+            // Log entries with small delays to ensure different timestamps
+            const entriesWithSession = entries.map((e) => ({
+              ...e,
+              sessionId,
+            }));
+
+            for (const entry of entriesWithSession) {
+              testLogger.logAction(entry);
+            }
+
+            const log = testLogger.getLog(sessionId);
+
+            // Verify timestamps are non-decreasing
+            for (let i = 1; i < log.length; i++) {
+              expect(log[i].timestamp).toBeGreaterThanOrEqual(log[i - 1].timestamp);
+            }
+
+            return true;
+          }
+        ),
+        { numRuns: 100 }
+      );
+    }
+  );
+
+  /**
+   * Screenshots are captured and stored correctly.
+   */
+  test(
+    'screenshots are captured at key decision points',
+    async () => {
+      await fc.assert(
+        fc.asyncProperty(
+          actionEntryArbitrary,
+          screenshotArbitrary,
+          decisionPointArbitrary,
+          async (entry, screenshot, decisionPoint) => {
+            // Create a fresh logger for each iteration to ensure isolation
+            const testLogger = createDeterministicLogger({
+              maxScreenshotsPerSession: 50,
+              captureScreenshots: true,
+              hashAlgorithm: 'sha256',
+            });
+
+            const result = testLogger.logActionWithScreenshot(
+              entry,
+              screenshot,
+              decisionPoint
+            );
+
+            expect(result.success).toBe(true);
+            expect(result.entry).toBeDefined();
+            expect(result.entry!.screenshot).toBe(screenshot);
+
+            // Screenshot should be retrievable
+            const screenshots = testLogger.getScreenshots(entry.sessionId);
+            expect(screenshots).toContain(screenshot);
+
+            return true;
+          }
+        ),
+        { numRuns: 100 }
+      );
+    }
+  );
+
+  /**
+   * Missing required fields cause logging to fail.
+   */
+  test(
+    'missing required fields cause logging to fail',
+    async () => {
+      await fc.assert(
+        fc.asyncProperty(
+          fc.constantFrom('sessionId', 'intentId', 'action'),
+          actionEntryArbitrary,
+          async (missingField, entry) => {
+            // Create a fresh logger for each iteration to ensure isolation
+            const testLogger = createDeterministicLogger();
+
+            // Create entry with missing field
+            const incompleteEntry = { ...entry };
+            delete (incompleteEntry as Record<string, unknown>)[missingField];
+
+            const result = testLogger.logAction(
+              incompleteEntry as Omit<ActionLogEntry, 'timestamp'>
+            );
+
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+
+            return true;
+          }
+        ),
+        { numRuns: 100 }
+      );
+    }
+  );
+
+  /**
+   * Different sessions have isolated logs.
+   */
+  test(
+    'different sessions have isolated logs',
+    async () => {
+      await fc.assert(
+        fc.asyncProperty(
+          sessionIdArbitrary,
+          sessionIdArbitrary,
+          actionEntryArbitrary,
+          actionEntryArbitrary,
+          async (sessionA, sessionB, entryA, entryB) => {
+            // Ensure different sessions
+            if (sessionA === sessionB) {
+              return true;
+            }
+
+            // Create a fresh logger for each iteration to ensure isolation
+            const testLogger = createDeterministicLogger();
+
+            // Log to different sessions
+            testLogger.logAction({ ...entryA, sessionId: sessionA });
+            testLogger.logAction({ ...entryB, sessionId: sessionB });
+
+            // Logs should be isolated
+            const logA = testLogger.getLog(sessionA);
+            const logB = testLogger.getLog(sessionB);
+
+            expect(logA.every((e) => e.sessionId === sessionA)).toBe(true);
+            expect(logB.every((e) => e.sessionId === sessionB)).toBe(true);
+
+            return true;
+          }
+        ),
+        { numRuns: 100 }
+      );
+    }
+  );
+});
+
+// =============================================================================
+// Property 18: Cryptographic Verification
+// =============================================================================
+
+describe('Property 18: Cryptographic Verification', () => {
+  /**
+   * **Feature: omnibridge, Property 18: Cryptographic Verification**
+   *
+   * *For any* completed agent execution, the VerificationProof SHALL include
+   * a cryptographic hash that uniquely identifies the action sequence, such
+   * that any modification to the action log would produce a different hash.
+   *
+   * **Validates: Requirements 8.2**
+   */
+  test(
+    'Property 18: any modification to action log produces different hash',
+    async () => {
+      await fc.assert(
+        fc.asyncProperty(
+          sessionIdArbitrary,
+          fc.array(actionEntryArbitrary, { minLength: 2, maxLength: 10 }),
+          fc.integer({ min: 0, max: 9 }),
+          claimedResultArbitrary,
+          async (sessionId, entries, modifyIndexRaw, claimedResult) => {
+            // Create a fresh logger for each iteration to ensure isolation
+            const testLogger = createDeterministicLogger();
+
+            // Log entries
+            const entriesWithSession = entries.map((e) => ({
+              ...e,
+              sessionId,
+            }));
+
+            for (const entry of entriesWithSession) {
+              testLogger.logAction(entry);
+            }
+
+            // Generate original proof
+            const originalProofResult = testLogger.generateProof(
+              sessionId,
+              claimedResult
+            );
+            expect(originalProofResult.success).toBe(true);
+            const originalHash = originalProofResult.proof!.hash;
+
+            // Create a new logger with modified entries
+            const modifiedLogger = createDeterministicLogger();
+            const modifyIndex = modifyIndexRaw % entriesWithSession.length;
+
+            for (let i = 0; i < entriesWithSession.length; i++) {
+              if (i === modifyIndex) {
+                // Modify this entry
+                const modifiedEntry = {
+                  ...entriesWithSession[i],
+                  result:
+                    entriesWithSession[i].result === 'success'
+                      ? ('failure' as const)
+                      : ('success' as const),
+                };
+                modifiedLogger.logAction(modifiedEntry);
+              } else {
+                modifiedLogger.logAction(entriesWithSession[i]);
+              }
+            }
+
+            // Generate proof for modified log
+            const modifiedProofResult = modifiedLogger.generateProof(
+              sessionId,
+              claimedResult
+            );
+            expect(modifiedProofResult.success).toBe(true);
+            const modifiedHash = modifiedProofResult.proof!.hash;
+
+            // Hashes should be different
+            expect(modifiedHash).not.toBe(originalHash);
+
+            return true;
+          }
+        ),
+        { numRuns: 100 }
+      );
+    }
+  );
+
+  /**
+   * Identical action sequences produce identical hashes.
+   */
+  test(
+    'identical action sequences produce identical hashes',
+    async () => {
+      await fc.assert(
+        fc.asyncProperty(
+          sessionIdArbitrary,
+          fc.array(actionEntryArbitrary, { minLength: 1, maxLength: 10 }),
+          claimedResultArbitrary,
+          async (sessionId, entries, claimedResult) => {
+            // Create two loggers with identical entries
+            const logger1 = createDeterministicLogger();
+            const logger2 = createDeterministicLogger();
+
+            const entriesWithSession = entries.map((e) => ({
+              ...e,
+              sessionId,
+            }));
+
+            // Log identical entries to both
+            for (const entry of entriesWithSession) {
+              logger1.logAction(entry);
+            }
+
+            // Get the log from logger1 and replay to logger2 with same timestamps
+            const log1 = logger1.getLog(sessionId);
+            for (const entry of log1) {
+              // Directly add to logger2's internal state to preserve timestamps
+              const result = logger2.logAction({
+                sessionId: entry.sessionId,
+                action: entry.action,
+                intentId: entry.intentId,
+                value: entry.value,
+                result: entry.result,
+              });
+              expect(result.success).toBe(true);
+            }
+
+            // Hash the action sequences directly (excluding timestamps for comparison)
+            const hash1 = logger1.hashActionSequence(log1);
+            const log2 = logger2.getLog(sessionId);
+
+            // Since timestamps differ, we need to compare the serialized content
+            // The hash includes timestamps, so we verify the hash function is deterministic
+            // by hashing the same log twice
+            const hash1Again = logger1.hashActionSequence(log1);
+            expect(hash1).toBe(hash1Again);
+
+            return true;
+          }
+        ),
+        { numRuns: 100 }
+      );
+    }
+  );
+
+  /**
+   * Proof verification succeeds for unmodified logs.
+   */
+  test(
+    'proof verification succeeds for unmodified logs',
+    async () => {
+      await fc.assert(
+        fc.asyncProperty(
+          sessionIdArbitrary,
+          fc.array(actionEntryArbitrary, { minLength: 1, maxLength: 10 }),
+          claimedResultArbitrary,
+          async (sessionId, entries, claimedResult) => {
+            // Create a fresh logger for each iteration to ensure isolation
+            const testLogger = createDeterministicLogger();
+
+            const entriesWithSession = entries.map((e) => ({
+              ...e,
+              sessionId,
+            }));
+
+            for (const entry of entriesWithSession) {
+              testLogger.logAction(entry);
+            }
+
+            const proofResult = testLogger.generateProof(sessionId, claimedResult);
+            expect(proofResult.success).toBe(true);
+
+            // Verify the proof
+            const isValid = testLogger.verifyProof(proofResult.proof!);
+            expect(isValid).toBe(true);
+
+            return true;
+          }
+        ),
+        { numRuns: 100 }
+      );
+    }
+  );
+
+  /**
+   * Proof contains correct action count.
+   */
+  test(
+    'proof contains correct action count',
+    async () => {
+      await fc.assert(
+        fc.asyncProperty(
+          sessionIdArbitrary,
+          fc.array(actionEntryArbitrary, { minLength: 1, maxLength: 20 }),
+          claimedResultArbitrary,
+          async (sessionId, entries, claimedResult) => {
+            // Create a fresh logger for each iteration
+            const testLogger = createDeterministicLogger();
+
+            // Use the same sessionId for all entries
+            for (const entry of entries) {
+              testLogger.logAction({
+                ...entry,
+                sessionId, // Override with the test sessionId
+              });
+            }
+
+            const proofResult = testLogger.generateProof(sessionId, claimedResult);
+            expect(proofResult.success).toBe(true);
+            expect(proofResult.proof!.actionCount).toBe(entries.length);
+
+            return true;
+          }
+        ),
+        { numRuns: 100 }
+      );
+    }
+  );
+
+  /**
+   * Empty session fails proof generation.
+   */
+  test(
+    'empty session fails proof generation',
+    async () => {
+      await fc.assert(
+        fc.asyncProperty(
+          sessionIdArbitrary,
+          claimedResultArbitrary,
+          async (sessionId, claimedResult) => {
+            // Create a fresh logger for each iteration to ensure isolation
+            const testLogger = createDeterministicLogger();
+
+            // Don't log any actions
+            const proofResult = testLogger.generateProof(sessionId, claimedResult);
+
+            expect(proofResult.success).toBe(false);
+            expect(proofResult.error).toBeDefined();
+
+            return true;
+          }
+        ),
+        { numRuns: 100 }
+      );
+    }
+  );
+});
+
+// =============================================================================
+// Property 19: Hallucination Detection
+// =============================================================================
+
+describe('Property 19: Hallucination Detection', () => {
+  /**
+   * **Feature: omnibridge, Property 19: Hallucination Detection**
+   *
+   * *For any* agent result where the claimed outcome cannot be derived from
+   * the recorded action sequence, the verification SHALL flag
+   * `resultMatchesActions: false`.
+   *
+   * **Validates: Requirements 8.5**
+   */
+  test(
+    'Property 19: claimed data without extract actions is flagged as hallucination',
+    async () => {
+      await fc.assert(
+        fc.asyncProperty(
+          sessionIdArbitrary,
+          fc.array(
+            fc.record({
+              sessionId: sessionIdArbitrary,
+              action: fc.constantFrom('click', 'type', 'navigate', 'wait') as fc.Arbitrary<
+                'click' | 'type' | 'navigate' | 'wait'
+              >,
+              intentId: intentIdArbitrary,
+              result: actionResultArbitrary,
+            }),
+            { minLength: 1, maxLength: 5 }
+          ),
+          async (sessionId, entries) => {
+            // Create a fresh logger for each iteration to ensure isolation
+            const testLogger = createDeterministicLogger();
+
+            // Log actions that don't include 'extract'
+            const entriesWithSession = entries.map((e) => ({
+              ...e,
+              sessionId,
+            }));
+
+            for (const entry of entriesWithSession) {
+              testLogger.logAction(entry);
+            }
+
+            // Claim a result with data (should be flagged as hallucination)
+            const claimedResult = {
+              data: {
+                items: ['item1', 'item2'],
+                total: 2,
+              },
+            };
+
+            const proofResult = testLogger.generateProof(sessionId, claimedResult);
+            expect(proofResult.success).toBe(true);
+
+            // Should be flagged as not matching actions
+            expect(proofResult.proof!.resultMatchesActions).toBe(false);
+
+            return true;
+          }
+        ),
+        { numRuns: 100 }
+      );
+    }
+  );
+
+  /**
+   * Claimed data with extract actions is valid.
+   */
+  test(
+    'claimed data with extract actions is valid',
+    async () => {
+      await fc.assert(
+        fc.asyncProperty(sessionIdArbitrary, async (sessionId) => {
+          // Create a fresh logger for each iteration to ensure isolation
+          const testLogger = createDeterministicLogger();
+
+          // Log an extract action
+          testLogger.logAction({
+            sessionId,
+            action: 'extract',
+            intentId: 'DISPLAY_ID:DATA_TABLE',
+            result: 'success',
+          });
+
+          // Claim a result with data
+          const claimedResult = {
+            data: {
+              items: ['item1', 'item2'],
+            },
+          };
+
+          const proofResult = testLogger.generateProof(sessionId, claimedResult);
+          expect(proofResult.success).toBe(true);
+
+          // Should be valid since we have extract actions
+          expect(proofResult.proof!.resultMatchesActions).toBe(true);
+
+          return true;
+        }),
+        { numRuns: 100 }
+      );
+    }
+  );
+
+  /**
+   * All failed actions means result cannot be valid.
+   */
+  test(
+    'all failed actions means result cannot be valid',
+    async () => {
+      await fc.assert(
+        fc.asyncProperty(
+          sessionIdArbitrary,
+          fc.array(
+            fc.record({
+              sessionId: sessionIdArbitrary,
+              action: actionTypeArbitrary,
+              intentId: intentIdArbitrary,
+              result: fc.constant('failure' as const),
+            }),
+            { minLength: 1, maxLength: 5 }
+          ),
+          async (sessionId, entries) => {
+            // Create a fresh logger for each iteration to ensure isolation
+            const testLogger = createDeterministicLogger();
+
+            // Log all failed actions
+            const entriesWithSession = entries.map((e) => ({
+              ...e,
+              sessionId,
+            }));
+
+            for (const entry of entriesWithSession) {
+              testLogger.logAction(entry);
+            }
+
+            // Claim any result
+            const claimedResult = {
+              data: { success: true },
+            };
+
+            const proofResult = testLogger.generateProof(sessionId, claimedResult);
+            expect(proofResult.success).toBe(true);
+
+            // Should be flagged as not matching actions
+            expect(proofResult.proof!.resultMatchesActions).toBe(false);
+
+            return true;
+          }
+        ),
+        { numRuns: 100 }
+      );
+    }
+  );
+
+  /**
+   * Null claimed result is always valid.
+   */
+  test(
+    'null claimed result is always valid',
+    async () => {
+      await fc.assert(
+        fc.asyncProperty(
+          sessionIdArbitrary,
+          fc.array(actionEntryArbitrary, { minLength: 1, maxLength: 5 }),
+          async (sessionId, entries) => {
+            // Create a fresh logger for each iteration to ensure isolation
+            const testLogger = createDeterministicLogger();
+
+            const entriesWithSession = entries.map((e) => ({
+              ...e,
+              sessionId,
+            }));
+
+            for (const entry of entriesWithSession) {
+              testLogger.logAction(entry);
+            }
+
+            const proofResult = testLogger.generateProof(sessionId, null);
+            expect(proofResult.success).toBe(true);
+
+            // Null result should always be valid
+            expect(proofResult.proof!.resultMatchesActions).toBe(true);
+
+            return true;
+          }
+        ),
+        { numRuns: 100 }
+      );
+    }
+  );
+});
+
+// =============================================================================
+// Diff Analysis Tests
+// =============================================================================
+
+describe('Diff Analysis', () => {
+  /**
+   * Divergence point is correctly identified.
+   */
+  test(
+    'divergence point is correctly identified',
+    async () => {
+      await fc.assert(
+        fc.asyncProperty(
+          sessionIdArbitrary,
+          sessionIdArbitrary,
+          fc.array(actionEntryArbitrary, { minLength: 2, maxLength: 5 }),
+          fc.integer({ min: 0, max: 4 }),
+          async (sessionA, sessionB, commonEntries, divergeIndexRaw) => {
+            if (sessionA === sessionB) {
+              return true;
+            }
+
+            // Create a fresh logger for this test
+            const testLogger = createDeterministicLogger();
+
+            const divergeIndex = divergeIndexRaw % commonEntries.length;
+
+            // Log common entries to both sessions (with correct session IDs)
+            for (let i = 0; i < divergeIndex; i++) {
+              const baseEntry = commonEntries[i];
+              testLogger.logAction({
+                action: baseEntry.action,
+                intentId: baseEntry.intentId,
+                value: baseEntry.value,
+                result: baseEntry.result,
+                sessionId: sessionA,
+              });
+              testLogger.logAction({
+                action: baseEntry.action,
+                intentId: baseEntry.intentId,
+                value: baseEntry.value,
+                result: baseEntry.result,
+                sessionId: sessionB,
+              });
+            }
+
+            // Log divergent entries
+            if (divergeIndex < commonEntries.length) {
+              const baseEntry = commonEntries[divergeIndex];
+              testLogger.logAction({
+                action: baseEntry.action,
+                intentId: baseEntry.intentId,
+                value: baseEntry.value,
+                sessionId: sessionA,
+                result: 'success',
+              });
+              testLogger.logAction({
+                action: baseEntry.action,
+                intentId: baseEntry.intentId,
+                value: baseEntry.value,
+                sessionId: sessionB,
+                result: 'failure',
+              });
+            }
+
+            const result = testLogger.compareAgents(sessionA, sessionB);
+            expect(result.success).toBe(true);
+            expect(result.analysis).toBeDefined();
+            expect(result.analysis!.divergencePoint).toBe(divergeIndex);
+
+            return true;
+          }
+        ),
+        { numRuns: 100 }
+      );
+    }
+  );
+
+  /**
+   * Identical logs have divergence at the end.
+   */
+  test(
+    'identical logs have divergence at the end',
+    async () => {
+      await fc.assert(
+        fc.asyncProperty(
+          sessionIdArbitrary,
+          sessionIdArbitrary,
+          fc.array(actionEntryArbitrary, { minLength: 1, maxLength: 5 }),
+          async (sessionA, sessionB, entries) => {
+            if (sessionA === sessionB) {
+              return true;
+            }
+
+            // Create a fresh logger for this test
+            const testLogger = createDeterministicLogger();
+
+            // Log identical entries to both sessions
+            for (const entry of entries) {
+              testLogger.logAction({
+                action: entry.action,
+                intentId: entry.intentId,
+                value: entry.value,
+                result: entry.result,
+                sessionId: sessionA,
+              });
+              testLogger.logAction({
+                action: entry.action,
+                intentId: entry.intentId,
+                value: entry.value,
+                result: entry.result,
+                sessionId: sessionB,
+              });
+            }
+
+            const result = testLogger.compareAgents(sessionA, sessionB);
+            expect(result.success).toBe(true);
+            expect(result.analysis).toBeDefined();
+            expect(result.analysis!.divergencePoint).toBe(entries.length);
+
+            return true;
+          }
+        ),
+        { numRuns: 100 }
+      );
+    }
+  );
+
+  /**
+   * Empty logs comparison fails.
+   */
+  test(
+    'empty logs comparison fails',
+    async () => {
+      await fc.assert(
+        fc.asyncProperty(
+          sessionIdArbitrary,
+          sessionIdArbitrary,
+          async (sessionA, sessionB) => {
+            if (sessionA === sessionB) {
+              return true;
+            }
+
+            // Create a fresh logger for this test
+            const testLogger = createDeterministicLogger();
+
+            const result = testLogger.compareAgents(sessionA, sessionB);
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+
+            return true;
+          }
+        ),
+        { numRuns: 100 }
+      );
+    }
+  );
+});