akm-cli 0.9.16 → 0.9.17-alpha.10

package/dist/commands/health.js

@@ -5,36 +5,35 @@ import fs from "node:fs";
 import path from "node:path";
 import { daysToMs, resolveStashDir } from "../core/common.js";
 import { loadConfig } from "../core/config/config.js";
-import { ConfigError, UsageError } from "../core/errors.js";
-import { readEvents } from "../core/events.js";
-import { openLogsDatabase } from "../core/logs-db.js";
+import { ConfigError, rethrowIfTestIsolationError, UsageError } from "../core/errors.js";
 import { classifyPathAccess, describeInaccessiblePath } from "../core/path-access.js";
 import { getConfigPath, getDataDir, getDbPath, getStateDbPathInDataDir } from "../core/paths.js";
-import { listExistingTableNames, listPendingStateMigrations, openStateDatabase } from "../core/state-db.js";
+import { listExistingTableNames, listPendingStateMigrations, openStateDatabaseWithReport, withStateDb, } from "../core/state-db.js";
 import { DURATION_UNITS, parseDuration, parseSinceToIso } from "../core/time.js";
 import { probeLlmEndpoint } from "../llm/client.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";
+import { getStateDbFreelistInfo, runStateDbQuickCheck } from "../storage/state-db-integrity.js";
 import { pkgVersion } from "../version.js";
-import { collectImproveAdvisories } from "./health/advisories.js";
+import { collectArchiveUsageAdvisory } from "./health/archive-usage.js";
 import { HEALTH_CHECKS, probeActiveImproveStrategy, runHealthEngineProbes, runPendingStateMigrationsCheck, SESSION_EXTRACTION_LEDGER_WINDOW_DAYS, } from "./health/checks.js";
+import { collectConfigSkewAdvisory } from "./health/config-skew.js";
 import { collectDataDirUsageAdvisory } from "./health/data-dir-usage.js";
+import { collectEgressAdvisory } from "./health/egress.js";
 import { engineLastUsedSince, readLastEngineUsage } from "./health/engine-usage.js";
-import { buildImproveSkipSummary, computeWallTimeStats, countAgentFailureReasons, isAgentTaskHistoryRow, roundRate, summarizeImproveCompleted, summarizeImproveRuns, taskFailureDetail, } from "./health/improve-metrics.js";
+import { emptyImproveMetrics, roundRate } from "./health/improve-metrics.js";
 import { emptyLlmUsageAggregate, readLlmUsageAggregate } from "./health/llm-usage.js";
-import { computeDegradationMetrics, computeDenominatorFixedCoverage, computeEnrichmentMintingRollup, probeStateDbRoundTrip, } from "./health/metrics.js";
 import { collectPluginStalenessAdvisories } from "./health/plugin-staleness.js";
 import { collectSchedulerBinaryAdvisory } from "./health/scheduler-binary.js";
 import { collectStashExposureAdvisory } from "./health/stash-exposure.js";
-import { collectSurfacesAdvisories } from "./health/surfaces.js";
-import { buildPerRunSummaries } from "./health/task-runs.js";
 import { buildTypeDirectoryAdvisory } from "./health/type-directory-check.js";
-import { ACTIVE_RUN_WARN_MS, IMPROVE_COMPLETED_EVENT, MIN_ROWS_FOR_WORST_TASK_FAIL_RATE, } from "./health/types.js";
+import { MIN_ROWS_FOR_WORST_TASK_FAIL_RATE, } from "./health/types.js";
 import { collectVersionDriftAdvisory } from "./health/version-drift.js";
-import { buildWindowMetrics, computeDeltas, partitionLogBackedRows, resolveWindowCompare } from "./health/windows.js";
+import { buildImproveWindowSummary, buildWindowMetrics, computeDeltas, computeTaskWindowRates, resolveWindowCompare, } from "./health/windows.js";
 const DEFAULT_SINCE_MS = 24 * 60 * 60 * 1000;
 export function parseHealthSince(since) {
     if (since === undefined || since.trim() === "") {
@@ -71,6 +70,65 @@ function validateAkmHealthOptions(options) {
         }
     }
 }
