akm-cli 0.9.0-rc.0 → 0.9.0-rc.13

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

@@ -1,18 +1,19 @@
 // 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/.
+import { decodeImproveResult } from "../../core/improve-result.js";
 import { queryImproveRuns } from "../../storage/repositories/improve-runs-repository.js";
-import { summarizeCalibration } from "../improve/calibration.js";
+import { decodeTaskHistoryMetadata } from "../../storage/repositories/task-history-repository.js";
 export function roundRate(value) {
     return Number(value.toFixed(4));
 }
 export function parseTaskMetadata(row) {
-    try {
-        return JSON.parse(row.metadata_json);
-    }
-    catch {
-        return {};
-    }
+    const metadata = decodeTaskHistoryMetadata(row.metadata_json);
+    return {
+        ...(metadata.durationMs !== undefined ? { durationMs: metadata.durationMs } : {}),
+        ...(metadata.detail ? { detail: metadata.detail } : {}),
+        ...(metadata.engine !== undefined ? { engine: metadata.engine } : {}),
+    };
 }
 function createUnknownImproveMetrics() {
     return {
@@ -20,14 +21,14 @@ function createUnknownImproveMetrics() {
         completed: 0,
         skipped: 0,
         skipReasons: {},
+        resultRows: { total: 0, included: 0, skipped: { invalid: 0 } },
         plannedRefs: 0,
-        profileFilteredRefs: 0,
+        strategyFilteredRefs: 0,
         actions: {
             reflect: { ok: 0, failed: 0, cooldown: 0, skipped: 0, guardRejected: 0, skippedByReason: {} },
             distill: {
                 queued: 0,
                 llmFailed: 0,
-                qualityRejected: 0,
                 judgeRejected: 0,
                 validatorRejected: 0,
                 configDisabled: 0,
@@ -42,7 +43,6 @@ function createUnknownImproveMetrics() {
             error: 0,
         },
         autoAccept: { promoted: 0, validationFailed: 0 },
-        calibration: summarizeCalibration([]),
         reflectsWithErrorContext: 0,
         coverageGapCount: 0,
         evalCasesWritten: 0,
@@ -84,18 +84,16 @@ function createUnknownImproveMetrics() {
             skippedAborted: 0,
             unaccounted: 0,
             htmlErrorCount: 0,
-            yieldEligibleRuns: 0,
-            yieldEligibleConsidered: 0,
-            yieldEligibleWritten: 0,
             yieldRate: 0,
             durationMs: 0,
-            writes: 0,
         },
         graphExtraction: {
             ran: false,
             extractedFiles: 0,
+            consideredFiles: 0,
             entities: 0,
             relations: 0,
+            extractionCoverage: 0,
             cacheHits: 0,
             cacheMisses: 0,
             cacheHitRate: 0,
@@ -130,7 +128,6 @@ function createUnknownImproveMetrics() {
         perfTelemetry: {
             dedupPoolSize: 0,
             llmPoolSize: 0,
-            judgedCacheSkipped: 0,
             embedMs: 0,
             embedCacheHits: 0,
             embedCacheMisses: 0,
@@ -171,140 +168,134 @@ export function summarizeImproveCompleted(events) {
     return metrics;
 }
 /**
- * Project a single `improve_runs.result_json` envelope into an accumulator-shaped
- * ImproveHealthMetrics. The aggregator merges these per-row metrics into one
- * window-level metric.
+ * Read the machine-readable reason from a distill `outcome: "skipped"` result.
  */
-function projectRunMetrics(result) {
-    const metrics = createUnknownImproveMetrics();
+function classifyDistillSkipReason(r) {
+    const explicitReason = typeof r?.skipReason === "string" ? r.skipReason : undefined;
+    return explicitReason || "unknown";
+}
+// ── projectRunMetrics phase helpers (chunk-9 WI-9.5c; file-level decompose of
+// the single-envelope projection — each helper mutates its own disjoint
+// subtree of the accumulator from the raw envelope, so call order does not
+// matter; kept in envelope-field order for readability) ──────────────────────
+/** plannedRefs / strategyFilteredRefs ref-count accounting. */
+function applyPlannedRefs(metrics, result) {
     // plannedRefs (array of {ref, reason})
     const plannedRefs = result.plannedRefs;
     if (Array.isArray(plannedRefs))
         metrics.plannedRefs += plannedRefs.length;
-    // profileFilteredRefs (array of {ref, reason}) — 2026-05-27: pre-filter
+    // strategyFilteredRefs (array of {ref, reason}) — 2026-05-27: pre-filter
     // bucket from `collectEligibleRefs` so the metric reflects work the
     // planner dropped before signal-delta / per-pass dispatch.
-    const profileFilteredRefs = result.profileFilteredRefs;
-    if (Array.isArray(profileFilteredRefs))
-        metrics.profileFilteredRefs += profileFilteredRefs.length;
-    // actions: split reflect / distill by outcome, count others.
-    const actions = result.actions;
-    if (Array.isArray(actions)) {
-        for (const action of actions) {
-            const mode = typeof action.mode === "string" ? action.mode : "";
-            switch (mode) {
-                case "reflect":
-                    metrics.actions.reflect.ok += 1;
-                    break;
-                case "reflect-failed":
-                    metrics.actions.reflect.failed += 1;
+    const strategyFilteredRefs = result.strategyFilteredRefs;
+    if (Array.isArray(strategyFilteredRefs))
+        metrics.strategyFilteredRefs += strategyFilteredRefs.length;
+}
+/** One `actions[]` entry → the matching counter bucket (see ImproveHealthMetrics.actions jsdoc for the taxonomy). */
+function applyAction(metrics, action) {
+    const mode = typeof action.mode === "string" ? action.mode : "";
+    switch (mode) {
+        case "reflect":
+            metrics.actions.reflect.ok += 1;
+            break;
+        case "reflect-failed":
+            metrics.actions.reflect.failed += 1;
+            break;
+        case "reflect-cooldown":
+            metrics.actions.reflect.cooldown += 1;
+            break;
+        case "reflect-skipped": {
+            metrics.actions.reflect.skipped += 1;
+            const r = action.result;
+            const reason = typeof r?.reason === "string" && r.reason.trim() ? r.reason : "unknown";
+            metrics.actions.reflect.skippedByReason[reason] = (metrics.actions.reflect.skippedByReason[reason] ?? 0) + 1;
+            break;
+        }
+        case "reflect-guard-rejected":
+            metrics.actions.reflect.guardRejected += 1;
+            break;
+        case "distill": {
+            const r = action.result;
+            const outcome = typeof r?.outcome === "string" ? r.outcome : "";
+            switch (outcome) {
+                case "queued":
+                    metrics.actions.distill.queued += 1;
                     break;
-                case "reflect-cooldown":
-                    metrics.actions.reflect.cooldown += 1;
+                case "llm_failed":
+                    metrics.actions.distill.llmFailed += 1;
                     break;
-                case "reflect-skipped": {
-                    metrics.actions.reflect.skipped += 1;
-                    const r = action.result;
-                    const reason = typeof r?.reason === "string" && r.reason.trim() ? r.reason : "unknown";
-                    metrics.actions.reflect.skippedByReason[reason] = (metrics.actions.reflect.skippedByReason[reason] ?? 0) + 1;
+                case "quality_rejected":
+                case "review_needed":
+                    metrics.actions.distill.judgeRejected += 1;
                     break;
-                }
-                case "reflect-guard-rejected":
-                    metrics.actions.reflect.guardRejected += 1;
+                case "validation_failed":
+                    metrics.actions.distill.validatorRejected += 1;
                     break;
-                case "distill": {
-                    const r = action.result;
-                    const outcome = typeof r?.outcome === "string" ? r.outcome : "";
-                    switch (outcome) {
-                        case "queued":
-                            metrics.actions.distill.queued += 1;
-                            break;
-                        case "llm_failed":
-                            metrics.actions.distill.llmFailed += 1;
-                            break;
-                        case "quality_rejected":
-                        case "review_needed":
-                            metrics.actions.distill.qualityRejected += 1;
-                            metrics.actions.distill.judgeRejected += 1;
-                            break;
-                        case "validation_failed":
-                            metrics.actions.distill.qualityRejected += 1;
-                            metrics.actions.distill.validatorRejected += 1;
-                            break;
-                        case "config_disabled":
-                            metrics.actions.distill.configDisabled += 1;
-                            break;
-                        case "skipped": {
-                            // Previously dropped on the floor. The four sub-paths that emit
-                            // `outcome: "skipped"` (see distill.ts:893, 1024, 1120, 1576):
-                            //   - recursive_lesson_input (type guard refused a lesson input)
-                            //   - conflict_noop (LLM resolved destination conflict as NOOP)
-                            //   - proposal-skipped cooldown / dedup at persistence
-                            // 465 events/7d in the user's live stack. The result message
-                            // typically encodes the reason; we also accept an explicit
-                            // `skipReason` field when downstream code sets it.
-                            metrics.actions.distill.deferred += 1;
-                            const explicitReason = typeof r?.skipReason === "string" ? r.skipReason : undefined;
-                            const msg = typeof r?.message === "string" ? r.message : "";
-                            let reason = explicitReason ?? "unknown";
-                            if (!explicitReason) {
-                                if (/lesson inputs/i.test(msg))
-                                    reason = "recursive_lesson_input";
-                                else if (/NOOP/.test(msg))
-                                    reason = "conflict_noop";
-                                else if (/cooldown/i.test(msg))
-                                    reason = "proposal_cooldown";
-                                else if (/content[_ ]?hash/i.test(msg))
-                                    reason = "content_hash_match";
-                            }
-                            metrics.actions.distill.deferredByReason[reason] =
-                                (metrics.actions.distill.deferredByReason[reason] ?? 0) + 1;
-                            break;
-                        }
-                        default:
-                            break;
-                    }
+                case "config_disabled":
+                    metrics.actions.distill.configDisabled += 1;
                     break;
-                }
-                case "distill-skipped": {
-                    metrics.actions.distill.skipped += 1;
-                    const r = action.result;
-                    const reason = typeof r?.reason === "string" && r.reason.trim() ? r.reason : "unknown";
-                    metrics.actions.distill.skippedByReason[reason] = (metrics.actions.distill.skippedByReason[reason] ?? 0) + 1;
+                case "skipped": {
+                    // Previously dropped on the floor. The four sub-paths that emit
+                    // `outcome: "skipped"` (see distill.ts:893, 1024, 1120, 1576):
+                    //   - recursive_lesson_input (type guard refused a lesson input)
+                    //   - conflict_noop (LLM resolved destination conflict as NOOP)
+                    //   - proposal-skipped cooldown / dedup at persistence
+                    // 465 events/7d in the user's live stack. The result message
+                    // typically encodes the reason; we also accept an explicit
+                    // `skipReason` field when downstream code sets it.
+                    metrics.actions.distill.deferred += 1;
+                    const reason = classifyDistillSkipReason(r);
+                    metrics.actions.distill.deferredByReason[reason] =
+                        (metrics.actions.distill.deferredByReason[reason] ?? 0) + 1;
                     break;
                 }
-                case "memory-prune":
-                    metrics.actions.memoryPrune += 1;
-                    break;
-                case "memory-inference":
-                    metrics.actions.memoryInference += 1;
-                    break;
-                case "graph-extraction":
-                    metrics.actions.graphExtraction += 1;
-                    break;
-                case "error":
-                    metrics.actions.error += 1;
+                default:
                     break;
             }
+            break;
         }
+        case "memory-prune":
+            metrics.actions.memoryPrune += 1;
+            break;
+        case "memory-inference":
+            metrics.actions.memoryInference += 1;
+            break;
+        case "graph-extraction":
+            metrics.actions.graphExtraction += 1;
+            break;
+        case "error":
+            metrics.actions.error += 1;
+            break;
     }
-    // C1 (13-bus-factor): new runs persist the bounded `distillSkipped` aggregate
-    // instead of per-ref `distill-skipped` rows. Read the total + per-reason
-    // histogram from it into the SAME `distill.skipped` / `skippedByReason`
-    // metric the per-ref loop above populated. Legacy rows carry the per-ref rows
-    // and NO aggregate (counted above); new rows carry the aggregate and NO
-    // per-ref rows (counted here) — so a run is never double-counted.
+}
+/** actions: split reflect / distill by outcome, count others. */
+function applyActionsList(metrics, result) {
+    const actions = result.actions;
+    if (!Array.isArray(actions))
+        return;
+    for (const action of actions) {
+        applyAction(metrics, action);
+    }
+}
+/**
+ * Read the bounded `distillSkipped` aggregate into the corresponding total and
+ * per-reason health metrics.
+ */
+function applyDistillSkippedAggregate(metrics, result) {
     const distillSkipped = result.distillSkipped;
-    if (distillSkipped && typeof distillSkipped === "object") {
-        metrics.actions.distill.skipped += toFiniteNumber(distillSkipped.total);
-        const byReason = distillSkipped.byReason;
-        if (byReason && typeof byReason === "object") {
-            for (const [reason, count] of Object.entries(byReason)) {
-                metrics.actions.distill.skippedByReason[reason] =
-                    (metrics.actions.distill.skippedByReason[reason] ?? 0) + toFiniteNumber(count);
-            }
+    if (!distillSkipped || typeof distillSkipped !== "object")
+        return;
+    metrics.actions.distill.skipped += toFiniteNumber(distillSkipped.total);
+    const byReason = distillSkipped.byReason;
+    if (byReason && typeof byReason === "object") {
+        for (const [reason, count] of Object.entries(byReason)) {
+            metrics.actions.distill.skippedByReason[reason] =
+                (metrics.actions.distill.skippedByReason[reason] ?? 0) + toFiniteNumber(count);
         }
     }
+}
+/** autoAccept + the small envelope-level counters (reflectsWithErrorContext, coverageGaps, evalCasesWritten, deadUrls). */
+function applyMiscCounters(metrics, result) {
     metrics.autoAccept.promoted += toFiniteNumber(result.gateAutoAcceptedCount);
     metrics.autoAccept.validationFailed += toFiniteNumber(result.gateAutoAcceptFailedCount);
     metrics.reflectsWithErrorContext += toFiniteNumber(result.reflectsWithErrorContext);
@@ -313,79 +304,86 @@ function projectRunMetrics(result) {
     metrics.evalCasesWritten += toFiniteNumber(result.evalCasesWritten);
     if (Array.isArray(result.deadUrls))
         metrics.deadUrlCount += result.deadUrls.length;
+}
+function applyMemorySummary(metrics, result) {
     const memorySummary = result.memorySummary;
-    if (memorySummary) {
-        metrics.memorySummary.eligible += toFiniteNumber(memorySummary.eligible);
-        metrics.memorySummary.derived += toFiniteNumber(memorySummary.derived);
-    }
+    if (!memorySummary)
+        return;
+    metrics.memorySummary.eligible += toFiniteNumber(memorySummary.eligible);
+    metrics.memorySummary.derived += toFiniteNumber(memorySummary.derived);
+}
+function applyMemoryCleanup(metrics, result) {
     const memoryCleanup = result.memoryCleanup;
-    if (memoryCleanup) {
-        if (Array.isArray(memoryCleanup.pruneCandidates))
-            metrics.memoryCleanup.pruneCandidates += memoryCleanup.pruneCandidates.length;
-        if (Array.isArray(memoryCleanup.contradictionCandidates))
-            metrics.memoryCleanup.contradictionCandidates += memoryCleanup.contradictionCandidates.length;
-        if (Array.isArray(memoryCleanup.beliefStateTransitions))
-            metrics.memoryCleanup.beliefStateTransitions += memoryCleanup.beliefStateTransitions.length;
-        if (Array.isArray(memoryCleanup.consolidationCandidates))
-            metrics.memoryCleanup.consolidationCandidates += memoryCleanup.consolidationCandidates.length;
-        if (Array.isArray(memoryCleanup.archived))
-            metrics.memoryCleanup.archived += memoryCleanup.archived.length;
-        if (Array.isArray(memoryCleanup.warnings))
-            metrics.memoryCleanup.warnings += memoryCleanup.warnings.length;
-    }
+    if (!memoryCleanup)
+        return;
+    if (Array.isArray(memoryCleanup.pruneCandidates))
+        metrics.memoryCleanup.pruneCandidates += memoryCleanup.pruneCandidates.length;
+    if (Array.isArray(memoryCleanup.contradictionCandidates))
+        metrics.memoryCleanup.contradictionCandidates += memoryCleanup.contradictionCandidates.length;
+    if (Array.isArray(memoryCleanup.beliefStateTransitions))
+        metrics.memoryCleanup.beliefStateTransitions += memoryCleanup.beliefStateTransitions.length;
+    if (Array.isArray(memoryCleanup.consolidationCandidates))
+        metrics.memoryCleanup.consolidationCandidates += memoryCleanup.consolidationCandidates.length;
+    if (Array.isArray(memoryCleanup.archived))
+        metrics.memoryCleanup.archived += memoryCleanup.archived.length;
+    if (Array.isArray(memoryCleanup.warnings))
+        metrics.memoryCleanup.warnings += memoryCleanup.warnings.length;
+}
+function applyConsolidation(metrics, result) {
     const consolidation = result.consolidation;
-    if (consolidation) {
-        metrics.consolidation.processed += toFiniteNumber(consolidation.processed);
-        metrics.consolidation.merged += toFiniteNumber(consolidation.merged);
-        metrics.consolidation.deleted += toFiniteNumber(consolidation.deleted);
-        metrics.consolidation.contradicted += toFiniteNumber(consolidation.contradicted);
-        if (Array.isArray(consolidation.promoted))
-            metrics.consolidation.promoted += consolidation.promoted.length;
-        metrics.consolidation.failedChunks += toFiniteNumber(consolidation.failedChunks);
-        metrics.consolidation.totalChunks += toFiniteNumber(consolidation.totalChunks);
-        metrics.consolidation.durationMs += toFiniteNumber(consolidation.durationMs);
-        metrics.consolidation.judgedNoAction += toFiniteNumber(consolidation.judgedNoAction);
-        metrics.consolidation.mergedSecondaries += toFiniteNumber(consolidation.mergedSecondaries);
-        metrics.consolidation.failedChunkMemories += toFiniteNumber(consolidation.failedChunkMemories);
-        // Structured emitter (new on this branch): consolidate.ts now pushes
-        // per-ref grouped `{ref, skips: [{op, reason}]}` entries to `skipReasons`
-        // for every deterministic post-LLM rejection. Each ref appears once but
-        // may carry multiple skips; aggregate every reason. Pre-fix envelopes have
-        // neither field, so be defensive.
-        const skipReasons = consolidation.skipReasons;
-        if (Array.isArray(skipReasons)) {
-            for (const entry of skipReasons) {
-                if (!entry || typeof entry !== "object")
+    if (!consolidation)
+        return;
+    metrics.consolidation.processed += toFiniteNumber(consolidation.processed);
+    metrics.consolidation.merged += toFiniteNumber(consolidation.merged);
+    metrics.consolidation.deleted += toFiniteNumber(consolidation.deleted);
+    metrics.consolidation.contradicted += toFiniteNumber(consolidation.contradicted);
+    if (Array.isArray(consolidation.promoted))
+        metrics.consolidation.promoted += consolidation.promoted.length;
+    metrics.consolidation.failedChunks += toFiniteNumber(consolidation.failedChunks);
+    metrics.consolidation.totalChunks += toFiniteNumber(consolidation.totalChunks);
+    metrics.consolidation.durationMs += toFiniteNumber(consolidation.durationMs);
+    metrics.consolidation.judgedNoAction += toFiniteNumber(consolidation.judgedNoAction);
+    metrics.consolidation.mergedSecondaries += toFiniteNumber(consolidation.mergedSecondaries);
+    metrics.consolidation.failedChunkMemories += toFiniteNumber(consolidation.failedChunkMemories);
+    // Structured emitter (new on this branch): consolidate.ts now pushes
+    // per-ref grouped `{ref, skips: [{op, reason}]}` entries to `skipReasons`
+    // for every deterministic post-LLM rejection. Each ref appears once but
+    // may carry multiple skips; aggregate every reason. Pre-fix envelopes have
+    // neither field, so be defensive.
+    const skipReasons = consolidation.skipReasons;
+    if (Array.isArray(skipReasons)) {
+        for (const entry of skipReasons) {
+            if (!entry || typeof entry !== "object")
+                continue;
+            const skips = entry.skips;
+            if (!Array.isArray(skips))
+                continue;
+            for (const skip of skips) {
+                if (!skip || typeof skip !== "object")
                     continue;
-                const skips = entry.skips;
-                if (!Array.isArray(skips))
+                const reason = skip.reason;
+                if (typeof reason !== "string" || !reason.trim())
                     continue;
-                for (const skip of skips) {
-                    if (!skip || typeof skip !== "object")
-                        continue;
-                    const reason = skip.reason;
-                    if (typeof reason !== "string" || !reason.trim())
-                        continue;
-                    metrics.consolidation.skipReasons[reason] = (metrics.consolidation.skipReasons[reason] ?? 0) + 1;
-                }
+                metrics.consolidation.skipReasons[reason] = (metrics.consolidation.skipReasons[reason] ?? 0) + 1;
             }
         }
-        // WS-5: extract perf telemetry from the consolidation envelope.
-        // Pre-WS-5 envelopes lack `perfTelemetry`; be defensive.
-        const perf = consolidation.perfTelemetry;
-        if (perf) {
-            metrics.perfTelemetry.runsWithTelemetry += 1;
-            metrics.perfTelemetry.dedupPoolSize += toFiniteNumber(perf.dedupPoolSize);
-            metrics.perfTelemetry.llmPoolSize += toFiniteNumber(perf.llmPoolSize);
-            metrics.perfTelemetry.judgedCacheSkipped += toFiniteNumber(perf.judgedCacheSkipped);
-            metrics.perfTelemetry.embedMs += toFiniteNumber(perf.embedMs);
-            metrics.perfTelemetry.embedCacheHits += toFiniteNumber(perf.embedCacheHits);
-            metrics.perfTelemetry.embedCacheMisses += toFiniteNumber(perf.embedCacheMisses);
-            const budgetFrac = toFiniteNumber(perf.estimatedBudgetFractionUsed);
-            if (budgetFrac > 1.0)
-                metrics.perfTelemetry.overBudgetRuns += 1;
-        }
     }
+    // WS-5: extract perf telemetry from the consolidation envelope.
+    // Pre-WS-5 envelopes lack `perfTelemetry`; be defensive.
+    const perf = consolidation.perfTelemetry;
+    if (perf) {
+        metrics.perfTelemetry.runsWithTelemetry += 1;
+        metrics.perfTelemetry.dedupPoolSize += toFiniteNumber(perf.dedupPoolSize);
+        metrics.perfTelemetry.llmPoolSize += toFiniteNumber(perf.llmPoolSize);
+        metrics.perfTelemetry.embedMs += toFiniteNumber(perf.embedMs);
+        metrics.perfTelemetry.embedCacheHits += toFiniteNumber(perf.embedCacheHits);
+        metrics.perfTelemetry.embedCacheMisses += toFiniteNumber(perf.embedCacheMisses);
+        const budgetFrac = toFiniteNumber(perf.estimatedBudgetFractionUsed);
+        if (budgetFrac > 1.0)
+            metrics.perfTelemetry.overBudgetRuns += 1;
+    }
+}
+function applyMemoryInference(metrics, result) {
     const memoryInference = result.memoryInference;
     if (memoryInference) {
         const considered = toFiniteNumber(memoryInference.considered);
@@ -400,25 +398,17 @@ function projectRunMetrics(result) {
         metrics.memoryInference.skippedAborted += toFiniteNumber(memoryInference.skippedAborted);
         metrics.memoryInference.unaccounted += toFiniteNumber(memoryInference.unaccounted);
         metrics.memoryInference.htmlErrorCount += toFiniteNumber(memoryInference.htmlErrorCount);
-        // Yield-rate gating: pre-cache-feature envelopes lack the `cacheHits`
-        // field entirely. Treating their `considered` as freshAttempts (since
-        // cacheHits=0) is mathematically tempting but operationally wrong —
-        // historical runs with the legacy schema have no cache instrumentation
-        // and the SUM dragged the reported rate to ~14% in local data. Only
-        // contribute to the yield aggregate when the envelope actually carries
-        // the field. See investigation 2026-05-26.
-        if (Object.hasOwn(memoryInference, "cacheHits")) {
-            metrics.memoryInference.yieldEligibleRuns += 1;
-            metrics.memoryInference.yieldEligibleConsidered += considered;
-            metrics.memoryInference.yieldEligibleWritten += writtenFacts;
-        }
     }
     metrics.memoryInference.durationMs += toFiniteNumber(result.memoryInferenceDurationMs);
+}
+function applyGraphExtraction(metrics, result) {
     const graphExtraction = result.graphExtraction;
     if (graphExtraction) {
         const quality = graphExtraction.quality;
-        if (quality)
+        if (quality) {
             metrics.graphExtraction.extractedFiles += toFiniteNumber(quality.extractedFiles);
+            metrics.graphExtraction.consideredFiles += toFiniteNumber(quality.consideredFiles);
+        }
         metrics.graphExtraction.entities += toFiniteNumber(graphExtraction.totalEntities);
         metrics.graphExtraction.relations += toFiniteNumber(graphExtraction.totalRelations);
         const telemetry = graphExtraction.telemetry;
@@ -433,18 +423,40 @@ function projectRunMetrics(result) {
         }
     }
     metrics.graphExtraction.durationMs += toFiniteNumber(result.graphExtractionDurationMs);
-    if (Array.isArray(result.extract)) {
-        for (const e of result.extract) {
-            metrics.sessionExtraction.sessionsScanned += toFiniteNumber(e.sessionsProcessed);
-            metrics.sessionExtraction.sessionsSkipped += toFiniteNumber(e.sessionsSkipped);
-            if (Array.isArray(e.sessions)) {
-                metrics.sessionExtraction.sessionsExtracted += e.sessions.filter((s) => Array.isArray(s.proposalIds) && s.proposalIds.length > 0).length;
-            }
-            metrics.sessionExtraction.proposalsCreated += Array.isArray(e.proposals) ? e.proposals.length : 0;
-            metrics.sessionExtraction.warnings += Array.isArray(e.warnings) ? e.warnings.length : 0;
-            metrics.sessionExtraction.durationMs += toFiniteNumber(e.durationMs);
+}
+function applySessionExtraction(metrics, result) {
+    if (!Array.isArray(result.extract))
+        return;
+    for (const e of result.extract) {
+        metrics.sessionExtraction.sessionsScanned += toFiniteNumber(e.sessionsProcessed);
+        metrics.sessionExtraction.sessionsSkipped += toFiniteNumber(e.sessionsSkipped);
+        if (Array.isArray(e.sessions)) {
+            metrics.sessionExtraction.sessionsExtracted += e.sessions.filter((s) => Array.isArray(s.proposalIds) && s.proposalIds.length > 0).length;
         }
+        metrics.sessionExtraction.proposalsCreated += Array.isArray(e.proposals) ? e.proposals.length : 0;
+        metrics.sessionExtraction.warnings += Array.isArray(e.warnings) ? e.warnings.length : 0;
+        metrics.sessionExtraction.durationMs += toFiniteNumber(e.durationMs);
     }
+}
+/**
+ * Project a single `improve_runs.result_json` envelope into an accumulator-shaped
+ * ImproveHealthMetrics. The aggregator merges these per-row metrics into one
+ * window-level metric. File-level decomposed (chunk-9 WI-9.5c) into one
+ * `apply*` helper per envelope section above; each mutates its own disjoint
+ * subtree of the accumulator so the call order below is not load-bearing.
+ */
+function projectRunMetrics(result) {
+    const metrics = createUnknownImproveMetrics();
+    applyPlannedRefs(metrics, result);
+    applyActionsList(metrics, result);
+    applyDistillSkippedAggregate(metrics, result);
+    applyMiscCounters(metrics, result);
+    applyMemorySummary(metrics, result);
+    applyMemoryCleanup(metrics, result);
+    applyConsolidation(metrics, result);
+    applyMemoryInference(metrics, result);
+    applyGraphExtraction(metrics, result);
+    applySessionExtraction(metrics, result);
     return metrics;
 }
 /**
@@ -465,19 +477,11 @@ function finalizeImproveMetrics(metrics) {
         metrics.memoryInference.considered > 0 ||
             metrics.memoryInference.written > 0 ||
             metrics.memoryInference.durationMs > 0;
-    metrics.memoryInference.writes = metrics.memoryInference.written;
-    // Yield denominator excludes cache hits AND legacy (pre-cacheHits-field)
-    // envelopes. Only runs whose envelope carries a `cacheHits` field
-    // contribute to freshAttempts/yieldRate; legacy rows remain in
-    // `considered`/`written` for totals but are excluded from the rate so
-    // they cannot drag it down. See ImproveHealthMetrics.memoryInference
-    // jsdoc for the rationale.
-    metrics.memoryInference.freshAttempts = Math.max(0, metrics.memoryInference.yieldEligibleConsidered -
-        metrics.memoryInference.cacheHits -
-        metrics.memoryInference.skippedAborted);
+    // Yield denominator excludes cache hits and aborted records.
+    metrics.memoryInference.freshAttempts = Math.max(0, metrics.memoryInference.considered - metrics.memoryInference.cacheHits - metrics.memoryInference.skippedAborted);
     metrics.memoryInference.yieldRate =
         metrics.memoryInference.freshAttempts > 0
-            ? roundRate(metrics.memoryInference.yieldEligibleWritten / metrics.memoryInference.freshAttempts)
+            ? roundRate(metrics.memoryInference.written / metrics.memoryInference.freshAttempts)
             : 0;
     metrics.graphExtraction.ran =
         metrics.graphExtraction.extractedFiles > 0 ||
@@ -485,6 +489,10 @@ function finalizeImproveMetrics(metrics) {
             metrics.graphExtraction.durationMs > 0;
     const cacheTotal = metrics.graphExtraction.cacheHits + metrics.graphExtraction.cacheMisses;
     metrics.graphExtraction.cacheHitRate = cacheTotal > 0 ? roundRate(metrics.graphExtraction.cacheHits / cacheTotal) : 0;
+    metrics.graphExtraction.extractionCoverage =
+        metrics.graphExtraction.consideredFiles > 0
+            ? roundRate(metrics.graphExtraction.extractedFiles / metrics.graphExtraction.consideredFiles)
+            : 0;
     metrics.sessionExtraction.ran =
         metrics.sessionExtraction.sessionsScanned > 0 ||
             metrics.sessionExtraction.proposalsCreated > 0 ||
@@ -496,8 +504,8 @@ function finalizeImproveMetrics(metrics) {
  */
 function mergeImproveMetrics(dst, src) {
     dst.plannedRefs += src.plannedRefs;
-    // profileFilteredRefs is the count of refs the planner drops up-front for the
-    // active profile — recomputed against the (stable) stash every run, so it is a
+    // strategyFilteredRefs is the count of refs the planner drops up-front for the
+    // active strategy — recomputed against the (stable) stash every run, so it is a
     // snapshot, NOT a per-run increment. Summing it re-counts the same refs each
     // run (the ~2.4M bug). Set from the most recent run in summarizeImproveRuns.
     dst.actions.reflect.ok += src.actions.reflect.ok;
@@ -510,7 +518,6 @@ function mergeImproveMetrics(dst, src) {
     }
     dst.actions.distill.queued += src.actions.distill.queued;
     dst.actions.distill.llmFailed += src.actions.distill.llmFailed;
-    dst.actions.distill.qualityRejected += src.actions.distill.qualityRejected;
     dst.actions.distill.judgeRejected += src.actions.distill.judgeRejected;
     dst.actions.distill.validatorRejected += src.actions.distill.validatorRejected;
     dst.actions.distill.configDisabled += src.actions.distill.configDisabled;
@@ -565,11 +572,10 @@ function mergeImproveMetrics(dst, src) {
     dst.memoryInference.skippedAborted += src.memoryInference.skippedAborted;
     dst.memoryInference.unaccounted += src.memoryInference.unaccounted;
     dst.memoryInference.htmlErrorCount += src.memoryInference.htmlErrorCount;
-    dst.memoryInference.yieldEligibleRuns += src.memoryInference.yieldEligibleRuns;
-    dst.memoryInference.yieldEligibleConsidered += src.memoryInference.yieldEligibleConsidered;
-    dst.memoryInference.yieldEligibleWritten += src.memoryInference.yieldEligibleWritten;
+    dst.memoryInference.retryAttempts += src.memoryInference.retryAttempts;
     dst.memoryInference.durationMs += src.memoryInference.durationMs;
     dst.graphExtraction.extractedFiles += src.graphExtraction.extractedFiles;
+    dst.graphExtraction.consideredFiles += src.graphExtraction.consideredFiles;
     dst.graphExtraction.entities += src.graphExtraction.entities;
     dst.graphExtraction.relations += src.graphExtraction.relations;
     dst.graphExtraction.cacheHits += src.graphExtraction.cacheHits;
@@ -578,6 +584,7 @@ function mergeImproveMetrics(dst, src) {
     dst.graphExtraction.failures += src.graphExtraction.failures;
     dst.graphExtraction.htmlErrors += src.graphExtraction.htmlErrors;
     dst.graphExtraction.nonArrayBatchFailures += src.graphExtraction.nonArrayBatchFailures;
+    dst.graphExtraction.retryAttempts += src.graphExtraction.retryAttempts;
     dst.graphExtraction.durationMs += src.graphExtraction.durationMs;
     dst.sessionExtraction.sessionsScanned += src.sessionExtraction.sessionsScanned;
     dst.sessionExtraction.sessionsExtracted += src.sessionExtraction.sessionsExtracted;
@@ -588,7 +595,6 @@ function mergeImproveMetrics(dst, src) {
     // WS-5: merge perf telemetry (additive sums).
     dst.perfTelemetry.dedupPoolSize += src.perfTelemetry.dedupPoolSize;
     dst.perfTelemetry.llmPoolSize += src.perfTelemetry.llmPoolSize;
-    dst.perfTelemetry.judgedCacheSkipped += src.perfTelemetry.judgedCacheSkipped;
     dst.perfTelemetry.embedMs += src.perfTelemetry.embedMs;
     dst.perfTelemetry.embedCacheHits += src.perfTelemetry.embedCacheHits;
     dst.perfTelemetry.embedCacheMisses += src.perfTelemetry.embedCacheMisses;
@@ -598,6 +604,15 @@ function mergeImproveMetrics(dst, src) {
     // totalAssets is intentionally NOT merged here — set from the most recent run in summarizeImproveRuns.
     dst.coverage.acceptedProposals += src.coverage.acceptedProposals;
 }
+function compareImproveRunRecency(a, b) {
+    const started = a.started_at.localeCompare(b.started_at);
+    if (started !== 0)
+        return started;
+    const completed = a.completed_at.localeCompare(b.completed_at);
+    if (completed !== 0)
+        return completed;
+    return a.id.localeCompare(b.id);
+}
 export function summarizeImproveRuns(db, since, until) {
     const accum = createUnknownImproveMetrics();
     const rows = queryImproveRuns(db, since, until);
@@ -611,24 +626,32 @@ export function summarizeImproveRuns(db, since, until) {
     };
     // memorySummary is a whole-stash snapshot per run, so the window value is the
     // MOST RECENT run's snapshot (current state) — not a sum across runs.
-    let latestStartMs = Number.NEGATIVE_INFINITY;
+    let latestCompleteRow;
     let latestMemorySummary;
-    let latestProfileFilteredRefs = 0;
+    let latestStrategyFilteredRefs = 0;
+    if (!accum.resultRows)
+        throw new Error("invariant: improve result-row accounting was not initialized");
+    accum.resultRows.total = rows.length;
     for (const row of rows) {
-        let result;
+        let decoded;
         try {
-            result = JSON.parse(row.result_json);
+            decoded = decodeImproveResult(row.result_json);
         }
         catch {
+            accum.resultRows.skipped.invalid += 1;
             continue;
         }
+        accum.resultRows.included += 1;
+        const result = decoded.envelope;
         const perRow = projectRunMetrics(result);
         mergeImproveMetrics(accum, perRow);
         const startMs = new Date(row.started_at).getTime();
-        if (Number.isFinite(startMs) && startMs >= latestStartMs) {
-            latestStartMs = startMs;
+        if (result.terminated === undefined &&
+            Number.isFinite(startMs) &&
+            (latestCompleteRow === undefined || compareImproveRunRecency(row, latestCompleteRow) > 0)) {
+            latestCompleteRow = row;
             latestMemorySummary = perRow.memorySummary;
-            latestProfileFilteredRefs = perRow.profileFilteredRefs;
+            latestStrategyFilteredRefs = perRow.strategyFilteredRefs;
         }
         // Collect per-phase durations directly off the envelope. consolidation's
         // duration lives inside the sub-object; memoryInference and graphExtraction
@@ -648,7 +671,7 @@ export function summarizeImproveRuns(db, since, until) {
     finalizeImproveMetrics(accum);
     if (latestMemorySummary)
         accum.memorySummary = latestMemorySummary;
-    accum.profileFilteredRefs = latestProfileFilteredRefs;
+    accum.strategyFilteredRefs = latestStrategyFilteredRefs;
     accum.wallTime.byPhase = {
         consolidation: summarizePhaseDurations(phaseDurations.consolidation),
         memoryInference: summarizePhaseDurations(phaseDurations.memoryInference),
@@ -681,11 +704,16 @@ export function summarizePhaseDurations(samples) {
  */
 export function projectImproveRunSummary(row, wallTimeMs, taskId) {
     let result = {};
+    let resultStatus = "invalid";
     try {
-        result = JSON.parse(row.result_json);
+        const decoded = decodeImproveResult(row.result_json);
+        result = decoded.envelope;
+        resultStatus = "valid";
     }
     catch {
-        // fall through with empty result so per-stage rollups are zeros
+        // Keep the persisted row visible in per-run output, but do not project its
+        // unknown payload or admit its duration to result-derived denominators.
+        wallTimeMs = 0;
     }
     const perRow = projectRunMetrics(result);
     finalizeImproveMetrics(perRow);
@@ -699,6 +727,9 @@ export function projectImproveRunSummary(row, wallTimeMs, taskId) {
         completedAt: row.completed_at,
         wallTimeMs,
         ok: row.ok === 1,
+        resultStatus,
+        resultComplete: resultStatus === "valid" && result.terminated === undefined,
+        strategy: row.strategy,
         scope: {
             mode: row.scope_mode,
             ...(row.scope_value ? { value: row.scope_value } : {}),
@@ -744,10 +775,10 @@ export function buildImproveSkipSummary(events) {
     //  - Per-occurrence (no `count`): one event per skipped ref → SUM is correct.
     //  - Aggregated snapshot (carries `count`): a single per-run event whose count
     //    is the number of refs that hit a STABLE, whole-stash condition that run
-    //    (`no_new_signal`, `profile_filtered_all_passes`). Each run re-counts the
+    //    (`no_new_signal`, `strategy_filtered_all_passes`). Each run re-counts the
     //    same stable set, so summing across the window re-counts it N times (the
     //    2.7M / 3M inflation). For these we keep the MOST RECENT run's count — the
-    //    current snapshot — matching how memorySummary/profileFilteredRefs are
+    //    current snapshot — matching how memorySummary/strategyFilteredRefs are
     //    handled. Events arrive in chronological (offset) order, so the last
     //    count-bearing event per reason is the latest run's value.
     const summed = {};