principles-disciple 1.8.0 → 1.8.2

package/tests/core/trajectory.test.ts

@@ -0,0 +1,265 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { TrajectoryDatabase } from '../../src/core/trajectory.js';
+
+describe('TrajectoryDatabase', () => {
+  let workspaceDir: string | null = null;
+
+  afterEach(() => {
+    if (workspaceDir) {
+      fs.rmSync(workspaceDir, { recursive: true, force: true });
+      workspaceDir = null;
+    }
+  });
+
+  it('bootstraps trajectory.db and blob/export directories', () => {
+    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-trajectory-'));
+    const db = new TrajectoryDatabase({ workspaceDir });
+
+    expect(fs.existsSync(path.join(workspaceDir, '.state', 'trajectory.db'))).toBe(true);
+    expect(fs.existsSync(path.join(workspaceDir, '.state', 'blobs'))).toBe(true);
+    expect(fs.existsSync(path.join(workspaceDir, '.state', 'exports'))).toBe(true);
+
+    const stats = db.getDataStats();
+    expect(stats.assistantTurns).toBe(0);
+    expect(stats.userTurns).toBe(0);
+    expect(stats.pendingSamples).toBe(0);
+    db.dispose();
+  });
+
+  it('stores oversized assistant raw text in blob storage and preserves sanitized text inline', () => {
+    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-trajectory-'));
+    const db = new TrajectoryDatabase({ workspaceDir, blobInlineThresholdBytes: 128 });
+
+    const raw = `${'A'.repeat(256)}\n<empathy signal="damage" severity="mild"/>`;
+    db.recordAssistantTurn({
+      sessionId: 's1',
+      runId: 'run-1',
+      provider: 'test',
+      model: 'model',
+      rawText: raw,
+      sanitizedText: 'clean text',
+      usageJson: { input: 10, output: 20 },
+      empathySignalJson: { detected: true, severity: 'mild' },
+    });
+
+    const turns = db.listAssistantTurns('s1');
+    expect(turns).toHaveLength(1);
+    expect(turns[0].sanitizedText).toBe('clean text');
+    expect(turns[0].rawText).toBe(raw);
+    expect(turns[0].blobRef).toBeTruthy();
+    db.dispose();
+  });
+
+  it('creates a pending correction sample after a user correction followed by successful recovery', () => {
+    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-trajectory-'));
+    const db = new TrajectoryDatabase({ workspaceDir });
+
+    const assistantTurnId = db.recordAssistantTurn({
+      sessionId: 's1',
+      runId: 'run-1',
+      provider: 'test',
+      model: 'model',
+      rawText: 'I changed the wrong file.',
+      sanitizedText: 'I changed the wrong file.',
+      usageJson: {},
+      empathySignalJson: { detected: false },
+    });
+
+    db.recordToolCall({
+      sessionId: 's1',
+      toolName: 'edit',
+      outcome: 'failure',
+      errorType: 'EACCES',
+      errorMessage: 'permission denied',
+    });
+
+    db.recordUserTurn({
+      sessionId: 's1',
+      turnIndex: 1,
+      rawText: '你错了，不是这个文件，重新来。',
+      correctionDetected: true,
+      correctionCue: '你错了',
+      referencesAssistantTurnId: assistantTurnId,
+    });
+
+    db.recordToolCall({
+      sessionId: 's1',
+      toolName: 'edit',
+      outcome: 'success',
+    });
+
+    const samples = db.listCorrectionSamples('pending');
+    expect(samples).toHaveLength(1);
+    expect(samples[0].sessionId).toBe('s1');
+    expect(samples[0].badAssistantTurnId).toBe(assistantTurnId);
+    expect(samples[0].reviewStatus).toBe('pending');
+    expect(samples[0].qualityScore).toBeGreaterThan(0);
+    db.dispose();
+  });
+
+  it('does not create a correction sample when prerequisites are missing', () => {
+    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-trajectory-'));
+    const db = new TrajectoryDatabase({ workspaceDir });
+
+    db.recordToolCall({
+      sessionId: 's1',
+      toolName: 'edit',
+      outcome: 'failure',
+      errorType: 'EACCES',
+    });
+    db.recordUserTurn({
+      sessionId: 's1',
+      turnIndex: 1,
+      rawText: 'redo',
+      correctionDetected: false,
+      referencesAssistantTurnId: null,
+    });
+    db.recordToolCall({
+      sessionId: 's1',
+      toolName: 'edit',
+      outcome: 'success',
+    });
+
+    expect(db.listCorrectionSamples('pending')).toHaveLength(0);
+    db.dispose();
+  });
+
+  it('raises when reviewing a missing correction sample', () => {
+    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-trajectory-'));
+    const db = new TrajectoryDatabase({ workspaceDir });
+
+    expect(() => db.reviewCorrectionSample('missing', 'approved')).toThrow('Correction sample not found');
+    db.dispose();
+  });
+
+  it('aggregates daily metrics without multiplying user corrections', () => {
+    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-trajectory-'));
+    const db = new TrajectoryDatabase({ workspaceDir });
+
+    db.recordToolCall({
+      sessionId: 's1',
+      toolName: 'edit',
+      outcome: 'failure',
+      createdAt: '2026-03-19T10:00:00.000Z',
+    });
+    db.recordToolCall({
+      sessionId: 's1',
+      toolName: 'write',
+      outcome: 'success',
+      createdAt: '2026-03-19T11:00:00.000Z',
+    });
+    db.recordUserTurn({
+      sessionId: 's1',
+      turnIndex: 1,
+      rawText: 'redo',
+      correctionDetected: true,
+      correctionCue: 'redo',
+      createdAt: '2026-03-19T12:00:00.000Z',
+    });
+    db.recordUserTurn({
+      sessionId: 's1',
+      turnIndex: 2,
+      rawText: 'again',
+      correctionDetected: true,
+      correctionCue: 'again',
+      createdAt: '2026-03-19T13:00:00.000Z',
+    });
+
+    const result = db.exportAnalytics();
+    const payload = JSON.parse(fs.readFileSync(result.filePath, 'utf8')) as {
+      dailyMetrics: Array<{ day: string; tool_calls: number; failures: number; user_corrections: number }>;
+    };
+    expect(payload.dailyMetrics).toEqual([
+      { day: '2026-03-19', tool_calls: 2, failures: 1, user_corrections: 2 },
+    ]);
+    db.dispose();
+  });
+
+  it('applies busy_timeout and prunes orphaned blobs on startup', () => {
+    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-trajectory-'));
+    const blobDir = path.join(workspaceDir, '.state', 'blobs');
+    fs.mkdirSync(blobDir, { recursive: true });
+    const orphanBlob = path.join(blobDir, 'assistant-orphan.txt');
+    fs.writeFileSync(orphanBlob, 'stale blob', 'utf8');
+    const oldTime = new Date('2026-01-01T00:00:00.000Z');
+    fs.utimesSync(orphanBlob, oldTime, oldTime);
+
+    const db = new TrajectoryDatabase({
+      workspaceDir,
+      busyTimeoutMs: 2500,
+      orphanBlobGraceDays: 0,
+    });
+
+    expect((db as any).db.pragma('busy_timeout', { simple: true })).toBe(2500);
+    expect(fs.existsSync(orphanBlob)).toBe(false);
+    db.dispose();
+  });
+
+  it('imports legacy sessions, events, and evolution artifacts idempotently', () => {
+    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-trajectory-'));
+    const sessionDir = path.join(workspaceDir, '.state', 'sessions');
+    const logsDir = path.join(workspaceDir, '.state', 'logs');
+    const memoryDir = path.join(workspaceDir, 'memory');
+    fs.mkdirSync(sessionDir, { recursive: true });
+    fs.mkdirSync(logsDir, { recursive: true });
+    fs.mkdirSync(memoryDir, { recursive: true });
+
+    fs.writeFileSync(
+      path.join(sessionDir, 'session-a.json'),
+      JSON.stringify({ sessionId: 'legacy-session', lastActivityAt: Date.parse('2026-03-18T10:00:00.000Z') }),
+      'utf8',
+    );
+    fs.writeFileSync(
+      path.join(logsDir, 'events.jsonl'),
+      [
+        JSON.stringify({
+          type: 'pain_signal',
+          sessionId: 'legacy-session',
+          ts: '2026-03-18T10:01:00.000Z',
+          data: { source: 'legacy_pain', score: 12, reason: 'legacy reason' },
+        }),
+        JSON.stringify({
+          type: 'trust_change',
+          sessionId: 'legacy-session',
+          ts: '2026-03-18T10:02:00.000Z',
+          data: { previousScore: 80, newScore: 82, delta: 2, reason: 'legacy trust' },
+        }),
+      ].join('\n'),
+      'utf8',
+    );
+    fs.writeFileSync(
+      path.join(memoryDir, 'evolution.jsonl'),
+      `${JSON.stringify({
+        type: 'principle_promoted',
+        ts: '2026-03-18T10:03:00.000Z',
+        data: { principleId: 'p-1', summary: 'legacy principle' },
+      })}\n`,
+      'utf8',
+    );
+
+    const db = new TrajectoryDatabase({ workspaceDir });
+    const firstStats = db.getDataStats();
+    expect(firstStats.painEvents).toBe(1);
+    expect(firstStats.assistantTurns).toBe(0);
+
+    const analytics = JSON.parse(fs.readFileSync(db.exportAnalytics().filePath, 'utf8')) as {
+      stats: { painEvents: number };
+      principleEffectiveness: Array<{ event_type: string; total: number }>;
+    };
+    expect(analytics.stats.painEvents).toBe(1);
+    expect(analytics.principleEffectiveness).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ event_type: 'principle_promoted', total: 1 }),
+      ]),
+    );
+    db.dispose();
+
+    const reopened = new TrajectoryDatabase({ workspaceDir });
+    const secondStats = reopened.getDataStats();
+    expect(secondStats.painEvents).toBe(1);
+    reopened.dispose();
+  });
+});

