principles-disciple 1.32.0 → 1.34.0

package/tests/hooks/llm.test.ts

@@ -1,308 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { handleLlmOutput, extractEmpathySignal, isEmpathyAuditPayload } from '../../src/hooks/llm';
-import * as painFlags from '../../src/core/pain';
-import * as sessionTracker from '../../src/core/session-tracker';
-import { ControlUiDatabase } from '../../src/core/control-ui-db';
-import { DetectionService } from '../../src/core/detection-service';
-import { WorkspaceContext } from '../../src/core/workspace-context';
-import fs from 'fs';
-import path from 'path';
-
-vi.mock('fs');
-vi.mock('../../src/core/pain', () => ({
-    writePainFlag: vi.fn(),
-}));
-vi.mock('../../src/core/control-ui-db');
-vi.mock('../../src/core/detection-service');
-vi.mock('../../src/core/workspace-context');
-
-describe('LLM Cognitive Distress Hook', () => {
-    const workspaceDir = '/mock/workspace';
-    const sessionId = 'test-session-auth';
-
-    const mockConfig = {
-        get: vi.fn((key) => {
-            if (key === 'thresholds.stuck_loops_trigger') return 3;
-            if (key === 'thresholds.cognitive_paralysis_input') return 4000;
-            if (key === 'scores.paralysis') return 40;
-            if (key === 'thresholds.pain_trigger') return 30;
-            if (key === 'scores.default_confusion') return 35;
-            if (key === 'empathy_engine.enabled') return true;
-            if (key === 'empathy_engine.dedupe_window_ms') return 60000;
-            if (key === 'empathy_engine.penalties.mild') return 10;
-            if (key === 'empathy_engine.penalties.moderate') return 25;
-            if (key === 'empathy_engine.penalties.severe') return 40;
-            if (key === 'empathy_engine.rate_limit.max_per_turn') return 40;
-            if (key === 'empathy_engine.rate_limit.max_per_hour') return 120;
-            if (key === 'empathy_engine.model_calibration') return { 'test/test': 0.5 };
-            return undefined;
-        })
-    };
-
-    const mockEventLog = {
-        recordRuleMatch: vi.fn(),
-        recordPainSignal: vi.fn(),
-    };
-    const mockControlUiDb = {
-        getRecentThinkingContext: vi.fn().mockReturnValue({
-            toolCalls: [{ toolName: 'edit', outcome: 'failure', errorType: 'EACCES' }],
-            painEvents: [{ source: 'user_empathy', score: 13 }],
-            gateBlocks: [],
-            userCorrections: [],
-            principleEvents: [],
-        }),
-        recordThinkingModelEvent: vi.fn(),
-        dispose: vi.fn(),
-    };
-
-    const mockWctx = {
-        workspaceDir,
-        stateDir: '/mock/workspace/.state',
-        config: mockConfig,
-        eventLog: mockEventLog,
-        trajectory: {
-            recordAssistantTurn: vi.fn().mockReturnValue(101),
-            recordPainEvent: vi.fn(),
-        },
-        resolve: vi.fn().mockImplementation((key) => {
-            if (key === 'THINKING_OS_USAGE') return path.join(workspaceDir, '.state', 'thinking_os_usage.json');
-            return '';
-        }),
-    };
-
-    beforeEach(() => {
-        vi.clearAllMocks();
-        sessionTracker.clearSession(sessionId);
-        vi.mocked(WorkspaceContext.fromHookContext).mockReturnValue(mockWctx as any);
-        vi.mocked(ControlUiDatabase).mockImplementation(function MockControlUiDatabase() {
-            return mockControlUiDb as any;
-        } as any);
-    });
-
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-
-    it('should detect confusion patterns via detection funnel (L1)', () => {
-        const mockFunnel = {
-            detect: vi.fn().mockReturnValue({
-                detected: true,
-                severity: 35,
-                ruleId: 'P_CONFUSION_EN',
-                source: 'l1_exact'
-            })
-        };
-        vi.mocked(DetectionService.get).mockReturnValue(mockFunnel as any);
-
-        const mockEvent = {
-            runId: 'r1',
-            sessionId,
-            provider: 'test',
-            assistantTexts: ['I am currently struggling to figure out why this test is failing.'],
-        };
-
-        handleLlmOutput(mockEvent as any, { workspaceDir, sessionId } as any);
-
-        expect(painFlags.writePainFlag).toHaveBeenCalledWith(
-            workspaceDir,
-            expect.objectContaining({
-                source: 'llm_p_confusion_en',
-                score: '35',
-                reason: expect.stringContaining('P_CONFUSION_EN')
-            })
-        );
-    });
-
-    it('should track Thinking OS mental model usage when signal is detected', () => {
-        const mockFunnel = {
-            detect: vi.fn().mockReturnValue({ detected: false, source: 'l3_async_queued' })
-        };
-        vi.mocked(DetectionService.get).mockReturnValue(mockFunnel as any);
-
-        const mockEvent = {
-            runId: 'r1',
-            sessionId,
-            provider: 'test',
-            model: 'test',
-            assistantTexts: ["According to Occam's Razor, the simplest approach is best."],
-        };
-
-        const usageLogPath = path.join(workspaceDir, '.state', 'thinking_os_usage.json');
-
-        vi.mocked(fs.existsSync).mockReturnValue(false);
-        const mockWrite = vi.fn();
-        vi.mocked(fs.writeFileSync).mockImplementation(mockWrite);
-
-        handleLlmOutput(mockEvent as any, { workspaceDir, sessionId } as any);
-
-        expect(mockWrite).toHaveBeenCalledWith(
-            usageLogPath,
-            expect.stringContaining('"T-06": 1'),
-            'utf8'
-        );
-        expect(mockControlUiDb.recordThinkingModelEvent).toHaveBeenCalledWith(
-            expect.objectContaining({
-                modelId: 'T-06',
-                assistantTurnId: expect.any(Number),
-            })
-        );
-    });
-
-    it('should parse structured empathy signal', () => {
-        const result = extractEmpathySignal('<empathy signal="damage" severity="severe" confidence="0.75" reason="ignored constraints"/>');
-        expect(result).toEqual(expect.objectContaining({
-            detected: true,
-            severity: 'severe',
-            confidence: 0.75,
-            mode: 'structured'
-        }));
-    });
-
-
-    it('should reject legacy empathy tag when embedded in regular assistant text', () => {
-        const result = extractEmpathySignal('User asked me to print [EMOTIONAL_DAMAGE_DETECTED:severe], so I echoed it.');
-        expect(result).toEqual(expect.objectContaining({
-            detected: false
-        }));
-    });
-
-    it('should NOT produce user_empathy from empathy JSON in main model output (Path 1 disabled)', () => {
-        vi.spyOn(sessionTracker, 'trackFriction').mockImplementation(() => ({ currentGfi: 0 } as any));
-        const mockFunnel = { detect: vi.fn().mockReturnValue({ detected: false, source: 'l3_async_queued' }) };
-        vi.mocked(DetectionService.get).mockReturnValue(mockFunnel as any);
-
-        const mockEvent = {
-            runId: 'r1',
-            sessionId,
-            provider: 'test',
-            model: 'test',
-            assistantTexts: ['[EMOTIONAL_DAMAGE_DETECTED:moderate]'],
-        };
-
-        handleLlmOutput(mockEvent as any, { workspaceDir, sessionId } as any);
-
-        expect(sessionTracker.trackFriction).not.toHaveBeenCalledWith(
-            sessionId,
-            expect.anything(),
-            expect.stringContaining('user_empathy'),
-            expect.anything(),
-            expect.anything()
-        );
-    });
-
-    it('should NOT produce user_empathy from structured empathy tag in main model output', () => {
-        vi.spyOn(sessionTracker, 'trackFriction').mockImplementation(() => ({ currentGfi: 0 } as any));
-        const mockFunnel = { detect: vi.fn().mockReturnValue({ detected: false, source: 'l3_async_queued' }) };
-        vi.mocked(DetectionService.get).mockReturnValue(mockFunnel as any);
-
-        const event = {
-            runId: 'same-run',
-            sessionId,
-            provider: 'test',
-            model: 'test',
-            assistantTexts: ['<empathy signal="damage" severity="severe" confidence="1" reason="reason-a"/>'],
-        };
-
-        handleLlmOutput(event as any, { workspaceDir, sessionId } as any);
-
-        expect(sessionTracker.trackFriction).not.toHaveBeenCalledWith(
-            sessionId,
-            expect.anything(),
-            expect.stringContaining('user_empathy'),
-            expect.anything(),
-            expect.anything()
-        );
-    });
-
-    it('should filter empathy audit payloads before detection to prevent rule_match pollution', () => {
-        const mockFunnel = {
-            detect: vi.fn().mockReturnValue({ detected: false, source: 'l3_async_queued' })
-        };
-        vi.mocked(DetectionService.get).mockReturnValue(mockFunnel as any);
-
-        const mockEvent = {
-            runId: 'r1',
-            sessionId,
-            provider: 'test',
-            assistantTexts: ['{"damageDetected": true, "severity": "moderate", "confidence": 0.8, "reason": "frustration"}'],
-        };
-
-        handleLlmOutput(mockEvent as any, { workspaceDir, sessionId } as any);
-
-        expect(mockFunnel.detect).toHaveBeenCalledWith('');
-    });
-
-    it('should continue pain processing when trajectory persistence fails', () => {
-        const mockFunnel = {
-            detect: vi.fn().mockReturnValue({
-                detected: true,
-                severity: 35,
-                ruleId: 'P_CONFUSION_EN',
-                source: 'l1_exact'
-            })
-        };
-        vi.mocked(DetectionService.get).mockReturnValue(mockFunnel as any);
-        mockWctx.trajectory.recordAssistantTurn.mockImplementation(() => {
-            throw new Error('db offline');
-        });
-
-        const logger = {
-            warn: vi.fn(),
-            info: vi.fn(),
-            error: vi.fn(),
-            debug: vi.fn(),
-        };
-
-        handleLlmOutput({
-            runId: 'r-fail',
-            sessionId,
-            provider: 'test',
-            model: 'test',
-            assistantTexts: ['I am currently struggling to figure out why this test is failing.'],
-        } as any, { workspaceDir, sessionId, logger } as any);
-
-        expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('Failed to persist assistant turn'));
-        expect(painFlags.writePainFlag).toHaveBeenCalledWith(
-            workspaceDir,
-            expect.objectContaining({
-                source: 'llm_p_confusion_en',
-                score: '35',
-            })
-        );
-        expect(mockEventLog.recordPainSignal).toHaveBeenCalledWith(
-            sessionId,
-            expect.objectContaining({
-                source: 'llm_p_confusion_en',
-                score: 35,
-            })
-        );
-    });
-
-    it('should rollback only the empathy slice when rollback tag is emitted', () => {
-        vi.spyOn(sessionTracker, 'resetFriction').mockImplementation(() => ({ currentGfi: 10 } as any));
-        const mockFunnel = { detect: vi.fn().mockReturnValue({ detected: false, source: 'l3_async_queued' }) };
-        vi.mocked(DetectionService.get).mockReturnValue(mockFunnel as any);
-        (mockEventLog as any).getLastEmpathyEventId = vi.fn().mockReturnValue('emp_rollback_1');
-        (mockEventLog as any).rollbackEmpathyEvent = vi.fn().mockReturnValue(13);
-
-        handleLlmOutput({
-            runId: 'r-rollback',
-            sessionId,
-            provider: 'test',
-            model: 'test',
-            assistantTexts: ['[EMPATHY_ROLLBACK_REQUEST]'],
-        } as any, { workspaceDir, sessionId } as any);
-
-        expect(mockEventLog.getLastEmpathyEventId).toHaveBeenCalledWith(sessionId);
-        expect(mockEventLog.rollbackEmpathyEvent).toHaveBeenCalledWith(
-            'emp_rollback_1',
-            sessionId,
-            'Natural language rollback request detected',
-            'natural_language'
-        );
-        expect(sessionTracker.resetFriction).toHaveBeenCalledWith(sessionId, workspaceDir, {
-            source: 'user_empathy',
-            amount: 13,
-        });
-    });
-});

