akm-cli 0.9.17-alpha.3 → 0.9.17-alpha.4

package/dist/commands/health/checks.js

@@ -10,7 +10,7 @@ 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";
@@ -784,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);
@@ -817,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
@@ -890,7 +905,9 @@ export const HEALTH_CHECKS = [
                     status: "fail",
                     confidence: "high",
                     message: `state.db failed PRAGMA quick_check: ${detail}. Repair: back up state.db, then run ` +
-                        `sqlite3 state.db ".dump" | sqlite3 state.new.db, verify state.new.db passes quick_check, and swap it in.`,
+                        `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 },
                 };
             }
@@ -925,7 +942,7 @@ export const HEALTH_CHECKS = [
     {
         name: "state-db-migrations",
         channel: "hard",
-        run: (ctx) => runPendingStateMigrationsCheck(ctx.stateDbPath),
+        run: (ctx) => appliedStateMigrationsCheck(ctx.stateDbPath, ctx.stateDbMigrations),
     },
     {
         name: "task-history-read",
@@ -939,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",
@@ -1127,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/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

@@ -331,44 +331,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")