@miller-tech/uap 1.11.0 → 1.12.0

package/dist/dashboard/data-service.js

@@ -4,12 +4,13 @@
  * Extracts structured data from all UAP subsystems for consumption
  * by both the CLI dashboard and the web overlay.
  */
-import { existsSync, readFileSync, statSync } from 'fs';
+import { existsSync, readFileSync, readdirSync, statSync } from 'fs';
 import { loadUapConfig } from '../utils/config-loader.js';
 import { join } from 'path';
 import { execSync } from 'child_process';
 import Database from 'better-sqlite3';
 import { globalSessionStats } from '../mcp-router/session-stats.js';
+import { getSessionSnapshot } from '../telemetry/session-telemetry.js';
 import { getPerformanceMonitor } from '../utils/performance-monitor.js';
 const SUBPROCESS_CACHE_TTL = 30_000; // 30 seconds
 let cachedGitData = null;
@@ -17,19 +18,108 @@ let cachedQdrantStatus = null;
 // ── DB Connection Pool for memory database (prevents opening/closing on every refresh) ──
 const MEMORY_DB_CACHE_TTL = 5_000; // 5 seconds
 let cachedMemoryDb = null;
+function getTelemetryDb(cwd) {
+    const dbPath = join(cwd, 'agents', 'data', 'memory', 'telemetry.db');
+    const db = new Database(dbPath);
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS time_series (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      timestamp TEXT NOT NULL,
+      data TEXT NOT NULL
+    )
+  `);
+    return db;
+}
+function persistTimeSeriesPoint(cwd, point) {
+    try {
+        const db = getTelemetryDb(cwd);
+        db.prepare('INSERT INTO time_series (timestamp, data) VALUES (?, ?)').run(point.timestamp, JSON.stringify(point));
+        // Keep only the last 500 points
+        db.prepare('DELETE FROM time_series WHERE id NOT IN (SELECT id FROM time_series ORDER BY id DESC LIMIT 500)').run();
+        db.close();
+    }
+    catch {
+        /* ignore */
+    }
+}
+function getTimeSeriesFromDb(cwd) {
+    try {
+        const db = getTelemetryDb(cwd);
+        const rows = db
+            .prepare('SELECT data FROM time_series ORDER BY id DESC LIMIT 120')
+            .all();
+        db.close();
+        return rows
+            .reverse()
+            .map((r) => {
+            try {
+                return JSON.parse(r.data);
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((p) => p !== null);
+    }
+    catch {
+        return [];
+    }
+}
+export function getTimeSeriesHistory(cwd) {
+    return getTimeSeriesFromDb(cwd);
+}
+export function pushTimeSeriesPoint(cwd, point) {
+    persistTimeSeriesPoint(cwd, point);
+}
 // ── Data Gathering ──
 export async function getDashboardData() {
     const cwd = process.cwd();
+    const tasks = getTaskData(cwd);
+    const coordination = getCoordData(cwd);
+    const memory = getMemoryData(cwd);
+    const compliance = getComplianceData(cwd);
+    const deployBuckets = getDeployBucketData(cwd);
+    // Persist time-series point
+    const tsPoint = {
+        timestamp: new Date().toISOString(),
+        tasks: {
+            total: tasks.total,
+            done: tasks.done,
+            inProgress: tasks.inProgress,
+            blocked: tasks.blocked,
+            open: tasks.open,
+        },
+        coordination: {
+            activeAgents: coordination.activeAgents,
+            totalAgents: coordination.totalAgents,
+            completedAgents: coordination.completedAgents,
+            patternHits: coordination.patternHits,
+            activeWorktrees: coordination.activeWorktrees,
+        },
+        deployBuckets,
+        compression: memory.compression,
+        memoryHitsMisses: memory.hitsMisses || { hits: 0, misses: 0, hitRate: 'N/A' },
+        compliance: {
+            totalChecks: compliance.totalChecks,
+            totalBlocks: compliance.totalBlocks,
+            blockRate: compliance.blockRate,
+        },
+    };
+    pushTimeSeriesPoint(cwd, tsPoint);
     return {
         timestamp: new Date().toISOString(),
         system: getSystemData(cwd),
         policies: getPolicyData(cwd),
+        policyFiles: getPolicyFiles(cwd),
         auditTrail: getAuditData(cwd),
-        memory: getMemoryData(cwd),
+        memory,
         models: getModelData(cwd),
-        tasks: getTaskData(cwd),
-        coordination: getCoordData(cwd),
+        tasks,
+        coordination,
         performance: getPerformanceData(),
+        timeSeries: getTimeSeriesHistory(cwd),
+        compliance,
+        deployBuckets,
     };
 }
 function getSystemData(cwd) {
@@ -100,6 +190,60 @@ function getPolicyData(cwd) {
         return [];
     }
 }
+/**
+ * Read policy .md files from the policies/ directory.
+ * Returns metadata about each file (excluding README.md).
+ */
+export function getPolicyFiles(cwd) {
+    const policiesDir = join(cwd, 'policies');
+    if (!existsSync(policiesDir))
+        return [];
+    try {
+        const files = readdirSync(policiesDir).filter((f) => f.endsWith('.md') && f.toLowerCase() !== 'readme.md');
+        return files.map((f) => {
+            const nameWithoutExt = f.replace(/\.md$/, '');
+            // Convert kebab-case to Title Case
+            const name = nameWithoutExt
+                .split('-')
+                .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+                .join(' ');
+            // Derive category from filename patterns
+            let category = 'general';
+            if (nameWithoutExt.includes('iac') || nameWithoutExt.includes('pipeline')) {
+                category = 'infrastructure';
+            }
+            else if (nameWithoutExt.includes('worktree') || nameWithoutExt.includes('file')) {
+                category = 'workflow';
+            }
+            else if (nameWithoutExt.includes('gate') ||
+                nameWithoutExt.includes('completion') ||
+                nameWithoutExt.includes('mandatory')) {
+                category = 'quality';
+            }
+            else if (nameWithoutExt.includes('semver') || nameWithoutExt.includes('version')) {
+                category = 'versioning';
+            }
+            else if (nameWithoutExt.includes('image') || nameWithoutExt.includes('asset')) {
+                category = 'assets';
+            }
+            else if (nameWithoutExt.includes('kubectl') || nameWithoutExt.includes('backport')) {
+                category = 'operations';
+            }
+            else if (nameWithoutExt.includes('backup')) {
+                category = 'safety';
+            }
+            return {
+                filename: f,
+                name,
+                category,
+                path: join(policiesDir, f),
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
 function getAuditData(cwd) {
     const dbPath = join(cwd, 'agents', 'data', 'memory', 'policies.db');
     if (!existsSync(dbPath))
@@ -137,6 +281,7 @@ function getMemoryData(cwd) {
     let l2Entries = 0;
     let l4Entities = 0;
     let l4Relationships = 0;
+    const recentQueries = [];
     if (existsSync(memDbPath)) {
         try {
             l1SizeKB = Math.round(statSync(memDbPath).size / 1024);
@@ -155,6 +300,23 @@ function getMemoryData(cwd) {
                 .all();
             if (hasMem.length > 0) {
                 l1Entries = db.prepare('SELECT COUNT(*) as c FROM memories').get().c;
+                // Recent queries from memories table (last 10)
+                try {
+                    const memRows = db
+                        .prepare(`SELECT type, substr(content, 1, 80) as snippet, timestamp
+               FROM memories ORDER BY id DESC LIMIT 10`)
+                        .all();
+                    for (const row of memRows) {
+                        recentQueries.push({
+                            query: row.snippet || '',
+                            type: row.type || 'memory',
+                            timestamp: row.timestamp || '',
+                        });
+                    }
+                }
+                catch {
+                    /* table might not have expected columns */
+                }
             }
             const hasSess = db
                 .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='session_memories'")
@@ -180,12 +342,72 @@ function getMemoryData(cwd) {
             /* ignore */
         }
     }
-    // Get compression stats first (needed for both cached and fresh paths)
+    // Get compression stats from session stats
     const stats = globalSessionStats.getSummary();
+    // Try real compression ratio from model_analytics.db
+    let compressionRaw = stats.totalRawBytes;
+    let compressionCtx = stats.totalContextBytes;
+    let compressionSavings = stats.savingsPercent;
+    const compressionCalls = stats.totalCalls;
+    const analyticsDbPath = join(cwd, 'agents', 'data', 'memory', 'model_analytics.db');
+    if (existsSync(analyticsDbPath) && compressionRaw === 0) {
+        try {
+            const aDb = new Database(analyticsDbPath, { readonly: true });
+            const hasTable = aDb
+                .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='task_outcomes'")
+                .all();
+            if (hasTable.length > 0) {
+                const row = aDb
+                    .prepare('SELECT SUM(tokensIn) as ti, SUM(tokensOut) as to2 FROM task_outcomes')
+                    .get();
+                if (row && row.ti && row.to2 && row.ti + row.to2 > 0) {
+                    compressionRaw = row.ti + row.to2;
+                    compressionCtx = row.to2;
+                    const ratio = row.to2 / (row.ti + row.to2);
+                    compressionSavings = ((1 - ratio) * 100).toFixed(1) + '%';
+                }
+            }
+            aDb.close();
+        }
+        catch {
+            /* ignore */
+        }
+    }
     // Use TTL cache for Qdrant status (Docker doesn't change faster than 30s)
     let l3Status = 'Stopped';
     let l3Uptime = '';
     const now = Date.now();
+    // Memory hits/misses: derive from memory types (observations=hits, thoughts=misses)
+    // or from session telemetry if available
+    const snapshot = getSessionSnapshot();
+    let memHits = snapshot?.memoryHits ?? 0;
+    let memMisses = snapshot?.memoryMisses ?? 0;
+    if (memHits === 0 && memMisses === 0 && existsSync(memDbPath)) {
+        try {
+            const mdb = cachedMemoryDb?.db || new Database(memDbPath, { readonly: true });
+            const typeCounts = mdb
+                .prepare('SELECT type, COUNT(*) as c FROM memories GROUP BY type')
+                .all();
+            for (const tc of typeCounts) {
+                if (tc.type === 'observation' || tc.type === 'action')
+                    memHits += tc.c;
+                else if (tc.type === 'thought')
+                    memMisses += tc.c;
+            }
+            // Session memories are all hits (successfully stored context)
+            const sesCount = mdb.prepare('SELECT COUNT(*) as c FROM session_memories').get();
+            memHits += sesCount.c;
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    const memTotal = memHits + memMisses;
+    const hitsMisses = {
+        hits: memHits,
+        misses: memMisses,
+        hitRate: memTotal > 0 ? `${Math.round((memHits / memTotal) * 100)}%` : 'N/A',
+    };
     if (cachedQdrantStatus && cachedQdrantStatus.expiresAt > now) {
         return {
             l1: { entries: l1Entries, sizeKB: l1SizeKB },
@@ -193,11 +415,13 @@ function getMemoryData(cwd) {
             l3: { status: cachedQdrantStatus.data.status, uptime: cachedQdrantStatus.data.uptime },
             l4: { entities: l4Entities, relationships: l4Relationships },
             compression: {
-                rawBytes: stats.totalRawBytes,
-                contextBytes: stats.totalContextBytes,
-                savingsPercent: stats.savingsPercent,
-                totalCalls: stats.totalCalls,
+                rawBytes: compressionRaw,
+                contextBytes: compressionCtx,
+                savingsPercent: compressionSavings,
+                totalCalls: compressionCalls,
             },
+            hitsMisses,
+            recentQueries,
         };
     }
     try {
@@ -223,11 +447,13 @@ function getMemoryData(cwd) {
         l3: { status: l3Status, uptime: l3Uptime },
         l4: { entities: l4Entities, relationships: l4Relationships },
         compression: {
-            rawBytes: stats.totalRawBytes,
-            contextBytes: stats.totalContextBytes,
-            savingsPercent: stats.savingsPercent,
-            totalCalls: stats.totalCalls,
+            rawBytes: compressionRaw,
+            contextBytes: compressionCtx,
+            savingsPercent: compressionSavings,
+            totalCalls: compressionCalls,
         },
+        hitsMisses,
+        recentQueries,
     };
 }
 function getModelData(cwd) {
@@ -293,18 +519,22 @@ function getTaskData(cwd) {
             result.blocked = db.prepare("SELECT COUNT(*) as c FROM tasks WHERE status='blocked'").get().c;
             result.open = db.prepare("SELECT COUNT(*) as c FROM tasks WHERE status='open'").get().c;
             // Fetch individual task items for kanban board (most recent 50)
-            const rows = db.prepare(`SELECT id, title, type, status, priority, assignee, updated_at
+            const rows = db
+                .prepare(`SELECT id, title, type, status, priority, assignee, updated_at
          FROM tasks
          WHERE status NOT IN ('done', 'wont_do')
          ORDER BY priority ASC, updated_at DESC
-         LIMIT 50`).all();
+         LIMIT 50`)
+                .all();
             // Also fetch recent done/wont_do (last 10)
-            const doneRows = db.prepare(`SELECT id, title, type, status, priority, assignee, updated_at
+            const doneRows = db
+                .prepare(`SELECT id, title, type, status, priority, assignee, updated_at
          FROM tasks
          WHERE status IN ('done', 'wont_do')
          ORDER BY updated_at DESC
-         LIMIT 10`).all();
-            result.items = [...rows, ...doneRows].map(r => ({
+         LIMIT 10`)
+                .all();
+            result.items = [...rows, ...doneRows].map((r) => ({
                 id: r.id,
                 title: r.title,
                 type: r.type,
@@ -323,33 +553,321 @@ function getTaskData(cwd) {
 }
 function getCoordData(cwd) {
     const coordDbPath = join(cwd, 'agents/data/coordination/coordination.db');
-    const result = { activeAgents: 0, activeClaims: 0, pendingDeploys: 0 };
+    const result = {
+        activeAgents: 0,
+        activeClaims: 0,
+        pendingDeploys: 0,
+        totalAgents: 0,
+        completedAgents: 0,
+        patternHits: 0,
+        patternSuccesses: 0,
+        activeWorktrees: 0,
+        agents: [],
+        skillsPerAgent: {},
+        patternsPerAgent: {},
+    };
     if (existsSync(coordDbPath)) {
         try {
             const db = new Database(coordDbPath, { readonly: true });
-            const hasAgents = db
-                .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='agent_registry'")
-                .all();
-            if (hasAgents.length > 0) {
-                result.activeAgents = db.prepare("SELECT COUNT(*) as c FROM agent_registry WHERE status='active'").get().c;
+            // Active agents
+            try {
+                const hasAgents = db
+                    .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='agent_registry'")
+                    .all();
+                if (hasAgents.length > 0) {
+                    result.activeAgents = db.prepare("SELECT COUNT(*) as c FROM agent_registry WHERE status='active'").get().c;
+                    result.totalAgents = db.prepare('SELECT COUNT(*) as c FROM agent_registry').get().c;
+                    result.completedAgents = db
+                        .prepare("SELECT COUNT(*) as c FROM agent_registry WHERE status='completed'")
+                        .get().c;
+                    // Agent list
+                    try {
+                        const agentRows = db
+                            .prepare('SELECT id, name, status, started_at FROM agent_registry ORDER BY started_at DESC LIMIT 20')
+                            .all();
+                        result.agents = agentRows.map((a) => ({
+                            id: a.id,
+                            name: a.name,
+                            status: a.status,
+                            startedAt: a.started_at,
+                        }));
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
             }
-            const hasClaims = db
-                .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='work_claims'")
-                .all();
-            if (hasClaims.length > 0) {
-                result.activeClaims = db.prepare("SELECT COUNT(*) as c FROM work_claims WHERE status='active'").get().c;
+            catch {
+                /* ignore */
+            }
+            // Work claims - NO status column, use COUNT(*)
+            try {
+                const hasClaims = db
+                    .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='work_claims'")
+                    .all();
+                if (hasClaims.length > 0) {
+                    result.activeClaims = db.prepare('SELECT COUNT(*) as c FROM work_claims').get().c;
+                }
+            }
+            catch {
+                /* ignore */
             }
+            // Deploy queue
+            try {
+                const hasDQ = db
+                    .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='deploy_queue'")
+                    .all();
+                if (hasDQ.length > 0) {
+                    result.pendingDeploys = db.prepare("SELECT COUNT(*) as c FROM deploy_queue WHERE status='pending'").get().c;
+                }
+            }
+            catch {
+                /* ignore */
+            }
+            // Pattern outcomes
+            try {
+                const hasPO = db
+                    .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='pattern_outcomes'")
+                    .all();
+                if (hasPO.length > 0) {
+                    const poRow = db
+                        .prepare('SELECT SUM(uses) as u, SUM(successes) as s FROM pattern_outcomes')
+                        .get();
+                    result.patternHits = poRow?.u || 0;
+                    result.patternSuccesses = poRow?.s || 0;
+                    // Patterns per agent - group by pattern_id
+                    try {
+                        const patternRows = db
+                            .prepare('SELECT pattern_id, task_category, uses FROM pattern_outcomes ORDER BY uses DESC')
+                            .all();
+                        // Group patterns by agent (use agent list if available, otherwise use 'all')
+                        const agentIds = result.agents.length > 0 ? result.agents.map((a) => a.id) : ['all'];
+                        for (const agentId of agentIds) {
+                            result.patternsPerAgent[agentId] = patternRows.map((p) => ({
+                                id: p.pattern_id,
+                                category: p.task_category,
+                                uses: p.uses,
+                            }));
+                        }
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                }
+            }
+            catch {
+                /* ignore */
+            }
+            db.close();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    // Worktree count from worktree registry
+    try {
+        const wtDbPath = join(cwd, '.uap/worktree_registry.db');
+        if (existsSync(wtDbPath)) {
+            const wtDb = new Database(wtDbPath, { readonly: true });
+            try {
+                const hasTable = wtDb
+                    .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='worktrees'")
+                    .all();
+                if (hasTable.length > 0) {
+                    result.activeWorktrees = wtDb.prepare("SELECT COUNT(*) as c FROM worktrees WHERE status='active'").get().c;
+                }
+            }
+            catch {
+                /* ignore */
+            }
+            wtDb.close();
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    // Skills per agent: read from .claude/skills/ directory (shared by all agents)
+    try {
+        const skillsDir = join(cwd, '.claude', 'skills');
+        if (existsSync(skillsDir)) {
+            const skillDirs = readdirSync(skillsDir).filter((d) => {
+                try {
+                    return statSync(join(skillsDir, d)).isDirectory();
+                }
+                catch {
+                    return false;
+                }
+            });
+            const agentIds = result.agents.length > 0 ? result.agents.map((a) => a.id) : ['all'];
+            for (const agentId of agentIds) {
+                result.skillsPerAgent[agentId] = skillDirs;
+            }
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return result;
+}
+export function getDeployBucketData(cwd) {
+    const coordDbPath = join(cwd, 'agents/data/coordination/coordination.db');
+    const summary = {
+        totalActions: 0,
+        queued: 0,
+        batched: 0,
+        executing: 0,
+        done: 0,
+        failed: 0,
+        batchCount: 0,
+        savedOps: 0,
+    };
+    if (!existsSync(coordDbPath))
+        return summary;
+    try {
+        const db = new Database(coordDbPath, { readonly: true });
+        try {
             const hasDQ = db
                 .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='deploy_queue'")
                 .all();
             if (hasDQ.length > 0) {
-                result.pendingDeploys = db.prepare("SELECT COUNT(*) as c FROM deploy_queue WHERE status='pending'").get().c;
+                // Use status mapping: 'completed' counts as done
+                const rows = db
+                    .prepare(`SELECT status, COUNT(*) as c FROM deploy_queue GROUP BY status`)
+                    .all();
+                for (const row of rows) {
+                    summary.totalActions += row.c;
+                    switch (row.status) {
+                        case 'pending':
+                            summary.queued += row.c;
+                            break;
+                        case 'batched':
+                            summary.batched += row.c;
+                            break;
+                        case 'executing':
+                            summary.executing += row.c;
+                            break;
+                        case 'completed':
+                            summary.done += row.c;
+                            break;
+                        case 'failed':
+                            summary.failed += row.c;
+                            break;
+                    }
+                }
+            }
+        }
+        catch {
+            /* ignore */
+        }
+        try {
+            const hasDB = db
+                .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='deploy_batches'")
+                .all();
+            if (hasDB.length > 0) {
+                summary.batchCount = db.prepare('SELECT COUNT(*) as c FROM deploy_batches').get().c;
             }
-            db.close();
         }
         catch {
             /* ignore */
         }
+        db.close();
+    }
+    catch {
+        /* ignore */
+    }
+    // Calculate saved ops (batched actions that were squashed)
+    if (summary.batchCount > 0 && summary.totalActions > summary.batchCount) {
+        summary.savedOps = summary.totalActions - summary.batchCount;
+    }
+    return summary;
+}
+// ── Compliance Data ──
+function categorizeMechanism(policyId, policyName, operation) {
+    const combined = `${policyId} ${policyName} ${operation}`.toLowerCase();
+    if (combined.includes('worktree'))
+        return 'Worktree Gate';
+    if (combined.includes('build'))
+        return 'Build Gate';
+    if (combined.includes('test'))
+        return 'Test Gate';
+    if (combined.includes('schema'))
+        return 'Schema Diff Gate';
+    if (combined.includes('backup'))
+        return 'File Backup';
+    if (combined.includes('version'))
+        return 'Version Gate';
+    if (combined.includes('lint'))
+        return 'Lint Gate';
+    if (combined.includes('deploy'))
+        return 'Deploy Gate';
+    if (combined.includes('security') || combined.includes('secret'))
+        return 'Security Gate';
+    return 'Policy Enforcement';
+}
+function getComplianceData(cwd) {
+    const dbPath = join(cwd, 'agents', 'data', 'memory', 'policies.db');
+    const result = {
+        totalChecks: 0,
+        totalBlocks: 0,
+        blockRate: '0%',
+        recentFailures: [],
+        failuresByMechanism: {},
+    };
+    if (!existsSync(dbPath))
+        return result;
+    try {
+        const db = new Database(dbPath, { readonly: true });
+        const hasTable = db
+            .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='policy_executions'")
+            .all();
+        if (hasTable.length === 0) {
+            db.close();
+            return result;
+        }
+        result.totalChecks = db.prepare('SELECT COUNT(*) as c FROM policy_executions').get().c;
+        result.totalBlocks = db.prepare('SELECT COUNT(*) as c FROM policy_executions WHERE allowed = 0').get().c;
+        result.blockRate =
+            result.totalChecks > 0
+                ? `${Math.round((result.totalBlocks / result.totalChecks) * 100)}%`
+                : '0%';
+        const hasPolicies = db
+            .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='policies'")
+            .all();
+        let failureRows;
+        if (hasPolicies.length > 0) {
+            failureRows = db
+                .prepare(`SELECT pe.policyId, pe.operation, pe.reason, pe.executedAt, COALESCE(p.name, pe.policyId) as policyName
+         FROM policy_executions pe LEFT JOIN policies p ON pe.policyId = p.id
+         WHERE pe.allowed = 0 ORDER BY pe.executedAt DESC LIMIT 50`)
+                .all();
+        }
+        else {
+            failureRows = db
+                .prepare(`SELECT policyId, operation, reason, executedAt, policyId as policyName
+         FROM policy_executions WHERE allowed = 0 ORDER BY executedAt DESC LIMIT 50`)
+                .all();
+        }
+        const mechanismCounts = {};
+        result.recentFailures = failureRows.map((r) => {
+            const pid = r.policyId || '';
+            const pname = r.policyName || pid;
+            const op = r.operation || 'unknown';
+            const mech = categorizeMechanism(pid, pname, op);
+            mechanismCounts[mech] = (mechanismCounts[mech] || 0) + 1;
+            return {
+                policyId: pid,
+                policyName: pname,
+                operation: op,
+                reason: r.reason || '',
+                executedAt: r.executedAt || '',
+                defeatedMechanism: mech,
+            };
+        });
+        result.failuresByMechanism = mechanismCounts;
+        db.close();
+    }
+    catch {
+        /* ignore */
     }
     return result;
 }