principles-disciple 1.126.0 → 1.128.0

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

@@ -1,212 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { recommendLifecycleRoute } from '@principles/core/runtime-v2';
-import type {
-  PrincipleLifecycleEvidence,
-  RuleLifecycleEvidence,
-} from '@principles/core/runtime-v2';
-
-function createRuleEvidence(id: string, overrides: Partial<RuleLifecycleEvidence> = {}): RuleLifecycleEvidence {
-  return {
-    rule: {
-      id,
-      version: 1,
-      name: id,
-      description: id,
-      type: 'hook',
-      triggerCondition: 'tool=write',
-      enforcement: 'block',
-      action: 'block risky write',
-      principleId: 'P-001',
-      status: 'enforced',
-      coverageRate: 0,
-      falsePositiveRate: 0,
-      implementationIds: [`IMPL-${id}`],
-      createdAt: '2026-04-08T00:00:00.000Z',
-      updatedAt: '2026-04-08T00:00:00.000Z',
-    },
-    implementations: [],
-    replayEvidence: {
-      reportCount: 0,
-      latestReports: [],
-      painNegative: { total: 0, passed: 0, failed: 0 },
-      successPositive: { total: 0, passed: 0, failed: 0 },
-      principleAnchor: { total: 0, passed: 0, failed: 0 },
-      passingImplementationIds: [],
-      failingImplementationIds: [],
-      needsReviewImplementationIds: [],
-    },
-    liveEvidence: {
-      activeCount: 0,
-      candidateCount: 0,
-      disabledCount: 0,
-      archivedCount: 0,
-      durablePenaltyCount: 0,
-      rollbackEvidenceCount: 0,
-      hasActiveImplementation: false,
-      hasPassingActiveImplementation: false,
-    },
-    lineageEvidence: {
-      records: [],
-      distinctPainSignalCount: 0,
-      distinctGateBlockCount: 0,
-      repeatedErrorSignal: 0,
-    },
-    ...overrides,
-  };
-}
-
-function createPrincipleEvidence(
-  rules: RuleLifecycleEvidence[],
-  overrides: Partial<PrincipleLifecycleEvidence> = {},
-): PrincipleLifecycleEvidence {
-  return {
-    principle: {
-      id: 'P-001',
-      version: 1,
-      text: 'Do the cheapest safe thing first',
-      triggerPattern: 'write',
-      action: 'prefer cheap safe fixes',
-      status: 'active',
-      priority: 'P1',
-      scope: 'general',
-      evaluability: 'weak_heuristic',
-      valueScore: 0,
-      adherenceRate: 0,
-      painPreventedCount: 0,
-      derivedFromPainIds: [],
-      ruleIds: rules.map((rule) => rule.rule.id),
-      conflictsWithPrincipleIds: [],
-      createdAt: '2026-04-08T00:00:00.000Z',
-      updatedAt: '2026-04-08T00:00:00.000Z',
-    },
-    rules,
-    summary: {
-      replayReportCount: rules.reduce((sum, rule) => sum + rule.replayEvidence.reportCount, 0),
-      activeImplementationCount: rules.reduce((sum, rule) => sum + rule.liveEvidence.activeCount, 0),
-      candidateImplementationCount: rules.reduce((sum, rule) => sum + rule.liveEvidence.candidateCount, 0),
-      disabledImplementationCount: rules.reduce((sum, rule) => sum + rule.liveEvidence.disabledCount, 0),
-      archivedImplementationCount: rules.reduce((sum, rule) => sum + rule.liveEvidence.archivedCount, 0),
-      distinctPainSignalCount: rules.reduce((sum, rule) => sum + rule.lineageEvidence.distinctPainSignalCount, 0),
-      distinctGateBlockCount: rules.reduce((sum, rule) => sum + rule.lineageEvidence.distinctGateBlockCount, 0),
-      repeatedErrorSignal: rules.reduce((sum, rule) => sum + rule.lineageEvidence.repeatedErrorSignal, 0),
-    },
-    ...overrides,
-  };
-}
-
-describe('recommendLifecycleRoute', () => {
-  it('recommends code for deterministic high-risk principles with repeated failures and sufficient replay evidence', () => {
-    const recommendation = recommendLifecycleRoute(
-      createPrincipleEvidence(
-        [
-          createRuleEvidence('R-001', {
-            replayEvidence: {
-              reportCount: 2,
-              latestReports: [],
-              painNegative: { total: 4, passed: 2, failed: 2 },
-              successPositive: { total: 2, passed: 2, failed: 0 },
-              principleAnchor: { total: 2, passed: 1, failed: 1 },
-              passingImplementationIds: [],
-              failingImplementationIds: ['IMPL-R-001'],
-              needsReviewImplementationIds: [],
-            },
-            liveEvidence: {
-              activeCount: 1,
-              candidateCount: 0,
-              disabledCount: 0,
-              archivedCount: 0,
-              durablePenaltyCount: 0,
-              rollbackEvidenceCount: 0,
-              hasActiveImplementation: true,
-              hasPassingActiveImplementation: false,
-            },
-            lineageEvidence: {
-              records: [],
-              distinctPainSignalCount: 2,
-              distinctGateBlockCount: 1,
-              repeatedErrorSignal: 3,
-            },
-          }),
-        ],
-        {
-          principle: {
-            ...createPrincipleEvidence([]).principle,
-            priority: 'P0',
-            evaluability: 'deterministic',
-            ruleIds: ['R-001'],
-          },
-          summary: {
-            replayReportCount: 2,
-            activeImplementationCount: 1,
-            candidateImplementationCount: 0,
-            disabledImplementationCount: 0,
-            archivedImplementationCount: 0,
-            distinctPainSignalCount: 2,
-            distinctGateBlockCount: 1,
-            repeatedErrorSignal: 3,
-          },
-        },
-      ),
-    );
-
-    expect(recommendation.route).toBe('code');
-    expect(recommendation.reasonCodes).toContain('deterministic_or_high_risk');
-    expect(recommendation.reasonCodes).toContain('repeated_errors_continue');
-    expect(recommendation.nextAction).toContain('manual');
-  });
-
-  it('recommends skill when a cheaper non-code path is viable', () => {
-    const recommendation = recommendLifecycleRoute(
-      createPrincipleEvidence([
-        createRuleEvidence('R-001', {
-          rule: {
-            ...createRuleEvidence('R-001').rule,
-            type: 'skill',
-            enforcement: 'warn',
-          },
-          replayEvidence: {
-            reportCount: 1,
-            latestReports: [],
-            painNegative: { total: 3, passed: 2, failed: 1 },
-            successPositive: { total: 3, passed: 3, failed: 0 },
-            principleAnchor: { total: 1, passed: 1, failed: 0 },
-            passingImplementationIds: [],
-            failingImplementationIds: [],
-            needsReviewImplementationIds: ['IMPL-R-001'],
-          },
-          liveEvidence: {
-            activeCount: 0,
-            candidateCount: 0,
-            disabledCount: 0,
-            archivedCount: 0,
-            durablePenaltyCount: 0,
-            rollbackEvidenceCount: 0,
-            hasActiveImplementation: false,
-            hasPassingActiveImplementation: false,
-          },
-          lineageEvidence: {
-            records: [],
-            distinctPainSignalCount: 1,
-            distinctGateBlockCount: 0,
-            repeatedErrorSignal: 1,
-          },
-        }),
-      ]),
-    );
-
-    expect(recommendation.route).toBe('skill');
-    expect(recommendation.reasonCodes).toContain('cheapest_viable_skill');
-    expect(recommendation.reasonCodes).toContain('no_hard_boundary_required');
-    expect(recommendation.nextAction).toContain('skill or prompt-level');
-  });
-
-  it('recommends defer when evidence is too sparse to choose a route confidently', () => {
-    const recommendation = recommendLifecycleRoute(
-      createPrincipleEvidence([createRuleEvidence('R-001')]),
-    );
-
-    expect(recommendation.route).toBe('defer');
-    expect(recommendation.reasonCodes).toEqual(['sparse_evidence']);
-    expect(recommendation.nextAction).toContain('Collect more replay evidence');
-  });
-});

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

