@plures/praxis 1.3.0 → 1.4.4

package/src/__tests__/decision-ledger.test.ts

@@ -1,485 +1,940 @@
 /**
- * Decision Ledger - Tests
+ * Decision Ledger — Comprehensive Tests
  *
- * Tests for contract definition, validation, and ledger operations.
- *
- * These tests are derived from the behavior ledger examples and assumptions.
+ * Tests the graph analysis engine, derivation tracing, contract verification,
+ * report generation, suggestions, and ledger diffing.
  */
 
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, beforeEach } from 'vitest';
 import { PraxisRegistry } from '../core/rules.js';
-import { defineRule } from '../dsl/index.js';
+import { LogicEngine, createPraxisEngine } from '../core/engine.js';
+import { RuleResult, fact } from '../core/rule-result.js';
+import { defineRule, defineConstraint } from '../dsl/index.js';
+import { defineContract } from '../decision-ledger/types.js';
+import { expectBehavior, ExpectationSet } from '../expectations/expectations.js';
+import type { PraxisState, PraxisEvent, PraxisFact } from '../core/protocol.js';
+
+// Import analyzer modules
 import {
-  defineContract,
-  getContract,
-  isContract,
-  validateContracts,
-  formatValidationReport,
-  ContractMissing,
-  AcknowledgeContractGap,
-  BehaviorLedger,
-  createBehaviorLedger,
-} from '../decision-ledger/index.js';
-
-describe('Decision Ledger', () => {
-  describe('Contract Definition', () => {
-    // Example 1 from behavior ledger: Defining a Contract for a Rule
-    it('should define a contract with behavior, examples, and invariants', () => {
-      const loginContract = defineContract({
-        ruleId: 'auth.login',
-        behavior: 'Process login events and create user session facts',
-        examples: [
-          {
-            given: 'User provides valid credentials',
-            when: 'LOGIN event is received',
-            then: 'UserSessionCreated fact is emitted',
-          },
-        ],
-        invariants: ['Session must have unique ID', 'Session must have timestamp'],
-        assumptions: [
-          {
-            id: 'assume-unique-username',
-            statement: 'Usernames are unique across the system',
-            confidence: 0.9,
-            justification: 'Standard practice in authentication systems',
-            impacts: ['spec', 'tests'],
-            status: 'active',
-          },
-        ],
-        references: [{ type: 'doc', url: 'https://docs.example.com/auth' }],
-      });
+  analyzeDependencyGraph,
+  findDeadRules,
+  findUnreachableStates,
+  findShadowedRules,
+  findContradictions,
+  findGaps,
+} from '../decision-ledger/analyzer.js';
+import {
+  traceDerivation,
+  traceImpact,
+} from '../decision-ledger/derivation.js';
+import {
+  verifyContractExamples,
+  verifyInvariants,
+  findContractGaps,
+  crossReferenceContracts,
+} from '../decision-ledger/contract-verification.js';
+import {
+  suggest,
+  suggestAll,
+} from '../decision-ledger/suggestions.js';
+import {
+  generateLedger,
+  formatLedger,
+  formatBuildOutput,
+  diffLedgers,
+} from '../decision-ledger/report.js';
+
+// ─── Test Helpers ───────────────────────────────────────────────────────────
+
+interface TestContext {
+  user?: { name: string; role: string };
+  cart?: { items: number; total: number };
+  sprint?: { name: string; hours: number; target: number };
+  network?: { connected: boolean };
+  settings?: { changed: boolean };
+}
+
+function createTestRegistry() {
+  const registry = new PraxisRegistry<TestContext>();
+
+  // Rule 1: Login handler (produces user.loggedIn)
+  registry.registerRule(defineRule<TestContext>({
+    id: 'auth.login',
+    description: 'Process login events and create user session',
+    eventTypes: ['LOGIN'],
+    impl: (state, events) => {
+      const loginEvent = events.find(e => e.tag === 'LOGIN');
+      if (!loginEvent) return RuleResult.skip('No login event');
+      return RuleResult.emit([
+        fact('user.loggedIn', { name: (loginEvent.payload as { username?: string })?.username ?? 'unknown' }),
+      ]);
+    },
+    contract: defineContract({
+      ruleId: 'auth.login',
+      behavior: 'Process login events and emit user session facts',
+      examples: [
+        { given: 'User provides valid credentials', when: 'LOGIN event', then: 'emit user.loggedIn fact' },
+        { given: 'User provides invalid credentials', when: 'LOGIN event', then: 'skip — invalid credentials' },
+      ],
+      invariants: ['Session must have a username'],
+    }),
+  }));
+
+  // Rule 2: Logout handler (retracts user.loggedIn)
+  registry.registerRule(defineRule<TestContext>({
+    id: 'auth.logout',
+    description: 'Process logout events and clear user session',
+    eventTypes: ['LOGOUT'],
+    impl: (_state, events) => {
+      const logoutEvent = events.find(e => e.tag === 'LOGOUT');
+      if (!logoutEvent) return RuleResult.skip('No logout event');
+      return RuleResult.retract(['user.loggedIn'], 'User logged out');
+    },
+    contract: defineContract({
+      ruleId: 'auth.logout',
+      behavior: 'Clear user session on logout',
+      examples: [
+        { given: 'User is logged in', when: 'LOGOUT event', then: 'retract user.loggedIn' },
+      ],
+      invariants: ['No session should remain after logout'],
+    }),
+  }));
+
+  // Rule 3: Cart add item (produces cart.updated)
+  registry.registerRule(defineRule<TestContext>({
+    id: 'cart.addItem',
+    description: 'Add item to cart',
+    eventTypes: ['ADD_TO_CART'],
+    impl: (state, events) => {
+      const addEvent = events.find(e => e.tag === 'ADD_TO_CART');
+      if (!addEvent) return RuleResult.skip('No add event');
+      const items = (state.context.cart?.items ?? 0) + 1;
+      return RuleResult.emit([
+        fact('cart.updated', { items, total: items * 10 }),
+      ]);
+    },
+    contract: defineContract({
+      ruleId: 'cart.addItem',
+      behavior: 'Update cart when items are added',
+      examples: [
+        { given: 'Cart has 2 items', when: 'ADD_TO_CART event', then: 'emit cart.updated with 3 items' },
+      ],
+      invariants: ['Cart total must be positive', 'Item count must not exceed 100'],
+    }),
+  }));
+
+  // Rule 4: Sprint pace check (produces sprint.behind or sprint.onPace)
+  registry.registerRule(defineRule<TestContext>({
+    id: 'sprint.paceCheck',
+    description: 'Check if sprint is on pace',
+    eventTypes: ['SPRINT_UPDATE'],
+    impl: (state, _events) => {
+      const sprint = state.context.sprint;
+      if (!sprint) return RuleResult.skip('No sprint data');
+      if (sprint.hours < sprint.target) {
+        return RuleResult.emit([fact('sprint.behind', { deficit: sprint.target - sprint.hours })]);
+      }
+      return RuleResult.emit([fact('sprint.onPace', { surplus: sprint.hours - sprint.target })]);
+    },
+    contract: defineContract({
+      ruleId: 'sprint.paceCheck',
+      behavior: 'Evaluate sprint pace and produce status facts',
+      examples: [
+        { given: 'Sprint has 20 of 40 hours', when: 'SPRINT_UPDATE event', then: 'emit sprint.behind' },
+        { given: 'Sprint has 45 of 40 hours', when: 'SPRINT_UPDATE event', then: 'emit sprint.onPace' },
+      ],
+      invariants: ['Either sprint.behind or sprint.onPace must be emitted, never both'],
+    }),
+  }));
+
+  // Rule 5: Network status (produces network.status)
+  registry.registerRule(defineRule<TestContext>({
+    id: 'network.status',
+    description: 'Track network connectivity status',
+    eventTypes: ['NETWORK_CHANGE'],
+    impl: (state, _events) => {
+      return RuleResult.emit([
+        fact('network.status', { connected: state.context.network?.connected ?? false }),
+      ]);
+    },
+  }));
+
+  // Rule 6: Dead rule — requires IMPORT_DATA event that no one sends
+  registry.registerRule(defineRule<TestContext>({
+    id: 'data.import',
+    description: 'Import data from external source',
+    eventTypes: ['IMPORT_DATA'],
+    impl: () => {
+      return RuleResult.emit([fact('data.imported', { count: 0 })]);
+    },
+  }));
+
+  // Rule 7: Another cart rule that ALSO produces cart.updated (contradiction)
+  registry.registerRule(defineRule<TestContext>({
+    id: 'cart.recalculate',
+    description: 'Recalculate cart totals',
+    eventTypes: ['ADD_TO_CART'],
+    impl: (state, _events) => {
+      const items = state.context.cart?.items ?? 0;
+      return RuleResult.emit([
+        fact('cart.updated', { items, total: items * 12 }), // Different price!
+      ]);
+    },
+    contract: defineContract({
+      ruleId: 'cart.recalculate',
+      behavior: 'Recalculate cart totals with tax',
+      examples: [
+        { given: 'Cart has 2 items', when: 'ADD_TO_CART event', then: 'emit cart.updated with tax' },
+      ],
+      invariants: ['Cart total must include tax'],
+    }),
+  }));
+
+  // Rule 8: Settings save (produces settings.saved)
+  registry.registerRule(defineRule<TestContext>({
+    id: 'settings.save',
+    description: 'Save settings when changed',
+    eventTypes: ['SAVE_SETTINGS'],
+    impl: (state, _events) => {
+      if (!state.context.settings?.changed) {
+        return RuleResult.skip('No settings changes');
+      }
+      return RuleResult.emit([
+        fact('settings.saved', { timestamp: Date.now() }),
+      ]);
+    },
+    contract: defineContract({
+      ruleId: 'settings.save',
+      behavior: 'Persist changed settings',
+      examples: [
+        { given: 'Settings have been modified', when: 'SAVE_SETTINGS event', then: 'emit settings.saved' },
+      ],
+      invariants: ['Only save when settings actually changed'],
+    }),
+  }));
+
+  // Rule 9: Shadowed rule — same event type as sprint.paceCheck but produces subset
+  registry.registerRule(defineRule<TestContext>({
+    id: 'sprint.simpleCheck',
+    description: 'Simple sprint status check',
+    eventTypes: ['SPRINT_UPDATE'],
+    impl: (state, _events) => {
+      const sprint = state.context.sprint;
+      if (!sprint) return RuleResult.skip('No sprint');
+      if (sprint.hours < sprint.target) {
+        return RuleResult.emit([fact('sprint.behind', { deficit: sprint.target - sprint.hours })]);
+      }
+      return RuleResult.noop('On pace');
+    },
+  }));
+
+  // Rule 10: Notification rule (reads user.loggedIn, produces notification.sent)
+  registry.registerRule(defineRule<TestContext>({
+    id: 'notification.welcome',
+    description: 'Send welcome notification when user logs in',
+    eventTypes: ['LOGIN'],
+    impl: (state, _events) => {
+      const userFact = state.facts.find(f => f.tag === 'user.loggedIn');
+      if (!userFact) return RuleResult.skip('No user session');
+      return RuleResult.emit([
+        fact('notification.sent', { type: 'welcome', to: (userFact.payload as { name: string }).name }),
+      ]);
+    },
+    contract: defineContract({
+      ruleId: 'notification.welcome',
+      behavior: 'Send welcome notification to logged-in user',
+      examples: [
+        { given: 'fact "user.loggedIn" exists', when: 'LOGIN event', then: 'emit notification.sent' },
+      ],
+      invariants: ['Notification must reference the logged-in user'],
+    }),
+  }));
+
+  // Rule 11: Another dead rule — requires WEBHOOK event
+  registry.registerRule(defineRule<TestContext>({
+    id: 'webhook.handler',
+    description: 'Process incoming webhooks',
+    eventTypes: ['WEBHOOK'],
+    impl: () => {
+      return RuleResult.emit([fact('webhook.processed', { success: true })]);
+    },
+  }));
+
+  // Constraint 1: Cart item limit
+  registry.registerConstraint(defineConstraint<TestContext>({
+    id: 'cart.maxItems',
+    description: 'Cart cannot exceed 100 items',
+    impl: (state) => {
+      const items = state.context.cart?.items ?? 0;
+      return items <= 100 || `Cart has ${items} items, max is 100`;
+    },
+  }));
+
+  // Constraint 2: Sprint hours positive
+  registry.registerConstraint(defineConstraint<TestContext>({
+    id: 'sprint.positiveHours',
+    description: 'Sprint hours must be non-negative',
+    impl: (state) => {
+      return (state.context.sprint?.hours ?? 0) >= 0 || 'Sprint hours are negative';
+    },
+  }));
+
+  return registry;
+}
+
+// ─── Tests ──────────────────────────────────────────────────────────────────
+
+describe('Decision Ledger Analyzer', () => {
+  let registry: PraxisRegistry<TestContext>;
+
+  beforeEach(() => {
+    registry = createTestRegistry();
+  });
 
-      expect(loginContract.ruleId).toBe('auth.login');
-      expect(loginContract.behavior).toBe('Process login events and create user session facts');
-      expect(loginContract.examples).toHaveLength(1);
-      expect(loginContract.examples[0].given).toBe('User provides valid credentials');
-      expect(loginContract.invariants).toHaveLength(2);
-      expect(loginContract.assumptions).toHaveLength(1);
-      expect(loginContract.assumptions![0].id).toBe('assume-unique-username');
-      expect(loginContract.references).toHaveLength(1);
-    });
-
-    it('should throw error if contract has no examples', () => {
-      expect(() => {
-        defineContract({
-          ruleId: 'test.rule',
-          behavior: 'Test behavior',
-          examples: [],
-          invariants: [],
-        });
-      }).toThrow('Contract must have at least one example');
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 1. Dependency Graph Analysis
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  describe('analyzeDependencyGraph', () => {
+    it('should build a dependency graph from the registry', () => {
+      const graph = analyzeDependencyGraph(registry);
+
+      expect(graph.facts.size).toBeGreaterThan(0);
+      expect(graph.edges.length).toBeGreaterThan(0);
+      expect(graph.producers.size).toBeGreaterThan(0);
     });
 
-    it('should validate contract structure with type guard', () => {
-      const validContract = {
-        ruleId: 'test.rule',
-        behavior: 'Test behavior',
-        examples: [{ given: 'a', when: 'b', then: 'c' }],
-        invariants: ['test'],
-      };
+    it('should identify fact producers', () => {
+      const graph = analyzeDependencyGraph(registry);
 
-      expect(isContract(validContract)).toBe(true);
+      // auth.login should produce user.loggedIn
+      const loginProduced = graph.producers.get('auth.login') ?? [];
+      expect(loginProduced).toContain('user.loggedIn');
+    });
 
-      const invalidContract = {
-        ruleId: 'test.rule',
-        behavior: 'Test behavior',
-        examples: [],
-        invariants: [],
-      };
+    it('should identify fact consumers', () => {
+      const graph = analyzeDependencyGraph(registry);
 
-      expect(isContract(invalidContract)).toBe(false);
+      // notification.welcome should consume user.loggedIn (via contract given text)
+      const userLoggedInNode = graph.facts.get('user.loggedIn');
+      expect(userLoggedInNode).toBeDefined();
+      // The node should have at least one producer
+      expect(userLoggedInNode!.producedBy.length).toBeGreaterThan(0);
     });
 
-    it('should extract contract from rule metadata', () => {
-      const contract = defineContract({
-        ruleId: 'test.rule',
-        behavior: 'Test behavior',
-        examples: [{ given: 'a', when: 'b', then: 'c' }],
-        invariants: [],
-      });
+    it('should track edges correctly', () => {
+      const graph = analyzeDependencyGraph(registry);
 
-      const rule = defineRule({
-        id: 'test.rule',
-        description: 'Test rule',
-        impl: () => [],
-        meta: { contract },
-      });
+      const producesEdges = graph.edges.filter(e => e.type === 'produces');
+      expect(producesEdges.length).toBeGreaterThan(0);
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 2. Dead Rules Detection
+  // ═══════════════════════════════════════════════════════════════════════════
 
-      const extracted = getContract(rule.meta);
-      expect(extracted).toBeDefined();
-      expect(extracted?.ruleId).toBe('test.rule');
+  describe('findDeadRules', () => {
+    it('should find rules with event types not in known set', () => {
+      const knownEvents = ['LOGIN', 'LOGOUT', 'ADD_TO_CART', 'SPRINT_UPDATE', 'NETWORK_CHANGE', 'SAVE_SETTINGS'];
+      const dead = findDeadRules(registry, knownEvents);
+
+      const deadIds = dead.map(d => d.ruleId);
+      expect(deadIds).toContain('data.import');
+      expect(deadIds).toContain('webhook.handler');
+    });
+
+    it('should not flag rules that match known event types', () => {
+      const knownEvents = ['LOGIN', 'LOGOUT', 'ADD_TO_CART', 'SPRINT_UPDATE', 'NETWORK_CHANGE', 'SAVE_SETTINGS'];
+      const dead = findDeadRules(registry, knownEvents);
+
+      const deadIds = dead.map(d => d.ruleId);
+      expect(deadIds).not.toContain('auth.login');
+      expect(deadIds).not.toContain('cart.addItem');
+    });
+
+    it('should include required event types in dead rule info', () => {
+      const dead = findDeadRules(registry, ['LOGIN']);
+      const dataImport = dead.find(d => d.ruleId === 'data.import');
+
+      expect(dataImport).toBeDefined();
+      expect(dataImport!.requiredEventTypes).toContain('IMPORT_DATA');
+    });
+
+    it('should find all dead rules when no events are known', () => {
+      const dead = findDeadRules(registry, []);
+      // All rules with event types should be dead
+      expect(dead.length).toBeGreaterThan(5);
     });
   });
 
-  describe('Contract Validation', () => {
-    // Example 2 from behavior ledger: Build-time Validation
-    it('should validate registry and produce complete/incomplete report', () => {
-      const registry = new PraxisRegistry();
-
-      // Rule with complete contract
-      const completeContract = defineContract({
-        ruleId: 'auth.login',
-        behavior: 'Process login events',
-        examples: [{ given: 'valid creds', when: 'LOGIN', then: 'session created' }],
-        invariants: ['unique session ID'],
-      });
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 3. Unreachable States Detection
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  describe('findUnreachableStates', () => {
+    it('should find consumed facts that are never produced', () => {
+      // Add a rule that consumes a non-existent fact
+      registry.registerRule(defineRule<TestContext>({
+        id: 'orphan.reader',
+        description: 'Reads a fact nobody produces',
+        eventTypes: ['LOGIN'],
+        impl: (state) => {
+          const orphan = state.facts.find(f => f.tag === 'orphan.fact');
+          if (!orphan) return RuleResult.skip();
+          return RuleResult.emit([fact('derived.fact', {})]);
+        },
+        contract: defineContract({
+          ruleId: 'orphan.reader',
+          behavior: 'Reads orphan.fact and produces derived.fact',
+          examples: [
+            { given: 'fact "orphan.fact" exists', when: 'LOGIN', then: 'emit derived.fact' },
+          ],
+          invariants: [],
+        }),
+      }));
 
-      registry.registerRule(
-        defineRule({
-          id: 'auth.login',
-          description: 'Login rule',
-          impl: () => [],
-          meta: { contract: completeContract },
-        })
-      );
+      const unreachable = findUnreachableStates(registry);
+      const orphanState = unreachable.find(u => u.factTags.includes('orphan.fact'));
+      expect(orphanState).toBeDefined();
+    });
 
-      // Rule without contract
-      registry.registerRule(
-        defineRule({
-          id: 'cart.addItem',
-          description: 'Add item to cart',
-          impl: () => [],
-        })
-      );
+    it('should return empty array when all consumed facts are produced', () => {
+      // Use a clean registry with matching producers and consumers
+      const cleanRegistry = new PraxisRegistry<TestContext>();
+      cleanRegistry.registerRule(defineRule<TestContext>({
+        id: 'simple.rule',
+        description: 'Simple',
+        eventTypes: ['TEST'],
+        impl: () => RuleResult.emit([fact('simple.fact', {})]),
+      }));
+
+      const unreachable = findUnreachableStates(cleanRegistry);
+      expect(unreachable.length).toBe(0);
+    });
+  });
 
-      const report = validateContracts(registry);
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 4. Shadowed Rules Detection
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  describe('findShadowedRules', () => {
+    it('should find rules where another produces a superset of facts', () => {
+      const shadowed = findShadowedRules(registry);
+
+      // sprint.simpleCheck should be shadowed by sprint.paceCheck
+      // paceCheck produces sprint.behind AND sprint.onPace, simpleCheck only sprint.behind
+      const simpleCheckShadowed = shadowed.find(s => s.ruleId === 'sprint.simpleCheck');
+      if (simpleCheckShadowed) {
+        expect(simpleCheckShadowed.shadowedBy).toBe('sprint.paceCheck');
+        expect(simpleCheckShadowed.sharedEventTypes).toContain('SPRINT_UPDATE');
+      }
+    });
 
-      expect(report.total).toBe(2);
-      expect(report.complete).toHaveLength(1);
-      expect(report.complete[0].ruleId).toBe('auth.login');
-      expect(report.missing).toHaveLength(1);
-      expect(report.missing).toContain('cart.addItem');
-      // Rules without contracts only appear in missing array, not incomplete
-      expect(report.incomplete).toHaveLength(0);
+    it('should include shared event types', () => {
+      const shadowed = findShadowedRules(registry);
+      for (const s of shadowed) {
+        expect(s.sharedEventTypes.length).toBeGreaterThan(0);
+      }
     });
+  });
 
-    it('should validate contract completeness', () => {
-      const registry = new PraxisRegistry();
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 5. Contradiction Detection
+  // ═══════════════════════════════════════════════════════════════════════════
 
-      // Contract missing behavior
-      const incompleteContract = defineContract({
-        ruleId: 'test.rule',
-        behavior: '', // Empty behavior
-        examples: [{ given: 'a', when: 'b', then: 'c' }],
-        invariants: [],
-      });
+  describe('findContradictions', () => {
+    it('should find rules producing the same fact tag with same event types', () => {
+      const contradictions = findContradictions(registry);
 
-      registry.registerRule(
-        defineRule({
-          id: 'test.rule',
-          description: 'Test',
-          impl: () => [],
-          meta: { contract: incompleteContract },
-        })
+      // cart.addItem and cart.recalculate both produce cart.updated
+      const cartConflict = contradictions.find(
+        c =>
+          (c.ruleA === 'cart.addItem' && c.ruleB === 'cart.recalculate') ||
+          (c.ruleA === 'cart.recalculate' && c.ruleB === 'cart.addItem'),
       );
+      expect(cartConflict).toBeDefined();
+      expect(cartConflict!.conflictingTag).toBe('cart.updated');
+    });
 
-      const report = validateContracts(registry, {
-        requiredFields: ['behavior', 'examples'],
-      });
+    it('should include the conflicting fact tag', () => {
+      const contradictions = findContradictions(registry);
+      for (const c of contradictions) {
+        expect(c.conflictingTag).toBeTruthy();
+      }
+    });
 
-      expect(report.incomplete).toHaveLength(1);
-      expect(report.incomplete[0].missing).toContain('behavior');
-    });
-
-    it('should format validation report as text', () => {
-      const registry = new PraxisRegistry();
-
-      registry.registerRule(
-        defineRule({
-          id: 'test.rule',
-          description: 'Test',
-          impl: () => [],
-          meta: {
-            contract: defineContract({
-              ruleId: 'test.rule',
-              behavior: 'Test',
-              examples: [{ given: 'a', when: 'b', then: 'c' }],
-              invariants: [],
-            }),
-          },
-        })
+    it('should not flag rules with non-overlapping event types as contradictions', () => {
+      // auth.login and cart.addItem both produce facts but with different event types
+      const contradictions = findContradictions(registry);
+      const falsePositive = contradictions.find(
+        c =>
+          (c.ruleA === 'auth.login' && c.ruleB === 'cart.addItem') ||
+          (c.ruleA === 'cart.addItem' && c.ruleB === 'auth.login'),
       );
+      expect(falsePositive).toBeUndefined();
+    });
+  });
 
-      const report = validateContracts(registry);
-      const formatted = formatValidationReport(report);
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 6. Gap Detection
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  describe('findGaps', () => {
+    it('should find expectations with no covering rules', () => {
+      const expectations = new ExpectationSet({ name: 'test' });
+      expectations.add(
+        expectBehavior('payment-processing')
+          .onlyWhen('cart total is positive')
+          .never('when cart is empty'),
+      );
 
-      expect(formatted).toContain('Contract Validation Report');
-      expect(formatted).toContain('✓ Complete Contracts:');
-      expect(formatted).toContain('test.rule');
+      const gaps = findGaps(registry, expectations);
+      const paymentGap = gaps.find(g => g.expectationName === 'payment-processing');
+      expect(paymentGap).toBeDefined();
+      expect(paymentGap!.type).toBe('no-rule');
     });
 
-    it('should support strict validation mode', () => {
-      const registry = new PraxisRegistry();
-
-      registry.registerRule(
-        defineRule({
-          id: 'missing.contract',
-          description: 'No contract',
-          impl: () => [],
-        })
+    it('should find expectations with partial coverage', () => {
+      const expectations = new ExpectationSet({ name: 'test' });
+      expectations.add(
+        expectBehavior('auth-login')
+          .onlyWhen('valid credentials provided')
+          .never('when account is locked')
+          .always('produces a session token'),
       );
 
-      const report = validateContracts(registry, { strict: true });
+      const gaps = findGaps(registry, expectations);
+      // auth.login exists but may not cover all conditions
+      const authGap = gaps.find(g => g.expectationName === 'auth-login');
+      // This may or may not be a gap depending on contract matching
+      // We just verify the function runs without error
+      expect(gaps).toBeDefined();
+    });
 
-      // Rules without contracts only appear in missing array, not incomplete
-      expect(report.missing).toHaveLength(1);
-      expect(report.missing).toContain('missing.contract');
-      expect(report.incomplete).toHaveLength(0);
+    it('should return empty array when all expectations are covered', () => {
+      const expectations = new ExpectationSet({ name: 'empty' });
+      const gaps = findGaps(registry, expectations);
+      expect(gaps).toEqual([]);
     });
   });
 
-  describe('Facts and Events', () => {
-    // Example 3 from behavior ledger: Runtime Validation
-    it('should create ContractMissing fact', () => {
-      const fact = ContractMissing.create({
-        ruleId: 'test.rule',
-        missing: ['behavior', 'examples'],
-        severity: 'warning',
-      });
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 7. Derivation Tracing
+  // ═══════════════════════════════════════════════════════════════════════════
 
-      expect(fact.tag).toBe('ContractMissing');
-      expect(fact.payload.ruleId).toBe('test.rule');
-      expect(fact.payload.missing).toContain('behavior');
-      expect(fact.payload.severity).toBe('warning');
+  describe('traceDerivation', () => {
+    it('should trace a fact back through rule chains', () => {
+      const engine = createPraxisEngine({ registry });
+
+      // Step with login event to produce user.loggedIn
+      engine.step([{ tag: 'LOGIN', payload: { username: 'alice' } }]);
+
+      const chain = traceDerivation('user.loggedIn', engine, registry);
+      expect(chain.targetFact).toBe('user.loggedIn');
+      expect(chain.steps.length).toBeGreaterThan(0);
+
+      // Should have at least a rule-fired step
+      const ruleFired = chain.steps.find(s => s.type === 'rule-fired' && s.id === 'auth.login');
+      expect(ruleFired).toBeDefined();
     });
 
-    // Example 4 from behavior ledger: Contract Gap Acknowledgment
-    it('should create AcknowledgeContractGap event', () => {
-      const event = AcknowledgeContractGap.create({
-        ruleId: 'legacy.process',
-        missing: ['spec', 'tests'],
-        justification: 'Legacy rule to be deprecated in v2.0',
-        expiresAt: '2025-12-31',
-      });
+    it('should include event triggers in the chain', () => {
+      const engine = createPraxisEngine({ registry });
+      engine.step([{ tag: 'LOGIN', payload: { username: 'alice' } }]);
 
-      expect(event.tag).toBe('ACKNOWLEDGE_CONTRACT_GAP');
-      expect(event.payload.ruleId).toBe('legacy.process');
-      expect(event.payload.justification).toBe('Legacy rule to be deprecated in v2.0');
-      expect(event.payload.expiresAt).toBe('2025-12-31');
+      const chain = traceDerivation('user.loggedIn', engine, registry);
+
+      const eventStep = chain.steps.find(s => s.type === 'event' && s.id === 'LOGIN');
+      expect(eventStep).toBeDefined();
     });
 
-    it('should use type guards for facts and events', () => {
-      const fact = ContractMissing.create({
-        ruleId: 'test',
-        missing: ['contract'],
-        severity: 'warning',
-      });
+    it('should handle multi-hop derivation', () => {
+      const engine = createPraxisEngine({ registry });
 
-      expect(ContractMissing.is(fact)).toBe(true);
+      // notification.welcome reads user.loggedIn (from auth.login)
+      const chain = traceDerivation('notification.sent', engine, registry);
+      expect(chain.steps.length).toBeGreaterThan(0);
 
-      const event = AcknowledgeContractGap.create({
-        ruleId: 'test',
-        missing: ['contract'],
-        justification: 'test',
-      });
+      // Should trace back through the chain
+      const hasRuleStep = chain.steps.some(s => s.type === 'rule-fired');
+      expect(hasRuleStep).toBe(true);
+    });
 
-      expect(AcknowledgeContractGap.is(event)).toBe(true);
+    it('should report depth correctly', () => {
+      const engine = createPraxisEngine({ registry });
+      const chain = traceDerivation('user.loggedIn', engine, registry);
+      expect(chain.depth).toBeGreaterThanOrEqual(1);
     });
   });
 
-  describe('Behavior Ledger', () => {
-    // Invariant: Ledger Append-Only
-    it('should maintain append-only ledger', () => {
-      const ledger = createBehaviorLedger();
+  describe('traceImpact', () => {
+    it('should find rules affected by removing a fact', () => {
+      const impact = traceImpact('user.loggedIn', registry);
 
-      const contract1 = defineContract({
-        ruleId: 'test.rule',
-        behavior: 'Version 1',
-        examples: [{ given: 'a', when: 'b', then: 'c' }],
-        invariants: [],
-      });
+      expect(impact.factTag).toBe('user.loggedIn');
+      // notification.welcome consumes user.loggedIn
+      // (detected via contract reference in "given")
+      expect(impact.affectedRules.length).toBeGreaterThanOrEqual(0);
+    });
 
-      ledger.append({
-        id: 'entry-1',
-        timestamp: new Date().toISOString(),
-        status: 'active',
-        author: 'system',
-        contract: contract1,
-      });
+    it('should find transitively affected facts', () => {
+      const impact = traceImpact('user.loggedIn', registry);
+      // If notification.welcome stops firing, notification.sent disappears
+      expect(impact.depth).toBeGreaterThanOrEqual(0);
+    });
+  });
 
-      expect(ledger.getAllEntries()).toHaveLength(1);
-
-      // Cannot append entry with same ID
-      expect(() => {
-        ledger.append({
-          id: 'entry-1',
-          timestamp: new Date().toISOString(),
-          status: 'active',
-          author: 'system',
-          contract: contract1,
-        });
-      }).toThrow('already exists');
-    });
-
-    // Invariant: Ledger Unique IDs
-    it('should enforce unique entry IDs', () => {
-      const ledger = createBehaviorLedger();
-
-      const contract = defineContract({
-        ruleId: 'test',
-        behavior: 'test',
-        examples: [{ given: 'a', when: 'b', then: 'c' }],
-        invariants: [],
-      });
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 8. Contract Verification
+  // ═══════════════════════════════════════════════════════════════════════════
 
-      ledger.append({
-        id: 'unique-1',
-        timestamp: new Date().toISOString(),
-        status: 'active',
-        author: 'system',
-        contract,
-      });
+  describe('verifyContractExamples', () => {
+    it('should run rule against contract examples', () => {
+      const rule = registry.getRule('auth.login')!;
+      const result = verifyContractExamples(rule, rule.contract!);
 
-      expect(() => {
-        ledger.append({
-          id: 'unique-1',
-          timestamp: new Date().toISOString(),
-          status: 'active',
-          author: 'system',
-          contract,
-        });
-      }).toThrow();
-    });
-
-    it('should supersede previous entries', () => {
-      const ledger = createBehaviorLedger();
-
-      const contract1 = defineContract({
-        ruleId: 'test.rule',
-        behavior: 'Version 1',
-        examples: [{ given: 'a', when: 'b', then: 'c' }],
-        invariants: [],
-        version: '1.0.0',
-      });
+      expect(result.ruleId).toBe('auth.login');
+      expect(result.examples.length).toBe(2);
+      // At least some examples should have a result
+      expect(result.passCount + result.failCount).toBe(2);
+    });
 
-      ledger.append({
-        id: 'entry-1',
-        timestamp: '2025-01-01T00:00:00Z',
-        status: 'active',
-        author: 'system',
-        contract: contract1,
+    it('should detect wrong implementations', () => {
+      // Create a rule with a contract that doesn't match
+      const badRule = defineRule<TestContext>({
+        id: 'bad.rule',
+        description: 'A rule with wrong implementation',
+        eventTypes: ['TEST'],
+        impl: () => {
+          // Contract says it should emit, but it always noops
+          return RuleResult.noop('Always noop');
+        },
+        contract: defineContract({
+          ruleId: 'bad.rule',
+          behavior: 'Should emit test.fact',
+          examples: [
+            { given: 'Normal state', when: 'TEST event', then: 'emit test.fact' },
+          ],
+          invariants: [],
+        }),
       });
 
-      const contract2 = defineContract({
-        ruleId: 'test.rule',
-        behavior: 'Version 2',
-        examples: [{ given: 'x', when: 'y', then: 'z' }],
-        invariants: [],
-        version: '2.0.0',
-      });
+      const result = verifyContractExamples(badRule, badRule.contract!);
+      expect(result.allPassed).toBe(false);
+      expect(result.failCount).toBeGreaterThan(0);
+    });
 
-      ledger.append({
-        id: 'entry-2',
-        timestamp: '2025-01-02T00:00:00Z',
-        status: 'active',
-        author: 'system',
-        contract: contract2,
-        supersedes: 'entry-1',
+    it('should pass when implementation matches contract', () => {
+      // Create a rule that matches its contract
+      const goodRule = defineRule<TestContext>({
+        id: 'good.rule',
+        description: 'A correctly implemented rule',
+        eventTypes: ['TEST'],
+        impl: () => {
+          return RuleResult.emit([fact('test.fact', { value: 1 })]);
+        },
+        contract: defineContract({
+          ruleId: 'good.rule',
+          behavior: 'Should emit test.fact',
+          examples: [
+            { given: 'Normal state', when: 'TEST event', then: 'emit test.fact' },
+          ],
+          invariants: [],
+        }),
       });
 
-      const latest = ledger.getLatestEntry('test.rule');
-      expect(latest?.id).toBe('entry-2');
-      expect(latest?.contract.version).toBe('2.0.0');
-
-      const entry1 = ledger.getEntry('entry-1');
-      expect(entry1?.status).toBe('superseded');
-    });
-
-    it('should track assumptions', () => {
-      const ledger = createBehaviorLedger();
-
-      const contract = defineContract({
-        ruleId: 'test.rule',
-        behavior: 'Test',
-        examples: [{ given: 'a', when: 'b', then: 'c' }],
-        invariants: [],
-        assumptions: [
-          {
-            id: 'test-assumption',
-            statement: 'Test assumption',
-            confidence: 0.8,
-            justification: 'For testing',
-            impacts: ['tests'],
-            status: 'active',
-          },
-        ],
-      });
+      const result = verifyContractExamples(goodRule, goodRule.contract!);
+      expect(result.allPassed).toBe(true);
+    });
+  });
 
-      ledger.append({
-        id: 'entry-1',
-        timestamp: new Date().toISOString(),
-        status: 'active',
-        author: 'system',
-        contract,
-      });
+  describe('verifyInvariants', () => {
+    it('should check invariants across all rules', () => {
+      const checks = verifyInvariants(registry);
+      expect(checks.length).toBeGreaterThan(0);
 
-      const assumptions = ledger.getActiveAssumptions();
-      expect(assumptions.size).toBe(1);
-      expect(assumptions.get('test-assumption')?.statement).toBe('Test assumption');
+      // All should be related to a rule
+      for (const check of checks) {
+        expect(check.ruleId).toBeTruthy();
+        expect(check.invariant).toBeTruthy();
+      }
     });
 
-    it('should export and import ledger as JSON', () => {
-      const ledger1 = createBehaviorLedger();
+    it('should report invariant status', () => {
+      const checks = verifyInvariants(registry);
+      for (const check of checks) {
+        expect(typeof check.holds).toBe('boolean');
+        expect(check.explanation).toBeTruthy();
+      }
+    });
+  });
 
-      const contract = defineContract({
-        ruleId: 'test.rule',
-        behavior: 'Test',
-        examples: [{ given: 'a', when: 'b', then: 'c' }],
-        invariants: [],
-      });
+  describe('findContractGaps', () => {
+    it('should find rules missing error path examples', () => {
+      const gaps = findContractGaps(registry);
 
-      ledger1.append({
-        id: 'entry-1',
-        timestamp: new Date().toISOString(),
-        status: 'active',
-        author: 'system',
-        contract,
-      });
+      // Several rules only have happy path examples
+      const errorPathGaps = gaps.filter(g => g.type === 'missing-error-path');
+      expect(errorPathGaps.length).toBeGreaterThan(0);
+    });
 
-      const json = ledger1.toJSON();
-      const ledger2 = BehaviorLedger.fromJSON(json);
+    it('should find rules with only 1 example', () => {
+      const gaps = findContractGaps(registry);
+      const boundaryGaps = gaps.filter(g => g.type === 'missing-boundary');
 
-      expect(ledger2.getAllEntries()).toHaveLength(1);
-      expect(ledger2.getEntry('entry-1')?.contract.ruleId).toBe('test.rule');
+      // Rules with exactly 1 example should be flagged
+      expect(boundaryGaps.length).toBeGreaterThan(0);
     });
+  });
 
-    it('should provide ledger statistics', () => {
-      const ledger = createBehaviorLedger();
+  describe('crossReferenceContracts', () => {
+    it('should find cross-references between rules', () => {
+      const refs = crossReferenceContracts(registry);
 
-      const contract1 = defineContract({
-        ruleId: 'rule1',
-        behavior: 'Rule 1',
-        examples: [{ given: 'a', when: 'b', then: 'c' }],
-        invariants: [],
-      });
+      // notification.welcome references user.loggedIn in its contract
+      const welcomeRef = refs.find(
+        r => r.sourceRuleId === 'notification.welcome' && r.referencedFactTag === 'user.loggedIn',
+      );
+      expect(welcomeRef).toBeDefined();
+      if (welcomeRef) {
+        expect(welcomeRef.valid).toBe(true);
+        expect(welcomeRef.producerRuleId).toBe('auth.login');
+      }
+    });
+  });
 
-      const contract2 = defineContract({
-        ruleId: 'rule2',
-        behavior: 'Rule 2',
-        examples: [{ given: 'x', when: 'y', then: 'z' }],
-        invariants: [],
-      });
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 9. Suggestions
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  describe('suggest', () => {
+    it('should generate actionable suggestion for dead rules', () => {
+      const dead = findDeadRules(registry, ['LOGIN']);
+      expect(dead.length).toBeGreaterThan(0);
+
+      const suggestion = suggest(dead[0], 'dead-rule');
+      expect(suggestion.findingType).toBe('dead-rule');
+      expect(suggestion.message).toBeTruthy();
+      expect(suggestion.message).not.toBe('fix it');
+      expect(suggestion.action).toBeTruthy();
+      expect(suggestion.priority).toBeGreaterThan(0);
+    });
 
-      ledger.append({
-        id: 'entry-1',
-        timestamp: new Date().toISOString(),
-        status: 'active',
-        author: 'system',
-        contract: contract1,
-      });
+    it('should generate suggestion with code skeleton', () => {
+      const dead = findDeadRules(registry, ['LOGIN']);
+      const suggestion = suggest(dead[0], 'dead-rule');
+      expect(suggestion.skeleton).toBeTruthy();
+    });
 
-      ledger.append({
-        id: 'entry-2',
-        timestamp: new Date().toISOString(),
-        status: 'active',
-        author: 'system',
-        contract: contract2,
+    it('should generate specific gap suggestions', () => {
+      const expectations = new ExpectationSet({ name: 'test' });
+      expectations.add(
+        expectBehavior('payment-processing')
+          .onlyWhen('cart total positive'),
+      );
+
+      const gaps = findGaps(registry, expectations);
+      expect(gaps.length).toBeGreaterThan(0);
+
+      const suggestion = suggest(gaps[0], 'gap');
+      expect(suggestion.findingType).toBe('gap');
+      expect(suggestion.message).toContain('payment-processing');
+      expect(suggestion.skeleton).toBeTruthy();
+    });
+
+    it('should generate contradiction suggestions', () => {
+      const contradictions = findContradictions(registry);
+      if (contradictions.length > 0) {
+        const suggestion = suggest(contradictions[0], 'contradiction');
+        expect(suggestion.findingType).toBe('contradiction');
+        expect(suggestion.action).toBe('add-priority');
+        expect(suggestion.priority).toBeGreaterThanOrEqual(9);
+      }
+    });
+  });
+
+  describe('suggestAll', () => {
+    it('should generate suggestions for all findings', () => {
+      const suggestions = suggestAll({
+        deadRules: findDeadRules(registry, ['LOGIN']),
+        contradictions: findContradictions(registry),
       });
 
-      const stats = ledger.getStats();
-      expect(stats.totalEntries).toBe(2);
-      expect(stats.activeEntries).toBe(2);
-      expect(stats.uniqueRules).toBe(2);
+      expect(suggestions.length).toBeGreaterThan(0);
+      // Should be sorted by priority
+      for (let i = 1; i < suggestions.length; i++) {
+        expect(suggestions[i - 1].priority).toBeGreaterThanOrEqual(suggestions[i].priority);
+      }
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 10. Report Generation
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  describe('generateLedger', () => {
+    it('should produce a complete analysis report', () => {
+      const engine = createPraxisEngine({ registry });
+      const report = generateLedger(registry, engine);
+
+      expect(report.timestamp).toBeTruthy();
+      expect(report.summary.totalRules).toBe(11);
+      expect(report.summary.totalConstraints).toBe(2);
+      expect(report.summary.healthScore).toBeGreaterThanOrEqual(0);
+      expect(report.summary.healthScore).toBeLessThanOrEqual(100);
+    });
+
+    it('should include expectations gaps when provided', () => {
+      const engine = createPraxisEngine({ registry });
+      const expectations = new ExpectationSet({ name: 'test' });
+      expectations.add(
+        expectBehavior('payment-processing')
+          .onlyWhen('cart total positive'),
+      );
+
+      const report = generateLedger(registry, engine, expectations);
+      expect(report.gaps.length).toBeGreaterThan(0);
+    });
+
+    it('should include dead rules in report', () => {
+      const engine = createPraxisEngine({ registry });
+      const report = generateLedger(registry, engine);
+
+      // data.import and webhook.handler should NOT be dead because
+      // generateLedger uses all known event types from rules themselves
+      // They use IMPORT_DATA and WEBHOOK which ARE known from the rules
+      expect(report.deadRules.length).toBe(0);
+    });
+  });
+
+  describe('formatLedger', () => {
+    it('should produce markdown output', () => {
+      const engine = createPraxisEngine({ registry });
+      const report = generateLedger(registry, engine);
+      const markdown = formatLedger(report);
+
+      expect(markdown).toContain('# ');
+      expect(markdown).toContain('Decision Ledger Analysis');
+      expect(markdown).toContain('Health Score');
+      expect(markdown).toContain('Summary');
+    });
+
+    it('should include all sections when findings exist', () => {
+      const engine = createPraxisEngine({ registry });
+      const expectations = new ExpectationSet({ name: 'test' });
+      expectations.add(
+        expectBehavior('payment-processing')
+          .onlyWhen('cart total positive'),
+      );
+
+      const report = generateLedger(registry, engine, expectations);
+      const markdown = formatLedger(report);
+
+      // Should have gaps section
+      if (report.gaps.length > 0) {
+        expect(markdown).toContain('Gaps');
+      }
+
+      // Should have suggestions
+      if (report.suggestions.length > 0) {
+        expect(markdown).toContain('Suggestions');
+      }
+    });
+  });
+
+  describe('formatBuildOutput', () => {
+    it('should produce CI-friendly annotations', () => {
+      const engine = createPraxisEngine({ registry });
+      const report = generateLedger(registry, engine);
+      const output = formatBuildOutput(report);
+
+      expect(output).toContain('::group::');
+      expect(output).toContain('::endgroup::');
+      expect(output).toContain('Score:');
+    });
+
+    it('should include errors for contradictions', () => {
+      const engine = createPraxisEngine({ registry });
+      const report = generateLedger(registry, engine);
+      const output = formatBuildOutput(report);
+
+      if (report.contradictions.length > 0) {
+        expect(output).toContain('::error');
+      }
+    });
+  });
+
+  // ═══════════════════════════════════════════════════════════════════════════
+  // 11. Ledger Diffing
+  // ═══════════════════════════════════════════════════════════════════════════
+
+  describe('diffLedgers', () => {
+    it('should detect added findings', () => {
+      const engine = createPraxisEngine({ registry });
+      const before = generateLedger(registry, engine);
+
+      // Add a problematic rule
+      registry.registerRule(defineRule<TestContext>({
+        id: 'orphan.consumer',
+        description: 'Consumes unknown fact',
+        eventTypes: ['MYSTERY_EVENT'],
+        impl: () => RuleResult.noop(),
+        contract: defineContract({
+          ruleId: 'orphan.consumer',
+          behavior: 'Reads mystery.fact',
+          examples: [
+            { given: 'fact "mystery.fact" exists', when: 'MYSTERY_EVENT', then: 'emit result.fact' },
+          ],
+          invariants: [],
+        }),
+      }));
+
+      const after = generateLedger(registry, engine);
+      const diff = diffLedgers(before, after);
+
+      expect(diff.changes.length).toBeGreaterThanOrEqual(0);
+      expect(diff.summary).toBeTruthy();
+      expect(diff.beforeTimestamp).toBe(before.timestamp);
+      expect(diff.afterTimestamp).toBe(after.timestamp);
+    });
+
+    it('should detect removed findings', () => {
+      const engine = createPraxisEngine({ registry });
+
+      // First report with expectations
+      const expectations = new ExpectationSet({ name: 'test' });
+      expectations.add(
+        expectBehavior('payment-processing')
+          .onlyWhen('cart total positive'),
+      );
+      const before = generateLedger(registry, engine, expectations);
+
+      // Second report without expectations (gap removed)
+      const after = generateLedger(registry, engine);
+      const diff = diffLedgers(before, after);
+
+      const removedGaps = diff.changes.filter(c => c.type === 'removed' && c.category === 'gap');
+      expect(removedGaps.length).toBeGreaterThan(0);
+    });
+
+    it('should calculate score delta', () => {
+      const engine = createPraxisEngine({ registry });
+      const before = generateLedger(registry, engine);
+      const after = generateLedger(registry, engine);
+
+      const diff = diffLedgers(before, after);
+      expect(typeof diff.scoreDelta).toBe('number');
+    });
+
+    it('should produce human-readable summary', () => {
+      const engine = createPraxisEngine({ registry });
+      const before = generateLedger(registry, engine);
+      const after = generateLedger(registry, engine);
+      const diff = diffLedgers(before, after);
+
+      expect(diff.summary).toContain('Score');
+      expect(diff.summary).toContain('changes');
     });
   });
 });