akm-cli 0.9.0-rc.8 → 0.9.0

package/dist/commands/health/html-report.js

@@ -24,9 +24,7 @@
  * `~1MB` `echarts.min.js` self-contained/"inline" mode was removed along with
  * the asset itself — `buildEchartsTag` always emits a `<script src>` tag
  * pointed at the jsDelivr CDN, so viewing the report now requires network
- * access. BEHAVIOR CHANGE (plan-accepted, ledgered): previously
- * `AKM_ECHARTS=cdn` opted IN to the CDN with "inline" as the default; there is
- * no more env var or option to opt back into an offline report.
+ * access. There is no env var or option to opt back into an offline report.
  */
 import { escapeHtml } from "../../output/html-render.js";
 import { pkgVersion } from "../../version.js";
@@ -158,10 +156,9 @@ function renderExecSummary(vm) {
         : '<li><span class="k">No runs in window</span><span class="v">—</span></li>';
     const windowRows = [
         li("Report window", esc(vm.window)),
-        li("Compare window", esc(vm.compare)),
+        li(vm.comparisonMode === "custom" ? "Comparison windows" : "Compare window", esc(vm.compare)),
         li("Runs", `${num(vm.totalRuns)} (${vm.failedRuns} failed)`),
         li("Included result rows", num(vm.includedResultRows)),
-        li("Normalized result rows", num(vm.normalizedResultRows)),
         li("Invalid result rows skipped", num(vm.skippedInvalidResultRows)),
         li("Stash derived", `<abbr title="Whole-stash recount of derived assets at report time — not a per-run sum.">${num(vm.memorySummary.derived)}</abbr>`),
         li("Stash eligible", `<abbr title="Whole-stash recount of eligible assets at report time — not a per-run sum.">${num(vm.memorySummary.eligible)}</abbr>`),
@@ -185,7 +182,7 @@ function renderExecSummary(vm) {
         <ul>${quickNumbers}</ul>
       </div>
       <div>
-        <h4>Trend vs prior ${esc(vm.compare)}</h4>
+        <h4>${vm.comparisonMode === "custom" ? `Trend: ${esc(vm.compare)}` : `Trend vs prior ${esc(vm.compare)}`}</h4>
         <ul>${trendRows}</ul>
         <h4 style="margin-top:14px;">Period-over-period deltas</h4>
         <ul>${deltaRows}</ul>
@@ -200,7 +197,7 @@ function renderExecSummary(vm) {
       </div>
     </div>
     <div class="overall">Overall trend: <b>${esc(vm.trend.overall)}</b> ${overallEmoji}
-      &nbsp;·&nbsp; based on decision quality, output volume, failures, and latency vs the prior window.</div>`.trim();
+      &nbsp;·&nbsp; based on decision quality, output volume, failures, and latency ${vm.comparisonMode === "custom" ? "across the selected windows" : "vs the prior window"}.</div>`.trim();
 }
 /**
  * Color is a health SIGNAL, not decoration: green/yellow/red where a card has
@@ -297,7 +294,7 @@ function renderActionItems(vm) {
             cls: "warn",
             title: "Semantic search blocked",
             descHtml: `Embedding provider unreachable. ${esc(vm.sem.detail)}. Curate falls back to keyword search — relevance scoring degraded.`,
-            remedy: "akm config show",
+            remedy: "akm config list",
         });
     }
     // Pending proposals to drain.
@@ -368,8 +365,8 @@ function renderActionItems(vm) {
             cls: "warn",
             title: `${vm.perf.overBudgetRuns} consolidation run${vm.perf.overBudgetRuns === 1 ? "" : "s"} exceeded budget`,
             descHtml: "Consolidation phase wall time exceeded the total run budget on these runs. " +
-                "Consider increasing the timeout or reducing the consolidation pool via profile config.",
-            remedy: "akm config show",
+                "Consider increasing the timeout or reducing the consolidation pool via strategy config.",
+            remedy: "akm config list",
         });
     }
     // Session-log notes (informational, lowest priority).

package/dist/commands/health/improve-metrics.js

@@ -12,10 +12,7 @@ export function parseTaskMetadata(row) {
     return {
         ...(metadata.durationMs !== undefined ? { durationMs: metadata.durationMs } : {}),
         ...(metadata.detail ? { detail: metadata.detail } : {}),
-        ...(metadata.metadataVersion === 2 && metadata.engine !== undefined ? { engine: metadata.engine } : {}),
-        ...(metadata.metadataVersion === 1 && metadata.legacyProfile !== undefined
-            ? { legacyProfile: metadata.legacyProfile }
-            : {}),
+        ...(metadata.engine !== undefined ? { engine: metadata.engine } : {}),
     };
 }
 function createUnknownImproveMetrics() {
@@ -24,7 +21,7 @@ function createUnknownImproveMetrics() {
         completed: 0,
         skipped: 0,
         skipReasons: {},
-        resultRows: { total: 0, included: 0, normalized: 0, skipped: { invalid: 0 } },
+        resultRows: { total: 0, included: 0, skipped: { invalid: 0 } },
         plannedRefs: 0,
         strategyFilteredRefs: 0,
         actions: {
@@ -32,7 +29,6 @@ function createUnknownImproveMetrics() {
             distill: {
                 queued: 0,
                 llmFailed: 0,
-                qualityRejected: 0,
                 judgeRejected: 0,
                 validatorRejected: 0,
                 configDisabled: 0,
@@ -88,18 +84,16 @@ function createUnknownImproveMetrics() {
             skippedAborted: 0,
             unaccounted: 0,
             htmlErrorCount: 0,
-            yieldEligibleRuns: 0,
-            yieldEligibleConsidered: 0,
-            yieldEligibleWritten: 0,
             yieldRate: 0,
             durationMs: 0,
-            writes: 0,
         },
         graphExtraction: {
             ran: false,
             extractedFiles: 0,
+            consideredFiles: 0,
             entities: 0,
             relations: 0,
+            extractionCoverage: 0,
             cacheHits: 0,
             cacheMisses: 0,
             cacheHitRate: 0,
@@ -174,29 +168,11 @@ export function summarizeImproveCompleted(events) {
     return metrics;
 }
 /**
- * Bucket a distill `outcome: "skipped"` result into a low-cardinality reason.
- * Prefers an explicit `skipReason`; otherwise sniffs the message. The WI-6.4
- * fingerprint/backoff vocabulary is checked before the legacy patterns, which
- * stay for historical improve_runs rows.
+ * Read the machine-readable reason from a distill `outcome: "skipped"` result.
  */
 function classifyDistillSkipReason(r) {
     const explicitReason = typeof r?.skipReason === "string" ? r.skipReason : undefined;
-    if (explicitReason)
-        return explicitReason;
-    const msg = typeof r?.message === "string" ? r.message : "";
-    if (/lesson inputs/i.test(msg))
-        return "recursive_lesson_input";
-    if (/NOOP/.test(msg))
-        return "conflict_noop";
-    if (/fingerprint/i.test(msg))
-        return "fingerprint_match";
-    if (/rejection backoff/i.test(msg))
-        return "rejection_backoff";
-    if (/cooldown/i.test(msg))
-        return "proposal_cooldown";
-    if (/content[_ ]?hash/i.test(msg))
-        return "content_hash_match";
-    return "unknown";
+    return explicitReason || "unknown";
 }
 // ── projectRunMetrics phase helpers (chunk-9 WI-9.5c; file-level decompose of
 // the single-envelope projection — each helper mutates its own disjoint
@@ -211,9 +187,7 @@ function applyPlannedRefs(metrics, result) {
     // strategyFilteredRefs (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.
-    // Health v3 reports strategy metrics only. Historical v1 profile filtering
-    // remains legacy data and must not be silently relabelled as a strategy metric.
-    const strategyFilteredRefs = result.schemaVersion === 2 ? result.strategyFilteredRefs : undefined;
+    const strategyFilteredRefs = result.strategyFilteredRefs;
     if (Array.isArray(strategyFilteredRefs))
         metrics.strategyFilteredRefs += strategyFilteredRefs.length;
 }
@@ -252,11 +226,9 @@ function applyAction(metrics, action) {
                     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":
@@ -282,13 +254,6 @@ function applyAction(metrics, action) {
             }
             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;
@@ -313,12 +278,8 @@ function applyActionsList(metrics, result) {
     }
 }
 /**
- * C1 (13-bus-factor): new runs persist the bounded `distillSkipped` aggregate
- * instead of per-ref `distill-skipped` rows. Read the total + per-reason
- * histogram from it into the SAME `distill.skipped` / `skippedByReason`
- * metric the per-ref loop above populated. Legacy rows carry the per-ref rows
- * and NO aggregate (counted above); new rows carry the aggregate and NO
- * per-ref rows (counted here) — so a run is never double-counted.
+ * Read the bounded `distillSkipped` aggregate into the corresponding total and
+ * per-reason health metrics.
  */
 function applyDistillSkippedAggregate(metrics, result) {
     const distillSkipped = result.distillSkipped;
@@ -437,18 +398,6 @@ function applyMemoryInference(metrics, result) {
         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);
 }
@@ -456,8 +405,10 @@ function applyGraphExtraction(metrics, result) {
     const graphExtraction = result.graphExtraction;
     if (graphExtraction) {
         const quality = graphExtraction.quality;
-        if (quality)
+        if (quality) {
             metrics.graphExtraction.extractedFiles += toFiniteNumber(quality.extractedFiles);
+            metrics.graphExtraction.consideredFiles += toFiniteNumber(quality.consideredFiles);
+        }
         metrics.graphExtraction.entities += toFiniteNumber(graphExtraction.totalEntities);
         metrics.graphExtraction.relations += toFiniteNumber(graphExtraction.totalRelations);
         const telemetry = graphExtraction.telemetry;
@@ -526,19 +477,11 @@ function finalizeImproveMetrics(metrics) {
         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);
+    // Yield denominator excludes cache hits and aborted records.
+    metrics.memoryInference.freshAttempts = Math.max(0, metrics.memoryInference.considered - metrics.memoryInference.cacheHits - metrics.memoryInference.skippedAborted);
     metrics.memoryInference.yieldRate =
         metrics.memoryInference.freshAttempts > 0
-            ? roundRate(metrics.memoryInference.yieldEligibleWritten / metrics.memoryInference.freshAttempts)
+            ? roundRate(metrics.memoryInference.written / metrics.memoryInference.freshAttempts)
             : 0;
     metrics.graphExtraction.ran =
         metrics.graphExtraction.extractedFiles > 0 ||
@@ -546,6 +489,10 @@ function finalizeImproveMetrics(metrics) {
             metrics.graphExtraction.durationMs > 0;
     const cacheTotal = metrics.graphExtraction.cacheHits + metrics.graphExtraction.cacheMisses;
     metrics.graphExtraction.cacheHitRate = cacheTotal > 0 ? roundRate(metrics.graphExtraction.cacheHits / cacheTotal) : 0;
+    metrics.graphExtraction.extractionCoverage =
+        metrics.graphExtraction.consideredFiles > 0
+            ? roundRate(metrics.graphExtraction.extractedFiles / metrics.graphExtraction.consideredFiles)
+            : 0;
     metrics.sessionExtraction.ran =
         metrics.sessionExtraction.sessionsScanned > 0 ||
             metrics.sessionExtraction.proposalsCreated > 0 ||
@@ -571,7 +518,6 @@ function mergeImproveMetrics(dst, src) {
     }
     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;
@@ -626,11 +572,10 @@ function mergeImproveMetrics(dst, src) {
     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.retryAttempts += src.memoryInference.retryAttempts;
     dst.memoryInference.durationMs += src.memoryInference.durationMs;
     dst.graphExtraction.extractedFiles += src.graphExtraction.extractedFiles;
+    dst.graphExtraction.consideredFiles += src.graphExtraction.consideredFiles;
     dst.graphExtraction.entities += src.graphExtraction.entities;
     dst.graphExtraction.relations += src.graphExtraction.relations;
     dst.graphExtraction.cacheHits += src.graphExtraction.cacheHits;
@@ -639,6 +584,7 @@ function mergeImproveMetrics(dst, src) {
     dst.graphExtraction.failures += src.graphExtraction.failures;
     dst.graphExtraction.htmlErrors += src.graphExtraction.htmlErrors;
     dst.graphExtraction.nonArrayBatchFailures += src.graphExtraction.nonArrayBatchFailures;
+    dst.graphExtraction.retryAttempts += src.graphExtraction.retryAttempts;
     dst.graphExtraction.durationMs += src.graphExtraction.durationMs;
     dst.sessionExtraction.sessionsScanned += src.sessionExtraction.sessionsScanned;
     dst.sessionExtraction.sessionsExtracted += src.sessionExtraction.sessionsExtracted;
@@ -662,7 +608,7 @@ function compareImproveRunRecency(a, b) {
     const started = a.started_at.localeCompare(b.started_at);
     if (started !== 0)
         return started;
-    const completed = (a.completed_at ?? "").localeCompare(b.completed_at ?? "");
+    const completed = a.completed_at.localeCompare(b.completed_at);
     if (completed !== 0)
         return completed;
     return a.id.localeCompare(b.id);
@@ -696,14 +642,11 @@ export function summarizeImproveRuns(db, since, until) {
             continue;
         }
         accum.resultRows.included += 1;
-        if (decoded.normalizedLegacyPartial)
-            accum.resultRows.normalized += 1;
         const result = decoded.envelope;
         const perRow = projectRunMetrics(result);
         mergeImproveMetrics(accum, perRow);
         const startMs = new Date(row.started_at).getTime();
-        if (!decoded.normalizedLegacyPartial &&
-            result.terminated === undefined &&
+        if (result.terminated === undefined &&
             Number.isFinite(startMs) &&
             (latestCompleteRow === undefined || compareImproveRunRecency(row, latestCompleteRow) > 0)) {
             latestCompleteRow = row;
@@ -765,7 +708,7 @@ export function projectImproveRunSummary(row, wallTimeMs, taskId) {
     try {
         const decoded = decodeImproveResult(row.result_json);
         result = decoded.envelope;
-        resultStatus = decoded.normalizedLegacyPartial ? "normalized" : "valid";
+        resultStatus = "valid";
     }
     catch {
         // Keep the persisted row visible in per-run output, but do not project its
@@ -787,7 +730,6 @@ export function projectImproveRunSummary(row, wallTimeMs, taskId) {
         resultStatus,
         resultComplete: resultStatus === "valid" && result.terminated === undefined,
         strategy: row.strategy,
-        legacyProfile: row.legacyProfile,
         scope: {
             mode: row.scope_mode,
             ...(row.scope_value ? { value: row.scope_value } : {}),

package/dist/commands/health/md-report.js

@@ -16,9 +16,7 @@ function renderTable(headers, rows) {
 }
 /**
  * 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.
+ * shape is stable so repeated operator reports remain easy to compare.
  *
  * Columns: ts | ok | actions | refl_ok/fail/cd/skip |
  *   distill_q/llm-fail/qrej/cfg/skip | cons_proc/promo/merge/del |
@@ -29,10 +27,9 @@ export function renderRunsDetailMd(runs) {
         "ts",
         "ok",
         "strategy",
-        "legacy_profile",
         "actions",
         "refl_ok/fail/cd/skip",
-        "distill_q/llm-fail/qrej/cfg/skip",
+        "distill_q/llm-fail/judge/validator/cfg/skip",
         "cons_proc/promo/merge/del",
         "mem_cons/written/skip",
         "graph_f/e/r",
@@ -47,7 +44,8 @@ export function renderRunsDetailMd(runs) {
             r.actions.reflect.skipped +
             r.actions.distill.queued +
             r.actions.distill.llmFailed +
-            r.actions.distill.qualityRejected +
+            r.actions.distill.judgeRejected +
+            r.actions.distill.validatorRejected +
             r.actions.distill.configDisabled +
             r.actions.distill.skipped +
             r.actions.memoryPrune +
@@ -58,10 +56,9 @@ export function renderRunsDetailMd(runs) {
             r.startedAt,
             String(r.ok),
             r.strategy ?? "",
-            r.legacyProfile ?? "",
             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.actions.distill.queued}/${r.actions.distill.llmFailed}/${r.actions.distill.judgeRejected}/${r.actions.distill.validatorRejected}/${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}`,
@@ -94,7 +91,6 @@ export function renderWindowCompareMd(windows, deltas) {
     const paths = [
         "runs",
         "improve.resultRows.included",
-        "improve.resultRows.normalized",
         "improve.resultRows.skipped.invalid",
         ...INTERESTING_DELTA_PATHS,
     ];

package/dist/commands/health/metrics.js

@@ -6,28 +6,71 @@
  * denominator-fixed coverage, the enrichment-vs-minting rollup, and the WS-5
  * per-run degradation metrics.
  */
-import { appendEvent, readEvents } from "../../core/events.js";
+import { rethrowIfTestIsolationError } from "../../core/errors.js";
 import { decodeImproveResult } from "../../core/improve-result.js";
+import { withStateDb } from "../../core/state-db.js";
+import { insertEvent } from "../../storage/repositories/events-repository.js";
 import { queryImproveRuns } from "../../storage/repositories/improve-runs-repository.js";
 import { listStateProposals } from "../../storage/repositories/proposals-repository.js";
+import { getTopRetrievalSalience } from "../../storage/repositories/salience-repository.js";
 import { roundRate, toFiniteNumber } from "./improve-metrics.js";
 import { ENRICHMENT_LANES, } from "./types.js";
 /** Event type appended + read back by the state.db round-trip probe. */
 const HEALTH_PROBE_EVENT = "health_probe";
+/** Synthetic sentinel ref (ref-grammar decision D-R3): a colon-free
+ * `<subsystem>/_<marker>` label. `health` has no asset stash-subdir, so
+ * `health/_probe` names the subsystem. */
+const HEALTH_PROBE_REF = "health/_probe";
+/**
+ * Verify state.db can accept a write and read it back — WITHOUT leaving any
+ * permanent trace (R-030). Earlier versions appended a `health_probe` event
+ * on every `akm health` invocation and never removed it: a read-only health
+ * check ran on a cron would grow state.db without bound (the only purge is
+ * `improve`'s retention pass, which a health-only user never runs). The probe
+ * row inserted here is deleted again inside the SAME connection once the
+ * round trip is confirmed, so the net effect on the `events` table is always
+ * zero rows — the round trip still genuinely exercises append + read against
+ * the real table, it just doesn't accumulate.
+ */
 export function probeStateDbRoundTrip(stateDbPath) {
-    const before = readEvents({}, { dbPath: stateDbPath }).nextOffset;
     const started = Date.now();
-    // Synthetic sentinel ref (ref-grammar decision D-R3): a colon-free
-    // `<subsystem>/_<marker>` label. `health` has no asset stash-subdir, so
-    // `health/_probe` names the subsystem. Written and read back in lockstep here;
-    // the round-trip matches on `eventType` + this exact ref, so both must agree.
-    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" };
+    try {
+        return withStateDb((db) => {
+            const ts = new Date().toISOString();
+            const insertedId = insertEvent(db, {
+                eventType: HEALTH_PROBE_EVENT,
+                ts,
+                ref: HEALTH_PROBE_REF,
+                metadata: { source: "akm health" },
+            });
+            const durationMs = Date.now() - started;
+            if (insertedId === undefined) {
+                return { ok: false, durationMs, error: "probe event insert did not return a row id" };
+            }
+            // The round-trip matches on the exact (id, eventType, ref) triple
+            // written above, then removes the row regardless of outcome — a
+            // failed round trip must not leak a row any more than a successful
+            // one should.
+            let roundTripOk = false;
+            try {
+                const row = db
+                    .prepare("SELECT 1 AS present FROM events WHERE id = ? AND event_type = ? AND ref = ?")
+                    .get(insertedId, HEALTH_PROBE_EVENT, HEALTH_PROBE_REF);
+                roundTripOk = row !== undefined;
+            }
+            finally {
+                db.prepare("DELETE FROM events WHERE id = ?").run(insertedId);
+            }
+            if (!roundTripOk) {
+                return { ok: false, durationMs, error: "probe event was not readable after append" };
+            }
+            return { ok: true, durationMs };
+        }, { path: stateDbPath });
+    }
+    catch (err) {
+        rethrowIfTestIsolationError(err);
+        return { ok: false, durationMs: Date.now() - started, error: err instanceof Error ? err.message : String(err) };
     }
-    return { ok: true, durationMs };
 }
 // ── WS-5 Observability helpers ───────────────────────────────────────────────
 /**
@@ -170,10 +213,10 @@ export function computeDegradationMetrics(db, since, until) {
     let entrenchmentFlagged;
     let salienceUniformityFlagged;
     try {
-        const rows = db
-            .prepare(`SELECT retrieval_salience FROM asset_salience
-         ORDER BY rank_score DESC LIMIT 100`)
-            .all();
+        // Fail-open: the asset_salience table may not exist yet (pre-WS-1 install).
+        // getTopRetrievalSalience (storage/repositories/salience-repository.ts,
+        // #672 part 2) owns the raw SQL; this call site's try/catch is unchanged.
+        const rows = getTopRetrievalSalience(db, 100);
         if (rows.length >= 5) {
             const vals = rows.map((r) => r.retrieval_salience).sort((a, b) => a - b);
             const n = vals.length;
@@ -181,12 +224,11 @@ export function computeDegradationMetrics(db, since, until) {
                 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;
+            // `sumAbsDiff` contains each unordered pair once, so the standard Gini
+            // denominator is n² × mean (the equivalent ordered-pair formula has 2n²).
+            const gini = mean > 0 ? sumAbsDiff / (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).
             // Two-tailed: >0.35 flags entrenchment (robustly above the ~0.1 uniform
             // baseline); <0.08 flags uniformity collapse — the distribution no longer
             // discriminates between assets (live 2026-07 value 0.040 sat unflagged

package/dist/commands/health/renderers.js

@@ -0,0 +1,47 @@
+// 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/.
+/**
+ * `akm health` document renderers, registered rather than intercepted (D7).
+ *
+ * Both handlers are **pure functions of the shaped result**. Everything the
+ * rich report needs — per-run rows, window-compare deltas, the pending
+ * proposal queue, and the window labels — travels in the result itself
+ * (`runs`/`deltas`/`report`, populated by `akm health --report`). There is no
+ * out-of-band context: an earlier revision bound the proposal queue through
+ * module state set by the command right before `output()`, which coupled the
+ * renderer to call order and made the command branch on the output format to
+ * know when to bind it. Putting the data in the envelope removed both.
+ *
+ * Returning `null` falls through to the generic renderer, so a result without
+ * the report dataset still renders — generically — instead of erroring or
+ * emitting an empty table.
+ */
+import { renderHtml, resolveTemplatePath } from "../../output/html-render.js";
+import { registerHtmlRenderer, registerMdRenderer } from "../../output/render-registry.js";
+import { buildHealthHtmlReplacements } from "./html-report.js";
+import { renderRunsDetailMd, renderWindowCompareMd } from "./md-report.js";
+function isHealthResult(value) {
+    return value !== null && typeof value === "object" && "status" in value;
+}
+registerMdRenderer("health", (result) => {
+    if (!isHealthResult(result))
+        return null;
+    if (result.windows && result.windows.length > 0) {
+        return renderWindowCompareMd(result.windows, result.deltas);
+    }
+    if (result.runs)
+        return renderRunsDetailMd(result.runs);
+    return null;
+});
+registerHtmlRenderer("health", (result) => {
+    if (!isHealthResult(result) || !result.report)
+        return null;
+    return renderHtml(resolveTemplatePath("health"), buildHealthHtmlReplacements(result, {
+        window: result.report.window,
+        compare: result.report.compare,
+        comparisonMode: result.report.comparisonMode,
+        proposals: result.report.pendingProposals,
+        deltas: result.deltas,
+    }));
+});

package/dist/commands/health/report-view-model.js

@@ -75,7 +75,6 @@ function reshapeRun(r) {
         resultComplete: r.resultComplete ?? (r.resultStatus === undefined || r.resultStatus === "valid"),
         taskId: r.taskId ?? "manual",
         strategy: r.strategy,
-        legacyProfile: r.legacyProfile,
         startedAt: r.startedAt,
         completedAt: r.completedAt,
         wallTimeMs: wall,
@@ -94,7 +93,7 @@ function reshapeRun(r) {
         processed: cons.processed,
         failedChunks: cons.failedChunks,
         totalChunks: cons.totalChunks,
-        miWritten: mi.written || mi.writes || 0,
+        miWritten: mi.written,
         miConsidered: mi.considered,
         miYieldRate: mi.yieldRate,
         miCacheHits: mi.cacheHits,
@@ -238,7 +237,7 @@ function buildAggregatesPhase(result, runsPhase) {
     const failedRuns = runs.filter((r) => !r.ok).length;
     const invoked = improve.invoked || totalRuns;
     const completed = improve.completed || totalRuns - failedRuns;
-    const miWritten = mi.written || mi.writes || 0;
+    const miWritten = mi.written;
     return {
         consolidation: cons,
         memoryInference: mi,
@@ -251,7 +250,6 @@ function buildAggregatesPhase(result, runsPhase) {
         llm,
         memorySummary: improve.memorySummary,
         includedResultRows: improve.resultRows?.included ?? totalRuns,
-        normalizedResultRows: improve.resultRows?.normalized ?? 0,
         skippedInvalidResultRows: improve.resultRows?.skipped.invalid ?? invalidRuns.length,
         invoked,
         completed,
@@ -375,7 +373,7 @@ function buildSummaryRows(aggregates, trend) {
             "Stash derived",
             num(aggregates.memorySummary.derived),
             "up",
-            "Whole-stash recount of derived assets at report time — not a per-run sum.",
+            "Whole-bundle recount of derived assets at report time — not a per-run sum.",
         ],
         ["Median wall time", fmtMs(wallTime.medianMs), trend.latency],
         ["P95 wall time", fmtMs(wallTime.p95Ms), trend.latency],
@@ -490,6 +488,7 @@ export function buildHealthReportViewModel(result, opts) {
     return {
         window: opts.window,
         compare: opts.compare,
+        comparisonMode: opts.comparisonMode ?? "duration",
         ...meta,
         runs: runsPhase.runs,
         invalidRuns: runsPhase.invalidRuns,

package/dist/commands/health/stash-exposure.js

@@ -40,7 +40,7 @@ export function collectStashExposureAdvisory(stashDir, git = realGit) {
         message: `${trackedFiles.length} env/secret file(s) are git-tracked AND a remote is configured — ` +
             `a 'git push' can leak tokens/keys (${preview}). ` +
             "Run 'git rm --cached' on them (a .gitignore rule alone does NOT untrack already-tracked " +
-            "files) and then add env/+secrets/ to .gitignore to prevent recurrence (akm init scaffolds it).",
+            "files) and then add env/+secrets/ to .gitignore to prevent recurrence (akm bundle create scaffolds it).",
         evidence: { trackedSecretFiles: trackedFiles },
     };
 }