principles-disciple 1.18.0 → 1.19.0

package/src/core/nocturnal-trinity.ts

@@ -307,6 +307,17 @@ If you cannot synthesize an artifact:
  */
  
 export interface TrinityRuntimeAdapter {
+  /**
+   * Check if the runtime surface is available for Trinity stage execution.
+   * @returns true if the adapter can invoke stages
+   */
+  isRuntimeAvailable(): boolean;
+
+  /**
+   * Get the reason for the last runtime failure, or null if no failure.
+   */
+  getLastFailureReason(): string | null;
+
   /**
    * Invoke the Dreamer stage.
    * @param snapshot Session trajectory snapshot
@@ -369,6 +380,29 @@ export interface TrinityRuntimeAdapter {
  * Uses api.runtime.agent.runEmbeddedPiAgent() which works in background contexts
  * (unlike api.runtime.subagent.* which requires gateway request scope).
  */
+export type TrinityRuntimeFailureCode =
+  | 'runtime_unavailable'
+  | 'invalid_runtime_request'
+  | 'runtime_run_failed'
+  | 'runtime_timeout'
+  | 'runtime_session_read_failed';
+
+export class TrinityRuntimeContractError extends Error {
+  readonly code: TrinityRuntimeFailureCode;
+  readonly diagnostics?: Record<string, unknown>;
+
+  constructor(
+    code: TrinityRuntimeFailureCode,
+    message: string,
+    diagnostics?: Record<string, unknown>
+  ) {
+    super(`${code}: ${message}`);
+    this.name = 'TrinityRuntimeContractError';
+    this.code = code;
+    this.diagnostics = diagnostics;
+  }
+}
+
 export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
 
   private readonly api: {
@@ -396,6 +430,7 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
     config?: unknown;
     logger?: { info: (msg: string) => void; warn: (msg: string) => void; error: (msg: string) => void };
   };
+  private lastFailureReason: string | null = null;
    
 
   private readonly stageTimeoutMs: number;
@@ -405,6 +440,13 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
     api: OpenClawTrinityRuntimeAdapter['api'],
     stageTimeoutMs = 300_000  // 5 min — increased from 3 min to accommodate slower LLM responses
   ) {
+    if (typeof api?.runtime?.agent?.runEmbeddedPiAgent !== 'function') {
+      throw new TrinityRuntimeContractError(
+        'runtime_unavailable',
+        'embedded runtime unavailable (missing runtime.agent.runEmbeddedPiAgent)',
+      );
+    }
+
     this.api = api;
     this.stageTimeoutMs = stageTimeoutMs;
     // Cross-platform temp directory for session files
@@ -413,6 +455,14 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
     this.cleanupStaleTempDirs();
   }
 
+  isRuntimeAvailable(): boolean {
+    return true;
+  }
+
+  getLastFailureReason(): string | null {
+    return this.lastFailureReason;
+  }
+
   /**
    * Clean up temp directories from previous crashed runs.
    * Matches pattern pd-trinity-* in the OS temp directory.
@@ -509,11 +559,17 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
       .join('\n');
   }
 
+  private classifyRuntimeError(error: unknown): TrinityRuntimeFailureCode {
+    const detail = error instanceof Error ? error.message : String(error);
+    return /timeout/i.test(detail) ? 'runtime_timeout' : 'runtime_run_failed';
+  }
+
   async invokeDreamer(
     snapshot: NocturnalSessionSnapshot,
     principleId: string,
     maxCandidates: number
   ): Promise<DreamerOutput> {
+    this.lastFailureReason = null;
     const runId = `dreamer-${randomUUID()}`;
     const sessionFile = this.createSessionFile('dreamer');
     const prompt = this.buildDreamerPrompt(snapshot, principleId, maxCandidates);
@@ -537,12 +593,10 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
 
       const outputText = this.extractPayloadText(result);
       if (!outputText) {
-        return {
-          valid: false,
-          candidates: [],
-          reason: 'Dreamer returned empty response',
-          generatedAt: new Date().toISOString(),
-        };
+        return this.buildRuntimeFailureDreamerOutput(
+          'runtime_session_read_failed',
+          'Dreamer returned empty response',
+        );
       }
 
       // DEBUG: Log Dreamer's actual output
@@ -550,12 +604,7 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
 
       return this.parseDreamerOutput(outputText);
     } catch (err) {
-      return {
-        valid: false,
-        candidates: [],
-        reason: `Dreamer failed: ${err instanceof Error ? err.message : String(err)}`,
-        generatedAt: new Date().toISOString(),
-      };
+      return this.buildRuntimeFailureDreamerOutput(this.classifyRuntimeError(err), err);
     } finally {
       try { fs.unlinkSync(sessionFile); } catch { /* ignore */ }
     }
