akm-cli 0.9.0-beta.2 → 0.9.0-beta.27

package/dist/commands/health.js

@@ -4,12 +4,15 @@
 import fs from "node:fs";
 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 { listExistingTableNames, listProposalGateDecisions, listStateProposals, openStateDatabase, queryCompletedTaskIntervals, queryImproveRuns, queryTaskHistory, } 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 { HEALTH_CHECKS } from "./health/checks.js";
+import { gateDecisionsToSamples, summarizeCalibration } from "./improve/calibration.js";
 const DEFAULT_SINCE_MS = 24 * 60 * 60 * 1000;
 const IMPROVE_COMPLETED_EVENT = "improve_completed";
 const HEALTH_PROBE_EVENT = "health_probe";
@@ -70,6 +73,7 @@ function createUnknownImproveMetrics() {
             error: 0,
         },
         autoAccept: { promoted: 0, validationFailed: 0 },
+        calibration: summarizeCalibration([]),
         reflectsWithErrorContext: 0,
         coverageGapCount: 0,
         evalCasesWritten: 0,
@@ -153,6 +157,22 @@ function createUnknownImproveMetrics() {
                 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) {
@@ -361,6 +381,21 @@ function projectRunMetrics(result) {
                 }
             }
         }
+        // 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) {
@@ -471,7 +506,10 @@ function finalizeImproveMetrics(metrics) {
  */
 function mergeImproveMetrics(dst, src) {
     dst.plannedRefs += src.plannedRefs;
-    dst.profileFilteredRefs += src.profileFilteredRefs;
+    // 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;
@@ -504,8 +542,10 @@ function mergeImproveMetrics(dst, src) {
     dst.coverageGapCount += src.coverageGapCount;
     dst.evalCasesWritten += src.evalCasesWritten;
     dst.deadUrlCount += src.deadUrlCount;
-    dst.memorySummary.eligible += src.memorySummary.eligible;
-    dst.memorySummary.derived += src.memorySummary.derived;
+    // 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;
@@ -554,6 +594,18 @@ function mergeImproveMetrics(dst, src) {
     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();
@@ -566,6 +618,11 @@ function summarizeImproveRuns(db, since, until) {
         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 {
@@ -576,6 +633,12 @@ function summarizeImproveRuns(db, since, until) {
         }
         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`,
@@ -592,6 +655,9 @@ function summarizeImproveRuns(db, since, until) {
             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),
@@ -622,7 +688,7 @@ function summarizePhaseDurations(samples) {
  * Project an improve_runs row + wall-time lookup into a single ImproveRunSummary.
  * Used by `akm health --detail per-run`.
  */
-function projectImproveRunSummary(row, wallTimeMs) {
+function projectImproveRunSummary(row, wallTimeMs, taskId) {
     let result = {};
     try {
         result = JSON.parse(row.result_json);
@@ -646,6 +712,7 @@ function projectImproveRunSummary(row, wallTimeMs) {
             mode: row.scope_mode,
             ...(row.scope_value ? { value: row.scope_value } : {}),
         },
+        taskId,
         actions: perRow.actions,
         memorySummary: perRow.memorySummary,
         memoryCleanup: perRow.memoryCleanup,
@@ -708,9 +775,62 @@ function findContainingTaskInterval(timestampMs, intervals) {
     }
     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();
@@ -730,7 +850,8 @@ function buildPerRunSummaries(db, since, until) {
             const interval = Number.isFinite(startMs) ? findContainingTaskInterval(startMs, taskIntervals) : undefined;
             wallTimeMs = interval?.durationMs ?? 0;
         }
-        summaries.push(projectImproveRunSummary(row, wallTimeMs));
+        const taskId = matchImproveTaskId(row.started_at, row.completed_at, improveTaskRuns);
+        summaries.push(projectImproveRunSummary(row, wallTimeMs, taskId));
     }
     return summaries;
 }
@@ -757,12 +878,34 @@ function computeWallTimeStats(durationsMs, byPhase) {
     };
 }
 function buildImproveSkipSummary(events) {
-    const skipReasons = {};
+    // 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";
-        skipReasons[reason] = (skipReasons[reason] ?? 0) + 1;
+        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;
+        }
     }
-    return { skipped: events.length, skipReasons };
+    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;
@@ -882,14 +1025,275 @@ function computeDeltas(first, last) {
     }
     return out;
 }
-function buildWindowMetrics(db, stateDbPath, since, until, now = () => Date.now()) {
+/**
+ * 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 taskRowsWithLogs = taskRows.filter((row) => row.log_path !== null);
-    const existingLogRows = taskRowsWithLogs.filter((row) => row.log_path && fs.existsSync(row.log_path));
+    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;
@@ -917,12 +1321,24 @@ function buildWindowMetrics(db, stateDbPath, since, until, now = () => Date.now(
     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 };
 }
@@ -961,6 +1377,16 @@ export function akmHealth(options = {}) {
     catch (error) {
         throw new ConfigError(`Unable to open state.db: ${error instanceof Error ? error.message : String(error)}`, "INVALID_CONFIG_FILE");
     }
+    // logs.db backs the log-backing metric (#579). Best-effort: when it cannot
+    // be opened, partitionLogBackedRows falls back to the on-disk file check, so
+    // health never hard-fails on a missing/locked logs database.
+    let logsDb;
+    try {
+        logsDb = openLogsDatabase(options.logsDbPath);
+    }
+    catch {
+        logsDb = undefined;
+    }
     try {
         const tables = listExistingTableNames(db, ["events", "task_history", "proposals", "schema_migrations"]);
         const tableNames = tables.map((row) => row.name).sort();
@@ -968,8 +1394,7 @@ export function akmHealth(options = {}) {
         const missingTables = requiredTables.filter((name) => !tableNames.includes(name));
         const probe = probeStateDbRoundTrip(stateDbPath);
         const taskRows = queryTaskHistory(db, { since });
-        const taskRowsWithLogs = taskRows.filter((row) => row.log_path !== null);
-        const existingLogRows = taskRowsWithLogs.filter((row) => row.log_path && fs.existsSync(row.log_path));
+        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;
@@ -995,6 +1420,35 @@ 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;
+        }
+        // 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.",
+            });
+        }
         let sessionLogEntries = [];
         try {
             const sinceDays = Math.max(0, Math.ceil((now() - new Date(since).getTime()) / (24 * 60 * 60 * 1000)));
@@ -1041,6 +1495,7 @@ export function akmHealth(options = {}) {
             stuckActiveRuns,
             logBackingRate: roundRate(logBackingRate),
             probeRoundTripMs: probe.durationMs,
+            llmUsage: readLlmUsageAggregate(stateDbPath, since),
         };
         const hardFailure = hardChecks.some((check) => check.status === "fail");
         const deterministicWarnings = [...hardChecks, ...advisories].some((check) => check.status === "warn" && check.kind === "deterministic");
@@ -1062,7 +1517,7 @@ export function akmHealth(options = {}) {
             windowResults = windowSpecs.map((spec) => {
                 const winSince = parseHealthSince(spec.since);
                 const winUntil = spec.until ? parseHealthSince(spec.until) : new Date(now()).toISOString();
-                const bundle = buildWindowMetrics(db, stateDbPath, winSince, winUntil, now);
+                const bundle = buildWindowMetrics(db, stateDbPath, winSince, winUntil, now, logsDb);
                 return {
                     name: spec.name,
                     since: winSince,
@@ -1112,6 +1567,14 @@ export function akmHealth(options = {}) {
     }
     finally {
         db.close();
+        if (logsDb) {
+            try {
+                logsDb.close();
+            }
+            catch {
+                // best-effort
+            }
+        }
     }
 }
 // ── Markdown renderers ───────────────────────────────────────────────────────