akm-cli 0.9.0-beta.9 → 0.9.0-rc.0

package/dist/commands/health.js

@@ -2,1011 +2,44 @@
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import fs from "node:fs";
+import path from "node:path";
+import { resolveStashDir } from "../core/common.js";
+import { loadConfig } from "../core/config/config.js";
 import { ConfigError, UsageError } from "../core/errors.js";
-import { appendEvent, readEvents } from "../core/events.js";
-import { buildTaskRunId, getLoggedRunIds, openLogsDatabase } from "../core/logs-db.js";
-import { getStateDbPathInDataDir } from "../core/paths.js";
-import { listExistingTableNames, openStateDatabase, queryCompletedTaskIntervals, queryImproveRuns, queryTaskHistory, } from "../core/state-db.js";
-import { parseSinceToIso } from "../core/time.js";
+import { readEvents } from "../core/events.js";
+import { openLogsDatabase } from "../core/logs-db.js";
+import { getCacheDir, getConfigDir, getConfigPath, getDataDir, getStateDbPathInDataDir } from "../core/paths.js";
+import { listExistingTableNames, openStateDatabase } from "../core/state-db.js";
+import { DURATION_UNITS, parseDuration, parseSinceToIso } from "../core/time.js";
 import { readSemanticStatus } from "../indexer/search/semantic-status.js";
 import { getExecutionLogCandidates } from "../integrations/session-logs/index.js";
-import { LLM_USAGE_EVENT } from "../llm/usage-persist.js";
+import { queryTaskHistory } from "../storage/repositories/task-history-repository.js";
+import { collectImproveAdvisories } from "./health/advisories.js";
 import { HEALTH_CHECKS } from "./health/checks.js";
+import { buildImproveSkipSummary, computeWallTimeStats, parseTaskMetadata, roundRate, summarizeImproveCompleted, summarizeImproveRuns, } from "./health/improve-metrics.js";
+import { readLlmUsageAggregate } from "./health/llm-usage.js";
+import { computeDegradationMetrics, computeDenominatorFixedCoverage, computeEnrichmentMintingRollup, probeStateDbRoundTrip, readCalibration, } from "./health/metrics.js";
+import { collectStashExposureAdvisory } from "./health/stash-exposure.js";
+import { collectSurfacesAdvisories } from "./health/surfaces.js";
+import { buildPerRunSummaries } from "./health/task-runs.js";
+import { ACTIVE_RUN_WARN_MS, IMPROVE_COMPLETED_EVENT, } from "./health/types.js";
+import { buildWindowMetrics, computeDeltas, partitionLogBackedRows, resolveWindowCompare } from "./health/windows.js";
 const DEFAULT_SINCE_MS = 24 * 60 * 60 * 1000;
