akm-cli 0.9.0-beta.11 → 0.9.0-beta.26

package/dist/commands/improve/improve.js

@@ -14,7 +14,7 @@ import { probeLock, releaseLock, releaseLockIfOwned, tryAcquireLockSync } from "
 import { classifyImproveAction } from "../../core/improve-types.js";
 import { openLogsDatabase, purgeOldTaskLogs } from "../../core/logs-db.js";
 import { getDbPath, getStateDbPathInDataDir } from "../../core/paths.js";
-import { openStateDatabase, purgeOldEvents, purgeOldImproveRuns } from "../../core/state-db.js";
+import { listProposalGateDecisions, listStateProposals, openStateDatabase, persistPhaseThreshold, purgeOldEvents, purgeOldImproveRuns, } from "../../core/state-db.js";
 import { info, warn } from "../../core/warn.js";
 import { closeDatabase, getAllEntries, getEntryCount, getRetrievalCounts, getUtilityScoresByIds, getZeroResultSearches, openDatabase, openExistingDatabase, } from "../../indexer/db/db.js";
 import { ensureIndex } from "../../indexer/ensure-index.js";
@@ -38,17 +38,23 @@ import { resolveDrainPolicy } from "../proposal/drain-policies.js";
 import { createProposal, expireStaleProposals, getProposal, isProposalSkipped, listProposals, purgeOrphanProposals, } from "../proposal/validators/proposals.js";
 import { runSchemaRepairPass } from "../sources/schema-repair.js";
 import { checkDeadUrls } from "../url-checker.js";
+import { computeThresholdAutoTune, gateDecisionsToSamples, summarizeCalibration, } from "./calibration.js";
 import { akmConsolidate } from "./consolidate.js";
 import { akmDistill, deriveLessonRef, isDistillRefusedInputType } from "./distill.js";
 import { deriveKnowledgeRef } from "./distill-promotion-policy.js";
 import { countEvalCases, writeEvalCase } from "./eval-cases.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 { isProfileFilteredForAllPasses, resolveImproveProfile, resolveProcessEnabled, shouldSkipRef, } from "./improve-profiles.js";
 import { detectAndWriteContradictions } from "./memory/memory-contradiction-detect.js";
 import { analyzeMemoryCleanup, applyMemoryCleanup } from "./memory/memory-improve.js";
+import { computeProxyAdequacy, getAllAssetOutcomes, getOutcomeScoresByRef, outcomeScoreToSalience, updateAssetOutcome, } from "./outcome-loop.js";
 import { DEFAULT_DUE_DAYS, DEFAULT_MAX_PER_RUN, selectProactiveMaintenanceRefs } from "./proactive-maintenance.js";
+import { akmProcedural } from "./procedural.js";
+import { akmRecombine } from "./recombine.js";
 import { akmReflect } from "./reflect.js";
+import { buildRankChangeReport, computeSalience, getAllRankScores, getAssetSalience, getConsecutiveNoOps, getLastUseMsByRef, recordNoOp, resetConsecutiveNoOps, SALIENCE_NO_OP_DAMPEN_FACTOR, SALIENCE_NO_OP_DAMPEN_THRESHOLD, upsertAssetSalience, } from "./salience.js";
 // #607 Lock Decomposition: fine-grained per-process locks replace the single
 // `improve.lock`. Three independent locks allow concurrent improve runs when
 // they touch different subsystems (e.g. quick-shredder consolidate can run
@@ -569,6 +575,107 @@ export function armBudgetWatchdog(budgetMs, controller, deps) {
         }
     };
 }
