principles-disciple 1.71.0 → 1.73.0

package/src/service/queue-io.ts

@@ -3,7 +3,7 @@
  *
  * Full persistence layer encapsulating queue file locking, atomic writes,
  * queue format, and enqueue orchestration. Depends on file-lock.ts, io.ts,
- * queue-migration.ts, correction-cue-learner.ts, and pain.ts.
+ * queue-migration.ts, and pain.ts.
  * Zero imports from evolution-worker.ts.
  */
 
@@ -16,364 +16,93 @@ import { migrateQueueToV2 } from './queue-migration.js';
 import type { EvolutionQueueItem } from '../core/evolution-types.js';
 import type { RawQueueItem } from './queue-migration.js';
 import type { PluginLogger } from '../openclaw-sdk.js';
-import type { WorkspaceContext } from '../core/workspace-context.js';
-import { CorrectionCueLearner } from '../core/correction-cue-learner.js';
-import { readPainFlagContract } from '../core/pain.js';
-
-/**
- * Extended EvolutionQueueItem that includes the recentPainContext field.
- * This field is added inline in evolution-worker.ts but needs to be available
- * in queue-io.ts for the enqueue functions.
- */
-interface EvolutionQueueItemWithPain extends EvolutionQueueItem {
-    recentPainContext?: RecentPainContext;
-}
 
 export const EVOLUTION_QUEUE_LOCK_SUFFIX = '.lock';
 export const LOCK_MAX_RETRIES = 50;
 export const LOCK_RETRY_DELAY_MS = 50;
 export const LOCK_STALE_MS = 30_000;
 
-export const SLEEP_REFLECTION_DEDUP_WINDOW_MS = 4 * 60 * 60 * 1000; // 4 hours
-
-// ---------------------------------------------------------------------------
-// requireQueueLock — thin wrapper that adds LockUnavailableError
-// ---------------------------------------------------------------------------
-
-/**
- * Acquire a queue lock, throwing LockUnavailableError on failure.
- * This is the standard lock used across all queue operations.
- */
 export async function requireQueueLock(
-    resourcePath: string,
-    logger: PluginLogger | { warn?: (message: string) => void; info?: (message: string) => void } | undefined,
-    scope: string,
-    lockSuffix: string = EVOLUTION_QUEUE_LOCK_SUFFIX,
+  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);
-    } catch (err) {
-        throw new LockUnavailableError(resourcePath, scope, { cause: err });
-    }
+  try {
+    return await acquireQueueLock(resourcePath, logger, lockSuffix);
+  } catch (err) {
+    throw new LockUnavailableError(resourcePath, scope, { cause: err });
+  }
 }
 
-// ---------------------------------------------------------------------------
-// RecentPainContext
-// ---------------------------------------------------------------------------
-
-export interface RecentPainContext {
-    mostRecent: {
-        score: number;
-        source: string;
-        reason: string;
-        timestamp: string;
-        sessionId: string;
-        /** Trajectory pain_events row ID — set when pain flag includes pain_event_id */
-        painEventId?: number;
-    } | null;
-    recentPainCount: number;
-    recentMaxPainScore: number;
-}
-
-// ---------------------------------------------------------------------------
-// Task ID creation
-// ---------------------------------------------------------------------------
-
 export function createEvolutionTaskId(
-    source: string,
-    score: number,
-    preview: string,
-    reason: string,
-    now: number,
+  source: string,
+  score: number,
+  preview: string,
+  reason: string,
+  now: number,
 ): string {
-    return createHash('md5')
-        .update(`${source}:${score}:${preview}:${reason}:${now}`)
-        .digest('hex')
-        .substring(0, 8);
+  return createHash('md5')
+    .update(`${source}:${score}:${preview}:${reason}:${now}`)
+    .digest('hex')
+    .substring(0, 8);
 }
 
