principles-disciple 1.72.0 → 1.74.0

package/src/service/evolution-worker.ts

@@ -12,48 +12,30 @@ import { SystemLogger } from '../core/system-logger.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import type { EventLog } from '../core/event-log.js';
 import { initPersistence, flushAllSessions } from '../core/session-tracker.js';
-import { addDiagnosticianTask, completeDiagnosticianTask, requeueDiagnosticianTask } from '../core/diagnostician-task-store.js';
-import { getEvolutionLogger } from '../core/evolution-logger.js';
 import type { TaskKind, TaskPriority } from '../core/trajectory-types.js';
 import type { PrincipleEvaluability } from '../types/principle-tree-schema.js';
 export type { TaskKind, TaskPriority } from '../core/trajectory-types.js';
 import { atomicWriteFileSync } from '../utils/io.js';
-import { validatePainSignal, type PainSignalValidationResult } from '../core/pain-signal.js';
 
 // Re-export queue I/O (extracted to queue-io.ts)
 export { loadEvolutionQueue, saveEvolutionQueue, withQueueLock, acquireQueueLock, requireQueueLock } from './queue-io.js';
-export { enqueueSleepReflectionTask, enqueueKeywordOptimizationTask } from './queue-io.js';
 export { EVOLUTION_QUEUE_LOCK_SUFFIX, LOCK_MAX_RETRIES, LOCK_RETRY_DELAY_MS, LOCK_STALE_MS } from './queue-io.js';
-import { saveEvolutionQueue, requireQueueLock, hasPendingTask, enqueueSleepReflectionTask, enqueueKeywordOptimizationTask, createEvolutionTaskId } from './queue-io.js';
-import type { RecentPainContext } from './queue-io.js';
-export type { RecentPainContext } from './queue-io.js';
-import { checkWorkspaceIdle, checkCooldown, recordCooldown } from './nocturnal-runtime.js';
-import { loadCooldownEscalationConfig, loadNocturnalConfigMerged } from './nocturnal-config.js';
+import { saveEvolutionQueue, requireQueueLock } from './queue-io.js';
 import { WorkflowStore } from './subagent-workflow/workflow-store.js';
-import { EmpathyObserverWorkflowManager } from './subagent-workflow/empathy-observer-workflow-manager.js';
-import { NocturnalWorkflowManager, nocturnalWorkflowSpec } from './subagent-workflow/nocturnal-workflow-manager.js';
 import {
-    createNocturnalTrajectoryExtractor,
-    type NocturnalPainEvent,
-    type NocturnalSessionSnapshot,
-} from '../core/nocturnal-trajectory-extractor.js';
-import { validateNocturnalSnapshotIngress } from '../core/nocturnal-snapshot-contract.js';
+    WorkflowFunnelLoader,
+    PiAiRuntimeAdapter,
+    CorrectionObserver,
+    AgentScheduler,
+} from '@principles/core/runtime-v2';
+import { KeywordOptimizationService } from './keyword-optimization-service.js';
+import { CorrectionCueLearner } from '../core/correction-cue-learner.js';
+
 import { PrincipleCompiler } from '../core/principle-compiler/index.js';
 import { loadLedger, updatePrinciple } from '../core/principle-tree-ledger.js';
-import { isExpectedSubagentError } from './subagent-workflow/subagent-error-utils.js';
-import { readPainFlagContract } from '../core/pain.js';
-import { CorrectionObserverWorkflowManager, correctionObserverWorkflowSpec } from './subagent-workflow/correction-observer-workflow-manager.js';
 import { findRecentDuplicateTask } from './evolution-dedup.js';
-import type { CorrectionObserverPayload } from './subagent-workflow/correction-observer-types.js';
-import { KeywordOptimizationService } from './keyword-optimization-service.js';
 import { TrajectoryRegistry } from '../core/trajectory.js';
-import { CorrectionCueLearner } from '../core/correction-cue-learner.js';
-import { classifyFailure, type ClassifiableTaskKind } from './failure-classifier.js';
-import { recordPersistentFailure, resetFailureState, isTaskKindInCooldown } from './cooldown-strategy.js';
-import { reconcileStartup } from './startup-reconciler.js';
-import { clearPainFlag } from '../core/pain-lifecycle.js';
 import { WORKFLOW_TTL_MS } from '../config/defaults/runtime.js';
-import { OpenClawTrinityRuntimeAdapter } from '../core/nocturnal-trinity.js';
 
 // ── Queue Event Payload Validation ─────────────────────────────────────────
 
@@ -99,16 +81,15 @@ export type { WatchdogResult };
 let timeoutId: NodeJS.Timeout | null = null;
 
 /**
- * Queue V2 Schema - Supports multiple task kinds while preserving pain_diagnosis semantics.
- *
- * taskKind semantics:
- * - pain_diagnosis: User-adjacent, triggers HEARTBEAT, injects into user prompts
- * - sleep_reflection: Background-only, never injects into user prompts, no HEARTBEAT
+ * Queue V2 Schema - Supports background evolution task kinds.
  *
- * Old queue items (without taskKind) are migrated to pain_diagnosis for compatibility.
+ * Pain diagnosis is Runtime v2 only: after_tool_call / pd pain record ->
+ * PainSignalBridge -> DiagnosticianRunner. EvolutionWorker does not read
+ * .pain_flag or process pain_diagnosis queue items.
  */
+/** @deprecated Use PDTaskStatus from '@principles/core/runtime-v2'. M2 migration will replace this. */
 export type QueueStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'canceled';
