principles-disciple 1.72.0 → 1.73.0

package/src/core/event-log.ts

@@ -1,4 +1,4 @@
- 
+
 import * as fs from 'fs';
 import * as path from 'path';
 import type {
@@ -17,36 +17,23 @@ import type {
   PlanApprovalEventData,
   EvolutionTaskEventData,
   EmpathyRollbackEventData,
-  // C: New event data types
   DiagnosisTaskEventData,
   HeartbeatDiagnosisEventData,
   DiagnosticianReportEventData,
   PrincipleCandidateEventData,
   RuleEnforcedEventData,
-  // C: Nocturnal funnel events (PD-FUNNEL-2.3)
-  NocturnalDreamerCompletedEventData,
-  NocturnalArtifactPersistedEventData,
-  NocturnalCodeCandidateCreatedEventData,
-  // C: RuleHost funnel events (PD-FUNNEL-2.4)
   RuleHostEvaluatedEventData,
   RuleHostBlockedEventData,
   RuleHostRequireApprovalEventData,
+  RuleHostAutoCorrectProposedEventData,
+  RuleHostAutoCorrectAppliedEventData,
+  RuntimeV2PromptActivationsInjectedEventData,
+  RuntimeV2ConfirmFirstGateEventData,
 } from '../types/event-types.js';
 import { createEmptyDailyStats } from '../types/event-types.js';
 import { atomicWriteFileSync } from '../utils/io.js';
 import type { PluginLogger } from '../openclaw-sdk.js';
 
-/**
- * EventLog - Structured event logging with daily statistics aggregation.
- *
- * Log files are date-stamped: events_YYYY-MM-DD.jsonl
- * Old event files are automatically cleaned up based on retention policy.
- */
-
-/**
- * Event log retention in days.
- * Files older than this are deleted on cleanup.
- */
 const EVENT_LOG_RETENTION_DAYS = 7;
 
 export class EventLog {
@@ -60,11 +47,9 @@ export class EventLog {
   private readonly flushIntervalMs = 30000;
   private flushTimer?: ReturnType<typeof setInterval>;
 
-  // Cached event file path for current date
   private currentEventsFile: string | undefined;
   private currentDate: string | undefined;
 
-  // Pain score sum per date (for avgScore calculation)
   private readonly painScoreSums: Map<string, number> = new Map();
 
   constructor(stateDir: string, logger?: PluginLogger) {
@@ -80,37 +65,24 @@ export class EventLog {
     this.startFlushTimer();
   }
 
-  /**
-   * Get the event file path for a given date.
-   */
   private getEventsFile(date: string): string {
     return path.join(this.logsDir, `events_${date}.jsonl`);
   }
 
-  /**
-   * Get today's date string (YYYY-MM-DD).
-   */
   private getTodayStr(): string {
     return new Date().toISOString().split('T')[0];
   }
 
-  /**
-   * Ensure we have the correct events file for today's date.
-   */
   private ensureEventsFile(): string {
     const today = this.getTodayStr();
     if (this.currentDate !== today || !this.currentEventsFile) {
       this.currentDate = today;
       this.currentEventsFile = this.getEventsFile(today);
-      // Run cleanup if date changed
       this.cleanupOldEventFiles(today);
     }
     return this.currentEventsFile;
   }
 
-  /**
-   * Clean up event files older than EVENT_LOG_RETENTION_DAYS.
-   */
   private cleanupOldEventFiles(_today: string): void {
     if (EVENT_LOG_RETENTION_DAYS <= 0) return;
 
@@ -133,7 +105,7 @@ export class EventLog {
   }
   
   recordToolCall(sessionId: string | undefined, data: ToolCallEventData): void {
-    const category = data.error ? 'failure' : 'success';
+    const category = data.error || (data.exitCode !== undefined && data.exitCode !== 0) ? 'failure' : 'success';
     this.record('tool_call', category, sessionId, data);
   }
   
@@ -189,7 +161,6 @@ export class EventLog {
     this.record('warn', 'failure', sessionId, { message, ...context });
   }
 
-  // C: Diagnostician heartbeat chain event recorders
   recordDiagnosisTask(data: DiagnosisTaskEventData): void {
     this.record('diagnosis_task', 'written', undefined, data);
   }
@@ -199,8 +170,6 @@ export class EventLog {
   }
 
   recordDiagnosticianReport(data: DiagnosticianReportEventData): void {
-    // Map three-state category to EventCategory
-    // Both missing_json and incomplete_fields map to 'failure' in EventCategory
     const categoryMap: Record<DiagnosticianReportEventData['category'], EventCategory> = {
       success: 'completed',
       missing_json: 'failure',
@@ -217,20 +186,6 @@ export class EventLog {
     this.record('rule_enforced', 'matched', undefined, data);
   }
 
-  // C: Nocturnal funnel event recorders (PD-FUNNEL-2.3)
-  recordNocturnalDreamerCompleted(data: NocturnalDreamerCompletedEventData): void {
-    this.record('nocturnal_dreamer_completed', 'completed', undefined, data);
-  }
-
-  recordNocturnalArtifactPersisted(data: NocturnalArtifactPersistedEventData): void {
-    this.record('nocturnal_artifact_persisted', 'completed', undefined, data);
-  }
-
-  recordNocturnalCodeCandidateCreated(data: NocturnalCodeCandidateCreatedEventData): void {
-    this.record('nocturnal_code_candidate_created', 'created', undefined, data);
-  }
-
-  // C: RuleHost funnel event recorders (PD-FUNNEL-2.4)
   recordRuleHostEvaluated(data: RuleHostEvaluatedEventData): void {
     this.record('rulehost_evaluated', 'evaluated', undefined, data);
   }
@@ -243,6 +198,26 @@ export class EventLog {
     this.record('rulehost_requireApproval', 'requireApproval', undefined, data);
   }
 
+  recordRuleHostAutoCorrectProposed(data: RuleHostAutoCorrectProposedEventData): void {
+    this.record('rulehost_auto_correct_proposed', 'auto_correct', undefined, data);
+  }
+
+  recordRuleHostAutoCorrectApplied(data: RuleHostAutoCorrectAppliedEventData): void {
+    this.record('rulehost_auto_correct_applied', 'auto_correct', undefined, data);
+  }
+
+  recordRuntimeV2ActivationsInjected(data: RuntimeV2PromptActivationsInjectedEventData): void {
+    this.record('runtime_v2_prompt_activations_injected', 'injected', data.sessionId, data);
+  }
+
+  recordConfirmFirstGateBlocked(data: RuntimeV2ConfirmFirstGateEventData): void {
+    this.record('runtime_v2_confirm_first_gate_blocked', 'blocked', data.sessionId, data);
+  }
+
+  recordConfirmFirstGateApproved(data: RuntimeV2ConfirmFirstGateEventData): void {
+    this.record('runtime_v2_confirm_first_gate_approved', 'approved', data.sessionId, data);
+  }
+
   private record(
     type: EventType, 
     category: EventCategory, 
@@ -269,8 +244,6 @@ export class EventLog {
     }
   }
 
-   
-   
   private formatDate(date: Date): string {
     return date.toISOString().split('T')[0];
   }
@@ -288,7 +261,6 @@ export class EventLog {
     }
   }
 
-   
   private updateStats(entry: EventLogEntry): void {
     let stats = this.statsCache.get(entry.date);
     if (!stats) {
@@ -300,24 +272,29 @@ export class EventLog {
       stats.tools.total++;
       if (entry.category === 'success') stats.tools.success++;
       else stats.tools.failure++;
+
+      const tcData = entry.data as unknown as ToolCallEventData;
+      const observedGfi = tcData.gfiAfter ?? tcData.gfi;
+      if (observedGfi !== undefined) {
+        stats.gfi.samples++;
+        stats.gfi.total += observedGfi;
+        stats.gfi.peak = Math.max(stats.gfi.peak, observedGfi);
+      }
     } else if (entry.type === 'pain_signal') {
       const data = entry.data as unknown as PainSignalEventData;
       stats.pain.signalsDetected++;
       stats.pain.maxScore = Math.max(stats.pain.maxScore, data.score);
 
-      // Track signals by source
       if (data.source) {
         stats.pain.signalsBySource[data.source] = (stats.pain.signalsBySource[data.source] || 0) + 1;
       }
 
-      // Accumulate score for avg calculation
       const currentSum = this.painScoreSums.get(entry.date) ?? 0;
       this.painScoreSums.set(entry.date, currentSum + (data.score || 0));
       stats.pain.avgScore = stats.pain.signalsDetected > 0
         ? Math.round((currentSum + (data.score || 0)) / stats.pain.signalsDetected)
         : 0;
 
-      // Update empathy stats for user_empathy source
       if (data.source === 'user_empathy') {
         if (data.deduped) {
           stats.empathy.dedupedCount++;
@@ -325,23 +302,19 @@ export class EventLog {
           stats.empathy.totalEvents++;
           stats.empathy.totalPenaltyScore += data.score || 0;
 
-          // By severity
           if (data.severity) {
             stats.empathy.bySeverity[data.severity]++;
             stats.empathy.scoreBySeverity[data.severity] += data.score || 0;
           }
 
-          // By detection mode
           if (data.detection_mode) {
             stats.empathy.byDetectionMode[data.detection_mode]++;
           }
 
-          // By origin
           if (data.origin) {
             stats.empathy.byOrigin[data.origin]++;
           }
 
-          // Confidence distribution
           const conf = data.confidence ?? 1;
           if (conf >= 0.8) stats.empathy.confidenceDistribution.high++;
           else if (conf >= 0.5) stats.empathy.confidenceDistribution.medium++;
@@ -357,7 +330,6 @@ export class EventLog {
       if (entry.category === 'success') stats.hooks.success++;
       else stats.hooks.failure++;
 
-      // Track by type
       if (data.hook) {
         if (!stats.hooks.byType[data.hook]) {
           stats.hooks.byType[data.hook] = { total: 0, success: 0, failure: 0 };
@@ -385,19 +357,13 @@ export class EventLog {
         stats.evolution.tasksEnqueued++;
       }
     }
-    // C: Diagnostician heartbeat chain event counters
     else if (entry.type === 'diagnosis_task') {
       stats.evolution.diagnosisTasksWritten++;
     } else if (entry.type === 'heartbeat_diagnosis') {
       stats.evolution.heartbeatsInjected++;
     } else if (entry.type === 'diagnostician_report') {
-      // Backward compat: handle old events with success:boolean and new events with category:string
-      // Widen to Record<string, unknown> because DiagnosticianReportEventData requires
-      // category (new format) but legacy persisted events have { success: boolean }.
       const raw = entry.data as unknown as Record<string, unknown>;
       if (Object.prototype.hasOwnProperty.call(raw, 'category')) {
-        // New format: category is 'success' | 'missing_json' | 'incomplete_fields'
-        // All three categories mean diagnosis completed and attempted to produce a report
         const cat = raw['category'] as string;
         if (cat === 'success' || cat === 'missing_json' || cat === 'incomplete_fields') {
           stats.evolution.diagnosticianReportsWritten++;
@@ -409,10 +375,6 @@ export class EventLog {
           stats.evolution.reportsIncompleteFields++;
         }
       } else if (Object.prototype.hasOwnProperty.call(raw, 'success')) {
-        // Legacy format: { success: boolean }
-        // Agreed fix: count ALL legacy events in diagnosticianReportsWritten (+1 for both true and false).
-        // Sub-counters (reportsMissingJson/reportsIncompleteFields) stay untouched because
-        // legacy events lack enough information to distinguish sub-category — preserve total, don't fake breakdown.
         stats.evolution.diagnosticianReportsWritten++;
       }
     } else if (entry.type === 'principle_candidate') {
@@ -420,32 +382,21 @@ export class EventLog {
     } else if (entry.type === 'rule_enforced') {
       stats.evolution.rulesEnforced++;
     }
-    // C: Nocturnal funnel event counters (PD-FUNNEL-2.3)
-    else if (entry.type === 'nocturnal_dreamer_completed') {
-      const data = entry.data as unknown as NocturnalDreamerCompletedEventData;
-      stats.evolution.nocturnalDreamerCompleted++;
-      if (data.chainMode === 'trinity') {
-        stats.evolution.nocturnalTrinityCompleted++;
-      }
-    } else if (entry.type === 'nocturnal_artifact_persisted') {
-      stats.evolution.nocturnalArtifactPersisted++;
-    } else if (entry.type === 'nocturnal_code_candidate_created') {
-      stats.evolution.nocturnalCodeCandidateCreated++;
-    }
-    // C: RuleHost funnel event counters (PD-FUNNEL-2.4)
     else if (entry.type === 'rulehost_evaluated') {
       stats.evolution.rulehostEvaluated++;
     } else if (entry.type === 'rulehost_blocked') {
       stats.evolution.rulehostBlocked++;
     } else if (entry.type === 'rulehost_requireApproval') {
       stats.evolution.rulehostRequireApproval++;
+    } else if (entry.type === 'rulehost_auto_correct_proposed') {
+      stats.evolution.rulehostAutoCorrectProposed++;
+    } else if (entry.type === 'rulehost_auto_correct_applied') {
+      stats.evolution.rulehostAutoCorrectApplied++;
     }
   }
 
   private startFlushTimer(): void {
     this.flushTimer = setInterval(() => this.flush(), this.flushIntervalMs);
-    // Don't keep the process alive just for this timer
-    // This allows tests and CLI to exit without waiting for flush
     this.flushTimer.unref();
   }
 
@@ -454,16 +405,10 @@ export class EventLog {
     this.flushStats();
   }
 
-  /**
-   * Return in-memory buffered events that have not been flushed yet.
-   * Intended for live runtime summaries that should not lag behind disk snapshots.
-   */
   getBufferedEvents(): EventLogEntry[] {
     return this.eventBuffer.map((entry) => ({ ...entry, data: { ...entry.data } }));
   }
 
-   
-     
   private getEventDedupKey(entry: EventLogEntry): string {
     const eventId = typeof (entry.data as { eventId?: unknown } | undefined)?.eventId === 'string'
       ? String((entry.data as { eventId?: string }).eventId)
@@ -545,10 +490,6 @@ export class EventLog {
     }
   }
 
-  /**
-   * Get daily statistics for a specific date.
-   * Returns empty stats if no events recorded for that date.
-   */
   getDailyStats(date: string): DailyStats {
     let stats = this.statsCache.get(date);
     if (!stats) {
@@ -558,17 +499,10 @@ export class EventLog {
     return stats;
   }
 
-  /**
-   * Get aggregated empathy statistics for multiple time ranges.
-   * @param range 'today' | 'week' | 'session'
-   * @param sessionId Optional session ID for session-scoped stats
-   */
-     
   getEmpathyStats(range: 'today' | 'week' | 'session', sessionId?: string): EmpathyEventStats {
     const now = new Date();
     const today = this.formatDate(now);
 
-    // Aggregate stats based on range
     const result: EmpathyEventStats = {
       totalEvents: 0,
       dedupedCount: 0,
@@ -585,10 +519,8 @@ export class EventLog {
     };
 
     if (range === 'session' && sessionId) {
-      // For session range, scan event buffer and events file
       this.aggregateSessionEmpathy(sessionId, result);
     } else if (range === 'week') {
-      // For week range, aggregate last 7 days
       for (let i = 0; i < 7; i++) {
         const date = new Date(now);
         date.setDate(date.getDate() - i);
@@ -626,7 +558,6 @@ export class EventLog {
         }
       }
     } else {
-      // Today only
       const stats = this.getDailyStats(today);
       Object.assign(result, stats.empathy);
       if (stats.empathy.totalEvents > 0 || stats.empathy.dedupedCount > 0) {
@@ -638,17 +569,12 @@ export class EventLog {
       }
     }
 
-    // Calculate dedupe hit rate
     const total = result.totalEvents + result.dedupedCount;
     result.dedupeHitRate = total > 0 ? result.dedupedCount / total : 0;
 
     return result;
   }
 
-  /**
-   * Aggregate empathy stats for a specific session.
-   */
-   
   private aggregateSessionEmpathy(sessionId: string, result: EmpathyEventStats): void {
     for (const entry of this.getMergedEvents()) {
       if (entry.sessionId === sessionId && entry.type === 'pain_signal') {
@@ -677,15 +603,8 @@ export class EventLog {
         result.rolledBackScore += data.originalScore || 0;
       }
     }
-
   }
 
-  /**
-   * Rollback an empathy event by ID.
-   * Returns the rolled back score, or 0 if event not found.
-   */
-   
-   
   rollbackEmpathyEvent(eventId: string, sessionId: string | undefined, reason: string, triggeredBy: 'user_command' | 'natural_language' | 'system'): number {
     const allEvents = this.getMergedEvents();
     let foundEvent: { entry: EventLogEntry; data: PainSignalEventData } | null = null;
@@ -706,7 +625,6 @@ export class EventLog {
 
     const originalScore = foundEvent.data.score || 0;
 
-    // Record the rollback event
     this.recordEmpathyRollback(sessionId, {
       eventId,
       originalScore,
@@ -718,9 +636,6 @@ export class EventLog {
     return originalScore;
   }
 
-  /**
-   * Get the last empathy event ID for a session (for rollback).
-   */
   getLastEmpathyEventId(sessionId: string): string | null {
     const allEvents = this.getMergedEvents();
     for (let i = allEvents.length - 1; i >= 0; i--) {
@@ -736,9 +651,6 @@ export class EventLog {
     return null;
   }
 
-  /**
-   * Find the latest pain signal for a given session.
-   */
   findLatestPainSignal(sessionId: string | undefined): PainSignalEventData | null {
     const allEvents = this.getMergedEvents();
     for (let i = allEvents.length - 1; i >= 0; i--) {
@@ -750,9 +662,6 @@ export class EventLog {
     return null;
   }
 
-  /**
-   * Dispose of the EventLog, flushing pending data and clearing timer.
-   */
   dispose(): void {
     if (this.flushTimer) {
       clearInterval(this.flushTimer);
@@ -762,9 +671,6 @@ export class EventLog {
   }
 }
 
-/**
- * Service to manage multiple EventLog instances by stateDir.
- */
 export class EventLogService {
   private static readonly instances: Map<string, EventLog> = new Map();
   

package/src/core/evolution-reducer.ts

@@ -105,6 +105,8 @@ export class EvolutionReducerImpl implements EvolutionReducer {
   private readonly failureStreak = new Map<string, number>();
   private lastPromotedAt: string | null = null;
   private isReplaying = false;
+  /** Registered pain_detected callbacks (e.g., PainSignalBridge). */
+  private readonly _painCallbacks: Array<(event: EvolutionLoopEvent) => void> = [];
 
   constructor(opts: { workspaceDir: string; stateDir?: string }) {
     this.workspaceDir = opts.workspaceDir;
@@ -145,6 +147,15 @@ export class EvolutionReducerImpl implements EvolutionReducer {
     // Performance: sweepExpiredProbation() moved to getProbationPrinciples() for lazy cleanup
   }
 
+  /**
+   * Register a callback for 'pain_detected' events.
+   * The callback is invoked synchronously within emitSync() after applyEvent completes.
+   * HG-4: Callbacks are fire-and-forget from the emitSync perspective.
+   */
+  on(callback: (event: EvolutionLoopEvent) => void): void {
+    this._painCallbacks.push(callback);
+  }
+
   getEventLog(): EvolutionLoopEvent[] {
     return [...this.memoryEvents];
   }
@@ -171,14 +182,14 @@ export class EvolutionReducerImpl implements EvolutionReducer {
     const p = this.principles.get(principleId);
     if (!p || p.status === 'active' || p.status === 'deprecated') return;
 
-    const nextStatus: PrincipleStatus = p.status === 'candidate' ? 'probation' : 'active';
+    const toStatus = (p.status === 'candidate' ? 'probation' : p.status === 'probation' ? 'active' : p.status) as PrincipleStatus;
     const event: EvolutionLoopEvent = {
       ts: new Date().toISOString(),
       type: 'principle_promoted',
       data: {
         principleId,
         from: p.status,
-        to: nextStatus,
+        to: toStatus,
         reason,
         successCount: p.validation.successCount,
       },
@@ -650,6 +661,14 @@ export class EvolutionReducerImpl implements EvolutionReducer {
         if (!this.isReplaying) {
           this.onPainDetected(event.data, event.ts);
         }
+        // PainSignalBridge subscriptions: invoke registered callbacks (fire-and-forget)
+        for (const cb of this._painCallbacks) {
+          try {
+            cb(event);
+          } catch {
+            // Keep the evolution loop resilient — callback errors must not propagate
+          }
+        }
         return;
       case 'candidate_created':
         this.onCandidateCreated(event.data, event.ts);