principles-disciple 1.14.0 → 1.16.0

package/tests/core/principle-tree-migration.test.ts

@@ -0,0 +1,77 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { needsMigration } from '../../src/core/principle-tree-migration.js';
+import { safeRmDir } from '../test-utils.js';
+
+function writeLedger(stateDir: string, payload: unknown): void {
+  fs.mkdirSync(stateDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(stateDir, 'principle_training_state.json'),
+    JSON.stringify(payload, null, 2),
+    'utf8'
+  );
+}
+
+describe('principle-tree-migration', () => {
+  const tempDirs: string[] = [];
+
+  afterEach(() => {
+    while (tempDirs.length > 0) {
+      const dir = tempDirs.pop();
+      if (dir) safeRmDir(dir);
+    }
+  });
+
+  it('requires migration when trainingStore and tree.principles counts match but ids differ', () => {
+    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-migration-'));
+    const stateDir = path.join(workspaceDir, '.state');
+    tempDirs.push(workspaceDir);
+
+    writeLedger(stateDir, {
+      P_001: {
+        principleId: 'P_001',
+        evaluability: 'manual_only',
+        applicableOpportunityCount: 0,
+        observedViolationCount: 0,
+        complianceRate: 0,
+        violationTrend: 0,
+        generatedSampleCount: 0,
+        approvedSampleCount: 0,
+        includedTrainRunIds: [],
+        deployedCheckpointIds: [],
+        internalizationStatus: 'prompt_only',
+      },
+      _tree: {
+        principles: {
+          P_999: {
+            id: 'P_999',
+            version: 1,
+            text: 'Other principle',
+            triggerPattern: '',
+            action: '',
+            status: 'candidate',
+            priority: 'P1',
+            scope: 'general',
+            evaluability: 'manual_only',
+            valueScore: 0,
+            adherenceRate: 0,
+            painPreventedCount: 0,
+            derivedFromPainIds: [],
+            ruleIds: [],
+            conflictsWithPrincipleIds: [],
+            createdAt: '2026-04-10T00:00:00.000Z',
+            updatedAt: '2026-04-10T00:00:00.000Z',
+          },
+        },
+        rules: {},
+        implementations: {},
+        metrics: {},
+        lastUpdated: '2026-04-10T00:00:00.000Z',
+      },
+    });
+
+    expect(needsMigration(stateDir)).toBe(true);
+  });
+});

package/tests/scripts/validate-live-path.test.ts

