principles-disciple 1.16.0 → 1.17.0

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

@@ -33,8 +33,9 @@ vi.mock('../../src/service/subagent-workflow/nocturnal-workflow-manager.js', ()
   },
 }));
 
-const { mockGetNocturnalSessionSnapshot } = vi.hoisted(() => ({
+const { mockGetNocturnalSessionSnapshot, mockListRecentNocturnalCandidateSessions } = vi.hoisted(() => ({
   mockGetNocturnalSessionSnapshot: vi.fn(),
+  mockListRecentNocturnalCandidateSessions: vi.fn(() => []),
 }));
 vi.mock('../../src/core/nocturnal-trajectory-extractor.js', async () => {
   const actual = await vi.importActual<typeof import('../../src/core/nocturnal-trajectory-extractor.js')>(
@@ -44,11 +45,14 @@ vi.mock('../../src/core/nocturnal-trajectory-extractor.js', async () => {
     ...actual,
     createNocturnalTrajectoryExtractor: vi.fn(() => ({
       getNocturnalSessionSnapshot: mockGetNocturnalSessionSnapshot,
+      listRecentNocturnalCandidateSessions: mockListRecentNocturnalCandidateSessions,
     })),
   };
 });
 
-import { EvolutionWorkerService } from '../../src/service/evolution-worker.js';
+import { EvolutionWorkerService, readRecentPainContext } from '../../src/service/evolution-worker.js';
+import { WorkspaceContext } from '../../src/core/workspace-context.js';
+import { handlePdReflect } from '../../src/commands/pd-reflect.js';
 import { safeRmDir } from '../test-utils.js';
 
 function readQueue(stateDir: string) {
@@ -112,7 +116,8 @@ describe('EvolutionWorkerService nocturnal hardening', () => {
 
       const queue = readQueue(stateDir);
       expect(queue[0].status).toBe('failed');
-      expect(queue[0].lastError).toContain('missing_usable_snapshot');
+      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 {
@@ -121,7 +126,7 @@ describe('EvolutionWorkerService nocturnal hardening', () => {
     }
   });
 
-  it('keeps gateway-only background failures as failed instead of completed stub fallback', async () => {
+  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 });
@@ -197,12 +202,563 @@ describe('EvolutionWorkerService nocturnal hardening', () => {
       await vi.advanceTimersByTimeAsync(6000);
 
       const queue = readQueue(stateDir);
-      expect(queue[0].status).toBe('failed');
-      expect(queue[0].resolution).toBe('failed_max_retries');
+      // #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');
+    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);
+    }
+  });
+
+  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 () => {
+    // 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);
+    }
+  });
+
+  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);
+    }
+  });
 });

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

@@ -82,4 +82,37 @@ describe('NocturnalWorkflowManager runtime hardening', () => {
 
     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/utils/subagent-probe.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import {
+  getSubagentRuntimeAvailability,
+  isSubagentRuntimeAvailable,
+} from '../../src/utils/subagent-probe.js';
+
+describe('subagent-probe', () => {
+  it('treats any callable run entrypoint as available', () => {
+    const runtime = {
+      run() {
+        return Promise.resolve({ runId: 'run-1' });
+      },
+    };
+
+    expect(getSubagentRuntimeAvailability(runtime)).toEqual({
+      available: true,
+      reason: 'callable',
+    });
+    expect(isSubagentRuntimeAvailable(runtime)).toBe(true);
+  });
+
+  it('reports missing runtime and missing run distinctly', () => {
+    expect(getSubagentRuntimeAvailability(undefined)).toEqual({
+      available: false,
+      reason: 'missing_runtime',
+    });
+    expect(getSubagentRuntimeAvailability({})).toEqual({
+      available: false,
+      reason: 'missing_run',
+    });
+  });
+});