principles-disciple 1.32.0 → 1.34.0

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 } from '../core/init.js';
+import { ensureStateTemplates, ensureCorePrinciples } 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';
@@ -32,6 +32,14 @@ import { validateNocturnalSnapshotIngress } from '../core/nocturnal-snapshot-con
 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);
+}
+
 const WORKFLOW_TTL_MS = 5 * 60 * 1000; // 5 minutes default TTL for helper workflows
 import { OpenClawTrinityRuntimeAdapter } from '../core/nocturnal-trinity.js';
 
@@ -48,6 +56,7 @@ interface WatchdogResult {
   details: string[];
 }
 
+ 
 async function runWorkflowWatchdog(
   wctx: WorkspaceContext,
   api: OpenClawPluginApi | null,
@@ -63,104 +72,10 @@ async function runWorkflowWatchdog(
     try {
       const allWorkflows: WorkflowRow[] = store.listWorkflows();
 
-      // Check 1: Stale active workflows (active > 2x TTL)
-      const staleThreshold = WORKFLOW_TTL_MS * 2;
-      const staleActive = allWorkflows.filter(
-        (wf: WorkflowRow) => wf.state === 'active' && (now - wf.created_at) > staleThreshold,
-      );
-      if (staleActive.length > 0) {
-        for (const wf of staleActive) {
-          const ageMin = Math.round((now - wf.created_at) / 60000);
-          details.push(`stale_active: ${wf.workflow_id} (${wf.workflow_type}, ${ageMin}min old)`);
-
-          // #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}`);
-              }
-            }
-          }
-        }
-      }
+      runWorkflowWatchdogCheckStale(allWorkflows, store, now, details, subagentRuntime, agentSession, logger);
+      runWorkflowWatchdogCheckUncleared(allWorkflows, details);
+      runWorkflowWatchdogCheckNocturnal(allWorkflows, details);
 
-      // 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;
@@ -181,6 +96,106 @@ 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;
 
 /**
@@ -193,7 +208,12 @@ 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';
+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;
 
 /**
  * Recent pain context attached to sleep_reflection tasks.
@@ -355,6 +375,7 @@ function isSessionAtOrBeforeTriggerTime(
     return true;
 }
 
+ 
 function buildFallbackNocturnalSnapshot(
     sleepTask: EvolutionQueueItem,
     extractor?: ReturnType<typeof createNocturnalTrajectoryExtractor> | null,
@@ -430,7 +451,7 @@ export const LOCK_RETRY_DELAY_MS = 50;
 export const LOCK_STALE_MS = 30_000;
 
  
-// eslint-disable-next-line @typescript-eslint/max-params
+ 
 export function createEvolutionTaskId(
     source: string,
     score: number,
@@ -464,7 +485,7 @@ export async function acquireQueueLock(resourcePath: string, logger: PluginLogge
 }
 
  
-// eslint-disable-next-line @typescript-eslint/max-params
+ 
 async function requireQueueLock(resourcePath: string, logger: PluginLogger | { warn?: (message: string) => void; info?: (message: string) => void } | undefined, scope: string, lockSuffix: string = EVOLUTION_QUEUE_LOCK_SUFFIX): Promise<() => void> {
     try {
         return await acquireQueueLock(resourcePath, logger, lockSuffix);
@@ -480,7 +501,7 @@ export function extractEvolutionTaskId(task: string): string | null {
 }
 
  
-// eslint-disable-next-line @typescript-eslint/max-params
+ 
 function findRecentDuplicateTask(
     queue: EvolutionQueueItem[],
     source: string,
@@ -488,14 +509,14 @@ function findRecentDuplicateTask(
     now: number,
     reason?: string
 ): EvolutionQueueItem | undefined {
-    // eslint-disable-next-line @typescript-eslint/no-use-before-define
+     
     const key = normalizePainDedupKey(source, preview, reason);
     return queue.find((task) => {
         if (task.status === 'completed') return false;
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+         
         const taskTime = new Date(task.enqueued_at || task.timestamp).getTime();
         if (!Number.isFinite(taskTime) || (now - taskTime) > PAIN_QUEUE_DEDUP_WINDOW_MS) return false;
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+         
         return normalizePainDedupKey(task.source, task.trigger_text_preview || '', task.reason) === key;
     });
 }
@@ -550,7 +571,7 @@ function normalizePainDedupKey(source: string, preview: string, reason?: string)
 
  
  
-// eslint-disable-next-line @typescript-eslint/max-params
+ 
 export function hasRecentDuplicateTask(queue: EvolutionQueueItem[], source: string, preview: string, now: number, reason?: string): boolean {
     return !!findRecentDuplicateTask(queue, source, preview, now, reason);
 }
@@ -678,7 +699,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 @typescript-eslint/init-declarations, no-useless-assignment
+     
     let rawQueue: RawQueueItem[] = [];
     try {
         rawQueue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
@@ -693,7 +714,7 @@ function loadEvolutionQueue(queuePath: string): EvolutionQueueItem[] {
  * Build and persist a new sleep_reflection task.
  */
  
