principles-disciple 1.41.0 → 1.43.0

package/tests/fixtures/legacy-queue-v1.json

@@ -0,0 +1,74 @@
+[
+  {
+    "id": "legacy-pain-001",
+    "task": "Diagnose tool_failure pain from write operation",
+    "score": 78,
+    "source": "tool_failure",
+    "reason": "Tool write failed on test.md. Error: EACCES permission denied",
+    "timestamp": "2026-04-10T08:30:00.000Z",
+    "enqueued_at": "2026-04-10T08:30:05.000Z",
+    "started_at": null,
+    "completed_at": null,
+    "assigned_session_key": null,
+    "trigger_text_preview": "Tool write failed on test.md",
+    "status": "pending",
+    "resolution": null,
+    "session_id": null,
+    "agent_id": null,
+    "traceId": "trace-legacy-001"
+  },
+  {
+    "id": "legacy-pain-002",
+    "task": "Diagnose runtime_unavailable pain from agent session",
+    "score": 65,
+    "source": "runtime_unavailable",
+    "reason": "Agent session timed out after 300s inactivity window",
+    "timestamp": "2026-04-11T14:22:00.000Z",
+    "enqueued_at": "2026-04-11T14:22:10.000Z",
+    "started_at": "2026-04-11T14:25:00.000Z",
+    "completed_at": null,
+    "assigned_session_key": "session-key-abc123",
+    "trigger_text_preview": "Agent session timed out",
+    "status": "in_progress",
+    "resolution": null,
+    "session_id": "session-abc123",
+    "agent_id": "main",
+    "traceId": "trace-legacy-002"
+  },
+  {
+    "id": "legacy-pain-003",
+    "task": "Diagnose gate_block pain from scoring validation",
+    "score": 90,
+    "source": "gate_block",
+    "reason": "Principle score 0.12 below threshold 0.70 for late_marker_no_principle",
+    "timestamp": "2026-04-12T09:15:00.000Z",
+    "enqueued_at": "2026-04-12T09:15:30.000Z",
+    "started_at": "2026-04-12T09:16:00.000Z",
+    "completed_at": "2026-04-12T09:20:45.000Z",
+    "assigned_session_key": "session-key-def456",
+    "trigger_text_preview": "Principle score below threshold",
+    "status": "completed",
+    "resolution": "late_marker_no_principle",
+    "session_id": "session-def456",
+    "agent_id": "main",
+    "traceId": "trace-legacy-003"
+  },
+  {
+    "id": "legacy-pain-004",
+    "task": "Diagnose thin_violation pain from rule scoring",
+    "score": 55,
+    "source": "thin_violation",
+    "reason": "Rule 'no-bare-throw' triggered but violation was benign; investigate scoring bias",
+    "timestamp": "2026-04-13T16:45:00.000Z",
+    "enqueued_at": "2026-04-13T16:45:15.000Z",
+    "started_at": "2026-04-13T16:46:00.000Z",
+    "completed_at": "2026-04-13T16:50:30.000Z",
+    "assigned_session_key": "session-key-ghi789",
+    "trigger_text_preview": "Rule scoring bias investigation",
+    "status": "failed",
+    "resolution": "failed_max_retries",
+    "session_id": "session-ghi789",
+    "agent_id": "main",
+    "traceId": "trace-legacy-004"
+  }
+]

package/tests/queue/async-lock.test.ts

