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

package/dist/commands/improve/preparation.js

@@ -3,196 +3,104 @@
 // 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 { makeBundleRef } from "../../core/asset/asset-ref.js";
 import { parseFrontmatter } from "../../core/asset/frontmatter.js";
+import { typeNameFromConceptId } from "../../core/asset/resolve-ref.js";
 import { daysToMs } from "../../core/common.js";
-import { getDefaultLlmConfig, loadConfig } from "../../core/config/config.js";
-import { rethrowIfTestIsolationError } from "../../core/errors.js";
+import { loadConfig } from "../../core/config/config.js";
+import { ConfigError, rethrowIfTestIsolationError } from "../../core/errors.js";
 import { appendEvent, readEvents } from "../../core/events.js";
 import { openStateDatabase, withStateDb } from "../../core/state-db.js";
 import { info, warn } from "../../core/warn.js";
-import { closeDatabase, getRetrievalCounts, getZeroResultSearches, openExistingDatabase } from "../../indexer/db/db.js";
 import { countUsageEventsByType } from "../../indexer/usage/usage-events.js";
+import { materializeLlmRunnerConnection } from "../../integrations/agent/runner.js";
 import { getAvailableHarnesses } from "../../integrations/session-logs/index.js";
 import { withLlmStage } from "../../llm/usage-telemetry.js";
-import { persistPhaseThreshold } from "../../storage/repositories/improve-runs-repository.js";
-import { listProposalGateDecisions, listStateProposals } from "../../storage/repositories/proposals-repository.js";
+import { closeDatabase, openExistingDatabase } from "../../storage/repositories/index-connection.js";
+import { getZeroResultSearches } from "../../storage/repositories/index-entries-repository.js";
+import { getRetrievalCounts } from "../../storage/repositories/index-utility-repository.js";
+import { listStateProposals } from "../../storage/repositories/proposals-repository.js";
 import { akmLint } from "../lint/index.js";
-import { getProposal, listProposals } from "../proposal/repository.js";
 import { runSchemaRepairPass } from "../sources/schema-repair.js";
-import { computeThresholdAutoTune, gateDecisionsToSamples, summarizeCalibration, } from "./calibration.js";
+import { isAutonomyLaneAllowed } from "./autonomy-gate.js";
 import { akmConsolidate } from "./consolidate.js";
 // Eligibility / candidate-selection predicates live in ./eligibility.
 import { buildLatestFeedbackTsMap, buildLatestProposalTsMap, buildUtilityMap, dedupeRefs, findAssetFilePath, isDistillCandidateRef, isLessonCandidate, isSignalDeltaEligible, } from "./eligibility.js";
 import { akmExtract, countNewExtractCandidates } from "./extract.js";
 import { computeValenceScore, FEEDBACK_WEIGHT, UTILITY_WEIGHT } from "./feedback-valence.js";
-import { makeGateConfig, resolveExtractConfidence, runAutoAcceptGate } from "./improve-auto-accept.js";
-import { resolveProcessEnabled } from "./improve-profiles.js";
 import { applyMemoryCleanup } from "./memory/memory-improve.js";
 import { computeProxyAdequacy, getAllAssetOutcomes, getOutcomeScoresByRef, OUTCOME_SCORE_MAX, outcomeScoreToSalience, updateAssetOutcome, } from "./outcome-loop.js";
 import { DEFAULT_DUE_DAYS, DEFAULT_MAX_PER_RUN, selectProactiveMaintenanceRefs } from "./proactive-maintenance.js";
