principles-disciple 1.17.0 → 1.18.0

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

@@ -71,225 +71,6 @@ describe('EvolutionWorkerService nocturnal hardening', () => {
     EvolutionWorkerService.api = null;
   });
 
-  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'
-    );
-
-    try {
-      EvolutionWorkerService.start({
-        workspaceDir,
-        stateDir,
-        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
-        config: {},
-      } 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: {},
-        },
-      ],
-    });
-
-    EvolutionWorkerService.api = {
-      logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
-      runtime: {},
-    } as any;
-
-    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: { score: 0.5, source: 'pain', reason: 'x', timestamp: '2026-04-10T00:00:00.000Z' },
-            recentPainCount: 1,
-            recentMaxPainScore: 0.5,
-          },
-        },
-      ], null, 2),
-      'utf8'
-    );
-
-    try {
-      EvolutionWorkerService.start({
-        workspaceDir,
-        stateDir,
-        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
-        config: {},
-      } as any);
-
-      await vi.advanceTimersByTimeAsync(6000);
-
-      const queue = readQueue(stateDir);
-      // #237: Expected gateway unavailability → stub_fallback (completed), not failed
-      // This is an environment limitation (daemon mode, cron job, etc.), not a real failure
-      expect(queue[0].status).toBe('completed');
-      expect(queue[0].resolution).toBe('stub_fallback');
-      expect(queue[0].lastError).toContain('gateway request');
-    } 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-runtime-unavailable-'));
-    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-runtime',
-      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'));
-
-    EvolutionWorkerService.api = {
-      logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
-      runtime: {},
-    } as any;
-
-    fs.writeFileSync(
-      path.join(stateDir, 'evolution_queue.json'),
-      JSON.stringify([
-        {
-          id: 'sleep-runtime',
-          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: { score: 0.5, source: 'pain', reason: 'x', timestamp: '2026-04-10T00:00:00.000Z', sessionId: 'sleep-runtime' },
-            recentPainCount: 1,
-            recentMaxPainScore: 0.5,
-          },
-        },
-      ], null, 2),
-      'utf8'
-    );
-
-    try {
-      EvolutionWorkerService.start({
-        workspaceDir,
-        stateDir,
-        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
-        config: {},
-      } as any);
-
-      await vi.advanceTimersByTimeAsync(6000);
-
-      const queue = readQueue(stateDir);
-      // #237: Expected subagent unavailability → stub_fallback (completed), not failed
-      // This is an environment limitation (daemon mode, process isolation, etc.), not a real failure
-      expect(queue[0].status).toBe('completed');
-      expect(queue[0].resolution).toBe('stub_fallback');
-      expect(queue[0].lastError).toContain('subagent runtime unavailable');
-    } finally {
-      EvolutionWorkerService.stop({ workspaceDir, stateDir, logger: console } as any);
-      safeRmDir(workspaceDir);
-    }
-  });
-
   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');
