principles-disciple 1.11.0 → 1.13.0

package/src/core/nocturnal-trinity.ts

@@ -27,11 +27,9 @@
  */
 
 import { randomUUID } from 'crypto';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as url from 'url';
 import type { NocturnalSessionSnapshot } from './nocturnal-trajectory-extractor.js';
 import { computeThinkingModelDelta } from './nocturnal-trajectory-extractor.js';
+import type { TrinityArtificerContext } from './nocturnal-artificer.js';
 import {
   runTournament,
   DEFAULT_SCORING_WEIGHTS,
@@ -45,22 +43,231 @@ import {
 } from './adaptive-thresholds.js';
 
 // ---------------------------------------------------------------------------
-// Role Prompt Loading
+// Embedded Role Prompts
 // ---------------------------------------------------------------------------
+// These prompts are embedded at build time to eliminate file system dependency.
+// Previously loaded from src/agents/*.md at runtime — fragile because esbuild
+// did not copy the agents/ directory into the bundle.
 
-const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
-const AGENTS_DIR = path.join(__dirname, '../agents');
+const NOCTURNAL_DREAMER_PROMPT = `# Nocturnal Dreamer — Candidate Generation
 
-function loadRolePrompt(filename: string): string {
-  const filePath = path.join(AGENTS_DIR, filename);
-  try {
-    return fs.readFileSync(filePath, 'utf-8');
-  } catch {
-    console.warn(`[Trinity] Could not load role prompt: ${filename}`);
-    return '';
+> System prompt for Trinity Dreamer stage.
+> Role: Generate multiple alternative "better decision" candidates from a session snapshot.
+
+## Role
+
+You are a principles analyst specializing in identifying decision alternatives.
+Your task is to analyze a session trajectory and generate **multiple candidate corrections**,
+each representing a different valid approach to the same problem.
+
+## Input
+
+You will receive:
+- A **target principle** (principle ID and description)
+- A **session trajectory snapshot** containing:
+  - Assistant turns (sanitized text, no raw content)
+  - User turns (correction cues only, no raw content)
+  - Tool calls with outcomes and error messages
+  - Pain events and gate blocks
+  - Session metadata
+
+## Task
+
+Analyze the session and generate **2-3 candidate corrections**, each capturing:
+
+1. **The bad decision**: What the agent decided or did that violated the target principle
+2. **The better decision**: What the agent should have done instead (unique per candidate)
+3. **The rationale**: Why this alternative is better
+4. **Confidence**: How confident you are this is a valid alternative (0.0-1.0)
+
+## Output Format
+
+You MUST respond with ONLY a valid JSON object. No markdown, no explanation, no preamble.
+
+{
+  "valid": true,
+  "candidates": [
+    {
+      "candidateIndex": 0,
+      "badDecision": "<what the agent did wrong>",
+      "betterDecision": "<what the agent should have done>",
+      "rationale": "<why this is better>",
+      "confidence": 0.95
+    }
+  ],
+  "generatedAt": "<ISO timestamp>"
+}
+
+## Quality Standards
+
+### Each candidate MUST:
+- Have a candidateIndex that is unique within the candidate list
+- Describe a specific, concrete badDecision (not generic anti-patterns)
+- Propose a specific, actionable betterDecision (contains an action verb)
+- Provide a principle-grounded rationale (explicitly references the principle)
+- Include a confidence score (0.0-1.0, higher = more confident)
+
+### Candidates should DIFFER from each other:
+- Different candidates should represent genuinely different approaches
+- Do not generate candidates with identical betterDecisions
+- Vary the confidence scores to reflect genuine uncertainty
+
+### Candidates must NOT:
+- Contain raw user text or private content
+- Reference non-existent tools or impossible actions
+- Propose vague improvements ("be more careful")
+- Exceed the requested number of candidates
+
+## Validation
+
+If you cannot generate valid candidates (e.g., no clear violation found, insufficient data), respond with:
+
+{
+  "valid": false,
+  "candidates": [],
+  "reason": "<why valid candidates cannot be generated>",
+  "generatedAt": "<ISO timestamp>"
+}`;
+
+const NOCTURNAL_PHILOSOPHER_PROMPT = `# Nocturnal Philosopher — Candidate Evaluation and Ranking
+
+> System prompt for Trinity Philosopher stage.
+> Role: Evaluate Dreamer's candidates and rank them by principle alignment and quality.
+
+## Role
+
+You are a principles analyst specializing in critical evaluation.
+Your task is to evaluate Dreamer's candidate corrections and rank them
+based on principle alignment, specificity, and actionability.
+
+## Input
+
+You will receive:
+- A **target principle** (principle ID and description)
+- **Dreamer's candidates** — a list of alternative corrections to evaluate
+
+## Task
+
+For each candidate, provide:
+1. **Critique**: A principle-grounded assessment of this candidate's strengths and weaknesses
+2. **Principle alignment**: Whether this candidate properly aligns with the target principle
+3. **Score**: Overall quality score (0.0-1.0, higher = better)
+4. **Rank**: Relative ranking among all candidates (1 = best)
+
+Finally, provide an **overall assessment** of the candidate set.
+
+## Output Format
+
+You MUST respond with ONLY a valid JSON object. No markdown, no explanation, no preamble.
+
+{
+  "valid": true,
+  "judgments": [
+    {
+      "candidateIndex": 0,
+      "critique": "<principle-grounded critique>",
+      "principleAligned": true,
+      "score": 0.92,
+      "rank": 1
+    }
+  ],
+  "overallAssessment": "<summary of candidate set quality>",
+  "generatedAt": "<ISO timestamp>"
+}
+
+## Evaluation Criteria
+
+### Score Components (0-1 scale each):
+1. **Principle Alignment** (weight: 0.4) — Does the betterDecision properly reflect the target principle?
+2. **Specificity** (weight: 0.3) — Is badDecision specific? Is betterDecision actionable?
+3. **Actionability** (weight: 0.3) — Does betterDecision describe a specific next step?
+
+### Ranking Rules:
+- Candidates are ranked by score (highest = rank 1)
+- Ties broken by: higher principle alignment, then lower candidateIndex
+
+## Validation
+
+If you cannot judge the candidates, respond with:
+
+{
+  "valid": false,
+  "judgments": [],
+  "overallAssessment": "",
+  "reason": "<why judgment cannot be produced>",
+  "generatedAt": "<ISO timestamp>"
+}`;
+
+const NOCTURNAL_SCRIBE_PROMPT = `# Nocturnal Scribe — Final Artifact Synthesis
+
+> System prompt for Trinity Scribe stage.
+> Role: Synthesize the best candidate into a final structured artifact.
+
+## Role
+
+You are a principles analyst specializing in structured output.
+Your task is to take the top-ranked candidate from Philosopher's evaluation
+and synthesize it into a final decision-point artifact that passes arbiter validation.
+
+## Input
+
+You will receive:
+- A **target principle** (principle ID and description)
+- A **session trajectory snapshot**
+- **Philosopher's judgments** — ranked candidates with critiques
+- **Dreamer's candidates** — the original candidate list
+
+## Task
+
+Select the best candidate (Philosopher's rank 1) and synthesize it into
+a final TrinityDraftArtifact.
+
+## Output Format
+
+You MUST respond with ONLY a valid JSON object. No markdown, no explanation, no preamble.
+
+{
+  "selectedCandidateIndex": 0,
+  "badDecision": "<final bad decision text>",
+  "betterDecision": "<final better decision text>",
+  "rationale": "<final rationale text>",
+  "sessionId": "<source session ID>",
+  "principleId": "<principle ID>",
+  "sourceSnapshotRef": "<snapshot reference>",
+  "telemetry": {
+    "chainMode": "trinity",
+    "dreamerPassed": true,
+    "philosopherPassed": true,
+    "scribePassed": true,
+    "candidateCount": 2,
+    "selectedCandidateIndex": 0,
+    "stageFailures": []
   }
 }
 
+## Validation
+
+If you cannot synthesize an artifact:
+
+{
+  "selectedCandidateIndex": -1,
+  "badDecision": "",
+  "betterDecision": "",
+  "rationale": "",
+  "sessionId": "<source session ID>",
+  "principleId": "<principle ID>",
+  "sourceSnapshotRef": "",
+  "telemetry": {
+    "chainMode": "trinity",
+    "dreamerPassed": true,
+    "philosopherPassed": false,
+    "scribePassed": false,
+    "candidateCount": 2,
+    "selectedCandidateIndex": -1,
+    "stageFailures": ["Philosopher: no valid judgments produced"]
+  }
+}`;
+
 // ---------------------------------------------------------------------------
 // Trinity Runtime Adapter
 // ---------------------------------------------------------------------------
@@ -69,6 +276,7 @@ function loadRolePrompt(filename: string): string {
  * Interface for Trinity stage invocation.
  * Implementations can use real subagent runtimes or stubs.
  */
+/* eslint-disable no-unused-vars -- Reason: interface method params are type signatures, not implementations */
 export interface TrinityRuntimeAdapter {
   /**
    * Invoke the Dreamer stage.
@@ -78,9 +286,9 @@ export interface TrinityRuntimeAdapter {
    * @returns Dreamer output JSON
    */
   invokeDreamer(
-    snapshot: NocturnalSessionSnapshot,
-    principleId: string,
-    maxCandidates: number
+    _snapshot: NocturnalSessionSnapshot,
+    _principleId: string,
+    _maxCandidates: number
   ): Promise<DreamerOutput>;
 
   /**
@@ -90,8 +298,8 @@ export interface TrinityRuntimeAdapter {
    * @returns Philosopher output JSON
    */
   invokePhilosopher(
-    dreamerOutput: DreamerOutput,
-    principleId: string
+    _dreamerOutput: DreamerOutput,
+    _principleId: string
   ): Promise<PhilosopherOutput>;
 
   /**
@@ -105,12 +313,12 @@ export interface TrinityRuntimeAdapter {
    * @returns Scribe draft artifact or null if failed
    */
   invokeScribe(
-    dreamerOutput: DreamerOutput,
-    philosopherOutput: PhilosopherOutput,
-    snapshot: NocturnalSessionSnapshot,
-    principleId: string,
-    telemetry: TrinityTelemetry,
-    config: TrinityConfig
+    _dreamerOutput: DreamerOutput,
+    _philosopherOutput: PhilosopherOutput,
+    _snapshot: NocturnalSessionSnapshot,
+    _principleId: string,
+    _telemetry: TrinityTelemetry,
+    _config: TrinityConfig
   ): Promise<TrinityDraftArtifact | null>;
 
   /**
@@ -119,6 +327,7 @@ export interface TrinityRuntimeAdapter {
    */
   close?(): Promise<void>;
 }
+/* eslint-enable no-unused-vars */
 
 // ---------------------------------------------------------------------------
 // OpenClaw Runtime Adapter
@@ -130,38 +339,40 @@ export interface TrinityRuntimeAdapter {
  * Does NOT depend on OpenClaw internals.
  */
 export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
+  /* eslint-disable no-unused-vars -- Reason: type-level function parameter names are documentation */
   private readonly api: {
     runtime: {
       subagent: {
-        run: (opts: {
+        run: (_opts: {
           sessionKey: string;
           message: string;
           extraSystemPrompt?: string;
           deliver?: boolean;
         }) => Promise<{ runId: string }>;
-        waitForRun: (opts: { runId: string; timeoutMs: number }) => Promise<{
+        waitForRun: (_opts: { runId: string; timeoutMs: number }) => Promise<{
           status: string;
           error?: string;
         }>;
-        getSessionMessages: (opts: {
+        getSessionMessages: (_opts: {
           sessionKey: string;
           limit: number;
         }) => Promise<{
           messages: unknown[];
         }>;
-        deleteSession: (opts: {
+        deleteSession: (_opts: {
           sessionKey: string;
           deleteTranscript?: boolean;
         }) => Promise<void>;
       };
     };
   };
+  /* eslint-enable no-unused-vars */
 
   private readonly stageTimeoutMs: number;
 
   constructor(
     api: OpenClawTrinityRuntimeAdapter['api'],
-    stageTimeoutMs = 180_000
+    stageTimeoutMs = 300_000  // 5 min — increased from 3 min to accommodate slower LLM responses
   ) {
     this.api = api;
     this.stageTimeoutMs = stageTimeoutMs;
@@ -173,7 +384,7 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
     maxCandidates: number
   ): Promise<DreamerOutput> {
     const sessionKey = `agent:main:subagent:ne-dreamer-${randomUUID()}`;
-    const systemPrompt = loadRolePrompt('nocturnal-dreamer.md');
+    const systemPrompt = NOCTURNAL_DREAMER_PROMPT;
 
     const prompt = this.buildDreamerPrompt(snapshot, principleId, maxCandidates);
 
@@ -204,13 +415,13 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
         limit: 5,
       });
 
-      const outputText = this.extractAssistantText(messages.messages as Array<{ role: string; text?: string; content?: string }>);
+      const outputText = this.extractAssistantText(messages.messages as { role: string; text?: string; content?: string }[]);
       return this.parseDreamerOutput(outputText);
     } finally {
       await this.api.runtime.subagent.deleteSession({
         sessionKey,
         deleteTranscript: true,
-      }).catch(() => {});
+      }).catch(() => { /* intentionally empty - fire-and-forget session cleanup */ });
     }
   }
 
@@ -219,7 +430,7 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
     principleId: string
   ): Promise<PhilosopherOutput> {
     const sessionKey = `agent:main:subagent:ne-philosopher-${randomUUID()}`;
-    const systemPrompt = loadRolePrompt('nocturnal-philosopher.md');
+    const systemPrompt = NOCTURNAL_PHILOSOPHER_PROMPT;
 
     const prompt = this.buildPhilosopherPrompt(dreamerOutput, principleId);
 
@@ -251,26 +462,28 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
         limit: 5,
       });
 
-      const outputText = this.extractAssistantText(messages.messages as Array<{ role: string; text?: string; content?: string }>);
+      const outputText = this.extractAssistantText(messages.messages as { role: string; text?: string; content?: string }[]);
       return this.parsePhilosopherOutput(outputText);
     } finally {
       await this.api.runtime.subagent.deleteSession({
         sessionKey,
         deleteTranscript: true,
-      }).catch(() => {});
+      }).catch(() => { /* intentionally empty - fire-and-forget session cleanup */ });
     }
   }
 