+// ── akmHealth phase helpers (chunk-9 WI-9.5b; file-level decompose following
+// the function's natural gather/advise/check/assemble phases) ───────────────
+/** Event type appended + read back by the state.db round-trip probe. */
+const HEALTH_PROBE_EVENT = "health_probe";
+/** Synthetic sentinel ref (ref-grammar decision D-R3): a colon-free
+ * `<subsystem>/_<marker>` label. `health` has no asset stash-subdir, so
+ * `health/_probe` names the subsystem. */
+const HEALTH_PROBE_REF = "health/_probe";
+/**
+ * Verify state.db can accept a write and read it back — WITHOUT leaving any
+ * permanent trace (R-030). Earlier versions appended a `health_probe` event
+ * on every `akm health` invocation and never removed it: a read-only health
+ * check ran on a cron would grow state.db without bound (the only purge is
+ * `improve`'s retention pass, which a health-only user never runs). The probe
+ * row inserted here is deleted again inside the SAME connection once the
+ * round trip is confirmed, so the net effect on the `events` table is always
+ * zero rows — the round trip still genuinely exercises append + read against
+ * the real table, it just doesn't accumulate.
+ */
+export function probeStateDbRoundTrip(stateDbPath) {
+    const started = Date.now();
+    try {
+        return withStateDb((db) => {
+            const ts = new Date().toISOString();
+            const insertedId = insertEvent(db, {
+                eventType: HEALTH_PROBE_EVENT,
+                ts,
+                ref: HEALTH_PROBE_REF,
+                metadata: { source: "akm health" },
+            });
+            const durationMs = Date.now() - started;
+            if (insertedId === undefined) {
+                return { ok: false, durationMs, error: "probe event insert did not return a row id" };
+            }
+            // The round-trip matches on the exact (id, eventType, ref) triple
+            // written above, then removes the row regardless of outcome — a
+            // failed round trip must not leak a row any more than a successful
+            // one should.
+            let roundTripOk = false;
+            try {
+                const row = db
+                    .prepare("SELECT 1 AS present FROM events WHERE id = ? AND event_type = ? AND ref = ?")
+                    .get(insertedId, HEALTH_PROBE_EVENT, HEALTH_PROBE_REF);
+                roundTripOk = row !== undefined;
+            }
+            finally {
+                db.prepare("DELETE FROM events WHERE id = ?").run(insertedId);
+            }
+            if (!roundTripOk) {
+                return { ok: false, durationMs, error: "probe event was not readable after append" };
+            }
+            return { ok: true, durationMs };
+        }, { path: stateDbPath });
+    }
+    catch (err) {
+        rethrowIfTestIsolationError(err);
+        return { ok: false, durationMs: Date.now() - started, error: err instanceof Error ? err.message : String(err) };
+    }
+}
 /**
  * Item 7: dedupe stuck-active rows by task_id (keeping the oldest/largest age
  * per id) so the `active-runs` check can name WHICH tasks are stuck instead of
@@ -118,43 +176,37 @@ function computeWorstTaskFailRate(rows) {
     return worst;
 }
 /** Table presence, the state.db round-trip probe, and task_history-derived rates. */