+/**
+ * #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 db = openStateDatabase(stateDbPath);
+    let summary;
+    try {
+        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;
+        summary = summarizeCalibration(gateDecisionsToSamples(decisions));
+    }
+    finally {
+        db.close();
+    }
+    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 {
+            const persistDb = openStateDatabase(stateDbPath);
+            try {
+                persistPhaseThreshold(persistDb, phase, result.newThreshold);
+            }
+            finally {
+                persistDb.close();
+            }
+        }
+        catch (err) {
+            warn(`[improve] calibration auto-tune: failed to persist phase threshold for ${phase}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return result.newThreshold;
+}
 export async function akmImprove(options = {}) {
     const scope = resolveImproveScope(options.scope);
     const reflectFn = options.reflectFn ?? akmReflect;
@@ -606,6 +713,23 @@ export async function akmImprove(options = {}) {
     // timeout root cause). Because beforeEach runs synchronously, env is still the
     // calling test's own at this point; we capture it before yielding the loop.
     const resolvedStateDbPath = getStateDbPathInDataDir();
+    // #612 / WS-4 — bounded, OPT-IN per-phase auto-accept threshold auto-tune.
+    // DEFAULT OFF: `autoTune: false` (or absent) is a complete no-op.
+    //
+    // WS-4 change: thresholds are now PER PHASE. The old single global mutation
+    // of `options.autoAccept` is retired — it caused every phase to share one
+    // calibration signal, so a reflect-dominated run could tighten the consolidate
+    // gate (or vice-versa). Instead:
+    //   - Each `makeGateConfig` call reads the phase's stored threshold from
+    //     state.db (Migration 012) and uses it as `phaseThreshold`, overriding
+    //     the `globalThreshold` (= options.autoAccept) for that phase.
+    //   - Per-phase `maybeAutoTuneThreshold` calls fire AFTER each phase's gate
+    //     has run and persist the new threshold to state.db for the NEXT run.
+    //   - `options.autoAccept` stays unchanged (it is the operator-supplied
+    //     baseline, not a mutable run-time state).
+    //
+    // The global tune call is intentionally removed here. See per-phase calls
+    // below (near each makeGateConfig / runAutoAcceptGate block).
     // #607 Lock decomposition: three per-process locks replace the single
     // `improve.lock`. Each process acquires only the lock(s) it needs, so
     // quick-shredder consolidate can run alongside daily reflect+distill.
@@ -792,6 +916,16 @@ export async function akmImprove(options = {}) {
     // run past the declared budget.
     // References: Anthropic *Building Effective Agents* (2024); CoALA §5 (arXiv:2309.02427).
     const budgetAbortController = new AbortController();
+    // Attach a live `remainingBudgetMs` getter to the signal so sub-callers
+    // (e.g. consolidate.ts cold-start budget estimation) can read the remaining
+    // wall-clock budget without needing an extra plumbing parameter. The property
+    // is computed at access time via a getter so it always reflects the actual
+    // elapsed time rather than a stale snapshot taken at arm time.
+    Object.defineProperty(budgetAbortController.signal, "remainingBudgetMs", {
+        get: () => Math.max(0, budgetMs - (Date.now() - startMs)),
+        enumerable: false,
+        configurable: true,
+    });
     // Declared in the outer scope so the `finally` can clear the timer even if a
     // throw occurs before/after it is armed. Defaults to a no-op until armed.
     let clearBudgetTimer = () => { };
@@ -864,6 +998,7 @@ export async function akmImprove(options = {}) {
             eventsCtx,
             initialCleanupWarnings: preEnsureCleanupWarnings,
             improveProfile,
+            budgetSignal: budgetAbortController.signal,
         });
         if (consolidatePrepAcquired)
             releaseProcessLock(consolidateLPath);
@@ -910,7 +1045,7 @@ export async function akmImprove(options = {}) {
         // graphExtraction both write index.db). Released immediately after.
         const consolidatePostLPath = processLockPath(lockBaseDir, "consolidate");
         const consolidatePostAcquired = tryAcquireProcessLock(consolidatePostLPath, PROCESS_LOCK_DEFS.consolidate.staleAfterMs, options.skipIfLocked, "consolidate") === "acquired";
-        const { allWarnings, deadUrls, memoryInference, graphExtraction, stalenessDetection, maintenanceActions, memoryInferenceDurationMs, graphExtractionDurationMs, orphansPurged, proposalsExpired, gateAutoAcceptedCount: postLoopGateCount, gateAutoAcceptFailedCount: postLoopGateFailedCount, } = await runImprovePostLoopStage({
+        const { allWarnings, deadUrls, memoryInference, graphExtraction, stalenessDetection, maintenanceActions, memoryInferenceDurationMs, graphExtractionDurationMs, orphansPurged, proposalsExpired, gateAutoAcceptedCount: postLoopGateCount, gateAutoAcceptFailedCount: postLoopGateFailedCount, recombination, proceduralCompilation, } = await runImprovePostLoopStage({
             scope,
             options,
             primaryStashDir,
@@ -987,6 +1122,8 @@ export async function akmImprove(options = {}) {
             ...(memoryInferenceDurationMs > 0 ? { memoryInferenceDurationMs } : {}),
             ...(graphExtractionDurationMs > 0 ? { graphExtractionDurationMs } : {}),
             ...(stalenessDetection ? { stalenessDetection } : {}),
+            ...(recombination ? { recombination } : {}),
+            ...(proceduralCompilation ? { proceduralCompilation } : {}),
             ...(orphansPurged !== undefined ? { orphansPurged } : {}),
             ...(proposalsExpired !== undefined && proposalsExpired > 0 ? { proposalsExpired } : {}),
             reflectCooldownActions: finalActions.filter((a) => a.mode === "reflect-cooldown").length,
@@ -1254,7 +1391,7 @@ function emitImproveCompletedEvent(result, durations, eventsCtx) {
  *      need, so the fix is non-invasive and provably correct.
  */
 async function runConsolidationPass(args) {
-    const { options, primaryStashDir, memorySummary, improveProfile, eventsCtx } = args;
+    const { options, primaryStashDir, memorySummary, improveProfile, eventsCtx, budgetSignal, runBudgetMs } = args;
     const baseConfig = options.config ?? loadConfig();
     const MEMORY_VOLUME_THRESHOLD = options.memoryVolumeConsolidationThreshold ?? 100;
     const hasLlm = !!(baseConfig.defaults?.llm || baseConfig.defaults?.agent);
@@ -1398,6 +1535,7 @@ async function runConsolidationPass(args) {
         stashDir: primaryStashDir,
         config: consolidationConfig,
         eventsCtx,
+        stateDbPath: eventsCtx?.dbPath,
     }, { minimumThreshold: 95 });
     if (consolidateDisabledByProfile) {
         info("[improve] consolidation skipped (disabled by improve profile)");
@@ -1434,6 +1572,14 @@ async function runConsolidationPass(args) {
             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
@@ -1441,6 +1587,13 @@ async function runConsolidationPass(args) {
             // 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,
+            p90ChunkSecondsDefault: improveProfile?.processes?.consolidate?.p90ChunkSecondsDefault,
+            // 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) => {
@@ -1485,10 +1638,21 @@ async function runConsolidationPass(args) {
     }
     // 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 };
 }
 async function runImprovePreparationStage(args) {
-    const { scope, options, plannedRefs, memoryCleanupPlan, primaryStashDir, memorySummary, reindexFn, startMs, budgetMs, eventsCtx, initialCleanupWarnings, improveProfile, } = args;
+    const { scope, options, plannedRefs, memoryCleanupPlan, primaryStashDir, memorySummary, reindexFn, startMs, budgetMs, eventsCtx, initialCleanupWarnings, improveProfile, budgetSignal, } = args;
     const actions = [];
     const cleanupWarnings = initialCleanupWarnings ? [...initialCleanupWarnings] : [];
     // Phase 0 — MEMORY.md budget check (200-line cap; warn at 180)
@@ -1525,6 +1689,8 @@ async function runImprovePreparationStage(args) {
         memorySummary,
         improveProfile,
         eventsCtx,
+        budgetSignal,
+        runBudgetMs: budgetMs,
     });
     // Phase 0.4 — session-extract pass.
     //
@@ -1557,6 +1723,7 @@ async function runImprovePreparationStage(args) {
         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)
@@ -1952,32 +2119,52 @@ async function runImprovePreparationStage(args) {
     // high-retrieval path (P0-A) 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 pass so we don't issue
-    // two readEvents({type:"feedback", ref}) per asset (one for signal filtering,
-    // one for ratio computation).
+    // Pre-compute feedback summary per ref in a SINGLE bulk read so we don't
+    // open state.db once per asset (which caused 5000+ accumulated FDs and a
+    // 2-hour runaway on a 13K-asset stash). Pattern mirrors buildLatestFeedbackTsMap
+    // 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.
+    //
+    // 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();
-    for (const candidate of [...processableRefs, ...noFeedbackPool]) {
-        if (feedbackSummary.has(candidate.ref))
-            continue;
-        const { events } = readEvents({ type: "feedback", ref: candidate.ref });
-        let hasSignal = false;
-        let positive = 0;
-        let negative = 0;
-        for (const e of events) {
-            if (!hasSignal &&
-                (e.ts ?? "") >= feedbackSinceCutoff &&
-                e.metadata !== undefined &&
-                (typeof e.metadata.signal === "string" || typeof e.metadata.note === "string")) {
-                hasSignal = true;
-            }
-            if (e.metadata?.signal === "positive")
-                positive++;
-            else if (e.metadata?.signal === "negative")
-                negative++;
-        }
-        feedbackSummary.set(candidate.ref, { hasSignal, positive, negative });
+    {
+        const feedbackCandidateSet = new Set([...processableRefs, ...noFeedbackPool].map((r) => 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))
+                    continue;
+                const entry = feedbackSummary.get(ref) ?? { hasSignal: false, positive: 0, negative: 0 };
+                const meta = e.metadata;
+                // hasSignal: only count feedback events within the 30-day window.
+                if (!entry.hasSignal &&
+                    (e.ts ?? "") >= feedbackSinceCutoff &&
+                    meta !== undefined &&
+                    (typeof meta.signal === "string" || typeof meta.note === "string")) {
+                    entry.hasSignal = true;
+                }
+                // positive/negative: all-time counts (no since filter, matching prior behaviour).
+                if (meta?.signal === "positive")
+                    entry.positive++;
+                else if (meta?.signal === "negative")
+                    entry.negative++;
+                feedbackSummary.set(ref, entry);
+            }
+            // Ensure every candidate has an entry (even refs with zero feedback events).
+            for (const ref of feedbackCandidateSet) {
+                if (!feedbackSummary.has(ref)) {
+                    feedbackSummary.set(ref, { hasSignal: false, positive: 0, negative: 0 });
+                }
+            }
+        }
     }
     const signalFiltered = processableRefs.filter((candidate) => feedbackSummary.get(candidate.ref)?.hasSignal === true);
     // P0-A: also surface zero-feedback assets that have been retrieved many times.
@@ -1997,7 +2184,10 @@ async function runImprovePreparationStage(args) {
     let highRetrievalRefs = [];
     // 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
+    // step 2: recency is MANDATORY — never pinned to floor).
     let retrievalCounts = new Map();
+    let lastUseMsForProactive = new Map();
     let dbForRetrieval;
     try {
         dbForRetrieval = openExistingDatabase();
@@ -2005,7 +2195,15 @@ async function runImprovePreparationStage(args) {
         if (showEventCount === 0) {
             warn("Warning: show events not yet in usage_events — zero-feedback fallback will match only search-retrieved assets.");
         }
-        retrievalCounts = getRetrievalCounts(dbForRetrieval, noFeedbackCandidates.map((r) => r.ref));
+        // 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
@@ -2049,7 +2247,6 @@ async function runImprovePreparationStage(args) {
         const pmCfg = improveProfile.processes?.proactiveMaintenance;
         const dueDays = pmCfg?.dueDays ?? DEFAULT_DUE_DAYS;
         const maxPerRun = pmCfg?.maxPerRun ?? pmCfg?.limit ?? DEFAULT_MAX_PER_RUN;
-        const importanceWeights = pmCfg?.importanceWeights;
         // 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.
@@ -2060,6 +2257,8 @@ async function runImprovePreparationStage(args) {
             lastReflectTs: lastReflectProposalTs,
             lastDistillTs: lastDistillProposalTs,
             retrievalCounts,
+            // WS-1: wire lastUseMs so the recency decay term is genuine (plan §step 2).
+            lastUseMs: lastUseMsForProactive,
             sizeBytesOf: (r) => {
                 const fp = r.filePath;
                 if (!fp)
@@ -2073,7 +2272,6 @@ async function runImprovePreparationStage(args) {
             },
             dueDays,
             maxPerRun,
-            importanceWeights,
         });
         proactiveRefs = selection.selected;
         proactiveMaintenanceSummary = {
@@ -2097,6 +2295,44 @@ async function runImprovePreparationStage(args) {
                 `(${selection.neverReflected} never reflected, dueDays=${dueDays}, maxPerRun=${maxPerRun})`);
         }
     }
+    // ── 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
+    // into the improve run even without retrieval or feedback signal. This rescues
+    // newly distilled assets that the stash has not yet surfaced to users.
+    //
+    // Cap: at most 10% of the effective run limit so the lane cannot crowd out
+    // reactive feedback. Requires state.db to have an asset_salience row — refs
+    // without a row (pre-#608 assets still on the type-weight stub) are skipped.
+    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));
+    {
+        let dbForHighSalience;
+        try {
+            dbForHighSalience = openStateDatabase(eventsCtx?.dbPath);
+            const effectiveLimit = options.limit ?? 10;
+            const highSalienceCap = Math.max(1, Math.floor(effectiveLimit * 0.1));
+            const candidates = noFeedbackCandidates.filter((r) => !proactiveAndRetrievalSet.has(r.ref));
+            for (const r of candidates) {
+                if (highSalienceRefs.length >= highSalienceCap)
+                    break;
+                const row = getAssetSalience(dbForHighSalience, r.ref);
+                if (row && row.encoding_salience >= salienceThreshold) {
+                    highSalienceRefs.push(r);
+                }
+            }
+        }
+        catch (err) {
+            rethrowIfTestIsolationError(err);
+            // best-effort: if DB unavailable, highSalienceRefs stays empty
+        }
+        finally {
+            if (dbForHighSalience)
+                dbForHighSalience.close();
+        }
+    }
     // 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
@@ -2104,7 +2340,7 @@ async function runImprovePreparationStage(args) {
     // 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].map((r) => r.ref));
+    const rescuedSet = new Set([...highRetrievalRefs, ...proactiveRefs, ...highSalienceRefs].map((r) => r.ref));
     for (const r of noFeedbackPool) {
         if (rescuedSet.has(r.ref))
             continue;
@@ -2124,12 +2360,18 @@ async function runImprovePreparationStage(args) {
     // 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 three sources are disjoint by construction
-    // (proactive draws from noFeedbackCandidates with the P0-A picks removed), but
-    // dedupe defensively so a ref can never enter the loop twice. `requireFeedbackSignal`
-    // still suppresses both fallback sources for callers that want feedback-only runs.
-    const signalAndRetrievalRefs = dedupeRefs([...signalFiltered, ...highRetrievalRefs, ...proactiveRefs]);
-    const mergedRefs = scope.mode === "ref" ? processableRefs : options.requireFeedbackSignal ? signalFiltered : signalAndRetrievalRefs;
+    // 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
@@ -2142,11 +2384,14 @@ async function runImprovePreparationStage(args) {
     // createProposal calls. See EligibilitySource for the lane vocabulary.
     //
     // Precedence (prefer the most specific reactive signal):
-    //   scope > signal-delta > high-retrieval > proactive
+    //   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. We apply lanes weakest-first so the strongest
-    // overwrites; the explicit --scope <ref> bypass wins outright (user intent).
+    // 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)
@@ -2165,27 +2410,561 @@ async function runImprovePreparationStage(args) {
         // mergedRefs is always a subset of the four lanes above).
         r.eligibilitySource = eligibilitySourceByRef.get(r.ref) ?? "unknown";
     }
+    // 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
+    // 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).
     const utilityMap = buildUtilityMap(mergedRefs);
-    // Load feedback ratio per ref from the pre-computed summary (no extra DB pass).
-    const feedbackRatios = new Map();
-    for (const ref of mergedRefs) {
-        const summary = feedbackSummary.get(ref.ref);
-        const positive = summary?.positive ?? 0;
-        const negative = summary?.negative ?? 0;
-        const total = positive + negative;
-        // ratio = negative proportion (high = needs more improvement)
-        feedbackRatios.set(ref.ref, total > 0 ? negative / total : 0);
-    }
-    // Sort: combine utility (desc) with feedback negativity (desc) — high-negative assets rank higher
+    let dbForSalience;
+    try {
+        dbForSalience = openExistingDatabase();
+        lastUseMsByRef = getLastUseMsByRef(dbForSalience, mergedRefs.map((r) => r.ref));
+    }
+    catch (err) {
+        rethrowIfTestIsolationError(err);
+        // best-effort: if DB unavailable, recency term stays at floor (lastUseMs=0)
+    }
+    finally {
+        if (dbForSalience)
+            closeDatabase(dbForSalience);
+    }
+    // ── WS-2 Outcome loop ─────────────────────────────────────────────────────
+    //
+    // Update asset_outcome for every ref in the merged set BEFORE computing the
+    // salience vector so the updated outcome_score feeds outcomeSalience this run.
+    //
+    // Inputs per ref:
+    //   - currentRetrievalCount: from retrievalCounts (index DB)
+    //   - lastRetrievedAt: from lastUseMsByRef (utility_scores.last_used_at)
+    //   - negativeFeedbackCount: cumulative negatives from feedbackSummary
+    //   - acceptedChangeCount: accepted proposals for this ref (state.db)
+    //   - valence: net valence from computeValenceScore(feedbackSummary.get(ref))
+    //   - utilityScore: from utilityMap (for warm-start seed on new rows)
+    //
+    // Best-effort: outcome failures never block the salience or ranking pass.
+    const outcomeSalienceByRef = new Map();
+    try {
+        const outcomeDb = eventsCtx?.db ?? openStateDatabase(eventsCtx?.dbPath);
+        const ownsOutcomeDb = !eventsCtx?.db;
+        try {
+            // Count accepted proposals per ref in one pass (avoid N separate queries).
+            // Scoped to primaryStashDir when available so multi-stash installs don't
+            // inflate counts with proposals from other stashes.
+            const acceptedCountByRef = new Map();
+            try {
+                const acceptedProposals = listStateProposals(outcomeDb, {
+                    status: "accepted",
+                    ...(primaryStashDir ? { stashDir: primaryStashDir } : {}),
+                });
+                for (const p of acceptedProposals) {
+                    acceptedCountByRef.set(p.ref, (acceptedCountByRef.get(p.ref) ?? 0) + 1);
+                }
+            }
+            catch {
+                // best-effort: if proposals query fails, accepted counts stay at 0
+            }
+            // Update each ref's outcome row and collect the resulting outcome scores.
+            const rawOutcomeScores = new Map();
+            const nowForOutcome = Date.now();
+            for (const r of mergedRefs) {
+                const fb = feedbackSummary.get(r.ref) ?? { positive: 0, negative: 0 };
+                const valenceResult = computeValenceScore(fb);
+                try {
+                    const result = updateAssetOutcome(outcomeDb, {
+                        ref: r.ref,
+                        currentRetrievalCount: retrievalCounts.get(r.ref) ?? 0,
+                        lastRetrievedAt: lastUseMsByRef.get(r.ref) ?? 0,
+                        acceptedChangeCount: acceptedCountByRef.get(r.ref) ?? 0,
+                        negativeFeedbackCount: fb.negative,
+                        valence: valenceResult.valence,
+                        utilityScore: utilityMap.get(r.ref),
+                        now: nowForOutcome,
+                    });
+                    rawOutcomeScores.set(r.ref, result.outcomeScore);
+                }
+                catch {
+                    // best-effort per-ref: skip this ref's outcome update on failure
+                }
+            }
+            // Compute stash-wide max outcome_score for normalisation (diversity floor).
+            // Read ALL rows (not just this run's batch) so the normalisation is
+            // stash-relative, not pool-relative.
+            let maxOutcomeScore = 0;
+            try {
+                const allOutcomes = getAllAssetOutcomes(outcomeDb);
+                for (const row of allOutcomes) {
+                    if (row.outcome_score > maxOutcomeScore)
+                        maxOutcomeScore = row.outcome_score;
+                }
+                // Proxy-adequacy tripwire: emit a health event if outcome_score is
+                // negatively correlated with accepted_change_rate (inverted proxy).
+                const adequacy = computeProxyAdequacy(allOutcomes);
+                if (adequacy.isInverted) {
+                    appendEvent({
+                        eventType: "outcome_proxy_inverted",
+                        ref: undefined,
+                        metadata: {
+                            correlation: adequacy.correlation,
+                            n: adequacy.n,
+                            note: "corr(outcome_score, accepted_change_rate) < −0.3: high-outcome_score assets have LOW accepted-change rates — the proxy's 'doing well' signal is inverted, so the coarse retrieval-delta signal is no longer trustworthy and the 0.10+ rich in-session signal is no longer deferrable. See plan §WS-2 proxy-adequacy tripwire.",
+                        },
+                    }, eventsCtx);
+                }
+            }
+            catch {
+                // best-effort: tripwire failure never blocks ranking
+            }
+            // Convert raw outcome scores → normalised outcomeSalience values in [0,1].
+            for (const [ref, score] of rawOutcomeScores) {
+                const normalised = outcomeScoreToSalience(score, maxOutcomeScore);
+                outcomeSalienceByRef.set(ref, normalised);
+            }
+            // 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.
+            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));
+                }
+            }
+        }
+        finally {
+            if (ownsOutcomeDb)
+                outcomeDb.close();
+        }
+    }
+    catch (err) {
+        rethrowIfTestIsolationError(err);
+        // best-effort: outcome failures never block salience computation
+    }
+    // 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.
+    // outcomeSalienceByRef is populated by WS-2 above (or empty on first run).
+    //
+    // Part-V gate: read the operator opt-in flag from config. Default false
+    // (WS-1 parity weights) until the maintainer runs scripts/akm-eval and sets
+    // improve.salience.outcomeWeightEnabled: true in the config.
+    const salienceConfig = (options.config ?? loadConfig()).improve?.salience;
+    const outcomeWeightEnabled = salienceConfig?.outcomeWeightEnabled === true;
+    const salienceMap = new Map();
+    const nowForSalience = Date.now();
+    for (const r of mergedRefs) {
+        const type = r.ref.includes(":") ? r.ref.slice(0, r.ref.indexOf(":")) : "";
+        const sizeBytes = (() => {
+            const fp = r.filePath;
+            if (!fp)
+                return undefined;
+            try {
+                return fs.statSync(fp).size;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        const vector = computeSalience({
+            ref: r.ref,
+            type,
+            retrievalFreq: retrievalCounts.get(r.ref) ?? 0,
+            lastUseMs: lastUseMsByRef.get(r.ref),
+            utilityScore: utilityMap.get(r.ref),
+            outcomeSalience: outcomeSalienceByRef.get(r.ref),
+            sizeBytes,
+            now: nowForSalience,
+            outcomeWeightEnabled,
+        });
+        salienceMap.set(r.ref, vector);
+    }
+    // Persist salience vectors to state.db (best-effort, non-blocking).
+    // The canonical store enables WS-3 homeostatic demotion and WS-2 outcome reads.
+    //
+    // Forgetting-safety report (plan §WS-1 step 7) — stash-wide rank comparison:
+    //
+    // BEFORE persisting the new rankScores, read ALL existing rows from state.db
+    // (not just the per-run candidate pool). This gives stash-wide rank positions so
+    // the top-200/below-500 thresholds are meaningful.
+    //
+    // Two distinct scenarios:
+    //
+    // A. First WS-1 run (table empty): the old stash-wide combinedEligibilityScore
+    //    ordering was never persisted in state.db (asset_salience is a new WS-1 table).
+    //    However, the old formula's inputs are available in-scope for every candidate
+    //    in the current pool: utility comes from utilityMap and the attention term
+    //    from feedbackSummary (positive/negative counts). We reconstruct the old
+    //    combinedEligibilityScore = utility * UTILITY_WEIGHT + attention * FEEDBACK_WEIGHT
+    //    for every ref in salienceMap and rank them, giving a candidate-pool-scoped
+    //    old ordering. This is a partial reconstruction (only current-pool refs, not
+    //    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/design/improve-reconciliation-plan.md §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
+    //    reconstructed comparison result in the metadata.
+    //
+    // B. Subsequent runs (table has rows): use ALL existing rows as old ranks, merge
+    //    them with the current run's salienceMap updates for new ranks, and call
+    //    buildRankChangeReport with stash-wide positions. This detects real rank drift
+    //    — e.g. a retrieval-pattern shift causing a previously top-200 asset to slip
+    //    below position 500.
+    //
+    // Measurement-protocol deferral (plan §269, Part-V):
+    // The Part-V T0 baseline (scripts/akm-eval + health report) and the throughput/
+    // quality gate are deferred pending owner sign-off. Full measurement requires a
+    // before/after `akm health` report. Owner-acknowledged deferral: WS-2 landing
+    // will re-introduce outcome salience and trigger the full re-tuning pass at that
+    // time. salience.ts already accepts outcomeSalience directly as an input
+    // (see SalienceInputs.outcomeSalience); no separate hook is needed.
+    //
+    // Forgetting-safety collection: populated inside scenario B below, consumed
+    // after the try/catch to union candidates into mergedRefs before the sort.
+    // Only refs from a real pre-existing ordering (scenario B) are collected;
+    // empty on scenario A or when no candidates dropped below the threshold.
+    let pendingForgettingRefs = [];
+    try {
+        const stateDb = openStateDatabase(eventsCtx?.dbPath);
+        try {
+            // 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);
+            if (existingAllScores.size === 0) {
+                // Scenario A: first WS-1 run — table empty.
+                //
+                // Reconstruct the old combinedEligibilityScore ordering for the current
+                // candidate pool using inputs that are already in-scope: utility from
+                // utilityMap and the attention term from feedbackSummary (positive/negative
+                // counts). Old formula: score = utility * UTILITY_WEIGHT + attention * FEEDBACK_WEIGHT.
+                //
+                // 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/design/improve-reconciliation-plan.md §WS-1 step 7.
+                const reconstructedOldScores = new Map();
+                for (const ref of salienceMap.keys()) {
+                    const utility = utilityMap.get(ref) ?? 0;
+                    const fb = feedbackSummary.get(ref) ?? { positive: 0, negative: 0 };
+                    const attention = computeValenceScore(fb).attention;
+                    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 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). ` +
+                        `Top drops: ${firstRunReport.forgettingCandidates
+                            .slice(0, 5)
+                            .map((e) => `${e.ref} (#${e.oldRank}→#${e.newRank})`)
+                            .join(", ")}`);
+                    pendingForgettingRefs = firstRunReport.forgettingCandidates.map((e) => e.ref);
+                }
+                appendEvent({
+                    eventType: "improve_salience_first_run",
+                    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",
+                        forgettingCandidates: firstRunReport.forgettingCandidates.length,
+                        topDrops: firstRunReport.forgettingCandidates.slice(0, 10).map((e) => ({
+                            ref: e.ref,
+                            oldRank: e.oldRank,
+                            newRank: e.newRank,
+                        })),
+                    },
+                }, eventsCtx);
+            }
+            else {
+                // Scenario B: subsequent run — compare stash-wide old vs. new ranks.
+                //
+                // Build new scores by merging the full table with this run's updates.
+                // Refs in salienceMap override their stored value; refs not in this run
+                // retain their stored value unchanged. This gives a complete stash-wide
+                // 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);
+                }
+                // 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 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. ` +
+                        `Top drops: ${report.forgettingCandidates
+                            .slice(0, 5)
+                            .map((e) => `${e.ref} (#${e.oldRank}→#${e.newRank})`)
+                            .join(", ")}`);
+                    // 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);
+                }
+                appendEvent({
+                    eventType: "improve_salience_rank_change",
+                    ref: undefined,
+                    metadata: {
+                        stashSize: existingAllScores.size,
+                        totalChanged: report.allChanges.length,
+                        forgettingCandidates: report.forgettingCandidates.length,
+                        topDrops: report.forgettingCandidates.slice(0, 10).map((e) => ({
+                            ref: e.ref,
+                            oldRank: e.oldRank,
+                            newRank: e.newRank,
+                        })),
+                    },
+                }, eventsCtx);
+            }
+            for (const [ref, vector] of salienceMap) {
+                upsertAssetSalience(stateDb, ref, vector, nowForSalience);
+            }
+        }
+        finally {
+            stateDb.close();
+        }
+    }
+    catch (err) {
+        rethrowIfTestIsolationError(err);
+        // best-effort: salience persistence failure never blocks ranking
+    }
+    // ── 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
+    // signal-delta gating. Any ref already present in mergedRefs keeps its
+    // existing eligibilitySource (stronger reactive signals win); refs not yet in
+    // the pool are synthesised as minimal ImproveEligibleRef stubs and labelled
+    // 'forgetting-safety' so S5/WS-5 can slice by lane. The dedupeRefs call
+    // ensures no ref can enter the loop twice.
+    if (pendingForgettingRefs.length > 0 && scope.mode !== "ref") {
+        const existingRefSet = new Set(mergedRefs.map((r) => r.ref));
+        const newForgettingRefs = [];
+        for (const ref of pendingForgettingRefs) {
+            if (!existingRefSet.has(ref)) {
+                // Ref not already in the candidate pool — synthesise a stub so it
+                // participates in the reflect/distill loop with proper attribution.
+                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).
+            eligibilitySourceByRef.set(ref, "forgetting-safety");
+        }
+        if (newForgettingRefs.length > 0) {
+            mergedRefs = dedupeRefs([...mergedRefs, ...newForgettingRefs]);
+        }
+        // Re-stamp attribution for any refs whose lane needs updating.
+        // Precedence (weakest → strongest, each overwrites the previous):
+        //   proactive < high-retrieval < 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.
+        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
+        // `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.
+        for (const ref of pendingForgettingRefs) {
+            eligibilitySourceByRef.set(ref, "forgetting-safety");
+        }
+        // signal-delta is the strongest reactive signal and overrides forgetting-safety.
+        for (const r of signalFiltered)
+            eligibilitySourceByRef.set(r.ref, "signal-delta");
+        // Update eligibilitySource on the ref objects themselves for any refs whose
+        // lane changed (covers both new stubs and pre-existing refs).
+        for (const r of mergedRefs) {
+            r.eligibilitySource = eligibilitySourceByRef.get(r.ref) ?? "unknown";
+        }
+    }
+    // ── 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
+    // regardless of cooldown — exactly like the forgetting-safety lane, replay is
+    // injected AFTER cooldown/signal-delta partitioning so it bypasses those gates.
+    //
+    // Strictly additive: the replay slice is appended AFTER the --limit fresh slice
+    // (see the loopRefs partition below), so it can never shrink the fresh-ref set.
+    // Replay is the WEAKEST lane — it only stamps refs no other lane already claimed,
+    // and budget is spent only on refs not already in mergedRefs (so a stronger lane
+    // never has its budget wasted or its label overwritten).
+    //
+    // Default replayBudget=0 ⇒ this whole block is a no-op (no DB open, no event,
+    // no mergedRefs mutation), preserving byte-identical pre-#610 selection behavior.
+    const replayBudget = (options.config ?? loadConfig()).improve?.salience?.replayBudget ?? 0;
+    const replayRefSet = new Set();
+    if (replayBudget > 0 && scope.mode !== "ref" && !options.requireFeedbackSignal) {
+        let replayDb;
+        try {
+            replayDb = openStateDatabase(eventsCtx?.dbPath);
+            const alreadyInPool = new Set(mergedRefs.map((r) => r.ref));
+            const allRankScores = getAllRankScores(replayDb);
+            // 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
+            // EXCLUDED — a stronger skip than the dampener (which only halves order).
+            let convergedSkipped = 0;
+            const candidates = [];
+            for (const [ref, rankScore] of allRankScores) {
+                if (alreadyInPool.has(ref))
+                    continue;
+                const noOps = getConsecutiveNoOps(replayDb, ref);
+                if (noOps >= SALIENCE_NO_OP_DAMPEN_THRESHOLD) {
+                    convergedSkipped++;
+                    continue;
+                }
+                candidates.push({ ref, rankScore });
+            }
+            candidates.sort((a, b) => b.rankScore !== a.rankScore ? b.rankScore - a.rankScore : a.ref < b.ref ? -1 : a.ref > b.ref ? 1 : 0);
+            const candidatePool = candidates.length;
+            const selected = candidates.slice(0, replayBudget);
+            const newReplayRefs = [];
+            for (const { ref } of selected) {
+                replayRefSet.add(ref);
+                // Synthesise a stub (mirror the forgetting-safety stub). Resolve the
+                // backing file from the planned-ref pool so the downstream existsSync
+                // guard keeps the ref (a replay candidate from asset_salience whose file
+                // is gone correctly drops out). Only refs present in the indexed pool can
+                // be revisited — refs without a planned entry get no filePath and are
+                // dropped by the disk check, which is the desired behavior.
+                const planned = plannedRefs.find((p) => p.ref === ref);
+                newReplayRefs.push({
+                    ref,
+                    reason: "scope-type",
+                    eligibilitySource: "replay",
+                    ...(planned?.filePath ? { filePath: planned.filePath } : {}),
+                });
+                // Seed the salienceMap so the sort/effectiveScore can rank the replay ref.
+                if (!salienceMap.has(ref)) {
+                    salienceMap.set(ref, {
+                        encoding: 0,
+                        outcome: 0,
+                        retrieval: 0,
+                        rankScore: allRankScores.get(ref) ?? 0,
+                    });
+                }
+            }
+            if (newReplayRefs.length > 0) {
+                mergedRefs = dedupeRefs([...mergedRefs, ...newReplayRefs]);
+                // Replay is the WEAKEST lane: stamp 'replay' ONLY for refs not already
+                // keyed by a stronger lane.
+                for (const ref of replayRefSet) {
+                    if (!eligibilitySourceByRef.has(ref))
+                        eligibilitySourceByRef.set(ref, "replay");
+                }
+                for (const r of mergedRefs) {
+                    r.eligibilitySource = eligibilitySourceByRef.get(r.ref) ?? "unknown";
+                }
+            }
+            // Aggregated observability event (never per-ref).
+            appendEvent({
+                eventType: "improve_replay_selected",
+                ref: undefined,
+                metadata: {
+                    count: newReplayRefs.length,
+                    budget: replayBudget,
+                    convergedSkipped,
+                    candidatePool,
+                },
+            }, eventsCtx);
+        }
+        catch (err) {
+            rethrowIfTestIsolationError(err);
+            // best-effort: if DB unavailable, replayRefSet stays empty
+        }
+        finally {
+            if (replayDb)
+                replayDb.close();
+        }
+    }
+    // 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 utilA = utilityMap.get(a.ref) ?? 0;
-        const utilB = utilityMap.get(b.ref) ?? 0;
-        const ratioA = feedbackRatios.get(a.ref) ?? 0;
-        const ratioB = feedbackRatios.get(b.ref) ?? 0;
-        // Combined score: 70% utility, 30% negative ratio
-        const scoreA = utilA * 0.7 + ratioA * 0.3;
-        const scoreB = utilB * 0.7 + ratioB * 0.3;
-        return scoreB - scoreA;
+        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 = [];
@@ -2261,8 +3040,22 @@ async function runImprovePreparationStage(args) {
         }
     }
     // ── 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 loopRefs = options.limit ? allLoopRefs.slice(0, options.limit) : allLoopRefs;
+    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).
@@ -2273,7 +3066,7 @@ async function runImprovePreparationStage(args) {
             `(${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)`);
+        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`);
@@ -2284,6 +3077,17 @@ async function runImprovePreparationStage(args) {
     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(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,
@@ -2403,6 +3207,10 @@ async function runImproveLoopStage(args) {
         stashDir: primaryStashDir,
         config: options.config ?? loadConfig(),
         eventsCtx,
+        stateDbPath: eventsCtx?.dbPath,
+        // candidateCount drives the exploration budget. loopRefs is the per-phase
+        // set for reflect/distill; pass it so exploration budget is proportional.
+        candidateCount: loopRefs.length,
     });
     const distillGateCfg = makeGateConfig("distill", {
         globalThreshold: options.autoAccept,
@@ -2410,6 +3218,8 @@ async function runImproveLoopStage(args) {
         stashDir: primaryStashDir,
         config: options.config ?? loadConfig(),
         eventsCtx,
+        stateDbPath: eventsCtx?.dbPath,
+        candidateCount: loopRefs.length,
     });
     for (const planned of loopRefs) {
         if (Date.now() - startMs >= budgetMs) {
@@ -2587,6 +3397,28 @@ async function runImproveLoopStage(args) {
                             reason: reflectResult.ok ? undefined : reflectResult.reason,
                         },
                     }, eventsCtx);
+                    // Plasticity counter (plan §WS-1 step 8): record no-ops so the
+                    // WS-1 selection comparator (effectiveScore, ~line 3073) can dampen
+                    // repeatedly-silent assets during consolidation-selection.
+                    // A no_change reflect means the LLM was invoked but found nothing to
+                    // improve — the asset is stable. Track it. A successful reflect means
+                    // the asset changed; reset the counter so the dampener lifts.
+                    if (isNoChange && eventsCtx?.db) {
+                        try {
+                            recordNoOp(eventsCtx.db, planned.ref);
+                        }
+                        catch {
+                            // best-effort: plasticity counter failure never blocks the run
+                        }
+                    }
+                    else if (reflectResult.ok && eventsCtx?.db) {
+                        try {
+                            resetConsecutiveNoOps(eventsCtx.db, planned.ref);
+                        }
+                        catch {
+                            // best-effort
+                        }
+                    }
                     if (reflectResult.ok) {
                         const reflectGr = await runAutoAcceptGate([{ proposalId: reflectResult.proposal.id, confidence: reflectResult.proposal.confidence }], reflectGateCfg);
                         gateAutoAcceptedCount += reflectGr.promoted.length;
@@ -2725,6 +3557,23 @@ async function runImproveLoopStage(args) {
                     if (!promotedToKnowledge)
                         memoryRefsForInference.add(planned.ref);
                 }
+                // Plasticity counter (plan §WS-1 step 8) for the distill path.
+                // quality_rejected: the LLM ran but produced output that didn't pass the
+                // quality gate — the asset is not yielding useful distill output.
+                // queued: a proposal was produced; reset the no-op counter.
+                if (eventsCtx?.db) {
+                    try {
+                        if (distillResult.outcome === "quality_rejected" || distillResult.outcome === "skipped") {
+                            recordNoOp(eventsCtx.db, planned.ref);
+                        }
+                        else if (distillResult.outcome === "queued") {
+                            resetConsecutiveNoOps(eventsCtx.db, planned.ref);
+                        }
+                    }
+                    catch {
+                        // best-effort: plasticity counter failure never blocks the run
+                    }
+                }
                 if (distillResult.outcome === "quality_rejected" && primaryStashDir) {
                     const slug = planned.ref
                         .replace(/[^a-z0-9]/gi, "-")
@@ -2791,6 +3640,26 @@ async function runImproveLoopStage(args) {
         completedCount++;
         info(`[improve] ${completedCount}/${loopRefs.length} ${planned.ref}`);
     }
+    // WS-4: Per-phase threshold auto-tune — runs AFTER the loop so the gate
+    // has processed all candidates for this run. Persists each phase's tuned
+    // threshold to state.db for the NEXT run's makeGateConfig to read.
+    // Best-effort: a tune failure must never fail the improve run.
+    const stateDbPathForTune = eventsCtx?.dbPath;
+    if (options.autoAccept !== undefined && stateDbPathForTune) {
+        const phaseGateCfgMap = {
+            reflect: reflectGateCfg,
+            distill: distillGateCfg,
+        };
+        for (const phase of ["reflect", "distill"]) {
+            const phaseCfg = phaseGateCfgMap[phase];
+            try {
+                maybeAutoTuneThreshold(phaseCfg.phaseThreshold ?? options.autoAccept, options.config ?? loadConfig(), stateDbPathForTune, undefined, phase);
+            }
+            catch (err) {
+                warn(`[improve] calibration auto-tune (${phase}) skipped: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
     return { reflectsWithErrorContext, memoryRefsForInference, gateAutoAcceptedCount, gateAutoAcceptFailedCount };
 }
 async function runImprovePostLoopStage(args) {
@@ -2834,9 +3703,70 @@ async function runImprovePostLoopStage(args) {
             // best-effort
         }
     }
+    // #609 — recombine / synthesize pass. Whole-corpus cross-episodic
+    // generalization. Runs in the post-loop stage under consolidate.lock (it
+    // reads the consolidated corpus and writes proposals). Opt-in: gated on the
+    // `recombine` process being enabled, whole-stash / type scope (never `ref`),
+    // and not a dry run. Mirrors the proactiveMaintenance opt-in wiring.
+    let recombination;
+    if (primaryStashDir &&
+        improveProfile &&
+        resolveProcessEnabled("recombine", improveProfile) &&
+        scope.mode !== "ref" &&
+        !options.dryRun) {
+        const recombineFn = options.recombineFn ?? akmRecombine;
+        try {
+            recombination = await recombineFn({
+                stashDir: primaryStashDir,
+                config: options.config ?? loadConfig(),
+                ...(options.runId ? { sourceRun: options.runId } : {}),
+                ...(budgetSignal ? { signal: budgetSignal } : {}),
+                ...(options.autoAccept !== undefined ? { autoAccept: options.autoAccept } : {}),
+                eligibilitySource: "recombine",
+                ...(eventsCtx ? { ctx: eventsCtx } : {}),
+                minClusterSize: improveProfile.processes?.recombine?.minClusterSize,
+                maxClustersPerRun: improveProfile.processes?.recombine?.maxClustersPerRun,
+                relatednessSource: improveProfile.processes?.recombine?.relatednessSource,
+                confirmThreshold: improveProfile.processes?.recombine?.confirmThreshold,
+            });
+        }
+        catch (e) {
+            allWarnings.push(`recombine: ${String(e)}`);
+        }
+    }
+    // #615 — procedural-compilation pass. Detects recurring successful ordered
+    // action sequences and compiles them into workflow proposals. Opt-in: gated
+    // on the `procedural` process being enabled, whole-stash / type scope (never
+    // `ref`), and not a dry run. Mirrors the recombine opt-in wiring.
+    let proceduralCompilation;
+    if (primaryStashDir &&
+        improveProfile &&
+        resolveProcessEnabled("procedural", improveProfile) &&
+        scope.mode !== "ref" &&
+        !options.dryRun) {
+        const proceduralFn = options.proceduralFn ?? akmProcedural;
+        try {
+            proceduralCompilation = await proceduralFn({
+                stashDir: primaryStashDir,
+                config: options.config ?? loadConfig(),
+                ...(options.runId ? { sourceRun: options.runId } : {}),
+                ...(budgetSignal ? { signal: budgetSignal } : {}),
+                ...(options.autoAccept !== undefined ? { autoAccept: options.autoAccept } : {}),
+                eligibilitySource: "procedural",
+                ...(eventsCtx ? { ctx: eventsCtx } : {}),
+                minRecurrence: improveProfile.processes?.procedural?.minRecurrence,
+                maxProposalsPerRun: improveProfile.processes?.procedural?.maxProposalsPerRun,
+            });
+        }
+        catch (e) {
+            allWarnings.push(`procedural: ${String(e)}`);
+        }
+    }
     return {
         allWarnings,
         deadUrls,
+        ...(recombination ? { recombination } : {}),
+        ...(proceduralCompilation ? { proceduralCompilation } : {}),
         ...(maintenanceResult.memoryInference ? { memoryInference: maintenanceResult.memoryInference } : {}),
         ...(maintenanceResult.graphExtraction ? { graphExtraction: maintenanceResult.graphExtraction } : {}),
         ...(maintenanceResult.stalenessDetection ? { stalenessDetection: maintenanceResult.stalenessDetection } : {}),