principles-disciple 1.145.0 → 1.145.2

package/dist/core/pain.d.ts

@@ -1,5 +1,4 @@
 export declare function computePainScore(rc: number, isSpiral: boolean, missingTestCommand: boolean, softScore: number, projectDir?: string): number;
-export declare function painSeverityLabel(painScore: number, isSpiral?: boolean, projectDir?: string): string;
 /**
  * Track principle value metrics when a pain signal is written.
  * This is observation-only — it does NOT affect the pain flag write flow.

package/dist/core/pain.js

@@ -20,30 +20,6 @@ export function computePainScore(rc, isSpiral, missingTestCommand, softScore, pr
     }
     return Math.min(100, score);
 }
-export function painSeverityLabel(painScore, isSpiral = false, projectDir) {
-    if (isSpiral) {
-        return "critical";
-    }
-    const stateDir = projectDir ? resolvePdPath(projectDir, 'STATE_DIR') : undefined;
-    const config = stateDir ? ConfigService.get(stateDir) : null;
-    const thresholds = config ? config.get('severity_thresholds') : {
-        high: 70,
-        medium: 40,
-        low: 20
-    };
-    if (painScore >= thresholds.high) {
-        return "high";
-    }
-    else if (painScore >= thresholds.medium) {
-        return "medium";
-    }
-    else if (painScore >= thresholds.low) {
-        return "low";
-    }
-    else {
-        return "info";
-    }
-}
 /**
  * Track principle value metrics when a pain signal is written.
  * This is observation-only — it does NOT affect the pain flag write flow.

package/dist/hooks/after-tool-call-helpers.d.ts

@@ -86,7 +86,9 @@ export declare function evaluatePainAdmissionForToolCall(event: PluginHookAfterT
  *
  * Only called when the admission decision is 'admitted'.
  */