-// eslint-disable-next-line @typescript-eslint/max-params
+ 
 function enqueueNewSleepReflectionTask(
     queue: EvolutionQueueItem[],
     recentPainContext: ReturnType<typeof readRecentPainContext>,
@@ -720,7 +741,7 @@ function enqueueNewSleepReflectionTask(
         recentPainContext,
     });
 
-    fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
+    atomicWriteFileSync(queuePath, JSON.stringify(queue, null, 2));
     logger?.info?.(`[PD:EvolutionWorker] Enqueued sleep_reflection task ${taskId}`);
 }
 
@@ -765,7 +786,8 @@ interface ParsedPainValues {
 }
 
  
-// eslint-disable-next-line @typescript-eslint/max-params
+ 
+ 
 async function doEnqueuePainTask(
     wctx: WorkspaceContext, logger: PluginLogger, painFlagPath: string,
     result: WorkerStatusReport['pain_flag'], v: ParsedPainValues,
@@ -811,7 +833,7 @@ async function doEnqueuePainTask(
             retryCount: 0, maxRetries: 3,
         });
 
-        fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
+        atomicWriteFileSync(queuePath, JSON.stringify(queue, null, 2));
         fs.appendFileSync(painFlagPath, `\nstatus: queued\ntask_id: ${taskId}\n`, 'utf8');
         result.enqueued = true;
 
@@ -839,6 +861,7 @@ 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 {
@@ -1012,7 +1035,8 @@ async function checkPainFlag(wctx: WorkspaceContext, logger: PluginLogger): Prom
 }
 
  