@@ -566,6 +615,7 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
     principleId: string,
     snapshot: NocturnalSessionSnapshot
   ): Promise<PhilosopherOutput> {
+    this.lastFailureReason = null;
     const runId = `philosopher-${randomUUID()}`;
     const sessionFile = this.createSessionFile('philosopher');
     const prompt = this.buildPhilosopherPrompt(dreamerOutput, principleId, snapshot);
@@ -587,13 +637,10 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
 
       const outputText = this.extractPayloadText(result);
       if (!outputText) {
-        return {
-          valid: false,
-          judgments: [],
-          overallAssessment: '',
-          reason: 'Philosopher returned empty response',
-          generatedAt: new Date().toISOString(),
-        };
+        return this.buildRuntimeFailurePhilosopherOutput(
+          'runtime_session_read_failed',
+          'Philosopher returned empty response',
+        );
       }
 
       // DEBUG: Log Philosopher's actual output
@@ -601,13 +648,7 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
 
       return this.parsePhilosopherOutput(outputText);
     } catch (err) {
-      return {
-        valid: false,
-        judgments: [],
-        overallAssessment: '',
-        reason: `Philosopher failed: ${err instanceof Error ? err.message : String(err)}`,
-        generatedAt: new Date().toISOString(),
-      };
+      return this.buildRuntimeFailurePhilosopherOutput(this.classifyRuntimeError(err), err);
     } finally {
       try { fs.unlinkSync(sessionFile); } catch { /* ignore */ }
     }
@@ -623,6 +664,7 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
 
     _config: TrinityConfig
   ): Promise<TrinityDraftArtifact | null> {
+    this.lastFailureReason = null;
     const runId = `scribe-${randomUUID()}`;
     const sessionFile = this.createSessionFile('scribe');
     const prompt = this.buildScribePrompt(dreamerOutput, philosopherOutput, snapshot, principleId);
@@ -644,6 +686,7 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
 
       const outputText = this.extractPayloadText(result);
       if (!outputText) {
+        this.recordFailure('runtime_session_read_failed', 'Scribe returned empty response');
         return null;
       }
 
@@ -652,6 +695,7 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
 
       return this.parseScribeOutput(outputText, snapshot, principleId, telemetry);
     } catch (err) {
+      this.recordFailure(this.classifyRuntimeError(err), err);
       return null;
     } finally {
       try { fs.unlinkSync(sessionFile); } catch { /* ignore */ }
@@ -966,6 +1010,19 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
     }
   }
 
+  private buildRuntimeFailureDreamerOutput(
+    code: TrinityRuntimeFailureCode,
+    error: unknown
+  ): DreamerOutput {
+    const reason = this.recordFailure(code, error);
+    return {
+      valid: false,
+      candidates: [],
+      reason,
+      generatedAt: new Date().toISOString(),
+    };
+  }
+
   private parsePhilosopherOutput(text: string): PhilosopherOutput {
     const json = this.extractJson(text);
     if (!json) {
@@ -1016,22 +1073,47 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
     }
   }
 