package/tests/core/workspace-context-factory.test.ts

@@ -0,0 +1,18 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createTestContext } from '../test-utils.js';
+import * as path from 'path';
+
+describe('WorkspaceContext Factory (Test Utils)', () => {
+    it('should create a test context with a temporary directory', () => {
+        const wctx = createTestContext();
+        
+        expect(wctx.workspaceDir).toContain('pd-test-');
+        expect(wctx.stateDir).toContain('.state');
+    });
+
+    it('should allow overriding workspaceDir', () => {
+        const customDir = path.resolve('/custom/test');
+        const wctx = createTestContext({ workspaceDir: customDir });
+        expect(wctx.workspaceDir).toBe(customDir);
+    });
+});

package/tests/core/workspace-context.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { WorkspaceContext } from '../../src/core/workspace-context.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+vi.mock('fs');
+vi.mock('../../src/core/trajectory.js', () => ({
+    TrajectoryRegistry: {
+        get: vi.fn(() => ({
+            dispose: vi.fn(),
+        })),
+        use: vi.fn(),
+        dispose: vi.fn(),
+        clear: vi.fn(),
+    }
+}));
+
+describe('WorkspaceContext', () => {
+    // Use path.resolve for cross-platform compatibility on Windows
+    const workspaceDir = path.resolve('/mock/workspace');
+    const stateDir = path.resolve('/mock/state');
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        WorkspaceContext.clearCache();
+    });
+
+    afterEach(() => {
+        vi.resetAllMocks();
+    });
+
+    it('should create an instance from hook context', () => {
+        const mockCtx = { workspaceDir, stateDir };
+        const wctx = WorkspaceContext.fromHookContext(mockCtx);
+        
+        expect(wctx.workspaceDir).toBe(workspaceDir);
+        expect(wctx.stateDir).toBe(stateDir);
+    });
+
+    it('should cache instances based on workspaceDir', () => {
+        const mockCtx1 = { workspaceDir, stateDir: path.resolve('/state1') };
+        const mockCtx2 = { workspaceDir, stateDir: path.resolve('/state2') };
+        
+        const wctx1 = WorkspaceContext.fromHookContext(mockCtx1);
+        const wctx2 = WorkspaceContext.fromHookContext(mockCtx2);
+        
+        expect(wctx1).toBe(wctx2);
+        expect(wctx1.stateDir).toBe(path.resolve('/state1'));
+    });
+
+    it('should use fallback workspace when workspaceDir is missing', () => {
+        const mockCtx = { stateDir };
+        const wctx = WorkspaceContext.fromHookContext(mockCtx);
+        expect(wctx).toBeDefined();
+        expect(wctx.workspaceDir).toBeDefined();
+    });
+
+    it('should resolve paths using PD_FILES keys', () => {
+        const mockCtx = { workspaceDir };
+        const wctx = WorkspaceContext.fromHookContext(mockCtx);
+        
+        // PROFILE is at .principles/PROFILE.json
+        expect(wctx.resolve('PROFILE')).toBe(path.join(workspaceDir, '.principles', 'PROFILE.json'));
+        // PLAN is at root
+        expect(wctx.resolve('PLAN')).toBe(path.join(workspaceDir, 'PLAN.md'));
+    });
+
+    it('should support explicit disposal from cache', () => {
+        const mockCtx = { workspaceDir };
+        const wctx1 = WorkspaceContext.fromHookContext(mockCtx);
+        
+        WorkspaceContext.dispose(workspaceDir);
+        
+        const wctx2 = WorkspaceContext.fromHookContext(mockCtx);
+        expect(wctx1).not.toBe(wctx2);
+    });
+
+    it('should allow invalidation of internal state', () => {
+        const mockCtx = { workspaceDir };
+        const wctx = WorkspaceContext.fromHookContext(mockCtx);
+        
+        expect(() => wctx.invalidate()).not.toThrow();
+    });
+
+    it('should lazy load ConfigService', () => {
+        const mockCtx = { workspaceDir };
+        const wctx = WorkspaceContext.fromHookContext(mockCtx);
+        
+        const config = wctx.config;
+        expect(config).toBeDefined();
+        expect(wctx.config).toBe(config); // Should be cached
+    });
+
+    it('should lazy load EventLog', () => {
+        const mockCtx = { workspaceDir };
+        const wctx = WorkspaceContext.fromHookContext(mockCtx);
+        
+        const eventLog = wctx.eventLog;
+        expect(eventLog).toBeDefined();
+        expect(wctx.eventLog).toBe(eventLog); // Should be cached
+    });
+
+    it('should pass trajectory settings from config into the registry', async () => {
+        const { TrajectoryRegistry } = await import('../../src/core/trajectory.js');
+        const mockCtx = { workspaceDir };
+        const wctx = WorkspaceContext.fromHookContext(mockCtx);
+
+        (wctx as any)._config = {
+            get: vi.fn((key: string) => {
+                if (key === 'trajectory.blob_inline_threshold_bytes') return 2048;
+                if (key === 'trajectory.busy_timeout_ms') return 1500;
+                if (key === 'trajectory.orphan_blob_grace_days') return 2;
+                return undefined;
+            }),
+        };
+
+        const trajectory = wctx.trajectory;
+        expect(trajectory).toBeDefined();
+        expect(TrajectoryRegistry.get).toHaveBeenCalledWith(workspaceDir, {
+            blobInlineThresholdBytes: 2048,
+            busyTimeoutMs: 1500,
+            orphanBlobGraceDays: 2,
+        });
+    });
+
+    it('should lazy load Dictionary service', () => {
+        const mockCtx = { workspaceDir };
+        const wctx = WorkspaceContext.fromHookContext(mockCtx);
+        
+        const dictionary = wctx.dictionary;
+        expect(dictionary).toBeDefined();
+        expect(wctx.dictionary).toBe(dictionary);
+    });
+});

