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

package/dist/commands/improve/improve.js

@@ -1,12 +1,15 @@
 // 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/.
+/**
+ * `akm improve`: under one run lock, bootstrap the index, drain the proposal
+ * backlog (triage), select candidates, run preparation → loop → post-loop, then
+ * commit what the run wrote (auto-sync). A dry run plans on read-only state.
+ */
 import fs from "node:fs";
 import path from "node:path";
-import { assertNever } from "../../core/assert.js";
 import { parseRefInput } from "../../core/asset/resolve-ref.js";
-import { daysToMs } from "../../core/common.js";
-import { bundlesToSourceEntries, loadConfig } from "../../core/config/config.js";
+import { bundlesToSourceEntries, loadConfig, } from "../../core/config/config.js";
 import { ConfigError, rethrowIfTestIsolationError, UsageError } from "../../core/errors.js";
 import { appendEvent, readEvents } from "../../core/events.js";
 import { classifyImproveAction, foldDistillSkipped } from "../../core/improve-types.js";
@@ -31,25 +34,20 @@ import { getEntryCount } from "../../storage/repositories/index-entries-reposito
 import { openSqliteReadSnapshot, SqliteReadSnapshotUnavailableError } from "../../storage/sqlite-read-snapshot.js";
 import { summarizeLlmUsageCrossTab } from "../health/llm-usage.js";
 import { drainProposals } from "../proposal/drain.js";
-import { resolveDrainPolicy } from "../proposal/drain-policies.js";
 import { describeGatedLanes, isAutonomyLaneAllowed } from "./autonomy-gate.js";
 import { akmDistill } from "./distill.js";
-// Eligibility / candidate-selection predicates live in ./eligibility.
-import { buildLatestProposalTsMap, collectEligibleRefs, collectEligibleRefsReadOnly, memoryCleanupParentRef, resolveImproveScope, shouldAnalyzeMemoryCleanup, } from "./eligibility.js";
-import { projectResolvedProcessRouting, resolveImprovePlan, resolveImproveStrategy, shouldSkipRef, } from "./improve-strategies.js";
+import { collectEligibleRefs, collectEligibleRefsReadOnly, memoryCleanupParentRef, resolveImproveScope, shouldAnalyzeMemoryCleanup, } from "./eligibility.js";
+import { eligibleRefCount, projectResolvedProcessRouting, resolveImprovePlan, resolveImproveStrategy, } from "./improve-strategies.js";
 import { buildImproveUsageReport } from "./improve-usage-report.js";
+import { lastAttemptByRef, loadLedgerSnapshot } from "./ledger.js";
 import { improveLockPath, releaseImproveLock, tryAcquireImproveLock } from "./locks.js";
-// The cycle loop / post-loop / maintenance stages live in ./loop-stages.
 import { runImproveLoopStage, runImprovePostLoopStage } from "./loop-stages.js";
 import { analyzeMemoryCleanup } from "./memory/memory-improve.js";
 import { buildImproveExecutionPlan } from "./planner.js";
-// The pre-loop preparation pipeline lives in ./preparation.
-import { runImprovePreparationStage } from "./preparation.js";
+import { CONSOLIDATION_CONFIG_KEYS, pickDefined, recordImproveSkip, runImprovePreparationStage } from "./preparation.js";
 import { DEFAULT_DUE_DAYS, filterProactiveDue } from "./proactive-maintenance.js";
 import { akmReflect } from "./reflect.js";
