principles-disciple 1.11.0 → 1.13.0

package/src/service/evolution-worker.ts

@@ -1,3 +1,4 @@
+/* global NodeJS */
 import * as fs from 'fs';
 import * as path from 'path';
 import { createHash } from 'crypto';
@@ -5,25 +6,155 @@ import type { OpenClawPluginServiceContext, OpenClawPluginApi, PluginLogger } fr
 import { DictionaryService } from '../core/dictionary-service.js';
 import { DetectionService } from '../core/detection-service.js';
 import { ensureStateTemplates } from '../core/init.js';
-import { extractCommonSubstring } from '../utils/nlp.js';
 import { SystemLogger } from '../core/system-logger.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
-import { EventLog } from '../core/event-log.js';
+import type { EventLog } from '../core/event-log.js';
 import { initPersistence, flushAllSessions } from '../core/session-tracker.js';
-import { acquireLockAsync, releaseLock, type LockContext } from '../utils/file-lock.js';
-import { getEvolutionLogger, type EvolutionStage } from '../core/evolution-logger.js';
+import { acquireLockAsync, releaseLock as releaseImportedLock, type LockContext } from '../utils/file-lock.js';
+import { addDiagnosticianTask, completeDiagnosticianTask } from '../core/diagnostician-task-store.js';
+import { getEvolutionLogger } from '../core/evolution-logger.js';
 import type { TaskKind, TaskPriority } from '../core/trajectory-types.js';
 export type { TaskKind, TaskPriority } from '../core/trajectory-types.js';
 import { LockUnavailableError } from '../config/index.js';
 import { checkWorkspaceIdle, checkCooldown } from './nocturnal-runtime.js';
 import { WorkflowStore } from './subagent-workflow/workflow-store.js';
+import type { WorkflowRow } from './subagent-workflow/types.js';
 import { EmpathyObserverWorkflowManager } from './subagent-workflow/empathy-observer-workflow-manager.js';
 import { DeepReflectWorkflowManager } from './subagent-workflow/deep-reflect-workflow-manager.js';
 import { NocturnalWorkflowManager, nocturnalWorkflowSpec } from './subagent-workflow/nocturnal-workflow-manager.js';
+import { createNocturnalTrajectoryExtractor } from '../core/nocturnal-trajectory-extractor.js';
+import { isExpectedSubagentError } from './subagent-workflow/subagent-error-utils.js';
 
 const WORKFLOW_TTL_MS = 5 * 60 * 1000; // 5 minutes default TTL for helper workflows
 import { OpenClawTrinityRuntimeAdapter } from '../core/nocturnal-trinity.js';
 
+// ── Workflow Watchdog ────────────────────────────────────────────────────────
+// Detects stale/orphaned workflows, invalid results, and cleanup failures.
+// Runs every heartbeat cycle, catching bugs like:
+//   #185 — orphaned active workflows
+//   #181 — structurally invalid results (all zeros)
+//   #180/#183 — expired workflows not swept
+//   #182 — unhandled rejections leaving workflows in limbo
+
+interface WatchdogResult {
+  anomalies: number;
+  details: string[];
+}
+
+async function runWorkflowWatchdog(
+  wctx: WorkspaceContext,
+  api: OpenClawPluginApi | null,
+  logger?: PluginLogger,
+): Promise<WatchdogResult> {
+  const details: string[] = [];
+  const now = Date.now();
+  const subagentRuntime = api?.runtime?.subagent;
+  const agentSession = api?.runtime?.agent?.session;
+
+  try {
+    const store = new WorkflowStore({ workspaceDir: wctx.workspaceDir });
+    try {
+      const allWorkflows: WorkflowRow[] = store.listWorkflows();
+
+      // Check 1: Stale active workflows (active > 2x TTL)
+      const staleThreshold = WORKFLOW_TTL_MS * 2;
+      const staleActive = allWorkflows.filter(
+        (wf: WorkflowRow) => wf.state === 'active' && (now - wf.created_at) > staleThreshold,
+      );
+      if (staleActive.length > 0) {
+        for (const wf of staleActive) {
+          const ageMin = Math.round((now - wf.created_at) / 60000);
+          details.push(`stale_active: ${wf.workflow_id} (${wf.workflow_type}, ${ageMin}min old)`);
+          store.updateWorkflowState(wf.workflow_id, 'terminal_error');
+          store.recordEvent(wf.workflow_id, 'watchdog_timeout', 'active', 'terminal_error', `Stale active > ${staleThreshold / 60000}s`, { ageMs: now - wf.created_at });
+
+          // Cleanup session if possible (#188: gateway-safe fallback)
+          if (wf.child_session_key) {
+            try {
+              if (subagentRuntime) {
+                await subagentRuntime.deleteSession({ sessionKey: wf.child_session_key, deleteTranscript: true });
+                logger?.info?.(`[PD:Watchdog] Cleaned up stale session: ${wf.child_session_key}`);
+              } else if (agentSession) {
+                const storePath = agentSession.resolveStorePath();
+                const sessionStore = agentSession.loadSessionStore(storePath, { skipCache: true });
+                const normalizedKey = wf.child_session_key.toLowerCase();
+                if (sessionStore[normalizedKey]) {
+                  delete sessionStore[normalizedKey];
+                  await agentSession.saveSessionStore(storePath, sessionStore);
+                  logger?.info?.(`[PD:Watchdog] Cleaned up stale session via agentSession fallback: ${wf.child_session_key}`);
+                }
+              }
+            } catch (cleanupErr) {
+              const errMsg = String(cleanupErr);
+              if (errMsg.includes('gateway request') && agentSession) {
+                const storePath = agentSession.resolveStorePath();
+                const sessionStore = agentSession.loadSessionStore(storePath, { skipCache: true });
+                const normalizedKey = wf.child_session_key.toLowerCase();
+                if (sessionStore[normalizedKey]) {
+                  delete sessionStore[normalizedKey];
+                  await agentSession.saveSessionStore(storePath, sessionStore);
+                  logger?.info?.(`[PD:Watchdog] Cleaned up stale session via agentSession fallback after gateway error: ${wf.child_session_key}`);
+                }
+              } else {
+                logger?.warn?.(`[PD:Watchdog] Failed to cleanup session ${wf.child_session_key}: ${errMsg}`);
+              }
+            }
+          }
+        }
+      }
+
+      // Check 2: Workflows in terminal_error/expired without cleanup
+      const unclearedTerminal = allWorkflows.filter(
+        (wf: WorkflowRow) => (wf.state === 'terminal_error' || wf.state === 'expired') && wf.cleanup_state === 'pending',
+      );
+      if (unclearedTerminal.length > 0) {
+        details.push(`uncleared_terminal: ${unclearedTerminal.length} workflows (will be swept next cycle)`);
+      }
+
+      // Check 3: Nocturnal workflow result validation (#181 pattern)
+      const nocturnalCompleted = allWorkflows.filter(
+        (wf: WorkflowRow) => wf.workflow_type === 'nocturnal' && wf.state === 'completed',
+      );
+      for (const wf of nocturnalCompleted) {
+        // Check if the metadata snapshot has all zeros (invalid data)
+        try {
+          const meta = JSON.parse(wf.metadata_json) as Record<string, unknown>;
+          const snapshot = meta.snapshot as Record<string, unknown> | undefined;
+          if (snapshot) {
+            // #219: Check for fallback data source (partial stats from pain context)
+            const dataSource = snapshot._dataSource as string | undefined;
+            if (dataSource === 'pain_context_fallback') {
+              details.push(`fallback_snapshot: nocturnal workflow ${wf.workflow_id} uses pain-context fallback (stats may be incomplete)`);
+            }
+            const stats = snapshot.stats as Record<string, number> | undefined;
+            if (stats && stats.totalAssistantTurns === 0 && stats.totalToolCalls === 0 && stats.totalPainEvents === 0 && stats.totalGateBlocks === 0) {
+              details.push(`empty_snapshot: nocturnal workflow ${wf.workflow_id} has all-zero stats`);
+            }
+          }
+        } catch { /* ignore malformed metadata */ }
+      }
+
+      // Summary
+      const stateCounts: Record<string, number> = {};
+      for (const wf of allWorkflows) {
+        stateCounts[wf.state] = (stateCounts[wf.state] || 0) + 1;
+      }
+      const stateSummary = Object.entries(stateCounts).map(([s, c]) => `${s}=${c}`).join(', ');
+      if (details.length === 0) {
+        logger?.debug?.(`[PD:Watchdog] OK — ${allWorkflows.length} workflows (${stateSummary})`);
+      } else {
+        logger?.info?.(`[PD:Watchdog] ${details.length} anomalies — ${allWorkflows.length} workflows (${stateSummary})`);
+      }
+    } finally {
+      store.dispose();
+    }
+  } catch (err) {
+    logger?.warn?.(`[PD:Watchdog] Failed to scan workflows: ${String(err)}`);
+  }
+
+  return { anomalies: details.length, details };
+}
+
 let timeoutId: NodeJS.Timeout | null = null;
 
 /**
@@ -36,7 +167,7 @@ let timeoutId: NodeJS.Timeout | null = null;
  * Old queue items (without taskKind) are migrated to pain_diagnosis for compatibility.
  */
 export type QueueStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'canceled';