@@ -1,56 +0,0 @@
-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

@@ -1,189 +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 { PrincipleLifecycleService } from '../../../src/core/principle-internalization/principle-lifecycle-service.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';
-import type { ReplayReport } from '../../../src/core/replay-engine.js';
-import { createTestContext, safeRmDir } from '../../test-utils.js';
-
-function makePrinciple(overrides: Partial<LedgerPrinciple> = {}): LedgerPrinciple {
-  return {
-    id: 'P-001',
-    version: 1,
-    text: 'Prefer cheap safe internalization',
-    triggerPattern: 'write',
-    action: 'prefer the cheapest viable fix',
-    status: 'active',
-    priority: 'P1',
-    scope: 'general',
-    evaluability: 'weak_heuristic',
-    valueScore: 0,
-    adherenceRate: 0,
-    painPreventedCount: 0,
-    derivedFromPainIds: [],
-    ruleIds: ['R-001'],
-    conflictsWithPrincipleIds: [],
-    createdAt: '2026-04-08T00:00:00.000Z',
-    updatedAt: '2026-04-08T00:00:00.000Z',
-    ...overrides,
-  };
-}
-
-function makeRule(overrides: Partial<LedgerRule> = {}): LedgerRule {
-  return {
-    id: 'R-001',
-    version: 1,
-    name: 'Coach cautious writes',
-    description: 'Encourage safer writes before escalating to hard boundaries.',
-    type: 'skill',
-    triggerCondition: 'tool=write',
-    enforcement: 'warn',
-    action: 'warn before risky write',
-    principleId: 'P-001',
-    status: 'implemented',
-    coverageRate: 0,
-    falsePositiveRate: 0,
-    implementationIds: ['IMPL-001'],
-    createdAt: '2026-04-08T00:00:00.000Z',
-    updatedAt: '2026-04-08T00:00:00.000Z',
-    ...overrides,
-  };
-}
-
-function makeImplementation(overrides: Partial<Implementation> = {}): Implementation {
-  return {
-    id: 'IMPL-001',
-    ruleId: 'R-001',
-    type: 'code',
-    path: 'implementations/IMPL-001/entry.js',
-    version: 'v1',
-    coversCondition: 'risky write',
-    coveragePercentage: 60,
-    lifecycleState: 'candidate',
-    createdAt: '2026-04-08T00:00:00.000Z',
-    updatedAt: '2026-04-08T00:00:00.000Z',
-    ...overrides,
-  };
-}
-
-function makeReplayReport(overrides: Partial<ReplayReport> = {}): ReplayReport {
-  return {
-    implementationId: 'IMPL-001',
-    generatedAt: '2026-04-08T00:00:00.000Z',
-    overallDecision: 'needs-review',
-    blockers: [],
-    sampleFingerprints: ['sample-1', 'sample-2', 'sample-3'],
-    replayResults: {
-      painNegative: { total: 2, passed: 2, failed: 0, details: [] },
-      successPositive: { total: 2, passed: 1, failed: 1, details: [] },
-      principleAnchor: { total: 1, passed: 1, failed: 0, details: [] },
-    },
-    ...overrides,
-  };
-}
-
-describe('principle-lifecycle-service', () => {
-  let tempDir: string;
-  let workspaceDir: string;
-  let stateDir: string;
-
-  beforeEach(() => {
-    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-lifecycle-service-'));
-    workspaceDir = path.join(tempDir, 'workspace');
-    stateDir = path.join(tempDir, 'state');
-    fs.mkdirSync(workspaceDir, { recursive: true });
-    fs.mkdirSync(stateDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    safeRmDir(tempDir);
-  });
-
-  function seedWorkspace(): void {
-    saveLedger(stateDir, {
-      trainingStore: {
-        'P-001': {
-          principleId: 'P-001',
-          evaluability: 'weak_heuristic',
-          applicableOpportunityCount: 5,
-          observedViolationCount: 2,
-          complianceRate: 0.6,
-          violationTrend: -0.2,
-          generatedSampleCount: 0,
-          approvedSampleCount: 0,
-          includedTrainRunIds: [],
-          deployedCheckpointIds: [],
-          internalizationStatus: 'internalized',
-        },
-      },
-      tree: {
-        principles: {
-          'P-001': makePrinciple(),
-        },
-        rules: {
-          'R-001': makeRule(),
-        },
-        implementations: {
-          'IMPL-001': makeImplementation(),
-        },
-        metrics: {},
-        lastUpdated: '2026-04-08T00:00:00.000Z',
-      },
-    });
-
-    const replayDir = path.join(getImplementationAssetRoot(stateDir, 'IMPL-001'), 'replays');
-    fs.mkdirSync(replayDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(replayDir, '2026-04-08T00-00-00-000Z.json'),
-      JSON.stringify(makeReplayReport(), null, 2),
-      'utf-8',
-    );
-  }
-
-  it('recomputes lifecycle metrics and exposes assessments plus route recommendations through one service', () => {
-    seedWorkspace();
-    const service = new PrincipleLifecycleService(workspaceDir, stateDir);
-
-    const recomputed = service.recomputeAll();
-    const assessments = service.listAssessments();
-    const recommendations = service.listRouteRecommendations();
-    const ledger = loadLedger(stateDir);
-
-    expect(recomputed).toHaveLength(1);
-    expect(recomputed[0].routeRecommendation.route).toBe('skill');
-    expect(assessments).toHaveLength(1);
-    expect(assessments[0].deprecatedReadiness.status).toBe('not-ready');
-    expect(recommendations).toEqual([assessments[0].routeRecommendation]);
-    expect(ledger.tree.rules['R-001'].coverageRate).toBeGreaterThan(0);
-    expect(ledger.tree.principles['P-001'].adherenceRate).toBeGreaterThan(0);
-    expect(ledger.tree.metrics['P-001']).toBeDefined();
-  });
-
-  it('surfaces the lifecycle service from WorkspaceContext without breaking existing consumers', () => {
-    seedWorkspace();
-    const context = createTestContext({ workspaceDir, stateDir });
-
-    expect(context.principleLifecycle).toBeInstanceOf(PrincipleLifecycleService);
-    expect(context.principleLifecycle.listAssessments()).toHaveLength(1);
-    expect(context.getActivePrincipleSubtrees()).toEqual([]);
-  });
-
-  it('keeps replay classifications behavioral-only', () => {
-    seedWorkspace();
-    const service = new PrincipleLifecycleService(workspaceDir, stateDir);
-
-    const assessments = service.listAssessments();
-    const readModel = service.buildReadModel();
-    const latestReport = readModel.principles[0].rules[0].replayEvidence.latestReports[0];
-
-    expect(assessments[0].routeRecommendation.route).toBe('skill');
-    expect(Object.keys(latestReport.replayResults)).toEqual([
-      'painNegative',
-      'successPositive',
-      'principleAnchor',
-    ]);
-  });
-});