principles-disciple 1.11.0 → 1.13.0

package/tests/service/evolution-worker.test.ts

@@ -2,14 +2,10 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import {
     EvolutionWorkerService,
     createEvolutionTaskId,
-    createPainCandidateFingerprint,
     extractEvolutionTaskId,
     hasRecentDuplicateTask,
     hasEquivalentPromotedRule,
-    processPromotion,
     registerEvolutionTaskSession,
-    shouldTrackPainCandidate,
-    trackPainCandidate,
 } from '../../src/service/evolution-worker.js';
 import { DictionaryService } from '../../src/core/dictionary-service.js';
 import * as sessionTracker from '../../src/core/session-tracker.js';
@@ -26,15 +22,6 @@ vi.mock('../../src/core/session-tracker', () => ({
     flushAllSessions: vi.fn(),
     listSessions: vi.fn(() => []), // Returns empty sessions for idle detection
 }));
-vi.mock('../../src/core/event-log', () => ({
-    EventLogService: {
-        get: vi.fn(() => ({
-            recordEvolutionTask: vi.fn(),
-            recordRulePromotion: vi.fn(),
-            flush: vi.fn(),
-        })),
-    },
-}));
 
 describe('EvolutionWorkerService', () => {
     beforeEach(() => {
@@ -103,43 +90,6 @@ describe('EvolutionWorkerService', () => {
         expect(idA).not.toBe(idB);
     });
 
-    it('should generate distinct pain candidate fingerprints when only the suffix differs', () => {
-        const prefix = 'A'.repeat(60);
-        const textA = `${prefix} root-cause-one`;
-        const textB = `${prefix} root-cause-two`;
-
-        expect(createPainCandidateFingerprint(textA)).not.toBe(createPainCandidateFingerprint(textB));
-    });
-
-    it('should skip known noise payloads when tracking pain candidates', () => {
-        expect(shouldTrackPainCandidate('NO_REPLY')).toBe(false);
-        expect(shouldTrackPainCandidate(
-            '{"damageDetected":false,"severity":"mild","confidence":0.95,"reason":"observer"}'
-        )).toBe(false);
-        expect(shouldTrackPainCandidate('Tool edit failed on MEMORY.md')).toBe(true);
-    });
-
-    it('should initialize candidates as pending and keep longer samples', async () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-pain-candidate-'));
-        const candidatePath = path.join(dir, 'pain_candidates.json');
-        const longText = `Tool edit failed on MEMORY.md: ${'x'.repeat(1200)}`;
-
-        try {
-            await trackPainCandidate(longText, {
-                resolve: () => candidatePath,
-            } as any);
-
-            const data = JSON.parse(fs.readFileSync(candidatePath, 'utf8'));
-            const candidate = Object.values(data.candidates)[0] as any;
-
-            expect(candidate.status).toBe('pending');
-            expect(candidate.samples[0].length).toBeGreaterThan(200);
-            expect(candidate.samples[0].length).toBeLessThanOrEqual(1000);
-        } finally {
-            safeRmDir(dir);
-        }
-    });
-
     it('should extract evolution task ids from diagnostician payloads', () => {
         expect(extractEvolutionTaskId('Diagnose systemic pain [ID: ab12cd34]. Source: tool_failure.')).toBe('ab12cd34');
         expect(extractEvolutionTaskId('plain task without id')).toBeNull();
@@ -171,79 +121,6 @@ describe('EvolutionWorkerService', () => {
         }
     });
 
-    it('should promote legacy candidates even when status is missing', async () => {
-        const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-promotion-'));
-        const candidatePath = path.join(dir, 'pain_candidates.json');
-        const addRule = vi.fn();
-
-        fs.writeFileSync(candidatePath, JSON.stringify({
-            candidates: {
-                deadbeef: {
-                    count: 3,
-                    firstSeen: '2026-03-20T00:00:00.000Z',
-                    samples: [
-                        'Tool edit failed on MEMORY.md. Could not find the exact text in MEMORY.md.',
-                        'Tool edit failed on CURRENT_FOCUS.md. Could not find the exact text in CURRENT_FOCUS.md.',
-                        'Tool edit failed on TEAM_COMMS.md. Could not find the exact text in TEAM_COMMS.md.',
-                    ],
-                },
-            },
-        }, null, 2), 'utf8');
-
-        try {
-            await processPromotion({
-                workspaceDir: dir,
-                resolve: () => candidatePath,
-                config: {
-                    get: (key: string) => {
-                        if (key === 'thresholds.promotion_count_threshold') return 3;
-                        if (key === 'scores.default_confusion') return 35;
-                        return undefined;
-                    },
-                },
-                dictionary: {
-                    addRule,
-                    getAllRules: () => ({}),
-                },
-            } as any, { info: vi.fn() }, null);
-
-            const saved = JSON.parse(fs.readFileSync(candidatePath, 'utf8'));
-            expect(addRule).toHaveBeenCalled();
-            expect(saved.candidates.deadbeef.status).toBe('promoted');
-        } finally {
-            safeRmDir(dir);
-        }
-    });
-
-    it('should flush the dictionary on its interval', async () => {
-        const mockDict = {
-            flush: vi.fn()
-        };
-        vi.mocked(DictionaryService.get).mockReturnValue(mockDict as any);
-
-        // Use path.resolve for cross-platform compatibility
-        const workspaceDir = path.resolve('/mock/workspace');
-        const expectedStateDir = path.join(workspaceDir, '.state');
-
-        const ctx = {
-            workspaceDir,
-            stateDir: path.resolve('/mock/state'),
-            logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() }
-        };
-
-        EvolutionWorkerService.start(ctx as any);
-
-        // Advance by 15 minutes
-        await vi.advanceTimersByTimeAsync(15 * 60 * 1000);
-
-        expect(mockDict.flush).toHaveBeenCalled();
-        // Service now uses workspace-specific stateDir, not ctx.stateDir
-        expect(sessionTracker.initPersistence).toHaveBeenCalledWith(expectedStateDir);
-        expect(sessionTracker.flushAllSessions).toHaveBeenCalled();
-        
-        EvolutionWorkerService.stop(ctx as any);
-    });
-
     it('should process queue work without persisting a legacy directive file', async () => {
         const mockDict = {
             flush: vi.fn()

package/tests/service/nocturnal-service-code-candidate.test.ts

@@ -0,0 +1,330 @@
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { executeNocturnalReflection } from '../../src/service/nocturnal-service.js';
+import { createNocturnalTrajectoryExtractor } from '../../src/core/nocturnal-trajectory-extractor.js';
+import { getDatasetRecordByArtifactId, listDatasetRecords } from '../../src/core/nocturnal-dataset.js';
+import { listArtifactLineageRecords } from '../../src/core/nocturnal-artifact-lineage.js';
+import {
+  listImplementationsForRule,
+  saveLedger,
+  type LedgerPrinciple,
+  type LedgerRule,
+} from '../../src/core/principle-tree-ledger.js';
+import {
+  getImplementationAssetRoot,
+  loadEntrySource,
+  loadManifest,
+} from '../../src/core/code-implementation-storage.js';
+import { TrajectoryDatabase, TrajectoryRegistry } from '../../src/core/trajectory.js';
+import { clearSession, listSessions, seedSessionForTest } from '../../src/core/session-tracker.js';
+import { safeRmDir } from '../test-utils.js';
+
+function makePrinciple(overrides: Partial<LedgerPrinciple> = {}): LedgerPrinciple {
+  return {
+    id: 'T-08',
+    version: 1,
+    text: 'Pain as Signal',
+    triggerPattern: 'pain',
+    action: 'Diagnose before repeating failures',
+    status: 'active',
+    priority: 'P1',
+    scope: 'general',
+    evaluability: 'deterministic',
+    valueScore: 0,
+    adherenceRate: 80,
+    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: 'Protect risky write',
+    description: 'Require approval for risky write operations.',
+    type: 'gate',
+    triggerCondition: 'risky write',
+    enforcement: 'block',
+    action: 'require approval for risky write',
+    principleId: 'T-08',
+    status: 'implemented',
+    coverageRate: 0,
+    falsePositiveRate: 0,
+    implementationIds: [],
+    createdAt: '2026-04-08T00:00:00.000Z',
+    updatedAt: '2026-04-08T00:00:00.000Z',
+    ...overrides,
+  };
+}
+
+function makeBehavioralArtifact(sessionId: string) {
+  return {
+    artifactId:
+      sessionId === 'session-skip'
+        ? '11111111-1111-4111-8111-111111111111'
+        : sessionId === 'session-success'
+          ? '22222222-2222-4222-8222-222222222222'
+          : sessionId === 'session-invalid'
+            ? '33333333-3333-4333-8333-333333333333'
+            : '44444444-4444-4444-8444-444444444444',
+    sessionId,
+    principleId: 'T-08',
+    sourceSnapshotRef: `snapshot-${sessionId}`,
+    badDecision: 'Retried a failing write operation without first checking the approval requirements',
+    betterDecision:
+      'Read docs/gateblocks.md to confirm the approval requirements before retrying the write operation',
+    rationale: 'Checking the gate guidance first prevents repeated blocked writes and preserves operator review boundaries',
+    createdAt: '2026-04-08T00:00:00.000Z',
+  };
+}
+
+describe('nocturnal-service code candidates', () => {
+  let tempDir: string;
+  let workspaceDir: string;
+  let stateDir: string;
+  let trajectory: TrajectoryDatabase;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-nocturnal-code-candidate-'));
+    workspaceDir = path.join(tempDir, 'workspace');
+    stateDir = path.join(tempDir, 'state');
+    fs.mkdirSync(workspaceDir, { recursive: true });
+    fs.mkdirSync(stateDir, { recursive: true });
+    trajectory = new TrajectoryDatabase({ workspaceDir });
+    createNocturnalTrajectoryExtractor(workspaceDir);
+
+    for (const session of listSessions()) {
+      clearSession(session.sessionId);
+    }
+  });
+
+  afterEach(() => {
+    try {
+      trajectory.dispose();
+    } catch {
+      // Best effort cleanup.
+    }
+    try {
+      TrajectoryRegistry.dispose(workspaceDir);
+    } catch {
+      // Best effort cleanup.
+    }
+    safeRmDir(tempDir);
+  });
+
+  function makeIdleResult() {
+    return {
+      isIdle: true,
+      mostRecentActivityAt: Date.now() - 2 * 60 * 60 * 1000,
+      idleForMs: 2 * 60 * 60 * 1000,
+      userActiveSessions: 0,
+      abandonedSessionIds: [],
+      trajectoryGuardrailConfirmsIdle: true,
+      reason: 'test override',
+    };
+  }
+
+  function seedSession(sessionId: string): void {
+    const startedAt = new Date().toISOString();
+    trajectory.recordSession({ sessionId, startedAt });
+    for (let i = 0; i < 2; i += 1) {
+      trajectory.recordToolCall({
+        sessionId,
+        toolName: 'write',
+        outcome: 'failure',
+        errorMessage: 'risky write blocked',
+      });
+    }
+    trajectory.recordPainEvent({
+      sessionId,
+      source: 'gate',
+      score: 75,
+      reason: 'risky write requires approval',
+    });
+    trajectory.recordGateBlock({
+      sessionId,
+      toolName: 'write',
+      reason: 'risky write requires approval',
+      riskLevel: 'medium',
+    });
+    seedSessionForTest(sessionId, workspaceDir, new Date(startedAt).getTime());
+  }
+
+  function seedLedger(singleRule = true): void {
+    saveLedger(stateDir, {
+      trainingStore: {
+        'T-08': {
+          principleId: 'T-08',
+          evaluability: 'deterministic',
+          applicableOpportunityCount: 5,
+          observedViolationCount: 3,
+          complianceRate: 0.2,
+          violationTrend: 1,
+          generatedSampleCount: 0,
+          approvedSampleCount: 0,
+          includedTrainRunIds: [],
+          deployedCheckpointIds: [],
+          internalizationStatus: 'internalized',
+        },
+      },
+      tree: {
+        principles: {
+          'T-08': makePrinciple({
+            ruleIds: singleRule ? ['R-001'] : ['R-001', 'R-002'],
+          }),
+        },
+        rules: singleRule
+          ? {
+              'R-001': makeRule(),
+            }
+          : {
+              'R-001': makeRule(),
+              'R-002': makeRule({
+                id: 'R-002',
+                name: 'Protect risky write',
+                description: 'Require approval for risky write operations.',
+                triggerCondition: 'risky write',
+                action: 'require approval for risky write',
+              }),
+            },
+        implementations: {},
+        metrics: {},
+        lastUpdated: '2026-04-08T00:00:00.000Z',
+      },
+    });
+  }
+
+  it('persists a behavioral artifact only when Artificer routing is skipped', () => {
+    seedLedger(false);
+    seedSession('session-skip');
+
+    const result = executeNocturnalReflection(workspaceDir, stateDir, {
+      idleCheckOverride: makeIdleResult(),
+      skipReflector: true,
+      reflectorOutputOverride: JSON.stringify(makeBehavioralArtifact('session-skip')),
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.diagnostics.persisted).toBe(true);
+    expect(result.diagnostics.artificer.status).toBe('skipped');
+    expect(result.diagnostics.artificer.reason).toBe('no_deterministic_rule');
+    expect(listImplementationsForRule(stateDir, 'R-001')).toHaveLength(0);
+
+    const datasetRecord = getDatasetRecordByArtifactId(
+      workspaceDir,
+      result.artifact!.artifactId
+    );
+    expect(datasetRecord?.classification).toBeNull();
+  });
+
+  it('persists a behavioral artifact and a candidate implementation when Artificer succeeds', () => {
+    seedLedger(true);
+    seedSession('session-success');
+
+    const result = executeNocturnalReflection(workspaceDir, stateDir, {
+      idleCheckOverride: makeIdleResult(),
+      skipReflector: true,
+      reflectorOutputOverride: JSON.stringify(makeBehavioralArtifact('session-success')),
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.diagnostics.artificer.status).toBe('persisted_candidate');
+
+    const implementations = listImplementationsForRule(stateDir, 'R-001');
+    expect(implementations).toHaveLength(1);
+    expect(implementations[0].lifecycleState).toBe('candidate');
+
+    const manifest = loadManifest(stateDir, implementations[0].id);
+    expect(manifest?.lineage).toMatchObject({
+      principleId: 'T-08',
+      ruleId: 'R-001',
+      sourceSessionId: 'session-success',
+    });
+    expect(loadEntrySource(stateDir, implementations[0].id)).toContain(
+      'requireApproval'
+    );
+    expect(fs.existsSync(getImplementationAssetRoot(stateDir, implementations[0].id))).toBe(
+      true
+    );
+
+    const lineage = listArtifactLineageRecords(workspaceDir);
+    expect(
+      lineage.some((record) => record.artifactKind === 'behavioral-sample')
+    ).toBe(true);
+    expect(
+      lineage.some(
+        (record) =>
+          record.artifactKind === 'rule-implementation-candidate' &&
+          record.implementationId === implementations[0].id
+      )
+    ).toBe(true);
+
+    const datasetRecord = getDatasetRecordByArtifactId(
+      workspaceDir,
+      result.artifact!.artifactId
+    );
+    expect(datasetRecord?.classification).toBeNull();
+  });
+
+  it('preserves the behavioral artifact when Artificer validation fails', () => {
+    seedLedger(true);
+    seedSession('session-invalid');
+
+    const result = executeNocturnalReflection(workspaceDir, stateDir, {
+      idleCheckOverride: makeIdleResult(),
+      skipReflector: true,
+      reflectorOutputOverride: JSON.stringify(makeBehavioralArtifact('session-invalid')),
+      artificerOutputOverride: JSON.stringify({
+        ruleId: 'R-001',
+        candidateSource:
+          'export const meta = { name: "bad", version: "1", ruleId: "R-001", coversCondition: "bad" }; export function evaluate() { eval("1 + 1"); return { decision: "allow", matched: false, reason: "bad" }; }',
+        helperUsage: [],
+        expectedDecision: 'allow',
+        rationale: 'bad candidate',
+        lineage: {
+          artifactKind: 'rule-implementation-candidate',
+          sourceSnapshotRef: 'snapshot-1',
+          sourcePainIds: ['pain:1'],
+          sourceGateBlockIds: ['gate:1'],
+        },
+      }),
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.diagnostics.persisted).toBe(true);
+    expect(result.diagnostics.artificer.status).toBe('validation_failed');
+    expect(result.diagnostics.artificer.reason).toBe('validator_rejected');
+    expect(listImplementationsForRule(stateDir, 'R-001')).toHaveLength(0);
+  });
+
+  it('cleans up the candidate when storage fails after ledger creation', () => {
+    seedLedger(true);
+    seedSession('session-storage-failure');
+    fs.mkdirSync(stateDir, { recursive: true });
+    fs.writeFileSync(path.join(stateDir, 'principles'), 'not-a-directory', 'utf-8');
+
+    const result = executeNocturnalReflection(workspaceDir, stateDir, {
+      idleCheckOverride: makeIdleResult(),
+      skipReflector: true,
+      reflectorOutputOverride: JSON.stringify(
+        makeBehavioralArtifact('session-storage-failure')
+      ),
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.diagnostics.artificer.status).toBe('validation_failed');
+    expect(result.diagnostics.artificer.reason).toBe('persistence_failed');
+    expect(listImplementationsForRule(stateDir, 'R-001')).toHaveLength(0);
+    expect(
+      listArtifactLineageRecords(workspaceDir, 'rule-implementation-candidate')
+    ).toHaveLength(0);
+  });
+});

package/tests/utils/nlp.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import { extractCommonPhrases, extractCommonSubstring } from '../../src/utils/nlp.js';
+import { extractCommonPhrases } from '../../src/utils/nlp.js';
 
 describe('NLP Utils', () => {
     describe('extractCommonPhrases (English)', () => {
@@ -32,22 +32,4 @@ describe('NLP Utils', () => {
             expect(result).toHaveLength(0);
         });
     });
-
-    describe('extractCommonSubstring (Chinese/Mixed)', () => {
-        it('should extract common substring from Chinese text', () => {
-            const samples = [
-                "这个问题让我有点头疼，不知道怎么解决。",
-                "代码报错了，让我有点头疼。",
-                "让我有点头疼，这逻辑不对啊。"
-            ];
-            const result = extractCommonSubstring(samples, 4);
-            // "让我有点头疼" is 6 chars, so it should find it or a part of it
-            expect(result[0]).toContain('让我有点头疼');
-        });
-
-        it('should handle short or insufficient samples', () => {
-            expect(extractCommonSubstring(["仅有一个样本"])).toHaveLength(0);
-            expect(extractCommonSubstring([], 4)).toHaveLength(0);
-        });
-    });
 });