-export declare function emitPainIfAdmitted(wctx: WorkspaceContext, event: PluginHookAfterToolCallEvent, observation: ToolCallObservation, outcome: ToolCallOutcome, admission: PainAdmissionDecision, sessionId: string, agentId: string | undefined, workspaceDir: string, emitPainDetectedEvent: (wctx: WorkspaceContext, event: import('../core/evolution-types.js').EvolutionLoopEvent) => Promise<void>): void;
+export declare function emitPainIfAdmitted(wctx: WorkspaceContext, event: PluginHookAfterToolCallEvent, observation: ToolCallObservation, outcome: ToolCallOutcome, admission: PainAdmissionDecision, sessionId: string, agentId: string | undefined, workspaceDir: string, emitPainDetectedEvent: (wctx: WorkspaceContext, event: import('../core/evolution-types.js').EvolutionLoopEvent, options?: {
+    recordObservability?: boolean;
+}) => Promise<void>): void;
 export { buildTrajectoryEvidence } from './trajectory-evidence.js';
 /**
  * Reset trigger cooldown state (for tests).

package/dist/hooks/after-tool-call-helpers.js

@@ -417,6 +417,9 @@ export function emitPainIfAdmitted(wctx, event, observation, outcome, admission,
     if (!admission.admitted)
         return;
     const failureSource = outcome.failureSource ?? 'tool_failure';
+    // PRI-453: Generate painId early so it can be passed as canonicalPainId to
+    // recordPainEvent, enabling dedup between legacy trajectory write and SDK path.
+    const painId = `pain_${Date.now()}_${observation.errorHash.slice(0, 8)}`;
     // Record to trajectory before Runtime V2 diagnosis
     wctx.trajectory?.recordPainEvent({
         sessionId,
@@ -426,6 +429,7 @@ export function emitPainIfAdmitted(wctx, event, observation, outcome, admission,
         severity: observation.painScore >= 70 ? 'severe' : observation.painScore >= 40 ? 'moderate' : 'mild',
         origin: 'system_infer',
         text: sanitizeForEvidence(observation.params.text ?? observation.params.content, workspaceDir) || undefined,
+        canonicalPainId: painId,
     });
     // Observe: track which principles would have prevented this pain (observation-only)
     try {
@@ -481,7 +485,7 @@ export function emitPainIfAdmitted(wctx, event, observation, outcome, admission,
         sessionId,
     });
     // Create painId inline (matches original createPainId)
-    const painId = `pain_${Date.now()}_${observation.errorHash.slice(0, 8)}`;
+    // PRI-453: painId is now generated early (above) to pass as canonicalPainId.
     emitPainDetectedEvent(wctx, {
         ts: new Date().toISOString(),
         type: 'pain_detected',
@@ -497,7 +501,7 @@ export function emitPainIfAdmitted(wctx, event, observation, outcome, admission,
             provenance: 'automatic_hook',
             evidence: buildTrajectoryEvidence(wctx, sessionId),
         },
-    });
+    }, { recordObservability: false });
 }
 // ── Shared Helpers ──────────────────────────────────────────────────────────
 export { buildTrajectoryEvidence } from './trajectory-evidence.js';

package/dist/hooks/gate-block-helper.js

@@ -78,15 +78,11 @@ export function recordGateBlockAndReturn(wctx, blockCtx, logger) {
     // so one mild block does not start a long diagnostician run.
     if (sessionId) {
         const GATE_BLOCK_PAIN_SCORE = 45; // Must be >= pain_trigger (40) so single gate block can trigger diagnosis (PRI-274)
-        // Record to trajectory (fire-and-forget, no .pain_flag file needed)
-        wctx.trajectory?.recordPainEvent?.({
-            sessionId,
-            source: 'gate_blocked',
-            score: GATE_BLOCK_PAIN_SCORE,
-            reason: `Gate blocked ${toolName} on ${filePath}: ${reason}`,
-            severity: 'mild',
-            origin: 'system_infer',
-        });
+        // PRI-453: Generate painId early. SDK observability path (emitPainDetectedEvent
+        // with default recordObservability: true) handles all writes: events_*.jsonl +
+        // evolution.jsonl + trajectory.db (with canonicalPainId for dedup). No separate
+        // legacy recordPainEvent call needed — avoids double-write to trajectory.db.
+        const gatePainId = `gate_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
         // PEAT-B1: Evidence triage (feature-flagged)
         let triageAdmitted = true;
         const gateBlockTriageFlag = loadFeatureFlagFromConfig(wctx.workspaceDir, 'painEvidenceAdmission');
@@ -142,7 +138,7 @@ export function recordGateBlockAndReturn(wctx, blockCtx, logger) {
                     ts: new Date().toISOString(),
                     type: 'pain_detected',
                     data: {
-                        painId: `gate_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`,
+                        painId: gatePainId,
                         painType: 'user_frustration',
                         source: 'gate_blocked',
                         reason: `Gate blocked ${toolName} on ${filePath}: ${reason}`,

package/dist/hooks/llm.js

@@ -266,6 +266,18 @@ export function handleLlmOutput(event, ctx) {
             reason: matchedReason,
             isRisky: false
         });
+        // PRI-453: Generate painId early and write to trajectory.db via legacy
+        // recordPainEvent so that disabling SDK observability path does not lose
+        // trajectory coverage. canonicalPainId enables dedup.
+        const painId = `llm_${Date.now()}`;
+        wctx.trajectory?.recordPainEvent?.({
+            sessionId: ctx.sessionId || 'unknown',
+            source,
+            score: painScore,
+            reason: matchedReason,
+            origin: 'system_infer',
+            canonicalPainId: painId,
+        });
         if (triageAdmitted) {
             const gate = evaluatePainDiagnosticGate({
                 source: source === 'llm_paralysis' ? 'llm_paralysis' : 'semantic',
@@ -286,7 +298,7 @@ export function handleLlmOutput(event, ctx) {
                     ts: new Date().toISOString(),
                     type: 'pain_detected',
                     data: {
-                        painId: `llm_${Date.now()}`,
+                        painId,
                         painType: 'user_frustration',
                         source,
                         reason: `${matchedReason}; diagnosticGate=${gate.reason}`,
@@ -296,7 +308,7 @@ export function handleLlmOutput(event, ctx) {
                         provenance: 'openclaw_context_bound',
                         evidence,
                     },
-                });
+                }, { recordObservability: false });
             }
             else {
                 ctx.logger?.info?.(`[PD:LLM] Pain signal recorded without Runtime V2 diagnosis: ${gate.detail}`);

package/dist/hooks/pain.d.ts

@@ -19,7 +19,9 @@ import type { EvolutionLoopEvent } from '../core/evolution-types.js';
 import type { PluginHookAfterToolCallEvent, PluginHookToolContext, OpenClawPluginApi } from '../openclaw-sdk.js';
 import { buildTrajectoryEvidence } from './trajectory-evidence.js';
 export { buildTrajectoryEvidence };
-export declare function emitPainDetectedEvent(wctx: WorkspaceContext, event: EvolutionLoopEvent): Promise<void>;
+export declare function emitPainDetectedEvent(wctx: WorkspaceContext, event: EvolutionLoopEvent, options?: {
+    recordObservability?: boolean;
+}): Promise<void>;
 /**
  * Handle after_tool_call hook — decomposed into pipeline stages.
  *

package/dist/hooks/pain.js

@@ -44,7 +44,7 @@ function createPainToPrincipleService(wctx) {
 }
 // buildTrajectoryEvidence is in ./trajectory-evidence.ts (re-exported above)
 // ── Pain Event Emission ─────────────────────────────────────────────────────
-export async function emitPainDetectedEvent(wctx, event) {
+export async function emitPainDetectedEvent(wctx, event, options) {
     try {
         wctx.evolutionReducer.emitSync(event);
     }
@@ -68,6 +68,10 @@ export async function emitPainDetectedEvent(wctx, event) {
                     score: painData.score,
                 }));
             }
+            // PRI-453: Hook paths that already write events_*.jsonl + trajectory.db
+            // via legacy writers pass recordObservability: false to avoid triple-write.
+            // CLI pd pain record and paths without legacy writers keep the default true.
+            const recordObs = options?.recordObservability ?? true;
             const result = await service.recordPain({
                 painId: painData.painId,
                 painType: painData.painType,
@@ -80,7 +84,7 @@ export async function emitPainDetectedEvent(wctx, event) {
                 traceId: painData.traceId,
                 provenance: painData.provenance,
                 evidence: painData.evidence,
-                recordObservability: true,
+                recordObservability: recordObs,
             });
             if (result.status === 'failed' && result.failureCategory) {
                 SystemLogger.log(wctx.workspaceDir, 'PAIN_SERVICE_FAILED', JSON.stringify({
@@ -216,6 +220,8 @@ function handleManualPain(event, ctx, wctx, workspaceDir, sessionId) {
         reason: `User intervention: ${reason}`,
         isRisky: true
     });
+    // PRI-453: Generate painId early to pass as canonicalPainId for dedup.
+    const painId = createPainId(sessionId);
     wctx.trajectory?.recordPainEvent?.({
         sessionId,
         source: 'manual',
@@ -223,6 +229,7 @@ function handleManualPain(event, ctx, wctx, workspaceDir, sessionId) {
         reason: `User intervention: ${reason}`,
         origin: 'user_manual',
         text: reason,
+        canonicalPainId: painId,
     });
     // Log to EvolutionLogger
     const evoLogger = getEvolutionLogger(workspaceDir, wctx.trajectory);
@@ -279,7 +286,7 @@ function handleManualPain(event, ctx, wctx, workspaceDir, sessionId) {
         ts: new Date().toISOString(),
         type: 'pain_detected',
         data: {
-            painId: createPainId(sessionId),
+            painId,
             painType: 'user_frustration',
             source: event.toolName,
             reason: `User intervention: ${reason}`,
@@ -290,5 +297,5 @@ function handleManualPain(event, ctx, wctx, workspaceDir, sessionId) {
             provenance: (sessionId && sessionId !== 'unknown') ? 'openclaw_context_bound' : 'owner_reported_no_host_trace',
             evidence: buildTrajectoryEvidence(wctx, sessionId),
         },
-    });
+    }, { recordObservability: false });
 }

package/dist/hooks/prompt.js

@@ -328,6 +328,27 @@ export async function handleBeforePromptBuild(event, ctx) {
                             source: 'user_empathy',
                             reason: `Accumulated GFI (${currentGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Matched: ${matchResult.matchedTerms.join(', ')}`,
                             isRisky: false,
+                            origin: 'system_infer',
+                            severity: gfiPainScore >= 40 ? 'moderate' : 'mild',
+                            confidence: 0.5,
+                            detection_mode: 'structured',
+                            deduped: false,
+                            trigger_text_excerpt: sanitizeForEvidence(latestUserMessage, workspaceDir).substring(0, 120),
+                            raw_score: gfiPainScore,
+                            calibrated_score: gfiPainScore,
+                            eventId: `empathy_gfi_${Date.now()}`,
+                        });
+                        // PRI-453: Generate painId early and write to trajectory.db via legacy
+                        // recordPainEvent so that disabling SDK observability path does not lose
+                        // trajectory coverage. canonicalPainId enables dedup.
+                        const gfiPainId = `empathy_gfi_${Date.now()}`;
+                        wctx.trajectory?.recordPainEvent?.({
+                            sessionId,
+                            source: 'user_empathy',
+                            score: gfiPainScore,
+                            reason: `Accumulated GFI (${currentGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Matched: ${matchResult.matchedTerms.join(', ')}`,
+                            origin: 'system_infer',
+                            canonicalPainId: gfiPainId,
                         });
                         if (gate.shouldDiagnose) {
                             logger?.info?.(`[PD:Empathy] Gate approved, calling emitPainDetectedEvent...`);
@@ -337,7 +358,7 @@ export async function handleBeforePromptBuild(event, ctx) {
                                     ts: new Date().toISOString(),
                                     type: 'pain_detected',
                                     data: {
-                                        painId: `empathy_gfi_${Date.now()}`,
+                                        painId: gfiPainId,
                                         painType: 'user_frustration',
                                         source: 'user_empathy',
                                         reason: `Accumulated GFI (${currentGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Matched: ${matchResult.matchedTerms.join(', ')}`,
@@ -347,7 +368,7 @@ export async function handleBeforePromptBuild(event, ctx) {
                                         provenance: 'openclaw_context_bound',
                                         evidence,
                                     },
-                                });
+                                }, { recordObservability: false });
                                 logger?.info?.(`[PD:Empathy] emitPainDetectedEvent completed (GFI-triggered)`);
                             }
                             catch (emitErr) {
@@ -392,6 +413,10 @@ export async function handleBeforePromptBuild(event, ctx) {
                                     calibrated_score: painScore,
                                     eventId,
                                 });
+                                // PRI-453: Generate painId early to pass as canonicalPainId for dedup.
+                                // Declared outside try block so it's accessible to emitPainDetectedEvent
+                                // later (lineage consistency: same id for trajectory + emitted event).
+                                const observerPainId = `empathy_gfi_${Date.now()}`;
                                 try {
                                     wctx.trajectory?.recordPainEvent?.({
                                         sessionId,
@@ -402,6 +427,7 @@ export async function handleBeforePromptBuild(event, ctx) {
                                         origin: 'system_infer',
                                         confidence: result.confidence,
                                         text: sanitizeForEvidence(latestUserMessage, workspaceDir),
+                                        canonicalPainId: observerPainId,
                                     });
                                 }
                                 catch (error) {
@@ -429,11 +455,15 @@ export async function handleBeforePromptBuild(event, ctx) {
                                         logger?.info?.(`[PD:Empathy] GFI threshold crossed after background observer. Emitting pain signal...`);
                                         try {
                                             const evidence = buildTrajectoryEvidence(wctx, sessionId);
+                                            // PRI-453: Reuse observerPainId for lineage consistency —
+                                            // the same id is used as canonicalPainId in recordPainEvent
+                                            // and as painId in the emitted event, so EvidenceChainConsoleModel
+                                            // can JOIN pain_events.canonical_pain_id = tasks.input_ref.
                                             await emitPainDetectedEvent(wctx, {
                                                 ts: new Date().toISOString(),
                                                 type: 'pain_detected',
                                                 data: {
-                                                    painId: `empathy_gfi_${Date.now()}`,
+                                                    painId: observerPainId,
                                                     painType: 'user_frustration',
                                                     source: 'user_empathy',
                                                     reason: `Accumulated GFI (${freshGfi.toFixed(1)}) crossed highGfi threshold (${highGfiThreshold}). Verified by Empathy Observer.`,
@@ -443,7 +473,7 @@ export async function handleBeforePromptBuild(event, ctx) {
                                                     provenance: 'openclaw_context_bound',
                                                     evidence,
                                                 },
-                                            });
+                                            }, { recordObservability: false });
                                         }
                                         catch (emitErr) {
                                             logger?.error?.(`[PD:Empathy] FAILED to emit observer-triggered pain event: ${String(emitErr)}`);

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "principles-disciple",
   "name": "Principles Disciple",
   "description": "Evolutionary programming agent framework with strategic guardrails and reflection loops.",
-  "version": "1.145.0",
+  "version": "1.145.2",
   "activation": {
     "onCapabilities": [
       "hook"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "principles-disciple",
-  "version": "1.145.0",
+  "version": "1.145.2",
   "description": "Native OpenClaw plugin for Principles Disciple",
   "type": "module",
   "main": "./dist/bundle.js",

package/dist/core/observability.d.ts

@@ -1,40 +0,0 @@
-export interface ObservabilityBaselines {
-    /** ISO 8601 timestamp when baselines were calculated */
-    calculatedAt: string;
-    /** Principle Stock: total count of principles in the ledger */
-    principleStock: number;
-    /** Total rules across all principles */
-    totalRules: number;
-    /** Total implementations across all rules */
-    totalImplementations: number;
-    /** Structure: average rules per principle (0 if no principles) */
-    avgRulesPerPrinciple: number;
-    /** Structure: average implementations per rule (0 if no rules) */
-    avgImplementationsPerRule: number;
-    /** Total pain events from trajectory DB (0 if DB unavailable) */
-    totalPainEvents: number;
-    /** Association Rate: principles / total pain events (0 if no pain events) */
-    associationRate: number;
-    /** Count of principles with internalizationStatus = 'internalized' */
-    internalizedCount: number;
-    /** Internalization Rate: internalized / total principles (0 if no principles) */
-    internalizationRate: number;
-    /** Distribution of principle statuses */
-    statusDistribution: Record<string, number>;
-    /** Distribution of principle priorities */
-    priorityDistribution: Record<string, number>;
-    /** Distribution of internalization statuses from training store */
-    internalizationDistribution: Record<string, number>;
-}
-/**
- * Calculate observability baselines for the principle evolution system.
- *
- * Reads the principle ledger from stateDir, computes metrics across four
- * dimensions (Stock, Structure, Association, Internalization), logs a summary
- * via SystemLogger, and persists results to .state/baselines.json.
- *
- * @param stateDir - The .state directory containing the principle ledger
- * @param workspaceDir - Optional workspace dir for SystemLogger routing
- * @returns The computed baselines
- */
-export declare function calculateBaselines(stateDir: string, workspaceDir?: string): ObservabilityBaselines;

