akm-cli 0.9.1 → 0.9.2-alpha.2

package/dist/commands/health/checks.js

@@ -3,11 +3,13 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { spawnSync } from "node:child_process";
 import { loadConfig } from "../../core/config/config.js";
+import { ConfigError } from "../../core/errors.js";
 import { withEngineFallback } from "../../integrations/agent/engine-fallback.js";
 import { resolveEngine } from "../../integrations/agent/engine-resolution.js";
-import { resolveModel } from "../../integrations/agent/model-aliases.js";
+import { executionEngineDefinitionsFromConfig } from "../../integrations/agent/execution-definitions.js";
+import { loadModelMap, mergeModelMapLayers, parseModelMapLayer, readInstalledModelMapText, resolveModelMapAlias, userModelMapPath, } from "../../integrations/agent/model-map.js";
 import { resolveImprovePlan } from "../improve/improve-strategies.js";
-import { ACTIVE_RUN_WARN_MS, TASK_FAIL_RATE_WARN, } from "./types.js";
+import { ACTIVE_RUN_WARN_MS, TASK_FAIL_RATE_WARN } from "./types.js";
 function credentialAvailable(credential, env) {
     return !credential?.required || credential.names.some((name) => Boolean(env[name]?.trim()));
 }
@@ -36,8 +38,21 @@ function runConfiguredEngineProbe(checkName, engineName, config, deps) {
             packageAvailable = false;
         }
         const binary = configuredEngine.bin ?? "opencode";
-        const version = (deps.spawnSync ?? spawnSync)(binary, ["--version"], { encoding: "utf8", timeout: 5_000 });
-        const binaryAvailable = (version.status ?? 1) === 0;
+        let binaryAvailable;
+        try {
+            const version = (deps.spawnSync ?? spawnSync)(binary, ["--version"], { encoding: "utf8", timeout: 5_000 });
+            binaryAvailable = (version.status ?? 1) === 0;
+        }
+        catch {
+            return {
+                name: checkName,
+                kind: "deterministic",
+                status: "warn",
+                confidence: "high",
+                message: `SDK engine "${engineName}" executable availability could not be checked.`,
+                evidence: { engine: engineName, runtimeKind: "sdk", binaryAvailable: false },
+            };
+        }
         const fallbackEngine = configuredEngine.llmEngine ?? config.defaults?.llmEngine;
         let fallback;
         let fallbackCredential;
