akm-cli 0.9.16 → 0.9.17-alpha.10

package/dist/commands/health/archive-usage.js

@@ -0,0 +1,92 @@
+// 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/.
+/**
+ * `memory-cleanup-archive` advisory for `akm health` (item 4, 0.9.17-alpha.9
+ * plan §5.4/§8 step 8).
+ *
+ * Reports the archive's size and file count for every bundle, git-backed or
+ * not. A bundle with no `.git` of its own keeps every retirement's archived
+ * bytes forever (the purge sweep never runs there at all), so that alone is
+ * reported. A git-backed bundle can ALSO have bytes the purge sweep will
+ * never remove: `.git` presence alone does not prove a retirement was ever
+ * committed (`proposal accept` only commits for a `kind: "git"` write
+ * target, and a `kind: "filesystem"` bundle that merely happens to have a
+ * `.git` directory never gets one) — those bytes sit there indefinitely,
+ * however old they get, with nothing else to say so. This checks the SAME
+ * git state `purgeGracedArchive` checks (tracked, clean, verifiable) and
+ * reports how much of the archive fails it.
+ *
+ * Silent whenever there is nothing to say: the archive does not exist or is
+ * empty, or (for a git-backed bundle) every byte in it is purgeable once it
+ * ages out.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { MEMORY_ARCHIVE_REL } from "../../core/asset/memory-archive.js";
+import { toPosix } from "../../core/common.js";
+import { checkGitPathSafety, isGitBackedStash } from "../../sources/providers/git-stash.js";
+import { MAX_WALK_ENTRIES, sizeOfPath } from "./data-dir-usage.js";
+/**
+ * Build the `memory-cleanup-archive` advisory, or `undefined` when there is
+ * nothing to report.
+ */
+export function collectArchiveUsageAdvisory(stashDir) {
+    const archiveRoot = path.join(stashDir, MEMORY_ARCHIVE_REL);
+    if (!fs.existsSync(archiveRoot))
+        return undefined;
+    if (!isGitBackedStash(stashDir)) {
+        const usage = sizeOfPath(archiveRoot, { remaining: MAX_WALK_ENTRIES });
+        if (usage.files === 0)
+            return undefined;
+        const lowerBound = usage.truncated ? ` (a lower bound — the walk stopped after ${MAX_WALK_ENTRIES} entries)` : "";
+        return {
+            name: "memory-cleanup-archive",
+            kind: "deterministic",
+            status: "pass",
+            confidence: "high",
+            message: `${usage.files} archived file(s), ${usage.bytes} byte(s)${lowerBound} in .akm/memory-cleanup/archive — ` +
+                "this bundle has no git history, so the purge sweep leaves it untouched.",
+            evidence: { files: usage.files, bytes: usage.bytes, truncated: usage.truncated },
+        };
+    }
+    // Git-backed: the SAME three checks purgeGracedArchive runs (B1, G10) —
+    // computed once here, not per file, and reused via `onFile` below instead
+    // of a second walk of the same tree. A failed git check here fails the
+    // same way purgeGracedArchive's own sweep would: nothing in the archive
+    // can be proven purgeable, so every byte counts as unpurgeable rather
+    // than guessing (`checkGitPathSafety`'s `isSafe` is always `false` when
+    // `ok` is `false`).
+    const gitSafety = checkGitPathSafety(stashDir, MEMORY_ARCHIVE_REL);
+    let unpurgeableFiles = 0;
+    let unpurgeableBytes = 0;
+    const usage = sizeOfPath(archiveRoot, { remaining: MAX_WALK_ENTRIES }, (filePath, bytes) => {
+        const key = toPosix(path.relative(stashDir, filePath));
+        if (!gitSafety.isSafe(key)) {
+            unpurgeableFiles++;
+            unpurgeableBytes += bytes;
+        }
+    });
+    if (usage.files === 0)
+        return undefined;
+    if (unpurgeableFiles === 0)
+        return undefined; // everything here is purgeable once it ages out — nothing to say
+    const lowerBound = usage.truncated ? ` (a lower bound — the walk stopped after ${MAX_WALK_ENTRIES} entries)` : "";
+    return {
+        name: "memory-cleanup-archive",
+        kind: "deterministic",
+        status: "warn",
+        confidence: "high",
+        message: `${usage.files} archived file(s), ${usage.bytes} byte(s)${lowerBound} in .akm/memory-cleanup/archive; ` +
+            `${unpurgeableFiles} file(s), ${unpurgeableBytes} byte(s) of that cannot be purged (untracked, modified, ` +
+            "or unverifiable in git) — commit them so the purge sweep can remove them once they age out.",
+        evidence: {
+            files: usage.files,
+            bytes: usage.bytes,
+            truncated: usage.truncated,
+            unpurgeableFiles,
+            unpurgeableBytes,
+            gitStateKnown: gitSafety.ok,
+        },
+    };
+}