-export type TaskResolution = 'marker_detected' | 'auto_completed_timeout' | 'failed_max_retries' | 'runtime_unavailable' | 'canceled' | 'late_marker_principle_created' | 'late_marker_no_principle' | 'stub_fallback' | 'skipped_thin_violation' | 'noise_classified';
+export type TaskResolution = 'marker_detected' | 'auto_completed_timeout' | 'failed_max_retries' | 'runtime_unavailable' | 'canceled' | 'late_marker_principle_created' | 'late_marker_no_principle' | 'stub_fallback' | 'skipped_thin_violation' | 'noise_classified' | 'retired';
 
 export interface EvolutionQueueItem {
     // Core identity
@@ -118,7 +99,7 @@ export interface EvolutionQueueItem {
     source: string;
     traceId?: string;           // Trace ID for linking events across the evolution lifecycle
     
-    // Legacy fields (still used for pain_diagnosis)
+    // Legacy fields kept for existing queue records and background task metadata.
     task?: string;
     score: number;
     reason: string;
@@ -141,12 +122,6 @@ export interface EvolutionQueueItem {
     // V2 result reference
     resultRef?: string;         // V2: reference to result artifact
 
-    // V2: Recent pain context for sleep_reflection tasks
-    // Attaches explicit recent pain signal without merging task kinds.
-    // Used by target selector for ranking bias and context enrichment.
-    recentPainContext?: RecentPainContext;
-
-    /** Trajectory pain_events row ID — set when pain flag includes pain_event_id */
     painEventId?: number;
 }
 
@@ -155,90 +130,7 @@ import { migrateToV2, isLegacyQueueItem, migrateQueueToV2, LegacyEvolutionQueueI
 export { migrateToV2, isLegacyQueueItem, migrateQueueToV2, LegacyEvolutionQueueItem, DEFAULT_TASK_KIND, DEFAULT_PRIORITY, DEFAULT_MAX_RETRIES };
 export type { RawQueueItem };
 
-function isSessionAtOrBeforeTriggerTime(
-    session: { startedAt: string; updatedAt: string },
-    triggerTimeMs: number,
-): boolean {
-    const startedAtMs = new Date(session.startedAt).getTime();
-    const updatedAtMs = new Date(session.updatedAt).getTime();
-    if (!Number.isFinite(triggerTimeMs)) {
-        return true;
-    }
-    if (Number.isFinite(startedAtMs) && startedAtMs > triggerTimeMs) {
-        return false;
-    }
-    if (Number.isFinite(updatedAtMs) && updatedAtMs > triggerTimeMs) {
-        return false;
-    }
-    return true;
-}
-
- 
-function buildFallbackNocturnalSnapshot(
-    sleepTask: EvolutionQueueItem,
-    extractor?: ReturnType<typeof createNocturnalTrajectoryExtractor> | null,
-    logger?: { warn?: (message: string) => void }
-): NocturnalSessionSnapshot | null {
-    const painContext = sleepTask.recentPainContext;
-    if (!painContext) {
-        return null;
-    }
-
-    const fallbackPainEvents: NocturnalPainEvent[] = painContext.mostRecent ? [{
-        source: painContext.mostRecent.source,
-        score: painContext.mostRecent.score,
-        severity: null,
-        reason: painContext.mostRecent.reason,
-        createdAt: painContext.mostRecent.timestamp,
-    }] : [];
-
-    // #246: Try to extract real session stats from trajectory DB for the pain session.
-    // The main path tries getNocturnalSessionSnapshot which returns null when no session
-    // exists. Here we attempt a lighter query via listRecentNocturnalCandidateSessions
-    // to at least get summary counts for the pain-triggering session.
-    let realStats: { totalAssistantTurns: number; totalToolCalls: number; failureCount: number; totalGateBlocks: number } | null = null;
-    if (extractor && painContext.mostRecent?.sessionId) {
-        try {
-            // #246-fix: Use minToolCalls=0 to avoid filtering out sessions with 0 tool calls.
-            // The pain-triggering session may have no tool calls but still be worth tracking.
-            const summaries = extractor.listRecentNocturnalCandidateSessions({ limit: 300, minToolCalls: 0 });
-            const match = summaries.find(s => s.sessionId === painContext.mostRecent?.sessionId);
-            if (match) {
-                realStats = {
-                    totalAssistantTurns: match.assistantTurnCount,
-                    totalToolCalls: match.toolCallCount,
-                    failureCount: match.failureCount,
-                    totalGateBlocks: match.gateBlockCount,
-                };
-            }
-        } catch (err) {
-            // #260: Log extraction failures — silent swallowing makes debugging impossible
-            // and can mask systemic trajectory DB issues.
-            logger?.warn?.(`[PD:EvolutionWorker] Failed to extract real stats for session ${painContext.mostRecent?.sessionId} (falling back to zeros): ${String(err)}`);
-        }
-    }
 
-    return {
-        sessionId: painContext.mostRecent?.sessionId || sleepTask.id,
-        startedAt: sleepTask.timestamp,
-        updatedAt: sleepTask.timestamp,
-        assistantTurns: [],
-        userTurns: [],
-        toolCalls: [],
-        painEvents: fallbackPainEvents,
-        gateBlocks: [],
-        // #268: Empty corrections in fallback path (no trajectory data available)
-        userCorrections: [],
-        stats: {
-            totalAssistantTurns: realStats?.totalAssistantTurns ?? 0,
-            totalToolCalls: realStats?.totalToolCalls ?? 0,
-            failureCount: realStats?.failureCount ?? 0,
-            totalPainEvents: painContext.recentPainCount,
-            totalGateBlocks: realStats?.totalGateBlocks ?? 0,
-        },
-        _dataSource: 'pain_context_fallback',
-    };
-}
 
 // Queue lock constants and requireQueueLock are imported from queue-io.ts
 
@@ -309,294 +201,6 @@ export function hasEquivalentPromotedRule(dictionary: { getAllRules(): Record<st
     });
 }
 
-interface ParsedPainValues {
-    score: number; source: string; reason: string; preview: string;
-    traceId: string; sessionId: string; agentId: string;
-    painEventId?: number;
-}
-
- 
- 
-async function doEnqueuePainTask(
-    wctx: WorkspaceContext, logger: PluginLogger, painFlagPath: string,
-    result: WorkerStatusReport['pain_flag'], v: ParsedPainValues,
-): Promise<WorkerStatusReport['pain_flag']> {
-    result.exists = true;
-    result.score = v.score;
-    result.source = v.source;
-
-    if (v.score < 30) {
-        result.skipped_reason = `score_too_low (${v.score} < 30)`;
-        if (logger) logger.info(`[PD:EvolutionWorker] Pain flag score too low: ${v.score} (source=${v.source})`);
-        return result;
-    }
-
-    // Validate pain signal through TypeBox schema before enqueuing.
-    // Malformed signals are logged and skipped — they never enter the queue.
-    const signalInput = {
-        source: v.source,
-        score: v.score,
-        timestamp: new Date().toISOString(),
-        reason: v.reason,
-        sessionId: v.sessionId ?? undefined,
-        agentId: v.agentId ?? undefined,
-        traceId: v.traceId ?? undefined,
-        triggerTextPreview: v.preview,
-    };
-    const validation: PainSignalValidationResult = validatePainSignal(signalInput);
-    if (!validation.valid) {
-        result.skipped_reason = `invalid_pain_signal (${validation.errors.join('; ')})`;
-        if (logger) logger.warn(`[PD:EvolutionWorker] Pain signal validation failed, skipping enqueue: ${validation.errors.join('; ')}`);
-        SystemLogger.log(wctx.workspaceDir, 'PAIN_SIGNAL_INVALID', `Validation errors: ${validation.errors.join('; ')} | source=${v.source} score=${v.score}`);
-        clearPainFlag(wctx.workspaceDir);
-        return result;
-    }
-
-    const queuePath = wctx.resolve('EVOLUTION_QUEUE');
-    const releaseLock = await requireQueueLock(queuePath, logger, 'checkPainFlag');
-    try {
-        let queue: EvolutionQueueItem[] = [];
-        if (fs.existsSync(queuePath)) {
-            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);
-        if (dup) {
-            fs.appendFileSync(painFlagPath, `\nstatus: queued\ntask_id: ${dup.id}\n`, 'utf8');
-            result.enqueued = true;
-            result.skipped_reason = 'duplicate';
-            if (logger) logger.info(`[PD:EvolutionWorker] Duplicate pain task skipped for source=${v.source} preview=${v.preview || 'N/A'}`);
-            clearPainFlag(wctx.workspaceDir);
-            return result;
-        }
-
-        const taskId = createEvolutionTaskId(v.source, v.score, v.preview, v.reason, now);
-        const nowIso = new Date(now).toISOString();
-        const effectiveTraceId = v.traceId || taskId;
-
-        queue.push({
-            id: taskId, taskKind: 'pain_diagnosis',
-            priority: v.score >= 70 ? 'high' : v.score >= 40 ? 'medium' : 'low',
-            score: v.score, source: v.source, reason: v.reason,
-            trigger_text_preview: v.preview, timestamp: nowIso, enqueued_at: nowIso,
-            status: 'pending', session_id: v.sessionId || undefined,
-            agent_id: v.agentId || undefined, traceId: effectiveTraceId,
-            retryCount: 0, maxRetries: 3,
-            painEventId: v.painEventId,
-        });
-
-        saveEvolutionQueue(queuePath, queue);
-        fs.appendFileSync(painFlagPath, `\nstatus: queued\ntask_id: ${taskId}\n`, 'utf8');
-        result.enqueued = true;
-
-        if (logger) logger.info(`[PD:EvolutionWorker] Enqueued pain task ${taskId} (score=${v.score})`);
-
-        const evoLogger = getEvolutionLogger(wctx.workspaceDir, wctx.trajectory);
-        evoLogger.logQueued({
-            traceId: effectiveTraceId,
-            taskId,
-            score: v.score,
-            source: v.source,
-            reason: v.reason,
-        });
-
-        wctx.trajectory?.recordEvolutionTask?.({
-            taskId,
-            traceId: effectiveTraceId,
-            source: v.source,
-            reason: v.reason,
-            score: v.score,
-            status: 'pending',
-            enqueuedAt: nowIso,
-        });
-    } finally { releaseLock(); }
-    clearPainFlag(wctx.workspaceDir);
-    return result;
-}
-
-async function checkPainFlag(wctx: WorkspaceContext, logger: PluginLogger): Promise<WorkerStatusReport['pain_flag']> {
-    const result: WorkerStatusReport['pain_flag'] = { exists: false, score: null, source: null, enqueued: false, skipped_reason: null };
-    try {
-        const painFlagPath = wctx.resolve('PAIN_FLAG');
-        if (!fs.existsSync(painFlagPath)) return result;
-
-        const rawPain = fs.readFileSync(painFlagPath, 'utf8');
-        const contract = readPainFlagContract(wctx.workspaceDir);
-
-        if (contract.status === 'valid') {
-            const score = parseInt(contract.data.score ?? '0', 10) || 0;
-            const source = contract.data.source ?? 'unknown';
-            const reason = contract.data.reason ?? 'Systemic pain detected';
-            const preview = contract.data.trigger_text_preview ?? '';
-            const isQueued = contract.data.status === 'queued';
-            const traceId = contract.data.trace_id ?? '';
-            const sessionId = contract.data.session_id ?? '';
-            const agentId = contract.data.agent_id ?? '';
-            const painEventIdRaw = contract.data.pain_event_id;
-            const painEventId = painEventIdRaw ? parseInt(painEventIdRaw, 10) : undefined;
-
-            result.exists = true;
-            result.score = score;
-            result.source = source;
-            result.enqueued = isQueued;
-
-            if (isQueued) {
-                result.skipped_reason = 'already_queued';
-                if (logger) logger.info(`[PD:EvolutionWorker] Pain flag already queued (score=${score}, source=${source})`);
-                clearPainFlag(wctx.workspaceDir, painEventId);
-                return result;
-            }
-
-            if (logger) logger.info(`[PD:EvolutionWorker] Detected pain flag (score: ${score}, source: ${source}). Enqueueing evolution task.`);
-            return doEnqueuePainTask(wctx, logger, painFlagPath, result, {
-                score, source, reason, preview, traceId, sessionId, agentId, painEventId,
-            });
-        }
-
-        if (contract.status === 'invalid' && (contract.format === 'kv' || contract.format === 'json' || contract.format === 'invalid_json')) {
-            result.exists = true;
-            result.skipped_reason = `invalid_pain_flag (${contract.missingFields.join(', ') || contract.format})`;
-            if (logger) logger.warn(`[PD:EvolutionWorker] Invalid pain flag skipped: ${result.skipped_reason}`);
-            clearPainFlag(wctx.workspaceDir);
-            return result;
-        }
-
-        // 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);
-
-            // 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';
-                const jsonReason = jsonPain.reason || jsonPain.requested_action || 'Systemic pain detected';
-                const jsonPreview = (jsonPain.symptoms || []).slice(0, 2).join('; ');
-
-                // Check if already queued by looking for 'status: queued' in the full file
-                const alreadyQueued = rawPain.includes('status: queued');
-                if (alreadyQueued) {
-                    result.exists = true;
-                    result.score = jsonScore;
-                    result.source = jsonSource;
-                    result.enqueued = true;
-                    result.skipped_reason = 'already_queued';
-                    if (logger) logger.info(`[PD:EvolutionWorker] Pain flag already queued (score=${jsonScore}, source=${jsonSource})`);
-                    clearPainFlag(wctx.workspaceDir, jsonPain.pain_event_id ? parseInt(jsonPain.pain_event_id, 10) : undefined);
-                    return result;
-                }
-
-                return doEnqueuePainTask(wctx, logger, painFlagPath, result, {
-                    score: jsonScore, source: jsonSource, reason: jsonReason,
-                    preview: jsonPreview, traceId: '',
-                    sessionId: jsonPain.session_id || '',
-                    agentId: jsonPain.agent_id || '',
-                    painEventId: jsonPain.pain_event_id ? parseInt(jsonPain.pain_event_id, 10) : undefined,
-                });
-            }
-        } 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;
-        let source = 'unknown';
-        let reason = 'Systemic pain detected';
-        let preview = '';
-        let isQueued = false;
-        let traceId = '';
-        let sessionId = '';
-        let agentId = '';
-        let painEventId: number | undefined;
-
-        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();
-            if (line.startsWith('trigger_text_preview:')) preview = line.slice('trigger_text_preview:'.length).trim();
-            if (line.startsWith('status: queued')) isQueued = true;
-            if (line.startsWith('trace_id:')) traceId = line.split(':', 2)[1].trim();
-            if (line.startsWith('session_id:')) sessionId = line.slice('session_id:'.length).trim();
-            if (line.startsWith('agent_id:')) agentId = line.slice('agent_id:'.length).trim();
-            if (line.startsWith('pain_event_id:')) {
-                const raw = line.slice('pain_event_id:'.length).trim();
-                painEventId = parseInt(raw, 10) || undefined;
-            }
-
-            // 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 = /\*\*Source\*\*:\s*(.+)/.exec(line);
-            if (mdSource) source = mdSource[1].trim();
-            const mdReason = /\*\*Reason\*\*:\s*(.+)/.exec(line);
-            if (mdReason) reason = mdReason[1].trim();
-            const mdTime = /\*\*Time\*\*:\s*(.+)/.exec(line);
-            if (mdTime) preview = `Human intervention at ${mdTime[1].trim()}`;
-        }
-
-        // Markdown format has no score — default to 50 for human intervention
-        if (score === 0 && source !== 'unknown') score = 50;
-
-        result.exists = true;
-        result.score = score;
-        result.source = source;
-        result.enqueued = isQueued;
-
-        if (isQueued) {
-            result.skipped_reason = 'already_queued';
-            if (logger) logger.info(`[PD:EvolutionWorker] Pain flag already queued (score=${score}, source=${source})`);
-            return result;
-        }
-
-        if (logger) logger.info(`[PD:EvolutionWorker] Detected pain flag (score: ${score}, source: ${source}). Enqueueing evolution task.`);
-
-        return doEnqueuePainTask(wctx, logger, painFlagPath, result, {
-            score, source, reason, preview,
-            traceId, sessionId, agentId, painEventId,
-        });
-
-    } catch (err) {
-        if (logger) logger.warn(`[PD:EvolutionWorker] Error processing pain flag: ${String(err)}`);
-        result.skipped_reason = `error: ${String(err)}`;
-    }
-    return result;
-}
-
 /**
  * Process compilation backfill and retry loop.
  * Phase 1 — Backfill: on first call, scan for old principles (compilationRetryCount === undefined)
@@ -757,7 +361,7 @@ function tryUpdatePrinciple(
     }
 }
 
-async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogger, eventLog: EventLog, api?: OpenClawPluginApi) {
+async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogger, _eventLog?: EventLog, _api?: OpenClawPluginApi) {
     const queuePath = wctx.resolve('EVOLUTION_QUEUE');
     if (!fs.existsSync(queuePath)) {
         logger?.debug?.('[PD:EvolutionWorker] No evolution queue file — nothing to process');
@@ -765,7 +369,6 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
     }
 
     const releaseLock = await requireQueueLock(queuePath, logger, 'processEvolutionQueue');
-    const evoLogger = getEvolutionLogger(wctx.workspaceDir, wctx.trajectory);
     let lockReleased = false;
 
     try {
@@ -792,6 +395,14 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
         // V2: Migrate queue to current schema if needed
         let queue: EvolutionQueueItem[] = migrateQueueToV2(rawQueue) as unknown as EvolutionQueueItem[];
 
+        // Runtime v2 owns pain diagnosis. Drop legacy pain_diagnosis queue items so
+        // EvolutionWorker cannot revive the old .pain_flag -> prompt path.
+        const beforeLegacyPainDrop = queue.length;
+        queue = queue.filter((item) => item.taskKind !== 'pain_diagnosis');
+        if (queue.length < beforeLegacyPainDrop) {
+            logger?.info?.(`[PD:EvolutionWorker] Dropped ${beforeLegacyPainDrop - queue.length} legacy pain_diagnosis queue item(s); use PainSignalBridge/pd pain record`);
+        }
+
         // Validate queue items — filter out malformed entries before processing.
         // Malformed items are logged + skipped; they never crash the evolution cycle.
         const beforeValidation = queue.length;
@@ -803,7 +414,7 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
             if (!item.status || typeof item.status !== 'string') errors.push('missing/invalid status');
             if (!item.taskKind || typeof item.taskKind !== 'string') errors.push('missing/invalid taskKind');
             else {
-                const validTaskKinds = ['pain_diagnosis', 'sleep_reflection', 'model_eval', 'keyword_optimization'];
+                const validTaskKinds = ['model_eval'];
                 if (!validTaskKinds.includes(item.taskKind)) {
                     errors.push(`invalid taskKind value '${item.taskKind}' (expected one of: ${validTaskKinds.join(', ')})`);
                 }
@@ -821,1251 +432,12 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
             logger?.info?.(`[PD:EvolutionWorker] Filtered ${beforeValidation - queue.length} malformed queue item(s)`);
         }
 
-        let queueChanged = rawQueue.some(isLegacyQueueItem) || queue.length < beforeValidation;
-
-        // Guard: Skip keyword_optimization if one is already pending/in-progress (CORR-08)
-        if (hasPendingTask(queue, 'keyword_optimization')) {
-            logger?.debug?.('[PD:EvolutionWorker] keyword_optimization task already pending/in-progress, skipping enqueue');
-        }
-
-        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();
-            if (age > timeout) {
-                task.status = 'failed';
-                task.completed_at = new Date().toISOString();
-                task.resolution = 'failed_max_retries';
-                task.retryCount = (task.retryCount ?? 0) + 1;
-                queueChanged = true;
-
-                // #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 = validateQueueEventPayload(failureEvent.payload_json);
-                            detailedError = `sleep_reflection failed: ${failureEvent.reason}`;
-                            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 (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,
-                             
-                            runtimeAdapter: new OpenClawTrinityRuntimeAdapter(api!),
-                            subagent: api?.runtime?.subagent,
-                        });
-                        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)}`);
-                    }
-                }
-            }
-        }
-
-        // Check in_progress tasks for completion (only pain_diagnosis gets HEARTBEAT treatment)
-        // Diagnostician runs via HEARTBEAT (main session LLM), not as a subagent.
-        // Marker file detection is the ONLY completion path for HEARTBEAT diagnostics.
-        for (const task of queue.filter(t => t.status === 'in_progress' && t.taskKind === 'pain_diagnosis')) {
-            const startedAt = new Date(task.started_at || task.timestamp);
-
-            // Condition 1: Check for marker file (created by diagnostician on completion)
-            const completeMarker = path.join(wctx.stateDir, `.evolution_complete_${task.id}`);
-            if (fs.existsSync(completeMarker)) {
-                if (logger) logger.info(`[PD:EvolutionWorker] Task ${task.id} completed - marker file detected`);
-
-                let principlesGenerated = 0;
-                // C: Track report success for event recording
-                // FIX: Use reportParsed flag so reportSuccess=false when JSON is missing/garbled
-                let reportSuccess = false;
-                let reportParsed = false;
-                // Create principle from the diagnostician's JSON report.
-                const reportPath = path.join(wctx.stateDir, `.diagnostician_report_${task.id}.json`);
-                if (fs.existsSync(reportPath)) {
-                    try {
-                        const raw = fs.readFileSync(reportPath, 'utf8');
-                        if (!raw || raw.trim().length === 0) {
-                            throw new Error('Report file is empty');
-                        }
-                        const reportData = JSON.parse(raw);
-                        if (!reportData) {
-                            throw new Error('JSON parsed but content is null/undefined');
-                        }
-                        // Report is valid JSON — mark as parsed
-                        reportParsed = true;
-
-                        // FIX: Validate phase completeness before accepting the report
-                        // A report missing critical phases is considered failed (not silently accepted).
-                        // The diagnostician must produce all 4 diagnostic phases.
-                        const phases = reportData?.phases || reportData?.diagnosis_report?.phases || {};
-                        const requiredPhases = [
-                            'evidence_gathering',
-                            'causal_chain',
-                            'root_cause_classification',
-                            'principle_extraction',
-                        ];
-                        const presentPhases = requiredPhases.filter(p =>
-                            phases && Object.keys(phases).length > 0 && phases[p]
-                        );
-                        if (presentPhases.length < requiredPhases.length) {
-                            const missing = requiredPhases.filter(p => !phases[p]);
-                            if (logger) logger.warn(`[PD:EvolutionWorker] Report for task ${task.id} incomplete — missing phases: ${missing.join(', ')} (present: ${presentPhases.length}/${requiredPhases.length})`);
-                            // PD-FUNNEL-1.1: Record incomplete_fields event BEFORE retry so funnel can see it.
-                            // The phase-completeness check requeues incomplete reports with continue; without
-                            // this record the funnel would have no signal for JSON-present-but-incomplete cases.
-                            if (eventLog) {
-                                eventLog.recordDiagnosticianReport({
-                                    taskId: task.id,
-                                    reportPath,
-                                    category: 'incomplete_fields',
-                                });
-                            }
-                            // Treat as retryable failure: don't mark success, let retry logic kick in
-                            reportParsed = false;
-                            // Also delete the incomplete marker so next heartbeat re-runs the diagnostician
-                            try { fs.unlinkSync(completeMarker); } catch { /* ignore if already gone */ }
-                            task.status = 'pending';
-                            task.resolution = undefined;
-                            queueChanged = true;
-                            continue;
-                        }
-
-                        // ── Step 3: Noise Classification Filter ──
-                        // Skip principle creation for low-value noise categories that don't represent
-                        // systemic failures or behavioral issues worth encoding as principles.
-                        const classification = reportData?.classification;
-                        const noiseCategories: Record<string, boolean> = {
-                            'development_transient': true, // CRLF drift, duplicate match, self-resolved dev issues
-                            'user_error': true,           // User mistakes, wrong file, bad input
-                        };
-                        if (classification?.category && noiseCategories[classification.category]) {
-                            if (logger) logger.info(`[PD:EvolutionWorker] Skipping principle for noise category "${classification.category}" — pain was ${classification.severity || 'low'} severity, not a systemic failure`);
-                            task.status = 'completed';
-                            task.completed_at = new Date().toISOString();
-                            task.resolution = 'noise_classified';
-                        } else {
-                        // Check ALL known nesting paths — matches subagent.ts parseDiagnosticianReport
-                        const principle = reportData?.principle
-                            || reportData?.phases?.principle_extraction?.principle
-                            || reportData?.diagnosis_report?.principle
-                            || reportData?.diagnosis_report?.phases?.principle_extraction?.principle;
-                        if (principle?.trigger_pattern && principle?.action) {
-                            // Check for duplicate principle (diagnostician may output existing principle)
-                            if (principle.duplicate === true) {
-                                logger.info(`[PD:EvolutionWorker] Diagnostician marked principle as duplicate: ${principle.duplicate_of || 'unknown'} — skipping creation for task ${task.id}`);
-                                task.status = 'completed';
-                                task.completed_at = new Date().toISOString();
-                                task.resolution = 'marker_detected';
-                            } else {
-                                // ── 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.info(`[PD:EvolutionWorker] Creating principle from report for task ${task.id}`);
-                                    const principleId = wctx.evolutionReducer.createPrincipleFromDiagnosis({
-                                        painId: task.painEventId !== undefined ? String(task.painEventId) : 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}`);
-                                        principlesGenerated = 1;
-                                        // C: Record principle_candidate_created event for observability
-                                        if (eventLog) {
-                                            eventLog.recordPrincipleCandidate({
-                                                principleId,
-                                                taskId: task.id,
-                                                source: 'diagnostician',
-                                            });
-                                        }
-                                    } 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';
-                                }
-                            }
-                        } else {
-                            logger.warn(`[PD:EvolutionWorker] Diagnostician report for task ${task.id} missing principle fields — diagnostician did not produce a principle`);
-                        }
-                        }
-                    } catch (err) {
-                        logger.warn(`[PD:EvolutionWorker] Failed to parse diagnostician report for task ${task.id}: ${String(err)}`);
-                    }
-                    // FIX: Only mark success if JSON was actually parsed and non-empty
-                    // If JSON was missing, garbled, or empty — reportSuccess stays false
-                    reportSuccess = reportParsed;
-                } else {
-                    // ── #366: Marker exists but JSON report missing — retry logic ──
-                    // Do NOT mark completed yet. Re-inject the task for the next heartbeat cycle.
-                    // Read retry count from marker file content.
-                    const MAX_REPORT_MISSING_RETRIES = 3;
-                    let markerRetries = 0;
-                    try {
-                        const markerContent = fs.readFileSync(completeMarker, 'utf8');
-                        const match = markerContent.match(/report_missing_retries:(\d+)/);
-                        if (match) markerRetries = parseInt(match[1], 10);
-                    } catch { /* marker may not be readable, use 0 */ }
-
-                    if (markerRetries < MAX_REPORT_MISSING_RETRIES) {
-                        // Re-inject: keep task in queue (don't mark completed), update marker with incremented count
-                        const newRetries = markerRetries + 1;
-                        if (logger) logger.info(`[PD:EvolutionWorker] Task ${task.id}: marker found but report missing — re-queuing (retry ${newRetries}/${MAX_REPORT_MISSING_RETRIES})`);
-                        // FIX: Update store's reportMissingRetries BEFORE deleting the marker.
-                        // This ensures the store's retry count is persisted even if the
-                        // diagnostician session crashes before re-adding the task.
-                        await requeueDiagnosticianTask(wctx.stateDir, task.id, MAX_REPORT_MISSING_RETRIES);
-                        // Also update the task in the main queue to keep it alive
-                        task.status = 'pending';
-                        task.resolution = undefined;
-                        queueChanged = true;
-                        // Delete the marker so the next heartbeat sees no marker
-                        // and re-processes the task as a fresh diagnostician run.
-                        try {
-                            fs.unlinkSync(completeMarker);
-                        } catch { /* ignore if already deleted */ }
-                        // Skip the completion/unlink block below — task is still pending
-                        continue;
-                    } else {
-                        // Max retries reached — accept that no report was produced
-                        if (logger) logger.warn(`[PD:EvolutionWorker] Task ${task.id}: max retries (${MAX_REPORT_MISSING_RETRIES}) reached — marking as failed_max_retries`);
-                        task.status = 'completed';
-                        task.completed_at = new Date().toISOString();
-                        task.resolution = 'failed_max_retries';
-                    }
-                }
-
-                // Only reached if JSON existed or max retries reached:
-                task.status = task.status || 'completed';
-                task.completed_at = task.completed_at || new Date().toISOString();
-                if (!task.resolution) task.resolution = 'marker_detected';
-                try {
-                    fs.unlinkSync(completeMarker);
-                } 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);
-
-                // C: Record diagnostician_report event for observability
-                if (eventLog) {
-                    // Map to three-state category:
-                    // - reportSuccess=true → 'success' (JSON exists, parsed, principle found)
-                    // - reportSuccess=false, reportParsed=true → 'incomplete_fields' (JSON existed but principle missing)
-                    // - reportSuccess=false, reportParsed=false → 'missing_json' (JSON never existed)
-                    const reportCategory: 'success' | 'missing_json' | 'incomplete_fields' =
-                        reportSuccess ? 'success' : reportParsed ? 'incomplete_fields' : 'missing_json';
-                    eventLog.recordDiagnosticianReport({
-                        taskId: task.id,
-                        reportPath,
-                        category: reportCategory,
-                    });
-                }
-
-                // Log to EvolutionLogger
-                const durationMs = task.started_at
-                    ? Date.now() - new Date(task.started_at).getTime()
-                    : undefined;
-                evoLogger.logCompleted({
-                    traceId: task.traceId || task.id,
-                    taskId: task.id,
-                    resolution: task.resolution as 'marker_detected' | 'auto_completed_timeout' | 'manual' | 'late_marker_principle_created' | 'late_marker_no_principle' | 'diagnostician_timeout',
-                    durationMs,
-                    principlesGenerated,
-                });
-
-                // Record task completion in event stats
-                eventLog.recordEvolutionTaskCompleted({
-                    taskId: task.id,
-                    taskType: task.source || 'unknown',
-                    reason: task.reason || '',
-                });
-
-                // Update evolution_tasks table
-                wctx.trajectory?.updateEvolutionTask?.(task.id, {
-                    status: 'completed',
-                    completedAt: task.completed_at,
-                    resolution: task.resolution as 'marker_detected' | 'auto_completed_timeout' | 'manual' | 'late_marker_principle_created' | 'late_marker_no_principle' | 'diagnostician_timeout',
-                });
-
-                wctx.trajectory?.recordTaskOutcome({
-                    sessionId: task.assigned_session_key || 'heartbeat:diagnostician',
-                    taskId: task.id,
-                    outcome: 'ok',
-                    summary: `Task ${task.id} completed — ${principlesGenerated} principle(s) generated (${task.resolution}).`
-                });
-                queueChanged = true;
-                continue;
-            }
-
-            const age = Date.now() - startedAt.getTime();
-            if (age > timeout) {
-                const timeoutMinutes = Math.round(timeout / 60000);
-
-                const timeoutCompleteMarker = path.join(wctx.stateDir, `.evolution_complete_${task.id}`);
-                const timeoutReportPath = path.join(wctx.stateDir, `.diagnostician_report_${task.id}.json`);
-
-                let principlesGenerated = 0;
-
-
-                if (fs.existsSync(timeoutCompleteMarker) && fs.existsSync(timeoutReportPath)) {
-                    if (logger) logger.info(`[PD:EvolutionWorker] Task ${task.id} timed out but marker found — creating principle anyway`);
-                    try {
-                        const reportData = JSON.parse(fs.readFileSync(timeoutReportPath, 'utf8'));
-                        const principle = reportData?.principle
-                            || reportData?.phases?.principle_extraction?.principle
-                            || reportData?.diagnosis_report?.principle
-                            || reportData?.diagnosis_report?.phases?.principle_extraction?.principle;
-                        if (principle?.trigger_pattern && principle?.action) {
-                            if (principle.duplicate === true) {
-                                logger.info(`[PD:EvolutionWorker] Diagnostician marked principle as duplicate: ${principle.duplicate_of || 'unknown'} — skipping for task ${task.id}`);
-                            } else {
-                                const principleId = wctx.evolutionReducer.createPrincipleFromDiagnosis({
-                                    painId: task.painEventId !== undefined ? String(task.painEventId) : 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.
-                                    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}`);
-                                    principlesGenerated = 1;
-                                }
-                            }
-                        }
-                    } catch (err) {
-                        logger.warn(`[PD:EvolutionWorker] Failed to parse late diagnostician report for task ${task.id}: ${String(err)}`);
-                    }
-                    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 = principlesGenerated > 0 ? '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';
-                }
-
-                // Critical: mark task as completed so it doesn't get re-processed
-                task.status = 'completed';
-                task.completed_at = new Date().toISOString();
-
-                // Log to EvolutionLogger - use task.resolution, not hardcoded value
-                evoLogger.logCompleted({
-                    traceId: task.traceId || task.id,
-                    taskId: task.id,
-                    resolution: task.resolution,
-                    durationMs: age,
-                    principlesGenerated,
-                });
-
-                // Record task completion in event stats (for timeout path too)
-                eventLog.recordEvolutionTaskCompleted({
-                    taskId: task.id,
-                    taskType: task.source || 'unknown',
-                    reason: task.reason || '',
-                });
-
-                // Update evolution_tasks table - use task.resolution, not hardcoded value
-                wctx.trajectory?.updateEvolutionTask?.(task.id, {
-                    status: 'completed',
-                    completedAt: task.completed_at,
-                    resolution: task.resolution,
-                });
-
-                wctx.trajectory?.recordTaskOutcome({
-                    sessionId: task.assigned_session_key || 'heartbeat:diagnostician',
-                    taskId: task.id,
-                    outcome: 'timeout',
-                    summary: `Task ${task.id} completed — ${principlesGenerated} principle(s) generated (${task.resolution}).`
-                });
-                queueChanged = true;
-            }
-        }
-
-        // V2: Process pain_diagnosis tasks FIRST (quick, inside lock),
-        // then sleep_reflection tasks (slow, lock released during execution).
-        // This order ensures pain tasks are never starved by long-running
-        // nocturnal reflection — sleep_reflection can safely return early
-        // because pain_diagnosis has already been handled.
-        const pendingTasks = queue.filter(t => t.status === 'pending' && t.taskKind === 'pain_diagnosis');
-
-        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 scoreDiff = b.score - a.score;
-                if (scoreDiff !== 0) return scoreDiff;
-                return (priorityWeight[b.priority] || 2) - (priorityWeight[a.priority] || 2);
-            });
-            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 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`);
-
-            let existingPrinciplesRef = '';
-            try {
-                const activePrinciples = wctx.evolutionReducer.getActivePrinciples();
-                if (activePrinciples.length > 0) {
-                    // Include all principles up to 20 — enough for duplicate detection
-                    // without overwhelming the context window
-                    const maxPrinciples = 20;
-                    const included = activePrinciples.length > maxPrinciples
-                        ? activePrinciples.slice(-maxPrinciples)
-                        : activePrinciples;
-                    const lines = included.map((p) => {
-                        let line = `### ${p.id}: ${p.text}`;
-                        if (p.priority && p.priority !== 'P1') line += ` [${p.priority}]`;
-                        if (p.scope === 'domain' && p.domain) line += ` (domain: ${p.domain})`;
-                        return line;
-                    });
-                    existingPrinciplesRef = `\n**Existing Principles for Duplicate Detection** (showing ${included.length}/${activePrinciples.length}):\n${lines.join('\n')}`;
-
-                    // Also inject suggested rules from existing principles (if any)
-                    const rulesByPrinciple = included.filter((p) => p.suggestedRules?.length);
-                    if (rulesByPrinciple.length > 0) {
-                        const ruleLines = rulesByPrinciple.flatMap((p) =>
-                            (p.suggestedRules ?? []).map((r) => `- [${p.id}] **${r.name}**: ${r.action} (type: ${r.type}, enforce: ${r.enforcement})`),
-                        );
-                        existingPrinciplesRef += `\n\n**Suggested Rules from Existing Principles**:\n${ruleLines.join('\n')}`;
-                    }
-                }
-            } 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
-            // P2: JSONL direct read - fallback when tools fail or session not visible
-            // The diagnostician skill implements both paths (Phase 0 protocol).
-            //
-            // Here we pre-extract JSONL context as backup and inject tool instructions.
-
-            let contextSection = '';
-            if (highestScoreTask.session_id && highestScoreTask.agent_id) {
-                try {
-                    const { extractRecentConversation, extractFailedToolContext } = await import('../core/pain-context-extractor.js');
-                    const conversation = await extractRecentConversation(highestScoreTask.session_id, highestScoreTask.agent_id, 5);
-                    
-                    if (conversation) {
-                        contextSection = `\n## Recent Conversation Context (pre-extracted JSONL fallback)\n\n${conversation}\n`;
-                        
-                        // Also try to extract failed tool context if this is a tool failure
-                        if (highestScoreTask.source === 'tool_failure') {
-                            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,
-                                    highestScoreTask.agent_id,
-                                    toolMatch[1],
-                                    fileMatch?.[1]?.trim(),
-                                );
-                                if (toolContext) {
-                                    contextSection += `\n## Failed Tool Call Context\n\n${toolContext}\n`;
-                                }
-                            }
-                        }
-                    }
-                    if (logger) {
-                        const turns = contextSection ? contextSection.split('\n').filter(l => l.startsWith('[User]') || l.startsWith('[Assistant]')).length : 0;
-                        logger?.debug?.(`[PD:EvolutionWorker] Pre-extracted ${turns} conversation turns for task ${highestScoreTask.id}`);
-                    }
-                } catch (e) {
-                    if (logger) logger.warn(`[PD:EvolutionWorker] Failed to extract conversation context for task ${highestScoreTask.id}: ${String(e)}. Diagnostician will use P1 tools or fallback.`);
-                }
-            }
-
-            const heartbeatContent = [
-                `## Evolution Task [ID: ${highestScoreTask.id}]`,
-                ``,
-                `**Pain Score**: ${highestScoreTask.score}`,
-                `**Source**: ${highestScoreTask.source}`,
-                `**Reason**: ${highestScoreTask.reason}`,
-                `**Trigger**: "${highestScoreTask.trigger_text_preview || 'N/A'}"`,
-                `**Queued At**: ${highestScoreTask.enqueued_at || nowIso}`,
-                `**Session ID**: ${highestScoreTask.session_id || 'N/A'}`,
-                `**Agent ID**: ${highestScoreTask.agent_id || 'main'}`,
-                ``,
-                `## Available Tools for Context Search (P1 - Preferred)`,
-                ``,
-                `1. **sessions_history** — Get full message history (requires sessionKey)`,
-                `2. **sessions_list** — List sessions (searches metadata only, NOT message content)`,
-                `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),`,
-                `use this pre-extracted context below:`,
-                contextSection || `*(No JSONL context available — use P1 tools first)*`,
-                ``,
-                `---`,
-                ``,
-                `## Diagnostician Protocol`,
-                ``,
-                `You MUST use the **pd-diagnostician** skill for this task.`,
-                `Read the full skill definition and follow the protocol EXACTLY as specified: Phase 0 (context extraction, optional) → Phase 1 (Evidence) → Phase 2 (Causal Chain) → Phase 3 (Classification) → Phase 4 (Principle Extraction).`,
-                `The skill defines the complete output contract — your JSON report MUST match the format specified in the skill.`,
-                ``,
-                `---`,
-                ``,
-                `After completing the analysis:`,
-                `1. Write your JSON diagnosis report to: ${reportFilePath}`,
-                `   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. After writing both files, reply with "DIAGNOSTICIAN_DONE: ${highestScoreTask.id}"`,
-                existingPrinciplesRef,
-            ].join('\n');
-
-            // 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 {
-                await addDiagnosticianTask(wctx.stateDir, highestScoreTask.id, heartbeatContent);
-                if (logger) logger.info(`[PD:EvolutionWorker] Wrote diagnostician task to diagnostician_tasks.json for task ${highestScoreTask.id}`);
-
-                // C: Record diagnosis_task_written event for observability
-                if (eventLog) {
-                    eventLog.recordDiagnosisTask({
-                        taskId: highestScoreTask.id,
-                        painEventId: highestScoreTask.painEventId !== undefined ? String(highestScoreTask.painEventId) : undefined,
-                        sessionId: highestScoreTask.session_id,
-                    });
-                }
-
-                // Task store write succeeded, now mark task as in_progress
-                highestScoreTask.task = taskDescription;
-                highestScoreTask.status = 'in_progress';
-                highestScoreTask.started_at = nowIso;
-                delete highestScoreTask.completed_at;
-                // Use placeholder so marker path can correlate task (no subagent spawned for HEARTBEAT)
-                // This fixes task_outcomes being empty for HEARTBEAT-triggered diagnostician runs
-                highestScoreTask.assigned_session_key = `heartbeat:diagnostician:${highestScoreTask.id}`;
-                queueChanged = true;
-
-                // Log to EvolutionLogger
-                evoLogger.logStarted({
-                    traceId: highestScoreTask.traceId || highestScoreTask.id,
-                    taskId: highestScoreTask.id,
-                });
-
-                // Update evolution_tasks table
-                wctx.trajectory?.updateEvolutionTask?.(highestScoreTask.id, {
-                    status: 'in_progress',
-                    startedAt: nowIso,
-                });
-
-                if (eventLog) {
-                    eventLog.recordEvolutionTask({
-                        taskId: highestScoreTask.id,
-                        taskType: highestScoreTask.source,
-                        reason: highestScoreTask.reason
-                    });
-                }
-            } catch (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)}`);
-            }
-        }
-
-        // Phase 2.4: Process sleep_reflection tasks AFTER pain_diagnosis.
-        // Claim tasks inside the lock, execute reflection outside the lock,
-        // 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.
-
-        // 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')
-        );
-        let sleepReflectionTasks = [...pendingSleepTasks, ...pollingSleepTasks];
-        // Phase 40: Check if sleep_reflection is in cooldown due to persistent failures
-        const sleepCooldown = isTaskKindInCooldown(wctx.stateDir, 'sleep_reflection');
-        if (sleepCooldown.inCooldown) {
-            logger?.info?.(`[PD:EvolutionWorker] sleep_reflection in cooldown (remaining ${Math.round(sleepCooldown.remainingMs / 60000)}min), skipping task processing`);
-            sleepReflectionTasks = [];
-        }
-        if (sleepReflectionTasks.length > 0) {
-            // --- 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 = queueChanged || pendingSleepTasks.length > 0;
-
-            // Write claimed state (includes any pain changes from above) and release lock
-            if (queueChanged) {
-                saveEvolutionQueue(queuePath, queue);
-            }
-            releaseLock();
-            // Phase 40: Track outcomes for failure classification after queue write
-            const sleepOutcomes: Array<{ taskKind: ClassifiableTaskKind; succeeded: boolean }> = [];
-            for (const sleepTask of sleepReflectionTasks) {
-                try {
-                    // 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}`);
-                    }
-
-                     
-                    let workflowId: string | undefined;
-                     
-                     
-                    let nocturnalManager: NocturnalWorkflowManager;
-                     
-                     
-                    let snapshotData: NocturnalSessionSnapshot | undefined;
-
-                    if (isPollingTask) {
-                         
-                        workflowId = sleepTask.resultRef!;
-                    } else {
-                        // Phase 1: Build trajectory snapshot for Nocturnal pipeline
-                        // Priority: Pain signal sessionId → Task ID → Recent session with violations
-                        let extractor: ReturnType<typeof createNocturnalTrajectoryExtractor> | null = null;
-                        try {
-                            extractor = createNocturnalTrajectoryExtractor(wctx.workspaceDir);
-
-                            // 1. Try exact session ID from pain signal (most accurate)
-                            const painSessionId = sleepTask.recentPainContext?.mostRecent?.sessionId;
-                            let fullSnapshot = painSessionId ? extractor.getNocturnalSessionSnapshot(painSessionId) : undefined;
-                            if (fullSnapshot) {
-                                logger?.info?.(`[PD:EvolutionWorker] Task ${sleepTask.id} using exact session from pain signal: ${painSessionId}`);
-                            }
-
-                            // 2. Try task ID (legacy compatibility, rarely matches)
-                            if (!fullSnapshot) {
-                                fullSnapshot = extractor.getNocturnalSessionSnapshot(sleepTask.id);
-                            }
-
-                            // 3. If no match, find most recent session WITH violation signals
-                            if (!fullSnapshot) {
-                                const taskTimeMs = new Date(sleepTask.enqueued_at || sleepTask.timestamp).getTime();
-                                const recentSessions = extractor.listRecentNocturnalCandidateSessions({
-                                    limit: 20,
-                                    minToolCalls: 1,
-                                    dateTo: sleepTask.enqueued_at || sleepTask.timestamp,
-                                }).filter((session) => isSessionAtOrBeforeTriggerTime(session, taskTimeMs));
-                                // Filter to sessions with actual violations (pain, failures, or gate blocks)
-                                const sessionsWithViolations = recentSessions.filter(
-                                    s => s.failureCount > 0 || s.painEventCount > 0 || s.gateBlockCount > 0
-                                );
-                                if (sessionsWithViolations.length > 0) {
-                                     
-                                    const targetSession = sessionsWithViolations[0];
-                                    logger?.info?.(`[PD:EvolutionWorker] Task ${sleepTask.id} using session with violations: ${targetSession.sessionId} (failed=${targetSession.failureCount}, pain=${targetSession.painEventCount}, gates=${targetSession.gateBlockCount})`);
-                                    fullSnapshot = extractor.getNocturnalSessionSnapshot(targetSession.sessionId);
-                                } else if (recentSessions.length > 0) {
-                                    // No sessions with violations, use most recent as last resort
-                                     
-                                    const latestSession = recentSessions[0];
-                                    logger?.warn?.(`[PD:EvolutionWorker] Task ${sleepTask.id} no sessions with violations found, using most recent: ${latestSession.sessionId} (failed=${latestSession.failureCount}, pain=${latestSession.painEventCount}, gates=${latestSession.gateBlockCount})`);
-                                    fullSnapshot = extractor.getNocturnalSessionSnapshot(latestSession.sessionId);
-                                } else {
-                                    logger?.warn?.(`[PD:EvolutionWorker] Task ${sleepTask.id} no sessions with tool calls in trajectory DB`);
-                                }
-                            }
-
-                            if (fullSnapshot) {
-                                snapshotData = fullSnapshot;
-                            }
-                        } catch (snapErr) {
-                            logger?.warn?.(`[PD:EvolutionWorker] Failed to build trajectory snapshot for ${sleepTask.id}: ${String(snapErr)}`);
-                        }
-
-                        // Phase 2: If no trajectory data, try pain-context fallback
-                        if (!snapshotData && sleepTask.recentPainContext) {
-                            logger?.warn?.(`[PD:EvolutionWorker] Using pain-context fallback for ${sleepTask.id}: trajectory snapshot unavailable, will try session summary from extractor`);
-                            snapshotData = buildFallbackNocturnalSnapshot(sleepTask, extractor, logger) ?? undefined;
-                        }
-
-                        const snapshotValidation = validateNocturnalSnapshotIngress(snapshotData);
-                        if (snapshotValidation.status !== 'valid') {
-                            sleepTask.status = 'failed';
-                            sleepTask.completed_at = new Date().toISOString();
-                            sleepTask.resolution = 'failed_max_retries';
-                            sleepOutcomes.push({ taskKind: 'sleep_reflection', succeeded: false });
-                            sleepTask.lastError = `sleep_reflection failed: invalid_snapshot_ingress (${snapshotValidation.reasons.join('; ') || 'missing snapshot'})`;
-                            sleepTask.retryCount = (sleepTask.retryCount ?? 0) + 1;
-                            logger?.warn?.(`[PD:EvolutionWorker] sleep_reflection task ${sleepTask.id} rejected: ${sleepTask.lastError}`);
-                            continue;
-                        }
-
-                        snapshotData = snapshotValidation.snapshot;
-                    }
-
-                    if (!api) {
-                        sleepTask.status = 'failed';
-                        sleepTask.completed_at = new Date().toISOString();
-                        sleepTask.resolution = 'failed_max_retries';
-                        sleepTask.lastError = 'No API available to create NocturnalWorkflowManager';
-                        sleepTask.retryCount = (sleepTask.retryCount ?? 0) + 1;
-                        sleepOutcomes.push({ taskKind: 'sleep_reflection', succeeded: false });
-                        logger?.warn?.(`[PD:EvolutionWorker] sleep_reflection task ${sleepTask.id} skipped: no API`);
-                        continue;
-                    }
-
-                    nocturnalManager = new NocturnalWorkflowManager({
-                        workspaceDir: wctx.workspaceDir,
-                        stateDir: wctx.stateDir,
-                        logger: api.logger,
-                        runtimeAdapter: new OpenClawTrinityRuntimeAdapter(api),
-                        subagent: api.runtime.subagent,
-                    });
-
-                    if (!isPollingTask) {
-                        const workflowHandle = await nocturnalManager.startWorkflow(nocturnalWorkflowSpec, {
-                            parentSessionId: `sleep_reflection:${sleepTask.id}`,
-                            workspaceDir: wctx.workspaceDir,
-                            taskInput: {},
-                            metadata: {
-                                snapshot: snapshotData,
-                                taskId: sleepTask.id,
-                                painContext: sleepTask.recentPainContext,
-                                triggerSource: sleepTask.source,
-                                // #297: Configure which preflight gates to skip.
-                                // sleep_reflection uses periodic trigger which bypasses idle by design.
-                                skipPreflightGates: ['idle'],
-                            },
-                        });
-                        sleepTask.resultRef = workflowHandle.workflowId;
-                         
-                        workflowId = workflowHandle.workflowId;
-                    }
-
-                    if (!workflowId) {
-                        sleepTask.status = 'failed';
-                        sleepTask.completed_at = new Date().toISOString();
-                        sleepTask.resolution = 'failed_max_retries';
-                        sleepTask.lastError = 'sleep_reflection failed: missing_workflow_id';
-                        sleepTask.retryCount = (sleepTask.retryCount ?? 0) + 1;
-                        sleepOutcomes.push({ taskKind: 'sleep_reflection', succeeded: false });
-                        logger?.warn?.(`[PD:EvolutionWorker] sleep_reflection task ${sleepTask.id} missing workflow id after startup`);
-                        continue;
-                    }
-
-                    // Workflow is running asynchronously. Check if it completed in this cycle
-                    // by polling getWorkflowDebugSummary.
-                    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' : workflowId;
-                            sleepOutcomes.push({ taskKind: 'sleep_reflection', succeeded: true });
-                            logger?.info?.(`[PD:EvolutionWorker] sleep_reflection task ${sleepTask.id} workflow completed`);
-                        } else if (summary.state === 'terminal_error') {
-                            // #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];
-                            const errorReason = lastEvent?.reason ?? 'unknown';
-                            // #219: Include payload details for better diagnostics
-                            let detailedError = `Workflow terminal_error: ${errorReason}`;
-                             
-                            let payload: unknown = {};
-                             
-                            try {
-                                payload = lastEvent?.payload ?? {};
-                                 
-                                if ((payload as any).skipReason) {
-                                     
-                                    detailedError += ` (skipReason: ${(payload as any).skipReason})`;
-                                 
-                                }
-                                 
-                                if ((payload as any).failures && Array.isArray((payload as any).failures) && (payload as any).failures.length > 0) {
-                                     
-                                    detailedError += ` | failures: ${((payload as any).failures as string[]).slice(0, 3).join(', ')}`;
-                                }
-                            } catch { /* ignore parse errors */ }
-                            sleepTask.lastError = detailedError;
-                            sleepTask.retryCount = (sleepTask.retryCount ?? 0) + 1;
-
-                            if (isExpectedSubagentError(errorReason)) {
-                                // #237: Expected unavailability → stub fallback, not hard failure
-                                sleepTask.status = 'completed';
-
-                                sleepTask.completed_at = new Date().toISOString();
-                                sleepTask.resolution = 'stub_fallback';
-                                sleepOutcomes.push({ taskKind: 'sleep_reflection', succeeded: true });
-
-                                logger?.warn?.(`[PD:EvolutionWorker] sleep_reflection task ${sleepTask.id} background runtime unavailable, using stub fallback: ${errorReason}`);
-                             
-                            } else if ((payload as any).skipReason === 'no_violating_sessions') {
-                                // #244: No meaningful violations found (thin filter) → skip without failure
-                                sleepTask.status = 'completed';
-                                sleepTask.completed_at = new Date().toISOString();
-                                sleepTask.resolution = 'skipped_thin_violation';
-                                sleepOutcomes.push({ taskKind: 'sleep_reflection', succeeded: true });
-                                logger?.info?.(`[PD:EvolutionWorker] sleep_reflection task ${sleepTask.id} completed: no sessions with meaningful violations found`);
-                            } else {
-                                sleepTask.status = 'failed';
-                                sleepTask.completed_at = new Date().toISOString();
-                                sleepTask.resolution = 'failed_max_retries';
-                                sleepOutcomes.push({ taskKind: 'sleep_reflection', succeeded: false });
-                                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) {
-                    // #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.
-                    sleepTask.completed_at = new Date().toISOString();
-                    sleepTask.lastError = String(taskErr);
-                    sleepTask.retryCount = (sleepTask.retryCount ?? 0) + 1;
-
-                    if (isExpectedSubagentError(taskErr)) {
-                        // #237: Expected unavailability → stub fallback, not hard failure
-                        sleepTask.status = 'completed';
-                        sleepTask.completed_at = new Date().toISOString();
-                        sleepTask.resolution = 'stub_fallback';
-                        sleepOutcomes.push({ taskKind: 'sleep_reflection', succeeded: true });
-                        logger?.warn?.(`[PD:EvolutionWorker] sleep_reflection task ${sleepTask.id} background runtime unavailable, using stub fallback: ${String(taskErr)}`);
-                    } else {
-                        sleepTask.status = 'failed';
-                        sleepTask.completed_at = new Date().toISOString();
-                        sleepTask.resolution = 'failed_max_retries';
-                        sleepOutcomes.push({ taskKind: 'sleep_reflection', succeeded: false });
-                        logger?.error?.(`[PD:EvolutionWorker] sleep_reflection task ${sleepTask.id} threw: ${taskErr}`);
-                    }
-                }
-            }
-
-            // --- Phase 3: Write results back (re-acquire lock) ---
-            try {
-                const resultLock = await requireQueueLock(queuePath, logger, 'sleepReflectionResult');
-                try {
-                    // Re-read queue to merge with any changes made while lock was released
-                    let freshQueue: (RawQueueItem | EvolutionQueueItem)[] = [];
-                    try {
-                        freshQueue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
-                    } catch { /* empty queue if corrupted */ }
-
-                    // Merge: update tasks by ID
-                    for (const sleepTask of sleepReflectionTasks) {
-                        const idx = freshQueue.findIndex((t) => (t as { id?: string }).id === sleepTask.id);
-                        if (idx >= 0) {
-                            freshQueue[idx] = sleepTask;
-                        }
-                    }
-                    atomicWriteFileSync(queuePath, JSON.stringify(freshQueue, null, 2));
-
-                    // Log completions to EvolutionLogger
-                    for (const sleepTask of sleepReflectionTasks) {
-                        if (sleepTask.status === 'completed' || sleepTask.status === 'failed') {
-                            evoLogger.logCompleted({
-                                traceId: sleepTask.traceId || sleepTask.id,
-                                taskId: sleepTask.id,
-                                resolution: sleepTask.status === 'completed'
-                                    ? (sleepTask.resolution === 'marker_detected' ? 'marker_detected' : 'manual')
-                                    : 'manual',
-                                durationMs: sleepTask.started_at
-                                    ? Date.now() - new Date(sleepTask.started_at).getTime()
-                                    : undefined,
-                            });
-                        }
-                    }
-                } finally {
-                    resultLock();
-                }
-            } catch (resultLockErr) {
-                // If we can't re-acquire lock, results are in memory but not persisted.
-                // Tasks will appear stuck as in_progress and will be retried on next cycle.
-                logger?.warn?.(`[PD:EvolutionWorker] Failed to write sleep_reflection results back: ${String(resultLockErr)}`);
-            }
-
-            // Phase 40: Process failure classification — evaluate once per taskKind,
-            // not per-outcome, to prevent tier escalation from firing N times for N failures.
-            try {
-                const hadAnySuccess = sleepOutcomes.some(o => o.succeeded);
-                const hadAnyFailure = sleepOutcomes.some(o => !o.succeeded);
-                if (hadAnySuccess) {
-                    await resetFailureState(wctx.stateDir, 'sleep_reflection');
-                }
-                if (hadAnyFailure) {
-                    const config = loadCooldownEscalationConfig(wctx.stateDir);
-                    const result = classifyFailure(queue, 'sleep_reflection', config.consecutive_threshold);
-                    if (result.classification === 'persistent') {
-                        await recordPersistentFailure(wctx.stateDir, 'sleep_reflection', config, result.consecutiveFailures);
-                        logger?.warn?.(`[PD:EvolutionWorker] sleep_reflection persistent failure (${result.consecutiveFailures} consecutive), escalating cooldown`);
-                    }
-                }
-            } catch { /* classification errors are non-blocking */ }
-
-            // Safe to return — pain_diagnosis was already processed above.
-            // keyword_optimization tasks are deferred to the next heartbeat cycle.
-            // Running both in the same cycle causes stale queue overwrite and
-            // double lock release (lock was released at line ~1703).
-            lockReleased = true;
-            return;
-        }
-
-        // ── keyword_optimization task processing ──────────────────────────────
-        // Process keyword_optimization tasks independently of sleep_reflection.
-        // Uses CorrectionObserverWorkflowManager to dispatch LLM subagent and
-        // KeywordOptimizationService to apply mutations to keyword store (CORR-09).
-        const pendingKeywordOptTasks = queue.filter(t => t.status === 'pending' && t.taskKind === 'keyword_optimization');
-        const inProgressKeywordOptTasks = queue.filter(t =>
-            t.status === 'in_progress' &&
-            t.taskKind === 'keyword_optimization' &&
-            t.resultRef &&
-            !t.resultRef.startsWith('trinity-draft')
-        );
-        const keywordOptTasks = [...pendingKeywordOptTasks, ...inProgressKeywordOptTasks];
-        // Phase 40: Check if keyword_optimization is in cooldown due to persistent failures
-        const kwOptCooldown = isTaskKindInCooldown(wctx.stateDir, 'keyword_optimization');
-        if (kwOptCooldown.inCooldown) {
-            logger?.info?.(`[PD:EvolutionWorker] keyword_optimization in cooldown (remaining ${Math.round(kwOptCooldown.remainingMs / 60000)}min), skipping task processing`);
-            if (keywordOptTasks.length > 0) {
-                // Skip all keyword_optimization tasks this cycle; release lock and return
-                if (queueChanged) {
-                    saveEvolutionQueue(queuePath, queue);
-                }
-                releaseLock();
-                lockReleased = true;
-                return;
-            }
-        }
-        if (keywordOptTasks.length > 0) {
-            // Claim pending tasks inside lock
-            for (const koTask of pendingKeywordOptTasks) {
-                koTask.status = 'in_progress';
-                koTask.started_at = new Date().toISOString();
-            }
-            queueChanged = queueChanged || pendingKeywordOptTasks.length > 0;
-
-            // Release lock during LLM dispatch (long-running)
-            saveEvolutionQueue(queuePath, queue);
-            releaseLock();
-            lockReleased = true;
-
-            // Phase 40: Track outcomes for failure classification after queue write
-            const kwOptOutcomes: Array<{ taskKind: ClassifiableTaskKind; succeeded: boolean }> = [];
-            for (const koTask of keywordOptTasks) {
-                const isPolling = !!koTask.resultRef && !koTask.resultRef.startsWith('trinity-draft');
-
-                if (isPolling) {
-                    logger?.debug?.(`[PD:EvolutionWorker] Polling existing keyword_optimization task ${koTask.id}`);
-                } else {
-                    logger?.info?.(`[PD:EvolutionWorker] Processing keyword_optimization task ${koTask.id}`);
-                }
-
-                try {
-                    // Build trajectoryHistory via KeywordOptimizationService
-                    const koService = KeywordOptimizationService.get(wctx.stateDir, wctx.workspaceDir, logger);
-                    const db = TrajectoryRegistry.get(wctx.workspaceDir);
-                    const recentSessionIds = db.listRecentSessions({ limit: 10 }).map(s => s.sessionId);
-                    const trajectoryHistory = await koService.buildTrajectoryHistory(recentSessionIds);
-
-                    // Build full payload (CORR-09, D-40-07, D-40-08)
-                    const learner = CorrectionCueLearner.get(wctx.stateDir);
-                    const store = learner.getStore();
-                    const payload: CorrectionObserverPayload = {
-                        workspaceDir: wctx.workspaceDir,
-                        parentSessionId: `keyword_optimization:${koTask.id}`,
-                        keywordStoreSummary: {
-                            totalKeywords: store.keywords.length,
-                            terms: store.keywords.map(k => ({
-                                term: k.term,
-                                weight: k.weight,
-                                hitCount: k.hitCount ?? 0,
-                                truePositiveCount: k.truePositiveCount ?? 0,
-                                falsePositiveCount: k.falsePositiveCount ?? 0,
-                            })),
-                        },
-                        recentMessages: [],
-                        trajectoryHistory,
-                    };
-
-                    // Dispatch LLM subagent via CorrectionObserverWorkflowManager
-                    const manager = new CorrectionObserverWorkflowManager({
-                        workspaceDir: wctx.workspaceDir,
-                        logger,
-                        subagent: api?.runtime?.subagent!,  
-                        agentSession: api?.runtime?.agent?.session,
-                    });
-
-                    let workflowId: string | undefined;
-                    if (!isPolling) {
-                        const handle = await manager.startWorkflow(correctionObserverWorkflowSpec, {
-                            parentSessionId: `keyword_optimization:${koTask.id}`,
-                            workspaceDir: wctx.workspaceDir,
-                            taskInput: payload,
-                        });
-                        workflowId = handle.workflowId;
-                        koTask.resultRef = workflowId;
-                    } else {
-                        workflowId = koTask.resultRef!;  
-                    }
-
-                    // Poll workflow state
-                    const summary = await manager.getWorkflowDebugSummary(workflowId);
-                    if (summary) {
-                        if (summary.state === 'completed') {
-                            // Get parsed LLM result and apply mutations to keyword store (CORR-09)
-                            const parsedResult = await manager.getWorkflowResult(workflowId);
-
-                            if (parsedResult?.updated) {
-                                koService.applyResult(parsedResult);
-                                await learner.recordOptimizationPerformed();
-                                logger?.info?.(`[PD:EvolutionWorker] keyword_optimization applied mutations: ${parsedResult.summary}`);
-                            } else {
-                                logger?.info?.(`[PD:EvolutionWorker] keyword_optimization completed with no updates`);
-                            }
-
-                            koTask.status = 'completed';
-                            koTask.completed_at = new Date().toISOString();
-                            koTask.resolution = 'marker_detected';
-                            kwOptOutcomes.push({ taskKind: 'keyword_optimization', succeeded: true });
-                            // CORR-08: Record throttle quota (max 4/day)
-                            recordCooldown(wctx.stateDir).catch(err =>
-                                logger?.warn?.(`[PD:EvolutionWorker] recordCooldown failed (non-blocking): ${String(err)}`)
-                            );
-                            logger?.info?.(`[PD:EvolutionWorker] keyword_optimization task ${koTask.id} workflow completed`);
-                        } else if (summary.state === 'terminal_error') {
-                            koTask.status = 'failed';
-                            koTask.completed_at = new Date().toISOString();
-                            koTask.resolution = 'failed_max_retries';
-                            kwOptOutcomes.push({ taskKind: 'keyword_optimization', succeeded: false });
-                            koTask.retryCount = (koTask.retryCount ?? 0) + 1;
-                            const lastEvent = summary.recentEvents[summary.recentEvents.length - 1];
-                            koTask.lastError = `keyword_optimization failed: ${lastEvent?.reason ?? 'unknown'}`;
-                            logger?.warn?.(`[PD:EvolutionWorker] keyword_optimization task ${koTask.id} workflow terminal_error: ${koTask.lastError}`);
-                        } else {
-                            logger?.info?.(`[PD:EvolutionWorker] keyword_optimization task ${koTask.id} workflow ${summary.state}, will poll again next cycle`);
-                        }
-                    }
-                } catch (koErr) {
-                    koTask.status = 'failed';
-                    koTask.completed_at = new Date().toISOString();
-                    koTask.resolution = 'failed_max_retries';
-                    kwOptOutcomes.push({ taskKind: 'keyword_optimization', succeeded: false });
-                    koTask.lastError = String(koErr);
-                    koTask.retryCount = (koTask.retryCount ?? 0) + 1;
-                    logger?.error?.(`[PD:EvolutionWorker] keyword_optimization task ${koTask.id} threw: ${koErr}`);
-                }
-            }
-
-            // Re-acquire lock to write results
-            const koResultLock = await requireQueueLock(queuePath, logger, 'keywordOptResult');
-            try {
-                let freshQueue: (RawQueueItem | EvolutionQueueItem)[] = [];
-                try {
-                    freshQueue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
-                } catch (readErr) {
-                    // Queue file corrupted — log warning but preserve in-memory task state
-                    logger?.warn?.(`[PD:EvolutionWorker] Queue file corrupted (${String(readErr)}), preserving in-memory state`);
-                    freshQueue = [];
-                }
-
-                // Append or replace keyword_optimization tasks
-                for (const koTask of keywordOptTasks) {
-                    const idx = freshQueue.findIndex((t) => (t as { id?: string }).id === koTask.id);
-                    if (idx >= 0) {
-                        freshQueue[idx] = koTask;
-                    } else {
-                        freshQueue.push(koTask);
-                    }
-                }
-                atomicWriteFileSync(queuePath, JSON.stringify(freshQueue, null, 2));
-            } catch (koResultErr) {
-                logger?.warn?.(`[PD:EvolutionWorker] Failed to write keyword_optimization results: ${String(koResultErr)}`);
-            } finally {
-                koResultLock();
-            }
-
-            // Phase 40: Process failure classification — evaluate once per taskKind
-            try {
-                const hadAnySuccess = kwOptOutcomes.some(o => o.succeeded);
-                const hadAnyFailure = kwOptOutcomes.some(o => !o.succeeded);
-                if (hadAnySuccess) {
-                    await resetFailureState(wctx.stateDir, 'keyword_optimization');
-                }
-                if (hadAnyFailure) {
-                    const config = loadCooldownEscalationConfig(wctx.stateDir);
-                    const freshQueue = JSON.parse(fs.readFileSync(queuePath, 'utf8')) as EvolutionQueueItem[];
-                    const result = classifyFailure(freshQueue, 'keyword_optimization', config.consecutive_threshold);
-                    if (result.classification === 'persistent') {
-                        await recordPersistentFailure(wctx.stateDir, 'keyword_optimization', config, result.consecutiveFailures);
-                        logger?.warn?.(`[PD:EvolutionWorker] keyword_optimization persistent failure (${result.consecutiveFailures} consecutive), escalating cooldown`);
-                    }
-                }
-            } catch { /* classification errors are non-blocking */ }
-
-            return;
-        }
+        let queueChanged = rawQueue.some(isLegacyQueueItem) || queue.length < beforeLegacyPainDrop || queue.length < beforeValidation;
 
         if (queueChanged) {
             saveEvolutionQueue(queuePath, queue);
         }
 