-import { buildRankChangeReport, computeSalience, getAllRankScores, getAssetSalience, getConsecutiveNoOps, getLastUseMsByRef, isContentEncodingRow, SALIENCE_NO_OP_DAMPEN_FACTOR, SALIENCE_NO_OP_DAMPEN_THRESHOLD, upsertAssetSalience, } from "./salience.js";
-// ── improve preparation stage ───────────────────────
-// The pre-loop preparation pipeline (consolidation, session-extract, validation/
-// repair, eligibility partitioning, selectors) extracted from improve.ts.
-/**
- * #612 / WS-4 — bounded, opt-in per-phase auto-accept threshold auto-tune.
- *
- * Reads `improve.calibration` from config. When `autoTune` is enabled, computes
- * the calibration of recent gate decisions, derives a bounded threshold
- * adjustment (clamped into the configured band, capped per step), logs it, and
- * records a `calibration_autotune` event. Returns the new threshold (integer
- * 0-100) when an adjustment was made, or `undefined` to leave the caller's
- * threshold unchanged.
- *
- * WS-4 change: accepts an optional `phase` parameter. When provided, the tuned
- * threshold is persisted to `improve_gate_thresholds` (state.db Migration 012)
- * keyed by phase so `makeGateConfig` can read it back on the next run and each
- * phase maintains its own calibrated threshold rather than a shared global.
- *
- * WS-4 ceiling: `maxThreshold` defaults to 85 (not 100) to prevent the gate
- * converging to pure exploitation and shutting down Gap-3/4 novelty throughput.
- *
- * DEFAULT OFF: with no `improve.calibration` block (or `autoTune: false`) this
- * returns `undefined` immediately, so the gate threshold is unchanged and
- * behaviour is byte-identical to today.
- */
-export function maybeAutoTuneThreshold(currentThreshold, config, stateDbPath, ctx, phase) {
-    const cal = config.improve?.calibration;
-    if (!cal?.autoTune)
-        return undefined;
-    // WS-4: default maxThreshold is now 85 (ceiling to prevent pure exploitation).
-    // Callers that explicitly set maxThreshold in config override this default.
-    const tuneConfig = {
-        autoTune: true,
-        minThreshold: cal.minThreshold ?? 0,
-        maxThreshold: cal.maxThreshold ?? 85,
-        maxStep: cal.maxStep ?? 5,
-        minSamples: cal.minSamples ?? 20,
-        targetAcceptRate: cal.targetAcceptRate ?? 0.9,
-    };
-    // Defensive: an inverted band disables tuning rather than clamping to nonsense.
-    if (tuneConfig.minThreshold > tuneConfig.maxThreshold)
-        return undefined;
-    const summary = withStateDb((db) => {
-        const allDecisions = listProposalGateDecisions(db);
-        // WS-4 fix: when called with a phase label, restrict calibration to that
-        // phase's decision pool so a reflect-dominated run cannot tighten the
-        // consolidate gate (or vice-versa). The gate field is `improve:<phase>`,
-        // matching what improve-auto-accept.ts stamps at line ~163.
-        const gateLabel = phase ? `improve:${phase}` : undefined;
-        const decisions = gateLabel ? allDecisions.filter((d) => d.gate === gateLabel) : allDecisions;
-        return summarizeCalibration(gateDecisionsToSamples(decisions));
-    }, { path: stateDbPath });
-    const result = computeThresholdAutoTune(currentThreshold, summary, tuneConfig);
-    if (!result.adjusted)
-        return undefined;
-    const appendEventFn = ctx?.appendEventFn ?? appendEvent;
-    const phaseLabel = phase ?? "global";
-    info(`[improve] calibration auto-tune (${phaseLabel}): threshold ${result.previousThreshold} -> ${result.newThreshold} ` +
-        `(${result.reason}; samples=${summary.samples}, acceptRate=${summary.overallAcceptRate}, ` +
-        `gap=${summary.calibrationGap}, band=[${tuneConfig.minThreshold},${tuneConfig.maxThreshold}])`);
-    try {
-        appendEventFn({
-            eventType: "calibration_autotune",
-            ref: "improve:calibration",
-            metadata: {
-                phase: phaseLabel,
-                previousThreshold: result.previousThreshold,
-                newThreshold: result.newThreshold,
-                delta: result.delta,
-                reason: result.reason,
-                samples: summary.samples,
-                overallAcceptRate: summary.overallAcceptRate,
-                calibrationGap: summary.calibrationGap,
-                minThreshold: tuneConfig.minThreshold,
-                maxThreshold: tuneConfig.maxThreshold,
-            },
-        });
-    }
-    catch (err) {
-        warn(`[improve] calibration auto-tune event not recorded: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    // WS-4: Persist the per-phase threshold so makeGateConfig reads it on the
-    // next run. Best-effort — a write failure must not abort the improve run.
-    if (phase) {
-        try {
-            withStateDb((persistDb) => persistPhaseThreshold(persistDb, phase, result.newThreshold), {
-                path: stateDbPath,
-            });
-        }
-        catch (err) {
-            warn(`[improve] calibration auto-tune: failed to persist phase threshold for ${phase}: ${err instanceof Error ? err.message : String(err)}`);
-        }
+import { buildRankChangeReport, computeSalience, getAllRankScores, getAssetSalience, getLastUseMsByRef, isContentEncodingRow, SALIENCE_NO_OP_DAMPEN_FACTOR, SALIENCE_NO_OP_DAMPEN_THRESHOLD, upsertAssetSalience, } from "./salience.js";
+import { bareImproveRef, improveStateReadRefs } from "./source-identity.js";
+function readAssetSalienceForImproveRef(db, ref, itemRef) {
+    for (const key of improveStateReadRefs(ref, itemRef)) {
+        const row = getAssetSalience(db, key);
+        if (row)
+            return row;
     }
-    return result.newThreshold;
+    return undefined;
+}
+function readConsecutiveNoOpsForImproveRef(db, ref, itemRef) {
+    return readAssetSalienceForImproveRef(db, ref, itemRef)?.consecutive_no_ops ?? 0;
+}
+// ── Durable-state write keys ──────────────────────────────────────────────────
+//
+// The durable improve-state writers (salience + outcome) key by the resolved
+// index entry's `item_ref` (`<bundle>//<conceptId>`) when the planner resolved
+// one (`ImproveEligibleRef.itemRef`). Both writers share one key expression,
+// `itemRefByRef.get(ref) ?? ref`.
+//
+// A direct `--scope <ref>` candidate does not flow through
+// `collectEligibleRefsFromIndex`, so its conceptId `ref` is the write key.
+//
+// itemRefByRef is `ref → item_ref | undefined`, built once per pass from the
+// candidate set.
+/** `ref → item_ref | undefined` for a run's candidate set. */
+function buildItemRefByRef(refs) {
+    const m = new Map();
+    for (const r of refs)
+        m.set(r.ref, r.itemRef);
+    return m;
+}
+/** Durable `asset_salience` write key: the entry's item_ref, else its conceptId `ref` (scope-ref fallback). */
+function salienceWriteKey(ref, itemRefByRef) {
+    return itemRefByRef.get(ref) ?? ref;
+}
+/** Durable `asset_outcome` write key: the entry's item_ref, else its conceptId `ref` (scope-ref fallback). */
+function outcomeWriteKey(ref, itemRefByRef) {
+    return itemRefByRef.get(ref) ?? ref;
+}
+/** Resolve an AKM asset type from a short or bundle-qualified conceptId. */
+function assetTypeOf(ref) {
+    const tail = ref.includes("//") ? ref.slice(ref.indexOf("//") + 2) : ref;
+    return typeNameFromConceptId(tail)?.type ?? "";
 }
 /**
- * Run (or gate-skip) the memory consolidation pass.
- *
- * #551 — two coordinated changes live here:
- *
- *   1. STRUCTURAL: this runs before extract in the improve pipeline (see
- *      `runImprovePreparationStage`). Consolidation therefore only ever judges
- *      PRIOR-run memories; current-run extract promotions are invisible to it.
- *
- *   2. SMARTER POOL-DELTA GATE: even among on-disk files, a memory whose only
- *      post-`lastConsolidateTs` mtime bump came from its OWN auto-accept
- *      promotion (i.e. it was just promoted by extract in the immediately
- *      preceding run and has not had a full improve cycle to settle) does NOT
- *      count as "work to do". We exclude those paths from the pool-delta check
- *      using the `promoted` events already emitted with each promotion's
- *      `assetPath`. A genuinely-settled prior memory — one edited by feedback,
- *      reflect, manual edit, or simply older than the last consolidate — still
- *      triggers the run. This is gate-option (a) from the issue (same-run /
- *      adjacent-run promotion exclusion), chosen over option (b) because there
- *      is no `extract_completed` event in the data model to gate against;
- *      `promoted` events with `assetPath` already carry exactly the signal we
- *      need, so the fix is non-invasive and provably correct.
+ * Evaluate the consolidation gate flags (volume trigger, #551 pool-delta
+ * cooldown, profile disable, #553 min-pool-size) up front, before any LLM call.
+ * Extracted verbatim from `runConsolidationPass` — logic is byte-identical.
  */
-export async function runConsolidationPass(args) {
-    const { options, primaryStashDir, memorySummary, improveProfile, eventsCtx, budgetSignal, runBudgetMs } = args;
-    const baseConfig = options.config ?? loadConfig();
+function evaluateConsolidationEligibility(args) {
+    const { options, primaryStashDir, memorySummary, improveProfile, resolvedPlan } = args;
     const MEMORY_VOLUME_THRESHOLD = options.memoryVolumeConsolidationThreshold ?? 100;
-    const hasLlm = !!(baseConfig.defaults?.llm || baseConfig.defaults?.agent);
+    const hasLlm = resolvedPlan.processes.consolidate.runner !== null;
     const volumeTriggered = typeof memorySummary.eligible === "number" && memorySummary.eligible > MEMORY_VOLUME_THRESHOLD && hasLlm;
-    // When volume triggers a consolidation pass, force-enable the consolidate
-    // process on the default improve profile so the gate accepts the run even
-    // if the user's config disabled it. We synthesise a new profile override
-    // rather than mutating connection settings.
-    const consolidationConfig = volumeTriggered
-        ? {
-            ...baseConfig,
-            profiles: {
-                ...(baseConfig.profiles ?? {}),
-                improve: {
-                    ...(baseConfig.profiles?.improve ?? {}),
-                    default: {
-                        ...(baseConfig.profiles?.improve?.default ?? {}),
-                        processes: {
-                            ...(baseConfig.profiles?.improve?.default?.processes ?? {}),
-                            consolidate: {
-                                ...(baseConfig.profiles?.improve?.default?.processes?.consolidate ?? {}),
-                                enabled: true,
-                            },
-                        },
-                    },
-                },
-            },
-        }
-        : baseConfig;
     // 0.8.0 pool-delta gate for consolidate: re-eligible iff at least one
     // memory file has been updated since the most recent successful
     // consolidate_completed event. Time-based cooldowns produced the same
     // synchronised-wave failure mode the reflect/distill cooldowns did; the
     // pool-delta gate ties consolidation to actual work-to-do.
+    const sourceName = options.sourceName ?? options.writeTarget?.source.name ?? options.config?.defaultBundle ?? "stash";
     const recentConsolidations = readEvents({ type: "consolidate_completed" });
     const lastConsolidation = recentConsolidations.events
-        .filter((e) => e.metadata?.processed && Number(e.metadata.processed) > 0)
+        .filter((e) => e.metadata?.source === sourceName && Number(e.metadata?.processed) > 0)
         .sort((a, b) => new Date(b.ts ?? 0).getTime() - new Date(a.ts ?? 0).getTime())[0];
-    const lastConsolidateTs = lastConsolidation?.ts;
+    const lastConsolidateTs = typeof lastConsolidation?.metadata?.completedThrough === "string"
+        ? lastConsolidation.metadata.completedThrough
+        : lastConsolidation?.ts;
     // #551 smarter gate: build the set of memory asset paths whose only delta
-    // since the last consolidate is their OWN auto-accept promotion. Those files
+    // since the last consolidate is their OWN promotion. Those files
     // have not had a full improve cycle to settle, so they offer no merge /
     // contradiction candidates yet — excluding them stops the gate firing on
     // freshly-promoted single-source memories. We read `promoted` events emitted
@@ -235,21 +143,29 @@ export async function runConsolidationPass(args) {
         if (!fs.existsSync(memoriesDir))
             return false;
         try {
-            return fs.readdirSync(memoriesDir).some((f) => {
-                if (!f.endsWith(".md"))
-                    return false;
-                const filePath = path.join(memoriesDir, f);
-                // #551: skip files that were only touched by their own promotion this
-                // cohort — they have no settled merge/contradiction candidates yet.
-                if (promotedSinceConsolidate.has(path.resolve(filePath)))
-                    return false;
-                try {
-                    return fs.statSync(filePath).mtime.toISOString() > lastConsolidateTs;
-                }
-                catch {
-                    return false;
+            const pending = [memoriesDir];
+            while (pending.length > 0) {
+                const current = pending.pop();
+                for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+                    const filePath = path.join(current, entry.name);
+                    if (entry.isDirectory()) {
+                        pending.push(filePath);
+                        continue;
+                    }
+                    if (!entry.isFile() || !entry.name.endsWith(".md"))
+                        continue;
+                    if (promotedSinceConsolidate.has(path.resolve(filePath)))
+                        continue;
+                    try {
+                        if (fs.statSync(filePath).mtime.toISOString() > lastConsolidateTs)
+                            return true;
+                    }
+                    catch {
+                        // Ignore files that disappear during the scan.
+                    }
                 }
-            });
+            }
+            return false;
         }
         catch {
             return false;
@@ -272,6 +188,21 @@ export async function runConsolidationPass(args) {
     // so a force-triggered run never trips the pool-size guard. The guard only
     // engages when minPoolSize > 0 and the eligible pool is strictly below it.
     const poolBelowMinSize = !volumeTriggered && minPoolSize > 0 && eligiblePoolSize < minPoolSize;
+    return {
+        volumeTriggered,
+        consolidationOnCooldown,
+        consolidateDisabledByProfile,
+        poolBelowMinSize,
+        eligiblePoolSize,
+        minPoolSize,
+        ...(lastConsolidateTs ? { lastConsolidationTs: lastConsolidateTs } : {}),
+    };
+}
+export async function runConsolidationPass(args) {
+    const { options, primaryStashDir, memorySummary, improveProfile, resolvedPlan, eventsCtx, budgetSignal, runBudgetMs, } = args;
+    const baseConfig = options.config ?? loadConfig();
+    const consolidationConfig = baseConfig;
+    const { volumeTriggered, consolidationOnCooldown, consolidateDisabledByProfile, poolBelowMinSize, eligiblePoolSize, minPoolSize, lastConsolidationTs, } = evaluateConsolidationEligibility({ options, primaryStashDir, memorySummary, improveProfile, resolvedPlan });
     let consolidation = {
         schemaVersion: 1,
         ok: true,
@@ -287,16 +218,6 @@ export async function runConsolidationPass(args) {
         warnings: [],
         durationMs: 0,
     };
-    let gateAutoAcceptedCount = 0;
-    let gateAutoAcceptFailedCount = 0;
-    const consolidateGateCfg = makeGateConfig("consolidate", {
-        globalThreshold: options.autoAccept,
-        dryRun: options.dryRun ?? false,
-        stashDir: primaryStashDir,
-        config: consolidationConfig,
-        eventsCtx,
-        stateDbPath: eventsCtx?.dbPath,
-    }, { minimumThreshold: 95 });
     if (consolidateDisabledByProfile) {
         info("[improve] consolidation skipped (disabled by improve profile)");
     }
@@ -306,7 +227,7 @@ export async function runConsolidationPass(args) {
         // it via the dynamic skipReasons aggregation under `pool_below_min_size`.
         appendEvent({
             eventType: "improve_skipped",
-            ref: "memory:_consolidation",
+            ref: "memories/_consolidation",
             metadata: {
                 reason: "pool_below_min_size",
                 poolSize: eligiblePoolSize,
@@ -316,13 +237,18 @@ export async function runConsolidationPass(args) {
         info(`[improve] consolidation skipped (pool ${eligiblePoolSize} < minPoolSize ${minPoolSize})`);
     }
     else if (!consolidationOnCooldown) {
+        const consolidationStartedAt = new Date().toISOString();
         consolidation = await withLlmStage("consolidate", () => akmConsolidate({
             ...options.consolidateOptions,
             config: consolidationConfig,
+            dryRun: options.dryRun ?? false,
             stashDir: options.stashDir,
             // Active profile for this improve run — lets consolidate's secondary
             // process-config reads honor `--profile <name>` instead of `default`.
             improveProfile,
+            llmConfig: resolvedPlan.processes.consolidate.runner
+                ? materializeLlmRunnerConnection(resolvedPlan.processes.consolidate.runner)
+                : null,
             autoTriggered: volumeTriggered,
             // Tie consolidate proposals back to this improve invocation so
             // accept-rate-per-run aggregation works. Mirrors reflect/propose/extract.
@@ -331,25 +257,9 @@ export async function runConsolidationPass(args) {
             // recently-changed memories + graph neighbours — use this for frequent
             // passes (quick-shredder). Leave absent in the nightly default profile for
             // a full-pool sweep that catches stale-but-unmerged duplicates.
-            incrementalSince: improveProfile?.processes?.consolidate?.incrementalSince,
             limit: improveProfile?.processes?.consolidate?.limit,
             neighborsPerChanged: improveProfile?.processes?.consolidate?.neighborsPerChanged,
             maxChunkSize: improveProfile?.processes?.consolidate?.maxChunkSize,
-            // #617 — deterministic near-duplicate dedup pre-pass. DEFAULT OFF; only
-            // runs when the profile explicitly sets `consolidate.dedup.enabled`.
-            dedup: improveProfile?.processes?.consolidate?.dedup,
-            // #581 — judged-state cache. DEFAULT OFF; only engages when the profile
-            // explicitly sets `consolidate.judgedCache.enabled`. Skips memories
-            // judged-unchanged since their last judge so one run sweeps the full
-            // corpus instead of narrowing to a time-window slice.
-            judgedCache: improveProfile?.processes?.consolidate?.judgedCache,
-            // Honor profile.autoAccept (already merged into options.autoAccept at the
-            // top of akmImprove). The CLI parser always supplies 90 when --auto-accept
-            // is absent, so ?? 90 is not needed here and would prevent --auto-accept=false
-            // (which maps to undefined) from disabling consolidation auto-accept.
-            // options.consolidateOptions.autoAccept (if explicitly provided by caller)
-            // still wins because the spread above runs first.
-            autoAccept: options.consolidateOptions?.autoAccept ?? options.autoAccept,
             // WS-3a: forward budget signal for graceful abort on timeout, and pass
             // the profile's p90 estimate for cold-start budget reduction.
             signal: budgetSignal,
@@ -357,28 +267,25 @@ export async function runConsolidationPass(args) {
             // WS-5: pass total run budget so perfTelemetry.estimatedBudgetFractionUsed
             // can flag when consolidation alone exceeded the budget.
             runBudgetMs,
-        }));
-        {
-            const consolidateGr = await runAutoAcceptGate(consolidation.promoted.map((proposalId) => {
-                try {
-                    if (!primaryStashDir)
-                        return { proposalId, confidence: undefined };
-                    const proposal = getProposal(primaryStashDir, proposalId);
-                    return { proposalId, confidence: proposal.confidence };
-                }
-                catch {
-                    return { proposalId, confidence: undefined };
-                }
-            }), consolidateGateCfg);
-            gateAutoAcceptedCount += consolidateGr.promoted.length;
-            gateAutoAcceptFailedCount += consolidateGr.failed.length;
-        }
-        if (consolidation.processed > 0) {
+        }), { engine: resolvedPlan.processes.consolidate.runner?.engine, process: "consolidate" });
+        const sourceName = options.sourceName ?? options.writeTarget?.source.name ?? baseConfig.defaultBundle ?? "stash";
+        const complete = (consolidation.failedChunks ?? 0) === 0 &&
+            (consolidation.failedChunkMemories ?? 0) === 0 &&
+            (consolidation.failedPromotions ?? 0) === 0 &&
+            (consolidation.deferredMemories ?? 0) === 0;
+        const hasUnappliedAdvisoryOperations = consolidation.planned?.some((op) => op.op !== "promote") ?? false;
+        if (consolidation.ok &&
+            !consolidation.dryRun &&
+            complete &&
+            !hasUnappliedAdvisoryOperations &&
+            consolidation.processed > 0) {
             appendEvent({
                 eventType: "consolidate_completed",
-                ref: "memory:_consolidation",
+                ref: makeBundleRef(sourceName, "memories/_consolidation"),
                 metadata: {
                     processed: consolidation.processed,
+                    source: sourceName,
+                    completedThrough: consolidationStartedAt,
                     merged: consolidation.merged,
                     deleted: consolidation.deleted,
                     contradicted: consolidation.contradicted,
@@ -391,38 +298,30 @@ export async function runConsolidationPass(args) {
     else {
         appendEvent({
             eventType: "improve_skipped",
-            ref: "memory:_consolidation",
+            ref: "memories/_consolidation",
             metadata: {
                 reason: "consolidation_no_memory_updates",
-                lastEventTs: lastConsolidation?.ts ?? null,
+                lastEventTs: lastConsolidationTs ?? null,
             },
         }, eventsCtx);
         info("[improve] consolidation skipped (no memory updates since last run)");
     }
     // D9: track whether consolidation wrote any data so graph extraction can reindex if needed
-    const consolidationRan = !consolidateDisabledByProfile && !poolBelowMinSize && !consolidationOnCooldown && consolidation.processed > 0;
-    // WS-4: Per-phase threshold auto-tune for the consolidate phase.
-    // Persists result for the NEXT run's makeGateConfig to read.
-    const consolidateTuneDbPath = eventsCtx?.dbPath;
-    if (options.autoAccept !== undefined && consolidateTuneDbPath) {
-        try {
-            maybeAutoTuneThreshold(consolidateGateCfg.phaseThreshold ?? options.autoAccept, consolidationConfig, consolidateTuneDbPath, undefined, "consolidate");
-        }
-        catch (err) {
-            warn(`[improve] calibration auto-tune (consolidate) skipped: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    return { consolidation, consolidationRan, gateAutoAcceptedCount, gateAutoAcceptFailedCount };
+    const consolidationRan = !consolidateDisabledByProfile &&
+        !poolBelowMinSize &&
+        !consolidationOnCooldown &&
+        !consolidation.previewOnly &&
+        consolidation.processed > 0;
+    return { consolidation, consolidationRan };
 }
 /**
  * Phase 0.4 — session-extract pass. Reads native session files through the
- * SessionLogHarness registry, asks a bounded LLM for candidate proposals, gates
- * them, and drains the extract backlog. Failures are non-fatal (collected into
- * `warnings`). Returns the extract results + the gate counters seeded from the
- * consolidation pass and accumulated here.
+ * SessionLogHarness registry, and asks a bounded LLM for candidate proposals.
+ * Failures are non-fatal (collected into `warnings`). Returns the extract
+ * results + any warnings collected along the way.
  */
 async function runSessionExtractPass(args) {
-    const { options, primaryStashDir, improveProfile, eventsCtx, seedGateAccepted, seedGateFailed } = args;
+    const { options, primaryStashDir, improveProfile, resolvedPlan, eventsCtx, budgetSignal } = args;
     const warnings = [];
     // Phase 0.4 — session-extract pass.
     //
@@ -433,9 +332,10 @@ async function runSessionExtractPass(args) {
     // / `akm feedback` invocations. Replaces the akm-plugin session-checkpoint
     // hook with an on-demand pull pipeline.
     //
-    // Default-on; opt out via the ACTIVE profile's `processes.extract.enabled: false`
-    // (#593: the gate respects the resolved improve profile, not just the
-    // hardcoded `default` profile path the legacy feature flag reads).
+    // Runs only when the ACTIVE strategy resolves
+    // `processes.extract.enabled: true` (#593: the gate respects the resolved
+    // improve strategy, not just the hardcoded `default` path the legacy feature
+    // flag read). Shipped `default` and `frequent` strategies leave this off.
     // Each available harness gets one call with the default --since window;
     // already-seen sessions (tracked in state.db.extract_sessions_seen) are
     // skipped automatically so re-runs don't burn LLM calls on unchanged data.
@@ -443,30 +343,17 @@ async function runSessionExtractPass(args) {
     // Failures are non-fatal — one harness throwing doesn't abort improve.
     // The extract envelope's own `warnings` field surfaces what went wrong.
     let extractResults;
-    // Seed the preparation-stage gate counters with consolidation's auto-accept
-    // gate results (#551: consolidation now runs in this stage), then accumulate
-    // extract's gate results on top.
-    let gateAutoAcceptedCount = seedGateAccepted;
-    let gateAutoAcceptFailedCount = seedGateFailed;
     const extractConfig = options.config ?? loadConfig();
-    const extractGateCfg = makeGateConfig("extract", {
-        globalThreshold: options.autoAccept,
-        dryRun: options.dryRun ?? false,
-        stashDir: primaryStashDir,
-        config: extractConfig,
-        eventsCtx,
-        stateDbPath: eventsCtx?.dbPath,
-    });
     // #554 minNewSessions gate: skip the entire extract pass (ensureIndex was
     // already done upstream; here we elide every akmExtract/processSession call)
     // when the NEW (unseen, in-window) candidate-session pool is below a minimum.
     // 22% of improve runs produce zero memory-inference writes because extract
     // finds no new sessions, yet still burns the full extract pipeline. Default 0
     // (disabled) preserves existing always-run behaviour; only opted-in profiles
-    // (e.g. `frequent`) set it. Evaluated BEFORE any LLM call so a skip costs zero
-    // LLM work AND writes nothing — which also means no extract auto-accept bumps
-    // memory mtimes, so a skipped extract never flags work for the NEXT run's
-    // consolidation mtime-gate (the downstream trigger #554 asks us to suppress).
+    // (e.g. a user-enabled `frequent` strategy) set it. Evaluated BEFORE any LLM
+    // call so a skip costs zero LLM work AND writes nothing. A skipped extract
+    // never flags work for the NEXT run's consolidation mtime-gate (the
+    // downstream trigger #554 asks us to suppress).
     const EXTRACT_DEFAULT_MIN_NEW_SESSIONS = 0;
     // Read from the ACTIVE resolved profile (not always `default`), matching how
     // `extract.enabled` resolves — otherwise a non-default profile (e.g.
@@ -476,11 +363,22 @@ async function runSessionExtractPass(args) {
     // #593/#594: the ACTIVE resolved improve profile is the single source of
     // truth for whether extract runs. (Previously this also ANDed in the legacy
     // `session_extraction` feature flag, which only reads
-    // `profiles.improve.default.processes.extract.enabled`; that made the default
-    // profile a global kill switch, so a non-default profile enabling extract was
-    // silently overridden. The default profile is now just another profile.)
+    // a retired global feature path; the selected strategy is authoritative.)
     // `akmExtract` re-checks the same active profile internally via `improveProfile`.
-    if (resolveProcessEnabled("extract", improveProfile)) {
+    if (resolvedPlan.processes.extract.enabled) {
+        const extractRunner = resolvedPlan.processes.extract.runner;
+        if (!extractRunner?.engine) {
+            throw new ConfigError("Resolved improve plan has no runner for enabled extract process.", "LLM_NOT_CONFIGURED");
+        }
+        const extractPlan = Object.freeze({
+            strategy: resolvedPlan.strategy.name,
+            engine: extractRunner.engine,
+            enabled: true,
+            process: resolvedPlan.processes.extract.config,
+            runner: extractRunner,
+            timeoutMs: extractRunner.timeoutMs === undefined ? 600_000 : extractRunner.timeoutMs,
+            embeddingConfig: Object.freeze(structuredClone(extractConfig.embedding)),
+        });
         const availableHarnesses = options.extractHarnesses ?? getAvailableHarnesses();
         // The guard engages only when minNewSessions > 0; 0 disables it entirely.
         let belowMinNewSessions = false;
@@ -503,7 +401,7 @@ async function runSessionExtractPass(args) {
                 // skipReasons aggregation surfaces this under `below_min_new_sessions`.
                 appendEvent({
                     eventType: "improve_skipped",
-                    ref: "memory:_extract",
+                    ref: "memories/_extract",
                     metadata: {
                         reason: "below_min_new_sessions",
                         newSessions: newCandidateCount,
@@ -521,25 +419,17 @@ async function runSessionExtractPass(args) {
                         type: h.name,
                         ...(primaryStashDir !== undefined ? { stashDir: primaryStashDir } : {}),
                         config: extractConfig,
-                        // Thread the ACTIVE profile so extract's internal gate + per-process
-                        // config read the running profile, not always `default`.
-                        improveProfile,
+                        resolvedPlan: extractPlan,
                         dryRun: options.dryRun ?? false,
+                        signal: budgetSignal,
                         ...(options.extractHarnesses ? { harnesses: options.extractHarnesses } : {}),
                         // C2: pin extract's skip-tracking state.db open to the boundary path.
                         ...(eventsCtx?.dbPath ? { stateDbPath: eventsCtx.dbPath } : {}),
-                    }));
+                        // R25: extract's event emits reuse the run's events context
+                        // (fast path when it carries the long-lived handle).
+                        eventsCtx,
+                    }), { engine: resolvedPlan.processes.extract.runner?.engine, process: "extract" });
                     extractResults.push(result);
-                    {
-                        const gr = await runAutoAcceptGate(primaryStashDir
-                            ? result.proposals.map((proposalId) => {
-                                const proposal = getProposal(primaryStashDir, proposalId);
-                                return { proposalId, confidence: resolveExtractConfidence(proposal) };
-                            })
-                            : [], extractGateCfg);
-                        gateAutoAcceptedCount += gr.promoted.length;
-                        gateAutoAcceptFailedCount += gr.failed.length;
-                    }
                 }
                 catch (err) {
                     const msg = err instanceof Error ? err.message : String(err);
@@ -553,73 +443,57 @@ async function runSessionExtractPass(args) {
             }
         }
     }
-    // Backlog drain: gate any pending extract proposals that weren't created in
-    // this run (i.e. pre-date the gate or were produced by a run that timed out
-    // before the gate fired). Without this, eligible proposals accumulate
-    // indefinitely — the fresh-gate only covers the current run's output.
-    if (primaryStashDir && !options.dryRun && options.autoAccept !== undefined) {
-        const freshIds = new Set((extractResults ?? []).flatMap((r) => r.proposals));
-        const backlog = listProposals(primaryStashDir, { status: "pending" }).filter((p) => p.source === "extract" && !freshIds.has(p.id));
-        if (backlog.length > 0) {
-            const backlogCandidates = backlog.map((p) => ({
-                proposalId: p.id,
-                confidence: resolveExtractConfidence(p),
-            }));
-            const backlogGr = await runAutoAcceptGate(backlogCandidates, extractGateCfg);
-            gateAutoAcceptedCount += backlogGr.promoted.length;
-            gateAutoAcceptFailedCount += backlogGr.failed.length;
-        }
-    }
-    return { extractResults, gateAutoAcceptedCount, gateAutoAcceptFailedCount, warnings, extractGateCfg };
+    return {
+        extractResults,
+        warnings,
+    };
 }
 /**
  * Phase 1 — validation + schema-repair pass. Scans postCleanupRefs for assets
  * with structural problems (missing file, missing lesson description), attempts
  * LLM schema repair, and returns the still-failing ref set + the repair records.
  */
-async function runValidationAndRepairPass(args) {
-    const { postCleanupRefs, options, startMs, budgetMs, primaryStashDir } = args;
-    const validationFailures = [];
-    for (const candidate of postCleanupRefs) {
+export async function runValidationAndRepairPass(args) {
+    const { postCleanupRefs, options, startMs, budgetMs, primaryStashDir, resolvedPlan, repairValidationFailures, schemaRepairFn = runSchemaRepairPass, } = args;
+    const validateCandidate = async (candidate) => {
         try {
-            // #591: use the path pre-resolved at planning time when it is still on
-            // disk — a serial async DB lookup per ref cost ~500 s on a 9 000-ref
-            // stash. Fall back to findAssetFilePath only for refs that bypassed
-            // collectEligibleRefs' index scan or whose file moved since planning.
             const filePath = candidate.filePath && fs.existsSync(candidate.filePath)
                 ? candidate.filePath
                 : await findAssetFilePath(candidate.ref, options.stashDir);
-            if (!filePath) {
-                validationFailures.push({ ref: candidate.ref, reason: "file not found on disk" });
-                continue;
-            }
-            if (path.extname(filePath).toLowerCase() !== ".md") {
-                continue;
-            }
+            if (!filePath)
+                return "file not found on disk";
+            if (path.extname(filePath).toLowerCase() !== ".md")
+                return undefined;
             if (isLessonCandidate(candidate.ref)) {
-                const raw = fs.readFileSync(filePath, "utf8");
-                const fm = parseFrontmatter(raw).data;
+                const fm = parseFrontmatter(fs.readFileSync(filePath, "utf8")).data;
                 if (!fm.description)
-                    validationFailures.push({ ref: candidate.ref, reason: "missing description" });
+                    return "missing description";
             }
+            return undefined;
         }
-        catch (e) {
-            validationFailures.push({ ref: candidate.ref, reason: String(e) });
+        catch (error) {
+            return String(error);
         }
+    };
+    const validationFailures = [];
+    for (const candidate of postCleanupRefs) {
+        const reason = await validateCandidate(candidate);
+        if (reason)
+            validationFailures.push({ ref: candidate.ref, reason });
     }
     if (validationFailures.length > 0) {
-        info(`[improve] ${validationFailures.length} assets have validation issues (will attempt schema repair):`);
+        info(`[improve] ${validationFailures.length} assets have validation issues${repairValidationFailures ? " (will attempt schema repair)" : ""}:`);
         for (const f of validationFailures)
             info(`  ${f.ref}: ${f.reason}`);
     }
     let schemaRepairs = [];
-    let repairedRefs = new Set();
+    const repairedRefs = new Set();
     // Schema repair pass: attempt to fix validation failures via LLM before skipping.
-    if (validationFailures.length > 0 && options.repairValidationFailures !== false) {
-        const baseConfigForRepair = options.config ?? loadConfig();
-        const llmCfg = getDefaultLlmConfig(baseConfigForRepair);
+    if (validationFailures.length > 0) {
+        const validationRunner = resolvedPlan.processes.validation.runner;
+        const llmCfg = validationRunner ? materializeLlmRunnerConnection(validationRunner) : undefined;
         if (llmCfg) {
-            const result = await runSchemaRepairPass(validationFailures, {
+            const result = await withLlmStage("validation", () => schemaRepairFn(validationFailures, {
                 startMs,
                 budgetMs,
                 llmConfig: llmCfg,
@@ -633,9 +507,17 @@ async function runValidationAndRepairPass(args) {
                 stashDir: primaryStashDir,
                 findFilePath: findAssetFilePath,
                 isLessonCandidateFn: isLessonCandidate,
-            });
+            }), { engine: resolvedPlan.processes.validation.runner?.engine, process: "validation" });
             schemaRepairs = result.repairs;
-            repairedRefs = result.repairedRefs;
+            // A repair result is advisory. Only a fresh structural read of the live
+            // asset can remove it from the failure set; queued content is not live.
+            const failedRefs = new Set(validationFailures.map((failure) => failure.ref));
+            const candidatesByRef = new Map(postCleanupRefs.map((candidate) => [candidate.ref, candidate]));
+            for (const ref of failedRefs) {
+                const candidate = candidatesByRef.get(ref);
+                if (candidate && !(await validateCandidate(candidate)))
+                    repairedRefs.add(ref);
+            }
         }
     }
     const validationFailureRefs = new Set(validationFailures.filter((f) => !repairedRefs.has(f.ref)).map((f) => f.ref));
@@ -645,32 +527,18 @@ async function runValidationAndRepairPass(args) {
     return { validationFailures, validationFailureRefs, schemaRepairs };
 }
 export async function runImprovePreparationStage(args) {
-    const { scope, options, plannedRefs, memoryCleanupPlan, primaryStashDir, memorySummary, reindexFn, startMs, budgetMs, eventsCtx, initialCleanupWarnings, improveProfile, budgetSignal, } = args;
+    const { scope, options, plannedRefs, memoryCleanupPlan, primaryStashDir, memorySummary, reindexFn, startMs, budgetMs, eventsCtx, initialCleanupWarnings, improveProfile, resolvedPlan, strategyName, budgetSignal, } = args;
     const actions = [];
     const cleanupWarnings = initialCleanupWarnings ? [...initialCleanupWarnings] : [];
-    // Phase 0 — MEMORY.md budget check (200-line cap; warn at 180)
-    let memoryIndexHealth;
-    if (primaryStashDir) {
-        const memoryMdPath = path.join(primaryStashDir, "memories", "MEMORY.md");
-        if (fs.existsSync(memoryMdPath)) {
-            try {
-                const lines = fs.readFileSync(memoryMdPath, "utf8").split("\n").length;
-                const overBudget = lines >= 180;
-                memoryIndexHealth = { lineCount: lines, overBudget };
-                if (overBudget) {
-                    cleanupWarnings.push(`MEMORY.md has ${lines} lines (budget: 200). Consolidation strongly recommended.`);
-                }
-            }
-            catch {
-                // best-effort
-            }
-        }
-    }
+    const memoryBudget = assessMemoryIndexBudget(primaryStashDir);
+    const memoryIndexHealth = memoryBudget.memoryIndexHealth;
+    if (memoryBudget.warning)
+        cleanupWarnings.push(memoryBudget.warning);
     // Phase 0.3 — memory consolidation pass (#551).
     //
     // Consolidation runs BEFORE the session-extract pass. This is the structural
-    // half of the #551 fix: extract auto-accept writes brand-new memory .md files
-    // on every run, which previously made the consolidation pool-delta gate fire
+    // half of the #551 fix: extract promotions write brand-new memory .md files,
+    // which previously made the consolidation pool-delta gate fire
     // unconditionally (any new file => "memory updated since last consolidate").
     // By running consolidation first, the gate and akmConsolidate only ever see
     // memories that existed at the start of the run — current-run extract
@@ -681,6 +549,7 @@ export async function runImprovePreparationStage(args) {
         primaryStashDir,
         memorySummary,
         improveProfile,
+        resolvedPlan,
         eventsCtx,
         budgetSignal,
         runBudgetMs: budgetMs,
@@ -690,13 +559,11 @@ export async function runImprovePreparationStage(args) {
         options,
         primaryStashDir,
         improveProfile,
+        resolvedPlan,
         eventsCtx,
-        seedGateAccepted: consolidationPass.gateAutoAcceptedCount,
-        seedGateFailed: consolidationPass.gateAutoAcceptFailedCount,
+        budgetSignal,
     });
     const extractResults = extractPass.extractResults;
-    const gateAutoAcceptedCount = extractPass.gateAutoAcceptedCount;
-    const gateAutoAcceptFailedCount = extractPass.gateAutoAcceptFailedCount;
     if (extractPass.warnings.length > 0)
         cleanupWarnings.push(...extractPass.warnings);
     // eligibleCount = raw pre-filter count (before cooldown/signal/cleanup filters).
@@ -704,19 +571,167 @@ export async function runImprovePreparationStage(args) {
     appendEvent({
         eventType: "improve_invoked",
         ref: scope.mode === "ref" ? scope.value : `improve:${scope.mode}:${scope.value ?? "all"}`,
-        metadata: { scope, dryRun: options.dryRun ?? false, eligibleCount: plannedRefs.length },
+        metadata: { strategy: strategyName, scope, dryRun: options.dryRun ?? false, eligibleCount: plannedRefs.length },
     }, eventsCtx);
     // ensureIndex now runs in akmImprove() BEFORE collectEligibleRefs so the
     // eligible-ref query sees a populated `entries` table on the very first
     // pass after a DB version upgrade (#339). Any failure messages from that
     // earlier call were threaded in via args.initialCleanupWarnings.
+    const cleanup = await applyCleanupPass({
+        primaryStashDir,
+        memoryCleanupPlan,
+        plannedRefs,
+        reindexFn,
+        budgetSignal,
+        allowApply: isAutonomyLaneAllowed("memoryCleanup", options.config ?? loadConfig()),
+    });
+    const appliedCleanup = cleanup.appliedCleanup;
+    const postCleanupRefs = cleanup.postCleanupRefs;
+    actions.push(...cleanup.pruneActions);
+    cleanupWarnings.push(...cleanup.warnings);
+    const { validationFailures, validationFailureRefs, schemaRepairs } = await runValidationAndRepairPass({
+        postCleanupRefs,
+        options,
+        startMs,
+        budgetMs,
+        primaryStashDir,
+        resolvedPlan,
+        repairValidationFailures: resolvedPlan.processes.validation.enabled && options.repairValidationFailures !== false,
+    });
+    // Phase 0.5 — structural hygiene pass
+    let lintSummary;
+    if (primaryStashDir) {
+        try {
+            const lintResult = akmLint({ fix: false, dir: primaryStashDir });
+            lintSummary = { fixed: lintResult.summary.fixed, flagged: lintResult.summary.flagged };
+        }
+        catch {
+            // lint is best-effort; never block improve
+        }
+    }
+    const recentErrors = seedRecentErrorWindows(schemaRepairs);
+    const snapshot = buildSnapshotManifest({ postCleanupRefs, validationFailureRefs });
+    const gathered = gatherCandidates({
+        scope,
+        options,
+        primaryStashDir,
+        eventsCtx,
+        improveProfile,
+        resolvedPlan,
+        postCleanupRefs,
+        validationFailureRefs,
+        snapshot,
+    });
+    actions.push(...gathered.actions);
+    const scored = scoreSalience({
+        scope,
+        options,
+        primaryStashDir,
+        eventsCtx,
+        mergedRefs: gathered.mergedRefs,
+        eligibilitySourceByRef: gathered.eligibilitySourceByRef,
+        feedbackSummary: gathered.feedbackSummary,
+        retrievalCounts: gathered.retrievalCounts,
+        signalFiltered: gathered.signalFiltered,
+        proactiveRefs: gathered.proactiveRefs,
+        highSalienceRefs: gathered.highSalienceRefs,
+    });
+    const filtered = await filterEligibility({
+        scope,
+        options,
+        plannedRefs,
+        eventsCtx,
+        mergedRefs: scored.mergedRefs,
+        salienceMap: scored.salienceMap,
+        eligibilitySourceByRef: gathered.eligibilitySourceByRef,
+        distillOnlyRefs: gathered.distillOnlyRefs,
+        validationFailureRefs,
+        summary: {
+            fullySkippedCount: gathered.fullySkippedCount,
+            preCooldownCount: gathered.preCooldownCount,
+            signalAndRetrievalRefs: gathered.signalAndRetrievalRefs,
+            signalFiltered: gathered.signalFiltered,
+        },
+    });
+    return {
+        actions,
+        cleanupWarnings,
+        appliedCleanup,
+        memoryIndexHealth,
+        extract: extractResults,
+        actionableRefs: filtered.actionableRefs,
+        signalBearingSet: gathered.signalBearingSet,
+        validationFailures,
+        schemaRepairs,
+        lintSummary,
+        loopRefs: filtered.loopRefs,
+        distillCooledRefs: gathered.distillCooledRefs,
+        distillOnlyRefs: filtered.distillOnlyRefs,
+        coverageGaps: filtered.coverageGaps,
+        recentErrors,
+        utilityMap: scored.utilityMap,
+        consolidation: consolidationPass.consolidation,
+        consolidationRan: consolidationPass.consolidationRan,
+        ...(gathered.proactiveMaintenanceSummary ? { proactiveMaintenance: gathered.proactiveMaintenanceSummary } : {}),
+    };
+}
+// ── preparation-stage passes (WI-7.6 decomposition, R31) ────────────────────
+// The six-pass split prescribed by the chunk-7 brief §WI-7.6, adapted to the
+// code as it exists at HEAD (anchors re-measured; see the chunk-7 ledger):
+//   snapshot-manifest  → buildSnapshotManifest
+//   candidate-gather   → gatherCandidates (+ its five lane/sub-passes)
+//   salience-score     → scoreSalience (+ outcome/vector/persist sub-passes)
+//   valence-score      → the two computeValenceScore call sites move VERBATIM
+//                        inside the salience passes (pure fn; no separate pass)
+//   standards-context  → does not exist in preparation.ts (assembly lives in
+//                        extract.ts — recorded in the ledger, no empty pass)
+//   eligibility-filter → filterEligibility (+ replay/disk-check sub-passes)
+// Every pass takes an args object and returns its results; the orchestrator
+// folds them. Shared-by-reference structures (the ImproveEligibleRef objects,
+// eligibilitySourceByRef, salienceMap, actions, recentErrors) keep their
+// identity — attribution stamps must travel with the ref objects into the
+// loop stage exactly as before.
+/** Phase 0 — MEMORY.md budget check (200-line cap; warn at 180). */
+function assessMemoryIndexBudget(primaryStashDir) {
+    let warning;
+    // Phase 0 — MEMORY.md budget check (200-line cap; warn at 180)
+    let memoryIndexHealth;
+    if (primaryStashDir) {
+        const memoryMdPath = path.join(primaryStashDir, "memories", "MEMORY.md");
+        if (fs.existsSync(memoryMdPath)) {
+            try {
+                const lines = fs.readFileSync(memoryMdPath, "utf8").split("\n").length;
+                const overBudget = lines >= 180;
+                memoryIndexHealth = { lineCount: lines, overBudget };
+                if (overBudget) {
+                    warning = `MEMORY.md has ${lines} lines (budget: 200). Consolidation strongly recommended.`;
+                }
+            }
+            catch {
+                // best-effort
+            }
+        }
+    }
+    return { memoryIndexHealth, warning };
+}
+/**
+ * Memory-cleanup apply + prune-action recording + the post-cleanup reindex.
+ * Returns the surviving ref set and the prune actions/warnings for the
+ * orchestrator to fold (same order as the old inline pushes).
+ */
+async function applyCleanupPass(args) {
+    const { primaryStashDir, memoryCleanupPlan, plannedRefs, reindexFn, budgetSignal, allowApply } = args;
+    const pruneActions = [];
+    const warnings = [];
     let appliedCleanup;
     try {
         appliedCleanup =
-            primaryStashDir && memoryCleanupPlan ? applyMemoryCleanup(primaryStashDir, memoryCleanupPlan) : undefined;
+            primaryStashDir && memoryCleanupPlan && allowApply
+                ? applyMemoryCleanup(primaryStashDir, memoryCleanupPlan)
+                : undefined;
     }
     catch (err) {
-        cleanupWarnings.push(`applyMemoryCleanup failed: ${err instanceof Error ? err.message : String(err)}`);
+        warnings.push(`applyMemoryCleanup failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     const archivedRefs = appliedCleanup?.archived.map((record) => record.ref) ?? [];
     const removed = new Set(archivedRefs);
@@ -730,7 +745,7 @@ export async function runImprovePreparationStage(args) {
             const archived = appliedCleanup.archived.find((record) => record.ref === candidate.ref);
             if (!archived)
                 continue;
-            actions.push({
+            pruneActions.push({
                 ref: candidate.ref,
                 mode: "memory-prune",
                 result: { ok: true, pruned: true, reason: candidate.reason },
@@ -738,31 +753,17 @@ export async function runImprovePreparationStage(args) {
         }
         if ((appliedCleanup.archived.length > 0 || appliedCleanup.beliefStateTransitions.length > 0) && primaryStashDir) {
             try {
-                await reindexFn({ stashDir: primaryStashDir });
+                await reindexFn({ stashDir: primaryStashDir, signal: budgetSignal });
             }
             catch (err) {
-                cleanupWarnings.push(`reindex after cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
+                warnings.push(`reindex after cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
     }
-    const { validationFailures, validationFailureRefs, schemaRepairs } = await runValidationAndRepairPass({
-        postCleanupRefs,
-        options,
-        startMs,
-        budgetMs,
-        primaryStashDir,
-    });
-    // Phase 0.5 — structural hygiene pass
-    let lintSummary;
-    if (primaryStashDir) {
-        try {
-            const lintResult = akmLint({ fix: true, dir: primaryStashDir });
-            lintSummary = { fixed: lintResult.summary.fixed, flagged: lintResult.summary.flagged };
-        }
-        catch {
-            // lint is best-effort; never block improve
-        }
-    }
+    return { appliedCleanup, postCleanupRefs, pruneActions, warnings };
+}
+/** Seed the per-originator rolling error windows from schema-repair errors. */
+function seedRecentErrorWindows(schemaRepairs) {
     // O-5 / #378: Per-originator rolling error windows.
     // Reflexion (arXiv:2303.11366) warns that cross-task verbal critique
     // contamination degrades below single-shot baseline. Each originator key
@@ -785,6 +786,11 @@ export async function runImprovePreparationStage(args) {
             pushRecentError("schema-repair", errMsg);
         }
     }
+    return recentErrors;
+}
+/** Pass: snapshot-manifest — the three timestamp maps + the 30-day signal window. */
+export function buildSnapshotManifest(args) {
+    const { postCleanupRefs, validationFailureRefs } = args;
     // ── Phase 2: signal-delta eligibility sets built EARLY ────────────────────
     // 0.8.0 replaces the flat time-based cooldowns (which produced synchronised
     // waves whenever many refs cooled at the same instant — see the 2026-05-26
@@ -801,69 +807,235 @@ export async function runImprovePreparationStage(args) {
     // The 30-day FEEDBACK_SIGNAL_WINDOW_DAYS bound still applies — only feedback
     // events newer than that count as "current signal". Ancient one-off
     // negatives don't permanently lock a ref into every run.
-    //
-    // High-retrieval refs (P0-A path) use a simpler "eligible once" rule: a
-    // ref with no feedback signal but retrievalCount ≥ threshold is eligible
-    // exactly once (no prior reflect proposal). Subsequent re-eligibility for
-    // those refs requires either a new feedback event (then the normal
-    // signal-delta gate applies) or human action. Documented limitation: this
-    // path does not re-fire on retrieval-count growth alone in 0.8.0; storing
-    // the retrieval count in proposal metadata for proper delta-tracking is
-    // captured as future work.
     const FEEDBACK_SIGNAL_WINDOW_DAYS = 30;
     const feedbackSinceCutoff = new Date(Date.now() - daysToMs(FEEDBACK_SIGNAL_WINDOW_DAYS)).toISOString();
     // Build the three timestamp maps once across the entire postCleanupRefs set.
     // Per-ref queries would be N+1 and the planner is already the hottest path
     // in `akm improve`.
     const candidateRefs = postCleanupRefs.filter((r) => !validationFailureRefs.has(r.ref)).map((r) => r.ref);
-    const latestFeedbackTs = buildLatestFeedbackTsMap(candidateRefs, feedbackSinceCutoff);
-    const lastReflectProposalTs = buildLatestProposalTsMap(candidateRefs, "reflect");
-    const lastDistillProposalTs = buildLatestProposalTsMap(candidateRefs, "distill");
-    // Refs the distill signal-delta gate rejected at planning time. The main
-    // loop reads this to skip distill for these refs without re-checking
-    // eligibility per iteration.
-    const distillCooledRefs = new Set();
-    const preCooldownCount = postCleanupRefs.length;
-    // ── Phase 3: partition postCleanupRefs by signal-delta eligibility ────────
-    // Three buckets (validation failures are excluded entirely):
-    //   eligibleRefs        — reflect signal-delta passes (full reflect+distill
-    //                         loop path; distill guard remains in the loop for
-    //                         refs that fail the distill signal-delta gate).
-    //   distillOnlyRefs     — reflect blocked but distill signal-delta passes
-    //                         AND ref is a distill candidate.
-    //   noFeedbackPool      — neither signal-delta gate passes *and* the ref has
-    //                         no recent feedback signal at all. These are NOT
-    //                         skipped here: they are handed to the high-retrieval
-    //                         fallback (P0-A) below so frequently-retrieved but
-    //                         never-rated assets can still be improved. Only refs
-    //                         that P0-A declines are ultimately fully skipped.
-    //   fullySkippedCount   — has stale feedback but no signal delta → genuine
-    //                         skip (counted, aggregated event emitted post-loop),
-    //                         excluded from sort.
-    const eligibleRefs = [];
-    const distillOnlyRefs = [];
-    // Zero-(recent-)feedback refs deferred to the P0-A high-retrieval fallback.
-    const noFeedbackPool = [];
-    let fullySkippedCount = 0;
-    // O-2 (#365): explicit --scope <ref> bypasses every gate (user intent wins).
-    const scopeRefBypass = scope.mode === "ref";
-    for (const r of postCleanupRefs) {
-        if (validationFailureRefs.has(r.ref))
+    // Carry each candidate's item_ref into the feedback/proposal timestamp reads.
+    const itemRefByRef = buildItemRefByRef(postCleanupRefs);
+    const latestFeedbackTs = buildLatestFeedbackTsMap(candidateRefs, feedbackSinceCutoff, itemRefByRef);
+    const lastReflectProposalTs = buildLatestProposalTsMap(candidateRefs, "reflect", itemRefByRef);
+    const lastDistillProposalTs = buildLatestProposalTsMap(candidateRefs, "distill", itemRefByRef);
+    return { feedbackSinceCutoff, latestFeedbackTs, lastReflectProposalTs, lastDistillProposalTs };
+}
+/**
+ * Pass: candidate-gather — the signal-delta partition, the bulk feedback
+ * summary, retrieval signals, the Layer-2 proactive and Layer-3 high-salience
+ * rescue lanes, the merged candidate set, and lane attribution stamping.
+ */
+function gatherCandidates(args) {
+    const { scope, options, primaryStashDir, eventsCtx, improveProfile, resolvedPlan, postCleanupRefs } = args;
+    const { feedbackSinceCutoff, lastReflectProposalTs, lastDistillProposalTs } = args.snapshot;
+    const partition = partitionBySignalDelta({
+        scope,
+        options,
+        eventsCtx,
+        postCleanupRefs,
+        validationFailureRefs: args.validationFailureRefs,
+        snapshot: args.snapshot,
+    });
+    const actions = [...partition.actions];
+    const { distillCooledRefs, preCooldownCount, eligibleRefs, distillOnlyRefs, noFeedbackPool, fullySkippedCount } = partition;
+    // ── Phase 4: signal/feedback/utility/sort on the reduced set ──────────────
+    // Everything from here works on (eligibleRefs ∪ distillOnlyRefs) plus the
+    // deferred noFeedbackPool that may be rescued by the proactive-maintenance
+    // (Layer 2) or high-salience (Layer 3) fallbacks below. The fully-skipped
+    // bucket has already been routed and its aggregated event emitted; we
+    // deliberately avoid spending DB/CPU on refs that the signal-delta gate
+    // rejected with feedback already on record.
+    const processableRefs = [...eligibleRefs, ...distillOnlyRefs];
+    const feedbackSummary = buildFeedbackSummaryMap({
+        processableRefs,
+        noFeedbackPool,
+        eventsCtx,
+        feedbackSinceCutoff,
+    });
+    const signalFiltered = processableRefs.filter((candidate) => feedbackSummary.get(candidate.ref)?.hasSignal === true);
+    const signalBearingSet = new Set(signalFiltered.map((r) => r.ref));
+    // Zero-feedback candidates for the proactive/high-salience fallbacks:
+    // processableRefs without a recent signal, plus the deferred noFeedbackPool.
+    // Dedupe by ref (the two sources are disjoint by construction, but guard
+    // against overlap defensively).
+    const noFeedbackSeen = new Set();
+    const noFeedbackCandidates = [];
+    for (const r of [...processableRefs.filter((r) => !signalBearingSet.has(r.ref)), ...noFeedbackPool]) {
+        if (noFeedbackSeen.has(r.ref))
             continue;
-        if (scopeRefBypass) {
-            eligibleRefs.push(r);
+        noFeedbackSeen.add(r.ref);
+        noFeedbackCandidates.push(r);
+    }
+    const { retrievalCounts, lastUseMsForProactive } = fetchRetrievalSignals({
+        options,
+        primaryStashDir,
+        signalFiltered,
+        noFeedbackCandidates,
+    });
+    const proactive = selectProactiveMaintenanceLane({
+        scope,
+        improveProfile,
+        resolvedPlan,
+        eventsCtx,
+        noFeedbackCandidates,
+        lastReflectProposalTs,
+        lastDistillProposalTs,
+        retrievalCounts,
+        lastUseMsForProactive,
+    });
+    const proactiveRefs = proactive.proactiveRefs;
+    const proactiveMaintenanceSummary = proactive.proactiveMaintenanceSummary;
+    const highSalienceRefs = selectHighSalienceLane({
+        options,
+        improveProfile,
+        eventsCtx,
+        noFeedbackCandidates,
+        proactiveRefs,
+        lastReflectProposalTs,
+    });
+    // Record an in-memory skip action for every zero-feedback ref that the
+    // partition loop deferred to the proactive/high-salience fallbacks but those
+    // lanes then declined (not due, below threshold, or a prior reflect proposal
+    // already on record). These never make it into mergedRefs, so without this
+    // they would silently vanish from the run summary. No DB event is written
+    // here — these refs carry no signal at all, so there is nothing for the skip
+    // histogram to aggregate; the action log alone preserves the per-ref audit
+    // trail (mirrors the fully-skipped action above).
+    const rescuedSet = new Set([...proactiveRefs, ...highSalienceRefs].map((r) => r.ref));
+    for (const r of noFeedbackPool) {
+        if (rescuedSet.has(r.ref))
             continue;
-        }
-        const reflectOk = isSignalDeltaEligible(r.ref, latestFeedbackTs, lastReflectProposalTs);
-        const distillOk = isSignalDeltaEligible(r.ref, latestFeedbackTs, lastDistillProposalTs);
-        const isDistillCandidate = isDistillCandidateRef(r.ref, options.stashDir);
-        if (reflectOk) {
-            if (!distillOk && isDistillCandidate) {
-                // Reflect passes the gate, distill does not — emit the synthetic
-                // distill-skipped action and event up-front so the in-loop guard
-                // does not have to re-derive eligibility.
-                distillCooledRefs.add(r.ref);
-                actions.push({ ref: r.ref, mode: "distill-skipped", result: { ok: true, reason: "distill signal-delta" } });
+        actions.push({
+            ref: r.ref,
+            mode: "distill-skipped",
+            result: { ok: true, reason: "no new signal since last proposal" },
+        });
+    }
+    // If the user explicitly scoped to a single ref, always act on it —
+    // skip the signal/retrieval filter entirely. The filter exists to avoid
+    // noisy "improve everything" runs; it should not gate an intentional
+    // per-ref invocation where the user's explicit choice is the signal.
+    //
+    // For type/all scope: only process refs with usage signals (recent feedback
+    // or a proactive/high-salience rescue). A stash with no signals has 0
+    // eligible refs — usage is the gate. Run `akm feedback <ref> --positive` or
+    // retrieve assets to bring them into the eligible pool.
+    // Layer-2 proactive refs join the eligible set alongside feedback-signal
+    // refs. The three sources are disjoint by construction (proactive draws from
+    // noFeedbackCandidates, and high-salience draws from the remainder), but
+    // dedupe defensively so a ref can never enter the loop twice.
+    // `requireFeedbackSignal` still suppresses all fallback sources for callers
+    // that want feedback-only runs.
+    const signalAndRetrievalRefs = dedupeRefs([...signalFiltered, ...proactiveRefs, ...highSalienceRefs]);
+    const mergedRefs = scope.mode === "ref" ? processableRefs : options.requireFeedbackSignal ? signalFiltered : signalAndRetrievalRefs;
+    // ── Attribution tagging: stamp each ref with the eligibility lane that
+    // selected it ──────────────────────────────────────────────────────────────
+    // Every reflect/distill proposal must record WHICH lane chose its source asset
+    // so downstream accept/reject/revert/retrieval outcomes can be sliced by lane
+    // (does the PROACTIVE lane produce value vs the reactive lanes?). We build the
+    // lane map here — the one place all three lanes are known — and stamp it onto
+    // each ImproveEligibleRef object. Because the ref objects are shared by
+    // reference across buckets, the stamp travels with the ref through the sort,
+    // disk-check, and loop stages down to the reflect/distill event emit sites and
+    // createProposal calls. See EligibilitySource for the lane vocabulary.
+    //
+    // Precedence (prefer the most specific reactive signal):
+    //   scope > signal-delta > proactive > high-salience
+    // A ref with real feedback is attributed to feedback even if it was also due
+    // for proactive maintenance or had high encoding salience. We apply lanes
+    // weakest-first so the strongest overwrites; the explicit --scope <ref> bypass
+    // wins outright (user intent).
+    const eligibilitySourceByRef = new Map();
+    for (const r of highSalienceRefs)
+        eligibilitySourceByRef.set(r.ref, "high-salience");
+    for (const r of proactiveRefs)
+        eligibilitySourceByRef.set(r.ref, "proactive");
+    for (const r of signalFiltered)
+        eligibilitySourceByRef.set(r.ref, "signal-delta");
+    if (scope.mode === "ref") {
+        // O-2 (#365): explicit --scope <ref> bypass — every ref in processableRefs
+        // arrived via the scopeRefBypass branch, so attribute the whole set to scope.
+        for (const r of processableRefs)
+            eligibilitySourceByRef.set(r.ref, "scope");
+    }
+    for (const r of mergedRefs) {
+        // "unknown" is a genuine fallback, never a silent alias for signal-delta:
+        // only refs we truly cannot attribute land here (none in practice, since
+        // mergedRefs is always a subset of the four lanes above).
+        r.eligibilitySource = eligibilitySourceByRef.get(r.ref) ?? "unknown";
+    }
+    return {
+        actions,
+        distillCooledRefs,
+        preCooldownCount,
+        distillOnlyRefs,
+        fullySkippedCount,
+        feedbackSummary,
+        signalFiltered,
+        signalBearingSet,
+        retrievalCounts,
+        proactiveRefs,
+        proactiveMaintenanceSummary,
+        highSalienceRefs,
+        signalAndRetrievalRefs,
+        mergedRefs,
+        eligibilitySourceByRef,
+    };
+}
+/**
+ * The signal-delta partition of postCleanupRefs into the four buckets (pass:
+ * candidate-gather, phase 3). The 2026-05-26 54-ref incident semantics move
+ * VERBATIM — see the phase-2/3 comments inside.
+ */
+export function partitionBySignalDelta(args) {
+    const { scope, options, eventsCtx, postCleanupRefs, validationFailureRefs } = args;
+    const { latestFeedbackTs, lastReflectProposalTs, lastDistillProposalTs } = args.snapshot;
+    const actions = [];
+    // Refs the distill signal-delta gate rejected at planning time. The main
+    // loop reads this to skip distill for these refs without re-checking
+    // eligibility per iteration.
+    const distillCooledRefs = new Set();
+    const preCooldownCount = postCleanupRefs.length;
+    // ── Phase 3: partition postCleanupRefs by signal-delta eligibility ────────
+    // Three buckets (validation failures are excluded entirely):
+    //   eligibleRefs        — reflect signal-delta passes (full reflect+distill
+    //                         loop path; distill guard remains in the loop for
+    //                         refs that fail the distill signal-delta gate).
+    //   distillOnlyRefs     — reflect blocked but distill signal-delta passes
+    //                         AND ref is a distill candidate.
+    //   noFeedbackPool      — neither signal-delta gate passes *and* the ref has
+    //                         no recent feedback signal at all. These are NOT
+    //                         skipped here: they are handed to the proactive
+    //                         (Layer 2) and high-salience (Layer 3) fallbacks
+    //                         below so never-rated assets can still be improved.
+    //                         Only refs those lanes decline are fully skipped.
+    //   fullySkippedCount   — has stale feedback but no signal delta → genuine
+    //                         skip (counted, aggregated event emitted post-loop),
+    //                         excluded from sort.
+    const eligibleRefs = [];
+    const distillOnlyRefs = [];
+    // Zero-(recent-)feedback refs deferred to the proactive/high-salience fallbacks.
+    const noFeedbackPool = [];
+    let fullySkippedCount = 0;
+    // O-2 (#365): explicit --scope <ref> bypasses every gate (user intent wins).
+    const scopeRefBypass = scope.mode === "ref";
+    for (const r of postCleanupRefs) {
+        if (validationFailureRefs.has(r.ref))
+            continue;
+        if (scopeRefBypass) {
+            eligibleRefs.push(r);
+            continue;
+        }
+        const reflectOk = isSignalDeltaEligible(r.ref, latestFeedbackTs, lastReflectProposalTs);
+        const distillOk = isSignalDeltaEligible(r.ref, latestFeedbackTs, lastDistillProposalTs);
+        const isDistillCandidate = isDistillCandidateRef(r.ref, options.stashDir);
+        if (reflectOk) {
+            if (!distillOk && isDistillCandidate) {
+                // Reflect passes the gate, distill does not — emit the synthetic
+                // distill-skipped action and event up-front so the in-loop guard
+                // does not have to re-derive eligibility.
+                distillCooledRefs.add(r.ref);
+                actions.push({ ref: r.ref, mode: "distill-skipped", result: { ok: true, reason: "distill signal-delta" } });
                 appendEvent({
                     eventType: "improve_skipped",
                     ref: r.ref,
@@ -883,16 +1055,16 @@ export async function runImprovePreparationStage(args) {
         }
         else if (!latestFeedbackTs.has(r.ref)) {
             // Neither signal-delta gate passes AND there is no recent feedback signal
-            // at all. Rather than skip outright, defer to the high-retrieval fallback
-            // (P0-A) below: a never-rated-but-frequently-retrieved asset is exactly
-            // what that path is meant to rescue. Refs P0-A declines are skipped there.
+            // at all. Rather than skip outright, defer to the proactive-maintenance
+            // and high-salience fallbacks below: a never-rated asset is exactly what
+            // those lanes are meant to rescue. Refs those lanes decline are skipped there.
             noFeedbackPool.push(r);
         }
         else {
             // Has feedback on record but no signal delta since the last proposal —
             // genuinely fully skipped. Counted here; a single aggregated
             // improve_skipped event is emitted after the loop (mirrors
-            // profile_filtered_all_passes) instead of one event per ref.
+            // strategy_filtered_all_passes) instead of one event per ref.
             fullySkippedCount++;
             actions.push({
                 ref: r.ref,
@@ -903,7 +1075,7 @@ export async function runImprovePreparationStage(args) {
     }
     // Emit ONE aggregated skip event for the fully-skipped bucket rather than one
     // improve_skipped event per ref (#592 pattern, mirrors
-    // profile_filtered_all_passes above). The per-ref loop previously produced
+    // strategy_filtered_all_passes above). The per-ref loop previously produced
     // ~11K state.db writes per run on a large stash, the dominant contributor to
     // 900 s timeouts. The in-memory `actions` log keeps the per-ref detail for the
     // run summary; no downstream consumer needs a per-ref DB audit trail (health's
@@ -918,26 +1090,23 @@ export async function runImprovePreparationStage(args) {
             },
         }, eventsCtx);
     }
-    // ── Phase 4: signal/feedback/utility/sort on the reduced set ──────────────
-    // Everything from here works on (eligibleRefs ∪ distillOnlyRefs) plus the
-    // deferred noFeedbackPool that may be rescued by the high-retrieval fallback
-    // (P0-A). The fully-skipped bucket has already been routed and its aggregated
-    // event emitted; we deliberately avoid spending DB/CPU on refs that the
-    // signal-delta gate rejected with feedback already on record.
-    const processableRefs = [...eligibleRefs, ...distillOnlyRefs];
-    // Refs eligible for the high-retrieval fallback (P0-A): the signal-delta
-    // partition above could not place these in a reflect/distill bucket, but they
-    // may still qualify if they have been retrieved often enough. Two disjoint
-    // sources feed this set:
-    //   1. noFeedbackPool — refs with no recent feedback that the partition loop
-    //      deliberately deferred here (otherwise they would never reach P0-A).
-    //   2. processableRefs entries that turn out to carry no recent feedback
-    //      *signal* once feedbackSummary is computed below.
-    // (1) is added here; (2) is folded in after feedbackSummary is built.
+    return {
+        actions,
+        distillCooledRefs,
+        preCooldownCount,
+        eligibleRefs,
+        distillOnlyRefs,
+        noFeedbackPool,
+        fullySkippedCount,
+    };
+}
+/** Bulk per-ref feedback summary in a SINGLE readEvents pass (candidate-gather). */
+function buildFeedbackSummaryMap(args) {
+    const { processableRefs, noFeedbackPool, eventsCtx, feedbackSinceCutoff } = args;
     // Gap 6: only surface feedback signals from the last 30 days so that
     // ancient one-off feedback events don't permanently lock an asset into
     // every improve run. Assets with only stale signals fall through to the
-    // high-retrieval path (P0-A) or are skipped until new signals arrive.
+    // proactive/high-salience fallbacks or are skipped until new signals arrive.
     // (FEEDBACK_SIGNAL_WINDOW_DAYS / feedbackSinceCutoff are already defined in
     // Phase 2 above for the signal-delta gate; we reuse them here.)
     // Pre-compute feedback summary per ref in a SINGLE bulk read so we don't
@@ -946,22 +1115,25 @@ export async function runImprovePreparationStage(args) {
     // above: one readEvents() call fetches ALL feedback events, then we aggregate
     // in-memory by ref — O(1) DB opens regardless of candidate set size.
     // Cover processableRefs *and* the deferred noFeedbackPool so utility/feedback
-    // ratios are available for any noFeedbackPool ref that P0-A rescues below.
+    // ratios are available for any noFeedbackPool ref the fallback lanes rescue below.
     //
     // Behavioral note: positive/negative COUNTS are all-time (same as the old
     // per-ref readEvents call which had no `since` filter); hasSignal is bounded
     // to feedbackSinceCutoff (same as the old inline `(e.ts ?? "") >= cutoff` guard).
     const feedbackSummary = new Map();
     {
-        const feedbackCandidateSet = new Set([...processableRefs, ...noFeedbackPool].map((r) => r.ref));
+        const feedbackCandidates = [...processableRefs, ...noFeedbackPool];
+        const feedbackCandidateSet = new Set(feedbackCandidates.map((r) => r.ref));
+        // Map each candidate's single durable event key back to its display ref.
+        const feedbackRefByDurableKey = new Map(feedbackCandidates.flatMap((r) => improveStateReadRefs(r.ref, r.itemRef).map((key) => [key, r.ref])));
         if (feedbackCandidateSet.size > 0) {
             // Fetch ALL feedback events in one query (no ref filter, no since filter =
             // single full table scan). Filtering per-ref in memory avoids N sequential
             // state.db opens — the dominant FD-leak path on large stashes.
             const { events: allFeedbackEvents } = readEvents({ type: "feedback" }, eventsCtx);
             for (const e of allFeedbackEvents) {
-                const ref = e.ref;
-                if (!ref || !feedbackCandidateSet.has(ref))
+                const ref = e.ref ? feedbackRefByDurableKey.get(e.ref) : undefined;
+                if (!ref)
                     continue;
                 const entry = feedbackSummary.get(ref) ?? { hasSignal: false, positive: 0, negative: 0 };
                 const meta = e.metadata;
@@ -987,22 +1159,11 @@ export async function runImprovePreparationStage(args) {
             }
         }
     }
-    const signalFiltered = processableRefs.filter((candidate) => feedbackSummary.get(candidate.ref)?.hasSignal === true);
-    // P0-A: also surface zero-feedback assets that have been retrieved many times.
-    const RETRIEVAL_COUNT_THRESHOLD = options.minRetrievalCount ?? 5;
-    const signalBearingSet = new Set(signalFiltered.map((r) => r.ref));
-    // Zero-feedback candidates for P0-A: processableRefs without a recent signal,
-    // plus the deferred noFeedbackPool. Dedupe by ref (the two sources are
-    // disjoint by construction, but guard against overlap defensively).
-    const noFeedbackSeen = new Set();
-    const noFeedbackCandidates = [];
-    for (const r of [...processableRefs.filter((r) => !signalBearingSet.has(r.ref)), ...noFeedbackPool]) {
-        if (noFeedbackSeen.has(r.ref))
-            continue;
-        noFeedbackSeen.add(r.ref);
-        noFeedbackCandidates.push(r);
-    }
-    let highRetrievalRefs = [];
+    return feedbackSummary;
+}
+/** Retrieval counts + last-use timestamps for the candidate pools (candidate-gather). */
+function fetchRetrievalSignals(args) {
+    const { options, primaryStashDir, signalFiltered, noFeedbackCandidates } = args;
     // Retrieval counts for the zero-feedback pool, hoisted so the Layer-2
     // proactive-maintenance selector below can reuse them without a second DB pass.
     // Also fetch lastUseMs here for the proactive-maintenance recency term (plan §WS-1
@@ -1012,67 +1173,64 @@ export async function runImprovePreparationStage(args) {
     let dbForRetrieval;
     try {
         dbForRetrieval = openExistingDatabase();
-        const showEventCount = countUsageEventsByType(dbForRetrieval, "show");
-        if (showEventCount === 0) {
-            warn("Warning: show events not yet in usage_events — zero-feedback fallback will match only search-retrieved assets.");
-        }
-        // Fetch retrieval counts for ALL candidates — not only the zero-feedback pool.
-        // Previously only noFeedbackCandidates were looked up, so feedback-bearing refs
-        // had retrievalFreq=0 in computeSalience(), collapsing their retrievalSalience
-        // to 0 regardless of actual use. Two assets of the same type — one
-        // heavily-retrieved, one never-touched — would receive identical rankScores.
-        // Fix (WS-1 blocker 3): union the feedback pool into the lookup.
-        const allCandidateRefs = [...new Set([...signalFiltered, ...noFeedbackCandidates].map((r) => r.ref))];
-        retrievalCounts = getRetrievalCounts(dbForRetrieval, allCandidateRefs);
-        lastUseMsForProactive = getLastUseMsByRef(dbForRetrieval, noFeedbackCandidates.map((r) => r.ref));
-        // High-retrieval signal-delta (simplified rule, 0.8.0): a no-feedback
-        // ref qualifies exactly once — when it has actually been retrieved
-        // (retrievalCount ≥ 1) AND retrievalCount ≥ threshold AND no prior reflect
-        // proposal exists for it. Once a reflect proposal is on record, subsequent
-        // re-eligibility requires explicit feedback (which flows through the normal
-        // signal-delta gate above). The explicit `> 0` guard keeps a threshold of 0
-        // from rescuing genuinely never-retrieved assets — the fallback is for
-        // *retrieved* assets, not silent ones. Tracking growth in retrieval count
-        // would require persisting the count in proposal metadata; deferred to a
-        // follow-up.
-        highRetrievalRefs = noFeedbackCandidates.filter((r) => {
-            const count = retrievalCounts.get(r.ref) ?? 0;
-            return count > 0 && count >= RETRIEVAL_COUNT_THRESHOLD && !lastReflectProposalTs.has(r.ref);
+        // usage_events lives in state.db (Chunk-8 WI-8.3); entries stay in index.db,
+        // so the retrieval-count reads take both handles.
+        const dbForRetrievalIndex = dbForRetrieval;
+        withStateDb((stateDb) => {
+            const showEventCount = countUsageEventsByType(stateDb, "show");
+            if (showEventCount === 0) {
+                warn("Warning: show events not yet in usage_events — zero-feedback fallback will match only search-retrieved assets.");
+            }
+            // Fetch retrieval counts for ALL candidates — not only the zero-feedback pool.
+            // Previously only noFeedbackCandidates were looked up, so feedback-bearing refs
+            // had retrievalFreq=0 in computeSalience(), collapsing their retrievalSalience
+            // to 0 regardless of actual use. Two assets of the same type — one
+            // heavily-retrieved, one never-touched — would receive identical rankScores.
+            // Fix (WS-1 blocker 3): union the feedback pool into the lookup.
+            const allCandidateRefs = [...new Set([...signalFiltered, ...noFeedbackCandidates].map((r) => r.ref))];
+            retrievalCounts = getRetrievalCounts(dbForRetrievalIndex, stateDb, allCandidateRefs, {
+                sourceName: options.sourceName,
+                stashDir: primaryStashDir,
+            });
         });
+        lastUseMsForProactive = getLastUseMsByRef(dbForRetrieval, noFeedbackCandidates.map((r) => r.ref), primaryStashDir);
     }
     catch (err) {
         rethrowIfTestIsolationError(err);
-        // best-effort: if DB unavailable, highRetrievalRefs stays empty
+        // best-effort: if DB unavailable, retrievalCounts/lastUseMsForProactive stay empty
     }
     finally {
         if (dbForRetrieval)
             closeDatabase(dbForRetrieval);
     }
-    // ── Layer 2: PROACTIVE MAINTENANCE SELECTOR (third eligibility source) ─────
-    // The signal-delta gate and P0-A only surface assets with fresh feedback or a
-    // raw-retrieval spike. Neither revisits a stable, high-value asset on a
-    // schedule, so on a quiet stash useful assets drift stale and are never
-    // refreshed. When the `proactiveMaintenance` process is enabled (DEFAULT OFF)
+    return { retrievalCounts, lastUseMsForProactive };
+}
+/** Layer 2 — the proactive-maintenance selector lane (candidate-gather). */
+function selectProactiveMaintenanceLane(args) {
+    const { scope, improveProfile, resolvedPlan, eventsCtx, noFeedbackCandidates, lastReflectProposalTs, lastDistillProposalTs, retrievalCounts, lastUseMsForProactive, } = args;
+    // ── Layer 2: PROACTIVE MAINTENANCE SELECTOR (second eligibility source) ────
+    // The signal-delta gate only surfaces assets with fresh feedback. It never
+    // revisits a stable, high-value asset on a schedule, so on a quiet stash
+    // useful assets drift stale and are never refreshed. When the
+    // `proactiveMaintenance` process is enabled (DEFAULT OFF)
     // and the run is whole-stash / type scope, this selector ranks the eligible
     // population by a composite maintenance priority, gates on staleness ("due"),
     // bounds to top-N, and folds the winners into the SAME candidate set the other
-    // two sources feed — so they flow through the existing #580 empty-diff /
+    // sources feed — so they flow through the existing #580 empty-diff /
     // cosmetic suppression and additive-distill gates. It adds no new mutation
     // logic of its own. The due gate doubles as the rotation cooldown: a freshly
     // reflected asset is excluded until it ages back past `dueDays`, so successive
     // runs rotate through the due pool rather than re-selecting the same heads.
     let proactiveRefs = [];
     let proactiveMaintenanceSummary;
-    const proactiveEnabled = scope.mode !== "ref" && resolveProcessEnabled("proactiveMaintenance", improveProfile);
+    const proactiveEnabled = scope.mode !== "ref" && resolvedPlan.processes.proactiveMaintenance.enabled;
     if (proactiveEnabled) {
         const pmCfg = improveProfile.processes?.proactiveMaintenance;
         const dueDays = pmCfg?.dueDays ?? DEFAULT_DUE_DAYS;
         const maxPerRun = pmCfg?.maxPerRun ?? pmCfg?.limit ?? DEFAULT_MAX_PER_RUN;
         // Candidate population: the zero-feedback / non-signal pool — exactly the
-        // assets the other two sources would NOT pick this run. Exclude any P0-A
-        // rescued this run so we never double-select the same ref.
-        const alreadySelected = new Set(highRetrievalRefs.map((r) => r.ref));
-        const pmCandidates = noFeedbackCandidates.filter((r) => !alreadySelected.has(r.ref));
+        // assets the signal-delta gate would NOT pick this run.
+        const pmCandidates = noFeedbackCandidates;
         const selection = selectProactiveMaintenanceRefs({
             candidates: pmCandidates,
             lastReflectTs: lastReflectProposalTs,
@@ -1116,6 +1274,11 @@ export async function runImprovePreparationStage(args) {
                 `(${selection.neverReflected} never reflected, dueDays=${dueDays}, maxPerRun=${maxPerRun})`);
         }
     }
+    return { proactiveRefs, proactiveMaintenanceSummary };
+}
+/** Layer 3 — the high-salience admission gate (#608/#644; candidate-gather). */
+function selectHighSalienceLane(args) {
+    const { options, improveProfile, eventsCtx, noFeedbackCandidates, proactiveRefs, lastReflectProposalTs } = args;
     // ── Layer 3: HIGH-SALIENCE ADMISSION GATE (#608) ──────────────────────────
     // Zero-feedback refs whose encoding_salience (set at distill time by
     // scoreEncodingSalience) exceeds the configured salienceThreshold are admitted
@@ -1128,11 +1291,11 @@ export async function runImprovePreparationStage(args) {
     //
     // Cooldown: a ref qualifies at most once — when no prior reflect proposal
     // exists for it (`!lastReflectProposalTs.has`). Without this guard the lane
-    // re-selects the same high-salience refs on EVERY run (auto-accept emits a
+    // re-selects the same high-salience refs on EVERY run (promotion emits a
     // `promoted` event, not `feedback`, so the ref never leaves
     // noFeedbackCandidates), burning LLM calls and churning the asset. This
-    // mirrors the P0-A high-retrieval gate's `!lastReflectProposalTs.has(r.ref)`
-    // guard above so all "rescue" lanes share the same once-per-asset semantics.
+    // mirrors the same `!lastReflectProposalTs.has(r.ref)` once-per-asset
+    // semantics the other "rescue" lanes share.
     //
     // Content-provenance gate (#644 follow-up): the row must ALSO carry a genuine
     // content-derived encoding score (`isContentEncodingRow`). Otherwise the lane
@@ -1144,11 +1307,11 @@ export async function runImprovePreparationStage(args) {
     // earn retrieval/feedback signal via the other lanes. This PRESERVES #608's
     // intent — distilled assets (the lane's real targets) keep their real content
     // score and still qualify — while cutting the type-stub waste. See §5 F1 of
-    // docs/design/improve-salience-working-reference.md and #608/#644.
+    // #608/#644.
     const highSalienceRefs = [];
     const salienceCfg = (options.config ?? loadConfig()).improve?.salience;
     const salienceThreshold = salienceCfg?.salienceThreshold ?? 0.75;
-    const proactiveAndRetrievalSet = new Set([...highRetrievalRefs, ...proactiveRefs].map((r) => r.ref));
+    const proactiveSelectedSet = new Set(proactiveRefs.map((r) => r.ref));
     try {
         withStateDb((dbForHighSalience) => {
             // Derive the cap from the resolved reflect limit (mirrors improve.ts's
@@ -1156,15 +1319,15 @@ export async function runImprovePreparationStage(args) {
             // collapse the lane to exactly 1 ref via the bare `?? 10` fallback.
             const effectiveLimit = options.limit ?? improveProfile?.processes?.reflect?.limit ?? improveProfile.limit ?? 10;
             const highSalienceCap = Math.max(1, Math.floor(effectiveLimit * 0.1));
-            const candidates = noFeedbackCandidates.filter((r) => !proactiveAndRetrievalSet.has(r.ref));
+            const candidates = noFeedbackCandidates.filter((r) => !proactiveSelectedSet.has(r.ref));
             // Collect ALL qualifying candidates, then take the top-N BY SCORE — the
             // previous first-N-in-scan-order break meant a higher-salience candidate
             // found later in the scan lost its slot to an earlier lower-scoring one.
             const qualifying = [];
             for (const r of candidates) {
-                const row = getAssetSalience(dbForHighSalience, r.ref);
+                const row = readAssetSalienceForImproveRef(dbForHighSalience, r.ref, r.itemRef);
                 if (row &&
-                    isContentEncodingRow(row, parseAssetRef(r.ref).type) &&
+                    isContentEncodingRow(row) &&
                     row.encoding_salience >= salienceThreshold &&
                     !lastReflectProposalTs.has(r.ref)) {
                     qualifying.push({ ref: r, score: row.encoding_salience });
@@ -1184,108 +1347,39 @@ export async function runImprovePreparationStage(args) {
         info(`[improve] high-salience lane admitted ${highSalienceRefs.length} content-scored ref(s) ` +
             `(threshold=${salienceThreshold}, requires content-derived encoding_source)`);
     }
-    // Record an in-memory skip action for every zero-feedback ref that the
-    // partition loop deferred to P0-A but P0-A then declined (retrievalCount below
-    // threshold, or a prior reflect proposal already on record). These never make
-    // it into mergedRefs, so without this they would silently vanish from the run
-    // summary. No DB event is written here — these refs carry no signal at all, so
-    // there is nothing for the skip histogram to aggregate; the action log alone
-    // preserves the per-ref audit trail (mirrors the fully-skipped action above).
-    const rescuedSet = new Set([...highRetrievalRefs, ...proactiveRefs, ...highSalienceRefs].map((r) => r.ref));
-    for (const r of noFeedbackPool) {
-        if (rescuedSet.has(r.ref))
-            continue;
-        actions.push({
-            ref: r.ref,
-            mode: "distill-skipped",
-            result: { ok: true, reason: "no new signal since last proposal" },
-        });
-    }
-    // If the user explicitly scoped to a single ref, always act on it —
-    // skip the signal/retrieval filter entirely. The filter exists to avoid
-    // noisy "improve everything" runs; it should not gate an intentional
-    // per-ref invocation where the user's explicit choice is the signal.
-    //
-    // For type/all scope: only process refs with usage signals (recent feedback
-    // or sufficient retrievals). A stash with no signals has 0 eligible refs —
-    // usage is the gate. Run `akm feedback <ref> --positive` or retrieve assets
-    // to bring them into the eligible pool.
-    // Layer-2 proactive refs join the eligible set alongside feedback-signal and
-    // high-retrieval (P0-A) refs. The four sources are disjoint by construction
-    // (proactive draws from noFeedbackCandidates with the P0-A picks removed, and
-    // high-salience draws from the remainder), but dedupe defensively so a ref can
-    // never enter the loop twice. `requireFeedbackSignal` still suppresses all
-    // fallback sources for callers that want feedback-only runs.
-    const signalAndRetrievalRefs = dedupeRefs([
-        ...signalFiltered,
-        ...highRetrievalRefs,
-        ...proactiveRefs,
-        ...highSalienceRefs,
-    ]);
-    let mergedRefs = scope.mode === "ref" ? processableRefs : options.requireFeedbackSignal ? signalFiltered : signalAndRetrievalRefs;
-    // ── Attribution tagging: stamp each ref with the eligibility lane that
-    // selected it ──────────────────────────────────────────────────────────────
-    // Every reflect/distill proposal must record WHICH lane chose its source asset
-    // so downstream accept/reject/revert/retrieval outcomes can be sliced by lane
-    // (does the PROACTIVE lane produce value vs the reactive lanes?). We build the
-    // lane map here — the one place all four lanes are known — and stamp it onto
-    // each ImproveEligibleRef object. Because the ref objects are shared by
-    // reference across buckets, the stamp travels with the ref through the sort,
-    // disk-check, and loop stages down to the reflect/distill event emit sites and
-    // createProposal calls. See EligibilitySource for the lane vocabulary.
-    //
-    // Precedence (prefer the most specific reactive signal):
-    //   scope > signal-delta > high-retrieval > proactive > high-salience
-    // A ref with real feedback is attributed to feedback even if it was also due
-    // for proactive maintenance or had high encoding salience. We apply lanes
-    // weakest-first so the strongest overwrites; the explicit --scope <ref> bypass
-    // wins outright (user intent).
-    const eligibilitySourceByRef = new Map();
-    for (const r of highSalienceRefs)
-        eligibilitySourceByRef.set(r.ref, "high-salience");
-    for (const r of proactiveRefs)
-        eligibilitySourceByRef.set(r.ref, "proactive");
-    for (const r of highRetrievalRefs)
-        eligibilitySourceByRef.set(r.ref, "high-retrieval");
-    for (const r of signalFiltered)
-        eligibilitySourceByRef.set(r.ref, "signal-delta");
-    if (scope.mode === "ref") {
-        // O-2 (#365): explicit --scope <ref> bypass — every ref in processableRefs
-        // arrived via the scopeRefBypass branch, so attribute the whole set to scope.
-        for (const r of processableRefs)
-            eligibilitySourceByRef.set(r.ref, "scope");
-    }
-    for (const r of mergedRefs) {
-        // "unknown" is a genuine fallback, never a silent alias for signal-delta:
-        // only refs we truly cannot attribute land here (none in practice, since
-        // mergedRefs is always a subset of the four lanes above).
-        r.eligibilitySource = eligibilitySourceByRef.get(r.ref) ?? "unknown";
-    }
+    return highSalienceRefs;
+}
+/**
+ * Pass: salience-score — the WS-2 outcome loop, the WS-1 salience vector
+ * computation (#644 provenance preserved), persistence + rank-change report,
+ * and the forgetting-safety injection. The valence-score call sites
+ * (computeValenceScore) live VERBATIM inside the outcome/persist sub-passes.
+ * Mutates the shared eligibilitySourceByRef map and ref objects in place —
+ * attribution identity is load-bearing (see the candidate-gather comments).
+ */
+function scoreSalience(args) {
+    const { scope, options, primaryStashDir, eventsCtx, eligibilitySourceByRef, feedbackSummary, retrievalCounts, signalFiltered, proactiveRefs, highSalienceRefs, } = args;
+    const mergedRefs = args.mergedRefs;
+    // Chunk-5 flip F5e — resolve each candidate's durable item_ref ONCE for this
+    // pass (the write/read key source for the outcome + salience state writers).
+    const itemRefByRef = buildItemRefByRef(mergedRefs);
     // WS-1 — Unified salience vector (S1 seam).
     //
-    // The legacy sort combined three independent formulas (utility EMA, negative-only
-    // ratio / symmetric-valence magnitude, and the proactive-maintenance priority
-    // formula). WS-1 converges them into one `computeSalience()` call per ref, with
+    // WS-1 converges utility, valence, and proactive-maintenance signals into one
+    // `computeSalience()` call per ref, with
     // three independently-stored sub-scores and one documented rankScore projection.
     //
-    // Migration note: if a profile still has `symmetricValence` set, emit a one-time
-    // warning — its behaviour (symmetric |valence| attention) is now always-on as
-    // part of the salience vector, so the knob is a no-op and will be removed in 0.10.
-    if (improveProfile.symmetricValence === true) {
-        warn("[improve] Profile option 'symmetricValence' is deprecated (WS-1 salience vector). " +
-            "Symmetric valence is now always active; remove the option from your improve profile.");
-    }
     // Fetch last-use timestamps from the index DB for the full merged set so the
     // recency term in retrievalSalience is genuinely decayable (plan §WS-1 step 2).
     // This reuses the index DB opened earlier for retrieval counts; a separate
     // lightweight open is used here to avoid holding the connection longer than needed.
     let lastUseMsByRef = new Map();
-    // utilityMap is kept for backward-compatible observability (health report reads it).
+    // Health and outcome reporting consume the utility projection.
     const utilityMap = buildUtilityMap(mergedRefs);
     let dbForSalience;
     try {
         dbForSalience = openExistingDatabase();
-        lastUseMsByRef = getLastUseMsByRef(dbForSalience, mergedRefs.map((r) => r.ref));
+        lastUseMsByRef = getLastUseMsByRef(dbForSalience, mergedRefs.map((r) => r.ref), primaryStashDir);
     }
     catch (err) {
         rethrowIfTestIsolationError(err);
@@ -1295,6 +1389,49 @@ export async function runImprovePreparationStage(args) {
         if (dbForSalience)
             closeDatabase(dbForSalience);
     }
+    const outcomeSalienceByRef = updateOutcomeScores({
+        mergedRefs,
+        itemRefByRef,
+        feedbackSummary,
+        retrievalCounts,
+        lastUseMsByRef,
+        utilityMap,
+        primaryStashDir,
+        eventsCtx,
+    });
+    const { salienceMap, nowForSalience } = computeSalienceVectors({
+        mergedRefs,
+        itemRefByRef,
+        options,
+        eventsCtx,
+        retrievalCounts,
+        lastUseMsByRef,
+        utilityMap,
+        outcomeSalienceByRef,
+    });
+    const pendingForgettingRefs = persistSalienceAndReportRanks({
+        salienceMap,
+        itemRefByRef,
+        utilityMap,
+        feedbackSummary,
+        options,
+        eventsCtx,
+        nowForSalience,
+    });
+    const finalMergedRefs = applyForgettingSafety({
+        pendingForgettingRefs,
+        scope,
+        mergedRefs,
+        eligibilitySourceByRef,
+        highSalienceRefs,
+        proactiveRefs,
+        signalFiltered,
+    });
+    return { mergedRefs: finalMergedRefs, utilityMap, lastUseMsByRef, salienceMap, nowForSalience };
+}
+/** WS-2 — update asset_outcome for the merged set; returns outcomeSalience by ref. */
+function updateOutcomeScores(args) {
+    const { mergedRefs, itemRefByRef, feedbackSummary, retrievalCounts, lastUseMsByRef, utilityMap, primaryStashDir, eventsCtx, } = args;
     // ── WS-2 Outcome loop ─────────────────────────────────────────────────────
     //
     // Update asset_outcome for every ref in the merged set BEFORE computing the
@@ -1336,7 +1473,9 @@ export async function runImprovePreparationStage(args) {
                 const valenceResult = computeValenceScore(fb);
                 try {
                     const result = updateAssetOutcome(outcomeDb, {
-                        ref: r.ref,
+                        // Key by item_ref when resolved, else by the conceptId. Keep
+                        // rawOutcomeScores keyed by r.ref, its in-memory identity.
+                        ref: outcomeWriteKey(r.ref, itemRefByRef),
                         currentRetrievalCount: retrievalCounts.get(r.ref) ?? 0,
                         lastRetrievedAt: lastUseMsByRef.get(r.ref) ?? 0,
                         acceptedChangeCount: acceptedCountByRef.get(r.ref) ?? 0,
@@ -1361,10 +1500,7 @@ export async function runImprovePreparationStage(args) {
                     if (row.outcome_score > maxOutcomeScore)
                         maxOutcomeScore = row.outcome_score;
                 }
-                // Read-clip: legacy rows written before the OUTCOME_SCORE_MAX write-clip
-                // existed can sit above the ceiling (live max was 3.13). Without this
-                // clip they inflate the normalisation denominator and floor everyone
-                // else's outcomeSalience (#691 follow-up).
+                // Keep the normalization denominator within the writer's score bounds.
                 maxOutcomeScore = Math.min(maxOutcomeScore, OUTCOME_SCORE_MAX);
                 // Proxy-adequacy tripwire (two-tailed): inverted (corr < −0.3) and
                 // dead (|corr| < 0.1 at n ≥ 500) both emit health events.
@@ -1402,11 +1538,18 @@ export async function runImprovePreparationStage(args) {
             }
             // Also fetch outcome scores for refs NOT updated this run (stale or absent)
             // so the outcomeSalience read path works for all refs in the batch.
+            // Chunk-5 flip F5e — query by each missing ref's WRITE key (item_ref,
+            // else bare) and map the stored-key result back to the bare `r.ref`
+            // identity that outcomeSalienceByRef is keyed on.
             const missingRefs = mergedRefs.map((r) => r.ref).filter((ref) => !rawOutcomeScores.has(ref));
             if (missingRefs.length > 0) {
-                const storedScores = getOutcomeScoresByRef(outcomeDb, missingRefs);
-                for (const [ref, score] of storedScores) {
-                    outcomeSalienceByRef.set(ref, outcomeScoreToSalience(score, maxOutcomeScore));
+                const refByWriteKey = new Map();
+                for (const ref of missingRefs)
+                    refByWriteKey.set(outcomeWriteKey(ref, itemRefByRef), ref);
+                const storedScores = getOutcomeScoresByRef(outcomeDb, [...refByWriteKey.keys()]);
+                for (const [writeKey, score] of storedScores) {
+                    const bareRef = refByWriteKey.get(writeKey) ?? writeKey;
+                    outcomeSalienceByRef.set(bareRef, outcomeScoreToSalience(score, maxOutcomeScore));
                 }
             }
         }, { path: eventsCtx?.dbPath, borrowed: eventsCtx?.db });
@@ -1415,6 +1558,11 @@ export async function runImprovePreparationStage(args) {
         rethrowIfTestIsolationError(err);
         // best-effort: outcome failures never block salience computation
     }
+    return outcomeSalienceByRef;
+}
+/** WS-1 — compute the salience vector per ref (#644 provenance preserved). */
+function computeSalienceVectors(args) {
+    const { mergedRefs, itemRefByRef, options, eventsCtx, retrievalCounts, lastUseMsByRef, utilityMap, outcomeSalienceByRef, } = args;
     // Compute the salience vector for every ref in the merged set.
     // retrievalCounts now covers the full candidate set (feedback-bearing + zero-feedback)
     // so feedback refs get their genuine retrieval frequency, not a 0-floor fallback.
@@ -1440,9 +1588,8 @@ export async function runImprovePreparationStage(args) {
     try {
         withStateDb((dbForStoredEncoding) => {
             for (const r of mergedRefs) {
-                const type = r.ref.includes(":") ? r.ref.slice(0, r.ref.indexOf(":")) : "";
-                const row = getAssetSalience(dbForStoredEncoding, r.ref);
-                if (row && isContentEncodingRow(row, type)) {
+                const row = readAssetSalienceForImproveRef(dbForStoredEncoding, r.ref, itemRefByRef.get(r.ref));
+                if (row && isContentEncodingRow(row)) {
                     storedEncodingByRef.set(r.ref, row.encoding_salience);
                 }
             }
@@ -1453,7 +1600,7 @@ export async function runImprovePreparationStage(args) {
         // best-effort: if DB unavailable, fall back to type-weight stub (prior behaviour)
     }
     for (const r of mergedRefs) {
-        const type = r.ref.includes(":") ? r.ref.slice(0, r.ref.indexOf(":")) : "";
+        const type = assetTypeOf(r.ref);
         const sizeBytes = (() => {
             const fp = r.filePath;
             if (!fp)
@@ -1482,6 +1629,40 @@ export async function runImprovePreparationStage(args) {
         });
         salienceMap.set(r.ref, vector);
     }
+    return { salienceMap, nowForSalience };
+}
+/** 1-indexed rank positions sorted by score desc (deterministic ref-asc tie-break). */
+function toRankPositions(scores) {
+    const sorted = [...scores.entries()].sort(([refA, a], [refB, b]) => b !== a ? b - a : refA < refB ? -1 : refA > refB ? 1 : 0);
+    return new Map(sorted.map(([ref], i) => [ref, i + 1]));
+}
+/**
+ * Chunk-5 flip F5e — the durable salience write-key maps for one improve pass.
+ * `wk(ref)` is a pool asset's write key (item_ref, else conceptId);
+ * `normalizeStoredKey` maps each in-pool asset's durable spelling to its write
+ * key (no stashSize double-count); and
+ * `refByWriteKey` reverses a write key back to its filesystem-facing bare ref.
+ */
+function buildSalienceWriteKeyMaps(itemRefByRef) {
+    const wk = (ref) => salienceWriteKey(ref, itemRefByRef);
+    const normalizeStoredKey = new Map();
+    const refByWriteKey = new Map();
+    for (const [ref, itemRef] of itemRefByRef) {
+        const writeKey = wk(ref);
+        refByWriteKey.set(writeKey, ref);
+        for (const spelling of improveStateReadRefs(ref, itemRef)) {
+            normalizeStoredKey.set(spelling, writeKey);
+        }
+    }
+    return { wk, normalizeStoredKey, refByWriteKey };
+}
+/** Persist salience vectors + the WS-1 step-7 rank-change/forgetting report. */
+function persistSalienceAndReportRanks(args) {
+    const { salienceMap, itemRefByRef, utilityMap, feedbackSummary, options, eventsCtx, nowForSalience } = args;
+    // Chunk-5 flip F5e — the WRITE-key space. salienceMap stays keyed by each
+    // candidate's own short `r.ref`; the state.db boundary keys by item_ref when
+    // available and otherwise by conceptId.
+    const { wk, normalizeStoredKey, refByWriteKey } = buildSalienceWriteKeyMaps(itemRefByRef);
     // Persist salience vectors to state.db (best-effort, non-blocking).
     // The canonical store enables WS-3 homeostatic demotion and WS-2 outcome reads.
     //
@@ -1504,7 +1685,7 @@ export async function runImprovePreparationStage(args) {
     //    stash-wide), but it is the most faithful comparison possible at cutover and
     //    allows the top-200→below-500 forgetting guard to fire if the formula change
     //    dramatically reorders the candidate pool.
-    //    See docs/archive/improve-reconciliation-plan.md §WS-1 step 7 — the stash-wide
+    //    WS-1 step 7 — the stash-wide
     //    ordering was unreconstructable (no prior state.db snapshot), so this candidate-
     //    pool partial reconstruction is the documented resolution for the first-run case.
     //    Emit `improve_salience_first_run` to mark the cutover moment and include the
@@ -1534,7 +1715,21 @@ export async function runImprovePreparationStage(args) {
             // Step 7: stash-wide rank-change report BEFORE overwriting the table.
             //
             // Load ALL existing rows so rank positions are stash-relative, not pool-relative.
-            const existingAllScores = getAllRankScores(stateDb);
+            // Source-scope by the `<bundle>//` prefix and fold each in-pool asset's
+            // stored spelling onto its single write key so
+            // the merge below never double-counts one asset across two spellings.
+            const allStoredScores = getAllRankScores(stateDb);
+            const existingAllScores = new Map();
+            for (const [ref, score] of allStoredScores) {
+                if (options.sourceName) {
+                    const boundary = ref.indexOf("//");
+                    const prefix = boundary >= 0 ? ref.slice(0, boundary) : undefined;
+                    const belongs = prefix === options.sourceName;
+                    if (!belongs)
+                        continue;
+                }
+                existingAllScores.set(normalizeStoredKey.get(ref) ?? ref, score);
+            }
             if (existingAllScores.size === 0) {
                 // Scenario A: first WS-1 run — table empty.
                 //
@@ -1546,7 +1741,7 @@ export async function runImprovePreparationStage(args) {
                 // Limitation: this covers only the current-run candidate pool, not the full
                 // stash. The stash-wide ordering was never persisted (asset_salience is a new
                 // WS-1 table), so this is the most faithful comparison possible at cutover.
-                // See docs/archive/improve-reconciliation-plan.md §WS-1 step 7.
+                // WS-1 step 7.
                 const reconstructedOldScores = new Map();
                 for (const ref of salienceMap.keys()) {
                     const utility = utilityMap.get(ref) ?? 0;
@@ -1555,12 +1750,8 @@ export async function runImprovePreparationStage(args) {
                     reconstructedOldScores.set(ref, utility * UTILITY_WEIGHT + attention * FEEDBACK_WEIGHT);
                 }
                 // Assign 1-indexed rank positions sorted by score desc (tie-break: ref asc).
-                const toRanks = (scores) => {
-                    const sorted = [...scores.entries()].sort(([refA, a], [refB, b]) => b !== a ? b - a : refA < refB ? -1 : refA > refB ? 1 : 0);
-                    return new Map(sorted.map(([ref], i) => [ref, i + 1]));
-                };
-                const oldRanks = toRanks(reconstructedOldScores);
-                const newRanks = toRanks(new Map([...salienceMap.entries()].map(([ref, v]) => [ref, v.rankScore])));
+                const oldRanks = toRankPositions(reconstructedOldScores);
+                const newRanks = toRankPositions(new Map([...salienceMap.entries()].map(([ref, v]) => [ref, v.rankScore])));
                 const firstRunReport = buildRankChangeReport(oldRanks, newRanks);
                 if (firstRunReport.forgettingCandidates.length > 0) {
                     warn(`[improve/salience] WS-1 first-run rank-change report: ${firstRunReport.forgettingCandidates.length} asset(s) fell from top-200 to below position 500 (cutover formula change). ` +
@@ -1575,7 +1766,7 @@ export async function runImprovePreparationStage(args) {
                     ref: undefined,
                     metadata: {
                         candidateCount: salienceMap.size,
-                        note: "first WS-1 salience run — partial reconstruction of old combinedEligibilityScore ordering for candidate pool (stash-wide ordering not available); see improve-reconciliation-plan.md §WS-1 step 7",
+                        note: "first WS-1 salience run — partial reconstruction of old combinedEligibilityScore ordering for candidate pool (stash-wide ordering not available); WS-1 step 7",
                         forgettingCandidates: firstRunReport.forgettingCandidates.length,
                         topDrops: firstRunReport.forgettingCandidates.slice(0, 10).map((e) => ({
                             ref: e.ref,
@@ -1594,15 +1785,13 @@ export async function runImprovePreparationStage(args) {
                 // picture of what the new ordering looks like after this run.
                 const mergedNewScores = new Map(existingAllScores);
                 for (const [ref, vector] of salienceMap) {
-                    mergedNewScores.set(ref, vector.rankScore);
+                    // Chunk-5 flip F5e — key this run's fresh scores by the WRITE key so
+                    // they overwrite (never duplicate) the same asset's normalized stored row.
+                    mergedNewScores.set(wk(ref), vector.rankScore);
                 }
                 // Assign 1-indexed rank positions sorted by score desc (tie-break: ref asc).
-                const toRanks = (scores) => {
-                    const sorted = [...scores.entries()].sort(([refA, a], [refB, b]) => b !== a ? b - a : refA < refB ? -1 : refA > refB ? 1 : 0);
-                    return new Map(sorted.map(([ref], i) => [ref, i + 1]));
-                };
-                const oldRanks = toRanks(existingAllScores);
-                const newRanks = toRanks(mergedNewScores);
+                const oldRanks = toRankPositions(existingAllScores);
+                const newRanks = toRankPositions(mergedNewScores);
                 const report = buildRankChangeReport(oldRanks, newRanks);
                 if (report.forgettingCandidates.length > 0) {
                     warn(`[improve/salience] WS-1 rank-change report: ${report.forgettingCandidates.length} asset(s) fell from top-200 to below position 500. ` +
@@ -1613,7 +1802,11 @@ export async function runImprovePreparationStage(args) {
                     // Collect refs for protective consolidation pass (plan §WS-1 step 7).
                     // These are force-included in the candidate pool (mergedRefs) after
                     // this try block, bypassing cooldown/signal-delta gating.
-                    pendingForgettingRefs = report.forgettingCandidates.map((e) => e.ref);
+                    // Chunk-5 flip F5e — map an in-pool candidate's write-key spelling
+                    // back to its bare `r.ref` so applyForgettingSafety re-stamps the
+                    // existing pool ref; a genuinely stash-wide (out-of-pool) candidate
+                    // keeps its stored spelling and is synthesised as a fresh stub.
+                    pendingForgettingRefs = report.forgettingCandidates.map((e) => refByWriteKey.get(e.ref) ?? e.ref);
                 }
                 appendEvent({
                     eventType: "improve_salience_rank_change",
@@ -1631,7 +1824,8 @@ export async function runImprovePreparationStage(args) {
                 }, eventsCtx);
             }
             for (const [ref, vector] of salienceMap) {
-                upsertAssetSalience(stateDb, ref, vector, nowForSalience);
+                // Persist salience under item_ref when resolved, else the conceptId.
+                upsertAssetSalience(stateDb, wk(ref), vector, nowForSalience);
             }
         }, { path: eventsCtx?.dbPath });
     }
@@ -1639,6 +1833,16 @@ export async function runImprovePreparationStage(args) {
         rethrowIfTestIsolationError(err);
         // best-effort: salience persistence failure never blocks ranking
     }
+    return pendingForgettingRefs;
+}
+/**
+ * The protective forgetting-safety injection (plan §WS-1 step 7). Returns the
+ * (possibly extended) mergedRefs; re-stamps lane attribution in precedence
+ * order on the SHARED ref objects and eligibilitySourceByRef map.
+ */
+export function applyForgettingSafety(args) {
+    const { pendingForgettingRefs, scope, eligibilitySourceByRef, highSalienceRefs, proactiveRefs, signalFiltered } = args;
+    let mergedRefs = args.mergedRefs;
     // ── Protective consolidation pass (plan §WS-1 step 7) ─────────────────────
     // Forgetting candidates detected in scenario B are force-injected into
     // mergedRefs here, BEFORE the effectiveScore sort, bypassing cooldown and
@@ -1657,8 +1861,8 @@ export async function runImprovePreparationStage(args) {
                 newForgettingRefs.push({ ref, reason: "scope-type", eligibilitySource: "forgetting-safety" });
             }
             // Always stamp the lane in the attribution map (overwrites weaker lanes;
-            // stronger reactive signals — scope/signal-delta/high-retrieval/proactive
-            // — are written after this block so they take precedence).
+            // stronger reactive signals — scope/signal-delta/proactive — are written
+            // after this block so they take precedence).
             eligibilitySourceByRef.set(ref, "forgetting-safety");
         }
         if (newForgettingRefs.length > 0) {
@@ -1666,25 +1870,23 @@ export async function runImprovePreparationStage(args) {
         }
         // Re-stamp attribution for any refs whose lane needs updating.
         // Precedence (weakest → strongest, each overwrites the previous):
-        //   proactive < high-retrieval < forgetting-safety < signal-delta
+        //   proactive < forgetting-safety < signal-delta
         // Scope mode is already excluded by the outer guard (`scope.mode !== "ref"`).
-        // forgetting-safety sits above proactive and high-retrieval so that a ref
-        // flagged as a forgetting candidate is always visible to S5/WS-5 as such,
-        // even when it was also due for a proactive maintenance run. signal-delta
-        // overrides forgetting-safety because a ref with fresh feedback is reactive
-        // and doesn't need the protective pass label for measurement purposes.
+        // forgetting-safety sits above proactive so that a ref flagged as a
+        // forgetting candidate is always visible to S5/WS-5 as such, even when it
+        // was also due for a proactive maintenance run. signal-delta overrides
+        // forgetting-safety because a ref with fresh feedback is reactive and
+        // doesn't need the protective pass label for measurement purposes.
         for (const r of highSalienceRefs)
             eligibilitySourceByRef.set(r.ref, "high-salience");
         for (const r of proactiveRefs)
             eligibilitySourceByRef.set(r.ref, "proactive");
-        for (const r of highRetrievalRefs)
-            eligibilitySourceByRef.set(r.ref, "high-retrieval");
-        // Apply forgetting-safety OVER proactive, high-retrieval, and high-salience
-        // (already stamped in the loop above via
+        // Apply forgetting-safety OVER proactive and high-salience (already
+        // stamped in the loop above via
         // `eligibilitySourceByRef.set(ref, "forgetting-safety")`). No-op here: the
-        // set() calls above for proactive/high-retrieval/high-salience overwrite the
-        // earlier forgetting-safety stamp — so we re-apply forgetting-safety now for
-        // those refs that are both forgetting candidates AND in another fallback lane.
+        // set() calls above for proactive/high-salience overwrite the earlier
+        // forgetting-safety stamp — so we re-apply forgetting-safety now for those
+        // refs that are both forgetting candidates AND in another fallback lane.
         for (const ref of pendingForgettingRefs) {
             eligibilitySourceByRef.set(ref, "forgetting-safety");
         }
@@ -1697,6 +1899,158 @@ export async function runImprovePreparationStage(args) {
             r.eligibilitySource = eligibilitySourceByRef.get(r.ref) ?? "unknown";
         }
     }
+    return mergedRefs;
+}
+/**
+ * Pass: eligibility-filter — replay selection (#610), the no-op dampener sort,
+ * coverage gaps, the disk-existence guard, the --limit slice, and the summary
+ * info emits.
+ */
+async function filterEligibility(args) {
+    const { scope, options, plannedRefs, eventsCtx, salienceMap, eligibilitySourceByRef, distillOnlyRefs } = args;
+    const { fullySkippedCount, preCooldownCount, signalAndRetrievalRefs, signalFiltered } = args.summary;
+    const validationFailureRefs = args.validationFailureRefs;
+    const replay = applyReplaySelection({
+        scope,
+        options,
+        plannedRefs,
+        eventsCtx,
+        mergedRefs: args.mergedRefs,
+        salienceMap,
+        eligibilitySourceByRef,
+    });
+    const mergedRefs = replay.mergedRefs;
+    const { replayRefSet, replayBudget } = replay;
+    // Build no-op map for consolidation-selection dampener (plan §WS-1 step 8).
+    // Reads consecutive_no_ops from the SAME pinned db handle used elsewhere in
+    // this function.  The effective score is used ONLY for processing/selection
+    // order — the persisted rank_score in asset_salience is never mutated here.
+    const noOpMap = new Map();
+    try {
+        const noOpDb = eventsCtx?.db ?? (eventsCtx?.dbPath ? openStateDatabase(eventsCtx.dbPath) : null);
+        if (noOpDb) {
+            const ownsNoOpDb = !eventsCtx?.db;
+            try {
+                for (const r of mergedRefs) {
+                    noOpMap.set(r.ref, readConsecutiveNoOpsForImproveRef(noOpDb, r.ref, r.itemRef));
+                }
+            }
+            finally {
+                if (ownsNoOpDb)
+                    noOpDb.close();
+            }
+        }
+    }
+    catch {
+        // best-effort: dampener failure never blocks selection
+    }
+    // Sort by effective selection score (desc), with explicit ref-string tie-break
+    // for determinism.  The effective score applies the consolidation-selection
+    // dampener: assets that have been repeatedly skipped (consecutive_no_ops >=
+    // THRESHOLD) are penalised by FACTOR so they sort after peers with similar
+    // rankScore.  The persisted rank_score is left unchanged — this is the whole
+    // point of the dampener (stable assets stay fully retrievable).
+    //
+    // WIRING NOTE (plan §WS-1 step 8 / "consolidation-selection" disambiguation):
+    // "consolidation-selection" in the plan refers to THIS reflect/distill
+    // eligibility ordering — i.e. which assets are chosen for the reflect/distill
+    // LLM pass — NOT to akmConsolidate (the cluster-merge phase at ~line 1994,
+    // which runs earlier and never reads noOpMap).  The no-op counter originates
+    // from no-change reflect / quality-rejected distill outcomes; the dampener
+    // suppresses repeated LLM attempts on those same assets without touching their
+    // persisted rank_score (so they remain fully retrievable).
+    //
+    // This is the only ranking path. The eligibilitySource lanes (signal-delta /
+    // proactive / high-salience) survive as labels set above.
+    const effectiveScore = (ref) => {
+        const rankScore = salienceMap.get(ref)?.rankScore ?? 0;
+        const noOps = noOpMap.get(ref) ?? 0;
+        return noOps >= SALIENCE_NO_OP_DAMPEN_THRESHOLD ? rankScore * SALIENCE_NO_OP_DAMPEN_FACTOR : rankScore;
+    };
+    const sorted = [...mergedRefs].sort((a, b) => {
+        const scoreA = effectiveScore(a.ref);
+        const scoreB = effectiveScore(b.ref);
+        if (scoreB !== scoreA)
+            return scoreB - scoreA;
+        // Stable tie-break: deterministic regardless of input ordering.
+        return a.ref < b.ref ? -1 : a.ref > b.ref ? 1 : 0;
+    });
+    // Phase 0: surface coverage gaps from zero-result search queries
+    let coverageGaps = [];
+    try {
+        const dbForGaps = openExistingDatabase();
+        try {
+            coverageGaps = getZeroResultSearches(dbForGaps);
+        }
+        finally {
+            closeDatabase(dbForGaps);
+        }
+    }
+    catch (err) {
+        rethrowIfTestIsolationError(err);
+        // best-effort
+    }
+    const diskCheck = await dropRefsMissingOnDisk({ sorted, options, eventsCtx });
+    const assetMissingOnDisk = diskCheck.assetMissingOnDisk;
+    const actionableRefs = diskCheck.actionableRefs;
+    // Re-split actionableRefs (sorted) into reflect-path vs distill-only-path while
+    // preserving sort order. distillOnlyRefs participate in the sort so --limit
+    // picks them by score, not by arbitrary position.
+    const distillOnlyRefSetForSort = new Set(distillOnlyRefs.map((r) => r.ref));
+    const reflectAndDistillRefsAfterSort = [];
+    const distillOnlyRefsAfterSort = [];
+    for (const r of actionableRefs) {
+        if (distillOnlyRefSetForSort.has(r.ref)) {
+            distillOnlyRefsAfterSort.push(r);
+        }
+        else {
+            reflectAndDistillRefsAfterSort.push(r);
+        }
+    }
+    // ── Phase 5: --limit applies to the post-cooldown actionable set ──────────
+    //
+    // #610 ADDITIVITY: replay-lane refs are budgeted SEPARATELY from the --limit
+    // fresh slice. Without this split, a high-rankScore replay ref could sort above
+    // a fresh ref in the single combined slice and STEAL its slot (violating AC2).
+    // We partition into the replay lane vs the rest, apply --limit to the
+    // non-replay (fresh) refs only, then APPEND up to `replayBudget` replay refs
+    // after the fresh slice. Sort order within each partition is preserved.
+    //
+    // Default replayBudget=0 reduces this to the exact pre-#610 expression: with no
+    // replay refs, `nonReplayLoop === allLoopRefs`, so `baseLoop === old slice` and
+    // `replayLoop.slice(0, 0) === []` — byte-identical.
+    const allLoopRefs = [...reflectAndDistillRefsAfterSort, ...distillOnlyRefsAfterSort];
+    const replayLoop = allLoopRefs.filter((r) => r.eligibilitySource === "replay");
+    const nonReplayLoop = allLoopRefs.filter((r) => r.eligibilitySource !== "replay");
+    const baseLoop = options.limit ? nonReplayLoop.slice(0, options.limit) : nonReplayLoop;
+    const loopRefs = [...baseLoop, ...replayLoop.slice(0, replayBudget)];
+    // Update the returned distillOnlyRefs to the sorted order so callers see the
+    // ranked view (loop stage uses it as a Set so order is irrelevant, but the
+    // shape change keeps downstream consumers consistent).
+    const distillOnlyRefsResult = distillOnlyRefsAfterSort;
+    const totalReflectBlocked = fullySkippedCount + distillOnlyRefs.length;
+    if (totalReflectBlocked > 0) {
+        info(`[improve] ${totalReflectBlocked} of ${preCooldownCount} indexed refs blocked by reflect signal-delta ` +
+            `(${fullySkippedCount} fully skipped, ${distillOnlyRefs.length} routed to distill-only)`);
+    }
+    if (signalAndRetrievalRefs.length > 0) {
+        info(`[improve] ${signalAndRetrievalRefs.length} refs with usage signals (${signalFiltered.length} feedback${replayRefSet.size > 0 ? `, ${replayRefSet.size} replay` : ""})`);
+    }
+    if (validationFailureRefs.size > 0) {
+        info(`[improve] ${validationFailureRefs.size} with validation failures excluded`);
+    }
+    if (assetMissingOnDisk.length > 0) {
+        info(`[improve] ${assetMissingOnDisk.length} candidates dropped — file not on disk`);
+    }
+    const deferredCount = actionableRefs.length - loopRefs.length;
+    info(`[improve] ${actionableRefs.length} actionable; ${loopRefs.length} will be processed` +
+        (options.limit && deferredCount > 0 ? ` (--limit ${options.limit} applied; ${deferredCount} deferred)` : ""));
+    return { loopRefs, actionableRefs, distillOnlyRefs: distillOnlyRefsResult, coverageGaps };
+}
+/** The #610 bounded, additive replay-selection lane (eligibility-filter). */
+function applyReplaySelection(args) {
+    const { scope, options, plannedRefs, eventsCtx, salienceMap, eligibilitySourceByRef } = args;
+    let mergedRefs = args.mergedRefs;
     // ── REPLAY SELECTION layer (#610) ─────────────────────────────────────────
     // Bounded, ADDITIVE replay budget: up to `replayBudget` top-salience refs are
     // revisited even with zero reactive signal (no feedback, no retrieval) and
@@ -1717,7 +2071,31 @@ export async function runImprovePreparationStage(args) {
         try {
             withStateDb((replayDb) => {
                 const alreadyInPool = new Set(mergedRefs.map((r) => r.ref));
-                const allRankScores = getAllRankScores(replayDb);
+                const storedRankScores = getAllRankScores(replayDb);
+                // Chunk-5 flip F5e — plan reverse map so a stored item_ref row re-keys
+                // back onto its filesystem-facing bare ref (the replay stub must match
+                // a planned entry for its filePath / disk check).
+                const itemRefByPlanned = buildItemRefByRef(plannedRefs);
+                const bareRefByItemRef = new Map();
+                for (const [bareRef, itemRef] of itemRefByPlanned)
+                    if (itemRef)
+                        bareRefByItemRef.set(itemRef, bareRef);
+                const allRankScores = options.sourceName
+                    ? (() => {
+                        // Source-scope by the bundle prefix, then re-key item_ref rows
+                        // onto the short conceptId used by the planned-ref pool.
+                        const m = new Map();
+                        for (const [ref, score] of storedRankScores) {
+                            const boundary = ref.indexOf("//");
+                            const prefix = boundary >= 0 ? ref.slice(0, boundary) : undefined;
+                            const belongs = prefix === options.sourceName;
+                            if (!belongs)
+                                continue;
+                            m.set(bareRefByItemRef.get(ref) ?? bareImproveRef(ref), score);
+                        }
+                        return m;
+                    })()
+                    : storedRankScores;
                 // Candidate universe = every salience row NOT already in the pool, ordered by
                 // rank_score desc with a deterministic ref-string tie-break (mirrors the main
                 // sort). Converged refs (consecutive_no_ops >= dampener threshold) are fully
@@ -1727,7 +2105,7 @@ export async function runImprovePreparationStage(args) {
                 for (const [ref, rankScore] of allRankScores) {
                     if (alreadyInPool.has(ref))
                         continue;
-                    const noOps = getConsecutiveNoOps(replayDb, ref);
+                    const noOps = readConsecutiveNoOpsForImproveRef(replayDb, ref, itemRefByPlanned.get(ref));
                     if (noOps >= SALIENCE_NO_OP_DAMPEN_THRESHOLD) {
                         convergedSkipped++;
                         continue;
@@ -1793,76 +2171,11 @@ export async function runImprovePreparationStage(args) {
             // best-effort: if DB unavailable, replayRefSet stays empty
         }
     }
-    // Build no-op map for consolidation-selection dampener (plan §WS-1 step 8).
-    // Reads consecutive_no_ops from the SAME pinned db handle used elsewhere in
-    // this function.  The effective score is used ONLY for processing/selection
-    // order — the persisted rank_score in asset_salience is never mutated here.
-    const noOpMap = new Map();
-    try {
-        const noOpDb = eventsCtx?.db ?? (eventsCtx?.dbPath ? openStateDatabase(eventsCtx.dbPath) : null);
-        if (noOpDb) {
-            const ownsNoOpDb = !eventsCtx?.db;
-            try {
-                for (const r of mergedRefs) {
-                    noOpMap.set(r.ref, getConsecutiveNoOps(noOpDb, r.ref));
-                }
-            }
-            finally {
-                if (ownsNoOpDb)
-                    noOpDb.close();
-            }
-        }
-    }
-    catch {
-        // best-effort: dampener failure never blocks selection
-    }
-    // Sort by effective selection score (desc), with explicit ref-string tie-break
-    // for determinism.  The effective score applies the consolidation-selection
-    // dampener: assets that have been repeatedly skipped (consecutive_no_ops >=
-    // THRESHOLD) are penalised by FACTOR so they sort after peers with similar
-    // rankScore.  The persisted rank_score is left unchanged — this is the whole
-    // point of the dampener (stable assets stay fully retrievable).
-    //
-    // WIRING NOTE (plan §WS-1 step 8 / "consolidation-selection" disambiguation):
-    // "consolidation-selection" in the plan refers to THIS reflect/distill
-    // eligibility ordering — i.e. which assets are chosen for the reflect/distill
-    // LLM pass — NOT to akmConsolidate (the cluster-merge phase at ~line 1994,
-    // which runs earlier and never reads noOpMap).  The no-op counter originates
-    // from no-change reflect / quality-rejected distill outcomes; the dampener
-    // suppresses repeated LLM attempts on those same assets without touching their
-    // persisted rank_score (so they remain fully retrievable).
-    //
-    // This is the ONLY ranking path — negativeOnlyRatio and the legacy
-    // symmetricValence branch are replaced. The three eligibilitySource lanes
-    // (signal-delta / high-retrieval / proactive) survive as labels (set above).
-    const effectiveScore = (ref) => {
-        const rankScore = salienceMap.get(ref)?.rankScore ?? 0;
-        const noOps = noOpMap.get(ref) ?? 0;
-        return noOps >= SALIENCE_NO_OP_DAMPEN_THRESHOLD ? rankScore * SALIENCE_NO_OP_DAMPEN_FACTOR : rankScore;
-    };
-    const sorted = [...mergedRefs].sort((a, b) => {
-        const scoreA = effectiveScore(a.ref);
-        const scoreB = effectiveScore(b.ref);
-        if (scoreB !== scoreA)
-            return scoreB - scoreA;
-        // Stable tie-break: deterministic regardless of input ordering.
-        return a.ref < b.ref ? -1 : a.ref > b.ref ? 1 : 0;
-    });
-    // Phase 0: surface coverage gaps from zero-result search queries
-    let coverageGaps = [];
-    try {
-        const dbForGaps = openExistingDatabase();
-        try {
-            coverageGaps = getZeroResultSearches(dbForGaps);
-        }
-        finally {
-            closeDatabase(dbForGaps);
-        }
-    }
-    catch (err) {
-        rethrowIfTestIsolationError(err);
-        // best-effort
-    }
+    return { mergedRefs, replayRefSet, replayBudget };
+}
+/** The final disk-existence guard + its aggregated audit event (eligibility-filter). */
+async function dropRefsMissingOnDisk(args) {
+    const { sorted, options, eventsCtx } = args;
     // actionableRefs is the post-cooldown, post-validation, post-signal, post-sort
     // set — i.e. the genuinely processable refs in priority order. Note: this is
     // a semantic shift from earlier code where actionableRefs was the pre-cooldown
@@ -1906,97 +2219,5 @@ export async function runImprovePreparationStage(args) {
             },
         }, eventsCtx);
     }
-    const actionableRefs = existsCheckedActionable;
-    // Re-split actionableRefs (sorted) into reflect-path vs distill-only-path while
-    // preserving sort order. distillOnlyRefs participate in the sort so --limit
-    // picks them by score, not by arbitrary position.
-    const distillOnlyRefSetForSort = new Set(distillOnlyRefs.map((r) => r.ref));
-    const reflectAndDistillRefsAfterSort = [];
-    const distillOnlyRefsAfterSort = [];
-    for (const r of actionableRefs) {
-        if (distillOnlyRefSetForSort.has(r.ref)) {
-            distillOnlyRefsAfterSort.push(r);
-        }
-        else {
-            reflectAndDistillRefsAfterSort.push(r);
-        }
-    }
-    // ── Phase 5: --limit applies to the post-cooldown actionable set ──────────
-    //
-    // #610 ADDITIVITY: replay-lane refs are budgeted SEPARATELY from the --limit
-    // fresh slice. Without this split, a high-rankScore replay ref could sort above
-    // a fresh ref in the single combined slice and STEAL its slot (violating AC2).
-    // We partition into the replay lane vs the rest, apply --limit to the
-    // non-replay (fresh) refs only, then APPEND up to `replayBudget` replay refs
-    // after the fresh slice. Sort order within each partition is preserved.
-    //
-    // Default replayBudget=0 reduces this to the exact pre-#610 expression: with no
-    // replay refs, `nonReplayLoop === allLoopRefs`, so `baseLoop === old slice` and
-    // `replayLoop.slice(0, 0) === []` — byte-identical.
-    const allLoopRefs = [...reflectAndDistillRefsAfterSort, ...distillOnlyRefsAfterSort];
-    const replayLoop = allLoopRefs.filter((r) => r.eligibilitySource === "replay");
-    const nonReplayLoop = allLoopRefs.filter((r) => r.eligibilitySource !== "replay");
-    const baseLoop = options.limit ? nonReplayLoop.slice(0, options.limit) : nonReplayLoop;
-    const loopRefs = [...baseLoop, ...replayLoop.slice(0, replayBudget)];
-    // Update the returned distillOnlyRefs to the sorted order so callers see the
-    // ranked view (loop stage uses it as a Set so order is irrelevant, but the
-    // shape change keeps downstream consumers consistent).
-    const distillOnlyRefsResult = distillOnlyRefsAfterSort;
-    const totalReflectBlocked = fullySkippedCount + distillOnlyRefs.length;
-    if (totalReflectBlocked > 0) {
-        info(`[improve] ${totalReflectBlocked} of ${preCooldownCount} indexed refs blocked by reflect signal-delta ` +
-            `(${fullySkippedCount} fully skipped, ${distillOnlyRefs.length} routed to distill-only)`);
-    }
-    if (signalAndRetrievalRefs.length > 0) {
-        info(`[improve] ${signalAndRetrievalRefs.length} refs with usage signals (${signalFiltered.length} feedback, ${highRetrievalRefs.length} high-retrieval${replayRefSet.size > 0 ? `, ${replayRefSet.size} replay` : ""})`);
-    }
-    if (validationFailureRefs.size > 0) {
-        info(`[improve] ${validationFailureRefs.size} with validation failures excluded`);
-    }
-    if (assetMissingOnDisk.length > 0) {
-        info(`[improve] ${assetMissingOnDisk.length} candidates dropped — file not on disk`);
-    }
-    const deferredCount = actionableRefs.length - loopRefs.length;
-    info(`[improve] ${actionableRefs.length} actionable; ${loopRefs.length} will be processed` +
-        (options.limit && deferredCount > 0 ? ` (--limit ${options.limit} applied; ${deferredCount} deferred)` : ""));
-    // WS-4: Per-phase threshold auto-tune for the extract phase.
-    // Persists result for the NEXT run's makeGateConfig to read.
-    const extractTuneDbPath = eventsCtx?.dbPath;
-    if (options.autoAccept !== undefined && extractTuneDbPath) {
-        try {
-            maybeAutoTuneThreshold(extractPass.extractGateCfg.phaseThreshold ?? options.autoAccept, options.config ?? loadConfig(), extractTuneDbPath, undefined, "extract");
-        }
-        catch (err) {
-            warn(`[improve] calibration auto-tune (extract) skipped: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    return {
-        actions,
-        cleanupWarnings,
-        appliedCleanup,
-        memoryIndexHealth,
-        extract: extractResults,
-        actionableRefs,
-        signalBearingSet,
-        validationFailures,
-        schemaRepairs,
-        lintSummary,
-        loopRefs,
-        distillCooledRefs,
-        distillOnlyRefs: distillOnlyRefsResult,
-        coverageGaps,
-        recentErrors,
-        utilityMap,
-        gateAutoAcceptedCount,
-        gateAutoAcceptFailedCount,
-        consolidation: consolidationPass.consolidation,
-        consolidationRan: consolidationPass.consolidationRan,
-        ...(proactiveMaintenanceSummary ? { proactiveMaintenance: proactiveMaintenanceSummary } : {}),
-    };
+    return { actionableRefs: existsCheckedActionable, assetMissingOnDisk };
 }
-// TODO(refactor): 13 args including `actions`/`recentErrors` mutation channels. Restructure into immutable plan + mutable context objects — deferred to dedicated refactor with isolated testing.
-/**
- * Parameter object for {@link runImproveLoopStage} (WS10). Pure type reshape of
- * the former inline arg struct — every field, name, and type is preserved so the
- * function body and all runtime values are byte-identical. No control-flow change.
- */