package/dist/commands/health/checks.js

@@ -10,9 +10,10 @@ import { EXTRACT_INFRASTRUCTURE_SKIP_REASONS } from "../../core/improve-types.js
 import { listPendingStateMigrations } from "../../core/state-db.js";
 import { withEngineFallback } from "../../integrations/agent/engine-fallback.js";
 import { isLlmCredentialAvailable, resolveEngine, } from "../../integrations/agent/engine-resolution.js";
-import { executionEngineDefinitionsFromConfig } from "../../integrations/agent/execution-definitions.js";
+import { executionEngineDefinitionsFromConfig } from "../../integrations/agent/execution.js";
 import { loadModelMap, mergeModelMapLayers, parseModelMapLayer, readInstalledModelMapText, resolveModelMapAlias, userModelMapPath, } from "../../integrations/agent/model-map.js";
 import { probeEndpointOnce } from "../../llm/client.js";
+import { STATE_DB_FREELIST_WARN_RATIO, } from "../../storage/state-db-integrity.js";
 import { listKeys } from "../env/env.js";
 import { resolveImprovePlan } from "../improve/improve-strategies.js";
 import { ENGINE_LAST_USED_LOOKBACK_DAYS } from "./engine-usage.js";
@@ -783,16 +784,10 @@ export function runSelectedModelAliasesProbe(deps = {}) {
     };
 }
 /**
- * Hard check: state.db's migration ledger has no pending entries.
- *
- * Read-only via `listPendingStateMigrations` (a preflight open, never a
- * managed one), so running this check is always safe — even when the
- * corresponding managed open would refuse outright because a pending
- * migration is historical-destructive (see `beforeMigrationLocked` in
- * `src/core/state/migrations.ts`). This is what lets `akm health` report that
- * refusal as an ordinary `fail` check instead of crashing the whole command —
- * and what replaces a bundler grepping akm's refusal error text
- * to detect the same case.
+ * `state-db-migrations` when the open itself failed: the migrations still
+ * pending after a failed apply, from a read-only listing that never applies
+ * anything. A `fail` row, not a crash, is what a bundler watches for instead
+ * of grepping akm's error text.
  */
 export function runPendingStateMigrationsCheck(stateDbPath, deps = {}) {
     const pending = (deps.listPendingStateMigrations ?? listPendingStateMigrations)(stateDbPath);
@@ -816,6 +811,27 @@ export function runPendingStateMigrationsCheck(stateDbPath, deps = {}) {
         evidence: { path: stateDbPath, pending },
     };
 }