-// ---------------------------------------------------------------------------
-// Queue helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Check whether a specific task kind has a pending or in-progress entry.
- */
 export function hasPendingTask(queue: EvolutionQueueItem[], taskKind: string): boolean {
-    return queue.some(
-        (t) => t.taskKind === taskKind && (t.status === 'pending' || t.status === 'in_progress'),
-    );
-}
-
-/**
- * Build a dedup key from pain context.
- * Returns null when no pain context is available (bypasses dedup).
- */
-function buildPainSourceKey(
-    painCtx: ReturnType<typeof readRecentPainContext>,
-): string | null {
-    if (!painCtx.mostRecent) return null;
-    return `${painCtx.mostRecent.source}::${painCtx.mostRecent.reason?.slice(0, 50) ?? ''}`;
-}
-
-/**
- * Check whether a similar sleep_reflection task completed recently.
- */
-function hasRecentSimilarReflection(
-    queue: EvolutionQueueItemWithPain[],
-    painSourceKey: string,
-    now: number,
-): EvolutionQueueItem | null {
-    return queue.find((t) => {
-        if (t.taskKind !== 'sleep_reflection') return false;
-        if (t.status !== 'completed') return false;
-        if (!t.completed_at) return false;
-        const age = now - new Date(t.completed_at).getTime();
-        if (age > SLEEP_REFLECTION_DEDUP_WINDOW_MS) return false;
-        const taskPainKey = buildPainSourceKey(t.recentPainContext ?? { mostRecent: null, recentPainCount: 0, recentMaxPainScore: 0 });
-        if (!taskPainKey) return false;
-        return taskPainKey === painSourceKey;
-    }) ?? null;
-}
-
-// ---------------------------------------------------------------------------
-// Pain context
-// ---------------------------------------------------------------------------
-
-export function readRecentPainContext(wctx: WorkspaceContext): RecentPainContext {
-    const contract = readPainFlagContract(wctx.workspaceDir);
-    if (contract.status !== 'valid') {
-        return { mostRecent: null, recentPainCount: 0, recentMaxPainScore: 0 };
-    }
-
-    try {
-        const score = parseInt(contract.data.score ?? '0', 10) || 0;
-        const source = contract.data.source ?? '';
-        const reason = contract.data.reason ?? '';
-        const timestamp = contract.data.time ?? '';
-        const sessionId = contract.data.session_id ?? '';
-        const painEventIdRaw = contract.data.pain_event_id;
-        const painEventId = painEventIdRaw ? parseInt(painEventIdRaw, 10) : undefined;
-
-        if (score > 0) {
-            return {
-                mostRecent: { score, source, reason, timestamp, sessionId, painEventId },
-                recentPainCount: 1,
-                recentMaxPainScore: score,
-            };
-        }
-    } catch (err) {
-      // Best effort — non-fatal, but surface unexpected errors
-       
-      console.warn(`[queue-io] Failed to read pain context (non-fatal): ${String(err)}`);
-       
-    }
-
-    return { mostRecent: null, recentPainCount: 0, recentMaxPainScore: 0 };
-}
-
-/**
- * Decide whether to skip enqueuing due to a recent similar reflection.
- */
-export function shouldSkipForDedup(
-    queue: EvolutionQueueItemWithPain[],
-    wctx: WorkspaceContext,
-    logger: PluginLogger | undefined,
-): boolean {
-    const recentPainContext = readRecentPainContext(wctx);
-    const painSourceKey = buildPainSourceKey(recentPainContext);
-
-    if (!painSourceKey) return false;
-
-    const now = Date.now();
-    const recentSimilarReflection = hasRecentSimilarReflection(queue, painSourceKey, now);
-
-    if (recentSimilarReflection) {
-        const completedTime = new Date(recentSimilarReflection.completed_at!).getTime();  
-        logger?.debug?.(`[PD:EvolutionWorker] Skipping sleep_reflection — similar reflection completed ${Math.round((now - completedTime) / 60000)}min ago (same pain pattern: ${painSourceKey})`);
-        return true;
-    }
-    return false;
-}
-
-// ---------------------------------------------------------------------------
-// Enqueue functions
-// ---------------------------------------------------------------------------
-
-function enqueueNewSleepReflectionTask(
-    queue: EvolutionQueueItemWithPain[],
-    recentPainContext: ReturnType<typeof readRecentPainContext>,
-    queuePath: string,
-    logger: PluginLogger | undefined,
-): void {
-    const taskId = createEvolutionTaskId('nocturnal', 50, 'idle workspace', 'Sleep-mode reflection', Date.now());
-    const nowIso = new Date().toISOString();
-
-    queue.push({
-        id: taskId,
-        taskKind: 'sleep_reflection',
-        priority: 'medium',
-        score: 50,
-        source: 'nocturnal',
-        reason: 'Sleep-mode reflection triggered by idle workspace',
-        trigger_text_preview: 'Idle workspace detected',
-        timestamp: nowIso,
-        enqueued_at: nowIso,
-        status: 'pending',
-        traceId: taskId,
-        retryCount: 0,
-        maxRetries: 1,
-        recentPainContext,
-    });
-
-    // Cast to EvolutionQueueItem[] because saveEvolutionQueue expects the base type
-    // but the queue may contain extended fields (recentPainContext) that are
-    // serialized as part of the JSON - this is safe at runtime.
-    saveEvolutionQueue(queuePath, queue as unknown as EvolutionQueueItem[]);
-    logger?.info?.(`[PD:EvolutionWorker] Enqueued sleep_reflection task ${taskId}`);
-}
-
-/**
- * Enqueue a sleep_reflection task if one is not already pending.
- */
-export async function enqueueSleepReflectionTask(
-    wctx: WorkspaceContext,
-    logger: PluginLogger | undefined,
-): Promise<void> {
-    const queuePath = wctx.resolve('EVOLUTION_QUEUE');
-    const releaseLock = await requireQueueLock(queuePath, logger, 'enqueueSleepReflection', EVOLUTION_QUEUE_LOCK_SUFFIX);
-
-    try {
-        const queue = loadEvolutionQueue(queuePath);
-
-        if (hasPendingTask(queue, 'sleep_reflection')) {
-            logger?.debug?.('[PD:EvolutionWorker] sleep_reflection task already pending/in-progress, skipping');
-            return;
-        }
-
-        if (shouldSkipForDedup(queue, wctx, logger)) {
-            return;
-        }
-
-        const recentPainContext = readRecentPainContext(wctx);
-        enqueueNewSleepReflectionTask(queue, recentPainContext, queuePath, logger);
-    } finally {
-        releaseLock();
-    }
-}
-
-/**
- * Enqueue a keyword_optimization task if one is not already pending/in-progress.
- */
-export async function enqueueKeywordOptimizationTask(
-    wctx: WorkspaceContext,
-    logger: PluginLogger | undefined,
-): Promise<void> {
-    const queuePath = wctx.resolve('EVOLUTION_QUEUE');
-    const releaseLock = await requireQueueLock(queuePath, logger, 'enqueueKeywordOpt', EVOLUTION_QUEUE_LOCK_SUFFIX);
-
-    try {
-        const queue = loadEvolutionQueue(queuePath);
-
-        if (hasPendingTask(queue, 'keyword_optimization')) {
-            logger?.debug?.('[PD:EvolutionWorker] keyword_optimization task already pending/in-progress, skipping');
-            return;
-        }
-
-        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,
-        });
-
-        saveEvolutionQueue(queuePath, queue);
-        logger?.info?.(`[PD:EvolutionWorker] Enqueued keyword_optimization task ${taskId}`);
-    } finally {
-        releaseLock();
-    }
+  return queue.some(
+    (t) => t.taskKind === taskKind && (t.status === 'pending' || t.status === 'in_progress'),
+  );
 }
 
 export async function acquireQueueLock(
-    resourcePath: string,
-    logger: PluginLogger | { warn?: (message: string) => void; info?: (message: string) => void } | undefined,
-    lockSuffix: string = EVOLUTION_QUEUE_LOCK_SUFFIX,
+  resourcePath: string,
+  logger: PluginLogger | { warn?: (message: string) => void; info?: (message: string) => void } | undefined,
+  lockSuffix: string = EVOLUTION_QUEUE_LOCK_SUFFIX,
 ): Promise<() => void> {
-    try {
-        const ctx: LockContext = await acquireLockAsync(resourcePath, {
-            lockSuffix,
-            maxRetries: LOCK_MAX_RETRIES,
-            baseRetryDelayMs: LOCK_RETRY_DELAY_MS,
-            lockStaleMs: LOCK_STALE_MS,
-        });
-        return () => releaseImportedLock(ctx);
-    } catch (error: unknown) {
-        const warn = logger?.warn;
-        warn?.(`[PD:EvolutionWorker] Failed to acquire lock for ${resourcePath}: ${String(error)}`);
-        throw error;
-    }
+  try {
+    const ctx: LockContext = await acquireLockAsync(resourcePath, {
+      lockSuffix,
+      maxRetries: LOCK_MAX_RETRIES,
+      baseRetryDelayMs: LOCK_RETRY_DELAY_MS,
+      lockStaleMs: LOCK_STALE_MS,
+    });
+    return () => releaseImportedLock(ctx);
+  } catch (error: unknown) {
+    const warn = logger?.warn;
+    warn?.(`[PD:EvolutionWorker] Failed to acquire lock for ${resourcePath}: ${String(error)}`);
+    throw error;
+  }
 }
 