@@ -0,0 +1,286 @@
+/**
+ * Validate Live Path Script Tests (Phase 18)
+ *
+ * TDD test suite for live path validation script.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { safeRmDir } from '../test-utils.js';
+import {
+  loadLedger,
+  saveLedger,
+  createRule,
+  updatePrinciple,
+  type HybridLedgerStore,
+  type LedgerPrinciple,
+  type LedgerRule,
+} from '../../src/core/principle-tree-ledger.js';
+import type { LegacyPrincipleTrainingStore, LegacyPrincipleTrainingState } from '../../src/core/principle-tree-ledger.js';
+
+// Script path
+const SCRIPT_PATH = path.join(__dirname, '../../scripts/validate-live-path.ts');
+
+describe('validate-live-path script', () => {
+  let tempDir: string;
+  let stateDir: string;
+  let queuePath: string;
+  let dbPath: string;
+
+  beforeAll(() => {
+    tempDir = fs.mkdtempSync(path.join(process.env.TMP || '/tmp', 'pd-validate-'));
+    stateDir = path.join(tempDir, '.state');
+    fs.mkdirSync(stateDir, { recursive: true });
+
+    queuePath = path.join(stateDir, 'EVOLUTION_QUEUE');
+    dbPath = path.join(stateDir, 'subagent_workflows.db');
+  });
+
+  afterAll(() => {
+    safeRmDir(tempDir);
+  });
+
+  // Helper: Create a minimal ledger principle
+  function createLedgerPrinciple(principleId: string, overrides: Partial<LedgerPrinciple> = {}): LedgerPrinciple {
+    return {
+      id: principleId,
+      version: 1,
+      text: `Test principle ${principleId}`,
+      triggerPattern: 'test',
+      action: 'test action',
+      status: 'active',
+      priority: 'P1',
+      scope: 'general',
+      evaluability: 'deterministic',
+      valueScore: 0,
+      adherenceRate: 0,
+      painPreventedCount: 0,
+      derivedFromPainIds: [],
+      ruleIds: [],
+      conflictsWithPrincipleIds: [],
+      createdAt: '2026-04-10T00:00:00.000Z',
+      updatedAt: '2026-04-10T00:00:00.000Z',
+      ...overrides,
+    };
+  }
+
+  // Helper: Setup ledger with bootstrapped rules
+  function setupBootstrapLedger(): void {
+    const trainingStore: LegacyPrincipleTrainingStore = {
+      'P_test_001': {
+        principleId: 'P_test_001',
+        evaluability: 'deterministic',
+        applicableOpportunityCount: 10,
+        observedViolationCount: 5,
+        complianceRate: 0.5,
+        violationTrend: 0,
+        generatedSampleCount: 0,
+        approvedSampleCount: 0,
+        includedTrainRunIds: [],
+        deployedCheckpointIds: [],
+        internalizationStatus: 'prompt_only',
+      },
+    };
+
+    const principle = createLedgerPrinciple('P_test_001');
+
+    const tree = {
+      principles: { 'P_test_001': principle },
+      rules: {} as Record<string, LedgerRule>,
+      implementations: {},
+      metrics: {},
+      lastUpdated: new Date().toISOString(),
+    };
+
+    const store: HybridLedgerStore = {
+      trainingStore,
+      tree,
+    };
+
+    saveLedger(stateDir, store);
+
+    // Create stub bootstrap rule
+    const ruleId = 'P_test_001_stub_bootstrap';
+    const rule = createRule(stateDir, {
+      id: ruleId,
+      version: 1,
+      name: 'Stub bootstrap rule for P_test_001',
+      description: 'Placeholder rule for principle-internalization bootstrap',
+      type: 'hook',
+      triggerCondition: 'stub: bootstrap placeholder',
+      enforcement: 'warn',
+      action: 'allow (stub)',
+      principleId: 'P_test_001',
+      status: 'proposed',
+      coverageRate: 0,
+      falsePositiveRate: 0,
+      implementationIds: [],
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
+
+    // Link rule to principle
+    updatePrinciple(stateDir, 'P_test_001', {
+      suggestedRules: [ruleId],
+    });
+  }
+
+  describe('script file existence', () => {
+    it('should have validate-live-path.ts script file', () => {
+      expect(fs.existsSync(SCRIPT_PATH)).toBe(true);
+    });
+
+    it('should have minimum 150 lines', () => {
+      const content = fs.readFileSync(SCRIPT_PATH, 'utf8');
+      const lineCount = content.split('\n').length;
+      expect(lineCount).toBeGreaterThanOrEqual(150);
+    });
+  });
+
+  describe('script imports and patterns', () => {
+    it('should implement acquireLockAsync and releaseLock functions', () => {
+      const content = fs.readFileSync(SCRIPT_PATH, 'utf8');
+      expect(content).toMatch(/acquireLockAsync/);
+      expect(content).toMatch(/releaseLock/);
+      // Script is standalone, so it doesn't import from file-lock.js
+      // It implements its own simplified lock functions
+    });
+
+    it('should use better-sqlite3 for direct SQLite query', () => {
+      const content = fs.readFileSync(SCRIPT_PATH, 'utf8');
+      expect(content).toMatch(/better-sqlite3/);
+      expect(content).toMatch(/workflow_type\s*=\s*['"]nocturnal['"]/);
+    });
+
+    it('should filter for _stub_bootstrap rules', () => {
+      const content = fs.readFileSync(SCRIPT_PATH, 'utf8');
+      expect(content).toMatch(/_stub_bootstrap/);
+    });
+
+    it('should have proper exit codes', () => {
+      const content = fs.readFileSync(SCRIPT_PATH, 'utf8');
+      expect(content).toMatch(/process\.exit\(0\)/);
+      expect(content).toMatch(/process\.exit\(1\)/);
+    });
+  });
+
+  describe('bootstrapped rule detection', () => {
+    it('should detect bootstrapped rules from ledger', () => {
+      setupBootstrapLedger();
+
+      const ledger = loadLedger(stateDir);
+      const bootstrappedRules = Object.values(ledger.tree.rules).filter(r =>
+        r.id.endsWith('_stub_bootstrap')
+      );
+
+      expect(bootstrappedRules.length).toBeGreaterThan(0);
+      expect(bootstrappedRules[0].id).toBe('P_test_001_stub_bootstrap');
+    });
+
+    it('should fail fast when no bootstrapped rules exist', () => {
+      // Create empty ledger
+      const store: HybridLedgerStore = {
+        trainingStore: {},
+        tree: {
+          principles: {},
+          rules: {},
+          implementations: {},
+          metrics: {},
+          lastUpdated: new Date().toISOString(),
+        },
+      };
+      saveLedger(stateDir, store);
+
+      const ledger = loadLedger(stateDir);
+      const bootstrappedRules = Object.values(ledger.tree.rules).filter(r =>
+        r.id.endsWith('_stub_bootstrap')
+      );
+
+      expect(bootstrappedRules.length).toBe(0);
+    });
+  });
+
+  describe('synthetic snapshot construction', () => {
+    it('should create snapshot with recentPain to pass hasUsableNocturnalSnapshot guard', () => {
+      // This test verifies the snapshot shape from plan context
+      const snapshot = {
+        sessionId: `validation-${Date.now()}`,
+        startedAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        assistantTurns: [],
+        userTurns: [],
+        toolCalls: [],
+        painEvents: [],
+        gateBlocks: [],
+        stats: {
+          totalAssistantTurns: 0,
+          totalToolCalls: 0,
+          failureCount: 0,
+          totalPainEvents: 1,
+          totalGateBlocks: 0,
+        },
+        recentPain: [{
+          source: 'live-validation',
+          score: 50,
+          severity: 'moderate',
+          reason: 'Synthetic snapshot for live path validation',
+          createdAt: new Date().toISOString(),
+        }],
+        _dataSource: 'pain_context_fallback',
+      };
+
+      // Verify snapshot has required fields
+      expect(snapshot.sessionId).toBeTruthy();
+      expect(snapshot.sessionId.length).toBeGreaterThan(0);
+      expect(snapshot.recentPain).toBeDefined();
+      expect(snapshot.recentPain!.length).toBeGreaterThan(0);
+      expect(snapshot._dataSource).toBe('pain_context_fallback');
+    });
+  });
+
+  describe('queue file locking', () => {
+    it('should use acquireLockAsync before writing to queue', () => {
+      const content = fs.readFileSync(SCRIPT_PATH, 'utf8');
+      // Check for lock acquisition pattern
+      expect(content).toMatch(/acquireLockAsync/);
+      expect(content).toMatch(/QUEUE_PATH/);
+    });
+
+    it('should release lock in finally block', () => {
+      const content = fs.readFileSync(SCRIPT_PATH, 'utf8');
+      // Check for finally block with lock release
+      expect(content).toMatch(/\}\s*finally/);
+      expect(content).toMatch(/if\s+\(lockCtx\)/);
+      expect(content).toMatch(/releaseLock\(lockCtx\)/);
+    });
+  });
+
+  describe('workflow store query', () => {
+    it('should query subagent_workflows.db directly for nocturnal workflows', () => {
+      const content = fs.readFileSync(SCRIPT_PATH, 'utf8');
+      // Check for raw SQLite query pattern
+      expect(content).toMatch(/workflow_type\s*=\s*['"]nocturnal['"]/);
+    });
+
+    it('should correlate workflow to queue item via taskId', () => {
+      const content = fs.readFileSync(SCRIPT_PATH, 'utf8');
+      // Check for taskId correlation pattern
+      expect(content).toMatch(/taskId|metadata_json/);
+    });
+  });
+
+  describe('resolution verification', () => {
+    it('should read resolution from queue item, not from WorkflowRow', () => {
+      const content = fs.readFileSync(SCRIPT_PATH, 'utf8');
+      // Check for resolution field access on queue
+      expect(content).toMatch(/resolution.*queue|queue.*resolution/);
+    });
+
+    it('should verify explicit resolution (not expired)', () => {
+      const content = fs.readFileSync(SCRIPT_PATH, 'utf8');
+      // Check for explicit resolution check
+      expect(content).toMatch(/resolution.*expired|expired.*resolution/);
+    });
+  });
+});

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

@@ -0,0 +1,208 @@
+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 } = vi.hoisted(() => ({
+  mockGetNocturnalSessionSnapshot: 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,
+    })),
+  };
+});
+
+import { EvolutionWorkerService } from '../../src/service/evolution-worker.js';
+import { safeRmDir } from '../test-utils.js';
+
+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('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('missing_usable_snapshot');
+      expect(queue[0].resultRef).toBeFalsy();
+      expect(mockStartWorkflow).not.toHaveBeenCalled();
+    } finally {
+      EvolutionWorkerService.stop({ workspaceDir, stateDir, logger: console } as any);
+      safeRmDir(workspaceDir);
+    }
+  });
+
+  it('keeps gateway-only background failures as failed instead of completed stub fallback', 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);
+      expect(queue[0].status).toBe('failed');
+      expect(queue[0].resolution).toBe('failed_max_retries');
+      expect(queue[0].lastError).toContain('gateway request');
+    } finally {
+      EvolutionWorkerService.stop({ workspaceDir, stateDir, logger: console } as any);
+      safeRmDir(workspaceDir);
+    }
+  });
+});

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

@@ -0,0 +1,113 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { WorkflowEventRow, WorkflowRow } from '../../src/service/subagent-workflow/types.js';
+
+const mockListWorkflows = vi.fn<() => WorkflowRow[]>();
+const mockGetWorkflow = vi.fn<(workflowId: string) => WorkflowRow | null>();
+const mockGetEvents = vi.fn<(workflowId: string) => WorkflowEventRow[]>();
+const mockGetStageOutputs = vi.fn<(workflowId: string) => Array<{ stage: string }>>();
+const mockDispose = vi.fn();
+
+vi.mock('../../src/service/subagent-workflow/workflow-store.js', () => ({
+  WorkflowStore: class {
+    listWorkflows = mockListWorkflows;
+    getWorkflow = mockGetWorkflow;
+    getEvents = mockGetEvents;
+    getStageOutputs = mockGetStageOutputs;
+    dispose = mockDispose;
+  },
+}));
+
+import { MonitoringQueryService } from '../../src/service/monitoring-query-service.js';
+
+function createWorkflow(overrides: Partial<WorkflowRow> = {}): WorkflowRow {
+  return {
+    workflow_id: overrides.workflow_id ?? 'wf-1',
+    workflow_type: overrides.workflow_type ?? 'nocturnal',
+    transport: overrides.transport ?? 'runtime_direct',
+    parent_session_id: overrides.parent_session_id ?? 'parent-1',
+    child_session_key: overrides.child_session_key ?? 'child-1',
+    run_id: overrides.run_id ?? null,
+    state: overrides.state ?? 'completed',
+    cleanup_state: overrides.cleanup_state ?? 'none',
+    created_at: overrides.created_at ?? Date.UTC(2026, 3, 10, 0, 0, 0),
+    updated_at: overrides.updated_at ?? Date.UTC(2026, 3, 10, 0, 5, 0),
+    last_observed_at: overrides.last_observed_at ?? null,
+    duration_ms: overrides.duration_ms ?? 1_000,
+    metadata_json: overrides.metadata_json ?? '{}',
+  };
+}
+
+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();
+    mockListWorkflows.mockReturnValue([]);
+    mockGetWorkflow.mockReturnValue(null);
+    mockGetEvents.mockReturnValue([]);
+    mockGetStageOutputs.mockReturnValue([]);
+  });
+
+  it('ignores malformed workflow metadata when listing workflows', () => {
+    mockListWorkflows.mockReturnValue([
+      createWorkflow({
+        workflow_id: 'wf-malformed',
+        metadata_json: '{invalid',
+      }),
+    ]);
+
+    const service = new MonitoringQueryService('/workspace');
+    const result = service.getWorkflows();
+
+    expect(result.workflows).toHaveLength(1);
+    expect(result.workflows[0]).toMatchObject({
+      workflowId: 'wf-malformed',
+      state: 'completed',
+      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);
+  });
+});