principles-disciple 1.72.0 → 1.73.0

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

@@ -15,42 +15,6 @@ vi.mock('../../src/core/session-tracker.js', () => ({
   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(() => []),
-}));
-
-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(() => ({
-      getNocturnalSessionSnapshot: mockGetNocturnalSessionSnapshot,
-      listRecentNocturnalCandidateSessions: mockListRecentNocturnalCandidateSessions,
-    })),
-  };
-});
-
 import { EvolutionWorkerService } from '../../src/service/evolution-worker.js';
 import { safeRmDir } from '../test-utils.js';
 
@@ -88,8 +52,7 @@ describe('EvolutionWorkerService timeout mechanisms', () => {
 
   // ── Pain diagnosis timeout (30 min) ──
 
-          // TODO: Fix - task status not transitioning correctly in test
-          it.skip('times out pain_diagnosis task after 30 minutes → resolution = diagnostician_timeout', async () => {    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-timeout-pain-'));
+          it('drops legacy pain_diagnosis tasks correctly on startup', async () => {    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-timeout-pain-'));
     const stateDir = path.join(workspaceDir, '.state');
     fs.mkdirSync(stateDir, { recursive: true });
 
@@ -138,21 +101,20 @@ describe('EvolutionWorkerService timeout mechanisms', () => {
       const queue = readQueue(stateDir);
       const task = queue.find((t: any) => t.id === 'timeout-test-30min');
 
-      expect(task.status).toBe('completed');
-      expect(task.resolution).toBe('diagnostician_timeout');
-      expect(task.completed_at).toBeDefined();
+      expect(task).toBeUndefined();
     } finally {
       EvolutionWorkerService.stop!({ workspaceDir, stateDir, logger: console } as any);
       safeRmDir(workspaceDir);
     }
   });
 
-  it('does not timeout pain_diagnosis task under 30 minutes', async () => {
+  it('drops legacy pain_diagnosis tasks instead of timing them out', async () => {
     const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-no-timeout-'));
     const stateDir = path.join(workspaceDir, '.state');
     fs.mkdirSync(stateDir, { recursive: true });
 
-    // Create an in_progress pain_diagnosis task that started 10 minutes ago
+    // Runtime v2 owns pain diagnosis. EvolutionWorker should not keep or
+    // timeout legacy pain_diagnosis queue items.
     const startedAt = new Date(Date.now() - 10 * 60 * 1000).toISOString();
     fs.writeFileSync(
       path.join(stateDir, 'evolution_queue.json'),
@@ -196,85 +158,7 @@ describe('EvolutionWorkerService timeout mechanisms', () => {
       const queue = readQueue(stateDir);
       const task = queue.find((t: any) => t.id === 'no-timeout-10min');
 
-      // Task should still be in_progress — not yet timed out
-      expect(task.status).toBe('in_progress');
-      expect(task.resolution).toBeUndefined();
-    } finally {
-      EvolutionWorkerService.stop!({ workspaceDir, stateDir, logger: console } as any);
-      safeRmDir(workspaceDir);
-    }
-  });
-
-  // ── Sleep reflection timeout (60 min default) ──
-
-  it('times out sleep_reflection task after 60 minutes → resolution = failed_max_retries', async () => {
-    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-timeout-sleep-'));
-    const stateDir = path.join(workspaceDir, '.state');
-    fs.mkdirSync(path.join(stateDir, 'sessions'), { recursive: true });
-    fs.mkdirSync(path.join(stateDir, 'logs'), { recursive: true });
-
-    // Create an in_progress sleep_reflection task that started 61 minutes ago
-    const startedAt = new Date(Date.now() - 61 * 60 * 1000).toISOString();
-    fs.writeFileSync(
-      path.join(stateDir, 'evolution_queue.json'),
-      JSON.stringify([
-        {
-          id: 'sleep-timeout-60min',
-          taskKind: 'sleep_reflection',
-          priority: 'medium',
-          score: 50,
-          source: 'nocturnal',
-          reason: 'Test sleep reflection timeout',
-          timestamp: startedAt,
-          enqueued_at: startedAt,
-          status: 'in_progress',
-          session_id: 'test',
-          agent_id: 'main',
-          started_at: startedAt,
-          resultRef: 'wf-sleep-timeout',
-          retryCount: 0,
-          maxRetries: 1,
-          recentPainContext: {
-            mostRecent: null,
-            recentPainCount: 0,
-            recentMaxPainScore: 0,
-          },
-        },
-      ], null, 2),
-      'utf8'
-    );
-
-    mockStartWorkflow.mockResolvedValue({
-      workflowId: 'wf-sleep-timeout',
-      childSessionKey: 'child-sleep',
-      state: 'terminal_error',
-    });
-    mockGetWorkflowDebugSummary.mockResolvedValue({
-      state: 'terminal_error',
-      metadata: {},
-      recentEvents: [{ reason: 'Test: simulating stuck sleep reflection', payload: {} }],
-    });
-
-    const mockApi = createMockApi();
-    EvolutionWorkerService.api = mockApi;
-
-    try {
-      EvolutionWorkerService.start({
-        workspaceDir,
-        stateDir,
-        logger: mockApi.logger,
-        config: fastPollConfig,
-        api: mockApi,
-      } as any);
-
-      await vi.advanceTimersByTimeAsync(5000);
-
-      const queue = readQueue(stateDir);
-      const task = queue.find((t: any) => t.id === 'sleep-timeout-60min');
-
-      expect(task.status).toBe('failed');
-      expect(task.resolution).toBe('failed_max_retries');
-      expect(task.completed_at).toBeDefined();
+      expect(task).toBeUndefined();
     } finally {
       EvolutionWorkerService.stop!({ workspaceDir, stateDir, logger: console } as any);
       safeRmDir(workspaceDir);
@@ -283,8 +167,7 @@ describe('EvolutionWorkerService timeout mechanisms', () => {
 
   // ── Report file cleanup on timeout ──
 
-  // TODO: Fix - report file not being cleaned up in test
-  it.skip('cleans up .diagnostician_report_*.json file on pain_diagnosis timeout', async () => {
+  it('drops legacy pain_diagnosis tasks and ignores stale diagnostician reports', async () => {
     const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-timeout-cleanup-'));
     const stateDir = path.join(workspaceDir, '.state');
     fs.mkdirSync(stateDir, { recursive: true });
@@ -335,14 +218,13 @@ describe('EvolutionWorkerService timeout mechanisms', () => {
 
       await vi.advanceTimersByTimeAsync(5000);
 
-      // Verify the report file was cleaned up
-      expect(fs.existsSync(reportPath)).toBe(false);
+      // Verify the report file is ignored because legacy pain_diagnosis tasks are dropped immediately
+      expect(fs.existsSync(reportPath)).toBe(true);
 
-      // Verify the task was marked as completed with timeout resolution
+      // Verify the task was dropped
       const queue = readQueue(stateDir);
       const task = queue.find((t: any) => t.id === 'timeout-cleanup');
-      expect(task.status).toBe('completed');
-      expect(task.resolution).toBe('diagnostician_timeout');
+      expect(task).toBeUndefined();
     } finally {
       EvolutionWorkerService.stop!({ workspaceDir, stateDir, logger: console } as any);
       safeRmDir(workspaceDir);

package/tests/service/internalization-trigger-adapter.test.ts

@@ -0,0 +1,251 @@
+/**
+ * Internalization Trigger Adapter - Unit Tests (PRI-63/65)
+ *
+ * PRI-65: Updated to use diagnosticJson for PI metadata, simulating
+ * real SqliteTaskStore behavior where PI fields live inside diagnosticJson.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { readFileSync } from 'fs';
+import { resolve } from 'path';
+import type { TaskRecord } from '@principles/core/runtime-v2';
+import { createPITaskDiagnosticJson } from '@principles/core/runtime-v2';
+import type { InternalizationChannel, ArtifactRef } from '@principles/core/runtime-v2';
+
+type MockLogger = {
+  debug?: (msg: string, meta?: Record<string, unknown>) => void;
+  info?: (msg: string, meta?: Record<string, unknown>) => void;
+  warn?: (msg: string, meta?: Record<string, unknown>) => void;
+  error?: (msg: string, meta?: Record<string, unknown>) => void;
+};
+
+interface MockProvider {
+  listTasks: ReturnType<typeof vi.fn>;
+  getTask: ReturnType<typeof vi.fn>;
+}
+
+/** Create a base TaskRecord (no PI metadata). Provider returns this from SQLite. */
+function makeTask(overrides: Partial<TaskRecord> & { taskId: string; taskKind: string }): TaskRecord {
+  return {
+    taskId: overrides.taskId,
+    taskKind: overrides.taskKind,
+    status: overrides.status ?? 'pending',
+    createdAt: overrides.createdAt ?? new Date().toISOString(),
+    updatedAt: overrides.updatedAt ?? new Date().toISOString(),
+    attemptCount: 0,
+    maxAttempts: 3,
+    leaseOwner: undefined,
+    leaseExpiresAt: undefined,
+    lastError: undefined,
+    inputRef: undefined,
+    resultRef: undefined,
+    ...overrides,
+  } as TaskRecord;
+}
+
+/** Create a TaskRecord with PI metadata stored in diagnosticJson (simulates SqliteTaskStore). */
+function makePITask(
+  taskId: string,
+  taskKind: string,
+  channel: InternalizationChannel,
+  options?: {
+    status?: TaskRecord['status'];
+    dependencyTaskIds?: string[];
+    parentTaskId?: string;
+    correlationId?: string;
+    timeoutMs?: number;
+    inputArtifactRefs?: ArtifactRef[];
+    outputArtifactRefs?: ArtifactRef[];
+  },
+): TaskRecord {
+  const meta = {
+    dependencyTaskIds: options?.dependencyTaskIds ?? [],
+    channel,
+    timeoutMs: options?.timeoutMs ?? 300000,
+    inputArtifactRefs: options?.inputArtifactRefs ?? [],
+    outputArtifactRefs: options?.outputArtifactRefs ?? [],
+    parentTaskId: options?.parentTaskId,
+    correlationId: options?.correlationId,
+  };
+  return {
+    ...makeTask({ taskId, taskKind, status: options?.status ?? 'pending' }),
+    diagnosticJson: createPITaskDiagnosticJson(meta),
+  } as TaskRecord;
+}
+
+function readAdapterSource(): string {
+  return readFileSync(
+    resolve(__dirname, '../../src/service/internalization-trigger-adapter.ts'),
+    'utf8',
+  );
+}
+
+describe('Internalization Trigger Adapter', () => {
+  let mockProvider: MockProvider;
+  let mockLogger: MockLogger;
+  let adapter: {
+    wake: (ctx: { workspaceDir: string; stateDir: string }) => Promise<void>;
+    start: (ctx: { workspaceDir: string; stateDir: string }, intervalMs?: number) => () => void;
+    stop: () => void;
+  };
+
+  beforeEach(async () => {
+    mockLogger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    mockProvider = { listTasks: vi.fn(), getTask: vi.fn() };
+    const mod = await import('../../src/service/internalization-trigger-adapter.js');
+    adapter = mod.createInternalizationTrigger(
+      mockProvider as import('../../src/service/internalization-trigger-adapter.js').InternalizationTaskProvider,
+      mockLogger,
+    ) as typeof adapter;
+  });
+
+  describe('wake — basic behavior', () => {
+    it('no pending tasks → returns without error', async () => {
+      mockProvider.listTasks.mockResolvedValue([]);
+      await expect(adapter.wake({ workspaceDir: '/test', stateDir: '/test/.state' })).resolves.not.toThrow();
+    });
+
+    it('pending task with no deps → logs INTERNALIZATION_TRIGGER_WAKE with correct payload', async () => {
+      const task = makePITask('task-1', 'dreamer', 'prompt', { status: 'pending', dependencyTaskIds: [] });
+      mockProvider.listTasks.mockResolvedValue([task]);
+      await adapter.wake({ workspaceDir: '/test', stateDir: '/test/.state' });
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        '[PD:InternalizationTrigger] INTERNALIZATION_TRIGGER_WAKE',
+        expect.objectContaining({ taskId: 'task-1', taskKind: 'dreamer', gateDecision: 'proceed' }),
+      );
+    });
+
+    it('retry_wait task → logs INTERNALIZATION_TRIGGER_WAKE', async () => {
+      const task = makePITask('task-retry', 'philosopher', 'prompt', { status: 'retry_wait', dependencyTaskIds: [] });
+      mockProvider.listTasks.mockResolvedValue([task]);
+      await adapter.wake({ workspaceDir: '/test', stateDir: '/test/.state' });
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        '[PD:InternalizationTrigger] INTERNALIZATION_TRIGGER_WAKE',
+        expect.objectContaining({ taskId: 'task-retry', taskKind: 'philosopher' }),
+      );
+    });
+
+    it('task with unmet deps → logs INTERNALIZATION_TRIGGER_BLOCKED with gateDecision blocked', async () => {
+      const depTask = makePITask('dep-1', 'scribe', 'prompt', { status: 'pending', dependencyTaskIds: [] });
+      const task = makePITask('task-blocked', 'dreamer', 'prompt', { status: 'pending', dependencyTaskIds: ['dep-1'] });
+      mockProvider.listTasks.mockResolvedValue([task]);
+      mockProvider.getTask.mockResolvedValue(depTask);
+      await adapter.wake({ workspaceDir: '/test', stateDir: '/test/.state' });
+      expect(mockLogger.debug).toHaveBeenCalledWith(
+        '[PD:InternalizationTrigger] INTERNALIZATION_TRIGGER_BLOCKED',
+        expect.objectContaining({ taskId: 'task-blocked', gateDecision: 'blocked', blockedBy: expect.any(Array) }),
+      );
+    });
+
+    it('task with failed dep → logs INTERNALIZATION_TRIGGER_BLOCKED with dependency_failed', async () => {
+      const depTask = makePITask('dep-failed', 'scribe', 'prompt', { status: 'failed', dependencyTaskIds: [] });
+      const task = makePITask('task-dep-failed', 'dreamer', 'prompt', { status: 'pending', dependencyTaskIds: ['dep-failed'] });
+      mockProvider.listTasks.mockResolvedValue([task]);
+      mockProvider.getTask.mockResolvedValue(depTask);
+      await adapter.wake({ workspaceDir: '/test', stateDir: '/test/.state' });
+      expect(mockLogger.debug).toHaveBeenCalledWith(
+        '[PD:InternalizationTrigger] INTERNALIZATION_TRIGGER_BLOCKED',
+        expect.objectContaining({ taskId: 'task-dep-failed', gateDecision: 'dependency_failed' }),
+      );
+    });
+
+    it('task with missing dep → logs INTERNALIZATION_TRIGGER_BLOCKED (fail closed)', async () => {
+      const task = makePITask('task-missing-dep', 'dreamer', 'prompt', { status: 'pending', dependencyTaskIds: ['nonexistent'] });
+      mockProvider.listTasks.mockResolvedValue([task]);
+      mockProvider.getTask.mockResolvedValue(null);
+      await adapter.wake({ workspaceDir: '/test', stateDir: '/test/.state' });
+      expect(mockLogger.debug).toHaveBeenCalledWith(
+        '[PD:InternalizationTrigger] INTERNALIZATION_TRIGGER_BLOCKED',
+        expect.objectContaining({ taskId: 'task-missing-dep', gateDecision: 'blocked' }),
+      );
+    });
+  });
+
+  describe('wake — fail closed', () => {
+    it('missing workspaceDir → does not throw', async () => {
+      await expect(adapter.wake({ workspaceDir: '', stateDir: '/test/.state' })).resolves.not.toThrow();
+    });
+
+    it('missing stateDir → does not throw', async () => {
+      await expect(adapter.wake({ workspaceDir: '/test', stateDir: '' })).resolves.not.toThrow();
+    });
+
+    it('provider throws → does not throw', async () => {
+      mockProvider.listTasks.mockRejectedValue(new Error('SQLite error'));
+      await expect(adapter.wake({ workspaceDir: '/test', stateDir: '/test/.state' })).resolves.not.toThrow();
+    });
+
+    it('task with unknown taskKind → filtered out silently', async () => {
+      const unknownTask = makeTask({ taskId: 'task-unknown', taskKind: 'diagnostician', status: 'pending', dependencyTaskIds: [] });
+      mockProvider.listTasks.mockResolvedValue([unknownTask]);
+      await expect(adapter.wake({ workspaceDir: '/test', stateDir: '/test/.state' })).resolves.not.toThrow();
+    });
+  });
+
+  describe('wake — fire and forget', () => {
+    it('wake() returns in < 200ms even with many tasks', async () => {
+      const manyTasks = Array.from({ length: 20 }, (_, i) =>
+        makePITask(`task-${i}`, 'dreamer', 'prompt', { status: 'pending', dependencyTaskIds: [] }),
+      );
+      mockProvider.listTasks.mockResolvedValue(manyTasks);
+      const start = Date.now();
+      await adapter.wake({ workspaceDir: '/test', stateDir: '/test/.state' });
+      expect(Date.now() - start).toBeLessThan(200);
+    });
+
+    it('wake() calls only read methods', async () => {
+      const task = makePITask('task-readonly', 'scribe', 'prompt', { status: 'pending', dependencyTaskIds: [] });
+      mockProvider.listTasks.mockResolvedValue([task]);
+      await adapter.wake({ workspaceDir: '/test', stateDir: '/test/.state' });
+      expect(mockProvider.listTasks).toHaveBeenCalled();
+    });
+  });
+
+  describe('start / stop', () => {
+    beforeEach(() => { vi.useFakeTimers(); });
+    afterEach(() => { vi.useRealTimers(); });
+
+    it('start() returns a stop function', () => {
+      mockProvider.listTasks.mockResolvedValue([]);
+      const stop = adapter.start({ workspaceDir: '/test', stateDir: '/test/.state' });
+      expect(typeof stop).toBe('function');
+      stop();
+    });
+
+    it('stop() is idempotent', () => {
+      mockProvider.listTasks.mockResolvedValue([]);
+      const stop = adapter.start({ workspaceDir: '/test', stateDir: '/test/.state' });
+      expect(() => stop()).not.toThrow();
+      expect(() => stop()).not.toThrow();
+    });
+  });
+
+  describe('architecture guards (source-level)', () => {
+    it('does not import nocturnal-trinity', () => {
+      expect(readAdapterSource()).not.toContain('nocturnal-trinity');
+    });
+
+    it('does not import runTrinity', () => {
+      expect(readAdapterSource()).not.toContain('runTrinity');
+    });
+
+    it('does import @principles/core/runtime-v2', () => {
+      expect(readAdapterSource()).toContain('@principles/core/runtime-v2');
+    });
+
+    it('imports hydratePITaskRecord from core (not own JSON.parse)', () => {
+      const src = readAdapterSource();
+      expect(src).toContain('hydratePITaskRecord');
+      // Must not contain ad-hoc JSON.parse for PI metadata
+      expect(src).not.toMatch(/JSON\.parse.*diagnosticJson/);
+    });
+
+    it('does NOT use isValidPITaskRecord directly on raw provider tasks', () => {
+      // The adapter now uses hydratePITaskRecord instead of isValidPITaskRecord
+      // to determine if a task is a valid PI task.
+      // isValidPITaskRecord checks top-level fields which don't exist on persisted tasks.
+      const src = readAdapterSource();
+      expect(src).not.toMatch(/isValidPITaskRecord\s*\(\s*t\s*\)/);
+    });
+  });
+});

package/tests/service/monitoring-query-service.test.ts

@@ -22,7 +22,7 @@ import { MonitoringQueryService } from '../../src/service/monitoring-query-servi
 function createWorkflow(overrides: Partial<WorkflowRow> = {}): WorkflowRow {
   return {
     workflow_id: overrides.workflow_id ?? 'wf-1',
-    workflow_type: overrides.workflow_type ?? 'nocturnal',
+    workflow_type: overrides.workflow_type ?? 'rulehost',
     transport: overrides.transport ?? 'runtime_direct',
     parent_session_id: overrides.parent_session_id ?? 'parent-1',
     child_session_key: overrides.child_session_key ?? 'child-1',
@@ -37,23 +37,6 @@ function createWorkflow(overrides: Partial<WorkflowRow> = {}): WorkflowRow {
   };
 }
 
-function createEvent(
-  workflowId: string,
-  eventType: string,
-  createdAt: number,
-  reason = ''
-): WorkflowEventRow {
-  return {
-    workflow_id: workflowId,
-    event_type: eventType,
-    from_state: null,
-    to_state: 'completed',
-    reason,
-    payload_json: '{}',
-    created_at: createdAt,
-  };
-}
-
 describe('MonitoringQueryService', () => {
   beforeEach(() => {
     vi.clearAllMocks();
@@ -81,33 +64,4 @@ describe('MonitoringQueryService', () => {
       stuckDuration: null,
     });
   });
-
-  it('computes failure rate per terminal workflow instead of per failed stage', () => {
-    mockListWorkflows.mockReturnValue([
-      createWorkflow({ workflow_id: 'wf-complete', state: 'completed', duration_ms: 500 }),
-      createWorkflow({ workflow_id: 'wf-failed', state: 'terminal_error', duration_ms: 750 }),
-    ]);
-    mockGetEvents.mockImplementation((workflowId: string) => {
-      if (workflowId === 'wf-failed') {
-        return [
-          createEvent(workflowId, 'trinity_dreamer_start', 1),
-          createEvent(workflowId, 'trinity_dreamer_failed', 2, 'dreamer failed'),
-          createEvent(workflowId, 'trinity_philosopher_start', 3),
-          createEvent(workflowId, 'trinity_philosopher_failed', 4, 'philosopher failed'),
-        ];
-      }
-      return [
-        createEvent(workflowId, 'trinity_dreamer_start', 1),
-        createEvent(workflowId, 'trinity_dreamer_complete', 2),
-      ];
-    });
-
-    const service = new MonitoringQueryService('/workspace');
-    const result = service.getTrinityHealth();
-
-    expect(result.totalCalls).toBe(2);
-    expect(result.failureRate).toBe(0.5);
-    expect(result.stageStats.dreamer.failed).toBe(1);
-    expect(result.stageStats.philosopher.failed).toBe(1);
-  });
 });

package/tests/service/queue-io.test.ts

@@ -2,7 +2,7 @@
  * Unit tests for queue-io.ts — queue persistence layer.
  */
 
-import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { describe, expect, it, beforeEach, afterEach } from 'vitest';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -15,14 +15,7 @@ import {
     LOCK_MAX_RETRIES,
     LOCK_RETRY_DELAY_MS,
     LOCK_STALE_MS,
-    readRecentPainContext,
 } from '../../src/service/queue-io.js';
-import { readPainFlagContract } from '../../src/core/pain.js';
-
-// Mock readPainFlagContract for readRecentPainContext tests
-vi.mock('../../src/core/pain.js', () => ({
-    readPainFlagContract: vi.fn(),
-}));
 
 let tmpDir: string;
 beforeEach(() => {
@@ -173,57 +166,3 @@ describe('withQueueLock RAII', () => {
         release();
     });
 });
-
-describe('readRecentPainContext', () => {
-  // readPainFlagContract is mocked via vi.mock above
-  const mockWctx = { workspaceDir: '/fake/workspace' } as any;
-
-  it('returns null context when contract status is not valid', () => {
-    vi.mocked(readPainFlagContract).mockReturnValueOnce({
-      status: 'missing',
-      format: 'missing',
-      data: {},
-      missingFields: [],
-    } as any);
-    const result = readRecentPainContext(mockWctx);
-    expect(result.mostRecent).toBeNull();
-    expect(result.recentPainCount).toBe(0);
-  });
-
-  it('returns null context when score parses to 0', () => {
-    vi.mocked(readPainFlagContract).mockReturnValueOnce({
-      status: 'valid',
-      format: 'kv',
-      data: { score: '0', source: 'tool_failure', reason: 'err', time: '2026-04-14T00:00:00Z', session_id: 's1' },
-      missingFields: [],
-    } as any);
-    const result = readRecentPainContext(mockWctx);
-    expect(result.mostRecent).toBeNull();
-  });
-
-  it('returns mostRecent with valid score > 0', () => {
-    vi.mocked(readPainFlagContract).mockReturnValueOnce({
-      status: 'valid',
-      format: 'kv',
-      data: { score: '75', source: 'tool_failure', reason: 'File write failed', time: '2026-04-14T10:00:00Z', session_id: 'sess-001' },
-      missingFields: [],
-    } as any);
-    const result = readRecentPainContext(mockWctx);
-    expect(result.mostRecent).not.toBeNull();
-    expect(result.mostRecent!.score).toBe(75);
-    expect(result.mostRecent!.source).toBe('tool_failure');
-    expect(result.recentPainCount).toBe(1);
-    expect(result.recentMaxPainScore).toBe(75);
-  });
-
-  it('returns null context when contract data is empty object', () => {
-    vi.mocked(readPainFlagContract).mockReturnValueOnce({
-      status: 'valid',
-      format: 'empty',
-      data: {},
-      missingFields: [],
-    } as any);
-    const result = readRecentPainContext(mockWctx);
-    expect(result.mostRecent).toBeNull();
-  });
-});

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

@@ -1000,7 +1000,9 @@ describe('RuntimeSummaryService', () => {
     });
   });
 
-  describe('Stalled diagnostician warning', () => {
+  // M8: Runtime v2 uses SQLite task store for pending tasks; legacy diagnostician_tasks.json
+  // is no longer read for pendingTasks count. This test verified stale behavior.
+  describe.skip('Stalled diagnostician warning', () => {
     it('raises a high-signal warning when tasks are injected but no reports are written', () => {
       const workspace = makeWorkspace();
       writeJson(path.join(workspace, '.state', 'AGENT_SCORECARD.json'), {