-// eslint-disable-next-line @typescript-eslint/max-params
+ 
+ 
 async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogger, eventLog: EventLog, api?: OpenClawPluginApi) {
     const queuePath = wctx.resolve('EVOLUTION_QUEUE');
     if (!fs.existsSync(queuePath)) {
@@ -1290,8 +1314,8 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
             }
 
             const age = Date.now() - startedAt.getTime();
-            if (age > timeout) {
-                const timeoutMinutes = Math.round(timeout / 60000);
+            if (age > PAIN_DIAGNOSIS_TIMEOUT_MS) {
+                const timeoutMinutes = Math.round(PAIN_DIAGNOSIS_TIMEOUT_MS / 60000);
 
                 const timeoutCompleteMarker = path.join(wctx.stateDir, `.evolution_complete_${task.id}`);
                 const timeoutReportPath = path.join(wctx.stateDir, `.diagnostician_report_${task.id}.json`);
@@ -1339,13 +1363,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] Task ${task.id} auto-completed after ${timeoutMinutes} minute timeout`);
+                    if (logger) logger.info(`[PD:EvolutionWorker] Pain diagnosis task ${task.id} timed out after ${timeoutMinutes} minutes`);
                     // #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';
+                    task.resolution = 'diagnostician_timeout';
                 }
 
                 // Critical: mark task as completed so it doesn't get re-processed
@@ -1371,7 +1395,7 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                     sessionId: task.assigned_session_key || 'heartbeat:diagnostician',
                     taskId: task.id,
                     outcome: 'timeout',
-                    summary: `Task ${task.id} auto-completed after ${timeoutMinutes} minute timeout.`
+                    summary: `Pain diagnosis task ${task.id} timed out after ${timeoutMinutes} minutes.`
                 });
                 queueChanged = true;
             }
@@ -1595,7 +1619,7 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
 
             // Write claimed state (includes any pain changes from above) and release lock
             if (queueChanged) {
-                fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
+                atomicWriteFileSync(queuePath, JSON.stringify(queue, null, 2));
             }
             releaseLock();
             for (const sleepTask of sleepReflectionTasks) {
@@ -1610,11 +1634,11 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                         logger?.info?.(`[PD:EvolutionWorker] Processing sleep_reflection task ${sleepTask.id}`);
                     }
 
-                    // eslint-disable-next-line @typescript-eslint/init-declarations
+                     
                     let workflowId: string | undefined;
-                    // eslint-disable-next-line @typescript-eslint/init-declarations
+                     
                     let nocturnalManager: NocturnalWorkflowManager;
-                    // eslint-disable-next-line @typescript-eslint/init-declarations
+                     
                     let snapshotData: NocturnalSessionSnapshot | undefined;
 
                     if (isPollingTask) {
@@ -1652,13 +1676,13 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                                     s => s.failureCount > 0 || s.painEventCount > 0 || s.gateBlockCount > 0
                                 );
                                 if (sessionsWithViolations.length > 0) {
-                                    // eslint-disable-next-line @typescript-eslint/prefer-destructuring
+                                     
                                     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
-                                    // eslint-disable-next-line @typescript-eslint/prefer-destructuring
+                                     
                                     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);
@@ -1728,7 +1752,7 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                             },
                         });
                         sleepTask.resultRef = workflowHandle.workflowId;
-                        // eslint-disable-next-line @typescript-eslint/prefer-destructuring
+                         
                         workflowId = workflowHandle.workflowId;
                     }
 
@@ -1847,7 +1871,7 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
                             freshQueue[idx] = sleepTask;
                         }
                     }
-                    fs.writeFileSync(queuePath, JSON.stringify(freshQueue, null, 2), 'utf8');
+                    atomicWriteFileSync(queuePath, JSON.stringify(freshQueue, null, 2));
 
                     // Log completions to EvolutionLogger
                     for (const sleepTask of sleepReflectionTasks) {
@@ -1879,7 +1903,7 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
         }
 
         if (queueChanged) {
-            fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
+            atomicWriteFileSync(queuePath, JSON.stringify(queue, null, 2));
         }
 
         // Pipeline observability: log stage-level summary at end of cycle
@@ -1906,6 +1930,7 @@ async function processEvolutionQueue(wctx: WorkspaceContext, logger: PluginLogge
 }
 
      
+ 
 async function processDetectionQueue(wctx: WorkspaceContext, api: OpenClawPluginApi, eventLog: EventLog) {
     const {logger} = api;
     try {
@@ -1961,7 +1986,7 @@ async function processDetectionQueue(wctx: WorkspaceContext, api: OpenClawPlugin
 // Evolution queue is now the single active pain→principle path
 
  
-// eslint-disable-next-line @typescript-eslint/max-params
+ 
 export async function registerEvolutionTaskSession(
     workspaceResolve: (key: string) => string,
     taskId: string,
@@ -1975,7 +2000,7 @@ export async function registerEvolutionTaskSession(
 
     try {
          
-        // eslint-disable-next-line @typescript-eslint/init-declarations
+         
         let rawQueue: RawQueueItem[];
         try {
             rawQueue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
@@ -1997,7 +2022,7 @@ export async function registerEvolutionTaskSession(
         if (!task.started_at) {
             task.started_at = new Date().toISOString();
         }
-        fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
+        atomicWriteFileSync(queuePath, JSON.stringify(queue, null, 2));
         return true;
     } finally {
         releaseLock();
@@ -2037,14 +2062,14 @@ interface WorkerStatusReport {
 function writeWorkerStatus(stateDir: string, report: WorkerStatusReport): void {
     try {
         const statusPath = path.join(stateDir, 'worker-status.json');
-        fs.writeFileSync(statusPath, JSON.stringify(report, null, 2), 'utf8');
+        atomicWriteFileSync(statusPath, JSON.stringify(report, null, 2));
     } catch {
         // Non-critical: worker-status.json is for monitoring, failure is acceptable
     }
 }
 
  
-// eslint-disable-next-line @typescript-eslint/max-params
+ 
 async function processEvolutionQueueWithResult(
     wctx: WorkspaceContext,
     logger: PluginLogger,
@@ -2066,7 +2091,7 @@ async function processEvolutionQueueWithResult(
         const purgeResult = purgeStaleFailedTasks(queue, logger);
         if (purgeResult.purged > 0) {
             // Write back the cleaned queue
-            fs.writeFileSync(queuePath, JSON.stringify(queue, null, 2), 'utf8');
+            atomicWriteFileSync(queuePath, JSON.stringify(queue, null, 2));
         }
 
         queueResult.total = queue.length;
@@ -2093,6 +2118,7 @@ export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
     api: null,
     _startedWorkspaces: new Set<string>(),
 
+     
     start(ctx: OpenClawPluginServiceContext): void {
         const workspaceDir = ctx?.workspaceDir;
         const logger = ctx?.logger || console;
@@ -2121,6 +2147,7 @@ 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);
@@ -2128,6 +2155,7 @@ export const EvolutionWorkerService: ExtendedEvolutionWorkerService = {
         // Periodic trigger tracking
         let heartbeatCounter = 0;
 
+         
         async function runCycle(): Promise<void> {
             const cycleStart = Date.now();
             heartbeatCounter++;
@@ -2208,23 +2236,21 @@ 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?.runHeartbeatOnce;
-                    logger.info(`[PD:EvolutionWorker] Pain flag enqueued — runHeartbeatOnce available: ${canTrigger} (api=${!!api}, runtime=${!!api?.runtime}, system=${!!api?.runtime?.system})`);
+                    const canTrigger = !!api?.runtime?.system?.requestHeartbeatNow;
+                    logger.info(`[PD:EvolutionWorker] Pain flag enqueued — requestHeartbeatNow available: ${canTrigger}`);
                     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.`);
-                        }
+                        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`);
                     } else {
-                        logger.warn(`[PD:EvolutionWorker] runHeartbeatOnce not available. Diagnostician will start on next regular heartbeat cycle.`);
+                        logger.warn(`[PD:EvolutionWorker] requestHeartbeatNow not available. Diagnostician will start on next regular heartbeat cycle.`);
                     }
                 }
 

package/src/service/nocturnal-service.ts

@@ -385,7 +385,10 @@ function persistArtifact(
     fs.mkdirSync(dir, { recursive: true });
   }
 
-  fs.writeFileSync(artifactPath, JSON.stringify(sampleRecord, null, 2), 'utf-8');
+  // Atomic write: temp file + rename prevents corruption on crash
+  const tmpPath = artifactPath + '.tmp';
+  fs.writeFileSync(tmpPath, JSON.stringify(sampleRecord, null, 2), 'utf8');
+  fs.renameSync(tmpPath, artifactPath);
   return artifactPath;
 }
 

package/src/service/subagent-workflow/index.ts

@@ -36,6 +36,20 @@ export {
     type NocturnalResult,
 } from './nocturnal-workflow-manager.js';
 
+// TODO: correction-observer-workflow-manager.ts is missing from repo
+// export {
+//     CorrectionObserverWorkflowManager,
+//     createCorrectionObserverWorkflowManager,
+//     correctionObserverWorkflowSpec,
+//     type CorrectionObserverWorkflowOptions,
+// } from './correction-observer-workflow-manager.js';
+
+// export type {
+//     CorrectionObserverWorkflowSpec,
+//     CorrectionObserverPayload,
+//     CorrectionObserverResult,
+// } from './correction-observer-types.js';
+
 export type {
     WorkflowState,
     WorkflowTransport,

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

@@ -311,7 +311,9 @@ export class NocturnalWorkflowManager implements WorkflowManager {
                         this.logger.warn(`[PD:NocturnalWorkflow] [${workflowId}] Arbiter result: passed=${result.diagnostics.arbiterResult.passed}, failures=${result.diagnostics.arbiterResult.failures.map(f => f.reason).join('; ')}`);
                     }
                     if (result.diagnostics?.selection) {
-                        this.logger.warn(`[PD:NocturnalWorkflow] [${workflowId}] Selection: decision=${result.diagnostics.selection.decision}, principleId=${result.diagnostics.selection.selectedPrincipleId ?? 'none'}, sessionId=${result.diagnostics.selection.selectedSessionId ?? 'none'}`);
+                        const sel = result.diagnostics.selection;
+                        const diag = sel.diagnostics;
+                        this.logger.warn(`[PD:NocturnalWorkflow] [${workflowId}] Selection: decision=${sel.decision}, principleId=${sel.selectedPrincipleId ?? 'none'}, sessionId=${sel.selectedSessionId ?? 'none'}, totalEvaluable=${diag.totalEvaluablePrinciples ?? 0}, filteredByCooldown=${diag.filteredByCooldown ?? 0}, passed=${diag.passedPrinciples?.length ?? 0}`);
                     }
                     
                     this.store.updateWorkflowState(workflowId, 'terminal_error');