+/**
+ * Hard check: state.db's ledger is current. Every open applies the pending
+ * migrations (copying the file aside first when one drops schema), so after
+ * health's own open nothing is pending; this names what that open applied, so
+ * an upgrade that migrated state.db is visible in the report.
+ */
+export function appliedStateMigrationsCheck(stateDbPath, report) {
+    const { applied, backupPath } = report;
+    const range = applied.length > 1 ? `${applied[0]} … ${applied[applied.length - 1]}` : applied[0];
+    return {
+        name: "state-db-migrations",
+        kind: "deterministic",
+        status: "pass",
+        confidence: "high",
+        message: applied.length === 0
+            ? "state.db has no pending migrations."
+            : `Applied ${applied.length} pending state.db migration(s) on open (${range})` +
+                (backupPath ? `; the pre-migration copy is ${backupPath}.` : "."),
+        evidence: { path: stateDbPath, pending: [], applied, ...(backupPath ? { backupPath } : {}) },
+    };
+}
 /**
  * #943: name the dominant `detail.reason` behind `task-fail-rate`'s warning
  * when one reason accounts for at least half of the window's command-task
@@ -868,10 +884,65 @@ export const HEALTH_CHECKS = [
             evidence: { path: ctx.stateDbPath, durationMs: ctx.probe.durationMs },
         }),
     },
+    {
+        // R0: nothing looked at state.db's own SQLite-level integrity before
+        // this — the round-trip probe above only proves one row can be appended
+        // and read back, which stays true on a database that fails
+        // `PRAGMA quick_check` elsewhere (corrupt indexes, out-of-order rowids).
+        // Also reports the freelist ratio (fraction of pages VACUUM could
+        // reclaim) so a bloated-but-uncorrupted file is visible as a warning
+        // rather than silence.
+        name: "state-db-integrity",
+        channel: "hard",
+        run: (ctx) => {
+            const { ok, lines, error } = ctx.stateDbIntegrity;
+            const { ratio: freelistRatio, error: freelistError } = ctx.stateDbFreelist;
+            if (!ok) {
+                const detail = error ?? lines.join("; ");
+                return {
+                    name: "state-db-integrity",
+                    kind: "deterministic",
+                    status: "fail",
+                    confidence: "high",
+                    message: `state.db failed PRAGMA quick_check: ${detail}. Repair: back up state.db, then run ` +
+                        `sqlite3 state.db ".recover" | sqlite3 state.new.db, verify state.new.db passes quick_check, stop ` +
+                        "every akm process, then delete state.db-wal and state.db-shm before swapping state.new.db in as " +
+                        "state.db — a leftover WAL from the OLD database is replayed onto the new one and corrupts it.",
+                    evidence: { path: ctx.stateDbPath, lines, freelistRatio },
+                };
+            }
+            if (freelistError) {
+                return {
+                    name: "state-db-integrity",
+                    kind: "deterministic",
+                    status: "fail",
+                    confidence: "high",
+                    message: `state.db passed PRAGMA quick_check, but reading its freelist/page-count failed: ${freelistError}.`,
+                    evidence: { path: ctx.stateDbPath, lines, freelistError },
+                };
+            }
+            const freelistWarn = freelistRatio > STATE_DB_FREELIST_WARN_RATIO;
+            return {
+                name: "state-db-integrity",
+                kind: "deterministic",
+                status: freelistWarn ? "warn" : "pass",
+                confidence: "high",
+                message: freelistWarn
+                    ? `state.db passed PRAGMA quick_check, but ${(freelistRatio * 100).toFixed(1)}% of its pages are free (reclaimable by VACUUM).`
+                    : "state.db passed PRAGMA quick_check.",
+                evidence: {
+                    path: ctx.stateDbPath,
+                    freelistCount: ctx.stateDbFreelist.freelistCount,
+                    pageCount: ctx.stateDbFreelist.pageCount,
+                    freelistRatio,
+                },
+            };
+        },
+    },
     {
         name: "state-db-migrations",
         channel: "hard",
-        run: (ctx) => runPendingStateMigrationsCheck(ctx.stateDbPath),
+        run: (ctx) => appliedStateMigrationsCheck(ctx.stateDbPath, ctx.stateDbMigrations),
     },
     {
         name: "task-history-read",
@@ -885,20 +956,6 @@ export const HEALTH_CHECKS = [
             evidence: { rows: ctx.taskRowCount, since: ctx.since },
         }),
     },
-    {
-        name: "task-log-backing",
-        channel: "hard",
-        run: (ctx) => ({
-            name: "task-log-backing",
-            kind: "deterministic",
-            status: ctx.logBackingRate === 1 ? "pass" : "fail",
-            confidence: "high",
-            message: ctx.logBackingRate === 1
-                ? "Every task_history log_path resolved on disk."
-                : `${ctx.taskRowsWithLogsCount - ctx.existingLogRowsCount} task log(s) referenced in task_history are missing.`,
-            evidence: { totalWithLogs: ctx.taskRowsWithLogsCount, existingLogs: ctx.existingLogRowsCount },
-        }),
-    },
     {
         name: "active-runs",
         channel: "hard",
@@ -1073,54 +1130,6 @@ export const HEALTH_CHECKS = [
             };
         },
     },
-    {
-        // #603: pool-saturation advisory. The raw `sessionsScanned` count fired on
-        // normal cadence changes (the Jun 12 false alarm). Instead track the ratio
-        // of NEW (unseen) sessions to the total session pool extract evaluated in
-        // the window: a low ratio is the *expected* steady state, only a near-zero
-        // ratio signals a possible discovery/dedup bug.
-        //
-        // unseen ≈ `sessionsScanned` (extract only processes new sessions; already-
-        // seen ones are deduped into `sessionsSkipped`). total = scanned + skipped.
-        // This is a heuristic approximation — `sessionsSkipped` also folds in
-        // too-short skips — so the check is informational and never gates status.
-        name: "pool-saturation",
-        channel: "advisory",
-        run: (ctx) => {
-            const sx = ctx.sessionExtraction;
-            const total = sx.sessionsScanned + sx.sessionsSkipped;
-            const unseen = sx.sessionsScanned;
-            const ratio = total > 0 ? unseen / total : null;
-            const pct = ratio === null ? null : Math.round(ratio * 1000) / 10;
-            let status = "pass";
-            let confidence = "low";
-            let message;
-            if (!sx.ran || ratio === null) {
-                message = "Pool saturation: no extract activity in the window — no signal.";
-            }
-            else if (ratio < 0.02) {
-                status = "warn";
-                confidence = "medium";
-                message = `Session pool near-exhausted: only ${pct}% of the ${total}-session pool was new (<2%). Possible discovery/dedup bug — verify extract is still finding new sessions.`;
-            }
-            else if (ratio < 0.1) {
-                confidence = "medium";
-                message = `Session pool saturation: ${pct}% of ${total} sessions were new (<10%, steady-state expected — informational).`;
-            }
-            else {
-                confidence = "medium";
-                message = `Session pool healthy: ${pct}% of ${total} sessions were new.`;
-            }
-            return {
-                name: "pool-saturation",
-                kind: "heuristic",
-                status,
-                confidence,
-                message,
-                evidence: { totalSessions: total, unseenSessions: unseen, saturationRatio: ratio },
-            };
-        },
-    },
     {
         name: "auto-accept-validation",
         channel: "advisory",

package/dist/commands/health/config-skew.js

@@ -0,0 +1,38 @@
+// 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/.
+/**
+ * `binary-config-skew` advisory for `akm health`: warn when config.json
+ * carries a `configVersion` NEWER than (or unorderable against) this binary's
+ * CURRENT_CONFIG_VERSION — a newer akm wrote the shared config, so this
+ * install is stale. That is the proven multi-install incident class. Silent
+ * for current or older versions and for unreadable configs (config loading
+ * reports its own errors).
+ */
+import { readTextFile } from "../../core/common.js";
+import { CURRENT_CONFIG_VERSION } from "../../core/config/config-schema.js";
+import { compareConfigVersion } from "../../core/config/config-version.js";
+export function collectConfigSkewAdvisory(configPath) {
+    let raw;
+    try {
+        raw = JSON.parse(readTextFile(configPath, "Config file"));
+    }
+    catch {
+        return undefined;
+    }
+    const onDisk = raw.configVersion;
+    const order = compareConfigVersion(onDisk, CURRENT_CONFIG_VERSION);
+    const skewed = order === 1 || (onDisk !== undefined && order === undefined);
+    if (!skewed)
+        return undefined;
+    return {
+        name: "binary-config-skew",
+        kind: "deterministic",
+        status: "warn",
+        confidence: "high",
+        message: `config.json has configVersion ${JSON.stringify(onDisk)} but this binary knows ${CURRENT_CONFIG_VERSION} — ` +
+            "a newer akm wrote the shared config, so this install is stale. Upgrade this install; do not keep a stale " +
+            "binary against the shared config/DBs.",
+        evidence: { onDiskConfigVersion: onDisk, binaryConfigVersion: CURRENT_CONFIG_VERSION },
+    };
+}

