akm-cli 0.9.0-beta.53 → 0.9.0-beta.55

package/dist/commands/health.js

@@ -1,23 +1,25 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // 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 { 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 { readEvents } from "../core/events.js";
+import { openLogsDatabase } from "../core/logs-db.js";
 import { getStateDbPathInDataDir } from "../core/paths.js";
-import { getLatestCycleMetrics, listExistingTableNames, listProposalGateDecisions, listStateProposals, openStateDatabase, queryCompletedTaskIntervals, queryImproveRuns, queryTaskHistory, } from "../core/state-db.js";
+import { listExistingTableNames, openStateDatabase } from "../core/state-db.js";
 import { 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 { gateDecisionsToSamples, summarizeCalibration } from "./improve/calibration.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 { 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();
@@ -35,1318 +37,6 @@ export function parseHealthSince(since) {
     }
     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 },
-        calibration: summarizeCalibration([]),
-        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,
-            nonArrayBatchFailures: 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 },
-            },
-        },
-        perfTelemetry: {
-            dedupPoolSize: 0,
-            llmPoolSize: 0,
-            judgedCacheSkipped: 0,
-            embedMs: 0,
-            embedCacheHits: 0,
-            embedCacheMisses: 0,
-            overBudgetRuns: 0,
-            runsWithTelemetry: 0,
-        },
-        coverage: {
-            rate: Number.NaN,
-            eligibleFraction: Number.NaN,
-            acceptedProposals: 0,
-            totalAssets: 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;
-                }
-            }
-        }
-        // WS-5: extract perf telemetry from the consolidation envelope.
-        // Pre-WS-5 envelopes lack `perfTelemetry`; be defensive.
-        const perf = consolidation.perfTelemetry;
-        if (perf) {
-            metrics.perfTelemetry.runsWithTelemetry += 1;
-            metrics.perfTelemetry.dedupPoolSize += toFiniteNumber(perf.dedupPoolSize);
-            metrics.perfTelemetry.llmPoolSize += toFiniteNumber(perf.llmPoolSize);
-            metrics.perfTelemetry.judgedCacheSkipped += toFiniteNumber(perf.judgedCacheSkipped);
-            metrics.perfTelemetry.embedMs += toFiniteNumber(perf.embedMs);
-            metrics.perfTelemetry.embedCacheHits += toFiniteNumber(perf.embedCacheHits);
-            metrics.perfTelemetry.embedCacheMisses += toFiniteNumber(perf.embedCacheMisses);
-            const budgetFrac = toFiniteNumber(perf.estimatedBudgetFractionUsed);
-            if (budgetFrac > 1.0)
-                metrics.perfTelemetry.overBudgetRuns += 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.nonArrayBatchFailures += toFiniteNumber(telemetry.nonArrayBatchFailures);
-        }
-    }
-    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;
-    // profileFilteredRefs is the count of refs the planner drops up-front for the
-    // active profile — recomputed against the (stable) stash every run, so it is a
-    // snapshot, NOT a per-run increment. Summing it re-counts the same refs each
-    // run (the ~2.4M bug). Set from the most recent run in summarizeImproveRuns.
-    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;
-    // NOTE: memorySummary (derived/eligible) is a WHOLE-STASH snapshot recorded on
-    // every run, NOT a per-run increment — summing it across the window inflates
-    // it ~N× (the 1.2M-eligible bug). It is set from the most recent run in
-    // summarizeImproveRuns instead, so it is intentionally not merged here.
-    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.nonArrayBatchFailures += src.graphExtraction.nonArrayBatchFailures;
-    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;
-    // WS-5: merge perf telemetry (additive sums).
-    dst.perfTelemetry.dedupPoolSize += src.perfTelemetry.dedupPoolSize;
-    dst.perfTelemetry.llmPoolSize += src.perfTelemetry.llmPoolSize;
-    dst.perfTelemetry.judgedCacheSkipped += src.perfTelemetry.judgedCacheSkipped;
-    dst.perfTelemetry.embedMs += src.perfTelemetry.embedMs;
-    dst.perfTelemetry.embedCacheHits += src.perfTelemetry.embedCacheHits;
-    dst.perfTelemetry.embedCacheMisses += src.perfTelemetry.embedCacheMisses;
-    dst.perfTelemetry.overBudgetRuns += src.perfTelemetry.overBudgetRuns;
-    dst.perfTelemetry.runsWithTelemetry += src.perfTelemetry.runsWithTelemetry;
-    // coverage: acceptedProposals is additive; totalAssets is a snapshot (like memorySummary).
-    // totalAssets is intentionally NOT merged here — set from the most recent run in summarizeImproveRuns.
-    dst.coverage.acceptedProposals += src.coverage.acceptedProposals;
-}
-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: [],
-    };
-    // memorySummary is a whole-stash snapshot per run, so the window value is the
-    // MOST RECENT run's snapshot (current state) — not a sum across runs.
-    let latestStartMs = Number.NEGATIVE_INFINITY;
-    let latestMemorySummary;
-    let latestProfileFilteredRefs = 0;
-    for (const row of rows) {
-        let result;
-        try {
-            result = JSON.parse(row.result_json);
-        }
-        catch {
-            continue;
-        }
-        const perRow = projectRunMetrics(result);
-        mergeImproveMetrics(accum, perRow);
-        const startMs = new Date(row.started_at).getTime();
-        if (Number.isFinite(startMs) && startMs >= latestStartMs) {
-            latestStartMs = startMs;
-            latestMemorySummary = perRow.memorySummary;
-            latestProfileFilteredRefs = perRow.profileFilteredRefs;
-        }
-        // 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);
-    if (latestMemorySummary)
-        accum.memorySummary = latestMemorySummary;
-    accum.profileFilteredRefs = latestProfileFilteredRefs;
-    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, taskId) {
-    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 } : {}),
-        },
-        taskId,
-        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;
-}
-/**
- * Load `task_history` rows whose `task_id` begins `akm-improve` (the scheduled
- * improve tasks: `akm-improve-frequent`, `akm-improve-proactive-weekly`, …) in
- * the window, widened ±5 min so a task that fired just before the window opened
- * still matches a run inside it. Used to attribute each improve run to the task
- * that launched it.
- */
-function loadImproveTaskRuns(db, since, until) {
-    const sinceMs = new Date(since).getTime();
-    const untilMs = until ? new Date(until).getTime() : undefined;
-    const widenedSince = new Date(sinceMs - 5 * 60 * 1000).toISOString();
-    const widenedUntil = untilMs !== undefined ? new Date(untilMs + 5 * 60 * 1000).toISOString() : undefined;
-    const runs = [];
-    for (const row of queryTaskHistory(db, { since: widenedSince, until: widenedUntil })) {
-        if (!row.task_id.startsWith("akm-improve"))
-            continue;
-        const startMs = new Date(row.started_at).getTime();
-        if (!Number.isFinite(startMs))
-            continue;
-        const endIso = row.completed_at ?? row.failed_at;
-        const endMs = endIso ? new Date(endIso).getTime() : Number.NaN;
-        runs.push({ taskId: row.task_id, startMs, endMs });
-    }
-    return runs;
-}
-/**
- * Attribute an improve run to the scheduled task that launched it by matching
- * start times within ±5 min, scored by start delta (plus end delta when both
- * ends are known). Port of the health-report skill's `match_task_id`. Returns
- * `"manual"` when no scheduled improve task matches.
- */
-function matchImproveTaskId(startedAt, completedAt, taskRuns) {
-    const startMs = new Date(startedAt).getTime();
-    if (!Number.isFinite(startMs))
-        return "manual";
-    const endMs = completedAt ? new Date(completedAt).getTime() : Number.NaN;
-    let best;
-    let bestScore = Number.POSITIVE_INFINITY;
-    for (const task of taskRuns) {
-        const startDelta = Math.abs(task.startMs - startMs);
-        if (startDelta > 5 * 60 * 1000)
-            continue;
-        let score = startDelta;
-        if (Number.isFinite(endMs) && Number.isFinite(task.endMs))
-            score += Math.abs(task.endMs - endMs);
-        if (score < bestScore) {
-            bestScore = score;
-            best = task.taskId;
-        }
-    }
-    return best ?? "manual";
-}
-function buildPerRunSummaries(db, since, until) {
-    const rows = queryImproveRuns(db, since, until);
-    const taskIntervals = loadTaskIntervals(db, since, until);
-    const improveTaskRuns = loadImproveTaskRuns(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;
-        }
-        const taskId = matchImproveTaskId(row.started_at, row.completed_at, improveTaskRuns);
-        summaries.push(projectImproveRunSummary(row, wallTimeMs, taskId));
-    }
-    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) {
-    // Two kinds of skip events:
-    //  - Per-occurrence (no `count`): one event per skipped ref → SUM is correct.
-    //  - Aggregated snapshot (carries `count`): a single per-run event whose count
-    //    is the number of refs that hit a STABLE, whole-stash condition that run
-    //    (`no_new_signal`, `profile_filtered_all_passes`). Each run re-counts the
-    //    same stable set, so summing across the window re-counts it N times (the
-    //    2.7M / 3M inflation). For these we keep the MOST RECENT run's count — the
-    //    current snapshot — matching how memorySummary/profileFilteredRefs are
-    //    handled. Events arrive in chronological (offset) order, so the last
-    //    count-bearing event per reason is the latest run's value.
-    const summed = {};
-    const latestSnapshot = {};
-    for (const event of events) {
-        const reason = typeof event.metadata?.reason === "string" && event.metadata.reason.trim() ? event.metadata.reason : "unknown";
-        const rawCount = event.metadata?.count;
-        if (typeof rawCount === "number" && Number.isFinite(rawCount) && rawCount > 0) {
-            latestSnapshot[reason] = rawCount; // overwrite → keeps the latest run's snapshot
-        }
-        else {
-            summed[reason] = (summed[reason] ?? 0) + 1;
-        }
-    }
-    const skipReasons = { ...summed };
-    for (const [reason, count] of Object.entries(latestSnapshot)) {
-        skipReasons[reason] = (skipReasons[reason] ?? 0) + count;
-    }
-    const skipped = Object.values(skipReasons).reduce((a, b) => a + b, 0);
-    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.graphExtraction.nonArrayBatchFailures",
-    "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);
-}
-/**
- * Read the auto-accept gate calibration summary (#612) over `[since, until)`.
- * Reads every proposal's `gateDecision` from the open state.db, projects the
- * acted-on (auto-accepted / auto-rejected) decisions into calibration samples
- * within the window, and aggregates them deterministically.
- */
-function readCalibration(db, since, until) {
-    const decisions = listProposalGateDecisions(db);
-    const samples = gateDecisionsToSamples(decisions, { since, ...(until !== undefined ? { until } : {}) });
-    return summarizeCalibration(samples);
-}
-// ── WS-5 Observability helpers ───────────────────────────────────────────────
-/**
- * Compute WS-5 denominator-fixed coverage metrics.
- *
- * `coverage = accepted_proposals / total_assets` (Part V §3).
- * The denominator is the TOTAL stash size (not the moving eligible set) so
- * more-inclusive WS-1 ranking cannot spuriously inflate coverage.
- * `eligibleFraction = eligible_assets / total_assets` is reported separately.
- *
- * Proposals are counted only when their `updatedAt` falls within `[since, until)`
- * so the rate is genuinely window-scoped (matching the JSDoc on the type).
- *
- * @param db - Open state.db connection.
- * @param totalAssets - Total stash asset count (eligible + derived) from the
- *   most recent run's memorySummary. 0 = denominator unknown, returns NaN rates.
- * @param eligibleAssets - Eligible (non-derived) asset count from the most recent run.
- * @param since - Window start (ISO-8601). Proposals accepted before this are excluded.
- * @param until - Window end (ISO-8601, exclusive). Absent = open-ended (up to now).
- * @param stashDir - Optional: scope accepted proposals to one stash. Absent = all stashes.
- */
-function computeDenominatorFixedCoverage(db, totalAssets, eligibleAssets, since, until, stashDir) {
-    let acceptedProposals = 0;
-    try {
-        const proposals = listStateProposals(db, {
-            status: "accepted",
-            ...(stashDir ? { stashDir } : {}),
-        }).filter((p) => {
-            const updatedAt = p.updatedAt ?? "";
-            if (updatedAt < since)
-                return false;
-            if (until !== undefined && updatedAt >= until)
-                return false;
-            return true;
-        });
-        acceptedProposals = proposals.length;
-    }
-    catch {
-        // Fail open: table may not exist on older installs.
-    }
-    if (totalAssets === 0) {
-        return {
-            rate: Number.NaN,
-            eligibleFraction: Number.NaN,
-            acceptedProposals,
-            totalAssets: 0,
-        };
-    }
-    return {
-        rate: roundRate(acceptedProposals / totalAssets),
-        eligibleFraction: roundRate(eligibleAssets / totalAssets),
-        acceptedProposals,
-        totalAssets,
-    };
-}
-/**
- * Compute WS-5 per-run degradation metrics (Part V §4).
- *
- * Health VIEWS only — reads from state.db tables populated by prior improve
- * runs. Gracefully returns partial data when tables are absent (pre-WS-1/2).
- *
- * @param db - Open state.db connection.
- * @param since - Window start (ISO-8601).
- * @param until - Window end (ISO-8601).
- */
-function computeDegradationMetrics(db, since, until) {
-    // (a) Corpus diversity — salience rank distribution of the top-100 assets.
-    // We use the Gini coefficient of retrieval_salience scores as an intra-corpus
-    // diversity proxy. A Gini close to 1 = highly concentrated (entrenched top
-    // assets), Gini near 0 = flat/diverse. This is a single-snapshot metric;
-    // consecutive-run centroid distance requires cross-run history not yet stored.
-    let corpusCentroidDistance = Number.NaN;
-    let entrenchmentFlagged;
-    try {
-        const rows = db
-            .prepare(`SELECT retrieval_salience FROM asset_salience
-         ORDER BY rank_score DESC LIMIT 100`)
-            .all();
-        if (rows.length >= 5) {
-            const vals = rows.map((r) => r.retrieval_salience).sort((a, b) => a - b);
-            const n = vals.length;
-            const sumAbsDiff = vals.reduce((acc, xi, i) => {
-                return acc + vals.slice(i + 1).reduce((a, xj) => a + Math.abs(xi - xj), 0);
-            }, 0);
-            const mean = vals.reduce((a, b) => a + b, 0) / n;
-            // Gini = (sum |xi - xj|) / (2 n^2 mean); 0 = perfect equality, 1 = perfect inequality.
-            const gini = mean > 0 ? sumAbsDiff / (2 * n * n * mean) : 0;
-            // Re-express as a diversity proxy in [0,1]: high gini = low diversity.
-            // corpusCentroidDistance approximation: gini is "distance from uniform".
-            // Note: retrieval_salience values are in [0,1], so the max achievable Gini
-            // with this formula is ~0.5 (when one asset dominates and others are near 0).
-            // Threshold: >0.35 flags entrenchment (robustly above the ~0.1 uniform baseline).
-            corpusCentroidDistance = roundRate(gini);
-            entrenchmentFlagged = gini > 0.35;
-        }
-    }
-    catch {
-        // Table not present (pre-WS-1 install) — leave NaN.
-    }
-    // (b) Merge fidelity — fraction of consolidate accepted proposals in the window
-    // whose ref also has a consolidate skip-reason of "contradict_target_missing"
-    // or an event indicating contradiction. Uses the improve_runs result_json
-    // consolidation.contradicted count as a proxy.
-    // Simple implementation: contradictionRate = total_contradicted / max(1, total_processed)
-    // sourced from the window's consolidation envelope.
-    // (The full "merge proposal → later contradiction" correlation requires cross-run
-    // history; this is the available proxy.)
-    let mergeFidelityContradictionRate = 0;
-    try {
-        const runs = queryImproveRuns(db, since, until);
-        let totalContradicted = 0;
-        let totalProcessed = 0;
-        for (const row of runs) {
-            try {
-                const result = JSON.parse(row.result_json);
-                const cons = result.consolidation;
-                if (cons) {
-                    totalContradicted += toFiniteNumber(cons.contradicted);
-                    totalProcessed += toFiniteNumber(cons.processed);
-                }
-            }
-            catch {
-                // Skip malformed rows.
-            }
-        }
-        if (totalProcessed > 0) {
-            mergeFidelityContradictionRate = roundRate(totalContradicted / totalProcessed);
-        }
-    }
-    catch {
-        // Fail open.
-    }
-    // (c) Generation distribution — fraction of asset_salience rows with
-    // generation >= 2. Generation is NOT currently stored in asset_salience
-    // (it's in frontmatter). We approximate using consecutive_no_ops as a
-    // maturity proxy: assets that have never been no-op'd are "fresh".
-    // TODO(0.10+): store generation in asset_salience for proper tracking.
-    let highGenerationFraction = Number.NaN;
-    try {
-        const genRows = db.prepare("SELECT consecutive_no_ops FROM asset_salience").all();
-        if (genRows.length > 0) {
-            // Use consecutive_no_ops >= 2 as a proxy for "has been through merge cycles".
-            const highGen = genRows.filter((r) => r.consecutive_no_ops >= 2).length;
-            highGenerationFraction = roundRate(highGen / genRows.length);
-        }
-    }
-    catch {
-        // Table not present.
-    }
-    // (d) Oracle spot-check — up to 5 recently accepted proposals in the window.
-    const oracleSpotCheck = [];
-    try {
-        const accepted = listStateProposals(db, { status: "accepted" }).filter((p) => {
-            const updatedAt = p.updatedAt ?? "";
-            return updatedAt >= since && updatedAt < until;
-        });
-        // Sample up to 5: pick evenly spaced (not just the first 5).
-        const step = Math.max(1, Math.floor(accepted.length / 5));
-        for (let i = 0; i < accepted.length && oracleSpotCheck.length < 5; i += step) {
-            const p = accepted[i];
-            if (p) {
-                oracleSpotCheck.push({
-                    proposalId: p.id,
-                    ref: p.ref,
-                    source: p.source ?? "unknown",
-                    acceptedAt: p.updatedAt ?? p.createdAt ?? "",
-                });
-            }
-        }
-    }
-    catch {
-        // Fail open.
-    }
-    return {
-        corpusCentroidDistance,
-        entrenchmentFlagged,
-        mergeFidelityContradictionRate,
-        highGenerationFraction,
-        oracleSpotCheck,
-    };
-}
-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);
-    improveSummary.calibration = readCalibration(db, since, until);
-    // WS-5: Compute denominator-fixed coverage from the most recent run's
-    // memorySummary (totalAssets = eligible + derived — the fixed denominator).
-    const totalAssets = improveSummary.memorySummary.eligible + improveSummary.memorySummary.derived;
-    improveSummary.coverage = computeDenominatorFixedCoverage(db, totalAssets, improveSummary.memorySummary.eligible, since, until);
-    // WS-5: Compute per-run degradation metrics (corpus diversity, merge fidelity,
-    // generation distribution, oracle spot-check). Health VIEWS only.
-    const degradation = computeDegradationMetrics(db, since, until);
-    if (degradation) {
-        improveSummary.degradation = degradation;
-    }
-    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");
@@ -1447,77 +137,8 @@ export function akmHealth(options = {}) {
         if (degradationMain) {
             improveSummary.degradation = degradationMain;
         }
-        // WS-2 proxy-adequacy tripwire: surface any outcome_proxy_inverted events
-        // in the health window as an advisory so operators know when the 0.10+
-        // rich in-session signal is no longer deferrable.
-        const proxyInvertedEvents = readEvents({ since, type: "outcome_proxy_inverted" }, { dbPath: stateDbPath }).events;
-        if (proxyInvertedEvents.length > 0) {
-            const lastEvent = proxyInvertedEvents[proxyInvertedEvents.length - 1];
-            const correlation = typeof lastEvent.metadata?.correlation === "number" ? lastEvent.metadata.correlation.toFixed(3) : "unknown";
-            advisories.push({
-                name: "outcome-proxy-adequacy",
-                status: "warn",
-                kind: "deterministic",
-                confidence: "high",
-                message: `WS-2 outcome proxy inverted (${proxyInvertedEvents.length} event(s) in window). ` +
-                    `corr(outcome_score, accepted_change_rate) = ${correlation} < −0.3. ` +
-                    "Popular assets are also the most-needing-improvement assets — " +
-                    "the retrieval-based proxy is inverted. " +
-                    "The 0.10+ rich in-session outcome signal is no longer deferrable. See plan §WS-2.",
-            });
-        }
-        // R5 collapse/churn detector: surface any collapse_detector_alert events
-        // in the health window, plus the latest cycle row's headline numbers so
-        // the operator can act without opening the DB. `unknown` when the detector
-        // has never produced a cycle row (no consolidate/recombine work yet).
-        try {
-            // Reuse the already-open state.db handle (readEvents supports a
-            // borrowed connection) — no extra open/migrate/close per health call.
-            const collapseAlertEvents = readEvents({ since, type: "collapse_detector_alert" }, { dbPath: stateDbPath, db }).events;
-            const latestCycle = getLatestCycleMetrics(db);
-            const cycleSummary = latestCycle
-                ? `Latest cycle (${latestCycle.ts}, ${latestCycle.pass}): mean canary recall ${latestCycle.mean_recall.toFixed(3)}, ` +
-                    `distinct-content ratio ${latestCycle.distinct_content_ratio.toFixed(3)}, ` +
-                    `${latestCycle.accepted_actions} accepted action(s).`
-                : "";
-            if (collapseAlertEvents.length > 0) {
-                const kinds = [...new Set(collapseAlertEvents.map((e) => String(e.metadata?.kind ?? "unknown")))];
-                const collapseKinds = kinds.filter((k) => k.startsWith("collapse"));
-                advisories.push({
-                    name: "collapse-churn-detector",
-                    status: "warn",
-                    kind: "deterministic",
-                    // Collapse kinds are measured, not inferred; churn/merge-floor
-                    // volume thresholds are still being tuned (design doc §7).
-                    confidence: collapseKinds.length > 0 ? "high" : "medium",
-                    message: `R5 detector fired ${collapseAlertEvents.length} alert(s) in window (kinds: ${kinds.join(", ")}). ` +
-                        `${cycleSummary} See docs/design/improve-collapse-churn-detector-design.md §6.3 runbook queries.`,
-                });
-            }
-            else if (latestCycle) {
-                advisories.push({
-                    name: "collapse-churn-detector",
-                    status: "pass",
-                    kind: "deterministic",
-                    confidence: "high",
-                    message: `No collapse/churn alerts in window. ${cycleSummary}`,
-                });
-            }
-            else {
-                advisories.push({
-                    name: "collapse-churn-detector",
-                    status: "unknown",
-                    kind: "deterministic",
-                    confidence: "high",
-                    message: "No detector cycle rows yet — the collapse/churn detector runs only on improve cycles " +
-                        "where consolidate/recombine did work (synthesis lanes may be idle).",
-                });
-            }
-        }
-        catch {
-            // Table may predate migration 016 in odd mixed-version setups — advisory
-            // is best-effort and must never fail the health command.
-        }
+        improveSummary.enrichmentMinting = computeEnrichmentMintingRollup(db, since, until);
+        advisories.push(...collectImproveAdvisories(db, stateDbPath, since, improveSummary));
         let sessionLogEntries = [];
         try {
             const sinceDays = Math.max(0, Math.ceil((now() - new Date(since).getTime()) / (24 * 60 * 60 * 1000)));
@@ -1648,103 +269,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.graphExtraction.nonArrayBatchFailures",
-        "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.