principles-disciple 1.17.0 → 1.19.0

package/tests/core/nocturnal-export.test.ts

@@ -15,6 +15,7 @@ import {
   updateReviewStatus,
   getDatasetRecord,
 } from '../../src/core/nocturnal-dataset.js';
+import { appendArtifactLineageRecord } from '../../src/core/nocturnal-artifact-lineage.js';
 import type { NocturnalDatasetRecord } from '../../src/core/nocturnal-dataset.js';
 
 // ---------------------------------------------------------------------------
@@ -123,9 +124,63 @@ describe('NocturnalExport exportORPOSamples', () => {
       expect(sample.rejected).toBeTruthy();
       expect(sample.rationale).toBeTruthy();
       expect(sample.datasetMetadata.exportId).toBe(result.manifest!.exportId);
+      expect(sample.datasetMetadata.evidenceSummary.lineageStatus).toBe('unknown');
     }
   });
 
+  it('degrades to evidence-bounded neutral text when lineage is missing', () => {
+    setupExportReady(tmpDir, 'art-no-lineage', 'gpt-4');
+
+    const result = exportORPOSamples(tmpDir, 'gpt-4');
+
+    expect(result.success).toBe(true);
+    const [sample] = fs.readFileSync(result.manifest!.exportPath, 'utf-8').trim().split('\n').map((line) => JSON.parse(line));
+    expect(sample.prompt).toBe('Take the next action without verified source evidence.');
+    expect(sample.rejected).toBe('Take the next action without verified source evidence.');
+    expect(sample.rationale).toContain('Source evidence is unknown');
+    expect(sample.datasetMetadata.evidenceSummary).toEqual({
+      lineageStatus: 'unknown',
+      painSignals: { status: 'unknown', count: null, ids: [] },
+      gateBlocks: { status: 'unknown', count: null, ids: [] },
+    });
+  });
+
+  it('exports observed lineage evidence when available', () => {
+    const record = setupExportReady(tmpDir, 'art-with-lineage', 'gpt-4');
+    appendArtifactLineageRecord(tmpDir, {
+      artifactKind: 'behavioral-sample',
+      artifactId: record.artifactId,
+      principleId: record.principleId,
+      ruleId: null,
+      sessionId: record.sessionId,
+      sourceSnapshotRef: record.sourceSnapshotRef,
+      sourcePainIds: ['pain-1', 'pain-2'],
+      sourceGateBlockIds: ['gate-1'],
+      storagePath: record.artifactPath,
+      implementationId: null,
+      createdAt: record.createdAt,
+    });
+
+    const result = exportORPOSamples(tmpDir, 'gpt-4');
+
+    expect(result.success).toBe(true);
+    const [sample] = fs.readFileSync(result.manifest!.exportPath, 'utf-8').trim().split('\n').map((line) => JSON.parse(line));
+    expect(sample.prompt).toContain('2 observed pain signals');
+    expect(sample.rejected).toContain('1 observed gate blocks');
+    expect(sample.rationale).toContain('Observed source evidence: 2 pain signals and 1 gate blocks');
+    expect(sample.datasetMetadata.evidenceSummary.lineageStatus).toBe('observed');
+    expect(sample.datasetMetadata.evidenceSummary.painSignals).toEqual({
+      status: 'observed',
+      count: 2,
+      ids: ['pain-1', 'pain-2'],
+    });
+    expect(sample.datasetMetadata.evidenceSummary.gateBlocks).toEqual({
+      status: 'observed',
+      count: 1,
+      ids: ['gate-1'],
+    });
+  });
+
   it('writes manifest alongside JSONL', () => {
     setupExportReady(tmpDir, 'art-manifest-1', 'gpt-4');
 

package/tests/core/nocturnal-trinity.test.ts

@@ -5,6 +5,8 @@ import {
   validateDraftArtifact,
   draftToArtifact,
   DEFAULT_TRINITY_CONFIG,
+  OpenClawTrinityRuntimeAdapter,
+  TrinityRuntimeContractError,
   type TrinityConfig,
   type DreamerOutput,
   type PhilosopherOutput,
@@ -25,12 +27,16 @@ function makeSnapshot(overrides: Partial<{
   failureCount: number;
   totalPainEvents: number;
   totalGateBlocks: number;
-}> = {}): {
-  sessionId: string;
-  stats: { failureCount: number; totalPainEvents: number; totalGateBlocks: number; totalAssistantTurns: number; totalToolCalls: number };
-} {
+}> = {}) {
   return {
     sessionId: 'session-test-123',
+    startedAt: '2026-04-12T00:00:00.000Z',
+    updatedAt: '2026-04-12T00:05:00.000Z',
+    assistantTurns: [],
+    userTurns: [],
+    toolCalls: [],
+    painEvents: [],
+    gateBlocks: [],
     stats: {
       failureCount: overrides.failureCount ?? 0,
       totalPainEvents: overrides.totalPainEvents ?? 0,
@@ -236,6 +242,73 @@ describe('validateDreamerOutput', () => {
   });
 });
 
+describe('OpenClawTrinityRuntimeAdapter contract hardening', () => {
+  function makeRuntimeApi(overrides: Partial<any> = {}) {
+    return {
+      runtime: {
+        agent: {
+          runEmbeddedPiAgent: vi.fn().mockResolvedValue({
+            payloads: [
+              { text: '{"valid":true,"candidates":[],"generatedAt":"2026-04-12T00:00:00.000Z"}' },
+            ],
+          }),
+        },
+        config: {
+          loadConfig: vi.fn().mockReturnValue({
+            agents: {
+              defaults: {
+                model: 'openai/gpt-5.4',
+              },
+            },
+          }),
+        },
+        ...overrides.runtime,
+      },
+      logger: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+      },
+    };
+  }
+
+  it('rejects missing runtime.agent.runEmbeddedPiAgent contract explicitly', () => {
+    expect(() => new OpenClawTrinityRuntimeAdapter({ runtime: {} } as any)).toThrow(TrinityRuntimeContractError);
+    expect(() => new OpenClawTrinityRuntimeAdapter({ runtime: {} } as any)).toThrow(/runtime_unavailable/);
+  });
+
+  it('passes explicit provider/model overrides into runtime.agent.runEmbeddedPiAgent', async () => {
+    const api = makeRuntimeApi();
+    const adapter = new OpenClawTrinityRuntimeAdapter(api as any);
+
+    await adapter.invokeDreamer(makeSnapshot({ failureCount: 1 }) as any, 'T-08', 2);
+
+    expect(api.runtime.agent.runEmbeddedPiAgent).toHaveBeenCalledWith(
+      expect.objectContaining({
+        provider: 'openai',
+        model: 'gpt-5.4',
+      }),
+    );
+  });
+
+  it('returns stable failure classes when runtime invocation fails', async () => {
+    const api = makeRuntimeApi({
+      runtime: {
+        agent: {
+          runEmbeddedPiAgent: vi.fn().mockRejectedValue(new Error('gateway unavailable')),
+        },
+      },
+    });
+    const adapter = new OpenClawTrinityRuntimeAdapter(api as any);
+
+    const result = await adapter.invokeDreamer(makeSnapshot({ failureCount: 1 }) as any, 'T-08', 2);
+
+    expect(result.valid).toBe(false);
+    expect(result.reason).toContain('runtime_run_failed');
+    expect(adapter.getLastFailureReason()).toContain('runtime_run_failed');
+  });
+});
+
 // ---------------------------------------------------------------------------
 // Tests: validatePhilosopherOutput
 // ---------------------------------------------------------------------------

package/tests/core/pain-integration.test.ts

@@ -479,5 +479,32 @@ unknown_meta: some data`;
         fs.rmSync(freshDir, { recursive: true, force: true });
       }
     });
+
+    it('readPainFlagData reads only the canonical .state/.pain_flag path', () => {
+      const legacyRootPath = path.join(TEST_DIR, 'PAIN_FLAG');
+      fs.writeFileSync(
+        legacyRootPath,
+        `source: legacy_root
+score: 90
+reason: should be ignored
+time: 2026-04-10T09:00:00.000Z`,
+        'utf-8',
+      );
+      fs.writeFileSync(
+        path.join(STATE_DIR, '.pain_flag'),
+        `source: canonical_state
+score: 80
+reason: should be read
+time: 2026-04-10T09:00:00.000Z`,
+        'utf-8',
+      );
+
+      const result = readPainFlagData(TEST_DIR);
+
+      expect(result.source).toBe('canonical_state');
+      expect(result.score).toBe('80');
+      const legacyResult = readPainFlagData(path.join(TEST_DIR, '..'));
+      expect(legacyResult.source).not.toBe('legacy_root');
+    });
   });
 });

package/tests/core/promotion-gate.test.ts

@@ -255,6 +255,11 @@ describe('promotion-gate', () => {
 
       expect(result.constraintChecks.length).toBeGreaterThan(0);
       expect(result.deltaCheck).toBeDefined();
+      expect(result.evidenceSummary).toEqual({
+        evidenceMode: 'eval-proxy',
+        shadowSampleCount: 0,
+        deltaSource: 'eval',
+      });
     });
   });
 

package/tests/core/replay-engine.test.ts

@@ -231,4 +231,23 @@ describe('ReplayEngine', () => {
     expect(fs.existsSync(reportDir)).toBe(true);
     expect(fs.readdirSync(reportDir).some((file) => file.endsWith('.json'))).toBe(true);
   });
+
+  it('marks empty replay evidence as needs-review instead of pass', () => {
+    seedLedgerAndImplementation();
+
+    const engine = new ReplayEngine(workspaceDir, stateDir);
+    const report = engine.runReplayForImplementation('IMPL-1', ['pain-negative']);
+
+    expect(report.overallDecision).toBe('needs-review');
+    expect(report.evidenceSummary).toEqual({
+      evidenceStatus: 'empty',
+      totalSamples: 0,
+      classifiedCounts: {
+        painNegative: 0,
+        successPositive: 0,
+        principleAnchor: 0,
+      },
+    });
+    expect(report.blockers[0]).toContain('NO REPLAY EVIDENCE');
+  });
 });