package/dist/commands/health/data-dir-usage.js

@@ -41,7 +41,7 @@ const DOMINANT_SUBDIR_PERCENT_THRESHOLD = 50;
  * cap the walk stops descending further and the advisory says its size
  * figures are a lower bound.
  */
-const MAX_WALK_ENTRIES = 100_000;
+export const MAX_WALK_ENTRIES = 100_000;
 /**
  * Below this the data dir is not worth an opinion. The advisory exists for
  * disk blowups (74 GB in the incident); on a small directory a ratio is
@@ -59,31 +59,42 @@ function liveDbBytesFor(name, sizes) {
     return ((sizes.get(name)?.bytes ?? 0) + (sizes.get(`${name}-wal`)?.bytes ?? 0) + (sizes.get(`${name}-shm`)?.bytes ?? 0));
 }
 /**
- * Recursively sum file sizes under `root` (stat-only, symlinks not
- * followed so a cyclic or huge-target symlink can't blow up the walk).
- * `budget` is a shared mutable counter across the whole tree so the
- * `MAX_WALK_ENTRIES` cap applies to the walk as a whole, not per-branch.
+ * Recursively sum file sizes (and count files) under `root` (stat-only,
+ * symlinks not followed so a cyclic or huge-target symlink can't blow up the
+ * walk). `budget` is a shared mutable counter across the whole tree so the
+ * entry cap applies to the walk as a whole, not per-branch — callers
+ * typically pass {@link MAX_WALK_ENTRIES}, sized for this module's own data
+ * dir walk, but a smaller/larger budget is fine for a different tree.
+ * Shared with the `archive-usage` advisory (N2) — the same "don't let a
+ * pathological tree hang a health check" concern applies to both.
+ *
+ * `onFile`, when given, is called once per leaf file (path, bytes) as the
+ * walk visits it — `archive-usage` uses this to classify each file's git
+ * state without a second, separate walk of the same tree.
  */