package/tests/hooks/progressive-trust-gate.test.ts

@@ -1,277 +0,0 @@
-/**
- * Tests for Progressive Trust Gate Module (EP-Only Version)
- *
- * 2026-03-29: EP System 是唯一的门控机制
- * - 不再有 Trust Score (30-100) 系统
- * - 不再有 Stage 1-4 分级
- * - 不再有基于行数的限制
- * - EP (Evolution Points) 是唯一的门控机制
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { PluginHookBeforeToolCallEvent } from '../../src/openclaw-sdk.js';
-import {
-  checkProgressiveTrustGate,
-  buildEvolutionGateReason,
-} from '../../src/hooks/progressive-trust-gate.js';
-import { checkEvolutionGate } from '../../src/core/evolution-engine.js';
-
-// Mock dependencies
-vi.mock('../../src/core/workspace-context.js', () => ({
-  WorkspaceContext: {
-    fromHookContext: vi.fn(() => mockWctx)
-  }
-}));
-
-vi.mock('../../src/utils/io.js', () => ({
-  planStatus: vi.fn(() => 'READY'),
-  normalizePath: vi.fn((p) => p),
-  isRisky: vi.fn(() => false)
-}));
-
-vi.mock('../../src/utils/glob-match.js', () => ({
-  matchesAnyPattern: vi.fn(() => false)
-}));
-
-vi.mock('../../src/core/risk-calculator.js', () => ({
-  assessRiskLevel: vi.fn(() => 'LOW'),
-  estimateLineChanges: vi.fn(() => 10)
-}));
-
-vi.mock('../../src/core/evolution-engine.js', () => ({
-  checkEvolutionGate: vi.fn(() => ({ allowed: true, currentTier: 1 }))
-}));
-
-vi.mock('../../src/hooks/gate-block-helper.js', () => ({
-  recordGateBlockAndReturn: vi.fn((wctx, params) => ({
-    block: true,
-    blockReason: params.reason || 'Blocked'
-  }))
-}));
-
-// Mock workspace context - simplified for EP-only
-const mockWctx = {
-  config: {
-    get: vi.fn(() => ({}))
-  },
-  eventLog: {
-    recordGateBlock: vi.fn(),
-    recordPlanApproval: vi.fn()
-  },
-  trajectory: {
-    recordGateBlock: vi.fn()
-  },
-  resolve: vi.fn((key) => key)
-};
-
-describe('progressive-trust-gate (EP-Only)', () => {
-  describe('checkProgressiveTrustGate - EP System', () => {
-    let mockEvent: PluginHookBeforeToolCallEvent;
-    let mockLogger: any;
-
-    beforeEach(() => {
-      mockEvent = {
-        toolName: 'edit',
-        params: {
-          file_path: '/test/file.ts',
-          content: 'test content\n'.repeat(10)
-        }
-      } as any;
-
-      mockLogger = {
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn()
-      };
-
-      // Reset EP mock
-      vi.mocked(checkEvolutionGate).mockReturnValue({ allowed: true, currentTier: 1 });
-
-      vi.clearAllMocks();
-    });
-
-    it('should allow when EP system allows', () => {
-      vi.mocked(checkEvolutionGate).mockReturnValue({ allowed: true, currentTier: 1 });
-
-      const result = checkProgressiveTrustGate(
-        mockEvent,
-        mockWctx as any,
-        '/test/file.ts',
-        false,
-        100, // Even large changes are allowed by EP
-        mockLogger,
-        { workspaceDir: '/test', sessionId: 'test-session' },
-        {}
-      );
-
-      // EP allows, so result should be undefined (allow)
-      expect(result).toBeUndefined();
-    });
-
-    it('should block when EP system denies', () => {
-      vi.mocked(checkEvolutionGate).mockReturnValue({
-        allowed: false,
-        currentTier: 1,
-        reason: 'EP Tier 1 limit: 150 lines max'
-      });
-
-      const result = checkProgressiveTrustGate(
-        mockEvent,
-        mockWctx as any,
-        '/test/file.ts',
-        false,
-        200,
-        mockLogger,
-        { workspaceDir: '/test', sessionId: 'test-session' },
-        {}
-      );
-
-      expect(result).toBeDefined();
-      expect(result?.block).toBe(true);
-      expect(result?.blockReason).toContain('EP');
-    });
-
-    it('should log EP decision info', () => {
-      vi.mocked(checkEvolutionGate).mockReturnValue({ allowed: true, currentTier: 2 });
-
-      checkProgressiveTrustGate(
-        mockEvent,
-        mockWctx as any,
-        '/test/file.ts',
-        false,
-        10,
-        mockLogger,
-        { workspaceDir: '/test', sessionId: 'test-session' },
-        {}
-      );
-
-      expect(mockLogger.info).toHaveBeenCalledWith(
-        expect.stringContaining('EP Gate:')
-      );
-    });
-
-    it('should allow risky path when EP allows', () => {
-      vi.mocked(checkEvolutionGate).mockReturnValue({
-        allowed: true,
-        currentTier: 4, // Tree tier - can access risk paths
-        reason: 'Tier 4 unlocked'
-      });
-
-      const result = checkProgressiveTrustGate(
-        mockEvent,
-        mockWctx as any,
-        '/test/risk-path',
-        true, // risky
-        500,
-        mockLogger,
-        { workspaceDir: '/test', sessionId: 'test-session' },
-        {}
-      );
-
-      expect(result).toBeUndefined();
-    });
-
-    it('should block risky path when EP denies', () => {
-      vi.mocked(checkEvolutionGate).mockReturnValue({
-        allowed: false,
-        currentTier: 2, // Sprout tier - cannot access risk paths
-        reason: 'Risk paths require Tree tier'
-      });
-
-      const result = checkProgressiveTrustGate(
-        mockEvent,
-        mockWctx as any,
-        '/test/risk-path',
-        true, // risky
-        10,
-        mockLogger,
-        { workspaceDir: '/test', sessionId: 'test-session' },
-        {}
-      );
-
-      expect(result).toBeDefined();
-      expect(result?.block).toBe(true);
-    });
-
-    it('should skip check when no workspaceDir', () => {
-      const result = checkProgressiveTrustGate(
-        mockEvent,
-        mockWctx as any,
-        '/test/file.ts',
-        false,
-        10,
-        mockLogger,
-        { sessionId: 'test-session' }, // No workspaceDir
-        {}
-      );
-
-      expect(result).toBeUndefined();
-      expect(mockLogger.warn).toHaveBeenCalledWith(
-        expect.stringContaining('No workspaceDir')
-      );
-    });
-
-    it('should pass correct parameters to checkEvolutionGate', () => {
-      vi.mocked(checkEvolutionGate).mockReturnValue({ allowed: true, currentTier: 1 });
-
-      checkProgressiveTrustGate(
-        mockEvent,
-        mockWctx as any,
-        '/test/file.ts',
-        true, // isRiskPath
-        100,
-        mockLogger,
-        { workspaceDir: '/test', sessionId: 'test-session' },
-        {}
-      );
-
-      expect(checkEvolutionGate).toHaveBeenCalledWith('/test', {
-        toolName: 'edit',
-        isRiskPath: true,
-      });
-    });
-  });
-
-  describe('buildEvolutionGateReason', () => {
-    it('should build EP gate rejection reason with tier info', () => {
-      const reason = buildEvolutionGateReason(2, 'Sprout', 'Max 50 lines');
-
-      expect(reason).toContain('EP Gate');
-      expect(reason).toContain('Tier 2');
-      expect(reason).toContain('Sprout');
-      expect(reason).toContain('Max 50 lines');
-    });
-
-    it('should handle unknown tier name', () => {
-      const reason = buildEvolutionGateReason(99, 'Unknown', 'Some restriction');
-
-      expect(reason).toContain('EP Gate');
-      expect(reason).toContain('Tier 99');
-      expect(reason).toContain('Unknown');
-    });
-  });
-
-  describe('EP Tier Names', () => {
-    it('should pass correct tier info to checkEvolutionGate', () => {
-      vi.mocked(checkEvolutionGate).mockReturnValue({ allowed: true, currentTier: 1 });
-      const event = { toolName: 'edit', params: { file_path: '/test.ts', content: '' } } as any;
-      const logger = { info: vi.fn() };
-
-      checkProgressiveTrustGate(
-        event,
-        mockWctx as any,
-        '/test.ts',
-        false,
-        10,
-        logger,
-        { workspaceDir: '/test' },
-        {}
-      );
-
-      expect(checkEvolutionGate).toHaveBeenCalledWith('/test', {
-        toolName: 'edit',
-        isRiskPath: false,
-      });
-    });
-  });
-});