principles-disciple 1.72.0 → 1.74.0

package/tests/service/evolution-worker.nocturnal.test.ts

@@ -1,601 +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';
-
-vi.mock('../../src/core/dictionary-service.js', () => ({
-  DictionaryService: {
-    get: vi.fn(() => ({ flush: vi.fn() })),
-  },
-}));
-
-vi.mock('../../src/core/session-tracker.js', () => ({
-  initPersistence: vi.fn(),
-  flushAllSessions: vi.fn(),
-  listSessions: vi.fn(() => []),
-}));
-
-const { mockStartWorkflow, mockGetWorkflowDebugSummary } = vi.hoisted(() => ({
-  mockStartWorkflow: vi.fn(),
-  mockGetWorkflowDebugSummary: vi.fn(),
-}));
-
-vi.mock('../../src/service/subagent-workflow/nocturnal-workflow-manager.js', () => ({
-  NocturnalWorkflowManager: class {
-    startWorkflow = mockStartWorkflow;
-    getWorkflowDebugSummary = mockGetWorkflowDebugSummary;
-  },
-  nocturnalWorkflowSpec: {
-    workflowType: 'nocturnal',
-    transport: 'runtime_direct',
-    timeoutMs: 15 * 60 * 1000,
-    ttlMs: 30 * 60 * 1000,
-  },
-}));
-
-const { mockGetNocturnalSessionSnapshot, mockListRecentNocturnalCandidateSessions } = vi.hoisted(() => ({
-  mockGetNocturnalSessionSnapshot: vi.fn(),
-  mockListRecentNocturnalCandidateSessions: vi.fn(() => [] as Array<{ sessionId: string; startedAt: string; failureCount: number; painEventCount: number; gateBlockCount: number }>),
-}));
-
-// Create a shared mock extractor instance so spy calls are tracked correctly
-const mockExtractorInstance = {
-  getNocturnalSessionSnapshot: mockGetNocturnalSessionSnapshot,
-  listRecentNocturnalCandidateSessions: mockListRecentNocturnalCandidateSessions,
-};
-
-vi.mock('../../src/core/nocturnal-trajectory-extractor.js', async () => {
-  const actual = await vi.importActual<typeof import('../../src/core/nocturnal-trajectory-extractor.js')>(
-    '../../src/core/nocturnal-trajectory-extractor.js'
-  );
-  return {
-    ...actual,
-    createNocturnalTrajectoryExtractor: vi.fn(() => mockExtractorInstance),
-  };
-});
-
-import { EvolutionWorkerService } from '../../src/service/evolution-worker.js';
-import { readRecentPainContext } from '../../src/service/evolution-pain-context.js';
-import { WorkspaceContext } from '../../src/core/workspace-context.js';
-import { handlePdReflect } from '../../src/commands/pd-reflect.js';
-import { safeRmDir } from '../test-utils.js';
-import * as diagnosticianStore from '../../src/core/diagnostician-task-store.js';
-
-// Helper to create a mock API for E2E tests
-function createMockApi() {
-  return {
-    logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
-    runtime: { 
-        agent: { runEmbeddedPiAgent: vi.fn() },
-        system: { 
-            requestHeartbeatNow: vi.fn(),
-            runHeartbeatOnce: vi.fn()
-        } 
-    },
-  } as any;
-}
-
-// Helper config for fast poll cycle
-const fastPollConfig = { get: (k: string) => k === 'intervals.worker_poll_ms' ? 100 : undefined };
-
-function readQueue(stateDir: string) {
-  return JSON.parse(fs.readFileSync(path.join(stateDir, 'evolution_queue.json'), 'utf8'));
-}
-
-describe('EvolutionWorkerService nocturnal hardening', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    vi.clearAllMocks();
-    EvolutionWorkerService.api = null;
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-    EvolutionWorkerService.api = null;
-  });
-
-  it('extracts session_id from .pain_flag file correctly', async () => {
-    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-pain-session-'));
-    const stateDir = path.join(workspaceDir, '.state');
-    fs.mkdirSync(stateDir, { recursive: true });
-
-    // Write a pain flag WITH session_id
-    fs.writeFileSync(
-      path.join(stateDir, '.pain_flag'),
-      `source: test_pain
-score: 80
-reason: test reason
-time: 2026-04-10T00:00:00.000Z
-session_id: explicit-session-from-pain
-`,
-      'utf8'
-    );
-
-    // Create a WorkspaceContext to test the function
-    const wctx = WorkspaceContext.fromHookContext({ workspaceDir, stateDir, logger: console } as any);
-
-    try {
-      const context = readRecentPainContext(wctx);
-
-      // Verify the session_id was extracted from the pain flag file
-      expect(context.mostRecent).toBeDefined();
-      expect(context.mostRecent!.sessionId).toBe('explicit-session-from-pain');
-      expect(context.mostRecent!.score).toBe(80);
-      expect(context.recentPainCount).toBe(1);
-    } finally {
-      safeRmDir(workspaceDir);
-    }
-  });
-
-  it('treats malformed pain flag data as unusable context', async () => {
-    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-pain-invalid-'));
-    const stateDir = path.join(workspaceDir, '.state');
-    fs.mkdirSync(stateDir, { recursive: true });
-
-    fs.writeFileSync(
-      path.join(stateDir, '.pain_flag'),
-      `source: test_pain
-score: 80`,
-      'utf8'
-    );
-
-    const wctx = WorkspaceContext.fromHookContext({ workspaceDir, stateDir, logger: console } as any);
-
-    try {
-      const context = readRecentPainContext(wctx);
-      expect(context.mostRecent).toBeNull();
-      expect(context.recentPainCount).toBe(0);
-    } finally {
-      safeRmDir(workspaceDir);
-    }
-  });
-
-  // === End-to-End Contract Tests ===
-
-  it('e2e: pain flag → worker enqueue → session_id is correctly attached to queued task', async () => {
-    // This test verifies the contract: when a pain flag with session_id exists,
-    // any sleep_reflection task created by the worker MUST carry that session_id
-    // in its recentPainContext.mostRecent.sessionId field.
-    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-e2e-pain-enqueue-'));
-    const stateDir = path.join(workspaceDir, '.state');
-    fs.mkdirSync(stateDir, { recursive: true });
-
-    // Write a pain flag WITH session_id
-    fs.writeFileSync(
-      path.join(stateDir, '.pain_flag'),
-      `source: tool_failure
-score: 70
-reason: Test pain with session
-time: 2026-04-10T00:00:00.000Z
-session_id: pain-session-abc
-`,
-      'utf8'
-    );
-
-    // Verify the worker's readRecentPainContext extracts the session_id correctly
-    const wctx = WorkspaceContext.fromHookContext({ workspaceDir, stateDir, logger: console } as any);
-    const painContext = readRecentPainContext(wctx);
-
-    // Contract: session_id must be extracted from the pain flag
-    expect(painContext.mostRecent).toBeDefined();
-    expect(painContext.mostRecent!.sessionId).toBe('pain-session-abc');
-    expect(painContext.mostRecent!.score).toBe(70);
-    expect(painContext.mostRecent!.source).toBe('tool_failure');
-
-    // Now simulate what the worker does: attach this context to a queued task
-    const simulatedTask = {
-      id: 'simulated-task',
-      taskKind: 'sleep_reflection',
-      recentPainContext: painContext,
-    };
-
-    // Verify the contract holds end-to-end
-    expect(simulatedTask.recentPainContext.mostRecent!.sessionId).toBe('pain-session-abc');
-  });
-
-  it('e2e: /pd-reflect command writes to workspace/.state, never to HOME/.state', async () => {
-    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-e2e-command-writes-'));
-    const stateDir = path.join(workspaceDir, '.state');
-    fs.mkdirSync(stateDir, { recursive: true });
-    fs.mkdirSync(path.join(stateDir, 'sessions'), { recursive: true });
-
-    // Ensure HOME/.state does NOT have the queue file
-    const homeState = path.join(os.homedir(), '.state');
-    const homeQueue = path.join(homeState, 'evolution_queue.json');
-    const homeExistedBefore = fs.existsSync(homeQueue);
-
-    try {
-      // Execute the command with explicit workspaceDir
-      const result = await handlePdReflect.handler({
-        workspaceDir,
-        channel: 'test',
-        isAuthorizedSender: true,
-        commandBody: '',
-        config: {},
-        api: { logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() } } as any,
-      } as any);
-
-      // Command should succeed
-      expect(result.isError).toBeFalsy();
-      expect(result.text).toContain('enqueued');
-
-      // Queue file should exist in workspace
-      const workspaceQueue = path.join(stateDir, 'evolution_queue.json');
-      expect(fs.existsSync(workspaceQueue)).toBe(true);
-
-      // Verify the task is in the workspace queue
-      const queue = readQueue(stateDir);
-      const manualTasks = queue.filter((t: any) => t.id.startsWith('manual_'));
-      expect(manualTasks.length).toBe(1);
-      expect(manualTasks[0].taskKind).toBe('sleep_reflection');
-
-      // HOME/.state/evolution_queue.json should NOT have been created/modified by this command
-      if (!homeExistedBefore) {
-        expect(fs.existsSync(homeQueue)).toBe(false);
-      }
-    } finally {
-      safeRmDir(workspaceDir);
-    }
-  });
-
-  // === Nocturnal E2E Pipeline Tests (from PR #243) ===
-
-  it('does not start a nocturnal workflow when only an empty fallback snapshot is available', async () => {
-    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-nocturnal-empty-'));
-    const stateDir = path.join(workspaceDir, '.state');
-    fs.mkdirSync(path.join(stateDir, 'sessions'), { recursive: true });
-    fs.mkdirSync(path.join(stateDir, 'logs'), { recursive: true });
-
-    mockGetNocturnalSessionSnapshot.mockReturnValue(null);
-
-    fs.writeFileSync(
-      path.join(stateDir, 'evolution_queue.json'),
-      JSON.stringify([
-        {
-          id: 'sleep-empty',
-          taskKind: 'sleep_reflection',
-          priority: 'medium',
-          score: 50,
-          source: 'nocturnal',
-          reason: 'Sleep reflection',
-          timestamp: '2026-04-10T00:00:00.000Z',
-          enqueued_at: '2026-04-10T00:00:00.000Z',
-          status: 'pending',
-          retryCount: 0,
-          maxRetries: 1,
-          recentPainContext: {
-            mostRecent: null,
-            recentPainCount: 0,
-            recentMaxPainScore: 0,
-          },
-        },
-      ], null, 2),
-      'utf8'
-    );
-
-    const mockApi = createMockApi();
-    EvolutionWorkerService.api = mockApi;
-
-    try {
-      EvolutionWorkerService.start({
-        workspaceDir,
-        stateDir,
-        logger: mockApi.logger,
-        config: fastPollConfig,
-        api: mockApi,
-      } as any);
-
-      await vi.advanceTimersByTimeAsync(6000);
-
-      const queue = readQueue(stateDir);
-      expect(queue[0].status).toBe('failed');
-      expect(queue[0].lastError).toContain('invalid_snapshot_ingress');
-      expect(queue[0].lastError).toContain('fallback snapshot must contain at least one pain signal');
-      expect(queue[0].resultRef).toBeFalsy();
-      expect(mockStartWorkflow).not.toHaveBeenCalled();
-    } finally {
-      EvolutionWorkerService.stop!({ workspaceDir, stateDir, logger: console } as any);
-      safeRmDir(workspaceDir);
-    }
-  });
-
-  it('uses stub_fallback for expected gateway-only background unavailability', async () => {
-    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-nocturnal-gateway-'));
-    const stateDir = path.join(workspaceDir, '.state');
-    fs.mkdirSync(path.join(stateDir, 'sessions'), { recursive: true });
-    fs.mkdirSync(path.join(stateDir, 'logs'), { recursive: true });
-
-    mockGetNocturnalSessionSnapshot.mockReturnValue({
-      sessionId: 'sleep-gateway',
-      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 },
-    });
-    mockStartWorkflow.mockResolvedValue({ workflowId: 'wf-1', childSessionKey: 'child-1', state: 'active' });
-    mockGetWorkflowDebugSummary.mockResolvedValue({
-      state: 'terminal_error',
-      metadata: {},
-      recentEvents: [{ reason: 'Error: Plugin runtime subagent methods are only available during a gateway request.', payload: {} }],
-    });
-
-    fs.writeFileSync(
-      path.join(stateDir, 'evolution_queue.json'),
-      JSON.stringify([
-        {
-          id: 'sleep-gateway',
-          taskKind: 'sleep_reflection',
-          priority: 'medium',
-          score: 50,
-          source: 'nocturnal',
-          reason: 'Sleep reflection',
-          timestamp: '2026-04-10T00:00:00.000Z',
-          enqueued_at: '2026-04-10T00:00:00.000Z',
-          status: 'pending',
-          retryCount: 0,
-          maxRetries: 1,
-          recentPainContext: {
-            mostRecent: { source: 'test', score: 50, reason: 'test', timestamp: '2026-04-10T00:00:00.000Z', sessionId: 'sleep-gateway' },
-            recentPainCount: 1,
-            recentMaxPainScore: 50,
-          },
-        },
-      ], null, 2),
-      'utf8'
-    );
-
-    const mockApi = createMockApi();
-    EvolutionWorkerService.api = mockApi;
-
-    try {
-      EvolutionWorkerService.start({
-        workspaceDir,
-        stateDir,
-        logger: mockApi.logger,
-        config: fastPollConfig,
-        api: mockApi,
-      } as any);
-
-      await vi.advanceTimersByTimeAsync(6000);
-
-      const queue = readQueue(stateDir);
-      expect(queue[0].status).toBe('completed');
-      expect(queue[0].resolution).toBe('stub_fallback');
-    } finally {
-      EvolutionWorkerService.stop!({ workspaceDir, stateDir, logger: console } as any);
-      safeRmDir(workspaceDir);
-    }
-  });
-
-  it('uses stub_fallback for expected subagent runtime unavailability', async () => {
-    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-nocturnal-subagent-'));
-    const stateDir = path.join(workspaceDir, '.state');
-    fs.mkdirSync(path.join(stateDir, 'sessions'), { recursive: true });
-    fs.mkdirSync(path.join(stateDir, 'logs'), { recursive: true });
-
-    mockGetNocturnalSessionSnapshot.mockReturnValue({
-      sessionId: 'sleep-subagent',
-      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 },
-    });
-    mockStartWorkflow.mockRejectedValue(new Error('NocturnalWorkflowManager: subagent runtime unavailable'));
-
-    fs.writeFileSync(
-      path.join(stateDir, 'evolution_queue.json'),
-      JSON.stringify([
-        {
-          id: 'sleep-subagent',
-          taskKind: 'sleep_reflection',
-          priority: 'medium',
-          score: 50,
-          source: 'nocturnal',
-          reason: 'Sleep reflection',
-          timestamp: '2026-04-10T00:00:00.000Z',
-          enqueued_at: '2026-04-10T00:00:00.000Z',
-          status: 'pending',
-          retryCount: 0,
-          maxRetries: 1,
-          recentPainContext: {
-            mostRecent: { source: 'test', score: 50, reason: 'test', timestamp: '2026-04-10T00:00:00.000Z', sessionId: 'sleep-subagent' },
-            recentPainCount: 1,
-            recentMaxPainScore: 50,
-          },
-        },
-      ], null, 2),
-      'utf8'
-    );
-
-    const mockApi = createMockApi();
-    EvolutionWorkerService.api = mockApi;
-
-    try {
-      EvolutionWorkerService.start({
-        workspaceDir,
-        stateDir,
-        logger: mockApi.logger,
-        config: fastPollConfig,
-        api: mockApi,
-      } as any);
-
-      await vi.advanceTimersByTimeAsync(6000);
-
-      const queue = readQueue(stateDir);
-      expect(queue[0].status).toBe('completed');
-      expect(queue[0].resolution).toBe('stub_fallback');
-    } finally {
-      EvolutionWorkerService.stop!({ workspaceDir, stateDir, logger: console } as any);
-      safeRmDir(workspaceDir);
-    }
-  });
-
-  it('prioritizes pain signal session ID for snapshot extraction', async () => {
-    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-nocturnal-pain-session-'));
-    const stateDir = path.join(workspaceDir, '.state');
-    fs.mkdirSync(path.join(stateDir, 'sessions'), { recursive: true });
-    fs.mkdirSync(path.join(stateDir, 'logs'), { recursive: true });
-
-    const painSessionId = 'pain-signal-session-123';
-
-    mockGetNocturnalSessionSnapshot.mockImplementation((sessionId: string) => {
-      if (sessionId === painSessionId) {
-        return {
-          sessionId: painSessionId,
-          startedAt: '2026-04-09T23:00:00.000Z',
-          updatedAt: '2026-04-09T23:01:00.000Z',
-          assistantTurns: [],
-          userTurns: [],
-          toolCalls: [],
-          painEvents: [{ source: 'tool_failure', score: 70, severity: null, reason: 'test', createdAt: '2026-04-09T23:00:00.000Z' }],
-          gateBlocks: [],
-          stats: { totalAssistantTurns: 1, totalToolCalls: 1, failureCount: 1, totalPainEvents: 1, totalGateBlocks: 0 },
-        };
-      }
-      return null;
-    });
-    mockStartWorkflow.mockResolvedValue({ workflowId: 'wf-pain', childSessionKey: 'child-pain', state: 'active' });
-
-    fs.writeFileSync(
-      path.join(stateDir, 'evolution_queue.json'),
-      JSON.stringify([
-        {
-          id: 'sleep-pain-priority',
-          taskKind: 'sleep_reflection',
-          priority: 'medium',
-          score: 50,
-          source: 'nocturnal',
-          reason: 'Sleep reflection',
-          timestamp: '2026-04-10T00:00:00.000Z',
-          enqueued_at: '2026-04-10T00:00:00.000Z',
-          status: 'pending',
-          retryCount: 0,
-          maxRetries: 1,
-          recentPainContext: {
-            mostRecent: { source: 'tool_failure', score: 70, reason: 'test', timestamp: '2026-04-10T00:00:00.000Z', sessionId: painSessionId },
-            recentPainCount: 1,
-            recentMaxPainScore: 70,
-          },
-        },
-      ], null, 2),
-      'utf8'
-    );
-
-    const mockApi = createMockApi();
-    EvolutionWorkerService.api = mockApi;
-
-    try {
-      EvolutionWorkerService.start({
-        workspaceDir,
-        stateDir,
-        logger: mockApi.logger,
-        config: fastPollConfig,
-        api: mockApi,
-      } as any);
-
-      await vi.advanceTimersByTimeAsync(6000);
-
-      expect(mockStartWorkflow).toHaveBeenCalledTimes(1);
-      const metadata = mockStartWorkflow.mock.calls[0][1].metadata;
-      expect(metadata.snapshot.sessionId).toBe(painSessionId);
-    } finally {
-      EvolutionWorkerService.stop!({ workspaceDir, stateDir, logger: console } as any);
-      safeRmDir(workspaceDir);
-    }
-  });
-
-  it('e2e: bounded session selection — never picks a session newer than the triggering task', async () => {
-    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-nocturnal-e2e-bounded-'));
-    const stateDir = path.join(workspaceDir, '.state');
-    fs.mkdirSync(path.join(stateDir, 'sessions'), { recursive: true });
-    fs.mkdirSync(path.join(stateDir, 'logs'), { recursive: true });
-
-    const taskTimestamp = '2026-04-10T00:00:00.000Z';
-    const validSessionTimestamp = '2026-04-09T23:00:00.000Z';
-    const invalidSessionTimestamp = '2026-04-10T01:00:00.000Z';
-
-    mockGetNocturnalSessionSnapshot.mockImplementation((sessionId: string) => {
-      if (sessionId === 'valid-session') {
-        return {
-          sessionId: 'valid-session',
-          startedAt: validSessionTimestamp,
-          updatedAt: validSessionTimestamp,
-          assistantTurns: [],
-          userTurns: [],
-          toolCalls: [],
-          painEvents: [{ source: 'tool_failure', score: 50, severity: null, reason: 'test', createdAt: validSessionTimestamp }],
-          gateBlocks: [],
-          stats: { totalAssistantTurns: 1, totalToolCalls: 1, failureCount: 1, totalPainEvents: 1, totalGateBlocks: 0 },
-        };
-      }
-      return null;
-    });
-    mockListRecentNocturnalCandidateSessions.mockReturnValue([
-      { sessionId: 'valid-session', startedAt: validSessionTimestamp, failureCount: 1, painEventCount: 1, gateBlockCount: 0 },
-      { sessionId: 'invalid-session', startedAt: invalidSessionTimestamp, failureCount: 1, painEventCount: 0, gateBlockCount: 0 },
-    ]);
-    mockStartWorkflow.mockResolvedValue({ workflowId: 'wf-bounded', childSessionKey: 'child-bounded', state: 'active' });
-
-    fs.writeFileSync(
-      path.join(stateDir, 'evolution_queue.json'),
-      JSON.stringify([
-        {
-          id: 'sleep-e2e-bounded',
-          taskKind: 'sleep_reflection',
-          priority: 'medium',
-          score: 50,
-          source: 'nocturnal',
-          reason: 'Sleep reflection',
-          timestamp: taskTimestamp,
-          enqueued_at: taskTimestamp,
-          status: 'pending',
-          retryCount: 0,
-          maxRetries: 1,
-          recentPainContext: {
-            mostRecent: { source: 'test', score: 50, reason: 'test', timestamp: taskTimestamp, sessionId: 'pain-session' },
-            recentPainCount: 1,
-            recentMaxPainScore: 50,
-          },
-        },
-      ], null, 2),
-      'utf8'
-    );
-
-    const mockApi = createMockApi();
-    EvolutionWorkerService.api = mockApi;
-
-    try {
-      EvolutionWorkerService.start({
-        workspaceDir,
-        stateDir,
-        logger: mockApi.logger,
-        config: fastPollConfig,
-        api: mockApi,
-      } as any);
-
-      await vi.advanceTimersByTimeAsync(6000);
-
-      expect(mockStartWorkflow).toHaveBeenCalledTimes(1);
-      const metadata = mockStartWorkflow.mock.calls[0][1].metadata;
-      expect(metadata.snapshot.sessionId).toBe('valid-session');
-      expect(new Date(metadata.snapshot.startedAt).getTime()).toBeLessThanOrEqual(new Date(taskTimestamp).getTime());
-    } finally {
-      EvolutionWorkerService.stop!({ workspaceDir, stateDir, logger: console } as any);
-      safeRmDir(workspaceDir);
-    }
-  });
-
-  // === PR #307 Fixes: Pain Diagnosis Timeout & Heartbeat Retry ===
-
-  // Note: Testing requestHeartbeatNow call directly is complex due to 
-  // the async nature of checkPainFlag → doEnqueuePainTask → requestHeartbeatNow.
-  // The fix is verified via E2E monitoring (PR #307 production verification).
-});