principles-disciple 1.8.0 → 1.8.2

package/tests/core/control-ui-db.test.ts

@@ -0,0 +1,75 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { ControlUiDatabase } from '../../src/core/control-ui-db.js';
+import { TrajectoryDatabase } from '../../src/core/trajectory.js';
+
+describe('ControlUiDatabase', () => {
+  let workspaceDir: string | null = null;
+
+  afterEach(() => {
+    if (workspaceDir) {
+      fs.rmSync(workspaceDir, { recursive: true, force: true });
+      workspaceDir = null;
+    }
+  });
+
+  it('creates thinking_model_events schema and derived views', () => {
+    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-control-ui-'));
+    const trajectory = new TrajectoryDatabase({ workspaceDir });
+    const assistantTurnId = trajectory.recordAssistantTurn({
+      sessionId: 's1',
+      runId: 'run-1',
+      provider: 'test',
+      model: 'model',
+      rawText: 'Let me check the actual logs first.',
+      sanitizedText: 'Let me check the actual logs first.',
+      usageJson: {},
+      empathySignalJson: { detected: false },
+      createdAt: '2026-03-19T09:00:00.000Z',
+    });
+    trajectory.recordToolCall({
+      sessionId: 's1',
+      toolName: 'read_file',
+      outcome: 'success',
+      createdAt: '2026-03-19T09:01:00.000Z',
+    });
+
+    const db = new ControlUiDatabase({ workspaceDir });
+    db.recordThinkingModelEvent({
+      sessionId: 's1',
+      runId: 'run-1',
+      assistantTurnId,
+      modelId: 'T-03',
+      matchedPattern: 'check|verify|confirm',
+      scenarioJson: ['verification', 'after-recovery'],
+      toolContextJson: [{ toolName: 'read_file', outcome: 'success' }],
+      painContextJson: [],
+      principleContextJson: [],
+      triggerExcerpt: 'Let me check the actual logs first.',
+      createdAt: '2026-03-19T09:00:00.000Z',
+    });
+
+    const usage = db.get<{ hits: number; distinct_turns: number }>(
+      'SELECT hits, distinct_turns FROM v_thinking_model_usage WHERE model_id = ?',
+      'T-03',
+    );
+    const scenarios = db.all<{ scenario: string; hits: number }>(
+      'SELECT scenario, hits FROM v_thinking_model_scenarios WHERE model_id = ? ORDER BY scenario ASC',
+      'T-03',
+    );
+
+    expect(usage).toEqual(expect.objectContaining({
+      hits: 1,
+      distinct_turns: 1,
+    }));
+    expect(scenarios).toEqual(expect.arrayContaining([
+      expect.objectContaining({ scenario: 'after-recovery', hits: 1 }),
+      expect.objectContaining({ scenario: 'verification', hits: 1 }),
+    ]));
+
+    db.dispose();
+    trajectory.dispose();
+  });
+});

package/tests/core/core-template-guidance.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = path.resolve(__dirname, '..', '..');
+
+describe('core template guidance', () => {
+  it('documents sessions_spawn for dispatched internal workers', () => {
+    const enAgents = fs.readFileSync(path.join(repoRoot, 'templates', 'langs', 'en', 'core', 'AGENTS.md'), 'utf8');
+    const enTools = fs.readFileSync(path.join(repoRoot, 'templates', 'langs', 'en', 'core', 'TOOLS.md'), 'utf8');
+
+    expect(enAgents).toContain('sessions_spawn');
+    expect(enTools).toContain('sessions_spawn');
+    expect(enAgents).toContain('pd-diagnostician');
+    expect(enAgents).toContain('Tool Routing Addendum');
+    expect(enTools).toContain('Agent Routing Clarification');
+  });
+});

