principles-disciple 1.72.0 → 1.74.0

package/tests/service/nocturnal-runtime-hardening.test.ts

@@ -1,118 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-
-const { mockExecuteNocturnalReflectionAsync } = vi.hoisted(() => ({
-  mockExecuteNocturnalReflectionAsync: vi.fn(),
-}));
-
-vi.mock('../../src/service/nocturnal-service.js', () => ({
-  executeNocturnalReflectionAsync: mockExecuteNocturnalReflectionAsync,
-}));
-
-vi.mock('../../src/utils/subagent-probe.js', () => ({
-  isSubagentRuntimeAvailable: vi.fn(() => true),
-}));
-
-vi.mock('../../src/core/nocturnal-paths.js', () => ({
-  resolveNocturnalDir: vi.fn((workspaceDir: string) => path.join(workspaceDir, '.state', 'nocturnal', 'samples')),
-}));
-
-import { NocturnalWorkflowManager, nocturnalWorkflowSpec } from '../../src/service/subagent-workflow/nocturnal-workflow-manager.js';
-import { safeRmDir } from '../test-utils.js';
-
-describe('NocturnalWorkflowManager runtime hardening', () => {
-  let workspaceDir: string;
-  let stateDir: string;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-nocturnal-wf-'));
-    stateDir = path.join(workspaceDir, '.state');
-    fs.mkdirSync(stateDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    safeRmDir(workspaceDir);
-  });
-
-  it('marks workflow terminal_error when async pipeline throws a gateway-only runtime error', async () => {
-    mockExecuteNocturnalReflectionAsync.mockRejectedValue(
-      new Error('Plugin runtime subagent methods are only available during a gateway request.')
-    );
-
-    const manager = new NocturnalWorkflowManager({
-      workspaceDir,
-      stateDir,
-      logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() } as any,
-      runtimeAdapter: {} as any,
-    });
-
-    const handle = await manager.startWorkflow(nocturnalWorkflowSpec, {
-      parentSessionId: 'sleep_reflection:test',
-      taskInput: {},
-      metadata: {
-        snapshot: {
-          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: 1,
-            totalPainEvents: 0,
-            totalGateBlocks: 0,
-            failureCount: 0,
-          },
-        },
-      },
-    });
-
-    await Promise.resolve();
-    await Promise.resolve();
-
-    const summary = await manager.getWorkflowDebugSummary(handle.workflowId);
-    expect(summary?.state).toBe('terminal_error');
-    expect(summary?.recentEvents.some((event) => event.eventType === 'nocturnal_failed')).toBe(true);
-
-    manager.dispose();
-  });
-
-  it('rejects malformed snapshot ingress before starting the async pipeline', async () => {
-    const manager = new NocturnalWorkflowManager({
-      workspaceDir,
-      stateDir,
-      logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() } as any,
-      runtimeAdapter: {} as any,
-    });
-
-    const handle = await manager.startWorkflow(nocturnalWorkflowSpec, {
-      parentSessionId: 'sleep_reflection:test',
-      taskInput: {},
-      metadata: {
-        snapshot: {
-          sessionId: 'session-1',
-          stats: {
-            totalAssistantTurns: 1,
-            totalToolCalls: 1,
-            totalPainEvents: 0,
-            totalGateBlocks: 0,
-            failureCount: 0,
-          },
-        },
-      },
-    });
-
-    const summary = await manager.getWorkflowDebugSummary(handle.workflowId);
-    expect(summary?.state).toBe('terminal_error');
-    expect(summary?.recentEvents.some((event) => event.eventType === 'nocturnal_failed')).toBe(true);
-    expect(mockExecuteNocturnalReflectionAsync).not.toHaveBeenCalled();
-
-    manager.dispose();
-  });
-});

package/tests/service/nocturnal-runtime.test.ts

