@aitne/daemon 0.1.0

package/dist/core/metrics.js

@@ -0,0 +1,747 @@
+import { getAgentDayBoundsUtc, getAgentDayDateStr } from "@aitne/shared";
+import { snapshotManagementTelemetry, } from "./management-telemetry.js";
+export class MetricsCollector {
+    db;
+    timezoneConfig;
+    constructor(db, timezoneConfig = { timezone: "", dayBoundaryHour: 4 }) {
+        this.db = db;
+        this.timezoneConfig = timezoneConfig;
+    }
+    collectTimeseries(days, now) {
+        if (days === 0) {
+            return this.todayTimeseries(now);
+        }
+        const daily = this.dailyBuckets(days);
+        const recentErrors = this.errorGroups(days);
+        const heatmap = this.heatmapData();
+        return { days, daily, recentErrors, heatmap };
+    }
+    todayTimeseries(now) {
+        const bounds = getAgentDayBoundsUtc(this.timezoneConfig.timezone, this.timezoneConfig.dayBoundaryHour, now);
+        const agentDateStr = getAgentDayDateStr(this.timezoneConfig.timezone, this.timezoneConfig.dayBoundaryHour, now);
+        const actionRow = this.db
+            .prepare(`SELECT
+           COUNT(*) as executions,
+           COUNT(*) FILTER (WHERE trigger = 'reactive') as reactive,
+           COUNT(*) FILTER (WHERE trigger = 'autonomous') as autonomous,
+           COUNT(*) FILTER (WHERE result = 'failed') as failures,
+           COUNT(*) FILTER (WHERE context_updated = 1 AND trigger = 'autonomous') as ctx_auto,
+           COUNT(*) FILTER (WHERE context_updated = 1 AND trigger = 'reactive') as ctx_reactive,
+           AVG(CASE WHEN trigger = 'reactive' AND result = 'success' THEN duration_ms END) as avg_duration
+         FROM agent_actions
+         WHERE started_at >= ? AND started_at < ?`)
+            .get(bounds.start, bounds.end);
+        const notifRow = this.db
+            .prepare(`SELECT
+           COUNT(*) FILTER (WHERE status = 'delivered') as delivered,
+           COUNT(*) FILTER (WHERE status = 'delivered' AND user_reaction IS NOT NULL) as reacted
+         FROM notification_log
+         WHERE created_at >= ? AND created_at < ?`)
+            .get(bounds.start, bounds.end);
+        const daily = [
+            {
+                date: agentDateStr,
+                executions: actionRow.executions ?? 0,
+                executionsReactive: actionRow.reactive ?? 0,
+                executionsAutonomous: actionRow.autonomous ?? 0,
+                failures: actionRow.failures ?? 0,
+                contextUpdatesAutonomous: actionRow.ctx_auto ?? 0,
+                contextUpdatesReactive: actionRow.ctx_reactive ?? 0,
+                avgDurationMs: actionRow.avg_duration !== null && actionRow.avg_duration !== undefined
+                    ? Math.round(actionRow.avg_duration)
+                    : null,
+                notificationsDelivered: notifRow.delivered,
+                notificationsReacted: notifRow.reacted,
+            },
+        ];
+        const recentErrors = this.errorGroupsInRange(bounds.start, bounds.end);
+        const heatmap = this.heatmapData();
+        return { days: 0, daily, recentErrors, heatmap };
+    }
+    dailyBuckets(days) {
+        // Execution metrics from agent_actions
+        const actionRows = this.db
+            .prepare(`SELECT
+           date(started_at) as date,
+           COUNT(*) as executions,
+           COUNT(*) FILTER (WHERE trigger = 'reactive') as reactive,
+           COUNT(*) FILTER (WHERE trigger = 'autonomous') as autonomous,
+           COUNT(*) FILTER (WHERE result = 'failed') as failures,
+           COUNT(*) FILTER (WHERE context_updated = 1 AND trigger = 'autonomous') as ctx_auto,
+           COUNT(*) FILTER (WHERE context_updated = 1 AND trigger = 'reactive') as ctx_reactive,
+           AVG(CASE WHEN trigger = 'reactive' AND result = 'success' THEN duration_ms END) as avg_duration
+         FROM agent_actions
+         WHERE started_at > datetime('now', '-' || ? || ' days')
+         GROUP BY date(started_at)
+         ORDER BY date ASC`)
+            .all(days);
+        // Notification metrics from notification_log
+        const notifRows = this.db
+            .prepare(`SELECT
+           date(created_at) as date,
+           COUNT(*) FILTER (WHERE status = 'delivered') as delivered,
+           COUNT(*) FILTER (WHERE status = 'delivered' AND user_reaction IS NOT NULL) as reacted
+         FROM notification_log
+         WHERE created_at > datetime('now', '-' || ? || ' days')
+         GROUP BY date(created_at)`)
+            .all(days);
+        const actionMap = new Map(actionRows.map((r) => [r.date, r]));
+        const notifMap = new Map(notifRows.map((r) => [r.date, r]));
+        // Build a continuous date range so charts have no gaps
+        const allDates = generateDateRange(days);
+        return allDates.map((date) => {
+            const row = actionMap.get(date);
+            const notif = notifMap.get(date);
+            return {
+                date,
+                executions: row?.executions ?? 0,
+                executionsReactive: row?.reactive ?? 0,
+                executionsAutonomous: row?.autonomous ?? 0,
+                failures: row?.failures ?? 0,
+                contextUpdatesAutonomous: row?.ctx_auto ?? 0,
+                contextUpdatesReactive: row?.ctx_reactive ?? 0,
+                avgDurationMs: row?.avg_duration !== null && row?.avg_duration !== undefined ? Math.round(row.avg_duration) : null,
+                notificationsDelivered: notif?.delivered ?? 0,
+                notificationsReacted: notif?.reacted ?? 0,
+            };
+        });
+    }
+    errorGroups(days) {
+        const rows = this.db
+            .prepare(`SELECT error, model_used, started_at
+         FROM agent_actions
+         WHERE result = 'failed'
+           AND error IS NOT NULL
+           AND started_at > datetime('now', '-' || ? || ' days')
+         ORDER BY started_at DESC`)
+            .all(days);
+        return groupErrorRows(rows);
+    }
+    /**
+     * Same shape as `errorGroups(days)` but filters by an explicit UTC
+     * [start, end) window. Shares `groupErrorRows()` + `inferBackendFromModel()`
+     * so the two paths can't drift.
+     */
+    errorGroupsInRange(startUtc, endUtc) {
+        const rows = this.db
+            .prepare(`SELECT error, model_used, started_at
+         FROM agent_actions
+         WHERE result = 'failed'
+           AND error IS NOT NULL
+           AND started_at >= ?
+           AND started_at < ?
+         ORDER BY started_at DESC`)
+            .all(startUtc, endUtc);
+        return groupErrorRows(rows);
+    }
+    heatmapData() {
+        // Always 12 weeks (84 days) regardless of the period param
+        const rows = this.db
+            .prepare(`SELECT date(started_at) as date, COUNT(*) as count
+         FROM agent_actions
+         WHERE started_at > datetime('now', '-84 days')
+         GROUP BY date(started_at)
+         ORDER BY date ASC`)
+            .all();
+        return rows;
+    }
+    collect() {
+        return {
+            collectedAt: new Date().toISOString(),
+            ...this.notificationMetrics(),
+            ...this.modelMetrics(),
+            proactiveForwardResume: this.proactiveForwardResumeMetrics(),
+            responseTime: this.responseTimeMetrics(),
+            cost: this.costMetrics(),
+            sessions: this.sessionMetrics(),
+        };
+    }
+    /**
+     * DELEGATED-TASK-MODE-DESIGN.md §11.2 — task-mode counters/histogram
+     * derived from the `delegated_task.exec` / `delegated_task.run` audit
+     * rows the invoker writes via `recordTaskHeaderInProgress` +
+     * `completeTaskHeader`. Source-of-truth is the rows themselves; this
+     * surface aggregates them so the dashboard / `/metrics/delegated-task`
+     * does not have to parse `detail` JSON inline.
+     *
+     * Window is the last `days` days (capped 1..90, default 30).
+     *
+     * Aggregation rules:
+     *   - `total` — count rows grouped by `(integrationKey, backend, result)`.
+     *     `result` is `'destructive_blocked'` when `detail.needsConfirmation`
+     *     is true (a successful row that didn't actually execute the
+     *     destructive op), otherwise the row's `result` value.
+     *   - `toolCalls` — per-integration histogram of `detail.toolCallCount`
+     *     across all rows (success + failure). Quantile estimates use the
+     *     same nearest-rank method as `responseTimeMetrics`.
+     *   - `validationFailures` — count rows where `detail.errorClass IN
+     *     ('parse_error','schema_violation')`.
+     *   - `destructiveBlocked` — count rows where `detail.needsConfirmation`
+     *     is true (successful confirmation envelope returned).
+     *   - `costUsd` — sum of `cost_usd` per `(integrationKey, backend)`.
+     *
+     * `cacheHit` rows (cost_usd=0, cost_source='cache') are included in all
+     * counts so the dashboard can compare cache vs. live volumes; their
+     * cost contribution is naturally zero.
+     */
+    collectDelegatedTaskMetrics(days = 30) {
+        const window = Number.isFinite(days)
+            ? Math.min(Math.max(Math.floor(days), 1), 90)
+            : 30;
+        const rows = this.db
+            .prepare(`SELECT
+           backend,
+           cost_usd,
+           result,
+           detail
+         FROM agent_actions
+         WHERE action_type IN ('delegated_task.exec', 'delegated_task.run')
+           AND started_at > datetime('now', '-' || ? || ' days')`)
+            .all(window);
+        const parsed = [];
+        for (const row of rows) {
+            let detail = {};
+            if (row.detail) {
+                try {
+                    detail = JSON.parse(row.detail);
+                }
+                catch {
+                    // Malformed JSON in detail is treated as empty so the row still
+                    // contributes to total/cost counts.
+                }
+            }
+            const integrationKey = typeof detail.integrationKey === "string"
+                ? detail.integrationKey
+                : null;
+            const errorClass = typeof detail.errorClass === "string"
+                ? detail.errorClass
+                : null;
+            const toolCallCount = typeof detail.toolCallCount === "number"
+                ? detail.toolCallCount
+                : null;
+            const needsConfirmation = detail.needsConfirmation === true;
+            parsed.push({
+                integrationKey,
+                backend: row.backend,
+                result: row.result ?? "unknown",
+                costUsd: row.cost_usd ?? 0,
+                toolCallCount,
+                errorClass,
+                needsConfirmation,
+            });
+        }
+        return {
+            windowDays: window,
+            collectedAt: new Date().toISOString(),
+            total: aggregateTotal(parsed),
+            toolCalls: aggregateToolCalls(parsed),
+            validationFailures: aggregateValidationFailures(parsed),
+            destructiveBlocked: aggregateDestructiveBlocked(parsed),
+            costUsd: aggregateCost(parsed),
+        };
+    }
+    /**
+     * docs/design/21-management-registry-and-entities.md §14.3 — the six
+     * Phase-8 metrics, shaped for the dashboard's Management → History tab
+     * and the `/metrics/managed-tasks` JSON surface.
+     *
+     * Sources:
+     *   - `managed_tasks` rows for `active`, `consecutiveFailures`,
+     *     `failingNow`.
+     *   - `agent_actions` rows of type
+     *     `management_task.run_recorded` / `management_task.run_now`
+     *     for the `runs.{ok,failed,skipped,unknown}` tally over `windowDays`.
+     *   - `snapshotManagementTelemetry()` for the histograms + entity-mirror
+     *     gauge (process-local; resets on daemon restart by design).
+     *
+     * Aggregation rules:
+     *   - Run rows are bucketed by the leading word of `detail.last_result`
+     *     (`failed*` → `failed`, `skipped*` → `skipped`, `ok*` → `ok`,
+     *     anything else → `unknown`). Case-insensitive.
+     *   - `failingNow` is the count of rows where
+     *     `consecutive_failures >= notifyThreshold`. The threshold is
+     *     parameterised so a future config change automatically widens the
+     *     gauge without re-deploying the dashboard.
+     */
+    collectManagementMetrics(options) {
+        const window = Number.isFinite(options.windowDays)
+            ? Math.min(Math.max(Math.floor(options.windowDays), 1), 90)
+            : 30;
+        const collectedAt = new Date().toISOString();
+        // Soft-fail every query: a malformed managed_tasks row should not
+        // blank the entire metrics endpoint. Each block returns a safe
+        // fallback so the dashboard renders gracefully under degraded DB
+        // conditions.
+        let active = 0;
+        let failingNow = 0;
+        try {
+            const row = this.db
+                .prepare(`SELECT
+             COUNT(*) AS active,
+             COUNT(*) FILTER (WHERE consecutive_failures >= ?) AS failing_now
+           FROM managed_tasks`)
+                .get(options.failureNotifyThreshold);
+            active = row.active ?? 0;
+            failingNow = row.failing_now ?? 0;
+        }
+        catch {
+            // table missing in tests / fresh DB — treat as zero
+        }
+        let consecutiveFailures = [];
+        try {
+            const rows = this.db
+                .prepare(`SELECT id AS mtId, app, consecutive_failures AS count
+             FROM managed_tasks
+            WHERE consecutive_failures > 0
+            ORDER BY consecutive_failures DESC, id ASC`)
+                .all();
+            consecutiveFailures = rows.map((r) => ({
+                mtId: r.mtId,
+                app: r.app,
+                count: r.count,
+            }));
+        }
+        catch {
+            // ignore — fallback is empty list
+        }
+        let runs = { ok: 0, failed: 0, skipped: 0, unknown: 0 };
+        try {
+            const rows = this.db
+                .prepare(`SELECT
+             json_extract(detail, '$.last_result') AS last_result,
+             COUNT(*) AS cnt
+           FROM agent_actions
+           WHERE action_type IN ('management_task.run_recorded', 'management_task.run_now')
+             AND started_at > datetime('now', '-' || ? || ' days')
+           GROUP BY 1`)
+                .all(window);
+            runs = aggregateManagedTaskRuns(rows);
+        }
+        catch {
+            // table missing or detail not JSON — treat as zero
+        }
+        const telemetry = snapshotManagementTelemetry();
+        return {
+            collectedAt,
+            windowDays: window,
+            active,
+            softWarningThreshold: options.softWarningThreshold,
+            hardCap: options.hardCap,
+            runs,
+            consecutiveFailures,
+            failureNotifyThreshold: options.failureNotifyThreshold,
+            failingNow,
+            managementMdRenderMs: telemetry.managementMdRenderMs,
+            activityViewRebuildMs: telemetry.activityViewRebuildMs,
+            entityMirrorLag: telemetry.entityMirrorLag,
+        };
+    }
+    notificationMetrics() {
+        const row = this.db
+            .prepare(`SELECT
+           COUNT(*) FILTER (WHERE status = 'delivered') as delivered,
+           COUNT(*) FILTER (WHERE status = 'delivered' AND user_reaction IS NOT NULL) as reacted,
+           COUNT(*) FILTER (WHERE status = 'suppressed') as suppressed
+         FROM notification_log
+         WHERE created_at > datetime('now', '-30 days')`)
+            .get();
+        const rate = row.delivered > 0 ? row.reacted / row.delivered : null;
+        return {
+            notificationConfirmRate: rate,
+            notificationCounts: {
+                delivered: row.delivered,
+                reacted: row.reacted,
+                suppressed: row.suppressed,
+            },
+        };
+    }
+    modelMetrics() {
+        // Count Sonnet sessions (not skipped) in last 30 days
+        const sonnetRow = this.db
+            .prepare(`SELECT COUNT(*) as cnt FROM agent_actions
+         WHERE model_used LIKE '%sonnet%'
+           AND result = 'success'
+           AND started_at > datetime('now', '-30 days')`)
+            .get();
+        // Count Opus sessions in last 30 days
+        const opusRow = this.db
+            .prepare(`SELECT COUNT(*) as cnt FROM agent_actions
+         WHERE model_used LIKE '%opus%'
+           AND result = 'success'
+           AND started_at > datetime('now', '-30 days')`)
+            .get();
+        // Advisor telemetry — populated by Claude Code backend only.
+        // `advisorCallRate` is defined as `(advisor calls) / (successful
+        // Sonnet+Opus sessions)` — i.e. roughly "how many advisor consults per
+        // session the agent makes". Returns null when there are no sessions to
+        // divide by.
+        const advisorRow = this.hasAdvisorCallCountColumn()
+            ? this.db
+                .prepare(`SELECT
+               COALESCE(SUM(advisor_call_count), 0) as total_calls,
+               COUNT(*) FILTER (
+                 WHERE (model_used LIKE '%sonnet%' OR model_used LIKE '%opus%')
+                   AND result = 'success'
+               ) as eligible_sessions
+             FROM agent_actions
+             WHERE started_at > datetime('now', '-30 days')`)
+                .get()
+            : { total_calls: 0, eligible_sessions: 0 };
+        const advisorCallRate = advisorRow.eligible_sessions > 0
+            ? advisorRow.total_calls / advisorRow.eligible_sessions
+            : null;
+        return {
+            advisorCallRate,
+            modelCounts: {
+                sonnetSessions: sonnetRow.cnt,
+                opusSessions: opusRow.cnt,
+            },
+        };
+    }
+    proactiveForwardResumeMetrics() {
+        const row = this.db
+            .prepare(`SELECT
+           COUNT(*) FILTER (WHERE action_type = 'proactive_forward_injected') as injected,
+           COUNT(*) FILTER (WHERE action_type = 'proactive_forward_disavowed') as disavowed
+         FROM agent_actions
+         WHERE action_type IN (
+           'proactive_forward_injected',
+           'proactive_forward_disavowed'
+         )
+           AND started_at > datetime('now', '-30 days')`)
+            .get();
+        const injected = row.injected ?? 0;
+        const disavowed = row.disavowed ?? 0;
+        return {
+            injected,
+            disavowed,
+            ratio: injected > 0 ? disavowed / injected : null,
+            threshold: 0.05,
+        };
+    }
+    /**
+     * Defensive guard for tests that hand-craft a DB without applying the
+     * full schema. Production DBs always have this column.
+     */
+    hasAdvisorCallCountColumn() {
+        const cols = this.db.pragma("table_info(agent_actions)");
+        return cols.some((col) => col.name === "advisor_call_count");
+    }
+    responseTimeMetrics() {
+        // Percentiles from reactive sessions (message responses) in last 30 days
+        const rows = this.db
+            .prepare(`SELECT duration_ms FROM agent_actions
+         WHERE trigger = 'reactive'
+           AND result = 'success'
+           AND duration_ms IS NOT NULL
+           AND started_at > datetime('now', '-30 days')
+         ORDER BY duration_ms ASC`)
+            .all();
+        if (rows.length === 0) {
+            return { p50: null, p90: null, p95: null, p99: null, avg: null };
+        }
+        const durations = rows.map((r) => r.duration_ms);
+        const p = (pct) => durations[Math.min(Math.floor(durations.length * pct), durations.length - 1)];
+        const avg = durations.reduce((a, b) => a + b, 0) / durations.length;
+        return {
+            p50: p(0.5),
+            p90: p(0.9),
+            p95: p(0.95),
+            p99: p(0.99),
+            avg: Math.round(avg),
+        };
+    }
+    costMetrics() {
+        // datetime(started_at) normalizes mixed ISO-8601 / SQL formats so that
+        // legacy delegated_proxy.invoke rows (written in ISO-with-T-and-Z) are
+        // not lexicographically excluded from the agent-day window.
+        const bounds = getAgentDayBoundsUtc(this.timezoneConfig.timezone, this.timezoneConfig.dayBoundaryHour);
+        const row = this.db
+            .prepare(`SELECT
+           COALESCE(SUM(CASE WHEN datetime(started_at) >= ? AND datetime(started_at) < ? THEN cost_usd ELSE 0 END), 0) as today,
+           COALESCE(SUM(CASE WHEN started_at > datetime('now', '-7 days') THEN cost_usd ELSE 0 END), 0) as last7d,
+           COALESCE(SUM(cost_usd), 0) as last30d
+         FROM agent_actions
+         WHERE started_at > datetime('now', '-30 days')`)
+            .get(bounds.start, bounds.end);
+        return {
+            todayUsd: row.today,
+            last7dUsd: row.last7d,
+            last30dUsd: row.last30d,
+        };
+    }
+    sessionMetrics() {
+        // See costMetrics() above — datetime(started_at) defends against legacy
+        // mixed-format rows that would otherwise sort outside the day window.
+        const bounds = getAgentDayBoundsUtc(this.timezoneConfig.timezone, this.timezoneConfig.dayBoundaryHour);
+        const row = this.db
+            .prepare(`SELECT
+           COUNT(*) as total,
+           COUNT(*) FILTER (WHERE trigger = 'autonomous') as autonomous,
+           COUNT(*) FILTER (WHERE trigger = 'reactive') as reactive
+         FROM agent_actions
+         WHERE datetime(started_at) >= ? AND datetime(started_at) < ?
+           AND cost_usd IS NOT NULL`)
+            .get(bounds.start, bounds.end);
+        return {
+            todayTotal: row.total,
+            todayAutonomous: row.autonomous,
+            todayReactive: row.reactive,
+        };
+    }
+}
+// ── Date helpers ──
+/** Generate an array of "YYYY-MM-DD" strings for the last N days (UTC). */
+function generateDateRange(days) {
+    const result = [];
+    const now = new Date();
+    for (let i = days - 1; i >= 0; i--) {
+        const d = new Date(now);
+        d.setUTCDate(now.getUTCDate() - i);
+        result.push(d.toISOString().slice(0, 10));
+    }
+    return result;
+}
+// ── Error classification ──
+/**
+ * Map a stored `model_used` string to a backend id. Purely a string-sniffing
+ * helper — no DB access, no logging. Shared by both `errorGroups(days)` and
+ * `errorGroupsInRange(start, end)` so the two windows stay consistent.
+ * Exported for direct unit testing — the two call sites are indirect.
+ */
+export function inferBackendFromModel(modelUsed) {
+    if (!modelUsed)
+        return null;
+    if (modelUsed.includes("sonnet") ||
+        modelUsed.includes("opus") ||
+        modelUsed.includes("haiku")) {
+        return "claude-code";
+    }
+    if (modelUsed.includes("gemini"))
+        return "gemini-cli";
+    if (modelUsed.includes("codex") ||
+        modelUsed.includes("gpt") ||
+        modelUsed.includes("o3") ||
+        modelUsed.includes("o4")) {
+        return "codex";
+    }
+    return null;
+}
+/**
+ * Group raw failed-action rows by category and return the shape the API
+ * exposes. Extracted so the days-windowed and agent-day-windowed variants
+ * share identical grouping / sampling rules. Exported for direct testing.
+ */
+export function groupErrorRows(rows) {
+    const groups = new Map();
+    for (const row of rows) {
+        const category = categorizeError(row.error);
+        const existing = groups.get(category);
+        if (existing) {
+            existing.count++;
+            continue;
+        }
+        groups.set(category, {
+            category,
+            count: 1,
+            lastSeen: row.started_at,
+            backend: inferBackendFromModel(row.model_used),
+            sampleMessage: row.error.length > 200 ? row.error.slice(0, 200) + "…" : row.error,
+        });
+    }
+    return [...groups.values()].sort((a, b) => b.count - a.count);
+}
+function bucketKey(integrationKey, backend) {
+    return `${integrationKey ?? "<none>"}::${backend ?? "<none>"}`;
+}
+function aggregateTotal(rows) {
+    const map = new Map();
+    for (const row of rows) {
+        // Confirmation envelopes ride the success path in agent_actions but
+        // they DID NOT execute the destructive tool — surfacing them under a
+        // distinct result bucket prevents the dashboard from mistaking them
+        // for "task succeeded" outcomes.
+        const result = row.needsConfirmation ? "destructive_blocked" : row.result;
+        const key = `${bucketKey(row.integrationKey, row.backend)}::${result}`;
+        const existing = map.get(key);
+        if (existing) {
+            existing.count++;
+            continue;
+        }
+        map.set(key, {
+            integrationKey: row.integrationKey,
+            backend: row.backend,
+            result,
+            count: 1,
+        });
+    }
+    return [...map.values()].sort((a, b) => b.count - a.count);
+}
+function aggregateToolCalls(rows) {
+    const groups = new Map();
+    for (const row of rows) {
+        if (row.toolCallCount === null)
+            continue;
+        const key = bucketKey(row.integrationKey, row.backend);
+        let group = groups.get(key);
+        if (!group) {
+            group = {
+                integrationKey: row.integrationKey,
+                backend: row.backend,
+                values: [],
+            };
+            groups.set(key, group);
+        }
+        group.values.push(row.toolCallCount);
+    }
+    return [...groups.values()].map((g) => {
+        const sorted = [...g.values].sort((a, b) => a - b);
+        const histogram = {
+            count: sorted.length,
+            sum: sorted.reduce((a, b) => a + b, 0),
+            min: sorted.length > 0 ? sorted[0] : null,
+            max: sorted.length > 0 ? sorted[sorted.length - 1] : null,
+            avg: sorted.length > 0 ? sorted.reduce((a, b) => a + b, 0) / sorted.length : null,
+            p50: percentile(sorted, 0.5),
+            p90: percentile(sorted, 0.9),
+            p95: percentile(sorted, 0.95),
+        };
+        return {
+            integrationKey: g.integrationKey,
+            backend: g.backend,
+            histogram,
+        };
+    });
+}
+function percentile(sorted, p) {
+    if (sorted.length === 0)
+        return null;
+    const idx = Math.min(Math.floor(sorted.length * p), sorted.length - 1);
+    return sorted[idx];
+}
+function aggregateValidationFailures(rows) {
+    const map = new Map();
+    for (const row of rows) {
+        if (row.errorClass !== "parse_error" && row.errorClass !== "schema_violation") {
+            continue;
+        }
+        const key = `${bucketKey(row.integrationKey, row.backend)}::${row.errorClass}`;
+        const existing = map.get(key);
+        if (existing) {
+            existing.count++;
+            continue;
+        }
+        map.set(key, {
+            integrationKey: row.integrationKey,
+            backend: row.backend,
+            kind: row.errorClass,
+            count: 1,
+        });
+    }
+    return [...map.values()].sort((a, b) => b.count - a.count);
+}
+function aggregateDestructiveBlocked(rows) {
+    const map = new Map();
+    for (const row of rows) {
+        if (!row.needsConfirmation)
+            continue;
+        const key = bucketKey(row.integrationKey, row.backend);
+        const existing = map.get(key);
+        if (existing) {
+            existing.count++;
+            continue;
+        }
+        map.set(key, {
+            integrationKey: row.integrationKey,
+            backend: row.backend,
+            count: 1,
+        });
+    }
+    return [...map.values()].sort((a, b) => b.count - a.count);
+}
+function aggregateCost(rows) {
+    const map = new Map();
+    for (const row of rows) {
+        const key = bucketKey(row.integrationKey, row.backend);
+        const existing = map.get(key);
+        if (existing) {
+            existing.costUsd += row.costUsd;
+            continue;
+        }
+        map.set(key, {
+            integrationKey: row.integrationKey,
+            backend: row.backend,
+            costUsd: row.costUsd,
+        });
+    }
+    return [...map.values()].sort((a, b) => b.costUsd - a.costUsd);
+}
+function categorizeError(error) {
+    const lower = error.toLowerCase();
+    if (lower.includes("quota") || lower.includes("rate limit") || lower.includes("429") || lower.includes("too many requests")) {
+        return "quota";
+    }
+    if (lower.includes("timeout") || lower.includes("timed out") || lower.includes("deadline")) {
+        return "timeout";
+    }
+    if (lower.includes("auth") || lower.includes("401") || lower.includes("403") || lower.includes("permission") || lower.includes("unauthorized")) {
+        return "auth";
+    }
+    if (lower.includes("network") || lower.includes("econnrefused") || lower.includes("enotfound") || lower.includes("fetch failed")) {
+        return "network";
+    }
+    return "other";
+}
+// ── Management-task run aggregation ──────────────────────────────────────────
+/**
+ * Bucket a `last_result` payload string into one of the four exposed
+ * counters. Pure helper exported for direct unit tests so the
+ * dashboard's run-totals contract is locked.
+ *
+ *   `null` / `''` / non-string                    → `unknown`
+ *   `failed`, `failed: ...`, `Failed (foo)`, ...  → `failed`
+ *   `skipped`, `skipped: foo`, ...                → `skipped`
+ *   `ok`, `ok (3 new)`, `OK`, ...                 → `ok`
+ *   anything else (`pending`, ad-hoc strings)     → `unknown`
+ *
+ * Whitespace and case are normalised; punctuation after the leading
+ * word is ignored. The leading-word policy is intentional — the
+ * `last_result` column is short-form-by-convention but free-text by
+ * schema, so a trailing detail string ("ok (3 new)") must not change
+ * the bucket.
+ */
+export function classifyManagedTaskRunResult(lastResult) {
+    if (typeof lastResult !== "string")
+        return "unknown";
+    const normalised = lastResult.trim().toLowerCase();
+    if (normalised === "")
+        return "unknown";
+    if (/^failed\b/.test(normalised) || normalised.startsWith("failed:")) {
+        return "failed";
+    }
+    if (/^skipped\b/.test(normalised) || normalised.startsWith("skipped:")) {
+        return "skipped";
+    }
+    if (/^ok\b/.test(normalised) || normalised === "ok") {
+        return "ok";
+    }
+    return "unknown";
+}
+/**
+ * Sum a flat list of `(last_result, count)` rows from
+ * `agent_actions` into the four-axis tally. Pure — DB-free for tests.
+ */
+export function aggregateManagedTaskRuns(rows) {
+    const totals = {
+        ok: 0,
+        failed: 0,
+        skipped: 0,
+        unknown: 0,
+    };
+    for (const row of rows) {
+        const bucket = classifyManagedTaskRunResult(row.last_result);
+        totals[bucket] += row.cnt;
+    }
+    return totals;
+}
+//# sourceMappingURL=metrics.js.map