akm-cli 0.10.261012-beta → 0.10.261014-beta

package/dist/commands/health/connections-and-harnesses-check.js

@@ -0,0 +1,109 @@
+// 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/.
+/**
+ * The `connections-and-harnesses` health check: the table of connections, harnesses and the work
+ * that runs on them (`../targets.ts`), with what only health asks for added to
+ * it. Whether a connection's endpoint answers is one bounded `GET /models`,
+ * once per distinct endpoint; a harness's version is its own `--version`, one
+ * process per harness. Both are probes: with `--no-probe` neither the endpoints
+ * are contacted nor any harness run.
+ */
+import { spawnSync } from "node:child_process";
+import { ambiguousDefaultAdvice, loadConfig } from "../../core/config/config.js";
+import { defaultWhich, probeVersion } from "../../integrations/agent/detect.js";
+import { resolveTarget } from "../../integrations/agent/resolution.js";
+import { probeEndpointOnce } from "../../llm/client.js";
+import { targetRows } from "../targets.js";
+const VERSION_TIMEOUT_MS = 5_000;
+/** Each connection's reachability, asked once per distinct endpoint. */
+async function probeConnections(config, probe) {
+    const cache = new Map();
+    const entries = await Promise.all(Object.entries(config.connections ?? {}).map(async ([name, connection]) => [name, await probeEndpointOnce(connection, cache, probe)]));
+    return new Map(entries);
+}
+/** Each installed harness's `--version`, its first line; none when it will not say. */
+function harnessVersions(config, which, spawn) {
+    const versions = new Map();
+    for (const name of Object.keys(config.harnesses ?? {})) {
+        try {
+            const target = resolveTarget({ config, layers: [{ harness: name }] });
+            if (target.kind !== "harness" || !which(target.bin))
+                continue;
+            const version = probeVersion(target.bin, VERSION_TIMEOUT_MS, spawn);
+            if (version !== undefined)
+                versions.set(name, version.split("\n")[0] || undefined);
+        }
+        catch {
+            // A harness that cannot be resolved or run has no version to report.
+        }
+    }
+    return versions;
+}
+/** What is wrong in the table, one phrase each. A key variable's name is never quoted. */
+function problems(rows, ambiguous) {
+    // No default among several connections or harnesses is the config's problem, said once whatever work it leaves
+    // without a place to run (work may still find one: model work falls to a harness).
+    const found = ambiguous ? [ambiguous] : [];
+    // A problem that several kinds of work share is said once.
+    const shared = new Map();
+    for (const row of rows) {
+        if (row.type === "connection") {
+            if (row.key === "env-unset")
+                found.push(`connection "${row.name}": the variable holding its key is not set`);
+            if (row.reachable === false) {
+                found.push(`connection "${row.name}" is not reachable${row.error ? ` (${row.error})` : ""}`);
+            }
+        }
+        else if (row.type === "harness") {
+            if (!row.installed)
+                found.push(`harness "${row.name}" (${row.platform}) was not found on PATH`);
+        }
+        else if (row.problem) {
+            const problem = row.problem.replace(/\.$/, "");
+            if (problem !== ambiguous)
+                shared.set(problem, [...(shared.get(problem) ?? []), row.process]);
+        }
+    }
+    for (const [problem, processes] of shared)
+        found.push(`${processes.join(", ")}: ${problem}`);
+    return found;
+}
+/** The check for a table. `unknown` when nothing is configured: there is nothing to be wrong. */
+export function connectionsAndHarnessesCheck(rows, probed, ambiguous) {
+    const connections = rows.filter((row) => row.type === "connection").length;
+    const harnesses = rows.filter((row) => row.type === "harness").length;
+    const base = {
+        name: "connections-and-harnesses",
+        kind: "deterministic",
+        confidence: "high",
+        evidence: { rows },
+    };
+    if (connections + harnesses === 0) {
+        return {
+            ...base,
+            status: "unknown",
+            message: "No connection or harness is configured: model features and agentic work are off. Run `akm setup`.",
+        };
+    }
+    const found = problems(rows, ambiguous);
+    const counts = `${connections} connection${connections === 1 ? "" : "s"} and ${harnesses} harness${harnesses === 1 ? "" : "es"}`;
+    const notProbed = connections > 0 && !probed ? " Reachability was not probed." : "";
+    return {
+        ...base,
+        status: found.length > 0 ? "warn" : "pass",
+        message: found.length > 0 ? `${counts}: ${found.join("; ")}.${notProbed}` : `${counts}, all ready.${notProbed}`,
+    };
+}
+export async function runConnectionsAndHarnessesCheck(deps = {}) {
+    const config = deps.loadConfig?.() ?? loadConfig();
+    const which = deps.which ?? defaultWhich;
+    const reachability = deps.probeReachable ? await probeConnections(config, deps.probeReachable) : undefined;
+    const rows = targetRows({
+        config,
+        env: deps.env,
+        which,
+        ...(reachability ? { reachability, versions: harnessVersions(config, which, deps.spawnSync ?? spawnSync) } : {}),
+    });
+    return connectionsAndHarnessesCheck(rows, reachability !== undefined, ambiguousDefaultAdvice(config));
+}

