principles-disciple 1.11.0 → 1.13.0

package/src/service/health-query-service.ts

@@ -85,14 +85,63 @@ export class HealthQueryService {
     this.eventLog = wctx.eventLog;
     this.evolutionReducer = wctx.evolutionReducer;
     this.uiDb = new ControlUiDatabase({ workspaceDir });
+    this.ensureTables();
+    this.syncGfiFromSession();
   }
 
   dispose(): void {
     this.uiDb.dispose();
   }
 
+  /**
+   * Ensure all tables required by HealthQueryService exist.
+   * This is a safety net for workspaces created before TrajectoryDatabase
+   * had full schema initialization, or where initSchema() was never called.
+   * Uses CREATE TABLE IF NOT EXISTS so it's idempotent.
+   */
+  private ensureTables(): void {
+    try {
+      this.uiDb.execute(`
+        CREATE TABLE IF NOT EXISTS pain_events (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id TEXT NOT NULL,
+          source TEXT NOT NULL,
+          score REAL NOT NULL DEFAULT 0,
+          reason TEXT DEFAULT '',
+          severity TEXT DEFAULT 'mild',
+          origin TEXT DEFAULT '',
+          confidence REAL DEFAULT 0,
+          text TEXT DEFAULT '',
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        )
+      `);
+      this.uiDb.execute(`
+        CREATE INDEX IF NOT EXISTS idx_pain_events_created_at ON pain_events(created_at)
+      `);
+      this.uiDb.execute(`
+        CREATE TABLE IF NOT EXISTS gate_blocks (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          session_id TEXT NOT NULL,
+          tool_name TEXT NOT NULL,
+          file_path TEXT,
+          reason TEXT NOT NULL,
+          gfi REAL,
+          gfi_after REAL,
+          trust_stage INTEGER,
+          gate_type TEXT,
+          created_at TEXT NOT NULL DEFAULT (datetime('now'))
+        )
+      `);
+      this.uiDb.execute(`
+        CREATE INDEX IF NOT EXISTS idx_gate_blocks_created_at ON gate_blocks(created_at)
+      `);
+    } catch (err) {
+      console.warn('[HealthQueryService] Table ensure failed (non-fatal):', err);
+    }
+  }
+
   getOverviewHealth(): {
-    gfi: { current: number; peakToday: number; threshold: number };
+    gfi: { current: number; peakToday: number; threshold: number; trend: { hour: string; value: number }[] };
     trust: { stage: number; stageLabel: string; score: number };
     evolution: { tier: string; points: number };
     painFlag: { active: boolean; source: string | null; score: number | null };
@@ -100,7 +149,6 @@ export class HealthQueryService {
     queue: { pending: number; inProgress: number; completed: number };
     activeStage: HealthStage;
   } {
-    const session = this.getCurrentSession();
     const threshold = this.getGfiThreshold();
     const trust = this.readTrust();
     const evolution = this.readEvolutionScore();
@@ -108,14 +156,21 @@ export class HealthQueryService {
     const queue = this.readQueueStats();
     const painFlag = this.readPainFlag();
 
-    const currentGfi = this.asNumber(session?.currentGfi, 0);
-    const peakToday = this.asNumber(session?.dailyGfiPeak, currentGfi);
+    // GFI: always read from SQLite (synced from session JSON at construction time)
+    const gfiData = this.readGfiFromDb();
+    const {currentGfi} = gfiData;
+    const peakToday = gfiData.dailyGfiPeak;
+
+    // GFI history trend: aggregate pain_events by hour
+    const today = new Date().toISOString().slice(0, 10);
+    const gfiTrend = this.readGfiTrend(today);
 
     return {
       gfi: {
         current: currentGfi,
         peakToday,
         threshold,
+        trend: gfiTrend,
       },
       trust,
       evolution,
@@ -127,14 +182,14 @@ export class HealthQueryService {
         deprecated: reducerStats.deprecatedCount,
       },
       queue,
-      activeStage: this.computeHealthStage(currentGfi, threshold, painFlag.active),
+      activeStage: HealthQueryService.computeHealthStage(currentGfi, threshold, painFlag.active),
     };
   }
 
   getEvolutionPrinciples(): {
     principles: {
       summary: { candidate: number; probation: number; active: number; deprecated: number };
-      recent: Array<{
+      recent: {
         principleId: string;
         status: string;
         triggerPattern: string;
@@ -142,14 +197,14 @@ export class HealthQueryService {
         fromStatus: string;
         toStatus: string;
         timestamp: string;
-      }>;
+      }[];
     };
     nocturnalTraining: {
       queue: { pending: number; inProgress: number; completed: number };
-      trinityRecords: Array<{ artifactId: string; status: string; createdAt: string }>;
+      trinityRecords: { artifactId: string; status: string; createdAt: string }[];
       arbiterPassRate: number;
       orpoSampleCount: number;
-      deployments: Array<{ modelId: string; status: string; checkpointPath: string | null }>;
+      deployments: { modelId: string; status: string; checkpointPath: string | null }[];
     };
     painSourceDistribution: Record<string, number>;
     activeStage: string;
@@ -176,14 +231,33 @@ export class HealthQueryService {
     };
   }
 
+  /**
+   * Read GFI trend for a specific day by aggregating pain_events by hour.
+   * Used by getOverviewHealth() to provide historical GFI context.
+   */
+  private readGfiTrend(date: string): { hour: string; value: number }[] {
+    try {
+      const rows = this.uiDb.all<{ hour: string; value: number }>(`
+        SELECT substr(created_at, 1, 13) || ':00:00Z' AS hour, ROUND(SUM(score), 2) AS value
+        FROM pain_events
+        WHERE substr(created_at, 1, 10) = ?
+        GROUP BY substr(created_at, 1, 13)
+        ORDER BY hour ASC
+      `, date);
+      return rows.map(row => ({ hour: row.hour, value: this.asNumber(row.value, 0) }));
+    } catch {
+      // pain_events table may not exist in this workspace — return empty trend
+      return [];
+    }
+  }
+
   getFeedbackGfi(): {
     current: number;
     peakToday: number;
     threshold: number;
-    trend: Array<{ hour: string; value: number }>;
+    trend: { hour: string; value: number }[];
     sources: Record<string, number>;
   } {
-    const session = this.getCurrentSession();
     const threshold = this.getGfiThreshold();
     const today = new Date().toISOString().slice(0, 10);
 
@@ -203,23 +277,26 @@ export class HealthQueryService {
       ORDER BY total DESC
     `, today);
 
+    // GFI: read from SQLite (synced from session JSON at construction time)
+    const gfiData = this.readGfiFromDb();
+
     return {
-      current: this.asNumber(session?.currentGfi, 0),
-      peakToday: this.asNumber(session?.dailyGfiPeak, this.asNumber(session?.currentGfi, 0)),
+      current: gfiData.currentGfi,
+      peakToday: gfiData.dailyGfiPeak,
       threshold,
       trend: trendRows.map((row) => ({ hour: row.hour, value: this.asNumber(row.value, 0) })),
       sources: Object.fromEntries(sourceRows.map((row) => [row.source, this.asNumber(row.total, 0)])),
     };
   }
 
-  getFeedbackEmpathyEvents(limit: number = 50): Array<{
+  getFeedbackEmpathyEvents(limit = 50): {
     timestamp: string;
     severity: string;
     score: number;
     reason: string;
     origin: string;
     gfiAfter: number;
-  }> {
+  }[] {
     const safeLimit = Math.max(1, Math.min(500, Math.floor(limit)));
     const events = this.readMergedEvents()
       .filter((entry) => entry.type === 'pain_signal' && String(entry.data?.source ?? '') === 'user_empathy')
@@ -239,13 +316,13 @@ export class HealthQueryService {
     });
   }
 
-  getFeedbackGateBlocks(limit: number = 50): Array<{
+  getFeedbackGateBlocks(limit = 50): {
     timestamp: string;
     toolName: string;
     reason: string;
     gfi: number;
     trustStage: number;
-  }> {
+  }[] {
     const trust = this.readTrust();
     const rows = this.readGateBlocksRaw(limit);
 
@@ -315,7 +392,7 @@ export class HealthQueryService {
     };
   }
 
-  getGateBlocks(limit: number = 50): Array<{
+  getGateBlocks(limit = 50): {
     timestamp: string;
     toolName: string;
     filePath: string | null;
@@ -323,7 +400,7 @@ export class HealthQueryService {
     gateType: string;
     gfi: number;
     trustStage: number;
-  }> {
+  }[] {
     const trust = this.readTrust();
     const rows = this.readGateBlocksRaw(limit);
 
@@ -347,13 +424,13 @@ export class HealthQueryService {
     );
     const rawStage = this.asNumber(
       scorecard.trustStage ?? scorecard.trust_stage ?? scorecard.stage,
-      this.inferTrustStageFromScore(score),
+      HealthQueryService.inferTrustStageFromScore(score),
     );
     const stage = Math.max(1, Math.min(4, Math.round(rawStage)));
 
     return {
       stage,
-      stageLabel: this.getTrustStageLabel(stage),
+      stageLabel: HealthQueryService.getTrustStageLabel(stage),
       score,
     };
   }
@@ -397,14 +474,20 @@ export class HealthQueryService {
   }
 
   private getCurrentSession(): SessionState | null {
+    // First, try in-memory sessions (live sessions from session-tracker)
     const sessions = listSessions(this.workspaceDir);
-    if (sessions.length === 0) return null;
-    const sorted = [...sessions].sort((a, b) => {
-      const aTs = Number(a.lastControlActivityAt ?? a.lastActivityAt ?? 0);
-      const bTs = Number(b.lastControlActivityAt ?? b.lastActivityAt ?? 0);
-      return bTs - aTs;
-    });
-    return sorted[0] ?? null;
+    if (sessions.length > 0) {
+      const sorted = [...sessions].sort((a, b) => {
+        const aTs = Number(a.lastControlActivityAt ?? a.lastActivityAt ?? 0);
+        const bTs = Number(b.lastControlActivityAt ?? b.lastActivityAt ?? 0);
+        return bTs - aTs;
+      });
+      return sorted[0] ?? null;
+    }
+
+    // Fallback: read session JSON files directly (handles process restarts where
+    // loadAllSessions may not have reloaded all sessions, or workspaceDir mismatch)
+    return this.readLatestSessionFromFile();
   }
 
   private getGfiThreshold(): number {
@@ -418,7 +501,7 @@ export class HealthQueryService {
     return fallback ?? 70;
   }
 
-  private computeHealthStage(currentGfi: number, threshold: number, painFlagActive: boolean): HealthStage {
+  private static computeHealthStage(currentGfi: number, threshold: number, painFlagActive: boolean): HealthStage {
     if (painFlagActive || currentGfi >= threshold) {
       return 'critical';
     }
@@ -428,7 +511,7 @@ export class HealthQueryService {
     return 'healthy';
   }
 
-  private getTrustStageLabel(stage: number): string {
+  private static getTrustStageLabel(stage: number): string {
     switch (stage) {
       case 1:
         return 'Observer';
@@ -443,7 +526,7 @@ export class HealthQueryService {
     }
   }
 
-  private inferTrustStageFromScore(score: number): number {
+  private static inferTrustStageFromScore(score: number): number {
     if (score >= 80) return 4;
     if (score >= 60) return 3;
     if (score >= 30) return 2;
@@ -468,6 +551,7 @@ export class HealthQueryService {
     const streamPath = resolvePdPath(this.workspaceDir, 'EVOLUTION_STREAM');
     if (!fs.existsSync(streamPath)) return [];
 
+    // eslint-disable-next-line no-useless-assignment -- Reason: initial value unused due to immediate reassignment
     let lines: string[] = [];
     try {
       const raw = fs.readFileSync(streamPath, 'utf8').trim();
@@ -479,6 +563,7 @@ export class HealthQueryService {
 
     const records: RecentPrincipleChange[] = [];
     for (const line of lines) {
+      // eslint-disable-next-line no-useless-assignment -- Reason: initial value unused due to immediate reassignment in try/catch
       let event: EvolutionStreamRecord | null = null;
       try {
         event = JSON.parse(line) as EvolutionStreamRecord;
@@ -572,10 +657,10 @@ export class HealthQueryService {
 
   private readNocturnalTraining(): {
     queue: { pending: number; inProgress: number; completed: number };
-    trinityRecords: Array<{ artifactId: string; status: string; createdAt: string }>;
+    trinityRecords: { artifactId: string; status: string; createdAt: string }[];
     arbiterPassRate: number;
     orpoSampleCount: number;
-    deployments: Array<{ modelId: string; status: string; checkpointPath: string | null }>;
+    deployments: { modelId: string; status: string; checkpointPath: string | null }[];
   } {
     const sampleDir = resolvePdPath(this.workspaceDir, 'NOCTURNAL_SAMPLES_DIR');
     const exportDir = resolvePdPath(this.workspaceDir, 'NOCTURNAL_EXPORTS_DIR');
@@ -696,6 +781,7 @@ export class HealthQueryService {
     return [];
   }
 
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this -- Reason: Private helper doesn't use instance state
   private getEventDedupKey(entry: EventLogEntry): string {
     const eventId = typeof entry.data?.eventId === 'string' ? entry.data.eventId : null;
     if (eventId) {
@@ -743,7 +829,7 @@ export class HealthQueryService {
     if (direct !== null) return direct;
 
     const reason = String(row.reason ?? '');
-    const match = reason.match(/gfi\s*[:=]\s*(-?\d+(?:\.\d+)?)/i);
+    const match = /gfi\s*[:=]\s*(-?\d+(?:\.\d+)?)/i.exec(reason);
     if (match) {
       return this.asNumber(Number(match[1]), 0);
     }
@@ -757,7 +843,7 @@ export class HealthQueryService {
     if (direct !== null) return Math.max(1, Math.min(4, Math.round(direct)));
 
     const reason = String(row.reason ?? '').toLowerCase();
-    const match = reason.match(/stage\s*(\d+)/i);
+    const match = /stage\s*(\d+)/i.exec(reason);
     if (match) {
       return Math.max(1, Math.min(4, Math.round(this.asNumber(Number(match[1]), fallbackStage))));
     }
@@ -765,6 +851,7 @@ export class HealthQueryService {
     return fallbackStage;
   }
 
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this -- Reason: Private helper doesn't use instance state
   private resolveGateType(row: GateBlockRow): string {
     if (typeof row.gate_type === 'string' && row.gate_type.trim().length > 0) {
       return row.gate_type;
@@ -788,12 +875,14 @@ export class HealthQueryService {
     return cached.has(columnName);
   }
 
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this -- Reason: Private helper doesn't use instance state
   private scoreToStatus(score: number): string {
     if (score >= 70) return 'healthy';
     if (score >= 40) return 'warning';
     return 'critical';
   }
 
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this -- Reason: Private helper doesn't use instance state
   private evolutionToStatus(tier: string, points: number): string {
     const lower = tier.toLowerCase();
     if (lower === 'forest' || lower === 'tree') return 'healthy';
@@ -801,7 +890,8 @@ export class HealthQueryService {
     return 'critical';
   }
 
-  private safeListFiles(dirPath: string, predicate: (name: string) => boolean): string[] {
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this, no-unused-vars -- Reason: Private helper doesn't use instance state
+  private safeListFiles(dirPath: string, predicate: (_name: string) => boolean): string[] {
     if (!fs.existsSync(dirPath)) return [];
     try {
       return fs.readdirSync(dirPath)
@@ -812,6 +902,7 @@ export class HealthQueryService {
     }
   }
 
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this -- Reason: Private helper doesn't use instance state
   private readJsonFile<T>(filePath: string, fallback: T): T {
     if (!fs.existsSync(filePath)) return fallback;
     try {
@@ -821,10 +912,12 @@ export class HealthQueryService {
     }
   }
 
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this -- Reason: Private helper doesn't use instance state
   private asNumber(value: unknown, fallback: number): number {
     return Number.isFinite(value) ? Number(value) : fallback;
   }
 
+  // eslint-disable-next-line @typescript-eslint/class-methods-use-this -- Reason: Private helper doesn't use instance state
   private asNullableNumber(value: unknown): number | null {
     if (Number.isFinite(value)) return Number(value);
     if (typeof value === 'string' && value.trim().length > 0) {
@@ -833,4 +926,88 @@ export class HealthQueryService {
     }
     return null;
   }
+
+  /**
+   * Sync GFI from the latest session JSON file into SQLite.
+   * Called at construction time so all queries read from a single source (SQLite).
+   */
+  private syncGfiFromSession(): void {
+    const session = this.readLatestSessionFromFile();
+    const currentGfi = this.asNumber(session?.currentGfi, 0);
+    const dailyGfiPeak = this.asNumber(session?.dailyGfiPeak, currentGfi);
+    const today = new Date().toISOString().slice(0, 10);
+
+    try {
+      this.uiDb.execute(`
+        CREATE TABLE IF NOT EXISTS gfi_state (
+          id INTEGER PRIMARY KEY CHECK (id = 1),
+          current_gfi REAL NOT NULL DEFAULT 0,
+          daily_gfi_peak REAL NOT NULL DEFAULT 0,
+          gfi_date TEXT NOT NULL DEFAULT ''
+        )
+      `);
+      this.uiDb.run(
+        'INSERT OR REPLACE INTO gfi_state (id, current_gfi, daily_gfi_peak, gfi_date) VALUES (1, ?, ?, ?)',
+        currentGfi,
+        dailyGfiPeak,
+        today,
+      );
+    } catch (err) {
+      console.warn('[HealthQueryService] Failed to sync GFI from session:', err);
+    }
+  }
+
+  /**
+   * Read current GFI state from SQLite.
+   */
+  private readGfiFromDb(): { currentGfi: number; dailyGfiPeak: number } {
+    try {
+      const row = this.uiDb.get<{ current_gfi: number; daily_gfi_peak: number }>(
+        'SELECT current_gfi, daily_gfi_peak FROM gfi_state WHERE id = 1',
+      );
+      if (!row) return { currentGfi: 0, dailyGfiPeak: 0 };
+      return {
+        currentGfi: row.current_gfi ?? 0,
+        dailyGfiPeak: row.daily_gfi_peak ?? 0,
+      };
+    } catch {
+      return { currentGfi: 0, dailyGfiPeak: 0 };
+    }
+  }
+
+  /**
+   * Read the most recent session JSON file from disk.
+   * Used to sync GFI from session-tracker's persistence into SQLite.
+   */
+  private readLatestSessionFromFile(): SessionState | null {
+    const sessionsDir = path.join(this.stateDir, 'sessions');
+    if (!fs.existsSync(sessionsDir)) return null;
+
+    try {
+      const files = fs.readdirSync(sessionsDir).filter(f => f.endsWith('.json'));
+      if (files.length === 0) return null;
+
+      let latest: SessionState | null = null;
+      let latestTs = 0;
+
+      for (const file of files) {
+        try {
+          const content = fs.readFileSync(path.join(sessionsDir, file), 'utf-8');
+          const state = JSON.parse(content) as SessionState;
+          if (state.workspaceDir && state.workspaceDir !== this.workspaceDir) continue;
+          const ts = Number(state.lastControlActivityAt ?? state.lastActivityAt ?? 0);
+          if (ts > latestTs) {
+            latestTs = ts;
+            latest = state;
+          }
+        } catch {
+          // Skip corrupted files
+        }
+      }
+
+      return latest;
+    } catch {
+      return null;
+    }
+  }
 }

package/src/service/nocturnal-runtime.ts

@@ -20,7 +20,8 @@
 
 import * as fs from 'fs';
 import * as path from 'path';
-import { listSessions, SessionState } from '../core/session-tracker.js';
+import type { SessionState } from '../core/session-tracker.js';
+import { listSessions } from '../core/session-tracker.js';
 import { withLockAsync } from '../utils/file-lock.js';
 
 // ---------------------------------------------------------------------------
@@ -303,6 +304,7 @@ export function checkWorkspaceIdle(
         trajectoryGuardrailConfirmsIdle = trajectoryIdleFor > idleThresholdMs * 0.8;
     }
 
+    // eslint-disable-next-line @typescript-eslint/init-declarations -- assigned in all if/else branches
     let reason: string;
     if (mostRecentActivityAt === 0) {
         reason = 'No active sessions found — workspace is idle';
@@ -350,8 +352,9 @@ export function checkCooldown(
     } = {}
 ): CooldownCheckResult {
     const {
-        globalCooldownMs = DEFAULT_GLOBAL_COOLDOWN_MS,
-        principleCooldownMs = DEFAULT_PRINCIPLE_COOLDOWN_MS,
+        /* eslint-disable @typescript-eslint/no-unused-vars, no-unused-vars -- Reason: Cooldown parameters reserved for future quota enforcement */
+        globalCooldownMs: _globalCooldownMs = DEFAULT_GLOBAL_COOLDOWN_MS,
+        principleCooldownMs: _principleCooldownMs = DEFAULT_PRINCIPLE_COOLDOWN_MS,
         maxRunsPerWindow = DEFAULT_MAX_RUNS_PER_WINDOW,
         quotaWindowMs = DEFAULT_QUOTA_WINDOW_MS,
     } = options;
@@ -369,7 +372,7 @@ export function checkCooldown(
         if (cooldownEnd > now) {
             globalCooldownActive = true;
             globalCooldownRemainingMs = cooldownEnd - now;
-            globalCooldownUntil = state.globalCooldownUntil;
+            globalCooldownUntil = state.globalCooldownUntil; // eslint-disable-line @typescript-eslint/prefer-destructuring -- Reason: globalCooldownUntil is reassignable outer let - destructuring would shadow
         }
     }
 
@@ -537,6 +540,7 @@ export interface PreflightCheckResult {
  * @param trajectoryLastActivityAt - Optional trajectory timestamp as secondary guardrail
  * @param idleCheckOverride - Optional override for idle check result (for testing)
  */
+/* eslint-disable @typescript-eslint/max-params -- Reason: Preflight check requires workspace, state, principleId, trajectory timestamp, and idle override */
 export function checkPreflight(
     workspaceDir: string,
     stateDir: string,