@@ -1,473 +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 {
-    checkWorkspaceIdle,
-    checkCooldown,
-    checkPreflight,
-    recordRunStart,
-    recordRunEnd,
-    clearAllCooldowns,
-    getRuntimeState,
-    DEFAULT_IDLE_THRESHOLD_MS,
-    DEFAULT_GLOBAL_COOLDOWN_MS,
-    DEFAULT_PRINCIPLE_COOLDOWN_MS,
-    DEFAULT_ABANDONED_THRESHOLD_MS,
-    NOCTURNAL_RUNTIME_FILE,
-} from '../../src/service/nocturnal-runtime.js';
-import { initPersistence, trackToolRead, clearSession, listSessions } from '../../src/core/session-tracker.js';
-import { safeRmDir } from '../test-utils.js';
-
-describe('NocturnalRuntime', () => {
-    let tempDir: string;
-    let workspaceDir: string;
-
-    beforeEach(() => {
-        vi.useFakeTimers();
-        // Use a fixed "now" for deterministic testing
-        vi.setSystemTime(new Date('2026-03-27T12:00:00.000Z'));
-
-        workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-nocturnal-ws-'));
-        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-nocturnal-'));
-
-        // Initialize session tracker persistence for the temp workspace
-        initPersistence(tempDir);
-    });
-
-    afterEach(() => {
-        vi.useRealTimers();
-        vi.clearAllMocks();
-        safeRmDir(workspaceDir);
-        safeRmDir(tempDir);
-        clearSession('session-active');
-        clearSession('session-stale');
-        clearSession('session-abandoned');
-        clearSession('session-ancient');
-    });
-
-    // -------------------------------------------------------------------------
-    // Idle Detection Tests
-    // -------------------------------------------------------------------------
-
-    describe('checkWorkspaceIdle', () => {
-        it('should return isIdle=true when no sessions exist', () => {
-            const result = checkWorkspaceIdle(workspaceDir);
-            expect(result.isIdle).toBe(true);
-            expect(result.userActiveSessions).toBe(0);
-            expect(result.abandonedSessionIds).toEqual([]);
-            expect(result.reason).toContain('No active sessions');
-        });
-
-        it('should return isIdle=false when a session is recent (within threshold)', () => {
-            // Create an active session with recent activity
-            trackToolRead('session-active', 'src/main.ts', workspaceDir);
-
-            const result = checkWorkspaceIdle(workspaceDir, { idleThresholdMs: 30 * 60 * 1000 });
-            expect(result.isIdle).toBe(false);
-            expect(result.userActiveSessions).toBe(1);
-            expect(result.abandonedSessionIds).toEqual([]);
-        });
-
-        it('should return isIdle=true when session is older than idle threshold', () => {
-            // Create a stale session (activity 45 min ago)
-            vi.setSystemTime(new Date('2026-03-27T11:15:00.000Z')); // 45 min before "now"
-            trackToolRead('session-stale', 'src/main.ts', workspaceDir);
-            vi.setSystemTime(new Date('2026-03-27T12:00:00.000Z')); // reset to "now"
-
-            const result = checkWorkspaceIdle(workspaceDir, { idleThresholdMs: 30 * 60 * 1000 });
-            expect(result.isIdle).toBe(true);
-            expect(result.idleForMs).toBeGreaterThan(30 * 60 * 1000);
-        });
-
-        // TODO: Fix - abandonedSessionIds not being populated correctly
-        it.skip('should treat abandoned sessions as not contributing to idle check', () => {
-            // Session active 3 hours ago — should be treated as abandoned
-            vi.setSystemTime(new Date('2026-03-27T09:00:00.000Z')); // 3 hours before "now"
-            trackToolRead('session-abandoned', 'src/main.ts', workspaceDir);
-            vi.setSystemTime(new Date('2026-03-27T12:00:00.000Z')); // reset to "now"
-
-            const result = checkWorkspaceIdle(workspaceDir, {
-                idleThresholdMs: 30 * 60 * 1000,
-                abandonedThresholdMs: 2 * 60 * 60 * 1000,
-            });
-
-            expect(result.isIdle).toBe(true); // No active sessions, so idle
-            expect(result.abandonedSessionIds).toContain('session-abandoned');
-            expect(result.userActiveSessions).toBe(0);
-            expect(result.reason).toContain('abandoned session(s) ignored');
-        });
-
-        // TODO: Fix - abandonedSessionIds not being populated correctly
-        it.skip('should ignore ancient sessions but still detect recent activity from other sessions', () => {
-            // Ancient session (4 hours ago — abandoned)
-            vi.setSystemTime(new Date('2026-03-27T08:00:00.000Z'));
-            trackToolRead('session-ancient', 'src/main.ts', workspaceDir);
-            vi.setSystemTime(new Date('2026-03-27T12:00:00.000Z'));
-
-            // Recent session (5 minutes ago — still active)
-            vi.setSystemTime(new Date('2026-03-27T11:55:00.000Z'));
-            trackToolRead('session-active', 'src/main.ts', workspaceDir);
-            vi.setSystemTime(new Date('2026-03-27T12:00:00.000Z'));
-
-            const result = checkWorkspaceIdle(workspaceDir, {
-                idleThresholdMs: 30 * 60 * 1000,
-                abandonedThresholdMs: 2 * 60 * 60 * 1000,
-            });
-
-            expect(result.isIdle).toBe(false); // Recent activity 5 min ago
-            expect(result.abandonedSessionIds).toContain('session-ancient');
-            expect(result.userActiveSessions).toBe(1);
-        });
-
-        it('should use trajectory timestamp as secondary guardrail', () => {
-            // No sessions, trajectory shows recent activity
-            const trajectoryRecent = Date.now() - 5 * 60 * 1000; // 5 min ago
-
-            const result = checkWorkspaceIdle(workspaceDir, {}, trajectoryRecent);
-            expect(result.isIdle).toBe(true); // Still idle (no sessions is primary)
-            expect(result.trajectoryGuardrailConfirmsIdle).toBe(false); // But trajectory disagrees
-        });
-
-        it('should confirm idle when both session state and trajectory agree', () => {
-            // No sessions, trajectory also shows idle (>80% of threshold)
-            const trajectoryOld = Date.now() - 40 * 60 * 1000; // 40 min ago (>24 min = 80% of 30min)
-
-            const result = checkWorkspaceIdle(workspaceDir, {}, trajectoryOld);
-            expect(result.isIdle).toBe(true);
-            expect(result.trajectoryGuardrailConfirmsIdle).toBe(true);
-        });
-
-        it('should report idleForMs correctly', () => {
-            // Session active 15 min ago
-            vi.setSystemTime(new Date('2026-03-27T11:45:00.000Z'));
-            trackToolRead('session-active', 'src/main.ts', workspaceDir);
-            vi.setSystemTime(new Date('2026-03-27T12:00:00.000Z'));
-
-            const result = checkWorkspaceIdle(workspaceDir, { idleThresholdMs: 30 * 60 * 1000 });
-            expect(result.idleForMs).toBe(15 * 60 * 1000);
-            expect(result.isIdle).toBe(false);
-        });
-    });
-
-    // -------------------------------------------------------------------------
-    // Cooldown Management Tests
-    // -------------------------------------------------------------------------
-
-    describe('checkCooldown', () => {
-        it('should return no active cooldowns when state is empty', () => {
-            const result = checkCooldown(tempDir);
-            expect(result.globalCooldownActive).toBe(false);
-            expect(result.principleCooldownActive).toBe(false);
-            expect(result.quotaExhausted).toBe(false);
-            expect(result.runsRemaining).toBe(3); // DEFAULT_MAX_RUNS_PER_WINDOW
-        });
-
-        it('should detect active global cooldown', async () => {
-            await recordRunStart(tempDir, 'T-01');
-
-            const result = checkCooldown(tempDir);
-            expect(result.globalCooldownActive).toBe(true);
-            expect(result.globalCooldownRemainingMs).toBe(DEFAULT_GLOBAL_COOLDOWN_MS);
-            expect(result.globalCooldownUntil).toBeTruthy();
-        });
-
-        it('should detect expired global cooldown', async () => {
-            await recordRunStart(tempDir, 'T-01');
-
-            // Advance time past the global cooldown
-            vi.advanceTimersByTime(DEFAULT_GLOBAL_COOLDOWN_MS + 1000);
-
-            const result = checkCooldown(tempDir);
-            expect(result.globalCooldownActive).toBe(false);
-            expect(result.globalCooldownRemainingMs).toBe(0);
-        });
-
-        it('should detect principle-specific cooldown after successful run', async () => {
-            await recordRunStart(tempDir, 'T-01');
-            await recordRunEnd(tempDir, 'success', { sampleCount: 5 });
-
-            const result = checkCooldown(tempDir, 'T-01');
-            expect(result.principleCooldownActive).toBe(true);
-            expect(result.principleCooldownRemainingMs).toBe(DEFAULT_PRINCIPLE_COOLDOWN_MS);
-        });
-
-        it('should not trigger principle cooldown on failed run', async () => {
-            await recordRunStart(tempDir, 'T-01');
-            await recordRunEnd(tempDir, 'failed', { reason: 'No violating sessions' });
-
-            // Global cooldown still active, but no principle cooldown
-            const result = checkCooldown(tempDir, 'T-01');
-            expect(result.globalCooldownActive).toBe(true);
-            expect(result.principleCooldownActive).toBe(false);
-        });
-
-        it('should not trigger principle cooldown on skipped run', async () => {
-            await recordRunStart(tempDir, 'T-01');
-            await recordRunEnd(tempDir, 'skipped', { reason: 'Idle check failed' });
-
-            const result = checkCooldown(tempDir, 'T-01');
-            expect(result.principleCooldownActive).toBe(false);
-        });
-
-        it('should enforce quota limit', async () => {
-            // Run max number of times
-            for (let i = 0; i < 3; i++) {
-                await recordRunStart(tempDir, 'T-01');
-                await recordRunEnd(tempDir, 'success', { sampleCount: 1 });
-                // Advance past global cooldown for each run
-                vi.advanceTimersByTime(DEFAULT_GLOBAL_COOLDOWN_MS + 1000);
-            }
-
-            const result = checkCooldown(tempDir);
-            expect(result.quotaExhausted).toBe(true);
-            expect(result.runsRemaining).toBe(0);
-        });
-
-        it('should reset quota after window expires', async () => {
-            // Run max times
-            for (let i = 0; i < 3; i++) {
-                await recordRunStart(tempDir, 'T-01');
-                await recordRunEnd(tempDir, 'success', { sampleCount: 1 });
-                vi.advanceTimersByTime(DEFAULT_GLOBAL_COOLDOWN_MS + 1000);
-            }
-
-            // Advance past the quota window
-            vi.advanceTimersByTime(24 * 60 * 60 * 1000 + 1000);
-
-            const result = checkCooldown(tempDir);
-            expect(result.quotaExhausted).toBe(false);
-            expect(result.runsRemaining).toBe(3);
-        });
-
-        it('should only cooldown specific principles, not others', async () => {
-            await recordRunStart(tempDir, 'T-01');
-            await recordRunEnd(tempDir, 'success');
-
-            const resultT01 = checkCooldown(tempDir, 'T-01');
-            const resultT02 = checkCooldown(tempDir, 'T-02');
-
-            expect(resultT01.principleCooldownActive).toBe(true);
-            expect(resultT02.principleCooldownActive).toBe(false);
-        });
-    });
-
-    // -------------------------------------------------------------------------
-    // Run Recording Tests
-    // -------------------------------------------------------------------------
-
-    describe('recordRunStart / recordRunEnd', () => {
-        it('should record run start timestamp', async () => {
-            await recordRunStart(tempDir, 'T-01');
-            const state = await getRuntimeState(tempDir);
-
-            expect(state.lastRunAt).toBeTruthy();
-            expect(state.lastRunMeta?.targetPrincipleId).toBe('T-01');
-            expect(state.lastRunMeta?.status).toBe('skipped');
-            expect(state.globalCooldownUntil).toBeTruthy();
-        });
-
-        it('should record successful run with sample count', async () => {
-            await recordRunStart(tempDir, 'T-01');
-            await recordRunEnd(tempDir, 'success', { sampleCount: 7 });
-
-            const state = await getRuntimeState(tempDir);
-            expect(state.lastSuccessfulRunAt).toBeTruthy();
-            expect(state.lastRunMeta?.status).toBe('success');
-            expect(state.lastRunMeta?.sampleCount).toBe(7);
-            expect(state.principleCooldowns['T-01']).toBeTruthy();
-        });
-
-        it('should preserve failed run reason without setting successful timestamp', async () => {
-            await recordRunStart(tempDir, 'T-02');
-            await recordRunEnd(tempDir, 'failed', { reason: 'No violating sessions found' });
-
-            const state = await getRuntimeState(tempDir);
-            expect(state.lastSuccessfulRunAt).toBeUndefined();
-            expect(state.lastRunMeta?.status).toBe('failed');
-            expect(state.lastRunMeta?.reason).toBe('No violating sessions found');
-            expect(state.principleCooldowns['T-02']).toBeUndefined(); // No principle cooldown on failure
-        });
-
-        it('should add timestamp to recentRunTimestamps for quota tracking', async () => {
-            await recordRunStart(tempDir, 'T-01');
-            const state = await getRuntimeState(tempDir);
-
-            expect(state.recentRunTimestamps.length).toBe(1);
-        });
-    });
-
-    // -------------------------------------------------------------------------
-    // clearAllCooldowns Tests
-    // -------------------------------------------------------------------------
-
-    describe('clearAllCooldowns', () => {
-        it('should clear all cooldown state', async () => {
-            await recordRunStart(tempDir, 'T-01');
-            await recordRunEnd(tempDir, 'success');
-
-            await clearAllCooldowns(tempDir);
-
-            const state = await getRuntimeState(tempDir);
-            expect(state.globalCooldownUntil).toBeUndefined();
-            expect(state.principleCooldowns).toEqual({});
-            expect(state.recentRunTimestamps).toEqual([]);
-            expect(state.lastRunMeta).toBeUndefined();
-        });
-    });
-
-    // -------------------------------------------------------------------------
-    // Preflight Check Tests
-    // -------------------------------------------------------------------------
-
-    describe('checkPreflight', () => {
-        it('should return canRun=true when workspace is idle and no cooldowns', () => {
-            // No sessions = idle
-            const result = checkPreflight(workspaceDir, tempDir, 'T-01');
-            expect(result.canRun).toBe(true);
-            expect(result.blockers).toEqual([]);
-        });
-
-        it('should block when workspace is not idle', () => {
-            // Create recent session
-            trackToolRead('session-active', 'src/main.ts', workspaceDir);
-
-            const result = checkPreflight(workspaceDir, tempDir, 'T-01');
-            expect(result.canRun).toBe(false);
-            expect(result.blockers.some(b => b.includes('not idle'))).toBe(true);
-        });
-
-        it('should block when global cooldown is active', async () => {
-            await recordRunStart(tempDir, 'T-01');
-
-            const result = checkPreflight(workspaceDir, tempDir, 'T-01');
-            expect(result.canRun).toBe(false);
-            expect(result.blockers.some(b => b.includes('Global cooldown'))).toBe(true);
-        });
-
-        it('should block when quota is exhausted', async () => {
-            // Exhaust quota
-            for (let i = 0; i < 3; i++) {
-                await recordRunStart(tempDir, 'T-01');
-                await recordRunEnd(tempDir, 'success', { sampleCount: 1 });
-                vi.advanceTimersByTime(DEFAULT_GLOBAL_COOLDOWN_MS + 1000);
-            }
-
-            const result = checkPreflight(workspaceDir, tempDir, 'T-01');
-            expect(result.canRun).toBe(false);
-            expect(result.blockers.some(b => b.includes('Quota exhausted'))).toBe(true);
-        });
-
-        it('should report all blockers when multiple conditions block', async () => {
-            // Create recent session AND set global cooldown
-            trackToolRead('session-active', 'src/main.ts', workspaceDir);
-            await recordRunStart(tempDir, 'T-01');
-
-            const result = checkPreflight(workspaceDir, tempDir, 'T-01');
-            expect(result.canRun).toBe(false);
-            expect(result.blockers.length).toBeGreaterThanOrEqual(2);
-        });
-
-        it('should include idle info in preflight result', () => {
-            const result = checkPreflight(workspaceDir, tempDir, 'T-01');
-            expect(result.idle).toBeDefined();
-            expect(result.idle.isIdle).toBe(true); // No sessions
-        });
-
-        it('should include cooldown info in preflight result', () => {
-            const result = checkPreflight(workspaceDir, tempDir, 'T-01');
-            expect(result.cooldown).toBeDefined();
-            expect(result.cooldown.globalCooldownActive).toBe(false);
-        });
-    });
-
-    // -------------------------------------------------------------------------
-    // Abandoned Session Tests (dedicated)
-// -------------------------------------------------------------------------
-
-    describe('abandoned sessions', () => {
-        it('should not block nocturnal flow when all sessions are abandoned but workspace otherwise empty', () => {
-            // Create only abandoned sessions (no recent activity)
-            vi.setSystemTime(new Date('2026-03-27T09:00:00.000Z')); // 3 hours ago
-            trackToolRead('session-abandoned', 'src/main.ts', workspaceDir);
-            vi.setSystemTime(new Date('2026-03-27T12:00:00.000Z'));
-
-            const result = checkWorkspaceIdle(workspaceDir, {
-                idleThresholdMs: 30 * 60 * 1000,
-                abandonedThresholdMs: 2 * 60 * 60 * 1000,
-            });
-
-            // Workspace should be considered idle (all sessions abandoned = effectively no sessions)
-            expect(result.isIdle).toBe(true);
-            expect(result.userActiveSessions).toBe(0);
-        });
-
-        // TODO: Fix - abandonedSessionIds not being populated correctly
-        it.skip('should not incorrectly block when there are abandoned AND active sessions', () => {
-            // Abandoned session (3 hours ago)
-            vi.setSystemTime(new Date('2026-03-27T09:00:00.000Z'));
-            trackToolRead('session-abandoned', 'src/main.ts', workspaceDir);
-
-            // Recent session (5 min ago)
-            vi.setSystemTime(new Date('2026-03-27T11:55:00.000Z'));
-            trackToolRead('session-active', 'src/main.ts', workspaceDir);
-            vi.setSystemTime(new Date('2026-03-27T12:00:00.000Z'));
-
-            const idleResult = checkWorkspaceIdle(workspaceDir, {
-                idleThresholdMs: 30 * 60 * 1000,
-                abandonedThresholdMs: 2 * 60 * 60 * 1000,
-            });
-
-            // Should NOT be idle because there's a recent active session
-            expect(idleResult.isIdle).toBe(false);
-            expect(idleResult.userActiveSessions).toBe(1);
-            expect(idleResult.abandonedSessionIds).toContain('session-abandoned');
-        });
-
-        it('should persist abandoned sessions do not create cooldown state', async () => {
-            // Create abandoned session
-            vi.setSystemTime(new Date('2026-03-27T09:00:00.000Z'));
-            trackToolRead('session-abandoned', 'src/main.ts', workspaceDir);
-            vi.setSystemTime(new Date('2026-03-27T12:00:00.000Z'));
-
-            // Workspace is idle, preflight should pass
-            const result = checkPreflight(workspaceDir, tempDir, 'T-01');
-            expect(result.canRun).toBe(true);
-        });
-    });
-
-    // -------------------------------------------------------------------------
-    // File Persistence Tests
-    // -------------------------------------------------------------------------
-
-    describe('file persistence', () => {
-        it('should create nocturnal-runtime.json on first write', async () => {
-            const filePath = path.join(tempDir, NOCTURNAL_RUNTIME_FILE);
-            expect(fs.existsSync(filePath)).toBe(false);
-
-            await recordRunStart(tempDir, 'T-01');
-            expect(fs.existsSync(filePath)).toBe(true);
-        });
-
-        it('should survive corrupted JSON (start fresh)', async () => {
-            const filePath = path.join(tempDir, NOCTURNAL_RUNTIME_FILE);
-            fs.mkdirSync(path.dirname(filePath), { recursive: true });
-            fs.writeFileSync(filePath, '{ corrupted json }', 'utf-8');
-
-            const state = await getRuntimeState(tempDir);
-            // Should return default state, not throw
-            expect(state.principleCooldowns).toEqual({});
-            expect(state.recentRunTimestamps).toEqual([]);
-        });
-
-        it('should read persisted cooldown on restart', async () => {
-            await recordRunStart(tempDir, 'T-01');
-            await recordRunEnd(tempDir, 'success');
-
-            // Simulate restart by re-reading
-            const state = await getRuntimeState(tempDir);
-            expect(state.lastSuccessfulRunAt).toBeTruthy();
-            expect(state.principleCooldowns['T-01']).toBeTruthy();
-        });
-    });
-});