-export type TaskResolution = 'marker_detected' | 'auto_completed_timeout' | 'failed_max_retries' | 'canceled' | 'late_marker_principle_created' | 'late_marker_no_principle';
+export type TaskResolution = 'marker_detected' | 'auto_completed_timeout' | 'failed_max_retries' | 'canceled' | 'late_marker_principle_created' | 'late_marker_no_principle' | 'stub_fallback';
 
 /**
  * Recent pain context attached to sleep_reflection tasks.
@@ -123,14 +254,6 @@ interface LegacyEvolutionQueueItem {
     resultRef?: string;
 }
 
-interface PainCandidateEntry {
-    count: number;
-    status: string;
-    firstSeen: string;
-    lastSeen: string;
-    samples: string[];
-}
-
 /**
  * Default values for new V2 fields when migrating legacy items.
  */
@@ -190,15 +313,11 @@ const PAIN_QUEUE_DEDUP_WINDOW_MS = 30 * 60 * 1000;
 
 // P0 fix: File lock constants and helper for queue operations (prevents TOCTOU race)
 export const EVOLUTION_QUEUE_LOCK_SUFFIX = '.lock';
-export const PAIN_CANDIDATES_LOCK_SUFFIX = '.candidates.lock';
 export const LOCK_MAX_RETRIES = 50;
 export const LOCK_RETRY_DELAY_MS = 50;
 export const LOCK_STALE_MS = 30_000;
-const PAIN_CANDIDATE_MAX_SAMPLES = 5;
-const PAIN_CANDIDATE_SAMPLE_LEN = 1000;
-const PAIN_CANDIDATE_FINGERPRINT_HEAD_LEN = 160;
-const PAIN_CANDIDATE_FINGERPRINT_TAIL_LEN = 80;
 
