akm-cli 0.9.0-beta.9 → 0.9.0-rc.0

package/dist/commands/health/checks.js

@@ -4,6 +4,7 @@
 import { spawnSync } from "node:child_process";
 import { loadConfig } from "../../core/config/config.js";
 import { detectAgentCliProfiles, requireAgentProfile } from "../../integrations/agent/index.js";
+import { TASK_FAIL_RATE_WARN, } from "./types.js";
 const ACTIVE_RUN_WARN_MS = 15 * 60 * 1000;
 /**
  * Probe the configured agent profile. Self-contained (reads config + PATH); the
@@ -188,24 +189,62 @@ export const HEALTH_CHECKS = [
         channel: "hard",
         run: () => runAgentProbe(),
     },
+    {
+        // C2 (13-bus-factor): the cron task-failure rate was computed and rendered
+        // in the HTML report but never surfaced as an advisory, so a sustained
+        // 15–16% fail rate stayed invisible on `akm health`. Warn at/above the SAME
+        // 5% threshold the html-report badge uses (see TASK_FAIL_RATE_WARN).
+        name: "task-fail-rate",
+        channel: "advisory",
+        run: (ctx) => {
+            const pctStr = `${(ctx.taskFailRate * 100).toFixed(1)}%`;
+            const thresholdPct = `${(TASK_FAIL_RATE_WARN * 100).toFixed(0)}%`;
+            const warn = ctx.taskFailRate >= TASK_FAIL_RATE_WARN;
+            return {
+                name: "task-fail-rate",
+                kind: "deterministic",
+                status: warn ? "warn" : "pass",
+                confidence: "high",
+                message: ctx.taskRowCount === 0
+                    ? `No cron tasks ran since ${ctx.since} — no task-fail-rate signal.`
+                    : warn
+                        ? `Cron task fail rate ${pctStr} across ${ctx.taskRowCount} task(s) since ${ctx.since} ≥ ${thresholdPct} threshold — inspect failed runs (ok=false) for early-exit/harness errors.`
+                        : `Cron task fail rate ${pctStr} across ${ctx.taskRowCount} task(s) since ${ctx.since} (below ${thresholdPct} threshold).`,
+                evidence: { taskFailRate: ctx.taskFailRate, taskRowCount: ctx.taskRowCount, threshold: TASK_FAIL_RATE_WARN },
+            };
+        },
+    },
     {
         name: "semantic-search-runtime",
         channel: "advisory",
-        run: (ctx) => ({
-            name: "semantic-search-runtime",
-            kind: "deterministic",
-            status: !ctx.semanticStatus ||
-                ctx.semanticStatus.status === "pending" ||
-                ctx.semanticStatus.status === "ready-js" ||
-                ctx.semanticStatus.status === "ready-vec"
-                ? "pass"
-                : "warn",
-            confidence: "medium",
-            message: ctx.semanticStatus
-                ? `Semantic search status: ${ctx.semanticStatus.status}`
-                : "No semantic-search runtime status recorded yet.",
-            evidence: ctx.semanticStatus ? { ...ctx.semanticStatus } : undefined,
-        }),
+        run: (ctx) => {
+            const blocked = ctx.semanticStatus?.status === "blocked";
+            // The generic "status: blocked" line is not actionable when the real
+            // problem is a configured remote embedding endpoint that is down while
+            // semanticSearchMode leaves semantic search enabled — every index run
+            // burns time failing against it and searches silently degrade to
+            // keyword-only. Name the endpoint and the two ways out.
+            const remoteReason = ctx.semanticStatus?.reason?.startsWith("remote-") === true;
+            const endpointAdvisory = blocked && remoteReason && ctx.embeddingEndpoint
+                ? `Configured embedding endpoint ${ctx.embeddingEndpoint} is failing ` +
+                    `(${ctx.semanticStatus?.reason}${ctx.semanticStatus?.message ? `: ${ctx.semanticStatus.message}` : ""}) ` +
+                    `while semanticSearchMode is "${ctx.semanticSearchMode ?? "auto"}". Searches fall back to keyword-only. ` +
+                    `Restore the endpoint, or set semanticSearchMode to "off" (or remove embedding.endpoint to use the local model).`
+                : undefined;
+            return {
+                name: "semantic-search-runtime",
+                kind: "deterministic",
+                status: !ctx.semanticStatus || !blocked ? "pass" : "warn",
+                confidence: "medium",
+                message: endpointAdvisory ??
+                    (ctx.semanticStatus
+                        ? `Semantic search status: ${ctx.semanticStatus.status}`
+                        : "No semantic-search runtime status recorded yet."),
+                evidence: ctx.semanticStatus
+                    ? { ...ctx.semanticStatus, ...(ctx.embeddingEndpoint ? { embeddingEndpoint: ctx.embeddingEndpoint } : {}) }
+                    : undefined,
+            };
+        },
     },
     {
         // session-log-failures: demoted to informational — the ERROR_PATTERNS regex
@@ -257,6 +296,54 @@ 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",
@@ -268,7 +355,7 @@ export const HEALTH_CHECKS = [
                 status: aa.validationFailed > 0 ? "warn" : "pass",
                 confidence: aa.promoted + aa.validationFailed > 0 ? "high" : "low",
                 message: aa.validationFailed > 0
-                    ? `${aa.validationFailed} proposal(s) passed confidence threshold but failed auto-accept validation (truncated description, invalid frontmatter, etc.) — they remain in the queue for manual review.`
+                    ? `${aa.validationFailed} auto-accept validation attempt(s) failed after passing the confidence threshold (truncated description, invalid frontmatter, etc.) — the affected proposals remain pending for manual review.`
                     : aa.promoted > 0
                         ? `Auto-accept healthy: ${aa.promoted} proposal(s) promoted, 0 validation failures.`
                         : "Auto-accept gate did not run (disabled or no proposals above threshold).",