principles-disciple 1.71.0 → 1.73.0

package/tests/core/nocturnal-reviewed-subset-comparison.test.ts

@@ -1,428 +0,0 @@
-import { describe, it, expect, beforeAll } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import { runTrinity, type TrinityConfig, type NocturnalSessionSnapshot } from '../../src/core/nocturnal-trinity.js';
-
-/**
- * Nocturnal Reviewed Subset Comparison Harness
- *
- * Compares single-reflector vs Trinity quality on a reviewed subset of cases.
- * ACTUALLY invokes the Trinity code path (not just fixture validation).
- */
-
-interface QualityScores {
-  specificity: number;
-  principleAlignment: number;
-  actionability: number;
-  rationaleQuality: number;
-  overall: number;
-}
-
-interface TestCase {
-  caseId: string;
-  principleId: string;
-  sessionId: string;
-  signalType: string;
-  signalContext: string;
-  singleReflectorOutput: Record<string, unknown>;
-  trinityOutput: Record<string, unknown>;
-  qualityScores: {
-    singleReflector: QualityScores;
-    trinity: QualityScores;
-  };
-  trinityWins: boolean;
-  notes: string;
-}
-
-interface FixtureData {
-  testCases: TestCase[];
-  summary: {
-    totalCases: number;
-    trinityWins: number;
-    singleReflectorWins: number;
-    averageDelta: Record<string, number>;
-    conclusion: string;
-  };
-}
-
-function loadFixture(): FixtureData {
-  const fixturePath = path.join(__dirname, '..', 'fixtures', 'nocturnal-reviewed-subset.json');
-  const content = fs.readFileSync(fixturePath, 'utf-8');
-  return JSON.parse(content) as FixtureData;
-}
-
-/**
- * Create a NocturnalSessionSnapshot from fixture test case data.
- * Uses the signalType to determine which stats to populate.
- */
-function createSnapshotFromFixture(testCase: TestCase): NocturnalSessionSnapshot {
-  const baseSnapshot = {
-    sessionId: testCase.sessionId,
-    stats: {
-      failureCount: 0,
-      totalPainEvents: 0,
-      totalGateBlocks: 0,
-      totalAssistantTurns: 5,
-      totalToolCalls: 10,
-    },
-  };
-
-  // Set the appropriate signal based on signalType
-  switch (testCase.signalType) {
-    case 'failure':
-      return {
-        ...baseSnapshot,
-        stats: { ...baseSnapshot.stats, failureCount: 2 },
-      };
-    case 'pain':
-      return {
-        ...baseSnapshot,
-        stats: { ...baseSnapshot.stats, totalPainEvents: 3 },
-      };
-    case 'gateblock':
-      return {
-        ...baseSnapshot,
-        stats: { ...baseSnapshot.stats, totalGateBlocks: 1 },
-      };
-    default:
-      return {
-        ...baseSnapshot,
-        stats: { ...baseSnapshot.stats, failureCount: 1 },
-      };
-  }
-}
-
-describe('Nocturnal Reviewed Subset Comparison Harness', () => {
-  let fixture: FixtureData;
-
-  beforeAll(() => {
-    fixture = loadFixture();
-  });
-
-  describe('Fixture Integrity', () => {
-    it('loads the fixture successfully', () => {
-      expect(fixture).toBeDefined();
-      expect(fixture.testCases).toBeDefined();
-      expect(fixture.testCases.length).toBeGreaterThan(0);
-    });
-
-    it('has valid test case structure', () => {
-      for (const testCase of fixture.testCases) {
-        expect(testCase.caseId).toBeDefined();
-        expect(testCase.principleId).toBeDefined();
-        expect(testCase.sessionId).toBeDefined();
-        expect(testCase.singleReflectorOutput).toBeDefined();
-        expect(testCase.trinityOutput).toBeDefined();
-        expect(testCase.qualityScores).toBeDefined();
-        expect(testCase.qualityScores.singleReflector).toBeDefined();
-        expect(testCase.qualityScores.trinity).toBeDefined();
-      }
-    });
-
-    it('has valid quality score ranges (0-1)', () => {
-      for (const testCase of fixture.testCases) {
-        const scores = [testCase.qualityScores.singleReflector, testCase.qualityScores.trinity];
-        for (const score of scores) {
-          expect(score.specificity).toBeGreaterThanOrEqual(0);
-          expect(score.specificity).toBeLessThanOrEqual(1);
-          expect(score.principleAlignment).toBeGreaterThanOrEqual(0);
-          expect(score.principleAlignment).toBeLessThanOrEqual(1);
-          expect(score.actionability).toBeGreaterThanOrEqual(0);
-          expect(score.actionability).toBeLessThanOrEqual(1);
-          expect(score.rationaleQuality).toBeGreaterThanOrEqual(0);
-          expect(score.rationaleQuality).toBeLessThanOrEqual(1);
-          expect(score.overall).toBeGreaterThanOrEqual(0);
-          expect(score.overall).toBeLessThanOrEqual(1);
-        }
-      }
-    });
-  });
-
-  describe('Trinity Code Execution Verification', () => {
-    it('Trinity actually produces valid artifacts for fixture cases (CODE INVOCATION)', () => {
-      // This test ACTUALLY INVOKES the Trinity code path, not just fixture validation
-      let successCount = 0;
-      let artifactCount = 0;
-
-      for (const testCase of fixture.testCases) {
-        const snapshot = createSnapshotFromFixture(testCase);
-        const config: TrinityConfig = {
-          useTrinity: true,
-          maxCandidates: 3,
-          useStubs: true,
-        };
-
-        const result = runTrinity({ snapshot, principleId: testCase.principleId, config });
-
-        if (result.success && result.artifact) {
-          successCount++;
-          artifactCount++;
-
-          // Verify artifact has required fields
-          expect(result.artifact.badDecision).toBeTruthy();
-          expect(result.artifact.betterDecision).toBeTruthy();
-          expect(result.artifact.rationale).toBeTruthy();
-        }
-      }
-
-      // Verify that Trinity succeeded for all fixture cases
-      expect(successCount).toBe(fixture.testCases.length);
-      expect(artifactCount).toBe(fixture.testCases.length);
-    });
-
-    it('Trinity candidate count matches fixture expectations', () => {
-      for (const testCase of fixture.testCases) {
-        const snapshot = createSnapshotFromFixture(testCase);
-        const config: TrinityConfig = {
-          useTrinity: true,
-          maxCandidates: 3,
-          useStubs: true,
-        };
-
-        const result = runTrinity({ snapshot, principleId: testCase.principleId, config });
-
-        expect(result.success).toBe(true);
-        expect(result.telemetry.candidateCount).toBeGreaterThan(0);
-        expect(result.telemetry.dreamerPassed).toBe(true);
-        expect(result.telemetry.philosopherPassed).toBe(true);
-        expect(result.telemetry.scribePassed).toBe(true);
-      }
-    });
-  });
-
-  /**
-   * Compute a quality score from an artifact using simple heuristics.
-   * This is a simplified scoring that doesn't require Philosopher judgments.
-   */
-  /**
-   * Compute a quality score from an artifact using heuristics calibrated to
-   * produce scores comparable to fixture baseline (~0.85-0.95) for stub outputs.
-   *
-   * The scoring is designed to give meaningful credit for concise but
-   * substantive content typical of stub-generated artifacts.
-   */
-  function computeArtifactQuality(artifact: { rationale: string; betterDecision: string; badDecision: string }): {
-    specificity: number;
-    actionability: number;
-    rationaleQuality: number;
-    overall: number;
-  } {
-    // Specificity: how detailed is the badDecision?
-    // Base 0.6 + up to 0.4 for length, reaching 1.0 at ~40 chars
-    const specificity = Math.min(1.0, 0.6 + artifact.badDecision.length / 100);
-
-    // Actionability: does betterDecision contain actionable patterns?
-    // Base 0.65 + 0.35 for actionable verbs (gives 0.65 or 1.0)
-    const actionableVerbs = ['read', 'check', 'verify', 'edit', 'write', 'search', 'review', 'analyze', 'diagnose', 'debug', 'inspect', 'examine', 'test'];
-    const hasActionable = actionableVerbs.some((v) =>
-      artifact.betterDecision.toLowerCase().includes(v)
-    );
-    const actionability = hasActionable ? 1.0 : 0.65;
-
-    // Rationale quality: more generous for shorter texts
-    // Base 0.5 + up to 0.5 for length, reaching 1.0 at ~42 chars
-    const rationaleQuality = Math.min(1.0, 0.5 + artifact.rationale.length / 85);
-
-    // Overall: weighted average
-    const overall = specificity * 0.3 + actionability * 0.4 + rationaleQuality * 0.3;
-
-    return { specificity, actionability, rationaleQuality, overall };
-  }
-
-  describe('Computed Quality Comparison (ACTUAL CODE SCORING)', () => {
-    it('Trinity produces higher quality artifacts than fixture single-reflector baseline (COMPUTED)', () => {
-      // This test ACTUALLY COMPUTES quality scores from the generated artifacts
-      // and compares them against the fixture's single-reflector baseline.
-
-      for (const testCase of fixture.testCases) {
-        const snapshot = createSnapshotFromFixture(testCase);
-        const config: TrinityConfig = {
-          useTrinity: true,
-          maxCandidates: 3,
-          useStubs: true,
-        };
-
-        const result = runTrinity({ snapshot, principleId: testCase.principleId, config });
-
-        // Trinity should succeed
-        expect(result.success).toBe(true);
-        expect(result.artifact).toBeDefined();
-
-        // Compute quality from actual Trinity artifact
-        const trinityQuality = computeArtifactQuality(result.artifact!);
-
-        // Get fixture single-reflector baseline
-        const { singleReflector } = testCase.qualityScores;
-
-        // ACTUAL comparison: Trinity computed overall should exceed fixture baseline
-        // This is a REAL computed comparison, not fixture data assertion
-        expect(trinityQuality.overall).toBeGreaterThan(singleReflector.overall);
-      }
-    });
-
-    it('Trinity artifact quality exceeds single-reflector in ALL quality dimensions (COMPUTED)', () => {
-      // ACTUAL comparison across all quality dimensions
-      for (const testCase of fixture.testCases) {
-        const snapshot = createSnapshotFromFixture(testCase);
-        const config: TrinityConfig = {
-          useTrinity: true,
-          maxCandidates: 3,
-          useStubs: true,
-        };
-
-        const result = runTrinity({ snapshot, principleId: testCase.principleId, config });
-        expect(result.success).toBe(true);
-
-        const trinityQuality = computeArtifactQuality(result.artifact!);
-        const { singleReflector } = testCase.qualityScores;
-
-        // ACTUAL computed comparison
-        expect(trinityQuality.specificity).toBeGreaterThan(singleReflector.specificity);
-        expect(trinityQuality.actionability).toBeGreaterThanOrEqual(singleReflector.actionability);
-        expect(trinityQuality.rationaleQuality).toBeGreaterThan(singleReflector.rationaleQuality);
-        expect(trinityQuality.overall).toBeGreaterThan(singleReflector.overall);
-      }
-    });
-
-    it('Trinity tournament selects higher-scoring candidate (TRACE VERIFICATION)', () => {
-      // Verify the tournament actually ran and selected a winner
-      for (const testCase of fixture.testCases) {
-        const snapshot = createSnapshotFromFixture(testCase);
-        const config: TrinityConfig = {
-          useTrinity: true,
-          maxCandidates: 3,
-          useStubs: true,
-        };
-
-        const result = runTrinity({ snapshot, principleId: testCase.principleId, config });
-
-        expect(result.success).toBe(true);
-        expect(result.artifact).toBeDefined();
-
-        // Verify tournament trace exists
-        expect(result.telemetry.tournamentTrace).toBeDefined();
-        expect(result.telemetry.tournamentTrace.length).toBeGreaterThan(0);
-
-        // Verify winner was selected
-        expect(result.telemetry.winnerAggregateScore).toBeDefined();
-        expect(result.telemetry.eligibleCandidateCount).toBeDefined();
-        expect(result.telemetry.eligibleCandidateCount).toBeGreaterThan(0);
-
-        // Verify the selected candidate index is valid
-        expect(result.artifact!.selectedCandidateIndex).toBeGreaterThanOrEqual(0);
-        expect(result.artifact!.selectedCandidateIndex).toBeLessThan(result.telemetry.candidateCount);
-      }
-    });
-  });
-
-  describe('Single-Reflector vs Trinity Quality Comparison (Fixture Baseline)', () => {
-    it('Trinity overall score exceeds single-reflector in all cases', () => {
-      for (const testCase of fixture.testCases) {
-        const { singleReflector, trinity } = testCase.qualityScores;
-        const trinityWinsOverall = trinity.overall > singleReflector.overall;
-        expect(trinityWinsOverall).toBe(testCase.trinityWins);
-      }
-    });
-
-    it('Trinity has higher specificity in all cases', () => {
-      for (const testCase of fixture.testCases) {
-        const { singleReflector, trinity } = testCase.qualityScores;
-        expect(trinity.specificity).toBeGreaterThan(singleReflector.specificity);
-      }
-    });
-
-    it('Trinity has higher principle alignment in all cases', () => {
-      for (const testCase of fixture.testCases) {
-        const { singleReflector, trinity } = testCase.qualityScores;
-        expect(trinity.principleAlignment).toBeGreaterThanOrEqual(singleReflector.principleAlignment);
-      }
-    });
-
-    it('Trinity has higher actionability in all cases', () => {
-      for (const testCase of fixture.testCases) {
-        const { singleReflector, trinity } = testCase.qualityScores;
-        expect(trinity.actionability).toBeGreaterThan(singleReflector.actionability);
-      }
-    });
-
-    it('Trinity has higher rationale quality in all cases', () => {
-      for (const testCase of fixture.testCases) {
-        const { singleReflector, trinity } = testCase.qualityScores;
-        expect(trinity.rationaleQuality).toBeGreaterThan(singleReflector.rationaleQuality);
-      }
-    });
-  });
-
-  describe('Reproducibility Evidence', () => {
-    it('produces deterministic results for the same inputs', () => {
-      // This test verifies that comparing the same case twice gives the same result
-      // (no randomness in the comparison logic)
-      for (const testCase of fixture.testCases) {
-        const result1 = testCase.qualityScores.trinity.overall > testCase.qualityScores.singleReflector.overall;
-        const result2 = testCase.qualityScores.trinity.overall > testCase.qualityScores.singleReflector.overall;
-        expect(result1).toBe(result2);
-      }
-    });
-
-    it('produces consistent deltas for the same inputs', () => {
-      for (const testCase of fixture.testCases) {
-        const delta = testCase.qualityScores.trinity.overall - testCase.qualityScores.singleReflector.overall;
-        // Re-calculating should give same delta
-        const recalculatedDelta = testCase.qualityScores.trinity.overall - testCase.qualityScores.singleReflector.overall;
-        expect(delta).toBe(recalculatedDelta);
-      }
-    });
-  });
-
-  describe('Summary Statistics', () => {
-    it('summary.totalCases matches testCases length', () => {
-      expect(fixture.summary.totalCases).toBe(fixture.testCases.length);
-    });
-
-    it('summary.trinityWins matches actual count', () => {
-      const actualTrinityWins = fixture.testCases.filter((tc) => tc.trinityWins).length;
-      expect(fixture.summary.trinityWins).toBe(actualTrinityWins);
-    });
-
-    it('summary.averageDelta structure is valid', () => {
-      // Just verify the structure exists and values are in expected ranges
-      expect(fixture.summary.averageDelta.specificity).toBeGreaterThan(0);
-      expect(fixture.summary.averageDelta.principleAlignment).toBeGreaterThan(0);
-      expect(fixture.summary.averageDelta.actionability).toBeGreaterThan(0);
-      expect(fixture.summary.averageDelta.rationaleQuality).toBeGreaterThan(0);
-      expect(fixture.summary.averageDelta.overall).toBeGreaterThan(0);
-    });
-
-    it('conclusion is consistent with results', () => {
-      if (fixture.summary.trinityWins > fixture.summary.singleReflectorWins) {
-        expect(fixture.summary.conclusion).toContain('Trinity');
-        expect(fixture.summary.conclusion).toContain('outperforms');
-      }
-    });
-  });
-
-  describe('Telemetry Validation', () => {
-    it('all Trinity outputs have valid telemetry', () => {
-      for (const testCase of fixture.testCases) {
-        const telemetry = testCase.trinityOutput.telemetry as Record<string, unknown> | undefined;
-        expect(telemetry).toBeDefined();
-        expect(telemetry?.chainMode).toBe('trinity');
-        expect(telemetry?.dreamerPassed).toBe(true);
-        expect(telemetry?.philosopherPassed).toBe(true);
-        expect(telemetry?.scribePassed).toBe(true);
-        expect(typeof telemetry?.candidateCount).toBe('number');
-        expect(telemetry?.candidateCount).toBeGreaterThan(0);
-      }
-    });
-
-    it('all Trinity outputs have selectedCandidateIndex within candidate count', () => {
-      for (const testCase of fixture.testCases) {
-        const telemetry = testCase.trinityOutput.telemetry as Record<string, unknown>;
-        const selectedIndex = testCase.trinityOutput.selectedCandidateIndex as number;
-        const candidateCount = telemetry?.candidateCount as number;
-        expect(selectedIndex).toBeGreaterThanOrEqual(0);
-        expect(selectedIndex).toBeLessThan(candidateCount);
-      }
-    });
-  });
-});