+/* eslint-disable @typescript-eslint/max-params -- Reason: Function requires all parameters for unique task ID generation */
 export function createEvolutionTaskId(
     source: string,
     score: number,
@@ -214,48 +333,7 @@ export function createEvolutionTaskId(
         .substring(0, 8);
 }
 
-function normalizePainCandidateText(text: string): string {
-    return text.replace(/\s+/g, ' ').trim();
-}
-
-export function shouldTrackPainCandidate(text: string): boolean {
-    const normalized = normalizePainCandidateText(text);
-    if (!normalized) return false;
-    if (normalized === 'NO_REPLY') return false;
-
-    // Skip empathy observer payloads: they are classifier telemetry, not user/system pain patterns.
-    if (
-        normalized.startsWith('{')
-        && normalized.endsWith('}')
-        && normalized.includes('"damageDetected"')
-        && normalized.includes('"severity"')
-        && normalized.includes('"confidence"')
-    ) {
-        return false;
-    }
-
-    return true;
-}
-
-export function createPainCandidateFingerprint(text: string): string {
-    const normalized = normalizePainCandidateText(text);
-    const head = normalized.substring(0, PAIN_CANDIDATE_FINGERPRINT_HEAD_LEN);
-    const tail = normalized.slice(-PAIN_CANDIDATE_FINGERPRINT_TAIL_LEN);
-
-    return createHash('md5')
-        .update(`${normalized.length}:${head}:${tail}`)
-        .digest('hex')
-        .substring(0, 8);
-}
-
-export function summarizePainCandidateSample(text: string): string {
-    return normalizePainCandidateText(text).substring(0, PAIN_CANDIDATE_SAMPLE_LEN);
-}
-
-function isPendingPainCandidate(status: string | undefined): boolean {
-    return status === undefined || status === 'pending';
-}
-
+/* eslint-disable no-unused-vars -- Reason: type-level function parameter names in logger union type are documentation */
 export async function acquireQueueLock(resourcePath: string, logger: PluginLogger | { warn?: (message: string) => void; info?: (message: string) => void } | undefined, lockSuffix: string = EVOLUTION_QUEUE_LOCK_SUFFIX): Promise<() => void> {
     try {
         const ctx: LockContext = await acquireLockAsync(resourcePath, {
@@ -264,7 +342,7 @@ export async function acquireQueueLock(resourcePath: string, logger: PluginLogge
             baseRetryDelayMs: LOCK_RETRY_DELAY_MS,
             lockStaleMs: LOCK_STALE_MS,
         });
-        return () => releaseLock(ctx);
+        return () => releaseImportedLock(ctx);
     } catch (error: unknown) {
         const warn = logger?.warn;
         warn?.(`[PD:EvolutionWorker] Failed to acquire lock for ${resourcePath}: ${String(error)}`);
@@ -272,6 +350,7 @@ export async function acquireQueueLock(resourcePath: string, logger: PluginLogge
     }
 }
 
+/* eslint-disable no-unused-vars, @typescript-eslint/max-params -- Reason: type-level function parameter names in logger union type are documentation */
 async function requireQueueLock(resourcePath: string, logger: PluginLogger | { warn?: (message: string) => void; info?: (message: string) => void } | undefined, scope: string, lockSuffix: string = EVOLUTION_QUEUE_LOCK_SUFFIX): Promise<() => void> {
     try {
         return await acquireQueueLock(resourcePath, logger, lockSuffix);
@@ -282,10 +361,11 @@ async function requireQueueLock(resourcePath: string, logger: PluginLogger | { w
 
 export function extractEvolutionTaskId(task: string): string | null {
     if (!task) return null;
-    const match = task.match(/\[ID:\s*([A-Za-z0-9_-]+)\]/);
+    const match = /\[ID:\s*([A-Za-z0-9_-]+)\]/.exec(task);
     return match?.[1] || null;
 }
 
+/* eslint-disable @typescript-eslint/max-params -- Reason: Function requires all parameters for duplicate detection */
 function findRecentDuplicateTask(
     queue: EvolutionQueueItem[],
     source: string,
@@ -293,11 +373,13 @@ function findRecentDuplicateTask(
     now: number,
     reason?: string
 ): EvolutionQueueItem | undefined {
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Reason: function is defined later in file but used in helper for consistency
     const key = normalizePainDedupKey(source, preview, reason);
     return queue.find((task) => {
         if (task.status === 'completed') return false;
         const taskTime = new Date(task.enqueued_at || task.timestamp).getTime();
         if (!Number.isFinite(taskTime) || (now - taskTime) > PAIN_QUEUE_DEDUP_WINDOW_MS) return false;
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define -- Reason: function is defined later in file but used in helper for consistency
         return normalizePainDedupKey(task.source, task.trigger_text_preview || '', task.reason) === key;
     });
 }
@@ -315,7 +397,6 @@ export function purgeStaleFailedTasks(
     queue: EvolutionQueueItem[],
     logger: PluginLogger,
 ): { purged: number; remaining: number; byReason: Record<string, number> } {
-    const beforeCount = queue.length;
     const cutoff = Date.now() - STALE_FAILED_TASK_MAX_AGE_MS;
     const byReason: Record<string, number> = {};
 
@@ -351,6 +432,7 @@ function normalizePainDedupKey(source: string, preview: string, reason?: string)
     return `${source.trim().toLowerCase()}::${preview.trim().toLowerCase()}::${normalizedReason}`;
 }
 
+/* eslint-disable @typescript-eslint/max-params -- Reason: Function requires all parameters for duplicate detection */
 export function hasRecentDuplicateTask(queue: EvolutionQueueItem[], source: string, preview: string, now: number, reason?: string): boolean {
     return !!findRecentDuplicateTask(queue, source, preview, now, reason);
 }
@@ -477,6 +559,7 @@ interface ParsedPainValues {
     traceId: string; sessionId: string; agentId: string;
 }
 
+/* eslint-disable @typescript-eslint/max-params -- Reason: Function requires all parameters for task enqueue */
 async function doEnqueuePainTask(
     wctx: WorkspaceContext, logger: PluginLogger, painFlagPath: string,
     result: WorkerStatusReport['pain_flag'], v: ParsedPainValues,
@@ -496,7 +579,7 @@ async function doEnqueuePainTask(
     try {
         let queue: EvolutionQueueItem[] = [];
         if (fs.existsSync(queuePath)) {
-            try { queue = JSON.parse(fs.readFileSync(queuePath, 'utf8')); } catch {}
+            try { queue = JSON.parse(fs.readFileSync(queuePath, 'utf8')); } catch { /* corrupted queue, treat as empty — safe fallback */ }
         }
         const now = Date.now();
         const dup = findRecentDuplicateTask(queue, v.source, v.preview, now, v.reason);
@@ -561,11 +644,25 @@ async function checkPainFlag(wctx: WorkspaceContext, logger: PluginLogger): Prom
         // Try JSON format first (pain skill structured output)
         // The file may have 'status: queued' and 'task_id: xxx' appended after the JSON object.
         // Extract just the JSON portion by finding the last '}' and parsing up to that point.
+        let parsedAsJson = false;
         try {
             const jsonEndIdx = rawPain.lastIndexOf('}');
             const jsonPortion = jsonEndIdx >= 0 ? rawPain.slice(0, jsonEndIdx + 1) : rawPain;
             const jsonPain = JSON.parse(jsonPortion);
-            if (typeof jsonPain === 'object' && jsonPain !== null && jsonPain.pain_score !== undefined) {
+
+            // Detect if this is a pain flag JSON object: has any of the known pain flag fields
+            const isPainJson = typeof jsonPain === 'object' && jsonPain !== null && (
+                jsonPain.pain_score !== undefined ||
+                jsonPain.score !== undefined ||
+                jsonPain.source !== undefined ||
+                jsonPain.reason !== undefined ||
+                jsonPain.session_id !== undefined ||
+                jsonPain.agent_id !== undefined
+            );
+
+            if (isPainJson) {
+                parsedAsJson = true;
+                // Score resolution: pain_score > score > default 50
                 const jsonScore = typeof jsonPain.pain_score === 'number' ? jsonPain.pain_score :
                                   typeof jsonPain.score === 'number' ? jsonPain.score : 50;
                 const jsonSource = jsonPain.source || 'human';
@@ -593,6 +690,14 @@ async function checkPainFlag(wctx: WorkspaceContext, logger: PluginLogger): Prom
             }
         } catch { /* Not JSON — fall through to KV/Markdown parsing */ }
 
+        // If we successfully parsed JSON but it didn't match pain flag fields,
+        // don't fall through to KV parsing — it's not a valid pain flag
+        if (parsedAsJson) {
+            if (logger) logger.warn('[PD:EvolutionWorker] Pain flag parsed as JSON but missing all expected fields — ignoring');
+            result.skipped_reason = 'invalid_json_format';
+            return result;
+        }
+
         const lines = rawPain.split('\n');
 
         let score = 0;
@@ -605,6 +710,7 @@ async function checkPainFlag(wctx: WorkspaceContext, logger: PluginLogger): Prom
         let agentId = '';
 
         for (const line of lines) {
+            // KV format: "key: value"
             if (line.startsWith('score:')) score = parseInt(line.split(':', 2)[1].trim(), 10) || 0;
             if (line.startsWith('source:')) source = line.split(':', 2)[1].trim();
             if (line.startsWith('reason:')) reason = line.slice('reason:'.length).trim();
@@ -614,12 +720,25 @@ async function checkPainFlag(wctx: WorkspaceContext, logger: PluginLogger): Prom
             if (line.startsWith('session_id:')) sessionId = line.slice('session_id:'.length).trim();
             if (line.startsWith('agent_id:')) agentId = line.slice('agent_id:'.length).trim();
 
+            // Key=Value fallback format: "key=value" (pain skill manual output)
+            // Handles both uppercase (Source=X) and lowercase (source=x) variants
+            if (line.startsWith('Source=') || line.startsWith('source=')) source = line.includes('Source=') ? line.slice('Source='.length).trim() : line.slice('source='.length).trim();
+            if (line.startsWith('Reason=') || line.startsWith('reason=')) reason = line.includes('Reason=') ? line.slice('Reason='.length).trim() : line.slice('reason='.length).trim();
+            if (line.startsWith('Score=') || line.startsWith('score=')) {
+                const scoreStr = line.includes('Score=') ? line.slice('Score='.length).trim() : line.slice('score='.length).trim();
+                score = parseInt(scoreStr, 10) || 0;
+            }
+            if (line.startsWith('Time=') || line.startsWith('time=')) {
+                const timeStr = line.includes('Time=') ? line.slice('Time='.length).trim() : line.slice('time='.length).trim();
+                preview = `Human intervention at ${timeStr}`;
+            }
+
             // Markdown format support (pain skill writes **Source**: xxx format)
-            const mdSource = line.match(/\*\*Source\*\*:\s*(.+)/);
+            const mdSource = /\*\*Source\*\*:\s*(.+)/.exec(line);
             if (mdSource) source = mdSource[1].trim();
-            const mdReason = line.match(/\*\*Reason\*\*:\s*(.+)/);
+            const mdReason = /\*\*Reason\*\*:\s*(.+)/.exec(line);
             if (mdReason) reason = mdReason[1].trim();
-            const mdTime = line.match(/\*\*Time\*\*:\s*(.+)/);
+            const mdTime = /\*\*Time\*\*:\s*(.+)/.exec(line);
             if (mdTime) preview = `Human intervention at ${mdTime[1].trim()}`;
         }
 
@@ -651,6 +770,7 @@ async function checkPainFlag(wctx: WorkspaceContext, logger: PluginLogger): Prom
     return result;
 }
 
+/* eslint-disable @typescript-eslint/max-params -- Reason: Function requires all parameters for queue processing */
 async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogger, eventLog: EventLog, api?: OpenClawPluginApi) {
     const queuePath = wctx.resolve('EVOLUTION_QUEUE');
     if (!fs.existsSync(queuePath)) {
@@ -688,13 +808,14 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
 
         let queueChanged = rawQueue.some(isLegacyQueueItem);
 
-        const config = wctx.config;
+        const {config} = wctx;
         const timeout = config.get('intervals.task_timeout_ms') || (60 * 60 * 1000); // Default 1 hour
 
         // V2: Recover stuck in_progress sleep_reflection tasks.
         // If the worker crashes or the result write-back fails after Phase 1 claimed
         // the task, it stays in_progress indefinitely. Detect via timeout and mark
         // as failed so a fresh task can be enqueued on the next idle cycle.
+        // #214: Also expire the underlying nocturnal workflow to prevent resource leaks.
         for (const task of queue.filter(t => t.status === 'in_progress' && t.taskKind === 'sleep_reflection')) {
             const startedAt = new Date(task.started_at || task.timestamp);
             const age = Date.now() - startedAt.getTime();
@@ -702,16 +823,68 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                 task.status = 'failed';
                 task.completed_at = new Date().toISOString();
                 task.resolution = 'failed_max_retries';
-                task.lastError = `sleep_reflection timed out after ${Math.round(timeout / 60000)} minutes`;
                 task.retryCount = (task.retryCount ?? 0) + 1;
                 queueChanged = true;
-                logger?.warn?.(`[PD:EvolutionWorker] sleep_reflection task ${task.id} timed out after ${Math.round(age / 60000)} minutes, marking as failed`);
+
+                // #219: Fetch real failure reason from workflow events for better diagnostics
+                let detailedError = `sleep_reflection timed out after ${Math.round(timeout / 60000)} minutes`;
+                if (task.resultRef && !task.resultRef.startsWith('trinity-draft')) {
+                    try {
+                        const wfStore = new WorkflowStore({ workspaceDir: wctx.workspaceDir });
+                        const events = wfStore.getEvents(task.resultRef);
+                        // Find the most recent failure event
+                        const failureEvent = events.filter(e => 
+                            e.event_type.includes('failed') || e.event_type.includes('error')
+                        ).pop();
+                        if (failureEvent) {
+                            const payload = failureEvent.payload_json ? JSON.parse(failureEvent.payload_json) : {};
+                            detailedError = `sleep_reflection failed: ${failureEvent.reason}`;
+                            if (payload.skipReason) {
+                                detailedError += ` (skipReason: ${payload.skipReason})`;
+                            }
+                            if (payload.failures && payload.failures.length > 0) {
+                                detailedError += ` | failures: ${payload.failures.slice(0, 3).join(', ')}`;
+                            }
+                        }
+                    } catch (fetchErr) {
+                        logger?.debug?.(`[PD:EvolutionWorker] Could not fetch workflow events for ${task.resultRef}: ${String(fetchErr)}`);
+                    }
+                }
+                task.lastError = detailedError;
+                
+                logger?.warn?.(`[PD:EvolutionWorker] sleep_reflection task ${task.id} timed out after ${Math.round(age / 60000)} minutes, marking as failed. Reason: ${detailedError}`);
                 evoLogger.logCompleted({
                     traceId: task.traceId || task.id,
                     taskId: task.id,
                     resolution: 'manual',
                     durationMs: age,
                 });
+
+                // #214: Expire the underlying nocturnal workflow to prevent resource leak.
+                // The task's resultRef holds the workflowId if one was started.
+                if (task.resultRef && !task.resultRef.startsWith('trinity-draft')) {
+                    try {
+                        const nocturnalMgr = new NocturnalWorkflowManager({
+                            workspaceDir: wctx.workspaceDir,
+                            stateDir: wctx.stateDir,
+                            logger: api?.logger || logger,
+                            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Reason: api is guaranteed non-null in this recovery path where runtimeAdapter is required
+                            runtimeAdapter: new OpenClawTrinityRuntimeAdapter(api!),
+                        });
+                        try {
+                            // Force-expire this specific workflow regardless of TTL
+                            nocturnalMgr.expireWorkflow(
+                                task.resultRef,
+                                `Sleep reflection task ${task.id} timed out after ${Math.round(age / 60000)} min`,
+                            );
+                            logger?.info?.(`[PD:EvolutionWorker] Expired nocturnal workflow ${task.resultRef} for timed-out sleep task ${task.id}`);
+                        } finally {
+                            nocturnalMgr.dispose();
+                        }
+                    } catch (expireErr) {
+                        logger?.warn?.(`[PD:EvolutionWorker] Could not expire nocturnal workflow ${task.resultRef}: ${String(expireErr)}`);
+                    }
+                }
             }
         }
 
@@ -744,24 +917,80 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                                 task.completed_at = new Date().toISOString();
                                 task.resolution = 'marker_detected';
                             } else {
-                                logger.info(`[PD:EvolutionWorker] Creating principle from report for task ${task.id}`);
-                                const principleId = wctx.evolutionReducer.createPrincipleFromDiagnosis({
-                                    painId: task.id,
-                                    painType: task.source === 'Human Intervention' ? 'user_frustration' : 'tool_failure',
-                                    triggerPattern: principle.trigger_pattern,
-                                    action: principle.action,
-                                    source: task.source || 'heartbeat_diagnostician',
-                                    evaluability: principle.evaluability || 'manual_only',
-                                    abstractedPrinciple: principle.abstracted_principle,
-                                });
-                                if (principleId) {
-                                    logger.info(`[PD:EvolutionWorker] Created principle ${principleId} from marker fallback for task ${task.id}`);
+                                // ── Server-side dedup guard (defense against LLM ignoring duplicate check) ──
+                                const existingPrinciples = wctx.evolutionReducer.getActivePrinciples();
+                                let serverDuplicate: string | null = null;
+                                if (existingPrinciples.length > 0) {
+                                    const newTrigger = (principle.trigger_pattern || '').toLowerCase();
+                                    const newAbstracted = (principle.abstracted_principle || '').toLowerCase();
+                                    for (const ep of existingPrinciples) {
+                                        const epTrigger = (ep.trigger || '').toLowerCase();
+                                        const epAbstracted = (ep.abstractedPrinciple || '').toLowerCase();
+                                        const epText = (ep.text || '').toLowerCase();
+
+                                        // Check 1: abstracted principle overlap (>70% keyword match)
+                                        const newKeywords = newAbstracted.split(/\s+/).filter((w: string) => w.length > 3);
+                                        const epKeywords = epAbstracted.split(/\s+/).filter((w: string) => w.length > 3);
+                                        if (newKeywords.length > 0 && epKeywords.length > 0) {
+                                            const overlap = newKeywords.filter((k: string) => epKeywords.includes(k)).length;
+                                            const overlapRatio = overlap / Math.max(newKeywords.length, epKeywords.length);
+                                            if (overlapRatio > 0.7) {
+                                                serverDuplicate = ep.id;
+                                                break;
+                                            }
+                                        }
+
+                                        // Check 2: trigger pattern contains same key terms
+                                        if (newTrigger.length > 10 && epTrigger.length > 10) {
+                                            const sharedTerms = newTrigger.split(/[\s|\\.+*?()[\]{}^$-]+/).filter((t: string) => t.length > 3);
+                                            if (sharedTerms.length > 0 && sharedTerms.every((t: string) => epTrigger.includes(t))) {
+                                                serverDuplicate = ep.id;
+                                                break;
+                                            }
+                                        }
+
+                                        // Check 3: text overlap (LLM often reuses text from existing principle)
+                                        if (epText.length > 20 && newTrigger.length > 20) {
+                                            const sharedPhrases = epText.split(/\s+/).filter(w => w.length > 5);
+                                            const matchCount = sharedPhrases.filter(w => newTrigger.includes(w)).length;
+                                            if (matchCount >= 3) {
+                                                serverDuplicate = ep.id;
+                                                break;
+                                            }
+                                        }
+                                    }
+                                }
+
+                                if (serverDuplicate) {
+                                    logger.info(`[PD:EvolutionWorker] Server-side dedup: new principle overlaps with existing ${serverDuplicate} — skipping creation for task ${task.id}`);
+                                    task.status = 'completed';
+                                    task.completed_at = new Date().toISOString();
+                                    task.resolution = 'marker_detected';
                                 } else {
-                                    logger.warn(`[PD:EvolutionWorker] createPrincipleFromDiagnosis returned null for task ${task.id} (may be duplicate or blacklisted)`);
+                                    logger.info(`[PD:EvolutionWorker] Creating principle from report for task ${task.id}`);
+                                    const principleId = wctx.evolutionReducer.createPrincipleFromDiagnosis({
+                                        painId: task.id,
+                                        painType: task.source === 'Human Intervention' ? 'user_frustration' : 'tool_failure',
+                                        triggerPattern: principle.trigger_pattern,
+                                        action: principle.action,
+                                        source: task.source || 'heartbeat_diagnostician',
+                                        // #212: Default to weak_heuristic so principles are auto-evaluable
+                                        // without requiring full detectorMetadata from the diagnostician.
+                                        evaluability: principle.evaluability || 'weak_heuristic',
+                                        // Review fix: Accept both snake_case and camelCase from LLM output
+                                        detectorMetadata: principle.detector_metadata || principle.detectorMetadata,
+                                        abstractedPrinciple: principle.abstracted_principle,
+                                        coreAxiomId: principle.core_axiom_id || principle.coreAxiomId,
+                                    });
+                                    if (principleId) {
+                                        logger.info(`[PD:EvolutionWorker] Created principle ${principleId} from marker fallback for task ${task.id}`);
+                                    } else {
+                                        logger.warn(`[PD:EvolutionWorker] createPrincipleFromDiagnosis returned null for task ${task.id} (may be duplicate or blacklisted)`);
+                                    }
+                                    task.status = 'completed';
+                                    task.completed_at = new Date().toISOString();
+                                    task.resolution = 'marker_detected';
                                 }
-                                task.status = 'completed';
-                                task.completed_at = new Date().toISOString();
-                                task.resolution = 'marker_detected';
                             }
                         } else {
                             logger.warn(`[PD:EvolutionWorker] Diagnostician report for task ${task.id} missing principle fields — diagnostician did not produce a principle`);
@@ -778,7 +1007,16 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                 task.resolution = 'marker_detected';
                 try {
                     fs.unlinkSync(completeMarker);
-                } catch {}
+                } catch { /* marker may have been deleted already, not critical */ }
+
+                // #190: Clean up diagnostician report file after processing
+                try {
+                    const cleanupReportPath = path.join(wctx.stateDir, `.diagnostician_report_${task.id}.json`);
+                    if (fs.existsSync(cleanupReportPath)) fs.unlinkSync(cleanupReportPath);
+                } catch { /* report may not exist, not critical */ }
+
+                // FIX (#187): Remove the task from the diagnostician task store
+                await completeDiagnosticianTask(wctx.stateDir, task.id);
 
                 // Log to EvolutionLogger
                 const durationMs = task.started_at
@@ -812,14 +1050,14 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
             if (age > timeout) {
                 const timeoutMinutes = Math.round(timeout / 60000);
 
-                const completeMarker = path.join(wctx.stateDir, `.evolution_complete_${task.id}`);
-                const reportPath = path.join(wctx.stateDir, `.diagnostician_report_${task.id}.json`);
+                const timeoutCompleteMarker = path.join(wctx.stateDir, `.evolution_complete_${task.id}`);
+                const timeoutReportPath = path.join(wctx.stateDir, `.diagnostician_report_${task.id}.json`);
 
-                if (fs.existsSync(completeMarker) && fs.existsSync(reportPath)) {
+                if (fs.existsSync(timeoutCompleteMarker) && fs.existsSync(timeoutReportPath)) {
                     if (logger) logger.info(`[PD:EvolutionWorker] Task ${task.id} timed out but marker found — creating principle anyway`);
                     let principleCreated = false;
                     try {
-                        const reportData = JSON.parse(fs.readFileSync(reportPath, 'utf8'));
+                        const reportData = JSON.parse(fs.readFileSync(timeoutReportPath, 'utf8'));
                         const principle = reportData?.principle
                             || reportData?.phases?.principle_extraction?.principle
                             || reportData?.diagnosis_report?.principle
@@ -834,9 +1072,13 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                                     triggerPattern: principle.trigger_pattern,
                                     action: principle.action,
                                     source: task.source || 'heartbeat_diagnostician',
-                                    evaluability: principle.evaluability || 'manual_only',
+                                    // #212: Default to weak_heuristic so principles are auto-evaluable.
+                                    evaluability: principle.evaluability || 'weak_heuristic',
+                                    // Review fix: Accept both snake_case and camelCase from LLM output
+                                    detectorMetadata: principle.detector_metadata || principle.detectorMetadata,
                                     abstractedPrinciple: principle.abstracted_principle,
-                                });
+                                        coreAxiomId: principle.core_axiom_id || principle.coreAxiomId,
+                                    });
                                 if (principleId) {
                                     logger.info(`[PD:EvolutionWorker] Created principle ${principleId} from late marker for task ${task.id}`);
                                     principleCreated = true;
@@ -846,10 +1088,20 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                     } catch (err) {
                         logger.warn(`[PD:EvolutionWorker] Failed to parse late diagnostician report for task ${task.id}: ${String(err)}`);
                     }
-                    try { fs.unlinkSync(completeMarker); } catch {}
+                    try { fs.unlinkSync(completeMarker); } catch { /* marker may not exist, not critical */ }
+                    // #190: Clean up diagnostician report file
+                    try {
+                        const lateReportPath = path.join(wctx.stateDir, `.diagnostician_report_${task.id}.json`);
+                        if (fs.existsSync(lateReportPath)) fs.unlinkSync(lateReportPath);
+                    } catch { /* report may not exist, not critical */ }
                     task.resolution = principleCreated ? 'late_marker_principle_created' : 'late_marker_no_principle';
                 } else {
                     if (logger) logger.info(`[PD:EvolutionWorker] Task ${task.id} auto-completed after ${timeoutMinutes} minute timeout`);
+                    // #190: Clean up diagnostician report file even on timeout (may have been written late)
+                    try {
+                        const autoTimeoutReportPath = path.join(wctx.stateDir, `.diagnostician_report_${task.id}.json`);
+                        if (fs.existsSync(autoTimeoutReportPath)) fs.unlinkSync(autoTimeoutReportPath);
+                    } catch { /* report may not exist, not critical */ }
                     task.resolution = 'auto_completed_timeout';
                 }
 
@@ -892,19 +1144,22 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
         if (pendingTasks.length > 0) {
             // V2: Also sort by priority within same score
             const priorityWeight = { high: 3, medium: 2, low: 1 };
-            const highestScoreTask = pendingTasks.sort((a, b) => {
+            const [highestScoreTask] = pendingTasks.sort((a, b) => {
                 const scoreDiff = b.score - a.score;
                 if (scoreDiff !== 0) return scoreDiff;
                 return (priorityWeight[b.priority] || 2) - (priorityWeight[a.priority] || 2);
-            })[0];
+            });
             const nowIso = new Date().toISOString();
 
             const taskDescription = `Diagnose systemic pain [ID: ${highestScoreTask.id}]. Source: ${highestScoreTask.source}. Reason: ${highestScoreTask.reason}. ` +
                   `Trigger text: "${highestScoreTask.trigger_text_preview || 'N/A'}"`;
 
-            // Prepare HEARTBEAT content first
-            // Use shared diagnostician protocol (consistent with pd-diagnostician skill)
-            const heartbeatPath = wctx.resolve('HEARTBEAT');
+            // Prepare diagnostician task content
+            // FIX (#187): Write diagnostician tasks to .state/diagnostician_tasks.json
+            // instead of HEARTBEAT.md. HEARTBEAT.md is a shared file that gets overwritten
+            // by the main session heartbeat, causing a race condition where the diagnostician
+            // task prompt is lost. The task store is in .state/ which is not modified by
+            // the main session.
             const markerFilePath = path.join(wctx.stateDir, `.evolution_complete_${highestScoreTask.id}`);
             const reportFilePath = path.join(wctx.stateDir, `.diagnostician_report_${highestScoreTask.id}.json`);
 
@@ -935,7 +1190,11 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                         existingPrinciplesRef += `\n\n**Suggested Rules from Existing Principles**:\n${ruleLines.join('\n')}`;
                     }
                 }
-            } catch {}
+            } catch (err) {
+                // #184: Log warning instead of silently swallowing — diagnostician needs
+                // existing principles context for duplicate detection.
+                logger?.warn?.(`[PD:EvolutionWorker] Failed to load active principles for duplicate detection: ${String(err)}`);
+            }
 
             // ── Context Enrichment (CTX-01): Dual-path strategy ──
             // P1: OpenClaw built-in tools (sessions_history) - safe, visibility-limited
@@ -955,8 +1214,8 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                         
                         // Also try to extract failed tool context if this is a tool failure
                         if (highestScoreTask.source === 'tool_failure') {
-                            const toolMatch = highestScoreTask.reason?.match(/Tool ([\w-]+) failed/);
-                            const fileMatch = highestScoreTask.reason?.match(/on (.+?)(?=\s*Error:|$)/i);
+                            const toolMatch = /Tool ([\w-]+) failed/.exec(highestScoreTask.reason);
+                            const fileMatch = /on (.+?)(?=\s*Error:|$)/i.exec(highestScoreTask.reason);
                             if (toolMatch) {
                                 const toolContext = await extractFailedToolContext(
                                     highestScoreTask.session_id,
@@ -997,6 +1256,7 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                 `3. **read_file / search_file_content** — Search codebase`,
                 ``,
                 `**P1 SOP**: sessions_history(sessionKey="agent:${highestScoreTask.agent_id || 'main'}:run:${highestScoreTask.session_id || 'N/A'}", limit=30)`,
+                highestScoreTask.session_id === 'N/A' || !highestScoreTask.session_id ? `\n\n**⚠️ IMPORTANT**: session_id is N/A — P1 sessions_history tool CANNOT be used. You MUST rely on P2 pre-extracted context below, the pain reason, and your own reasoning. Do NOT hallucinate session details.` : '',
                 ``,
                 `## Pre-extracted Context (P2 - JSONL Fallback)`,
                 `If OpenClaw tools cannot access the session (visibility limits),`,
@@ -1018,17 +1278,19 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                 `   The JSON structure MUST match the output format defined in the pd-diagnostician skill.`,
                 `2. Mark the task complete by creating a marker file: ${markerFilePath}`,
                 `   The marker file should contain: "diagnostic_completed: <timestamp>\\noutcome: <summary>"`,
-                `3. Replace this HEARTBEAT.md content with "HEARTBEAT_OK"`,
+                `3. After writing both files, reply with "DIAGNOSTICIAN_DONE: ${highestScoreTask.id}"`,
                 existingPrinciplesRef,
             ].join('\n');
 
-            // Try to write HEARTBEAT.md FIRST
-            // Only mark task as in_progress after successful write to avoid stuck tasks
+            // FIX (#187): Write to diagnostician_tasks.json instead of HEARTBEAT.md
+            // HEARTBEAT.md is a shared file that gets overwritten by the main session
+            // heartbeat, causing a race condition. The task store is in .state/ and is
+            // not modified by the main session.
             try {
-                fs.writeFileSync(heartbeatPath, heartbeatContent, 'utf8');
-                if (logger) logger.info(`[PD:EvolutionWorker] Wrote diagnostician task to HEARTBEAT.md for task ${highestScoreTask.id}`);
+                await addDiagnosticianTask(wctx.stateDir, highestScoreTask.id, heartbeatContent);
+                if (logger) logger.info(`[PD:EvolutionWorker] Wrote diagnostician task to diagnostician_tasks.json for task ${highestScoreTask.id}`);
 
-                // HEARTBEAT write succeeded, now mark task as in_progress
+                // Task store write succeeded, now mark task as in_progress
                 highestScoreTask.task = taskDescription;
                 highestScoreTask.status = 'in_progress';
                 highestScoreTask.started_at = nowIso;
@@ -1058,9 +1320,9 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                     });
                 }
             } catch (heartbeatErr) {
-                // HEARTBEAT write failed - keep task as pending for next cycle retry
-                if (logger) logger.error(`[PD:EvolutionWorker] Failed to write HEARTBEAT.md for task ${highestScoreTask.id}: ${String(heartbeatErr)}. Task will remain pending for next cycle.`);
-                SystemLogger.log(wctx.workspaceDir, 'HEARTBEAT_WRITE_FAILED', `Task ${highestScoreTask.id} HEARTBEAT write failed: ${String(heartbeatErr)}`);
+                // Diagnostician task store write failed - keep task as pending for next cycle retry
+                if (logger) logger.error(`[PD:EvolutionWorker] Failed to write diagnostician task for task ${highestScoreTask.id}: ${String(heartbeatErr)}. Task will remain pending for next cycle.`);
+                SystemLogger.log(wctx.workspaceDir, 'DIAGNOSTICIAN_TASK_WRITE_FAILED', `Task ${highestScoreTask.id} diagnostician task write failed: ${String(heartbeatErr)}`);
             }
         }
 
@@ -1069,14 +1331,24 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
         // then re-acquire the lock to write results. This prevents the long-running
         // nocturnal reflection from blocking all other queue consumers.
         // Safe to return early here because pain_diagnosis was already handled above.
-        const sleepReflectionTasks = queue.filter(t => t.status === 'pending' && t.taskKind === 'sleep_reflection');
+
+        // FIX: Also poll in_progress tasks that were started in a previous cycle.
+        // Previously only 'pending' tasks were filtered, so an in_progress task from
+        // a previous heartbeat cycle would never be re-polled until the 1-hour
+        // stuck task recovery kicked in.
+        const pendingSleepTasks = queue.filter(t => t.status === 'pending' && t.taskKind === 'sleep_reflection');
+        const pollingSleepTasks = queue.filter(t =>
+            t.status === 'in_progress' && t.taskKind === 'sleep_reflection' && t.resultRef && !t.resultRef.startsWith('trinity-draft')
+        );
+        const sleepReflectionTasks = [...pendingSleepTasks, ...pollingSleepTasks];
         if (sleepReflectionTasks.length > 0) {
-            // --- Phase 1: Claim tasks (inside lock) ---
-            for (const sleepTask of sleepReflectionTasks) {
+            // --- Phase 1: Claim only pending tasks (inside lock) ---
+            // in_progress tasks from previous cycles are already claimed, don't re-claim them
+            for (const sleepTask of pendingSleepTasks) {
                 sleepTask.status = 'in_progress';
                 sleepTask.started_at = new Date().toISOString();
             }
-            queueChanged = true;
+            queueChanged = queueChanged || pendingSleepTasks.length > 0;
 
             // Write claimed state (includes any pain changes from above) and release lock
             if (queueChanged) {
@@ -1085,10 +1357,19 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
             releaseLock();
             for (const sleepTask of sleepReflectionTasks) {
                 try {
-                    logger?.info?.(`[PD:EvolutionWorker] Processing sleep_reflection task ${sleepTask.id}`);
+                    // FIX: For in_progress tasks from a previous cycle, just poll the workflow.
+                    // Don't start a new workflow — that was already done when the task was first claimed.
+                    const isPollingTask = !!sleepTask.resultRef && !sleepTask.resultRef.startsWith('trinity-draft');
+
+                    if (isPollingTask) {
+                        logger?.debug?.(`[PD:EvolutionWorker] Polling existing sleep_reflection task ${sleepTask.id} (workflowId: ${sleepTask.resultRef})`);
+                    } else {
+                        logger?.info?.(`[PD:EvolutionWorker] Processing sleep_reflection task ${sleepTask.id}`);
+                    }
 
                     // NOC-14: Use NocturnalWorkflowManager for sleep_reflection tasks
                     // Lazy-create manager (needs runtimeAdapter from api)
+                    // eslint-disable-next-line @typescript-eslint/init-declarations -- assigned in if block, else block continues
                     let nocturnalManager: NocturnalWorkflowManager | undefined;
                     if (api) {
                         nocturnalManager = new NocturnalWorkflowManager({
@@ -1108,57 +1389,142 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                         continue;
                     }
 
-                    // Start workflow via NocturnalWorkflowManager instead of direct executeNocturnalReflectionAsync
-                    // Pass taskId in metadata for correlation
-                    const workflowHandle = await nocturnalManager.startWorkflow(nocturnalWorkflowSpec, {
-                        parentSessionId: `sleep_reflection:${sleepTask.id}`,
-                        workspaceDir: wctx.workspaceDir,
-                        taskInput: {},
-                        metadata: {
-                            snapshot: sleepTask.recentPainContext ? {
+                    // eslint-disable-next-line @typescript-eslint/init-declarations -- assigned in both if/else branches
+                    let workflowId: string;
+
+                    if (isPollingTask) {
+                        // Poll-only path: skip workflow start, use existing workflowId
+                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Reason: isPollingTask flag is only set when resultRef is expected to be present
+                        workflowId = sleepTask.resultRef!;
+                    } else {
+                        // Start workflow via NocturnalWorkflowManager instead of direct executeNocturnalReflectionAsync
+                        // Pass taskId in metadata for correlation
+
+                        // #181: Build a proper snapshot from trajectory.db instead of hardcoded zeros
+                        // eslint-disable-next-line @typescript-eslint/init-declarations -- undefined is valid zero value, assigned conditionally in if/fallback blocks
+                        let snapshotData: Record<string, unknown> | undefined;
+                        if (sleepTask.recentPainContext) {
+                            try {
+                                const extractor = createNocturnalTrajectoryExtractor(wctx.workspaceDir);
+                                const fullSnapshot = extractor.getNocturnalSessionSnapshot(sleepTask.id);
+                                if (fullSnapshot) {
+                                    snapshotData = {
+                                        sessionId: fullSnapshot.sessionId,
+                                        sessionStart: fullSnapshot.startedAt,
+                                        stats: fullSnapshot.stats,
+                                        recentPain: fullSnapshot.painEvents.slice(-5), // last 5
+                                    };
+                                }
+                            } catch (snapErr) {
+                                logger?.warn?.(`[PD:EvolutionWorker] Failed to build trajectory snapshot for ${sleepTask.id}: ${String(snapErr)}`);
+                            }
+                        }
+                        // Fallback: use pain context only if trajectory extractor failed
+                        if (!snapshotData && sleepTask.recentPainContext) {
+                            // #200: Log fallback usage to make data gaps visible
+                            logger?.warn?.(`[PD:EvolutionWorker] Using pain-context fallback for ${sleepTask.id}: trajectory stats unavailable (stats will be partial)`);
+                            snapshotData = {
                                 sessionId: sleepTask.id,
                                 sessionStart: sleepTask.timestamp,
-                                stats: { totalAssistantTurns: 0, totalToolCalls: 0, failureCount: 0, totalPainEvents: sleepTask.recentPainContext.recentPainCount, totalGateBlocks: 0 },
+                                stats: {
+                                    totalAssistantTurns: 0,
+                                    totalToolCalls: 0,
+                                    failureCount: 0,
+                                    totalPainEvents: sleepTask.recentPainContext.recentPainCount,
+                                    totalGateBlocks: 0,
+                                },
                                 recentPain: sleepTask.recentPainContext.mostRecent ? [sleepTask.recentPainContext.mostRecent] : [],
-                            } : undefined,
-                            principleId: 'default',
-                            taskId: sleepTask.id,  // NOC-14: correlation ID for evolution worker
-                        },
-                    });
+                                // #200: Mark data source so downstream can handle appropriately
+                                _dataSource: 'pain_context_fallback',
+                            };
+                        }
+
+                        const workflowHandle = await nocturnalManager.startWorkflow(nocturnalWorkflowSpec, {
+                            parentSessionId: `sleep_reflection:${sleepTask.id}`,
+                            workspaceDir: wctx.workspaceDir,
+                            taskInput: {},
+                            metadata: {
+                                snapshot: snapshotData,
+                                // #205: Remove hardcoded 'default' - let NocturnalTargetSelector choose
+                                // via executeNocturnalReflectionAsync when no principleId is provided
+                                taskId: sleepTask.id,  // NOC-14: correlation ID for evolution worker
+                                // Pass painContext to Selector for principle ranking bias
+                                painContext: sleepTask.recentPainContext,
+                            },
+                        });
 
-                    // Store workflowId on task for polling on subsequent cycles
-                    sleepTask.resultRef = workflowHandle.workflowId;
+                        // Store workflowId on task for polling on subsequent cycles
+                        sleepTask.resultRef = workflowHandle.workflowId;
+                        // eslint-disable-next-line @typescript-eslint/prefer-destructuring -- Reason: workflowId is reassignable outer let - destructuring would shadow
+                        workflowId = workflowHandle.workflowId;
+                    }
 
                     // Workflow is running asynchronously. Check if it completed in this cycle
                     // by polling getWorkflowDebugSummary.
-                    const summary = await nocturnalManager.getWorkflowDebugSummary(workflowHandle.workflowId);
+                    const summary = await nocturnalManager.getWorkflowDebugSummary(workflowId);
                     if (summary) {
                         if (summary.state === 'completed') {
                             sleepTask.status = 'completed';
                             sleepTask.completed_at = new Date().toISOString();
                             sleepTask.resolution = 'marker_detected';
-                            sleepTask.resultRef = summary.metadata?.nocturnalResult ? 'trinity-draft' : workflowHandle.workflowId;
+                            sleepTask.resultRef = summary.metadata?.nocturnalResult ? 'trinity-draft' : workflowId;
                             logger?.info?.(`[PD:EvolutionWorker] sleep_reflection task ${sleepTask.id} workflow completed`);
                         } else if (summary.state === 'terminal_error') {
-                            sleepTask.status = 'failed';
-                            sleepTask.completed_at = new Date().toISOString();
-                            sleepTask.resolution = 'failed_max_retries';
+                            // #208/#209: Classify terminal_error reason before hardcoding to failed.
+                            // The async executeNocturnalReflectionAsync catches subagent errors and
+                            // records them as terminal_error. Without this check, expected errors
+                            // (daemon mode, process isolation) would always become failed_max_retries.
                             const lastEvent = summary.recentEvents[summary.recentEvents.length - 1];
-                            sleepTask.lastError = `Workflow terminal_error: ${lastEvent?.reason ?? 'unknown'}`;
+                            const errorReason = lastEvent?.reason ?? 'unknown';
+                            // #219: Include payload details for better diagnostics
+                            let detailedError = `Workflow terminal_error: ${errorReason}`;
+                            try {
+                                const payload = lastEvent?.payload ?? {};
+                                if (payload.skipReason) {
+                                    detailedError += ` (skipReason: ${payload.skipReason})`;
+                                }
+                                if (payload.failures && Array.isArray(payload.failures) && payload.failures.length > 0) {
+                                    detailedError += ` | failures: ${(payload.failures as string[]).slice(0, 3).join(', ')}`;
+                                }
+                            } catch { /* ignore parse errors */ }
+                            sleepTask.lastError = detailedError;
                             sleepTask.retryCount = (sleepTask.retryCount ?? 0) + 1;
-                            logger?.warn?.(`[PD:EvolutionWorker] sleep_reflection task ${sleepTask.id} workflow failed: ${sleepTask.lastError}`);
+
+                            if (isExpectedSubagentError(errorReason)) {
+                                // #202: Expected subagent unavailability — use stub fallback
+                                sleepTask.status = 'completed';
+                                sleepTask.completed_at = new Date().toISOString();
+                                sleepTask.resolution = 'stub_fallback';
+                                logger?.info?.(`[PD:EvolutionWorker] sleep_reflection task ${sleepTask.id} workflow completed with stub fallback (expected subagent error: ${errorReason})`);
+                            } else {
+                                sleepTask.status = 'failed';
+                                sleepTask.completed_at = new Date().toISOString();
+                                sleepTask.resolution = 'failed_max_retries';
+                                logger?.warn?.(`[PD:EvolutionWorker] sleep_reflection task ${sleepTask.id} workflow failed: ${sleepTask.lastError}`);
+                            }
                         } else {
                             // Workflow still active, keep task in_progress for next cycle
                             logger?.info?.(`[PD:EvolutionWorker] sleep_reflection task ${sleepTask.id} workflow ${summary.state}, will poll again next cycle`);
                         }
                     }
                 } catch (taskErr) {
-                    sleepTask.status = 'failed';
-                    sleepTask.completed_at = new Date().toISOString();
-                    sleepTask.resolution = 'failed_max_retries';
-                    sleepTask.lastError = String(taskErr);
-                    sleepTask.retryCount = (sleepTask.retryCount ?? 0) + 1;
-                    logger?.error?.(`[PD:EvolutionWorker] sleep_reflection task ${sleepTask.id} threw: ${taskErr}`);
+                    // #202: Handle expected subagent unavailability (e.g., process isolation in daemon mode)
+                    // When subagent is unavailable due to gateway running in separate process,
+                    // use stub fallback instead of failing the task.
+                    if (isExpectedSubagentError(taskErr)) {
+                        sleepTask.status = 'completed';
+                        sleepTask.completed_at = new Date().toISOString();
+                        sleepTask.resolution = 'stub_fallback';
+                        sleepTask.lastError = String(taskErr);
+                        logger?.info?.(`[PD:EvolutionWorker] sleep_reflection task ${sleepTask.id} completed with stub fallback (subagent unavailable)`);
+                    } else {
+                        sleepTask.status = 'failed';
+                        sleepTask.completed_at = new Date().toISOString();
+                        sleepTask.resolution = 'failed_max_retries';
+                        sleepTask.lastError = String(taskErr);
+                        sleepTask.retryCount = (sleepTask.retryCount ?? 0) + 1;
+                        logger?.error?.(`[PD:EvolutionWorker] sleep_reflection task ${sleepTask.id} threw: ${taskErr}`);
+                    }
                 }
             }
 
@@ -1238,7 +1604,7 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
 }
 
 async function processDetectionQueue(wctx: WorkspaceContext, api: OpenClawPluginApi, eventLog: EventLog) {
-    const logger = api.logger;
+    const {logger} = api;
     try {
         const funnel = DetectionService.get(wctx.stateDir);
         const queue = funnel.flushQueue();
@@ -1280,8 +1646,7 @@ async function processDetectionQueue(wctx: WorkspaceContext, api: OpenClawPlugin
                         continue;
                     }
                 }
-                // No L3 hit - fall through to track as pain candidate
-                await trackPainCandidate(text, wctx);
+                // No L3 hit — pain candidate tracking removed (D-05)
             }
         }
     } catch (err) {
@@ -1289,108 +1654,10 @@ async function processDetectionQueue(wctx: WorkspaceContext, api: OpenClawPlugin
     }
 }
 
-export async function trackPainCandidate(text: string, wctx: WorkspaceContext) {
-    if (!shouldTrackPainCandidate(text)) return;
-
-    const candidatePath = wctx.resolve('PAIN_CANDIDATES');
-    const releaseLock = await requireQueueLock(candidatePath, console, 'trackPainCandidate', PAIN_CANDIDATES_LOCK_SUFFIX);
-
-    try {
-        let data: { candidates: Record<string, PainCandidateEntry> } = { candidates: {} };
-        if (fs.existsSync(candidatePath)) {
-            try {
-                data = JSON.parse(fs.readFileSync(candidatePath, 'utf8'));
-            } catch (e) {
-                // Keep going with empty data if parse fails, but log it
-                // eslint-disable-next-line no-console
-                console.warn(`[PD:EvolutionWorker] Failed to parse pain candidates: ${String(e)}`);
-            }
-        }
-
-        const fingerprint = createPainCandidateFingerprint(text);
-        const now = new Date().toISOString();
-        if (!data.candidates[fingerprint]) {
-            data.candidates[fingerprint] = { count: 0, status: 'pending', firstSeen: now, lastSeen: now, samples: [] };
-        }
-
-        const cand = data.candidates[fingerprint];
-        cand.status = cand.status || 'pending';
-        cand.count++;
-        cand.lastSeen = now;
-
-        const sample = summarizePainCandidateSample(text);
-        if (cand.samples.length < PAIN_CANDIDATE_MAX_SAMPLES && !cand.samples.includes(sample)) {
-            cand.samples.push(sample);
-        }
-        
-        fs.writeFileSync(candidatePath, JSON.stringify(data, null, 2), 'utf8');
-    } finally {
-        releaseLock();
-    }
-}
-
-export async function processPromotion(wctx: WorkspaceContext, logger: PluginLogger, eventLog: EventLog) {
-    const candidatePath = wctx.resolve('PAIN_CANDIDATES');
-    if (!fs.existsSync(candidatePath)) return;
-
-    const releaseLock = await requireQueueLock(candidatePath, logger, 'processPromotion', PAIN_CANDIDATES_LOCK_SUFFIX);
-
-    try {
-        const config = wctx.config;
-        const dictionary = wctx.dictionary;
-        const data: { candidates: Record<string, PainCandidateEntry> } = JSON.parse(fs.readFileSync(candidatePath, 'utf8'));
-        const countThreshold = config.get('thresholds.promotion_count_threshold') || 3;
-
-        let promotedCount = 0;
-        let changed = false;
-
-        for (const [fingerprint, cand] of Object.entries(data.candidates)) {
-            if (isPendingPainCandidate(cand.status) && cand.count >= countThreshold) {
-                // Normalize undefined status to 'pending'
-                if (cand.status !== 'pending') {
-                    cand.status = 'pending';
-                    changed = true;
-                }
-                const commonPhrases = extractCommonSubstring(cand.samples);
-
-                if (commonPhrases.length > 0) {
-                    const phrase = commonPhrases[0];
-                    const ruleId = `P_PROMOTED_${fingerprint.toUpperCase()}`;
-
-                    if (hasEquivalentPromotedRule(dictionary, phrase)) {
-                        cand.status = 'duplicate';
-                        changed = true;
-                        logger?.info?.(`[PD:EvolutionWorker] Skipping duplicate promoted rule for candidate ${fingerprint}: ${phrase}`);
-                        continue;
-                    }
-
-                    if (logger) logger.info(`[PD:EvolutionWorker] Promoting candidate ${fingerprint} to formal rule: ${ruleId}`);
-                    SystemLogger.log(wctx.workspaceDir, 'RULE_PROMOTED', `Candidate ${fingerprint} promoted to rule ${ruleId}`);
-
-                    dictionary.addRule(ruleId, {
-                        type: 'exact_match',
-                        phrases: [phrase],
-                        severity: config.get('scores.default_confusion') || 35,
-                        status: 'active'
-                    });
-
-                    cand.status = 'promoted';
-                    promotedCount++;
-                    changed = true;
-                }
-            }
-        }
-
-        if (changed) {
-            fs.writeFileSync(candidatePath, JSON.stringify(data, null, 2), 'utf8');
-        }
-    } catch (err) {
-        if (logger) logger.warn(`[PD:EvolutionWorker] Error during rule promotion: ${String(err)}`);
-    } finally {
-        releaseLock();
-    }
-}
+// PAIN_CANDIDATES system removed (D-05, D-06): trackPainCandidate and processPromotion deleted
+// Evolution queue is now the single active pain→principle path
 
+/* eslint-disable no-unused-vars, @typescript-eslint/max-params -- Reason: type-level function parameter names in logger union type and unused workspaceResolve key are documentation/signature */
 export async function registerEvolutionTaskSession(
     workspaceResolve: (key: string) => string,
     taskId: string,
@@ -1403,6 +1670,7 @@ export async function registerEvolutionTaskSession(
     const releaseLock = await requireQueueLock(queuePath, logger, 'registerEvolutionTaskSession');
 
     try {
+        // eslint-disable-next-line @typescript-eslint/init-declarations -- assigned in try, catch has early return
         let rawQueue: RawQueueItem[];
         try {
             rawQueue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
@@ -1442,12 +1710,14 @@ export async function registerEvolutionTaskSession(
  * Production evidence shows directive stopped updating on 2026-03-22 and is stale.
  */
 
+/* eslint-disable no-unused-vars -- Reason: interface method parameters are type signatures */
 export interface ExtendedEvolutionWorkerService {
     id: string;
     api: OpenClawPluginApi | null;
     start: (ctx: OpenClawPluginServiceContext) => void | Promise<void>;
     stop?: (ctx: OpenClawPluginServiceContext) => void | Promise<void>;
 }
+/* eslint-enable no-unused-vars */
 
 interface WorkerStatusReport {
     timestamp: string;
@@ -1462,9 +1732,13 @@ function writeWorkerStatus(stateDir: string, report: WorkerStatusReport): void {
     try {
         const statusPath = path.join(stateDir, 'worker-status.json');
         fs.writeFileSync(statusPath, JSON.stringify(report, null, 2), 'utf8');
-    } catch {}
+    } catch (err) {
+        // Non-critical: worker-status.json is for monitoring, not core logic
+        console.warn(`[PD:EvolutionWorker] Failed to write worker-status.json: ${String(err)}`);
+    }
 }
 
+/* eslint-disable @typescript-eslint/max-params -- Reason: Function requires all parameters for queue processing */
 async function processEvolutionQueueWithResult(
     wctx: WorkspaceContext,
     logger: PluginLogger,
@@ -1480,7 +1754,7 @@ async function processEvolutionQueueWithResult(
             return { queue: queueResult, errors };
         }
 
-        const queue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
+        const queue: EvolutionQueueItem[] = JSON.parse(fs.readFileSync(queuePath, 'utf8')) as EvolutionQueueItem[];
 
         // Purge stale failed tasks before processing (keeps queue lean)
         const purgeResult = purgeStaleFailedTasks(queue, logger);
@@ -1490,10 +1764,10 @@ async function processEvolutionQueueWithResult(
         }
 
         queueResult.total = queue.length;
-        queueResult.pending = queue.filter((t: any) => t.status === 'pending').length;
-        queueResult.in_progress = queue.filter((t: any) => t.status === 'in_progress').length;
-        queueResult.failed_this_cycle = queue.filter((t: any) => t.status === 'failed').length;
-        queueResult.completed_this_cycle = queue.filter((t: any) => t.status === 'completed').length;
+        queueResult.pending = queue.filter((t) => t.status === 'pending').length;
+        queueResult.in_progress = queue.filter((t) => t.status === 'in_progress').length;
+        queueResult.failed_this_cycle = queue.filter((t) => t.status === 'failed').length;
+        queueResult.completed_this_cycle = queue.filter((t) => t.status === 'completed').length;
 
         // Log queue health snapshot every cycle
         logger.info(`[PD:EvolutionWorker] Queue snapshot: total=${queueResult.total} pending=${queueResult.pending} in_progress=${queueResult.in_progress} completed=${queueResult.completed_this_cycle} failed=${queueResult.failed_this_cycle} purged=${purgeResult.purged}`);
@@ -1514,7 +1788,7 @@ export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
 
     start(ctx: OpenClawPluginServiceContext): void {
         const logger = ctx?.logger || console;
-        const api = this.api;
+        const {api} = this;
         const workspaceDir = ctx?.workspaceDir;
 
         if (!workspaceDir) {
@@ -1526,9 +1800,9 @@ export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
         if (logger) logger.info(`[PD:EvolutionWorker] Starting with workspaceDir=${wctx.workspaceDir}, stateDir=${wctx.stateDir}`);
 
         initPersistence(wctx.stateDir);
-        const eventLog = wctx.eventLog;
+        const {eventLog} = wctx;
 
-        const config = wctx.config;
+        const {config} = wctx;
         const language = config.get('language') || 'en';
         ensureStateTemplates({ logger }, wctx.stateDir, language);
 
@@ -1602,17 +1876,19 @@ export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
                 if (api) {
                     await processDetectionQueue(wctx, api, eventLog);
                 }
-                await processPromotion(wctx, logger, eventLog);
+                // processPromotion removed (D-06) — promotion via PAIN_CANDIDATES no longer needed
 
                 try {
                     // Delegate to workflow managers' sweepExpiredWorkflows so that
                     // session/transcript cleanup runs via driver.deleteSession().
                     const subagentRuntime = api?.runtime?.subagent;
+                    const agentSession = api?.runtime?.agent?.session;
                     if (subagentRuntime) {
                         const empathyMgr = new EmpathyObserverWorkflowManager({
                             workspaceDir: wctx.workspaceDir,
                             logger: api.logger,
                             subagent: subagentRuntime,
+                            agentSession,
                         });
                         let swept = 0;
                         try {
@@ -1625,6 +1901,7 @@ export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
                             workspaceDir: wctx.workspaceDir,
                             logger: api.logger,
                             subagent: subagentRuntime,
+                            agentSession,
                         });
                         try {
                             swept += await deepReflectMgr.sweepExpiredWorkflows(WORKFLOW_TTL_MS);
@@ -1632,6 +1909,20 @@ export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
                             deepReflectMgr.dispose();
                         }
 
+                        // #183 + #188: Sweep Nocturnal workflows too (with gateway-safe fallback)
+                        try {
+                            const nocturnalMgr = new NocturnalWorkflowManager({
+                                workspaceDir: wctx.workspaceDir,
+                                stateDir: wctx.stateDir,
+                                logger: api.logger,
+                                runtimeAdapter: new OpenClawTrinityRuntimeAdapter(api),
+                            });
+                            swept += await nocturnalMgr.sweepExpiredWorkflows(WORKFLOW_TTL_MS, subagentRuntime, agentSession);
+                            nocturnalMgr.dispose();
+                        } catch (noctSweepErr) {
+                            logger?.warn?.(`[PD:EvolutionWorker] Nocturnal sweep failed: ${String(noctSweepErr)}`);
+                        }
+
                         if (swept > 0) {
                             logger?.info?.(`[PD:EvolutionWorker] Swept ${swept} expired workflows (with session cleanup)`);
                         }
@@ -1654,6 +1945,19 @@ export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
                     logger?.warn?.(`[PD:EvolutionWorker] ${errMsg}`);
                 }
 
+                // ── Workflow Watchdog: detect stale active workflows ──
+                // This catches bugs like #185 (orphaned active), #181 (empty results),
+                // #180/#183 (expired without cleanup), #182 (unhandled rejection).
+                try {
+                    const watchdogResult = await runWorkflowWatchdog(wctx, api, logger);
+                    if (watchdogResult.anomalies > 0) {
+                        logger?.warn?.(`[PD:Watchdog] ${watchdogResult.anomalies} anomalies: ${watchdogResult.details.join('; ')}`);
+                        cycleResult.errors.push(...watchdogResult.details);
+                    }
+                } catch (watchdogErr) {
+                    logger?.warn?.(`[PD:Watchdog] Watchdog failed: ${String(watchdogErr)}`);
+                }
+
                 wctx.dictionary.flush();
                 flushAllSessions();
 
@@ -1686,7 +1990,7 @@ export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
                 if (api) {
                     await processDetectionQueue(wctx, api, eventLog);
                 }
-                await processPromotion(wctx, logger, eventLog);
+                // processPromotion removed (D-06)
                 timeoutId = setTimeout(runCycle, interval);
             })().catch((err) => {
                 if (logger) logger.error(`[PD:EvolutionWorker] Startup worker cycle failed: ${String(err)}`);