-function gatherTaskHistoryPhase(db, logsDb, since, stateDbPath, now) {
+function gatherTaskHistoryPhase(db, since, stateDbPath, now) {
     const tables = listExistingTableNames(db, ["events", "task_history", "proposals", "schema_migrations"]);
     const tableNames = tables.map((row) => row.name).sort();
     const requiredTables = ["events", "proposals", "schema_migrations", "task_history"];
     const missingTables = requiredTables.filter((name) => !tableNames.includes(name));
     const probe = probeStateDbRoundTrip(stateDbPath);
-    const taskRows = queryTaskHistory(db, { since });
-    const { withLogs: taskRowsWithLogs, backed: existingLogRows } = partitionLogBackedRows(taskRows, logsDb);
-    const failedTaskRows = taskRows.filter((row) => row.status === "failed");
-    const activeRows = taskRows.filter((row) => row.status === "active" && row.completed_at === null);
-    const stuckActiveRows = activeRows.filter((row) => now() - new Date(row.started_at).getTime() > ACTIVE_RUN_WARN_MS);
+    // R0: read-only, independent of the round-trip probe above — quick_check
+    // catches corruption a successful append/read cannot (out-of-order rowids,
+    // bad index entry counts), and the freelist reading is purely informational.
+    const stateDbIntegrity = runStateDbQuickCheck(stateDbPath);
+    const stateDbFreelist = getStateDbFreelistInfo(stateDbPath);
     // D8 (spec §5.3): 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 for the full mapping).
-    const agentRows = taskRows.filter((row) => isAgentTaskHistoryRow(row));
-    const agentFailures = agentRows.filter((row) => {
-        const detail = taskFailureDetail(row);
-        return typeof detail?.reason === "string" && detail.reason.length > 0;
-    });
-    const logBackingRate = taskRowsWithLogs.length === 0 ? 1 : existingLogRows.length / taskRowsWithLogs.length;
-    const taskFailRate = taskRows.length === 0 ? 0 : failedTaskRows.length / taskRows.length;
-    const agentFailureRate = agentRows.length === 0 ? 0 : agentFailures.length / agentRows.length;
+    // isAgentTaskHistoryRow's header comment, referenced from
+    // computeTaskWindowRates, for the full mapping).
+    const taskRows = queryTaskHistory(db, { since });
+    const rates = computeTaskWindowRates(taskRows, now);
     return {
         tableNames,
         missingTables,
         probe,
+        stateDbIntegrity,
+        stateDbFreelist,
         taskRowCount: taskRows.length,
-        taskRowsWithLogsCount: taskRowsWithLogs.length,
-        existingLogRowsCount: existingLogRows.length,
-        stuckActiveRuns: stuckActiveRows.length,
-        stuckActiveTasks: dedupeStuckActiveTasks(stuckActiveRows, now),
-        logBackingRate,
-        taskFailRate,
+        stuckActiveRuns: rates.stuckActiveRuns,
+        stuckActiveTasks: dedupeStuckActiveTasks(rates.stuckActiveRows, now),
+        taskFailRate: rates.taskFailRate,
         worstTaskFailRate: computeWorstTaskFailRate(taskRows),
-        agentFailureRate,
-        agentFailureReasonCounts: countAgentFailureReasons(agentFailures),
+        agentFailureRate: rates.agentFailureRate,
+        agentFailureReasonCounts: rates.agentFailureReasonCounts,
     };
 }
 /**
@@ -183,47 +235,16 @@ function gatherSessionExtractionLedgerPhase(db, now) {
     return { since, rows: getExtractOutcomeCountsSince(db, since) };
 }
 /**
- * Assemble the window's improve-pipeline summary: invoked/completed/skipped
- * counts from events, the per-run result_json aggregate, wall-time stats, and
- * the WS-5 coverage/degradation/enrichment-minting rollups.
- */
-function gatherImproveSummaryPhase(db, stateDbPath, since, now) {
-    const improveInvoked = readEvents({ since, type: "improve_invoked" }, { dbPath: stateDbPath }).events.length;
-    const improveCompletedEvents = readEvents({ since, type: IMPROVE_COMPLETED_EVENT }, { dbPath: stateDbPath }).events;
-    const improveSkippedEvents = readEvents({ since, type: "improve_skipped" }, { dbPath: stateDbPath }).events;
-    const eventsMetrics = summarizeImproveCompleted(improveCompletedEvents);
-    const { metrics: improveSummary } = summarizeImproveRuns(db, since);
-    improveSummary.invoked = improveInvoked;
-    improveSummary.completed = eventsMetrics.completed;
-    const skipSummary = buildImproveSkipSummary(improveSkippedEvents);
-    improveSummary.skipped = skipSummary.skipped;
-    improveSummary.skipReasons = skipSummary.skipReasons;
-    const perRunSummaries = buildPerRunSummaries(db, since);
-    const wallTimes = perRunSummaries.map((run) => run.wallTimeMs).filter((ms) => Number.isFinite(ms) && ms > 0);
-    improveSummary.wallTime = computeWallTimeStats(wallTimes, improveSummary.wallTime.byPhase);
-    // WS-5: Compute denominator-fixed coverage and per-run degradation metrics
-    // for the main health path (not just window-compare mode).
-    const until = new Date(now()).toISOString();
-    const totalAssetsMain = improveSummary.memorySummary.eligible + improveSummary.memorySummary.derived;
-    improveSummary.coverage = computeDenominatorFixedCoverage(db, totalAssetsMain, improveSummary.memorySummary.eligible, since, until);
-    const degradationMain = computeDegradationMetrics(db, since, until);
-    if (degradationMain) {
-        improveSummary.degradation = degradationMain;
-    }
-    improveSummary.enrichmentMinting = computeEnrichmentMintingRollup(db, since, until);
-    return { improveSummary, perRunSummaries };
-}
-/**
- * The best-effort advisory groups beyond the health-check registry: improve
- * advisories, the `stash-git-exposure` probe, the 08 surfaces group
- * (binary-config-skew, egress-endpoints), `type-directory-disagreement`
- * (#831), `data-dir-usage` (#896), and `plugin-version` (itlackey/akm#832).
- * Order matches emission order in the returned array. A probe/filesystem
- * failure in any try/catch must not abort the health report — each group
- * degrades to "no advisory" independently.
+ * The best-effort advisory groups beyond the health-check registry: the
+ * `stash-git-exposure` probe, the 08 surfaces group (binary-config-skew,
+ * egress-endpoints), `type-directory-disagreement` (#831), `data-dir-usage`
+ * (#896), and `plugin-version` (itlackey/akm#832). Order matches emission
+ * order in the returned array. A probe/filesystem failure in any try/catch
+ * must not abort the health report — each group degrades to "no advisory"
+ * independently.
  */
-function gatherAncillaryAdvisories(db, stateDbPath, since, improveSummary, options, egressConfigView) {
-    const advisories = [...collectImproveAdvisories(db, stateDbPath, since, improveSummary)];
+function gatherAncillaryAdvisories(db, options, egressConfigView) {
+    const advisories = [];
     const indexStateMismatch = detectIndexStateGenerationMismatch(db);
     if (indexStateMismatch)
         advisories.push(indexStateMismatch);
@@ -250,10 +271,12 @@ function gatherAncillaryAdvisories(db, stateDbPath, since, improveSummary, optio
     // egress-endpoints). Best-effort — a filesystem probe failure must not abort
     // the health report.
     try {
-        advisories.push(...collectSurfacesAdvisories({
-            configPath: getConfigPath(),
-            config: egressConfigView,
-        }));
+        const configSkew = collectConfigSkewAdvisory(getConfigPath());
+        if (configSkew)
+            advisories.push(configSkew);
+        const egress = collectEgressAdvisory(egressConfigView);
+        if (egress)
+            advisories.push(egress);
     }
     catch {
         // Non-fatal.
@@ -269,6 +292,18 @@ function gatherAncillaryAdvisories(db, stateDbPath, since, improveSummary, optio
     catch {
         // Non-fatal.
     }
+    // Item 4 (alpha.9 plan §5.4/§8 step 8): a bundle with no git history of its
+    // own never gets the purge sweep, so its memory-cleanup archive only ever
+    // grows — report its size and file count instead. Best-effort — an
+    // unreadable archive must not abort the health report.
+    try {
+        const archiveUsage = collectArchiveUsageAdvisory(options.stashDir ?? resolveStashDir());
+        if (archiveUsage)
+            advisories.push(archiveUsage);
+    }
+    catch {
+        // Non-fatal.
+    }
     // #896: report the data dir's total size and its largest top-level
     // subdirectory, so a disk-usage blowup (e.g. unpruned migration snapshot
     // backups, #897) is self-diagnosing instead of requiring `du` archaeology.
@@ -391,7 +426,7 @@ function detectIndexStateGenerationMismatch(stateDb) {
  * per-window bundles and computes deltas between the earliest and latest
  * window. Top-level metrics retain the primary `--since` query.
  */
-function resolveWindowComparePhase(options, db, stateDbPath, now, logsDb) {
+function resolveWindowComparePhase(options, db, stateDbPath, now) {
     let windowSpecs;
     if (options.windowCompare) {
         windowSpecs = resolveWindowCompare(options.windowCompare, now);
@@ -405,7 +440,7 @@ function resolveWindowComparePhase(options, db, stateDbPath, now, logsDb) {
         windowResults = windowSpecs.map((spec) => {
             const winSince = parseHealthSince(spec.since);
             const winUntil = spec.until ? parseHealthSince(spec.until) : new Date(now()).toISOString();
-            const bundle = buildWindowMetrics(db, stateDbPath, winSince, winUntil, now, logsDb);
+            const bundle = buildWindowMetrics(db, stateDbPath, winSince, winUntil, now);
             return {
                 name: spec.name,
                 since: winSince,
@@ -430,19 +465,13 @@ function resolveWindowComparePhase(options, db, stateDbPath, now, logsDb) {
     return { windowResults, deltas };
 }
 /**
- * The health report for a state.db a managed open cannot reach at all: either
- * the file is not readable (#791), or — the same shape, a different cause —
- * it holds a pending migration the managed open refuses to apply without
- * deliberate consent (`akm upgrade` / `akm migrate apply` are the
- * only two callers allowed to admit a historical-destructive migration; see
- * `beforeMigrationLocked` in `src/core/state/migrations.ts`).
+ * The health report for a state.db the open cannot reach at all: either the
+ * file is not readable (#791), or — the same shape, a different cause — the
+ * open failed while applying a pending migration, which is left pending.
  *
  * `akm health` is what an operator (or a bundler's boot check) runs when
  * something else is misbehaving, so it must survive either problem long
- * enough to NAME it. Previously an unreadable file was already handled this
- * way, but a pending migration was not: the managed open's refusal escaped as
- * a thrown `ConfigError` (exit 78) and crashed the whole command before any
- * check — including this one — could report anything.
+ * enough to NAME it rather than exit 78 before any check could report.
  *
  * Reported as a single hard-channel `fail` check — the run genuinely could
  * not open state.db, so every check that depends on it is skipped rather than
@@ -462,13 +491,9 @@ function degradedStateDbReport(hardCheck, options) {
             agentFailureRate: 0,
             agentFailureReasonCounts: {},
             stuckActiveRuns: 0,
-            logBackingRate: 0,
-            // `null`, not 0: the round-trip probe did not run, which is not the same
-            // as it running instantly.
-            probeRoundTripMs: null,
             llmUsage: emptyLlmUsageAggregate(),
         },
-        improve: summarizeImproveCompleted([]),
+        improve: emptyImproveMetrics(),
     };
 }
 function unreadableStateDbCheck(detail) {
@@ -490,29 +515,25 @@ export async function akmHealth(options = {}) {
     const stateDbPath = options.stateDbPath ?? getStateDbPathInDataDir();
     const hardChecks = [];
     const advisories = [];
-    // #791: an UNREADABLE state.db, or one with a pending migration the
-    // managed open refuses to apply, are the two failures `akm health` most
-    // needs to be able to report, because this is the command an operator (or a
-    // bundler's boot check) runs to find out why everything else is behaving
-    // oddly. Dying here meant health could not diagnose that state at all — not
-    // even the checks that never touch state.db got to run. Report it as a
-    // finding instead.
-    let db;
+    // #791: an UNREADABLE state.db, or one whose pending migration failed to
+    // apply, are the two failures `akm health` most needs to be able to report,
+    // because this is the command an operator (or a bundler's boot check) runs
+    // to find out why everything else is behaving oddly. Report it as a finding
+    // instead of dying before any check runs. The open itself applies every
+    // pending migration; `state-db-migrations` reports what it applied.
+    let opened;
     try {
-        db = openStateDatabase(stateDbPath);
+        opened = openStateDatabaseWithReport(stateDbPath);
     }
     catch (error) {
         const { access, code } = classifyPathAccess(stateDbPath);
         if (access === "inaccessible") {
             return degradedStateDbReport(unreadableStateDbCheck(describeInaccessiblePath(stateDbPath, code)), options);
         }
-        // The managed open's refusal of a pending historical-destructive
-        // migration is a plain `Error`, not a distinguishable error class — so
-        // confirm the cause via the read-only preflight (`listPendingStateMigrations`,
-        // which never applies anything) rather than pattern-matching the message.
-        // A ledger too broken to enumerate at all throws here too; in that case
-        // fall through to the generic config-error report below, since it is a
-        // genuinely different, rarer failure this check cannot explain.
+        // A migration that failed to apply rolled back and is still pending:
+        // name it from a read-only listing (which never applies anything) rather
+        // than pattern-matching the error text. A ledger too broken to enumerate
+        // throws here too and falls through to the generic config error below.
         let pendingMigrationsCheck;
         try {
             pendingMigrationsCheck = runPendingStateMigrationsCheck(stateDbPath, { listPendingStateMigrations });
@@ -525,16 +546,7 @@ export async function akmHealth(options = {}) {
         }
         throw new ConfigError(`Unable to open state.db: ${error instanceof Error ? error.message : String(error)}`, "INVALID_CONFIG_FILE");
     }
-    // logs.db backs the log-backing metric (#579). Best-effort: when it cannot
-    // be opened, partitionLogBackedRows falls back to the on-disk file check, so
-    // health never hard-fails on a missing/locked logs database.
-    let logsDb;
-    try {
-        logsDb = openLogsDatabase(options.logsDbPath);
-    }
-    catch {
-        logsDb = undefined;
-    }
+    const { db } = opened;
     try {
         // Network probes overlap the local database phases below; awaited where consumed.
         const engineProbesPromise = runHealthEngineProbes({ probeReachable: options.probe ? probeLlmEndpoint : undefined });
@@ -549,11 +561,15 @@ export async function akmHealth(options = {}) {
             cliVersion: pkgVersion,
         });
         schedulerBinaryDriftPromise.catch(() => undefined);
-        const taskHistory = gatherTaskHistoryPhase(db, logsDb, since, stateDbPath, now);
+        const taskHistory = gatherTaskHistoryPhase(db, since, stateDbPath, now);
         const { tableNames, missingTables, probe } = taskHistory;
         const { egressConfigView, thinkingOffEngines } = gatherEgressConfigPhase();
-        const { improveSummary } = gatherImproveSummaryPhase(db, stateDbPath, since, now);
-        advisories.push(...gatherAncillaryAdvisories(db, stateDbPath, since, improveSummary, options, egressConfigView));
+        // 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`.
+        const until = new Date(now()).toISOString();
+        const { improve: improveSummary, perRunSummaries } = buildImproveWindowSummary(db, stateDbPath, since, until);
+        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
@@ -580,16 +596,15 @@ export async function akmHealth(options = {}) {
             tableNames,
             missingTables,
             probe,
+            stateDbIntegrity: taskHistory.stateDbIntegrity,
+            stateDbFreelist: taskHistory.stateDbFreelist,
+            stateDbMigrations: { applied: opened.applied, ...(opened.backupPath ? { backupPath: opened.backupPath } : {}) },
             taskRowCount: taskHistory.taskRowCount,
             taskFailRate: taskHistory.taskFailRate,
-            taskRowsWithLogsCount: taskHistory.taskRowsWithLogsCount,
-            existingLogRowsCount: taskHistory.existingLogRowsCount,
-            logBackingRate: taskHistory.logBackingRate,
             stuckActiveRuns: taskHistory.stuckActiveRuns,
             stuckActiveTasks: taskHistory.stuckActiveTasks,
             worstTaskFailRate: taskHistory.worstTaskFailRate,
             agentFailureReasonCounts: taskHistory.agentFailureReasonCounts,
-            sessionExtraction: improveSummary.sessionExtraction,
             sessionExtractionLedger,
             autoAccept: improveSummary.autoAccept,
             engineProbes,
@@ -614,20 +629,15 @@ export async function akmHealth(options = {}) {
             agentFailureRate: roundRate(taskHistory.agentFailureRate),
             agentFailureReasonCounts: taskHistory.agentFailureReasonCounts,
             stuckActiveRuns: taskHistory.stuckActiveRuns,
-            logBackingRate: roundRate(taskHistory.logBackingRate),
-            probeRoundTripMs: probe.durationMs,
             llmUsage,
         };
         const hardFailure = hardChecks.some((check) => check.status === "fail");
         const deterministicWarnings = [...hardChecks, ...advisories].some((check) => check.status === "warn" && check.kind === "deterministic");
         const status = hardFailure ? "fail" : deterministicWarnings ? "warn" : "pass";
         // ── Window-compare mode (Phase 3) ─────────────────────────────────────
-        const { windowResults, deltas } = resolveWindowComparePhase(options, db, stateDbPath, now, logsDb);
+        const { windowResults, deltas } = resolveWindowComparePhase(options, db, stateDbPath, now);
         // ── Per-run mode (Phase 2) ────────────────────────────────────────────
-        let runs;
-        if (options.groupBy === "run") {
-            runs = buildPerRunSummaries(db, since);
-        }
+        const runs = options.groupBy === "run" ? perRunSummaries : undefined;
         return {
             schemaVersion: 3,
             ok: !hardFailure,
@@ -644,14 +654,6 @@ export async function akmHealth(options = {}) {
     }
     finally {
         db.close();
-        if (logsDb) {
-            try {
-                logsDb.close();
-            }
-            catch {
-                // best-effort
-            }
-        }
     }
 }
 // Markdown renderers (renderRunsDetailMd / renderWindowCompareMd) live in

package/dist/commands/improve/consolidate/chunking.js

@@ -1,145 +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/.
-// Chunk sizing + per-chunk prompt assembly for consolidate. Pure token math and
-// prompt-string construction over MemoryEntry inputs — no LLM call, no embedder,
-// no orchestrator coupling.
+/** Consolidate's chunk sizing and per-chunk prompt (pure token math and text). */
 import fs from "node:fs";
 import { parseFrontmatter } from "../../../core/asset/frontmatter.js";
-import { cacheHash } from "../content-hash.js";
-/**
- * Conservative chars-per-token estimate used when computing prompt budgets.
- * English text averages roughly 4 chars/token for most LLM tokenizers. We use
- * 3 to stay conservative (shorter tokens = more tokens per char). Exported so
- * other context-length-driven budgets (e.g. reflect's direct-LLM content cap,
- * #952) share this single estimate instead of redeclaring it.
- */
+import { contentHash, stripFrontmatterBody } from "../content-hash.js";
+/** A conservative chars-per-token estimate, shared by every context-length budget. */
 export const CHARS_PER_TOKEN = 3;
-/**
- * Overhead budget reserved for the system prompt, chunk header lines, and per-
- * memory metadata lines (name, description, tags, separator). Measured at
- * roughly 600 chars for the system prompt + ~100 chars of header + ~50 chars
- * per memory × chunk size.  We round up to 2 000 tokens to leave room for the
- * model's own output.
- */
+/** System prompt, headers and per-memory metadata, with room for the output. */
 const PROMPT_OVERHEAD_TOKENS = 2_000;
 /**
- * Default effective token budget used when the default LLM profile's
- * `contextLength` is not set. This is intentionally conservative (4 096)
- * rather than being set to the model's actual context window, because:
- *
- *   - When the agent path is used, the agent CLI (e.g. opencode)
- *     prepends its own large system prompt + conversation history before
- *     forwarding to the model. That overhead easily consumes 30K+ tokens on
- *     a model with a 16K context window, leaving very little room for
- *     chunk content.
- *   - When the HTTP path is used (an LLM profile is selected), only the akm
- *     system prompt and user prompt are sent, so the budget can be set to the
- *     model's actual context length via the selected LLM engine's contextLength.
- *
- * Set the selected LLM engine's contextLength in your config file to the
- * model's actual context window to allow larger chunks on the HTTP path.
+ * The budget when the engine sets no `contextLength`. Conservative on purpose:
+ * an agent CLI prepends its own large prompt; set `contextLength` on a direct
+ * LLM engine to allow bigger chunks.
  */
 export const DEFAULT_CONTEXT_LENGTH_TOKENS = 4_096;
-/**
- * Given the model's context window and the per-memory body truncation limit,
- * return the maximum number of memories that can safely fit in one chunk
- * without the prompt overflowing the context window.
- *
- * The formula is:
- *   usableTokens = contextLength - PROMPT_OVERHEAD_TOKENS
- *   tokensPerMemory = ceil(bodyTruncation / CHARS_PER_TOKEN)
- *   chunkSize = floor(usableTokens / tokensPerMemory)
- *
- * Result is clamped between 1 and 50 to avoid degenerate values.
- *
- * @param contextLength - Model context window in tokens.
- * @param bodyTruncation - Max chars per memory body included in the prompt.
- * @param maxChunkSize - Optional override for the hardcoded cap of 50 (1–50).
- */
+/** Memories per chunk: `(contextLength − overhead) / ceil(bodyTruncation / CHARS_PER_TOKEN)`, within 1…cap (50). */
 export function computeSafeChunkSize(contextLength, bodyTruncation, maxChunkSize) {
     const usableTokens = Math.max(contextLength - PROMPT_OVERHEAD_TOKENS, 0);
     const tokensPerMemory = Math.max(Math.ceil(bodyTruncation / CHARS_PER_TOKEN), 1);
-    const raw = Math.floor(usableTokens / tokensPerMemory);
-    return Math.max(1, Math.min(maxChunkSize ?? 50, raw));
+    return Math.max(1, Math.min(maxChunkSize ?? 50, Math.floor(usableTokens / tokensPerMemory)));
 }
 /**
- * Build the per-chunk user prompt fed to the consolidate LLM.
- *
- * Each memory is annotated with two flags that drive the system-prompt
- * rules at lines 181-186:
- *   - `(captureMode: hot)` — user-explicit memory; system prompt rule 2
- *     forbids proposing delete. ~60 wasted LLM verdicts/4h on this user's
- *     stack before this annotation.
- *   - `(already queued)` — the memory's body hash matches a pending
- *     consolidate proposal; system prompt rule 3 forbids proposing
- *     promote/merge/contradict. ~107/4h before this annotation.
- *
- * Both annotations are visible to the LLM. `pendingProposalBodyHashes`
- * is precomputed once per run by `loadPendingConsolidateProposalHashes`
- * so the cost stays O(memories) inside the chunk loop.
+ * One chunk's user prompt. Each memory shows its body only (frontmatter can
+ * outrun the truncation and leave the model judging metadata), marked
+ * `captureMode: hot` when the user captured it explicitly and `already queued`
+ * when a pending consolidate proposal carries its body hash — the system
+ * prompt forbids promoting those.
  */
-export function buildChunkPrompt(sourceName, memories, chunkIndex, totalChunks, bodyTruncation, pendingProposalBodyHashes = new Set(), standardsContext = "") {
-    const start = memories[0] ? `memories/${memories[0].name}` : "";
-    const lastMemory = memories[memories.length - 1];
-    const end = lastMemory ? `memories/${lastMemory.name}` : "";
-    const annotationsByIndex = [];
-    const hotRefs = [];
-    for (const m of memories) {
-        let body = "";
+export function buildChunkPrompt(sourceName, memories, chunkIndex, totalChunks, bodyTruncation, pendingProposalBodyHashes = new Set()) {
+    const lines = [
+        `Source: ${sourceName}`,
+        `Chunk ${chunkIndex + 1} of ${totalChunks} (${memories.length} memories):`,
+        "",
+    ];
+    memories.forEach((m, i) => {
+        let body;
         try {
             body = fs.readFileSync(m.filePath, "utf8");
         }
         catch {
             body = "(unreadable)";
         }
-        const parsed = parseFrontmatter(body);
-        const isHot = parsed.data.captureMode === "hot";
-        // Use cacheHash (case-preserving stripped body) to match the domain used
-        // by loadPendingConsolidateProposalHashes and the body-embedding cache.
-        const bodyHash = cacheHash(body);
-        const isAlreadyQueued = pendingProposalBodyHashes.has(bodyHash);
-        annotationsByIndex.push({ isHot, isAlreadyQueued, body });
-        if (isHot)
-            hotRefs.push(`memories/${m.name}`);
-    }
-    const lines = [
-        `Source: ${sourceName}`,
-        `Chunk ${chunkIndex + 1} of ${totalChunks}, memories ${start}–${end}:`,
-        "",
-    ];
-    if (standardsContext.trim()) {
-        lines.push("Standards to follow (the rulebook for this target):");
-        lines.push(standardsContext.trim());
-        lines.push("");
-    }
-    // Top-of-prompt protection block for hot refs. Neutral phrasing — avoid
-    // op-words like "promote", "merge", "contradict" so the model doesn't
-    // accidentally treat the warning as a hint to use that op elsewhere
-    // (variant B leaked the word "contradict" into the control sample
-    // during the diagnostic).
-    if (hotRefs.length > 0) {
-        lines.push("⛔ DO NOT propose any `delete` operation for these refs — they are user-explicit (captureMode: hot) and the downstream guard refuses them regardless. Proposing delete for any of these only wastes tokens.");
-        for (const ref of hotRefs)
-            lines.push(`  - ${ref}`);
-        lines.push("");
-    }
-    for (let i = 0; i < memories.length; i++) {
-        const m = memories[i];
-        // `annotationsByIndex` has exactly one entry per memory (built in the loop above).
-        const { isHot, isAlreadyQueued, body } = annotationsByIndex[i];
         const annotations = [];
-        if (isHot)
+        if (parseFrontmatter(body).data.captureMode === "hot")
             annotations.push("captureMode: hot");
-        if (isAlreadyQueued)
+        if (pendingProposalBodyHashes.has(contentHash(body, "body")))
             annotations.push("already queued");
         const annotationSuffix = annotations.length > 0 ? ` (${annotations.join("; ")})` : "";
-        lines.push(`[${i + 1}] memories/${m.name}${annotationSuffix}`);
-        lines.push(`Description: ${m.description || "(none)"}`);
-        lines.push(`Tags: ${m.tags.length > 0 ? m.tags.join(", ") : "(none)"}`);
-        lines.push("---");
-        lines.push(body.slice(0, bodyTruncation));
-        lines.push("");
-    }
+        lines.push(`[${i + 1}] memories/${m.name}${annotationSuffix}`, `Description: ${m.description || "(none)"}`, `Tags: ${m.tags.length > 0 ? m.tags.join(", ") : "(none)"}`, "---", stripFrontmatterBody(body).slice(0, bodyTruncation), "");
+    });
     return lines.join("\n");
 }