principles-disciple 1.36.0 → 1.37.0

package/tests/integration/gate-real-io.e2e.test.ts

@@ -0,0 +1,251 @@
+/**
+ * Gate Real I/O E2E Tests
+ *
+ * PURPOSE: Verify Gate decision chain with real file system operations.
+ * These tests are designed to DISCOVER bugs, not just confirm existing behavior.
+ *
+ * DESIGN PRINCIPLES:
+ * 1. Use real file system (no mocks for I/O)
+ * 2. Test business invariants: blocks MUST be persisted, state MUST be consistent
+ * 3. Use independent Oracle: read files directly for verification
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { TrajectoryDatabase } from '../../src/core/trajectory.js';
+import { EventLog } from '../../src/core/event-log.js';
+
+// ─────────────────────────────────────────────────────────────────────
+// Helper functions
+// ─────────────────────────────────────────────────────────────────────
+
+interface TestWorkspace {
+  workspaceDir: string;
+  stateDir: string;
+  profilePath: string;
+  planPath: string;
+  trajectory: TrajectoryDatabase;
+  eventLog: EventLog;
+}
+
+function createTestWorkspace(): TestWorkspace {
+  const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-e2e-gate-'));
+  const stateDir = path.join(workspaceDir, '.state');
+  const principlesDir = path.join(workspaceDir, '.principles');
+
+  fs.mkdirSync(stateDir, { recursive: true });
+  fs.mkdirSync(principlesDir, { recursive: true });
+
+  const profilePath = path.join(principlesDir, 'PROFILE.json');
+  const planPath = path.join(workspaceDir, 'PLAN.md');
+
+  // Create default PROFILE.json
+  const defaultProfile = {
+    risk_paths: ['/etc/', '/usr/', '~/.ssh/'],
+    gate: {
+      require_plan_for_risk_paths: true,
+    },
+    progressive_gate: {
+      enabled: true,
+      plan_approvals: {
+        enabled: false,
+        max_lines_override: -1,
+        allowed_patterns: [],
+        allowed_operations: [],
+      },
+    },
+    edit_verification: {
+      enabled: true,
+      max_file_size_bytes: 10 * 1024 * 1024,
+      fuzzy_match_enabled: true,
+      fuzzy_match_threshold: 0.8,
+      skip_large_file_action: 'warn',
+    },
+    thinking_checkpoint: {
+      enabled: false,
+    },
+  };
+  fs.writeFileSync(profilePath, JSON.stringify(defaultProfile, null, 2));
+
+  // Create empty PLAN.md
+  fs.writeFileSync(planPath, '# PLAN\n\nStatus: READY\n');
+
+  // Create trajectory database
+  const trajectory = new TrajectoryDatabase({ workspaceDir });
+
+  // Create event log
+  const eventLog = new EventLog(stateDir);
+
+  return { workspaceDir, stateDir, profilePath, planPath, trajectory, eventLog };
+}
+
+function cleanupWorkspace(ws: TestWorkspace | null): void {
+  if (!ws) return;
+  try {
+    ws.trajectory?.dispose();
+    fs.rmSync(ws.workspaceDir, { recursive: true, force: true });
+  } catch {
+    // ignore
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────
+// PART 1: EventLog Invariants
+// ─────────────────────────────────────────────────────────────────────
+
+describe('Gate: EventLog Invariants', () => {
+  let ws: TestWorkspace | null = null;
+
+  beforeEach(() => {
+    ws = createTestWorkspace();
+  });
+
+  afterEach(() => {
+    cleanupWorkspace(ws);
+    ws = null;
+  });
+
+  describe('INVARIANT: Gate block events must be logged', () => {
+    it('EventLog MUST persist gate block events', () => {
+      ws!.eventLog.recordGateBlock('test-session', {
+        toolName: 'run_shell_command',
+        filePath: '/etc/passwd',
+        reason: 'Risky path detected',
+        blockSource: 'e2e_test',
+      });
+
+      // Independent verification: check events file
+      const today = new Date().toISOString().split('T')[0];
+      const eventsFile = path.join(ws!.stateDir, 'logs', `events_${today}.jsonl`);
+
+      // EventLog buffers, need to flush
+      ws!.eventLog.flush();
+
+      expect(fs.existsSync(eventsFile)).toBe(true);
+
+      const content = fs.readFileSync(eventsFile, 'utf-8');
+      expect(content).toContain('gate_block');
+      expect(content).toContain('run_shell_command');
+    });
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// PART 2: Edit Verification Invariants
+// ─────────────────────────────────────────────────────────────────────
+
+describe('Gate: Edit Verification Invariants', () => {
+  let ws: TestWorkspace | null = null;
+  let testFilePath: string;
+
+  beforeEach(() => {
+    ws = createTestWorkspace();
+    testFilePath = path.join(ws!.workspaceDir, 'test-file.ts');
+    fs.writeFileSync(testFilePath, `function hello() {
+  console.log('Hello, World!');
+}
+
+function goodbye() {
+  console.log('Goodbye!');
+}
+`);
+  });
+
+  afterEach(() => {
+    cleanupWorkspace(ws);
+    ws = null;
+  });
+
+  describe('INVARIANT: Edit verification format', () => {
+    it('Exact match MUST succeed for correct oldText', () => {
+      const fileContent = fs.readFileSync(testFilePath, 'utf-8');
+      const oldText = "console.log('Hello, World!');";
+
+      // Verify the text exists - this is what edit verification checks
+      expect(fileContent).toContain(oldText);
+    });
+
+    it('Edit verification MUST fail for non-existent text', () => {
+      const fileContent = fs.readFileSync(testFilePath, 'utf-8');
+      const nonExistentText = "this text does not exist in the file 12345";
+
+      // Verify the text does NOT exist
+      expect(fileContent).not.toContain(nonExistentText);
+    });
+  });
+
+  describe('INVARIANT: File size handling', () => {
+    it('Large file MUST be detectable', () => {
+      // Create a large file (over 10MB)
+      const largeContent = 'x'.repeat(11 * 1024 * 1024);
+      const largeFilePath = path.join(ws!.workspaceDir, 'large-file.ts');
+      fs.writeFileSync(largeFilePath, largeContent);
+
+      const stats = fs.statSync(largeFilePath);
+
+      // INVARIANT: Large file must be detectable
+      expect(stats.size).toBeGreaterThan(10 * 1024 * 1024);
+
+      // Cleanup
+      fs.unlinkSync(largeFilePath);
+    });
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// PART 3: Resilience Tests
+// ─────────────────────────────────────────────────────────────────────
+
+describe('Gate: Resilience', () => {
+  let ws: TestWorkspace | null = null;
+
+  beforeEach(() => {
+    ws = createTestWorkspace();
+  });
+
+  afterEach(() => {
+    cleanupWorkspace(ws);
+    ws = null;
+  });
+
+  describe('RESILIENCE: Missing configuration', () => {
+    it('Profile file MUST be readable when valid JSON', () => {
+      const profileContent = fs.readFileSync(ws!.profilePath, 'utf-8');
+      const profile = JSON.parse(profileContent);
+
+      // INVARIANT: Valid profile must have expected structure
+      expect(profile).toBeDefined();
+      expect(profile.gate).toBeDefined();
+    });
+
+    it('Gate MUST handle corrupted PROFILE.json gracefully', () => {
+      // Write invalid JSON
+      fs.writeFileSync(ws!.profilePath, 'not valid json {{{');
+
+      // Attempt to parse should throw, but not crash
+      expect(() => {
+        try {
+          JSON.parse(fs.readFileSync(ws!.profilePath, 'utf-8'));
+        } catch {
+          // Expected
+        }
+      }).not.toThrow();
+    });
+  });
+
+  describe('RESILIENCE: Missing state directory', () => {
+    it('EventLog MUST handle missing logs directory', () => {
+      // Remove state directory
+      fs.rmSync(ws!.stateDir, { recursive: true, force: true });
+
+      // Attempt to create event log
+      // Should recreate the directory
+      expect(() => new EventLog(ws!.stateDir)).not.toThrow();
+
+      // Verify directory was created
+      expect(fs.existsSync(ws!.stateDir)).toBe(true);
+    });
+  });
+});

package/tests/integration/pain-diagnostician-loop.e2e.test.ts

@@ -0,0 +1,380 @@
+/**
+ * Pain → Diagnostician Loop E2E Tests
+ *
+ * PURPOSE: Verify business invariants in the Pain → Diagnostician loop.
+ * These tests are designed to DISCOVER bugs, not just confirm existing behavior.
+ *
+ * DESIGN PRINCIPLES:
+ * 1. Use real file system (no mocks for I/O)
+ * 2. Test business invariants, not implementation details
+ * 3. Use independent Oracle data sources for verification
+ * 4. Test resilience (corruption recovery, concurrency safety)
+ *
+ * DATA FLOW:
+ * after_tool_call (hooks/pain.ts)
+ *     → writePainFlag → .state/.pain_flag
+ * Evolution Worker (service/evolution-worker.ts)
+ *     → enqueues pain_diagnosis task → evolution_queue.json
+ *     → addDiagnosticianTask → diagnostician_tasks.json
+ * before_prompt_build (hooks/prompt.ts)
+ *     → getPendingDiagnosticianTasks → inject into prompt
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import {
+  buildPainFlag,
+  writePainFlag,
+  readPainFlagData,
+  validatePainFlag,
+} from '../../src/core/pain.js';
+import { getPendingDiagnosticianTasks, addDiagnosticianTask } from '../../src/core/diagnostician-task-store.js';
+
+// ─────────────────────────────────────────────────────────────────────
+// Helper functions
+// ─────────────────────────────────────────────────────────────────────
+
+function createTestWorkspace(): { workspaceDir: string; stateDir: string } {
+  const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-e2e-pain-'));
+  const stateDir = path.join(workspaceDir, '.state');
+  fs.mkdirSync(stateDir, { recursive: true });
+  fs.mkdirSync(path.join(workspaceDir, '.principles'), { recursive: true });
+  return { workspaceDir, stateDir };
+}
+
+function cleanupWorkspace(workspaceDir: string): void {
+  try {
+    fs.rmSync(workspaceDir, { recursive: true, force: true });
+  } catch {
+    // ignore
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────
+// PART 1: Business Invariants
+// Tests that verify system MUST maintain these rules
+// ─────────────────────────────────────────────────────────────────────
+
+describe('Pain → Diagnostician: Business Invariants', () => {
+  let workspaceDir: string;
+  let stateDir: string;
+
+  beforeEach(() => {
+    const ws = createTestWorkspace();
+    workspaceDir = ws.workspaceDir;
+    stateDir = ws.stateDir;
+  });
+
+  afterEach(() => {
+    cleanupWorkspace(workspaceDir);
+  });
+
+  // ── INVARIANT 1: Pain flag format contract ──
+  describe('INVARIANT: Pain flag format contract', () => {
+    it('MUST contain all required fields after writePainFlag', () => {
+      const data = buildPainFlag({
+        source: 'tool_failure',
+        score: '70',
+        reason: 'Command failed with exit code 1',
+        session_id: 'test-session-123',
+        agent_id: 'main',
+        is_risky: true,
+      });
+
+      writePainFlag(workspaceDir, data);
+
+      // Independent verification: read file directly, don't trust writePainFlag
+      const painFlagPath = path.join(stateDir, '.pain_flag');
+      expect(fs.existsSync(painFlagPath)).toBe(true);
+
+      const content = fs.readFileSync(painFlagPath, 'utf-8');
+
+      // INVARIANT: All required fields MUST be present
+      expect(content).toContain('source: tool_failure');
+      expect(content).toContain('score: 70');
+      expect(content).toMatch(/time: \d{4}-\d{2}-\d{2}T/); // ISO timestamp with space
+      expect(content).toContain('reason:');
+      expect(content).toContain('is_risky: true');
+    });
+
+    it('MUST NOT write empty optional fields to disk', () => {
+      const data = buildPainFlag({
+        source: 'human_intervention',
+        score: '50',
+        reason: 'User feedback',
+        // Optional fields omitted
+      });
+
+      writePainFlag(workspaceDir, data);
+
+      const content = fs.readFileSync(path.join(stateDir, '.pain_flag'), 'utf-8');
+
+      // INVARIANT: Empty optional fields MUST NOT appear in file
+      // This prevents confusion when reading the file
+      expect(content).not.toMatch(/trace_id:\s*$/m);
+      expect(content).not.toMatch(/trigger_text_preview:\s*$/m);
+    });
+
+    it('score MUST be in valid range 0-100', () => {
+      // Test boundary values
+      const scores = ['0', '50', '100'];
+
+      for (const score of scores) {
+        const data = buildPainFlag({
+          source: 'test',
+          score,
+          reason: 'Test',
+        });
+
+        writePainFlag(workspaceDir, data);
+
+        const read = readPainFlagData(workspaceDir);
+        const numScore = Number(read.score);
+
+        // INVARIANT: Score MUST be in valid range
+        expect(numScore).toBeGreaterThanOrEqual(0);
+        expect(numScore).toBeLessThanOrEqual(100);
+      }
+    });
+  });
+
+  // ── INVARIANT 2: Pain flag validation contract ──
+  describe('INVARIANT: Pain flag validation', () => {
+    it('validatePainFlag MUST reject flags missing required fields', () => {
+      const invalidFlags = [
+        { source: '', score: '50', time: '2024-01-01', reason: 'test' }, // empty source
+        { source: 'test', score: '', time: '2024-01-01', reason: 'test' }, // empty score
+        { source: 'test', score: '50', time: '', reason: 'test' }, // empty time
+        { source: 'test', score: '50', time: '2024-01-01', reason: '' }, // empty reason
+      ];
+
+      for (const flag of invalidFlags) {
+        const missing = validatePainFlag(flag);
+        // INVARIANT: Missing required fields MUST be detected
+        expect(missing.length).toBeGreaterThan(0);
+      }
+    });
+
+    it('validatePainFlag MUST accept valid flags', () => {
+      const validFlag = {
+        source: 'tool_failure',
+        score: '70',
+        time: new Date().toISOString(),
+        reason: 'Command failed',
+        session_id: 'test',
+        agent_id: 'main',
+        is_risky: 'false',
+      };
+
+      const missing = validatePainFlag(validFlag);
+      // INVARIANT: Valid flags MUST pass validation
+      expect(missing).toEqual([]);
+    });
+  });
+
+  // ── INVARIANT 3: Diagnostician task store contract ──
+  describe('INVARIANT: Diagnostician task store', () => {
+    it('MUST persist tasks with correct structure', async () => {
+      const taskId = `task-${Date.now()}`;
+      const prompt = 'Diagnose the following pain signal:\n- source: tool_failure\n- score: 70';
+
+      await addDiagnosticianTask(stateDir, taskId, prompt);
+
+      // Independent verification: read file directly
+      const tasksPath = path.join(stateDir, 'diagnostician_tasks.json');
+      expect(fs.existsSync(tasksPath)).toBe(true);
+
+      const store = JSON.parse(fs.readFileSync(tasksPath, 'utf-8'));
+
+      // INVARIANT: Task MUST be in store with correct structure
+      expect(store.tasks).toBeDefined();
+      expect(store.tasks[taskId]).toBeDefined();
+      expect(store.tasks[taskId].prompt).toBe(prompt);
+      expect(store.tasks[taskId].status).toBe('pending');
+      expect(store.tasks[taskId].createdAt).toBeDefined();
+    });
+
+    it('getPendingDiagnosticianTasks MUST only return pending tasks', async () => {
+      // Add pending task
+      await addDiagnosticianTask(stateDir, 'pending-task', 'Test prompt');
+
+      // Add completed task manually
+      const tasksPath = path.join(stateDir, 'diagnostician_tasks.json');
+      const store = { tasks: {} };
+      store.tasks['completed-task'] = {
+        prompt: 'Completed',
+        status: 'completed',
+        createdAt: new Date().toISOString(),
+      };
+      fs.writeFileSync(tasksPath, JSON.stringify(store));
+
+      // Add pending task to the store
+      const existingStore = JSON.parse(fs.readFileSync(tasksPath, 'utf-8'));
+      existingStore.tasks['pending-task'] = {
+        prompt: 'Pending',
+        status: 'pending',
+        createdAt: new Date().toISOString(),
+      };
+      fs.writeFileSync(tasksPath, JSON.stringify(existingStore));
+
+      const pending = getPendingDiagnosticianTasks(stateDir);
+
+      // INVARIANT: Only pending tasks MUST be returned
+      expect(pending.some(t => t.id === 'pending-task')).toBe(true);
+      expect(pending.some(t => t.id === 'completed-task')).toBe(false);
+    });
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// PART 2: Resilience Tests
+// Tests that verify system behavior under abnormal conditions
+// ─────────────────────────────────────────────────────────────────────
+
+describe('Pain → Diagnostician: Resilience', () => {
+  let workspaceDir: string;
+  let stateDir: string;
+
+  beforeEach(() => {
+    const ws = createTestWorkspace();
+    workspaceDir = ws.workspaceDir;
+    stateDir = ws.stateDir;
+  });
+
+  afterEach(() => {
+    cleanupWorkspace(workspaceDir);
+  });
+
+  // ── RESILIENCE 1: Corruption recovery ──
+  describe('RESILIENCE: Corruption recovery', () => {
+    it('readPainFlagData MUST NOT crash on corrupted file', () => {
+      // Write corrupted content
+      fs.writeFileSync(path.join(stateDir, '.pain_flag'), 'invalid {{{ json');
+
+      // This should NOT throw
+      expect(() => readPainFlagData(workspaceDir)).not.toThrow();
+
+      const data = readPainFlagData(workspaceDir);
+
+      // INVARIANT: Should return safe default, not undefined/null
+      expect(data).toBeDefined();
+      expect(typeof data).toBe('object');
+    });
+
+    it('getPendingDiagnosticianTasks MUST NOT crash on missing file', () => {
+      // Don't create diagnostician_tasks.json
+
+      // This should NOT throw
+      expect(() => getPendingDiagnosticianTasks(stateDir)).not.toThrow();
+
+      const pending = getPendingDiagnosticianTasks(stateDir);
+
+      // INVARIANT: Should return empty array, not crash
+      expect(Array.isArray(pending)).toBe(true);
+      expect(pending.length).toBe(0);
+    });
+
+    it('getPendingDiagnosticianTasks MUST NOT crash on corrupted JSON', () => {
+      fs.writeFileSync(
+        path.join(stateDir, 'diagnostician_tasks.json'),
+        'not valid json {{{'
+      );
+
+      // This should NOT throw
+      expect(() => getPendingDiagnosticianTasks(stateDir)).not.toThrow();
+
+      const pending = getPendingDiagnosticianTasks(stateDir);
+
+      // INVARIANT: Should return empty array as fallback
+      expect(Array.isArray(pending)).toBe(true);
+    });
+  });
+
+  // ── RESILIENCE 2: Concurrent access safety ──
+  describe('RESILIENCE: Concurrent access', () => {
+    it('writePainFlag MUST handle rapid sequential writes', () => {
+      // Simulate rapid consecutive writes
+      for (let i = 0; i < 10; i++) {
+        const data = buildPainFlag({
+          source: `test-${i}`,
+          score: String(i * 10),
+          reason: `Test ${i}`,
+        });
+        writePainFlag(workspaceDir, data);
+      }
+
+      // INVARIANT: File must exist and be valid after rapid writes
+      const painFlagPath = path.join(stateDir, '.pain_flag');
+      expect(fs.existsSync(painFlagPath)).toBe(true);
+
+      const content = fs.readFileSync(painFlagPath, 'utf-8');
+
+      // Should not have corruption artifacts
+      expect(content).not.toContain('undefined');
+      expect(content).not.toContain('[object Object]');
+      expect(content).not.toContain('null');
+    });
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// PART 3: Round-trip Tests
+// Tests that verify data survives the full write → read cycle
+// ─────────────────────────────────────────────────────────────────────
+
+describe('Pain → Diagnostician: Round-trip', () => {
+  let workspaceDir: string;
+  let stateDir: string;
+
+  beforeEach(() => {
+    const ws = createTestWorkspace();
+    workspaceDir = ws.workspaceDir;
+    stateDir = ws.stateDir;
+  });
+
+  afterEach(() => {
+    cleanupWorkspace(workspaceDir);
+  });
+
+  it('Pain flag round-trip: write → read → verify', () => {
+    const original = buildPainFlag({
+      source: 'tool_failure',
+      score: '75',
+      reason: 'npm test failed with exit code 1',
+      session_id: 'session-abc123',
+      agent_id: 'main',
+      is_risky: false,
+      trace_id: 'trace-xyz789',
+      trigger_text_preview: 'npm test',
+    });
+
+    writePainFlag(workspaceDir, original);
+    const read = readPainFlagData(workspaceDir);
+
+    // INVARIANT: All fields MUST survive round-trip
+    expect(read.source).toBe(original.source);
+    expect(read.score).toBe(original.score);
+    expect(read.reason).toBe(original.reason);
+    expect(read.session_id).toBe(original.session_id);
+    expect(read.agent_id).toBe(original.agent_id);
+    expect(read.is_risky).toBe(original.is_risky);
+    expect(read.trace_id).toBe(original.trace_id);
+    expect(read.trigger_text_preview).toBe(original.trigger_text_preview);
+  });
+
+  it('Diagnostician task round-trip: add → get → verify', async () => {
+    const taskId = 'round-trip-task';
+    const prompt = 'Analyze the following error:\n```\nError: ENOENT\n```';
+
+    await addDiagnosticianTask(stateDir, taskId, prompt);
+    const pending = getPendingDiagnosticianTasks(stateDir);
+    const task = pending.find(t => t.id === taskId);
+
+    // INVARIANT: Task MUST survive round-trip
+    expect(task).toBeDefined();
+    expect(task!.task.prompt).toBe(prompt);
+    expect(task!.task.status).toBe('pending');
+  });
+});

package/tests/integration/tool-hooks-workspace-dir.e2e.test.ts

@@ -31,11 +31,17 @@ const createMockApi = (workspaceDir: string) => ({
   pluginConfig: {},
 });
 
+// Helper to get today's events file path (EventLog uses date-stamped files)
+const getTodayEventsFile = (logsDir: string) => {
+  const today = new Date().toISOString().split('T')[0];
+  return path.join(logsDir, `events_${today}.jsonl`);
+};
+
 describe('E2E: Tool Hooks workspaceDir Resolution', () => {
   const testWorkspaceDir = path.join(os.tmpdir(), 'pd-tool-hooks-e2e-test');
   const stateDir = path.join(testWorkspaceDir, '.state');
   const logsDir = path.join(stateDir, 'logs');
-  const eventsFile = path.join(logsDir, 'events.jsonl');
+  const eventsFile = getTodayEventsFile(logsDir);
 
   beforeAll(() => {
     // Create test workspace structure
@@ -149,7 +155,7 @@ describe('E2E: EventLog flushImmediately', () => {
   const testWorkspaceDir = path.join(os.tmpdir(), 'pd-eventlog-flush-test');
   const stateDir = path.join(testWorkspaceDir, '.state');
   const logsDir = path.join(stateDir, 'logs');
-  const eventsFile = path.join(logsDir, 'events.jsonl');
+  const eventsFile = getTodayEventsFile(logsDir);
 
   beforeAll(() => {
     fs.mkdirSync(logsDir, { recursive: true });