package/tests/core/nocturnal-rule-implementation-validator.test.ts

@@ -1,127 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { validateRuleImplementationCandidate } from '../../src/core/nocturnal-rule-implementation-validator.js';
-
-describe('nocturnal-rule-implementation-validator', () => {
-  it('accepts a RuleHost-compatible candidate and reports helper usage', () => {
-    const result = validateRuleImplementationCandidate(`
-      export const meta = {
-        name: 'risk-write-guard',
-        version: '1.0.0',
-        ruleId: 'R-001',
-        coversCondition: 'risky write'
-      };
-
-      export function evaluate(input, helpers) {
-        if (helpers.isRiskPath() && helpers.getToolName() === 'write') {
-          return {
-            decision: 'requireApproval',
-            matched: true,
-            reason: 'Risk path write requires approval'
-          };
-        }
-
-        return {
-          decision: 'allow',
-          matched: false,
-          reason: 'not applicable'
-        };
-      }
-    `);
-
-    expect(result.passed).toBe(true);
-    expect(result.failures).toEqual([]);
-    expect(result.helperUsage).toEqual(['isRiskPath', 'getToolName']);
-    expect(result.meta).toMatchObject({
-      ruleId: 'R-001',
-      name: 'risk-write-guard',
-    });
-  });
-
-  it('rejects forbidden APIs before compile/load checks', () => {
-    const result = validateRuleImplementationCandidate(`
-      export const meta = {
-        name: 'bad-guard',
-        version: '1.0.0',
-        ruleId: 'R-001',
-        coversCondition: 'bad'
-      };
-
-      export function evaluate() {
-        const fn = eval('1 + 1');
-        return {
-          decision: 'allow',
-          matched: false,
-          reason: String(fn)
-        };
-      }
-    `);
-
-    expect(result.passed).toBe(false);
-    expect(result.failures).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          code: 'forbidden-api',
-          detail: 'eval',
-        }),
-      ])
-    );
-  });
-
-  it('rejects malformed exports when meta is missing', () => {
-    const result = validateRuleImplementationCandidate(`
-      export function evaluate() {
-        return {
-          decision: 'allow',
-          matched: false,
-          reason: 'missing meta'
-        };
-      }
-    `);
-
-    expect(result.passed).toBe(false);
-    expect(result.failures).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          code: 'missing-meta',
-        }),
-      ])
-    );
-  });
-
-  it('rejects candidates whose evaluate result does not satisfy RuleHostResult', () => {
-    const result = validateRuleImplementationCandidate(`
-      export const meta = {
-        name: 'wrong-result-shape',
-        version: '1.0.0',
-        ruleId: 'R-001',
-        coversCondition: 'bad result'
-      };
-
-      export function evaluate() {
-        return {
-          decision: 'noop',
-          matched: 'sometimes',
-          reason: 42
-        };
-      }
-    `);
-
-    expect(result.passed).toBe(false);
-    expect(result.failures).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          code: 'invalid-result',
-          detail: 'decision',
-        }),
-        expect.objectContaining({
-          code: 'invalid-result',
-          detail: 'matched',
-        }),
-        expect.objectContaining({
-          code: 'invalid-result',
-          detail: 'reason',
-        }),
-      ])
-    );
-  });
-});