-import { createRunContext } from "./run-context.js";
-import { errMessage } from "./shared.js";
-// Re-exported from ./loop-stages for test importers (improve-db-locking).
+import { errMessage, noticeSet } from "./stage.js";
 export { runImproveMaintenancePasses } from "./loop-stages.js";
 export function renderSyncCommitMessage(template, result, nowMs) {
     const iso = new Date(nowMs).toISOString();
@@ -67,18 +65,16 @@ export function renderSyncCommitMessage(template, result, nowMs) {
     return template.replace(/\{(\w+)\}/g, (match, key) => tokens[key] ?? match);
 }
 /**
- * How long the improve loop waits for its FIRST engine response (success or
- * error — any terminal record proves the run is not silent) before printing
- * one default-level line. The timer is armed once the triage/index prepass
- * finishes and the loop is about to start dispatching engine requests — not
- * at run start — so it measures engine latency, not prepass time. Field
- * re-test (#957): an engine pointed at a dead endpoint produced zero output
- * for minutes, so a genuine hang looked identical to a normal-but-slow run.
- * A few seconds is short enough that an operator watching a scheduled run's
- * live log sees something promptly, long enough that an ordinary fast
- * response never prints it.
+ * How long the loop waits for its first engine response before printing one
+ * "still waiting" line (#957): a dead endpoint otherwise looks like a slow run.
+ * Armed when the loop starts, not at run start.
  */
 export const FIRST_ENGINE_RESPONSE_HEARTBEAT_MS = 5_000;
+/**
+ * Abort the run at the budget; force-exit (0 — budget exhaustion is a normal
+ * scheduled-task outcome) only if the drain overruns the grace period.
+ * Returns an idempotent disposer.
+ */
 export function armBudgetWatchdog(budgetMs, controller, deps) {
     const setTimeoutFn = deps?.setTimeoutFn ?? setTimeout;
     const clearTimeoutFn = deps?.clearTimeoutFn ?? clearTimeout;
@@ -86,15 +82,10 @@ export function armBudgetWatchdog(budgetMs, controller, deps) {
     const hardKillGraceMs = deps?.hardKillGraceMs ?? 5_000;
     let hardKillTimer;
     const budgetTimer = setTimeoutFn(() => {
-        // Cooperative cancellation first: let the run drain.
         controller.abort("improve budget exhausted");
-        // Watchdog: only force-exit if the drain itself overruns the grace period.
-        // Exit 0: budget exhaustion is a normal scheduled-task condition, not an error.
         hardKillTimer = setTimeoutFn(() => exitFn(0), hardKillGraceMs);
-        // Never keep the event loop alive solely for the watchdog.
         hardKillTimer.unref?.();
     }, budgetMs);
-    // RAII dispose: clears whichever timer is still pending. Idempotent.
     return () => {
         clearTimeoutFn(budgetTimer);
         if (hardKillTimer !== undefined) {
@@ -103,62 +94,30 @@ export function armBudgetWatchdog(budgetMs, controller, deps) {
         }
     };
 }
-/**
- * The run's write-provenance journal lifecycle as one named unit (#652).
- *
- * The journal is opened once the run owns its lock — so it spans exactly the
- * window in which this run, and only this run, is allowed to write — and closed
- * on every exit path including the crash-safety commit. Keeping the mutable
- * handle behind this factory rather than as a bare `let` in {@link akmImprove}
- * is also what keeps that function under the R31 size gate
- * (`tests/architecture/improve-fn-size-ratchet.test.ts`, absolute 220-line bar
- * with an empty baseline): lifecycle state belongs in a named unit, not in the
- * orchestrator's preamble.
- */
-function createRunWriteJournal() {
-    let journal;
-    return {
-        open: () => {
-            journal = beginWriteProvenance();
-        },
-        close: () => {
-            journal?.end();
-            journal = undefined;
-        },
-        current: () => journal,
-    };
-}
 export async function akmImprove(options = {}) {
     const setup = resolveImproveRunSetup(options);
     options = setup.options;
-    const { budgetMs, budgetAbortController, scope, selectedStrategy, syncRepoDir, resolvedStateDbPath, resolvedLockPath, } = setup;
+    const { budgetMs, budgetAbortController, scope, selectedStrategy, syncRepoDir, resolvedStateDbPath } = setup;
     let clearBudgetTimer = () => { };
     let clearFirstResponseHeartbeat = () => { };
-    // #957: set by the usage sink's onRecord callback the moment any engine
-    // call terminates (success or error), including one issued by the prepass
-    // itself — makes arming the heartbeat below a no-op when the run is
-    // already known not to be silent.
+    // Set by the usage sink when any engine call terminates, prepass included.
     let firstEngineResponseSeen = false;
     let initialGitPaths = new Set();
-    const runJournal = createRunWriteJournal();
+    // The write-provenance journal (#652) spans exactly the window this run holds the lock.
+    let journal;
+    const closeJournal = () => {
+        journal?.end();
+        journal = undefined;
+    };
     const preEnsureCleanupWarnings = [];
-    let plannedRefs = [];
-    let memorySummary = { eligible: 0, derived: 0 };
-    let strategyFilteredRefs = [];
-    let indexSnapshot;
-    let memoryCleanupPlan;
-    let autonomyGatedDirectLanes = [];
-    let guidance;
+    let collected;
     let triageDrain;
     let ensureIndexDurationMs;
     let improveLockOwnership;
     let exitBackstop;
-    // I1: open a single state.db connection for the main improve run so all
-    // appendEvent calls reuse one handle instead of open/migrate/close per call.
     let eventsDb;
-    // Start boundary-pinned for prepass telemetry, then replace this binding with
-    // the long-lived handle after the prepass. The usage sink resolves it per
-    // append, so one owner and counter span both lifecycle phases.
+    // Boundary-pinned for the prepass; replaced by the long-lived handle after it.
+    // The usage sink resolves it per append.
     let eventsCtx = { dbPath: resolvedStateDbPath };
     let disposeLlmUsageSink = () => { };
     const releaseRunLock = () => {
@@ -170,15 +129,27 @@ export async function akmImprove(options = {}) {
             releaseImproveLock(ownership);
         }
         catch {
-            // Best-effort cleanup. Exact ownership prevents deleting a successor.
+            // Best-effort; exact ownership never deletes a successor's lock.
         }
     };
+    const teardown = () => {
+        // The usage sink goes before eventsDb closes; the journal closes after the
+        // crash-safety commit that still needs it.
+        disposeLlmUsageSink();
+        clearFirstResponseHeartbeat();
+        clearBudgetTimer();
+        if (exitBackstop) {
+            // Only our own listener: removeAllListeners would drop the host's.
+            process.removeListener("exit", exitBackstop);
+            exitBackstop = undefined;
+        }
+        releaseRunLock();
+        closeJournal();
+    };
     const commitStashBatch = makeCommitStashBatch({
         run: setup,
         getInitialGitPaths: () => initialGitPaths,
-        getWriteJournal: () => runJournal.current(),
-        // Captured via getter: the live `eventsCtx` binding is reassigned after the
-        // prepass, and the catch-path sync must write through the current context.
+        getWriteJournal: () => journal,
         getEventsCtx: () => eventsCtx,
     });
     if (!options.dryRun) {
@@ -187,8 +158,7 @@ export async function akmImprove(options = {}) {
     }
     try {
         if (!options.dryRun) {
-            const acquisition = tryAcquireImproveLock(resolvedLockPath, options.skipIfLocked, {
-                // R25: C2 boundary-pinned path — the long-lived handle doesn't exist yet.
+            const acquisition = tryAcquireImproveLock(setup.resolvedLockPath, options.skipIfLocked, {
                 dbPath: resolvedStateDbPath,
             });
             if (acquisition.state === "skipped") {
@@ -204,86 +174,38 @@ export async function akmImprove(options = {}) {
             process.on("exit", exitBackstop);
             initialGitPaths =
                 syncRepoDir && isGitBackedStash(syncRepoDir) ? new Set(listGitChangedPaths(syncRepoDir)) : new Set();
-            // #652: open AFTER the lock, so the journal covers exactly the window in
-            // which this run — and only this run — is allowed to write.
-            runJournal.open();
-            // R6: ensureIndex BEFORE triage, not after. Triage promotes proposals
-            // straight into the flat `knowledge/` root; running the blocking
-            // reindex only afterward (inside indexAndCollect, below) meant every
-            // triage promotion dirtied the stash right before the rescan that is
-            // supposed to precede it, so the "blocking" reindex always found fresh
-            // work and paid for a full walk on the very run it was meant to avoid.
+            journal = beginWriteProvenance();
+            // The index is made current BEFORE triage (R6): triage promotes into the
+            // stash, and a reindex after it would always find fresh work.
             const bootstrap = await runIndexBootstrapPass(setup, budgetAbortController.signal);
             preEnsureCleanupWarnings.push(...bootstrap.warnings);
             ensureIndexDurationMs = bootstrap.ensureIndexDurationMs;
-            // Drain the standing proposal backlog under the now-current index, so
-            // fresh proposal generation sees promotions from this same serialized
-            // run.
             triageDrain = await runTriagePrePass(setup);
-            // R6: index triage's own writes incrementally (the R8
-            // `indexWrittenAssets` pattern) instead of letting them sit newer than
-            // `builtAt` until the next full reindex. `collectEligibleRefs` below
-            // still needs to see them, and per-file staleness (`ensure-index.ts`)
-            // needs their `content_hash` recorded so it does not re-trigger a full
-            // rescan next run for content it already has.
-            if (setup.primaryStashDir) {
-                const triageWrittenPaths = runJournal.current()?.writtenPaths() ?? [];
-                if (triageWrittenPaths.length > 0) {
-                    await indexWrittenAssets(setup.primaryStashDir, triageWrittenPaths);
-                }
+            // Index triage's own writes incrementally so selection sees them.
+            const triageWrittenPaths = journal?.writtenPaths() ?? [];
+            if (setup.primaryStashDir && triageWrittenPaths.length > 0) {
+                await indexWrittenAssets(setup.primaryStashDir, triageWrittenPaths);
             }
         }
-        const collected = await indexAndCollect({ run: setup });
-        plannedRefs = collected.plannedRefs;
-        memorySummary = collected.memorySummary;
-        strategyFilteredRefs = collected.strategyFilteredRefs;
-        indexSnapshot = collected.indexSnapshot;
-        memoryCleanupPlan = collected.memoryCleanupPlan;
-        autonomyGatedDirectLanes = collected.autonomyGatedDirectLanes;
-        guidance = collected.guidance;
+        collected = await indexAndCollect(setup);
         if (options.dryRun) {
-            const result = await runDryPlanningStage({
-                run: setup,
-                collected,
-                resolvedStateDbPath,
-                budgetMs,
-                initialCleanupWarnings: preEnsureCleanupWarnings,
-                signal: budgetAbortController.signal,
-            });
+            const result = await runDryPlanningStage(setup, collected, preEnsureCleanupWarnings);
             clearBudgetTimer();
             return result;
         }
     }
     catch (err) {
-        // If the live prepass fails, emit its summary and clear the owning sink
-        // before any run teardown. The disposer is idempotent with the main finalizer.
-        disposeLlmUsageSink();
-        clearFirstResponseHeartbeat();
-        clearBudgetTimer();
-        if (exitBackstop) {
-            process.removeListener("exit", exitBackstop);
-            exitBackstop = undefined;
-        }
-        releaseRunLock();
-        runJournal.close();
+        teardown();
         throw err;
     }
     try {
-        const openedEvents = openImproveEventsContext(resolvedStateDbPath);
-        eventsDb = openedEvents.db;
-        eventsCtx = openedEvents.ctx;
-        // WI-9.10: construct the run's RunContext here — the first point after
-        // run-setup where config/stashDir/eventsCtx/proposalsCtx/sourceRun/dryRun
-        // are all in hand. See buildImproveRunContext for exactly which
-        // already-resolved values back each field.
-        const ctx = buildImproveRunContext(setup, eventsCtx);
-        // #957: arm the heartbeat here, immediately before the improve loop
-        // starts dispatching engine requests — not at run start, where its timer
-        // would measure the triage/index prepass instead of engine latency. A
-        // no-op when the prepass already produced a terminal LLM record (the
-        // onRecord callback above already saw it). Cleared the moment any call
-        // terminates (success or error) — never rearmed, so this prints at most
-        // once per run.
+        try {
+            eventsDb = openStateDatabase(resolvedStateDbPath);
+            eventsCtx = { db: eventsDb };
+        }
+        catch (err) {
+            rethrowIfTestIsolationError(err);
+        }
         if (!firstEngineResponseSeen) {
             const firstResponseTimer = setTimeout(() => {
                 warn("[improve] Still waiting for the first engine response...");
@@ -291,46 +213,11 @@ export async function akmImprove(options = {}) {
             firstResponseTimer.unref?.();
             clearFirstResponseHeartbeat = () => clearTimeout(firstResponseTimer);
         }
-        const seq = await runImproveStageSequence({
-            run: setup,
-            strategyFilteredRefs,
-            plannedRefs,
-            memoryCleanupPlan,
-            autonomyGatedDirectLanes,
-            memorySummary,
-            preEnsureCleanupWarnings,
-            eventsCtx,
-            ctx,
-        });
-        const result = finalizeImproveResult({
-            run: setup,
-            seq,
-            guidance,
-            memorySummary,
-            memoryCleanupPlan,
-            strategyFilteredRefs,
-            rawPlannedRefs: plannedRefs,
-            indexSnapshot,
-            triageDrain,
-            ensureIndexDurationMs,
-            eventsCtx,
-        });
-        // End-of-run BATCH auto-sync — the converged commit. Recognition is
-        // decoupled from the per-write path (see write-source.ts case-3): the primary
-        // stash writes as a filesystem source during the run, then is committed via
-        // the same `saveGitStash` that `akm sync` calls. The gating (git-backed
-        // primary stash, sync not disabled) and the NON-FATAL guarantee now live in
-        // `commitStashBatch` (#662); the inter-cycle and catch-path calls reuse it.
-        // dry-run already returned above, so this always runs on a completed live
-        // run. `result.sync` reflects this final commit (for a one-cycle run it is
-        // the only commit; for a multi-cycle run the earlier cycles were banked by
-        // the inter-cycle calls and this records the last batch). `result` carries
-        // the full `{accepted}`/`{refs}`/`{triage_*}` token data for the message.
-        //
-        // #652: surface the run's write provenance on the envelope BEFORE the sync
-        // (the sync itself writes no assets), so `result.writtenPaths` describes
-        // exactly the set the commit below was scoped to.
-        const writtenPaths = describeRunWrittenPaths(setup, runJournal.current()?.writtenPaths() ?? []);
+        const seq = await runImproveStageSequence(setup, collected, preEnsureCleanupWarnings, eventsCtx);
+        const result = finalizeImproveResult({ run: setup, seq, collected, triageDrain, ensureIndexDurationMs, eventsCtx });
+        // The run's write provenance goes on the envelope before the sync, so
+        // `writtenPaths` is exactly the set the commit is scoped to.
+        const writtenPaths = describeRunWrittenPaths(setup, journal?.writtenPaths() ?? []);
         if (writtenPaths.length > 0)
             result.writtenPaths = writtenPaths;
         result.sync = commitStashBatch(result);
@@ -338,64 +225,24 @@ export async function akmImprove(options = {}) {
     }
     catch (err) {
         recordImproveFailure(err, setup, eventsCtx);
-        // #662 crash/abort safety net: commit whatever this run already wrote to the
-        // primary stash BEFORE rethrowing, so an interrupted run (mid-cycle crash or
-        // a cooperative budget abort that surfaces as a throw) does not leave its
-        // writes uncommitted until a later clean run sweeps them up. Best-effort —
-        // `commitStashBatch` swallows its own errors and no-ops a clean tree, so this
-        // never masks or supersedes the original failure being rethrown below.
-        commitStashBatch({ scope, plannedRefs, runId: options.runId });
+        // Crash/abort safety net (#662): commit what this run already wrote.
+        // commitStashBatch never throws and no-ops a clean tree.
+        commitStashBatch({ scope, plannedRefs: collected.plannedRefs, runId: options.runId });
         throw err;
     }
     finally {
-        // #576: clear the per-run LLM usage sink BEFORE closing `eventsDb` below, so
-        // no late sink invocation can write through a closed handle.
-        disposeLlmUsageSink();
-        // #957: never leave the first-response heartbeat timer pending past the run.
-        clearFirstResponseHeartbeat();
-        // O-1 (#364): Clear the budget abort timer so it does not keep the event
-        // loop alive after the run completes.
-        clearBudgetTimer();
-        // Drop ONLY our own process.exit backstop so it does not fire later (or
-        // accumulate across repeated in-process calls). Must NOT use
-        // removeAllListeners("exit") here: in the in-process model (tests and
-        // programmatic callers import cli.ts) that would silently destroy exit
-        // handlers owned by the host or other commands.
-        if (exitBackstop) {
-            process.removeListener("exit", exitBackstop);
-            exitBackstop = undefined;
-        }
-        releaseRunLock();
-        // #652: close the write-provenance journal LAST among the write-facing
-        // teardown steps — the catch path's crash-safety commit above still needs
-        // it open to know what this run wrote.
-        runJournal.close();
-        // I1: close the long-lived state.db connection opened at the top of the run.
+        teardown();
         try {
             eventsDb?.close();
         }
         catch {
-            // ignore — DB may already be closed
+            // already closed
         }
     }
 }
-/** Open the run-owned state handle while preserving the boundary-pinned fallback. */
-function openImproveEventsContext(dbPath) {
-    try {
-        const db = openStateDatabase(dbPath);
-        return { db, ctx: { db } };
-    }
-    catch (err) {
-        rethrowIfTestIsolationError(err);
-        return { ctx: { dbPath } };
-    }
-}
 /**
- * Shape the run's journaled absolute paths for `result.writtenPaths` (#652):
- * POSIX-relative to the run's primary stash dir (the repo root for a git-backed
- * stash) when the write landed inside it, absolute otherwise — a run writing to
- * a `--target` bundle outside the stash still reports what it wrote. Deduped and
- * sorted so the field is stable across runs.
+ * The run's journaled paths for `result.writtenPaths`: POSIX-relative to the
+ * primary stash when inside it, absolute otherwise; deduped and sorted.
  */
 function describeRunWrittenPaths(setup, writtenPaths) {
     const root = setup.primaryStashDir ?? setup.syncRepoDir;
@@ -407,19 +254,16 @@ function describeRunWrittenPaths(setup, writtenPaths) {
     return [...described].sort();
 }
 /**
- * Resolve a dry-run inspection source without adapting it into a write target.
- * Exported so `improve-cli.ts`'s `--show-prompt` (#952) can resolve the same
- * read-only bundle a plain `--dry-run` would, without duplicating this
- * selector/target/fallback precedence.
+ * The source a dry run (or `--show-prompt`) inspects, without adapting it into
+ * a write target.
  */
 export function resolveImproveReadSource(config, scopedRef, explicitTarget, fallbackStashDir) {
     if (scopedRef?.origin && explicitTarget && scopedRef.origin !== explicitTarget) {
         throw new UsageError(`Qualified ref bundle "${scopedRef.origin}" conflicts with --target "${explicitTarget}".`, "INVALID_FLAG_VALUE", `Drop --target or use --target ${scopedRef.origin}.`);
     }
     const selector = scopedRef?.origin ?? explicitTarget ?? config.defaultWriteTarget;
-    if (!selector && fallbackStashDir) {
+    if (!selector && fallbackStashDir)
         return { source: { name: "stash", path: fallbackStashDir } };
-    }
     const configuredSelector = selector ?? config.defaultBundle;
     if (configuredSelector) {
         const entry = bundlesToSourceEntries(config)?.find((source) => source.name === configuredSelector);
@@ -433,17 +277,14 @@ export function resolveImproveReadSource(config, scopedRef, explicitTarget, fall
         return { selector: configuredSelector, source: { name: configuredSelector, path: sourcePath } };
     }
     const implicit = resolveSourceEntries(undefined, config)[0];
-    if (!implicit) {
+    if (!implicit)
         throw new ConfigError("no source configured; run `akm bundle create`", "STASH_DIR_NOT_FOUND");
-    }
     return { source: { name: implicit.registryId ?? "stash", path: implicit.path } };
 }
 /**
- * Run-setup: budget/watchdog plumbing, scope + seam resolution, the invocation
- * plan, write-target resolution, the profile-defaulted options rebuild, and
- * the boundary-pinned state.db/lock paths. Fully SYNCHRONOUS — the C2 boundary
- * snapshot (resolvedStateDbPath) must be taken before the first await of the
- * run.
+ * Run setup, fully synchronous: the budget signal, the invocation plan, the
+ * write target, the profile-defaulted options, and the state.db and lock paths
+ * pinned before the first await (C2: a later env change cannot redirect them).
  */
 function resolveImproveRunSetup(options) {
     const startMs = Date.now();
@@ -455,30 +296,15 @@ function resolveImproveRunSetup(options) {
         configurable: true,
     });
     const scope = resolveImproveScope(options.scope);
-    const reflectFn = options.reflectFn ?? akmReflect;
-    const distillFn = options.distillFn ?? akmDistill;
-    const ensureIndexFn = options.ensureIndexFn ?? ensureIndex;
-    const reindexFn = options.reindexFn ?? akmIndex;
-    const drainProposalsFn = options.drainProposalsFn ?? drainProposals;
-    // #616 multi-cycle test seams. Default to the real module-local fns.
-    const collectEligibleRefsImpl = options.collectEligibleRefsFn ?? (options.dryRun ? collectEligibleRefsReadOnly : collectEligibleRefs);
-    const runImprovePreparationStageImpl = options.runImprovePreparationStageFn ?? runImprovePreparationStage;
-    const runImproveLoopStageImpl = options.runImproveLoopStageFn ?? runImproveLoopStage;
-    const runImprovePostLoopStageImpl = options.runImprovePostLoopStageFn ?? runImprovePostLoopStage;
-    // Resolve the improve profile for this run. Profile drives type filtering,
-    // process gating, and the default limit value.
-    const _earlyConfig = options.config ?? loadConfig();
-    const configuredImproveProfile = resolveImproveStrategy(options.strategy, _earlyConfig).config;
+    const config = options.config ?? loadConfig();
+    const configuredImproveProfile = resolveImproveStrategy(options.strategy, config).config;
+    // A dry run never dispatches, so an all-disabled strategy must not abort it.
     const resolvedPlan = options.resolvedPlan ??
-        // #800/#957 round 3 — same dry-run exemption as improve-cli.ts's own
-        // resolveImprovePlan call: a dry run never dispatches, so a strategy left
-        // fully disabled by an unreachable credential must not abort here either.
-        resolveImprovePlan(options.strategy, _earlyConfig, {
+        resolveImprovePlan(options.strategy, config, {
             repairValidationFailures: options.repairValidationFailures,
             allowAllDisabled: options.dryRun,
         });
     const selectedStrategy = resolvedPlan.strategy;
-    const improveSensitiveValues = collectEngineCredentialValues(_earlyConfig);
     const improveProfile = selectedStrategy.config;
     const configuredLimits = {
         ...(options.limit !== undefined ? { cli: options.limit } : {}),
@@ -487,52 +313,36 @@ function resolveImproveRunSetup(options) {
             ? { reflect: configuredImproveProfile.processes.reflect.limit }
             : {}),
     };
+    // --limit, then the reflect process limit, then the profile limit.
     const effectiveLimit = options.limit ?? improveProfile?.processes?.reflect?.limit ?? improveProfile.limit;
     const scopedRef = scope.mode === "ref" && scope.value ? parseRefInput(scope.value) : undefined;
     const readSource = options.dryRun
         ? options.writeTarget
             ? { selector: options.writeTarget.selector, source: options.writeTarget.source }
-            : resolveImproveReadSource(_earlyConfig, scopedRef, options.target, options.stashDir)
+            : resolveImproveReadSource(config, scopedRef, options.target, options.stashDir)
         : undefined;
     const writeTarget = options.dryRun
         ? undefined
         : scopedRef?.origin
-            ? resolveMutationTarget(_earlyConfig, scopedRef, options.writeTarget?.source.name ?? options.target).target
+            ? resolveMutationTarget(config, scopedRef, options.writeTarget?.source.name ?? options.target).target
             : (options.writeTarget ??
-                (options.target || _earlyConfig.defaultWriteTarget || !options.stashDir
-                    ? resolveWriteTarget(_earlyConfig, options.target)
+                (options.target || config.defaultWriteTarget || !options.stashDir
+                    ? resolveWriteTarget(config, options.target)
                     : {
                         source: { kind: "filesystem", name: "stash", path: options.stashDir },
-                        config: {
-                            type: "filesystem",
-                            name: "stash",
-                            path: options.stashDir,
-                            writable: true,
-                        },
+                        config: { type: "filesystem", name: "stash", path: options.stashDir, writable: true },
                     }));
     const selectedSource = writeTarget?.source ?? readSource?.source;
     if (!selectedSource)
         throw new ConfigError("improve could not resolve a source", "STASH_DIR_NOT_FOUND");
-    const selectedSelector = writeTarget?.selector ?? readSource?.selector;
-    // Apply profile defaults — CLI flags take precedence over profile defaults.
-    // Rebuild options with effective values so all downstream stage functions
-    // automatically pick up the profile-driven defaults.
+    // Every stage reads this one config snapshot; nothing reloads it mid-run.
     options = {
         ...options,
-        // Pin nested calls and quality gates to the same config snapshot as the
-        // invocation plan. They must never reload a changed config mid-run.
-        config: _earlyConfig,
-        target: selectedSelector,
+        config,
+        target: writeTarget?.selector ?? readSource?.selector,
         sourceName: selectedSource.name,
         ...(writeTarget ? { writeTarget } : {}),
         stashDir: selectedSource.path,
-        consolidateOptions: {
-            ...options.consolidateOptions,
-            target: selectedSelector,
-            ...(writeTarget ? { writeTarget } : {}),
-        },
-        // Profile-level limit, then process-level reflect.limit as fallback.
-        // CLI --limit takes precedence over both.
         limit: effectiveLimit,
     };
     let primaryStashDir;
@@ -542,42 +352,24 @@ function resolveImproveRunSetup(options) {
     catch {
         primaryStashDir = undefined;
     }
-    const syncRepoDir = writeTarget?.source.repoPath ?? primaryStashDir;
-    // C2 (#553/#554/#499): resolve the state.db path ONCE, synchronously, at the
-    // command boundary — before the first `await` below. Every state.db open in
-    // this run (`openStateDatabase`, every default-path `appendEvent`) is pinned
-    // to this snapshot via `eventsCtx.dbPath`, so a parallel test file mutating
-    // `process.env.XDG_DATA_HOME` across an await boundary can never redirect this
-    // run's DB opens to a wrong/just-deleted tmpdir mid-flight (the parallel-load
-    // timeout root cause). Because beforeEach runs synchronously, env is still the
-    // calling test's own at this point; we capture it before yielding the loop.
-    const resolvedStateDbPath = getStateDbPathInDataDir();
-    // One conservative run lock protects the complete mutation window, including
-    // triage, indexing, proposal work, maintenance, and final stash sync. Moved
-    // out of `$STASH/.akm` to `$STATE/locks/<stash>/` (itlackey/akm#890): a lock
-    // file is machine-local coordination state, not content that must travel
-    // with the bundle.
-    const lockBaseDir = getStashLocksDir(primaryStashDir ?? options.stashDir ?? ".");
-    const resolvedLockPath = improveLockPath(lockBaseDir);
-    const effectiveSync = { ...improveProfile.sync, ...options.sync };
     return {
         startMs,
         budgetMs,
         budgetAbortController,
         scope,
-        reflectFn,
-        distillFn,
-        ensureIndexFn,
-        reindexFn,
-        drainProposalsFn,
-        collectEligibleRefsImpl,
-        runImprovePreparationStageImpl,
-        runImproveLoopStageImpl,
-        runImprovePostLoopStageImpl,
-        _earlyConfig,
+        reflectFn: options.reflectFn ?? akmReflect,
+        distillFn: options.distillFn ?? akmDistill,
+        ensureIndexFn: options.ensureIndexFn ?? ensureIndex,
+        reindexFn: options.reindexFn ?? akmIndex,
+        drainProposalsFn: options.drainProposalsFn ?? drainProposals,
+        collectEligibleRefsImpl: options.collectEligibleRefsFn ?? (options.dryRun ? collectEligibleRefsReadOnly : collectEligibleRefs),
+        runImprovePreparationStageImpl: options.runImprovePreparationStageFn ?? runImprovePreparationStage,
+        runImproveLoopStageImpl: options.runImproveLoopStageFn ?? runImproveLoopStage,
+        runImprovePostLoopStageImpl: options.runImprovePostLoopStageFn ?? runImprovePostLoopStage,
+        config,
         resolvedPlan,
         selectedStrategy,
-        improveSensitiveValues,
+        improveSensitiveValues: collectEngineCredentialValues(config),
         improveProfile,
         configuredImproveProfile,
         configuredLimits,
@@ -585,108 +377,58 @@ function resolveImproveRunSetup(options) {
         writeTarget,
         options,
         primaryStashDir,
-        syncRepoDir,
-        resolvedStateDbPath,
-        resolvedLockPath,
-        effectiveSync,
+        syncRepoDir: writeTarget?.source.repoPath ?? primaryStashDir,
+        resolvedStateDbPath: getStateDbPathInDataDir(),
+        // The run lock is machine-local state, kept outside the bundle (#890).
+        resolvedLockPath: improveLockPath(getStashLocksDir(primaryStashDir ?? options.stashDir ?? ".")),
+        effectiveSync: { ...improveProfile.sync, ...options.sync },
     };
 }
-/**
- * WI-9.10: build the run's {@link RunContext} purely from values
- * `resolveImproveRunSetup` and the long-lived state.db open already
- * resolved — no second config load, no new db handle. Called once, right
- * after `eventsCtx` is resolved (the last of {config, stashDir, eventsCtx,
- * proposalsCtx, sourceRun, dryRun} to become available in `akmImprove`).
- */
-function buildImproveRunContext(run, eventsCtx) {
-    return createRunContext({
-        config: run._earlyConfig,
-        // primaryStashDir can fail to resolve (rare); "." mirrors the existing
-        // lockBaseDir fallback in resolveImproveRunSetup for the same case. This
-        // is a BEST-EFFORT value for the required RunContext field only — the
-        // loop stage reads `ImproveLoopState.primaryStashDir` (the honest
-        // optional), so its `if (primaryStashDir)` guards still skip on the
-        // unresolvable path; no RunContext consumer reads `ctx.stashDir` there.
-        stashDir: run.primaryStashDir ?? run.options.stashDir ?? ".",
-        eventsCtx,
-        // ProposalsContext threads only a dbPath seam (D14: no db handle is
-        // threaded in), mirroring eventsCtx's own dbPath-only fallback shape.
-        // Not yet wired into any proposal call site this stage — verb-level
-        // RunContext adoption (reflect/distill/extract/consolidate) is later.
-        proposalsCtx: { dbPath: run.resolvedStateDbPath },
-        // Representative symbolic runner for this run: reflect is the loop's
-        // primary model-driving process. Credentials remain unresolved here.
-        getLlmRunner: () => run.resolvedPlan.processes.reflect.runner,
-        sourceRun: run.options.runId ?? `improve-${run.startMs}`,
-        // Always false here: callers only reach this point past the dry-run
-        // early return in akmImprove.
-        dryRun: run.options.dryRun ?? false,
-        // Same AbortSignal instance armBudgetWatchdog stamped a live
-        // `remainingBudgetMs` getter onto (#616) — identity preserved so
-        // `ctx.signal.remainingBudgetMs` resolves correctly for every consumer.
-        signal: run.budgetAbortController.signal,
-    });
-}
-/** The catch-path improve_failed audit event (D3), redacted. */
+/** The redacted `improve_failed` event for a crashed run. */
 function recordImproveFailure(err, run, eventsCtx) {
-    const { scope, selectedStrategy, improveSensitiveValues, startMs } = run;
-    // D3: emit improve_failed on unexpected crash so dashboards can detect failures.
     appendEvent({
         eventType: "improve_failed",
-        ref: scope.mode === "ref" ? scope.value : `improve:${scope.mode}:${scope.value ?? "all"}`,
+        ref: run.scope.mode === "ref" ? run.scope.value : `improve:${run.scope.mode}:${run.scope.value ?? "all"}`,
         metadata: {
-            strategy: selectedStrategy.name,
-            error: redactSensitiveText(errMessage(err), improveSensitiveValues),
-            durationMs: Date.now() - startMs,
+            strategy: run.selectedStrategy.name,
+            error: redactSensitiveText(errMessage(err), run.improveSensitiveValues),
+            durationMs: Date.now() - run.startMs,
         },
     }, eventsCtx);
 }
-/**
- * R6: ensureIndex bootstrap pass, hoisted out of `indexAndCollect` (below) so
- * the caller can run it BEFORE the triage pre-pass instead of after it —
- * triage promotes proposals straight into `knowledge/`, so ensureIndex must
- * see a current index before triage dirties it, not after. Gated exactly as
- * this logic was gated inside `indexAndCollect`: only for a resolved
- * `primaryStashDir` on a non-dry-run.
- *
- * #339 fix carried over unchanged: ensureIndex MUST run before
- * collectEligibleRefs. The eligible-ref query reads the `entries` table; if a
- * DB version upgrade just dropped that table (or the index is otherwise
- * empty), skipping this would silently return plannedRefs=[] and the improve
- * loop would no-op.
- */
-async function runIndexBootstrapPass(run, signal) {
-    const { primaryStashDir, options, ensureIndexFn } = run;
-    const warnings = [];
-    if (!primaryStashDir || options.dryRun)
-        return { warnings };
-    // Probe pre-ensureIndex entry count to drive the loud-fail warning below.
-    // Best-effort: a missing DB / unreadable schema is the fresh-install case
-    // and not a bug — we silently skip the probe.
-    let preEnsureEntryCount;
+function probeEntryCount() {
     try {
-        const dbPath = getDbPath();
-        if (fs.existsSync(dbPath)) {
-            const probeDb = openExistingDatabase();
-            try {
-                preEnsureEntryCount = getEntryCount(probeDb);
-            }
-            finally {
-                closeDatabase(probeDb);
-            }
+        if (!fs.existsSync(getDbPath()))
+            return undefined;
+        const db = openExistingDatabase();
+        try {
+            return getEntryCount(db);
+        }
+        finally {
+            closeDatabase(db);
         }
     }
     catch (err) {
         rethrowIfTestIsolationError(err);
-        // best-effort; leave preEnsureEntryCount undefined
+        return undefined;
     }
+}
+/**
+ * ensureIndex before selection (#339): the eligible-ref query reads `entries`,
+ * which a DB version upgrade may just have dropped. An index that was empty
+ * and is now populated means an upgrade rebuild happened; say so.
+ */
+async function runIndexBootstrapPass(run, signal) {
+    const { primaryStashDir, options } = run;
+    const warnings = [];
+    if (!primaryStashDir || options.dryRun)
+        return { warnings };
+    const preEnsureEntryCount = probeEntryCount();
     let ensureIndexDurationMs;
     try {
-        await ensureIndexFn(primaryStashDir, {
+        await run.ensureIndexFn(primaryStashDir, {
             mode: "blocking",
             signal,
-            // R6: capture the implicit reindex's wall-clock cost (otherwise
-            // discarded) so the caller can surface it on the improve result.
             onReindexTiming: ({ durationMs }) => {
                 ensureIndexDurationMs = durationMs;
             },
@@ -697,72 +439,37 @@ async function runIndexBootstrapPass(run, signal) {
             throw err;
         warnings.push(`ensureIndex failed: ${errMessage(err)}`);
     }
-    // #339 loud-fail: if the index was empty pre-ensureIndex but is now
-    // populated, a version-upgrade-triggered rebuild just happened. Surface
-    // that on stderr so the improve run is not silently masked by stale
-    // index state. Zero-before AND zero-after is the empty-stash case and
-    // is intentionally not warned (not a bug).
-    if (preEnsureEntryCount === 0) {
-        try {
-            const probeDb = openExistingDatabase();
-            let postCount = 0;
-            try {
-                postCount = getEntryCount(probeDb);
-            }
-            finally {
-                closeDatabase(probeDb);
-            }
-            if (postCount > 0) {
-                warn("[improve] index was empty after DB version upgrade — repopulating before continuing");
-            }
-        }
-        catch (err) {
-            rethrowIfTestIsolationError(err);
-            // best-effort
-        }
+    if (preEnsureEntryCount === 0 && (probeEntryCount() ?? 0) > 0) {
+        warn("[improve] index was empty after DB version upgrade — repopulating before continuing");
     }
     return { warnings, ensureIndexDurationMs };
 }
-/**
- * collectEligibleRefs + the contradiction pre-pass + the memory-cleanup
- * recompute. Formerly the runIndexAndCollect closure mutating outer `let`s;
- * now a pure pass returning its results. The ensureIndex bootstrap this
- * function used to open with now runs earlier, before triage — see
- * {@link runIndexBootstrapPass} and its call site in `akmImprove`.
- */
-async function indexAndCollect(args) {
-    const { scope, options, primaryStashDir, improveProfile, _earlyConfig, collectEligibleRefsImpl } = args.run;
-    const { plannedRefs, memorySummary, strategyFilteredRefs = [], indexSnapshot, } = await collectEligibleRefsImpl(scope, options.stashDir, improveProfile, _earlyConfig);
+/** Candidate selection plus the memory-cleanup plan and the autonomy-gated direct lanes. */
+async function indexAndCollect(run) {
+    const { scope, options, primaryStashDir, improveProfile, config } = run;
+    const { plannedRefs, memorySummary, strategyFilteredRefs, indexSnapshot } = await run.collectEligibleRefsImpl(scope, options.stashDir, improveProfile, config);
     const cleanupParentRef = memoryCleanupParentRef(scope, options.stashDir);
-    // D8 — the two direct lanes share one eligibility predicate, which reads scope
-    // and eligible-memory count and no strategy flag at all. Compute it once: it
-    // decides whether each lane would have run, which is also what decides whether
-    // a gated lane is worth REPORTING. A lane that was never eligible was not
-    // suppressed by the gate, so claiming it was would be noise.
-    const cleanupEligible = shouldAnalyzeMemoryCleanup(scope, memorySummary.eligible, primaryStashDir);
-    // Cleanup remains independent of the disabled contradiction writer.
-    const memoryCleanupPlan = cleanupEligible
+    const memoryCleanupPlan = shouldAnalyzeMemoryCleanup(scope, memorySummary.eligible, primaryStashDir)
         ? analyzeMemoryCleanup(primaryStashDir, cleanupParentRef ? { parentRef: cleanupParentRef } : undefined)
         : undefined;
+    // A lane that would not have run anyway was not suppressed by the gate.
     const cleanupWouldMutate = Boolean(memoryCleanupPlan &&
         (memoryCleanupPlan.pruneCandidates.length > 0 ||
             memoryCleanupPlan.beliefStateTransitions.length > 0 ||
             memoryCleanupPlan.relativeDateCandidates.length > 0));
-    const autonomyGatedDirectLanes = cleanupWouldMutate && !isAutonomyLaneAllowed("memoryCleanup", _earlyConfig) ? ["memoryCleanup"] : [];
-    const guidance = memorySummary.eligible > 0
-        ? "Improve folds memory cleanup into the same proposal queue: speculative promotions still go through reflect/distill proposals, while high-confidence redundant derived memories are moved into a recoverable cleanup archive instead of being left active in the stash."
-        : undefined;
     return {
         plannedRefs,
         memorySummary,
         strategyFilteredRefs: strategyFilteredRefs ?? [],
         indexSnapshot,
         memoryCleanupPlan,
-        autonomyGatedDirectLanes,
-        guidance,
+        autonomyGatedDirectLanes: cleanupWouldMutate && !isAutonomyLaneAllowed("memoryCleanup", config) ? ["memoryCleanup"] : [],
+        guidance: memorySummary.eligible > 0
+            ? "Improve folds memory cleanup into the same proposal queue: speculative promotions still go through reflect/distill proposals, while high-confidence redundant derived memories are moved into a recoverable cleanup archive instead of being left active in the stash."
+            : undefined,
     };
 }
-/** The P2 lock-skipped envelope (graceful `skipIfLocked` early return). Exported for unit tests. */
+/** The envelope for a run skipped because another run holds the lock. */
 export function buildLockSkippedResult(strategyName, scope, runId) {
     return {
         schemaVersion: 2,
@@ -777,14 +484,13 @@ export function buildLockSkippedResult(strategyName, scope, runId) {
         ...(runId !== undefined ? { runId } : {}),
     };
 }
-/** Evaluate the real selectors on read-only state, stopping before every writer boundary. */
-async function runDryPlanningStage(args) {
-    const { run, collected, resolvedStateDbPath, budgetMs, initialCleanupWarnings, signal } = args;
+/** A dry run: the real selectors on a read-only state.db snapshot, stopping before every writer. */
+async function runDryPlanningStage(run, collected, initialCleanupWarnings) {
     let stateDb;
     let stateSnapshotUnavailable = false;
     try {
         try {
-            stateDb = openSqliteReadSnapshot(resolvedStateDbPath);
+            stateDb = openSqliteReadSnapshot(run.resolvedStateDbPath);
             stateSnapshotUnavailable = !stateDb;
         }
         catch (error) {
@@ -792,27 +498,13 @@ async function runDryPlanningStage(args) {
                 throw error;
             stateSnapshotUnavailable = true;
         }
-        const eventsCtx = {
-            ...(stateDb ? { db: stateDb } : { dbPath: resolvedStateDbPath }),
-            readOnly: true,
-            ...(stateSnapshotUnavailable ? { readOnlySnapshotUnavailable: true } : {}),
-        };
         const preparation = await run.runImprovePreparationStageImpl({
-            scope: run.scope,
-            options: run.options,
-            plannedRefs: collected.plannedRefs,
-            memoryCleanupPlan: collected.memoryCleanupPlan,
-            primaryStashDir: run.primaryStashDir,
-            memorySummary: collected.memorySummary,
-            reindexFn: run.reindexFn,
-            startMs: run.startMs,
-            budgetMs,
-            eventsCtx,
-            initialCleanupWarnings,
-            improveProfile: run.improveProfile,
-            resolvedPlan: run.resolvedPlan,
-            strategyName: run.selectedStrategy.name,
-            budgetSignal: signal,
+            ...preparationArgs(run, collected, initialCleanupWarnings),
+            eventsCtx: {
+                ...(stateDb ? { db: stateDb } : { dbPath: run.resolvedStateDbPath }),
+                readOnly: true,
+                ...(stateSnapshotUnavailable ? { readOnlySnapshotUnavailable: true } : {}),
+            },
             planOnly: true,
         });
         return buildDryRunResult(run, collected, preparation);
@@ -821,114 +513,101 @@ async function runDryPlanningStage(args) {
         stateDb?.close();
     }
 }
-/** The P3 dry-run envelope (plan-only early return). Exported for unit tests. */
+function preparationArgs(run, collected, initialCleanupWarnings) {
+    return {
+        scope: run.scope,
+        options: run.options,
+        plannedRefs: collected.plannedRefs,
+        memoryCleanupPlan: collected.memoryCleanupPlan,
+        primaryStashDir: run.primaryStashDir,
+        memorySummary: collected.memorySummary,
+        reindexFn: run.reindexFn,
+        startMs: run.startMs,
+        budgetMs: run.budgetMs,
+        initialCleanupWarnings,
+        improveProfile: run.improveProfile,
+        resolvedPlan: run.resolvedPlan,
+        strategyName: run.selectedStrategy.name,
+        budgetSignal: run.budgetAbortController.signal,
+    };
+}
+/** The plan-only envelope of a dry run. */
 export function buildDryRunResult(run, collected, preparation) {
-    const { selectedStrategy, scope } = run;
     const { guidance, memorySummary, memoryCleanupPlan, plannedRefs, strategyFilteredRefs } = collected;
-    const effectiveRefs = preparation?.loopRefs ?? plannedRefs;
-    const notices = collectImproveNotices({ resolvedPlan: run.resolvedPlan });
+    const notices = collectImproveNotices(run.resolvedPlan, []);
     return {
         schemaVersion: 2,
         ok: true,
-        strategy: selectedStrategy.name,
-        scope,
+        strategy: run.selectedStrategy.name,
+        scope: run.scope,
         dryRun: true,
-        ...(notices.length > 0 ? { notices } : {}),
+        ...notices.fields(),
         ...(guidance ? { guidance } : {}),
         memorySummary,
         ...(memoryCleanupPlan ? { memoryCleanup: shapeMemoryCleanup(memoryCleanupPlan) } : {}),
-        plannedRefs: effectiveRefs,
-        ...(preparation?.planning
-            ? {
-                plan: buildResultExecutionPlan(run, preparation, plannedRefs, strategyFilteredRefs, collected.indexSnapshot, true),
-            }
-            : {}),
+        plannedRefs: preparation?.loopRefs ?? plannedRefs,
+        ...(preparation?.planning ? { plan: buildResultExecutionPlan(run, preparation, collected, true) } : {}),
         ...(strategyFilteredRefs.length > 0 ? { strategyFilteredRefs } : {}),
         ...(run.resolvedPlan.engineUnavailable.length > 0 ? { skippedProcesses: run.resolvedPlan.engineUnavailable } : {}),
         ...(run.options.engineProbe !== undefined ? { engineProbe: run.options.engineProbe } : {}),
         ...(preparation?.proactiveMaintenance ? { proactiveMaintenance: preparation.proactiveMaintenance } : {}),
     };
 }
-/** One public plan projection for the dry and live result assemblers. */
-function buildResultExecutionPlan(run, preparation, rawProfileEligibleRefs, strategyFilteredRefs, indexSnapshot, dryRun) {
-    const { improveProfile, configuredImproveProfile, resolvedPlan, configuredLimits, effectiveLimit, scope } = run;
-    const triageConfig = improveProfile.processes?.triage;
+/** The public execution-plan projection shared by the dry and live results. */
+function buildResultExecutionPlan(run, preparation, collected, dryRun) {
+    const { improveProfile, configuredImproveProfile, resolvedPlan, scope } = run;
+    const { strategyFilteredRefs } = collected;
     const configuredTriage = configuredImproveProfile.processes?.triage;
-    const configuredProactive = configuredImproveProfile.processes?.proactiveMaintenance;
-    const configuredConsolidation = configuredImproveProfile.processes?.consolidate;
-    const triageEnabled = scope.mode !== "ref" && resolvedPlan.processes.triage.enabled;
-    const distillOnlySet = new Set(preparation.distillOnlyRefs.map((entry) => entry.ref));
     const inferenceMinPending = improveProfile.processes?.memoryInference?.minPendingCount;
     const pendingMemories = run.primaryStashDir && inferenceMinPending !== undefined && inferenceMinPending > 0
         ? collectPendingMemories(run.primaryStashDir).length
         : undefined;
-    const memoryInferenceEnabled = resolvedPlan.processes.memoryInference.enabled &&
-        !(pendingMemories !== undefined && inferenceMinPending !== undefined && pendingMemories < inferenceMinPending);
+    const belowMinPending = pendingMemories !== undefined && inferenceMinPending !== undefined && pendingMemories < inferenceMinPending;
+    const memoryInferenceEnabled = resolvedPlan.processes.memoryInference.enabled && !belowMinPending;
     const graphExtractionEnabled = resolvedPlan.processes.graphExtraction.enabled && run.primaryStashDir !== undefined;
-    const profileGate = {
-        name: "profile",
-        removed: strategyFilteredRefs.length,
-        reason: "all enabled per-ref processes refuse the asset type",
-    };
-    // #947 — per-process resolved engine/model/notices, plus how many of this
-    // run's effective refs each ref-scoped process (reflect/distill/consolidate)
-    // would act on. Counts only (not a per-ref matrix) to bound result_json size.
-    const REF_SCOPED_PROCESSES = new Set(["reflect", "distill", "consolidate"]);
+    // Per-process routing, plus how many effective refs each ref-scoped process would act on (#947).
     const processes = projectResolvedProcessRouting(resolvedPlan).map((row) => {
-        if (!REF_SCOPED_PROCESSES.has(row.process))
-            return row;
-        const eligibleRefs = preparation.loopRefs.filter((entry) => !shouldSkipRef(entry.ref, row.process, resolvedPlan.strategy.config)
-            .skip).length;
-        return { ...row, eligibleRefs };
+        const eligibleRefs = eligibleRefCount(preparation.loopRefs, row.process, resolvedPlan.strategy.config);
+        return eligibleRefs === undefined ? row : { ...row, eligibleRefs };
     });
     const proactive = preparation.planning.proactive
         ? {
             ...preparation.planning.proactive,
-            configured: {
-                ...(configuredProactive?.dueDays !== undefined ? { dueDays: configuredProactive.dueDays } : {}),
-                ...(configuredProactive?.maxPerRun !== undefined ? { maxPerRun: configuredProactive.maxPerRun } : {}),
-                ...(configuredProactive?.limit !== undefined ? { limit: configuredProactive.limit } : {}),
-            },
+            configured: pickDefined(configuredImproveProfile.processes?.proactiveMaintenance, [
+                "dueDays",
+                "maxPerRun",
+                "limit",
+            ]),
         }
         : undefined;
-    const consolidation = {
-        ...preparation.planning.consolidation,
-        configured: {
-            ...(configuredConsolidation?.enabled !== undefined ? { enabled: configuredConsolidation.enabled } : {}),
-            ...(configuredConsolidation?.minPoolSize !== undefined
-                ? { minPoolSize: configuredConsolidation.minPoolSize }
-                : {}),
-            ...(configuredConsolidation?.limit !== undefined ? { limit: configuredConsolidation.limit } : {}),
-            ...(configuredConsolidation?.maxChunkSize !== undefined
-                ? { maxChunkSize: configuredConsolidation.maxChunkSize }
-                : {}),
-            ...(configuredConsolidation?.incrementalSince !== undefined
-                ? { incrementalSince: configuredConsolidation.incrementalSince }
-                : {}),
-        },
-    };
     return buildImproveExecutionPlan({
         dryRun,
-        snapshot: indexSnapshot ?? {
+        snapshot: collected.indexSnapshot ?? {
             status: "unknown",
             reason: "the injected selector did not report an index snapshot status",
         },
-        rawInScope: rawProfileEligibleRefs.length + strategyFilteredRefs.length,
+        rawInScope: collected.plannedRefs.length + strategyFilteredRefs.length,
         selectedRefs: preparation.actionableRefs,
         effectiveRefs: preparation.loopRefs,
-        distillOnlyRefs: distillOnlySet,
-        configuredLimits,
-        effectiveLimit,
-        replayBudget: preparation.planning.replayBudget,
-        gates: [profileGate, ...preparation.planning.gates],
+        distillOnlyRefs: new Set(preparation.distillOnlyRefs.map((entry) => entry.ref)),
+        configuredLimits: run.configuredLimits,
+        effectiveLimit: run.effectiveLimit,
+        gates: [
+            {
+                name: "profile",
+                removed: strategyFilteredRefs.length,
+                reason: "all enabled per-ref processes refuse the asset type",
+            },
+            ...preparation.planning.gates,
+        ],
         processes,
         ...(proactive ? { proactive } : {}),
-        consolidation,
+        consolidation: {
+            ...preparation.planning.consolidation,
+            configured: pickDefined(configuredImproveProfile.processes?.consolidate, CONSOLIDATION_CONFIG_KEYS),
+        },
         stageConfig: {
-            extract: {
-                enabled: preparation.planning.extract.wouldRun,
-                reason: preparation.planning.extract.reason,
-            },
+            extract: { enabled: preparation.planning.extract.wouldRun, reason: preparation.planning.extract.reason },
             graphExtraction: {
                 enabled: graphExtractionEnabled,
                 reason: !resolvedPlan.processes.graphExtraction.enabled
@@ -949,78 +628,51 @@ function buildResultExecutionPlan(run, preparation, rawProfileEligibleRefs, stra
             },
         },
         triage: {
-            enabled: triageEnabled,
+            enabled: scope.mode !== "ref" && resolvedPlan.processes.triage.enabled,
             configuredMode: configuredTriage?.applyMode ?? "queue",
-            mode: triageConfig?.applyMode ?? "queue",
+            mode: improveProfile.processes?.triage?.applyMode ?? "queue",
             maxAcceptsPerRun: configuredTriage?.maxAcceptsPerRun ?? 25,
-            ...(configuredTriage?.maxDiffLines !== undefined ? { maxDiffLines: configuredTriage.maxDiffLines } : {}),
         },
     });
 }
-/** The triage drain pre-pass (non-fatal; single-ref scope never drains). */
+/** Drain the proposal backlog before generating more (non-fatal; a single-ref scope never drains). */
 async function runTriagePrePass(run) {
-    const { primaryStashDir, resolvedPlan, scope, options, improveProfile, drainProposalsFn } = run;
-    let triageDrain;
-    if (primaryStashDir && resolvedPlan.processes.triage.enabled) {
-        if (scope.mode === "ref") {
-            warn("[improve] triage pre-pass skipped (single-ref scope never drains the whole queue)");
-        }
-        else {
-            try {
-                const triageConfig = improveProfile.processes?.triage;
-                const policy = resolveDrainPolicy(triageConfig?.policy);
-                const applyMode = triageConfig?.applyMode ?? "queue";
-                const maxAccepts = triageConfig?.maxAcceptsPerRun ?? 25;
-                triageDrain = await withLlmStage("triage", () => drainProposalsFn({
-                    stashDir: primaryStashDir,
-                    ...(options.target ? { target: options.target } : {}),
-                    config: options.config,
-                    policy,
-                    applyMode,
-                    maxAccepts,
-                    dryRun: false,
-                    excludeIds: new Set(),
-                    ...(triageConfig?.maxDiffLines !== undefined ? { maxDiffLines: triageConfig.maxDiffLines } : {}),
-                    judgment: resolvedPlan.triageJudgment,
-                }), { engine: resolvedPlan.triageJudgment?.engine, process: "triage.judgment" });
-            }
-            catch (err) {
-                warn(`[improve] triage pre-pass failed (non-fatal): ${errMessage(err)}`);
-            }
-        }
+    const { primaryStashDir, resolvedPlan, scope, options, improveProfile } = run;
+    if (!primaryStashDir || !resolvedPlan.processes.triage.enabled)
+        return undefined;
+    if (scope.mode === "ref") {
+        warn("[improve] triage pre-pass skipped (single-ref scope never drains the whole queue)");
+        return undefined;
+    }
+    try {
+        const triageConfig = improveProfile.processes?.triage;
+        return await withLlmStage("triage", () => run.drainProposalsFn({
+            stashDir: primaryStashDir,
+            ...(options.target ? { target: options.target } : {}),
+            config: options.config,
+            applyMode: triageConfig?.applyMode ?? "queue",
+            maxAccepts: triageConfig?.maxAcceptsPerRun ?? 25,
+            dryRun: false,
+            excludeIds: new Set(),
+            judgment: resolvedPlan.triageJudgment,
+        }), { engine: resolvedPlan.triageJudgment?.engine, process: "triage.judgment" });
+    }
+    catch (err) {
+        warn(`[improve] triage pre-pass failed (non-fatal): ${errMessage(err)}`);
+        return undefined;
     }
-    return triageDrain;
-}
-/** A path is never staged by auto-sync when it is (or looks like) a lock file. */
-function isSyncExcludedPath(relativePath) {
-    return path.basename(relativePath).includes(".lock");
 }
 /**
- * Resolve the EXACT repo-relative path set the auto-sync commit stages (#652).
- *
- * Precedence:
- *
- *   1. **Run-scoped write provenance** (`writtenPaths`, absolute) — the paths
- *      this run actually wrote, created, or removed, intersected with the paths
- *      Git currently reports as changed. The intersection is what makes the set
- *      correct rather than merely plausible: it drops a journaled path whose
- *      final bytes match HEAD (nothing to commit), a journaled path that was
- *      created and then removed again (never existed for Git), and any journaled
- *      path Git ignores (which `saveGitStash` would otherwise reject outright).
- *      A journaled path that was ALREADY dirty when the run started stays IN —
- *      this run rewrote it, so this run owns it.
- *   2. **Dirty-path diff** (pre-#652 behaviour) — only when no journal was open,
- *      which a live run never hits. Kept as the defensive fallback so a future
- *      caller that commits outside the journal window degrades to the previous,
- *      battle-tested heuristic instead of silently committing nothing.
- *
- * `unattributed` counts in-scope paths that became dirty DURING the run without
- * this run writing them: concurrent human edits (correctly excluded) and, if the
- * number is ever surprising, the fingerprint of a missing journal call site.
+ * The exact repo-relative paths the auto-sync commit stages (#652): the paths
+ * this run wrote that Git reports changed (a journaled path already dirty at
+ * start stays in — this run rewrote it). Without a journal, the pre-#652
+ * dirty-path diff. `unattributed` counts in-scope paths that went dirty during
+ * the run without this run writing them (concurrent edits, left alone). Lock
+ * files are never staged.
  */
 export function resolveSyncPathSet(input) {
     const { repoDir, assetPrefix, changedPaths, initialPaths, writtenPaths, provenance } = input;
-    const inScope = (relativePath) => !isSyncExcludedPath(relativePath) &&
+    const inScope = (relativePath) => !path.basename(relativePath).includes(".lock") &&
         (!assetPrefix || relativePath === assetPrefix || relativePath.startsWith(`${assetPrefix}/`));
     if (!provenance) {
         return { paths: changedPaths.filter((p) => !initialPaths.has(p) && inScope(p)), unattributed: [] };
@@ -1029,9 +681,8 @@ export function resolveSyncPathSet(input) {
     const attributed = new Set();
     for (const absolutePath of writtenPaths) {
         const relativePath = relativeWrittenPath(repoDir, absolutePath);
-        if (!relativePath || !changed.has(relativePath) || !inScope(relativePath))
-            continue;
-        attributed.add(relativePath);
+        if (relativePath && changed.has(relativePath) && inScope(relativePath))
+            attributed.add(relativePath);
     }
     return {
         paths: [...attributed].sort(),
@@ -1039,60 +690,46 @@ export function resolveSyncPathSet(input) {
     };
 }
 /**
- * Crash-safe / incremental stash sync (#662) — see the factory-returned
- * closure's original doc block: the primary stash writes as a filesystem
- * source DURING the run; this commits them at end-of-run AND from the catch
- * path. Idempotent + NON-FATAL. `getEventsCtx`/`getInitialGitPaths`/
- * `getWriteJournal` are getters because those outer bindings are (re)assigned
- * after this factory runs — the returned closure must observe the live values.
+ * The auto-sync commit (#662), used at end of run and from the crash path:
+ * idempotent and never throws. The getters read bindings reassigned after this
+ * factory runs.
  */
 function makeCommitStashBatch(deps) {
-    const { writeTarget, primaryStashDir, effectiveSync, options, _earlyConfig, improveProfile } = deps.run;
+    const { writeTarget, primaryStashDir, effectiveSync, options, config, improveProfile } = deps.run;
     return (messageContext) => {
         const eventsCtx = deps.getEventsCtx();
-        const initialGitPaths = deps.getInitialGitPaths();
         const writeJournal = deps.getWriteJournal();
         const repoDir = writeTarget?.source.repoPath ?? primaryStashDir;
         if (!primaryStashDir || !repoDir || effectiveSync.enabled === false || !isGitBackedStash(repoDir)) {
             return undefined;
         }
         const saveGitStashFn = options.saveGitStashFn ?? saveGitStash;
-        const writableOverride = writeTarget ? resolveWritable(writeTarget.config) : resolveWritableOverride(_earlyConfig);
+        const writableOverride = writeTarget ? resolveWritable(writeTarget.config) : resolveWritableOverride(config);
         const push = options.sync?.push ?? improveProfile.sync?.push ?? true;
         const message = renderSyncCommitMessage(effectiveSync.message ?? "akm improve auto-sync", messageContext, Date.now());
+        const record = (metadata) => appendEvent({ eventType: "stash_synced", metadata }, eventsCtx);
         try {
             const assetRoot = writeTarget?.source.path ?? primaryStashDir;
-            const assetPrefix = assetRoot ? path.relative(repoDir, assetRoot).replaceAll(path.sep, "/") : "";
             const { paths, unattributed } = resolveSyncPathSet({
                 repoDir,
-                assetPrefix,
+                assetPrefix: path.relative(repoDir, assetRoot).replaceAll(path.sep, "/"),
                 changedPaths: listGitChangedPaths(repoDir),
-                initialPaths: initialGitPaths,
+                initialPaths: deps.getInitialGitPaths(),
                 writtenPaths: writeJournal?.writtenPaths() ?? [],
                 provenance: writeJournal !== undefined,
             });
             if (unattributed.length > 0) {
                 warnVerbose(`[improve] auto-sync left ${unattributed.length} path(s) uncommitted — not written by this run: ${unattributed.join(", ")}`);
             }
-            const syncResult = saveGitStashFn(undefined, message, writableOverride, {
-                push,
-                repoDir,
-                paths,
+            const syncResult = saveGitStashFn(undefined, message, writableOverride, { push, repoDir, paths });
+            record({
+                committed: syncResult.committed,
+                pushed: syncResult.pushed,
+                skipped: syncResult.skipped,
+                reason: syncResult.reason ?? null,
+                attributed: paths.length,
+                unattributed: unattributed.length,
             });
-            appendEvent({
-                eventType: "stash_synced",
-                metadata: {
-                    committed: syncResult.committed,
-                    pushed: syncResult.pushed,
-                    skipped: syncResult.skipped,
-                    reason: syncResult.reason ?? null,
-                    // #652 provenance audit trail: how many paths this run staged, and
-                    // how many in-scope paths went dirty during the run that it did NOT
-                    // write (concurrent edits — deliberately left for their author).
-                    attributed: paths.length,
-                    unattributed: unattributed.length,
-                },
-            }, eventsCtx);
             return {
                 committed: syncResult.committed,
                 pushed: syncResult.pushed,
@@ -1103,296 +740,131 @@ function makeCommitStashBatch(deps) {
         catch (syncErr) {
             const reason = errMessage(syncErr);
             warn(`improve: stash sync failed (non-fatal): ${reason}`);
-            appendEvent({
-                eventType: "stash_synced",
-                metadata: { committed: false, pushed: false, skipped: true, reason },
-            }, eventsCtx);
+            record({ committed: false, pushed: false, skipped: true, reason });
             return { committed: false, pushed: false, skipped: true, reason };
         }
     };
 }
-/** D6: pre-load the last 30 days of proposal_rejected events once per run. */
-function preloadRejectedProposals() {
-    // D6: pre-load all proposal_rejected events from the last 30 days once,
-    // so the per-asset loop can use a Map lookup instead of N DB round trips.
-    const REJECTED_PROPOSAL_WINDOW_MS = daysToMs(30);
-    const rejectedProposalSince = new Date(Date.now() - REJECTED_PROPOSAL_WINDOW_MS).toISOString();
-    const allRejectedProposalEvents = readEvents({ type: "proposal_rejected", since: rejectedProposalSince }).events;
-    const rejectedProposalsByRef = new Map();
-    for (const e of allRejectedProposalEvents) {
-        if (e.ref && (!rejectedProposalsByRef.has(e.ref) || e.ts > (rejectedProposalsByRef.get(e.ref)?.ts ?? ""))) {
-            rejectedProposalsByRef.set(e.ref, e);
-        }
-    }
-    return rejectedProposalsByRef;
-}
 /**
- * Post-lock proactive cooldown re-filter: re-read cooldown timestamps
- * immediately before the loop so external proposal writes that occurred
- * before this run acquired its lock are visible.
+ * Re-read the improve ledger under the lock and drop proactive refs another run
+ * attempted after this one planned.
  */
-export function refilterProactiveLoopRefs(loopRefs, improveProfile) {
-    // Re-read cooldown timestamps immediately before execution so external
-    // proposal writes that occurred before this run acquired its lock are visible.
+export function refilterProactiveLoopRefs(loopRefs, improveProfile, ledgerAccess) {
     const proactiveLoopRefs = loopRefs.filter((r) => r.eligibilitySource === "proactive");
-    let postLockLoopRefs = loopRefs;
-    if (proactiveLoopRefs.length > 0) {
-        const proactiveRefStrs = proactiveLoopRefs.map((r) => r.ref);
-        // Correlate proposal timestamps on each candidate's durable key.
-        const proactiveItemRefByRef = new Map(proactiveLoopRefs.map((r) => [r.ref, r.itemRef]));
-        const freshReflectTs = buildLatestProposalTsMap(proactiveRefStrs, "reflect", proactiveItemRefByRef);
-        const freshDistillTs = buildLatestProposalTsMap(proactiveRefStrs, "distill", proactiveItemRefByRef);
-        const pmDueDays = improveProfile.processes?.proactiveMaintenance?.dueDays ?? DEFAULT_DUE_DAYS;
-        const stillDue = new Set(filterProactiveDue(proactiveLoopRefs, freshReflectTs, freshDistillTs, pmDueDays, Date.now()).map((r) => r.ref));
-        const dropped = proactiveLoopRefs.filter((r) => !stillDue.has(r.ref));
-        if (dropped.length > 0) {
-            info(`[improve] post-lock cooldown re-filter: dropped ${dropped.length} proactive ref(s) claimed by concurrent run (${dropped.map((r) => r.ref).join(", ")})`);
-            postLockLoopRefs = loopRefs.filter((r) => r.eligibilitySource !== "proactive" || stillDue.has(r.ref));
-        }
-    }
-    return postLockLoopRefs;
+    if (proactiveLoopRefs.length === 0 || !ledgerAccess.stashDir)
+        return loopRefs;
+    const ledger = loadLedgerSnapshot({ eventsCtx: ledgerAccess.eventsCtx }, ledgerAccess.stashDir, [
+        "reflect",
+        "distill",
+    ]);
+    const stillDue = new Set(filterProactiveDue(proactiveLoopRefs, lastAttemptByRef(ledger, "reflect", proactiveLoopRefs), lastAttemptByRef(ledger, "distill", proactiveLoopRefs), improveProfile.processes?.proactiveMaintenance?.dueDays ?? DEFAULT_DUE_DAYS, Date.now()).map((r) => r.ref));
+    const dropped = proactiveLoopRefs.filter((r) => !stillDue.has(r.ref));
+    if (dropped.length === 0)
+        return loopRefs;
+    info(`[improve] post-lock cooldown re-filter: dropped ${dropped.length} proactive ref(s) claimed by concurrent run (${dropped.map((r) => r.ref).join(", ")})`);
+    return loopRefs.filter((r) => r.eligibilitySource !== "proactive" || stillDue.has(r.ref));
 }
 /**
- * Post-loop stage, or a no-op skip when the shared wall-clock budget is
- * already exhausted. The result still finalizes normally on skip, so
- * scheduled budget exhaustion exits 0 (extracted verbatim from
- * `runImproveStageSequence` — fn-size decomposition, no logic change).
+ * The audit events for refs and lanes this run will not touch, then
+ * preparation → loop → post-loop. No post-loop work starts past the budget; the
+ * result still finalizes, so budget exhaustion exits 0.
  */
-async function runPostLoopStageOrSkip(args) {
-    const { budgetAbortController, scope, options, primaryStashDir, preparation, memoryRefsForInference, eventsCtx, improveProfile, resolvedPlan, runImprovePostLoopStageImpl, } = args;
-    // Do not start new post-loop work after the shared wall-clock budget. The
-    // result still finalizes normally, so scheduled budget exhaustion exits 0.
-    const emptyPostLoopResult = {
-        allWarnings: [],
-        memoryInferenceDurationMs: 0,
-        graphExtractionDurationMs: 0,
-    };
-    const remainingBudget = budgetAbortController.signal.remainingBudgetMs;
-    if (budgetAbortController.signal.aborted || (remainingBudget !== undefined && remainingBudget <= 0)) {
-        info("[improve] post-loop maintenance skipped (wall-clock budget exhausted)");
-        return emptyPostLoopResult;
+async function runImproveStageSequence(run, collected, preEnsureCleanupWarnings, eventsCtx) {
+    const { scope, options, primaryStashDir, improveProfile, resolvedPlan, budgetAbortController } = run;
+    const strategy = run.selectedStrategy.name;
+    // One count-only row for planner-filtered refs, never one per ref (#592).
+    if (collected.strategyFilteredRefs.length > 0) {
+        recordImproveSkip(eventsCtx, undefined, {
+            strategy,
+            reason: "strategy_filtered_all_passes",
+            count: collected.strategyFilteredRefs.length,
+        });
     }
-    return runImprovePostLoopStageImpl({
-        scope,
-        options,
-        primaryStashDir,
-        actionableRefs: preparation.actionableRefs,
-        appliedCleanup: preparation.appliedCleanup,
-        cleanupWarnings: preparation.cleanupWarnings,
-        memoryRefsForInference,
+    // A gated lane names the config key that would enable it.
+    for (const lane of [...resolvedPlan.autonomyGated, ...describeGatedLanes(collected.autonomyGatedDirectLanes)]) {
+        warn(`[improve] ${lane.lane} skipped — it ${lane.reason}. Set \`${lane.configKey}: true\` to enable it.`);
+        recordImproveSkip(eventsCtx, undefined, {
+            strategy,
+            reason: "autonomy_gated",
+            lane: lane.lane,
+            configKey: lane.configKey,
+        });
+    }
+    for (const item of resolvedPlan.engineUnavailable) {
+        warn(`[improve] ${item.process} skipped — it ${item.reason}.`);
+        recordImproveSkip(eventsCtx, undefined, {
+            strategy,
+            reason: "engine_unavailable",
+            process: item.process,
+            configKey: item.configKey,
+        });
+    }
+    const preparation = await run.runImprovePreparationStageImpl({
+        ...preparationArgs(run, collected, preEnsureCleanupWarnings),
+        eventsCtx,
+    });
+    const loopResult = await run.runImproveLoopStageImpl({
         eventsCtx,
         budgetSignal: budgetAbortController.signal,
+        primaryStashDir,
+        scope,
+        options,
+        reflectFn: run.reflectFn,
+        distillFn: run.distillFn,
+        loopRefs: refilterProactiveLoopRefs(preparation.loopRefs, improveProfile, {
+            stashDir: primaryStashDir ?? options.stashDir,
+            eventsCtx,
+        }),
+        actions: preparation.actions,
+        signalBearingSet: preparation.signalBearingSet,
+        distillCooledRefs: preparation.distillCooledRefs,
+        distillOnlyRefs: preparation.distillOnlyRefs,
+        recentErrors: preparation.recentErrors,
+        startMs: run.startMs,
+        budgetMs: run.budgetMs,
         improveProfile,
         resolvedPlan,
-        consolidationRan: preparation.consolidationRan,
-        // R5: floor violations from this run's consolidate pass, for the collapse
-        // detector's merge-floor advisory.
-        consolidationMergeFloorViolations: preparation.consolidation.mergeFloorViolations ?? 0,
     });
-}
-/**
- * Stage-sequencing: the strategy-filtered audit event, then the single
- * prep → loop → post-loop pass via the #616 seams (D12). Returns every
- * accumulator the result assembly reads — the old closure-scoped `let`s.
- */
-async function runImproveStageSequence(args) {
-    const { strategyFilteredRefs, plannedRefs, memoryCleanupPlan, memorySummary, preEnsureCleanupWarnings, eventsCtx, ctx, } = args;
-    const { scope, options, primaryStashDir, startMs, budgetMs, improveProfile, resolvedPlan, budgetAbortController, selectedStrategy, reflectFn, distillFn, reindexFn, runImprovePreparationStageImpl, runImproveLoopStageImpl, runImprovePostLoopStageImpl, } = args.run;
-    // 2026-05-27: one summary `improve_skipped` audit event (count only) for
-    // planner-pre-filtered refs — never per-ref (#592: O(n) sequential state.db
-    // writes cost ~500 s on a 9 000-ref stash; health reads the counters).
-    if (strategyFilteredRefs.length > 0) {
-        appendEvent({
-            eventType: "improve_skipped",
-            ref: undefined,
-            metadata: {
-                strategy: selectedStrategy.name,
-                reason: "strategy_filtered_all_passes",
-                count: strategyFilteredRefs.length,
-            },
-        }, eventsCtx);
-    }
-    // D8 — one event per lane the autonomy gate downgraded, naming the lane AND
-    // the config key that would enable it. This is the difference between a gate
-    // and a silent no-op: whatever the user would have seen happen, they now see
-    // explained. `health` already aggregates `improve_skipped` by reason
-    // (buildImproveSkipSummary), so these surface there without new machinery.
-    for (const lane of [...args.run.resolvedPlan.autonomyGated, ...describeGatedLanes(args.autonomyGatedDirectLanes)]) {
-        warn(`[improve] ${lane.lane} skipped — it ${lane.reason}. Set \`${lane.configKey}: true\` to enable it.`);
-        appendEvent({
-            eventType: "improve_skipped",
-            ref: undefined,
-            metadata: {
-                strategy: selectedStrategy.name,
-                reason: "autonomy_gated",
-                lane: lane.lane,
-                configKey: lane.configKey,
-            },
-        }, eventsCtx);
-    }
-    for (const item of resolvedPlan.engineUnavailable) {
-        warn(`[improve] ${item.process} skipped — it ${item.reason}.`);
-        appendEvent({
-            eventType: "improve_skipped",
-            ref: undefined,
-            metadata: {
-                strategy: selectedStrategy.name,
-                reason: "engine_unavailable",
-                process: item.process,
-                configKey: item.configKey,
-            },
-        }, eventsCtx);
+    let postLoop = { allWarnings: [], memoryInferenceDurationMs: 0, graphExtractionDurationMs: 0 };
+    const remainingBudget = budgetAbortController.signal.remainingBudgetMs;
+    if (budgetAbortController.signal.aborted || (remainingBudget !== undefined && remainingBudget <= 0)) {
+        info("[improve] post-loop maintenance skipped (wall-clock budget exhausted)");
     }
-    // Single prep->loop->post-loop pass, run under the invocation's lock.
-    // Accumulators are direct assignments from the single pass's results.
-    let preparation;
-    let memoryRefsForInference = new Set();
-    let consolidation;
-    let memoryInference;
-    let graphExtraction;
-    let cycleMetrics;
-    // Summed counters/durations.
-    let reflectsWithErrorContext = 0;
-    let memoryInferenceDurationMs = 0;
-    let graphExtractionDurationMs = 0;
-    let orphansPurged;
-    let proposalsExpired;
-    // Concatenated arrays.
-    const allWarnings = [];
-    let deadUrls;
-    let deadUrlCoverage;
-    const finalActions = [];
-    {
-        const runPreparation = () => runImprovePreparationStageImpl({
+    else {
+        postLoop = await run.runImprovePostLoopStageImpl({
             scope,
             options,
-            plannedRefs,
-            memoryCleanupPlan,
             primaryStashDir,
-            memorySummary,
-            reindexFn,
-            startMs,
-            budgetMs,
+            actionableRefs: preparation.actionableRefs,
+            appliedCleanup: preparation.appliedCleanup,
+            cleanupWarnings: preparation.cleanupWarnings,
+            memoryRefsForInference: loopResult.memoryRefsForInference,
             eventsCtx,
-            initialCleanupWarnings: preEnsureCleanupWarnings,
-            improveProfile,
-            resolvedPlan,
-            strategyName: selectedStrategy.name,
             budgetSignal: budgetAbortController.signal,
-        });
-        preparation = await runPreparation();
-        const rejectedProposalsByRef = preloadRejectedProposals();
-        const runLoop = () => {
-            const postLockLoopRefs = refilterProactiveLoopRefs(preparation.loopRefs, improveProfile);
-            return runImproveLoopStageImpl({
-                ctx,
-                primaryStashDir,
-                scope,
-                options,
-                reflectFn,
-                distillFn,
-                loopRefs: postLockLoopRefs,
-                actions: preparation.actions,
-                signalBearingSet: preparation.signalBearingSet,
-                distillCooledRefs: preparation.distillCooledRefs,
-                distillOnlyRefs: preparation.distillOnlyRefs,
-                recentErrors: preparation.recentErrors,
-                rejectedProposalsByRef,
-                utilityMap: preparation.utilityMap,
-                startMs,
-                budgetMs,
-                improveProfile,
-                resolvedPlan,
-            });
-        };
-        const loopResult = await runLoop();
-        reflectsWithErrorContext += loopResult.reflectsWithErrorContext;
-        memoryRefsForInference = loopResult.memoryRefsForInference;
-        // #551: consolidation now runs in the preparation stage (before extract);
-        // its result and run-flag are read from `preparation`, not the post-loop.
-        consolidation = preparation.consolidation;
-        const postLoopResult = await runPostLoopStageOrSkip({
-            budgetAbortController,
-            scope,
-            options,
-            primaryStashDir,
-            preparation,
-            memoryRefsForInference,
-            eventsCtx,
             improveProfile,
             resolvedPlan,
-            runImprovePostLoopStageImpl,
         });
-        // Result objects (single pass — no cycle accumulation).
-        memoryInference = postLoopResult.memoryInference;
-        graphExtraction = postLoopResult.graphExtraction;
-        if (postLoopResult.cycleMetrics)
-            cycleMetrics = postLoopResult.cycleMetrics;
-        // Summed counters/durations.
-        memoryInferenceDurationMs += postLoopResult.memoryInferenceDurationMs;
-        graphExtractionDurationMs += postLoopResult.graphExtractionDurationMs;
-        if (postLoopResult.orphansPurged !== undefined) {
-            orphansPurged = (orphansPurged ?? 0) + postLoopResult.orphansPurged;
-        }
-        if (postLoopResult.proposalsExpired !== undefined) {
-            proposalsExpired = (proposalsExpired ?? 0) + postLoopResult.proposalsExpired;
-        }
-        // Concatenated arrays.
-        allWarnings.push(...postLoopResult.allWarnings);
-        if (postLoopResult.deadUrls !== undefined) {
-            deadUrls = [...(deadUrls ?? []), ...postLoopResult.deadUrls];
-        }
-        if (postLoopResult.deadUrlCoverage !== undefined) {
-            deadUrlCoverage = postLoopResult.deadUrlCoverage;
-        }
-        const maintenanceActions = postLoopResult.maintenanceActions;
-        if (maintenanceActions && maintenanceActions.length > 0) {
-            finalActions.push(...preparation.actions, ...maintenanceActions);
-        }
-        else {
-            finalActions.push(...preparation.actions);
-        }
     }
     return {
         preparation,
-        memoryRefsForInference,
-        consolidation,
-        memoryInference,
-        graphExtraction,
-        cycleMetrics,
-        reflectsWithErrorContext,
-        memoryInferenceDurationMs,
-        graphExtractionDurationMs,
-        orphansPurged,
-        proposalsExpired,
-        allWarnings,
-        deadUrls,
-        deadUrlCoverage,
-        finalActions,
+        postLoop,
+        reflectsWithErrorContext: loopResult.reflectsWithErrorContext,
+        finalActions: [...preparation.actions, ...(postLoop.maintenanceActions ?? [])],
     };
 }
-/**
- * Run-teardown, result half: assemble the AkmImproveResult envelope and emit
- * the improve_completed event (same adjacency as the old inline code — no
- * side effects run between assembly and emit).
- */
+/** Assemble the result envelope and emit `improve_completed`. */
 function finalizeImproveResult(args) {
-    const { guidance, memorySummary, memoryCleanupPlan, strategyFilteredRefs, rawPlannedRefs, indexSnapshot, triageDrain, ensureIndexDurationMs, eventsCtx, } = args;
-    const { selectedStrategy, scope, options, startMs, resolvedPlan } = args.run;
-    const { preparation, consolidation, memoryInference, graphExtraction, cycleMetrics, reflectsWithErrorContext, memoryInferenceDurationMs, graphExtractionDurationMs, orphansPurged, proposalsExpired, allWarnings, deadUrls, deadUrlCoverage, finalActions, } = args.seq;
-    // C1 (13-bus-factor): fold the per-ref `distill-skipped` rows (~13k/run,
-    // ~91% of result_json bytes) into a bounded aggregate BEFORE persistence.
-    // The metric total + per-reason breakdown are preserved on `distillSkipped`;
-    // the unbounded row list never reaches result_json. Reflect skip counters
-    // below still read `finalActions` (reflect skips are not folded).
+    const { run, collected, triageDrain, ensureIndexDurationMs, eventsCtx } = args;
+    const { preparation, postLoop, reflectsWithErrorContext, finalActions } = args.seq;
+    const { options, startMs, resolvedPlan } = run;
+    const { memoryCleanupPlan, strategyFilteredRefs } = collected;
+    const consolidation = preparation.consolidation;
+    const { memoryInference, graphExtraction, allWarnings, deadUrls, deadUrlCoverage, orphansPurged, proposalsExpired } = postLoop;
+    const { memoryInferenceDurationMs, graphExtractionDurationMs } = postLoop;
+    // The per-ref distill-skipped rows fold into a bounded aggregate before persistence (C1).
     const { actions: persistedActions, aggregate: distillSkippedAggregate } = foldDistillSkipped(finalActions);
-    // #944 — this run's LLM call/token accounting, split by process x engine x
-    // model, plus which enabled processes made zero calls and why. `llm_usage`
-    // events carry no runId column, so bound the read to this run's own wall
-    // clock — the same per-run event-scoping technique `health/windows.ts`
-    // already uses for wall time. `until` is "now" (assembly happens at
-    // teardown, after every LLM call this run will make has already emitted
-    // its event).
+    // This run's LLM accounting (#944): llm_usage rows carry no run id, so the
+    // read is bounded by the run's own wall clock.
     const usageEvents = readEvents({ since: new Date(startMs).toISOString(), type: LLM_USAGE_EVENT }, eventsCtx).events;
     const usageReport = buildImproveUsageReport({
         resolvedPlan,
@@ -1402,37 +874,36 @@ function finalizeImproveResult(args) {
         persistedActions,
         distillSkippedAggregate,
     });
-    const notices = collectImproveNotices({
-        resolvedPlan: args.run.resolvedPlan,
-        actions: finalActions,
-        schemaRepairs: preparation.schemaRepairs,
+    const notices = collectImproveNotices(resolvedPlan, [
+        ...finalActions.map((action) => action.result),
+        ...preparation.schemaRepairs,
         consolidation,
-        extract: preparation.extract,
+        ...(preparation.extract ?? []).flatMap((extract) => [extract, ...(extract.sessions ?? [])]),
         memoryInference,
         graphExtraction,
         triageDrain,
-    });
+    ]);
+    const applied = preparation.appliedCleanup;
+    const countMode = (mode) => finalActions.filter((a) => a.mode === mode).length;
     const result = {
         schemaVersion: 2,
         ok: true,
-        strategy: selectedStrategy.name,
-        scope,
+        strategy: run.selectedStrategy.name,
+        scope: run.scope,
         dryRun: false,
-        ...(notices.length > 0 ? { notices } : {}),
-        ...(guidance ? { guidance } : {}),
-        memorySummary,
+        ...notices.fields(),
+        ...(collected.guidance ? { guidance: collected.guidance } : {}),
+        memorySummary: collected.memorySummary,
         ...(memoryCleanupPlan
             ? {
                 memoryCleanup: {
                     ...shapeMemoryCleanup(memoryCleanupPlan),
-                    ...(preparation.appliedCleanup
+                    ...(applied
                         ? {
-                            archived: preparation.appliedCleanup.archived,
-                            ...(preparation.appliedCleanup.transitionLogPath
-                                ? { transitionLogPath: preparation.appliedCleanup.transitionLogPath }
-                                : {}),
-                            ...(preparation.appliedCleanup.transitionLogEntries !== undefined
-                                ? { transitionLogEntries: preparation.appliedCleanup.transitionLogEntries }
+                            archived: applied.archived,
+                            ...(applied.transitionLogPath ? { transitionLogPath: applied.transitionLogPath } : {}),
+                            ...(applied.transitionLogEntries !== undefined
+                                ? { transitionLogEntries: applied.transitionLogEntries }
                                 : {}),
                             ...(allWarnings.length > 0 ? { warnings: allWarnings } : {}),
                         }
@@ -1443,11 +914,7 @@ function finalizeImproveResult(args) {
             }
             : {}),
         plannedRefs: preparation.loopRefs,
-        ...(preparation.planning
-            ? {
-                plan: buildResultExecutionPlan(args.run, preparation, rawPlannedRefs, strategyFilteredRefs, indexSnapshot, false),
-            }
-            : {}),
+        ...(preparation.planning ? { plan: buildResultExecutionPlan(run, preparation, collected, false) } : {}),
         ...(strategyFilteredRefs.length > 0 ? { strategyFilteredRefs } : {}),
         ...(resolvedPlan.engineUnavailable.length > 0 ? { skippedProcesses: resolvedPlan.engineUnavailable } : {}),
         ...(options.engineProbe !== undefined ? { engineProbe: options.engineProbe } : {}),
@@ -1462,37 +929,21 @@ function finalizeImproveResult(args) {
         ...(preparation.coverageGaps.length > 0 ? { coverageGaps: preparation.coverageGaps } : {}),
         ...(preparation.extract && preparation.extract.length > 0 ? { extract: preparation.extract } : {}),
         ...(deadUrls !== undefined && deadUrls.length > 0 ? { deadUrls } : {}),
-        // Present whenever the check ran, unlike `deadUrls` above — a clean run
-        // (zero dead links) still needs to tell the health report how much of
-        // the bundle it actually covered (#892).
+        // Present whenever the check ran, so health knows the coverage of a clean run (#892).
         ...(deadUrlCoverage !== undefined ? { deadUrlCoverage } : {}),
         ...(reflectsWithErrorContext > 0 ? { reflectsWithErrorContext } : {}),
         ...(memoryInference ? { memoryInference } : {}),
         ...(graphExtraction ? { graphExtraction } : {}),
-        // Per-phase wall-clock durations. Surfaced at the top level of the
-        // envelope (not nested) because `health.ts`'s `wallTime.byPhase`
-        // aggregator and the existing `memoryInference.durationMs` /
-        // `graphExtraction.durationMs` health buckets all read
-        // `result.{memoryInferenceDurationMs,graphExtractionDurationMs}`
-        // directly. Mirrors how `consolidation.durationMs` is surfaced inside
-        // the consolidation sub-object (different convention because the
-        // consolidation result type already owns that field). Phases that did
-        // not run (zero duration) are omitted so the aggregator's
-        // "phase actually ran" filter (`> 0`) excludes them from the median/p95
-        // sample. Plumbed in d1273d0's follow-up — see
-        // `/tmp/akm-health-investigations/metrics-taxonomy-review.md` §1k / §3.
+        // Top-level phase durations feed health's wall-time buckets; a phase that
+        // did not run is omitted, not zero.
         ...(memoryInferenceDurationMs > 0 ? { memoryInferenceDurationMs } : {}),
         ...(graphExtractionDurationMs > 0 ? { graphExtractionDurationMs } : {}),
-        // R6: the start-of-run implicit reindex's wall-clock cost, when one ran
-        // (absent — not zero — when the index was already fresh and no inline
-        // rebuild was needed).
         ...(ensureIndexDurationMs !== undefined ? { ensureIndexDurationMs } : {}),
-        ...(cycleMetrics ? { cycleMetrics } : {}),
         ...(orphansPurged !== undefined ? { orphansPurged } : {}),
         ...(proposalsExpired !== undefined && proposalsExpired > 0 ? { proposalsExpired } : {}),
-        reflectCooldownActions: finalActions.filter((a) => a.mode === "reflect-cooldown").length,
-        reflectSkippedActions: finalActions.filter((a) => a.mode === "reflect-skipped").length,
-        reflectGuardRejectedActions: finalActions.filter((a) => a.mode === "reflect-guard-rejected").length,
+        reflectCooldownActions: countMode("reflect-cooldown"),
+        reflectSkippedActions: countMode("reflect-skipped"),
+        reflectGuardRejectedActions: countMode("reflect-guard-rejected"),
         ...(triageDrain
             ? {
                 triage: {
@@ -1507,116 +958,60 @@ function finalizeImproveResult(args) {
         ...(preparation.proactiveMaintenance ? { proactiveMaintenance: preparation.proactiveMaintenance } : {}),
         ...(options.runId !== undefined ? { runId: options.runId } : {}),
     };
-    if (!result.dryRun)
-        emitImproveCompletedEvent(result, {
-            memoryInferenceDurationMs,
-            graphExtractionDurationMs,
-            totalDurationMs: Date.now() - startMs,
-            warningCount: allWarnings.length,
-            orphansPurged: orphansPurged ?? 0,
-        }, eventsCtx);
+    emitImproveCompletedEvent(result, {
+        memoryInferenceDurationMs,
+        graphExtractionDurationMs,
+        totalDurationMs: Date.now() - startMs,
+        warningCount: allWarnings.length,
+        orphansPurged: orphansPurged ?? 0,
+    }, eventsCtx);
     return result;
 }
-function collectImproveNotices(args) {
-    const byKey = new Map();
+/** Every lowering notice the plan and this run's stage results carry, deduplicated. */
+function collectImproveNotices(resolvedPlan, carriers) {
+    const notices = noticeSet();
     const collect = (carrier) => {
-        if (typeof carrier !== "object" || carrier === null)
-            return;
-        const notices = carrier.notices;
-        if (!Array.isArray(notices))
-            return;
-        for (const notice of notices)
-            byKey.set(JSON.stringify(notice), notice);
+        const list = carrier?.notices;
+        if (typeof carrier === "object" && Array.isArray(list))
+            notices.add(list);
     };
-    for (const process of Object.values(args.resolvedPlan.processes))
+    for (const process of Object.values(resolvedPlan.processes))
         collect(process);
-    for (const notice of args.resolvedPlan.triageJudgmentNotices ?? []) {
-        byKey.set(JSON.stringify(notice), notice);
-    }
-    for (const action of args.actions ?? [])
-        collect(action.result);
-    for (const repair of args.schemaRepairs ?? [])
-        collect(repair);
-    collect(args.consolidation);
-    for (const extract of args.extract ?? []) {
-        collect(extract);
-        for (const session of extract.sessions ?? [])
-            collect(session);
-    }
-    collect(args.memoryInference);
-    collect(args.graphExtraction);
-    collect(args.triageDrain);
-    return Object.freeze([...byKey.values()]);
+    notices.add(resolvedPlan.triageJudgmentNotices ?? []);
+    for (const carrier of carriers)
+        collect(carrier);
+    return notices;
 }
+/** `improve_completed` per-mode counters; keyed by every mode so a new one cannot be dropped. */
+const ACTION_COUNTER = {
+    reflect: "reflectActions",
+    distill: "distillActions",
+    "distill-skipped": "distillSkippedActions",
+    "memory-prune": "memoryPruneActions",
+    "memory-inference": "memoryInferenceActions",
+    "graph-extraction": "graphExtractionActions",
+    error: "errorActions",
+    "reflect-failed": "reflectFailedActions",
+    "reflect-cooldown": "reflectCooldownActions",
+    "reflect-skipped": "reflectSkippedActions",
+    "reflect-guard-rejected": "reflectGuardRejectedActions",
+};
 function emitImproveCompletedEvent(result, durations, eventsCtx) {
-    const actionCounts = {
-        reflect: 0,
-        reflectFailed: 0,
-        reflectCooldown: 0,
-        reflectSkipped: 0,
-        reflectGuardRejected: 0,
-        distill: 0,
-        distillSkipped: 0,
-        memoryPrune: 0,
-        memoryInference: 0,
-        graphExtraction: 0,
-        error: 0,
-    };
-    // Coarse audit buckets, derived from the SAME classifyImproveAction the
-    // persisted metrics_json uses (state-db.ts#computeImproveRunMetrics) so the
-    // emitted event and the stored row can never disagree.
+    const counts = Object.fromEntries(Object.values(ACTION_COUNTER).map((key) => [key, 0]));
+    // The coarse buckets come from the same classifier the persisted metrics use.
     const classCounts = { accepted: 0, rejected: 0, skipped: 0, error: 0, noop: 0 };
     for (const action of result.actions ?? []) {
+        const key = ACTION_COUNTER[action.mode];
+        if (key)
+            counts[key] = (counts[key] ?? 0) + 1;
         classCounts[classifyImproveAction(action.mode)] += 1;
-        // Per-variant counters for the event metadata. The default arm makes any
-        // new ImproveActionMode variant a compile error so a future variant cannot
-        // be silently dropped from the improve_completed event (the `reflect-guard-
-        // rejected` case below was previously missing here entirely).
-        switch (action.mode) {
-            case "reflect":
-                actionCounts.reflect += 1;
-                break;
-            case "reflect-failed":
-                actionCounts.reflectFailed += 1;
-                break;
-            case "reflect-cooldown":
-                actionCounts.reflectCooldown += 1;
-                break;
-            case "reflect-skipped":
-                actionCounts.reflectSkipped += 1;
-                break;
-            case "reflect-guard-rejected":
-                actionCounts.reflectGuardRejected += 1;
-                break;
-            case "distill":
-                actionCounts.distill += 1;
-                break;
-            case "distill-skipped":
-                actionCounts.distillSkipped += 1;
-                break;
-            case "memory-prune":
-                actionCounts.memoryPrune += 1;
-                break;
-            case "memory-inference":
-                actionCounts.memoryInference += 1;
-                break;
-            case "graph-extraction":
-                actionCounts.graphExtraction += 1;
-                break;
-            case "error":
-                actionCounts.error += 1;
-                break;
-            default:
-                assertNever(action.mode);
-        }
     }
-    // C1: distill-skipped rows are no longer in `result.actions` (folded into the
-    // bounded `distillSkipped` aggregate at assembly). Add the aggregate total to
-    // the per-variant counter AND the coarse `skipped` bucket so the emitted event
-    // still reports the true skipped volume.
+    // distill-skipped rows were folded into the aggregate; count them back in.
     const distillSkippedTotal = result.distillSkipped?.total ?? 0;
-    actionCounts.distillSkipped += distillSkippedTotal;
+    counts.distillSkippedActions = (counts.distillSkippedActions ?? 0) + distillSkippedTotal;
     classCounts.skipped += distillSkippedTotal;
+    const cleanup = result.memoryCleanup;
+    const quality = result.graphExtraction?.quality;
     appendEvent({
         eventType: "improve_completed",
         ref: result.scope.mode === "ref"
@@ -1625,19 +1020,7 @@ function emitImproveCompletedEvent(result, durations, eventsCtx) {
         metadata: {
             strategy: result.strategy,
             plannedRefs: result.plannedRefs.length,
-            reflectActions: actionCounts.reflect,
-            distillActions: actionCounts.distill,
-            distillSkippedActions: actionCounts.distillSkipped,
-            memoryPruneActions: actionCounts.memoryPrune,
-            memoryInferenceActions: actionCounts.memoryInference,
-            graphExtractionActions: actionCounts.graphExtraction,
-            errorActions: actionCounts.error,
-            reflectFailedActions: actionCounts.reflectFailed,
-            reflectCooldownActions: actionCounts.reflectCooldown,
-            reflectSkippedActions: actionCounts.reflectSkipped,
-            // Previously dropped from the event entirely; now emitted so the guard
-            // rejections are visible in improve_completed telemetry.
-            reflectGuardRejectedActions: actionCounts.reflectGuardRejected,
+            ...counts,
             acceptedActions: classCounts.accepted,
             rejectedActions: classCounts.rejected,
             skippedActions: classCounts.skipped,
@@ -1650,32 +1033,29 @@ function emitImproveCompletedEvent(result, durations, eventsCtx) {
             deadUrlsSkipped: result.deadUrlCoverage?.skipped ?? 0,
             memoryEligible: result.memorySummary.eligible,
             memoryDerived: result.memorySummary.derived,
-            memoryCleanupPruneCandidates: result.memoryCleanup?.pruneCandidates.length ?? 0,
-            memoryCleanupContradictionCandidates: result.memoryCleanup?.contradictionCandidates.length ?? 0,
-            memoryCleanupBeliefStateTransitions: result.memoryCleanup?.beliefStateTransitions.length ?? 0,
-            memoryCleanupConsolidationCandidates: result.memoryCleanup?.consolidationCandidates.length ?? 0,
-            memoryCleanupArchived: result.memoryCleanup?.archived?.length ?? 0,
-            memoryCleanupWarnings: result.memoryCleanup?.warnings?.length ?? 0,
+            memoryCleanupPruneCandidates: cleanup?.pruneCandidates.length ?? 0,
+            memoryCleanupContradictionCandidates: cleanup?.contradictionCandidates.length ?? 0,
+            memoryCleanupBeliefStateTransitions: cleanup?.beliefStateTransitions.length ?? 0,
+            memoryCleanupConsolidationCandidates: cleanup?.consolidationCandidates.length ?? 0,
+            memoryCleanupArchived: cleanup?.archived?.length ?? 0,
+            memoryCleanupWarnings: cleanup?.warnings?.length ?? 0,
             consolidationProcessed: result.consolidation?.processed ?? 0,
             consolidationDurationMs: result.consolidation?.durationMs ?? 0,
             memoryInferenceWrites: result.memoryInference?.writtenFacts ?? 0,
             memoryInferenceDurationMs: durations.memoryInferenceDurationMs,
-            graphExtractionExtractedFiles: result.graphExtraction?.quality.extractedFiles ?? 0,
+            graphExtractionExtractedFiles: quality?.extractedFiles ?? 0,
             graphExtractionDurationMs: durations.graphExtractionDurationMs,
-            // Layer-2 proactive-maintenance coverage (0 when the process is disabled
-            // or the run was ref-scoped) so a scheduled sweep's reach is trackable.
             proactiveSelected: result.proactiveMaintenance?.selected ?? 0,
             proactiveDueTotal: result.proactiveMaintenance?.dueTotal ?? 0,
             proactiveNeverReflected: result.proactiveMaintenance?.neverReflected ?? 0,
-            // New metrics for tuning the improve loop.
-            ...(durations.totalDurationMs !== undefined ? { durationMs: durations.totalDurationMs } : {}),
-            ...(durations.warningCount !== undefined ? { warningCount: durations.warningCount } : {}),
-            ...(durations.orphansPurged !== undefined ? { orphansPurged: durations.orphansPurged } : {}),
-            ...(result.graphExtraction?.quality
+            durationMs: durations.totalDurationMs,
+            warningCount: durations.warningCount,
+            orphansPurged: durations.orphansPurged,
+            ...(quality
                 ? {
-                    graphCoverage: result.graphExtraction.quality.extractionCoverage,
-                    graphDensity: result.graphExtraction.quality.density,
-                    graphEntities: result.graphExtraction.quality.entityCount,
+                    graphCoverage: quality.extractionCoverage,
+                    graphDensity: quality.density,
+                    graphEntities: quality.entityCount,
                 }
                 : {}),
         },