package/dist/core/observability.js

@@ -1,164 +0,0 @@
-/**
- * Observability Baselines for the Evolution SDK.
- *
- * Provides calculateBaselines() which measures the current state of the
- * principle evolution system across four dimensions:
- *
- * 1. Principle Stock: total count of principles in the ledger
- * 2. Structure: average sub-principles (rules) and implementations per principle
- * 3. Association Rate: principles created / total pain events recorded
- * 4. Internalization Rate: internalized principles / total principles
- *
- * Results are logged via SystemLogger and persisted to .state/baselines.json.
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import { loadLedger } from './principle-tree-ledger.js';
-import { SystemLogger } from './system-logger.js';
-import { atomicWriteFileSync } from '../utils/io.js';
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const BASELINES_FILE = 'baselines.json';
-// ---------------------------------------------------------------------------
-// Implementation
-// ---------------------------------------------------------------------------
-/**
- * Calculate observability baselines for the principle evolution system.
- *
- * Reads the principle ledger from stateDir, computes metrics across four
- * dimensions (Stock, Structure, Association, Internalization), logs a summary
- * via SystemLogger, and persists results to .state/baselines.json.
- *
- * @param stateDir - The .state directory containing the principle ledger
- * @param workspaceDir - Optional workspace dir for SystemLogger routing
- * @returns The computed baselines
- */
-export function calculateBaselines(stateDir, workspaceDir) {
-    const ledger = loadLedger(stateDir);
-    const { tree, trainingStore } = ledger;
-    const principles = Object.values(tree.principles);
-    const rules = Object.values(tree.rules);
-    const implementations = Object.values(tree.implementations);
-    const principleStock = principles.length;
-    const totalRules = rules.length;
-    const totalImplementations = implementations.length;
-    // Structure metrics
-    const avgRulesPerPrinciple = principleStock > 0
-        ? totalRules / principleStock
-        : 0;
-    const avgImplementationsPerRule = totalRules > 0
-        ? totalImplementations / totalRules
-        : 0;
-    // Count pain events from trajectory DB
-    const totalPainEvents = countPainEvents(stateDir);
-    // Association Rate: how many principles were created per pain event
-    const associationRate = totalPainEvents > 0
-        ? principleStock / totalPainEvents
-        : 0;
-    // Internalization Rate from training store
-    // Filter to only entries whose principleId still exists in the ledger tree
-    // to avoid orphaned/deleted entries inflating the ratio
-    const trainingEntries = Object.values(trainingStore);
-    const activePrincipleIds = new Set(Object.keys(tree.principles));
-    const activeEntries = trainingEntries.filter((entry) => activePrincipleIds.has(entry.principleId));
-    const internalizedCount = activeEntries.filter((entry) => entry.internalizationStatus === 'internalized').length;
-    const internalizationRate = principleStock > 0
-        ? internalizedCount / principleStock
-        : 0;
-    // Status distribution
-    const statusDistribution = {};
-    for (const p of principles) {
-        statusDistribution[p.status] = (statusDistribution[p.status] ?? 0) + 1;
-    }
-    // Priority distribution
-    const priorityDistribution = {};
-    for (const p of principles) {
-        priorityDistribution[p.priority] = (priorityDistribution[p.priority] ?? 0) + 1;
-    }
-    // Internalization status distribution from training store
-    const internalizationDistribution = {};
-    for (const entry of trainingEntries) {
-        internalizationDistribution[entry.internalizationStatus] =
-            (internalizationDistribution[entry.internalizationStatus] ?? 0) + 1;
-    }
-    const baselines = {
-        calculatedAt: new Date().toISOString(),
-        principleStock,
-        totalRules,
-        totalImplementations,
-        avgRulesPerPrinciple: roundTo3(avgRulesPerPrinciple),
-        avgImplementationsPerRule: roundTo3(avgImplementationsPerRule),
-        totalPainEvents,
-        associationRate: roundTo3(associationRate),
-        internalizedCount,
-        internalizationRate: roundTo3(internalizationRate),
-        statusDistribution,
-        priorityDistribution,
-        internalizationDistribution,
-    };
-    // Log summary
-    SystemLogger.log(workspaceDir, 'OBSERVABILITY_BASELINES', formatBaselineSummary(baselines));
-    // Persist to .state/baselines.json
-    persistBaselines(stateDir, baselines);
-    return baselines;
-}
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-function roundTo3(n) {
-    return Math.round(n * 1000) / 1000;
-}
-function formatBaselineSummary(b) {
-    return [
-        `Principle Stock: ${b.principleStock}`,
-        `Structure: ${b.avgRulesPerPrinciple} rules/principle, ${b.avgImplementationsPerRule} impls/rule`,
-        `Association Rate: ${b.associationRate} (${b.principleStock} principles / ${b.totalPainEvents} pain events)`,
-        `Internalization Rate: ${b.internalizationRate} (${b.internalizedCount}/${b.principleStock})`,
-    ].join(' | ');
-}
-/**
- * Count pain events from the trajectory SQLite database.
- * Returns 0 if the database is unavailable or the table doesn't exist.
- */
-function countPainEvents(stateDir) {
-    const dbPath = path.join(stateDir, 'trajectory.db');
-    if (!fs.existsSync(dbPath)) {
-        return 0;
-    }
-    try {
-        // Use dynamic import for better-sqlite3 to avoid hard dependency
-        // at module load time. If not available, return 0.
-        const Database = require('better-sqlite3');
-        const db = new Database(dbPath, { readonly: true });
-        try {
-            const row = db.prepare('SELECT COUNT(*) as count FROM pain_events').get();
-            return row?.count ?? 0;
-        }
-        finally {
-            db.close();
-        }
-    }
-    catch (err) {
-        // better-sqlite3 not available, or table doesn't exist — log and return 0
-        SystemLogger.log(stateDir, 'OBSERVABILITY_SQL_ERROR', `countPainEvents failed: ${String(err)}`);
-        return 0;
-    }
-}
-/**
- * Persist baselines to .state/baselines.json atomically.
- */
-function persistBaselines(stateDir, baselines) {
-    try {
-        const filePath = path.join(stateDir, BASELINES_FILE);
-        const dir = path.dirname(filePath);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-        atomicWriteFileSync(filePath, JSON.stringify(baselines, null, 2));
-    }
-    catch {
-        // Baselines persistence is best-effort — don't crash the caller
-        // (the SystemLogger call above already logged the values)
-    }
-}