package/dist/commands/health/egress.js

@@ -34,10 +34,10 @@ export function collectEgressAdvisory(config) {
             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)
+    for (const [name, connection] of Object.entries(config.connections ?? {})) {
+        if (!connection?.endpoint)
             continue;
-        endpoints.push(`llm ${name}: ${engine.endpoint}`);
+        endpoints.push(`connection ${name}: ${connection.endpoint}`);
     }
     if (config.embedding?.endpoint)
         endpoints.push(`embedding: ${config.embedding.endpoint}`);

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

@@ -156,7 +156,7 @@ function renderExecSummary(vm) {
         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>`),
         li("Pending proposals", String(vm.proposals.length)),
-        li("Semantic search", vm.sem.blocked ? "BLOCKED" : "OK"),
+        li("Semantic search", vm.sem.label),
     ].join("");
     const overallEmoji = vm.trend.overall === "improving" ? "📈" : vm.trend.overall === "degrading" ? "📉" : "↔️";
     const verdictSentence = `${vm.verdictWord} — ${esc(vm.verdictRest)}.`;
@@ -199,9 +199,8 @@ function renderExecSummary(vm) {
  * last).
  */
 function renderKpiCards(vm) {
-    const semValue = vm.sem.blocked ? "BLOCKED" : "OK";
-    const semColor = vm.sem.blocked ? "red" : "green";
-    const semStyle = vm.sem.blocked ? "font-size:18px;" : "";
+    const semColor = { pass: "green", warn: "yellow", fail: "red", unknown: "neutral" }[vm.sem.status];
+    const semStyle = vm.sem.label.length > 3 ? "font-size:18px;" : "";
     const completionColor = vm.completionPct >= 99 ? "green" : vm.completionPct >= 90 ? "yellow" : "red";
     const kpiCard = (color, label, value, sub, valueStyle = "") => `<div class="kpi-card ${color}">
       <div class="label">${label}</div>
@@ -217,7 +216,7 @@ function renderKpiCards(vm) {
         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`),
-        kpiCard(semColor, "Semantic Search", semValue, esc(vm.sem.detail), semStyle),
+        kpiCard(semColor, "Semantic Search", vm.sem.label, esc(vm.sem.detail), semStyle),
         kpiCard(vm.proposals.length > 0 ? "yellow" : "neutral", "Pending Proposals", String(vm.proposals.length), `from ${esc(vm.window)} batch`),
     ].join("\n");
 }
@@ -278,15 +277,15 @@ function renderActionItems(vm) {
             remedy: `akm health --since=${vm.window} --group-by run`,
         });
     }
-    // Semantic search blocked.
-    if (vm.sem.blocked) {
+    // Semantic search blocked or unavailable.
+    if (vm.sem.status === "fail") {
         pushItem({
             key: "semantic-search-blocked",
             prio: "P2",
             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 list",
+            title: `Semantic search ${vm.sem.label.toLowerCase()}`,
+            descHtml: `${esc(vm.sem.detail)} Curate falls back to keyword search — relevance scoring degraded.`,
+            remedy: "akm index --full --verbose",
         });
     }
     // Pending proposals to drain.

package/dist/commands/health/plugin-staleness.js

@@ -38,10 +38,10 @@
  * That query is a `git ls-remote --tags` (lists refs; fetches nothing,
  * writes nothing) with a short timeout, and any failure (offline, no
  * remote, timeout) degrades to "installed version reported, no staleness
- * claim" rather than a false positive or a hang. Unlike `cli-version`, this
- * check is NOT gated behind `--probe`/`--no-probe` — it predates that flag
- * and stays unconditional; see `./version-drift.ts` for why the newer check
- * chose the opposite default.
+ * claim" rather than a false positive or a hang. Like `cli-version`, this
+ * check is gated behind `--probe`/`--no-probe`: with probing off the remote is
+ * not asked, the row reports `unknown` ("not probed") and only the local range
+ * check (3) runs.
  *
  * Every collector here is best-effort and silent on missing/unreadable
  * input: no Claude plugin installed, no marketplace clone, an unreadable
@@ -53,6 +53,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { OPENCODE_V1, OPENCODE_V2, readPackageVersion, } from "../../integrations/harnesses/opencode/plugin-layout.js";
+import { opencodeCacheDir } from "../../integrations/harnesses/opencode/roots.js";
 import { isExactSemver, isSemverRange, maxSatisfying, satisfiesRange } from "../../registry/semver.js";
 /**
  * Root directory holding Claude Code's plugin cache + marketplace clones.
@@ -72,8 +73,8 @@ function claudePluginsDir() {
  * sharing the host's databases with every other akm install — its version
  * lag matters the same way a stale Claude plugin's does.
  */
-function opencodeCacheDir() {
-    return process.env.AKM_OPENCODE_CACHE_DIR ?? path.join(os.homedir(), ".cache", "opencode");
+function defaultOpencodeCacheRoot() {
+    return process.env.AKM_OPENCODE_CACHE_DIR ?? opencodeCacheDir();
 }
 const OPENCODE_PLUGIN_LOCATIONS = [
     {
@@ -245,8 +246,9 @@ export function collectPluginStalenessAdvisories(options) {
     const pluginsRoot = options.pluginsRoot ?? claudePluginsDir();
     const listRemoteTags = options.listRemoteTags ?? realListRemoteTags;
     const plugins = detectInstalledPlugins(pluginsRoot);
-    const results = plugins.map((plugin) => buildAdvisory(plugin, options.cliVersion, pluginsRoot, listRemoteTags));
-    const opencodeCacheRoot = options.opencodeCacheRoot ?? opencodeCacheDir();
+    const probe = options.probe ?? true;
+    const results = plugins.map((plugin) => buildAdvisory(plugin, options.cliVersion, pluginsRoot, listRemoteTags, probe));
+    const opencodeCacheRoot = options.opencodeCacheRoot ?? defaultOpencodeCacheRoot();
     for (const plugin of OPENCODE_PLUGIN_LOCATIONS) {
         for (const bundled of findBundledAkm(plugin, opencodeCacheRoot)) {
             results.push(buildOpencodeBundledAdvisory(plugin, bundled, options.cliVersion));
@@ -254,13 +256,13 @@ export function collectPluginStalenessAdvisories(options) {
     }
     return results;
 }
-function buildAdvisory(plugin, cliVersion, pluginsRoot, listRemoteTags) {
+function buildAdvisory(plugin, cliVersion, pluginsRoot, listRemoteTags, probe) {
     const pluginRef = `${plugin.pluginName}@${plugin.marketplace}`;
     // Point 2: newest available vs. installed, via the marketplace clone's remote.
     const marketplaceDir = path.join(pluginsRoot, "marketplaces", plugin.marketplace);
     let availableVersion;
     try {
-        const tags = fs.existsSync(marketplaceDir) ? listRemoteTags(marketplaceDir) : undefined;
+        const tags = probe && fs.existsSync(marketplaceDir) ? listRemoteTags(marketplaceDir) : undefined;
         availableVersion = tags && tags.length > 0 ? maxSatisfying(tags, "*") : undefined;
     }
     catch {
@@ -274,6 +276,8 @@ function buildAdvisory(plugin, cliVersion, pluginsRoot, listRemoteTags) {
     const rangeKnown = versionRange !== undefined && isSemverRange(versionRange);
     const admitted = rangeKnown ? satisfiesRange(cliVersion, versionRange) : undefined;
     const messageParts = [`${pluginRef}: installed ${plugin.version}`];
+    if (!probe)
+        messageParts.push("newest tag was not probed");
     if (availableVersion !== undefined) {
         messageParts.push(stale ? `available ${availableVersion} (STALE)` : `available ${availableVersion} (up to date)`);
     }
@@ -285,7 +289,9 @@ function buildAdvisory(plugin, cliVersion, pluginsRoot, listRemoteTags) {
     return {
         name: "plugin-version",
         kind: "deterministic",
-        status: stale || admitted === false ? "warn" : "pass",
+        // Not probed => staleness is unknown, not "up to date"; only the local
+        // range check can still warn.
+        status: stale || admitted === false ? "warn" : probe ? "pass" : "unknown",
         confidence: "high",
         message: messageParts.join(" — "),
         evidence: {
@@ -294,6 +300,7 @@ function buildAdvisory(plugin, cliVersion, pluginsRoot, listRemoteTags) {
             plugin: plugin.pluginName,
             installedVersion: plugin.version,
             availableVersion: availableVersion ?? null,
+            ...(probe ? {} : { probed: false }),
             stale,
             versionRange: versionRange ?? null,
             cliVersion,

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

@@ -121,16 +121,20 @@ function buildTrend(deltas) {
     const overall = score >= 1 ? "improving" : score <= -1 ? "degrading" : "mixed";
     return { decisionQuality, outputVolume, latency, overall };
 }
-function readSemSearch(advisories) {
-    const check = advisories.find((a) => a.name === "semantic-search-runtime");
+function readSemSearch(hardChecks) {
+    const check = hardChecks.find((c) => c.name === "semantic-search");
     if (!check)
-        return { blocked: false, detail: "" };
-    const evidence = check.evidence ?? {};
-    const status = String(evidence.status ?? "unknown");
-    const blocked = check.status !== "pass" || status.toLowerCase().includes("block");
-    const entries = typeof evidence.entryCount === "number" ? evidence.entryCount : 0;
-    const embeddings = typeof evidence.embeddingCount === "number" ? evidence.embeddingCount : 0;
-    return { blocked, detail: `${num(entries)} entries, ${num(embeddings)} embeddings` };
+        return { label: "UNKNOWN", status: "unknown", detail: "" };
+    const label = check.evidence?.status === "unavailable"
+        ? "UNAVAILABLE"
+        : check.status === "fail"
+            ? "BLOCKED"
+            : check.status === "unknown"
+                ? "UNKNOWN"
+                : check.evidence?.mode === "off"
+                    ? "OFF"
+                    : "OK";
+    return { label, status: check.status, detail: check.message };
 }
 // ── Report-window → time-slice candidates (data only; HTML wrapping is the
 //    renderer's job) ─────────────────────────────────────────────────────────
@@ -265,8 +269,8 @@ function buildVerdictPhase(result, trend, sem, proposals, failedRuns) {
     const concerns = [];
     if (failedRuns > 0)
         concerns.push(`${failedRuns} failed run${failedRuns === 1 ? "" : "s"}`);
-    if (sem.blocked)
-        concerns.push("semantic search blocked");
+    if (sem.status === "fail")
+        concerns.push(`semantic search ${sem.label.toLowerCase()}`);
     if (proposals.length > 0)
         concerns.push(`${proposals.length} pending proposal${proposals.length === 1 ? "" : "s"}`);
     const trendClause = trend.overall === "improving"
@@ -371,7 +375,7 @@ export function buildHealthReportViewModel(result, opts) {
     const deltas = opts.deltas ?? {};
     const proposals = opts.proposals;
     const runsPhase = partitionRuns(result);
-    const sem = readSemSearch(result.advisories);
+    const sem = readSemSearch(result.hardChecks);
     const trend = buildTrend(deltas);
     const aggregates = buildAggregatesPhase(result, runsPhase);
     const meta = buildMetaPhase(result, runsPhase.runs);

package/dist/commands/health/scheduler-binary.js

@@ -10,7 +10,7 @@
  * stale after upgrading akm through a different installer than the one
  * active at the last `task sync` (e.g. npm-global to a standalone binary):
  * the schedule kept invoking a version behind, with nothing in `akm health`
- * surfacing it, until an unrelated failure (a rejected `secret://` engine
+ * surfacing it, until an unrelated failure (a rejected `${ref}` engine
  * key on the stale binary) surfaced the drift.
  *
  * Modelled 1:1 on `version-drift.ts`'s shape: an injectable seam,

package/dist/commands/health/semantic-search-check.js

@@ -0,0 +1,85 @@
+// 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/.
+/**
+ * `semantic-search` for `akm health`: what the last `akm index` recorded about
+ * semantic search (status, embedding runtime, the reason it failed), with the
+ * index's own entry and vector counts read now. It loads no model and makes no
+ * request, and nothing gates search on it (#873 removed the cached verdict
+ * search used to obey); it reports what the index says.
+ */
+import { getDbPath } from "../../core/paths.js";
+import { SEMANTIC_SEARCH_META_KEY } from "../../indexer/walk/index-context.js";
+import { LOCAL_EMBEDDING_RUNTIME } from "../../llm/embedders/local.js";
+import { closeDatabase, openReadonlyExistingDatabase } from "../../storage/repositories/index-connection.js";
+import { getEmbeddableEntryCount } from "../../storage/repositories/index-entries-repository.js";
+import { getMeta } from "../../storage/repositories/index-meta-repository.js";
+import { getEmbeddingCount } from "../../storage/repositories/index-vec-repository.js";
+/** Read the last index run's record and the index's counts, read-only. */
+export function readSemanticSearchState(mode) {
+    try {
+        const db = openReadonlyExistingDatabase(getDbPath());
+        if (!db)
+            return { mode };
+        try {
+            const raw = getMeta(db, SEMANTIC_SEARCH_META_KEY);
+            return {
+                mode,
+                index: {
+                    ...(raw ? { record: JSON.parse(raw) } : {}),
+                    builtAt: getMeta(db, "builtAt"),
+                    entryCount: getEmbeddableEntryCount(db),
+                    embeddingCount: getEmbeddingCount(db),
+                },
+            };
+        }
+        finally {
+            closeDatabase(db);
+        }
+    }
+    catch (error) {
+        return { mode, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+export function semanticSearchCheck(state) {
+    const result = (status, message, evidence) => ({
+        name: "semantic-search",
+        kind: "deterministic",
+        status,
+        confidence: "high",
+        message,
+        ...(evidence ? { evidence } : {}),
+    });
+    if (state.mode === "off")
+        return result("pass", "Semantic search is off (semanticSearchMode: off).", { mode: "off" });
+    if (state.error)
+        return result("unknown", `Could not read the index: ${state.error}`);
+    const index = state.index;
+    if (!index?.record)
+        return result("unknown", "No semantic-search state recorded yet; run `akm index`.");
+    const { record, builtAt, entryCount, embeddingCount } = index;
+    const evidence = { ...record, ...(builtAt ? { builtAt } : {}), entryCount, embeddingCount };
+    const asOf = builtAt ? ` at the last index (${builtAt})` : " at the last index";
+    switch (record.status) {
+        case "unavailable":
+            // No native library for this platform is not something to fix: keyword search is the healthy state there.
+            return record.unavailable === "platform"
+                ? result("warn", `Semantic search is unavailable on this platform: ${record.reason} ` +
+                    'Set semanticSearchMode to "off", or embedding.endpoint to a remote embedding service.', evidence)
+                : result("fail", `Semantic search was unavailable on this machine${asOf}: ${record.reason}`, evidence);
+        case "blocked":
+            return result("fail", `Semantic search was blocked${asOf}: ${record.reason}`, evidence);
+        case "ready-js":
+            if (embeddingCount < entryCount) {
+                return result("warn", `Embeddings lag entries (${embeddingCount}/${entryCount}); run \`akm index\` to embed the rest.`, evidence);
+            }
+            if (record.provider === "local" && record.runtime && record.runtime !== LOCAL_EMBEDDING_RUNTIME) {
+                return result("warn", `Local embeddings ran on ${record.runtime}, not the native ${LOCAL_EMBEDDING_RUNTIME}${asOf}.`, evidence);
+            }
+            return result("pass", `Semantic search ready (${embeddingCount}/${entryCount} embeddings${record.runtime ? ` on ${record.runtime}` : ""}).`, evidence);
+        case "disabled":
+            return result("unknown", `Semantic search was off${asOf}; run \`akm index\` to build it.`, evidence);
+        default:
+            return result("unknown", `No entries were indexed${asOf}.`, evidence);
+    }
+}

package/dist/commands/health/type-directory-check.js

@@ -94,9 +94,6 @@ function explainOverride(resolvedType, content) {
     if (fm.type === "workflow" && resolvedType === "workflow") {
         return { winner: "smart-md:workflow-frontmatter", knownGoodOverride: true };
     }
-    if ("tools" in fm && resolvedType === "agent") {
-        return { winner: "smart-md:tools-frontmatter", knownGoodOverride: true };
-    }
     if ("agent" in fm && resolvedType === "command") {
         return { winner: "smart-md:agent-frontmatter", knownGoodOverride: true };
     }

package/dist/commands/health.js

@@ -14,7 +14,6 @@ import { probeLlmEndpoint } from "../llm/client.js";
 import { openDatabase } from "../storage/database.js";
 import { insertEvent } from "../storage/repositories/events-repository.js";
 import { getExtractOutcomeCountsSince } from "../storage/repositories/extract-sessions-repository.js";
-import { countImproveRunsSince } from "../storage/repositories/improve-runs-repository.js";
 import { closeDatabase, openReadonlyExistingDatabase } from "../storage/repositories/index-connection.js";
 import { getAllEntries } from "../storage/repositories/index-entries-repository.js";
 import { queryTaskHistory } from "../storage/repositories/task-history-repository.js";
@@ -22,15 +21,16 @@ import { applyReadonlyPragmas } from "../storage/sqlite-pragmas.js";
 import { getStateDbFreelistInfo, runStateDbIntegrityCheck } from "../storage/state-db-integrity.js";
 import { pkgVersion } from "../version.js";
 import { collectArchiveUsageAdvisory } from "./health/archive-usage.js";
-import { HEALTH_CHECKS, probeActiveImproveStrategy, runHealthEngineProbes, runPendingStateMigrationsCheck, SESSION_EXTRACTION_LEDGER_WINDOW_DAYS, } from "./health/checks.js";
+import { HEALTH_CHECKS, runPendingStateMigrationsCheck, SESSION_EXTRACTION_LEDGER_WINDOW_DAYS, } from "./health/checks.js";
 import { collectConfigSkewAdvisory } from "./health/config-skew.js";
+import { runConnectionsAndHarnessesCheck } from "./health/connections-and-harnesses-check.js";
 import { collectDataDirUsageAdvisory } from "./health/data-dir-usage.js";
 import { collectEgressAdvisory } from "./health/egress.js";
-import { engineLastUsedSince, readLastEngineUsage } from "./health/engine-usage.js";
 import { emptyImproveMetrics, roundRate } from "./health/improve-metrics.js";
 import { emptyLlmUsageAggregate, readLlmUsageAggregate } from "./health/llm-usage.js";
 import { collectPluginStalenessAdvisories } from "./health/plugin-staleness.js";
 import { collectSchedulerBinaryAdvisory } from "./health/scheduler-binary.js";
+import { readSemanticSearchState } from "./health/semantic-search-check.js";
 import { collectStashExposureAdvisory } from "./health/stash-exposure.js";
 import { buildTypeDirectoryAdvisory } from "./health/type-directory-check.js";
 import { MIN_ROWS_FOR_WORST_TASK_FAIL_RATE, } from "./health/types.js";
@@ -189,7 +189,7 @@ function gatherTaskHistoryPhase(db, since, stateDbPath, now, readOnly) {
     // bad index entry counts), and the freelist reading is purely informational.
     const stateDbIntegrity = runStateDbIntegrityCheck(stateDbPath);
     const stateDbFreelist = getStateDbFreelistInfo(stateDbPath);
-    // D8 (spec §5.3): a marked "command" row or a legacy (unmarked) "prompt"
+    // A marked "command" row or a legacy (unmarked) "prompt"
     // row is the agent/LLM arm; an unmarked "command" row is the legacy
     // native shell/script arm and must not be counted here (see
     // isAgentTaskHistoryRow's header comment, referenced from
@@ -212,24 +212,25 @@ function gatherTaskHistoryPhase(db, since, stateDbPath, now, readOnly) {
     };
 }
 /**
- * Config fields the surfaces advisory and (#949) the `thinking-control`
- * check need. Best-effort: an unloadable config leaves both fields at their
- * empty fallback and the callers degrade to their generic/unknown states.
+ * The config view the surfaces advisory needs. Best-effort: an unloadable
+ * config leaves it undefined and the advisory degrades to its generic state.
  */
-function gatherEgressConfigPhase() {
-    let egressConfigView;
-    let thinkingOffEngines = [];
+function gatherEgressConfigView() {
     try {
-        const config = loadConfig();
-        egressConfigView = config;
-        thinkingOffEngines = Object.entries(config.engines ?? {})
-            .filter(([, engine]) => engine.kind === "llm" && engine.enableThinking === false)
-            .map(([name]) => name);
+        return loadConfig();
     }
     catch {
-        // fall through with undefined/empty
+        return undefined;
+    }
+}
+/** The configured `semanticSearchMode`; undefined when the config cannot load. */
+function gatherSemanticSearchMode() {
+    try {
+        return loadConfig().semanticSearchMode;
+    }
+    catch {
+        return undefined;
     }
-    return { egressConfigView, thinkingOffEngines };
 }
 /** Extract-ledger outcome counts for the `session-extraction` check's window, independent of `--since`. */
 function gatherSessionExtractionLedgerPhase(db, now) {
@@ -323,9 +324,9 @@ function gatherAncillaryAdvisories(db, options, egressConfigView) {
     // and warn when stale or when the plugin's own akm-cli version range no
     // longer admits this CLI. Best-effort — no plugin installed, an unreadable
     // manifest, or a network failure while checking the newest tag must not
-    // abort the health report.
+    // abort the health report. The newest-tag lookup honors `--no-probe`.
     try {
-        advisories.push(...collectPluginStalenessAdvisories({ cliVersion: pkgVersion }));
+        advisories.push(...collectPluginStalenessAdvisories({ cliVersion: pkgVersion, probe: Boolean(options.probe) }));
     }
     catch {
         // Non-fatal.
@@ -582,9 +583,11 @@ export async function akmHealth(options = {}) {
     try {
         const { windowResults, deltas } = resolveWindowComparePhase(options, db, stateDbPath, now);
         // Network probes overlap the local database phases below; awaited where consumed.
-        const engineProbesPromise = runHealthEngineProbes({ probeReachable: options.probe ? probeLlmEndpoint : undefined });
-        engineProbesPromise.catch(() => undefined);
-        // #950: same best-effort, --probe-gated discipline as engineProbesPromise
+        const connectionsAndHarnessesPromise = runConnectionsAndHarnessesCheck({
+            probeReachable: options.probe ? probeLlmEndpoint : undefined,
+        });
+        connectionsAndHarnessesPromise.catch(() => undefined);
+        // #950: same best-effort, --probe-gated discipline as connectionsAndHarnessesPromise
         // above — started here, alongside it, and awaited later.
         const versionDriftPromise = collectVersionDriftAdvisory(Boolean(options.probe), { cliVersion: pkgVersion });
         versionDriftPromise.catch(() => undefined);
@@ -596,7 +599,7 @@ export async function akmHealth(options = {}) {
         schedulerBinaryDriftPromise.catch(() => undefined);
         const taskHistory = gatherTaskHistoryPhase(db, since, stateDbPath, now, readOnly);
         const { tableNames, missingTables, probe } = taskHistory;
-        const { egressConfigView, thinkingOffEngines } = gatherEgressConfigPhase();
+        const egressConfigView = gatherEgressConfigView();
         // Same window bundle `--window-compare` builds per-window (windows.ts) —
         // reused here for the main `--since` window's improve summary and for
         // `--group-by run`, so neither re-reads `improve_runs`.
@@ -604,20 +607,10 @@ export async function akmHealth(options = {}) {
         const { improve: improveSummary, perRunSummaries } = buildImproveWindowSummary(db, stateDbPath, since, until, readOnly);
         advisories.push(...gatherAncillaryAdvisories(db, options, egressConfigView));
         const sessionExtractionLedger = gatherSessionExtractionLedgerPhase(db, now);
-        // #950: computed once (no IO beyond config/env, same as gatherEgressConfigPhase)
-        // so `active-improve-strategy` and `engine-last-used` project the same
-        // process→engine map instead of each resolving the strategy independently.
-        const { check: activeImproveStrategy, processEngines: activeImproveStrategyEngines } = probeActiveImproveStrategy();
-        // #950: `engine-last-used` reads a fixed lookback window independent of
-        // `--since` (mirrors sessionExtractionLedger's independent window above).
-        const engineLastUsedSinceIso = engineLastUsedSince(now);
-        const engineLastUsed = readLastEngineUsage(stateDbPath, now, readOnly);
-        const improveRunsInLookbackWindow = countImproveRunsSince(db, engineLastUsedSinceIso);
-        const engineProbes = await engineProbesPromise;
+        const connectionsAndHarnesses = await connectionsAndHarnessesPromise;
         const versionDrift = await versionDriftPromise;
         const schedulerBinaryDrift = await schedulerBinaryDriftPromise;
-        // Read once, shared by the `thinking-control` check (#949) and the
-        // `metrics.llmUsage` report field below — same window, same aggregate.
+        // The `metrics.llmUsage` report field below.
         const llmUsage = readLlmUsageAggregate(stateDbPath, since, undefined, readOnly);
         // Run the ordered health-check registry. Each check projects the shared
         // context computed above into one HealthCheckResult; `channel` routes it to
@@ -640,14 +633,9 @@ export async function akmHealth(options = {}) {
             agentFailureReasonCounts: taskHistory.agentFailureReasonCounts,
             sessionExtractionLedger,
             autoAccept: improveSummary.autoAccept,
-            engineProbes,
-            thinkingOffEngines,
-            llmUsage,
+            connectionsAndHarnesses,
+            semanticSearch: readSemanticSearchState(gatherSemanticSearchMode()),
             versionDrift,
-            activeImproveStrategy,
-            activeImproveStrategyEngines,
-            engineLastUsed,
-            improveRunsInLookbackWindow,
             schedulerBinaryDrift,
         };
         for (const check of HEALTH_CHECKS) {