-/**
- * RAII-style lock guard — always releases the lock on exceptions.
- */
 export async function withQueueLock<T>(
-    resourcePath: string,
-    logger: PluginLogger | { warn?: (message: string) => void; info?: (message: string) => void } | undefined,
-    scope: string,
-    fn: () => Promise<T>,
+  resourcePath: string,
+  logger: PluginLogger | { warn?: (message: string) => void; info?: (message: string) => void } | undefined,
+  scope: string,
+  fn: () => Promise<T>,
 ): Promise<T> {
-    const releaseLock = await acquireQueueLock(resourcePath, logger, EVOLUTION_QUEUE_LOCK_SUFFIX);
-    try {
-        return await fn();
-    } finally {
-        releaseLock();
-    }
+  const releaseLock = await acquireQueueLock(resourcePath, logger, EVOLUTION_QUEUE_LOCK_SUFFIX);
+  try {
+    return await fn();
+  } finally {
+    releaseLock();
+  }
 }
 
-/**
- * Load and migrate the evolution queue. Returns empty array if file doesn't exist.
- */
 export function loadEvolutionQueue(queuePath: string): EvolutionQueueItem[] {
-    let rawQueue: RawQueueItem[] = [];
-    try {
-        rawQueue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
-    } catch (err) {
-        if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
-            // Queue doesn't exist yet - create empty array
-            rawQueue = [];
-        } else {
-            // Corrupted JSON or other read error — warn and recover with empty queue
-             
-            console.warn(`[queue-io] Failed to load evolution queue (recovering with empty): ${String(err)}`);
-             
-            rawQueue = [];
-        }
+  let rawQueue: RawQueueItem[] = [];
+  try {
+    rawQueue = JSON.parse(fs.readFileSync(queuePath, 'utf8'));
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+      rawQueue = [];
+    } else {
+      console.warn(`[queue-io] Failed to load evolution queue (recovering with empty): ${String(err)}`);
+      rawQueue = [];
     }
-    return migrateQueueToV2(rawQueue) as unknown as EvolutionQueueItem[];
+  }
+  return migrateQueueToV2(rawQueue) as unknown as EvolutionQueueItem[];
 }
 
