principles-disciple 1.72.0 → 1.73.0

package/tests/core/principle-internalization/{internalization-routing-policy.test.ts → lifecycle-routing-policy.test.ts}

@@ -1,9 +1,9 @@
 import { describe, expect, it } from 'vitest';
-import { recommendInternalizationRoute } from '../../../src/core/principle-internalization/internalization-routing-policy.js';
+import { recommendLifecycleRoute } from '@principles/core/runtime-v2';
 import type {
   PrincipleLifecycleEvidence,
   RuleLifecycleEvidence,
-} from '../../../src/core/principle-internalization/lifecycle-read-model.js';
+} from '@principles/core/runtime-v2';
 
 function createRuleEvidence(id: string, overrides: Partial<RuleLifecycleEvidence> = {}): RuleLifecycleEvidence {
   return {
@@ -94,9 +94,9 @@ function createPrincipleEvidence(
   };
 }
 
-describe('internalization-routing-policy', () => {
+describe('recommendLifecycleRoute', () => {
   it('recommends code for deterministic high-risk principles with repeated failures and sufficient replay evidence', () => {
-    const recommendation = recommendInternalizationRoute(
+    const recommendation = recommendLifecycleRoute(
       createPrincipleEvidence(
         [
           createRuleEvidence('R-001', {
@@ -156,7 +156,7 @@ describe('internalization-routing-policy', () => {
   });
 
   it('recommends skill when a cheaper non-code path is viable', () => {
-    const recommendation = recommendInternalizationRoute(
+    const recommendation = recommendLifecycleRoute(
       createPrincipleEvidence([
         createRuleEvidence('R-001', {
           rule: {
@@ -201,7 +201,7 @@ describe('internalization-routing-policy', () => {
   });
 
   it('recommends defer when evidence is too sparse to choose a route confidently', () => {
-    const recommendation = recommendInternalizationRoute(
+    const recommendation = recommendLifecycleRoute(
       createPrincipleEvidence([createRuleEvidence('R-001')]),
     );
 

package/tests/core/principle-internalization/lineage-source-retired.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'vitest';
+import { FilesystemLifecycleDatasource, LineageSourceRetiredError } from '../../../src/core/principle-internalization/filesystem-lifecycle-datasource.js';
+import { buildLifecycleReadModel } from '@principles/core/runtime-v2';
+
+describe('LineageSourceRetiredError regression guard (PRI-230)', () => {
+  it('listLineageRecords throws LineageSourceRetiredError, not return []', () => {
+    const ds = new FilesystemLifecycleDatasource('/tmp/nonexistent', '/tmp/nonexistent');
+    expect(() => ds.listLineageRecords('rule-implementation-candidate')).toThrow(LineageSourceRetiredError);
+  });
+
+  it('LineageSourceRetiredError message mentions PRI-230 and nocturnal-artifact-lineage', () => {
+    const ds = new FilesystemLifecycleDatasource('/tmp/nonexistent', '/tmp/nonexistent');
+    try {
+      ds.listLineageRecords('rule-implementation-candidate');
+      expect.unreachable('Should have thrown');
+    } catch (err) {
+      expect(err).toBeInstanceOf(LineageSourceRetiredError);
+      const message = (err as LineageSourceRetiredError).message;
+      expect(message).toContain('PRI-230');
+      expect(message).toContain('nocturnal-artifact-lineage');
+    }
+  });
+
+  it('LineageSourceRetiredError has correct name property', () => {
+    const err = new LineageSourceRetiredError();
+    expect(err.name).toBe('LineageSourceRetiredError');
+  });
+
+  it('retired datasource does not return empty array that could be misinterpreted as "no lineage"', () => {
+    const ds = new FilesystemLifecycleDatasource('/tmp/nonexistent', '/tmp/nonexistent');
+    let returnedEmptyArray = false;
+    try {
+      const result = ds.listLineageRecords('rule-implementation-candidate');
+      returnedEmptyArray = Array.isArray(result) && result.length === 0;
+    } catch {
+      // expected
+    }
+    expect(returnedEmptyArray).toBe(false);
+  });
+});
+
+describe('buildLifecycleReadModel with retired lineage source (PRI-230)', () => {
+  it('produces lineageEvidence with sourceRetired=true when datasource throws LineageSourceRetiredError', () => {
+    const ds = new FilesystemLifecycleDatasource('/tmp/nonexistent', '/tmp/nonexistent');
+    let model: ReturnType<typeof buildLifecycleReadModel>;
+    expect(() => {
+      model = buildLifecycleReadModel(ds);
+    }).not.toThrow();
+
+    const rules = model!.principles.flatMap((p) => p.rules);
+    for (const rule of rules) {
+      expect(rule.lineageEvidence.sourceRetired).toBe(true);
+      expect(rule.lineageEvidence.records).toEqual([]);
+    }
+  });
+});

package/tests/core/principle-internalization/principle-lifecycle-service.test.ts

@@ -3,7 +3,6 @@ import * as fs from 'fs';
 import * as os from 'os';
 import * as path from 'path';
 import { PrincipleLifecycleService } from '../../../src/core/principle-internalization/principle-lifecycle-service.js';
-import { appendCandidateArtifactLineageRecord, listArtifactLineageRecords } from '../../../src/core/nocturnal-artifact-lineage.js';
 import { getImplementationAssetRoot } from '../../../src/core/code-implementation-storage.js';
 import { loadLedger, saveLedger, type LedgerPrinciple, type LedgerRule } from '../../../src/core/principle-tree-ledger.js';
 import type { Implementation } from '../../../src/types/principle-tree-schema.js';
@@ -142,19 +141,6 @@ describe('principle-lifecycle-service', () => {
       JSON.stringify(makeReplayReport(), null, 2),
       'utf-8',
     );
-
-    appendCandidateArtifactLineageRecord(workspaceDir, {
-      artifactId: 'artifact-1',
-      principleId: 'P-001',
-      ruleId: 'R-001',
-      sessionId: 'session-1',
-      sourceSnapshotRef: 'snapshot-1',
-      sourcePainIds: ['pain-1'],
-      sourceGateBlockIds: ['gate-1'],
-      storagePath: getImplementationAssetRoot(stateDir, 'IMPL-001'),
-      implementationId: 'IMPL-001',
-      createdAt: '2026-04-08T00:00:00.000Z',
-    });
   }
 
   it('recomputes lifecycle metrics and exposes assessments plus route recommendations through one service', () => {
@@ -185,13 +171,12 @@ describe('principle-lifecycle-service', () => {
     expect(context.getActivePrincipleSubtrees()).toEqual([]);
   });
 
-  it('keeps replay classifications behavioral-only and preserves candidate lineage semantics', () => {
+  it('keeps replay classifications behavioral-only', () => {
     seedWorkspace();
     const service = new PrincipleLifecycleService(workspaceDir, stateDir);
 
     const assessments = service.listAssessments();
     const readModel = service.buildReadModel();
-    const lineage = listArtifactLineageRecords(workspaceDir, 'rule-implementation-candidate');
     const latestReport = readModel.principles[0].rules[0].replayEvidence.latestReports[0];
 
     expect(assessments[0].routeRecommendation.route).toBe('skill');
@@ -200,12 +185,5 @@ describe('principle-lifecycle-service', () => {
       'successPositive',
       'principleAnchor',
     ]);
-    expect(lineage).toHaveLength(1);
-    expect(lineage[0]).toMatchObject({
-      artifactKind: 'rule-implementation-candidate',
-      sourcePainIds: ['pain-1'],
-      sourceGateBlockIds: ['gate-1'],
-      implementationId: 'IMPL-001',
-    });
   });
 });

package/tests/core/principle-tree-ledger-adapter.test.ts

@@ -0,0 +1,253 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { PrincipleTreeLedgerAdapter } from '../../src/core/principle-tree-ledger-adapter.js';
+import { loadLedger } from '../../src/core/principle-tree-ledger.js';
+import { CandidateIntakeError, INTAKE_ERROR_CODES } from '@principles/core/runtime-v2';
+import type { LedgerPrincipleEntry } from '@principles/core/runtime-v2';
+import { safeRmDir } from '../test-utils.js';
+
+// Mock principle-tree-ledger.js module
+// Use vi.mock with factory to provide controllable addPrincipleToLedger
+vi.mock('../../src/core/principle-tree-ledger.js', async () => {
+  const actual = await vi.importActual<typeof import('../../src/core/principle-tree-ledger.js')>('../../src/core/principle-tree-ledger.js');
+  return {
+    ...actual,
+    addPrincipleToLedger: vi.fn(actual.addPrincipleToLedger),
+  };
+});
+
+describe('PrincipleTreeLedgerAdapter', () => {
+  let tempDir: string;
+  let stateDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-adapter-'));
+    stateDir = path.join(tempDir, '.state');
+    fs.mkdirSync(stateDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    safeRmDir(tempDir);
+  });
+
+  function createEntry(overrides: Partial<LedgerPrincipleEntry> = {}): LedgerPrincipleEntry {
+    return {
+      id: '550e8400-e29b-41d4-a716-446655440000',
+      title: 'Test Principle',
+      text: 'When file delete is attempted, then verify backup exists first.',
+      triggerPattern: 'file delete',
+      action: 'verify backup exists',
+      status: 'probation',
+      evaluability: 'weak_heuristic',
+      sourceRef: 'candidate://test-candidate-001',
+      artifactRef: 'artifact://test-artifact-001',
+      taskRef: 'task://test-task-001',
+      createdAt: '2026-04-26T10:00:00.000Z',
+      ...overrides,
+    };
+  }
+
+  describe('writeProbationEntry', () => {
+    it('writes a LedgerPrinciple to the ledger file with correct field expansion', () => {
+      const adapter = new PrincipleTreeLedgerAdapter({ stateDir });
+      const entry = createEntry();
+      const result = adapter.writeProbationEntry(entry);
+
+      expect(result).toBe(entry);
+
+      const store = loadLedger(stateDir);
+      const written = store.tree.principles[entry.id];
+      expect(written).toBeDefined();
+      expect(written.id).toBe(entry.id);
+      expect(written.text).toBe(entry.text);
+      expect(written.status).toBe('candidate');
+      expect(written.triggerPattern).toBe(entry.triggerPattern);
+      expect(written.action).toBe(entry.action);
+    });
+
+    it('is idempotent — second call with same candidateId returns existing entry, no double write', () => {
+      const adapter = new PrincipleTreeLedgerAdapter({ stateDir });
+      const entry = createEntry();
+      const first = adapter.writeProbationEntry(entry);
+      const second = adapter.writeProbationEntry(entry);
+
+      expect(second).toBe(first);
+
+      const store = loadLedger(stateDir);
+      expect(Object.keys(store.tree.principles).length).toBe(1);
+    });
+
+    it('different candidates produce different entries', () => {
+      const adapter = new PrincipleTreeLedgerAdapter({ stateDir });
+      const entry1 = createEntry({
+        id: '550e8400-e29b-41d4-a716-446655440000',
+        sourceRef: 'candidate://alpha',
+      });
+      const entry2 = createEntry({
+        id: '660e8400-e29b-41d4-a716-446655440001',
+        sourceRef: 'candidate://beta',
+        title: 'Another Principle',
+        text: 'When network fails, retry with backoff.',
+      });
+
+      adapter.writeProbationEntry(entry1);
+      adapter.writeProbationEntry(entry2);
+
+      const store = loadLedger(stateDir);
+      expect(Object.keys(store.tree.principles).length).toBe(2);
+      expect(store.tree.principles[entry1.id]).toBeDefined();
+      expect(store.tree.principles[entry2.id]).toBeDefined();
+
+      expect(adapter.existsForCandidate('alpha')).toBeDefined();
+      expect(adapter.existsForCandidate('beta')).toBeDefined();
+    });
+  });
+
+  describe('existsForCandidate', () => {
+    it('returns the entry for a previously written candidate', () => {
+      const adapter = new PrincipleTreeLedgerAdapter({ stateDir });
+      const entry = createEntry();
+      adapter.writeProbationEntry(entry);
+
+      const found = adapter.existsForCandidate('test-candidate-001');
+      expect(found).not.toBeNull();
+      expect(found?.id).toBe(entry.id);
+      expect(found?.title).toBe(entry.title);
+      expect(found?.sourceRef).toBe(entry.sourceRef);
+    });
+
+    it('returns null for an unknown candidate', () => {
+      const adapter = new PrincipleTreeLedgerAdapter({ stateDir });
+      const result = adapter.existsForCandidate('nonexistent-candidate');
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('field expansion', () => {
+    it('maps status probation to candidate', () => {
+      const adapter = new PrincipleTreeLedgerAdapter({ stateDir });
+      const entry = createEntry();
+      adapter.writeProbationEntry(entry);
+
+      const store = loadLedger(stateDir);
+      const written = store.tree.principles[entry.id];
+      expect(written.status).toBe('candidate');
+      expect(written.status).not.toBe('probation');
+    });
+
+    it('applies default values correctly', () => {
+      const adapter = new PrincipleTreeLedgerAdapter({ stateDir });
+      const entry = createEntry({
+        triggerPattern: undefined,
+        action: undefined,
+        artifactRef: undefined,
+        taskRef: undefined,
+      });
+      adapter.writeProbationEntry(entry);
+
+      const store = loadLedger(stateDir);
+      const written = store.tree.principles[entry.id];
+      expect(written.version).toBe(1);
+      expect(written.priority).toBe('P1');
+      expect(written.scope).toBe('general');
+      expect(written.valueScore).toBe(0);
+      expect(written.adherenceRate).toBe(0);
+      expect(written.painPreventedCount).toBe(0);
+      expect(written.createdAt).toBe(entry.createdAt);
+      expect(written.updatedAt).toBe(entry.createdAt);
+    });
+
+    it('passes through triggerPattern and action (Decision B)', () => {
+      const adapter = new PrincipleTreeLedgerAdapter({ stateDir });
+      const entry1 = createEntry({ triggerPattern: 'file delete', action: 'verify backup' });
+      adapter.writeProbationEntry(entry1);
+
+      let store = loadLedger(stateDir);
+      let written = store.tree.principles[entry1.id];
+      expect(written.triggerPattern).toBe('file delete');
+      expect(written.action).toBe('verify backup');
+
+      const entry2 = createEntry({
+        id: '770e8400-e29b-41d4-a716-446655440002',
+        sourceRef: 'candidate://test-002',
+        triggerPattern: undefined,
+        action: undefined,
+      });
+      adapter.writeProbationEntry(entry2);
+
+      store = loadLedger(stateDir);
+      written = store.tree.principles[entry2.id];
+      expect(written.triggerPattern).toBe('');
+      expect(written.action).toBe('');
+    });
+
+    it('does NOT include sourceRef, artifactRef, taskRef in ledger (Decision C)', () => {
+      const adapter = new PrincipleTreeLedgerAdapter({ stateDir });
+      const entry = createEntry();
+      adapter.writeProbationEntry(entry);
+
+      const store = loadLedger(stateDir);
+      const written = store.tree.principles[entry.id];
+      expect('sourceRef' in written).toBe(false);
+      expect('artifactRef' in written).toBe(false);
+      expect('taskRef' in written).toBe(false);
+
+      // But existsForCandidate still works
+      expect(adapter.existsForCandidate('test-candidate-001')).not.toBeNull();
+    });
+
+    it('populates derivedFromPainIds with candidateId (Q1 resolved)', () => {
+      const adapter = new PrincipleTreeLedgerAdapter({ stateDir });
+      const entry = createEntry({ sourceRef: 'candidate://test-candidate-001' });
+      adapter.writeProbationEntry(entry);
+
+      const store = loadLedger(stateDir);
+      const written = store.tree.principles[entry.id];
+      expect(written.derivedFromPainIds).toEqual(['test-candidate-001']);
+    });
+  });
+
+  describe('error handling', () => {
+    it('throws LEDGER_WRITE_FAILED when addPrincipleToLedger fails', async () => {
+      const mockedModule = await import('../../src/core/principle-tree-ledger.js');
+      const mockAdd = vi.mocked(mockedModule.addPrincipleToLedger);
+      mockAdd.mockImplementation(() => {
+        throw new Error('Disk full');
+      });
+
+      const adapter = new PrincipleTreeLedgerAdapter({ stateDir });
+      const entry = createEntry();
+
+      expect(() => adapter.writeProbationEntry(entry)).toThrow(CandidateIntakeError);
+      try {
+        adapter.writeProbationEntry(entry);
+      } catch (err) {
+        expect(err).toBeInstanceOf(CandidateIntakeError);
+        expect((err as CandidateIntakeError).code).toBe(INTAKE_ERROR_CODES.LEDGER_WRITE_FAILED);
+        expect((err as Error).message).toContain(entry.id);
+      }
+
+      mockAdd.mockRestore();
+    });
+  });
+
+  describe('instance isolation', () => {
+    it('separate instances have separate Maps', () => {
+      const tempDir2 = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-adapter-'));
+      const stateDir2 = path.join(tempDir2, '.state');
+      fs.mkdirSync(stateDir2, { recursive: true });
+
+      const adapterA = new PrincipleTreeLedgerAdapter({ stateDir });
+      const adapterB = new PrincipleTreeLedgerAdapter({ stateDir: stateDir2 });
+
+      const entryA = createEntry({ sourceRef: 'candidate://candidate-A' });
+      adapterA.writeProbationEntry(entryA);
+
+      expect(adapterB.existsForCandidate('candidate-A')).toBeNull();
+
+      safeRmDir(tempDir2);
+    });
+  });
+});

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

@@ -139,8 +139,6 @@ describe('ReflectionContextCollector', () => {
       expect(result!.principle.id).toBe('P_001');
       expect(result!.painEvents).toEqual([]);
       expect(result!.sessionSnapshot).toBeNull();
-      expect(result!.lineage.sourcePainIds).toEqual(['pain_no_exist']);
-      expect(result!.lineage.sessionId).toBeNull();
     });
 
     it('returns context with pain events and null snapshot when painIds match events but not a specific session', () => {
@@ -159,9 +157,6 @@ describe('ReflectionContextCollector', () => {
 
       expect(result).not.toBeNull();
       expect(result!.principle.id).toBe('P_002');
-      expect(result!.lineage.sourcePainIds).toEqual(['pain_001']);
-      // painId -> sessionId resolution is a known gap, so painEvents may be empty
-      // and sessionSnapshot may be null
     });
 
     it('resolves pain events from a known session', () => {
@@ -181,9 +176,6 @@ describe('ReflectionContextCollector', () => {
 
       expect(result).not.toBeNull();
       expect(result!.principle.id).toBe('P_003');
-      // painId -> sessionId gap: we attempt to find sessions containing pain events
-      // The lineage sessionId should be populated if we can resolve it
-      expect(result!.lineage.sourcePainIds).toEqual(['pain_from_sess_with_pain']);
     });
   });
 
@@ -258,8 +250,6 @@ describe('ReflectionContextCollector', () => {
       expect(results).toHaveLength(1);
 
       const ctx = results[0];
-      expect(ctx.lineage.sourcePainIds).toEqual(['p1', 'p2', 'p3']);
-      expect(ctx.lineage.sessionId).toBeNull();
       expect(ctx.sessionSnapshot).toBeNull();
     });
   });
@@ -297,7 +287,6 @@ describe('ReflectionContextCollector', () => {
       // Exact match: only ONE pain event should match
       expect(result!.painEvents).toHaveLength(1);
       expect(result!.painEvents[0].reason).toBe('exact_match_target');
-      expect(result!.lineage.sessionId).toBe(sessionId);
     });
 
     it('falls back to substring heuristic when no exact ID match', () => {
@@ -340,17 +329,14 @@ describe('ReflectionContextCollector', () => {
       expect(results).toHaveLength(1);
 
       const ctx: ReflectionContext = results[0];
-      // Verify all fields exist
       expect(ctx).toHaveProperty('principle');
       expect(ctx).toHaveProperty('painEvents');
       expect(ctx).toHaveProperty('sessionSnapshot');
-      expect(ctx).toHaveProperty('lineage');
 
       expect(ctx.principle.id).toBe('P_SHAPE');
       expect(ctx.principle.text).toBe('Shape test principle');
       expect(ctx.principle.action).toBe('Do the thing');
       expect(Array.isArray(ctx.painEvents)).toBe(true);
-      expect(ctx.lineage.sourcePainIds).toEqual(['pain_shape']);
     });
   });
 });