principles-disciple 1.127.0 → 1.129.0

package/dist/core/event-log.js

@@ -0,0 +1,702 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { createEmptyDailyStats } from '../types/event-types.js';
+import { atomicWriteFileSync } from '../utils/io.js';
+import { redactTelemetryString } from '@principles/core/runtime-v2';
+const EVENT_LOG_RETENTION_DAYS = 7;
+export class EventLog {
+    logsDir;
+    statsFile;
+    logger;
+    statsCache = new Map();
+    eventBuffer = [];
+    maxBufferSize = 20;
+    flushIntervalMs = 30000;
+    flushTimer;
+    currentEventsFile;
+    currentDate;
+    painScoreSums = new Map();
+    constructor(stateDir, logger) {
+        this.logsDir = path.join(stateDir, 'logs');
+        if (!fs.existsSync(this.logsDir)) {
+            fs.mkdirSync(this.logsDir, { recursive: true });
+        }
+        this.statsFile = path.join(this.logsDir, 'daily-stats.json');
+        this.logger = logger;
+        this.loadStats();
+        this.startFlushTimer();
+    }
+    getEventsFile(date) {
+        return path.join(this.logsDir, `events_${date}.jsonl`);
+    }
+    getTodayStr() {
+        return new Date().toISOString().split('T')[0];
+    }
+    ensureEventsFile() {
+        const today = this.getTodayStr();
+        if (this.currentDate !== today || !this.currentEventsFile) {
+            this.currentDate = today;
+            this.currentEventsFile = this.getEventsFile(today);
+            this.cleanupOldEventFiles(today);
+        }
+        return this.currentEventsFile;
+    }
+    cleanupOldEventFiles(_today) {
+        if (EVENT_LOG_RETENTION_DAYS <= 0)
+            return;
+        try {
+            const cutoffMs = Date.now() - EVENT_LOG_RETENTION_DAYS * 24 * 60 * 60 * 1000;
+            const files = fs.readdirSync(this.logsDir);
+            for (const file of files) {
+                if (!file.startsWith('events_') || !file.endsWith('.jsonl'))
+                    continue;
+                const filePath = path.join(this.logsDir, file);
+                const stat = fs.statSync(filePath);
+                if (stat.mtimeMs < cutoffMs) {
+                    fs.unlinkSync(filePath);
+                }
+            }
+        }
+        catch (err) {
+            this.logger?.debug?.(`[PD] Event file cleanup failed (non-blocking): ${String(err)}`);
+        }
+    }
+    recordToolCall(sessionId, data) {
+        const category = data.error || (data.exitCode !== undefined && data.exitCode !== 0) ? 'failure' : 'success';
+        this.record('tool_call', category, sessionId, data);
+    }
+    recordPainSignal(sessionId, data) {
+        this.record('pain_signal', 'detected', sessionId, data);
+    }
+    recordRuleMatch(sessionId, data) {
+        this.record('rule_match', 'detected', sessionId, data);
+    }
+    recordRulePromotion(data) {
+        this.record('rule_promotion', 'promoted', undefined, data);
+    }
+    recordHookExecution(data, opts) {
+        const category = data.error ? 'failure' : 'success';
+        this.record('hook_execution', category, undefined, data);
+        if (opts?.flushImmediately) {
+            this.flushEvents();
+        }
+    }
+    recordGateBlock(sessionId, data) {
+        this.record('gate_block', 'blocked', sessionId, data);
+    }
+    recordGateBypass(sessionId, data) {
+        this.record('gate_bypass', 'bypassed', sessionId, data);
+    }
+    recordPlanApproval(sessionId, data) {
+        this.record('plan_approval', 'approved', sessionId, data);
+    }
+    recordEvolutionTask(data) {
+        this.record('evolution_task', 'enqueued', undefined, data);
+    }
+    recordEvolutionTaskCompleted(data) {
+        this.record('evolution_task', 'completed', undefined, data);
+    }
+    recordEmpathyRollback(sessionId, data) {
+        this.record('empathy_rollback', 'rolled_back', sessionId, data);
+    }
+    recordError(sessionId, message, context) {
+        this.record('error', 'failure', sessionId, { message, ...context });
+    }
+    recordWarn(sessionId, message, context) {
+        this.record('warn', 'failure', sessionId, { message, ...context });
+    }
+    recordDiagnosisTask(data) {
+        this.record('diagnosis_task', 'written', undefined, data);
+    }
+    recordHeartbeatDiagnosis(data) {
+        this.record('heartbeat_diagnosis', 'injected', undefined, data);
+    }
+    recordDiagnosticianReport(data) {
+        const categoryMap = {
+            success: 'completed',
+            missing_json: 'failure',
+            incomplete_fields: 'failure',
+        };
+        this.record('diagnostician_report', categoryMap[data.category], undefined, data);
+    }
+    recordPrincipleCandidate(data) {
+        this.record('principle_candidate', 'created', undefined, data);
+    }
+    recordRuleEnforced(data) {
+        this.record('rule_enforced', 'matched', undefined, data);
+    }
+    recordRuleHostEvaluated(data) {
+        this.record('rulehost_evaluated', 'evaluated', undefined, data);
+    }
+    recordRuleHostBlocked(data) {
+        this.record('rulehost_blocked', 'blocked', undefined, data);
+    }
+    recordRuleHostRequireApproval(data) {
+        this.record('rulehost_requireApproval', 'requireApproval', undefined, data);
+    }
+    recordRuleHostAutoCorrectProposed(data) {
+        this.record('rulehost_auto_correct_proposed', 'auto_correct', undefined, data);
+    }
+    recordRuleHostAutoCorrectApplied(data) {
+        this.record('rulehost_auto_correct_applied', 'auto_correct', undefined, data);
+    }
+    recordRuntimeV2ActivationsInjected(data) {
+        this.record('runtime_v2_prompt_activations_injected', 'injected', data.sessionId, data);
+    }
+    /**
+     * PRI-437: Record that an approved rule failed to compile or load.
+     *
+     * This is NOT just a logger.warn — the unhealthy state is persisted to EventLog
+     * so it's visible to CLI (pd runtime health) and Console API.
+     *
+     * ERR-002: degradation includes a reason and nextAction (not silent).
+     */
+    recordRuleHostUnhealthy(data) {
+        this.record('rulehost_unhealthy', 'failure', undefined, data);
+    }
+    /**
+     * Redact telemetry-sensitive string values in event data before persistence.
+     * Applies redactTelemetryString to known high-risk fields (filePath, command,
+     * reason, args, new_string, old_string, text, paramsSummary values) and to all
+     * string values in tool_call/rulehost_* data as a safety net.
+     *
+     * ERR-002: never throws; returns data unchanged on error.
+     * ERR-045/046: covers composite command strings, Authorization headers, env vars.
+     */
+    redactEventData(type, data) {
+        try {
+            // Known high-risk event types — telemetry that carries tool commands / paths
+            const telemetryTypes = new Set([
+                'tool_call',
+                'rulehost_evaluated',
+                'rulehost_blocked',
+                'rulehost_requireApproval',
+                'rulehost_auto_correct_proposed',
+                'rulehost_auto_correct_applied',
+                'rule_enforced',
+                'hook_execution',
+                'gate_block',
+                'gate_bypass',
+            ]);
+            if (!telemetryTypes.has(type))
+                return data;
+            const redacted = {};
+            for (const [key, value] of Object.entries(data)) {
+                if (typeof value === 'string') {
+                    redacted[key] = redactTelemetryString(value);
+                }
+                else if (Array.isArray(value)) {
+                    // Recurse into arrays (e.g. correctedFields with original/applied)
+                    redacted[key] = value.map((item) => {
+                        if (typeof item === 'string') {
+                            return redactTelemetryString(item);
+                        }
+                        if (typeof item === 'object' && item !== null) {
+                            const nested = {};
+                            for (const [nk, nv] of Object.entries(item)) {
+                                nested[nk] = typeof nv === 'string' ? redactTelemetryString(nv) : nv;
+                            }
+                            return nested;
+                        }
+                        return item;
+                    });
+                }
+                else if (typeof value === 'object' && value !== null) {
+                    // Recurse one level for nested objects (e.g. paramsSummary)
+                    const nested = {};
+                    for (const [nk, nv] of Object.entries(value)) {
+                        if (typeof nv === 'string') {
+                            nested[nk] = redactTelemetryString(nv);
+                        }
+                        else {
+                            nested[nk] = nv;
+                        }
+                    }
+                    redacted[key] = nested;
+                }
+                else {
+                    redacted[key] = value;
+                }
+            }
+            return redacted;
+        }
+        catch (e) {
+            // ERR-002: fail safe — never write raw payload on redaction failure.
+            // Return a masked payload with context so downstream knows what happened.
+            const errStr = e instanceof Error ? e.message.slice(0, 200) : String(e).slice(0, 200);
+            const masked = {
+                redactionFailure: true,
+                redactionStatus: 'failed',
+                'redaction.status': 'failed',
+                redactionReason: errStr || 'unknown error',
+                redactionDataDropped: true,
+                originalType: type,
+                originalSessionId: data.sessionId ?? null,
+            };
+            return masked;
+        }
+    }
+    record(type, category, sessionId, data) {
+        const now = new Date();
+        const date = this.formatDate(now);
+        const redactedData = this.redactEventData(type, data);
+        const entry = {
+            ts: now.toISOString(),
+            date,
+            type,
+            category,
+            sessionId,
+            data: redactedData,
+        };
+        this.eventBuffer.push(entry);
+        this.updateStats(entry);
+        if (this.eventBuffer.length >= this.maxBufferSize) {
+            this.flushEvents();
+        }
+    }
+    formatDate(date) {
+        return date.toISOString().split('T')[0];
+    }
+    loadStats() {
+        if (fs.existsSync(this.statsFile)) {
+            try {
+                const data = JSON.parse(fs.readFileSync(this.statsFile, 'utf-8'));
+                for (const date in data) {
+                    this.statsCache.set(date, data[date]);
+                }
+            }
+            catch (e) {
+                if (this.logger)
+                    this.logger.error(`[PD] Failed to load daily-stats.json: ${String(e)}`);
+            }
+        }
+    }
+    updateStats(entry) {
+        let stats = this.statsCache.get(entry.date);
+        if (!stats) {
+            stats = createEmptyDailyStats(entry.date);
+            this.statsCache.set(entry.date, stats);
+        }
+        if (entry.type === 'tool_call') {
+            stats.tools.total++;
+            if (entry.category === 'success')
+                stats.tools.success++;
+            else
+                stats.tools.failure++;
+            const tcData = entry.data;
+            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;
+            stats.pain.signalsDetected++;
+            stats.pain.maxScore = Math.max(stats.pain.maxScore, data.score);
+            if (data.source) {
+                stats.pain.signalsBySource[data.source] = (stats.pain.signalsBySource[data.source] || 0) + 1;
+            }
+            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;
+            if (data.source === 'user_empathy') {
+                if (data.deduped) {
+                    stats.empathy.dedupedCount++;
+                }
+                else {
+                    stats.empathy.totalEvents++;
+                    stats.empathy.totalPenaltyScore += data.score || 0;
+                    if (data.severity) {
+                        stats.empathy.bySeverity[data.severity]++;
+                        stats.empathy.scoreBySeverity[data.severity] += data.score || 0;
+                    }
+                    if (data.detection_mode) {
+                        stats.empathy.byDetectionMode[data.detection_mode]++;
+                    }
+                    if (data.origin) {
+                        stats.empathy.byOrigin[data.origin]++;
+                    }
+                    const conf = data.confidence ?? 1;
+                    if (conf >= 0.8)
+                        stats.empathy.confidenceDistribution.high++;
+                    else if (conf >= 0.5)
+                        stats.empathy.confidenceDistribution.medium++;
+                    else
+                        stats.empathy.confidenceDistribution.low++;
+                }
+                const total = stats.empathy.totalEvents + stats.empathy.dedupedCount;
+                stats.empathy.dedupeHitRate = total > 0 ? stats.empathy.dedupedCount / total : 0;
+            }
+        }
+        else if (entry.type === 'hook_execution') {
+            const data = entry.data;
+            stats.hooks.total++;
+            if (entry.category === 'success')
+                stats.hooks.success++;
+            else
+                stats.hooks.failure++;
+            if (data.hook) {
+                if (!stats.hooks.byType[data.hook]) {
+                    stats.hooks.byType[data.hook] = { total: 0, success: 0, failure: 0 };
+                }
+                stats.hooks.byType[data.hook].total++;
+                if (entry.category === 'success')
+                    stats.hooks.byType[data.hook].success++;
+                else
+                    stats.hooks.byType[data.hook].failure++;
+            }
+        }
+        else if (entry.type === 'empathy_rollback') {
+            const data = entry.data;
+            stats.empathy.rollbackCount++;
+            stats.empathy.rolledBackScore += data.originalScore || 0;
+        }
+        else if (entry.type === 'rule_match') {
+            const data = entry.data;
+            if (data.ruleId) {
+                stats.pain.rulesMatched[data.ruleId] = (stats.pain.rulesMatched[data.ruleId] || 0) + 1;
+            }
+        }
+        else if (entry.type === 'rule_promotion') {
+            stats.pain.candidatesPromoted++;
+            stats.evolution.rulesPromoted++;
+        }
+        else if (entry.type === 'evolution_task') {
+            if (entry.category === 'completed') {
+                stats.evolution.tasksCompleted++;
+            }
+            else if (entry.category === 'enqueued') {
+                stats.evolution.tasksEnqueued++;
+            }
+        }
+        else if (entry.type === 'diagnosis_task') {
+            stats.evolution.diagnosisTasksWritten++;
+        }
+        else if (entry.type === 'heartbeat_diagnosis') {
+            stats.evolution.heartbeatsInjected++;
+        }
+        else if (entry.type === 'diagnostician_report') {
+            const raw = entry.data;
+            if (Object.prototype.hasOwnProperty.call(raw, 'category')) {
+                const cat = raw['category'];
+                if (cat === 'success' || cat === 'missing_json' || cat === 'incomplete_fields') {
+                    stats.evolution.diagnosticianReportsWritten++;
+                }
+                if (cat === 'missing_json') {
+                    stats.evolution.reportsMissingJson++;
+                }
+                if (cat === 'incomplete_fields') {
+                    stats.evolution.reportsIncompleteFields++;
+                }
+            }
+            else if (Object.prototype.hasOwnProperty.call(raw, 'success')) {
+                stats.evolution.diagnosticianReportsWritten++;
+            }
+        }
+        else if (entry.type === 'principle_candidate') {
+            stats.evolution.principleCandidatesCreated++;
+        }
+        else if (entry.type === 'rule_enforced') {
+            stats.evolution.rulesEnforced++;
+        }
+        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++;
+        }
+    }
+    startFlushTimer() {
+        this.flushTimer = setInterval(() => this.flush(), this.flushIntervalMs);
+        this.flushTimer.unref();
+    }
+    flush() {
+        this.flushEvents();
+        this.flushStats();
+    }
+    getBufferedEvents() {
+        return this.eventBuffer.map((entry) => ({ ...entry, data: { ...entry.data } }));
+    }
+    getEventDedupKey(entry) {
+        const eventId = typeof entry.data?.eventId === 'string'
+            ? String(entry.data.eventId)
+            : null;
+        if (eventId) {
+            return `${entry.type}:${entry.sessionId ?? 'none'}:${eventId}`;
+        }
+        const data = entry.data ?? {};
+        return [
+            entry.ts ?? 'no-ts',
+            entry.type ?? 'no-type',
+            entry.category ?? 'no-category',
+            entry.sessionId ?? 'no-session',
+            typeof data.source === 'string' ? data.source : 'no-source',
+            typeof data.toolName === 'string' ? data.toolName : 'no-tool',
+            typeof data.reason === 'string' ? data.reason : 'no-reason',
+        ].join('::');
+    }
+    readPersistedEvents() {
+        const eventsFile = this.ensureEventsFile();
+        if (!fs.existsSync(eventsFile))
+            return [];
+        try {
+            const content = fs.readFileSync(eventsFile, 'utf-8');
+            return content
+                .trim()
+                .split('\n')
+                .filter((line) => line.trim().length > 0)
+                .map((line) => {
+                try {
+                    return JSON.parse(line);
+                }
+                catch (err) {
+                    this.logger?.warn?.(`[PD] Corrupted event line skipped: ${String(err).slice(0, 100)}`);
+                    return null;
+                }
+            })
+                .filter((entry) => entry !== null);
+        }
+        catch (e) {
+            if (this.logger)
+                this.logger.error(`[PD] Failed to read events file: ${String(e)}`);
+            return [];
+        }
+    }
+    getMergedEvents() {
+        const merged = new Map();
+        for (const entry of [...this.readPersistedEvents(), ...this.getBufferedEvents()]) {
+            merged.set(this.getEventDedupKey(entry), entry);
+        }
+        return [...merged.values()].sort((a, b) => a.ts.localeCompare(b.ts));
+    }
+    flushEvents() {
+        if (this.eventBuffer.length === 0)
+            return;
+        const eventsFile = this.ensureEventsFile();
+        const lines = this.eventBuffer.map(e => JSON.stringify(e)).join('\n') + '\n';
+        try {
+            fs.appendFileSync(eventsFile, lines, 'utf-8');
+            this.eventBuffer = [];
+        }
+        catch (e) {
+            if (this.logger)
+                this.logger.error(`[PD] Failed to flush events: ${String(e)}`);
+        }
+    }
+    flushStats() {
+        if (this.statsCache.size === 0)
+            return;
+        const data = {};
+        this.statsCache.forEach((stats, date) => {
+            data[date] = stats;
+        });
+        try {
+            atomicWriteFileSync(this.statsFile, JSON.stringify(data, null, 2));
+        }
+        catch (e) {
+            if (this.logger)
+                this.logger.error(`[PD] Failed to flush daily-stats.json: ${String(e)}`);
+        }
+    }
+    getDailyStats(date) {
+        let stats = this.statsCache.get(date);
+        if (!stats) {
+            stats = createEmptyDailyStats(date);
+            this.statsCache.set(date, stats);
+        }
+        return stats;
+    }
+    getEmpathyStats(range, sessionId) {
+        const now = new Date();
+        const today = this.formatDate(now);
+        const result = {
+            totalEvents: 0,
+            dedupedCount: 0,
+            dedupeHitRate: 0,
+            totalPenaltyScore: 0,
+            rolledBackScore: 0,
+            rollbackCount: 0,
+            bySeverity: { mild: 0, moderate: 0, severe: 0 },
+            scoreBySeverity: { mild: 0, moderate: 0, severe: 0 },
+            byDetectionMode: { structured: 0, legacy_tag: 0 },
+            byOrigin: { assistant_self_report: 0, user_manual: 0, system_infer: 0 },
+            confidenceDistribution: { high: 0, medium: 0, low: 0 },
+            dailyTrend: [],
+        };
+        if (range === 'session' && sessionId) {
+            this.aggregateSessionEmpathy(sessionId, result);
+        }
+        else if (range === 'week') {
+            for (let i = 0; i < 7; i++) {
+                const date = new Date(now);
+                date.setDate(date.getDate() - i);
+                const dateStr = this.formatDate(date);
+                const stats = this.getDailyStats(dateStr);
+                result.totalEvents += stats.empathy.totalEvents;
+                result.dedupedCount += stats.empathy.dedupedCount;
+                result.totalPenaltyScore += stats.empathy.totalPenaltyScore;
+                result.rolledBackScore += stats.empathy.rolledBackScore;
+                result.rollbackCount += stats.empathy.rollbackCount;
+                for (const sev of ['mild', 'moderate', 'severe']) {
+                    result.bySeverity[sev] += stats.empathy.bySeverity[sev];
+                    result.scoreBySeverity[sev] += stats.empathy.scoreBySeverity[sev];
+                }
+                result.byDetectionMode.structured += stats.empathy.byDetectionMode.structured;
+                result.byDetectionMode.legacy_tag += stats.empathy.byDetectionMode.legacy_tag;
+                for (const org of ['assistant_self_report', 'user_manual', 'system_infer']) {
+                    result.byOrigin[org] += stats.empathy.byOrigin[org];
+                }
+                result.confidenceDistribution.high += stats.empathy.confidenceDistribution.high;
+                result.confidenceDistribution.medium += stats.empathy.confidenceDistribution.medium;
+                result.confidenceDistribution.low += stats.empathy.confidenceDistribution.low;
+                if (stats.empathy.totalEvents > 0 || stats.empathy.dedupedCount > 0) {
+                    result.dailyTrend.push({
+                        date: dateStr,
+                        count: stats.empathy.totalEvents,
+                        score: stats.empathy.totalPenaltyScore,
+                    });
+                }
+            }
+        }
+        else {
+            const stats = this.getDailyStats(today);
+            Object.assign(result, stats.empathy);
+            if (stats.empathy.totalEvents > 0 || stats.empathy.dedupedCount > 0) {
+                result.dailyTrend = [{
+                        date: today,
+                        count: stats.empathy.totalEvents,
+                        score: stats.empathy.totalPenaltyScore,
+                    }];
+            }
+        }
+        const total = result.totalEvents + result.dedupedCount;
+        result.dedupeHitRate = total > 0 ? result.dedupedCount / total : 0;
+        return result;
+    }
+    aggregateSessionEmpathy(sessionId, result) {
+        for (const entry of this.getMergedEvents()) {
+            if (entry.sessionId === sessionId && entry.type === 'pain_signal') {
+                const data = entry.data;
+                if (data.source === 'user_empathy') {
+                    if (data.deduped) {
+                        result.dedupedCount++;
+                    }
+                    else {
+                        result.totalEvents++;
+                        result.totalPenaltyScore += data.score || 0;
+                        if (data.severity) {
+                            result.bySeverity[data.severity]++;
+                            result.scoreBySeverity[data.severity] += data.score || 0;
+                        }
+                        if (data.detection_mode)
+                            result.byDetectionMode[data.detection_mode]++;
+                        if (data.origin)
+                            result.byOrigin[data.origin]++;
+                        const conf = data.confidence ?? 1;
+                        if (conf >= 0.8)
+                            result.confidenceDistribution.high++;
+                        else if (conf >= 0.5)
+                            result.confidenceDistribution.medium++;
+                        else
+                            result.confidenceDistribution.low++;
+                    }
+                }
+            }
+            else if (entry.sessionId === sessionId && entry.type === 'empathy_rollback') {
+                const data = entry.data;
+                result.rollbackCount++;
+                result.rolledBackScore += data.originalScore || 0;
+            }
+        }
+    }
+    rollbackEmpathyEvent(eventId, sessionId, reason, triggeredBy) {
+        const allEvents = this.getMergedEvents();
+        let foundEvent = null;
+        for (const entry of allEvents) {
+            if (entry.type === 'pain_signal') {
+                const data = entry.data;
+                if (data.eventId === eventId && data.source === 'user_empathy') {
+                    foundEvent = { entry, data };
+                    break;
+                }
+            }
+        }
+        if (!foundEvent || foundEvent.data.deduped) {
+            return 0;
+        }
+        const originalScore = foundEvent.data.score || 0;
+        this.recordEmpathyRollback(sessionId, {
+            eventId,
+            originalScore,
+            originalSessionId: foundEvent.entry.sessionId,
+            reason,
+            triggeredBy,
+        });
+        return originalScore;
+    }
+    getLastEmpathyEventId(sessionId) {
+        const allEvents = this.getMergedEvents();
+        for (let i = allEvents.length - 1; i >= 0; i--) {
+            const entry = allEvents[i];
+            if (entry.sessionId === sessionId && entry.type === 'pain_signal') {
+                const data = entry.data;
+                if (data.source === 'user_empathy' && !data.deduped) {
+                    return data.eventId || null;
+                }
+            }
+        }
+        return null;
+    }
+    findLatestPainSignal(sessionId) {
+        const allEvents = this.getMergedEvents();
+        for (let i = allEvents.length - 1; i >= 0; i--) {
+            const entry = allEvents[i];
+            if (entry.sessionId === sessionId && entry.type === "pain_signal") {
+                return entry.data;
+            }
+        }
+        return null;
+    }
+    dispose() {
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = undefined;
+        }
+        this.flush();
+    }
+}
+export class EventLogService {
+    static instances = new Map();
+    static get(stateDir, logger) {
+        let instance = this.instances.get(stateDir);
+        if (!instance) {
+            instance = new EventLog(stateDir, logger);
+            this.instances.set(stateDir, instance);
+        }
+        return instance;
+    }
+    static flushAll() {
+        for (const instance of this.instances.values()) {
+            instance.flush();
+        }
+    }
+    static disposeAll() {
+        for (const instance of this.instances.values()) {
+            instance.dispose();
+        }
+        this.instances.clear();
+    }
+}