-/**
- * Atomically write the queue to disk.
- */
 export function saveEvolutionQueue(queuePath: string, queue: EvolutionQueueItem[]): void {
-    atomicWriteFileSync(queuePath, JSON.stringify(queue, null, 2));
+  atomicWriteFileSync(queuePath, JSON.stringify(queue, null, 2));
 }

package/src/service/runtime-summary-service.ts

@@ -1,13 +1,15 @@
 import * as fs from 'fs';
+import Database from 'better-sqlite3';
 import * as path from 'path';
 import { readPainFlagData } from '../core/pain.js';
 import { listSessions } from '../core/session-tracker.js';
 import { WorkspaceContext } from '../core/workspace-context.js';
 import { evaluatePhase3Inputs } from './phase3-input-filter.js';
 import { TrajectoryRegistry } from '../core/trajectory.js';
-import { getPendingDiagnosticianTasks } from '../core/diagnostician-task-store.js';
 import type { WorkflowStage } from '../core/workflow-funnel-loader.js';
 import type { RuntimeTruth, AnalyticsTruth } from '../types/runtime-summary.js';
+import { buildGfiWorkspaceSnapshot } from '@principles/core/runtime-v2';
+import type { GfiWorkspaceSnapshot } from '@principles/core/runtime-v2';
 
 export type RuntimeDataQuality = 'authoritative' | 'partial';
 export type RuntimeRewardPolicy =