+  // eslint-disable-next-line @typescript-eslint/max-params -- Reason: scribe invocation requires all context parameters - refactoring would break API
   async invokeScribe(
     dreamerOutput: DreamerOutput,
     philosopherOutput: PhilosopherOutput,
     snapshot: NocturnalSessionSnapshot,
     principleId: string,
     telemetry: TrinityTelemetry,
-    config: TrinityConfig
+    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars -- Reason: interface requires this param but implementation doesn't use it
+    _config: TrinityConfig
   ): Promise<TrinityDraftArtifact | null> {
     const sessionKey = `agent:main:subagent:ne-scribe-${randomUUID()}`;
-    const systemPrompt = loadRolePrompt('nocturnal-scribe.md');
+    const systemPrompt = NOCTURNAL_SCRIBE_PROMPT;
 
     const prompt = this.buildScribePrompt(dreamerOutput, philosopherOutput, snapshot, principleId);
 
@@ -296,16 +509,17 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
         limit: 5,
       });
 
-      const outputText = this.extractAssistantText(messages.messages as Array<{ role: string; text?: string; content?: string }>);
+      const outputText = this.extractAssistantText(messages.messages as { role: string; text?: string; content?: string }[]);
       return this.parseScribeOutput(outputText, snapshot, principleId, telemetry);
     } finally {
       await this.api.runtime.subagent.deleteSession({
         sessionKey,
         deleteTranscript: true,
-      }).catch(() => {});
+      }).catch(() => { /* intentionally empty - fire-and-forget session cleanup */ });
     }
   }
 
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this -- Reason: interface-required close() with no-op implementation
   async close(): Promise<void> {
     // Nothing to clean up in this implementation
   }