@@ -51,8 +66,8 @@ function runConfiguredEngineProbe(checkName, engineName, config, deps) {
         catch {
             sdkRunner = undefined;
         }
-        if (sdkRunner?.fallbackConnection) {
-            fallback = { kind: "llm", connection: sdkRunner.fallbackConnection };
+        if (sdkRunner?.fallbackConnection && fallbackEngine) {
+            fallback = { kind: "llm", engine: fallbackEngine, connection: sdkRunner.fallbackConnection };
             fallbackCredential = sdkRunner.fallbackCredential;
         }
         else if (fallbackEngine) {
@@ -67,9 +82,7 @@ function runConfiguredEngineProbe(checkName, engineName, config, deps) {
                 fallback = undefined;
             }
         }
-        const configuredModel = configuredEngine.model
-            ? resolveModel(configuredEngine.model, "opencode-sdk", configuredEngine.modelAliases, config.modelAliases)
-            : undefined;
+        const configuredModel = configuredEngine.model;
         const effectiveModel = sdkRunner?.profile.model ?? configuredModel ?? fallback?.connection.model;
         const fallbackCredentialAvailable = credentialAvailable(fallbackCredential, env);
         const missing = [
@@ -169,6 +182,58 @@ function runConfiguredEngineProbe(checkName, engineName, config, deps) {
         };
     }
 }
+function projectEngineProbe(result, name) {
+    return result.name === name ? result : { ...result, name };
+}
+function projectSelectedEngineProbe(availability, engineName, checkName) {
+    const result = availability.get(engineName);
+    if (result)
+        return projectEngineProbe(result, checkName);
+    return {
+        name: checkName,
+        kind: "deterministic",
+        status: "warn",
+        confidence: "high",
+        message: `Engine "${engineName}" availability could not be checked.`,
+        evidence: { engine: engineName },
+    };
+}
+function unconfiguredEngineProbe(name) {
+    return {
+        name,
+        kind: "deterministic",
+        status: "unknown",
+        confidence: "high",
+        message: name === "default-llm-engine" ? "No default LLM engine is configured." : "No default engine is configured.",
+    };
+}
+function configuredEnginesProjection(engineNames, availability) {
+    if (engineNames.length === 0) {
+        return {
+            name: "configured-engines",
+            kind: "deterministic",
+            status: "unknown",
+            confidence: "high",
+            message: "No engines are explicitly configured.",
+            evidence: { engines: [] },
+        };
+    }
+    const engines = engineNames.map((engine) => ({
+        engine,
+        status: availability.get(engine)?.status === "pass" ? "pass" : "warn",
+    }));
+    const unavailable = engines.filter((engine) => engine.status === "warn").length;
+    return {
+        name: "configured-engines",
+        kind: "deterministic",
+        status: unavailable === 0 ? "pass" : "warn",
+        confidence: "high",
+        message: unavailable === 0
+            ? `All ${engines.length} explicitly configured engines are available.`
+            : `${unavailable} of ${engines.length} explicitly configured engines ${unavailable === 1 ? "is" : "are"} unavailable.`,
+        evidence: { engines },
+    };
+}
 export function runDefaultEngineProbe(deps = {}) {
     // Probe the effective view: an install with no `defaults.engine` but a usable
     // opencode binary DOES have a working default, and reporting otherwise would
@@ -180,6 +245,38 @@ export function runDefaultLlmEngineProbe(deps = {}) {
     const config = deps.loadConfig?.() ?? loadConfig();
     return runConfiguredEngineProbe("default-llm-engine", config.defaults?.llmEngine, config, deps);
 }
+/** Probe every explicitly configured engine without exposing connection or model material. */
+export function runConfiguredEnginesProbe(deps = {}) {
+    const config = deps.loadConfig?.() ?? loadConfig();
+    const engineNames = Object.keys(config.engines ?? {}).sort();
+    const availability = new Map(engineNames.map((engine) => [engine, runConfiguredEngineProbe("configured-engine", engine, config, deps)]));
+    return configuredEnginesProjection(engineNames, availability);
+}
+/**
+ * Build the per-health-run availability snapshot. Each distinct selected or
+ * explicitly configured engine is probed once; the three public checks are
+ * projections of that immutable result set.
+ */
+export function runHealthEngineProbes(deps = {}) {
+    const configured = deps.loadConfig?.() ?? loadConfig();
+    const effective = withEngineFallback(configured, deps.which).config;
+    const defaultEngineName = effective.defaults?.engine;
+    const defaultLlmEngineName = configured.defaults?.llmEngine;
+    const explicitEngineNames = Object.keys(configured.engines ?? {}).sort();
+    const probeNames = [...new Set([...explicitEngineNames, defaultEngineName, defaultLlmEngineName])]
+        .filter((name) => name !== undefined)
+        .sort();
+    const availability = new Map(probeNames.map((engine) => [engine, runConfiguredEngineProbe("configured-engine", engine, effective, deps)]));
+    return Object.freeze({
+        defaultEngine: defaultEngineName
+            ? projectSelectedEngineProbe(availability, defaultEngineName, "default-engine")
+            : unconfiguredEngineProbe("default-engine"),
+        defaultLlmEngine: defaultLlmEngineName
+            ? projectSelectedEngineProbe(availability, defaultLlmEngineName, "default-llm-engine")
+            : unconfiguredEngineProbe("default-llm-engine"),
+        configuredEngines: configuredEnginesProjection(explicitEngineNames, availability),
+    });
+}
 export function runActiveImproveStrategyProbe(deps = {}) {
     const config = deps.loadConfig?.() ?? loadConfig();
     const strategyName = config.defaults?.improveStrategy ?? "default";
@@ -226,6 +323,124 @@ export function runActiveImproveStrategyProbe(deps = {}) {
         };
     }
 }
+/**
+ * Validate the immutable installed model map and optional user overlay.
+ * Installed corruption is a package defect (fail); a bad optional user file
+ * is operator-fixable configuration (warn); absence is the normal state.
+ */
+export function runModelMapProbe(options = {}) {
+    let installedText;
+    try {
+        installedText = readInstalledModelMapText(options);
+        mergeModelMapLayers(parseModelMapLayer(installedText, "installed models.json"));
+    }
+    catch (error) {
+        return {
+            name: "model-map-files",
+            kind: "deterministic",
+            status: "fail",
+            confidence: "high",
+            message: `Installed models.json is invalid; this AKM installation cannot resolve model aliases: ${error instanceof Error ? error.message : String(error)}`,
+            evidence: { installedSource: "package asset" },
+        };
+    }
+    try {
+        const loaded = loadModelMap({ ...options, installedText });
+        return {
+            name: "model-map-files",
+            kind: "deterministic",
+            status: "pass",
+            confidence: "high",
+            message: loaded.userStatus === "loaded"
+                ? `Installed defaults and user models.json at ${loaded.userPath} are valid.`
+                : "Installed model defaults are valid; no optional user models.json is present.",
+            evidence: {
+                installedSource: "package asset",
+                userPath: loaded.userPath,
+                userStatus: loaded.userStatus,
+                aliases: Object.keys(loaded.map.aliases).sort(),
+            },
+        };
+    }
+    catch (error) {
+        const hint = error instanceof ConfigError ? error.hint() : undefined;
+        return {
+            name: "model-map-files",
+            kind: "deterministic",
+            status: "warn",
+            confidence: "high",
+            message: `${error instanceof Error ? error.message : String(error)}${hint ? ` ${hint}` : ""}`,
+            evidence: {
+                installedSource: "package asset",
+                userPath: userModelMapPath(options.env),
+                userStatus: "invalid",
+            },
+        };
+    }
+}
+/**
+ * Check model selections owned by configured engines against the common model
+ * map. Unknown identifiers are deliberate exact-model pass-throughs; only an
+ * alias known somewhere in the map but absent for the selected engine warns.
+ */
+export function runSelectedModelAliasesProbe(deps = {}) {
+    const config = deps.loadConfig?.() ?? loadConfig();
+    const definitions = executionEngineDefinitionsFromConfig(config);
+    const selected = Object.entries(definitions)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .flatMap(([engine, definition]) => {
+        const model = definition.defaults?.model;
+        const modelMapKey = definition.modelMapKey ?? definition.selection.platform ?? definition.selection.name;
+        return typeof model === "string" ? [{ engine, alias: model, modelMapKey }] : [];
+    });
+    if (selected.length === 0) {
+        return {
+            name: "selected-model-aliases",
+            kind: "deterministic",
+            status: "unknown",
+            confidence: "high",
+            message: "No configured engines select a model.",
+            evidence: { checked: [], missing: [] },
+        };
+    }
+    let modelMap;
+    try {
+        modelMap = (deps.loadModelMap ?? loadModelMap)({ env: deps.env, installedText: deps.installedText });
+    }
+    catch {
+        return {
+            name: "selected-model-aliases",
+            kind: "deterministic",
+            status: "unknown",
+            confidence: "high",
+            message: "Configured model selections could not be checked because the model map is invalid.",
+            evidence: { checked: [], missing: [] },
+        };
+    }
+    const outcomes = selected.map(({ engine, alias, modelMapKey }) => {
+        try {
+            const resolution = resolveModelMapAlias(alias, modelMapKey, modelMap.map);
+            return resolution.interpretation === "alias"
+                ? { kind: "alias", evidence: { engine, alias, modelMapKey } }
+                : { kind: "exact" };
+        }
+        catch {
+            return { kind: "missing", evidence: { engine, alias, modelMapKey } };
+        }
+    });
+    const checked = outcomes.flatMap((outcome) => (outcome.kind === "exact" ? [] : [outcome.evidence]));
+    const missing = outcomes.flatMap((outcome) => (outcome.kind === "missing" ? [outcome.evidence] : []));
+    return {
+        name: "selected-model-aliases",
+        kind: "deterministic",
+        status: missing.length === 0 ? "pass" : "warn",
+        confidence: "high",
+        message: missing.length === 0
+            ? `All ${selected.length} configured model selections resolve for their selected engines.`
+            : `${missing.length} of ${selected.length} configured model selections ${missing.length === 1 ? "has" : "have"} no mapping for ${missing.length === 1 ? "its" : "their"} selected engine${missing.length === 1 ? "" : "s"}.`,
+        evidence: { checked, missing },
+    };
+}
 /**
  * The ordered health-check registry. ORDER IS LOAD-BEARING: `akmHealth`
  * iterates this array and appends to hardChecks/advisories in sequence, so the
@@ -312,12 +527,27 @@ export const HEALTH_CHECKS = [
     {
         name: "default-engine",
         channel: "hard",
-        run: () => runDefaultEngineProbe(),
+        run: (ctx) => ctx.engineProbes.defaultEngine,
+    },
+    {
+        name: "model-map-files",
+        channel: "hard",
+        run: () => runModelMapProbe(),
+    },
+    {
+        name: "selected-model-aliases",
+        channel: "hard",
+        run: () => runSelectedModelAliasesProbe(),
     },
     {
         name: "default-llm-engine",
         channel: "hard",
-        run: () => runDefaultLlmEngineProbe(),
+        run: (ctx) => ctx.engineProbes.defaultLlmEngine,
+    },
+    {
+        name: "configured-engines",
+        channel: "hard",
+        run: (ctx) => ctx.engineProbes.configuredEngines,
     },
     {
         name: "active-improve-strategy",
@@ -409,24 +639,6 @@ export const HEALTH_CHECKS = [
             };
         },
     },
-    {
-        // session-log-failures: demoted to informational — the ERROR_PATTERNS regex
-        // scans pre-LLM session text and produces false positives on diagnostic
-        // conversation. It does not gate the real extraction pipeline (akmExtract).
-        // Never triggers warn; kept for backward-compat visibility only.
-        name: "session-log-failures",
-        channel: "advisory",
-        run: (ctx) => ({
-            name: "session-log-failures",
-            kind: "heuristic",
-            status: "pass",
-            confidence: "low",
-            message: ctx.sessionLogEntries.length === 0
-                ? "No repeated external session-log failure patterns were detected."
-                : `${ctx.sessionLogEntries.length} raw session-log keyword match(es) detected (pre-LLM, informational only).`,
-            evidence: { candidates: ctx.sessionLogEntries.slice(0, 5) },
-        }),
-    },
     {
         name: "session-extraction",
         channel: "advisory",

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

@@ -369,20 +369,6 @@ function renderActionItems(vm) {
             remedy: "akm config list",
         });
     }
-    // Session-log notes (informational, lowest priority).
-    if (vm.sessionLogAdvisories.length > 0) {
-        const patterns = vm.sessionLogAdvisories
-            .slice(0, 6)
-            .map((p) => `<li>${esc(p.topic)}</li>`)
-            .join("");
-        pushItem({
-            key: "session-log-notes",
-            prio: "P3",
-            cls: "warn",
-            title: `${vm.sessionLogAdvisories.length} session-log note(s) (informational)`,
-            descHtml: `<ul style="margin:4px 0 0 16px;padding:0;">${patterns}</ul>`,
-        });
-    }
     items.sort((a, b) => PRIO_RANK[a.prio] - PRIO_RANK[b.prio]);
     return items.length > 0
         ? items.map(actionItemCard).join("\n")

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

@@ -503,6 +503,5 @@ export function buildHealthReportViewModel(result, opts) {
         sliceCandidates: computeSliceCandidates(opts.window),
         distillReasons,
         advisories: result.advisories,
-        sessionLogAdvisories: result.sessionLogAdvisories,
     };
 }

package/dist/commands/health/surfaces.js

@@ -17,14 +17,13 @@
 import { MAX_CONFIG_FILE_BYTES, readTextFileWithLimit } from "../../core/common.js";
 import { CURRENT_CONFIG_VERSION } from "../../core/config/config-schema.js";
 import { compareConfigVersion } from "../../core/config/config-version.js";
+import { formatRegistryUrl } from "../../core/registry-url.js";
 /**
  * `binary-config-skew` (08-F3): warn when config.json carries a configVersion
  * NEWER than (or unorderable against) this binary's CURRENT_CONFIG_VERSION —
  * i.e. a newer/foreign akm wrote the shared config and this install is stale.
- * That is exactly the state where auto-migration is skipped (downgrade
- * protection) and the proven multi-install incident class begins. Silent for
- * same/older versions (auto-migration handles those) and unreadable configs
- * (config loading surfaces its own errors).
+ * That is the proven multi-install incident class. Silent for current or older
+ * versions and unreadable configs (config loading surfaces its own errors).
  */
 export function collectConfigSkewAdvisory(configPath) {
     let raw;
@@ -45,8 +44,8 @@ export function collectConfigSkewAdvisory(configPath) {
         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 and auto-migration is skipped " +
-            "(downgrade protection). Upgrade this install; do not keep a stale binary against the shared config/DBs.",
+            "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 },
     };
 }
@@ -64,7 +63,7 @@ export function collectEgressAdvisory(config) {
     for (const reg of config.registries ?? []) {
         if (reg.enabled === false || !reg.url)
             continue;
-        endpoints.push(`registry ${reg.name ?? "(unnamed)"}: ${reg.url}`);
+        endpoints.push(`registry ${reg.name ?? "(unnamed)"}: ${formatRegistryUrl(reg.url)}`);
     }
     for (const [key, bundle] of Object.entries(config.bundles ?? {})) {
         if (!bundle)

package/dist/commands/health/types.js

@@ -16,7 +16,6 @@
  *   - `./types-improve` — the {@link ImproveHealthMetrics} accumulator and its
  *     WS-5 sub-rollups (coverage, perf telemetry, degradation, enrichment
  *     minting).
- *   - `./types-session-log` — {@link SessionLogAdvisory}.
  *   - `./types-runs` — {@link ImproveRunSummary} (`--group-by run`).
  *   - `./types-windows` — {@link WindowSpec}/{@link WindowResult}/{@link DeltaEntry}
  *     (`--window-compare`/`--windows`).
@@ -27,5 +26,4 @@ export * from "./types-improve.js";
 export * from "./types-metrics.js";
 export * from "./types-result.js";
 export * from "./types-runs.js";
-export * from "./types-session-log.js";
 export * from "./types-windows.js";

package/dist/commands/health.js

@@ -10,14 +10,14 @@ import { readEvents } from "../core/events.js";
 import { listTxnJournalsTolerant, TXN_SWEEP_GRACE_MS } from "../core/fs-txn.js";
 import { openLogsDatabase } from "../core/logs-db.js";
 import { classifyPathAccess, describeInaccessiblePath } from "../core/path-access.js";
-import { getConfigPath, getDataDir, getStateDbPathInDataDir } from "../core/paths.js";
+import { getConfigPath, getDataDir, getDbPath, getStateDbPathInDataDir } from "../core/paths.js";
 import { listExistingTableNames, openStateDatabase } from "../core/state-db.js";
 import { DURATION_UNITS, parseDuration, parseSinceToIso } from "../core/time.js";
 import { readSemanticStatus } from "../indexer/search/semantic-status.js";
-import { getExecutionLogCandidates } from "../integrations/session-logs/index.js";
+import { closeDatabase, openReadonlyExistingDatabase } from "../storage/repositories/index-connection.js";
 import { queryTaskHistory } from "../storage/repositories/task-history-repository.js";
 import { collectImproveAdvisories } from "./health/advisories.js";
-import { HEALTH_CHECKS } from "./health/checks.js";
+import { HEALTH_CHECKS, runHealthEngineProbes } from "./health/checks.js";
 import { buildImproveSkipSummary, computeWallTimeStats, parseTaskMetadata, roundRate, summarizeImproveCompleted, summarizeImproveRuns, } from "./health/improve-metrics.js";
 import { emptyLlmUsageAggregate, readLlmUsageAggregate } from "./health/llm-usage.js";
 import { computeDegradationMetrics, computeDenominatorFixedCoverage, computeEnrichmentMintingRollup, probeStateDbRoundTrip, } from "./health/metrics.js";
@@ -235,6 +235,9 @@ function gatherImproveSummaryPhase(db, stateDbPath, since, now) {
  */
 function gatherAncillaryAdvisories(db, stateDbPath, since, improveSummary, options, egressConfigView) {
     const advisories = [...collectImproveAdvisories(db, stateDbPath, since, improveSummary)];
+    const indexStateMismatch = detectIndexStateGenerationMismatch(db);
+    if (indexStateMismatch)
+        advisories.push(indexStateMismatch);
     // 08-F1: surface a `stash-git-exposure` advisory when env/secret assets are
     // git-tracked AND a remote is configured (the leak moment). Best-effort.
     // Cheap guard: only shell out to git when the stash has its OWN `.git` (or a
@@ -268,19 +271,64 @@ function gatherAncillaryAdvisories(db, stateDbPath, since, improveSummary, optio
     }
     return advisories;
 }
-/** Execution-log-derived session advisories. Best-effort: any failure yields an empty list. */
-function gatherSessionLogAdvisories(since, now, getExecutionLogCandidatesFn) {
+/**
+ * Detect the durable signature of an interrupted cross-database update.
+ *
+ * `usage_events.entry_ref` is the stable identity while `entry_id` names the
+ * current, regenerable index row. A linked event whose id is absent or resolves
+ * to a different ref means index.db and state.db describe adjacent generations.
+ * Legacy/bare refs and deliberately detached rows are excluded. The scan is
+ * streaming and keeps only a bounded evidence sample so health cannot mirror
+ * either database into the JS heap.
+ *
+ * Best-effort by design: an absent/unreadable/incompatible index has its own
+ * diagnostics and must not make the state health path throw.
+ */
+function detectIndexStateGenerationMismatch(stateDb) {
+    let indexDb;
     try {
-        const sinceDays = Math.max(0, Math.ceil((now() - new Date(since).getTime()) / (24 * 60 * 60 * 1000)));
-        return getExecutionLogCandidatesFn(sinceDays).map((entry) => ({
-            topic: entry.topic,
-            frequency: entry.frequency,
-            source: entry.source,
-            isFailurePattern: entry.isFailurePattern,
-        }));
+        indexDb = openReadonlyExistingDatabase(getDbPath());
+        if (!indexDb)
+            return undefined;
+        const byId = indexDb.prepare("SELECT item_ref FROM entries WHERE id = ?");
+        const rows = stateDb
+            .prepare("SELECT DISTINCT entry_id, entry_ref FROM usage_events " +
+            "WHERE entry_id IS NOT NULL AND entry_ref IS NOT NULL AND instr(entry_ref, '//') > 0")
+            .iterate();
+        let mismatches = 0;
+        const sample = [];
+        for (const row of rows) {
+            const indexedRef = byId.get(row.entry_id)?.item_ref ?? null;
+            if (indexedRef === row.entry_ref)
+                continue;
+            mismatches += 1;
+            if (sample.length < 5)
+                sample.push({ entryId: row.entry_id, entryRef: row.entry_ref, indexedRef });
+        }
+        if (mismatches === 0)
+            return undefined;
+        return {
+            name: "index-state-generation",
+            kind: "deterministic",
+            status: "warn",
+            confidence: "high",
+            message: `${mismatches} durable usage link(s) disagree with the current searchable index generation. ` +
+                "Stop concurrent writers and run 'akm index --full' to relink state to the current index.",
+            evidence: { mismatches, sample },
+        };
     }
     catch {
-        return [];
+        return undefined;
+    }
+    finally {
+        if (indexDb) {
+            try {
+                closeDatabase(indexDb);
+            }
+            catch {
+                // Best-effort advisory: a close failure must not abort health.
+            }
+        }
     }
 }
 /**
@@ -370,7 +418,6 @@ function unreadableStateDbReport(detail, options) {
             llmUsage: emptyLlmUsageAggregate(),
         },
         improve: summarizeImproveCompleted([]),
-        sessionLogAdvisories: [],
     };
 }
 export function akmHealth(options = {}) {
@@ -380,7 +427,6 @@ export function akmHealth(options = {}) {
     const stateDbPath = options.stateDbPath ?? getStateDbPathInDataDir();
     const hardChecks = [];
     const advisories = [];
-    const getExecutionLogCandidatesFn = options.getExecutionLogCandidatesFn ?? getExecutionLogCandidates;
     // #791: an UNREADABLE state.db is the one failure `akm health` most needs to
     // be able to report, because it is the command an operator runs to find out
     // why everything else is behaving oddly. Dying here with exit 78 meant health
@@ -414,7 +460,7 @@ export function akmHealth(options = {}) {
         const { semanticStatus, semanticSearchMode, embeddingEndpoint, egressConfigView } = gatherSemanticConfigPhase();
         const { improveSummary } = gatherImproveSummaryPhase(db, stateDbPath, since, now);
         advisories.push(...gatherAncillaryAdvisories(db, stateDbPath, since, improveSummary, options, egressConfigView));
-        const sessionLogEntries = gatherSessionLogAdvisories(since, now, getExecutionLogCandidatesFn);
+        const engineProbes = runHealthEngineProbes();
         // Run the ordered health-check registry. Each check projects the shared
         // context computed above into one HealthCheckResult; `channel` routes it to
         // hardChecks or advisories. Declaration order in HEALTH_CHECKS is the
@@ -437,9 +483,9 @@ export function akmHealth(options = {}) {
             semanticStatus,
             semanticSearchMode,
             embeddingEndpoint,
-            sessionLogEntries,
             sessionExtraction: improveSummary.sessionExtraction,
             autoAccept: improveSummary.autoAccept,
+            engineProbes,
         };
         for (const check of HEALTH_CHECKS) {
             const result = check.run(checkContext);
@@ -475,7 +521,6 @@ export function akmHealth(options = {}) {
             advisories,
             metrics,
             improve: improveSummary,
-            sessionLogAdvisories: sessionLogEntries,
             ...(runs ? { runs } : {}),
             ...(windowResults ? { windows: windowResults } : {}),
             ...(deltas ? { deltas } : {}),

package/dist/commands/improve/collapse-detector.js

@@ -163,10 +163,9 @@ export function refreshCanarySet(stateDb, indexDb, cfg) {
  * Name-free content fingerprint text for entropy metrics. The indexed
  * search_text EMBEDS the (unique) entry name, which would pin the
  * distinct-content ratio at 1.0 forever; convergence shows up in the
- * description/tags/heading fields, so those are what get hashed. (The raw body
- * is not in the index at all — search_text covers metadata + TOC headings —
- * so v1 entropy is measured over the searchable surface, which is also what
- * generic merged assets converge on.)
+ * description/tags/heading fields, so those are what get hashed. Bounded body
+ * content is searchable but deliberately excluded from this fingerprint: the
+ * detector measures the structured surface generic merged assets converge on.
  */
 function contentFingerprint(entry) {
     const parts = [entry.description ?? "", (entry.tags ?? []).join(" "), (entry.toc ?? []).map((h) => h.text).join(" ")];
@@ -262,9 +261,9 @@ export function computeCycleMetrics(stateDb, indexDb, args) {
         contentHashes.add(normHash(fingerprint));
         if ((e.entry.generation ?? 0) > maxGeneration)
             overGeneration++;
-        learningTexts.push({ key: e.entryKey, text: fingerprint });
+        learningTexts.push({ key: e.itemRef, text: fingerprint });
     }
-    // Deterministic diversity sample: sort by entryKey, take every ⌈N/cap⌉-th row.
+    // Deterministic diversity sample: sort by item ref, take every ⌈N/cap⌉-th row.
     learningTexts.sort((a, b) => (a.key < b.key ? -1 : 1));
     const step = Math.max(1, Math.ceil(learningTexts.length / DIVERSITY_SAMPLE_CAP));
     let diversitySum = 0;