+  private buildRuntimeFailurePhilosopherOutput(
+    code: TrinityRuntimeFailureCode,
+    error: unknown
+  ): PhilosopherOutput {
+    const reason = this.recordFailure(code, error);
+    return {
+      valid: false,
+      judgments: [],
+      overallAssessment: '',
+      reason,
+      generatedAt: new Date().toISOString(),
+    };
+  }
+
+  private recordFailure(
+    code: TrinityRuntimeFailureCode,
+    error: unknown
+  ): string {
+    const detail = error instanceof Error ? error.message : String(error);
+    this.lastFailureReason = `${code}: ${detail}`;
+    return this.lastFailureReason;
+  }
+
    
   private parseScribeOutput(
     text: string,
     snapshot: NocturnalSessionSnapshot,
     principleId: string,
-     
+
     _telemetry: TrinityTelemetry
   ): TrinityDraftArtifact | null {
     const json = this.extractJson(text);
     if (!json) {
+      this.recordFailure('runtime_run_failed', new Error('Scribe output contains no parseable JSON'));
       return null;
     }
 
     try {
       const parsed = JSON.parse(json);
       if (typeof parsed.selectedCandidateIndex !== 'number') {
+        this.recordFailure('runtime_run_failed', new Error(`Scribe output missing "selectedCandidateIndex" field: ${text.slice(0, 200)}`));
         return null;
       }
 
@@ -1045,7 +1127,7 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
         sourceSnapshotRef: `snapshot-${snapshot.sessionId}-${Date.now()}`,
         telemetry: {
           chainMode: 'trinity',
-          usedStubs: false,
+          usedStubs: _telemetry.usedStubs,
           dreamerPassed: true,
           philosopherPassed: true,
           scribePassed: true,
@@ -1055,6 +1137,7 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
         },
       };
     } catch {
+      this.recordFailure('runtime_run_failed', new Error(`Scribe output JSON parse error: ${json.slice(0, 200)}`));
       return null;
     }
   }

package/src/core/promotion-gate.ts

@@ -277,6 +277,12 @@ export interface PromotionGateResult {
     threshold: number;
     passed: boolean;
   };