package/tests/fixtures/nocturnal-reviewed-subset.json

@@ -0,0 +1,183 @@
+{
+  "$schema": "nocturnal-reviewed-subset-v1",
+  "description": "Reviewed subset fixture for comparing single-reflector vs Trinity quality",
+  "version": "1.0.0",
+  "createdAt": "2026-03-28T00:00:00.000Z",
+  "testCases": [
+    {
+      "caseId": "case-001",
+      "principleId": "T-01",
+      "principleDescription": "Map Before Territory: Always survey the existing structure before making changes",
+      "sessionId": "session-case-001",
+      "signalType": "failure",
+      "signalContext": "Agent edited src/main.ts without reading it first, causing a merge conflict",
+      "singleReflectorOutput": {
+        "artifactId": "single-001-artifact",
+        "sessionId": "session-case-001",
+        "principleId": "T-01",
+        "sourceSnapshotRef": "snapshot-case-001",
+        "badDecision": "Edited src/main.ts without first reading its contents, leading to a merge conflict",
+        "betterDecision": "Read src/main.ts to understand its current structure before making edits",
+        "rationale": "Surveying the existing territory prevents conflicts and ensures edits integrate properly",
+        "createdAt": "2026-03-28T00:01:00.000Z"
+      },
+      "trinityOutput": {
+        "selectedCandidateIndex": 0,
+        "badDecision": "Edited src/main.ts without first reading its contents, leading to a merge conflict with parallel changes",
+        "betterDecision": "Before editing, read src/main.ts to understand its current structure and identify any conflicting sections",
+        "rationale": "Surveying the existing territory before making changes prevents conflicts and ensures the edit integrates properly with the current implementation",
+        "sessionId": "session-case-001",
+        "principleId": "T-01",
+        "sourceSnapshotRef": "snapshot-case-001",
+        "telemetry": {
+          "chainMode": "trinity",
+          "dreamerPassed": true,
+          "philosopherPassed": true,
+          "scribePassed": true,
+          "candidateCount": 3,
+          "selectedCandidateIndex": 0,
+          "stageFailures": []
+        }
+      },
+      "qualityScores": {
+        "singleReflector": {
+          "specificity": 0.85,
+          "principleAlignment": 0.90,
+          "actionability": 0.88,
+          "rationaleQuality": 0.85,
+          "overall": 0.87
+        },
+        "trinity": {
+          "specificity": 0.95,
+          "principleAlignment": 0.95,
+          "actionability": 0.92,
+          "rationaleQuality": 0.95,
+          "overall": 0.94
+        }
+      },
+      "trinityWins": true,
+      "notes": "Trinity produces more specific badDecision and betterDecision with better rationale"
+    },
+    {
+      "caseId": "case-002",
+      "principleId": "T-08",
+      "principleDescription": "Pain as Signal: Treat failures and errors as signals to pause and reflect",
+      "sessionId": "session-case-002",
+      "signalType": "pain",
+      "signalContext": "Agent retries failing bash command 3 times without any diagnosis",
+      "singleReflectorOutput": {
+        "artifactId": "single-002-artifact",
+        "sessionId": "session-case-002",
+        "principleId": "T-08",
+        "sourceSnapshotRef": "snapshot-case-002",
+        "badDecision": "Retried failing operation without diagnosing",
+        "betterDecision": "Diagnose before retrying",
+        "rationale": "Treating failures as signals prevents repeated failures",
+        "createdAt": "2026-03-28T00:02:00.000Z"
+      },
+      "trinityOutput": {
+        "selectedCandidateIndex": 0,
+        "badDecision": "After bash command failed with 'command not found', immediately retried the exact same command without pausing to diagnose the root cause",
+        "betterDecision": "When the bash command fails, pause to check if the tool is installed, verify the path, or consult documentation before retrying",
+        "rationale": "Treating each failure as a signal to diagnose rather than blindly retry prevents repeated failures and respects the cost of each action attempt",
+        "sessionId": "session-case-002",
+        "principleId": "T-08",
+        "sourceSnapshotRef": "snapshot-case-002",
+        "telemetry": {
+          "chainMode": "trinity",
+          "dreamerPassed": true,
+          "philosopherPassed": true,
+          "scribePassed": true,
+          "candidateCount": 2,
+          "selectedCandidateIndex": 0,
+          "stageFailures": []
+        }
+      },
+      "qualityScores": {
+        "singleReflector": {
+          "specificity": 0.70,
+          "principleAlignment": 0.85,
+          "actionability": 0.75,
+          "rationaleQuality": 0.80,
+          "overall": 0.77
+        },
+        "trinity": {
+          "specificity": 0.95,
+          "principleAlignment": 0.95,
+          "actionability": 0.90,
+          "rationaleQuality": 0.95,
+          "overall": 0.94
+        }
+      },
+      "trinityWins": true,
+      "notes": "Single-reflector is generic; Trinity provides specific diagnosis steps"
+    },
+    {
+      "caseId": "case-003",
+      "principleId": "T-03",
+      "principleDescription": "Evidence Over Intuition: Ground decisions in observable evidence",
+      "sessionId": "session-case-003",
+      "signalType": "gate_block",
+      "signalContext": "Agent proceeded with a tool call despite receiving a gate block",
+      "singleReflectorOutput": {
+        "artifactId": "single-003-artifact",
+        "sessionId": "session-case-003",
+        "principleId": "T-03",
+        "sourceSnapshotRef": "snapshot-case-003",
+        "badDecision": "Proceeded despite gate block",
+        "betterDecision": "Respect gate blocks",
+        "rationale": "Gate blocks are safety mechanisms",
+        "createdAt": "2026-03-28T00:03:00.000Z"
+      },
+      "trinityOutput": {
+        "selectedCandidateIndex": 0,
+        "badDecision": "Proceeded with a tool call despite receiving a gate block, bypassing the safety check",
+        "betterDecision": "Read the blocked operation documentation and obtain proper authorization before retrying the operation",
+        "rationale": "Respecting gate blocks prevents unintended system modifications and ensures alignment with operational constraints",
+        "sessionId": "session-case-003",
+        "principleId": "T-03",
+        "sourceSnapshotRef": "snapshot-case-003",
+        "telemetry": {
+          "chainMode": "trinity",
+          "dreamerPassed": true,
+          "philosopherPassed": true,
+          "scribePassed": true,
+          "candidateCount": 3,
+          "selectedCandidateIndex": 0,
+          "stageFailures": []
+        }
+      },
+      "qualityScores": {
+        "singleReflector": {
+          "specificity": 0.60,
+          "principleAlignment": 0.75,
+          "actionability": 0.65,
+          "rationaleQuality": 0.70,
+          "overall": 0.68
+        },
+        "trinity": {
+          "specificity": 0.90,
+          "principleAlignment": 0.95,
+          "actionability": 0.88,
+          "rationaleQuality": 0.92,
+          "overall": 0.91
+        }
+      },
+      "trinityWins": true,
+      "notes": "Single-reflector is too generic; Trinity is much more specific"
+    }
+  ],
+  "summary": {
+    "totalCases": 3,
+    "trinityWins": 3,
+    "singleReflectorWins": 0,
+    "averageDelta": {
+      "specificity": 0.23,
+      "principleAlignment": 0.10,
+      "actionability": 0.17,
+      "rationaleQuality": 0.17,
+      "overall": 0.19
+    },
+    "conclusion": "Trinity consistently outperforms single-reflector on reviewed subset"
+  }
+}