package/tests/core/detection-funnel.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { DetectionFunnel } from '../../src/core/detection-funnel.js';
+
+describe('DetectionFunnel', () => {
+    const mockDictionary = {
+        match: vi.fn(),
+    };
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+
+    it('should skip protocol text before dictionary and queue checks', () => {
+        const funnel = new DetectionFunnel(mockDictionary as any);
+        const enqueueSpy = vi.spyOn(funnel as any, 'enqueueAsync');
+
+        const result = funnel.detect('[EVOLUTION_ACK]');
+
+        expect(result).toEqual({ detected: false, source: 'l1_exact' });
+        expect(mockDictionary.match).not.toHaveBeenCalled();
+        expect(enqueueSpy).not.toHaveBeenCalled();
+    });
+
+    it('L1: should return true immediately if dictionary matches', async () => {
+        mockDictionary.match.mockReturnValue({ ruleId: 'P_CONFUSION', severity: 35 });
+        const funnel = new DetectionFunnel(mockDictionary as any);
+
+        const result = funnel.detect('I am confused');
+
+        expect(result.detected).toBe(true);
+        expect(result.source).toBe('l1_exact');
+        expect(mockDictionary.match).toHaveBeenCalledWith('I am confused');
+    });
+
+    it('L2: should return true if found in cache after initial mismatch', async () => {
+        mockDictionary.match.mockReturnValue(undefined);
+        const funnel = new DetectionFunnel(mockDictionary as any);
+
+        // Manually prime the cache for testing (or simulate a previous L3 hit)
+        (funnel as any).cache.set('hash_123', { detected: true, severity: 40 });
+
+        // We need a stable hash for the test
+        vi.spyOn(funnel as any, 'computeHash').mockReturnValue('hash_123');
+
+        const result = funnel.detect('Some repetitive text');
+
+        expect(result.detected).toBe(true);
+        expect(result.source).toBe('l2_cache');
+    });
+
+    it('L3: should enqueue for async detection if mismatch and not in cache', () => {
+        mockDictionary.match.mockReturnValue(undefined);
+        const funnel = new DetectionFunnel(mockDictionary as any);
+        const enqueueSpy = vi.spyOn(funnel as any, 'enqueueAsync');
+
+        const result = funnel.detect('New unknown expression');
+
+        expect(result.detected).toBe(false);
+        expect(result.source).toBe('l3_async_queued');
+        expect(enqueueSpy).toHaveBeenCalledWith('New unknown expression');
+    });
+});

package/tests/core/detection-service.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { DetectionService } from '../../src/core/detection-service.js';
+import { DictionaryService } from '../../src/core/dictionary-service.js';
+import { DetectionFunnel } from '../../src/core/detection-funnel.js';
+
+vi.mock('../../src/core/dictionary-service.js');
+vi.mock('../../src/core/detection-funnel.js');
+
+describe('DetectionService', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        DetectionService.reset();
+    });
+
+    it('should create a new instance on first get', () => {
+        const mockDict = {};
+        vi.mocked(DictionaryService.get).mockReturnValue(mockDict as any);
+
+        const funnel1 = DetectionService.get('/dir1');
+        
+        expect(DictionaryService.get).toHaveBeenCalledWith('/dir1');
+        expect(DetectionFunnel).toHaveBeenCalledWith(mockDict);
+        expect(funnel1).toBeDefined();
+    });
+
+    it('should return the same instance for the same stateDir', () => {
+        const funnel1 = DetectionService.get('/dir1');
+        const funnel2 = DetectionService.get('/dir1');
+
+        expect(funnel1).toBe(funnel2);
+        expect(DictionaryService.get).toHaveBeenCalledTimes(1);
+    });
+
+    it('should create a new instance if stateDir changes', () => {
+        const funnel1 = DetectionService.get('/dir1');
+        const funnel2 = DetectionService.get('/dir2');
+
+        expect(funnel1).not.toBe(funnel2);
+        expect(DictionaryService.get).toHaveBeenCalledTimes(2);
+        expect(DictionaryService.get).toHaveBeenNthCalledWith(2, '/dir2');
+    });
+
+    it('should reset the instance correctly', () => {
+        DetectionService.get('/dir1');
+        DetectionService.reset();
+        DetectionService.get('/dir1');
+
+        expect(DictionaryService.get).toHaveBeenCalledTimes(2);
+    });
+});

package/tests/core/dictionary-service.test.ts

