principles-disciple 1.107.0 → 1.108.0

package/tests/core/evolution-hook.test.ts

@@ -1,123 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import type { EvolutionHook, PrincipleCreatedEvent, PrinciplePromotedEvent } from '../../src/core/evolution-hook.js';
-import { noOpEvolutionHook } from '../../src/core/evolution-hook.js';
-import type { PainSignal } from '../../src/core/pain-signal.js';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function validPainSignal(overrides: Partial<PainSignal> = {}): PainSignal {
-  return {
-    source: 'tool_failure',
-    score: 75,
-    timestamp: '2026-04-17T00:00:00.000Z',
-    reason: 'File not found',
-    sessionId: 'session-001',
-    agentId: 'main',
-    traceId: 'trace-001',
-    triggerTextPreview: 'File not found: test.ts',
-    domain: 'coding',
-    severity: 'high',
-    context: {},
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('EvolutionHook', () => {
-  it('implements all 3 methods', () => {
-    const calls: string[] = [];
-    const hook: EvolutionHook = {
-      onPainDetected(signal: PainSignal): void { calls.push(`pain:${signal.source}`); },
-      onPrincipleCreated(event: PrincipleCreatedEvent): void { calls.push(`created:${event.id}`); },
-      onPrinciplePromoted(event: PrinciplePromotedEvent): void { calls.push(`promoted:${event.id}`); },
-    };
-
-    hook.onPainDetected(validPainSignal());
-    hook.onPrincipleCreated({ id: 'p-1', text: 'Test principle', trigger: 'tool failure' });
-    hook.onPrinciplePromoted({ id: 'p-1', from: 'candidate', to: 'active' });
-
-    expect(calls).toEqual(['pain:tool_failure', 'created:p-1', 'promoted:p-1']);
-  });
-
-  it('onPainDetected receives a PainSignal', () => {
-    let received: PainSignal | undefined;
-    const hook: EvolutionHook = {
-      ...noOpEvolutionHook,
-      onPainDetected(signal: PainSignal): void { received = signal; },
-    };
-
-    const signal = validPainSignal();
-    hook.onPainDetected(signal);
-    expect(received).toEqual(signal);
-  });
-
-  it('onPrincipleCreated receives a PrincipleCreatedEvent', () => {
-    let received: PrincipleCreatedEvent | undefined;
-    const hook: EvolutionHook = {
-      ...noOpEvolutionHook,
-      onPrincipleCreated(event: PrincipleCreatedEvent): void { received = event; },
-    };
-
-    const event = { id: 'p-1', text: 'Test principle', trigger: 'tool failure' };
-    hook.onPrincipleCreated(event);
-    expect(received).toEqual(event);
-  });
-
-  it('onPrinciplePromoted receives a PrinciplePromotedEvent', () => {
-    let received: PrinciplePromotedEvent | undefined;
-    const hook: EvolutionHook = {
-      ...noOpEvolutionHook,
-      onPrinciplePromoted(event: PrinciplePromotedEvent): void { received = event; },
-    };
-
-    const event = { id: 'p-1', from: 'candidate', to: 'active' };
-    hook.onPrinciplePromoted(event);
-    expect(received).toEqual(event);
-  });
-});
-
-describe('noOpEvolutionHook', () => {
-  it('implements all 3 methods as no-ops', () => {
-    expect(() => {
-      noOpEvolutionHook.onPainDetected(validPainSignal());
-      noOpEvolutionHook.onPrincipleCreated({ id: 'p-1', text: 'Test', trigger: 'test' });
-      noOpEvolutionHook.onPrinciplePromoted({ id: 'p-1', from: 'candidate', to: 'active' });
-    }).not.toThrow();
-  });
-
-  it('can be spread to override individual methods', () => {
-    const calls: string[] = [];
-    const hook: EvolutionHook = {
-      ...noOpEvolutionHook,
-      onPainDetected(_signal: PainSignal): void { calls.push('pain'); },
-    };
-
-    hook.onPainDetected(validPainSignal());
-    hook.onPrincipleCreated({ id: 'p-1', text: 'Test', trigger: 'test' });
-
-    expect(calls).toEqual(['pain']);
-  });
-});
-
-describe('PrincipleCreatedEvent', () => {
-  it('has required fields: id, text, trigger', () => {
-    const event: PrincipleCreatedEvent = { id: 'p-1', text: 'Always verify', trigger: 'tool failure' };
-    expect(event.id).toBe('p-1');
-    expect(event.text).toBe('Always verify');
-    expect(event.trigger).toBe('tool failure');
-  });
-});
-
-describe('PrinciplePromotedEvent', () => {
-  it('has required fields: id, from, to', () => {
-    const event: PrinciplePromotedEvent = { id: 'p-1', from: 'candidate', to: 'active' };
-    expect(event.id).toBe('p-1');
-    expect(event.from).toBe('candidate');
-    expect(event.to).toBe('active');
-  });
-});

package/tests/core/file-storage-adapter.test.ts

@@ -1,285 +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 { FileStorageAdapter } from '../../src/core/file-storage-adapter.js';
-import type { HybridLedgerStore } from '../../src/core/principle-tree-ledger.js';
-import { TREE_NAMESPACE, loadLedger } from '../../src/core/principle-tree-ledger.js';
-import { safeRmDir } from '../test-utils.js';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function createTmpDir(): string {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'pd-file-storage-adapter-test-'));
-}
-
-function createEmptyStore(): HybridLedgerStore {
-  return {
-    trainingStore: {},
-    tree: {
-      principles: {},
-      rules: {},
-      implementations: {},
-      metrics: {},
-      lastUpdated: new Date(0).toISOString(),
-    },
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('FileStorageAdapter', () => {
-  let tmpDir: string;
-  let adapter: FileStorageAdapter;
-
-  beforeEach(() => {
-    tmpDir = createTmpDir();
-    adapter = new FileStorageAdapter(tmpDir, tmpDir);
-  });
-
-  afterEach(() => {
-    safeRmDir(tmpDir);
-  });
-
-  // -------------------------------------------------------------------------
-  // loadLedger
-  // -------------------------------------------------------------------------
-
-  describe('loadLedger', () => {
-    it('returns empty store when no file exists', async () => {
-      const store = await adapter.loadLedger();
-      expect(store.trainingStore).toEqual({});
-      expect(store.tree.principles).toEqual({});
-      expect(store.tree.rules).toEqual({});
-    });
-
-    it('loads existing persisted store', async () => {
-      const original = createEmptyStore();
-      original.tree.principles['P-001'] = {
-        id: 'P-001',
-        version: 1,
-        text: 'Write before delete',
-        triggerPattern: 'delete',
-        action: 'write first',
-        status: 'active',
-        priority: 'P1',
-        scope: 'general',
-        evaluability: 'deterministic',
-        valueScore: 0,
-        adherenceRate: 0,
-        painPreventedCount: 0,
-        derivedFromPainIds: [],
-        ruleIds: [],
-        conflictsWithPrincipleIds: [],
-        createdAt: '2026-04-17T00:00:00.000Z',
-        updatedAt: '2026-04-17T00:00:00.000Z',
-      };
-
-      // Persist using the low-level ledger to seed the file
-      await adapter.saveLedger(original);
-      const loaded = await adapter.loadLedger();
-      expect(loaded.tree.principles['P-001']).toBeDefined();
-      expect(loaded.tree.principles['P-001'].text).toBe('Write before delete');
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // saveLedger
-  // -------------------------------------------------------------------------
-
-  describe('saveLedger', () => {
-    it('persists store to disk', async () => {
-      const store = createEmptyStore();
-      store.trainingStore['test-principle'] = {
-        principleId: 'test-principle',
-        evaluability: 'manual_only',
-        applicableOpportunityCount: 0,
-        observedViolationCount: 0,
-        complianceRate: 0,
-        violationTrend: 0,
-        generatedSampleCount: 0,
-        approvedSampleCount: 0,
-        includedTrainRunIds: [],
-        deployedCheckpointIds: [],
-        internalizationStatus: 'prompt_only',
-      };
-
-      await adapter.saveLedger(store);
-
-      // Verify file exists and contains the data
-      const filePath = path.join(tmpDir, 'principle_training_state.json');
-      expect(fs.existsSync(filePath)).toBe(true);
-      const raw = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-      expect(raw['test-principle']).toBeDefined();
-      expect(raw[TREE_NAMESPACE]).toBeDefined();
-    });
-
-    it('round-trips data through save and load', async () => {
-      const store = createEmptyStore();
-      store.trainingStore['p-1'] = {
-        principleId: 'p-1',
-        evaluability: 'weak_heuristic',
-        applicableOpportunityCount: 5,
-        observedViolationCount: 2,
-        complianceRate: 0.6,
-        violationTrend: -0.1,
-        generatedSampleCount: 3,
-        approvedSampleCount: 2,
-        includedTrainRunIds: ['run-1'],
-        deployedCheckpointIds: [],
-        internalizationStatus: 'in_training',
-      };
-
-      await adapter.saveLedger(store);
-      const loaded = await adapter.loadLedger();
-      expect(loaded.trainingStore['p-1'].evaluability).toBe('weak_heuristic');
-      expect(loaded.trainingStore['p-1'].applicableOpportunityCount).toBe(5);
-    });
-  });
-
-  // -------------------------------------------------------------------------
-  // mutateLedger
-  // -------------------------------------------------------------------------
-
-  describe('mutateLedger', () => {
-    it('reads, mutates, and writes atomically', async () => {
-      // Start with empty store
-      await adapter.saveLedger(createEmptyStore());
-
-      const result = await adapter.mutateLedger((store) => {
-        store.tree.principles['P-002'] = {
-          id: 'P-002',
-          version: 1,
-          text: 'Test principle',
-          triggerPattern: 'test',
-          action: 'do something',
-          status: 'candidate',
-          priority: 'P2',
-          scope: 'general',
-          evaluability: 'manual_only',
-          valueScore: 0,
-          adherenceRate: 0,
-          painPreventedCount: 0,
-          derivedFromPainIds: [],
-          ruleIds: [],
-          conflictsWithPrincipleIds: [],
-          createdAt: '2026-04-17T00:00:00.000Z',
-          updatedAt: '2026-04-17T00:00:00.000Z',
-        };
-        return 42;
-      });
-
-      expect(result).toBe(42);
-      const loaded = await adapter.loadLedger();
-      expect(loaded.tree.principles['P-002']).toBeDefined();
-      expect(loaded.tree.principles['P-002'].text).toBe('Test principle');
-    });
-
-    it('returns the value from the mutate function', async () => {
-      await adapter.saveLedger(createEmptyStore());
-
-      const count = await adapter.mutateLedger((store) => {
-        return Object.keys(store.tree.principles).length;
-      });
-
-      expect(count).toBe(0);
-    });
-
-    it('supports async mutate functions', async () => {
-      await adapter.saveLedger(createEmptyStore());
-
-      const result = await adapter.mutateLedger(async (store) => {
-        // Simulate async work
-        await new Promise((r) => setTimeout(r, 10));
-        store.trainingStore['async-test'] = {
-          principleId: 'async-test',
-          evaluability: 'deterministic',
-          applicableOpportunityCount: 1,
-          observedViolationCount: 0,
-          complianceRate: 1.0,
-          violationTrend: 0,
-          generatedSampleCount: 0,
-          approvedSampleCount: 0,
-          includedTrainRunIds: [],
-          deployedCheckpointIds: [],
-          internalizationStatus: 'prompt_only',
-        };
-        return 'async-done';
-      });
-
-      expect(result).toBe('async-done');
-      const loaded = await adapter.loadLedger();
-      expect(loaded.trainingStore['async-test']).toBeDefined();
-    });
-
-    it('persists via atomicWriteFileSync (file is not corrupted)', async () => {
-      await adapter.saveLedger(createEmptyStore());
-
-      await adapter.mutateLedger((store) => {
-        store.tree.principles['P-003'] = {
-          id: 'P-003',
-          version: 1,
-          text: 'Atomic write test',
-          triggerPattern: 'test',
-          action: 'verify atomicity',
-          status: 'candidate',
-          priority: 'P1',
-          scope: 'general',
-          evaluability: 'manual_only',
-          valueScore: 0,
-          adherenceRate: 0,
-          painPreventedCount: 0,
-          derivedFromPainIds: [],
-          ruleIds: [],
-          conflictsWithPrincipleIds: [],
-          createdAt: '2026-04-17T00:00:00.000Z',
-          updatedAt: '2026-04-17T00:00:00.000Z',
-        };
-      });
-
-      // Verify no leftover temp file
-      const filePath = path.join(tmpDir, 'principle_training_state.json');
-      expect(fs.existsSync(filePath + '.tmp')).toBe(false);
-      expect(fs.existsSync(filePath)).toBe(true);
-
-      // File is valid JSON
-      const raw = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-      expect(raw[TREE_NAMESPACE].principles['P-003']).toBeDefined();
-    });
-
-    it('is compatible with low-level loadLedger', async () => {
-      await adapter.saveLedger(createEmptyStore());
-
-      await adapter.mutateLedger((store) => {
-        store.tree.principles['P-COMPAT'] = {
-          id: 'P-COMPAT',
-          version: 1,
-          text: 'Compatibility test',
-          triggerPattern: 'compat',
-          action: 'verify',
-          status: 'active',
-          priority: 'P1',
-          scope: 'general',
-          evaluability: 'deterministic',
-          valueScore: 10,
-          adherenceRate: 0.8,
-          painPreventedCount: 5,
-          derivedFromPainIds: ['pain-1'],
-          ruleIds: [],
-          conflictsWithPrincipleIds: [],
-          createdAt: '2026-04-17T00:00:00.000Z',
-          updatedAt: '2026-04-17T00:00:00.000Z',
-        };
-      });
-
-      // Load with the low-level function — should see the same data
-      const ledger = loadLedger(tmpDir);
-      expect(ledger.tree.principles['P-COMPAT']).toBeDefined();
-      expect(ledger.tree.principles['P-COMPAT'].text).toBe('Compatibility test');
-    });
-  });
-});

package/tests/core/merge-gate-audit.test.ts

@@ -1,117 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import {
-  formatMergeGateAuditReport,
-  runMergeGateAudit,
-} from '../../src/core/merge-gate-audit.js';
-import { createImplementationAssetDir, getImplementationAssetRoot } from '../../src/core/code-implementation-storage.js';
-import { safeRmDir } from '../test-utils.js';
-
-describe('merge-gate-audit', () => {
-  let tempDir: string;
-  let workspaceDir: string;
-  let stateDir: string;
-
-  beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-merge-gate-audit-'));
-    workspaceDir = path.join(tempDir, 'workspace');
-    stateDir = path.join(tempDir, '.state');
-    fs.mkdirSync(workspaceDir, { recursive: true });
-    fs.mkdirSync(stateDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    safeRmDir(tempDir);
-  });
-
-  it('returns defer when audit surfaces are not populated yet', () => {
-    const report = runMergeGateAudit(workspaceDir, stateDir);
-
-    expect(report.overallStatus).toBe('defer');
-    expect(report.checks.find((check) => check.id === 'pain_flag_path_contract')?.status).toBe('pass');
-    expect(report.checks.find((check) => check.id === 'queue_path_contract')?.status).toBe('pass');
-    expect(report.checks.find((check) => check.id === 'replay_evidence_integrity')?.status).toBe('defer');
-    expect(report.counts.defer).toBeGreaterThan(0);
-  });
-
-  it('blocks malformed replay reports that claim pass without evidence', () => {
-    createImplementationAssetDir(stateDir, 'IMPL-1', '1.0.0');
-    const replayDir = path.join(getImplementationAssetRoot(stateDir, 'IMPL-1'), 'replays');
-    fs.mkdirSync(replayDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(replayDir, 'bad-report.json'),
-      JSON.stringify(
-        {
-          overallDecision: 'pass',
-          blockers: [],
-          generatedAt: '2026-04-12T09:00:00.000Z',
-          implementationId: 'IMPL-1',
-          evidenceSummary: {
-            evidenceStatus: 'empty',
-            totalSamples: 0,
-            classifiedCounts: {
-              painNegative: 0,
-              successPositive: 0,
-              principleAnchor: 0,
-            },
-          },
-        },
-        null,
-        2,
-      ),
-      'utf-8',
-    );
-
-    const report = runMergeGateAudit(workspaceDir, stateDir);
-    const replayCheck = report.checks.find((check) => check.id === 'replay_evidence_integrity');
-
-    expect(report.overallStatus).toBe('block');
-    expect(replayCheck?.status).toBe('block');
-  });
-
-  it('blocks when replay reports are malformed', () => {
-    createImplementationAssetDir(stateDir, 'IMPL-BAD', '1.0.0');
-    const replayDir = path.join(getImplementationAssetRoot(stateDir, 'IMPL-BAD'), 'replays');
-    fs.mkdirSync(replayDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(replayDir, 'malformed.json'),
-      '{bad json',
-      'utf-8',
-    );
-
-    const report = runMergeGateAudit(workspaceDir, stateDir);
-    const replayCheck = report.checks.find((c) => c.id === 'replay_evidence_integrity');
-    const details = replayCheck?.details as Record<string, string[]> | undefined;
-
-    expect(report.overallStatus).toBe('block');
-    expect(replayCheck?.status).toBe('block');
-    expect(details?.malformedReports).toHaveLength(1);
-  });
-
-  it('blocks when replay reports have invalid evidenceSummary shape', () => {
-    createImplementationAssetDir(stateDir, 'IMPL-NOEVID', '1.0.0');
-    const replayDir = path.join(getImplementationAssetRoot(stateDir, 'IMPL-NOEVID'), 'replays');
-    fs.mkdirSync(replayDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(replayDir, 'bad-evidence.json'),
-      JSON.stringify({
-        overallDecision: 'pass',
-        blockers: [],
-        generatedAt: '2026-04-12T09:00:00.000Z',
-        implementationId: 'IMPL-NOEVID',
-        evidenceSummary: { evidenceStatus: 'observed' },
-      }),
-      'utf-8',
-    );
-
-    const report = runMergeGateAudit(workspaceDir, stateDir);
-    const replayCheck = report.checks.find((c) => c.id === 'replay_evidence_integrity');
-    const details = replayCheck?.details as Record<string, string[]> | undefined;
-
-    expect(report.overallStatus).toBe('block');
-    expect(replayCheck?.status).toBe('block');
-    expect(details?.missingEvidenceSummary).toHaveLength(1);
-  });
-});