principles-disciple 1.34.0 → 1.34.2

package/src/service/evolution-worker.ts

@@ -5,7 +5,7 @@ import { createHash } from 'crypto';
 import type { OpenClawPluginServiceContext, OpenClawPluginApi, PluginLogger } from '../openclaw-sdk.js';
 import { DictionaryService } from '../core/dictionary-service.js';
 import { DetectionService } from '../core/detection-service.js';
-import { ensureStateTemplates, ensureCorePrinciples } from '../core/init.js';
+import { ensureStateTemplates } from '../core/init.js';
 import { SystemLogger } from '../core/system-logger.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import type { EventLog } from '../core/event-log.js';
@@ -31,18 +31,24 @@ import {
 import { validateNocturnalSnapshotIngress } from '../core/nocturnal-snapshot-contract.js';
 import { isExpectedSubagentError } from './subagent-workflow/subagent-error-utils.js';
 import { readPainFlagContract } from '../core/pain.js';
-
-// ── Atomic File Write ────────────────────────────────────────────────────────
-// Write to temp then rename — atomic on POSIX, prevents partial-write corruption on crash.
-function atomicWriteFileSync(filePath: string, data: string): void {
-    const tmpPath = filePath + '.tmp';
-    fs.writeFileSync(tmpPath, data, 'utf8');
-    fs.renameSync(tmpPath, filePath);
-}
+import { CorrectionObserverWorkflowManager, correctionObserverWorkflowSpec } from './correction-observer-workflow-manager.js';
+import type { CorrectionObserverPayload } from './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';
 
 const WORKFLOW_TTL_MS = 5 * 60 * 1000; // 5 minutes default TTL for helper workflows
 import { OpenClawTrinityRuntimeAdapter } from '../core/nocturnal-trinity.js';
 
+/**
+ * Atomic file write — write to temp then rename to prevent partial writes on crash.
+ */
+function atomicWriteFileSync(filePath: string, data: string): void {
+  const tmpPath = filePath + '.tmp';
+  fs.writeFileSync(tmpPath, data, 'utf8');
+  fs.renameSync(tmpPath, filePath);
+}
+
 // ── Workflow Watchdog ────────────────────────────────────────────────────────
 // Detects stale/orphaned workflows, invalid results, and cleanup failures.
 // Runs every heartbeat cycle, catching bugs like:
@@ -56,7 +62,6 @@ interface WatchdogResult {
   details: string[];
 }
 
- 
 async function runWorkflowWatchdog(
   wctx: WorkspaceContext,
   api: OpenClawPluginApi | null,
@@ -72,10 +77,104 @@ async function runWorkflowWatchdog(
     try {
       const allWorkflows: WorkflowRow[] = store.listWorkflows();
 
-      runWorkflowWatchdogCheckStale(allWorkflows, store, now, details, subagentRuntime, agentSession, logger);
-      runWorkflowWatchdogCheckUncleared(allWorkflows, details);
-      runWorkflowWatchdogCheckNocturnal(allWorkflows, details);
+      // Check 1: Stale active workflows (active > 2x TTL)
+      const staleThreshold = WORKFLOW_TTL_MS * 2;
+      const staleActive = allWorkflows.filter(
+        (wf: WorkflowRow) => wf.state === 'active' && (now - wf.created_at) > staleThreshold,
+      );
+      if (staleActive.length > 0) {
+        for (const wf of staleActive) {
+          const ageMin = Math.round((now - wf.created_at) / 60000);
+          details.push(`stale_active: ${wf.workflow_id} (${wf.workflow_type}, ${ageMin}min old)`);
+
+          // #257: Check if the last recorded event reason indicates expected subagent unavailability.
+          // If so, skip marking as terminal_error — the workflow is stale because the subagent
+          // was expectedly unavailable (daemon mode, process isolation), not due to a hard failure.
+          const events = store.getEvents(wf.workflow_id);
+          const lastEventReason = events.length > 0 ? events[events.length - 1].reason : 'unknown';
+          if (isExpectedSubagentError(lastEventReason)) {
+            logger?.debug?.(`[PD:Watchdog] Skipping stale active workflow ${wf.workflow_id}: expected subagent error (${lastEventReason})`);
+            continue;
+          }
+
+          store.updateWorkflowState(wf.workflow_id, 'terminal_error');
+          store.recordEvent(wf.workflow_id, 'watchdog_timeout', 'active', 'terminal_error', `Stale active > ${staleThreshold / 60000}s`, { ageMs: now - wf.created_at });
+
+          // Cleanup session if possible (#188: gateway-safe fallback)
+          if (wf.child_session_key) {
+            try {
+              if (subagentRuntime) {
+                await subagentRuntime.deleteSession({ sessionKey: wf.child_session_key, deleteTranscript: true });
+                logger?.info?.(`[PD:Watchdog] Cleaned up stale session: ${wf.child_session_key}`);
+              } else if (agentSession) {
+                const storePath = agentSession.resolveStorePath();
+                const sessionStore = agentSession.loadSessionStore(storePath, { skipCache: true });
+                const normalizedKey = wf.child_session_key.toLowerCase();
+                if (sessionStore[normalizedKey]) {
+                  delete sessionStore[normalizedKey];
+                  await agentSession.saveSessionStore(storePath, sessionStore);
+                  logger?.info?.(`[PD:Watchdog] Cleaned up stale session via agentSession fallback: ${wf.child_session_key}`);
+                }
+              }
+            } catch (cleanupErr) {
+              const errMsg = String(cleanupErr);
+              if (errMsg.includes('gateway request') && agentSession) {
+                const storePath = agentSession.resolveStorePath();
+                const sessionStore = agentSession.loadSessionStore(storePath, { skipCache: true });
+                const normalizedKey = wf.child_session_key.toLowerCase();
+                if (sessionStore[normalizedKey]) {
+                  delete sessionStore[normalizedKey];
+                  await agentSession.saveSessionStore(storePath, sessionStore);
+                  logger?.info?.(`[PD:Watchdog] Cleaned up stale session via agentSession fallback after gateway error: ${wf.child_session_key}`);
+                }
+              } else {
+                logger?.warn?.(`[PD:Watchdog] Failed to cleanup session ${wf.child_session_key}: ${errMsg}`);
+              }
+            }
+          }
+        }
+      }
+
+      // Check 2: Workflows in terminal_error/expired without cleanup
+      const unclearedTerminal = allWorkflows.filter(
+        (wf: WorkflowRow) => (wf.state === 'terminal_error' || wf.state === 'expired') && wf.cleanup_state === 'pending',
+      );
+      if (unclearedTerminal.length > 0) {
+        details.push(`uncleared_terminal: ${unclearedTerminal.length} workflows (will be swept next cycle)`);
+      }
+
+      // Check 3: Nocturnal workflow result validation (#181 pattern)
+      const nocturnalCompleted = allWorkflows.filter(
+        (wf: WorkflowRow) => wf.workflow_type === 'nocturnal' && wf.state === 'completed',
+      );
+      for (const wf of nocturnalCompleted) {
+        // Check if the metadata snapshot has all zeros (invalid data)
+        try {
+          const meta = JSON.parse(wf.metadata_json) as Record<string, unknown>;
+          const snapshot = meta.snapshot as Record<string, unknown> | undefined;
+          if (snapshot) {
+            // #219: Check for fallback data source (partial stats from pain context)
+            const dataSource = snapshot._dataSource as string | undefined;
+            if (dataSource === 'pain_context_fallback') {
+              details.push(`fallback_snapshot: nocturnal workflow ${wf.workflow_id} uses pain-context fallback (stats may be incomplete)`);
+            }
+            const stats = snapshot.stats as Record<string, number> | undefined;
+            // #246: Stats are now always number (never null). Detect "empty" fallback:
+            // fallback + all counts zero means no real data was available.
+            // NOTE: totalAssistantTurns may be 0 even for valid sessions because
+            // listRecentNocturnalCandidateSessions (used in fallback path) does not
+            // populate assistantTurnCount (only getNocturnalSessionSnapshot does).
+            // We use totalToolCalls=0 as the primary indicator instead.
+            if (stats && dataSource === 'pain_context_fallback' &&
+                stats.totalToolCalls === 0 && stats.totalGateBlocks === 0 &&
+                stats.failureCount === 0) {
+              details.push(`fallback_snapshot_stats: nocturnal workflow ${wf.workflow_id} has empty fallback stats (no trajectory data found)`);
+            }
+          }
+        } catch { /* ignore malformed metadata */ }
+      }
 
+      // Summary
       const stateCounts: Record<string, number> = {};
       for (const wf of allWorkflows) {
         stateCounts[wf.state] = (stateCounts[wf.state] || 0) + 1;
@@ -96,106 +195,6 @@ async function runWorkflowWatchdog(
   return { anomalies: details.length, details };
 }
 
-// ── Watchdog helpers (extracted from runWorkflowWatchdog for complexity) ──
-
- 
-async function cleanupStaleWorkflowSession(
-  wf: WorkflowRow,
-  subagentRuntime: { deleteSession: (opts: { sessionKey: string; deleteTranscript: boolean }) => Promise<void> } | undefined,
-  agentSession: { resolveStorePath: () => string; loadSessionStore: (p: string, o: { skipCache: boolean }) => Record<string, unknown>; saveSessionStore: (p: string, s: Record<string, unknown>) => Promise<void> } | undefined,
-  logger?: PluginLogger,
-): Promise<void> {
-  if (!wf.child_session_key) return;
-  try {
-    if (subagentRuntime) {
-      await subagentRuntime.deleteSession({ sessionKey: wf.child_session_key, deleteTranscript: true });
-      logger?.info?.(`[PD:Watchdog] Cleaned up stale session: ${wf.child_session_key}`);
-    } else if (agentSession) {
-      const storePath = agentSession.resolveStorePath();
-      const sessionStore = agentSession.loadSessionStore(storePath, { skipCache: true });
-      const normalizedKey = wf.child_session_key.toLowerCase();
-      if (sessionStore[normalizedKey]) {
-        delete sessionStore[normalizedKey];
-        await agentSession.saveSessionStore(storePath, sessionStore);
-        logger?.info?.(`[PD:Watchdog] Cleaned up stale session via agentSession fallback: ${wf.child_session_key}`);
-      }
-    }
-  } catch (cleanupErr) {
-    const errMsg = String(cleanupErr);
-    if (errMsg.includes('gateway request') && agentSession) {
-      const storePath = agentSession.resolveStorePath();
-      const sessionStore = agentSession.loadSessionStore(storePath, { skipCache: true });
-      const normalizedKey = wf.child_session_key.toLowerCase();
-      if (sessionStore[normalizedKey]) {
-        delete sessionStore[normalizedKey];
-        await agentSession.saveSessionStore(storePath, sessionStore);
-        logger?.info?.(`[PD:Watchdog] Cleaned up stale session via agentSession fallback after gateway error: ${wf.child_session_key}`);
-      }
-    } else {
-      logger?.warn?.(`[PD:Watchdog] Failed to cleanup session ${wf.child_session_key}: ${errMsg}`);
-    }
-  }
-}
-
-function runWorkflowWatchdogCheckStale(
-  allWorkflows: WorkflowRow[],
-  store: WorkflowStore,
-  now: number,
-  details: string[],
-  subagentRuntime: { deleteSession: (opts: { sessionKey: string; deleteTranscript: boolean }) => Promise<void> } | undefined,
-  agentSession: { resolveStorePath: () => string; loadSessionStore: (p: string, o: { skipCache: boolean }) => Record<string, unknown>; saveSessionStore: (p: string, s: Record<string, unknown>) => Promise<void> } | undefined,
-  logger?: PluginLogger,
-): void {
-  const staleThreshold = WORKFLOW_TTL_MS * 2;
-  for (const wf of allWorkflows) {
-    if (wf.state !== 'active' || (now - wf.created_at) <= staleThreshold) continue;
-    const ageMin = Math.round((now - wf.created_at) / 60000);
-    details.push(`stale_active: ${wf.workflow_id} (${wf.workflow_type}, ${ageMin}min old)`);
-
-    const events = store.getEvents(wf.workflow_id);
-    const lastEventReason = events.length > 0 ? events[events.length - 1].reason : 'unknown';
-    if (isExpectedSubagentError(lastEventReason)) {
-      logger?.debug?.(`[PD:Watchdog] Skipping stale active workflow ${wf.workflow_id}: expected subagent error (${lastEventReason})`);
-      continue;
-    }
-
-    store.updateWorkflowState(wf.workflow_id, 'terminal_error');
-    store.recordEvent(wf.workflow_id, 'watchdog_timeout', 'active', 'terminal_error', `Stale active > ${staleThreshold / 60000}s`, { ageMs: now - wf.created_at });
-    void cleanupStaleWorkflowSession(wf, subagentRuntime, agentSession, logger);
-  }
-}
-
-function runWorkflowWatchdogCheckUncleared(allWorkflows: WorkflowRow[], details: string[]): void {
-  const unclearedTerminal = allWorkflows.filter(
-    (wf: WorkflowRow) => (wf.state === 'terminal_error' || wf.state === 'expired') && wf.cleanup_state === 'pending',
-  );
-  if (unclearedTerminal.length > 0) {
-    details.push(`uncleared_terminal: ${unclearedTerminal.length} workflows (will be swept next cycle)`);
-  }
-}
-
- 
-function runWorkflowWatchdogCheckNocturnal(allWorkflows: WorkflowRow[], details: string[]): void {
-  for (const wf of allWorkflows) {
-    if (wf.workflow_type !== 'nocturnal' || wf.state !== 'completed') continue;
-    try {
-      const meta = JSON.parse(wf.metadata_json) as Record<string, unknown>;
-      const snapshot = meta.snapshot as Record<string, unknown> | undefined;
-      if (!snapshot) continue;
-      const dataSource = snapshot._dataSource as string | undefined;
-      if (dataSource === 'pain_context_fallback') {
-        details.push(`fallback_snapshot: nocturnal workflow ${wf.workflow_id} uses pain-context fallback (stats may be incomplete)`);
-        const stats = snapshot.stats as Record<string, number> | undefined;
-        if (stats && stats.totalToolCalls === 0 && stats.totalGateBlocks === 0 && stats.failureCount === 0) {
-          details.push(`fallback_snapshot_stats: nocturnal workflow ${wf.workflow_id} has empty fallback stats (no trajectory data found)`);
-        }
-      }
-    } catch { /* ignore malformed metadata */ }
-  }
-}
-
-// ── End watchdog helpers ──
-
 let timeoutId: NodeJS.Timeout | null = null;
 
 /**
@@ -208,12 +207,7 @@ let timeoutId: NodeJS.Timeout | null = null;
  * Old queue items (without taskKind) are migrated to pain_diagnosis for compatibility.
  */
 export type QueueStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'canceled';
-export type TaskResolution = 'marker_detected' | 'auto_completed_timeout' | 'failed_max_retries' | 'runtime_unavailable' | 'canceled' | 'late_marker_principle_created' | 'late_marker_no_principle' | 'stub_fallback' | 'skipped_thin_violation' | 'diagnostician_timeout';
-
-/** Timeout for pain_diagnosis tasks (30 min) — separate from sleep_reflection timeout.
- *  Pain diagnostics run via HEARTBEAT (main session LLM), not as a subagent.
- *  If the agent is persistently busy, we don't want the task to starve indefinitely. */
-const PAIN_DIAGNOSIS_TIMEOUT_MS = 30 * 60 * 1000;
+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';
 
 /**
  * Recent pain context attached to sleep_reflection tasks.
@@ -375,7 +369,6 @@ function isSessionAtOrBeforeTriggerTime(
     return true;
 }
 
- 
 function buildFallbackNocturnalSnapshot(
     sleepTask: EvolutionQueueItem,
     extractor?: ReturnType<typeof createNocturnalTrajectoryExtractor> | null,
@@ -510,13 +503,14 @@ function findRecentDuplicateTask(
     reason?: string
 ): EvolutionQueueItem | undefined {
      
+     
     const key = normalizePainDedupKey(source, preview, reason);
     return queue.find((task) => {
         if (task.status === 'completed') return false;
-         
         const taskTime = new Date(task.enqueued_at || task.timestamp).getTime();
         if (!Number.isFinite(taskTime) || (now - taskTime) > PAIN_QUEUE_DEDUP_WINDOW_MS) return false;
          
+         
         return normalizePainDedupKey(task.source, task.trigger_text_preview || '', task.reason) === key;
     });
 }
@@ -571,7 +565,6 @@ function normalizePainDedupKey(source: string, preview: string, reason?: string)
 
  
  
- 
 export function hasRecentDuplicateTask(queue: EvolutionQueueItem[], source: string, preview: string, now: number, reason?: string): boolean {
     return !!findRecentDuplicateTask(queue, source, preview, now, reason);
 }
@@ -699,7 +692,7 @@ function shouldSkipForDedup(
  * Load and migrate the evolution queue. Returns empty array if file doesn't exist.
  */
 function loadEvolutionQueue(queuePath: string): EvolutionQueueItem[] {
-     
+    // eslint-disable-next-line no-useless-assignment
     let rawQueue: RawQueueItem[] = [];
     try {
         rawQueue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
@@ -714,7 +707,6 @@ function loadEvolutionQueue(queuePath: string): EvolutionQueueItem[] {
  * Build and persist a new sleep_reflection task.
  */
  
- 
 function enqueueNewSleepReflectionTask(
     queue: EvolutionQueueItem[],
     recentPainContext: ReturnType<typeof readRecentPainContext>,
@@ -780,6 +772,60 @@ async function enqueueSleepReflectionTask(
     }
 }
 
+/**
+ * Enqueue a keyword_optimization task if one is not already pending/in-progress (CORR-08).
+ * Dispatches LLM subagent via CorrectionObserverWorkflowManager to optimize
+ * correction keywords based on FPR and match history.
+ */
+async function enqueueKeywordOptimizationTask(
+    wctx: WorkspaceContext,
+    logger: PluginLogger,
+): Promise<void> {
+    const queuePath = wctx.resolve('EVOLUTION_QUEUE');
+    const releaseLock = await requireQueueLock(queuePath, logger, 'enqueueKeywordOpt', EVOLUTION_QUEUE_LOCK_SUFFIX);
+
+    try {
+        const queue = loadEvolutionQueue(queuePath);
+
+        // Guard: Skip if a keyword_optimization task is already pending/in-progress (CORR-08)
+        if (hasPendingTask(queue, 'keyword_optimization')) {
+            logger?.debug?.('[PD:EvolutionWorker] keyword_optimization task already pending/in-progress, skipping');
+            return;
+        }
+
+        // Guard: Skip if daily optimization throttle is exhausted (CORR-08)
+        const learner = CorrectionCueLearner.get(wctx.stateDir);
+        if (!learner.canRunKeywordOptimization()) {
+            logger?.debug?.('[PD:EvolutionWorker] keyword_optimization throttle exhausted, skipping');
+            return;
+        }
+
+        const taskId = createEvolutionTaskId('keyword_optimization', 50, 'keyword optimization', 'Keyword optimization via LLM', Date.now());
+        const nowIso = new Date().toISOString();
+
+        queue.push({
+            id: taskId,
+            taskKind: 'keyword_optimization',
+            priority: 'medium',
+            score: 50,
+            source: 'correction',
+            reason: 'Keyword optimization triggered by heartbeat',
+            trigger_text_preview: 'Keyword optimization via LLM',
+            timestamp: nowIso,
+            enqueued_at: nowIso,
+            status: 'pending',
+            traceId: taskId,
+            retryCount: 0,
+            maxRetries: 1,
+        });
+
+        fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
+        logger?.info?.(`[PD:EvolutionWorker] Enqueued keyword_optimization task ${taskId}`);
+    } finally {
+        releaseLock();
+    }
+}
+
 interface ParsedPainValues {
     score: number; source: string; reason: string; preview: string;
     traceId: string; sessionId: string; agentId: string;
@@ -787,7 +833,6 @@ interface ParsedPainValues {
 
  
  
- 
 async function doEnqueuePainTask(
     wctx: WorkspaceContext, logger: PluginLogger, painFlagPath: string,
     result: WorkerStatusReport['pain_flag'], v: ParsedPainValues,
@@ -861,7 +906,6 @@ async function doEnqueuePainTask(
     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 {
@@ -1036,7 +1080,6 @@ async function checkPainFlag(wctx: WorkspaceContext, logger: PluginLogger): Prom
 
  
  
- 
 async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogger, eventLog: EventLog, api?: OpenClawPluginApi) {
     const queuePath = wctx.resolve('EVOLUTION_QUEUE');
     if (!fs.existsSync(queuePath)) {
@@ -1074,6 +1117,11 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
 
         let queueChanged = rawQueue.some(isLegacyQueueItem);
 
+        // 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
 
@@ -1314,8 +1362,8 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
             }
 
             const age = Date.now() - startedAt.getTime();
-            if (age > PAIN_DIAGNOSIS_TIMEOUT_MS) {
-                const timeoutMinutes = Math.round(PAIN_DIAGNOSIS_TIMEOUT_MS / 60000);
+            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`);
@@ -1363,13 +1411,13 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                     } catch { /* report may not exist, not critical */ }
                     task.resolution = principleCreated ? 'late_marker_principle_created' : 'late_marker_no_principle';
                 } else {
-                    if (logger) logger.info(`[PD:EvolutionWorker] Pain diagnosis task ${task.id} timed out after ${timeoutMinutes} minutes`);
+                    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 = 'diagnostician_timeout';
+                    task.resolution = 'auto_completed_timeout';
                 }
 
                 // Critical: mark task as completed so it doesn't get re-processed
@@ -1395,7 +1443,7 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                     sessionId: task.assigned_session_key || 'heartbeat:diagnostician',
                     taskId: task.id,
                     outcome: 'timeout',
-                    summary: `Pain diagnosis task ${task.id} timed out after ${timeoutMinutes} minutes.`
+                    summary: `Task ${task.id} auto-completed after ${timeoutMinutes} minute timeout.`
                 });
                 queueChanged = true;
             }
@@ -1637,8 +1685,10 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                      
                     let workflowId: string | undefined;
                      
+                     
                     let nocturnalManager: NocturnalWorkflowManager;
                      
+                     
                     let snapshotData: NocturnalSessionSnapshot | undefined;
 
                     if (isPollingTask) {
@@ -1902,6 +1952,159 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
             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];
+        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)
+            fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
+            releaseLock();
+            lockReleased = true;
+
+            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';
+                            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';
+                            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';
+                    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);
+                    }
+                }
+                fs.writeFileSync(queuePath, JSON.stringify(freshQueue, null, 2));
+            } catch (koResultErr) {
+                logger?.warn?.(`[PD:EvolutionWorker] Failed to write keyword_optimization results: ${String(koResultErr)}`);
+            } finally {
+                koResultLock();
+            }
+            return;
+        }
+
         if (queueChanged) {
             atomicWriteFileSync(queuePath, JSON.stringify(queue, null, 2));
         }
@@ -1930,7 +2133,6 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
 }
 
      
- 
 async function processDetectionQueue(wctx: WorkspaceContext, api: OpenClawPluginApi, eventLog: EventLog) {
     const {logger} = api;
     try {
@@ -2063,8 +2265,10 @@ function writeWorkerStatus(stateDir: string, report: WorkerStatusReport): void {
     try {
         const statusPath = path.join(stateDir, 'worker-status.json');
         atomicWriteFileSync(statusPath, JSON.stringify(report, null, 2));
-    } catch {
+    } catch (statusErr) {
         // Non-critical: worker-status.json is for monitoring, failure is acceptable
+        // (no logger available in this standalone helper)
+        void statusErr;
     }
 }
 
@@ -2118,7 +2322,6 @@ export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
     api: null,
     _startedWorkspaces: new Set<string>(),
 
-     
     start(ctx: OpenClawPluginServiceContext): void {
         const workspaceDir = ctx?.workspaceDir;
         const logger = ctx?.logger || console;
@@ -2147,7 +2350,6 @@ export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
         const {config} = wctx;
         const language = config.get('language') || 'en';
         ensureStateTemplates({ logger }, wctx.stateDir, language);
-        ensureCorePrinciples(wctx.stateDir, logger);
 
         const initialDelay = 5000;
         const interval = config.get('intervals.worker_poll_ms') || (15 * 60 * 1000);
@@ -2155,7 +2357,6 @@ export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
         // Periodic trigger tracking
         let heartbeatCounter = 0;
 
-         
         async function runCycle(): Promise<void> {
             const cycleStart = Date.now();
             heartbeatCounter++;
@@ -2198,7 +2399,17 @@ export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
                 }
 
                 // Path 2: Periodic trigger (fires regardless of idle state)
+                // keyword_optimization fires every period_heartbeats (CORR-07).
+                // IMPORTANT: check keyword_optimization BEFORE resetting counter for sleep_reflection.
                 if (sleepConfig.trigger_mode === 'periodic') {
+                    // keyword_optimization check BEFORE counter reset (CORR-07 fix)
+                    if (heartbeatCounter > 0 && heartbeatCounter % sleepConfig.period_heartbeats === 0) {
+                        logger?.info?.(`[PD:EvolutionWorker] Periodic keyword_optimization trigger at heartbeat ${heartbeatCounter}`);
+                        enqueueKeywordOptimizationTask(wctx, logger).catch((err) => {
+                            logger?.error?.(`[PD:EvolutionWorker] Failed to enqueue keyword_optimization task: ${String(err)}`);
+                        });
+                    }
+
                     if (heartbeatCounter >= sleepConfig.period_heartbeats) {
                         logger?.info?.(`[PD:EvolutionWorker] Periodic trigger: heartbeatCounter=${heartbeatCounter} >= period_heartbeats=${sleepConfig.period_heartbeats}`);
                         shouldTrySleepReflection = true;
@@ -2236,21 +2447,23 @@ export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
                 // 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.
-                //
-                // P3 (#299): Use requestHeartbeatNow instead of runHeartbeatOnce.
-                // requestHeartbeatNow enters the wake layer which auto-retries on
-                // requests-in-flight (1s intervals). runHeartbeatOnce was a one-shot
-                // that got permanently skipped when agent was busy.
                 if (painCheckResult.enqueued) {
-                    const canTrigger = !!api?.runtime?.system?.requestHeartbeatNow;
-                    logger.info(`[PD:EvolutionWorker] Pain flag enqueued — requestHeartbeatNow available: ${canTrigger}`);
+                    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) {
-                        api.runtime.system.requestHeartbeatNow({
-                            reason: `pd-pain-diagnosis: pain flag detected, starting diagnostician`,
-                        });
-                        logger.info(`[PD:EvolutionWorker] Heartbeat wake requested — wake layer will auto-retry if busy`);
+                        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] requestHeartbeatNow not available. Diagnostician will start on next regular heartbeat cycle.`);
+                        logger.warn(`[PD:EvolutionWorker] runHeartbeatOnce not available. Diagnostician will start on next regular heartbeat cycle.`);
                     }
                 }