@devflow-tools/server 0.8.10 → 0.9.0

package/dist/telemetry/telemetry.service.js

@@ -12,66 +12,109 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { Inject, Injectable, NotFoundException, Optional } from "@nestjs/common";
 import { TelemetryEngine } from "@devflow-tools/telemetry";
+import { DevFlowDatabase } from "@devflow-tools/database";
 import { ErrorCode } from "../common/error-codes.js";
+import { AutoChecker } from './auto-checker.js';
 let TelemetryService = class TelemetryService {
     constructor(database) {
-        this.engine = new TelemetryEngine();
+        this.engine = new TelemetryEngine(); // Legacy in-memory store — real data goes through this.db
         this.db = database ?? null;
     }
     async recordEvent(event) {
-        await this.engine.recordEvent(event);
+        if (!this.db)
+            return;
+        this.db.insertEvent?.({
+            runId: event.runId,
+            kind: event.kind,
+            timestamp: event.timestamp,
+            duration: event.duration,
+            toolName: event.data?.toolName,
+            pluginName: event.data?.mcpToolName,
+            metadata: event.data,
+        });
+    }
+    // ---- Sessions ----
+    async createSession(params) {
+        if (!this.db)
+            return;
+        this.db.insertSession({
+            id: params.id,
+            projectRoot: params.projectRoot,
+            label: params.label,
+            startedAt: params.startedAt,
+        });
     }
+    async getSession(id) {
+        if (!this.db)
+            throw new NotFoundException({ error: { code: ErrorCode.RUN_NOT_FOUND, message: `Session "${id}" not found`, details: {} } });
+        const session = this.db.getSession(id);
+        if (!session)
+            throw new NotFoundException({ error: { code: ErrorCode.RUN_NOT_FOUND, message: `Session "${id}" not found`, details: {} } });
+        return session;
+    }
+    async listSessions(limit, offset, projectRoot) {
+        if (!this.db)
+            return [];
+        return this.db.listSessions(limit, offset, projectRoot);
+    }
+    async getSessionEvents(sessionId) {
+        if (!this.db)
+            return [];
+        return this.db.listToolCallEventsBySession?.(sessionId) ?? [];
+    }
+    async closeSession(id, finishedAt) {
+        if (!this.db)
+            return;
+        this.db.closeSession(id, finishedAt);
+    }
+    async createSkillExecution(params) {
+        if (!this.db)
+            return;
+        this.db.insertSkillExecution({
+            executionId: params.executionId,
+            sessionId: params.sessionId,
+            skillName: params.skillName,
+            startedAt: params.startedAt,
+            status: 'running',
+        });
+    }
+    // ---- Runs (now backed by sessions) ----
     async listRuns(limit, offset, source) {
-        const runs = Array.from(this.engine.runs.values());
-        let filtered = runs;
-        if (source) {
-            filtered = runs.filter((r) => r.meta?.source === source);
-        }
-        const engineRuns = filtered.slice(offset, offset + limit).map((r) => ({
-            id: r.meta?.runId ?? "", agent: r.meta?.agent ?? "", mode: r.meta?.mode ?? "",
-            source: r.meta?.source ?? "unknown", status: r.status, startedAt: r.startedAt, tokenUsed: r.tokenUsed,
-        }));
-        // Also include skill_executions from the database (hook telemetry)
         if (this.db) {
             try {
-                const execs = this.db.listSkillExecutions(limit, 0);
-                const dbRuns = execs.map((e) => ({
-                    id: e.executionId,
+                const sessions = this.db.listSessions(limit, offset);
+                return sessions.map((s) => ({
+                    id: s.id,
                     agent: "claude-code",
                     mode: "hook",
                     source: "hook",
-                    status: e.status,
-                    startedAt: e.startedAt,
-                    tokenUsed: e.totalTokens,
-                    skillName: e.skillName,
-                    totalToolCalls: e.totalToolCalls,
-                    mcpToolCalls: e.mcpToolCalls,
-                    mcpComplianceRate: e.mcpComplianceRate,
+                    status: s.status,
+                    startedAt: s.startedAt,
+                    totalToolCalls: s.totalToolCalls,
+                    mcpToolCalls: s.mcpToolCalls,
+                    mcpComplianceRate: s.mcpToolCalls > 0 ? Math.round(s.mcpToolCalls / s.totalToolCalls * 100) / 100 : 0,
                 }));
-                // Merge: db runs first (most recent), then engine runs, dedup by id
-                const seen = new Set();
-                const merged = [...dbRuns, ...engineRuns].filter((r) => {
-                    if (seen.has(r.id))
-                        return false;
-                    seen.add(r.id);
-                    return true;
-                });
-                return merged.slice(offset, offset + limit);
-            }
-            catch {
-                // DB not available — fall back to engine runs only
             }
+            catch { }
         }
-        return engineRuns;
+        return [];
     }
     async getRun(id) {
-        // 1. Try in-memory engine first
-        const run = this.engine.runs.get(id);
-        if (run)
-            return run;
-        // 2. Fall back to database (skill_executions)
+        // Try session first, then skill execution, then engine
         if (this.db) {
             try {
+                const s = this.db.getSession(id);
+                if (s) {
+                    return {
+                        meta: { runId: s.id, agent: "claude-code", mode: "hook", source: "hook" },
+                        status: s.status,
+                        startedAt: s.startedAt,
+                        finishedAt: s.finishedAt,
+                        totalToolCalls: s.totalToolCalls,
+                        mcpToolCalls: s.mcpToolCalls,
+                        steps: [],
+                    };
+                }
                 const exec = this.db.getSkillExecution(id);
                 if (exec) {
                     return {
@@ -79,411 +122,326 @@ let TelemetryService = class TelemetryService {
                         status: exec.status,
                         startedAt: exec.startedAt,
                         finishedAt: exec.finishedAt,
-                        tokenUsed: exec.totalTokens,
-                        steps: [],
-                        // Extra fields from skill_executions
                         skillName: exec.skillName,
                         totalToolCalls: exec.totalToolCalls,
                         mcpToolCalls: exec.mcpToolCalls,
-                        directToolCalls: exec.directToolCalls,
                         mcpComplianceRate: exec.mcpComplianceRate,
+                        steps: [],
                     };
                 }
             }
-            catch { /* DB not available */ }
+            catch { }
         }
+        const run = this.engine.runs.get(id);
+        if (run)
+            return run;
         throw new NotFoundException({ error: { code: ErrorCode.RUN_NOT_FOUND, message: `Run "${id}" not found`, details: {} } });
     }
     async getTimeline(from, to) {
-        const runs = Array.from(this.engine.runs.values());
-        return runs
-            .filter((r) => {
-            if (from && r.startedAt < Number(from))
-                return false;
-            if (to && r.startedAt > Number(to))
-                return false;
-            return true;
-        })
-            .flatMap((r) => r.steps?.map((s) => ({
-            runId: r.meta?.runId, stepId: s.stepId, type: s.type,
-            duration: s.duration, timestamp: s.timestamp,
-        })) ?? []);
+        if (!this.db)
+            return [];
+        try {
+            const sessions = this.db.listSessions(500, 0);
+            return sessions
+                .filter((s) => {
+                if (from && s.startedAt < Number(from))
+                    return false;
+                if (to && s.startedAt > Number(to))
+                    return false;
+                return true;
+            })
+                .map((s) => ({
+                runId: s.id,
+                stepId: s.id,
+                type: "session",
+                duration: s.durationMs,
+                timestamp: s.startedAt,
+            }));
+        }
+        catch {
+            return [];
+        }
     }
     async getRunEvents(runId) {
-        // 1. Try in-memory engine first
-        const engineEvents = await this.engine.listEvents(runId);
-        if (engineEvents && engineEvents.length > 0)
-            return engineEvents;
-        // 2. Fall back to database (tool_call_events)
+        // Try session events first
         if (this.db) {
             try {
-                const dbEvents = this.db.listToolCallEvents(runId);
-                if (dbEvents && dbEvents.length > 0) {
-                    return dbEvents.map((e) => ({
-                        eventId: e.eventId,
-                        runId,
-                        stepId: e.eventId,
-                        type: e.isMcpTool ? "mcp_tool" : e.toolType === "subagent" ? "subagent" : "tool_use",
-                        timestamp: e.timestamp,
-                        duration: e.duration,
-                        toolName: e.toolName,
-                        toolType: e.toolType,
-                        isMcpTool: e.isMcpTool,
-                        mcpToolName: e.mcpToolName,
-                        mcpEnforced: e.mcpEnforced,
-                        mcpFallback: e.mcpFallback,
-                        tokensUsed: e.tokensUsed,
-                        blocked: e.blocked,
-                        blockReason: e.blockReason,
-                        error: e.error,
-                        output: e.output,
-                        input: e.input,
-                    }));
-                }
+                const events = this.db.listToolCallEventsBySession(runId);
+                if (events && events.length > 0)
+                    return events;
+                const execEvents = this.db.listToolCallEvents(runId);
+                if (execEvents && execEvents.length > 0)
+                    return execEvents;
             }
-            catch { /* DB not available */ }
+            catch { }
         }
+        const engineEvents = await this.engine.listEvents(runId);
         return engineEvents ?? [];
     }
     async getRunStats(runId) {
-        // 1. Try in-memory engine first
-        const engineStats = await this.engine.getRunStats(runId);
-        if (engineStats && engineStats.totalEvents > 0)
-            return engineStats;
-        // 2. Fall back to database
         if (this.db) {
             try {
-                const exec = this.db.getSkillExecution(runId);
-                const events = this.db.listToolCallEvents(runId);
-                if (exec) {
-                    const sumTokens = events?.reduce((s, e) => s + (e.tokensUsed ?? 0), 0) ?? 0;
+                const events = this.db.listToolCallEventsBySession(runId) ?? this.db.listToolCallEvents(runId) ?? [];
+                if (events.length > 0) {
                     return {
-                        totalEvents: events?.length ?? 0,
+                        totalEvents: events.length,
                         llmCalls: 0,
-                        totalTokens: exec.totalTokens || sumTokens,
-                        toolUses: exec.totalToolCalls,
+                        totalTokens: 0,
+                        toolUses: events.length,
                         fileReads: 0,
                         fileWrites: 0,
                         bashCommands: 0,
-                        errors: events?.filter((e) => e.error).length ?? 0,
-                        totalDuration: exec.totalDuration,
-                        mcpToolCalls: exec.mcpToolCalls,
-                        directToolCalls: exec.directToolCalls,
-                        mcpComplianceRate: exec.mcpComplianceRate,
+                        errors: events.filter((e) => e.error).length,
+                        totalDuration: 0,
+                        mcpToolCalls: events.filter((e) => e.isMcpTool).length,
+                        directToolCalls: events.filter((e) => !e.isMcpTool).length,
+                        mcpComplianceRate: events.length > 0
+                            ? events.filter((e) => e.isMcpTool).length / events.length : 0,
                     };
                 }
             }
-            catch { /* DB not available */ }
+            catch { }
         }
-        return engineStats;
+        return this.engine.getRunStats(runId);
     }
     async endRun(runId, result) {
         await this.engine.endRun(runId, result);
     }
-    async getFeedbackStats(projectRoot, periodDays) {
-        const allEvents = this.collectAllEvents();
-        const cutoff = periodDays != null
-            ? Date.now() - periodDays * 24 * 60 * 60 * 1000
-            : undefined;
-        const feedbackEvents = allEvents.filter((e) => {
-            if (e.data?.toolName !== "context_feedback")
-                return false;
-            if (projectRoot && e.data?.toolInput?.projectRoot !== projectRoot)
-                return false;
-            if (cutoff != null && (e.timestamp ?? 0) < cutoff)
-                return false;
-            return true;
-        });
-        const total = feedbackEvents.length;
-        const hits = feedbackEvents.filter((e) => e.data?.toolInput?.feedback === "hit").length;
-        const partials = feedbackEvents.filter((e) => e.data?.toolInput?.feedback === "partial").length;
-        const misses = feedbackEvents.filter((e) => e.data?.toolInput?.feedback === "miss").length;
-        return {
-            total,
-            hits,
-            partials,
-            misses,
-            hitRate: total > 0 ? hits / total : 0,
-            partialRate: total > 0 ? partials / total : 0,
-            missRate: total > 0 ? misses / total : 0,
-        };
-    }
-    collectAllEvents() {
-        const eventsMap = this.engine.events;
-        if (!eventsMap)
-            return [];
-        const all = [];
-        for (const events of eventsMap.values()) {
-            if (Array.isArray(events))
-                all.push(...events);
-        }
-        return all;
-    }
+    // ---- Telemetry Stats (from sessions + tool_call_events) ----
     async getStats(periodDays = 7) {
-        const runs = Array.from(this.engine.runs.values());
+        if (!this.db)
+            return this.emptyStats();
         const now = Date.now();
         const cutoff = now - periodDays * 24 * 60 * 60 * 1000;
-        const periodRuns = runs.filter((r) => r.startedAt >= cutoff);
-        const days = {};
-        for (const r of periodRuns) {
-            const day = new Date(r.startedAt).toISOString().slice(0, 10);
-            if (!days[day])
-                days[day] = { runs: 0, tokens: 0 };
-            days[day].runs++;
-            days[day].tokens += r.tokenUsed ?? 0;
-        }
-        let totalTokens = 0;
-        let totalLlmCalls = 0;
-        let totalToolUses = 0;
-        for (const r of periodRuns) {
-            const events = (this.engine.events.get(r.meta?.runId) ?? []);
-            totalTokens += r.tokenUsed ?? 0;
-            totalLlmCalls += events.filter((e) => e.kind === "llm_call").length;
-            totalToolUses += events.filter((e) => e.kind === "tool_use").length;
-        }
-        const from = new Date(cutoff).toISOString().slice(0, 10);
-        const to = new Date(now).toISOString().slice(0, 10);
-        return {
-            period: { from, to },
-            summary: {
-                totalRuns: periodRuns.length,
-                completedRuns: periodRuns.filter((r) => r.status === "completed").length,
-                failedRuns: periodRuns.filter((r) => r.status === "failed").length,
-                totalTokens,
-                totalLlmCalls,
-                totalToolUses,
-                avgRunDuration: periodRuns.length > 0
-                    ? Math.round(periodRuns.reduce((s, r) => s + ((r.finishedAt ?? now) - r.startedAt), 0) / periodRuns.length)
-                    : 0,
-            },
-            byDay: Object.entries(days)
-                .map(([date, d]) => ({ date, ...d }))
-                .sort((a, b) => a.date.localeCompare(b.date)),
-            byWorkflow: this.buildWorkflowBreakdown(periodRuns, now),
-            byPlugin: this.buildPluginBreakdown(periodRuns),
-        };
-    }
-    buildWorkflowBreakdown(periodRuns, now) {
-        const byWorkflow = {};
-        for (const r of periodRuns) {
-            const wf = r.workflowName ?? r.meta?.workflowName ?? "unknown";
-            if (!byWorkflow[wf])
-                byWorkflow[wf] = { runs: 0, completed: 0, failed: 0, avgDuration: 0 };
-            byWorkflow[wf].runs++;
-            if (r.status === "completed")
-                byWorkflow[wf].completed++;
-            else
-                byWorkflow[wf].failed++;
-            byWorkflow[wf].avgDuration += ((r.finishedAt ?? now) - r.startedAt);
-        }
-        for (const wf of Object.keys(byWorkflow)) {
-            byWorkflow[wf].avgDuration = byWorkflow[wf].runs > 0
-                ? Math.round(byWorkflow[wf].avgDuration / byWorkflow[wf].runs) : 0;
+        try {
+            const sessions = this.db.listSessions(1000, 0);
+            const periodSessions = sessions.filter((s) => s.startedAt >= cutoff);
+            const days = {};
+            let totalToolCalls = 0;
+            for (const s of periodSessions) {
+                const day = new Date(s.startedAt).toISOString().slice(0, 10);
+                if (!days[day])
+                    days[day] = { runs: 0 };
+                days[day].runs++;
+                totalToolCalls += s.totalToolCalls ?? 0;
+            }
+            return {
+                period: {
+                    from: new Date(cutoff).toISOString().slice(0, 10),
+                    to: new Date(now).toISOString().slice(0, 10),
+                },
+                summary: {
+                    totalRuns: periodSessions.length,
+                    completedRuns: periodSessions.filter((s) => s.status === 'completed').length,
+                    failedRuns: periodSessions.filter((s) => s.status === 'failed').length,
+                    totalTokens: 0,
+                    totalLlmCalls: 0,
+                    totalToolUses: totalToolCalls,
+                    avgRunDuration: periodSessions.length > 0
+                        ? Math.round(periodSessions.reduce((sum, s) => sum + (s.durationMs ?? 0), 0) / periodSessions.length)
+                        : 0,
+                },
+                byDay: Object.entries(days)
+                    .map(([date, d]) => ({ date, tokens: 0, ...d }))
+                    .sort((a, b) => a.date.localeCompare(b.date)),
+                byWorkflow: [],
+                byPlugin: [],
+            };
         }
-        return Object.entries(byWorkflow).map(([name, d]) => ({
-            name,
-            runs: d.runs,
-            successRate: d.runs > 0 ? d.completed / d.runs : 0,
-            avgDuration: d.avgDuration,
-        }));
-    }
-    buildPluginBreakdown(periodRuns) {
-        const byPlugin = {};
-        for (const r of periodRuns) {
-            const pl = r.pluginName ?? r.meta?.pluginName ?? "none";
-            if (!byPlugin[pl])
-                byPlugin[pl] = { runs: 0, completed: 0, failed: 0 };
-            byPlugin[pl].runs++;
-            if (r.status === "completed")
-                byPlugin[pl].completed++;
-            else
-                byPlugin[pl].failed++;
+        catch {
+            return this.emptyStats();
         }
-        return Object.entries(byPlugin).map(([name, d]) => ({
-            name,
-            runs: d.runs,
-            successRate: d.runs > 0 ? d.completed / d.runs : 0,
-        }));
     }
-    async getOpsRoiSummary() {
-        const runs = Array.from(this.engine.runs.values());
-        const now = Date.now();
-        const totalRuns = runs.length;
-        const successfulRuns = runs.filter((r) => r.status === "completed").length;
-        const successRate = totalRuns > 0 ? successfulRuns / totalRuns : 0;
-        const totalTokens = runs.reduce((sum, r) => sum + (r.tokenUsed ?? 0), 0);
-        const avgTokenUsage = totalRuns > 0 ? totalTokens / totalRuns : 0;
-        const totalDuration = runs.reduce((sum, r) => {
-            const start = r.startedAt ?? 0;
-            const end = r.finishedAt ?? now;
-            return sum + (end - start);
-        }, 0);
-        const avgDuration = totalRuns > 0 ? totalDuration / totalRuns : 0;
-        // Feedback hit rate: combine run-level feedback with context_feedback telemetry events
-        const runFeedbackHits = runs.filter((r) => r.relevanceFeedback === "hit" || r.meta?.relevanceFeedback === "hit").length;
-        const runFeedbackTotal = runs.filter((r) => r.relevanceFeedback !== undefined || r.meta?.relevanceFeedback !== undefined).length;
-        const telemetryFeedback = await this.getFeedbackStats();
-        const combinedHits = runFeedbackHits + telemetryFeedback.hits;
-        const combinedTotal = runFeedbackTotal + telemetryFeedback.total;
-        const feedbackHitRate = combinedTotal > 0 ? combinedHits / combinedTotal : 0;
+    emptyStats() {
         return {
-            period: "all-time",
-            totalRuns,
-            successfulRuns,
-            successRate,
-            avgTokenUsage,
-            avgDuration,
-            feedbackHitRate,
-            trend: "stable",
-        };
-    }
-    async getExperimentalRoiSummary() {
-        return {
-            totalScenarios: 0,
-            avgTimeSavedRate: null,
-            avgTokenReductionRate: null,
-            avgFirstPassLift: null,
-            avgReworkReductionRate: null,
-            conclusion: "No experimental data available yet",
+            period: { from: '', to: '' },
+            summary: { totalRuns: 0, completedRuns: 0, failedRuns: 0, totalTokens: 0, totalLlmCalls: 0, totalToolUses: 0, avgRunDuration: 0 },
+            byDay: [],
+            byWorkflow: [],
+            byPlugin: [],
         };
     }
+    // ---- ROI Summary (from sessions + tool_call_events) ----
     async getRoiSummary(periodDays = 7) {
-        const runs = Array.from(this.engine.runs.values());
+        if (!this.db)
+            return this.emptyRoiSummary();
         const now = Date.now();
         const cutoff = now - periodDays * 24 * 60 * 60 * 1000;
-        const periodRuns = runs.filter((r) => r.startedAt >= cutoff);
-        // Overview
-        const totalRuns = periodRuns.length;
-        const completedRuns = periodRuns.filter((r) => r.status === "completed").length;
-        const failedRuns = periodRuns.filter((r) => r.status !== "completed").length;
-        const avgDuration = totalRuns > 0
-            ? Math.round(periodRuns.reduce((s, r) => s + ((r.finishedAt ?? now) - r.startedAt), 0) / totalRuns)
-            : 0;
-        const avgTokens = totalRuns > 0
-            ? Math.round(periodRuns.reduce((s, r) => s + (r.tokenUsed ?? 0), 0) / totalRuns)
-            : 0;
-        const firstPassSuccesses = periodRuns.filter((r) => r.firstPassSuccess === true || r.meta?.firstPassSuccess === true).length;
-        const firstPassSuccessRate = totalRuns > 0 ? firstPassSuccesses / totalRuns : 0;
-        // Combine run-level feedback with context_feedback telemetry events
-        const runFeedbackHits = periodRuns.filter((r) => r.relevanceFeedback === "hit" || r.meta?.relevanceFeedback === "hit").length;
-        const runFeedbackTotal = periodRuns.filter((r) => r.relevanceFeedback !== undefined || r.meta?.relevanceFeedback !== undefined).length;
-        const telemetryFeedback = await this.getFeedbackStats(undefined, periodDays);
-        const combinedHits = runFeedbackHits + telemetryFeedback.hits;
-        const combinedTotal = runFeedbackTotal + telemetryFeedback.total;
-        const feedbackHitRate = combinedTotal > 0 ? combinedHits / combinedTotal : 0;
-        // Efficiency
-        const totalRetries = periodRuns.reduce((s, r) => s + (r.retryCount ?? r.meta?.retryCount ?? 0), 0);
-        const avgRetryCount = totalRuns > 0 ? totalRetries / totalRuns : 0;
-        const avgTimePerTask = avgDuration;
-        // Failure breakdown
-        const failureBreakdown = {
-            context_insufficient: 0,
-            knowledge_missing: 0,
-            workflow_design_issue: 0,
-            tool_error: 0,
-            agent_override: 0,
-            unknown: 0,
-        };
-        for (const r of periodRuns) {
-            if (r.status !== "completed") {
-                const runId = r.meta?.runId;
-                if (runId) {
-                    try {
-                        const cat = await this.engine.classifyFailure(runId);
-                        failureBreakdown[cat] = (failureBreakdown[cat] ?? 0) + 1;
+        try {
+            const sessions = this.db.listSessions(1000, 0);
+            const periodSessions = sessions.filter((s) => s.startedAt >= cutoff);
+            const totalRuns = periodSessions.length;
+            const completedRuns = periodSessions.filter((s) => s.status === 'completed').length;
+            const failedRuns = periodSessions.filter((s) => s.status === 'failed').length;
+            const avgDuration = totalRuns > 0
+                ? Math.round(periodSessions.reduce((sum, s) => sum + (s.durationMs ?? 0), 0) / totalRuns)
+                : 0;
+            // Daily breakdown
+            const days = {};
+            for (const s of periodSessions) {
+                const day = new Date(s.startedAt).toISOString().slice(0, 10);
+                if (!days[day])
+                    days[day] = { runs: 0, failures: 0 };
+                days[day].runs++;
+                if (s.status === 'failed')
+                    days[day].failures++;
+            }
+            // Batch fetch all events for all period sessions
+            const allEventGroups = this.db.listToolCallEventsBySessions(periodSessions.map((s) => s.id));
+            // Failure breakdown from tool_call_events errors
+            const failureBreakdown = {
+                tool_error: 0,
+                mcp_unavailable: 0,
+                unknown: 0,
+            };
+            const byPlugin = {};
+            for (const s of periodSessions) {
+                const events = (allEventGroups[s.id] ?? []);
+                for (const e of events) {
+                    if (e.error) {
+                        const err = e.error.toLowerCase();
+                        if (err.includes('mcp') || err.includes('unavailable') || err.includes('not found'))
+                            failureBreakdown.mcp_unavailable++;
+                        else if (err.includes('tool') || err.includes('command') || err.includes('error'))
+                            failureBreakdown.tool_error++;
+                        else
+                            failureBreakdown.unknown++;
                     }
-                    catch {
-                        failureBreakdown.unknown++;
+                    if (e.mcpToolName) {
+                        const prefix = e.mcpToolName.split('_')[0];
+                        if (prefix)
+                            byPlugin[prefix] = (byPlugin[prefix] ?? 0) + 1;
                     }
                 }
-                else {
-                    failureBreakdown.unknown++;
-                }
             }
+            return {
+                period: {
+                    from: new Date(cutoff).toISOString().slice(0, 10),
+                    to: new Date(now).toISOString().slice(0, 10),
+                },
+                overview: {
+                    totalRuns,
+                    completedRuns,
+                    failedRuns,
+                    avgDuration,
+                    firstPassSuccessRate: totalRuns > 0 ? Math.round((completedRuns / totalRuns) * 10000) / 100 : 0,
+                },
+                efficiency: {
+                    avgTimePerTask: avgDuration,
+                },
+                failures: {
+                    total: failedRuns,
+                    breakdown: failureBreakdown,
+                },
+                workflows: [],
+                plugins: Object.entries(byPlugin).map(([name, runs]) => {
+                    const pluginSessions = periodSessions.filter((s) => {
+                        const evts = (allEventGroups[s.id] ?? []);
+                        return evts.some((e) => e.mcpToolName?.startsWith(name + '_'));
+                    });
+                    const completed = pluginSessions.filter((s) => s.status === 'completed').length;
+                    const successRate = pluginSessions.length > 0
+                        ? Math.round((completed / pluginSessions.length) * 10000) / 100
+                        : 0;
+                    return { name, runs, successRate };
+                }),
+                byDay: Object.entries(days)
+                    .map(([date, d]) => ({ date, ...d, tokens: 0 }))
+                    .sort((a, b) => a.date.localeCompare(b.date)),
+            };
         }
-        // Daily breakdown
-        const days = {};
-        for (const r of periodRuns) {
-            const day = new Date(r.startedAt).toISOString().slice(0, 10);
-            if (!days[day])
-                days[day] = { runs: 0, tokens: 0, failures: 0 };
-            days[day].runs++;
-            days[day].tokens += r.tokenUsed ?? 0;
-            if (r.status !== "completed")
-                days[day].failures++;
+        catch {
+            return this.emptyRoiSummary();
         }
-        return {
-            period: {
-                from: new Date(cutoff).toISOString().slice(0, 10),
-                to: new Date(now).toISOString().slice(0, 10),
-            },
-            overview: {
-                totalRuns, completedRuns, failedRuns, avgDuration, avgTokens,
-                firstPassSuccessRate, feedbackHitRate,
-            },
-            efficiency: {
-                totalTokensSaved: 0, // needs baseline comparison data
-                avgTimePerTask,
-                avgRetryCount,
-            },
-            failures: {
-                total: failedRuns,
-                breakdown: failureBreakdown,
-            },
-            workflows: this.buildWorkflowBreakdown(periodRuns, now),
-            plugins: this.buildPluginBreakdown(periodRuns),
-            byDay: Object.entries(days)
-                .map(([date, d]) => ({ date, ...d }))
-                .sort((a, b) => a.date.localeCompare(b.date)),
-        };
     }
-    async getPluginEffectiveness(pluginName, projectRoot) {
-        const runs = Array.from(this.engine.runs.values());
-        const pluginRuns = runs.filter((r) => {
-            const name = r.pluginName ?? r.meta?.pluginName;
-            if (name !== pluginName)
-                return false;
-            if (projectRoot && r.meta?.projectRoot !== projectRoot)
-                return false;
-            return true;
-        });
-        const total = pluginRuns.length;
-        const successful = pluginRuns.filter((r) => r.status === "completed").length;
-        const startedAts = pluginRuns.map((r) => r.startedAt).filter((t) => typeof t === "number");
+    emptyRoiSummary() {
         return {
-            name: pluginName,
-            totalRuns: total,
-            successRate: total > 0 ? successful / total : 0,
-            lastUsedAt: startedAts.length > 0
-                ? new Date(Math.max(...startedAts)).toISOString()
-                : null,
+            period: { from: '', to: '' },
+            overview: { totalRuns: 0, completedRuns: 0, failedRuns: 0, avgDuration: 0, firstPassSuccessRate: 0 },
+            efficiency: { avgTimePerTask: 0 },
+            failures: { total: 0, breakdown: { tool_error: 0, mcp_unavailable: 0, unknown: 0 } },
+            workflows: [],
+            plugins: [],
+            byDay: [],
         };
     }
-    async getPluginUsageStats(pluginName) {
-        const runs = Array.from(this.engine.runs.values());
-        const pluginRuns = runs.filter((r) => {
-            const name = r.pluginName ?? r.meta?.pluginName;
-            return name === pluginName;
+    // ---- Skill Execution Tracking ----
+    async recordExecutionStart(params) {
+        if (!this.db)
+            return;
+        this.db.insertSkillExecution({
+            executionId: params.executionId,
+            sessionId: params.sessionId,
+            skillName: params.skillName,
+            startedAt: params.startedAt,
+            status: 'running',
         });
-        const totalRuns = pluginRuns.length;
-        const successfulRuns = pluginRuns.filter((r) => r.status === "completed").length;
-        const projectRoots = new Set();
-        for (const r of pluginRuns) {
-            const root = r.meta?.projectRoot;
-            if (root)
-                projectRoots.add(root);
+    }
+    async recordToolCall(event) {
+        if (!this.db)
+            return;
+        try {
+            this.db.insertToolCallEvent({
+                eventId: event.eventId,
+                executionId: event.executionId,
+                sessionId: event.sessionId,
+                timestamp: event.timestamp,
+                toolName: event.toolName,
+                toolType: event.toolType,
+                isMcpTool: event.isMcpTool,
+                mcpToolName: event.mcpToolName,
+                mcpEnforced: event.mcpEnforced,
+                mcpFallback: event.mcpFallback,
+                kind: event.kind ?? 'tool_use',
+                input: event.input,
+                duration: event.duration,
+                parentToolCallId: event.parentToolCallId,
+                subagentId: event.subagentId,
+                error: event.error,
+                blocked: event.blocked,
+                blockReason: event.blockReason,
+            });
         }
-        const startedAts = pluginRuns.map((r) => r.startedAt).filter((t) => typeof t === "number");
-        const lastUsedAt = startedAts.length > 0
-            ? new Date(Math.max(...startedAts)).toISOString()
-            : undefined;
-        return {
-            activeProjects: projectRoots.size,
-            totalRuns,
-            successfulRuns,
-            lastUsedAt,
-        };
+        catch { }
+    }
+    async updateToolCallOutput(eventId, output, completedAt, duration) {
+        if (!this.db)
+            return;
+        try {
+            this.db.updateToolCallEvent(eventId, { output: JSON.stringify(output), duration });
+        }
+        catch { }
+    }
+    async recordExecutionComplete(params) {
+        if (!this.db)
+            return;
+        this.db.updateSkillExecution(params.executionId, {
+            status: params.status,
+            finishedAt: params.finishedAt,
+            totalDuration: params.summary.totalDuration,
+            mcpComplianceRate: params.summary.mcpComplianceRate,
+            totalToolCalls: params.summary.totalToolCalls,
+            mcpToolCalls: params.summary.mcpToolCalls,
+            directToolCalls: params.summary.directToolCalls,
+            subagentCount: params.summary.subagentCount,
+        });
+    }
+    async getExecutions(limit, skillName) {
+        if (!this.db)
+            return [];
+        return this.db.listSkillExecutions(limit, skillName);
     }
+    async getExecutionEvents(executionId) {
+        if (!this.db)
+            return [];
+        return this.db.listToolCallEvents(executionId);
+    }
+    async getMcpCompliance() {
+        if (!this.db)
+            return { overall: 0, bySkill: {}, missedTools: [] };
+        return this.db.getMcpCompliance();
+    }
+    // ---- Failure classification (unchanged) ----
     async classifyFailure(runId) {
         const run = await this.getRun(runId).catch(() => null);
         if (!run || run.status !== "failed")
@@ -542,6 +500,13 @@ let TelemetryService = class TelemetryService {
         };
     }
     async cleanup(olderThanDays) {
+        if (!this.db)
+            return 0;
+        try {
+            this.db.cleanupStaleRecords?.();
+        }
+        catch { }
+        // Also clean up legacy engine runs
         const runs = this.engine.runs;
         const cutoff = Date.now() - olderThanDays * 24 * 60 * 60 * 1000;
         let removed = 0;
@@ -553,99 +518,118 @@ let TelemetryService = class TelemetryService {
         }
         return removed;
     }
-    // ---- Skill Execution Tracking ----
-    async recordExecutionStart(params) {
-        if (!this.db)
-            return; // Graceful: no database = skip silently
-        this.db.insertSkillExecution({
-            executionId: params.executionId,
-            skillName: params.skillName,
-            startedAt: params.startedAt,
-            status: 'running',
-        });
-    }
-    async recordToolCall(event) {
+    // @Interval(5 * 60 * 1000) — uncomment when @nestjs/schedule is available
+    async cleanupStaleRecords() {
         if (!this.db)
             return;
-        // Auto-create a placeholder execution if none exists (orphan tool call from hook)
-        const existing = this.db.getSkillExecution(event.executionId);
-        if (!existing) {
-            this.db.insertSkillExecution({
-                executionId: event.executionId,
-                skillName: event.mcpToolName ?? event.toolName,
-                startedAt: event.timestamp,
-                status: 'running',
-            });
+        try {
+            this.db.cleanupStaleRecords?.();
         }
-        this.db.insertToolCallEvent({
-            eventId: event.eventId,
-            executionId: event.executionId,
-            timestamp: event.timestamp,
-            toolName: event.toolName,
-            toolType: event.toolType,
-            isMcpTool: event.isMcpTool,
-            mcpToolName: event.mcpToolName,
-            mcpEnforced: event.mcpEnforced,
-            mcpFallback: event.mcpFallback,
-            input: event.input,
-            tokensUsed: event.tokensUsed,
-            duration: event.duration,
-            parentToolCallId: event.parentToolCallId,
-            subagentId: event.subagentId,
-            error: event.error,
-            blocked: event.blocked,
-            blockReason: event.blockReason,
-        });
+        catch { /* best-effort */ }
     }
-    async updateToolCallOutput(eventId, output) {
+    // ---- Stub methods for external callers that reference old API ----
+    // ---- Tool Metrics ----
+    async recordToolMetric(metric) {
         if (!this.db)
             return;
-        this.db.updateToolCallEvent(eventId, { output: JSON.stringify(output) });
+        this.db.insertToolMetric({ ...metric, createdAt: Date.now() });
     }
-    async recordExecutionComplete(params) {
+    async getToolMetrics(sessionId, toolName, limit = 100, offset = 0) {
+        if (!this.db)
+            return [];
+        return this.db.getToolMetrics(sessionId, toolName, limit, offset);
+    }
+    async getToolMetricsSummary(days = 7) {
+        if (!this.db)
+            return [];
+        return this.db.getToolMetricsSummary(days);
+    }
+    // ---- Accuracy Queries ----
+    async recordAccuracyQuery(params) {
         if (!this.db)
             return;
-        // Defensive: re-aggregate real counts from DB, don't trust client input
-        const events = this.db.listToolCallEvents(params.executionId);
-        const totalToolCalls = events.length;
-        const mcpToolCalls = events.filter((e) => e.isMcpTool).length;
-        const directToolCalls = events.filter((e) => !e.isMcpTool).length;
-        const subagentCount = events.filter((e) => e.toolType === 'subagent').length;
-        this.db.updateSkillExecution(params.executionId, {
-            status: params.status,
-            finishedAt: params.finishedAt,
-            totalDuration: params.summary.totalDuration,
-            totalTokens: params.summary.totalTokens,
-            mcpComplianceRate: totalToolCalls > 0
-                ? Math.round(mcpToolCalls / totalToolCalls * 10000) / 100
-                : 0,
-            totalToolCalls,
-            mcpToolCalls,
-            directToolCalls,
-            subagentCount,
-        });
+        this.db.insertAccuracyQuery({ ...params, createdAt: Date.now() });
     }
-    async getExecutions(limit, skillName) {
+    async getAccuracyQueries(options) {
         if (!this.db)
             return [];
-        return this.db.listSkillExecutions(limit, skillName);
+        return this.db.getAccuracyQueries(options);
     }
-    async getExecutionEvents(executionId) {
+    async updateAccuracyFeedback(id, feedback) {
+        if (!this.db)
+            return;
+        this.db.updateAccuracyFeedback(id, feedback);
+    }
+    async getAccuracyStats(engine, since) {
+        if (!this.db)
+            return { totalQueries: 0, annotatedQueries: 0, hitRate: null };
+        return this.db.getAccuracyStats(engine, since);
+    }
+    // ---- Auto Checker ----
+    async runAutoCheck() {
         if (!this.db)
             return [];
-        return this.db.listToolCallEvents(executionId);
+        const checker = new AutoChecker(this.db);
+        return checker.checkAll();
     }
-    async getMcpCompliance() {
+    // ---- Stub methods ----
+    async getFeedbackStats(_projectRoot, _periodDays) {
+        return { total: 0, hits: 0, partials: 0, misses: 0, hitRate: 0, partialRate: 0, missRate: 0 };
+    }
+    async getOpsRoiSummary() {
+        return {
+            period: "all-time",
+            totalRuns: 0,
+            successfulRuns: 0,
+            successRate: 0,
+            avgDuration: 0,
+            trend: "stable",
+        };
+    }
+    async getExperimentalRoiSummary() {
+        return {
+            totalScenarios: 0,
+            avgTimeSavedRate: null,
+            avgTokenReductionRate: null,
+            avgFirstPassLift: null,
+            avgReworkReductionRate: null,
+            conclusion: "No experimental data available yet",
+        };
+    }
+    async getPluginEffectiveness(pluginName, _projectRoot) {
         if (!this.db)
-            return { overall: 0, bySkill: {}, missedTools: [] };
-        return this.db.getMcpCompliance();
+            return { name: pluginName, totalRuns: 0, successRate: 0, lastUsedAt: null };
+        const sessions = this.db.listSessions(1000, 0);
+        let useCount = 0;
+        for (const s of sessions) {
+            const events = this.db.listToolCallEventsBySession(s.id);
+            for (const e of events) {
+                if (e.mcpToolName?.startsWith(pluginName + '_'))
+                    useCount++;
+            }
+        }
+        return {
+            name: pluginName,
+            totalRuns: useCount,
+            successRate: 0,
+            lastUsedAt: null,
+        };
+    }
+    async getPluginUsageStats(pluginName) {
+        const eff = await this.getPluginEffectiveness(pluginName);
+        return {
+            activeProjects: 0,
+            totalRuns: eff.totalRuns,
+            successfulRuns: 0,
+            lastUsedAt: eff.lastUsedAt ?? undefined,
+        };
     }
 };
 TelemetryService = __decorate([
     Injectable(),
     __param(0, Optional()),
     __param(0, Inject('DATABASE')),
-    __metadata("design:paramtypes", [Object])
+    __metadata("design:paramtypes", [DevFlowDatabase])
 ], TelemetryService);
 export { TelemetryService };
 //# sourceMappingURL=telemetry.service.js.map