akm-cli 0.9.30 → 0.10.261001-beta

package/dist/commands/improve/improve.js

@@ -28,7 +28,7 @@ import { resolveEntryContentDir, resolveSourceEntries } from "../../indexer/sear
 import { collectEngineCredentialValues } from "../../integrations/agent/engine-resolution.js";
 import { installLlmUsagePersistence } from "../../llm/usage-persist.js";
 import { withLlmStage } from "../../llm/usage-telemetry.js";
-import { isGitBackedStash, listGitChangedPaths, resolveWritableOverride, saveGitStash, } from "../../sources/providers/git.js";
+import { GitStashPushError, isGitBackedStash, listGitChangedPaths, resolveWritableOverride, saveGitStash, } from "../../sources/providers/git.js";
 import { closeDatabase, openExistingDatabase } from "../../storage/repositories/index-connection.js";
 import { getEntryCount } from "../../storage/repositories/index-entries-repository.js";
 import { openSqliteReadSnapshot, SqliteReadSnapshotUnavailableError } from "../../storage/sqlite-read-snapshot.js";
@@ -70,7 +70,8 @@ export function renderSyncCommitMessage(template, result, nowMs) {
 export const FIRST_ENGINE_RESPONSE_HEARTBEAT_MS = 5_000;
 /**
  * Abort the run at the budget; force-exit (0 — budget exhaustion is a normal
- * scheduled-task outcome) only if the drain overruns the grace period.
+ * scheduled-task outcome) only if the drain overruns the grace period, after
+ * `onHardKill` has persisted what the killed run left behind.
  * Returns an idempotent disposer.
  */
 export function armBudgetWatchdog(budgetMs, controller, deps) {
@@ -81,7 +82,15 @@ export function armBudgetWatchdog(budgetMs, controller, deps) {
     let hardKillTimer;
     const budgetTimer = setTimeoutFn(() => {
         controller.abort("improve budget exhausted");
-        hardKillTimer = setTimeoutFn(() => exitFn(0), hardKillGraceMs);
+        hardKillTimer = setTimeoutFn(() => {
+            try {
+                deps?.onHardKill?.();
+            }
+            catch {
+                // Best-effort: the forced exit must still happen.
+            }
+            exitFn(0);
+        }, hardKillGraceMs);
         hardKillTimer.unref?.();
     }, budgetMs);
     return () => {
@@ -101,6 +110,7 @@ export async function akmImprove(options = {}) {
     // Set by the usage sink when any engine call terminates, prepass included.
     let firstEngineResponseSeen = false;
     let initialGitPaths = new Set();
+    let preRunSync;
     // The write-provenance journal (#652) spans exactly the window this run holds the lock.
     let journal;
     const closeJournal = () => {
@@ -155,7 +165,20 @@ export async function akmImprove(options = {}) {
     });
     if (!options.dryRun) {
         const remainingBudget = budgetAbortController.signal.remainingBudgetMs;
-        clearBudgetTimer = armBudgetWatchdog(Math.max(1, remainingBudget ?? budgetMs), budgetAbortController);
+        clearBudgetTimer = armBudgetWatchdog(Math.max(1, remainingBudget ?? budgetMs), budgetAbortController, {
+            // The forced exit skips every finally and the CLI catch: leave a terminated
+            // run record and bank the files this run wrote (journal is in memory) first.
+            // Local commit only — a push to a dead remote must not hang the exit.
+            onHardKill: () => {
+                try {
+                    options.onBudgetHardKill?.();
+                }
+                catch {
+                    // best-effort
+                }
+                commitStashBatch({ scope, plannedRefs: collected?.plannedRefs ?? [], runId: options.runId }, { push: false });
+            },
+        });
     }
     try {
         if (!options.dryRun) {
@@ -174,6 +197,9 @@ export async function akmImprove(options = {}) {
             });
             exitBackstop = releaseRunLock;
             process.on("exit", exitBackstop);
+            // Pull in what another host pushed before anything reads the bundle (#1091). This also commits
+            // pending managed-path changes, as `akm sync` does, so they are not mistaken for this run's writes.
+            preRunSync = syncBeforeRun(setup, eventsCtx);
             initialGitPaths =
                 syncRepoDir && isGitBackedStash(syncRepoDir) ? new Set(listGitChangedPaths(syncRepoDir)) : new Set();
             journal = beginWriteProvenance();
@@ -246,6 +272,8 @@ export async function akmImprove(options = {}) {
         if (writtenPaths.length > 0)
             result.writtenPaths = writtenPaths;
         result.sync = commitStashBatch(result);
+        if (preRunSync)
+            result.preRunSync = preRunSync;
         return result;
     }
     catch (err) {
@@ -654,7 +682,7 @@ function buildResultExecutionPlan(run, preparation, collected, dryRun) {
             enabled: scope.mode !== "ref" && resolvedPlan.processes.triage.enabled,
             configuredMode: configuredTriage?.applyMode ?? "queue",
             mode: improveProfile.processes?.triage?.applyMode ?? "queue",
-            maxAcceptsPerRun: configuredTriage?.maxAcceptsPerRun ?? 25,
+            maxAcceptsPerRun: configuredTriage?.maxAcceptsPerRun ?? 200,
         },
     });
 }
@@ -674,7 +702,7 @@ async function runTriagePrePass(run) {
             ...(options.target ? { target: options.target } : {}),
             config: options.config,
             applyMode: triageConfig?.applyMode ?? "queue",
-            maxAccepts: triageConfig?.maxAcceptsPerRun ?? 25,
+            maxAccepts: triageConfig?.maxAcceptsPerRun ?? 200,
             dryRun: false,
             excludeIds: new Set(),
             judgment: resolvedPlan.triageJudgment,
@@ -712,60 +740,114 @@ export function resolveSyncPathSet(input) {
         unattributed: changedPaths.filter((p) => !attributed.has(p) && !initialPaths.has(p) && inScope(p)).sort(),
     };
 }
+/**
+ * One `saveGitStash` call for the run's write-target bundle, shared by the
+ * pre-run sync and the auto-sync commit: never throws, records a `stash_synced`
+ * event, and returns undefined when the bundle is not git-backed, there is no
+ * primary stash, or sync is disabled (`--no-sync` / `sync.enabled: false`).
+ * `scopePaths` runs inside the guard; leaving `paths` undefined means what
+ * `akm sync` stages (the managed paths).
+ */
+function runStashSync(run, eventsCtx, phase, input) {
+    const { writeTarget, primaryStashDir, effectiveSync, options, config, improveProfile } = run;
+    const repoDir = writeTarget?.source.repoPath ?? primaryStashDir;
+    if (!primaryStashDir || !repoDir || effectiveSync.enabled === false || !isGitBackedStash(repoDir)) {
+        return undefined;
+    }
+    const saveGitStashFn = options.saveGitStashFn ?? saveGitStash;
+    const writableOverride = writeTarget ? resolveWritable(writeTarget.config) : resolveWritableOverride(config);
+    const push = input.push ?? options.sync?.push ?? improveProfile.sync?.push ?? true;
+    const record = (metadata) => appendEvent({ eventType: "stash_synced", metadata: { phase, ...metadata } }, eventsCtx);
+    try {
+        const { paths, unattributed } = input.scopePaths({
+            repoDir,
+            assetRoot: writeTarget?.source.path ?? primaryStashDir,
+        });
+        const syncResult = saveGitStashFn(undefined, input.message, writableOverride, {
+            push,
+            repoDir,
+            ...(paths ? { paths } : {}),
+        });
+        record({
+            committed: syncResult.committed,
+            pushed: syncResult.pushed,
+            skipped: syncResult.skipped,
+            reason: syncResult.reason ?? null,
+            ...(paths ? { attributed: paths.length, unattributed: unattributed ?? 0 } : {}),
+        });
+        return {
+            committed: syncResult.committed,
+            pushed: syncResult.pushed,
+            skipped: syncResult.skipped,
+            ...(syncResult.reason !== undefined ? { reason: syncResult.reason } : {}),
+        };
+    }
+    catch (syncErr) {
+        const reason = errMessage(syncErr);
+        warn(`improve: stash sync failed (non-fatal): ${reason}`);
+        // A push that failed after the commit landed still left the commit in the repo.
+        const committed = syncErr instanceof GitStashPushError;
+        record({ committed, pushed: false, skipped: true, reason });
+        return { committed, pushed: false, skipped: true, reason };
+    }
+}
+/**
+ * The pre-run sync (#1091): the same fetch / fast-forward-or-merge / commit /
+ * push `akm sync` runs for the write-target bundle, before the index and plan
+ * stages so they see what another host pushed. A conflict or fetch failure is
+ * a warning, never an abort: the run continues on the local state.
+ */
+function syncBeforeRun(run, eventsCtx) {
+    const outcome = runStashSync(run, eventsCtx, "pre-run", {
+        message: "akm improve pre-run sync",
+        scopePaths: ({ repoDir, assetRoot }) => {
+            // A bundle whose content sits in a subdirectory of the repo stages only that subdirectory, as
+            // `akm sync` does for a content root; a root-level bundle leaves `paths` to the managed-path default.
+            const assetPrefix = path.relative(repoDir, assetRoot).replaceAll(path.sep, "/");
+            if (!assetPrefix)
+                return {};
+            return resolveSyncPathSet({
+                repoDir,
+                assetPrefix,
+                changedPaths: listGitChangedPaths(repoDir),
+                initialPaths: new Set(),
+                writtenPaths: [],
+                provenance: false,
+            });
+        },
+    });
+    if (outcome?.reason)
+        warn(`[improve] pre-run sync: ${outcome.reason}; continuing on the local state`);
+    return outcome;
+}
 /**
  * The auto-sync commit (#662), used at end of run and from the crash path:
  * idempotent and never throws. The getters read bindings reassigned after this
  * factory runs.
  */
 function makeCommitStashBatch(deps) {
-    const { writeTarget, primaryStashDir, effectiveSync, options, config, improveProfile } = deps.run;
-    return (messageContext) => {
-        const eventsCtx = deps.getEventsCtx();
+    const { effectiveSync } = deps.run;
+    return (messageContext, override) => {
         const writeJournal = deps.getWriteJournal();
-        const repoDir = writeTarget?.source.repoPath ?? primaryStashDir;
-        if (!primaryStashDir || !repoDir || effectiveSync.enabled === false || !isGitBackedStash(repoDir)) {
-            return undefined;
-        }
-        const saveGitStashFn = options.saveGitStashFn ?? saveGitStash;
-        const writableOverride = writeTarget ? resolveWritable(writeTarget.config) : resolveWritableOverride(config);
-        const push = options.sync?.push ?? improveProfile.sync?.push ?? true;
         const message = renderSyncCommitMessage(effectiveSync.message ?? "akm improve auto-sync", messageContext, Date.now());
-        const record = (metadata) => appendEvent({ eventType: "stash_synced", metadata }, eventsCtx);
-        try {
-            const assetRoot = writeTarget?.source.path ?? primaryStashDir;
-            const { paths, unattributed } = resolveSyncPathSet({
-                repoDir,
-                assetPrefix: path.relative(repoDir, assetRoot).replaceAll(path.sep, "/"),
-                changedPaths: listGitChangedPaths(repoDir),
-                initialPaths: deps.getInitialGitPaths(),
-                writtenPaths: writeJournal?.writtenPaths() ?? [],
-                provenance: writeJournal !== undefined,
-            });
-            if (unattributed.length > 0) {
-                warnVerbose(`[improve] auto-sync left ${unattributed.length} path(s) uncommitted — not written by this run: ${unattributed.join(", ")}`);
-            }
-            const syncResult = saveGitStashFn(undefined, message, writableOverride, { push, repoDir, paths });
-            record({
-                committed: syncResult.committed,
-                pushed: syncResult.pushed,
-                skipped: syncResult.skipped,
-                reason: syncResult.reason ?? null,
-                attributed: paths.length,
-                unattributed: unattributed.length,
-            });
-            return {
-                committed: syncResult.committed,
-                pushed: syncResult.pushed,
-                skipped: syncResult.skipped,
-                ...(syncResult.reason !== undefined ? { reason: syncResult.reason } : {}),
-            };
-        }
-        catch (syncErr) {
-            const reason = errMessage(syncErr);
-            warn(`improve: stash sync failed (non-fatal): ${reason}`);
-            record({ committed: false, pushed: false, skipped: true, reason });
-            return { committed: false, pushed: false, skipped: true, reason };
-        }
+        return runStashSync(deps.run, deps.getEventsCtx(), "end-of-run", {
+            message,
+            push: override?.push,
+            scopePaths: ({ repoDir, assetRoot }) => {
+                const { paths, unattributed } = resolveSyncPathSet({
+                    repoDir,
+                    assetPrefix: path.relative(repoDir, assetRoot).replaceAll(path.sep, "/"),
+                    changedPaths: listGitChangedPaths(repoDir),
+                    initialPaths: deps.getInitialGitPaths(),
+                    writtenPaths: writeJournal?.writtenPaths() ?? [],
+                    provenance: writeJournal !== undefined,
+                });
+                if (unattributed.length > 0) {
+                    warnVerbose(`[improve] auto-sync left ${unattributed.length} path(s) uncommitted — not written by this run: ${unattributed.join(", ")}`);
+                }
+                return { paths, unattributed: unattributed.length };
+            },
+        });
     };
 }
 /**

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

@@ -22,7 +22,7 @@ import { getLiveRefSnapshot, isRefLiveInSnapshot, } from "../../storage/reposito
 import { clearAssetOutcomeMissing, countAssetOutcomeMissing, deleteAssetOutcomeMissingBefore, listAssetOutcomeMissingState, stampAssetOutcomeMissing, } from "../../storage/repositories/outcome-repository.js";
 import { clearAssetSalienceMissing, countAssetSalienceMissing, deleteAssetSalienceMissingBefore, listAssetSalienceMissingState, stampAssetSalienceMissing, } from "../../storage/repositories/salience-repository.js";
 import { readFreelistInfo, STATE_DB_VACUUMED_EVENT, vacuumIfReclaimable } from "../../storage/state-db-integrity.js";
-import { purgeOldTaskLogFiles } from "../../tasks/run/task-log.js";
+import { purgeOldRunLogFiles, purgeOldTaskLogFiles } from "../../tasks/run/task-log.js";
 import { expireStaleProposals, purgeOrphanProposals } from "../proposal/repository.js";
 import { checkDeadUrls } from "../url-checker.js";
 import { isDistillCandidateRef } from "./eligibility.js";
@@ -148,7 +148,6 @@ async function runLoopReflectPass(planned, env, tally) {
         ...(options.sourceName && primaryStashDir ? { target: { source: options.sourceName, root: primaryStashDir } } : {}),
         ...(reflectErrors.length > 0 ? { avoidPatterns: [...reflectErrors] } : {}),
         eventSource: "improve",
-        lowValueFilter: improveProfile.processes?.reflect?.lowValueFilter?.enabled === true,
         ...(improveProfile.processes?.reflect?.defectFilter
             ? { defectFilter: improveProfile.processes.reflect.defectFilter }
             : {}),
@@ -174,10 +173,18 @@ async function runLoopReflectPass(planned, env, tally) {
         result,
     });
     // A quality rejection recorded itself, and the judge's text is no lesson for
-    // the next prompt; skips revisit on the `unchanged` cadence.
+    // the next prompt; skips revisit on the `unchanged` cadence. A transient
+    // failure (transport, parse, timeout, budget abort, crash) is not a verdict
+    // on the asset and writes no row, like distill: a `failed` row would advance
+    // the ledger cursor and consume the feedback that planned the ref. Only a
+    // guard rejection records `failed`.
     if (!result.ok && reason !== "quality_rejected") {
-        recordLoopAttempt(planned, env, "reflect", skipped ? "unchanged" : "failed", reason);
-        if (!skipped) {
+        if (skipped)
+            recordLoopAttempt(planned, env, "reflect", "unchanged", reason);
+        else if (reason === "content_policy_reject")
+            recordLoopAttempt(planned, env, "reflect", "failed", reason);
+        // A budget abort is no lesson for the next prompt either.
+        if (!skipped && reason !== "aborted") {
             tally.recentErrorPushes.push({
                 originator: "reflect",
                 message: result.error ?? reason ?? "unknown reflect error",
@@ -588,6 +595,12 @@ export function runRetentionPurgePass(ctx) {
     catch (err) {
         warnings.push(`task log files purge failed: ${errMessage(err)}`);
     }
+    try {
+        report("run_log_files_purged", "run_log_files/_purge", purgeOldRunLogFiles(retentionDays), "improve/index run log file(s)");
+    }
+    catch (err) {
+        warnings.push(`run log files purge failed: ${errMessage(err)}`);
+    }
     return { warnings };
 }
 /**

package/dist/commands/improve/planner.js

@@ -99,7 +99,6 @@ export function buildImproveExecutionPlan(input) {
             effective: { ...input.consolidation.effective },
             gates: {
                 profile: { ...input.consolidation.gates.profile },
-                minimumPool: { ...input.consolidation.gates.minimumPool },
                 delta: { ...input.consolidation.gates.delta },
             },
         },

package/dist/commands/improve/preparation.js

@@ -9,8 +9,8 @@
  * Candidate selection reads the improve ledger plus one set of signals: a ref
  * is eligible for a source when feedback newer than its last attempt landed and
  * no ledger window holds it, and reflect reads only negative feedback. Refs
- * without recent feedback can still be picked by the fallback lanes (proactive
- * maintenance, high salience), which only score them; the survivors are ranked
+ * without recent feedback can still be picked by the proactive-maintenance
+ * lane, which plans them with the rest; the survivors are ranked
  * by salience, checked on disk and capped. A plan-only run evaluates the same
  * selectors against read snapshots and writes nothing.
  */
@@ -35,7 +35,7 @@ import { isAutonomyLaneAllowed } from "./autonomy-gate.js";
 import { akmConsolidate, inspectConsolidationPool, loadExistingKnowledgeBodyHashes, makeConsolidateResult, } from "./consolidate.js";
 import { computeSafeChunkSize, DEFAULT_CONTEXT_LENGTH_TOKENS } from "./consolidate/chunking.js";
 import { contentHash } from "./content-hash.js";
-import { assetTypeOf, buildUtilityMap, dedupeRefs, findAssetFilePath, isDistillCandidateRef, isLessonCandidate, resolveImproveScope, withIndexDb, } from "./eligibility.js";
+import { assetTypeOf, buildUtilityMap, dedupeRefs, findAssetFilePath, isDistillCandidateRef, isLessonCandidate, withIndexDb, } from "./eligibility.js";
 import { akmExtract, countNewExtractCandidates } from "./extract.js";
 import { computeValenceScore } from "./feedback-valence.js";
 import { isLedgerBlocked, lastAttemptByRef, ledgerRowFor, loadLedgerSnapshot, stateKey, } from "./ledger.js";
@@ -81,7 +81,7 @@ export function pickDefined(source, keys) {
             out[key] = source[key];
     return out;
 }
-export const CONSOLIDATION_CONFIG_KEYS = ["enabled", "minPoolSize", "limit", "maxChunkSize"];
+export const CONSOLIDATION_CONFIG_KEYS = ["enabled", "limit", "maxChunkSize"];
 /** Emit an aggregate `improve_skipped` row (never one per ref). */
 export function recordImproveSkip(eventsCtx, ref, metadata) {
     appendEvent({ eventType: "improve_skipped", ref, metadata }, eventsCtx);
@@ -96,19 +96,13 @@ export function pushRecentError(recentErrors, originator, msg) {
 }
 // ── Consolidation ────────────────────────────────────────────────────────────
 /**
- * The consolidation gates and pool, with no model call: the profile toggle,
- * `minPoolSize` (not for a named strategy or ref scope, nor once the pool is
- * over the 100-memory volume trigger), and the ledger delta (every memory
- * judged recently and unchanged since means nothing to do).
+ * The consolidation gates and pool, with no model call: the profile toggle
+ * and the ledger delta (every memory judged recently and unchanged since
+ * means nothing to do).
  */
 function planConsolidationPass(args) {
-    const { options, primaryStashDir, memorySummary, resolvedPlan } = args;
+    const { options, primaryStashDir, resolvedPlan } = args;
     const processConfig = args.improveProfile?.processes?.consolidate;
-    const volumeTriggered = memorySummary.eligible > 100 && resolvedPlan.processes.consolidate.runner !== null;
-    const minPoolSize = typeof processConfig?.minPoolSize === "number" ? processConfig.minPoolSize : 0;
-    const eligiblePoolSize = typeof memorySummary.eligible === "number" ? memorySummary.eligible : 0;
-    const userNamed = options.strategy !== undefined || resolveImproveScope(options.scope).mode === "ref";
-    const poolBelowMinSize = !volumeTriggered && !userNamed && minPoolSize > 0 && eligiblePoolSize < minPoolSize;
     const pool = primaryStashDir
         ? inspectConsolidationPool({
             config: options.config,
@@ -127,18 +121,13 @@ function planConsolidationPass(args) {
         DEFAULT_CONTEXT_LENGTH_TOKENS, 500, processConfig?.maxChunkSize);
     const profilePassed = processConfig?.enabled !== false;
     const deltaPassed = pool.candidatePoolSize > 0 || pool.judgedUnchanged === 0;
-    const wouldRun = profilePassed && !poolBelowMinSize && deltaPassed && pool.candidatePoolSize > 0;
-    const belowMin = `pool ${eligiblePoolSize} is below minPoolSize ${minPoolSize}`;
+    const wouldRun = profilePassed && deltaPassed && pool.candidatePoolSize > 0;
     const unchanged = "every memory was judged recently and is unchanged since";
     return {
-        poolBelowMinSize,
-        eligiblePoolSize,
-        minPoolSize,
         plan: {
             configured: pickDefined(processConfig, CONSOLIDATION_CONFIG_KEYS),
             effective: {
                 enabled: profilePassed,
-                minPoolSize,
                 ...(processConfig?.limit !== undefined ? { limit: processConfig.limit } : {}),
                 chunkSize,
             },
@@ -149,10 +138,6 @@ function planConsolidationPass(args) {
                     passed: profilePassed,
                     reason: profilePassed ? "consolidation enabled" : "disabled by improve profile",
                 },
-                minimumPool: {
-                    passed: !poolBelowMinSize,
-                    reason: poolBelowMinSize ? belowMin : `pool satisfies minPoolSize ${minPoolSize}`,
-                },
                 delta: {
                     passed: deltaPassed,
                     reason: !deltaPassed
@@ -165,13 +150,11 @@ function planConsolidationPass(args) {
             wouldRun,
             reason: !profilePassed
                 ? "disabled by improve profile"
-                : poolBelowMinSize
-                    ? belowMin
-                    : !deltaPassed
-                        ? unchanged
-                        : pool.candidatePoolSize === 0
-                            ? "candidate pool is empty after narrowing"
-                            : "all consolidation gates pass",
+                : !deltaPassed
+                    ? unchanged
+                    : pool.candidatePoolSize === 0
+                        ? "candidate pool is empty after narrowing"
+                        : "all consolidation gates pass",
             estimatedChunks: wouldRun ? Math.ceil(pool.candidatePoolSize / chunkSize) : 0,
         },
     };
@@ -186,14 +169,6 @@ async function runConsolidationPass(args) {
     if (!planned.plan.gates.profile.passed) {
         info("[improve] consolidation skipped (disabled by improve profile)");
     }
-    else if (planned.poolBelowMinSize) {
-        recordImproveSkip(eventsCtx, "memories/_consolidation", {
-            reason: "pool_below_min_size",
-            poolSize: planned.eligiblePoolSize,
-            minPoolSize: planned.minPoolSize,
-        });
-        info(`[improve] consolidation skipped (pool ${planned.eligiblePoolSize} < minPoolSize ${planned.minPoolSize})`);
-    }
     else if (!planned.plan.gates.delta.passed) {
         recordImproveSkip(eventsCtx, "memories/_consolidation", { reason: "consolidation_no_memory_updates" });
         info("[improve] consolidation skipped (every memory was judged recently and is unchanged)");
@@ -212,7 +187,6 @@ async function runConsolidationPass(args) {
             limit: processConfig?.limit,
             maxChunkSize: processConfig?.maxChunkSize,
             signal: args.budgetSignal,
-            p90ChunkSecondsDefault: processConfig?.p90ChunkSecondsDefault,
             // Its read-only proposal lookups go through the run's own state.db handle.
             ...(eventsCtx?.db ? { proposalsCtx: { db: eventsCtx.db } } : {}),
         }));
@@ -671,7 +645,7 @@ export function buildSnapshotManifest(args) {
  *  - distillOnlyRefs: only distill's passes (any signal, a positive or a note
  *    included), on a distill candidate;
  *  - noFeedbackPool: no recent feedback and no reflect window, left to the
- *    fallback lanes, which only score them;
+ *    proactive-maintenance lane;
  *  - fullySkippedCount: feedback on record but nothing new, or a live window.
  * An explicit `--scope <ref>` bypasses every gate.
  */
@@ -722,12 +696,12 @@ export function partitionBySignalDelta(args) {
     return out;
 }
 /**
- * Pick the loop's refs: signal delta, the fallback lanes (unless
- * `--require-feedback-signal`; they score, never plan), lane attribution,
- * salience, the no-op-dampened ranking, the disk check and the limit.
+ * Pick the loop's refs: signal delta, the proactive-maintenance lane (unless
+ * `--require-feedback-signal`), lane attribution, salience, the no-op-dampened
+ * ranking, the disk check and the limit.
  */
 async function selectLoopCandidates(args, postCleanupRefs, validationFailureRefs, actions, persist) {
-    const { scope, options, primaryStashDir, eventsCtx, improveProfile } = args;
+    const { scope, options, primaryStashDir, eventsCtx } = args;
     const snapshot = buildSnapshotManifest({
         postCleanupRefs,
         validationFailureRefs,
@@ -739,9 +713,8 @@ async function selectLoopCandidates(args, postCleanupRefs, validationFailureRefs
     const processableRefs = [...partition.eligibleRefs, ...partition.distillOnlyRefs];
     const signalFiltered = processableRefs.filter((c) => snapshot.feedback.get(c.ref)?.hasSignal === true);
     const signalBearingSet = new Set(signalFiltered.map((r) => r.ref));
-    // The fallback lanes (proactive, high salience) have no usage evidence of
-    // their own: they pick only what retrieval returned or new material improve
-    // never processed (#986). Evaluated once per candidate.
+    // The proactive lane has no usage evidence of its own: it picks only what
+    // retrieval returned or new material improve never processed (#986). Evaluated once per candidate.
     const fallbackEligible = postCleanupRefs.filter((c) => !validationFailureRefs.has(c.ref));
     const allowFallbacks = options.requireFeedbackSignal !== true;
     const retrievalScope = scope.mode === "ref" || !allowFallbacks
@@ -753,22 +726,20 @@ async function selectLoopCandidates(args, postCleanupRefs, validationFailureRefs
         ...partition.noFeedbackPool,
     ]);
     const noFeedbackCandidates = noFeedbackPool.filter((r) => !unscoped.has(r.ref));
-    // Only a ref no fallback lane may pick anymore is charged to the retrieval gate.
+    // Only a ref the proactive lane may not pick is charged to the retrieval gate.
     const outOfScope = new Set(noFeedbackPool.filter((r) => unscoped.has(r.ref)).map((r) => r.ref));
     const retrieval = fetchRetrievalSignals(options, signalFiltered, noFeedbackCandidates, eventsCtx, persist);
     const proactive = allowFallbacks
         ? selectProactiveMaintenanceLane(args, noFeedbackCandidates, snapshot, retrieval, persist)
         : { proactiveRefs: [] };
-    const highSalienceRefs = allowFallbacks
-        ? selectHighSalienceLane(options, improveProfile, eventsCtx, noFeedbackCandidates.filter((r) => !proactive.proactiveRefs.some((p) => p.ref === r.ref)), snapshot.lastReflectAttemptAt, persist)
-        : [];
-    // An explicit ref scope always acts on its ref; otherwise only feedback plans the loop. The fallback lanes'
-    // picks are scored with it, never planned: a rewrite needs negative feedback.
-    const signalAndRetrievalRefs = dedupeRefs([...signalFiltered, ...proactive.proactiveRefs, ...highSalienceRefs]);
-    const mergedRefs = scope.mode === "ref" ? processableRefs : signalFiltered;
-    const scoredRefs = scope.mode === "ref" ? processableRefs : signalAndRetrievalRefs;
-    // Lane attribution: signal-delta, and an explicit ref scope over it.
+    // Planned: signal-delta refs plus the proactive lane's picks (whole-stash / type scope); an explicit ref scope
+    // acts on its own refs.
+    const mergedRefs = scope.mode === "ref" ? processableRefs : dedupeRefs([...signalFiltered, ...proactive.proactiveRefs]);
+    // Lane attribution, weakest first so the strongest wins: proactive < signal-delta, and an explicit ref scope
+    // over everything.
     const sourceByRef = new Map();
+    for (const r of proactive.proactiveRefs)
+        sourceByRef.set(r.ref, "proactive");
     for (const r of signalFiltered)
         sourceByRef.set(r.ref, "signal-delta");
     if (scope.mode === "ref")
@@ -776,7 +747,7 @@ async function selectLoopCandidates(args, postCleanupRefs, validationFailureRefs
             sourceByRef.set(r.ref, "scope");
     for (const r of mergedRefs)
         r.eligibilitySource = sourceByRef.get(r.ref) ?? "unknown";
-    const salienceMap = scoreSalience(args, scoredRefs, snapshot.feedback, retrieval.retrievalCounts, persist);
+    const salienceMap = scoreSalience(args, mergedRefs, snapshot.feedback, retrieval.retrievalCounts, persist);
     // Rank by salience; a ref skipped as a no-op repeatedly sorts lower (its stored rank is untouched).
     const noOps = new Map();
     withRunState(eventsCtx, persist, (db) => {
@@ -795,8 +766,8 @@ async function selectLoopCandidates(args, postCleanupRefs, validationFailureRefs
         distillOnlyRefs: partition.distillOnlyRefs,
         limit: options.limit,
     });
-    if (signalAndRetrievalRefs.length > 0) {
-        info(`[improve] ${signalAndRetrievalRefs.length} refs with usage signals (${signalFiltered.length} feedback)`);
+    if (mergedRefs.length > 0) {
+        info(`[improve] ${mergedRefs.length} refs with usage signals (${signalFiltered.length} feedback)`);
     }
     if (validationFailureRefs.size > 0)
         info(`[improve] ${validationFailureRefs.size} with validation failures excluded`);
@@ -883,11 +854,11 @@ function fetchRetrievalSignals(options, signalFiltered, noFeedbackCandidates, ev
     return out;
 }
 /**
- * Proactive maintenance (default off, whole-stash/type runs): pick stable
- * assets due for a revisit. The picks are scored and never planned: improve
- * does not rewrite on a proactive cadence. The due gate doubles as the
- * rotation cooldown: a freshly reflected asset waits `dueDays` before it is
- * picked again.
+ * Proactive maintenance (default on, whole-stash/type runs): pick stable
+ * assets due for a revisit and plan them with the feedback-bearing refs. The
+ * cap against a proposal flood: `maxPerRun` limits the picks per run, the due
+ * gate admits only an asset not reflected or distilled for `dueDays` (so each
+ * comes up at most once per `dueDays`), and reflect's `limit` bounds the run.
  */
 function selectProactiveMaintenanceLane(args, candidates, snapshot, retrieval, persist) {
     if (args.scope.mode === "ref" || !args.resolvedPlan.processes.proactiveMaintenance.enabled) {
@@ -895,7 +866,7 @@ function selectProactiveMaintenanceLane(args, candidates, snapshot, retrieval, p
     }
     const pmCfg = args.improveProfile.processes?.proactiveMaintenance;
     const dueDays = pmCfg?.dueDays ?? DEFAULT_DUE_DAYS;
-    const maxPerRun = pmCfg?.maxPerRun ?? pmCfg?.limit ?? DEFAULT_MAX_PER_RUN;
+    const maxPerRun = pmCfg?.maxPerRun ?? DEFAULT_MAX_PER_RUN;
     const selection = selectProactiveMaintenanceRefs({
         candidates,
         lastReflectTs: snapshot.lastReflectAttemptAt,
@@ -927,7 +898,7 @@ function selectProactiveMaintenanceLane(args, candidates, snapshot, retrieval, p
         proactiveRefs: selection.selected,
         proactiveMaintenanceSummary: { ...summary, selectedRefs },
         proactivePlan: {
-            configured: pickDefined(pmCfg, ["dueDays", "maxPerRun", "limit"]),
+            configured: pickDefined(pmCfg, ["dueDays", "maxPerRun"]),
             effective: { dueDays, maxPerRun },
             candidatePool: candidates.length,
             ...summary,
@@ -935,41 +906,13 @@ function selectProactiveMaintenanceLane(args, candidates, snapshot, retrieval, p
         },
     };
 }
-/**
- * High salience: zero-feedback refs whose content-derived encoding score (not
- * a per-type stub) reaches `salienceThreshold` and that were never reflected,
- * top-N by score, capped at 10% of the effective limit. The picks are scored,
- * never planned.
- */
-function selectHighSalienceLane(options, improveProfile, eventsCtx, candidates, lastReflectAttemptAt, persist) {
-    const threshold = (options.config ?? loadConfig()).improve?.salience?.salienceThreshold ?? 0.75;
-    const effectiveLimit = options.limit ?? improveProfile?.processes?.reflect?.limit ?? improveProfile.limit ?? 10;
-    const selected = withRunState(eventsCtx, persist, (db) => candidates
-        .flatMap((r) => {
-        const row = getAssetSalience(db, keyOf(r));
-        return row &&
-            isContentEncodingRow(row) &&
-            row.encoding_salience >= threshold &&
-            !lastReflectAttemptAt.has(r.ref)
-            ? [{ ref: r, score: row.encoding_salience }]
-            : [];
-    })
-        .sort((a, b) => b.score - a.score)
-        .slice(0, Math.max(1, Math.floor(effectiveLimit * 0.1)))
-        .map((q) => q.ref)) ?? [];
-    if (selected.length > 0) {
-        info(`[improve] high-salience lane admitted ${selected.length} content-scored ref(s) ` +
-            `(threshold=${threshold}, requires content-derived encoding_source)`);
-    }
-    return selected;
-}
 /**
  * Score the merged refs: update `asset_outcome` (projected on a plan-only
  * run), compute each salience vector (keeping a stored content-derived
  * encoding score), then persist it.
  */
 function scoreSalience(args, mergedRefs, feedback, retrievalCounts, persist) {
-    const { options, eventsCtx } = args;
+    const { eventsCtx } = args;
     const utilityMap = buildUtilityMap(mergedRefs, !persist);
     const lastUseMsByRef = withIndexDb(!persist, (db) => getLastUseMsByRef(db, mergedRefs)) ?? new Map();
     const outcomeSalience = updateOutcomeScores({
@@ -982,7 +925,6 @@ function scoreSalience(args, mergedRefs, feedback, retrievalCounts, persist) {
         eventsCtx,
         persist,
     });
-    const outcomeWeightEnabled = (options.config ?? loadConfig()).improve?.salience?.outcomeWeightEnabled !== false;
     const storedEncoding = new Map();
     withRunState(eventsCtx, persist, (db) => {
         for (const r of mergedRefs) {
@@ -1005,7 +947,6 @@ function scoreSalience(args, mergedRefs, feedback, retrievalCounts, persist) {
             outcomeSalience: outcomeSalience.get(r.ref),
             sizeBytes: fileSize(r.filePath),
             now,
-            outcomeWeightEnabled,
         }));
     }
     if (persist) {

package/dist/commands/improve/proactive-maintenance.js

@@ -6,8 +6,8 @@ import { computeSalience } from "./salience.js";
 const DAY_MS = 86_400_000;
 /** An asset is due when last reflected/distilled more than this many days ago (or never). */
 export const DEFAULT_DUE_DAYS = 30;
-/** Default bound on how many assets the selector surfaces per run. */
-export const DEFAULT_MAX_PER_RUN = 25;
+/** Fallback for `maxPerRun`; the same as the shipped `default` strategy. */
+export const DEFAULT_MAX_PER_RUN = 15;
 /** Size floor for the cost term, so tiny files don't divide by ~0. */
 const SIZE_FLOOR_BYTES = 200;
 /**