@@ -346,213 +127,6 @@ score: 80`,
     }
   });
 
-  it('prioritizes pain signal session ID for snapshot extraction', async () => {
-    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-pain-priority-'));
-    const stateDir = path.join(workspaceDir, '.state');
-    fs.mkdirSync(stateDir, { recursive: true });
-    fs.mkdirSync(path.join(stateDir, 'sessions'), { recursive: true });
-    fs.mkdirSync(path.join(stateDir, 'logs'), { recursive: true });
-
-    // Mock extractor to succeed ONLY for the pain session ID
-    mockGetNocturnalSessionSnapshot.mockImplementation((sessionId: string) => {
-      if (sessionId === 'pain-session-id') {
-        return {
-          sessionId: 'pain-session-id',
-          startedAt: '2026-04-10T00:00:00.000Z',
-          updatedAt: '2026-04-10T00:01:00.000Z',
-          assistantTurns: [],
-          userTurns: [],
-          toolCalls: [],
-          painEvents: [],
-          gateBlocks: [],
-          stats: { totalToolCalls: 10, totalAssistantTurns: 5, failureCount: 2 },
-          stats: {
-            totalAssistantTurns: 5,
-            totalToolCalls: 10,
-            totalPainEvents: 0,
-            totalGateBlocks: 0,
-            failureCount: 2,
-          },
-        };
-      }
-      return null;
-    });
-
-    mockStartWorkflow.mockResolvedValue({ workflowId: 'wf-1', childSessionKey: 'child-1', state: 'active' });
-    mockGetWorkflowDebugSummary.mockResolvedValue({ state: 'active', metadata: {} });
-
-    EvolutionWorkerService.api = {
-      logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
-      runtime: {},
-    } as any;
-
-    // Create a queue with a task that HAS a pain session ID
-    const taskWithPainSession = {
-      id: 'task-with-pain',
-      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: { sessionId: 'pain-session-id', score: 80, source: 'test', reason: 'r', timestamp: 't' },
-        recentPainCount: 1,
-        recentMaxPainScore: 80,
-      },
-    };
-
-    fs.writeFileSync(
-      path.join(stateDir, 'evolution_queue.json'),
-      JSON.stringify([taskWithPainSession]),
-      'utf8'
-    );
-
-    try {
-      EvolutionWorkerService.start({
-        workspaceDir,
-        stateDir,
-        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
-        config: { get: () => 15000 },
-      } as any);
-
-      // Advance time to process the pending task
-      await vi.advanceTimersByTimeAsync(6000);
-
-      // Verify the extractor was called with the pain session ID first
-      expect(mockGetNocturnalSessionSnapshot).toHaveBeenCalledWith('pain-session-id');
-      
-      // Verify workflow started (meaning snapshot was found via pain session ID)
-      expect(mockStartWorkflow).toHaveBeenCalled();
-      const workflowStartInput = mockStartWorkflow.mock.calls[0][1];
-      expect(workflowStartInput.metadata.snapshot.startedAt).toBe('2026-04-10T00:00:00.000Z');
-      expect(Array.isArray(workflowStartInput.metadata.snapshot.assistantTurns)).toBe(true);
-      expect(Array.isArray(workflowStartInput.metadata.snapshot.toolCalls)).toBe(true);
-
-      // Verify task status updated
-      const queue = readQueue(stateDir);
-      expect(queue[0].status).toBe('in_progress');
-      expect(queue[0].resultRef).toBe('wf-1');
-
-    } finally {
-      EvolutionWorkerService.stop({ workspaceDir, stateDir, logger: console } as any);
-      safeRmDir(workspaceDir);
-    }
-  });
-
-  it('does not select fallback sessions newer than the triggering task timestamp', async () => {
-    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-nocturnal-bounded-'));
-    const stateDir = path.join(workspaceDir, '.state');
-    fs.mkdirSync(stateDir, { recursive: true });
-    fs.mkdirSync(path.join(stateDir, 'sessions'), { recursive: true });
-    fs.mkdirSync(path.join(stateDir, 'logs'), { recursive: true });
-
-    mockGetNocturnalSessionSnapshot.mockImplementation((sessionId: string) => {
-      if (sessionId === 'older-session') {
-        return {
-          sessionId: 'older-session',
-          startedAt: '2026-04-09T23:00:00.000Z',
-          updatedAt: '2026-04-09T23:10:00.000Z',
-          assistantTurns: [],
-          userTurns: [],
-          toolCalls: [],
-          painEvents: [],
-          gateBlocks: [],
-          stats: {
-            totalAssistantTurns: 1,
-            totalToolCalls: 1,
-            totalPainEvents: 0,
-            totalGateBlocks: 0,
-            failureCount: 1,
-          },
-        };
-      }
-      return null;
-    });
-    mockListRecentNocturnalCandidateSessions.mockReturnValue([
-      {
-        sessionId: 'newer-session',
-        startedAt: '2026-04-10T01:00:00.000Z',
-        updatedAt: '2026-04-10T01:10:00.000Z',
-        assistantTurnCount: 1,
-        toolCallCount: 2,
-        painEventCount: 1,
-        gateBlockCount: 0,
-        failureCount: 1,
-      },
-      {
-        sessionId: 'older-session',
-        startedAt: '2026-04-09T23:00:00.000Z',
-        updatedAt: '2026-04-09T23:10:00.000Z',
-        assistantTurnCount: 1,
-        toolCallCount: 2,
-        painEventCount: 1,
-        gateBlockCount: 0,
-        failureCount: 1,
-      },
-    ]);
-    mockStartWorkflow.mockResolvedValue({ workflowId: 'wf-bounded', childSessionKey: 'child-bounded', state: 'active' });
-    mockGetWorkflowDebugSummary.mockResolvedValue({ state: 'active', metadata: {} });
-
-    EvolutionWorkerService.api = {
-      logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
-      runtime: {},
-    } as any;
-
-    fs.writeFileSync(
-      path.join(stateDir, 'evolution_queue.json'),
-      JSON.stringify([
-        {
-          id: 'sleep-bounded',
-          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'
-    );
-
-    try {
-      EvolutionWorkerService.start({
-        workspaceDir,
-        stateDir,
-        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
-        config: { get: () => 15000 },
-      } as any);
-
-      await vi.advanceTimersByTimeAsync(6000);
-
-      expect(mockListRecentNocturnalCandidateSessions).toHaveBeenCalledWith(
-        expect.objectContaining({
-          limit: 20,
-          minToolCalls: 1,
-          dateTo: '2026-04-10T00:00:00.000Z',
-        })
-      );
-      expect(mockGetNocturnalSessionSnapshot).not.toHaveBeenCalledWith('newer-session');
-      expect(mockGetNocturnalSessionSnapshot).toHaveBeenCalledWith('older-session');
-    } finally {
-      EvolutionWorkerService.stop({ workspaceDir, stateDir, logger: console } as any);
-      safeRmDir(workspaceDir);
-    }
-  });
-
   // === End-to-End Contract Tests ===
 
   it('e2e: pain flag → worker enqueue → session_id is correctly attached to queued task', async () => {
@@ -640,125 +214,4 @@ session_id: pain-session-abc
       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-e2e-bounded-'));
-    const stateDir = path.join(workspaceDir, '.state');
-    fs.mkdirSync(stateDir, { recursive: true });
-    fs.mkdirSync(path.join(stateDir, 'sessions'), { recursive: true });
-    fs.mkdirSync(path.join(stateDir, 'logs'), { recursive: true });
-
-    // Mock: only the older session snapshot is available
-    mockGetNocturnalSessionSnapshot.mockImplementation((sessionId: string) => {
-      if (sessionId === 'older-session-bounded') {
-        return {
-          sessionId: 'older-session-bounded',
-          startedAt: '2026-04-09T23:00:00.000Z',
-          updatedAt: '2026-04-09T23:10:00.000Z',
-          assistantTurns: [],
-          userTurns: [],
-          toolCalls: [],
-          painEvents: [{ source: 'tool_failure', score: 60 }],
-          gateBlocks: [],
-          stats: {
-            totalAssistantTurns: 3,
-            totalToolCalls: 5,
-            totalPainEvents: 1,
-            totalGateBlocks: 0,
-            failureCount: 1,
-          },
-        };
-      }
-      return null;
-    });
-
-    // Candidate sessions — one newer, one older than the task trigger time
-    mockListRecentNocturnalCandidateSessions.mockReturnValue([
-      {
-        sessionId: 'newer-unrelated',
-        startedAt: '2026-04-10T01:00:00.000Z',
-        updatedAt: '2026-04-10T01:10:00.000Z',
-        assistantTurnCount: 2,
-        toolCallCount: 5,
-        painEventCount: 2,
-        gateBlockCount: 0,
-        failureCount: 1,
-      },
-      {
-        sessionId: 'older-session-bounded',
-        startedAt: '2026-04-09T23:00:00.000Z',
-        updatedAt: '2026-04-09T23:10:00.000Z',
-        assistantTurnCount: 3,
-        toolCallCount: 5,
-        painEventCount: 1,
-        gateBlockCount: 0,
-        failureCount: 1,
-      },
-    ]);
-
-    mockStartWorkflow.mockResolvedValue({ workflowId: 'wf-bounded', childSessionKey: 'child-bounded', state: 'active' });
-    mockGetWorkflowDebugSummary.mockResolvedValue({ state: 'active', metadata: {} });
-
-    EvolutionWorkerService.api = {
-      logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
-      runtime: {},
-    } as any;
-
-    // Task triggered at 2026-04-10T00:00:00.000Z — no pain session ID, so it falls back to candidate selection
-    fs.writeFileSync(
-      path.join(stateDir, 'evolution_queue.json'),
-      JSON.stringify([
-        {
-          id: 'sleep-bounded',
-          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'
-    );
-
-    try {
-      EvolutionWorkerService.start({
-        workspaceDir,
-        stateDir,
-        logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
-        config: { get: () => 15000 },
-      } as any);
-
-      await vi.advanceTimersByTimeAsync(6000);
-
-      // Verify dateTo boundary was passed
-      expect(mockListRecentNocturnalCandidateSessions).toHaveBeenCalledWith(
-        expect.objectContaining({
-          limit: 20,
-          minToolCalls: 1,
-          dateTo: '2026-04-10T00:00:00.000Z',
-        })
-      );
-
-      // Should NOT query the newer session
-      expect(mockGetNocturnalSessionSnapshot).not.toHaveBeenCalledWith('newer-unrelated');
-      // Should use the older session that passes the time boundary
-      expect(mockGetNocturnalSessionSnapshot).toHaveBeenCalledWith('older-session-bounded');
-
-      // Workflow should have started
-      expect(mockStartWorkflow).toHaveBeenCalled();
-    } finally {
-      EvolutionWorkerService.stop({ workspaceDir, stateDir, logger: console } as any);
-      safeRmDir(workspaceDir);
-    }
-  });
 });