@@ -314,8 +528,9 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
   // Private Helper Methods
   // ---------------------------------------------------------------------------
 
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this -- Reason: pure utility function that doesn't need instance state
   private extractAssistantText(
-    messages: Array<{ role: string; text?: string; content?: string }>
+    messages: { role: string; text?: string; content?: string }[]
   ): string {
     for (let i = messages.length - 1; i >= 0; i--) {
       const msg = messages[i] as { role: string; text?: string; content?: string };
@@ -326,6 +541,7 @@ export class OpenClawTrinityRuntimeAdapter implements TrinityRuntimeAdapter {
     return '';
   }
 
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this -- Reason: pure utility function that doesn't need instance state
   private buildDreamerPrompt(
     snapshot: NocturnalSessionSnapshot,
     principleId: string,
@@ -346,6 +562,7 @@ Please analyze this session and generate ${maxCandidates} candidate corrections.
 Respond with ONLY a valid JSON object matching the DreamerOutput contract.`;
   }
 
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this -- Reason: utility method doesn't require this - pure prompt building function
   private buildPhilosopherPrompt(
     dreamerOutput: DreamerOutput,
     principleId: string
@@ -359,6 +576,7 @@ ${candidatesJson}
 Please evaluate each candidate and rank them by principle alignment, specificity, and actionability. Respond with ONLY a valid JSON object matching the PhilosopherOutput contract.`;
   }
 
+  /* eslint-disable @typescript-eslint/class-methods-use-this, @typescript-eslint/max-params -- Reason: helper function needs all 4 context params and doesn't use instance state */
   private buildScribePrompt(
     dreamerOutput: DreamerOutput,
     philosopherOutput: PhilosopherOutput,
@@ -378,6 +596,7 @@ ${judgmentsJson}
 
 Select the best candidate (Philosopher's rank 1) and synthesize it into a final TrinityDraftArtifact. Respond with ONLY a valid JSON object.`;
   }
+  /* eslint-enable @typescript-eslint/class-methods-use-this, @typescript-eslint/max-params */
 
   private parseDreamerOutput(text: string): DreamerOutput {
     const json = this.extractJson(text);
@@ -475,11 +694,13 @@ Select the best candidate (Philosopher's rank 1) and synthesize it into a final
     }
   }
 
+  // eslint-disable-next-line @typescript-eslint/max-params -- Reason: output parsing requires text + snapshot + principleId + telemetry - refactoring would break API
   private parseScribeOutput(
     text: string,
     snapshot: NocturnalSessionSnapshot,
     principleId: string,
-    telemetry: TrinityTelemetry
+    // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars -- Reason: interface requires this param but implementation doesn't use it
+    _telemetry: TrinityTelemetry
   ): TrinityDraftArtifact | null {
     const json = this.extractJson(text);
     if (!json) {
@@ -519,6 +740,7 @@ Select the best candidate (Philosopher's rank 1) and synthesize it into a final
   /**
    * Extract JSON object from text that may contain markdown code blocks.
    */
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this -- Reason: pure utility function that doesn't need instance state
   private extractJson(text: string): string | null {
     // Try direct parse first
     try {
@@ -529,7 +751,7 @@ Select the best candidate (Philosopher's rank 1) and synthesize it into a final
     }
 
     // Match triple-backtick JSON blocks
-    const codeBlockMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+    const codeBlockMatch = /```(?:json)?\s*\n?([\s\S]*?)\n?```/.exec(text);
     if (codeBlockMatch) {
       const extracted = codeBlockMatch[1].trim();
       try {
@@ -696,6 +918,8 @@ export interface TrinityDraftArtifact {
   thinkingModelDelta?: number;
   /** Reflection quality: gain in planning ratio (-1 to 1) */
   planningRatioGain?: number;
+  /** Optional routing context for a follow-on Artificer stage */
+  artificerContext?: TrinityArtificerContext;
 }
 
 export interface TrinityTelemetry {
@@ -749,19 +973,14 @@ export interface TrinityResult {
   failures: TrinityStageFailure[];
   /** Whether fallback to single-reflector occurred */
   fallbackOccurred: boolean;
+  /** Optional routing context for a follow-on Artificer stage */
+  artificerContext?: TrinityArtificerContext;
 }
 
 // ---------------------------------------------------------------------------
 // Internal Types for Trinity Execution
 // ---------------------------------------------------------------------------
 
-/**
- * Enriched candidate after Philosopher judgment.
- */
-interface EnrichedCandidate extends DreamerCandidate {
-  judgment: PhilosopherJudgment;
-}
-
 // ---------------------------------------------------------------------------
 // Stub Stage Implementations (Phase 2 — no real subagent calls)
 // ---------------------------------------------------------------------------
@@ -781,6 +1000,10 @@ export function invokeStubDreamer(
   const hasPain = snapshot.stats.totalPainEvents > 0;
   const hasGateBlocks = snapshot.stats.totalGateBlocks > 0;
 
+  // #219: Detect fallback data source - stats may be incomplete
+  const isFallback = snapshot._dataSource === 'pain_context_fallback';
+  const fallbackWarning = isFallback ? ' [fallback data: stats may be incomplete]' : '';
+
   const candidates: DreamerCandidate[] = [];
 
   // Generate candidates based on available signals
@@ -879,11 +1102,19 @@ export function invokeStubDreamer(
   // Ensure we don't exceed maxCandidates
   const limitedCandidates = candidates.slice(0, Math.min(candidates.length, maxCandidates));
 
+  // #219: Add fallback warning to rationales if data source is fallback
+  const annotatedCandidates = isFallback
+    ? limitedCandidates.map((c) => ({
+        ...c,
+        rationale: c.rationale + fallbackWarning,
+      }))
+    : limitedCandidates;
+
   return {
-    valid: limitedCandidates.length > 0,
-    candidates: limitedCandidates,
+    valid: annotatedCandidates.length > 0,
+    candidates: annotatedCandidates,
     generatedAt: new Date().toISOString(),
-    reason: limitedCandidates.length === 0 ? 'No signal available for candidate generation' : undefined,
+    reason: annotatedCandidates.length === 0 ? 'No signal available for candidate generation' : undefined,
   };
 }
 
@@ -895,7 +1126,8 @@ export function invokeStubDreamer(
  */
 export function invokeStubPhilosopher(
   dreamerOutput: DreamerOutput,
-  principleId: string
+  // eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars -- Reason: interface requires this param but stub implementation doesn't use it
+  _principleId: string
 ): PhilosopherOutput {
   if (!dreamerOutput.valid || dreamerOutput.candidates.length === 0) {
     return {
@@ -953,7 +1185,7 @@ export function invokeStubPhilosopher(
     j.rank = idx + 1;
   });
 
-  const topJudgment = judgments[0];
+  const [topJudgment] = judgments;
 
   return {
     valid: true,
@@ -969,6 +1201,7 @@ export function invokeStubPhilosopher(
  * In production, this would call the actual Scribe subagent.
  * The stub uses tournament selection (scoring + thresholds) to pick the winner.
  */
+// eslint-disable-next-line @typescript-eslint/max-params -- Reason: stub scribe requires all context parameters - refactoring would break API
 export function invokeStubScribe(
   dreamerOutput: DreamerOutput,
   philosopherOutput: PhilosopherOutput,
@@ -998,7 +1231,7 @@ export function invokeStubScribe(
     return null;
   }
 
-  const winner = tournamentResult.winner;
+  const {winner} = tournamentResult;
 
   // Update telemetry with tournament info
   const updatedTelemetry: TrinityTelemetry = {
@@ -1046,6 +1279,7 @@ export function runTrinity(options: RunTrinityOptions): TrinityResult {
 
   // Stub path: use synchronous stub implementations
   if (config.useStubs) {
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Reason: function is defined later in file but callback order makes this necessary
     return runTrinityWithStubs(snapshot, principleId, config);
   }
 
@@ -1084,6 +1318,7 @@ export async function runTrinityAsync(options: RunTrinityOptions): Promise<Trini
 
   if (config.useStubs) {
     // Stub path: use synchronous stubs
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Reason: function is defined later in file but callback order makes this necessary
     return runTrinityWithStubs(snapshot, principleId, config);
   }
 
@@ -1125,14 +1360,19 @@ export async function runTrinityAsync(options: RunTrinityOptions): Promise<Trini
 
   try {
     // Step 1: Dreamer — generate candidates via real subagent
+    const dreamerStart = Date.now();
+    console.log(`[Trinity] Step 1/3: Invoking Dreamer (principleId=${principleId}, maxCandidates=${config.maxCandidates})`);
     const dreamerOutput = await adapter.invokeDreamer(snapshot, principleId, config.maxCandidates);
+    console.log(`[Trinity] Dreamer completed in ${Date.now() - dreamerStart}ms, valid=${dreamerOutput.valid}, candidates=${dreamerOutput.candidates?.length ?? 0}`);
 
     if (!dreamerOutput.valid || dreamerOutput.candidates.length === 0) {
+      const reason = dreamerOutput.reason ?? 'No valid candidates generated';
+      console.warn(`[Trinity] Dreamer failed: ${reason}`);
       failures.push({
         stage: 'dreamer',
-        reason: dreamerOutput.reason ?? 'No valid candidates generated',
+        reason,
       });
-      telemetry.stageFailures.push(`Dreamer: ${dreamerOutput.reason ?? 'failed'}`);
+      telemetry.stageFailures.push(`Dreamer: ${reason}`);
       return { success: false, telemetry, failures, fallbackOccurred: false };
     }
 
@@ -1140,20 +1380,27 @@ export async function runTrinityAsync(options: RunTrinityOptions): Promise<Trini
     telemetry.candidateCount = dreamerOutput.candidates.length;
 
     // Step 2: Philosopher — rank candidates via real subagent
+    const philosopherStart = Date.now();
+    console.log(`[Trinity] Step 2/3: Invoking Philosopher (${dreamerOutput.candidates.length} candidates)`);
     const philosopherOutput = await adapter.invokePhilosopher(dreamerOutput, principleId);
+    console.log(`[Trinity] Philosopher completed in ${Date.now() - philosopherStart}ms, valid=${philosopherOutput.valid}, judgments=${philosopherOutput.judgments?.length ?? 0}`);
 
     if (!philosopherOutput.valid || philosopherOutput.judgments.length === 0) {
+      const reason = philosopherOutput.reason ?? 'No judgments produced';
+      console.warn(`[Trinity] Philosopher failed: ${reason}`);
       failures.push({
         stage: 'philosopher',
-        reason: philosopherOutput.reason ?? 'No judgments produced',
+        reason,
       });
-      telemetry.stageFailures.push(`Philosopher: ${philosopherOutput.reason ?? 'failed'}`);
+      telemetry.stageFailures.push(`Philosopher: ${reason}`);
       return { success: false, telemetry, failures, fallbackOccurred: false };
     }
 
     telemetry.philosopherPassed = true;
 
     // Step 3: Scribe — synthesize final artifact via real subagent
+    const scribeStart = Date.now();
+    console.log(`[Trinity] Step 3/3: Invoking Scribe (synthesizing artifact)`);
     const draftArtifact = await adapter.invokeScribe(
       dreamerOutput,
       philosopherOutput,
@@ -1162,8 +1409,10 @@ export async function runTrinityAsync(options: RunTrinityOptions): Promise<Trini
       telemetry,
       config
     );
+    console.log(`[Trinity] Scribe completed in ${Date.now() - scribeStart}ms, artifact=${!!draftArtifact}`);
 
     if (!draftArtifact) {
+      console.warn(`[Trinity] Scribe failed: Failed to synthesize artifact from candidates`);
       failures.push({ stage: 'scribe', reason: 'Failed to synthesize artifact from candidates' });
       telemetry.stageFailures.push('Scribe: synthesis failed');
       return { success: false, telemetry, failures, fallbackOccurred: false };
@@ -1171,6 +1420,7 @@ export async function runTrinityAsync(options: RunTrinityOptions): Promise<Trini
 
     telemetry.scribePassed = true;
     telemetry.selectedCandidateIndex = draftArtifact.selectedCandidateIndex;
+    console.log(`[Trinity] Trinity chain completed successfully: selectedCandidateIndex=${draftArtifact.selectedCandidateIndex}`);
 
     if (draftArtifact.telemetry) {
       telemetry.tournamentTrace = draftArtifact.telemetry.tournamentTrace;
@@ -1179,10 +1429,17 @@ export async function runTrinityAsync(options: RunTrinityOptions): Promise<Trini
       telemetry.eligibleCandidateCount = draftArtifact.telemetry.eligibleCandidateCount;
     }
 
-    return { success: true, artifact: draftArtifact, telemetry, failures: [], fallbackOccurred: false };
+    return {
+      success: true,
+      artifact: draftArtifact,
+      telemetry,
+      failures: [],
+      fallbackOccurred: false,
+      artificerContext: draftArtifact.artificerContext,
+    };
   } finally {
     if (adapter.close) {
-      await adapter.close().catch(() => {});
+      await adapter.close().catch(() => { /* intentionally empty - adapter cleanup error ignored */ });
     }
   }
 }
@@ -1280,6 +1537,7 @@ function runTrinityWithStubs(
     telemetry,
     failures: [],
     fallbackOccurred: false,
+    artificerContext: draftArtifact.artificerContext,
   };
 }