principles-disciple 1.72.0 → 1.74.0

package/tests/integration/pain-diagnostician-loop.e2e.test.ts

@@ -1,380 +0,0 @@
-/**
- * Pain → Diagnostician Loop E2E Tests
- *
- * PURPOSE: Verify business invariants in the Pain → Diagnostician loop.
- * These tests are designed to DISCOVER bugs, not just confirm existing behavior.
- *
- * DESIGN PRINCIPLES:
- * 1. Use real file system (no mocks for I/O)
- * 2. Test business invariants, not implementation details
- * 3. Use independent Oracle data sources for verification
- * 4. Test resilience (corruption recovery, concurrency safety)
- *
- * DATA FLOW:
- * after_tool_call (hooks/pain.ts)
- *     → writePainFlag → .state/.pain_flag
- * Evolution Worker (service/evolution-worker.ts)
- *     → enqueues pain_diagnosis task → evolution_queue.json
- *     → addDiagnosticianTask → diagnostician_tasks.json
- * before_prompt_build (hooks/prompt.ts)
- *     → getPendingDiagnosticianTasks → inject into prompt
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import {
-  buildPainFlag,
-  writePainFlag,
-  readPainFlagData,
-  validatePainFlag,
-} from '../../src/core/pain.js';
-import { getPendingDiagnosticianTasks, addDiagnosticianTask } from '../../src/core/diagnostician-task-store.js';
-
-// ─────────────────────────────────────────────────────────────────────
-// Helper functions
-// ─────────────────────────────────────────────────────────────────────
-
-function createTestWorkspace(): { workspaceDir: string; stateDir: string } {
-  const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-e2e-pain-'));
-  const stateDir = path.join(workspaceDir, '.state');
-  fs.mkdirSync(stateDir, { recursive: true });
-  fs.mkdirSync(path.join(workspaceDir, '.principles'), { recursive: true });
-  return { workspaceDir, stateDir };
-}
-
-function cleanupWorkspace(workspaceDir: string): void {
-  try {
-    fs.rmSync(workspaceDir, { recursive: true, force: true });
-  } catch {
-    // ignore
-  }
-}
-
-// ─────────────────────────────────────────────────────────────────────
-// PART 1: Business Invariants
-// Tests that verify system MUST maintain these rules
-// ─────────────────────────────────────────────────────────────────────
-
-describe('Pain → Diagnostician: Business Invariants', () => {
-  let workspaceDir: string;
-  let stateDir: string;
-
-  beforeEach(() => {
-    const ws = createTestWorkspace();
-    workspaceDir = ws.workspaceDir;
-    stateDir = ws.stateDir;
-  });
-
-  afterEach(() => {
-    cleanupWorkspace(workspaceDir);
-  });
-
-  // ── INVARIANT 1: Pain flag format contract ──
-  describe('INVARIANT: Pain flag format contract', () => {
-    it('MUST contain all required fields after writePainFlag', () => {
-      const data = buildPainFlag({
-        source: 'tool_failure',
-        score: '70',
-        reason: 'Command failed with exit code 1',
-        session_id: 'test-session-123',
-        agent_id: 'main',
-        is_risky: true,
-      });
-
-      writePainFlag(workspaceDir, data);
-
-      // Independent verification: read file directly, don't trust writePainFlag
-      const painFlagPath = path.join(stateDir, '.pain_flag');
-      expect(fs.existsSync(painFlagPath)).toBe(true);
-
-      const content = fs.readFileSync(painFlagPath, 'utf-8');
-
-      // INVARIANT: All required fields MUST be present
-      expect(content).toContain('source: tool_failure');
-      expect(content).toContain('score: 70');
-      expect(content).toMatch(/time: \d{4}-\d{2}-\d{2}T/); // ISO timestamp with space
-      expect(content).toContain('reason:');
-      expect(content).toContain('is_risky: true');
-    });
-
-    it('MUST NOT write empty optional fields to disk', () => {
-      const data = buildPainFlag({
-        source: 'human_intervention',
-        score: '50',
-        reason: 'User feedback',
-        // Optional fields omitted
-      });
-
-      writePainFlag(workspaceDir, data);
-
-      const content = fs.readFileSync(path.join(stateDir, '.pain_flag'), 'utf-8');
-
-      // INVARIANT: Empty optional fields MUST NOT appear in file
-      // This prevents confusion when reading the file
-      expect(content).not.toMatch(/trace_id:\s*$/m);
-      expect(content).not.toMatch(/trigger_text_preview:\s*$/m);
-    });
-
-    it('score MUST be in valid range 0-100', () => {
-      // Test boundary values
-      const scores = ['0', '50', '100'];
-
-      for (const score of scores) {
-        const data = buildPainFlag({
-          source: 'test',
-          score,
-          reason: 'Test',
-        });
-
-        writePainFlag(workspaceDir, data);
-
-        const read = readPainFlagData(workspaceDir);
-        const numScore = Number(read.score);
-
-        // INVARIANT: Score MUST be in valid range
-        expect(numScore).toBeGreaterThanOrEqual(0);
-        expect(numScore).toBeLessThanOrEqual(100);
-      }
-    });
-  });
-
-  // ── INVARIANT 2: Pain flag validation contract ──
-  describe('INVARIANT: Pain flag validation', () => {
-    it('validatePainFlag MUST reject flags missing required fields', () => {
-      const invalidFlags = [
-        { source: '', score: '50', time: '2024-01-01', reason: 'test' }, // empty source
-        { source: 'test', score: '', time: '2024-01-01', reason: 'test' }, // empty score
-        { source: 'test', score: '50', time: '', reason: 'test' }, // empty time
-        { source: 'test', score: '50', time: '2024-01-01', reason: '' }, // empty reason
-      ];
-
-      for (const flag of invalidFlags) {
-        const missing = validatePainFlag(flag);
-        // INVARIANT: Missing required fields MUST be detected
-        expect(missing.length).toBeGreaterThan(0);
-      }
-    });
-
-    it('validatePainFlag MUST accept valid flags', () => {
-      const validFlag = {
-        source: 'tool_failure',
-        score: '70',
-        time: new Date().toISOString(),
-        reason: 'Command failed',
-        session_id: 'test',
-        agent_id: 'main',
-        is_risky: 'false',
-      };
-
-      const missing = validatePainFlag(validFlag);
-      // INVARIANT: Valid flags MUST pass validation
-      expect(missing).toEqual([]);
-    });
-  });
-
-  // ── INVARIANT 3: Diagnostician task store contract ──
-  describe('INVARIANT: Diagnostician task store', () => {
-    it('MUST persist tasks with correct structure', async () => {
-      const taskId = `task-${Date.now()}`;
-      const prompt = 'Diagnose the following pain signal:\n- source: tool_failure\n- score: 70';
-
-      await addDiagnosticianTask(stateDir, taskId, prompt);
-
-      // Independent verification: read file directly
-      const tasksPath = path.join(stateDir, 'diagnostician_tasks.json');
-      expect(fs.existsSync(tasksPath)).toBe(true);
-
-      const store = JSON.parse(fs.readFileSync(tasksPath, 'utf-8'));
-
-      // INVARIANT: Task MUST be in store with correct structure
-      expect(store.tasks).toBeDefined();
-      expect(store.tasks[taskId]).toBeDefined();
-      expect(store.tasks[taskId].prompt).toBe(prompt);
-      expect(store.tasks[taskId].status).toBe('pending');
-      expect(store.tasks[taskId].createdAt).toBeDefined();
-    });
-
-    it('getPendingDiagnosticianTasks MUST only return pending tasks', async () => {
-      // Add pending task
-      await addDiagnosticianTask(stateDir, 'pending-task', 'Test prompt');
-
-      // Add completed task manually
-      const tasksPath = path.join(stateDir, 'diagnostician_tasks.json');
-      const store = { tasks: {} };
-      store.tasks['completed-task'] = {
-        prompt: 'Completed',
-        status: 'completed',
-        createdAt: new Date().toISOString(),
-      };
-      fs.writeFileSync(tasksPath, JSON.stringify(store));
-
-      // Add pending task to the store
-      const existingStore = JSON.parse(fs.readFileSync(tasksPath, 'utf-8'));
-      existingStore.tasks['pending-task'] = {
-        prompt: 'Pending',
-        status: 'pending',
-        createdAt: new Date().toISOString(),
-      };
-      fs.writeFileSync(tasksPath, JSON.stringify(existingStore));
-
-      const pending = getPendingDiagnosticianTasks(stateDir);
-
-      // INVARIANT: Only pending tasks MUST be returned
-      expect(pending.some(t => t.id === 'pending-task')).toBe(true);
-      expect(pending.some(t => t.id === 'completed-task')).toBe(false);
-    });
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────
-// PART 2: Resilience Tests
-// Tests that verify system behavior under abnormal conditions
-// ─────────────────────────────────────────────────────────────────────
-
-describe('Pain → Diagnostician: Resilience', () => {
-  let workspaceDir: string;
-  let stateDir: string;
-
-  beforeEach(() => {
-    const ws = createTestWorkspace();
-    workspaceDir = ws.workspaceDir;
-    stateDir = ws.stateDir;
-  });
-
-  afterEach(() => {
-    cleanupWorkspace(workspaceDir);
-  });
-
-  // ── RESILIENCE 1: Corruption recovery ──
-  describe('RESILIENCE: Corruption recovery', () => {
-    it('readPainFlagData MUST NOT crash on corrupted file', () => {
-      // Write corrupted content
-      fs.writeFileSync(path.join(stateDir, '.pain_flag'), 'invalid {{{ json');
-
-      // This should NOT throw
-      expect(() => readPainFlagData(workspaceDir)).not.toThrow();
-
-      const data = readPainFlagData(workspaceDir);
-
-      // INVARIANT: Should return safe default, not undefined/null
-      expect(data).toBeDefined();
-      expect(typeof data).toBe('object');
-    });
-
-    it('getPendingDiagnosticianTasks MUST NOT crash on missing file', () => {
-      // Don't create diagnostician_tasks.json
-
-      // This should NOT throw
-      expect(() => getPendingDiagnosticianTasks(stateDir)).not.toThrow();
-
-      const pending = getPendingDiagnosticianTasks(stateDir);
-
-      // INVARIANT: Should return empty array, not crash
-      expect(Array.isArray(pending)).toBe(true);
-      expect(pending.length).toBe(0);
-    });
-
-    it('getPendingDiagnosticianTasks MUST NOT crash on corrupted JSON', () => {
-      fs.writeFileSync(
-        path.join(stateDir, 'diagnostician_tasks.json'),
-        'not valid json {{{'
-      );
-
-      // This should NOT throw
-      expect(() => getPendingDiagnosticianTasks(stateDir)).not.toThrow();
-
-      const pending = getPendingDiagnosticianTasks(stateDir);
-
-      // INVARIANT: Should return empty array as fallback
-      expect(Array.isArray(pending)).toBe(true);
-    });
-  });
-
-  // ── RESILIENCE 2: Concurrent access safety ──
-  describe('RESILIENCE: Concurrent access', () => {
-    it('writePainFlag MUST handle rapid sequential writes', () => {
-      // Simulate rapid consecutive writes
-      for (let i = 0; i < 10; i++) {
-        const data = buildPainFlag({
-          source: `test-${i}`,
-          score: String(i * 10),
-          reason: `Test ${i}`,
-        });
-        writePainFlag(workspaceDir, data);
-      }
-
-      // INVARIANT: File must exist and be valid after rapid writes
-      const painFlagPath = path.join(stateDir, '.pain_flag');
-      expect(fs.existsSync(painFlagPath)).toBe(true);
-
-      const content = fs.readFileSync(painFlagPath, 'utf-8');
-
-      // Should not have corruption artifacts
-      expect(content).not.toContain('undefined');
-      expect(content).not.toContain('[object Object]');
-      expect(content).not.toContain('null');
-    });
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────
-// PART 3: Round-trip Tests
-// Tests that verify data survives the full write → read cycle
-// ─────────────────────────────────────────────────────────────────────
-
-describe('Pain → Diagnostician: Round-trip', () => {
-  let workspaceDir: string;
-  let stateDir: string;
-
-  beforeEach(() => {
-    const ws = createTestWorkspace();
-    workspaceDir = ws.workspaceDir;
-    stateDir = ws.stateDir;
-  });
-
-  afterEach(() => {
-    cleanupWorkspace(workspaceDir);
-  });
-
-  it('Pain flag round-trip: write → read → verify', () => {
-    const original = buildPainFlag({
-      source: 'tool_failure',
-      score: '75',
-      reason: 'npm test failed with exit code 1',
-      session_id: 'session-abc123',
-      agent_id: 'main',
-      is_risky: false,
-      trace_id: 'trace-xyz789',
-      trigger_text_preview: 'npm test',
-    });
-
-    writePainFlag(workspaceDir, original);
-    const read = readPainFlagData(workspaceDir);
-
-    // INVARIANT: All fields MUST survive round-trip
-    expect(read.source).toBe(original.source);
-    expect(read.score).toBe(original.score);
-    expect(read.reason).toBe(original.reason);
-    expect(read.session_id).toBe(original.session_id);
-    expect(read.agent_id).toBe(original.agent_id);
-    expect(read.is_risky).toBe(original.is_risky);
-    expect(read.trace_id).toBe(original.trace_id);
-    expect(read.trigger_text_preview).toBe(original.trigger_text_preview);
-  });
-
-  it('Diagnostician task round-trip: add → get → verify', async () => {
-    const taskId = 'round-trip-task';
-    const prompt = 'Analyze the following error:\n```\nError: ENOENT\n```';
-
-    await addDiagnosticianTask(stateDir, taskId, prompt);
-    const pending = getPendingDiagnosticianTasks(stateDir);
-    const task = pending.find(t => t.id === taskId);
-
-    // INVARIANT: Task MUST survive round-trip
-    expect(task).toBeDefined();
-    expect(task!.task.prompt).toBe(prompt);
-    expect(task!.task.status).toBe('pending');
-  });
-});

package/tests/service/control-ui-query-service.test.ts

@@ -1,121 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { ControlUiQueryService } from '../../src/service/control-ui-query-service.js';
-
-const mocks = vi.hoisted(() => ({
-  fromHookContext: vi.fn(),
-  clearCache: vi.fn(),
-  controlUiDb: {
-    all: vi.fn(),
-    get: vi.fn(),
-    dispose: vi.fn(),
-  },
-  trajectory: {
-    getDataStats: vi.fn(),
-  },
-}));
-
-vi.mock('../../src/core/workspace-context.js', () => ({
-  WorkspaceContext: {
-    fromHookContext: mocks.fromHookContext,
-    clearCache: mocks.clearCache,
-  },
-}));
-
-vi.mock('../../src/core/control-ui-db.js', () => ({
-  ControlUiDatabase: class {
-    constructor() {
-      return mocks.controlUiDb as any;
-    }
-  },
-}));
-
-describe('ControlUiQueryService', () => {
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('returns null for unknown thinking models', () => {
-    mocks.fromHookContext.mockReturnValue({ trajectory: mocks.trajectory } as any);
-    const service = new ControlUiQueryService('/mock/workspace');
-
-    expect(service.getThinkingModelDetail('UNKNOWN')).toBeNull();
-    service.dispose();
-  });
-
-  it('labels overview responses as trajectory analytics rather than runtime control state', () => {
-    mocks.fromHookContext.mockReturnValue({ trajectory: mocks.trajectory } as any);
-    mocks.trajectory.getDataStats.mockReturnValue({
-      dbPath: '/mock/trajectory.db',
-      dbSizeBytes: 0,
-      assistantTurns: 0,
-      userTurns: 0,
-      toolCalls: 0,
-      painEvents: 0,
-      pendingSamples: 0,
-      approvedSamples: 0,
-      blobBytes: 0,
-      lastIngestAt: null,
-    });
-    mocks.controlUiDb.get.mockImplementation((sql: string) => {
-      if (sql.includes('FROM gate_blocks')) return { count: 0 };
-      if (sql.includes('FROM task_outcomes')) return { count: 0 };
-      return { count: 0 };
-    });
-    mocks.controlUiDb.all.mockImplementation((sql: string) => {
-      if (sql.includes('v_error_clusters')) return [];
-      if (sql.includes('v_sample_queue')) return [];
-      if (sql.includes('correction_samples')) return [];
-      if (sql.includes('v_thinking_model_effectiveness')) return [];
-      if (sql.includes('v_thinking_model_daily_trend')) return [];
-      if (sql.includes('v_thinking_model_scenarios')) return [];
-      return [];
-    });
-    const service = new ControlUiQueryService('/mock/workspace');
-    const overview = service.getOverview();
-
-    expect(overview.dataSource).toBe('trajectory_db_analytics');
-    expect(overview.runtimeControlPlaneSource).toBe('pd_evolution_status');
-    expect(overview.summary.gateBlocks).toBe(0);
-    expect(overview.summary.taskOutcomes).toBe(0);
-    service.dispose();
-  });
-
-  it('surfaces gate block and task outcome counts from trajectory analytics', () => {
-    mocks.fromHookContext.mockReturnValue({ trajectory: mocks.trajectory } as any);
-    mocks.trajectory.getDataStats.mockReturnValue({
-      dbPath: '/mock/trajectory.db',
-      dbSizeBytes: 0,
-      assistantTurns: 0,
-      userTurns: 0,
-      toolCalls: 0,
-      painEvents: 0,
-      pendingSamples: 0,
-      approvedSamples: 0,
-      blobBytes: 0,
-      lastIngestAt: null,
-    });
-    mocks.controlUiDb.get.mockImplementation((sql: string) => {
-      if (sql.includes('FROM gate_blocks')) return { count: 1 };
-      if (sql.includes('FROM task_outcomes')) return { count: 1 };
-      return { count: 0 };
-    });
-    mocks.controlUiDb.all.mockImplementation((sql: string) => {
-      if (sql.includes('v_error_clusters')) return [];
-      if (sql.includes('v_sample_queue')) return [];
-      if (sql.includes('correction_samples')) return [];
-      if (sql.includes('v_thinking_model_effectiveness')) return [];
-      if (sql.includes('v_thinking_model_daily_trend')) return [];
-      if (sql.includes('v_thinking_model_scenarios')) return [];
-      return [];
-    });
-    const service = new ControlUiQueryService('/mock/workspace');
-    const overview = service.getOverview();
-
-    expect(overview.summary.gateBlocks).toBe(1);
-    expect(overview.summary.taskOutcomes).toBe(1);
-    expect(overview.dataSource).toBe('trajectory_db_analytics');
-    expect(overview.runtimeControlPlaneSource).toBe('pd_evolution_status');
-
-    service.dispose();
-  });
-});

package/tests/service/cooldown-strategy.test.ts

@@ -1,164 +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 { recordPersistentFailure, resetFailureState, isTaskKindInCooldown } from '../../src/service/cooldown-strategy.js';
-import { readState } from '../../src/service/nocturnal-runtime.js';
-
-let tmpDir: string;
-
-beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cooldown-test-'));
-});
-
-afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-});
-
-describe('cooldown-strategy', () => {
-    describe('recordPersistentFailure', () => {
-        it('sets Tier 1 (30min) on first call', async () => {
-            await recordPersistentFailure(tmpDir, 'sleep_reflection');
-            const state = await readState(tmpDir);
-
-            expect(state.taskFailureState).toBeDefined();
-            expect(state.taskFailureState!['sleep_reflection'].consecutiveFailures).toBe(1);
-            expect(state.taskFailureState!['sleep_reflection'].escalationTier).toBe(1);
-
-            const cooldownUntil = new Date(state.taskFailureState!['sleep_reflection'].cooldownUntil!).getTime();
-            const expectedEnd = Date.now() + 30 * 60 * 1000;
-            expect(Math.abs(cooldownUntil - expectedEnd)).toBeLessThan(5000);
-        });
-
-        it('sets Tier 2 (4h) on second call', async () => {
-            await recordPersistentFailure(tmpDir, 'sleep_reflection');
-            await recordPersistentFailure(tmpDir, 'sleep_reflection');
-            const state = await readState(tmpDir);
-
-            expect(state.taskFailureState!['sleep_reflection'].consecutiveFailures).toBe(2);
-            expect(state.taskFailureState!['sleep_reflection'].escalationTier).toBe(2);
-
-            const cooldownUntil = new Date(state.taskFailureState!['sleep_reflection'].cooldownUntil!).getTime();
-            const expectedEnd = Date.now() + 4 * 60 * 60 * 1000;
-            expect(Math.abs(cooldownUntil - expectedEnd)).toBeLessThan(5000);
-        });
-
-        it('caps at Tier 3 (24h) on fourth+ call', async () => {
-            for (let i = 0; i < 4; i++) {
-                await recordPersistentFailure(tmpDir, 'sleep_reflection');
-            }
-            const state = await readState(tmpDir);
-
-            expect(state.taskFailureState!['sleep_reflection'].consecutiveFailures).toBe(4);
-            expect(state.taskFailureState!['sleep_reflection'].escalationTier).toBe(3);
-
-            const cooldownUntil = new Date(state.taskFailureState!['sleep_reflection'].cooldownUntil!).getTime();
-            const expectedEnd = Date.now() + 24 * 60 * 60 * 1000;
-            expect(Math.abs(cooldownUntil - expectedEnd)).toBeLessThan(5000);
-        });
-
-        it('independent state per task kind', async () => {
-            await recordPersistentFailure(tmpDir, 'sleep_reflection');
-            await new Promise((r) => setTimeout(r, 10)); // ensure distinct timestamps
-            await recordPersistentFailure(tmpDir, 'keyword_optimization');
-            const state = await readState(tmpDir);
-
-            expect(state.taskFailureState!['sleep_reflection'].escalationTier).toBe(1);
-            expect(state.taskFailureState!['keyword_optimization'].escalationTier).toBe(1);
-            expect(state.taskFailureState!['sleep_reflection'].cooldownUntil).not.toBe(
-                state.taskFailureState!['keyword_optimization'].cooldownUntil,
-            );
-        });
-    });
-
-    describe('resetFailureState', () => {
-        it('clears failures after escalation', async () => {
-            await recordPersistentFailure(tmpDir, 'sleep_reflection');
-            await resetFailureState(tmpDir, 'sleep_reflection');
-            const state = await readState(tmpDir);
-
-            expect(state.taskFailureState!['sleep_reflection'].consecutiveFailures).toBe(0);
-            expect(state.taskFailureState!['sleep_reflection'].escalationTier).toBe(0);
-            expect(state.taskFailureState!['sleep_reflection'].cooldownUntil).toBeUndefined();
-        });
-
-        it('is idempotent with no prior state', async () => {
-            await expect(resetFailureState(tmpDir, 'sleep_reflection')).resolves.not.toThrow();
-        });
-    });
-
-    describe('isTaskKindInCooldown', () => {
-        it('returns inCooldown=true after recordPersistentFailure', async () => {
-            await recordPersistentFailure(tmpDir, 'sleep_reflection');
-            const result = isTaskKindInCooldown(tmpDir, 'sleep_reflection');
-
-            expect(result.inCooldown).toBe(true);
-            expect(result.remainingMs).toBeGreaterThan(0);
-            expect(result.cooldownUntil).not.toBeNull();
-        });
-
-        it('returns inCooldown=false when cooldownUntil is in the past', async () => {
-            // Manually set expired cooldown
-            const state = await readState(tmpDir);
-            state.taskFailureState = {
-                sleep_reflection: {
-                    consecutiveFailures: 1,
-                    escalationTier: 1,
-                    cooldownUntil: new Date(Date.now() - 60000).toISOString(),
-                },
-            };
-            const { writeState } = await import('../../src/service/nocturnal-runtime.js');
-            await writeState(tmpDir, state);
-
-            const result = isTaskKindInCooldown(tmpDir, 'sleep_reflection');
-            expect(result.inCooldown).toBe(false);
-            expect(result.remainingMs).toBe(0);
-        });
-
-        it('returns inCooldown=false when no state exists', () => {
-            const result = isTaskKindInCooldown(tmpDir, 'sleep_reflection');
-            expect(result.inCooldown).toBe(false);
-            expect(result.remainingMs).toBe(0);
-        });
-
-        it('returns inCooldown=false for untracked task kind', async () => {
-            await recordPersistentFailure(tmpDir, 'sleep_reflection');
-            const result = isTaskKindInCooldown(tmpDir, 'keyword_optimization');
-
-            expect(result.inCooldown).toBe(false);
-            expect(result.remainingMs).toBe(0);
-        });
-    });
-
-    describe('state persistence', () => {
-        it('state survives to disk after recordPersistentFailure', async () => {
-            await recordPersistentFailure(tmpDir, 'sleep_reflection');
-
-            // Read directly from file to verify persistence
-            const filePath = path.join(tmpDir, 'nocturnal-runtime.json');
-            expect(fs.existsSync(filePath)).toBe(true);
-            const raw = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-            expect(raw.taskFailureState).toBeDefined();
-            expect(raw.taskFailureState.sleep_reflection).toBeDefined();
-            expect(raw.taskFailureState.sleep_reflection.consecutiveFailures).toBe(1);
-        });
-    });
-
-    describe('custom config', () => {
-        it('uses custom tier durations', async () => {
-            const customConfig = {
-                tier1_ms: 1000,
-                tier2_ms: 5000,
-                tier3_ms: 10000,
-                consecutive_threshold: 3,
-            };
-            await recordPersistentFailure(tmpDir, 'sleep_reflection', customConfig);
-            const state = await readState(tmpDir);
-
-            const cooldownUntil = new Date(state.taskFailureState!['sleep_reflection'].cooldownUntil!).getTime();
-            const expectedEnd = Date.now() + 1000;
-            expect(Math.abs(cooldownUntil - expectedEnd)).toBeLessThan(1000);
-        });
-    });
-});