@@ -47,6 +49,7 @@ export interface RuntimeSummary {
     peak: number | null;
     sources: RuntimeSummarySource[];
     dataQuality: RuntimeDataQuality;
+    workspaceSnapshot?: GfiWorkspaceSnapshot;
   };
   evolution: {
     queue: {
@@ -62,8 +65,8 @@ export interface RuntimeSummary {
     };
     dataQuality: RuntimeDataQuality;
   };
-  // D: Heartbeat Diagnostician chain — separate from evolution/nocturnal chain
-  heartbeatDiagnosis: {
+  // D: Runtime Diagnostician chain (M8) — replaced legacy heartbeat path
+  runtimeDiagnosis: {
     /** Tasks pending in diagnostician_tasks.json (not yet processed by heartbeat) */
     pendingTasks: number;
     /** Total diagnosis tasks written by evolution worker (today from event log) */
@@ -123,6 +126,10 @@ export interface RuntimeSummary {
 interface PersistedSessionState {
   sessionId: string;
   currentGfi?: number;
+  gfiBySource?: Record<string, number>;
+  lastErrorSource?: string;
+  consecutiveErrors?: number;
+  lastGfiDecayAt?: number;
   dailyGfiPeak?: number;
   lastActivityAt?: number;
   lastControlActivityAt?: number;
@@ -222,7 +229,7 @@ export class RuntimeSummaryService {
     const selectedSession = this.selectSession(sessions, options?.sessionId ?? null);
     const selectedSessionId = selectedSession.session?.sessionId ?? null;
 
-    const persistedEvents = this.readEvents(path.join(wctx.stateDir, 'logs', 'events.jsonl'), warnings);
+    const persistedEvents = this.readEvents(path.join(wctx.stateDir, 'logs'), warnings);
     const hasBufferedEventAccess =
       typeof (wctx.eventLog as { getBufferedEvents?: () => EventLogEntry[] }).getBufferedEvents === 'function';
     const bufferedEvents = hasBufferedEventAccess
@@ -311,6 +318,23 @@ export class RuntimeSummaryService {
     const gfiPeak =
       sessionPeak ?? (Number.isFinite(dailyGfiPeak) ? Number(dailyGfiPeak) : null);
 
+    // PRI-78/PRI-82: Build authoritative GFI workspace snapshot (active vs stale)
+    // Uses real persisted GFI fields: gfiBySource, consecutiveErrors, lastErrorSource,
+    // lastGfiDecayAt, dailyGfiPeak from session-tracker persistence.
+    const gfiWorkspaceSnapshot: GfiWorkspaceSnapshot = buildGfiWorkspaceSnapshot({
+      sessions: sessions.map((s) => ({
+        sessionId: s.sessionId,
+        currentGfi: s.currentGfi ?? 0,
+        gfiBySource: s.gfiBySource ?? {},
+        consecutiveErrors: s.consecutiveErrors ?? 0,
+        lastErrorSource: s.lastErrorSource,
+        lastGfiDecayAt: s.lastGfiDecayAt,
+        dailyGfiPeak: s.dailyGfiPeak,
+        lastActivityAt: s.lastControlActivityAt ?? s.lastActivityAt ?? 0,
+      })),
+      nowMs: Date.now(),
+    });
+
     pushWarning(warnings, GFI_PARTIAL_WARNING);
     if (sessionPeak === null && Number.isFinite(dailyGfiPeak)) {
       pushWarning(warnings, DAILY_GFI_WARNING);
@@ -343,13 +367,25 @@ export class RuntimeSummaryService {
     const gfiSources = this.buildGfiSources(events, selectedSessionId);
     const gateStats = this.buildGateStats(events, selectedSessionId, warnings);
 
-    // D: Heartbeat Diagnostician chain — separate from evolution/nocturnal chain
-    // Read pending tasks from the diagnostician task store
-    const pendingDiagTasks = getPendingDiagnosticianTasks(wctx.stateDir);
+    // D: Runtime Diagnostician chain (M8) — queries runtime-v2 SQLite task store
     // Read heartbeat diagnosis stats from daily event log
     const diagDailyStats = dailyStats?.[todayStr]?.evolution;
-    const heartbeatDiagnosis = {
-      pendingTasks: pendingDiagTasks.length,
+    let pendingRuntimeDiagTasks = 0;
+    try {
+      const taskStoreDbPath = path.join(wctx.stateDir, '.principles', 'db', 'task-store.db');
+      if (fs.existsSync(taskStoreDbPath)) {
+        const db = new Database(taskStoreDbPath, { readonly: true });
+        const row = db.prepare(`
+          SELECT COUNT(*) as count FROM tasks
+          WHERE task_kind = 'diagnostician' AND status = 'pending'
+        `).get() as { count: number };
+        pendingRuntimeDiagTasks = row?.count ?? 0;
+        db.close();
+      }
+    } catch { /* task store not yet initialized — 0 pending */ }
+    // TODO(PRI-XXX): distinguish "not initialized" from permission/corruption/query errors
+    const runtimeDiagnosis = {
+      pendingTasks: pendingRuntimeDiagTasks,
       tasksWrittenToday: diagDailyStats?.diagnosisTasksWritten ?? 0,
       reportsWrittenToday: diagDailyStats?.diagnosticianReportsWritten ?? 0,
       reportsMissingJsonToday: diagDailyStats?.reportsMissingJson ?? 0,
@@ -358,6 +394,22 @@ export class RuntimeSummaryService {
       heartbeatsInjectedToday: diagDailyStats?.heartbeatsInjected ?? 0,
     };
 
+    // D: Stall detection — high-signal warning when the diagnostician loop appears broken.
+    // Conditions: tasks are being injected (heartbeats > 0) but no reports are being written.
+    if (
+      runtimeDiagnosis.heartbeatsInjectedToday > 0 &&
+      runtimeDiagnosis.reportsWrittenToday === 0 &&
+      runtimeDiagnosis.pendingTasks > 0
+    ) {
+      pushWarning(
+        warnings,
+        'Diagnostician appears stalled: heartbeats are injecting tasks ' +
+        `(${runtimeDiagnosis.heartbeatsInjectedToday}) but no reports are being written. ` +
+        `${runtimeDiagnosis.pendingTasks} task(s) remain pending. ` +
+        'Check prompt injection size limits and diagnostician task processing.'
+      );
+    }
+
     // Read trajectory analytics data (historical data, NOT runtime truth)
     const trajectoryStats = this.readTrajectoryStats(workspaceDir, warnings);
 
@@ -406,6 +458,7 @@ export class RuntimeSummaryService {
         peak: gfiPeak,
         sources: gfiSources,
         dataQuality: 'partial',
+        workspaceSnapshot: gfiWorkspaceSnapshot,
       },
       evolution: {
         queue: queueStats,
@@ -435,8 +488,8 @@ export class RuntimeSummaryService {
         lastSignal: lastPainSignal,
       },
       gate: gateStats,
-      // D: Heartbeat Diagnostician chain — separate from evolution/nocturnal
-      heartbeatDiagnosis,
+      // D: Heartbeat Diagnostician chain
+      runtimeDiagnosis,
       ...(workflowFunnelsOutput && { workflowFunnels: workflowFunnelsOutput }),
       metadata: {
         generatedAt,
@@ -508,6 +561,12 @@ export class RuntimeSummaryService {
         sessionId: live.sessionId,
         currentGfi:
           Number.isFinite(live.currentGfi) ? Number(live.currentGfi) : persisted?.currentGfi,
+        gfiBySource:
+          live.gfiBySource ? { ...live.gfiBySource } : persisted?.gfiBySource,
+        lastErrorSource: live.lastErrorSource || persisted?.lastErrorSource,
+        consecutiveErrors:
+          Number.isFinite(live.consecutiveErrors) ? Number(live.consecutiveErrors) : persisted?.consecutiveErrors,
+        lastGfiDecayAt: live.lastGfiDecayAt || persisted?.lastGfiDecayAt,
         dailyGfiPeak:
           Number.isFinite(live.dailyGfiPeak) ? Number(live.dailyGfiPeak) : persisted?.dailyGfiPeak,
         lastActivityAt:
@@ -596,14 +655,49 @@ export class RuntimeSummaryService {
     };
   }
 
-  private static readEvents(eventsPath: string, warnings: string[]): EventLogEntry[] {
-    if (!fs.existsSync(eventsPath)) {
-      warnings.push('No events.jsonl file exists yet; recent pain and gate summaries are partial.');
+  private static readEvents(logsDir: string, warnings: string[]): EventLogEntry[] {
+    // The event log is stored as daily files: events_YYYY-MM-DD.jsonl.
+    // Prefer today's file; fall back to the most recent daily file so that
+    // gate/pain stats are still populated when the day rolled over.
+    const dir = logsDir;
+
+    let bestFile: string | null = null;
+
+    if (fs.existsSync(dir)) {
+      const today = new Date().toISOString().slice(0, 10); // YYYY-MM-DD
+      // Prefer exact match on today's file
+      const todayFile = path.join(dir, `events_${today}.jsonl`);
+      if (fs.existsSync(todayFile)) {
+        bestFile = todayFile;
+      } else {
+        // Fallback: pick the most recent file by date embedded in the filename
+        // (lexical comparison works for ISO dates YYYY-MM-DD).
+        let newestDate = '';
+        try {
+          for (const file of fs.readdirSync(dir)) {
+            const m = file.match(/^events_(\d{4}-\d{2}-\d{2})\.jsonl$/);
+            if (!m) continue;
+            const fileDate = m[1];
+            if (fileDate > newestDate) {
+              newestDate = fileDate;
+              bestFile = path.join(dir, file);
+            }
+          }
+        } catch { /* ignore scan errors */ }
+      }
+    }
+
+    if (!bestFile) {
+      pushWarning(
+        warnings,
+        'No event log file found; recent pain and gate summaries are partial. ' +
+        'Expected format: events_YYYY-MM-DD.jsonl in the logs directory.'
+      );
       return [];
     }
 
     try {
-      const raw = fs.readFileSync(eventsPath, 'utf8').trim();
+      const raw = fs.readFileSync(bestFile, 'utf8').trim();
       if (!raw) return [];
       let parseFailures = 0;
       const entries = raw
@@ -620,12 +714,15 @@ export class RuntimeSummaryService {
       if (parseFailures > 0) {
         pushWarning(
           warnings,
-          `Skipped ${parseFailures} malformed event line${parseFailures === 1 ? '' : 's'} while reading events.jsonl.`
+          `Skipped ${parseFailures} malformed event line${parseFailures === 1 ? '' : 's'} while reading ${path.basename(bestFile!)}.`
         );
       }
       return entries;
     } catch {
-      pushWarning(warnings, 'Failed to read events.jsonl; recent pain and gate summaries are partial.');
+      pushWarning(
+        warnings,
+        `Failed to read ${path.basename(bestFile!)}; recent pain and gate summaries are partial.`
+      );
       return [];
     }
   }
@@ -657,7 +754,7 @@ export class RuntimeSummaryService {
 
       return {
         source: `tool_failure:${String(entry.data?.toolName ?? 'unknown')}`,
-        score: this.asFiniteNumber(entry.data?.gfi),
+        score: this.asFiniteNumber(entry.data?.gfiAfter ?? entry.data?.gfi),
         ts: entry.ts,
       };
     });