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

package/dist/commands/improve/loop-stages.js

@@ -1,28 +1,32 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
+import fs from "node:fs";
 import path from "node:path";
-import { parseAssetRef } from "../../core/asset/asset-ref.js";
+import { parseRefInput } from "../../core/asset/resolve-ref.js";
 import { daysToMs } from "../../core/common.js";
-import { loadConfig } from "../../core/config/config.js";
+import { DEFAULT_GRAPH_EXTRACTION_BATCH_SIZE, loadConfig } from "../../core/config/config.js";
 import { UsageError } from "../../core/errors.js";
 import { appendEvent } from "../../core/events.js";
 import { openLogsDatabase, purgeOldTaskLogs } from "../../core/logs-db.js";
 import { getDbPath } from "../../core/paths.js";
 import { withStateDb } from "../../core/state-db.js";
-import { info, warn } from "../../core/warn.js";
-import { closeDatabase, openIndexDatabase } from "../../indexer/db/db.js";
-import { runGraphExtractionPass } from "../../indexer/graph/graph-extraction.js";
+import { info } from "../../core/warn.js";
+import { DEFAULT_GRAPH_EXTRACTION_INCLUDE_TYPES, runGraphExtractionPass, } from "../../indexer/graph/graph-extraction.js";
 import { withIndexWriterLease } from "../../indexer/index-writer-lock.js";
 import { collectPendingMemories, runMemoryInferencePass, } from "../../indexer/passes/memory-inference.js";
 import { getWritableStashDirs, resolveSourceEntries } from "../../indexer/search/search-source.js";
-import { resolveImproveProcessRunnerFromProfile } from "../../integrations/agent/runner.js";
+import { materializeLlmRunnerConnection } from "../../integrations/agent/runner.js";
 import { isProcessEnabled } from "../../llm/feature-gate.js";
 import { withLlmStage } from "../../llm/usage-telemetry.js";
 import { purgeOldCycleMetrics } from "../../storage/repositories/canaries-repository.js";
 import { purgeOldEvents } from "../../storage/repositories/events-repository.js";
 import { purgeOldImproveRuns } from "../../storage/repositories/improve-runs-repository.js";
-import { createProposal, expireStaleProposals, isProposalSkipped, listProposals, purgeOrphanProposals, } from "../proposal/repository.js";
+import { closeDatabase, openIndexDatabase } from "../../storage/repositories/index-connection.js";
+import { getEntryByRef } from "../../storage/repositories/index-entries-repository.js";
+import { clearAssetOutcomeMissing, countAssetOutcomeMissing, deleteAssetOutcomeMissingBefore, listAssetOutcomeMissingState, stampAssetOutcomeMissing, } from "../../storage/repositories/outcome-repository.js";
+import { clearAssetSalienceMissing, countAssetSalienceMissing, deleteAssetSalienceMissingBefore, listAssetSalienceMissingState, stampAssetSalienceMissing, } from "../../storage/repositories/salience-repository.js";
+import { expireStaleProposals, listProposals, purgeOrphanProposals } from "../proposal/repository.js";
 import { checkDeadUrls } from "../url-checker.js";
 import { DEFAULT_RETENTION_DAYS as CYCLE_METRICS_RETENTION_DAYS, runCollapseDetector } from "./collapse-detector.js";
 import { deriveLessonRef } from "./distill.js";
@@ -30,570 +34,527 @@ import { deriveKnowledgeRef } from "./distill-promotion-policy.js";
 // Eligibility / candidate-selection predicates live in ./eligibility.
 import { findAssetFilePath, isDistillCandidateRef } from "./eligibility.js";
 import { writeEvalCase } from "./eval-cases.js";
-import { makeGateConfig, runAutoAcceptGate } from "./improve-auto-accept.js";
-import { resolveProcessEnabled, shouldSkipRef } from "./improve-profiles.js";
-// The pre-loop preparation pipeline lives in ./preparation.
-import { maybeAutoTuneThreshold } from "./preparation.js";
-import { akmProcedural } from "./procedural.js";
-import { akmRecombine } from "./recombine.js";
+import { shouldSkipRef } from "./improve-strategies.js";
 import { recordNoOp, resetConsecutiveNoOps } from "./salience.js";
 import { errMessage, refSlug } from "./shared.js";
+import { bareImproveRef, durableImproveRef } from "./source-identity.js";
 // ── improve loop / post-loop / maintenance stages ───────────────────
 // The cycle stages run by akmImprove, extracted from improve.ts.
