principles-disciple 1.32.0 → 1.33.0

package/tests/core/rule-host.test.ts

@@ -1,389 +0,0 @@
-/**
- * Rule Host Tests
- *
- * PURPOSE: Verify that the RuleHost class:
- *   - Returns undefined when no active implementations exist
- *   - Returns block when an implementation returns block (with short-circuit)
- *   - Returns requireApproval when an implementation returns requireApproval
- *   - Returns undefined when all implementations return allow or matched=false
- *   - Degrades conservatively on vm load or execution errors
- *   - Merges multiple implementation decisions correctly
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { RuleHost } from '../../src/core/rule-host.js';
-import type { RuleHostInput, RuleHostResult } from '../../src/core/rule-host-types.js';
-
-// Mock the ledger module
-vi.mock('../../src/core/principle-tree-ledger.js', () => ({
-  loadLedger: vi.fn(),
-  listImplementationsByLifecycleState: vi.fn(() => []),
-  findActiveImplementation: vi.fn(() => null),
-}));
-
-vi.mock('../../src/core/code-implementation-storage.js', () => ({
-  loadEntrySource: vi.fn(() => null),
-}));
-
-// Mock fs to avoid actual file reads
-vi.mock('fs', () => ({
-  existsSync: vi.fn(() => false),
-  readFileSync: vi.fn(),
-}));
-
-vi.mock('../../src/core/rule-implementation-runtime.js', () => ({
-  loadRuleImplementationModule: vi.fn(),
-}));
-
-import { listImplementationsByLifecycleState } from '../../src/core/principle-tree-ledger.js';
-import { loadEntrySource } from '../../src/core/code-implementation-storage.js';
-import { loadRuleImplementationModule } from '../../src/core/rule-implementation-runtime.js';
-import * as fs from 'fs';
-
-const mockedListImplementations = vi.mocked(listImplementationsByLifecycleState);
-const mockedLoadEntrySource = vi.mocked(loadEntrySource);
-const mockedLoadRuleImplementationModule = vi.mocked(loadRuleImplementationModule);
-const mockedExistsSync = vi.mocked(fs.existsSync);
-const mockedReadFileSync = vi.mocked(fs.readFileSync);
-
-function makeInput(overrides?: Partial<RuleHostInput>): RuleHostInput {
-  return {
-    action: {
-      toolName: 'write',
-      normalizedPath: 'src/test.ts',
-      paramsSummary: {},
-    },
-    workspace: {
-      isRiskPath: false,
-      planStatus: 'READY',
-      hasPlanFile: true,
-    },
-    session: {
-      sessionId: 'test-session',
-      currentGfi: 10,
-      recentThinking: false,
-    },
-    evolution: {
-      epTier: 3,
-    },
-    derived: {
-      estimatedLineChanges: 50,
-      bashRisk: 'normal',
-    },
-    ...overrides,
-  };
-}
-
-function makeMockImpl(id: string, type: string = 'code', lifecycleState: string = 'active') {
-  return {
-    id,
-    ruleId: `RULE_${id}`,
-    type,
-    path: `/impls/${id}.js`,
-    version: '1.0.0',
-    coversCondition: 'test',
-    coveragePercentage: 100,
-    lifecycleState,
-    createdAt: '2026-01-01T00:00:00Z',
-    updatedAt: '2026-01-01T00:00:00Z',
-  };
-}
-
-describe('RuleHost', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockedLoadEntrySource.mockReturnValue(null);
-  });
-
-  it('should return undefined when no active implementations exist (empty ledger)', () => {
-    mockedListImplementations.mockReturnValue([]);
-    const host = new RuleHost('/mock/state');
-    const result = host.evaluate(makeInput());
-    expect(result).toBeUndefined();
-  });
-
-  it('should return undefined when implementations exist but none are type=code', () => {
-    mockedListImplementations.mockReturnValue([
-      makeMockImpl('IMPL_01', 'skill', 'active'),
-      makeMockImpl('IMPL_02', 'lora', 'active'),
-    ] as any);
-    const host = new RuleHost('/mock/state');
-    const result = host.evaluate(makeInput());
-    expect(result).toBeUndefined();
-  });
-
-  it('should return undefined when implementations exist but none are lifecycleState=active', () => {
-    // listImplementationsByLifecycleState('active') only returns active ones
-    mockedListImplementations.mockReturnValue([]);
-    const host = new RuleHost('/mock/state');
-    const result = host.evaluate(makeInput());
-    expect(result).toBeUndefined();
-  });
-
-  it('should return block when a loaded implementation returns decision=block', () => {
-    const blockResult: RuleHostResult = {
-      decision: 'block',
-      matched: true,
-      reason: 'Dangerous operation',
-    };
-    const mockImpl = makeMockImpl('IMPL_BLOCK');
-
-    mockedListImplementations.mockReturnValue([mockImpl] as any);
-    mockedExistsSync.mockReturnValue(true);
-    mockedReadFileSync.mockReturnValue('module.exports = {}');
-    mockedLoadRuleImplementationModule.mockReturnValue({
-      meta: { name: 'block-test', version: '1.0.0', ruleId: 'RULE_BLOCK', coversCondition: 'test' },
-      evaluate: (_input: any, _helpers: any) => blockResult,
-    });
-
-    const host = new RuleHost('/mock/state');
-    const result = host.evaluate(makeInput());
-    expect(result).toBeDefined();
-    expect(result?.decision).toBe('block');
-    expect(result?.matched).toBe(true);
-    expect(result?.reason).toBe('Dangerous operation');
-  });
-
-  it('should return block (short-circuit) when first of two implementations returns block', () => {
-    const blockResult: RuleHostResult = {
-      decision: 'block',
-      matched: true,
-      reason: 'First impl blocks',
-    };
-    const allowResult: RuleHostResult = {
-      decision: 'allow',
-      matched: true,
-      reason: 'Second impl allows',
-    };
-
-    const impl1 = makeMockImpl('IMPL_01');
-    const impl2 = makeMockImpl('IMPL_02');
-
-    mockedListImplementations.mockReturnValue([impl1, impl2] as any);
-    mockedExistsSync.mockReturnValue(true);
-    mockedReadFileSync.mockReturnValue('module.exports = {}');
-
-    let callCount = 0;
-    mockedLoadRuleImplementationModule.mockImplementation(() => {
-      callCount++;
-      if (callCount === 1) {
-        return {
-          meta: { name: 'block-first', version: '1.0.0', ruleId: 'RULE_01', coversCondition: 'test' },
-          evaluate: () => blockResult,
-        };
-      }
-      return {
-        meta: { name: 'allow-second', version: '1.0.0', ruleId: 'RULE_02', coversCondition: 'test' },
-        evaluate: () => allowResult,
-      };
-    });
-
-    const host = new RuleHost('/mock/state');
-    const result = host.evaluate(makeInput());
-
-    expect(result?.decision).toBe('block');
-    expect(result?.reason).toBe('First impl blocks');
-  });
-
-  it('should return requireApproval when a loaded implementation returns decision=requireApproval', () => {
-    const approvalResult: RuleHostResult = {
-      decision: 'requireApproval',
-      matched: true,
-      reason: 'High-risk path modification',
-    };
-    const mockImpl = makeMockImpl('IMPL_APPROVAL');
-
-    mockedListImplementations.mockReturnValue([mockImpl] as any);
-    mockedExistsSync.mockReturnValue(true);
-    mockedReadFileSync.mockReturnValue('module.exports = {}');
-    mockedLoadRuleImplementationModule.mockReturnValue({
-      meta: { name: 'approval-test', version: '1.0.0', ruleId: 'RULE_APPROVAL', coversCondition: 'test' },
-      evaluate: () => approvalResult,
-    });
-
-    const host = new RuleHost('/mock/state');
-    const result = host.evaluate(makeInput());
-    expect(result?.decision).toBe('requireApproval');
-    expect(result?.matched).toBe(true);
-    expect(result?.reason).toBe('High-risk path modification');
-  });
-
-  it('should return undefined when all implementations return allow or matched=false', () => {
-    const allowResult: RuleHostResult = {
-      decision: 'allow',
-      matched: true,
-      reason: 'OK',
-    };
-    const unmatchedResult: RuleHostResult = {
-      decision: 'allow',
-      matched: false,
-      reason: 'Not applicable',
-    };
-
-    const impl1 = makeMockImpl('IMPL_01');
-    const impl2 = makeMockImpl('IMPL_02');
-
-    mockedListImplementations.mockReturnValue([impl1, impl2] as any);
-    mockedExistsSync.mockReturnValue(true);
-    mockedReadFileSync.mockReturnValue('module.exports = {}');
-
-    let callCount = 0;
-    mockedLoadRuleImplementationModule.mockImplementation(() => {
-      callCount++;
-      if (callCount === 1) {
-        return {
-          meta: { name: 'allow-1', version: '1.0.0', ruleId: 'RULE_01', coversCondition: 'test' },
-          evaluate: () => allowResult,
-        };
-      }
-      return {
-        meta: { name: 'unmatched-2', version: '1.0.0', ruleId: 'RULE_02', coversCondition: 'test' },
-        evaluate: () => unmatchedResult,
-      };
-    });
-
-    const host = new RuleHost('/mock/state');
-    const result = host.evaluate(makeInput());
-    expect(result).toBeUndefined();
-  });
-
-  it('should return undefined on vm load error (conservative degradation)', () => {
-    const mockImpl = makeMockImpl('IMPL_BAD');
-    mockedListImplementations.mockReturnValue([mockImpl] as any);
-    mockedExistsSync.mockReturnValue(true);
-    mockedReadFileSync.mockReturnValue('bad syntax {{{');
-    mockedLoadRuleImplementationModule.mockImplementation(() => {
-      throw new Error('Compilation failed: unexpected token');
-    });
-
-    const host = new RuleHost('/mock/state');
-    const result = host.evaluate(makeInput());
-    expect(result).toBeUndefined();
-  });
-
-  it('should use injected logger for degradation warnings instead of direct console writes', () => {
-    const warn = vi.fn();
-    const mockImpl = makeMockImpl('IMPL_BAD');
-    mockedListImplementations.mockReturnValue([mockImpl] as any);
-    mockedExistsSync.mockReturnValue(true);
-    mockedReadFileSync.mockReturnValue('bad syntax {{{');
-    mockedLoadRuleImplementationModule.mockImplementation(() => {
-      throw new Error('Compilation failed: unexpected token');
-    });
-
-    const host = new RuleHost('/mock/state', { warn });
-    const result = host.evaluate(makeInput());
-
-    expect(result).toBeUndefined();
-    expect(warn).toHaveBeenCalledWith(
-      expect.stringContaining('Failed to compile implementation IMPL_BAD')
-    );
-  });
-
-  it('should return undefined on vm execution error (conservative degradation)', () => {
-    const mockImpl = makeMockImpl('IMPL_EXEC_ERR');
-    mockedListImplementations.mockReturnValue([mockImpl] as any);
-    mockedExistsSync.mockReturnValue(true);
-    mockedReadFileSync.mockReturnValue('module.exports = {}');
-    mockedLoadRuleImplementationModule.mockReturnValue({
-      meta: { name: 'exec-err', version: '1.0.0', ruleId: 'RULE_ERR', coversCondition: 'test' },
-      evaluate: () => {
-        throw new Error('Runtime error during evaluation');
-      },
-    });
-
-    const host = new RuleHost('/mock/state');
-    const result = host.evaluate(makeInput());
-    expect(result).toBeUndefined();
-  });
-
-  it('should return undefined when implementation asset path does not exist', () => {
-    const mockImpl = makeMockImpl('IMPL_NOFILE');
-    mockedListImplementations.mockReturnValue([mockImpl] as any);
-    mockedExistsSync.mockReturnValue(false);
-
-    const host = new RuleHost('/mock/state');
-    const result = host.evaluate(makeInput());
-    expect(result).toBeUndefined();
-  });
-
-  it('loads code implementations from storage assets before falling back to impl.path', () => {
-    const blockResult: RuleHostResult = {
-      decision: 'block',
-      matched: true,
-      reason: 'Loaded from storage asset',
-    };
-    const mockImpl = makeMockImpl('IMPL_STORAGE');
-
-    mockedListImplementations.mockReturnValue([mockImpl] as any);
-    mockedLoadEntrySource.mockReturnValue('export const meta = {}; export function evaluate() {}');
-    mockedExistsSync.mockReturnValue(false);
-    mockedLoadRuleImplementationModule.mockReturnValue({
-      meta: { name: 'storage-test', version: '1.0.0', ruleId: 'RULE_STORAGE', coversCondition: 'test' },
-      evaluate: () => blockResult,
-    });
-
-    const host = new RuleHost('/mock/state');
-    const result = host.evaluate(makeInput());
-
-    expect(mockedLoadEntrySource).toHaveBeenCalledWith('/mock/state', 'IMPL_STORAGE');
-    expect(mockedReadFileSync).not.toHaveBeenCalled();
-    expect(result?.decision).toBe('block');
-    expect(result?.reason).toBe('Loaded from storage asset');
-  });
-
-  it('should merge multiple requireApproval results', () => {
-    const approval1: RuleHostResult = {
-      decision: 'requireApproval',
-      matched: true,
-      reason: 'Risk path',
-      diagnostics: { riskLevel: 'high' },
-    };
-    const approval2: RuleHostResult = {
-      decision: 'requireApproval',
-      matched: true,
-      reason: 'Large change',
-      diagnostics: { lineCount: 500 },
-    };
-
-    const impl1 = makeMockImpl('IMPL_01');
-    const impl2 = makeMockImpl('IMPL_02');
-
-    mockedListImplementations.mockReturnValue([impl1, impl2] as any);
-    mockedExistsSync.mockReturnValue(true);
-    mockedReadFileSync.mockReturnValue('module.exports = {}');
-
-    let callCount = 0;
-    mockedLoadRuleImplementationModule.mockImplementation(() => {
-      callCount++;
-      if (callCount === 1) {
-        return {
-          meta: { name: 'approval-1', version: '1.0.0', ruleId: 'RULE_01', coversCondition: 'test' },
-          evaluate: () => approval1,
-        };
-      }
-      return {
-        meta: { name: 'approval-2', version: '1.0.0', ruleId: 'RULE_02', coversCondition: 'test' },
-        evaluate: () => approval2,
-      };
-    });
-
-    const host = new RuleHost('/mock/state');
-    const result = host.evaluate(makeInput());
-
-    expect(result?.decision).toBe('requireApproval');
-    expect(result?.reason).toContain('Risk path');
-    expect(result?.reason).toContain('Large change');
-    expect(result?.diagnostics).toEqual({ riskLevel: 'high', lineCount: 500 });
-  });
-
-  it('should return undefined when ledger access fails', () => {
-    mockedListImplementations.mockImplementation(() => {
-      throw new Error('Ledger file not found');
-    });
-
-    const host = new RuleHost('/mock/state');
-    const result = host.evaluate(makeInput());
-    expect(result).toBeUndefined();
-  });
-});

package/tests/core/trajectory-correction-pain.test.ts

@@ -1,180 +0,0 @@
-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';
-
-function safeRmDir(dir: string): void {
-  try { fs.rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
-}
-
-describe('Trajectory — correction_rejected pain event (Phase 2b)', () => {
-  let workspaceDir: string;
-  let trajectory: TrajectoryDatabase;
-
-  beforeEach(() => {
-    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-correction-pain-'));
-    trajectory = new TrajectoryDatabase({ workspaceDir });
-  });
-
-  afterEach(() => {
-    trajectory?.dispose();
-    safeRmDir(workspaceDir);
-  });
-
-  it('emits a pain event when a correction sample is rejected', async () => {
-    // Step 1: Create a session
-    trajectory.recordSession({
-      sessionId: 'test-session-001',
-      startedAt: new Date().toISOString(),
-    });
-
-    // Step 2: Create an assistant turn (to be referenced)
-    const assistantTurnId = trajectory.recordAssistantTurn({
-      sessionId: 'test-session-001',
-      turnIndex: 0,
-      rawText: 'Here is some code I wrote',
-      createdAt: new Date().toISOString(),
-    });
-
-    // Step 3: Create a user turn with correction_cue (triggers auto-creation)
-    trajectory.recordUserTurn({
-      sessionId: 'test-session-001',
-      turnIndex: 1,
-      rawText: 'This is wrong. Fix it properly.',
-      correctionDetected: true,
-      correctionCue: 'This is wrong. Fix it properly.',
-      referencesAssistantTurnId: assistantTurnId,
-      createdAt: new Date().toISOString(),
-    });
-
-    // Wait for async sample creation
-    await new Promise(resolve => setTimeout(resolve, 50));
-
-    // Verify sample was created as pending
-    const pendingSamples = trajectory.listCorrectionSamples('pending');
-    expect(pendingSamples.length).toBe(1);
-    const sampleId = pendingSamples[0].sampleId;
-
-    // Verify no pain events yet
-    const painEventsBefore = trajectory.listPainEventsForSession('test-session-001');
-    expect(painEventsBefore.length).toBe(0);
-
-    // Step 4: Review as rejected
-    trajectory.reviewCorrectionSample(sampleId, 'rejected', 'Does not match requirements');
-
-    // Step 5: Verify pain event was created
-    const painEventsAfter = trajectory.listPainEventsForSession('test-session-001');
-    expect(painEventsAfter.length).toBe(1);
-
-    const painEvent = painEventsAfter[0];
-    expect(painEvent.source).toBe('correction_rejected');
-    expect(painEvent.reason).toContain('Correction rejected');
-    expect(painEvent.origin).toBe('system_infer');
-  });
-
-  it('does NOT emit a pain event when a correction sample is approved', async () => {
-    // Setup: session + assistant turn + user correction turn
-    trajectory.recordSession({
-      sessionId: 'test-session-002',
-      startedAt: new Date().toISOString(),
-    });
-    const assistantTurnId = trajectory.recordAssistantTurn({
-      sessionId: 'test-session-002',
-      turnIndex: 0,
-      rawText: 'Here is some code',
-      createdAt: new Date().toISOString(),
-    });
-    trajectory.recordUserTurn({
-      sessionId: 'test-session-002',
-      turnIndex: 1,
-      rawText: 'This needs work',
-      correctionDetected: true,
-      correctionCue: 'This needs work',
-      referencesAssistantTurnId: assistantTurnId,
-      createdAt: new Date().toISOString(),
-    });
-
-    // Wait for async sample creation
-    await new Promise(resolve => setTimeout(resolve, 50));
-
-    // Get pending sample
-    const pendingSamples = trajectory.listCorrectionSamples('pending');
-    expect(pendingSamples.length).toBe(1);
-    const sampleId = pendingSamples[0].sampleId;
-
-    // Review as approved - should NOT trigger pain event
-    trajectory.reviewCorrectionSample(sampleId, 'approved', 'Looks good');
-
-    // Verify NO pain event was created (approved != rejected)
-    const painEvents = trajectory.listPainEventsForSession('test-session-002');
-    expect(painEvents.length).toBe(0);
-  });
-
-  it('maps quality_score to pain_score correctly (0-100 range)', async () => {
-    // Setup: with quality score components
-    trajectory.recordSession({
-      sessionId: 'test-session-003',
-      startedAt: new Date().toISOString(),
-    });
-    const assistantTurnId = trajectory.recordAssistantTurn({
-      sessionId: 'test-session-003',
-      turnIndex: 0,
-      rawText: 'Code here',
-      createdAt: new Date().toISOString(),
-    });
-
-    // Create user turn with correction_cue (adds 20 points)
-    trajectory.recordUserTurn({
-      sessionId: 'test-session-003',
-      turnIndex: 1,
-      rawText: 'Wrong approach. Try a different algorithm.',
-      correctionDetected: true,
-      correctionCue: 'Wrong approach. Try a different algorithm.',
-      referencesAssistantTurnId: assistantTurnId,
-      createdAt: new Date().toISOString(),
-    });
-
-    // Add a failed tool call (adds 20 points)
-    trajectory.recordToolCall({
-      sessionId: 'test-session-003',
-      turnIndex: 2,
-      toolName: 'write',
-      toolCallIndex: 0,
-      paramsJson: { path: '/tmp/test.txt', content: 'test' },
-      outcome: 'failure',
-      errorMessage: 'Permission denied',
-      errorType: 'PermissionError',
-      createdAt: new Date().toISOString(),
-    });
-
-    // Add successful calls (adds 25 points)
-    trajectory.recordToolCall({
-      sessionId: 'test-session-003',
-      turnIndex: 3,
-      toolName: 'read',
-      toolCallIndex: 1,
-      paramsJson: { path: '/tmp/test.txt' },
-      outcome: 'success',
-      resultJson: { content: 'file content' },
-      createdAt: new Date().toISOString(),
-    });
-
-    // Wait for async sample creation
-    await new Promise(resolve => setTimeout(resolve, 50));
-
-    // Get pending sample (quality_score ~65: 20 + 20 + 25)
-    const pendingSamples = trajectory.listCorrectionSamples('pending');
-    expect(pendingSamples.length).toBe(1);
-    const sampleId = pendingSamples[0].sampleId;
-
-    // Review as rejected
-    trajectory.reviewCorrectionSample(sampleId, 'rejected', 'Test rejection');
-
-    // Verify pain score is clamped to 0-100
-    const painEvents = trajectory.listPainEventsForSession('test-session-003');
-    expect(painEvents.length).toBe(1);
-    expect(painEvents[0].score).toBeGreaterThanOrEqual(0);
-    expect(painEvents[0].score).toBeLessThanOrEqual(100);
-  });
-});