-const IMPROVE_COMPLETED_EVENT = "improve_completed";
-const HEALTH_PROBE_EVENT = "health_probe";
-const ACTIVE_RUN_WARN_MS = 15 * 60 * 1000;
 export function parseHealthSince(since) {
     if (since === undefined || since.trim() === "") {
         return new Date(Date.now() - DEFAULT_SINCE_MS).toISOString();
     }
     const trimmed = since.trim();
-    const durationMatch = trimmed.match(/^(\d+)([dhm])$/i);
-    if (durationMatch) {
-        const amount = Number.parseInt(durationMatch[1] ?? "0", 10);
-        const unit = (durationMatch[2] ?? "d").toLowerCase();
-        if (!Number.isFinite(amount) || amount < 0) {
-            throw new UsageError("--since must be a non-negative duration or timestamp.", "INVALID_FLAG_VALUE");
-        }
-        const multiplier = unit === "h" ? 60 * 60 * 1000 : unit === "m" ? 30 * 24 * 60 * 60 * 1000 : 24 * 60 * 60 * 1000;
-        return new Date(Date.now() - amount * multiplier).toISOString();
+    // Unit grammar is the CLI-wide canonical map: `m` = minutes, `M` = months.
+    // (Historically `--since 5m` meant 5 months here; it now means 5 minutes,
+    // with `5M` for months — unified with consolidate / `--window-compare`.)
+    // Not lower-cased: case distinguishes `m` (minutes) from `M` (months).
+    const durationMs = parseDuration(trimmed, DURATION_UNITS);
+    if (durationMs !== null) {
+        return new Date(Date.now() - durationMs).toISOString();
     }
     return parseSinceToIso(trimmed);
 }
-function roundRate(value) {
-    return Number(value.toFixed(4));
-}
-function parseTaskMetadata(row) {
-    try {
-        return JSON.parse(row.metadata_json);
-    }
-    catch {
-        return {};
-    }
-}
-function createUnknownImproveMetrics() {
-    return {
-        invoked: 0,
-        completed: 0,
-        skipped: 0,
-        skipReasons: {},
-        plannedRefs: 0,
-        profileFilteredRefs: 0,
-        actions: {
-            reflect: { ok: 0, failed: 0, cooldown: 0, skipped: 0, guardRejected: 0, skippedByReason: {} },
-            distill: {
-                queued: 0,
-                llmFailed: 0,
-                qualityRejected: 0,
-                judgeRejected: 0,
-                validatorRejected: 0,
-                configDisabled: 0,
-                skipped: 0,
-                skippedByReason: {},
-                deferred: 0,
-                deferredByReason: {},
-            },
-            memoryPrune: 0,
-            memoryInference: 0,
-            graphExtraction: 0,
-            error: 0,
-        },
-        autoAccept: { promoted: 0, validationFailed: 0 },
-        reflectsWithErrorContext: 0,
-        coverageGapCount: 0,
-        evalCasesWritten: 0,
-        deadUrlCount: 0,
-        memorySummary: { eligible: 0, derived: 0 },
-        memoryCleanup: {
-            pruneCandidates: 0,
-            contradictionCandidates: 0,
-            beliefStateTransitions: 0,
-            consolidationCandidates: 0,
-            archived: 0,
-            warnings: 0,
-        },
-        consolidation: {
-            ran: false,
-            processed: 0,
-            promoted: 0,
-            merged: 0,
-            deleted: 0,
-            contradicted: 0,
-            judgedNoAction: 0,
-            mergedSecondaries: 0,
-            failedChunkMemories: 0,
-            skipReasons: {},
-            failedChunks: 0,
-            totalChunks: 0,
-            durationMs: 0,
-        },
-        memoryInference: {
-            ran: false,
-            considered: 0,
-            cacheHits: 0,
-            retryAttempts: 0,
-            freshAttempts: 0,
-            splitParents: 0,
-            written: 0,
-            skippedNoFacts: 0,
-            skippedChildExists: 0,
-            skippedAborted: 0,
-            unaccounted: 0,
-            htmlErrorCount: 0,
-            yieldEligibleRuns: 0,
-            yieldEligibleConsidered: 0,
-            yieldEligibleWritten: 0,
-            yieldRate: 0,
-            durationMs: 0,
-            writes: 0,
-        },
-        graphExtraction: {
-            ran: false,
-            extractedFiles: 0,
-            entities: 0,
-            relations: 0,
-            cacheHits: 0,
-            cacheMisses: 0,
-            cacheHitRate: 0,
-            truncations: 0,
-            failures: 0,
-            htmlErrors: 0,
-            retryAttempts: 0,
-            durationMs: 0,
-        },
-        sessionExtraction: {
-            ran: false,
-            sessionsScanned: 0,
-            sessionsExtracted: 0,
-            sessionsSkipped: 0,
-            proposalsCreated: 0,
-            warnings: 0,
-            durationMs: 0,
-        },
-        wallTime: {
-            count: 0,
-            medianMs: 0,
-            p95Ms: 0,
-            minMs: 0,
-            maxMs: 0,
-            byPhase: {
-                consolidation: { count: 0, totalMs: 0, medianMs: 0, p95Ms: 0 },
-                memoryInference: { count: 0, totalMs: 0, medianMs: 0, p95Ms: 0 },
-                graphExtraction: { count: 0, totalMs: 0, medianMs: 0, p95Ms: 0 },
-            },
-        },
-    };
-}
-function toFiniteNumber(value) {
-    if (typeof value === "number" && Number.isFinite(value))
-        return value;
-    if (typeof value === "string" && value.trim()) {
-        const parsed = Number(value);
-        if (Number.isFinite(parsed))
-            return parsed;
-    }
-    return 0;
-}
-/**
- * Event-derived metrics. Only `completed` and skipReasons/invoked are sourced
- * from events in v2 — the richer fields come from {@link summarizeImproveRuns}.
- * The function still receives `improve_completed` events so that the completed
- * count reflects the canonical event stream (it lines up 1:1 with improve_runs
- * rows in practice, but the events table remains the system-of-record for the
- * existence of a run).
- */
-function summarizeImproveCompleted(events) {
-    const metrics = createUnknownImproveMetrics();
-    metrics.completed = events.length;
-    return metrics;
-}
-/**
- * Project a single `improve_runs.result_json` envelope into an accumulator-shaped
- * ImproveHealthMetrics. The aggregator merges these per-row metrics into one
- * window-level metric.
- */
-function projectRunMetrics(result) {
-    const metrics = createUnknownImproveMetrics();
-    // plannedRefs (array of {ref, reason})
-    const plannedRefs = result.plannedRefs;
-    if (Array.isArray(plannedRefs))
-        metrics.plannedRefs += plannedRefs.length;
-    // profileFilteredRefs (array of {ref, reason}) — 2026-05-27: pre-filter
-    // bucket from `collectEligibleRefs` so the metric reflects work the
-    // planner dropped before signal-delta / per-pass dispatch.
-    const profileFilteredRefs = result.profileFilteredRefs;
-    if (Array.isArray(profileFilteredRefs))
-        metrics.profileFilteredRefs += profileFilteredRefs.length;
-    // actions: split reflect / distill by outcome, count others.
-    const actions = result.actions;
-    if (Array.isArray(actions)) {
-        for (const action of actions) {
-            const mode = typeof action.mode === "string" ? action.mode : "";
-            switch (mode) {
-                case "reflect":
-                    metrics.actions.reflect.ok += 1;
-                    break;
-                case "reflect-failed":
-                    metrics.actions.reflect.failed += 1;
-                    break;
-                case "reflect-cooldown":
-                    metrics.actions.reflect.cooldown += 1;
-                    break;
-                case "reflect-skipped": {
-                    metrics.actions.reflect.skipped += 1;
-                    const r = action.result;
-                    const reason = typeof r?.reason === "string" && r.reason.trim() ? r.reason : "unknown";
-                    metrics.actions.reflect.skippedByReason[reason] = (metrics.actions.reflect.skippedByReason[reason] ?? 0) + 1;
-                    break;
-                }
-                case "reflect-guard-rejected":
-                    metrics.actions.reflect.guardRejected += 1;
-                    break;
-                case "distill": {
-                    const r = action.result;
-                    const outcome = typeof r?.outcome === "string" ? r.outcome : "";
-                    switch (outcome) {
-                        case "queued":
-                            metrics.actions.distill.queued += 1;
-                            break;
-                        case "llm_failed":
-                            metrics.actions.distill.llmFailed += 1;
-                            break;
-                        case "quality_rejected":
-                        case "review_needed":
-                            metrics.actions.distill.qualityRejected += 1;
-                            metrics.actions.distill.judgeRejected += 1;
-                            break;
-                        case "validation_failed":
-                            metrics.actions.distill.qualityRejected += 1;
-                            metrics.actions.distill.validatorRejected += 1;
-                            break;
-                        case "config_disabled":
-                            metrics.actions.distill.configDisabled += 1;
-                            break;
-                        case "skipped": {
-                            // Previously dropped on the floor. The four sub-paths that emit
-                            // `outcome: "skipped"` (see distill.ts:893, 1024, 1120, 1576):
-                            //   - recursive_lesson_input (type guard refused a lesson input)
-                            //   - conflict_noop (LLM resolved destination conflict as NOOP)
-                            //   - proposal-skipped cooldown / dedup at persistence
-                            // 465 events/7d in the user's live stack. The result message
-                            // typically encodes the reason; we also accept an explicit
-                            // `skipReason` field when downstream code sets it.
-                            metrics.actions.distill.deferred += 1;
-                            const explicitReason = typeof r?.skipReason === "string" ? r.skipReason : undefined;
-                            const msg = typeof r?.message === "string" ? r.message : "";
-                            let reason = explicitReason ?? "unknown";
-                            if (!explicitReason) {
-                                if (/lesson inputs/i.test(msg))
-                                    reason = "recursive_lesson_input";
-                                else if (/NOOP/.test(msg))
-                                    reason = "conflict_noop";
-                                else if (/cooldown/i.test(msg))
-                                    reason = "proposal_cooldown";
-                                else if (/content[_ ]?hash/i.test(msg))
-                                    reason = "content_hash_match";
-                            }
-                            metrics.actions.distill.deferredByReason[reason] =
-                                (metrics.actions.distill.deferredByReason[reason] ?? 0) + 1;
-                            break;
-                        }
-                        default:
-                            break;
-                    }
-                    break;
-                }
-                case "distill-skipped": {
-                    metrics.actions.distill.skipped += 1;
-                    const r = action.result;
-                    const reason = typeof r?.reason === "string" && r.reason.trim() ? r.reason : "unknown";
-                    metrics.actions.distill.skippedByReason[reason] = (metrics.actions.distill.skippedByReason[reason] ?? 0) + 1;
-                    break;
-                }
-                case "memory-prune":
-                    metrics.actions.memoryPrune += 1;
-                    break;
-                case "memory-inference":
-                    metrics.actions.memoryInference += 1;
-                    break;
-                case "graph-extraction":
-                    metrics.actions.graphExtraction += 1;
-                    break;
-                case "error":
-                    metrics.actions.error += 1;
-                    break;
-            }
-        }
-    }
-    metrics.autoAccept.promoted += toFiniteNumber(result.gateAutoAcceptedCount);
-    metrics.autoAccept.validationFailed += toFiniteNumber(result.gateAutoAcceptFailedCount);
-    metrics.reflectsWithErrorContext += toFiniteNumber(result.reflectsWithErrorContext);
-    if (Array.isArray(result.coverageGaps))
-        metrics.coverageGapCount += result.coverageGaps.length;
-    metrics.evalCasesWritten += toFiniteNumber(result.evalCasesWritten);
-    if (Array.isArray(result.deadUrls))
-        metrics.deadUrlCount += result.deadUrls.length;
-    const memorySummary = result.memorySummary;
-    if (memorySummary) {
-        metrics.memorySummary.eligible += toFiniteNumber(memorySummary.eligible);
-        metrics.memorySummary.derived += toFiniteNumber(memorySummary.derived);
-    }
-    const memoryCleanup = result.memoryCleanup;
-    if (memoryCleanup) {
-        if (Array.isArray(memoryCleanup.pruneCandidates))
-            metrics.memoryCleanup.pruneCandidates += memoryCleanup.pruneCandidates.length;
-        if (Array.isArray(memoryCleanup.contradictionCandidates))
-            metrics.memoryCleanup.contradictionCandidates += memoryCleanup.contradictionCandidates.length;
-        if (Array.isArray(memoryCleanup.beliefStateTransitions))
-            metrics.memoryCleanup.beliefStateTransitions += memoryCleanup.beliefStateTransitions.length;
-        if (Array.isArray(memoryCleanup.consolidationCandidates))
-            metrics.memoryCleanup.consolidationCandidates += memoryCleanup.consolidationCandidates.length;
-        if (Array.isArray(memoryCleanup.archived))
-            metrics.memoryCleanup.archived += memoryCleanup.archived.length;
-        if (Array.isArray(memoryCleanup.warnings))
-            metrics.memoryCleanup.warnings += memoryCleanup.warnings.length;
-    }
-    const consolidation = result.consolidation;
-    if (consolidation) {
-        metrics.consolidation.processed += toFiniteNumber(consolidation.processed);
-        metrics.consolidation.merged += toFiniteNumber(consolidation.merged);
-        metrics.consolidation.deleted += toFiniteNumber(consolidation.deleted);
-        metrics.consolidation.contradicted += toFiniteNumber(consolidation.contradicted);
-        if (Array.isArray(consolidation.promoted))
-            metrics.consolidation.promoted += consolidation.promoted.length;
-        metrics.consolidation.failedChunks += toFiniteNumber(consolidation.failedChunks);
-        metrics.consolidation.totalChunks += toFiniteNumber(consolidation.totalChunks);
-        metrics.consolidation.durationMs += toFiniteNumber(consolidation.durationMs);
-        metrics.consolidation.judgedNoAction += toFiniteNumber(consolidation.judgedNoAction);
-        metrics.consolidation.mergedSecondaries += toFiniteNumber(consolidation.mergedSecondaries);
-        metrics.consolidation.failedChunkMemories += toFiniteNumber(consolidation.failedChunkMemories);
-        // Structured emitter (new on this branch): consolidate.ts now pushes
-        // per-ref grouped `{ref, skips: [{op, reason}]}` entries to `skipReasons`
-        // for every deterministic post-LLM rejection. Each ref appears once but
-        // may carry multiple skips; aggregate every reason. Pre-fix envelopes have
-        // neither field, so be defensive.
-        const skipReasons = consolidation.skipReasons;
-        if (Array.isArray(skipReasons)) {
-            for (const entry of skipReasons) {
-                if (!entry || typeof entry !== "object")
-                    continue;
-                const skips = entry.skips;
-                if (!Array.isArray(skips))
-                    continue;
-                for (const skip of skips) {
-                    if (!skip || typeof skip !== "object")
-                        continue;
-                    const reason = skip.reason;
-                    if (typeof reason !== "string" || !reason.trim())
-                        continue;
-                    metrics.consolidation.skipReasons[reason] = (metrics.consolidation.skipReasons[reason] ?? 0) + 1;
-                }
-            }
-        }
-    }
-    const memoryInference = result.memoryInference;
-    if (memoryInference) {
-        const considered = toFiniteNumber(memoryInference.considered);
-        const writtenFacts = toFiniteNumber(memoryInference.writtenFacts);
-        metrics.memoryInference.considered += considered;
-        metrics.memoryInference.cacheHits += toFiniteNumber(memoryInference.cacheHits);
-        metrics.memoryInference.retryAttempts += toFiniteNumber(memoryInference.retryAttempts);
-        metrics.memoryInference.splitParents += toFiniteNumber(memoryInference.splitParents);
-        metrics.memoryInference.written += writtenFacts;
-        metrics.memoryInference.skippedNoFacts += toFiniteNumber(memoryInference.skippedNoFacts);
-        metrics.memoryInference.skippedChildExists += toFiniteNumber(memoryInference.skippedChildExists);
-        metrics.memoryInference.skippedAborted += toFiniteNumber(memoryInference.skippedAborted);
-        metrics.memoryInference.unaccounted += toFiniteNumber(memoryInference.unaccounted);
-        metrics.memoryInference.htmlErrorCount += toFiniteNumber(memoryInference.htmlErrorCount);
-        // Yield-rate gating: pre-cache-feature envelopes lack the `cacheHits`
-        // field entirely. Treating their `considered` as freshAttempts (since
-        // cacheHits=0) is mathematically tempting but operationally wrong —
-        // historical runs with the legacy schema have no cache instrumentation
-        // and the SUM dragged the reported rate to ~14% in local data. Only
-        // contribute to the yield aggregate when the envelope actually carries
-        // the field. See investigation 2026-05-26.
-        if (Object.hasOwn(memoryInference, "cacheHits")) {
-            metrics.memoryInference.yieldEligibleRuns += 1;
-            metrics.memoryInference.yieldEligibleConsidered += considered;
-            metrics.memoryInference.yieldEligibleWritten += writtenFacts;
-        }
-    }
-    metrics.memoryInference.durationMs += toFiniteNumber(result.memoryInferenceDurationMs);
-    const graphExtraction = result.graphExtraction;
-    if (graphExtraction) {
-        const quality = graphExtraction.quality;
-        if (quality)
-            metrics.graphExtraction.extractedFiles += toFiniteNumber(quality.extractedFiles);
-        metrics.graphExtraction.entities += toFiniteNumber(graphExtraction.totalEntities);
-        metrics.graphExtraction.relations += toFiniteNumber(graphExtraction.totalRelations);
-        const telemetry = graphExtraction.telemetry;
-        if (telemetry) {
-            metrics.graphExtraction.cacheHits += toFiniteNumber(telemetry.cacheHits);
-            metrics.graphExtraction.cacheMisses += toFiniteNumber(telemetry.cacheMisses);
-            metrics.graphExtraction.truncations += toFiniteNumber(telemetry.truncationCount);
-            metrics.graphExtraction.failures += toFiniteNumber(telemetry.failureCount);
-            metrics.graphExtraction.htmlErrors += toFiniteNumber(telemetry.htmlErrorCount);
-            metrics.graphExtraction.retryAttempts += toFiniteNumber(telemetry.retryAttempts);
-        }
-    }
-    metrics.graphExtraction.durationMs += toFiniteNumber(result.graphExtractionDurationMs);
-    if (Array.isArray(result.extract)) {
-        for (const e of result.extract) {
-            metrics.sessionExtraction.sessionsScanned += toFiniteNumber(e.sessionsProcessed);
-            metrics.sessionExtraction.sessionsSkipped += toFiniteNumber(e.sessionsSkipped);
-            if (Array.isArray(e.sessions)) {
-                metrics.sessionExtraction.sessionsExtracted += e.sessions.filter((s) => Array.isArray(s.proposalIds) && s.proposalIds.length > 0).length;
-            }
-            metrics.sessionExtraction.proposalsCreated += Array.isArray(e.proposals) ? e.proposals.length : 0;
-            metrics.sessionExtraction.warnings += Array.isArray(e.warnings) ? e.warnings.length : 0;
-            metrics.sessionExtraction.durationMs += toFiniteNumber(e.durationMs);
-        }
-    }
-    return metrics;
-}
-/**
- * Finalize derived flags and rates on an accumulator. Used both for the
- * window-level aggregate and for each per-run row in --detail per-run mode
- * so the single-row metrics still expose `ran` / `yieldRate` / `cacheHitRate`.
- */
-function finalizeImproveMetrics(metrics) {
-    metrics.consolidation.ran =
-        metrics.consolidation.processed > 0 ||
-            metrics.consolidation.durationMs > 0 ||
-            metrics.consolidation.promoted > 0 ||
-            metrics.consolidation.merged > 0 ||
-            metrics.consolidation.deleted > 0 ||
-            metrics.consolidation.contradicted > 0 ||
-            metrics.consolidation.totalChunks > 0;
-    metrics.memoryInference.ran =
-        metrics.memoryInference.considered > 0 ||
-            metrics.memoryInference.written > 0 ||
-            metrics.memoryInference.durationMs > 0;
-    metrics.memoryInference.writes = metrics.memoryInference.written;
-    // Yield denominator excludes cache hits AND legacy (pre-cacheHits-field)
-    // envelopes. Only runs whose envelope carries a `cacheHits` field
-    // contribute to freshAttempts/yieldRate; legacy rows remain in
-    // `considered`/`written` for totals but are excluded from the rate so
-    // they cannot drag it down. See ImproveHealthMetrics.memoryInference
-    // jsdoc for the rationale.
-    metrics.memoryInference.freshAttempts = Math.max(0, metrics.memoryInference.yieldEligibleConsidered -
-        metrics.memoryInference.cacheHits -
-        metrics.memoryInference.skippedAborted);
-    metrics.memoryInference.yieldRate =
-        metrics.memoryInference.freshAttempts > 0
-            ? roundRate(metrics.memoryInference.yieldEligibleWritten / metrics.memoryInference.freshAttempts)
-            : 0;
-    metrics.graphExtraction.ran =
-        metrics.graphExtraction.extractedFiles > 0 ||
-            metrics.graphExtraction.entities > 0 ||
-            metrics.graphExtraction.durationMs > 0;
-    const cacheTotal = metrics.graphExtraction.cacheHits + metrics.graphExtraction.cacheMisses;
-    metrics.graphExtraction.cacheHitRate = cacheTotal > 0 ? roundRate(metrics.graphExtraction.cacheHits / cacheTotal) : 0;
-    metrics.sessionExtraction.ran =
-        metrics.sessionExtraction.sessionsScanned > 0 ||
-            metrics.sessionExtraction.proposalsCreated > 0 ||
-            metrics.sessionExtraction.durationMs > 0;
-}
-/**
- * Merge per-row metrics from `src` into accumulator `dst`. All numeric fields
- * are additive; cumulative rates are recomputed by finalizeImproveMetrics.
- */
-function mergeImproveMetrics(dst, src) {
-    dst.plannedRefs += src.plannedRefs;
-    dst.profileFilteredRefs += src.profileFilteredRefs;
-    dst.actions.reflect.ok += src.actions.reflect.ok;
-    dst.actions.reflect.failed += src.actions.reflect.failed;
-    dst.actions.reflect.cooldown += src.actions.reflect.cooldown;
-    dst.actions.reflect.skipped += src.actions.reflect.skipped;
-    dst.actions.reflect.guardRejected += src.actions.reflect.guardRejected;
-    for (const [reason, count] of Object.entries(src.actions.reflect.skippedByReason)) {
-        dst.actions.reflect.skippedByReason[reason] = (dst.actions.reflect.skippedByReason[reason] ?? 0) + count;
-    }
-    dst.actions.distill.queued += src.actions.distill.queued;
-    dst.actions.distill.llmFailed += src.actions.distill.llmFailed;
-    dst.actions.distill.qualityRejected += src.actions.distill.qualityRejected;
-    dst.actions.distill.judgeRejected += src.actions.distill.judgeRejected;
-    dst.actions.distill.validatorRejected += src.actions.distill.validatorRejected;
-    dst.actions.distill.configDisabled += src.actions.distill.configDisabled;
-    dst.actions.distill.skipped += src.actions.distill.skipped;
-    for (const [reason, count] of Object.entries(src.actions.distill.skippedByReason)) {
-        dst.actions.distill.skippedByReason[reason] = (dst.actions.distill.skippedByReason[reason] ?? 0) + count;
-    }
-    dst.actions.distill.deferred += src.actions.distill.deferred;
-    for (const [reason, count] of Object.entries(src.actions.distill.deferredByReason)) {
-        dst.actions.distill.deferredByReason[reason] = (dst.actions.distill.deferredByReason[reason] ?? 0) + count;
-    }
-    dst.actions.memoryPrune += src.actions.memoryPrune;
-    dst.actions.memoryInference += src.actions.memoryInference;
-    dst.actions.graphExtraction += src.actions.graphExtraction;
-    dst.actions.error += src.actions.error;
-    dst.autoAccept.promoted += src.autoAccept.promoted;
-    dst.autoAccept.validationFailed += src.autoAccept.validationFailed;
-    dst.reflectsWithErrorContext += src.reflectsWithErrorContext;
-    dst.coverageGapCount += src.coverageGapCount;
-    dst.evalCasesWritten += src.evalCasesWritten;
-    dst.deadUrlCount += src.deadUrlCount;
-    dst.memorySummary.eligible += src.memorySummary.eligible;
-    dst.memorySummary.derived += src.memorySummary.derived;
-    dst.memoryCleanup.pruneCandidates += src.memoryCleanup.pruneCandidates;
-    dst.memoryCleanup.contradictionCandidates += src.memoryCleanup.contradictionCandidates;
-    dst.memoryCleanup.beliefStateTransitions += src.memoryCleanup.beliefStateTransitions;
-    dst.memoryCleanup.consolidationCandidates += src.memoryCleanup.consolidationCandidates;
-    dst.memoryCleanup.archived += src.memoryCleanup.archived;
-    dst.memoryCleanup.warnings += src.memoryCleanup.warnings;
-    dst.consolidation.processed += src.consolidation.processed;
-    dst.consolidation.promoted += src.consolidation.promoted;
-    dst.consolidation.merged += src.consolidation.merged;
-    dst.consolidation.deleted += src.consolidation.deleted;
-    dst.consolidation.contradicted += src.consolidation.contradicted;
-    dst.consolidation.failedChunks += src.consolidation.failedChunks;
-    dst.consolidation.totalChunks += src.consolidation.totalChunks;
-    dst.consolidation.durationMs += src.consolidation.durationMs;
-    dst.consolidation.judgedNoAction += src.consolidation.judgedNoAction;
-    dst.consolidation.mergedSecondaries += src.consolidation.mergedSecondaries;
-    dst.consolidation.failedChunkMemories += src.consolidation.failedChunkMemories;
-    for (const [reason, count] of Object.entries(src.consolidation.skipReasons)) {
-        dst.consolidation.skipReasons[reason] = (dst.consolidation.skipReasons[reason] ?? 0) + count;
-    }
-    dst.memoryInference.considered += src.memoryInference.considered;
-    dst.memoryInference.cacheHits += src.memoryInference.cacheHits;
-    dst.memoryInference.splitParents += src.memoryInference.splitParents;
-    dst.memoryInference.written += src.memoryInference.written;
-    dst.memoryInference.skippedNoFacts += src.memoryInference.skippedNoFacts;
-    dst.memoryInference.skippedChildExists += src.memoryInference.skippedChildExists;
-    dst.memoryInference.skippedAborted += src.memoryInference.skippedAborted;
-    dst.memoryInference.unaccounted += src.memoryInference.unaccounted;
-    dst.memoryInference.htmlErrorCount += src.memoryInference.htmlErrorCount;
-    dst.memoryInference.yieldEligibleRuns += src.memoryInference.yieldEligibleRuns;
-    dst.memoryInference.yieldEligibleConsidered += src.memoryInference.yieldEligibleConsidered;
-    dst.memoryInference.yieldEligibleWritten += src.memoryInference.yieldEligibleWritten;
-    dst.memoryInference.durationMs += src.memoryInference.durationMs;
-    dst.graphExtraction.extractedFiles += src.graphExtraction.extractedFiles;
-    dst.graphExtraction.entities += src.graphExtraction.entities;
-    dst.graphExtraction.relations += src.graphExtraction.relations;
-    dst.graphExtraction.cacheHits += src.graphExtraction.cacheHits;
-    dst.graphExtraction.cacheMisses += src.graphExtraction.cacheMisses;
-    dst.graphExtraction.truncations += src.graphExtraction.truncations;
-    dst.graphExtraction.failures += src.graphExtraction.failures;
-    dst.graphExtraction.htmlErrors += src.graphExtraction.htmlErrors;
-    dst.graphExtraction.durationMs += src.graphExtraction.durationMs;
-    dst.sessionExtraction.sessionsScanned += src.sessionExtraction.sessionsScanned;
-    dst.sessionExtraction.sessionsExtracted += src.sessionExtraction.sessionsExtracted;
-    dst.sessionExtraction.sessionsSkipped += src.sessionExtraction.sessionsSkipped;
-    dst.sessionExtraction.proposalsCreated += src.sessionExtraction.proposalsCreated;
-    dst.sessionExtraction.warnings += src.sessionExtraction.warnings;
-    dst.sessionExtraction.durationMs += src.sessionExtraction.durationMs;
-}
-function summarizeImproveRuns(db, since, until) {
-    const accum = createUnknownImproveMetrics();
-    const rows = queryImproveRuns(db, since, until);
-    // Per-phase wall-time samples. Each entry is one envelope's durationMs for
-    // that phase. Phases that did not run on a given envelope are simply
-    // omitted (NOT counted as 0) so the median/p95 reflect actual phase work.
-    const phaseDurations = {
-        consolidation: [],
-        memoryInference: [],
-        graphExtraction: [],
-    };
-    for (const row of rows) {
-        let result;
-        try {
-            result = JSON.parse(row.result_json);
-        }
-        catch {
-            continue;
-        }
-        const perRow = projectRunMetrics(result);
-        mergeImproveMetrics(accum, perRow);
-        // Collect per-phase durations directly off the envelope. consolidation's
-        // duration lives inside the sub-object; memoryInference and graphExtraction
-        // expose top-level *DurationMs keys (`memoryInferenceDurationMs`,
-        // `graphExtractionDurationMs`) when they actually ran on that envelope.
-        const consol = result.consolidation;
-        const consolMs = toFiniteNumber(consol?.durationMs);
-        if (consolMs > 0)
-            phaseDurations.consolidation.push(consolMs);
-        const memMs = toFiniteNumber(result.memoryInferenceDurationMs);
-        if (memMs > 0)
-            phaseDurations.memoryInference.push(memMs);
-        const graphMs = toFiniteNumber(result.graphExtractionDurationMs);
-        if (graphMs > 0)
-            phaseDurations.graphExtraction.push(graphMs);
-    }
-    finalizeImproveMetrics(accum);
-    accum.wallTime.byPhase = {
-        consolidation: summarizePhaseDurations(phaseDurations.consolidation),
-        memoryInference: summarizePhaseDurations(phaseDurations.memoryInference),
-        graphExtraction: summarizePhaseDurations(phaseDurations.graphExtraction),
-    };
-    return { metrics: accum, runCount: rows.length };
-}
-/**
- * Aggregate a list of per-envelope phase durations into the
- * `wallTime.byPhase.*` shape: count, total, median, p95. Median/p95 use the
- * same nearest-rank picker as the top-level wallTime stats so the two are
- * comparable.
- */
-function summarizePhaseDurations(samples) {
-    if (samples.length === 0)
-        return { count: 0, totalMs: 0, medianMs: 0, p95Ms: 0 };
-    const sorted = [...samples].sort((a, b) => a - b);
-    const pick = (q) => sorted[Math.min(sorted.length - 1, Math.floor(q * sorted.length))] ?? 0;
-    const totalMs = sorted.reduce((acc, n) => acc + n, 0);
-    return {
-        count: sorted.length,
-        totalMs,
-        medianMs: pick(0.5),
-        p95Ms: pick(0.95),
-    };
-}
-/**
- * Project an improve_runs row + wall-time lookup into a single ImproveRunSummary.
- * Used by `akm health --detail per-run`.
- */
-function projectImproveRunSummary(row, wallTimeMs) {
-    let result = {};
-    try {
-        result = JSON.parse(row.result_json);
-    }
-    catch {
-        // fall through with empty result so per-stage rollups are zeros
-    }
-    const perRow = projectRunMetrics(result);
-    finalizeImproveMetrics(perRow);
-    const orphansPurged = toFiniteNumber(result.orphansPurged);
-    const lintSummary = result.lintSummary;
-    const lintFixed = lintSummary ? toFiniteNumber(lintSummary.fixed) : 0;
-    const lintFlagged = lintSummary ? toFiniteNumber(lintSummary.flagged) : 0;
-    return {
-        id: row.id,
-        startedAt: row.started_at,
-        completedAt: row.completed_at,
-        wallTimeMs,
-        ok: row.ok === 1,
-        scope: {
-            mode: row.scope_mode,
-            ...(row.scope_value ? { value: row.scope_value } : {}),
-        },
-        actions: perRow.actions,
-        memorySummary: perRow.memorySummary,
-        memoryCleanup: perRow.memoryCleanup,
-        consolidation: perRow.consolidation,
-        memoryInference: perRow.memoryInference,
-        graphExtraction: perRow.graphExtraction,
-        reflectsWithErrorContext: perRow.reflectsWithErrorContext,
-        evalCasesWritten: perRow.evalCasesWritten,
-        orphansPurged,
-        lintFixed,
-        lintFlagged,
-    };
-}
-/**
- * Load task_history intervals for `task_id='akm-improve'` in the window.
- * Returned sorted by startMs ascending so containment lookups can use a
- * linear scan (typical N is ~24/day; not worth a tree).
- *
- * The window filter is widened by 5 minutes on each side because the cron
- * task wraps `akm improve` — the task `started_at` fires at e.g. :07:01
- * while `recordImproveRun` writes the matching `improve_runs.started_at`
- * later (after config load, planning, etc.), so the improve_runs row can
- * be inside the window even when its enclosing task_history row started
- * just before the window opened.
- */
-function loadTaskIntervals(db, since, until) {
-    const sinceMs = new Date(since).getTime();
-    const untilMs = until ? new Date(until).getTime() : Number.POSITIVE_INFINITY;
-    const widenedSince = new Date(sinceMs - 5 * 60 * 1000).toISOString();
-    const widenedUntil = Number.isFinite(untilMs) ? new Date(untilMs + 5 * 60 * 1000).toISOString() : undefined;
-    const rows = queryCompletedTaskIntervals(db, widenedSince, widenedUntil);
-    const intervals = [];
-    for (const row of rows) {
-        const startMs = new Date(row.started_at).getTime();
-        const endMs = new Date(row.completed_at).getTime();
-        if (!Number.isFinite(startMs) || !Number.isFinite(endMs) || endMs < startMs)
-            continue;
-        intervals.push({ startMs, endMs, durationMs: endMs - startMs });
-    }
-    return intervals;
-}
-/**
- * Find the task_history interval that contains the given timestamp. The
- * task wraps `akm improve`, so `improve_runs.started_at` (when
- * `recordImproveRun` writes) always falls inside the enclosing task's
- * [started_at, completed_at]. Returns undefined when no interval
- * contains the timestamp (which happens for manually-invoked improve
- * runs not driven by the `akm-improve` task).
- *
- * Linear scan because N is small. We tolerate a 1s slop on the upper
- * bound to handle clock skew between the wrapper's `completed_at` write
- * and recordImproveRun's `started_at` write.
- */
-function findContainingTaskInterval(timestampMs, intervals) {
-    const SLOP_MS = 1000;
-    for (const interval of intervals) {
-        if (timestampMs >= interval.startMs && timestampMs <= interval.endMs + SLOP_MS) {
-            return interval;
-        }
-    }
-    return undefined;
-}
-function buildPerRunSummaries(db, since, until) {
-    const rows = queryImproveRuns(db, since, until);
-    const taskIntervals = loadTaskIntervals(db, since, until);
-    const summaries = [];
-    for (const row of rows) {
-        const startMs = new Date(row.started_at).getTime();
-        const endMs = new Date(row.completed_at).getTime();
-        // Prefer the improve_runs row's own (completed_at - started_at) delta:
-        // recordImproveRun now persists distinct start/end timestamps, so the
-        // row's own delta is the authoritative per-run wall time even for
-        // manually-invoked `akm improve` runs with no enclosing task_history.
-        // Only fall back to the task_history containing-interval join for legacy/
-        // backfill rows where started_at == completed_at (row delta is 0).
-        const hasRowDelta = Number.isFinite(startMs) && Number.isFinite(endMs) && endMs > startMs;
-        let wallTimeMs;
-        if (hasRowDelta) {
-            wallTimeMs = endMs - startMs;
-        }
-        else {
-            const interval = Number.isFinite(startMs) ? findContainingTaskInterval(startMs, taskIntervals) : undefined;
-            wallTimeMs = interval?.durationMs ?? 0;
-        }
-        summaries.push(projectImproveRunSummary(row, wallTimeMs));
-    }
-    return summaries;
-}
-function emptyPhaseStats() {
-    return {
-        consolidation: { count: 0, totalMs: 0, medianMs: 0, p95Ms: 0 },
-        memoryInference: { count: 0, totalMs: 0, medianMs: 0, p95Ms: 0 },
-        graphExtraction: { count: 0, totalMs: 0, medianMs: 0, p95Ms: 0 },
-    };
-}
-function computeWallTimeStats(durationsMs, byPhase) {
-    const phase = byPhase ?? emptyPhaseStats();
-    if (durationsMs.length === 0)
-        return { count: 0, medianMs: 0, p95Ms: 0, minMs: 0, maxMs: 0, byPhase: phase };
-    const sorted = [...durationsMs].sort((a, b) => a - b);
-    const pick = (q) => sorted[Math.min(sorted.length - 1, Math.floor(q * sorted.length))] ?? 0;
-    return {
-        count: sorted.length,
-        medianMs: pick(0.5),
-        p95Ms: pick(0.95),
-        minMs: sorted[0] ?? 0,
-        maxMs: sorted[sorted.length - 1] ?? 0,
-        byPhase: phase,
-    };
-}
-function buildImproveSkipSummary(events) {
-    const skipReasons = {};
-    let skipped = 0;
-    for (const event of events) {
-        const reason = typeof event.metadata?.reason === "string" && event.metadata.reason.trim() ? event.metadata.reason : "unknown";
-        // Aggregated skip events (e.g. `no_new_signal`, `profile_filtered_all_passes`)
-        // carry a `count` of the refs they represent in a single row instead of one
-        // event per ref. Honor that count so the skip histogram reflects the true
-        // number of skipped refs; per-ref events without a count contribute 1.
-        const rawCount = event.metadata?.count;
-        const count = typeof rawCount === "number" && Number.isFinite(rawCount) && rawCount > 0 ? rawCount : 1;
-        skipReasons[reason] = (skipReasons[reason] ?? 0) + count;
-        skipped += count;
-    }
-    return { skipped, skipReasons };
-}
-function probeStateDbRoundTrip(stateDbPath) {
-    const before = readEvents({}, { dbPath: stateDbPath }).nextOffset;
-    const started = Date.now();
-    appendEvent({ eventType: HEALTH_PROBE_EVENT, ref: "health:probe", metadata: { source: "akm health" } }, { dbPath: stateDbPath });
-    const after = readEvents({ sinceOffset: before, type: HEALTH_PROBE_EVENT, ref: "health:probe" }, { dbPath: stateDbPath });
-    const durationMs = Date.now() - started;
-    if (after.events.length === 0 || after.nextOffset <= before) {
-        return { ok: false, durationMs, error: "probe event was not readable after append" };
-    }
-    return { ok: true, durationMs };
-}
-/**
- * Parse a `--window-compare <duration>` shorthand into two adjacent windows
- * (current, prior). Duration syntax matches {@link parseHealthSince}.
- */
-function resolveWindowCompare(duration, now = () => Date.now()) {
-    const trimmed = duration.trim();
-    const durationMatch = trimmed.match(/^(\d+)([dhm])$/i);
-    if (!durationMatch) {
-        throw new UsageError("--window-compare must be a duration like '24h', '7d', or '30m'.", "INVALID_FLAG_VALUE");
-    }
-    const amount = Number.parseInt(durationMatch[1] ?? "0", 10);
-    const unit = (durationMatch[2] ?? "h").toLowerCase();
-    if (!Number.isFinite(amount) || amount <= 0) {
-        throw new UsageError("--window-compare must be a positive duration.", "INVALID_FLAG_VALUE");
-    }
-    const multiplier = unit === "h" ? 60 * 60 * 1000 : unit === "m" ? 60 * 1000 : 24 * 60 * 60 * 1000;
-    const ms = amount * multiplier;
-    const nowMs = now();
-    const currentSince = new Date(nowMs - ms).toISOString();
-    const currentUntil = new Date(nowMs).toISOString();
-    const priorSince = new Date(nowMs - 2 * ms).toISOString();
-    const priorUntil = currentSince;
-    return [
-        { name: "current", since: currentSince, until: currentUntil },
-        { name: "prior", since: priorSince, until: priorUntil },
-    ];
-}
-/**
- * Parse a single repeatable `--windows` value of the form
- * `name=...,since=...,until=...`. All keys are optional EXCEPT name and since.
- */
-export function parseWindowSpec(raw) {
-    const fields = {};
-    for (const part of raw.split(",")) {
-        const trimmed = part.trim();
-        if (!trimmed)
-            continue;
-        const eq = trimmed.indexOf("=");
-        if (eq < 0) {
-            throw new UsageError(`--windows entry must be a comma-separated list of key=value pairs: ${raw}`, "INVALID_FLAG_VALUE");
-        }
-        const key = trimmed.slice(0, eq).trim();
-        const value = trimmed.slice(eq + 1).trim();
-        fields[key] = value;
-    }
-    if (!fields.name) {
-        throw new UsageError(`--windows entry is missing required 'name': ${raw}`, "INVALID_FLAG_VALUE");
-    }
-    if (!fields.since) {
-        throw new UsageError(`--windows entry is missing required 'since': ${raw}`, "INVALID_FLAG_VALUE");
-    }
-    return {
-        name: fields.name,
-        since: fields.since,
-        ...(fields.until ? { until: fields.until } : {}),
-    };
-}
-/** Hard-coded list of "interesting" metric paths for window-compare deltas. */
-const INTERESTING_DELTA_PATHS = [
-    "improve.actions.reflect.failed",
-    "improve.actions.reflect.guardRejected",
-    "improve.actions.distill.llmFailed",
-    "improve.actions.distill.queued",
-    "improve.actions.distill.deferred",
-    "improve.consolidation.promoted",
-    "improve.memoryInference.written",
-    "improve.memoryInference.yieldRate",
-    "improve.memoryInference.skippedNoFacts",
-    "improve.memoryInference.htmlErrorCount",
-    "improve.graphExtraction.cacheHitRate",
-    "improve.graphExtraction.failures",
-    "improve.graphExtraction.htmlErrors",
-    "improve.sessionExtraction.sessionsScanned",
-    "improve.sessionExtraction.proposalsCreated",
-    "improve.autoAccept.promoted",
-    "improve.autoAccept.validationFailed",
-    "improve.wallTime.medianMs",
-    "improve.wallTime.p95Ms",
-];
-function readNumericPath(obj, path) {
-    const parts = path.split(".");
-    let cursor = obj;
-    for (const part of parts) {
-        if (typeof cursor !== "object" || cursor === null)
-            return 0;
-        cursor = cursor[part];
-    }
-    return typeof cursor === "number" && Number.isFinite(cursor) ? cursor : 0;
-}
-function computeDeltas(first, last) {
-    const out = {};
-    for (const path of INTERESTING_DELTA_PATHS) {
-        const from = readNumericPath(first, path);
-        const to = readNumericPath(last, path);
-        if (from === 0 && to === 0)
-            continue;
-        let pctChange;
-        if (from === 0) {
-            pctChange = to === 0 ? 0 : "+inf";
-        }
-        else {
-            pctChange = Number((((to - from) / from) * 100).toFixed(2));
-        }
-        out[path] = { from, to, pctChange };
-    }
-    return out;
-}
-/**
- * Partition task_history rows into "should have a log" (non-null log_path) and
- * "log is actually backed". A run counts as backed when logs.db holds rows for
- * its run_id (#579 — the DB is the primary record); rows written before logs.db
- * existed fall back to the transitional on-disk file check. `logsDb` may be
- * undefined when logs.db could not be opened — then only the file check runs.
- */
-function partitionLogBackedRows(taskRows, logsDb) {
-    const withLogs = taskRows.filter((row) => row.log_path !== null);
-    const loggedRunIds = logsDb
-        ? getLoggedRunIds(logsDb, withLogs.map((row) => buildTaskRunId(row.task_id, row.started_at)))
-        : new Set();
-    const backed = withLogs.filter((row) => loggedRunIds.has(buildTaskRunId(row.task_id, row.started_at)) ||
-        (row.log_path !== null && fs.existsSync(row.log_path)));
-    return { withLogs, backed };
-}
-/** Stage key used for `llm_usage` events recorded outside any stage scope. */
-const UNATTRIBUTED_STAGE = "unattributed";
-function emptyLlmUsageStageAggregate() {
-    return {
-        calls: 0,
-        totalDurationMs: 0,
-        promptTokens: 0,
-        completionTokens: 0,
-        totalTokens: 0,
-        reasoningTokens: 0,
-    };
-}
-function emptyLlmUsageAggregate() {
-    return { ...emptyLlmUsageStageAggregate(), byStage: {} };
-}
-/**
- * Aggregate `llm_usage` events (#576) into a window total plus a per-stage
- * breakdown of call count, wall-time, and token usage. Token fields absent from
- * a best-effort record contribute 0. Calls with no `stage` land under
- * {@link UNATTRIBUTED_STAGE}.
- */
-function summarizeLlmUsage(events) {
-    const aggregate = emptyLlmUsageAggregate();
-    for (const event of events) {
-        const meta = event.metadata ?? {};
-        const stageKey = typeof meta.stage === "string" && meta.stage ? meta.stage : UNATTRIBUTED_STAGE;
-        let stage = aggregate.byStage[stageKey];
-        if (!stage) {
-            stage = emptyLlmUsageStageAggregate();
-            aggregate.byStage[stageKey] = stage;
-        }
-        const durationMs = toFiniteNumber(meta.durationMs);
-        const promptTokens = toFiniteNumber(meta.promptTokens);
-        const completionTokens = toFiniteNumber(meta.completionTokens);
-        const totalTokens = toFiniteNumber(meta.totalTokens);
-        const reasoningTokens = toFiniteNumber(meta.reasoningTokens);
-        for (const target of [aggregate, stage]) {
-            target.calls += 1;
-            target.totalDurationMs += durationMs;
-            target.promptTokens += promptTokens;
-            target.completionTokens += completionTokens;
-            target.totalTokens += totalTokens;
-            target.reasoningTokens += reasoningTokens;
-        }
-    }
-    return aggregate;
-}
-function readLlmUsageAggregate(stateDbPath, since, until) {
-    const events = readEvents({ since, type: LLM_USAGE_EVENT }, { dbPath: stateDbPath }).events.filter((event) => {
-        if (until === undefined)
-            return true;
-        return new Date(event.ts ?? since).getTime() < new Date(until).getTime();
-    });
-    return summarizeLlmUsage(events);
-}
-function buildWindowMetrics(db, stateDbPath, since, until, now = () => Date.now(), logsDb) {
-    const taskRows = queryTaskHistory(db, { since }).filter((row) => {
-        const startMs = new Date(row.started_at).getTime();
-        const untilMs = new Date(until).getTime();
-        return !Number.isFinite(untilMs) || startMs < untilMs;
-    });
-    const { withLogs: taskRowsWithLogs, backed: existingLogRows } = partitionLogBackedRows(taskRows, logsDb);
-    const failedTaskRows = taskRows.filter((row) => row.status === "failed");
-    const activeRows = taskRows.filter((row) => row.status === "active");
-    const stuckActiveRuns = activeRows.filter((row) => now() - new Date(row.started_at).getTime() > ACTIVE_RUN_WARN_MS).length;
-    const promptRows = taskRows.filter((row) => row.target_kind === "prompt");
-    const promptFailures = promptRows.filter((row) => {
-        const detail = parseTaskMetadata(row).detail;
-        return typeof detail?.reason === "string" && detail.reason.length > 0;
-    });
-    const logBackingRate = taskRowsWithLogs.length === 0 ? 1 : existingLogRows.length / taskRowsWithLogs.length;
-    const taskFailRate = taskRows.length === 0 ? 0 : failedTaskRows.length / taskRows.length;
-    const agentFailureRate = promptRows.length === 0 ? 0 : promptFailures.length / promptRows.length;
-    const improveInvoked = readEvents({ since, type: "improve_invoked" }, { dbPath: stateDbPath }).events.filter((event) => new Date(event.ts ?? since).getTime() < new Date(until).getTime()).length;
-    const improveCompletedEvents = readEvents({ since, type: IMPROVE_COMPLETED_EVENT }, { dbPath: stateDbPath }).events.filter((event) => new Date(event.ts ?? since).getTime() < new Date(until).getTime());
-    const improveSkippedEvents = readEvents({ since, type: "improve_skipped" }, { dbPath: stateDbPath }).events.filter((event) => new Date(event.ts ?? since).getTime() < new Date(until).getTime());
-    const eventsMetrics = summarizeImproveCompleted(improveCompletedEvents);
-    const { metrics: improveSummary, runCount } = summarizeImproveRuns(db, since, until);
-    improveSummary.invoked = improveInvoked;
-    improveSummary.completed = eventsMetrics.completed;
-    const skipSummary = buildImproveSkipSummary(improveSkippedEvents);
-    improveSummary.skipped = skipSummary.skipped;
-    improveSummary.skipReasons = skipSummary.skipReasons;
-    // Preserve the per-phase aggregation computed by summarizeImproveRuns and
-    // derive top-level wall times from the same improve-runs window so counts
-    // and percentiles stay aligned with per-run reporting.
-    const perRunSummaries = buildPerRunSummaries(db, since, until);
-    const wallTimes = perRunSummaries.map((run) => run.wallTimeMs).filter((ms) => Number.isFinite(ms) && ms > 0);
-    improveSummary.wallTime = computeWallTimeStats(wallTimes, improveSummary.wallTime.byPhase);
-    const metrics = {
-        taskFailRate: roundRate(taskFailRate),
-        agentFailureRate: roundRate(agentFailureRate),
-        stuckActiveRuns,
-        logBackingRate: roundRate(logBackingRate),
-        probeRoundTripMs: null,
-        llmUsage: readLlmUsageAggregate(stateDbPath, since, until),
-    };
-    return { improve: improveSummary, metrics, runs: runCount };
-}
 function validateAkmHealthOptions(options) {
     if (options.groupBy !== undefined && options.groupBy !== "run") {
         throw new UsageError(`Invalid value for --group-by: ${options.groupBy}. Expected: run`, "INVALID_FLAG_VALUE");
@@ -1072,6 +105,20 @@ export function akmHealth(options = {}) {
         const taskFailRate = taskRows.length === 0 ? 0 : failedTaskRows.length / taskRows.length;
         const agentFailureRate = promptRows.length === 0 ? 0 : promptFailures.length / promptRows.length;
         const semanticStatus = readSemanticStatus();
+        // For the embedding-endpoint advisory. Best-effort: an unloadable config
+        // leaves both undefined and the check falls back to its generic message.
+        let semanticSearchMode;
+        let embeddingEndpoint;
+        let egressConfigView;
+        try {
+            const config = loadConfig();
+            semanticSearchMode = config.semanticSearchMode;
+            embeddingEndpoint = config.embedding?.endpoint;
+            egressConfigView = config;
+        }
+        catch {
+            // fall through with undefined
+        }
         const improveInvoked = readEvents({ since, type: "improve_invoked" }, { dbPath: stateDbPath }).events.length;
         const improveCompletedEvents = readEvents({ since, type: IMPROVE_COMPLETED_EVENT }, { dbPath: stateDbPath }).events;
         const improveSkippedEvents = readEvents({ since, type: "improve_skipped" }, { dbPath: stateDbPath }).events;
@@ -1085,6 +132,53 @@ export function akmHealth(options = {}) {
         const perRunSummaries = buildPerRunSummaries(db, since);
         const wallTimes = perRunSummaries.map((run) => run.wallTimeMs).filter((ms) => Number.isFinite(ms) && ms > 0);
         improveSummary.wallTime = computeWallTimeStats(wallTimes, improveSummary.wallTime.byPhase);
+        improveSummary.calibration = readCalibration(db, since);
+        // WS-5: Compute denominator-fixed coverage and per-run degradation metrics
+        // for the main health path (not just window-compare mode).
+        const until = new Date(now()).toISOString();
+        const totalAssetsMain = improveSummary.memorySummary.eligible + improveSummary.memorySummary.derived;
+        improveSummary.coverage = computeDenominatorFixedCoverage(db, totalAssetsMain, improveSummary.memorySummary.eligible, since, until);
+        const degradationMain = computeDegradationMetrics(db, since, until);
+        if (degradationMain) {
+            improveSummary.degradation = degradationMain;
+        }
+        improveSummary.enrichmentMinting = computeEnrichmentMintingRollup(db, since, until);
+        advisories.push(...collectImproveAdvisories(db, stateDbPath, since, improveSummary));
+        // 08-F1: surface a `stash-git-exposure` advisory when env/secret assets are
+        // git-tracked AND a remote is configured (the leak moment). Best-effort.
+        // Cheap guard: only shell out to git when the stash has its OWN `.git` (or a
+        // test injected a fake seam), so the hot path never spawns for a non-git
+        // stash — the common unit-test case. Trade-off: a stash manually pointed at a
+        // bare subdirectory of a parent git repo (no `.git` of its own) is not
+        // checked. akm-init always creates `.git` at the stash root, so any
+        // akm-initialised stash is covered; this only skips hand-pointed nested ones.
+        try {
+            const exposureStashDir = options.stashDir ?? resolveStashDir();
+            if (options.stashExposureGit || fs.existsSync(path.join(exposureStashDir, ".git"))) {
+                const stashExposure = collectStashExposureAdvisory(exposureStashDir, options.stashExposureGit);
+                if (stashExposure)
+                    advisories.push(stashExposure);
+            }
+        }
+        catch {
+            // Non-fatal — a git/probe failure must not abort the health report.
+        }
+        // 08 surfaces: the remaining read-only advisory group (secret-file-perms,
+        // binary-config-skew, orphan-stores, egress-endpoints). Best-effort — a
+        // filesystem probe failure must not abort the health report.
+        try {
+            advisories.push(...collectSurfacesAdvisories({
+                stashDir: options.stashDir ?? resolveStashDir(),
+                cacheDir: getCacheDir(),
+                dataDir: getDataDir(),
+                configDir: getConfigDir(),
+                configPath: getConfigPath(),
+                config: egressConfigView,
+            }));
+        }
+        catch {
+            // Non-fatal.
+        }
         let sessionLogEntries = [];
         try {
             const sinceDays = Math.max(0, Math.ceil((now() - new Date(since).getTime()) / (24 * 60 * 60 * 1000)));
@@ -1109,11 +203,14 @@ export function akmHealth(options = {}) {
             missingTables,
             probe,
             taskRowCount: taskRows.length,
+            taskFailRate,
             taskRowsWithLogsCount: taskRowsWithLogs.length,
             existingLogRowsCount: existingLogRows.length,
             logBackingRate,
             stuckActiveRuns,
             semanticStatus,
+            semanticSearchMode,
+            embeddingEndpoint,
             sessionLogEntries,
             sessionExtraction: improveSummary.sessionExtraction,
             autoAccept: improveSummary.autoAccept,
@@ -1213,102 +310,5 @@ export function akmHealth(options = {}) {
         }
     }
 }
-// ── Markdown renderers ───────────────────────────────────────────────────────
-function padRight(s, width) {
-    return s.length >= width ? s : s + " ".repeat(width - s.length);
-}
-function renderTable(headers, rows) {
-    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)));
-    const lines = [];
-    lines.push(headers.map((h, i) => padRight(h, widths[i] ?? 0)).join("  "));
-    for (const row of rows) {
-        lines.push(row.map((cell, i) => padRight(cell ?? "", widths[i] ?? 0)).join("  "));
-    }
-    return lines.join("\n");
-}
-/**
- * Render `--detail per-run` rows as a TSV-ish aligned table. The column
- * shape was originally inherited from the retired
- * `scripts/improve-stats/runs-detail` bash helper; keep the same shape
- * so operator muscle memory carries over.
- *
- * Columns: ts | ok | actions | refl_ok/fail/cd/skip |
- *   distill_q/llm-fail/qrej/cfg/skip | cons_proc/promo/merge/del |
- *   mem_cons/written/skip | graph_f/e/r | orphans | lint_f/fl
- */
-export function renderRunsDetailMd(runs) {
-    const headers = [
-        "ts",
-        "ok",
-        "actions",
-        "refl_ok/fail/cd/skip",
-        "distill_q/llm-fail/qrej/cfg/skip",
-        "cons_proc/promo/merge/del",
-        "mem_cons/written/skip",
-        "graph_f/e/r",
-        "orphans",
-        "lint_f/fl",
-    ];
-    const rows = runs.map((r) => {
-        const totalActions = r.actions.reflect.ok +
-            r.actions.reflect.failed +
-            r.actions.reflect.cooldown +
-            r.actions.reflect.skipped +
-            r.actions.distill.queued +
-            r.actions.distill.llmFailed +
-            r.actions.distill.qualityRejected +
-            r.actions.distill.configDisabled +
-            r.actions.distill.skipped +
-            r.actions.memoryPrune +
-            r.actions.memoryInference +
-            r.actions.graphExtraction +
-            r.actions.error;
-        return [
-            r.startedAt,
-            String(r.ok),
-            String(totalActions),
-            `${r.actions.reflect.ok}/${r.actions.reflect.failed}/${r.actions.reflect.cooldown}/${r.actions.reflect.skipped}`,
-            `${r.actions.distill.queued}/${r.actions.distill.llmFailed}/${r.actions.distill.qualityRejected}/${r.actions.distill.configDisabled}/${r.actions.distill.skipped}`,
-            `${r.consolidation.processed}/${r.consolidation.promoted}/${r.consolidation.merged}/${r.consolidation.deleted}`,
-            `${r.memoryInference.considered}/${r.memoryInference.written}/${r.memoryInference.skippedNoFacts}`,
-            `${r.graphExtraction.extractedFiles}/${r.graphExtraction.entities}/${r.graphExtraction.relations}`,
-            String(r.orphansPurged),
-            `${r.lintFixed}/${r.lintFlagged}`,
-        ];
-    });
-    return renderTable(headers, rows);
-}
-/**
- * Render a window-compare comparison as a side-by-side metric table with a
- * delta column. Bad-direction deltas (e.g. +pct on failed counts) get a `!`
- * marker prefix.
- */
-export function renderWindowCompareMd(windows, deltas) {
-    if (windows.length === 0)
-        return "";
-    const headers = ["metric", ...windows.map((w) => w.name), "delta"];
-    const badIfPositive = new Set([
-        "improve.actions.reflect.failed",
-        "improve.actions.distill.llmFailed",
-        "improve.graphExtraction.failures",
-        "improve.wallTime.medianMs",
-        "improve.wallTime.p95Ms",
-        "improve.memoryInference.skippedNoFacts",
-    ]);
-    const rows = [];
-    for (const path of INTERESTING_DELTA_PATHS) {
-        const values = windows.map((w) => String(readNumericPath(w, path)));
-        const delta = deltas?.[path];
-        let deltaStr = "—";
-        if (delta) {
-            const pct = delta.pctChange;
-            const num = typeof pct === "number" ? pct : pct;
-            const sign = typeof num === "number" && num > 0 ? "+" : "";
-            const formatted = typeof num === "number" ? `${sign}${num}%` : String(num);
-            const marker = badIfPositive.has(path) && typeof num === "number" && num > 0 ? "!" : "";
-            deltaStr = marker + formatted;
-        }
-        rows.push([path, ...values, deltaStr]);
-    }
-    return renderTable(headers, rows);
-}
+// Markdown renderers (renderRunsDetailMd / renderWindowCompareMd) live in
+// health/md-report.ts, mirroring the HTML extraction in health/html-report.ts.