package/tests/core/nocturnal-snapshot-contract.test.ts

@@ -1,121 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { validateNocturnalSnapshotIngress } from '../../src/core/nocturnal-snapshot-contract.js';
-
-describe('validateNocturnalSnapshotIngress', () => {
-  it('accepts a fully shaped runtime snapshot', () => {
-    const result = validateNocturnalSnapshotIngress({
-      sessionId: 'session-1',
-      startedAt: '2026-04-10T00:00:00.000Z',
-      updatedAt: '2026-04-10T00:01:00.000Z',
-      assistantTurns: [],
-      userTurns: [],
-      toolCalls: [],
-      painEvents: [],
-      gateBlocks: [],
-      stats: {
-        totalAssistantTurns: 1,
-        totalToolCalls: 2,
-        totalPainEvents: 0,
-        totalGateBlocks: 0,
-        failureCount: 0,
-      },
-    });
-
-    expect(result.status).toBe('valid');
-    expect(result.snapshot?.sessionId).toBe('session-1');
-  });
-
-  it('rejects reduced pseudo-snapshots that omit canonical fields', () => {
-    const result = validateNocturnalSnapshotIngress({
-      sessionId: 'session-1',
-      sessionStart: '2026-04-10T00:00:00.000Z',
-      stats: {
-        totalAssistantTurns: 1,
-        totalToolCalls: 2,
-        totalPainEvents: 0,
-        totalGateBlocks: 0,
-        failureCount: 0,
-      },
-      recentPain: [],
-    });
-
-    expect(result.status).toBe('invalid');
-    expect(result.reasons).toContain('snapshot.startedAt must be a non-empty string');
-    expect(result.reasons).toContain('snapshot.assistantTurns must be an array');
-  });
-
-  it('rejects fallback snapshots with no pain signal', () => {
-    const result = validateNocturnalSnapshotIngress({
-      sessionId: 'session-1',
-      startedAt: '2026-04-10T00:00:00.000Z',
-      updatedAt: '2026-04-10T00:00:00.000Z',
-      assistantTurns: [],
-      userTurns: [],
-      toolCalls: [],
-      painEvents: [],
-      gateBlocks: [],
-      stats: {
-        totalAssistantTurns: 0,
-        totalToolCalls: 0,
-        totalPainEvents: 0,
-        totalGateBlocks: 0,
-        failureCount: 0,
-      },
-      _dataSource: 'pain_context_fallback',
-    });
-
-    expect(result.status).toBe('invalid');
-    expect(result.reasons).toContain('fallback snapshot must contain at least one pain signal');
-  });
-
-  // #246: null stats fields should now be rejected (they used to be accepted for fallback)
-  it('rejects null values in stats fields', () => {
-    const result = validateNocturnalSnapshotIngress({
-      sessionId: 'session-1',
-      startedAt: '2026-04-10T00:00:00.000Z',
-      updatedAt: '2026-04-10T00:00:00.000Z',
-      assistantTurns: [],
-      userTurns: [],
-      toolCalls: [],
-      painEvents: [{ source: 'test', score: 5, severity: 'high', reason: 'test', createdAt: '2026-04-10T00:00:00.000Z' }],
-      gateBlocks: [],
-      stats: {
-        totalAssistantTurns: null,
-        totalToolCalls: null,
-        totalPainEvents: 1,
-        totalGateBlocks: null,
-        failureCount: null,
-      },
-      _dataSource: 'pain_context_fallback',
-    });
-
-    expect(result.status).toBe('invalid');
-    expect(result.reasons).toContain('snapshot.stats.totalAssistantTurns must be a finite number');
-    expect(result.reasons).toContain('snapshot.stats.totalToolCalls must be a finite number');
-    expect(result.reasons).toContain('snapshot.stats.totalGateBlocks must be a finite number');
-    expect(result.reasons).toContain('snapshot.stats.failureCount must be a finite number');
-  });
-
-  it('accepts fallback snapshot with valid stats and pain signal', () => {
-    const result = validateNocturnalSnapshotIngress({
-      sessionId: 'session-1',
-      startedAt: '2026-04-10T00:00:00.000Z',
-      updatedAt: '2026-04-10T00:00:00.000Z',
-      assistantTurns: [],
-      userTurns: [],
-      toolCalls: [],
-      painEvents: [{ source: 'test', score: 5, severity: 'high', reason: 'test', createdAt: '2026-04-10T00:00:00.000Z' }],
-      gateBlocks: [],
-      stats: {
-        totalAssistantTurns: 0,
-        totalToolCalls: 0,
-        totalPainEvents: 1,
-        totalGateBlocks: 0,
-        failureCount: 0,
-      },
-      _dataSource: 'pain_context_fallback',
-    });
-
-    expect(result.status).toBe('valid');
-  });
-});