@@ -0,0 +1,116 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { DictionaryService } from '../../src/core/dictionary-service.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+vi.mock('fs');
+
+describe('DictionaryService', () => {
+    const stateDir = '/mock/state';
+    const dictPath = path.join(stateDir, 'pain_dictionary.json');
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        DictionaryService.reset();
+    });
+
+    it('should create and return a PainDictionary instance', () => {
+        const mockData = {
+            rules: {
+                'TEST_RULE': {
+                    type: 'regex',
+                    pattern: 'test pattern',
+                    severity: 50,
+                    hits: 5,
+                    status: 'active'
+                }
+            }
+        };
+
+        vi.mocked(fs.existsSync).mockImplementation((p) => p.toString() === dictPath);
+        vi.mocked(fs.readFileSync).mockImplementation((p) => {
+            if (p.toString() === dictPath) return JSON.stringify(mockData);
+            return '';
+        });
+
+        const dict = DictionaryService.get(stateDir);
+        expect(dict).toBeDefined();
+        expect(dict.getRule('TEST_RULE')?.severity).toBe(50);
+    });
+
+    it('should return the same instance for the same stateDir', () => {
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+
+        const dict1 = DictionaryService.get(stateDir);
+        const dict2 = DictionaryService.get(stateDir);
+
+        expect(dict1).toBe(dict2);
+    });
+
+    it('should create a new instance when stateDir changes', () => {
+        const stateDir1 = '/mock/state1';
+        const stateDir2 = '/mock/state2';
+        const dictPath1 = path.join(stateDir1, 'pain_dictionary.json');
+        const dictPath2 = path.join(stateDir2, 'pain_dictionary.json');
+
+        vi.mocked(fs.existsSync).mockImplementation((p) => 
+            p.toString() === dictPath1 || p.toString() === dictPath2
+        );
+        vi.mocked(fs.readFileSync).mockImplementation((p) => {
+            if (p.toString() === dictPath1) {
+                return JSON.stringify({
+                    rules: { 'RULE1': { type: 'regex', pattern: 'r1', severity: 10, hits: 0, status: 'active' } }
+                });
+            }
+            if (p.toString() === dictPath2) {
+                return JSON.stringify({
+                    rules: { 'RULE2': { type: 'regex', pattern: 'r2', severity: 20, hits: 0, status: 'active' } }
+                });
+            }
+            return '';
+        });
+
+        const dict1 = DictionaryService.get(stateDir1);
+        expect(dict1.getRule('RULE1')).toBeDefined();
+        expect(dict1.getRule('RULE2')).toBeUndefined();
+
+        const dict2 = DictionaryService.get(stateDir2);
+        expect(dict2.getRule('RULE2')).toBeDefined();
+        expect(dict2.getRule('RULE1')).toBeUndefined();
+
+        expect(dict1).not.toBe(dict2);
+    });
+
+    it('should reset the singleton instance', () => {
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+
+        const dict1 = DictionaryService.get(stateDir);
+        DictionaryService.reset();
+        const dict2 = DictionaryService.get(stateDir);
+
+        expect(dict1).not.toBe(dict2);
+    });
+
+    it('should maintain state across multiple get calls', () => {
+        const mockData = {
+            rules: {
+                'MATCH_TEST': {
+                    type: 'regex',
+                    pattern: 'confused',
+                    severity: 30,
+                    hits: 0,
+                    status: 'active'
+                }
+            }
+        };
+
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockData));
+
+        const dict1 = DictionaryService.get(stateDir);
+        dict1.match('I am confused');
+
+        const dict2 = DictionaryService.get(stateDir);
+        expect(dict2.getRule('MATCH_TEST')?.hits).toBe(1);
+    });
+});

package/tests/core/dictionary.test.ts

