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

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

@@ -63,6 +63,46 @@ import { isExactSemver, isSemverRange, maxSatisfying, satisfiesRange } from "../
 function claudePluginsDir() {
     return process.env.AKM_CLAUDE_PLUGINS_DIR ?? path.join(os.homedir(), ".claude", "plugins");
 }
+/**
+ * Root of OpenCode's package cache, same override pattern as
+ * {@link claudePluginsDir} (`AKM_OPENCODE_CACHE_DIR` for tests).
+ * The OpenCode plugin (`akm-opencode`) bundles its own `akm-cli` under
+ * `packages/akm-opencode/node_modules/akm-cli` and runs it in-process,
+ * 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");
+}
+/**
+ * Read the OpenCode plugin's bundled `akm-cli` version from its
+ * `package.json` — never executed, just parsed, mirroring
+ * {@link detectInstalledPlugins}'s manifest read. `undefined` when the
+ * OpenCode plugin, or its bundled akm-cli, is not installed.
+ */
+function detectOpencodeBundledAkmVersion(cacheRoot) {
+    const pkgPath = path.join(cacheRoot, "packages", "akm-opencode", "node_modules", "akm-cli", "package.json");
+    try {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+        return typeof pkg.version === "string" ? pkg.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function buildOpencodeBundledAdvisory(bundledVersion, cliVersion) {
+    const stale = bundledVersion !== cliVersion;
+    return {
+        name: "opencode-plugin-version",
+        kind: "deterministic",
+        status: stale ? "warn" : "pass",
+        confidence: "high",
+        message: stale
+            ? `OpenCode's bundled akm-cli is v${bundledVersion}, but the running CLI is v${cliVersion} — it shares the same databases in-process; update the OpenCode plugin.`
+            : `OpenCode's bundled akm-cli matches the running v${cliVersion}.`,
+        evidence: { bundledVersion, cliVersion },
+    };
+}
 /**
  * Scan `<pluginsRoot>/cache/<marketplace>/akm/<version>/` for every
  * `akm` plugin cache entry, picking the highest cached version per
@@ -165,14 +205,24 @@ const realListRemoteTags = (marketplaceDir) => {
     return [...new Set(tags)];
 };
 /**
- * Build one `plugin-version` advisory per detected `akm` harness plugin.
- * Returns `[]` when no plugin is installed — the benign, common case.
+ * Build one `plugin-version` advisory per detected `akm` harness plugin,
+ * plus one `opencode-plugin-version` advisory when the
+ * OpenCode plugin's bundled `akm-cli` is found — it shares the host's
+ * databases in-process, so its lag matters the same way a stale Claude
+ * plugin's does. Returns `[]` when neither is installed — the benign,
+ * common case.
  */
 export function collectPluginStalenessAdvisories(options) {
     const pluginsRoot = options.pluginsRoot ?? claudePluginsDir();
     const listRemoteTags = options.listRemoteTags ?? realListRemoteTags;
     const plugins = detectInstalledPlugins(pluginsRoot);
-    return plugins.map((plugin) => buildAdvisory(plugin, options.cliVersion, pluginsRoot, listRemoteTags));
+    const results = plugins.map((plugin) => buildAdvisory(plugin, options.cliVersion, pluginsRoot, listRemoteTags));
+    const opencodeCacheRoot = options.opencodeCacheRoot ?? opencodeCacheDir();
+    const bundledVersion = detectOpencodeBundledAkmVersion(opencodeCacheRoot);
+    if (bundledVersion !== undefined) {
+        results.push(buildOpencodeBundledAdvisory(bundledVersion, options.cliVersion));
+    }
+    return results;
 }
 function buildAdvisory(plugin, cliVersion, pluginsRoot, listRemoteTags) {
     const pluginRef = `${plugin.pluginName}@${plugin.marketplace}`;

package/dist/commands/health/renderers.js

@@ -2,7 +2,7 @@
 // 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/.
 /**
- * `akm health` document renderers, registered rather than intercepted (D7).
+ * `akm health` document renderers.
  *
  * Both handlers are **pure functions of the shaped result**. Everything the
  * rich report needs — per-run rows, window-compare deltas, the pending
@@ -13,12 +13,19 @@
  * renderer to call order and made the command branch on the output format to
  * know when to bind it. Putting the data in the envelope removed both.
  *
+ * The Markdown renderer registers into the shared per-command registry (D7,
+ * `../../output/render-registry.ts`) alongside every other command's `--format
+ * md` renderer. The HTML renderer does not: `health` was, and remains, the
+ * only command with a bespoke HTML report, so `cli/shared.ts` calls
+ * {@link renderHealthHtml} directly instead of going through a registry with
+ * exactly one possible registrant.
+ *
  * Returning `null` falls through to the generic renderer, so a result without
  * the report dataset still renders — generically — instead of erroring or
  * emitting an empty table.
  */
 import { renderHtml, resolveTemplatePath } from "../../output/html-render.js";
-import { registerHtmlRenderer, registerMdRenderer } from "../../output/render-registry.js";
+import { registerMdRenderer } from "../../output/render-registry.js";
 import { buildHealthHtmlReplacements } from "./html-report.js";
 import { renderRunsDetailMd, renderWindowCompareMd } from "./md-report.js";
 function isHealthResult(value) {
@@ -34,7 +41,8 @@ registerMdRenderer("health", (result) => {
         return renderRunsDetailMd(result.runs);
     return null;
 });
-registerHtmlRenderer("health", (result) => {
+/** `--format html` renderer for `akm health`, called directly from `cli/shared.ts`. */
+export function renderHealthHtml(result) {
     if (!isHealthResult(result) || !result.report)
         return null;
     return renderHtml(resolveTemplatePath("health"), buildHealthHtmlReplacements(result, {
@@ -44,4 +52,4 @@ registerHtmlRenderer("health", (result) => {
         proposals: result.report.pendingProposals,
         deltas: result.deltas,
     }));
-});
+}

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

@@ -79,31 +79,18 @@ function reshapeRun(r) {
         completedAt: r.completedAt,
         wallTimeMs: wall,
         ok: r.ok,
-        mode: r.scope.mode,
         consDurationMs: consMs,
         miDurationMs: miMs,
         geDurationMs: geMs,
         otherMs: Math.max(0, wall - consMs - miMs - geMs),
-        consRan: cons.ran,
         promoted: cons.promoted,
         merged: cons.merged,
         deleted: cons.deleted,
         contradicted: cons.contradicted,
         judgedNoAction: cons.judgedNoAction,
-        processed: cons.processed,
-        failedChunks: cons.failedChunks,
-        totalChunks: cons.totalChunks,
         miWritten: mi.written,
-        miConsidered: mi.considered,
-        miYieldRate: mi.yieldRate,
-        miCacheHits: mi.cacheHits,
         geEntities: ge.entities,
         geRelations: ge.relations,
-        geCacheHitRate: ge.cacheHitRate,
-        geFailures: ge.failures,
-        distillSkipped: r.actions.distill.skipped,
-        distillQueued: r.actions.distill.queued,
-        distillLlmFailed: r.actions.distill.llmFailed,
         distillByReason: r.actions.distill.skippedByReason,
         reflectOk: r.actions.reflect.ok,
         reflectFailed: r.actions.reflect.failed,
@@ -111,8 +98,6 @@ function reshapeRun(r) {
         eligible: r.memorySummary.eligible,
         lintFlagged: r.lintFlagged,
         lintFixed: r.lintFixed,
-        reflectsWithErrorContext: r.reflectsWithErrorContext,
-        orphansPurged: r.orphansPurged,
     };
 }
 function compareRuns(a, b) {
@@ -135,11 +120,7 @@ function classify(deltas, metricKeys, lowerIsBetter = false) {
 }
 function buildTrend(deltas) {
     const decisionQuality = classify(deltas, ["improve.memoryInference.yieldRate", "improve.consolidation.promoted"]);
-    const outputVolume = classify(deltas, [
-        "improve.consolidation.promoted",
-        "improve.memoryInference.written",
-        "improve.sessionExtraction.proposalsCreated",
-    ]);
+    const outputVolume = classify(deltas, ["improve.consolidation.promoted", "improve.memoryInference.written"]);
     const failures = classify(deltas, ["improve.graphExtraction.failures"], true);
     const latency = classify(deltas, ["improve.wallTime.medianMs", "improve.wallTime.p95Ms"], true);
     const score = [decisionQuality, outputVolume, failures, latency].reduce((acc, d) => acc + (d === "up" ? 1 : d === "down" ? -1 : 0), 0);
@@ -205,19 +186,7 @@ function buildAggregatesPhase(result, runsPhase) {
     const mi = improve.memoryInference;
     const ge = improve.graphExtraction;
     const wallTime = improve.wallTime;
-    // WS-5: perf telemetry, coverage, and degradation metrics.
-    const perf = improve.perfTelemetry ?? {
-        dedupPoolSize: 0,
-        llmPoolSize: 0,
-        embedMs: 0,
-        embedCacheHits: 0,
-        embedCacheMisses: 0,
-        overBudgetRuns: 0,
-        runsWithTelemetry: 0,
-    };
     const coverage = improve.coverage;
-    const degradation = improve.degradation;
-    const minting = improve.enrichmentMinting;
     // #576: real per-stage LLM token/time accounting (replaces the GPU-time
     // proxy). Optional-guarded so reports built from older health JSON without
     // the aggregate still render.
@@ -242,10 +211,7 @@ function buildAggregatesPhase(result, runsPhase) {
         memoryInference: mi,
         graphExtraction: ge,
         wallTime,
-        perf,
         coverage,
-        degradation,
-        minting,
         llm,
         memorySummary: improve.memorySummary,
         includedResultRows: improve.resultRows?.included ?? totalRuns,
@@ -343,7 +309,7 @@ function groupProposalsBySource(proposals) {
 }
 /** Summary table rows: the base metric set + the WS-5 coverage/minting/perf/degradation extensions, when present. */
 function buildSummaryRows(aggregates, trend) {
-    const { consolidation: cons, graphExtraction: ge, wallTime, llm, coverage, minting, perf, degradation } = aggregates;
+    const { consolidation: cons, graphExtraction: ge, wallTime, llm, coverage } = aggregates;
     const summaryRows = [
         ["Task fail rate", aggregates.taskFailRate, "flat"],
         ["Agent fail rate", aggregates.agentFailRate, "flat"],
@@ -388,80 +354,19 @@ function buildSummaryRows(aggregates, trend) {
             "Tokens spent on model reasoning/thinking, billed separately from prompt and completion.",
         ],
         ["LLM wall time", fmtMs(llm.totalDurationMs), trend.latency],
-    ];
-    // WS-5: denominator-fixed coverage rows (only when we have real data).
-    if (coverage && !Number.isNaN(coverage.rate)) {
-        summaryRows.push([
-            "Coverage rate",
-            pct(coverage.rate, 1),
-            "flat",
-            "Distinct accepted refs / total stash assets (denominator-fixed). Shows what fraction of the corpus has been touched.",
-        ], [
-            "Eligible fraction",
-            pct(coverage.eligibleFraction, 1),
-            "flat",
-            "Eligible assets / total stash assets. Fraction the improve pipeline actively considers.",
-        ], [
+        [
             "Coverage accepted",
             num(coverage.acceptedProposals),
             "flat",
-            "Total accepted proposals in the window (raw volume — includes repeated rewrites of the same asset).",
-        ], [
-            "Churn ratio",
-            Number.isFinite(coverage.churnRatio) ? num(coverage.churnRatio) : "—",
-            Number.isFinite(coverage.churnRatio) && coverage.churnRatio > 1.5 ? "down" : "flat",
-            "Accepted proposals / distinct refs touched. >1.5 = the loop is repeatedly rewriting the same assets (churn, not coverage).",
-        ]);
-    }
-    // Enrichment-vs-minting policy rollup (reporting-only).
-    if (minting && Number.isFinite(minting.share)) {
-        summaryRows.push([
-            "Enrichment-lane minted share",
-            pct(minting.share, 1),
-            minting.share > 0.05 ? "down" : "flat",
-            `New assets minted by enrichment lanes / their accepted total (${minting.minted} minted vs ${minting.updated} updated). Enrichment lanes are ratified to edit existing assets only; WARN >5%, FAIL >15%.`,
-        ]);
-    }
-    // WS-5: perf telemetry rows (only when at least one run reported telemetry).
-    if (perf.runsWithTelemetry > 0) {
-        const embedCacheTotal = perf.embedCacheHits + perf.embedCacheMisses;
-        const embedCacheHitRate = embedCacheTotal > 0 ? pct(perf.embedCacheHits / embedCacheTotal, 1) : "—";
-        summaryRows.push([
-            "Embed cache hit rate",
-            embedCacheHitRate,
-            "flat",
-            "Fraction of embedding lookups served from cache (>95% is healthy). Aggregated across WS-5 runs.",
-        ], [
-            "Embed wall time",
-            fmtMs(perf.embedMs),
-            "flat",
-            "Cumulative embedding wall-clock time across consolidation runs in the window.",
-        ], [
-            "Dedup pool size",
-            num(perf.dedupPoolSize),
-            "flat",
-            "Memory pool size after incremental narrowing, before the limit cap. WS-5 perf telemetry.",
-        ], [
-            "Over-budget consolidation runs",
-            String(perf.overBudgetRuns),
-            perf.overBudgetRuns > 0 ? "down" : "flat",
-            "Runs where consolidation alone exceeded the total run budget (estimatedBudgetFractionUsed > 1.0).",
-        ]);
-    }
-    // WS-5: degradation metrics rows.
-    if (degradation) {
-        summaryRows.push([
-            "Corpus diversity (Gini)",
-            num(degradation.corpusCentroidDistance),
-            degradation.entrenchmentFlagged || degradation.salienceUniformityFlagged ? "down" : "flat",
-            `Gini coefficient of positive retrieval_salience values across ${degradation.retrievalSalienceSampleSize} resolvable assets. Two-tailed: >0.35 = entrenchment risk; <0.08 = collapsed toward uniform.`,
-        ], [
-            "Merge fidelity contradiction rate",
-            pct(degradation.mergeFidelityContradictionRate, 1),
+            "Accepted proposals in the window (raw volume — includes repeated rewrites of the same asset).",
+        ],
+        [
+            "Distinct assets touched",
+            num(coverage.distinctRefs),
             "flat",
-            "Fraction of consolidated proposals that involved a contradiction, from consolidation result envelopes.",
-        ]);
-    }
+            "Distinct assets touched by accepted proposals in the window.",
+        ],
+    ];
     return summaryRows;
 }
 /**

package/dist/commands/health/types-improve.js

@@ -2,28 +2,13 @@
 // 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/.
 /**
- * Lanes ratified as ENRICHMENT-ONLY: they may propose edits to existing
- * assets (metadata, relations, content refresh) but must not mint new ones.
- * New-asset generation belongs to the signal-gated minting lanes
- * (extract/distill/memory-inference).
- */
-export const ENRICHMENT_LANES = ["proactive", "high-salience", "signal-delta"];
-/** Minted share of enrichment-lane accepts that triggers a WARN advisory. */
-export const ENRICHMENT_MINTED_WARN_SHARE = 0.05;
-/** Minted share of enrichment-lane accepts that triggers a FAIL advisory. */
-export const ENRICHMENT_MINTED_FAIL_SHARE = 0.15;
-/**
- * Cron task failure rate at or above which the `task-fail-rate` health advisory
- * warns. 0.05 (5%) is the SAME threshold the HTML report already applies as its
- * fail-rate pass/warn cutoff (`failOk = taskFailRate < 0.05` in
- * src/commands/health/html-report.ts) — this constant makes it the single
- * source so the advisory and the rendered badge cannot drift.
+ * Cron task failure rate at or above which the `task-fail-rate` advisory
+ * warns; also the HTML report's fail-rate badge cutoff, so the two cannot drift.
  */
 export const TASK_FAIL_RATE_WARN = 0.05;
 /**
  * Minimum task_history rows a single task_id needs in the window before its
- * per-task fail rate feeds the `task-fail-rate` advisory's "worst single
- * task" signal. Guards against a rarely-run task (e.g. 1 failure out of 1
- * run) reading as a 100% fail rate off a single noisy sample.
+ * own fail rate feeds `task-fail-rate` — a task run once and failed once is
+ * not a 100% signal.
  */
 export const MIN_ROWS_FOR_WORST_TASK_FAIL_RATE = 5;

package/dist/commands/health/windows.js

@@ -3,17 +3,14 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
  * Window handling for `akm health`: `--window-compare` / `--windows` parsing,
- * per-window metric assembly, log-backing partition, and delta computation.
+ * per-window metric assembly, and delta computation between two windows.
  */
-import fs from "node:fs";
 import { UsageError } from "../../core/errors.js";
 import { readEvents } from "../../core/events.js";
-import { buildTaskRunId, getLoggedRunIds } from "../../core/logs-db.js";
 import { DURATION_UNITS, parseDuration } from "../../core/time.js";
 import { queryTaskHistory } from "../../storage/repositories/task-history-repository.js";
-import { buildImproveSkipSummary, computeWallTimeStats, countAgentFailureReasons, isAgentTaskHistoryRow, roundRate, summarizeImproveCompleted, summarizeImproveRuns, taskFailureDetail, } from "./improve-metrics.js";
+import { buildImproveSkipSummary, computeWallTimeStats, computeWindowProposalCoverage, countAgentFailureReasons, isAgentTaskHistoryRow, roundRate, summarizeImproveRuns, taskFailureDetail, } from "./improve-metrics.js";
 import { readLlmUsageAggregate } from "./llm-usage.js";
-import { computeDegradationMetrics, computeDenominatorFixedCoverage } from "./metrics.js";
 import { buildPerRunSummaries } from "./task-runs.js";
 import { ACTIVE_RUN_WARN_MS, IMPROVE_COMPLETED_EVENT, } from "./types.js";
 /**
@@ -71,28 +68,30 @@ export function parseWindowSpec(raw) {
         ...(fields.until ? { until: fields.until } : {}),
     };
 }
-/** Hard-coded list of "interesting" metric paths for window-compare deltas. */
+/**
+ * Metric paths diffed between the earliest and latest window (`deltas` in the
+ * JSON result; the delta column of `--format md`). Paths are relative to a
+ * {@link WindowResult}.
+ */
 export const INTERESTING_DELTA_PATHS = [
     "improve.actions.reflect.failed",
-    "improve.actions.reflect.guardRejected",
-    "improve.actions.distill.llmFailed",
     "improve.actions.distill.queued",
-    "improve.actions.distill.deferred",
+    "improve.actions.distill.llmFailed",
     "improve.consolidation.promoted",
     "improve.memoryInference.written",
     "improve.memoryInference.yieldRate",
     "improve.memoryInference.skippedNoFacts",
-    "improve.memoryInference.htmlErrorCount",
-    "improve.graphExtraction.cacheHitRate",
     "improve.graphExtraction.failures",
-    "improve.graphExtraction.htmlErrors",
-    "improve.graphExtraction.nonArrayBatchFailures",
-    "improve.sessionExtraction.sessionsScanned",
-    "improve.sessionExtraction.proposalsCreated",
     "improve.autoAccept.promoted",
     "improve.autoAccept.validationFailed",
+    "improve.coverage.acceptedProposals",
+    "improve.coverage.distinctRefs",
     "improve.wallTime.medianMs",
     "improve.wallTime.p95Ms",
+    "metrics.llmUsage.calls",
+    "metrics.llmUsage.totalTokens",
+    "metrics.llmUsage.totalDurationMs",
+    "metrics.llmUsage.failures",
 ];
 export function readNumericPath(obj, path) {
     const parts = path.split(".");
@@ -123,74 +122,66 @@ export function computeDeltas(first, last) {
     return out;
 }
 /**
- * Partition task_history rows into "should have a log" (non-null log_path) and
- * "log is actually backed". A run counts as backed when logs.db holds rows for
- * its run_id (#579 — the DB is the primary record); rows written before logs.db
- * existed fall back to the transitional on-disk file check. `logsDb` may be
- * undefined when logs.db could not be opened — then only the file check runs.
+ * Task-history-derived rates, shared by the main health path
+ * (`health.ts`'s `gatherTaskHistoryPhase`) and {@link buildWindowMetrics}
+ * below — previously computed twice with the only difference being whether
+ * the caller had already bounded `taskRows` by an `until`. Pure projection of
+ * already-queried rows; callers own the `since`/`until` query.
  */
-export function partitionLogBackedRows(taskRows, logsDb) {
-    const withLogs = taskRows.filter((row) => row.log_path !== null);
-    const loggedRunIds = logsDb
-        ? getLoggedRunIds(logsDb, withLogs.map((row) => buildTaskRunId(row.task_id, row.started_at)))
-        : new Set();
-    const backed = withLogs.filter((row) => loggedRunIds.has(buildTaskRunId(row.task_id, row.started_at)) ||
-        (row.log_path !== null && fs.existsSync(row.log_path)));
-    return { withLogs, backed };
-}
-export function buildWindowMetrics(db, stateDbPath, since, until, now = () => Date.now(), logsDb) {
-    const taskRows = queryTaskHistory(db, { since }).filter((row) => {
-        const startMs = new Date(row.started_at).getTime();
-        const untilMs = new Date(until).getTime();
-        return !Number.isFinite(untilMs) || startMs < untilMs;
-    });
-    const { withLogs: taskRowsWithLogs, backed: existingLogRows } = partitionLogBackedRows(taskRows, logsDb);
+export function computeTaskWindowRates(taskRows, now) {
     const failedTaskRows = taskRows.filter((row) => row.status === "failed");
     const activeRows = taskRows.filter((row) => row.status === "active" && row.completed_at === null);
-    const stuckActiveRuns = activeRows.filter((row) => now() - new Date(row.started_at).getTime() > ACTIVE_RUN_WARN_MS).length;
+    const stuckActiveRows = activeRows.filter((row) => now() - new Date(row.started_at).getTime() > ACTIVE_RUN_WARN_MS);
     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;
-    const agentFailureReasonCounts = countAgentFailureReasons(agentFailures);
-    const improveInvoked = readEvents({ since, type: "improve_invoked" }, { dbPath: stateDbPath }).events.filter((event) => new Date(event.ts ?? since).getTime() < new Date(until).getTime()).length;
-    const improveCompletedEvents = readEvents({ since, type: IMPROVE_COMPLETED_EVENT }, { dbPath: stateDbPath }).events.filter((event) => new Date(event.ts ?? since).getTime() < new Date(until).getTime());
-    const improveSkippedEvents = readEvents({ since, type: "improve_skipped" }, { dbPath: stateDbPath }).events.filter((event) => new Date(event.ts ?? since).getTime() < new Date(until).getTime());
-    const eventsMetrics = summarizeImproveCompleted(improveCompletedEvents);
-    const { metrics: improveSummary, runCount } = summarizeImproveRuns(db, since, until);
-    improveSummary.invoked = improveInvoked;
-    improveSummary.completed = eventsMetrics.completed;
-    const skipSummary = buildImproveSkipSummary(improveSkippedEvents);
-    improveSummary.skipped = skipSummary.skipped;
-    improveSummary.skipReasons = skipSummary.skipReasons;
-    // Preserve the per-phase aggregation computed by summarizeImproveRuns and
-    // derive top-level wall times from the same improve-runs window so counts
-    // and percentiles stay aligned with per-run reporting.
+    return {
+        taskFailRate: taskRows.length === 0 ? 0 : failedTaskRows.length / taskRows.length,
+        agentFailureRate: agentRows.length === 0 ? 0 : agentFailures.length / agentRows.length,
+        agentFailureReasonCounts: countAgentFailureReasons(agentFailures),
+        stuckActiveRuns: stuckActiveRows.length,
+        stuckActiveRows,
+    };
+}
+/**
+ * Improve-pipeline window summary, shared by the main health path
+ * (`health.ts`) and {@link buildWindowMetrics} below: events-derived
+ * invoked/completed/skipped counts, the `result_json` aggregate, wall-time
+ * stats from the same per-run rows, and accepted-proposal coverage, all over
+ * one `[since, until)`.
+ */
+export function buildImproveWindowSummary(db, stateDbPath, since, until) {
+    const untilMs = new Date(until).getTime();
+    const eventsBeforeUntil = (type) => readEvents({ since, type }, { dbPath: stateDbPath }).events.filter((event) => new Date(event.ts ?? since).getTime() < untilMs);
+    const { metrics: improve, runCount } = summarizeImproveRuns(db, since, until);
+    improve.invoked = eventsBeforeUntil("improve_invoked").length;
+    improve.completed = eventsBeforeUntil(IMPROVE_COMPLETED_EVENT).length;
+    const skipSummary = buildImproveSkipSummary(eventsBeforeUntil("improve_skipped"));
+    improve.skipped = skipSummary.skipped;
+    improve.skipReasons = skipSummary.skipReasons;
+    // Wall times come from the same improve-runs window as the per-run
+    // reporting so counts and percentiles stay aligned with it.
     const perRunSummaries = buildPerRunSummaries(db, since, until);
-    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 from the most recent run's
-    // memorySummary (totalAssets = eligible + derived — the fixed denominator).
-    const totalAssets = improveSummary.memorySummary.eligible + improveSummary.memorySummary.derived;
-    improveSummary.coverage = computeDenominatorFixedCoverage(db, totalAssets, improveSummary.memorySummary.eligible, since, until);
-    // WS-5: Compute per-run degradation metrics (corpus diversity, merge fidelity,
-    // generation distribution, oracle spot-check). Health VIEWS only.
-    const degradation = computeDegradationMetrics(db, since, until);
-    if (degradation) {
-        improveSummary.degradation = degradation;
-    }
+    improve.wallTime = computeWallTimeStats(perRunSummaries.map((run) => run.wallTimeMs).filter((ms) => Number.isFinite(ms) && ms > 0));
+    improve.coverage = computeWindowProposalCoverage(db, since, until);
+    return { improve, runCount, perRunSummaries };
+}
+export function buildWindowMetrics(db, stateDbPath, since, until, now = () => Date.now()) {
+    const untilMs = new Date(until).getTime();
+    const taskRows = queryTaskHistory(db, { since }).filter((row) => {
+        const startMs = new Date(row.started_at).getTime();
+        return !Number.isFinite(untilMs) || startMs < untilMs;
+    });
+    const rates = computeTaskWindowRates(taskRows, now);
+    const { improve, runCount } = buildImproveWindowSummary(db, stateDbPath, since, until);
     const metrics = {
-        taskFailRate: roundRate(taskFailRate),
-        agentFailureRate: roundRate(agentFailureRate),
-        agentFailureReasonCounts,
-        stuckActiveRuns,
-        logBackingRate: roundRate(logBackingRate),
-        probeRoundTripMs: null,
+        taskFailRate: roundRate(rates.taskFailRate),
+        agentFailureRate: roundRate(rates.agentFailureRate),
+        agentFailureReasonCounts: rates.agentFailureReasonCounts,
+        stuckActiveRuns: rates.stuckActiveRuns,
         llmUsage: readLlmUsageAggregate(stateDbPath, since, until),
     };
-    return { improve: improveSummary, metrics, runs: runCount };
+    return { improve, metrics, runs: runCount };
 }