principles-disciple 1.71.0 → 1.73.0

package/tests/service/nocturnal-target-selector.test.ts

@@ -1,615 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import {
-  NocturnalTargetSelector,
-  selectNocturnalTarget,
-  type NocturnalSelectionResult,
-  type SkipReason,
-} from '../../src/service/nocturnal-target-selector.js';
-import { NocturnalTrajectoryExtractor } from '../../src/core/nocturnal-trajectory-extractor.js';
-import { TrajectoryDatabase } from '../../src/core/trajectory.js';
-import {
-  saveStore,
-  createDefaultPrincipleState,
-  PRINCIPLE_TRAINING_FILE,
-} from '../../src/core/principle-training-state.js';
-import {
-  initPersistence,
-  trackToolRead,
-  clearSession,
-  getSession,
-} from '../../src/core/session-tracker.js';
-import { safeRmDir } from '../test-utils.js';
-import {
-  NOCTURNAL_RUNTIME_FILE,
-  DEFAULT_IDLE_THRESHOLD_MS,
-} from '../../src/service/nocturnal-runtime.js';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function seedSession(
-  trajectory: TrajectoryDatabase,
-  sessionId: string,
-  startedAt?: string
-): void {
-  trajectory.recordSession({ sessionId, startedAt: startedAt ?? new Date().toISOString() });
-}
-
-function seedAssistantTurn(
-  trajectory: TrajectoryDatabase,
-  sessionId: string,
-  sanitizedText: string,
-  rawText: string
-): void {
-  trajectory.recordAssistantTurn({
-    sessionId,
-    runId: 'run-1',
-    provider: 'openai',
-    model: 'gpt-4',
-    rawText,
-    sanitizedText,
-    usageJson: {},
-    empathySignalJson: {},
-  });
-}
-
-function seedToolCall(
-  trajectory: TrajectoryDatabase,
-  sessionId: string,
-  toolName: string,
-  outcome: 'success' | 'failure' | 'blocked',
-  errorMessage?: string,
-  filePath?: string
-): void {
-  trajectory.recordToolCall({
-    sessionId,
-    toolName,
-    outcome,
-    errorMessage: errorMessage ?? null,
-    paramsJson: filePath ? { filePath } : undefined,
-  });
-}
-
-function seedPainEvent(
-  trajectory: TrajectoryDatabase,
-  sessionId: string,
-  score: number,
-  source: string
-): void {
-  trajectory.recordPainEvent({ sessionId, source, score });
-}
-
-function seedGateBlock(
-  trajectory: TrajectoryDatabase,
-  sessionId: string,
-  toolName: string,
-  reason: string
-): void {
-  trajectory.recordGateBlock({ sessionId, toolName, reason });
-}
-
-function seedTrainingState(
-  stateDir: string,
-  principleId: string,
-  overrides: Partial<ReturnType<typeof createDefaultPrincipleState>> = {}
-): void {
-  const store = { [principleId]: { ...createDefaultPrincipleState(principleId), ...overrides } };
-  saveStore(stateDir, store);
-}
-
-function setRuntimeCooldown(
-  stateDir: string,
-  cooldownUntil: string
-): void {
-  const runtimePath = path.join(stateDir, NOCTURNAL_RUNTIME_FILE);
-  fs.mkdirSync(stateDir, { recursive: true });
-  // Set per-principle cooldown only (not global cooldown)
-  fs.writeFileSync(
-    runtimePath,
-    JSON.stringify({ principleCooldowns: { 'T-01': cooldownUntil }, recentRunTimestamps: [] }),
-    'utf-8'
-  );
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('NocturnalTargetSelector', () => {
-  let tempDir: string;
-  let workspaceDir: string;
-  let stateDir: string;
-  let trajectory: TrajectoryDatabase;
-  let extractor: NocturnalTrajectoryExtractor;
-
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date('2026-03-27T12:00:00.000Z'));
-
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-target-sel-'));
-    workspaceDir = path.join(tempDir, 'workspace');
-    stateDir = path.join(tempDir, 'state');
-    fs.mkdirSync(workspaceDir);
-    fs.mkdirSync(stateDir, { recursive: true });
-
-    // Initialize session tracker persistence
-    initPersistence(stateDir);
-
-    // Create trajectory and extractor
-    trajectory = new TrajectoryDatabase({ workspaceDir });
-    extractor = new NocturnalTrajectoryExtractor(trajectory);
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.clearAllMocks();
-    trajectory.dispose();
-    clearSession('session-violating');
-    clearSession('session-clean');
-    clearSession('session-active-workspace-idle');
-    safeRmDir(tempDir);
-  });
-
-  // -------------------------------------------------------------------------
-  // Idle check integration
-  // -------------------------------------------------------------------------
-
-  describe('workspace idle check', () => {
-    it('returns skip with workspace_not_idle when session is active', () => {
-      // Create a recently active session
-      trackToolRead('session-active', 'src/main.ts', workspaceDir);
-
-      const selector = new NocturnalTargetSelector(workspaceDir, stateDir, extractor);
-      const result = selector.select();
-
-      expect(result.decision).toBe('skip');
-      expect(result.skipReason).toBe('workspace_not_idle');
-      expect(result.diagnostics.idleCheckPassed).toBe(false);
-    });
-
-    it('passes idle check when no sessions exist', () => {
-      const selector = new NocturnalTargetSelector(workspaceDir, stateDir, extractor);
-      const result = selector.select();
-
-      // Will fail on cooldown or no_evaluable_principles next, not idle
-      expect(result.diagnostics.idleCheckPassed).toBe(true);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Evaluable principles filtering
-  // -------------------------------------------------------------------------
-
-  describe('evaluable principles filtering', () => {
-    it('returns no_evaluable_principles when no training state exists', () => {
-      const selector = new NocturnalTargetSelector(workspaceDir, stateDir, extractor);
-      const result = selector.select();
-
-      expect(result.decision).toBe('skip');
-      expect(result.skipReason).toBe('no_evaluable_principles');
-      expect(result.diagnostics.totalEvaluablePrinciples).toBe(0);
-    });
-
-    it('excludes manual_only principles from selection', () => {
-      seedTrainingState(stateDir, 'T-01', {
-        evaluability: 'manual_only',
-        internalizationStatus: 'prompt_only',
-        applicableOpportunityCount: 5,
-        observedViolationCount: 2,
-        complianceRate: 0.6,
-      });
-
-      const selector = new NocturnalTargetSelector(workspaceDir, stateDir, extractor);
-      const result = selector.select();
-
-      expect(result.decision).toBe('skip');
-      expect(result.skipReason).toBe('no_evaluable_principles');
-      expect(result.diagnostics.totalEvaluablePrinciples).toBe(0);
-    });
-
-    it('includes deterministic evaluability principles', () => {
-      seedTrainingState(stateDir, 'T-01', {
-        evaluability: 'deterministic',
-        internalizationStatus: 'needs_training',
-        applicableOpportunityCount: 5,
-        observedViolationCount: 2,
-        complianceRate: 0.6,
-      });
-
-      seedSession(trajectory, 'session-violating');
-      seedToolCall(trajectory, 'session-violating', 'edit_file', 'success');
-      seedToolCall(trajectory, 'session-violating', 'bash', 'failure', 'error');
-
-      const selector = new NocturnalTargetSelector(workspaceDir, stateDir, extractor);
-      const result = selector.select();
-
-      expect(result.decision).toBe('skip'); // Will fail on no_violating_sessions (T-01 not violated)
-      expect(result.diagnostics.totalEvaluablePrinciples).toBe(1);
-      expect(result.diagnostics.passedPrinciples).toContain('T-01');
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Cooldown filtering
-  // -------------------------------------------------------------------------
-
-  describe('cooldown filtering', () => {
-    it('returns all_targets_in_cooldown when all candidates are in cooldown', () => {
-      // Set cooldown for T-01
-      const cooldownUntil = new Date(Date.now() + 3600000).toISOString(); // 1 hour from now
-      setRuntimeCooldown(stateDir, cooldownUntil);
-
-      seedTrainingState(stateDir, 'T-01', {
-        evaluability: 'deterministic',
-        internalizationStatus: 'needs_training',
-        applicableOpportunityCount: 5,
-        observedViolationCount: 2,
-        complianceRate: 0.6,
-      });
-
-      const selector = new NocturnalTargetSelector(workspaceDir, stateDir, extractor);
-      const result = selector.select();
-
-      expect(result.decision).toBe('skip');
-      expect(result.skipReason).toBe('all_targets_in_cooldown');
-      expect(result.diagnostics.filteredByCooldown).toBe(1);
-    });
-
-    it('penalizes cooldown principles in scoring', () => {
-      seedTrainingState(stateDir, 'T-01', {
-        evaluability: 'deterministic',
-        internalizationStatus: 'needs_training',
-        applicableOpportunityCount: 5,
-        observedViolationCount: 2,
-        complianceRate: 0.6,
-      });
-      seedTrainingState(stateDir, 'T-02', {
-        evaluability: 'weak_heuristic',
-        internalizationStatus: 'needs_training',
-        applicableOpportunityCount: 5,
-        observedViolationCount: 2,
-        complianceRate: 0.6,
-      });
-
-      // Set cooldown only for T-01
-      const cooldownUntil = new Date(Date.now() + 3600000).toISOString();
-      setRuntimeCooldown(stateDir, cooldownUntil);
-
-      seedSession(trajectory, 'session-violating');
-      seedToolCall(trajectory, 'session-violating', 'read_file', 'success');
-
-      const selector = new NocturnalTargetSelector(workspaceDir, stateDir, extractor);
-      const result = selector.select();
-
-      // T-01 is in cooldown, T-02 should be selected
-      expect(result.diagnostics.passedPrinciples).not.toContain('T-01');
-      expect(result.diagnostics.passedPrinciples).toContain('T-02');
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // No violating sessions
-  // -------------------------------------------------------------------------
-
-  describe('no violating sessions', () => {
-    it('returns no_violating_sessions when sessions exist but no violations for T-01', () => {
-      seedTrainingState(stateDir, 'T-01', {
-        evaluability: 'deterministic',
-        internalizationStatus: 'needs_training',
-        applicableOpportunityCount: 5,
-        observedViolationCount: 2,
-        complianceRate: 0.6,
-      });
-
-      seedSession(trajectory, 'session-clean');
-      seedToolCall(trajectory, 'session-clean', 'read_file', 'success');
-      seedToolCall(trajectory, 'session-clean', 'read_file', 'success');
-
-      const selector = new NocturnalTargetSelector(workspaceDir, stateDir, extractor);
-      const result = selector.select();
-
-      expect(result.decision).toBe('skip');
-      expect(result.skipReason).toBe('no_violating_sessions');
-      expect(result.diagnostics.violatingSessionCount).toBe(0);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Successful selection
-  // -------------------------------------------------------------------------
-
-  describe('successful selection', () => {
-    it('selects principle with violating session when conditions are met', () => {
-      // Use T-08 (Pain as Signal) which triggers when pain + failure followed by immediate continuation
-      seedTrainingState(stateDir, 'T-08', {
-        evaluability: 'deterministic',
-        internalizationStatus: 'needs_training',
-        applicableOpportunityCount: 5,
-        observedViolationCount: 2,
-        complianceRate: 0.6,
-      });
-
-      // T-08 violation: pain + failure, then immediate continued operation without read/reflect
-      // Sequence: grep (success) → bash (failure) → edit (continues without reflect)
-      seedSession(trajectory, 'session-violating');
-      seedToolCall(trajectory, 'session-violating', 'grep', 'success');
-      seedToolCall(trajectory, 'session-violating', 'bash', 'failure', 'command failed');
-      seedToolCall(trajectory, 'session-violating', 'edit_file', 'success'); // continues immediately (not read)
-      seedPainEvent(trajectory, 'session-violating', 50, 'tool_failure');
-
-      const selector = new NocturnalTargetSelector(workspaceDir, stateDir, extractor);
-      const result = selector.select();
-
-      expect(result.decision).toBe('selected');
-      expect(result.selectedPrincipleId).toBe('T-08');
-      expect(result.selectedSessionId).toBe('session-violating');
-      expect(result.diagnostics.idleCheckPassed).toBe(true);
-    });
-
-    it('records scoring breakdown in diagnostics', () => {
-      seedTrainingState(stateDir, 'T-01', {
-        evaluability: 'deterministic',
-        internalizationStatus: 'needs_training',
-        applicableOpportunityCount: 5,
-        observedViolationCount: 2,
-        complianceRate: 0.6,
-        generatedSampleCount: 0,
-        violationTrend: 1,
-      });
-
-      seedSession(trajectory, 'session-violating');
-      seedToolCall(trajectory, 'session-violating', 'edit_file', 'failure', 'error');
-
-      const selector = new NocturnalTargetSelector(workspaceDir, stateDir, extractor);
-      const result = selector.select();
-
-      expect(result.diagnostics.scoringBreakdown).toHaveProperty('T-01');
-      expect(typeof result.diagnostics.scoringBreakdown['T-01']).toBe('number');
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Quota and global cooldown
-  // -------------------------------------------------------------------------
-
-  describe('quota and global cooldown', () => {
-    it('returns quota_exhausted when max runs reached', () => {
-      seedTrainingState(stateDir, 'T-01', {
-        evaluability: 'deterministic',
-        internalizationStatus: 'needs_training',
-        applicableOpportunityCount: 5,
-        observedViolationCount: 2,
-        complianceRate: 0.6,
-      });
-
-      // Set quota to exhausted by having many recent run timestamps
-      const runtimePath = path.join(stateDir, NOCTURNAL_RUNTIME_FILE);
-      fs.mkdirSync(stateDir, { recursive: true });
-      const now = new Date().toISOString();
-      const recentTimestamps = Array(10).fill(now); // 10 runs, exceeding DEFAULT_MAX_RUNS_PER_WINDOW=3
-      fs.writeFileSync(
-        runtimePath,
-        JSON.stringify({ principleCooldowns: {}, recentRunTimestamps: recentTimestamps }),
-        'utf-8'
-      );
-
-      seedSession(trajectory, 'session-violating');
-      seedToolCall(trajectory, 'session-violating', 'bash', 'failure', 'error');
-
-      const selector = new NocturnalTargetSelector(workspaceDir, stateDir, extractor);
-      const result = selector.select();
-
-      expect(result.decision).toBe('skip');
-      expect(result.skipReason).toBe('quota_exhausted');
-      expect(result.diagnostics.quotaCheckPassed).toBe(false);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Convenience function
-  // -------------------------------------------------------------------------
-
-  describe('selectNocturnalTarget convenience function', () => {
-    it('works as a standalone function', () => {
-      seedTrainingState(stateDir, 'T-01', {
-        evaluability: 'deterministic',
-        internalizationStatus: 'needs_training',
-        applicableOpportunityCount: 5,
-        observedViolationCount: 2,
-        complianceRate: 0.6,
-      });
-
-      seedSession(trajectory, 'session-violating');
-      seedToolCall(trajectory, 'session-violating', 'edit_file', 'success');
-      seedToolCall(trajectory, 'session-violating', 'bash', 'failure', 'error');
-
-      const result = selectNocturnalTarget(workspaceDir, stateDir, extractor);
-
-      expect(result.decision).toBe('skip'); // Will fail on no_violating_sessions
-      expect(result.diagnostics.totalEvaluablePrinciples).toBe(1);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Skip reason taxonomy
-  // -------------------------------------------------------------------------
-
-  describe('skip reason taxonomy', () => {
-    it('no_evaluable_principles — when no training state exists', () => {
-      // No seed needed - no evaluable principles
-      const selector = new NocturnalTargetSelector(workspaceDir, stateDir, extractor);
-      const result = selector.select();
-
-      expect(result.decision).toBe('skip');
-      expect(result.skipReason).toBe('no_evaluable_principles');
-    });
-
-    it('workspace_not_idle — when session is active', () => {
-      // Create a recently active session
-      trackToolRead('session-active-workspace-idle', 'src/main.ts', workspaceDir);
-
-      const selector = new NocturnalTargetSelector(workspaceDir, stateDir, extractor);
-      const result = selector.select();
-
-      expect(result.decision).toBe('skip');
-      expect(result.skipReason).toBe('workspace_not_idle');
-    });
-
-    it('quota_exhausted — when max runs per window reached', () => {
-      seedTrainingState(stateDir, 'T-01', {
-        evaluability: 'deterministic',
-        internalizationStatus: 'needs_training',
-      });
-
-      const runtimePath = path.join(stateDir, NOCTURNAL_RUNTIME_FILE);
-      const now = new Date().toISOString();
-      fs.writeFileSync(
-        runtimePath,
-        JSON.stringify({ principleCooldowns: {}, recentRunTimestamps: Array(10).fill(now) }),
-        'utf-8'
-      );
-
-      const selector = new NocturnalTargetSelector(workspaceDir, stateDir, extractor);
-      const result = selector.select();
-
-      expect(result.decision).toBe('skip');
-      expect(result.skipReason).toBe('quota_exhausted');
-    });
-
-    it('all_targets_in_cooldown — when all candidates are in per-principle cooldown', () => {
-      const cooldownUntil = new Date(Date.now() + 3600000).toISOString();
-      setRuntimeCooldown(stateDir, cooldownUntil);
-      seedTrainingState(stateDir, 'T-01', {
-        evaluability: 'deterministic',
-        internalizationStatus: 'needs_training',
-      });
-
-      const selector = new NocturnalTargetSelector(workspaceDir, stateDir, extractor);
-      const result = selector.select();
-
-      expect(result.decision).toBe('skip');
-      expect(result.skipReason).toBe('all_targets_in_cooldown');
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // Pain context bias
-  // -------------------------------------------------------------------------
-
-  describe('pain context bias', () => {
-    it('includes pain context in diagnostics when provided', () => {
-      seedTrainingState(stateDir, 'T-01', {
-        evaluability: 'deterministic',
-        internalizationStatus: 'needs_training',
-        applicableOpportunityCount: 5,
-        observedViolationCount: 2,
-        complianceRate: 0.6,
-      });
-
-      const recentPainContext = {
-        mostRecent: { score: 8, source: 'tool_failure', reason: 'edit failed', timestamp: '2026-03-27T10:00:00.000Z' },
-        recentPainCount: 3,
-        recentMaxPainScore: 8,
-      };
-
-      const selector = new NocturnalTargetSelector(workspaceDir, stateDir, extractor, {
-        recentPainContext,
-      });
-      const result = selector.select();
-
-      expect(result.diagnostics.painContext).toBeDefined();
-      expect(result.diagnostics.painContext!.hasRecentPain).toBe(true);
-      expect(result.diagnostics.painContext!.recentPainCount).toBe(3);
-      expect(result.diagnostics.painContext!.recentMaxPainScore).toBe(8);
-      expect(result.diagnostics.painContext!.painSource).toBe('tool_failure');
-    });
-
-    it('does not include pain context in diagnostics when not provided', () => {
-      seedTrainingState(stateDir, 'T-01', {
-        evaluability: 'deterministic',
-        internalizationStatus: 'needs_training',
-      });
-
-      const selector = new NocturnalTargetSelector(workspaceDir, stateDir, extractor);
-      const result = selector.select();
-
-      expect(result.diagnostics.painContext).toBeUndefined();
-    });
-
-    it('biases toward principles when recent pain count is high', () => {
-      // Seed one principle with known scoring characteristics
-      seedTrainingState(stateDir, 'T-01', {
-        evaluability: 'deterministic',
-        internalizationStatus: 'needs_training',
-        applicableOpportunityCount: 10,
-        observedViolationCount: 5,
-        complianceRate: 0.5,
-        generatedSampleCount: 5,
-        violationTrend: 0,
-      });
-
-      seedSession(trajectory, 'session-violating');
-      seedToolCall(trajectory, 'session-violating', 'edit_file', 'failure', 'error');
-
-      // Without pain context - baseline score
-      // Base 50 + compliance 12.5 (0.5*25) + scarcity 9 (15-6) + trend 0 = 71.5 -> 71
-      const selectorWithoutPain = new NocturnalTargetSelector(workspaceDir, stateDir, extractor);
-      const resultWithoutPain = selectorWithoutPain.select();
-
-      // With high pain context - score should be boosted
-      // Pain contribution: mostRecent (score 9) = 13.5, additional 4 = 4, high pain bonus = 5
-      // Total pain = 22.5 -> 23
-      // New total: 71 + 23 = 94
-      const highPainContext = {
-        mostRecent: { score: 9, source: 'tool_failure', reason: 'high pain', timestamp: '2026-03-27T10:00:00.000Z' },
-        recentPainCount: 5,
-        recentMaxPainScore: 9,
-      };
-
-      const selectorWithPain = new NocturnalTargetSelector(workspaceDir, stateDir, extractor, {
-        recentPainContext: highPainContext,
-      });
-      const resultWithPain = selectorWithPain.select();
-
-      // Pain context should be present and have correct values
-      expect(resultWithPain.diagnostics.painContext).toBeDefined();
-      expect(resultWithPain.diagnostics.painContext!.hasRecentPain).toBe(true);
-      expect(resultWithPain.diagnostics.painContext!.recentMaxPainScore).toBe(9);
-      expect(resultWithPain.diagnostics.painContext!.recentPainCount).toBe(5);
-
-      // Score with pain should be significantly higher than without pain
-      const t01ScoreWithPain = resultWithPain.diagnostics.scoringBreakdown['T-01'];
-      const t01ScoreWithoutPain = resultWithoutPain.diagnostics.scoringBreakdown['T-01'];
-      expect(t01ScoreWithPain).toBeGreaterThan(t01ScoreWithoutPain);
-
-      // The difference should be at least 20 (pain contribution)
-      expect(t01ScoreWithPain - t01ScoreWithoutPain).toBeGreaterThanOrEqual(20);
-    });
-
-    it('has zero painContext when recentPainCount is 0', () => {
-      seedTrainingState(stateDir, 'T-01', {
-        evaluability: 'deterministic',
-        internalizationStatus: 'needs_training',
-      });
-
-      const emptyPainContext = {
-        mostRecent: null,
-        recentPainCount: 0,
-        recentMaxPainScore: 0,
-      };
-
-      const selector = new NocturnalTargetSelector(workspaceDir, stateDir, extractor, {
-        recentPainContext: emptyPainContext,
-      });
-      const result = selector.select();
-
-      expect(result.diagnostics.painContext).toBeDefined();
-      expect(result.diagnostics.painContext!.hasRecentPain).toBe(false);
-      expect(result.diagnostics.painContext!.recentPainCount).toBe(0);
-    });
-  });
-});