-export async function runImproveLoopStage(args) {
-    const { scope, options, primaryStashDir, reflectFn, distillFn, loopRefs, actions, signalBearingSet, distillCooledRefs, distillOnlyRefs, recentErrors, rejectedProposalsByRef, utilityMap, startMs, budgetMs, eventsCtx, improveProfile, } = args;
+/** O-5 / #378: rolling per-originator error-window cap. */
+const RECENT_ERRORS_CAP = 3;
+/** O-5 / #378: push a per-originator error into the rolling window. */
+function pushRecentError(recentErrors, originator, msg) {
+    if (!recentErrors[originator])
+        recentErrors[originator] = [];
+    recentErrors[originator].push(msg);
+    if (recentErrors[originator].length > RECENT_ERRORS_CAP)
+        recentErrors[originator].shift();
+}
+/**
+ * Build the per-run loop environment from the run context: the derived guards
+ * and the pending-proposal preload.
+ */
+export function prepareImproveLoopEnv(args) {
+    const { ctx, scope, options, reflectFn, distillFn, loopRefs, signalBearingSet, distillCooledRefs, distillOnlyRefs, recentErrors, rejectedProposalsByRef, startMs, budgetMs, improveProfile, resolvedPlan, } = args;
+    // WI-9.10: the legacy dual context's optional eventsCtx/budgetSignal are
+    // now RunContext's required eventsCtx / optional signal — renamed local
+    // aliases so the rest of this function (and the ImproveLoopEnv object
+    // literal below) is unchanged. `primaryStashDir` deliberately comes from
+    // the state's honest optional field, NOT `ctx.stashDir`: the rare
+    // unresolvable-primary path must keep skipping the `if (primaryStashDir)`
+    // guards below (see the field's doc in ./improve-run-types).
+    const primaryStashDir = args.primaryStashDir;
+    const eventsCtx = ctx.eventsCtx;
+    const budgetSignal = ctx.signal;
     // O-1 (#364): compute remaining budget at call time so each sub-call
     // receives only its fair share of the wall-clock budget.
     const remainingBudgetMs = () => Math.max(0, budgetMs - (Date.now() - startMs));
-    const RECENT_ERRORS_CAP = 3;
+    // Build a Set for O(1) membership test — these refs skip the reflect call (Bug D2).
+    const distillOnlyRefSet = new Set(distillOnlyRefs.map((r) => r.ref));
     // requirePlannedRefs guard: when the distill profile sets this flag, skip
     // distill for distill-only refs if the reflect phase produced no planned refs.
     // Prevents the distill loop from generating hundreds of distill-skipped events
     // on quiet passes (all refs on reflect cooldown, no new signal to distill).
     const requirePlannedRefs = improveProfile?.processes?.distill?.requirePlannedRefs === true;
-    const _distillOnlyRefNames = new Set(distillOnlyRefs.map((r) => r.ref));
-    const hasReflectEligibleRefs = loopRefs.some((r) => !_distillOnlyRefNames.has(r.ref));
+    const hasReflectEligibleRefs = loopRefs.some((r) => !distillOnlyRefSet.has(r.ref));
     const skipDistillDueToRequirePlannedRefs = requirePlannedRefs && !hasReflectEligibleRefs;
-    // R-2 / #389: Self-Consistency multi-sample voting helpers.
-    // Wang et al. arXiv:2203.11171 — N=3 samples beat single-shot on reasoning tasks.
-    const SC_THRESHOLD = options.selfConsistencyThreshold ?? 0.7;
-    const SC_N = Math.min(Math.max(2, options.selfConsistencyN ?? 3), 5);
-    /**
-     * Compute Jaccard token overlap between two strings.
-     * Tokenizes by whitespace; returns 0 when both are empty.
-     */
-    function jaccardSimilarity(a, b) {
-        const tokensA = new Set(a.split(/\s+/).filter(Boolean));
-        const tokensB = new Set(b.split(/\s+/).filter(Boolean));
-        if (tokensA.size === 0 && tokensB.size === 0)
-            return 1;
-        let intersection = 0;
-        for (const t of tokensA) {
-            if (tokensB.has(t))
-                intersection++;
-        }
-        const union = tokensA.size + tokensB.size - intersection;
-        return union > 0 ? intersection / union : 0;
-    }
-    /**
-     * Given N reflect results, return the one with the highest average Jaccard
-     * similarity to all other successful results (majority-vote winner).
-     * Falls back to the first successful result when N < 2.
-     */
-    function pickMajorityVote(results) {
-        const successful = results.filter((r) => r.ok);
-        if (successful.length === 0)
-            return (results[0] ?? {
-                schemaVersion: 1,
-                ok: false,
-                reason: "non_zero_exit",
-                error: "all samples failed",
-                exitCode: null,
-            });
-        if (successful.length === 1)
-            return successful[0];
-        let bestIdx = 0;
-        let bestScore = -1;
-        for (let i = 0; i < successful.length; i++) {
-            let totalSim = 0;
-            for (let j = 0; j < successful.length; j++) {
-                if (i === j)
-                    continue;
-                totalSim += jaccardSimilarity(successful[i].proposal.payload.content ?? "", successful[j].proposal.payload.content ?? "");
-            }
-            const avgSim = totalSim / (successful.length - 1);
-            if (avgSim > bestScore) {
-                bestScore = avgSim;
-                bestIdx = i;
-            }
-        }
-        return successful[bestIdx] ?? successful[0];
-    }
-    // O-5 / #378: helper to push per-originator errors into the rolling window.
-    function pushRecentError(originator, msg) {
-        if (!recentErrors[originator])
-            recentErrors[originator] = [];
-        recentErrors[originator].push(msg);
-        if (recentErrors[originator].length > RECENT_ERRORS_CAP)
-            recentErrors[originator].shift();
-    }
-    // Build a Set for O(1) membership test — these refs skip the reflect call (Bug D2).
-    const distillOnlyRefSet = new Set(distillOnlyRefs.map((r) => r.ref));
-    let completedCount = 0;
-    let reflectsWithErrorContext = 0;
-    const memoryRefsForInference = new Set();
     // Pre-load all pending proposals once instead of querying per asset in the loop.
     const dedupeStashDirForProposals = primaryStashDir ?? options.stashDir;
     const pendingProposalRefSet = new Set(dedupeStashDirForProposals
         ? listProposals(dedupeStashDirForProposals, { status: "pending" }).map((p) => p.ref)
         : []);
-    let gateAutoAcceptedCount = 0;
-    let gateAutoAcceptFailedCount = 0;
-    const reflectGateCfg = makeGateConfig("reflect", {
-        globalThreshold: options.autoAccept,
-        dryRun: options.dryRun ?? false,
-        stashDir: primaryStashDir,
-        config: options.config ?? loadConfig(),
-        eventsCtx,
-        stateDbPath: eventsCtx?.dbPath,
-        // candidateCount drives the exploration budget. loopRefs is the per-phase
-        // set for reflect/distill; pass it so exploration budget is proportional.
-        candidateCount: loopRefs.length,
-    });
-    const distillGateCfg = makeGateConfig("distill", {
-        globalThreshold: options.autoAccept,
-        dryRun: options.dryRun ?? false,
-        stashDir: primaryStashDir,
-        config: options.config ?? loadConfig(),
+    return {
+        scope,
+        options,
+        primaryStashDir,
+        reflectFn,
+        distillFn,
+        signalBearingSet,
+        distillCooledRefs,
+        distillOnlyRefSet,
+        recentErrors,
+        rejectedProposalsByRef,
         eventsCtx,
-        stateDbPath: eventsCtx?.dbPath,
-        candidateCount: loopRefs.length,
-    });
-    for (const planned of loopRefs) {
-        if (Date.now() - startMs >= budgetMs) {
-            const remaining = loopRefs.length - completedCount;
-            info(`[improve] budget exhausted after ${Math.round((Date.now() - startMs) / 60000)}min — ${remaining} assets skipped`);
+        improveProfile,
+        resolvedPlan,
+        budgetSignal,
+        skipDistillDueToRequirePlannedRefs,
+        pendingProposalRefSet,
+        remainingBudgetMs,
+    };
+}
+/**
+ * One improve-loop iteration for a single planned ref: the reflect pass, then
+ * the distill pass, with the per-ref error classification (B7) around both.
+ * `continue` in the old inline loop body is an early `return` inside the
+ * passes; the orchestrator folds the returned tally and owns the run counters.
+ */
+export async function processImproveLoopRef(planned, env) {
+    const tally = {
+        actions: [],
+        reflectsWithErrorContext: 0,
+        recentErrorPushes: [],
+        memoryRefsForInference: [],
+    };
+    try {
+        // Bug D2: distillOnlyRefs skip the reflect call but still run the distill path.
+        // Bug D1: in-loop distill-cooldown check removed — distill-cooled candidates
+        //         have their synthetic actions emitted in runImprovePreparationStage.
+        const isDistillOnly = env.distillOnlyRefSet.has(planned.ref);
+        const parsedPlannedRef = parseRefInput(planned.ref);
+        await runLoopReflectPass(planned, isDistillOnly, env, tally);
+        // isDistillOnly refs: no reflect action emitted — proceed directly to the distill pass.
+        await runLoopDistillPass(planned, parsedPlannedRef, isDistillOnly, env, tally);
+    }
+    catch (err) {
+        // B7: UsageError thrown by akmDistill on validation_failed should be recorded
+        // as mode:"distill" with outcome:"validation_failed", NOT as a generic error.
+        // The distill_invoked event was already emitted inside akmDistill before the throw.
+        if (err instanceof UsageError) {
+            tally.actions.push({
+                ref: planned.ref,
+                mode: "distill",
+                result: { ok: false, outcome: "validation_failed", error: err.message },
+            });
+        }
+        else {
+            tally.actions.push({
+                ref: planned.ref,
+                mode: "error",
+                result: { ok: false, error: errMessage(err) },
+            });
+        }
+    }
+    return tally;
+}
+/**
+ * Reflect half of one loop iteration: type/profile gates, the reflect call with
+ * recent-error avoidPatterns, outcome classification (cooldown / guard-reject /
+ * type-refused / noise-gate), and plasticity counters. Records onto the per-ref
+ * tally only.
+ */
+async function runLoopReflectPass(planned, isDistillOnly, env, tally) {
+    const { options, primaryStashDir, reflectFn, eventsCtx, improveProfile, resolvedPlan, budgetSignal } = env;
+    // B6: derived memories are machine-generated; skip reflect to avoid noisy proposals.
+    // shouldDistillMemoryRef already returns false for .derived refs, so the distill
+    // path is also a no-op for them — we just avoid unnecessary agent spawns.
+    // D2: distillOnlyRefs also skip the reflect call (reflect-cooled, distill path only).
+    if (!isDistillOnly && !planned.ref.endsWith(".derived")) {
+        // Type guard: skip reflect for unsupported types (script, env, task, etc.)
+        // and raw wiki directories, driven by the active improve profile.
+        const reflectSkip = shouldSkipRef(planned.ref, "reflect", improveProfile);
+        if (reflectSkip.skip) {
+            tally.actions.push({
+                ref: planned.ref,
+                mode: "reflect-skipped",
+                result: { ok: true, reason: reflectSkip.reason },
+            });
+        }
+        else {
+            // O-5 / #378: only inject reflect-originator errors into the reflect call.
+            // Cross-task errors (e.g. schema-repair) must NOT contaminate reflect prompts.
+            const reflectErrors = env.recentErrors.reflect ?? [];
+            if (reflectErrors.length > 0)
+                tally.reflectsWithErrorContext++;
+            // O-1 (#364): pass remaining budget as timeoutMs so the agent spawn is
+            // bounded by the wall-clock deadline rather than the default per-profile timeout.
+            const reflectBudgetMs = env.remainingBudgetMs();
+            // Use the runner frozen in the invocation plan; no leaf re-resolution.
+            const reflectProfileRunner = resolvedPlan.processes.reflect.runner;
+            const reflectCallArgs = {
+                ref: planned.ref,
+                // Carry the resolved item_ref so reflect uses the same durable key for
+                // events and state reads.
+                ...(planned.itemRef ? { itemRef: planned.itemRef } : {}),
+                task: options.task,
+                // Active strategy supplies non-engine process tuning.
+                ...(improveProfile ? { improveProfile } : {}),
+                config: options.config,
+                ...(primaryStashDir ? { stashDir: primaryStashDir } : {}),
+                ...(options.sourceName && primaryStashDir
+                    ? { target: { source: options.sourceName, root: primaryStashDir } }
+                    : {}),
+                ...(reflectErrors.length > 0 ? { avoidPatterns: [...reflectErrors] } : {}),
+                eventSource: "improve",
+                // #639 — resolve the low-value filter from the ACTIVE improve profile
+                // (default off when unset), so the running strategy decides.
+                lowValueFilter: improveProfile.processes?.reflect?.lowValueFilter?.enabled === true,
+                ...(reflectBudgetMs > 0 ? { timeoutMs: reflectBudgetMs } : {}),
+                signal: budgetSignal,
+                runner: reflectProfileRunner ?? null,
+                // R25: reflect's event emits reuse the run's long-lived state.db handle.
+                eventsCtx: env.eventsCtx,
+                // Attribution: carry the eligibility lane so reflect stamps it on
+                // the reflect_invoked event and the persisted proposal.
+                ...(planned.eligibilitySource ? { eligibilitySource: planned.eligibilitySource } : {}),
+            };
+            const reflectResult = await withLlmStage("reflect", () => reflectFn(reflectCallArgs), {
+                engine: resolvedPlan.processes.reflect.runner?.engine,
+                process: "reflect",
+            });
+            const isCooldown = !reflectResult.ok && reflectResult.reason === "cooldown";
+            // Content-policy guard hits (reflect size-rail rejections) are NOT
+            // LLM faults — the agent responded fine, the downstream guard
+            // blocked the output. Route them to a distinct `reflect-guard-rejected`
+            // mode so health metrics can split deterministic guard hits out of
+            // true LLM failures. See
+            // `/tmp/akm-health-investigations/metrics-taxonomy-review.md` §1a.
+            const isGuardReject = !reflectResult.ok && reflectResult.reason === "content_policy_reject";
+            // Type-guard rejection (reflect refused a script/env/task ref) is
+            // also NOT an LLM failure — the LLM is never invoked. Route to the
+            // existing `reflect-skipped` bucket so it does not inflate the
+            // failure-rate numerator. ~9% of `reflect-failed` events in the
+            // user's stack were this case; see review §1a row "Reflect refused
+            // asset type".
+            const isTypeRefused = !reflectResult.ok && reflectResult.reason === "unsupported_type";
+            // Noise-gate suppression (#580): the candidate edit was an empty
+            // diff or a cosmetic-only reformat of the current asset. Like
+            // `unsupported_type`, this is a deterministic skip — not an LLM
+            // fault — so it routes to the `reflect-skipped` bucket and stays
+            // out of recentErrors/avoidPatterns.
+            const isNoChange = !reflectResult.ok && reflectResult.reason === "no_change";
+            tally.actions.push({
+                ref: planned.ref,
+                mode: reflectResult.ok
+                    ? "reflect"
+                    : isCooldown
+                        ? "reflect-cooldown"
+                        : isGuardReject
+                            ? "reflect-guard-rejected"
+                            : isTypeRefused || isNoChange
+                                ? "reflect-skipped"
+                                : "reflect-failed",
+                result: reflectResult,
+            });
+            // Cooldown skips, guard rejects, type-refused skips, and noise-gate
+            // skips are not failures — do not pollute recentErrors with them
+            // (those get injected as `avoidPatterns` into the next reflect
+            // prompt). Guard rejects ARE worth showing the LLM as a learn-signal
+            // so the next iteration sees "your last expansion was too large";
+            // type-refused and no-change are deterministic and add no learning
+            // signal.
+            if (!reflectResult.ok && !isCooldown && !isTypeRefused && !isNoChange) {
+                const errMsg = reflectResult.error ?? reflectResult.reason ?? "unknown reflect error";
+                tally.recentErrorPushes.push({ originator: "reflect", message: errMsg });
+            }
+            // improve_reflect_outcome — per-asset metric for tuning the reflect path.
             appendEvent({
-                eventType: "improve_skipped",
+                eventType: "improve_reflect_outcome",
                 ref: planned.ref,
                 metadata: {
-                    reason: "budget_exhausted",
-                    remaining,
+                    ok: reflectResult.ok,
+                    durationMs: reflectResult.ok ? reflectResult.durationMs : undefined,
+                    engine: reflectResult.engine,
+                    reason: reflectResult.ok ? undefined : reflectResult.reason,
                 },
             }, eventsCtx);
-            // B11: Emit improve_skipped for all remaining assets that will not be processed.
-            for (const remainingRef of loopRefs.slice(completedCount + 1)) {
-                appendEvent({
-                    eventType: "improve_skipped",
-                    ref: remainingRef.ref,
-                    metadata: { reason: "budget_exhausted_batch", remaining: loopRefs.length - completedCount - 1 },
-                }, eventsCtx);
+            // Plasticity counter (plan §WS-1 step 8): record no-ops so the
+            // WS-1 selection comparator (effectiveScore, ~line 3073) can dampen
+            // repeatedly-silent assets during consolidation-selection.
+            // A no_change reflect means the LLM was invoked but found nothing to
+            // improve — the asset is stable. Track it. A successful reflect means
+            // the asset changed; reset the counter so the dampener lifts.
+            // Use the same item_ref-or-conceptId salience key as preparation/distill.
+            const plasticityKey = planned.itemRef ?? durableImproveRef(planned.ref);
+            if (isNoChange && eventsCtx?.db) {
+                try {
+                    recordNoOp(eventsCtx.db, plasticityKey);
+                }
+                catch {
+                    // best-effort: plasticity counter failure never blocks the run
+                }
             }
-            actions.push({
-                ref: planned.ref,
-                mode: "error",
-                result: { ok: false, error: "timeout: improve wall-clock budget exhausted" },
-            });
-            break;
-        }
-        try {
-            // Bug D2: distillOnlyRefs skip the reflect call but still run the distill path.
-            // Bug D1: in-loop distill-cooldown check removed — distill-cooled candidates
-            //         have their synthetic actions emitted in runImprovePreparationStage.
-            const isDistillOnly = distillOnlyRefSet.has(planned.ref);
-            const parsedPlannedRef = parseAssetRef(planned.ref);
-            // B6: derived memories are machine-generated; skip reflect to avoid noisy proposals.
-            // shouldDistillMemoryRef already returns false for .derived refs, so the distill
-            // path is also a no-op for them — we just avoid unnecessary agent spawns.
-            // D2: distillOnlyRefs also skip the reflect call (reflect-cooled, distill path only).
-            if (!isDistillOnly && !planned.ref.endsWith(".derived")) {
-                // Type guard: skip reflect for unsupported types (script, env, task, etc.)
-                // and raw wiki directories, driven by the active improve profile.
-                const reflectSkip = shouldSkipRef(planned.ref, "reflect", improveProfile);
-                if (reflectSkip.skip) {
-                    actions.push({
-                        ref: planned.ref,
-                        mode: "reflect-skipped",
-                        result: { ok: true, reason: reflectSkip.reason },
-                    });
+            else if (reflectResult.ok && eventsCtx?.db) {
+                try {
+                    resetConsecutiveNoOps(eventsCtx.db, plasticityKey);
+                }
+                catch {
+                    // best-effort
                 }
-                else {
-                    // O-5 / #378: only inject reflect-originator errors into the reflect call.
-                    // Cross-task errors (e.g. schema-repair) must NOT contaminate reflect prompts.
-                    const reflectErrors = recentErrors.reflect ?? [];
-                    if (reflectErrors.length > 0)
-                        reflectsWithErrorContext++;
-                    // O-1 (#364): pass remaining budget as timeoutMs so the agent spawn is
-                    // bounded by the wall-clock deadline rather than the default per-profile timeout.
-                    const reflectBudgetMs = remainingBudgetMs();
-                    // Wire profile.processes.reflect.{mode, profile, timeoutMs} into the reflect
-                    // dispatch when present. Falls back to akmReflect's own config-based resolution
-                    // (profiles.improve.<name>.processes.reflect → defaults.llm) when the profile
-                    // does not specify.
-                    const reflectProfileRunner = resolveImproveProcessRunnerFromProfile(improveProfile.processes?.reflect, options.config ?? loadConfig());
-                    const reflectCallArgs = {
-                        ref: planned.ref,
-                        task: options.task,
-                        // Active profile so reflect's per-process reads honor `--profile`.
-                        ...(improveProfile ? { improveProfile } : {}),
-                        ...(options.stashDir ? { stashDir: options.stashDir } : {}),
-                        ...(reflectErrors.length > 0 ? { avoidPatterns: [...reflectErrors] } : {}),
-                        agentProcess: options.agentProcess ?? "reflect",
-                        eventSource: "improve",
-                        // #639 — resolve the low-value filter from the ACTIVE improve profile
-                        // (default off when unset), so the running profile decides instead of
-                        // a hardcoded profiles.improve.default path.
-                        lowValueFilter: improveProfile.processes?.reflect?.lowValueFilter?.enabled === true,
-                        ...(reflectBudgetMs > 0 ? { timeoutMs: reflectBudgetMs } : {}),
-                        ...(reflectProfileRunner ? { runner: reflectProfileRunner } : {}),
-                        // Attribution: carry the eligibility lane so reflect stamps it on
-                        // the reflect_invoked event and the persisted proposal.
-                        ...(planned.eligibilitySource ? { eligibilitySource: planned.eligibilitySource } : {}),
-                    };
-                    // R-2 / #389: Self-consistency multi-sample voting for high-utility refs.
-                    // Self-Consistency arXiv:2203.11171 — N=3 samples beat single-shot quality.
-                    const refUtility = utilityMap.get(planned.ref) ?? 0;
-                    const useConsistency = refUtility >= SC_THRESHOLD && SC_N >= 2;
-                    let reflectResult;
-                    if (useConsistency) {
-                        const samples = [];
-                        for (let s = 0; s < SC_N; s++) {
-                            if (remainingBudgetMs() <= 0)
-                                break;
-                            // draftMode: skip DB write so each sample doesn't create a proposal.
-                            samples.push(await withLlmStage("reflect", () => reflectFn({ ...reflectCallArgs, draftMode: true })));
-                        }
-                        const winner = pickMajorityVote(samples.length > 0
-                            ? samples
-                            : [await withLlmStage("reflect", () => reflectFn({ ...reflectCallArgs, draftMode: true }))]);
-                        // Persist only the majority-vote winner as a single real proposal.
-                        if (winner.ok && primaryStashDir) {
-                            const persistResult = createProposal(primaryStashDir, {
-                                ref: winner.proposal.ref,
-                                source: "reflect",
-                                sourceRun: `reflect-sc-${Date.now()}`,
-                                payload: winner.proposal.payload,
-                                // Attribution: the self-consistency path persists the winner here
-                                // (draftMode skips reflect's own createProposal), so stamp the lane.
-                                ...(planned.eligibilitySource ? { eligibilitySource: planned.eligibilitySource } : {}),
-                            });
-                            reflectResult = isProposalSkipped(persistResult)
-                                ? {
-                                    schemaVersion: 1,
-                                    ok: false,
-                                    reason: "cooldown",
-                                    error: `SC proposal skipped: ${persistResult.message}`,
-                                    ref: winner.ref,
-                                    exitCode: null,
-                                }
-                                : { ...winner, proposal: persistResult };
-                        }
-                        else {
-                            reflectResult = winner;
-                        }
-                    }
-                    else {
-                        reflectResult = await withLlmStage("reflect", () => reflectFn(reflectCallArgs));
-                    }
-                    const isCooldown = !reflectResult.ok && reflectResult.reason === "cooldown";
-                    // Content-policy guard hits (reflect size-rail rejections) are NOT
-                    // LLM faults — the agent responded fine, the downstream guard
-                    // blocked the output. Route them to a distinct `reflect-guard-rejected`
-                    // mode so health metrics can split deterministic guard hits out of
-                    // true LLM failures. See
-                    // `/tmp/akm-health-investigations/metrics-taxonomy-review.md` §1a.
-                    const isGuardReject = !reflectResult.ok && reflectResult.reason === "content_policy_reject";
-                    // Type-guard rejection (reflect refused a script/env/task ref) is
-                    // also NOT an LLM failure — the LLM is never invoked. Route to the
-                    // existing `reflect-skipped` bucket so it does not inflate the
-                    // failure-rate numerator. ~9% of `reflect-failed` events in the
-                    // user's stack were this case; see review §1a row "Reflect refused
-                    // asset type".
-                    const isTypeRefused = !reflectResult.ok && reflectResult.reason === "unsupported_type";
-                    // Noise-gate suppression (#580): the candidate edit was an empty
-                    // diff or a cosmetic-only reformat of the current asset. Like
-                    // `unsupported_type`, this is a deterministic skip — not an LLM
-                    // fault — so it routes to the `reflect-skipped` bucket and stays
-                    // out of recentErrors/avoidPatterns.
-                    const isNoChange = !reflectResult.ok && reflectResult.reason === "no_change";
-                    actions.push({
-                        ref: planned.ref,
-                        mode: reflectResult.ok
-                            ? "reflect"
-                            : isCooldown
-                                ? "reflect-cooldown"
-                                : isGuardReject
-                                    ? "reflect-guard-rejected"
-                                    : isTypeRefused || isNoChange
-                                        ? "reflect-skipped"
-                                        : "reflect-failed",
-                        result: reflectResult,
-                    });
-                    // Cooldown skips, guard rejects, type-refused skips, and noise-gate
-                    // skips are not failures — do not pollute recentErrors with them
-                    // (those get injected as `avoidPatterns` into the next reflect
-                    // prompt). Guard rejects ARE worth showing the LLM as a learn-signal
-                    // so the next iteration sees "your last expansion was too large";
-                    // type-refused and no-change are deterministic and add no learning
-                    // signal.
-                    if (!reflectResult.ok && !isCooldown && !isTypeRefused && !isNoChange) {
-                        const errMsg = reflectResult.error ?? reflectResult.reason ?? "unknown reflect error";
-                        pushRecentError("reflect", errMsg);
-                    }
-                    // improve_reflect_outcome — per-asset metric for tuning the reflect path.
-                    appendEvent({
-                        eventType: "improve_reflect_outcome",
-                        ref: planned.ref,
-                        metadata: {
-                            ok: reflectResult.ok,
-                            durationMs: reflectResult.ok ? reflectResult.durationMs : undefined,
-                            agentProfile: reflectResult.ok ? reflectResult.agentProfile : undefined,
-                            reason: reflectResult.ok ? undefined : reflectResult.reason,
-                        },
-                    }, eventsCtx);
-                    // Plasticity counter (plan §WS-1 step 8): record no-ops so the
-                    // WS-1 selection comparator (effectiveScore, ~line 3073) can dampen
-                    // repeatedly-silent assets during consolidation-selection.
-                    // A no_change reflect means the LLM was invoked but found nothing to
-                    // improve — the asset is stable. Track it. A successful reflect means
-                    // the asset changed; reset the counter so the dampener lifts.
-                    if (isNoChange && eventsCtx?.db) {
-                        try {
-                            recordNoOp(eventsCtx.db, planned.ref);
-                        }
-                        catch {
-                            // best-effort: plasticity counter failure never blocks the run
-                        }
-                    }
-                    else if (reflectResult.ok && eventsCtx?.db) {
-                        try {
-                            resetConsecutiveNoOps(eventsCtx.db, planned.ref);
-                        }
-                        catch {
-                            // best-effort
-                        }
-                    }
-                    if (reflectResult.ok) {
-                        const reflectGr = await runAutoAcceptGate([{ proposalId: reflectResult.proposal.id, confidence: reflectResult.proposal.confidence }], reflectGateCfg);
-                        gateAutoAcceptedCount += reflectGr.promoted.length;
-                        gateAutoAcceptFailedCount += reflectGr.failed.length;
-                    }
-                } // end else (reflect type/profile check)
             }
-            else if (!isDistillOnly && planned.ref.endsWith(".derived")) {
-                // B6: .derived refs skip reflect; record synthetic skip action.
-                actions.push({
+        } // end else (reflect type/profile check)
+    }
+    else if (!isDistillOnly && planned.ref.endsWith(".derived")) {
+        // B6: .derived refs skip reflect; record synthetic skip action.
+        tally.actions.push({
+            ref: planned.ref,
+            mode: "distill-skipped",
+            result: { ok: true, reason: "derived-memory-reflect-skipped" },
+        });
+        appendEvent({
+            eventType: "improve_skipped",
+            ref: planned.ref,
+            metadata: { reason: "derived_memory_reflect_skipped" },
+        }, eventsCtx);
+    }
+}
+/**
+ * Distill half of one loop iteration: the profile / requirePlannedRefs /
+ * candidate-type / weak-signal / cooldown gates, then the pending-proposal and
+ * reject-grace dedup checks, then {@link invokeDistillAndRecord}. Each gate
+ * that was a `continue` in the old inline loop body is an early `return` here.
+ */
+async function runLoopDistillPass(planned, parsedPlannedRef, isDistillOnly, env, tally) {
+    const { options, primaryStashDir, eventsCtx, improveProfile } = env;
+    const hasRecentFeedbackSignal = env.signalBearingSet.has(planned.ref);
+    const explicitRefScope = env.scope.mode === "ref";
+    // Profile gate: apply the full type-filter / raw-wiki / disabled rules to
+    // distill so callers who configure `profile.processes.distill.allowedTypes`
+    // or land on raw-wiki refs get a recorded skip action instead of silently
+    // proceeding.
+    const distillSkip = shouldSkipRef(planned.ref, "distill", improveProfile);
+    if (distillSkip.skip) {
+        tally.actions.push({
+            ref: planned.ref,
+            mode: "distill-skipped",
+            result: { ok: true, reason: distillSkip.reason },
+        });
+        return;
+    }
+    // requirePlannedRefs guard: skip distill for distill-only refs when no
+    // reflect-eligible refs were planned this run, preventing mass skip events.
+    if (env.skipDistillDueToRequirePlannedRefs && isDistillOnly) {
+        tally.actions.push({
+            ref: planned.ref,
+            mode: "distill-skipped",
+            result: { ok: true, reason: "require_planned_refs" },
+        });
+        return;
+    }
+    // See `isDistillCandidateRef` — excludes `lesson:*` (and anything else in
+    // DISTILL_REFUSED_INPUT_TYPES) so distill never gets queued for an input
+    // it will refuse.
+    const shouldAttemptDistill = isDistillCandidateRef(planned.ref, options.stashDir);
+    const skipMemoryDistillForWeakSignal = !isDistillOnly && parsedPlannedRef.type === "memory" && !hasRecentFeedbackSignal && !explicitRefScope;
+    // distillCooledRefs guard: pre-filter emitted synthetic actions for distill-candidate
+    // refs; non-candidate refs in the set are blocked here.
+    // O-2 (#365): bypass the distill cooldown when the user explicitly targeted
+    // this ref via --scope — their intent overrides unattended-run policies.
+    if (shouldAttemptDistill &&
+        !skipMemoryDistillForWeakSignal &&
+        (!env.distillCooledRefs.has(planned.ref) || explicitRefScope)) {
+        // TODO(refactor): single call site needs both lesson+knowledge refs for proposal dedup. If a third target ref type is added, extract deriveAllTargetRefs(inputRef): string[].
+        const lessonRef = deriveLessonRef(planned.ref);
+        const knowledgeRef = deriveKnowledgeRef(planned.ref);
+        const dedupeStashDir = primaryStashDir ?? options.stashDir;
+        if (dedupeStashDir) {
+            // B2: check both lesson ref and knowledge ref since auto-promoted memories
+            // create knowledge: proposals, not lesson: proposals.
+            const hasExistingPending = env.pendingProposalRefSet.has(lessonRef) || env.pendingProposalRefSet.has(knowledgeRef);
+            if (hasExistingPending) {
+                tally.actions.push({
                     ref: planned.ref,
                     mode: "distill-skipped",
-                    result: { ok: true, reason: "derived-memory-reflect-skipped" },
+                    result: { ok: true, reason: "pending proposal exists" },
                 });
                 appendEvent({
                     eventType: "improve_skipped",
                     ref: planned.ref,
-                    metadata: { reason: "derived_memory_reflect_skipped" },
+                    metadata: { reason: "pending_proposal_exists" },
                 }, eventsCtx);
+                return;
             }
-            // isDistillOnly refs: no reflect action emitted — proceed directly to distill path below.
-            const hasRecentFeedbackSignal = signalBearingSet.has(planned.ref);
-            const explicitRefScope = scope.mode === "ref";
-            // Profile gate: apply the full type-filter / raw-wiki / disabled rules to
-            // distill so callers who configure `profile.processes.distill.allowedTypes`
-            // or land on raw-wiki refs get a recorded skip action instead of silently
-            // proceeding.
-            const distillSkip = shouldSkipRef(planned.ref, "distill", improveProfile);
-            if (distillSkip.skip) {
-                actions.push({
-                    ref: planned.ref,
-                    mode: "distill-skipped",
-                    result: { ok: true, reason: distillSkip.reason },
-                });
-                completedCount++;
-                info(`[improve] ${completedCount}/${loopRefs.length} ${planned.ref}`);
-                continue;
-            }
-            // requirePlannedRefs guard: skip distill for distill-only refs when no
-            // reflect-eligible refs were planned this run, preventing mass skip events.
-            if (skipDistillDueToRequirePlannedRefs && isDistillOnly) {
-                actions.push({
-                    ref: planned.ref,
-                    mode: "distill-skipped",
-                    result: { ok: true, reason: "require_planned_refs" },
-                });
-                completedCount++;
-                info(`[improve] ${completedCount}/${loopRefs.length} ${planned.ref}`);
-                continue;
-            }
-            // See `isDistillCandidateRef` — excludes `lesson:*` (and anything else in
-            // DISTILL_REFUSED_INPUT_TYPES) so distill never gets queued for an input
-            // it will refuse.
-            const shouldAttemptDistill = isDistillCandidateRef(planned.ref, options.stashDir);
-            const skipMemoryDistillForWeakSignal = !isDistillOnly && parsedPlannedRef.type === "memory" && !hasRecentFeedbackSignal && !explicitRefScope;
-            // distillCooledRefs guard: pre-filter emitted synthetic actions for distill-candidate
-            // refs; non-candidate refs in the set are blocked here.
-            // O-2 (#365): bypass the distill cooldown when the user explicitly targeted
-            // this ref via --scope — their intent overrides unattended-run policies.
-            if (shouldAttemptDistill &&
-                !skipMemoryDistillForWeakSignal &&
-                (!distillCooledRefs.has(planned.ref) || explicitRefScope)) {
-                // TODO(refactor): single call site needs both lesson+knowledge refs for proposal dedup. If a third target ref type is added, extract deriveAllTargetRefs(inputRef): string[].
-                const lessonRef = deriveLessonRef(planned.ref);
-                const knowledgeRef = deriveKnowledgeRef(planned.ref);
-                const dedupeStashDir = primaryStashDir ?? options.stashDir;
-                if (dedupeStashDir) {
-                    // B2: check both lesson ref and knowledge ref since auto-promoted memories
-                    // create knowledge: proposals, not lesson: proposals.
-                    const hasExistingPending = pendingProposalRefSet.has(lessonRef) || pendingProposalRefSet.has(knowledgeRef);
-                    if (hasExistingPending) {
-                        actions.push({
-                            ref: planned.ref,
-                            mode: "distill-skipped",
-                            result: { ok: true, reason: "pending proposal exists" },
-                        });
-                        appendEvent({
-                            eventType: "improve_skipped",
-                            ref: planned.ref,
-                            metadata: { reason: "pending_proposal_exists" },
-                        }, eventsCtx);
-                        completedCount++;
-                        info(`[improve] ${completedCount}/${loopRefs.length} ${planned.ref}`);
-                        continue;
-                    }
-                    // D-2 (#370): reject-aware cooldown for distill. When the reviewer
-                    // recently rejected a distilled lesson or knowledge proposal for this
-                    // asset, skip re-distillation for a 1-day grace window. Prevents the
-                    // same rejected proposal from being regenerated immediately. The
-                    // window is fixed (the 0.8.0 redesign moved per-ref cooldowns to
-                    // signal-delta gates and dropped --distill-cooldown-days; a short
-                    // reject grace is preserved here so a fresh rejection isn't
-                    // overridden by the same run).
-                    // References: ExpeL arXiv:2308.10144, STaR arXiv:2203.14465.
-                    const DISTILL_REJECT_COOLDOWN_MS = daysToMs(1);
-                    const recentlyRejectedLesson = !explicitRefScope && // O-2: bypass when --scope <ref> is explicit
-                        (rejectedProposalsByRef.has(lessonRef) || rejectedProposalsByRef.has(knowledgeRef));
-                    if (recentlyRejectedLesson) {
-                        const rejectedEntry = rejectedProposalsByRef.get(lessonRef) ?? rejectedProposalsByRef.get(knowledgeRef);
-                        const rejectedAgeMs = rejectedEntry ? Date.now() - new Date(rejectedEntry.ts).getTime() : 0;
-                        if (rejectedAgeMs < DISTILL_REJECT_COOLDOWN_MS) {
-                            actions.push({
-                                ref: planned.ref,
-                                mode: "distill-skipped",
-                                result: { ok: true, reason: "distill reject grace window" },
-                            });
-                            appendEvent({
-                                eventType: "improve_skipped",
-                                ref: planned.ref,
-                                metadata: {
-                                    reason: "distill_reject_grace_window",
-                                },
-                            }, eventsCtx);
-                            completedCount++;
-                            info(`[improve] ${completedCount}/${loopRefs.length} ${planned.ref}`);
-                            continue;
-                        }
-                    }
-                }
-                const distillResult = await withLlmStage("distill", () => distillFn({
-                    ref: planned.ref,
-                    ...(parsedPlannedRef.type === "memory" ? { proposalKind: "auto" } : {}),
-                    ...(options.stashDir ? { stashDir: options.stashDir } : {}),
-                    // Active profile so distill's per-process reads honor `--profile`.
-                    ...(improveProfile ? { improveProfile } : {}),
-                    // Attribution: carry the eligibility lane so distill stamps it on the
-                    // distill_invoked event and the persisted proposal.
-                    ...(planned.eligibilitySource ? { eligibilitySource: planned.eligibilitySource } : {}),
-                }));
-                actions.push({ ref: planned.ref, mode: "distill", result: distillResult });
-                if (distillResult.outcome === "queued" && distillResult.proposal) {
-                    const distillGr = await runAutoAcceptGate([{ proposalId: distillResult.proposal.id, confidence: distillResult.proposal.confidence }], distillGateCfg);
-                    gateAutoAcceptedCount += distillGr.promoted.length;
-                    gateAutoAcceptFailedCount += distillGr.failed.length;
-                }
-                if (parsedPlannedRef.type === "memory") {
-                    const promotedToKnowledge = distillResult.outcome === "queued" && distillResult.proposalKind === "knowledge";
-                    if (!promotedToKnowledge)
-                        memoryRefsForInference.add(planned.ref);
-                }
-                // Plasticity counter (plan §WS-1 step 8) for the distill path.
-                // quality_rejected: the LLM ran but produced output that didn't pass the
-                // quality gate — the asset is not yielding useful distill output.
-                // queued: a proposal was produced; reset the no-op counter.
-                if (eventsCtx?.db) {
-                    try {
-                        if (distillResult.outcome === "quality_rejected" || distillResult.outcome === "skipped") {
-                            recordNoOp(eventsCtx.db, planned.ref);
-                        }
-                        else if (distillResult.outcome === "queued") {
-                            resetConsecutiveNoOps(eventsCtx.db, planned.ref);
-                        }
-                    }
-                    catch {
-                        // best-effort: plasticity counter failure never blocks the run
-                    }
-                }
-                if (distillResult.outcome === "quality_rejected" && primaryStashDir) {
-                    const slug = refSlug(planned.ref);
-                    writeEvalCase(primaryStashDir, {
+            // D-2 (#370): reject-aware cooldown for distill. When the reviewer
+            // recently rejected a distilled lesson or knowledge proposal for this
+            // asset, skip re-distillation for a 1-day grace window. Prevents the
+            // same rejected proposal from being regenerated immediately. The
+            // window is fixed (the 0.8.0 redesign moved per-ref cooldowns to
+            // signal-delta gates and dropped --distill-cooldown-days; a short
+            // reject grace is preserved here so a fresh rejection isn't
+            // overridden by the same run).
+            // References: ExpeL arXiv:2308.10144, STaR arXiv:2203.14465.
+            const DISTILL_REJECT_COOLDOWN_MS = daysToMs(1);
+            const recentlyRejectedLesson = !explicitRefScope && // O-2: bypass when --scope <ref> is explicit
+                (env.rejectedProposalsByRef.has(lessonRef) || env.rejectedProposalsByRef.has(knowledgeRef));
+            if (recentlyRejectedLesson) {
+                const rejectedEntry = env.rejectedProposalsByRef.get(lessonRef) ?? env.rejectedProposalsByRef.get(knowledgeRef);
+                const rejectedAgeMs = rejectedEntry ? Date.now() - new Date(rejectedEntry.ts).getTime() : 0;
+                if (rejectedAgeMs < DISTILL_REJECT_COOLDOWN_MS) {
+                    tally.actions.push({
                         ref: planned.ref,
-                        failureReason: distillResult.reason ?? "quality gate rejected",
-                        assetType: parseAssetRef(planned.ref).type ?? "unknown",
-                        rejectedAt: Date.now(),
-                        source: "distill_quality_rejected",
-                        slug: `${slug}-${Date.now()}`,
+                        mode: "distill-skipped",
+                        result: { ok: true, reason: "distill reject grace window" },
                     });
-                }
-                // D6: use pre-loaded map instead of per-iteration DB query
-                const rejectedProposalEvent = rejectedProposalsByRef.get(planned.ref);
-                if (rejectedProposalEvent && primaryStashDir) {
-                    const slug = refSlug(planned.ref);
-                    writeEvalCase(primaryStashDir, {
+                    appendEvent({
+                        eventType: "improve_skipped",
                         ref: planned.ref,
-                        failureReason: rejectedProposalEvent.metadata?.reason ?? "proposal rejected",
-                        assetType: parseAssetRef(planned.ref).type ?? "unknown",
-                        rejectedAt: new Date(rejectedProposalEvent.ts).getTime(),
-                        source: "proposal_rejected",
-                        slug: `${slug}-rejected`,
-                    });
+                        metadata: {
+                            reason: "distill_reject_grace_window",
+                        },
+                    }, eventsCtx);
+                    return;
                 }
             }
-            else if (skipMemoryDistillForWeakSignal) {
-                actions.push({
-                    ref: planned.ref,
-                    mode: "distill-skipped",
-                    result: { ok: true, reason: "memory requires recent feedback signal" },
-                });
-                appendEvent({
-                    eventType: "improve_skipped",
-                    ref: planned.ref,
-                    metadata: { reason: "memory_distill_requires_feedback" },
-                }, eventsCtx);
-            }
         }
-        catch (err) {
-            // B7: UsageError thrown by akmDistill on validation_failed should be recorded
-            // as mode:"distill" with outcome:"validation_failed", NOT as a generic error.
-            // The distill_invoked event was already emitted inside akmDistill before the throw.
-            if (err instanceof UsageError) {
-                actions.push({
-                    ref: planned.ref,
-                    mode: "distill",
-                    result: { ok: false, outcome: "validation_failed", error: err.message },
-                });
+        await invokeDistillAndRecord(planned, parsedPlannedRef, env, tally);
+    }
+    else if (skipMemoryDistillForWeakSignal) {
+        tally.actions.push({
+            ref: planned.ref,
+            mode: "distill-skipped",
+            result: { ok: true, reason: "memory requires recent feedback signal" },
+        });
+        appendEvent({
+            eventType: "improve_skipped",
+            ref: planned.ref,
+            metadata: { reason: "memory_distill_requires_feedback" },
+        }, eventsCtx);
+    }
+}
+/**
+ * The distill invocation for one ref that passed every gate: the `distillFn`
+ * call, memory-inference queueing, plasticity counters, and the
+ * quality-rejected / proposal-rejected eval-case writes.
+ */
+async function invokeDistillAndRecord(planned, parsedPlannedRef, env, tally) {
+    const { options, primaryStashDir, distillFn, eventsCtx, improveProfile, resolvedPlan, budgetSignal } = env;
+    const distillResult = await withLlmStage("distill", () => distillFn({
+        ref: planned.ref,
+        // Carry the resolved item_ref so distill matches preparation's state key.
+        ...(planned.itemRef ? { itemRef: planned.itemRef } : {}),
+        ...(parsedPlannedRef.type === "memory" ? { proposalKind: "auto" } : {}),
+        ...(primaryStashDir ? { stashDir: primaryStashDir } : {}),
+        // Active profile so distill's per-process reads honor `--profile`.
+        ...(improveProfile ? { improveProfile } : {}),
+        config: options.config,
+        llmConfig: resolvedPlan.processes.distill.runner
+            ? materializeLlmRunnerConnection(resolvedPlan.processes.distill.runner)
+            : null,
+        signal: budgetSignal,
+        // R25: distill's event emits reuse the run's long-lived state.db handle.
+        eventsCtx,
+        // Attribution: carry the eligibility lane so distill stamps it on the
+        // distill_invoked event and the persisted proposal.
+        ...(planned.eligibilitySource ? { eligibilitySource: planned.eligibilitySource } : {}),
+    }), { engine: resolvedPlan.processes.distill.runner?.engine, process: "distill" });
+    tally.actions.push({ ref: planned.ref, mode: "distill", result: distillResult });
+    if (parsedPlannedRef.type === "memory") {
+        const promotedToKnowledge = distillResult.outcome === "queued" && distillResult.proposalKind === "knowledge";
+        if (!promotedToKnowledge)
+            tally.memoryRefsForInference.push(planned.ref);
+    }
+    // Plasticity counter (plan §WS-1 step 8) for the distill path.
+    // quality_rejected: the LLM ran but produced output that didn't pass the
+    // quality gate — the asset is not yielding useful distill output.
+    // queued: a proposal was produced; reset the no-op counter.
+    if (eventsCtx?.db) {
+        // Use the same item_ref-or-conceptId key as the distill/preparation writers.
+        const plasticityKey = planned.itemRef ?? durableImproveRef(planned.ref);
+        try {
+            if (distillResult.outcome === "quality_rejected" || distillResult.outcome === "skipped") {
+                recordNoOp(eventsCtx.db, plasticityKey);
             }
-            else {
-                actions.push({
-                    ref: planned.ref,
-                    mode: "error",
-                    result: { ok: false, error: errMessage(err) },
-                });
+            else if (distillResult.outcome === "queued") {
+                resetConsecutiveNoOps(eventsCtx.db, plasticityKey);
             }
         }
-        completedCount++;
-        info(`[improve] ${completedCount}/${loopRefs.length} ${planned.ref}`);
+        catch {
+            // best-effort: plasticity counter failure never blocks the run
+        }
     }
-    // WS-4: Per-phase threshold auto-tune — runs AFTER the loop so the gate
-    // has processed all candidates for this run. Persists each phase's tuned
-    // threshold to state.db for the NEXT run's makeGateConfig to read.
-    // Best-effort: a tune failure must never fail the improve run.
-    const stateDbPathForTune = eventsCtx?.dbPath;
-    if (options.autoAccept !== undefined && stateDbPathForTune) {
-        const phaseGateCfgMap = {
-            reflect: reflectGateCfg,
-            distill: distillGateCfg,
-        };
-        for (const phase of ["reflect", "distill"]) {
-            const phaseCfg = phaseGateCfgMap[phase];
-            try {
-                maybeAutoTuneThreshold(phaseCfg.phaseThreshold ?? options.autoAccept, options.config ?? loadConfig(), stateDbPathForTune, undefined, phase);
-            }
-            catch (err) {
-                warn(`[improve] calibration auto-tune (${phase}) skipped: ${errMessage(err)}`);
-            }
+    if (distillResult.outcome === "quality_rejected" && primaryStashDir) {
+        const slug = refSlug(planned.ref);
+        writeEvalCase(primaryStashDir, {
+            ref: planned.ref,
+            failureReason: distillResult.reason ?? "quality gate rejected",
+            assetType: parseRefInput(planned.ref).type ?? "unknown",
+            rejectedAt: Date.now(),
+            source: "distill_quality_rejected",
+            slug: `${slug}-${Date.now()}`,
+        });
+    }
+    // D6: use pre-loaded map instead of per-iteration DB query
+    const rejectedProposalEvent = env.rejectedProposalsByRef.get(planned.ref);
+    if (rejectedProposalEvent && primaryStashDir) {
+        const slug = refSlug(planned.ref);
+        writeEvalCase(primaryStashDir, {
+            ref: planned.ref,
+            failureReason: rejectedProposalEvent.metadata?.reason ?? "proposal rejected",
+            assetType: parseRefInput(planned.ref).type ?? "unknown",
+            rejectedAt: new Date(rejectedProposalEvent.ts).getTime(),
+            source: "proposal_rejected",
+            slug: `${slug}-rejected`,
+        });
+    }
+}
+/**
+ * Wall-clock budget exhausted mid-loop (O-1 / #364): emit the improve_skipped
+ * events for the current and remaining refs (B11) and return the terminal
+ * error action for the orchestrator to record before breaking out of the loop.
+ */
+function recordBudgetExhausted(args) {
+    const { planned, loopRefs, completedCount, startMs, eventsCtx } = args;
+    const remaining = loopRefs.length - completedCount;
+    info(`[improve] budget exhausted after ${Math.round((Date.now() - startMs) / 60000)}min — ${remaining} assets skipped`);
+    appendEvent({
+        eventType: "improve_skipped",
+        ref: planned.ref,
+        metadata: {
+            reason: "budget_exhausted",
+            remaining,
+        },
+    }, eventsCtx);
+    // B11: Emit improve_skipped for all remaining assets that will not be processed.
+    for (const remainingRef of loopRefs.slice(completedCount + 1)) {
+        appendEvent({
+            eventType: "improve_skipped",
+            ref: remainingRef.ref,
+            metadata: { reason: "budget_exhausted_batch", remaining: loopRefs.length - completedCount - 1 },
+        }, eventsCtx);
+    }
+    return {
+        ref: planned.ref,
+        mode: "error",
+        result: { ok: false, error: "timeout: improve wall-clock budget exhausted" },
+    };
+}
+export async function runImproveLoopStage(args) {
+    const { ctx, loopRefs, actions, recentErrors, startMs, budgetMs } = args;
+    const eventsCtx = ctx.eventsCtx;
+    const env = prepareImproveLoopEnv(args);
+    let completedCount = 0;
+    let reflectsWithErrorContext = 0;
+    const memoryRefsForInference = new Set();
+    for (const planned of loopRefs) {
+        if (Date.now() - startMs >= budgetMs) {
+            actions.push(recordBudgetExhausted({ planned, loopRefs, completedCount, startMs, eventsCtx }));
+            break;
         }
+        const tally = await processImproveLoopRef(planned, env);
+        // Fold the per-ref tally into run-level state — the passes never touch it.
+        actions.push(...tally.actions);
+        for (const push of tally.recentErrorPushes)
+            pushRecentError(recentErrors, push.originator, push.message);
+        reflectsWithErrorContext += tally.reflectsWithErrorContext;
+        for (const ref of tally.memoryRefsForInference)
+            memoryRefsForInference.add(ref);
+        completedCount++;
+        info(`[improve] ${completedCount}/${loopRefs.length} ${planned.ref}`);
     }
-    return { reflectsWithErrorContext, memoryRefsForInference, gateAutoAcceptedCount, gateAutoAcceptFailedCount };
+    return { reflectsWithErrorContext, memoryRefsForInference };
 }
 export async function runImprovePostLoopStage(args) {
-    const { scope, options, primaryStashDir, actionableRefs, appliedCleanup, cleanupWarnings, memoryRefsForInference, reindexFn, eventsCtx, budgetSignal, improveProfile, consolidationRan, } = args;
+    const { scope, options, primaryStashDir, actionableRefs, appliedCleanup, cleanupWarnings, memoryRefsForInference, reindexFn, eventsCtx, budgetSignal, improveProfile, resolvedPlan, consolidationRan, } = args;
     const allWarnings = [...cleanupWarnings, ...(appliedCleanup?.warnings ?? [])];
     info("[improve] post-loop maintenance starting");
     const maintenanceResult = await runImproveMaintenancePasses({
@@ -608,6 +569,7 @@ export async function runImprovePostLoopStage(args) {
         budgetSignal,
         eventsCtx,
         improveProfile,
+        resolvedPlan,
     });
     let deadUrls;
     if (scope.mode === "all" && primaryStashDir && actionableRefs.length > 0) {
@@ -615,14 +577,28 @@ export async function runImprovePostLoopStage(args) {
             const knowledgeEntries = actionableRefs
                 .filter((r) => {
                 try {
-                    return parseAssetRef(r.ref).type === "knowledge";
+                    return parseRefInput(r.ref).type === "knowledge";
                 }
                 catch {
                     return false;
                 }
             })
                 .slice(0, 10)
-                .map((r) => ({ ref: r.ref, body: "" }));
+                .map((r) => {
+                // The URL scan needs the document body; filePath is pre-resolved on
+                // eligible refs at planning time (#591). Best-effort — an unreadable
+                // or unresolved file contributes no URLs, same as before.
+                let body = "";
+                if (r.filePath) {
+                    try {
+                        body = fs.readFileSync(r.filePath, "utf8");
+                    }
+                    catch {
+                        // best-effort
+                    }
+                }
+                return { ref: r.ref, body };
+            });
             if (knowledgeEntries.length > 0) {
                 info(`[improve] checking URLs in ${knowledgeEntries.length} knowledge refs`);
                 deadUrls = await checkDeadUrls(primaryStashDir, knowledgeEntries);
@@ -633,86 +609,17 @@ export async function runImprovePostLoopStage(args) {
             // best-effort
         }
     }
-    // #609 — recombine / synthesize pass. Whole-corpus cross-episodic
-    // generalization. Runs in the post-loop stage under consolidate.lock (it
-    // reads the consolidated corpus and writes proposals). Opt-in: gated on the
-    // `recombine` process being enabled, whole-stash / type scope (never `ref`),
-    // and not a dry run. Mirrors the proactiveMaintenance opt-in wiring.
-    let recombination;
-    if (primaryStashDir &&
-        improveProfile &&
-        resolveProcessEnabled("recombine", improveProfile) &&
-        scope.mode !== "ref" &&
-        !options.dryRun) {
-        const recombineFn = options.recombineFn ?? akmRecombine;
-        try {
-            recombination = await recombineFn({
-                stashDir: primaryStashDir,
-                config: options.config ?? loadConfig(),
-                improveProfile,
-                ...(options.runId ? { sourceRun: options.runId } : {}),
-                ...(budgetSignal ? { signal: budgetSignal } : {}),
-                eligibilitySource: "recombine",
-                ...(eventsCtx ? { ctx: eventsCtx } : {}),
-                minClusterSize: improveProfile.processes?.recombine?.minClusterSize,
-                maxClustersPerRun: improveProfile.processes?.recombine?.maxClustersPerRun,
-                relatednessSource: improveProfile.processes?.recombine?.relatednessSource,
-                confirmThreshold: improveProfile.processes?.recombine?.confirmThreshold,
-                // #632 — clustering-tuning knobs. UNSET = pre-#632 behaviour.
-                maxClusterSize: improveProfile.processes?.recombine?.maxClusterSize,
-                excludeTags: improveProfile.processes?.recombine?.excludeTags,
-                excludeEntities: improveProfile.processes?.recombine?.excludeEntities,
-            });
-        }
-        catch (e) {
-            allWarnings.push(`recombine: ${String(e)}`);
-        }
-    }
-    // #615 — procedural-compilation pass. Detects recurring successful ordered
-    // action sequences and compiles them into workflow proposals. Opt-in: gated
-    // on the `procedural` process being enabled, whole-stash / type scope (never
-    // `ref`), and not a dry run. Mirrors the recombine opt-in wiring.
-    let proceduralCompilation;
-    if (primaryStashDir &&
-        improveProfile &&
-        resolveProcessEnabled("procedural", improveProfile) &&
-        scope.mode !== "ref" &&
-        !options.dryRun) {
-        const proceduralFn = options.proceduralFn ?? akmProcedural;
-        try {
-            proceduralCompilation = await proceduralFn({
-                stashDir: primaryStashDir,
-                config: options.config ?? loadConfig(),
-                ...(improveProfile ? { improveProfile } : {}),
-                ...(options.runId ? { sourceRun: options.runId } : {}),
-                ...(budgetSignal ? { signal: budgetSignal } : {}),
-                eligibilitySource: "procedural",
-                ...(eventsCtx ? { ctx: eventsCtx } : {}),
-                minRecurrence: improveProfile.processes?.procedural?.minRecurrence,
-                maxProposalsPerRun: improveProfile.processes?.procedural?.maxProposalsPerRun,
-            });
-        }
-        catch (e) {
-            allWarnings.push(`procedural: ${String(e)}`);
-        }
-    }
     // ── R5: collapse/churn detector ────────────────────────────────────────────
-    // One snapshot per QUALIFYING cycle: consolidate processed work and/or
-    // recombine formed clusters. Runs AFTER the maintenance reindex so FTS sees
-    // the post-merge index; one call site covers both passes. Deterministic,
+    // One snapshot per QUALIFYING cycle: consolidate processed work. Runs AFTER
+    // the maintenance reindex so FTS sees the post-merge index. Deterministic,
     // observe-only, fail-open (the orchestrator catches everything) — and inert
     // on the ~9-in-10 default-profile runs that touch no merges.
     let cycleMetrics;
-    const recombineWorked = (recombination?.clustersFormed ?? 0) > 0;
-    if (!options.dryRun && (consolidationRan || recombineWorked)) {
+    if (!options.dryRun && consolidationRan) {
         cycleMetrics = runCollapseDetector({
             runId: options.runId ?? "improve-adhoc",
             ...(improveProfile ? { improveProfile } : {}),
-            pass: consolidationRan && recombineWorked ? "both" : consolidationRan ? "consolidate" : "recombine",
-            // prep+loop gate accepts, PLUS recombine's confirmed-lesson promotions —
-            // recombine churn is the historically observed failure mode and its
-            // promotions never flow through the prep/loop gates.
-            acceptedActions: (args.acceptedActions ?? 0) + (recombination?.lessonsPromoted ?? 0),
+            pass: "consolidate",
             mergeFloorViolations: args.consolidationMergeFloorViolations ?? 0,
             config: options.config ?? loadConfig(),
             ...(eventsCtx ? { eventsCtx } : {}),
@@ -722,8 +629,6 @@ export async function runImprovePostLoopStage(args) {
         allWarnings,
         deadUrls,
         ...(cycleMetrics ? { cycleMetrics } : {}),
-        ...(recombination ? { recombination } : {}),
-        ...(proceduralCompilation ? { proceduralCompilation } : {}),
         ...(maintenanceResult.memoryInference ? { memoryInference: maintenanceResult.memoryInference } : {}),
         ...(maintenanceResult.graphExtraction ? { graphExtraction: maintenanceResult.graphExtraction } : {}),
         ...(maintenanceResult.actions && maintenanceResult.actions.length > 0
@@ -733,368 +638,650 @@ export async function runImprovePostLoopStage(args) {
         graphExtractionDurationMs: maintenanceResult.graphExtractionDurationMs,
         orphansPurged: maintenanceResult.orphansPurged,
         proposalsExpired: maintenanceResult.proposalsExpired,
-        // Consolidation's auto-accept gate counts now accrue in the preparation
-        // stage (#551); post-loop no longer runs an auto-accept gate of its own.
-        gateAutoAcceptedCount: 0,
-        gateAutoAcceptFailedCount: 0,
     };
 }
-// TODO(refactor): mutates the passed-in `allWarnings` array as a hidden side channel. Return warnings in ImproveMaintenanceResult and merge in caller — invasive signature change deferred to next refactor pass.
-// Exported for tests (#584/#585 DB-locking regression coverage); production
-// callers reach it only through akmImprove → runImprovePostLoopStage.
-// TODO(refactor): mutates the passed-in `allWarnings` array as a hidden side channel. Return warnings in ImproveMaintenanceResult and merge in caller — invasive signature change deferred to next refactor pass.
 // Exported for tests (#584/#585 DB-locking regression coverage); production
 // callers reach it only through akmImprove → runImprovePostLoopStage.
 export async function runImproveMaintenancePasses(args) {
-    const { options, primaryStashDir, memoryRefsForInference, allWarnings, reindexFn, consolidationRan, budgetSignal, eventsCtx, improveProfile, } = args;
+    const { options, primaryStashDir, memoryRefsForInference, allWarnings, reindexFn, budgetSignal, eventsCtx } = args;
     if (!primaryStashDir)
         return { memoryInferenceDurationMs: 0, graphExtractionDurationMs: 0 };
+    if (budgetSignal?.aborted)
+        return { memoryInferenceDurationMs: 0, graphExtractionDurationMs: 0 };
     const config = options.config ?? loadConfig();
     const sources = resolveSourceEntries(options.stashDir, config);
     const memoryInferenceFn = options.memoryInferenceFn ?? runMemoryInferencePass;
     const graphExtractionFn = options.graphExtractionFn ?? runGraphExtractionPass;
-    let db;
-    let memoryInference;
-    let graphExtraction;
-    let reindexedAfterInference = false;
-    const actions = [];
-    let memoryInferenceDurationMs = 0;
-    let graphExtractionDurationMs = 0;
-    let orphansPurged = 0;
-    let proposalsExpired = 0;
     const openIndexDb = () => openIndexDatabase(getDbPath(), config.embedding?.dimension ? { embeddingDim: config.embedding.dimension } : undefined);
-    // #584: reindexFn opens its own write handle on the same index.db WAL file.
-    // Holding our handle across that call produced SQLITE_BUSY / "database is
-    // locked" failures in production, so the handle is closed BEFORE every
-    // reindex and reopened after — the fresh handle also sees the post-reindex
-    // state that graph extraction below relies on. The
-    // reopen runs in `finally` so a failed reindex still leaves a usable handle.
+    const dbCell = {};
+    // #584: see the MaintenanceCtx.reindexWithIndexDbReleased doc — close before
+    // every reindex, reopen in `finally` so a failed reindex still leaves a
+    // usable handle in the cell.
     const reindexWithIndexDbReleased = async (stashDir) => {
-        if (db) {
-            closeDatabase(db);
-            db = undefined;
+        if (dbCell.current) {
+            closeDatabase(dbCell.current);
+            dbCell.current = undefined;
         }
         try {
-            await reindexFn({ stashDir });
+            await reindexFn({ stashDir, signal: budgetSignal });
         }
         finally {
-            db = openIndexDb();
+            dbCell.current = openIndexDb();
         }
     };
-    await withIndexWriterLease({ purpose: "improve-maintenance", signal: budgetSignal }, async () => {
-        try {
-            db = openIndexDb();
-            // Memory inference candidate-discovery (post-Item 9 fix from
-            // memory:akm-improve-critical-review-2026-05-20). Previously this pass
-            // was gated on memoryRefsForInference.size > 0 AND passed those refs as a
-            // candidateRefs filter. But memoryRefsForInference is populated from refs
-            // distilled THIS RUN — by the time that happens, those parents are
-            // already split (`inferenceProcessed: true`) and `isPendingMemory` excludes
-            // them. The genuinely-pending parents in the stash never entered the
-            // filter. Result: 0/0/0 for 25 consecutive runs.
-            //
-            // Fix: always run the pass when the feature is enabled; let the pass's
-            // own `collectPendingMemories` + `isPendingMemory` predicate find
-            // candidates from the filesystem-of-truth. The this-run set is still
-            // logged as a hint but no longer used as a filter.
-            const memoryInferenceDisabledByProfile = improveProfile?.processes?.memoryInference?.enabled === false;
-            const minPendingCount = improveProfile?.processes?.memoryInference?.minPendingCount;
-            const pendingBelowMinCount = (() => {
-                if (!primaryStashDir || minPendingCount === undefined || minPendingCount <= 0)
-                    return false;
-                const pending = collectPendingMemories(primaryStashDir).length;
-                if (pending < minPendingCount) {
-                    info(`[improve] memory inference skipped (${pending} pending < minPendingCount ${minPendingCount})`);
-                    return true;
-                }
-                return false;
-            })();
-            if (memoryInferenceDisabledByProfile) {
-                info("[improve] memory inference skipped (disabled by improve profile)");
-            }
-            else if (pendingBelowMinCount) {
-                // skipped — message already emitted above
+    const ctx = {
+        config,
+        sources,
+        primaryStashDir,
+        eventsCtx,
+        budgetSignal,
+        improveProfile: args.improveProfile,
+        resolvedPlan: args.resolvedPlan,
+        memoryInferenceFn,
+        graphExtractionFn,
+        reindexWithIndexDbReleased,
+    };
+    const collected = await withIndexWriterLease({ purpose: "improve-maintenance", signal: budgetSignal }, () => runMaintenancePassesUnderLease(ctx, dbCell, {
+        actionableRefs: args.actionableRefs,
+        memoryRefsForInference,
+        consolidationRan: args.consolidationRan,
+        allWarnings,
+        openIndexDb,
+    }));
+    return {
+        ...(collected.memoryInference ? { memoryInference: collected.memoryInference } : {}),
+        ...(collected.graphExtraction ? { graphExtraction: collected.graphExtraction } : {}),
+        ...(collected.actions.length > 0 ? { actions: collected.actions } : {}),
+        memoryInferenceDurationMs: collected.memoryInferenceDurationMs,
+        graphExtractionDurationMs: collected.graphExtractionDurationMs,
+        orphansPurged: collected.orphansPurged,
+        proposalsExpired: collected.proposalsExpired,
+    };
+}
+/**
+ * The maintenance sequence run under the index-writer lease (formerly the
+ * ~389-line anonymous `withIndexWriterLease` callback): memory inference →
+ * reindex-after-inference → graph extraction → proposal hygiene (orphan purge,
+ * expiration) → retention purges. Each pass returns its results and warnings;
+ * this orchestrator folds warnings into the caller's `allWarnings` sink at the
+ * same points the inline code pushed them.
+ */
+async function runMaintenancePassesUnderLease(ctx, dbCell, args) {
+    const { allWarnings } = args;
+    const actions = [];
+    let reindexedAfterInference = false;
+    try {
+        dbCell.current = args.openIndexDb();
+        const inference = await runMemoryInferenceMaintenancePass(ctx, dbCell, args.memoryRefsForInference);
+        if (inference.action)
+            actions.push(inference.action);
+        allWarnings.push(...inference.warnings);
+        const memoryInference = inference.memoryInference;
+        if (memoryInference && (memoryInference.splitParents > 0 || memoryInference.writtenFacts > 0)) {
+            info("[improve] reindexing after memory inference writes");
+            try {
+                await ctx.reindexWithIndexDbReleased(ctx.primaryStashDir);
+                reindexedAfterInference = true;
+                info("[improve] reindex after memory inference complete");
             }
-            else {
-                const hintRefs = memoryRefsForInference.size;
-                info(hintRefs > 0
-                    ? `[improve] memory inference starting (${hintRefs} hint refs touched this run; pass discovers all pending)`
-                    : "[improve] memory inference starting (discovering pending parents)");
-                const inferenceStart = Date.now();
-                try {
-                    // O-1 (#364): pass budget signal so a hung inference call is cancelled.
-                    memoryInference = await withLlmStage("memory-inference", () => memoryInferenceFn({
-                        config,
-                        sources,
-                        signal: budgetSignal,
-                        db,
-                        reEnrich: false,
-                        onProgress: (event) => {
-                            const current = event.currentRef ? ` ${event.currentRef}` : "";
-                            info(`[improve] memory inference ${event.processed}/${event.total}${current} (written ${event.writtenFacts}, skipped ${event.skippedNoFacts})`);
-                        },
-                    }));
-                    memoryInferenceDurationMs = Date.now() - inferenceStart;
-                    actions.push({ ref: "memory:_inference", mode: "memory-inference", result: memoryInference });
-                    info(`[improve] memory inference complete (${memoryInference.writtenFacts} facts written from ${memoryInference.splitParents} parents)`);
-                }
-                catch (err) {
-                    memoryInferenceDurationMs = Date.now() - inferenceStart;
-                    allWarnings.push(`memory inference failed: ${errMessage(err)}`);
-                }
+            catch (err) {
+                allWarnings.push(`reindex after memory inference failed: ${errMessage(err)}`);
             }
-            if (memoryInference && (memoryInference.splitParents > 0 || memoryInference.writtenFacts > 0)) {
-                info("[improve] reindexing after memory inference writes");
+        }
+        const graph = await runGraphExtractionMaintenancePass(ctx, dbCell, {
+            actionableRefs: args.actionableRefs,
+            memoryRefsForInference: args.memoryRefsForInference,
+            consolidationRan: args.consolidationRan,
+            reindexedAfterInference,
+        });
+        if (graph.action)
+            actions.push(graph.action);
+        allWarnings.push(...graph.warnings);
+        const orphan = runOrphanProposalPurgePass(ctx);
+        allWarnings.push(...orphan.warnings);
+        // #733: orphan-state GC — stamps/clears/(optionally) collects
+        // asset_salience/asset_outcome rows whose ref no longer resolves in
+        // index.db. Needs the SAME already-open index.db handle (dbCell.current)
+        // the passes above share.
+        const stateGc = runOrphanStateGcPass(ctx, dbCell);
+        allWarnings.push(...stateGc.warnings);
+        const expiration = runProposalExpirationPass(ctx);
+        allWarnings.push(...expiration.warnings);
+        allWarnings.push(...runRetentionPurgePass(ctx).warnings);
+        return {
+            memoryInference,
+            graphExtraction: graph.graphExtraction,
+            actions,
+            memoryInferenceDurationMs: inference.durationMs,
+            graphExtractionDurationMs: graph.durationMs,
+            orphansPurged: orphan.orphansPurged,
+            proposalsExpired: expiration.proposalsExpired,
+        };
+    }
+    finally {
+        if (dbCell.current)
+            closeDatabase(dbCell.current);
+    }
+}
+/**
+ * Memory inference candidate-discovery (post-Item 9 fix from
+ * memories/akm-improve-critical-review-2026-05-20). Previously this pass
+ * was gated on memoryRefsForInference.size > 0 AND passed those refs as a
+ * candidateRefs filter. But memoryRefsForInference is populated from refs
+ * distilled THIS RUN — by the time that happens, those parents are
+ * already split (`inferenceProcessed: true`) and `isPendingMemory` excludes
+ * them. The genuinely-pending parents in the stash never entered the
+ * filter. Result: 0/0/0 for 25 consecutive runs.
+ *
+ * Fix: always run the pass when the feature is enabled; let the pass's
+ * own `collectPendingMemories` + `isPendingMemory` predicate find
+ * candidates from the filesystem-of-truth. The this-run set is still
+ * logged as a hint but no longer used as a filter.
+ */
+export async function runMemoryInferenceMaintenancePass(ctx, dbCell, memoryRefsForInference) {
+    const { config, sources, primaryStashDir, budgetSignal, improveProfile, resolvedPlan, memoryInferenceFn } = ctx;
+    const warnings = [];
+    let memoryInference;
+    let durationMs = 0;
+    let action;
+    const memoryInferenceDisabledByProfile = improveProfile?.processes?.memoryInference?.enabled === false;
+    const minPendingCount = improveProfile?.processes?.memoryInference?.minPendingCount;
+    const pendingBelowMinCount = (() => {
+        if (!primaryStashDir || minPendingCount === undefined || minPendingCount <= 0)
+            return false;
+        const pending = collectPendingMemories(primaryStashDir).length;
+        if (pending < minPendingCount) {
+            info(`[improve] memory inference skipped (${pending} pending < minPendingCount ${minPendingCount})`);
+            return true;
+        }
+        return false;
+    })();
+    if (memoryInferenceDisabledByProfile) {
+        info("[improve] memory inference skipped (disabled by improve profile)");
+    }
+    else if (pendingBelowMinCount) {
+        // skipped — message already emitted above
+    }
+    else {
+        const hintRefs = memoryRefsForInference.size;
+        info(hintRefs > 0
+            ? `[improve] memory inference starting (${hintRefs} hint refs touched this run; pass discovers all pending)`
+            : "[improve] memory inference starting (discovering pending parents)");
+        const inferenceStart = Date.now();
+        try {
+            // O-1 (#364): pass budget signal so a hung inference call is cancelled.
+            memoryInference = await withLlmStage("memory-inference", () => memoryInferenceFn({
+                config,
+                ...(resolvedPlan
+                    ? {
+                        llmConfig: resolvedPlan.processes.memoryInference.runner
+                            ? materializeLlmRunnerConnection(resolvedPlan.processes.memoryInference.runner)
+                            : null,
+                    }
+                    : {}),
+                sources,
+                signal: budgetSignal,
+                db: dbCell.current,
+                reEnrich: false,
+                onProgress: (event) => {
+                    const current = event.currentRef ? ` ${event.currentRef}` : "";
+                    info(`[improve] memory inference ${event.processed}/${event.total}${current} (written ${event.writtenFacts}, skipped ${event.skippedNoFacts})`);
+                },
+            }), { engine: resolvedPlan?.processes.memoryInference.runner?.engine, process: "memoryInference" });
+            durationMs = Date.now() - inferenceStart;
+            // Synthetic sentinel ref (ref-grammar decision D-R3): a colon-free
+            // `<domain>/_<marker>` label on the event row, never parsed as an asset
+            // ref. The domain is the asset stash-subdir for asset-scoped sentinels
+            // (`memories/…`) and the subsystem name for maintenance/artifact sentinels
+            // (`graph/…`, `events/…`, `proposals/…`, `health/…`, …). Readers match the
+            // event by `eventType`, never by this string.
+            action = { ref: "memories/_inference", mode: "memory-inference", result: memoryInference };
+            info(`[improve] memory inference complete (${memoryInference.writtenFacts} facts written from ${memoryInference.splitParents} parents)`);
+        }
+        catch (err) {
+            durationMs = Date.now() - inferenceStart;
+            warnings.push(`memory inference failed: ${errMessage(err)}`);
+        }
+    }
+    return { memoryInference, durationMs, action, warnings };
+}
+/**
+ * Graph-extraction maintenance pass.
+ *
+ * INVARIANT: graph extraction normally runs only on files touched by
+ * actionable refs (candidatePaths). Full-corpus scans are opt-in via
+ * profile.processes.graphExtraction.fullScan = true (used by the
+ * `graph-refresh` built-in profile and its weekly scheduled task).
+ * The empty-Set fallback is intentional when no refs were touched —
+ * the extractor's filter rejects every file and returns empty, keeping
+ * the pass invoked so the action is recorded and tests stay exercised.
+ */
+export async function runGraphExtractionMaintenancePass(ctx, dbCell, args) {
+    const { config, sources, primaryStashDir, budgetSignal, improveProfile, resolvedPlan, graphExtractionFn } = ctx;
+    const warnings = [];
+    let graphExtraction;
+    let durationMs = 0;
+    let action;
+    let reindexedAfterInference = args.reindexedAfterInference;
+    const graphEnabled = resolvedPlan ? true : isProcessEnabled("index", "graph_extraction", config);
+    const graphExtractionDisabledByProfile = improveProfile?.processes?.graphExtraction?.enabled === false;
+    const graphExtractionFullScan = improveProfile?.processes?.graphExtraction?.fullScan === true;
+    // #624 P2: optional incremental high-signal-first cap. Unset = process all
+    // eligible (byte-identical to today; no ranking/slice).
+    const graphExtractionTopN = improveProfile?.processes?.graphExtraction?.topN;
+    const graphExtractionIncludeTypes = improveProfile?.processes?.graphExtraction?.includeTypes ?? [
+        ...DEFAULT_GRAPH_EXTRACTION_INCLUDE_TYPES,
+    ];
+    const graphExtractionBatchSize = improveProfile?.processes?.graphExtraction?.batchSize ?? DEFAULT_GRAPH_EXTRACTION_BATCH_SIZE;
+    // Build the set of refs actually touched this run.
+    const touchedRefs = new Set();
+    for (const r of args.actionableRefs)
+        touchedRefs.add(r.ref);
+    for (const r of args.memoryRefsForInference)
+        touchedRefs.add(r);
+    if (graphExtractionDisabledByProfile) {
+        info("[improve] graph extraction skipped (disabled by improve profile)");
+    }
+    else if (sources.length > 0 && graphEnabled) {
+        info(`[improve] graph extraction starting${graphExtractionFullScan ? " (full-corpus scan)" : ""}`);
+        const extractionStart = Date.now();
+        try {
+            // D9: if consolidation ran but memory inference did not reindex, force a reindex
+            // so graph extraction sees current DB state after consolidation writes.
+            if (args.consolidationRan && !reindexedAfterInference) {
+                info("[improve] reindexing after consolidation (graph extraction needs current state)");
                 try {
-                    await reindexWithIndexDbReleased(primaryStashDir);
+                    await ctx.reindexWithIndexDbReleased(primaryStashDir);
                     reindexedAfterInference = true;
-                    info("[improve] reindex after memory inference complete");
+                    info("[improve] reindex after consolidation complete");
                 }
                 catch (err) {
-                    allWarnings.push(`reindex after memory inference failed: ${errMessage(err)}`);
+                    warnings.push(`reindex after consolidation failed: ${errMessage(err)}`);
                 }
             }
-            const graphEnabled = isProcessEnabled("index", "graph_extraction", config);
-            const graphExtractionDisabledByProfile = improveProfile?.processes?.graphExtraction?.enabled === false;
-            const graphExtractionFullScan = improveProfile?.processes?.graphExtraction?.fullScan === true;
-            // #624 P2: optional incremental high-signal-first cap. Unset = process all
-            // eligible (byte-identical to today; no ranking/slice).
-            const graphExtractionTopN = improveProfile?.processes?.graphExtraction?.topN;
-            // Build the set of refs actually touched this run.
-            const touchedRefs = new Set();
-            for (const r of args.actionableRefs)
-                touchedRefs.add(r.ref);
-            for (const r of memoryRefsForInference)
-                touchedRefs.add(r);
-            // INVARIANT: graph extraction normally runs only on files touched by
-            // actionable refs (candidatePaths). Full-corpus scans are opt-in via
-            // profile.processes.graphExtraction.fullScan = true (used by the
-            // `graph-refresh` built-in profile and its weekly scheduled task).
-            // The empty-Set fallback is intentional when no refs were touched —
-            // the extractor's filter rejects every file and returns empty, keeping
-            // the pass invoked so the action is recorded and tests stay exercised.
-            if (graphExtractionDisabledByProfile) {
-                info("[improve] graph extraction skipped (disabled by improve profile)");
-            }
-            else if (sources.length > 0 && graphEnabled) {
-                info(`[improve] graph extraction starting${graphExtractionFullScan ? " (full-corpus scan)" : ""}`);
-                const extractionStart = Date.now();
-                try {
-                    // D9: if consolidation ran but memory inference did not reindex, force a reindex
-                    // so graph extraction sees current DB state after consolidation writes.
-                    if (consolidationRan && !reindexedAfterInference) {
-                        info("[improve] reindexing after consolidation (graph extraction needs current state)");
-                        try {
-                            await reindexWithIndexDbReleased(primaryStashDir);
-                            reindexedAfterInference = true;
-                            info("[improve] reindex after consolidation complete");
-                        }
-                        catch (err) {
-                            allWarnings.push(`reindex after consolidation failed: ${errMessage(err)}`);
-                        }
-                    }
-                    // #584: no close/reopen needed here — reindexWithIndexDbReleased
-                    // already swapped in a fresh post-reindex handle.
-                    // Resolve touched refs to absolute file paths. Skipped for fullScan
-                    // (candidatePaths stays undefined → extractor processes all files).
-                    let candidatePaths;
-                    if (!graphExtractionFullScan) {
-                        candidatePaths = new Set();
-                        if (primaryStashDir && touchedRefs.size > 0) {
-                            const writableDirSet = new Set(getWritableStashDirs(primaryStashDir).map((d) => path.resolve(d)));
-                            const resolved = await Promise.all([...touchedRefs].map((ref) => findAssetFilePath(ref, primaryStashDir, writableDirSet).catch(() => null)));
-                            for (const p of resolved) {
-                                if (typeof p === "string" && p.length > 0)
-                                    candidatePaths.add(p);
-                            }
-                        }
+            // #584: no close/reopen needed here — reindexWithIndexDbReleased
+            // already swapped in a fresh post-reindex handle.
+            // Resolve touched refs to absolute file paths. Skipped for fullScan
+            // (candidatePaths stays undefined → extractor processes all files).
+            let candidatePaths;
+            if (!graphExtractionFullScan) {
+                candidatePaths = new Set();
+                if (primaryStashDir && touchedRefs.size > 0) {
+                    const writableDirSet = new Set(getWritableStashDirs(primaryStashDir).map((d) => path.resolve(d)));
+                    const resolved = await Promise.all([...touchedRefs].map((ref) => findAssetFilePath(ref, primaryStashDir, writableDirSet).catch(() => null)));
+                    for (const p of resolved) {
+                        if (typeof p === "string" && p.length > 0)
+                            candidatePaths.add(p);
                     }
-                    const progressHandler = (event) => {
-                        const current = event.currentPath ? ` ${path.basename(event.currentPath)}` : "";
-                        info(`[improve] graph extraction ${event.processed}/${event.total}${current} (extracted ${event.extracted}, entities ${event.totalEntities}, relations ${event.totalRelations})`);
-                    };
-                    // O-1 (#364): pass budget signal so a hung graph extraction call is cancelled.
-                    graphExtraction = await withLlmStage("graph-extraction", () => graphExtractionFn({
-                        config,
-                        sources,
-                        signal: budgetSignal,
-                        db,
-                        reEnrich: false,
-                        onProgress: progressHandler,
-                        options: { candidatePaths, ...(graphExtractionTopN != null ? { topN: graphExtractionTopN } : {}) },
-                    }));
-                    graphExtractionDurationMs = Date.now() - extractionStart;
-                    actions.push({ ref: "graph:_artifact", mode: "graph-extraction", result: graphExtraction });
-                    info(`[improve] graph extraction complete (${graphExtraction.quality.extractedFiles} files, ${graphExtraction.quality.entityCount} entities, ${graphExtraction.quality.relationCount} relations)`);
                 }
-                catch (err) {
-                    graphExtractionDurationMs = Date.now() - extractionStart;
-                    allWarnings.push(`graph extraction failed: ${errMessage(err)}`);
-                }
-            }
-            else if (sources.length > 0 && !graphEnabled) {
-                info("[improve] graph extraction skipped (features.index.graph_extraction is disabled)");
             }
-            // Orphan proposal purge — reject pending reflect proposals whose target
-            // asset no longer exists on disk. Runs after graph extraction so newly
-            // promoted assets from accept flows during this run are already present.
-            if (primaryStashDir) {
-                try {
-                    const purgeResult = purgeOrphanProposals(primaryStashDir, sources.map((s) => s.path));
-                    orphansPurged = purgeResult.rejected;
-                    if (purgeResult.rejected > 0) {
-                        info(`[improve] orphan purge: ${purgeResult.rejected}/${purgeResult.checked} orphaned proposals rejected (${purgeResult.durationMs}ms)`);
+            const progressHandler = (event) => {
+                const current = event.currentPath ? ` ${path.basename(event.currentPath)}` : "";
+                info(`[improve] graph extraction ${event.processed}/${event.total}${current} (extracted ${event.extracted}, entities ${event.totalEntities}, relations ${event.totalRelations})`);
+            };
+            // O-1 (#364): pass budget signal so a hung graph extraction call is cancelled.
+            graphExtraction = await withLlmStage("graph-extraction", () => graphExtractionFn({
+                config,
+                ...(resolvedPlan
+                    ? {
+                        llmConfig: resolvedPlan.processes.graphExtraction.runner
+                            ? materializeLlmRunnerConnection(resolvedPlan.processes.graphExtraction.runner)
+                            : null,
                     }
-                    appendEvent({
-                        eventType: "proposal_orphan_purge",
-                        ref: "proposals:_orphan-purge",
-                        metadata: {
-                            checked: purgeResult.checked,
-                            rejected: purgeResult.rejected,
-                            durationMs: purgeResult.durationMs,
-                            byType: purgeResult.byType,
-                            orphans: purgeResult.orphans.map((o) => o.ref),
-                        },
-                    }, eventsCtx);
+                    : {}),
+                sources,
+                signal: budgetSignal,
+                db: dbCell.current,
+                reEnrich: false,
+                onProgress: progressHandler,
+                options: {
+                    candidatePaths,
+                    includeTypes: graphExtractionIncludeTypes,
+                    batchSize: graphExtractionBatchSize,
+                    ...(graphExtractionTopN != null ? { topN: graphExtractionTopN } : {}),
+                },
+            }), { engine: resolvedPlan?.processes.graphExtraction.runner?.engine, process: "graphExtraction" });
+            durationMs = Date.now() - extractionStart;
+            // Synthetic sentinel ref (D-R3): `graph` has no asset stash-subdir, so the
+            // colon-free `graph/_artifact` names the subsystem, per the sentinel
+            // convention documented at the memory-inference writer above.
+            action = { ref: "graph/_artifact", mode: "graph-extraction", result: graphExtraction };
+            info(`[improve] graph extraction complete (${graphExtraction.quality.extractedFiles} files, ${graphExtraction.quality.entityCount} entities, ${graphExtraction.quality.relationCount} relations)`);
+        }
+        catch (err) {
+            durationMs = Date.now() - extractionStart;
+            warnings.push(`graph extraction failed: ${errMessage(err)}`);
+        }
+    }
+    else if (sources.length > 0 && !graphEnabled) {
+        info("[improve] graph extraction skipped (features.index.graph_extraction is disabled)");
+    }
+    return { graphExtraction, durationMs, action, warnings };
+}
+/**
+ * Orphan proposal purge — reject pending reflect proposals whose target
+ * asset no longer exists on disk. Runs after graph extraction so newly
+ * promoted assets from accept flows during this run are already present.
+ */
+function runOrphanProposalPurgePass(ctx) {
+    const { primaryStashDir, sources, eventsCtx } = ctx;
+    const warnings = [];
+    let orphansPurged = 0;
+    try {
+        const purgeResult = purgeOrphanProposals(primaryStashDir, sources.map((s) => s.path));
+        orphansPurged = purgeResult.rejected;
+        if (purgeResult.rejected > 0) {
+            info(`[improve] orphan purge: ${purgeResult.rejected}/${purgeResult.checked} orphaned proposals rejected (${purgeResult.durationMs}ms)`);
+        }
+        appendEvent({
+            eventType: "proposal_orphan_purge",
+            ref: "proposals/_orphan-purge",
+            metadata: {
+                checked: purgeResult.checked,
+                rejected: purgeResult.rejected,
+                durationMs: purgeResult.durationMs,
+                byType: purgeResult.byType,
+                orphans: purgeResult.orphans.map((o) => o.ref),
+            },
+        }, eventsCtx);
+    }
+    catch (err) {
+        warnings.push(`orphan purge failed: ${errMessage(err)}`);
+    }
+    return { orphansPurged, warnings };
+}
+/**
+ * Phase 6B (Advantage D6b): expire pending proposals that have aged past
+ * the retention window. Runs AFTER orphan purge so we never double-archive
+ * a proposal that orphan-purge already moved. `expireStaleProposals` emits
+ * its own per-proposal `proposal_expired` events; we additionally emit a
+ * single roll-up event here for parity with the orphan-purge surface.
+ */
+function runProposalExpirationPass(ctx) {
+    const { primaryStashDir, config, eventsCtx } = ctx;
+    const warnings = [];
+    let proposalsExpired = 0;
+    try {
+        const expireResult = expireStaleProposals(primaryStashDir, config);
+        proposalsExpired = expireResult.expired;
+        if (expireResult.expired > 0) {
+            info(`[improve] expiration: ${expireResult.expired}/${expireResult.checked} pending proposals expired ` +
+                `(retention=${expireResult.retentionDays}d, ${expireResult.durationMs}ms)`);
+        }
+        appendEvent({
+            eventType: "proposal_expiration_pass",
+            ref: "proposals/_expiration",
+            metadata: {
+                checked: expireResult.checked,
+                expired: expireResult.expired,
+                durationMs: expireResult.durationMs,
+                retentionDays: expireResult.retentionDays,
+                expiredProposals: expireResult.expiredProposals,
+            },
+        }, eventsCtx);
+    }
+    catch (err) {
+        warnings.push(`proposal expiration failed: ${errMessage(err)}`);
+    }
+    return { proposalsExpired, warnings };
+}
+/**
+ * Fix #2 (observability 0.8.0): trim the events table in state.db so it
+ * doesn't grow unbounded. `akm health` writes a `health_probe` row on every
+ * invocation, and every command surface emits at least one event besides —
+ * without this trim, state.db is a permanent append-only log. Config key
+ * `improve.eventRetentionDays` (default 90, set 0 to disable) controls the
+ * window. The purge runs against state.db (a different SQLite file from
+ * the index handle the other passes use).
+ */
+export function runRetentionPurgePass(ctx) {
+    const { config, eventsCtx } = ctx;
+    const warnings = [];
+    const retentionDays = typeof config.improve?.eventRetentionDays === "number" ? config.improve.eventRetentionDays : 90;
+    if (retentionDays > 0) {
+        // #585: reuse the long-lived eventsCtx.db connection when akmImprove
+        // opened one — opening a second state.db write connection while
+        // eventsDb is still live made two simultaneous writers contend on the
+        // same WAL file ("database is locked"). Only the eventsCtx.dbPath
+        // fallback path (state.db failed to open up-front) opens — and then
+        // owns and closes — its own handle. C2 still holds: the fallback uses
+        // the boundary-pinned path, never a live `process.env` re-read.
+        try {
+            withStateDb((stateDb) => {
+                const purgedCount = purgeOldEvents(stateDb, retentionDays);
+                if (purgedCount > 0) {
+                    info(`[improve] events purge: ${purgedCount} event(s) older than ${retentionDays}d removed from state.db`);
                 }
-                catch (err) {
-                    allWarnings.push(`orphan purge failed: ${errMessage(err)}`);
+                appendEvent({
+                    eventType: "events_purged",
+                    ref: "events/_purge",
+                    metadata: { purgedCount, retentionDays },
+                }, eventsCtx);
+                // improve_runs uses the same retention window as events — both are
+                // observability/audit data, both grow append-only, both have a
+                // dedicated purge helper. Mirroring the events purge here means a
+                // single retention knob (improve.eventRetentionDays) governs both.
+                const improveRunsPurged = purgeOldImproveRuns(stateDb, retentionDays);
+                if (improveRunsPurged > 0) {
+                    info(`[improve] improve_runs purge: ${improveRunsPurged} run(s) older than ${retentionDays}d removed from state.db`);
                 }
-                // Phase 6B (Advantage D6b): expire pending proposals that have aged past
-                // the retention window. Runs AFTER orphan purge so we never double-archive
-                // a proposal that orphan-purge already moved. `expireStaleProposals` emits
-                // its own per-proposal `proposal_expired` events; we additionally emit a
-                // single roll-up event here for parity with the orphan-purge surface.
-                try {
-                    const expireResult = expireStaleProposals(primaryStashDir, config);
-                    proposalsExpired = expireResult.expired;
-                    if (expireResult.expired > 0) {
-                        info(`[improve] expiration: ${expireResult.expired}/${expireResult.checked} pending proposals expired ` +
-                            `(retention=${expireResult.retentionDays}d, ${expireResult.durationMs}ms)`);
-                    }
+                appendEvent({
+                    eventType: "improve_runs_purged",
+                    ref: "improve_runs/_purge",
+                    metadata: { purgedCount: improveRunsPurged, retentionDays },
+                }, eventsCtx);
+                // R5: improve_cycle_metrics has its OWN retention window
+                // (default 365d — a slow collapse needs a longer trend than
+                // the 90d events window). canary_queries rows are never purged.
+                const cycleRetention = config.improve?.collapseDetector?.retentionDays ?? CYCLE_METRICS_RETENTION_DAYS;
+                const cycleMetricsPurged = purgeOldCycleMetrics(stateDb, cycleRetention);
+                if (cycleMetricsPurged > 0) {
+                    info(`[improve] cycle-metrics purge: ${cycleMetricsPurged} row(s) older than ${cycleRetention}d removed from state.db`);
                     appendEvent({
-                        eventType: "proposal_expiration_pass",
-                        ref: "proposals:_expiration",
-                        metadata: {
-                            checked: expireResult.checked,
-                            expired: expireResult.expired,
-                            durationMs: expireResult.durationMs,
-                            retentionDays: expireResult.retentionDays,
-                            expiredProposals: expireResult.expiredProposals,
-                        },
+                        // Dedicated type (mirrors improve_runs_purged) so consumers
+                        // never have to disambiguate purge targets via the ref string.
+                        eventType: "improve_cycle_metrics_purged",
+                        ref: "improve_cycle_metrics/_purge",
+                        metadata: { purgedCount: cycleMetricsPurged, retentionDays: cycleRetention },
                     }, eventsCtx);
                 }
-                catch (err) {
-                    allWarnings.push(`proposal expiration failed: ${errMessage(err)}`);
-                }
-            }
-            // Fix #2 (observability 0.8.0): trim the events table in state.db so it
-            // doesn't grow unbounded. `akm health` writes a `health_probe` row on every
-            // invocation, and every command surface emits at least one event besides —
-            // without this trim, state.db is a permanent append-only log. Config key
-            // `improve.eventRetentionDays` (default 90, set 0 to disable) controls the
-            // window. The purge runs against state.db (a different SQLite file from
-            // the index `db` above).
-            {
-                const retentionDays = typeof config.improve?.eventRetentionDays === "number" ? config.improve.eventRetentionDays : 90;
-                if (retentionDays > 0) {
-                    // #585: reuse the long-lived eventsCtx.db connection when akmImprove
-                    // opened one — opening a second state.db write connection while
-                    // eventsDb is still live made two simultaneous writers contend on the
-                    // same WAL file ("database is locked"). Only the eventsCtx.dbPath
-                    // fallback path (state.db failed to open up-front) opens — and then
-                    // owns and closes — its own handle. C2 still holds: the fallback uses
-                    // the boundary-pinned path, never a live `process.env` re-read.
-                    try {
-                        withStateDb((stateDb) => {
-                            const purgedCount = purgeOldEvents(stateDb, retentionDays);
-                            if (purgedCount > 0) {
-                                info(`[improve] events purge: ${purgedCount} event(s) older than ${retentionDays}d removed from state.db`);
-                            }
-                            appendEvent({
-                                eventType: "events_purged",
-                                ref: "events:_purge",
-                                metadata: { purgedCount, retentionDays },
-                            }, eventsCtx);
-                            // improve_runs uses the same retention window as events — both are
-                            // observability/audit data, both grow append-only, both have a
-                            // dedicated purge helper. Mirroring the events purge here means a
-                            // single retention knob (improve.eventRetentionDays) governs both.
-                            const improveRunsPurged = purgeOldImproveRuns(stateDb, retentionDays);
-                            if (improveRunsPurged > 0) {
-                                info(`[improve] improve_runs purge: ${improveRunsPurged} run(s) older than ${retentionDays}d removed from state.db`);
-                            }
-                            appendEvent({
-                                eventType: "improve_runs_purged",
-                                ref: "improve_runs:_purge",
-                                metadata: { purgedCount: improveRunsPurged, retentionDays },
-                            }, eventsCtx);
-                            // R5: improve_cycle_metrics has its OWN retention window
-                            // (default 365d — a slow collapse needs a longer trend than
-                            // the 90d events window). canary_queries rows are never purged.
-                            const cycleRetention = config.improve?.collapseDetector?.retentionDays ?? CYCLE_METRICS_RETENTION_DAYS;
-                            const cycleMetricsPurged = purgeOldCycleMetrics(stateDb, cycleRetention);
-                            if (cycleMetricsPurged > 0) {
-                                info(`[improve] cycle-metrics purge: ${cycleMetricsPurged} row(s) older than ${cycleRetention}d removed from state.db`);
-                                appendEvent({
-                                    // Dedicated type (mirrors improve_runs_purged) so consumers
-                                    // never have to disambiguate purge targets via the ref string.
-                                    eventType: "improve_cycle_metrics_purged",
-                                    ref: "improve_cycle_metrics:_purge",
-                                    metadata: { purgedCount: cycleMetricsPurged, retentionDays: cycleRetention },
-                                }, eventsCtx);
-                            }
-                        }, { path: eventsCtx?.dbPath, borrowed: eventsCtx?.db });
-                    }
-                    catch (err) {
-                        allWarnings.push(`events purge failed: ${errMessage(err)}`);
-                    }
-                    // task_logs in logs.db (#579) shares the same retention window as
-                    // events/improve_runs — all three are observability data governed by
-                    // the single improve.eventRetentionDays knob. Separate try/finally
-                    // because logs.db is a different file: a locked/missing logs.db must
-                    // not block the state.db purges above.
-                    let logsDb;
-                    try {
-                        logsDb = openLogsDatabase();
-                        const taskLogsPurged = purgeOldTaskLogs(logsDb, retentionDays);
-                        if (taskLogsPurged > 0) {
-                            info(`[improve] task_logs purge: ${taskLogsPurged} log line(s) older than ${retentionDays}d removed from logs.db`);
-                        }
-                        appendEvent({
-                            eventType: "task_logs_purged",
-                            ref: "task_logs:_purge",
-                            metadata: { purgedCount: taskLogsPurged, retentionDays },
-                        }, eventsCtx);
-                    }
-                    catch (err) {
-                        allWarnings.push(`task_logs purge failed: ${errMessage(err)}`);
-                    }
-                    finally {
-                        if (logsDb) {
-                            try {
-                                logsDb.close();
-                            }
-                            catch {
-                                // best-effort
-                            }
-                        }
-                    }
-                }
+            }, { path: eventsCtx?.dbPath, borrowed: eventsCtx?.db });
+        }
+        catch (err) {
+            warnings.push(`events purge failed: ${errMessage(err)}`);
+        }
+        // task_logs in logs.db (#579) shares the same retention window as
+        // events/improve_runs — all three are observability data governed by
+        // the single improve.eventRetentionDays knob. Separate try/finally
+        // because logs.db is a different file: a locked/missing logs.db must
+        // not block the state.db purges above.
+        let logsDb;
+        try {
+            logsDb = openLogsDatabase();
+            const taskLogsPurged = purgeOldTaskLogs(logsDb, retentionDays);
+            if (taskLogsPurged > 0) {
+                info(`[improve] task_logs purge: ${taskLogsPurged} log line(s) older than ${retentionDays}d removed from logs.db`);
             }
+            appendEvent({
+                eventType: "task_logs_purged",
+                ref: "task_logs/_purge",
+                metadata: { purgedCount: taskLogsPurged, retentionDays },
+            }, eventsCtx);
+        }
+        catch (err) {
+            warnings.push(`task_logs purge failed: ${errMessage(err)}`);
         }
         finally {
-            if (db)
-                closeDatabase(db);
+            if (logsDb) {
+                try {
+                    logsDb.close();
+                }
+                catch {
+                    // best-effort
+                }
+            }
         }
-    });
-    return {
-        ...(memoryInference ? { memoryInference } : {}),
-        ...(graphExtraction ? { graphExtraction } : {}),
-        ...(actions.length > 0 ? { actions } : {}),
-        memoryInferenceDurationMs,
-        graphExtractionDurationMs,
-        orphansPurged,
-        proposalsExpired,
-    };
+    }
+    return { warnings };
+}
+// ── #733 — orphan-state GC pass (Workstream C) ──────────────────────────────
+//
+// Deliberately lean: one maintenance pass, one additive migration (021), one
+// event type (asset_state_gc), one config gate (improve.stateGc.collect,
+// default false). See docs/architecture/specs/0.9.0-close-out-plan.md
+// Workstream C for the full design rationale. No quarantine archive, no
+// circuit breaker, no health-advisory plumbing, no new tables.
+/**
+ * Grace window (ms) before an unresolved `asset_salience` / `asset_outcome`
+ * row becomes delete-eligible — only when `improve.stateGc.collect` is true.
+ * A named constant, not a config knob (owner ruling — see the close-out
+ * plan's Workstream C). Mirrors `TXN_SWEEP_GRACE_MS` (src/core/fs-txn.ts:298).
+ */
+export const STATE_GC_GRACE_MS = daysToMs(7);
+/**
+ * Resolve one state-table's stored `asset_ref` against the live index.
+ *
+ * "ref not present in entries.item_ref" is the authoritative-deletion
+ * predicate (see the pass doc comment below), so this is a thin wrapper
+ * around the same single-ref probe the rest of improve uses
+ * (`getEntryByRef`, index-entries-repository.ts) — which already resolves
+ * both storage spellings a write can produce (`salienceWriteKey`/
+ * `outcomeWriteKey` = `itemRef ?? ref`): an exact bundle-qualified item_ref,
+ * or a bare conceptId matched by suffix across all bundles.
+ *
+ * On top of that, falls back to the BARE conceptId form (`bareImproveRef` —
+ * the same primitive `preparation.ts`'s `normalizeStoredKey` map is built
+ * from via `improveStateReadRefs`) when the stored ref carries a bundle
+ * prefix that no longer matches exactly. This is the legacy-spelling
+ * normalization trap: a naive `asset_ref NOT IN (SELECT item_ref FROM
+ * entries)` would treat a live asset whose row predates bundle-qualification
+ * (or whose bundle prefix is stale) as an orphan and delete it. Preferring
+ * "never delete a live row" over "never miss a genuinely dead one" mirrors
+ * `getEntryByRef`'s own bare-conceptId suffix-match trade-off.
+ */
+function isStateRefLive(indexDb, storedRef) {
+    if (getEntryByRef(indexDb, storedRef) !== null)
+        return true;
+    const bare = bareImproveRef(storedRef);
+    return bare !== storedRef && getEntryByRef(indexDb, bare) !== null;
+}
+/**
+ * Sweep ONE state table: stamp refs that just went unresolved, clear refs
+ * that resolved again, and — only when `collect` is true — delete rows whose
+ * `missing_since` is older than {@link STATE_GC_GRACE_MS}. `pending` is a
+ * point-in-time snapshot taken AFTER stamp/clear/delete (re-queried, not
+ * accumulated), so it reflects the current backlog rather than this run's
+ * delta — "every run emits the counts either way, so live data accumulates
+ * proof" (close-out plan, Workstream C).
+ */
+function gcOneStateTable(args) {
+    const { refRows, indexDb, now, collect, stamp, clear, deleteOlderThan, countPending } = args;
+    const toStamp = [];
+    const toClear = [];
+    for (const row of refRows) {
+        const live = isStateRefLive(indexDb, row.asset_ref);
+        if (!live && row.missing_since == null)
+            toStamp.push(row.asset_ref);
+        else if (live && row.missing_since != null)
+            toClear.push(row.asset_ref);
+    }
+    if (toStamp.length > 0)
+        stamp(toStamp, now);
+    if (toClear.length > 0)
+        clear(toClear);
+    const collected = collect ? deleteOlderThan(now - STATE_GC_GRACE_MS) : 0;
+    const pending = countPending();
+    return { pending, collected };
+}
+/**
+ * Orphan-state GC — #733 (Workstream C). For each of the two per-asset state
+ * tables (`asset_salience`, `asset_outcome`), stamps `missing_since` on refs
+ * that no longer resolve against `entries.item_ref` in index.db, clears the
+ * stamp on refs that resolve again, and — only when `improve.stateGc.collect`
+ * is true — deletes rows whose stamp is older than {@link STATE_GC_GRACE_MS}.
+ *
+ * "ref not present in entries.item_ref" IS the authoritative-deletion
+ * predicate: "absent ≠ deleted" is inherited from the indexer, not
+ * re-implemented here — an incomplete or failed source scan preserves that
+ * source's last-known-good `entries` rows (indexer.ts ~1195-1199), and
+ * mass-wipe is already gated upstream (`preserveExistingIndex` +
+ * `fullDelete && scanComplete`). A temporarily unreachable source therefore
+ * never surfaces candidates; no separate scan-status tracking is needed.
+ *
+ * Runs under the SAME index-writer lease / borrowed-state.db-connection
+ * discipline as the neighboring maintenance passes: `dbCell.current` supplies
+ * the already-open index.db handle (#584), and state.db access goes through
+ * `withStateDb(..., { borrowed: eventsCtx?.db })` so this never opens a
+ * second live writer alongside a long-lived `eventsCtx.db` connection — see
+ * the #585 comment on {@link runRetentionPurgePass}'s events-purge call for
+ * why that matters ("database is locked").
+ *
+ * Exported for direct test coverage (tests/integration/commands/improve/
+ * state-gc.test.ts), mirroring the `runMemoryInferenceMaintenancePass` /
+ * `runGraphExtractionMaintenancePass` / `runRetentionPurgePass` precedent;
+ * production callers reach it only through `runMaintenancePassesUnderLease`.
+ */
+export function runOrphanStateGcPass(ctx, dbCell) {
+    const { eventsCtx, config } = ctx;
+    const warnings = [];
+    const indexDb = dbCell.current;
+    if (!indexDb) {
+        warnings.push("orphan state GC skipped: no index.db handle available");
+        return { pending: 0, collected: 0, warnings };
+    }
+    const collect = config.improve?.stateGc?.collect === true;
+    const now = Date.now();
+    let pending = 0;
+    let collected = 0;
+    try {
+        withStateDb((stateDb) => {
+            const salienceResult = gcOneStateTable({
+                refRows: listAssetSalienceMissingState(stateDb),
+                indexDb,
+                now,
+                collect,
+                stamp: (refs, ts) => stampAssetSalienceMissing(stateDb, refs, ts),
+                clear: (refs) => clearAssetSalienceMissing(stateDb, refs),
+                deleteOlderThan: (cutoffMs) => deleteAssetSalienceMissingBefore(stateDb, cutoffMs),
+                countPending: () => countAssetSalienceMissing(stateDb),
+            });
+            const outcomeResult = gcOneStateTable({
+                refRows: listAssetOutcomeMissingState(stateDb),
+                indexDb,
+                now,
+                collect,
+                stamp: (refs, ts) => stampAssetOutcomeMissing(stateDb, refs, ts),
+                clear: (refs) => clearAssetOutcomeMissing(stateDb, refs),
+                deleteOlderThan: (cutoffMs) => deleteAssetOutcomeMissingBefore(stateDb, cutoffMs),
+                countPending: () => countAssetOutcomeMissing(stateDb),
+            });
+            // Table-name-shaped keys ("salience"/"outcome", not the guarded
+            // "asset_salience"/"asset_outcome" table names) — this file sits
+            // outside src/storage/repositories/**, where the state-table-sql
+            // lint rule (#672) forbids naming those tables even in a log string
+            // or an object key, not just in raw SQL.
+            const byTable = { salience: salienceResult, outcome: outcomeResult };
+            pending = salienceResult.pending + outcomeResult.pending;
+            collected = salienceResult.collected + outcomeResult.collected;
+            if (pending > 0 || collected > 0) {
+                info(`[improve] orphan state GC: ${pending} pending, ${collected} collected ` +
+                    `(salience ${salienceResult.pending}/${salienceResult.collected}, ` +
+                    `outcome ${outcomeResult.pending}/${outcomeResult.collected})`);
+                // #733 — asset_state_gc reports the current per-table backlog
+                // snapshot (`pending`) plus this run's deletions (`collected`);
+                // emitted only when there is something to report (mirrors the
+                // rekey script's no-op-stays-silent precedent) so a perpetually
+                // clean stash never accumulates events.
+                appendEvent({
+                    eventType: "asset_state_gc",
+                    ref: "asset_state/_gc",
+                    metadata: { pending, collected, byTable },
+                }, eventsCtx);
+            }
+        }, { path: eventsCtx?.dbPath, borrowed: eventsCtx?.db });
+    }
+    catch (err) {
+        warnings.push(`orphan state GC failed: ${errMessage(err)}`);
+    }
+    return { pending, collected, warnings };
 }