+
+  evidenceSummary: {
+    evidenceMode: 'shadow' | 'eval-proxy' | 'mixed';
+    shadowSampleCount: number;
+    deltaSource: 'eval';
+  };
 }
 
 /**
@@ -337,6 +343,11 @@ export function evaluatePromotionGate(
       blockers,
       constraintChecks: [],
       deltaCheck: { actual: 0, threshold: minDelta, passed: false },
+      evidenceSummary: {
+        evidenceMode: 'eval-proxy',
+        shadowSampleCount: 0,
+        deltaSource: 'eval',
+      },
     };
   }
 
@@ -351,6 +362,11 @@ export function evaluatePromotionGate(
       blockers,
       constraintChecks: [],
       deltaCheck: { actual: 0, threshold: minDelta, passed: false },
+      evidenceSummary: {
+        evidenceMode: 'eval-proxy',
+        shadowSampleCount: 0,
+        deltaSource: 'eval',
+      },
     };
   }
 
@@ -366,6 +382,11 @@ export function evaluatePromotionGate(
       blockers,
       constraintChecks: [],
       deltaCheck: { actual: 0, threshold: minDelta, passed: false },
+      evidenceSummary: {
+        evidenceMode: 'eval-proxy',
+        shadowSampleCount: 0,
+        deltaSource: 'eval',
+      },
     };
   }
 
@@ -496,12 +517,24 @@ export function evaluatePromotionGate(
     suggestedState = 'rejected';
   }
 
+  const evidenceMode =
+    arbiterRejectSource === 'shadow' && executabilityRejectSource === 'shadow'
+      ? 'shadow'
+      : arbiterRejectSource === 'eval-proxy' && executabilityRejectSource === 'eval-proxy'
+        ? 'eval-proxy'
+        : 'mixed';
+
   return {
     passes: allPassed,
     suggestedState,
     blockers,
     constraintChecks,
     deltaCheck,
+    evidenceSummary: {
+      evidenceMode,
+      shadowSampleCount: shadowStats?.totalCount ?? 0,
+      deltaSource: 'eval',
+    },
   };
 }
 

package/src/core/replay-engine.ts

@@ -63,6 +63,15 @@ export interface ReplayReport {
     principleAnchor: ClassificationSummary;
   };
   blockers: string[];
+  evidenceSummary: {
+    evidenceStatus: 'observed' | 'empty';
+    totalSamples: number;
+    classifiedCounts: {
+      painNegative: number;
+      successPositive: number;
+      principleAnchor: number;
+    };
+  };
   generatedAt: string;
   implementationId: string;
   sampleFingerprints: string[];
@@ -432,6 +441,11 @@ export class ReplayEngine {
     const successSummary = toSummary(successPositive);
     const anchorSummary = toSummary(principleAnchor);
     const blockers: string[] = [];
+    const totalSamples = results.length;
+
+    if (totalSamples === 0) {
+      blockers.push('NO REPLAY EVIDENCE: No classified replay samples were available. Report cannot justify promotion-quality conclusions.');
+    }
 
     for (const leak of painSummary.details.filter((result) => !result.passed)) {
       blockers.push(
@@ -459,6 +473,15 @@ export class ReplayEngine {
         principleAnchor: anchorSummary,
       },
       blockers,
+      evidenceSummary: {
+        evidenceStatus: totalSamples > 0 ? 'observed' : 'empty',
+        totalSamples,
+        classifiedCounts: {
+          painNegative: painSummary.total,
+          successPositive: successSummary.total,
+          principleAnchor: anchorSummary.total,
+        },
+      },
       generatedAt: new Date().toISOString(),
       implementationId,
       sampleFingerprints: results.map((result) => result.sampleFingerprint),
@@ -471,6 +494,7 @@ export class ReplayEngine {
     success: ClassificationSummary,
     anchor: ClassificationSummary
   ): 'pass' | 'fail' | 'needs-review' {
+    if (pain.total + success.total + anchor.total === 0) return 'needs-review';
     if (pain.failed > 0) return 'fail';
     if (anchor.failed > 0) return 'fail';
     if (success.failed > 0) return 'needs-review';
@@ -526,6 +550,7 @@ export function formatReplayReport(report: ReplayReport): string {
   output += `Implementation: ${report.implementationId}\n`;
   output += `Generated At:   ${report.generatedAt}\n`;
   output += `Overall Decision: [${decisionEmoji}]\n\n`;
+  output += `Evidence Status: ${report.evidenceSummary.evidenceStatus} (samples=${report.evidenceSummary.totalSamples})\n\n`;
 
   const formatSection = (
     label: string,

package/src/service/subagent-workflow/nocturnal-workflow-manager.ts

@@ -40,7 +40,6 @@ import type { NocturnalSessionSnapshot } from '../../core/nocturnal-trajectory-e
 import type { RecentPainContext } from '../evolution-worker.js';
 import * as fs from 'fs';
 import * as path from 'path';
-import { isSubagentRuntimeAvailable } from '../../utils/subagent-probe.js';
 import { validateNocturnalSnapshotIngress } from '../../core/nocturnal-snapshot-contract.js';
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -173,11 +172,8 @@ export class NocturnalWorkflowManager implements WorkflowManager {
             metadata?: Record<string, unknown>;
         }
     ): Promise<WorkflowHandle> {
-        // #179: Check subagent runtime availability before starting
-        // Other workflow managers (empathy, deep-reflect) have this check
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Reason: TrinityRuntimeAdapter interface doesn't expose api.runtime.subagent, but OpenClawTrinityRuntimeAdapter has it
-        const subagent = (this.runtimeAdapter as any).api?.runtime?.subagent;
-        if (!isSubagentRuntimeAvailable(subagent)) {
+        const runtimeAvailable = this.runtimeAdapter.isRuntimeAvailable();
+        if (!runtimeAvailable) {
             this.logger.warn(`[PD:NocturnalWorkflow] Subagent runtime unavailable, skipping workflow`);
             throw new Error(`NocturnalWorkflowManager: subagent runtime unavailable`);
         }