-        // Pipeline observability: log stage-level summary at end of cycle
-        const pendingPain = queue.filter((t) => t.status === 'pending' && t.taskKind === 'pain_diagnosis').length;
-        const inProgressPain = queue.filter((t) => t.status === 'in_progress' && t.taskKind === 'pain_diagnosis').length;
-        if (inProgressPain > 0) {
-            const stuck = queue
-                .filter((t) => t.status === 'in_progress' && t.taskKind === 'pain_diagnosis')
-                .map((t) => `${t.id} (since ${t.started_at || 'unknown'})`);
-            logger?.info?.(`[PD:EvolutionWorker] Pipeline: ${inProgressPain} pain_diagnosis task(s) in_progress — awaiting agent response: ${stuck.join(', ')}`);
-        }
-        if (pendingPain > 0) {
-            logger?.info?.(`[PD:EvolutionWorker] Pipeline: ${pendingPain} pain_diagnosis task(s) pending — HEARTBEAT.md will trigger next cycle`);
-        }
-        const painCompleted = queue.filter((t) => t.status === 'completed' && t.taskKind === 'pain_diagnosis').length;
-        logger?.info?.(`[PD:EvolutionWorker] Pipeline summary: pain_completed=${painCompleted} pain_pending=${pendingPain} pain_in_progress=${inProgressPain}`);
     } catch (err) {
         if (logger) logger.warn(`[PD:EvolutionWorker] Error processing evolution queue: ${String(err)}`);
     } finally {
@@ -2260,6 +632,49 @@ async function processEvolutionQueueWithResult(
     return { queue: queueResult, errors };
 }
 
+function resolveCorrectionObserver(wctx: WorkspaceContext, logger?: Pick<PluginLogger, 'info' | 'warn' | 'error' | 'debug'>): CorrectionObserver | null {
+  try {
+    const loader = new WorkflowFunnelLoader(wctx.stateDir);
+    const funnel = loader.getFunnel('pd-correction-observer');
+    const policy = funnel?.policy;
+    if (!policy || policy.runtimeKind !== 'pi-ai') {
+      logger?.debug?.('[PD:Correction] workflows.yaml pd-correction-observer policy not found. Falling back to environment variables.');
+      const provider = process.env.PD_CORRECTION_PROVIDER || 'anthropic';
+      const model = process.env.PD_CORRECTION_MODEL || 'anthropic/claude-3-5-sonnet';
+      const apiKeyEnv = process.env.PD_CORRECTION_API_KEY_ENV || 'ANTHROPIC_API_KEY';
+      const baseUrl = process.env.PD_CORRECTION_BASE_URL;
+
+      if (!process.env[apiKeyEnv]) {
+        logger?.debug?.(`[PD:Correction] Correction observer API key env ${apiKeyEnv} is not set. Periodic optimization disabled.`);
+        return null;
+      }
+
+      const adapter = new PiAiRuntimeAdapter({
+        provider,
+        model,
+        apiKeyEnv,
+        baseUrl,
+        workspace: wctx.workspaceDir,
+      });
+      return new CorrectionObserver({ runtimeAdapter: adapter });
+    }
+
+    const adapter = new PiAiRuntimeAdapter({
+      provider: String(policy.provider),
+      model: String(policy.model),
+      apiKeyEnv: String(policy.apiKeyEnv),
+      maxRetries: policy.maxRetries,
+      timeoutMs: policy.timeoutMs ?? 30_000,
+      baseUrl: policy.baseUrl,
+      workspace: wctx.workspaceDir,
+    });
+    return new CorrectionObserver({ runtimeAdapter: adapter }, { timeoutMs: policy.timeoutMs });
+  } catch (err) {
+    logger?.warn?.(`[PD:Correction] Failed to resolve CorrectionObserver: ${String(err)}`);
+    return null;
+  }
+}
+
 export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
     id: 'principles-evolution-worker',
     api: null,
@@ -2328,149 +743,125 @@ export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
             };
 
             try {
-                // Load config on each cycle (supports runtime updates) — single file read
-                const mergedConfig = loadNocturnalConfigMerged(wctx.stateDir);
-                const { sleepReflection: sleepConfig, keywordOptimization: kwOptConfig } = mergedConfig;
-
                 // Compilation backfill: runs on every heartbeat to retry failed compilations.
                 // Fire-and-forget — errors are logged within the function.
                 processCompilationBackfill(wctx, logger).catch((err) => {
                     logger?.error?.(`[PD:EvolutionWorker] CompilationBackfill threw: ${String(err)}`);
                 });
 
-                const idleResult = checkWorkspaceIdle(wctx.workspaceDir, {});
-                logger?.info?.(`[PD:EvolutionWorker] HEARTBEAT cycle=${new Date().toISOString()} idle=${idleResult.isIdle} idleForMs=${idleResult.idleForMs} userActiveSessions=${idleResult.userActiveSessions} abandonedSessions=${idleResult.abandonedSessionIds.length} lastActivityEpoch=${idleResult.mostRecentActivityAt} triggerMode=${sleepConfig.trigger_mode}`);
-
-                let shouldTrySleepReflection = false;
-
-                // Path 1: Idle-based trigger (default mode)
-                if (idleResult.isIdle && sleepConfig.trigger_mode === 'idle') {
-                    logger?.info?.(`[PD:EvolutionWorker] Workspace idle (${idleResult.idleForMs}ms since last activity)`);
-                    shouldTrySleepReflection = true;
-                }
-
-                // keyword_optimization: Independent periodic trigger (CORR-07).
-                // Fires every kwOptConfig.period_heartbeats regardless of trigger_mode.
-                // Has its own dedicated config (default 24 heartbeats = 6 hours).
-                if (kwOptConfig.enabled && heartbeatCounter > 0 && heartbeatCounter % kwOptConfig.period_heartbeats === 0) {
-                    logger?.info?.(`[PD:EvolutionWorker] keyword_optimization trigger at heartbeat ${heartbeatCounter} (trigger_mode=${sleepConfig.trigger_mode})`);
-                    enqueueKeywordOptimizationTask(wctx, logger).catch((err) => {
-                        logger?.error?.(`[PD:EvolutionWorker] Failed to enqueue keyword_optimization task: ${String(err)}`);
-                    });
-                }
-
-                // Path 2: Periodic trigger for sleep_reflection (fires regardless of idle state)
-                if (sleepConfig.trigger_mode === 'periodic') {
-                    if (heartbeatCounter >= sleepConfig.period_heartbeats) {
-                        logger?.info?.(`[PD:EvolutionWorker] Periodic trigger: heartbeatCounter=${heartbeatCounter} >= period_heartbeats=${sleepConfig.period_heartbeats}`);
-                        shouldTrySleepReflection = true;
-                        heartbeatCounter = 0; // Reset counter
-                    } else {
-                        logger?.info?.(`[PD:EvolutionWorker] Periodic: ${heartbeatCounter}/${sleepConfig.period_heartbeats} heartbeats — waiting`);
-                    }
-                }
-
-                if (shouldTrySleepReflection) {
-                    const cooldown = checkCooldown(wctx.stateDir, undefined, {
-                        globalCooldownMs: sleepConfig.cooldown_ms,
-                        maxRunsPerWindow: sleepConfig.max_runs_per_day,
-                        quotaWindowMs: 24 * 60 * 60 * 1000,
-                    });
-                    logger?.info?.(`[PD:EvolutionWorker] Cooldown check: globalCooldownActive=${cooldown.globalCooldownActive} quotaExhausted=${cooldown.quotaExhausted} runsRemaining=${cooldown.runsRemaining}`);
-                    if (!cooldown.globalCooldownActive && !cooldown.quotaExhausted) {
-                        logger?.info?.('[PD:EvolutionWorker] Attempting to enqueue sleep_reflection task...');
-                        enqueueSleepReflectionTask(wctx, logger).catch((err) => {
-                            logger?.error?.(`[PD:EvolutionWorker] Failed to enqueue sleep_reflection task: ${String(err)}`);
-                        });
-                    } else {
-                        logger?.info?.(`[PD:EvolutionWorker] Skipping sleep_reflection: globalCooldown=${cooldown.globalCooldownActive} quotaExhausted=${cooldown.quotaExhausted}`);
-                    }
-                }
-
-                const painCheckResult = await checkPainFlag(wctx, logger);
-                cycleResult.pain_flag = painCheckResult;
+                logger?.info?.(`[PD:EvolutionWorker] HEARTBEAT cycle=${new Date().toISOString()}`);
 
                 const queueResult = await processEvolutionQueueWithResult(wctx, logger, eventLog, api ?? undefined);
                 cycleResult.queue = queueResult.queue;
                 if (queueResult.errors) cycleResult.errors.push(...queueResult.errors);
 
-                // If pain flag was enqueued AND processEvolutionQueue wrote HEARTBEAT.md
-                // with a diagnostician task, immediately trigger a heartbeat to start
-                // the diagnostician without waiting for the next 15-minute interval.
-                // Must run AFTER processEvolutionQueue — HEARTBEAT.md must be written first.
-                if (painCheckResult.enqueued) {
-                    const canTrigger = !!api?.runtime?.system?.runHeartbeatOnce;
-                    logger.info(`[PD:EvolutionWorker] Pain flag enqueued — runHeartbeatOnce available: ${canTrigger} (api=${!!api}, runtime=${!!api?.runtime}, system=${!!api?.runtime?.system})`);
-                    if (canTrigger) {
-                        try {
-                            const hbResult = await api.runtime.system.runHeartbeatOnce({
-                                reason: `pd-pain-diagnosis: pain flag detected, starting diagnostician`,
-                            });
-                            logger.info(`[PD:EvolutionWorker] Immediate heartbeat result: status=${hbResult.status}${hbResult.status === 'ran' ? ` duration=${hbResult.durationMs}ms` : ''}${hbResult.status === 'skipped' || hbResult.status === 'failed' ? ` reason=${hbResult.reason}` : ''}`);
-                            if (hbResult.status === 'skipped' || hbResult.status === 'failed') {
-                                logger.warn(`[PD:EvolutionWorker] Immediate heartbeat was ${hbResult.status} (${hbResult.reason}). Diagnostician will start on next regular heartbeat cycle.`);
-                            }
-                        } catch (hbErr) {
-                            logger.warn(`[PD:EvolutionWorker] Failed to trigger immediate heartbeat: ${String(hbErr)}. Diagnostician will start on next regular heartbeat cycle.`);
-                        }
-                    } else {
-                        logger.warn(`[PD:EvolutionWorker] runHeartbeatOnce not available. Diagnostician will start on next regular heartbeat cycle.`);
-                    }
-                }
-
                 if (api) {
                     await processDetectionQueue(wctx, api, eventLog);
                 }
                 // processPromotion removed (D-06) — promotion via PAIN_CANDIDATES no longer needed
 
+                // ── Correction Observer: periodic keyword optimization (D-40-08 / H-1) ──
                 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 {
-                            swept += await empathyMgr.sweepExpiredWorkflows(WORKFLOW_TTL_MS);
-                        } finally {
-                            empathyMgr.dispose();
-                        }
+                    const observer = resolveCorrectionObserver(wctx, logger);
+                    if (observer) {
+                        logger?.info?.('[PD:EvolutionWorker] Correction Observer resolved. Initiating periodic optimization...');
+                        const db = TrajectoryRegistry.get(wctx.workspaceDir);
+                        const recentSessions = db.listRecentSessions({ limit: 20 });
+                        const recentSessionIds = recentSessions.map(s => s.sessionId);
+
+                        if (recentSessionIds.length > 0) {
+                            const recentMessages: string[] = [];
+                            for (const sId of recentSessionIds.slice(0, 5)) {
+                                try {
+                                    const turns = db.listUserTurnsForSession(sId);
+                                    for (const t of turns) {
+                                        if (t.rawExcerpt) {
+                                            recentMessages.push(t.rawExcerpt);
+                                        }
+                                    }
+                                } catch (turnErr) {
+                                    logger?.warn?.(`[PD:EvolutionWorker] Failed to load user turns for session ${sId}: ${String(turnErr)}`);
+                                }
+                            }
 
-                        // #183 + #188: Sweep Nocturnal workflows too (with gateway-safe fallback)
-                        try {
-                            const nocturnalMgr = new NocturnalWorkflowManager({
+                            const learner = CorrectionCueLearner.get(wctx.stateDir);
+                            const keywords = learner.getStore().keywords;
+                            const keywordStoreSummary = {
+                                totalKeywords: keywords.length,
+                                terms: keywords.map(k => ({
+                                    term: k.term,
+                                    weight: k.weight,
+                                    hitCount: k.hitCount ?? 0,
+                                    truePositiveCount: k.truePositiveCount ?? 0,
+                                    falsePositiveCount: k.falsePositiveCount ?? 0,
+                                })),
+                            };
+
+                            const optimizationService = KeywordOptimizationService.get(wctx.stateDir, wctx.workspaceDir, logger);
+                            const trajectoryHistory = await optimizationService.buildTrajectoryHistory(recentSessionIds);
+
+                            const payload = {
+                                parentSessionId: 'evolution-worker',
                                 workspaceDir: wctx.workspaceDir,
-                                stateDir: wctx.stateDir,
-                                logger: api.logger,
-                                runtimeAdapter: new OpenClawTrinityRuntimeAdapter(api),
-                                subagent: api.runtime.subagent,
+                                keywordStoreSummary,
+                                recentMessages,
+                                trajectoryHistory,
+                            };
+
+                            const scheduler = new AgentScheduler();
+                            scheduler.register({
+                                agentId: 'correction-observer',
+                                mode: 'realtime',
+                                runner: observer,
                             });
-                            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)`);
+                            logger?.info?.(`[PD:EvolutionWorker] Dispatching correction-observer with ${trajectoryHistory.length} trajectory events, ${recentMessages.length} recent messages.`);
+                            const result = await scheduler.dispatch('correction-observer', payload);
+                            logger?.info?.(`[PD:EvolutionWorker] Correction-observer completed: updated=${result.updated}, summary="${result.summary}"`);
+                            
+                            if (result.updated) {
+                                optimizationService.applyResult(result);
+                            }
+                        } else {
+                            logger?.info?.('[PD:EvolutionWorker] No recent sessions found. Skipping correction optimization.');
                         }
-                    } else {
-                        // Fallback: if subagent runtime unavailable, mark as expired
-                        // but log that session cleanup was skipped.
-                        const workflowStore = new WorkflowStore({ workspaceDir: wctx.workspaceDir });
+                    }
+                } catch (corrErr) {
+                    const corrErrMsg = `Correction observer execution failed: ${String(corrErr)}`;
+                    cycleResult.errors.push(corrErrMsg);
+                    logger?.warn?.(`[PD:EvolutionWorker] ${corrErrMsg}`);
+                }
+
+                try {
+                    const subagentRuntime = api?.runtime?.subagent;
+                    const workflowStore = new WorkflowStore({ workspaceDir: wctx.workspaceDir });
+                    try {
                         const expiredWorkflows = workflowStore.getExpiredWorkflows(WORKFLOW_TTL_MS);
                         for (const wf of expiredWorkflows) {
+                            // Attempt session cleanup when runtime is available
+                            if (subagentRuntime && wf.child_session_key) {
+                                try {
+                                    await subagentRuntime.deleteSession({ sessionKey: wf.child_session_key, deleteTranscript: true });
+                                    workflowStore.updateCleanupState(wf.workflow_id, 'completed');
+                                    logger?.info?.(`[PD:EvolutionWorker] Cleaned up session ${wf.child_session_key} for expired workflow ${wf.workflow_id}`);
+                                } catch (cleanupErr) {
+                                    const errMsg = `Session cleanup failed for workflow ${wf.workflow_id} (child_session=${wf.child_session_key}): ${String(cleanupErr)}`;
+                                    workflowStore.updateCleanupState(wf.workflow_id, 'failed');
+                                    cycleResult.errors.push(errMsg);
+                                    logger?.warn?.(`[PD:EvolutionWorker] ${errMsg}`);
+                                }
+                            } else if (wf.child_session_key) {
+                                // Runtime unavailable but session exists — structured failure, not silent
+                                const errMsg = `Session cleanup unavailable for workflow ${wf.workflow_id} (child_session=${wf.child_session_key}): subagentRuntime not in gateway context`;
+                                workflowStore.updateCleanupState(wf.workflow_id, 'failed');
+                                cycleResult.errors.push(errMsg);
+                                logger?.warn?.(`[PD:EvolutionWorker] ${errMsg}`);
+                            }
                             workflowStore.updateWorkflowState(wf.workflow_id, 'expired');
-                            workflowStore.updateCleanupState(wf.workflow_id, 'failed');
-                            workflowStore.recordEvent(wf.workflow_id, 'swept', wf.state, 'expired', 'TTL expired (no runtime for session cleanup)', {});
-                            logger?.warn?.(`[PD:EvolutionWorker] Marked workflow ${wf.workflow_id} as expired but could not cleanup session (subagent runtime unavailable)`);
+                            workflowStore.recordEvent(wf.workflow_id, 'swept', wf.state, 'expired', 'TTL expired', {});
+                            logger?.warn?.(`[PD:EvolutionWorker] Marked workflow ${wf.workflow_id} as expired`);
                         }
+                    } finally {
                         workflowStore.dispose();
                     }
                 } catch (sweepErr) {
@@ -2516,20 +907,6 @@ export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
 
         timeoutId = setTimeout(() => {
             void (async () => {
-                // Phase 41: Startup reconciliation — validate state, clear stale cooldowns, clean orphans
-                try {
-                    const reconResult = await reconcileStartup(wctx.stateDir);
-                    if (reconResult.cooldownsCleared > 0 || reconResult.orphansRemoved.length > 0 || reconResult.stateReset) {
-                        logger?.info?.(`[PD:EvolutionWorker] Startup reconciliation: ${reconResult.cooldownsCleared} stale cooldowns cleared, ${reconResult.orphansRemoved.length} orphan files removed, stateReset=${reconResult.stateReset}`);
-                    } else {
-                        logger?.debug?.('[PD:EvolutionWorker] Startup reconciliation: clean state, no action needed');
-                    }
-                } catch (reconErr) {
-                    logger?.warn?.(`[PD:EvolutionWorker] Startup reconciliation failed (non-blocking): ${String(reconErr)}`);
-                }
-
-                await checkPainFlag(wctx, logger);
-                // Use the same pipeline as regular cycles (includes purge + observability)
                 const queueResult = await processEvolutionQueueWithResult(wctx, logger, eventLog, api ?? undefined);
                 if (queueResult.errors.length > 0) {
                     queueResult.errors.forEach((e) => logger?.error?.(`[PD:EvolutionWorker] Startup cycle error: ${e}`));