principles-disciple 1.72.0 → 1.73.0

package/tests/core/nocturnal-trajectory-extractor.test.ts

@@ -1,634 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import {
-  NocturnalTrajectoryExtractor,
-  listNocturnalCandidateSessions,
-  getNocturnalSessionSnapshot,
-  computeThinkingModelActivation,
-  computePlanningRatio,
-  computeThinkingModelDelta,
-  computePlanningRatioGain,
-  type NocturnalSessionSnapshot,
-  type NocturnalSessionSummary,
-} from '../../src/core/nocturnal-trajectory-extractor.js';
-import { TrajectoryDatabase } from '../../src/core/trajectory.js';
-
-describe('NocturnalTrajectoryExtractor', () => {
-  let tmpDir: string;
-  let trajectory: TrajectoryDatabase;
-  let extractor: NocturnalTrajectoryExtractor;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-nocturnal-extractor-test-'));
-    trajectory = new TrajectoryDatabase({ workspaceDir: tmpDir });
-    extractor = new NocturnalTrajectoryExtractor(trajectory);
-  });
-
-  afterEach(() => {
-    trajectory.dispose();
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  // -------------------------------------------------------------------------
-  // Helper: Seed trajectory data
-  // -------------------------------------------------------------------------
-
-  function seedSession(sessionId: string, startedAt?: string): void {
-    trajectory.recordSession({ sessionId, startedAt: startedAt ?? new Date().toISOString() });
-  }
-
-  function seedAssistantTurn(
-    sessionId: string,
-    sanitizedText: string,
-    rawText: string,
-    model = 'gpt-4'
-  ): void {
-    trajectory.recordAssistantTurn({
-      sessionId,
-      runId: 'run-1',
-      provider: 'openai',
-      model,
-      rawText,
-      sanitizedText,
-      usageJson: {},
-      empathySignalJson: {},
-    });
-  }
-
-  function seedToolCall(
-    sessionId: string,
-    toolName: string,
-    outcome: 'success' | 'failure' | 'blocked',
-    errorMessage?: string
-  ): void {
-    trajectory.recordToolCall({
-      sessionId,
-      toolName,
-      outcome,
-      errorMessage: errorMessage ?? null,
-    });
-  }
-
-  function seedPainEvent(
-    sessionId: string,
-    score: number,
-    source: string,
-    reason?: string
-  ): void {
-    trajectory.recordPainEvent({
-      sessionId,
-      source,
-      score,
-      reason: reason ?? null,
-    });
-  }
-
-  function seedGateBlock(
-    sessionId: string,
-    toolName: string,
-    reason: string
-  ): void {
-    trajectory.recordGateBlock({
-      sessionId,
-      toolName,
-      reason,
-    });
-  }
-
-  // -------------------------------------------------------------------------
-  // listRecentNocturnalCandidateSessions
-  // -------------------------------------------------------------------------
-
-  describe('listRecentNocturnalCandidateSessions', () => {
-    it('returns empty array when no sessions exist', () => {
-      const result = extractor.listRecentNocturnalCandidateSessions();
-      expect(result).toEqual([]);
-    });
-
-    it('returns sessions with tool calls above threshold', () => {
-      seedSession('session-1');
-      seedSession('session-2');
-      seedToolCall('session-1', 'read_file', 'success');
-      seedToolCall('session-2', 'read_file', 'success');
-
-      const result = extractor.listRecentNocturnalCandidateSessions();
-      expect(result).toHaveLength(2);
-      expect(result.map((s) => s.sessionId).sort()).toEqual(['session-1', 'session-2']);
-    });
-
-    it('filters out sessions below minToolCalls threshold', () => {
-      seedSession('session-1');
-      seedSession('session-2');
-      seedToolCall('session-1', 'read_file', 'success');
-      // session-2 has no tool calls
-
-      const result = extractor.listRecentNocturnalCandidateSessions({ minToolCalls: 1 });
-      expect(result).toHaveLength(1);
-      expect(result[0].sessionId).toBe('session-1');
-    });
-
-    it('counts failures correctly', () => {
-      seedSession('session-1');
-      seedToolCall('session-1', 'bash', 'failure', 'command failed');
-      seedToolCall('session-1', 'read_file', 'success');
-
-      const result = extractor.listRecentNocturnalCandidateSessions();
-      expect(result[0].failureCount).toBe(1);
-      expect(result[0].toolCallCount).toBe(2);
-    });
-
-    it('counts pain events and gate blocks', () => {
-      seedSession('session-1');
-      seedToolCall('session-1', 'bash', 'failure', 'command failed');
-      seedPainEvent('session-1', 50, 'tool_failure', 'bash failed');
-      seedGateBlock('session-1', 'delete_file', 'risky operation');
-
-      const result = extractor.listRecentNocturnalCandidateSessions();
-      expect(result[0].painEventCount).toBe(1);
-      expect(result[0].gateBlockCount).toBe(1);
-    });
-
-    it('respects limit option', () => {
-      for (let i = 0; i < 10; i++) {
-        seedSession(`session-${i}`);
-        seedToolCall(`session-${i}`, 'read_file', 'success');
-      }
-
-      const result = extractor.listRecentNocturnalCandidateSessions({ limit: 5 });
-      expect(result).toHaveLength(5);
-    });
-
-    it('returns sessions ordered by most recently updated', () => {
-      const old = new Date(Date.now() - 86400000).toISOString(); // 1 day ago
-      const recent = new Date().toISOString();
-      seedSession('session-old', old);
-      seedSession('session-recent', recent);
-      seedToolCall('session-old', 'read_file', 'success');
-      seedToolCall('session-recent', 'read_file', 'success');
-
-      const result = extractor.listRecentNocturnalCandidateSessions();
-      expect(result[0].sessionId).toBe('session-recent');
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // getNocturnalSessionSnapshot
-  // -------------------------------------------------------------------------
-
-  describe('getNocturnalSessionSnapshot', () => {
-    it('returns null for non-existent session', () => {
-      const result = extractor.getNocturnalSessionSnapshot('does-not-exist');
-      expect(result).toBeNull();
-    });
-
-    it('returns full snapshot with all turn types', () => {
-      seedSession('session-1');
-      seedAssistantTurn('session-1', 'I will read the file first.', 'User asked me to read the file.');
-      seedAssistantTurn(
-        'session-1',
-        'I am editing the file now.',
-        'User asked me to edit the file.'
-      );
-      trajectory.recordUserTurn({
-        sessionId: 'session-1',
-        turnIndex: 0,
-        rawText: 'Good, keep going',
-        correctionDetected: false,
-      });
-      trajectory.recordUserTurn({
-        sessionId: 'session-1',
-        turnIndex: 1,
-        rawText: 'No, that is wrong!',
-        correctionDetected: true,
-        correctionCue: 'explicit correction',
-      });
-      seedToolCall('session-1', 'read_file', 'success');
-      seedToolCall('session-1', 'edit_file', 'success');
-      seedPainEvent('session-1', 40, 'tool_failure', 'minor issue');
-      seedGateBlock('session-1', 'delete_file', 'risky');
-
-      const snapshot = extractor.getNocturnalSessionSnapshot('session-1');
-
-      expect(snapshot).not.toBeNull();
-      snapshot!;
-
-      expect(snapshot!.sessionId).toBe('session-1');
-      expect(snapshot!.assistantTurns).toHaveLength(2);
-      expect(snapshot!.userTurns).toHaveLength(2);
-      expect(snapshot!.toolCalls).toHaveLength(2);
-      expect(snapshot!.painEvents).toHaveLength(1);
-      expect(snapshot!.gateBlocks).toHaveLength(1);
-      expect(snapshot!.stats.totalAssistantTurns).toBe(2);
-      expect(snapshot!.stats.totalToolCalls).toBe(2);
-      expect(snapshot!.stats.failureCount).toBe(0);
-    });
-
-    it('sanitizedText only — never raw_text', () => {
-      seedSession('session-1');
-      seedAssistantTurn(
-        'session-1',
-        'I will fix the bug now.',
-        'User private API key was exposed in the file content. Fix the bug now please!'
-      );
-
-      const snapshot = extractor.getNocturnalSessionSnapshot('session-1');
-
-      expect(snapshot).not.toBeNull();
-      // Sanitized text should not contain the private content
-      expect(snapshot!.assistantTurns[0].sanitizedText).toBe('I will fix the bug now.');
-      // Ensure raw text is NOT in the snapshot
-      expect(JSON.stringify(snapshot)).not.toContain('API key');
-      expect(JSON.stringify(snapshot)).not.toContain('exposed');
-    });
-
-    it('user turns expose only correctionCue — never raw user text', () => {
-      seedSession('session-1');
-      trajectory.recordUserTurn({
-        sessionId: 'session-1',
-        turnIndex: 0,
-        rawText: 'DELETE ALL THE FILES immediately!',
-        correctionDetected: true,
-        correctionCue: 'User said "No, that is wrong!"',
-      });
-
-      const snapshot = extractor.getNocturnalSessionSnapshot('session-1');
-
-      expect(snapshot).not.toBeNull();
-      // Only correctionCue should be present
-      expect(snapshot!.userTurns[0].correctionCue).toBe('User said "No, that is wrong!"');
-      // rawText should NOT be in the snapshot
-      expect(JSON.stringify(snapshot)).not.toContain('DELETE ALL THE FILES');
-    });
-
-    it('tool calls include outcome and error info but not params', () => {
-      seedSession('session-1');
-      seedToolCall('session-1', 'bash', 'failure', 'rm: cannot delete /protected: Permission denied');
-
-      const snapshot = extractor.getNocturnalSessionSnapshot('session-1');
-
-      expect(snapshot).not.toBeNull();
-      expect(snapshot!.toolCalls[0].toolName).toBe('bash');
-      expect(snapshot!.toolCalls[0].outcome).toBe('failure');
-      expect(snapshot!.toolCalls[0].errorMessage).toBe('rm: cannot delete /protected: Permission denied');
-      // params should not be included (we don't seed params in seedToolCall)
-      expect(snapshot!.toolCalls[0]).not.toHaveProperty('paramsJson');
-    });
-
-    it('pain events include score and reason only', () => {
-      seedSession('session-1');
-      seedPainEvent('session-1', 65, 'gate_block', 'Agent attempted risky delete without plan');
-
-      const snapshot = extractor.getNocturnalSessionSnapshot('session-1');
-
-      expect(snapshot).not.toBeNull();
-      expect(snapshot!.painEvents[0].score).toBe(65);
-      expect(snapshot!.painEvents[0].reason).toBe('Agent attempted risky delete without plan');
-      expect(snapshot!.painEvents[0].source).toBe('gate_block');
-    });
-
-    it('gate blocks include tool and reason only', () => {
-      seedSession('session-1');
-      seedGateBlock('session-1', 'delete_file', 'No PLAN.md found for risky path');
-
-      const snapshot = extractor.getNocturnalSessionSnapshot('session-1');
-
-      expect(snapshot).not.toBeNull();
-      expect(snapshot!.gateBlocks[0].toolName).toBe('delete_file');
-      expect(snapshot!.gateBlocks[0].reason).toBe('No PLAN.md found for risky path');
-    });
-
-    it('snapshot stats compute failureCount correctly', () => {
-      seedSession('session-1');
-      seedToolCall('session-1', 'bash', 'failure', 'error 1');
-      seedToolCall('session-1', 'read_file', 'success');
-      seedToolCall('session-1', 'bash', 'failure', 'error 2');
-      seedToolCall('session-1', 'edit_file', 'success');
-
-      const snapshot = extractor.getNocturnalSessionSnapshot('session-1');
-
-      expect(snapshot).not.toBeNull();
-      expect(snapshot!.stats.failureCount).toBe(2);
-      expect(snapshot!.stats.totalToolCalls).toBe(4);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Convenience wrappers
-  // -------------------------------------------------------------------------
-
-  describe('module-level convenience functions', () => {
-    it('listNocturnalCandidateSessions works as a standalone function', () => {
-      seedSession('session-1');
-      seedToolCall('session-1', 'read_file', 'success');
-
-      const result = listNocturnalCandidateSessions(trajectory);
-      expect(result).toHaveLength(1);
-    });
-
-    it('getNocturnalSessionSnapshot works as a standalone function', () => {
-      seedSession('session-1');
-      seedAssistantTurn('session-1', 'Hello', 'Hello');
-
-      const result = getNocturnalSessionSnapshot(trajectory, 'session-1');
-      expect(result).not.toBeNull();
-      expect(result!.sessionId).toBe('session-1');
-    });
-
-    it('getNocturnalSessionSnapshot returns null for non-existent session', () => {
-      const result = getNocturnalSessionSnapshot(trajectory, 'non-existent');
-      expect(result).toBeNull();
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Security / sanitization guarantees
-  // -------------------------------------------------------------------------
-
-  describe('sanitization guarantees', () => {
-    it('snapshot JSON stringified output does not contain raw_text field names', () => {
-      seedSession('session-1');
-      seedAssistantTurn(
-        'session-1',
-        'Fixed the issue.',
-        'SECRET_API_KEY=sk-12345678 user private data here'
-      );
-
-      const snapshot = extractor.getNocturnalSessionSnapshot('session-1');
-      const jsonStr = JSON.stringify(snapshot);
-
-      // Verify sanitized text is present
-      expect(jsonStr).toContain('Fixed the issue.');
-      // Verify raw text content is NOT present
-      expect(jsonStr).not.toContain('SECRET_API_KEY');
-      expect(jsonStr).not.toContain('sk-12345678');
-      expect(jsonStr).not.toContain('user private data');
-      // Verify field name 'rawText' is NOT in the output
-      expect(jsonStr).not.toContain('"rawText"');
-    });
-
-    it('session with very long raw text only stores sanitized version', () => {
-      const longContent = 'A'.repeat(10000);
-      seedSession('session-1');
-      seedAssistantTurn('session-1', 'Summary: large file processed', longContent);
-
-      const snapshot = extractor.getNocturnalSessionSnapshot('session-1');
-      expect(snapshot).not.toBeNull();
-      // The sanitized text should be short
-      expect(snapshot!.assistantTurns[0].sanitizedText).toBe('Summary: large file processed');
-      // The JSON should not contain the long raw content
-      expect(JSON.stringify(snapshot)).not.toContain(longContent);
-    });
-  });
-});
-
-describe('Reflection Quality Metrics', () => {
-  // -------------------------------------------------------------------------
-  // computeThinkingModelActivation
-  // -------------------------------------------------------------------------
-
-  describe('computeThinkingModelActivation', () => {
-    it('returns 0 for empty text', () => {
-      expect(computeThinkingModelActivation('')).toBe(0);
-      expect(computeThinkingModelActivation('   ')).toBe(0);
-    });
-
-    it('returns 0 for text with no thinking model patterns', () => {
-      const text = 'Just do it now without any planning';
-      const activation = computeThinkingModelActivation(text);
-      expect(activation).toBeGreaterThanOrEqual(0);
-      expect(activation).toBeLessThanOrEqual(1);
-    });
-
-    it('returns positive value for text with thinking model patterns', () => {
-      // T-01 pattern: "let me first understand the structure"
-      const text = 'Let me first understand the structure before editing anything';
-      const activation = computeThinkingModelActivation(text);
-      expect(activation).toBeGreaterThan(0);
-      expect(activation).toBeLessThanOrEqual(1);
-    });
-
-    it('returns value rounded to 2 decimal places', () => {
-      const text = 'Based on the evidence and logs, let me check the actual source code';
-      const activation = computeThinkingModelActivation(text);
-      // Should be rounded to 2 decimal places
-      expect(activation * 100).toBe(Math.round(activation * 100));
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // computePlanningRatio
-  // -------------------------------------------------------------------------
-
-  describe('computePlanningRatio', () => {
-    it('returns 0 for snapshot with no tool calls', () => {
-      const snapshot: NocturnalSessionSnapshot = {
-        sessionId: 'test',
-        startedAt: '',
-        principleId: '',
-        assistantTurns: [],
-        userTurns: [],
-        toolCalls: [],
-        painEvents: [],
-        gateBlocks: [],
-        stats: { failureCount: 0, totalPainEvents: 0, totalGateBlocks: 0 },
-      };
-      expect(computePlanningRatio(snapshot)).toBe(0);
-    });
-
-    it('returns 0 for snapshot with writes but no preceding reads', () => {
-      const snapshot: NocturnalSessionSnapshot = {
-        sessionId: 'test',
-        startedAt: '',
-        principleId: '',
-        assistantTurns: [],
-        userTurns: [],
-        toolCalls: [
-          { toolName: 'edit', outcome: 'success', filePath: null, durationMs: 100, exitCode: null, errorType: null, errorMessage: null, createdAt: '' },
-          { toolName: 'write', outcome: 'success', filePath: null, durationMs: 100, exitCode: null, errorType: null, errorMessage: null, createdAt: '' },
-        ],
-        painEvents: [],
-        gateBlocks: [],
-        stats: { failureCount: 0, totalPainEvents: 0, totalGateBlocks: 0 },
-      };
-      expect(computePlanningRatio(snapshot)).toBe(0);
-    });
-
-    it('returns 1 for snapshot where all writes are preceded by reads', () => {
-      const snapshot: NocturnalSessionSnapshot = {
-        sessionId: 'test',
-        startedAt: '',
-        principleId: '',
-        assistantTurns: [],
-        userTurns: [],
-        toolCalls: [
-          { toolName: 'read', outcome: 'success', filePath: null, durationMs: 100, exitCode: null, errorType: null, errorMessage: null, createdAt: '' },
-          { toolName: 'edit', outcome: 'success', filePath: null, durationMs: 100, exitCode: null, errorType: null, errorMessage: null, createdAt: '' },
-        ],
-        painEvents: [],
-        gateBlocks: [],
-        stats: { failureCount: 0, totalPainEvents: 0, totalGateBlocks: 0 },
-      };
-      expect(computePlanningRatio(snapshot)).toBe(1);
-    });
-
-    it('returns 0.5 when half of writes are preceded by reads', () => {
-      const snapshot: NocturnalSessionSnapshot = {
-        sessionId: 'test',
-        startedAt: '',
-        principleId: '',
-        assistantTurns: [],
-        userTurns: [],
-        toolCalls: [
-          { toolName: 'read', outcome: 'success', filePath: null, durationMs: 100, exitCode: null, errorType: null, errorMessage: null, createdAt: '' },
-          { toolName: 'edit', outcome: 'success', filePath: null, durationMs: 100, exitCode: null, errorType: null, errorMessage: null, createdAt: '' },
-          { toolName: 'edit', outcome: 'success', filePath: null, durationMs: 100, exitCode: null, errorType: null, errorMessage: null, createdAt: '' },
-        ],
-        painEvents: [],
-        gateBlocks: [],
-        stats: { failureCount: 0, totalPainEvents: 0, totalGateBlocks: 0 },
-      };
-      expect(computePlanningRatio(snapshot)).toBe(0.5);
-    });
-
-    it('returns value rounded to 2 decimal places', () => {
-      const snapshot: NocturnalSessionSnapshot = {
-        sessionId: 'test',
-        startedAt: '',
-        principleId: '',
-        assistantTurns: [],
-        userTurns: [],
-        toolCalls: [
-          { toolName: 'read', outcome: 'success', filePath: null, durationMs: 100, exitCode: null, errorType: null, errorMessage: null, createdAt: '' },
-          { toolName: 'read', outcome: 'success', filePath: null, durationMs: 100, exitCode: null, errorType: null, errorMessage: null, createdAt: '' },
-          { toolName: 'edit', outcome: 'success', filePath: null, durationMs: 100, exitCode: null, errorType: null, errorMessage: null, createdAt: '' },
-        ],
-        painEvents: [],
-        gateBlocks: [],
-        stats: { failureCount: 0, totalPainEvents: 0, totalGateBlocks: 0 },
-      };
-      expect(computePlanningRatio(snapshot)).toBe(1);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // computeThinkingModelDelta
-  // -------------------------------------------------------------------------
-
-  describe('computeThinkingModelDelta', () => {
-    it('returns 0 for identical texts', () => {
-      const text = 'Just do it now';
-      expect(computeThinkingModelDelta(text, text)).toBe(0);
-    });
-
-    it('returns positive delta when improved has more thinking models', () => {
-      const original = 'Edit the file now';
-      const improved = 'Let me first understand the structure before editing anything';
-      const delta = computeThinkingModelDelta(original, improved);
-      expect(delta).toBeGreaterThan(0);
-    });
-
-    it('returns negative delta when improved has fewer thinking models', () => {
-      const original = 'Let me first understand the structure before editing anything';
-      const improved = 'Edit the file now';
-      const delta = computeThinkingModelDelta(original, improved);
-      expect(delta).toBeLessThan(0);
-    });
-
-    it('returns delta rounded to 2 decimal places', () => {
-      const original = 'Edit the file';
-      const improved = 'Based on the evidence, let me check the actual source and verify before editing';
-      const delta = computeThinkingModelDelta(original, improved);
-      expect(delta * 100).toBe(Math.round(delta * 100));
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // computePlanningRatioGain
-  // -------------------------------------------------------------------------
-
-  describe('computePlanningRatioGain', () => {
-    it('returns 0 for identical snapshots', () => {
-      const snapshot: NocturnalSessionSnapshot = {
-        sessionId: 'test',
-        startedAt: '',
-        principleId: '',
-        assistantTurns: [],
-        userTurns: [],
-        toolCalls: [
-          { toolName: 'read', outcome: 'success', filePath: null, durationMs: 100, exitCode: null, errorType: null, errorMessage: null, createdAt: '' },
-          { toolName: 'edit', outcome: 'success', filePath: null, durationMs: 100, exitCode: null, errorType: null, errorMessage: null, createdAt: '' },
-        ],
-        painEvents: [],
-        gateBlocks: [],
-        stats: { failureCount: 0, totalPainEvents: 0, totalGateBlocks: 0 },
-      };
-      expect(computePlanningRatioGain(snapshot, snapshot)).toBe(0);
-    });
-
-    it('returns positive gain when improved has better planning ratio', () => {
-      const original: NocturnalSessionSnapshot = {
-        sessionId: 'test',
-        startedAt: '',
-        principleId: '',
-        assistantTurns: [],
-        userTurns: [],
-        toolCalls: [
-          { toolName: 'edit', outcome: 'success', filePath: null, durationMs: 100, exitCode: null, errorType: null, errorMessage: null, createdAt: '' },
-        ],
-        painEvents: [],
-        gateBlocks: [],
-        stats: { failureCount: 0, totalPainEvents: 0, totalGateBlocks: 0 },
-      };
-      const improved: NocturnalSessionSnapshot = {
-        sessionId: 'test',
-        startedAt: '',
-        principleId: '',
-        assistantTurns: [],
-        userTurns: [],
-        toolCalls: [
-          { toolName: 'read', outcome: 'success', filePath: null, durationMs: 100, exitCode: null, errorType: null, errorMessage: null, createdAt: '' },
-          { toolName: 'edit', outcome: 'success', filePath: null, durationMs: 100, exitCode: null, errorType: null, errorMessage: null, createdAt: '' },
-        ],
-        painEvents: [],
-        gateBlocks: [],
-        stats: { failureCount: 0, totalPainEvents: 0, totalGateBlocks: 0 },
-      };
-      const gain = computePlanningRatioGain(original, improved);
-      expect(gain).toBeGreaterThan(0);
-    });
-
-    it('returns negative gain when improved has worse planning ratio', () => {
-      const original: NocturnalSessionSnapshot = {
-        sessionId: 'test',
-        startedAt: '',
-        principleId: '',
-        assistantTurns: [],
-        userTurns: [],
-        toolCalls: [
-          { toolName: 'read', outcome: 'success', filePath: null, durationMs: 100, exitCode: null, errorType: null, errorMessage: null, createdAt: '' },
-          { toolName: 'edit', outcome: 'success', filePath: null, durationMs: 100, exitCode: null, errorType: null, errorMessage: null, createdAt: '' },
-        ],
-        painEvents: [],
-        gateBlocks: [],
-        stats: { failureCount: 0, totalPainEvents: 0, totalGateBlocks: 0 },
-      };
-      const improved: NocturnalSessionSnapshot = {
-        sessionId: 'test',
-        startedAt: '',
-        principleId: '',
-        assistantTurns: [],
-        userTurns: [],
-        toolCalls: [
-          { toolName: 'edit', outcome: 'success', filePath: null, durationMs: 100, exitCode: null, errorType: null, errorMessage: null, createdAt: '' },
-        ],
-        painEvents: [],
-        gateBlocks: [],
-        stats: { failureCount: 0, totalPainEvents: 0, totalGateBlocks: 0 },
-      };
-      const gain = computePlanningRatioGain(original, improved);
-      expect(gain).toBeLessThan(0);
-    });
-  });
-});