-function sizeOfPath(root, budget) {
+export function sizeOfPath(root, budget, onFile) {
     let stat;
     try {
         stat = fs.lstatSync(root);
     }
     catch {
-        return { bytes: 0, truncated: false };
+        return { bytes: 0, files: 0, truncated: false };
     }
     if (stat.isSymbolicLink())
-        return { bytes: 0, truncated: false };
-    if (!stat.isDirectory())
-        return { bytes: stat.size, truncated: false };
+        return { bytes: 0, files: 0, truncated: false };
+    if (!stat.isDirectory()) {
+        onFile?.(root, stat.size);
+        return { bytes: stat.size, files: 1, truncated: false };
+    }
     let entries;
     try {
         entries = fs.readdirSync(root, { withFileTypes: true });
     }
     catch {
-        return { bytes: 0, truncated: false };
+        return { bytes: 0, files: 0, truncated: false };
     }
     let bytes = 0;
+    let files = 0;
     let truncated = false;
     for (const entry of entries) {
         if (budget.remaining <= 0) {
@@ -91,12 +102,13 @@ function sizeOfPath(root, budget) {
             break;
         }
         budget.remaining--;
-        const sub = sizeOfPath(path.join(root, entry.name), budget);
+        const sub = sizeOfPath(path.join(root, entry.name), budget, onFile);
         bytes += sub.bytes;
+        files += sub.files;
         if (sub.truncated)
             truncated = true;
     }
-    return { bytes, truncated };
+    return { bytes, files, truncated };
 }
 /** `1610612736` -> `"1.5G"`. Values under 10 in a unit keep one decimal; 10+ round to an integer. */
 function formatBytes(bytes) {

package/dist/commands/health/egress.js

@@ -0,0 +1,54 @@
+// 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/.
+/**
+ * `egress-endpoints` advisory for `akm health` (meta-review 08, surfaces 3/9):
+ * the remote-destination list, for eyeball diff. A pure projection over the
+ * effective config (no process.env reads); silent when nothing remote is
+ * configured, matching the `stash-git-exposure` / `binary-config-skew`
+ * advisories' pattern.
+ */
+import { formatRegistryUrl } from "../../core/registry-url.js";
+/**
+ * `egress-endpoints` (08 surfaces 3/9): the full list of remote destinations
+ * akm can talk to under the effective config — registries, remote sources,
+ * LLM endpoints, embedding endpoint — as one pass-status informational entry
+ * for eyeball diff against expectations. Silent only when nothing remote is
+ * configured at all.
+ */
+export function collectEgressAdvisory(config) {
+    if (!config)
+        return undefined;
+    const endpoints = [];
+    for (const reg of config.registries ?? []) {
+        if (reg.enabled === false || !reg.url)
+            continue;
+        endpoints.push(`registry ${reg.name ?? "(unnamed)"}: ${formatRegistryUrl(reg.url)}`);
+    }
+    for (const [key, bundle] of Object.entries(config.bundles ?? {})) {
+        if (!bundle)
+            continue;
+        const url = bundle.git ?? bundle.website?.url;
+        if (!url)
+            continue;
+        endpoints.push(`source ${key} (${bundle.git ? "git" : "website"}): ${url}`);
+    }
+    for (const [name, engine] of Object.entries(config.engines ?? {})) {
+        if (engine?.kind !== "llm" || !engine.endpoint)
+            continue;
+        endpoints.push(`llm ${name}: ${engine.endpoint}`);
+    }
+    if (config.embedding?.endpoint)
+        endpoints.push(`embedding: ${config.embedding.endpoint}`);
+    if (endpoints.length === 0)
+        return undefined;
+    return {
+        name: "egress-endpoints",
+        kind: "deterministic",
+        status: "pass",
+        confidence: "high",
+        message: `${endpoints.length} remote endpoint(s) in the effective config (registries/sources/LLM/embedding) — ` +
+            "review the evidence list for unexpected destinations.",
+        evidence: { endpoints },
+    };
+}

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

@@ -131,7 +131,6 @@ function renderExecSummary(vm) {
     const trendRows = [
         trendLi("Decision quality", vm.trend.decisionQuality),
         trendLi("Output volume", vm.trend.outputVolume),
-        trendLi("Failures", vm.trend.failures),
         trendLi("Latency", vm.trend.latency),
     ].join("");
     const deltaRows = [
@@ -151,7 +150,6 @@ function renderExecSummary(vm) {
             li("Promoted", String(vm.latest.promoted)),
             li("Judged: no action", `<abbr title="Candidates reviewed but intentionally left unchanged on this run.">${vm.latest.judgedNoAction}</abbr>`),
             li("MI written", String(vm.latest.miWritten)),
-            li("Graph entities/relations", `${vm.latest.geEntities} / ${vm.latest.geRelations}`),
         ].join("")
         : '<li><span class="k">No runs in window</span><span class="v">—</span></li>';
     const windowRows = [
@@ -197,7 +195,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 ${vm.comparisonMode === "custom" ? "across the selected windows" : "vs the prior window"}.</div>`.trim();
+      &nbsp;·&nbsp; based on decision quality, output volume, 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
@@ -221,7 +219,6 @@ function renderKpiCards(vm) {
         kpiCard("neutral", "Median Duration", `${vm.medianDurMin}m`, `p95 = ${vm.p95DurMin}m`),
         kpiCard("blue", "Total Promoted", num(vm.consolidation.promoted), `avg ${vm.avgPromoted} / run`),
         kpiCard("blue", "MI Written", num(vm.miWritten), `${vm.miYieldRate} yield rate`),
-        kpiCard("purple", "Graph Entities", num(vm.graphExtraction.entities), `+${num(vm.graphExtraction.relations)} relations`),
         kpiCard("neutral", "Stash Derived", num(vm.memorySummary.derived), `of ${num(vm.memorySummary.eligible)} eligible (whole-stash)`),
         // #576: real LLM work — duration leads, tokens compact, not a GPU proxy.
         kpiCard(vm.llm.calls > 0 ? "purple" : "neutral", "🧠 LLM Work", `${vm.llmTokensCompact} tok`, `${fmtMs(vm.llm.totalDurationMs)} · ${num(vm.llm.calls)} calls · ${compact(vm.llm.reasoningTokens)} reasoning`),
@@ -331,44 +328,6 @@ function renderActionItems(vm) {
             descHtml: `Newest run is ${esc(latestRunHuman)} — older than the 6h freshness threshold. Check the improve scheduler/cron.`,
         });
     }
-    // WS-5: corpus entrenchment flag.
-    if (vm.degradation?.entrenchmentFlagged) {
-        pushItem({
-            key: "corpus-entrenchment",
-            prio: "P2",
-            cls: "warn",
-            title: "Corpus entrenchment risk: retrieval_salience Gini > 0.35",
-            descHtml: "A small set of assets dominates retrieval — retrieval diversity is low. " +
-                "Review top-ranked assets for stale or over-represented content. " +
-                `Corpus diversity proxy: ${esc(String(vm.degradation.corpusCentroidDistance))}.`,
-            remedy: "akm health --format json | jq '.improve.degradation'",
-        });
-    }
-    // Low-tail companion: salience distribution collapsed toward uniform.
-    if (vm.degradation?.salienceUniformityFlagged) {
-        pushItem({
-            key: "salience-uniformity-collapse",
-            prio: "P2",
-            cls: "warn",
-            title: "Salience distribution collapsed: retrieval_salience Gini < 0.08",
-            descHtml: `The ${vm.degradation.retrievalSalienceSampleSize} observed, resolvable salience scores are near-uniform — ` +
-                "ranking carries little discrimination among assets with retrieval evidence. " +
-                `Corpus diversity proxy: ${esc(String(vm.degradation.corpusCentroidDistance))}.`,
-            remedy: "akm health --format json | jq '.improve.degradation'",
-        });
-    }
-    // WS-5: over-budget consolidation advisory.
-    if (vm.perf.overBudgetRuns > 0) {
-        pushItem({
-            key: "over-budget-consolidation",
-            prio: "P2",
-            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 strategy config.",
-            remedy: "akm config list",
-        });
-    }
     items.sort((a, b) => PRIO_RANK[a.prio] - PRIO_RANK[b.prio]);
     return items.length > 0
         ? items.map(actionItemCard).join("\n")