@@ -0,0 +1,200 @@
+/**
+ * Unit tests for asyncLockQueues concurrency with Promise.all race detection.
+ * Tests file-level async lock serialization and Map state cleanup per D-05.
+ * Uses vi.useFakeTimers() in beforeEach/afterEach per D-10,
+ * but concurrency tests run with real timers to avoid Promise.all + fake timer issues.
+ * Uses os.tmpdir() per D-11.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { withAsyncLock, asyncLockQueues } from '../../src/utils/file-lock.js';
+
+describe('asyncLockQueues', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    // D-10: Use fake timers in beforeEach (afterEach restores real timers)
+    vi.useFakeTimers();
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-async-lock-test-'));
+    // D-05: clear Map state between tests
+    asyncLockQueues.clear();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('serializes concurrent operations on same file (Promise.all race detection)', async () => {
+    const filePath = path.join(tempDir, 'serialized-test.json');
+    fs.writeFileSync(filePath, '{}', 'utf8');
+
+    const results: number[] = [];
+
+    // Use real timers for this test (fake timers + Promise.all + setTimeout don't mix well)
+    vi.useRealTimers();
+
+    const promises = [
+      withAsyncLock(filePath, async () => {
+        results.push(1);
+        await new Promise(r => setTimeout(r, 50));
+        results.push(2);
+      }),
+      withAsyncLock(filePath, async () => {
+        results.push(3);
+        await new Promise(r => setTimeout(r, 50));
+        results.push(4);
+      }),
+    ];
+
+    await Promise.all(promises);
+
+    // Both operations completed
+    expect(results).toHaveLength(4);
+
+    // Non-interleaved: first operation completes before second starts
+    // [1, 2, 3, 4] means first ran fully, then second ran fully
+    // [3, 4, 1, 2] means second ran fully, then first ran fully
+    // [1, 3, 2, 4] would mean interleaving (bad) — but lock prevents this
+    const isNonInterleaved =
+      (results[0] === 1 && results[1] === 2) ||
+      (results[0] === 3 && results[1] === 4);
+
+    expect(isNonInterleaved).toBe(true);
+
+    // Restore fake timers for afterEach cleanup
+    vi.useFakeTimers();
+  });
+
+  it('allows concurrent operations on different files', async () => {
+    const fileA = path.join(tempDir, 'file-a.json');
+    const fileB = path.join(tempDir, 'file-b.json');
+    fs.writeFileSync(fileA, '{}', 'utf8');
+    fs.writeFileSync(fileB, '{}', 'utf8');
+
+    const results: string[] = [];
+
+    // Use real timers for this test
+    vi.useRealTimers();
+
+    const promiseA = withAsyncLock(fileA, async () => {
+      results.push('A-start');
+      await new Promise(r => setTimeout(r, 20));
+      results.push('A-end');
+    });
+
+    const promiseB = withAsyncLock(fileB, async () => {
+      results.push('B-start');
+      await new Promise(r => setTimeout(r, 20));
+      results.push('B-end');
+    });
+
+    await Promise.all([promiseA, promiseB]);
+
+    // Both operations completed
+    expect(results).toHaveLength(4);
+    // Operations on different files should interleave (both run concurrently)
+    expect(results).toContain('A-start');
+    expect(results).toContain('A-end');
+    expect(results).toContain('B-start');
+    expect(results).toContain('B-end');
+
+    // Restore fake timers for afterEach cleanup
+    vi.useFakeTimers();
+  });
+
+  it('clears Map state between tests (beforeEach clearing)', async () => {
+    // Verify Map is empty at start of test (beforeEach cleared it)
+    expect(asyncLockQueues.size).toBe(0);
+
+    const filePath = path.join(tempDir, 'map-state-test.json');
+    fs.writeFileSync(filePath, '{}', 'utf8');
+
+    // Use real timers
+    vi.useRealTimers();
+
+    // Add entries to the Map via withAsyncLock (starts operations but doesn't wait)
+    const p1 = withAsyncLock(filePath, async () => {
+      await new Promise(r => setTimeout(r, 100));
+    });
+
+    // Wait a bit for the operation to start
+    await new Promise(r => setTimeout(r, 10));
+
+    // Map should have entries (lock for filePath is queued)
+    expect(asyncLockQueues.size).toBeGreaterThanOrEqual(1);
+
+    // Wait for operation to complete to avoid affecting other tests
+    await p1;
+
+    // Restore fake timers for afterEach cleanup
+    vi.useFakeTimers();
+  });
+
+  it('releases lock after function throws', async () => {
+    const filePath = path.join(tempDir, 'error-test.json');
+    fs.writeFileSync(filePath, '{}', 'utf8');
+
+    // Use real timers
+    vi.useRealTimers();
+
+    // First call throws
+    await expect(
+      withAsyncLock(filePath, async () => {
+        throw new Error('intentional failure');
+      })
+    ).rejects.toThrow('intentional failure');
+
+    // Second call should succeed (lock was released)
+    const result = await withAsyncLock(filePath, async () => 'success-after-error');
+
+    expect(result).toBe('success-after-error');
+
+    // Restore fake timers for afterEach cleanup
+    vi.useFakeTimers();
+  });
+
+  it('returns correct value from withAsyncLock', async () => {
+    const filePath = path.join(tempDir, 'return-value-test.json');
+    fs.writeFileSync(filePath, '{}', 'utf8');
+
+    // Use real timers
+    vi.useRealTimers();
+
+    const result = await withAsyncLock(filePath, async () => {
+      return { success: true, value: 42 };
+    });
+
+    expect(result).toEqual({ success: true, value: 42 });
+
+    // Restore fake timers for afterEach cleanup
+    vi.useFakeTimers();
+  });
+
+  it('handles multiple sequential operations on same file', async () => {
+    const filePath = path.join(tempDir, 'sequential-test.json');
+    fs.writeFileSync(filePath, '{}', 'utf8');
+
+    // Use real timers
+    vi.useRealTimers();
+
+    const results: number[] = [];
+
+    for (let i = 0; i < 3; i++) {
+      const idx = i;
+      await withAsyncLock(filePath, async () => {
+        results.push(idx);
+        await new Promise(r => setTimeout(r, 10));
+      });
+    }
+
+    // All three sequential operations completed
+    expect(results).toEqual([0, 1, 2]);
+
+    // Restore fake timers for afterEach cleanup
+    vi.useFakeTimers();
+  });
+});

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

@@ -0,0 +1,296 @@
+/**
+ * Unit tests for loadEvolutionQueue queue loading and migration.
+ * Uses vi.useFakeTimers() per D-10.
+ */
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { loadEvolutionQueue, validateQueueEventPayload } from '../../src/service/evolution-worker.js';
+
+describe('loadEvolutionQueue', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-queue-test-'));
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('loads and migrates legacy queue from file', () => {
+    // Write legacy v1 format (no taskKind, no priority)
+    const legacyQueue = [
+      {
+        id: 'legacy-001',
+        task: 'Diagnose tool_failure pain',
+        score: 78,
+        source: 'tool_failure',
+        reason: 'Tool write failed',
+        timestamp: '2026-04-10T08:30:00.000Z',
+        enqueued_at: '2026-04-10T08:30:05.000Z',
+        started_at: null,
+        completed_at: null,
+        assigned_session_key: null,
+        trigger_text_preview: 'Tool write failed',
+        status: 'pending',
+        resolution: null,
+        session_id: null,
+        agent_id: null,
+        traceId: 'trace-001',
+      },
+    ];
+    const queuePath = path.join(tempDir, 'evolution_queue.json');
+    fs.writeFileSync(queuePath, JSON.stringify(legacyQueue), 'utf8');
+
+    const result = loadEvolutionQueue(queuePath);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe('legacy-001');
+    expect(result[0].taskKind).toBe('pain_diagnosis'); // DEFAULT_TASK_KIND
+    expect(result[0].priority).toBe('medium'); // DEFAULT_PRIORITY
+    expect(result[0].retryCount).toBe(0);
+    expect(result[0].maxRetries).toBe(3);
+  });
+
+  it('loads empty array when file does not exist', () => {
+    const nonExistentPath = path.join(tempDir, 'does-not-exist.json');
+    const result = loadEvolutionQueue(nonExistentPath);
+
+    expect(result).toEqual([]);
+  });
+
+  it('loads existing V2 queue unchanged', () => {
+    // Write V2 format with taskKind and priority
+    const v2Queue = [
+      {
+        id: 'v2-001',
+        taskKind: 'sleep_reflection',
+        priority: 'high',
+        score: 55,
+        source: 'nocturnal',
+        reason: 'Idle workspace',
+        timestamp: '2026-04-13T00:00:00.000Z',
+        enqueued_at: '2026-04-13T00:00:05.000Z',
+        started_at: null,
+        completed_at: null,
+        assigned_session_key: null,
+        trigger_text_preview: 'Idle workspace detected',
+        status: 'pending',
+        resolution: undefined,
+        session_id: null,
+        agent_id: null,
+        traceId: 'trace-v2-001',
+        retryCount: 0,
+        maxRetries: 1,
+        lastError: undefined,
+        resultRef: undefined,
+      },
+    ];
+    const queuePath = path.join(tempDir, 'evolution_queue_v2.json');
+    fs.writeFileSync(queuePath, JSON.stringify(v2Queue), 'utf8');
+
+    const result = loadEvolutionQueue(queuePath);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe('v2-001');
+    expect(result[0].taskKind).toBe('sleep_reflection'); // unchanged
+    expect(result[0].priority).toBe('high'); // unchanged
+    expect(result[0].maxRetries).toBe(1); // unchanged
+  });
+
+  it('respects timestamp ordering in loaded queue', () => {
+    const orderedQueue = [
+      {
+        id: 'first',
+        taskKind: 'pain_diagnosis',
+        priority: 'low',
+        score: 30,
+        source: 'tool_failure',
+        reason: 'First task',
+        timestamp: '2026-04-10T08:00:00.000Z',
+        enqueued_at: '2026-04-10T08:00:00.000Z',
+        started_at: null,
+        completed_at: null,
+        assigned_session_key: null,
+        trigger_text_preview: 'First',
+        status: 'pending',
+        resolution: undefined,
+        session_id: null,
+        agent_id: null,
+        traceId: 'trace-first',
+        retryCount: 0,
+        maxRetries: 3,
+        lastError: undefined,
+        resultRef: undefined,
+      },
+      {
+        id: 'second',
+        taskKind: 'pain_diagnosis',
+        priority: 'medium',
+        score: 60,
+        source: 'tool_failure',
+        reason: 'Second task',
+        timestamp: '2026-04-11T08:00:00.000Z',
+        enqueued_at: '2026-04-11T08:00:00.000Z',
+        started_at: null,
+        completed_at: null,
+        assigned_session_key: null,
+        trigger_text_preview: 'Second',
+        status: 'pending',
+        resolution: undefined,
+        session_id: null,
+        agent_id: null,
+        traceId: 'trace-second',
+        retryCount: 0,
+        maxRetries: 3,
+        lastError: undefined,
+        resultRef: undefined,
+      },
+      {
+        id: 'third',
+        taskKind: 'pain_diagnosis',
+        priority: 'high',
+        score: 90,
+        source: 'tool_failure',
+        reason: 'Third task',
+        timestamp: '2026-04-12T08:00:00.000Z',
+        enqueued_at: '2026-04-12T08:00:00.000Z',
+        started_at: null,
+        completed_at: null,
+        assigned_session_key: null,
+        trigger_text_preview: 'Third',
+        status: 'pending',
+        resolution: undefined,
+        session_id: null,
+        agent_id: null,
+        traceId: 'trace-third',
+        retryCount: 0,
+        maxRetries: 3,
+        lastError: undefined,
+        resultRef: undefined,
+      },
+    ];
+    const queuePath = path.join(tempDir, 'ordered_queue.json');
+    fs.writeFileSync(queuePath, JSON.stringify(orderedQueue), 'utf8');
+
+    const result = loadEvolutionQueue(queuePath);
+
+    expect(result[0].id).toBe('first');
+    expect(result[1].id).toBe('second');
+    expect(result[2].id).toBe('third');
+  });
+
+  it('handles file with trailing newline', () => {
+    const queueWithNewline = [
+      {
+        id: 'newline-test',
+        taskKind: 'pain_diagnosis',
+        priority: 'medium',
+        score: 50,
+        source: 'tool_failure',
+        reason: 'Trailing newline test',
+        timestamp: '2026-04-10T10:00:00.000Z',
+        enqueued_at: '2026-04-10T10:00:00.000Z',
+        started_at: null,
+        completed_at: null,
+        assigned_session_key: null,
+        trigger_text_preview: 'Trailing newline',
+        status: 'pending',
+        resolution: undefined,
+        session_id: null,
+        agent_id: null,
+        traceId: 'trace-newline',
+        retryCount: 0,
+        maxRetries: 3,
+        lastError: undefined,
+        resultRef: undefined,
+      },
+    ];
+    const queuePath = path.join(tempDir, 'newline_queue.json');
+    fs.writeFileSync(queuePath, JSON.stringify(queueWithNewline) + '\n', 'utf8');
+
+    const result = loadEvolutionQueue(queuePath);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe('newline-test');
+  });
+
+  it('round-trip: load returns same data that was written', () => {
+    // Write a V2-format queue, load it, verify data integrity
+    const originalQueue = [
+      {
+        id: 'roundtrip-001',
+        taskKind: 'sleep_reflection',
+        priority: 'high',
+        score: 88,
+        source: 'nocturnal',
+        reason: 'Round-trip test',
+        timestamp: '2026-04-14T02:00:00.000Z',
+        enqueued_at: '2026-04-14T02:00:00.000Z',
+        started_at: null,
+        completed_at: null,
+        assigned_session_key: null,
+        trigger_text_preview: 'Round-trip',
+        status: 'pending',
+        resolution: undefined,
+        session_id: null,
+        agent_id: null,
+        traceId: 'trace-roundtrip',
+        retryCount: 0,
+        maxRetries: 1,
+        lastError: undefined,
+        resultRef: undefined,
+      },
+    ];
+    const queuePath = path.join(tempDir, 'roundtrip_queue.json');
+    fs.writeFileSync(queuePath, JSON.stringify(originalQueue), 'utf8');
+
+    const loaded = loadEvolutionQueue(queuePath);
+
+    expect(loaded).toHaveLength(1);
+    expect(loaded[0].id).toBe(originalQueue[0].id);
+    expect(loaded[0].taskKind).toBe(originalQueue[0].taskKind);
+    expect(loaded[0].priority).toBe(originalQueue[0].priority);
+    expect(loaded[0].score).toBe(originalQueue[0].score);
+    expect(loaded[0].source).toBe(originalQueue[0].source);
+    expect(loaded[0].status).toBe(originalQueue[0].status);
+  });
+});
+
+describe('validateQueueEventPayload', () => {
+  it('returns empty object for null/undefined', () => {
+    expect(validateQueueEventPayload(null)).toEqual({});
+    expect(validateQueueEventPayload(undefined)).toEqual({});
+  });
+
+  it('throws for non-string input', () => {
+    expect(() => (validateQueueEventPayload as any)(123)).toThrow('must be a string');
+    expect(() => (validateQueueEventPayload as any)({})).toThrow('must be a string');
+  });
+
+  it('throws for JSON that is not an object', () => {
+    // Primitive JSON values pass typeof check but fail the object/null guard
+    expect(() => validateQueueEventPayload('"string"')).toThrow('must be a JSON object');
+    // Arrays pass typeof === 'object' check so they reach required fields check first
+    expect(() => validateQueueEventPayload('[1,2,3]')).toThrow('missing required fields');
+  });
+
+  it('throws for object missing required fields', () => {
+    expect(() => validateQueueEventPayload('{"type":"x"}')).toThrow('missing required fields');
+    expect(() => validateQueueEventPayload('{"workspaceId":"x"}')).toThrow('missing required fields');
+  });
+
+  it('returns parsed object for valid payload', () => {
+    const valid = '{"type":"test","workspaceId":"ws-001"}';
+    expect(validateQueueEventPayload(valid)).toEqual({ type: 'test', workspaceId: 'ws-001' });
+  });
+
+  it('throws wrapped SyntaxError for invalid JSON', () => {
+    expect(() => validateQueueEventPayload('not json')).toThrow('Invalid JSON');
+  });
+});