@@ -0,0 +1,168 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { PainDictionary } from '../../src/core/dictionary.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+vi.mock('fs');
+
+describe('PainDictionary', () => {
+    const stateDir = '/mock/state';
+    const dictPath = path.join(stateDir, 'pain_dictionary.json');
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it('should load dictionary from file if it exists', () => {
+        const mockData = {
+            rules: {
+                'TEST_RULE': {
+                    type: 'regex',
+                    pattern: 'test pattern',
+                    severity: 50,
+                    hits: 5,
+                    status: 'active'
+                }
+            }
+        };
+
+        vi.mocked(fs.existsSync).mockImplementation((p) => p.toString() === dictPath);
+        vi.mocked(fs.readFileSync).mockImplementation((p) => {
+            if (p.toString() === dictPath) return JSON.stringify(mockData);
+            return '';
+        });
+
+        const dict = new PainDictionary(stateDir);
+        dict.load();
+
+        const rule = dict.getRule('TEST_RULE');
+        expect(rule).toBeDefined();
+        expect(rule?.hits).toBe(5);
+    });
+
+    it('should initialize with defaults if file does not exist', () => {
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+
+        const dict = new PainDictionary(stateDir);
+        dict.load();
+
+        // Should have some default rules (we'll implement some defaults)
+        expect(Object.keys(dict.getAllRules()).length).toBeGreaterThan(0);
+    });
+
+    it('should match regex patterns and update hits', () => {
+        const mockData = {
+            rules: {
+                'CONFUSION': {
+                    type: 'regex',
+                    pattern: 'I am confused',
+                    severity: 35,
+                    hits: 0,
+                    status: 'active'
+                }
+            }
+        };
+
+        vi.mocked(fs.existsSync).mockImplementation((p) => p.toString() === dictPath);
+        vi.mocked(fs.readFileSync).mockImplementation((p) => {
+            if (p.toString() === dictPath) return JSON.stringify(mockData);
+            return '';
+        });
+
+        const dict = new PainDictionary(stateDir);
+        dict.load();
+
+        const match = dict.match('Oh no, I am confused right now.');
+        expect(match).toBeDefined();
+        expect(match?.ruleId).toBe('CONFUSION');
+        expect(dict.getRule('CONFUSION')?.hits).toBe(1);
+    });
+
+    it('should match exact phrases and update hits', () => {
+        const mockData = {
+            rules: {
+                'LOOP': {
+                    type: 'exact_match',
+                    phrases: ['going in circles', 'back to square one'],
+                    severity: 45,
+                    hits: 0,
+                    status: 'active'
+                }
+            }
+        };
+
+        vi.mocked(fs.existsSync).mockImplementation((p) => p.toString() === dictPath);
+        vi.mocked(fs.readFileSync).mockImplementation((p) => {
+            if (p.toString() === dictPath) return JSON.stringify(mockData);
+            return '';
+        });
+
+        const dict = new PainDictionary(stateDir);
+        dict.load();
+
+        const match = dict.match('It seems we are going in circles.');
+        expect(match).toBeDefined();
+        expect(match?.ruleId).toBe('LOOP');
+        expect(dict.getRule('LOOP')?.hits).toBe(1);
+    });
+
+
+    it('should ignore protocol tokens during pain matching', () => {
+        const mockData = {
+            rules: {
+                'FRUSTRATION': {
+                    type: 'regex',
+                    pattern: '失败',
+                    severity: 50,
+                    hits: 0,
+                    status: 'active'
+                }
+            }
+        };
+
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockData));
+
+        const dict = new PainDictionary(stateDir);
+        dict.load();
+
+        expect(dict.match('[EVOLUTION_ACK] 之前有失败记录')).toBeUndefined();
+        expect(dict.getRule('FRUSTRATION')?.hits).toBe(0);
+    });
+
+    it('should not write to disk on every match', () => {
+        const mockData = {
+            rules: {
+                'TEST': { type: 'regex', pattern: 'test', severity: 10, hits: 0, status: 'active' }
+            }
+        };
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockData));
+
+        const dict = new PainDictionary(stateDir);
+        dict.load();
+        dict.match('test message');
+
+        expect(fs.writeFileSync).not.toHaveBeenCalled();
+    });
+
+    it('should flush hits to disk when requested', () => {
+        const mockData = {
+            rules: {
+                'TEST': { type: 'regex', pattern: 'test', severity: 10, hits: 0, status: 'active' }
+            }
+        };
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(mockData));
+
+        const dict = new PainDictionary(stateDir);
+        dict.load();
+        dict.match('test message');
+        dict.flush();
+
+        expect(fs.writeFileSync).toHaveBeenCalled();
+        const callArgs = vi.mocked(fs.writeFileSync).mock.calls[0];
+        expect(callArgs[0].toString()).toBe(dictPath);
+        expect(JSON.parse(callArgs[1] as string).rules.TEST.hits).toBe(1);
+    });
+});