akm-cli 0.9.0-rc.3 → 0.9.0-rc.5

package/dist/commands/improve/improve.js

@@ -30,9 +30,7 @@ import { akmDistill } from "./distill.js";
 import { buildLatestProposalTsMap, collectEligibleRefs, collectEligibleRefsReadOnly, memoryCleanupParentRef, resolveImproveScope, shouldAnalyzeMemoryCleanup, } from "./eligibility.js";
 import { countEvalCases } from "./eval-cases.js";
 import { resolveImprovePlan } from "./improve-strategies.js";
-// #607 per-process lock primitives live in ./locks. Imported for internal use;
-// resetHeldProcessLocks is re-exported (the test seam imports it from here).
-import { PROCESS_LOCK_DEFS, processLockPath, releaseAllProcessLocks, releaseHeldLocksIfOwned, releaseProcessLock, tryAcquireProcessLock, withOptionalProcessLock, } from "./locks.js";
+import { improveLockPath, MIN_IMPROVE_LOCK_STALE_MS, releaseImproveLock, tryAcquireImproveLock } from "./locks.js";
 // The cycle loop / post-loop / maintenance stages live in ./loop-stages.
 import { runImproveLoopStage, runImprovePostLoopStage } from "./loop-stages.js";
 import { detectAndWriteContradictions } from "./memory/memory-contradiction-detect.js";
@@ -43,7 +41,6 @@ import { DEFAULT_DUE_DAYS, filterProactiveDue } from "./proactive-maintenance.js
 import { akmReflect } from "./reflect.js";
 import { errMessage } from "./shared.js";
 import { shouldReadLegacyBareImproveState } from "./source-identity.js";
-export { resetHeldProcessLocks } from "./locks.js";
 // Re-exported from ./loop-stages for test importers (improve-db-locking).
 export { runImproveMaintenancePasses } from "./loop-stages.js";
 // Re-exported from ./preparation so existing importers (tests, callers) resolve.
@@ -88,6 +85,15 @@ export function armBudgetWatchdog(budgetMs, controller, deps) {
     };
 }
 export async function akmImprove(options = {}) {
+    const startMs = Date.now();
+    const budgetMs = options.timeoutMs ?? 2 * 60 * 60 * 1000;
+    const budgetAbortController = new AbortController();
+    Object.defineProperty(budgetAbortController.signal, "remainingBudgetMs", {
+        get: () => Math.max(0, budgetMs - (Date.now() - startMs)),
+        enumerable: false,
+        configurable: true,
+    });
+    let clearBudgetTimer = () => { };
     const scope = resolveImproveScope(options.scope);
     const reflectFn = options.reflectFn ?? akmReflect;
     const distillFn = options.distillFn ?? akmDistill;
@@ -101,14 +107,7 @@ export async function akmImprove(options = {}) {
     const runImprovePostLoopStageImpl = options.runImprovePostLoopStageFn ?? runImprovePostLoopStage;
     // Resolve the improve profile for this run. Profile drives type filtering,
     // process gating, and default autoAccept/limit values.
-    let _earlyConfig = options.config ?? loadConfig();
-    const writeTarget = options.writeTarget ??
-        (options.target
-            ? resolveWriteTarget(_earlyConfig, options.target, { requireWritable: !options.dryRun })
-            : undefined);
-    if (writeTarget && options.target) {
-        _earlyConfig = { ..._earlyConfig, defaultWriteTarget: writeTarget.source.name };
-    }
+    const _earlyConfig = options.config ?? loadConfig();
     const resolvedPlan = options.resolvedPlan ??
         resolveImprovePlan(options.strategy, _earlyConfig, {
             repairValidationFailures: options.repairValidationFailures,
@@ -116,6 +115,18 @@ export async function akmImprove(options = {}) {
     const selectedStrategy = resolvedPlan.strategy;
     const improveSensitiveValues = collectEngineCredentialValues(_earlyConfig);
     const improveProfile = selectedStrategy.config;
+    const writeTarget = options.writeTarget ??
+        (options.target || _earlyConfig.defaultWriteTarget || !options.stashDir
+            ? resolveWriteTarget(_earlyConfig, options.target, { requireWritable: !options.dryRun })
+            : {
+                source: { kind: "filesystem", name: "stash", path: options.stashDir },
+                config: {
+                    type: "filesystem",
+                    name: "stash",
+                    path: options.stashDir,
+                    writable: true,
+                },
+            });
     // Apply profile defaults — CLI flags take precedence over profile defaults.
     // Rebuild options with effective values so all downstream stage functions
     // automatically pick up the profile-driven defaults.
@@ -124,20 +135,17 @@ export async function akmImprove(options = {}) {
         // Pin nested calls and quality gates to the same config snapshot as the
         // invocation plan. They must never reload a changed config mid-run.
         config: _earlyConfig,
-        ...(writeTarget
-            ? {
-                target: writeTarget.source.name,
-                writeTarget,
-                stashDir: writeTarget.source.path,
-                consolidateOptions: {
-                    ...options.consolidateOptions,
-                    target: writeTarget.source.name,
-                    writeTarget,
-                },
-            }
-            : {}),
+        target: writeTarget.selector,
+        sourceName: writeTarget.source.name,
+        writeTarget,
+        stashDir: writeTarget.source.path,
+        consolidateOptions: {
+            ...options.consolidateOptions,
+            target: writeTarget.selector,
+            writeTarget,
+        },
         legacyBareState: options.legacyBareState ??
-            shouldReadLegacyBareImproveState(writeTarget?.source.name, writeTarget?.source.path, _earlyConfig),
+            shouldReadLegacyBareImproveState(writeTarget.source.name, writeTarget.source.path, _earlyConfig),
         autoAccept: options.autoAccept ?? improveProfile.autoAccept,
         // Profile-level limit, then process-level reflect.limit as fallback.
         // CLI --limit takes precedence over both.
@@ -154,7 +162,7 @@ export async function akmImprove(options = {}) {
         primaryStashDir = undefined;
     }
     const syncRepoDir = writeTarget?.source.repoPath ?? primaryStashDir;
-    const initialGitPaths = syncRepoDir && isGitBackedStash(syncRepoDir) ? new Set(listGitChangedPaths(syncRepoDir)) : new Set();
+    let initialGitPaths = new Set();
     // C2 (#553/#554/#499): resolve the state.db path ONCE, synchronously, at the
     // command boundary — before the first `await` below. Every state.db open in
     // this run (`openStateDatabase`, every default-path `appendEvent`) is pinned
@@ -181,16 +189,11 @@ export async function akmImprove(options = {}) {
     //
     // 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.
-    //
-    //   consolidate.lock     — protects consolidate + memoryInference + graphExtraction (index.db writers)
-    //   reflect-distill.lock — protects reflect + distill (state.db proposal writers)
-    //   triage.lock          — protects triage pre-pass (state.db proposal promotions)
-    //
-    // Lock base directory — same `.akm/` under the primary stash dir.
+    // One conservative run lock protects the complete mutation window, including
+    // triage, indexing, proposal work, maintenance, and final stash sync.
     const lockBaseDir = primaryStashDir ? path.join(primaryStashDir, ".akm") : path.join(options.stashDir ?? ".", ".akm");
+    const resolvedLockPath = improveLockPath(lockBaseDir);
+    const lockStaleAfterMs = Math.max(MIN_IMPROVE_LOCK_STALE_MS, budgetMs + 10 * 60 * 1000);
     const preEnsureCleanupWarnings = [];
     // #616: assigned by runIndexAndCollect() (closure) so TS cannot prove definite
     // assignment — seed with empty values; the first runIndexAndCollect() call
@@ -236,9 +239,11 @@ export async function akmImprove(options = {}) {
                 // best-effort; leave preEnsureEntryCount undefined
             }
             try {
-                await ensureIndexFn(primaryStashDir, { mode: "blocking" });
+                await ensureIndexFn(primaryStashDir, { mode: "blocking", signal: budgetAbortController.signal });
             }
             catch (err) {
+                if (budgetAbortController.signal.aborted)
+                    throw err;
                 preEnsureCleanupWarnings.push(`ensureIndex failed: ${errMessage(err)}`);
             }
             // #339 loud-fail: if the index was empty pre-ensureIndex but is now
@@ -286,6 +291,8 @@ export async function akmImprove(options = {}) {
                     : null), { engine: resolvedPlan.processes.consolidate.runner?.engine, process: "consolidate" });
             }
             catch (err) {
+                if (budgetAbortController.signal.aborted)
+                    throw err;
                 // Non-fatal: contradiction detection is a best-effort pass.
                 warn(`[improve] contradiction detection failed (non-fatal): ${errMessage(err)}`);
             }
@@ -298,60 +305,74 @@ export async function akmImprove(options = {}) {
                 ? "Improve folds memory cleanup into the same proposal queue: speculative promotions still go through reflect/distill proposals, while high-confidence redundant derived memories are moved into a recoverable cleanup archive instead of being left active in the stash."
                 : undefined;
     };
-    // Holds our own process.on("exit") backstop so the finally can remove EXACTLY
-    // that handler (not every exit listener in the process). Declared in the scope
-    // shared by the try and its finally; assigned when the backstop is registered.
+    let improveLockOwnership;
     let exitBackstop;
+    const releaseRunLock = () => {
+        const ownership = improveLockOwnership;
+        if (!ownership)
+            return;
+        improveLockOwnership = undefined;
+        try {
+            releaseImproveLock(ownership);
+        }
+        catch {
+            // Best-effort cleanup. Exact ownership prevents deleting a successor.
+        }
+    };
+    if (!options.dryRun) {
+        const remainingBudget = budgetAbortController.signal.remainingBudgetMs;
+        clearBudgetTimer = armBudgetWatchdog(Math.max(1, remainingBudget ?? budgetMs), budgetAbortController);
+    }
     try {
-        // #607: Per-process lock acquisition. Each process acquires only the lock(s)
-        // it needs. The dry-run branch produces plannedRefs/memorySummary WITHOUT any
-        // locks (decision: dry-run never mutates the queue).
         if (!options.dryRun) {
-            // Backstop release on process.exit() (signal handler / budget watchdog),
-            // which skips the finally below. Removed in that finally on the normal path.
-            const releaseAllOnExit = () => releaseHeldLocksIfOwned();
-            exitBackstop = releaseAllOnExit;
-            process.on("exit", releaseAllOnExit);
-            // #607 triage pre-pass: acquire triage.lock, drain the standing pending
-            // backlog BEFORE ensureIndex so improve generates fresh proposals against
-            // a cleared queue (no `duplicate_pending` collisions) and ensureIndex
-            // absorbs triage's promotions for free. Release immediately after —
-            // triage.lock is not needed again until the next improve run.
+            const acquisition = tryAcquireImproveLock(resolvedLockPath, lockStaleAfterMs, options.skipIfLocked);
+            if (acquisition.state === "skipped") {
+                clearBudgetTimer();
+                return {
+                    schemaVersion: 2,
+                    ok: true,
+                    strategy: selectedStrategy.name,
+                    scope,
+                    dryRun: false,
+                    skipped: { reason: "lock-held" },
+                    memorySummary: { eligible: 0, derived: 0 },
+                    plannedRefs: [],
+                    actions: [],
+                    ...(options.runId !== undefined ? { runId: options.runId } : {}),
+                };
+            }
+            improveLockOwnership = acquisition.ownership;
+            exitBackstop = releaseRunLock;
+            process.on("exit", exitBackstop);
+            initialGitPaths =
+                syncRepoDir && isGitBackedStash(syncRepoDir) ? new Set(listGitChangedPaths(syncRepoDir)) : new Set();
+            // Drain the standing proposal backlog before indexing so fresh proposal
+            // generation sees promotions from this same serialized run.
             if (primaryStashDir && resolvedPlan.processes.triage.enabled) {
                 if (scope.mode === "ref") {
                     warn("[improve] triage pre-pass skipped (single-ref scope never drains the whole queue)");
                 }
                 else {
-                    const triageLPath = processLockPath(lockBaseDir, "triage");
-                    const triageResult = tryAcquireProcessLock(triageLPath, PROCESS_LOCK_DEFS.triage.staleAfterMs, options.skipIfLocked, "triage");
-                    if (triageResult.state === "skipped") {
-                        triageDrain = undefined;
+                    try {
+                        const triageConfig = improveProfile.processes?.triage;
+                        const policy = resolveDrainPolicy(triageConfig?.policy);
+                        const applyMode = triageConfig?.applyMode ?? "queue";
+                        const maxAccepts = triageConfig?.maxAcceptsPerRun ?? 25;
+                        triageDrain = await drainProposalsFn({
+                            stashDir: primaryStashDir,
+                            ...(options.target ? { target: options.target } : {}),
+                            config: options.config,
+                            policy,
+                            applyMode,
+                            maxAccepts,
+                            dryRun: false,
+                            excludeIds: new Set(),
+                            ...(triageConfig?.maxDiffLines !== undefined ? { maxDiffLines: triageConfig.maxDiffLines } : {}),
+                            judgment: resolvedPlan.triageJudgment,
+                        });
                     }
-                    else {
-                        try {
-                            const triageConfig = improveProfile.processes?.triage;
-                            const policy = resolveDrainPolicy(triageConfig?.policy);
-                            const applyMode = triageConfig?.applyMode ?? "queue";
-                            const maxAccepts = triageConfig?.maxAcceptsPerRun ?? 25;
-                            triageDrain = await drainProposalsFn({
-                                stashDir: primaryStashDir,
-                                ...(options.target ? { target: options.target } : {}),
-                                config: options.config,
-                                policy,
-                                applyMode,
-                                maxAccepts,
-                                dryRun: false,
-                                excludeIds: new Set(),
-                                ...(triageConfig?.maxDiffLines !== undefined ? { maxDiffLines: triageConfig.maxDiffLines } : {}),
-                                judgment: resolvedPlan.triageJudgment,
-                            });
-                        }
-                        catch (err) {
-                            warn(`[improve] triage pre-pass failed (non-fatal): ${errMessage(err)}`);
-                        }
-                        finally {
-                            releaseProcessLock(triageResult.ownership);
-                        }
+                    catch (err) {
+                        warn(`[improve] triage pre-pass failed (non-fatal): ${errMessage(err)}`);
                     }
                 }
             }
@@ -373,39 +394,19 @@ export async function akmImprove(options = {}) {
                 plannedRefs,
                 ...(strategyFilteredRefs.length > 0 ? { strategyFilteredRefs } : {}),
             };
+            clearBudgetTimer();
             return result;
         }
     }
     catch (err) {
-        releaseAllProcessLocks();
+        clearBudgetTimer();
+        if (exitBackstop) {
+            process.removeListener("exit", exitBackstop);
+            exitBackstop = undefined;
+        }
+        releaseRunLock();
         throw err;
     }
-    // #607: per-process locks are acquired/released around each stage below.
-    // The triage pre-pass already ran under triage.lock (released). The
-    // preparation stage runs under consolidate.lock, the loop stage under
-    // reflect-distill.lock, and the post-loop stage under consolidate.lock again.
-    // Each stage acquires its lock just before starting and releases in finally.
-    // best-effort `unlinkSync` is a no-op when no lock file exists.
-    const startMs = Date.now();
-    const budgetMs = options.timeoutMs ?? 2 * 60 * 60 * 1000; // default 2 hours
-    // O-1 (#364): Create a shared AbortController derived from startMs + budgetMs.
-    // Every async seam receives this signal so a hung sub-call cannot extend the
-    // 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 = () => { };
     // I1: open a single state.db connection for the entire improve run so all
     // appendEvent calls reuse one handle instead of open/migrate/close per call.
     let eventsDb;
@@ -489,14 +490,6 @@ export async function akmImprove(options = {}) {
         }
     };
     try {
-        // H7 (#566): arm the budget watchdog. `armBudgetWatchdog` captures both the
-        // budget timer and the hard-kill timer it schedules on exhaustion, returning
-        // a single dispose() that clears whichever are still pending. The `finally`
-        // calls dispose() via `clearBudgetTimer` (RAII), so a clean cooperative
-        // drain cancels the pending hard-kill before it can fire — the process then
-        // exits naturally instead of being force-`exit(0)`-ed mid-flush, which could
-        // truncate an in-flight log or `state.db` transaction.
-        clearBudgetTimer = armBudgetWatchdog(budgetMs, budgetAbortController);
         try {
             eventsDb = openStateDatabase(resolvedStateDbPath);
             eventsCtx = { db: eventsDb };
@@ -533,9 +526,8 @@ export async function akmImprove(options = {}) {
         // #616 — bounded multi-cycle phasing. The prep->loop->post-loop sequence is
         // wrapped in an N-cycle loop. Each cycle re-runs ensureIndex +
         // collectEligibleRefs (via runIndexAndCollect) so gate-accepted output of
-        // cycle N becomes selectable input to cycle N+1. The per-stage process locks
-        // (consolidate / reflect-distill) are acquired+released INSIDE each cycle,
-        // exactly as the single-pass path did. For maxCycles:1 the loop runs once and
+        // cycle N becomes selectable input to cycle N+1. The whole sequence runs
+        // under the invocation's single lock. For maxCycles:1 the loop runs once and
         // every accumulator below collapses to the single-cycle value (sum-of-one,
         // concat-of-one, last==only) => BYTE-IDENTICAL to pre-#616.
         //
@@ -606,15 +598,7 @@ export async function akmImprove(options = {}) {
                     }, eventsCtx);
                 }
             }
-            // #607: acquire consolidate.lock for the preparation stage (consolidate,
-            // ensureIndex, extract all write index.db). Released immediately after.
-            const consolidateLPath = processLockPath(lockBaseDir, "consolidate");
-            preparation = await withOptionalProcessLock({
-                lockPath: consolidateLPath,
-                staleAfterMs: PROCESS_LOCK_DEFS.consolidate.staleAfterMs,
-                skipIfLocked: options.skipIfLocked,
-                label: "consolidate",
-            }, () => runImprovePreparationStageImpl({
+            const runPreparation = () => runImprovePreparationStageImpl({
                 scope,
                 options,
                 plannedRefs,
@@ -630,7 +614,8 @@ export async function akmImprove(options = {}) {
                 resolvedPlan,
                 strategyName: selectedStrategy.name,
                 budgetSignal: budgetAbortController.signal,
-            }));
+            });
+            preparation = await runPreparation();
             prepGateCount += preparation.gateAutoAcceptedCount;
             prepGateFailedCount += preparation.gateAutoAcceptFailedCount;
             // D6: pre-load all proposal_rejected events from the last 30 days once,
@@ -644,26 +629,15 @@ export async function akmImprove(options = {}) {
                     rejectedProposalsByRef.set(e.ref, e);
                 }
             }
-            // #607: acquire reflect-distill.lock for the loop stage (reflect + distill
-            // both write proposals to state.db). Released immediately after.
-            const reflectDistillLPath = processLockPath(lockBaseDir, "reflectDistill");
-            const loopResult = await withOptionalProcessLock({
-                lockPath: reflectDistillLPath,
-                staleAfterMs: PROCESS_LOCK_DEFS.reflectDistill.staleAfterMs,
-                skipIfLocked: options.skipIfLocked,
-                label: "reflect-distill",
-            }, () => {
-                // Post-lock cooldown re-filter for proactive refs (#SELECT-TIME-LEAK).
-                // Planning built `lastReflectProposalTs` BEFORE acquiring this lock, so a
-                // concurrent run's `reflect_invoked` writes are invisible to it. Now that
-                // we hold the lock, re-read fresh timestamp maps for the proactive subset
-                // and drop any ref whose cooldown has been consumed by the concurrent run.
+            const runLoop = () => {
+                // Re-read cooldown timestamps immediately before execution so external
+                // proposal writes that occurred before this run acquired its lock are visible.
                 const proactiveLoopRefs = preparation.loopRefs.filter((r) => r.eligibilitySource === "proactive");
                 let postLockLoopRefs = preparation.loopRefs;
                 if (proactiveLoopRefs.length > 0) {
                     const proactiveRefStrs = proactiveLoopRefs.map((r) => r.ref);
-                    const freshReflectTs = buildLatestProposalTsMap(proactiveRefStrs, "reflect", options.target, options.legacyBareState);
-                    const freshDistillTs = buildLatestProposalTsMap(proactiveRefStrs, "distill", options.target, options.legacyBareState);
+                    const freshReflectTs = buildLatestProposalTsMap(proactiveRefStrs, "reflect", options.sourceName, options.legacyBareState);
+                    const freshDistillTs = buildLatestProposalTsMap(proactiveRefStrs, "distill", options.sourceName, options.legacyBareState);
                     const pmDueDays = improveProfile.processes?.proactiveMaintenance?.dueDays ?? DEFAULT_DUE_DAYS;
                     const stillDue = new Set(filterProactiveDue(proactiveLoopRefs, freshReflectTs, freshDistillTs, pmDueDays, Date.now()).map((r) => r.ref));
                     const dropped = proactiveLoopRefs.filter((r) => !stillDue.has(r.ref));
@@ -693,7 +667,8 @@ export async function akmImprove(options = {}) {
                     resolvedPlan,
                     budgetSignal: budgetAbortController.signal,
                 });
-            });
+            };
+            const loopResult = await runLoop();
             const loopGateCountThisCycle = loopResult.gateAutoAcceptedCount;
             reflectsWithErrorContext += loopResult.reflectsWithErrorContext;
             loopGateCount += loopResult.gateAutoAcceptedCount;
@@ -702,33 +677,42 @@ export async function akmImprove(options = {}) {
             // #551: consolidation now runs in the preparation stage (before extract);
             // its result and run-flag are read from `preparation`, not the post-loop.
             consolidation = preparation.consolidation;
-            // #607: acquire consolidate.lock for the post-loop stage (memoryInference +
-            // graphExtraction both write index.db). Released immediately after.
-            const consolidatePostLPath = processLockPath(lockBaseDir, "consolidate");
-            const postLoopResult = await withOptionalProcessLock({
-                lockPath: consolidatePostLPath,
-                staleAfterMs: PROCESS_LOCK_DEFS.consolidate.staleAfterMs,
-                skipIfLocked: options.skipIfLocked,
-                label: "consolidate",
-            }, () => runImprovePostLoopStageImpl({
-                scope,
-                options,
-                primaryStashDir,
-                actionableRefs: preparation.actionableRefs,
-                appliedCleanup: preparation.appliedCleanup,
-                cleanupWarnings: preparation.cleanupWarnings,
-                memoryRefsForInference,
-                reindexFn,
-                eventsCtx,
-                budgetSignal: budgetAbortController.signal,
-                improveProfile,
-                resolvedPlan,
-                consolidationRan: preparation.consolidationRan,
-                // R5: floor violations from this run's consolidate pass + the
-                // auto-accepted volume so far (prep + loop gates) for churn detection.
-                consolidationMergeFloorViolations: preparation.consolidation.mergeFloorViolations ?? 0,
-                acceptedActions: preparation.gateAutoAcceptedCount + loopGateCountThisCycle,
-            }));
+            // Do not start new post-loop work after the shared wall-clock budget. The
+            // result still finalizes normally, so scheduled budget exhaustion exits 0.
+            const emptyPostLoopResult = {
+                allWarnings: [],
+                gateAutoAcceptedCount: 0,
+                gateAutoAcceptFailedCount: 0,
+                memoryInferenceDurationMs: 0,
+                graphExtractionDurationMs: 0,
+            };
+            const remainingBudget = budgetAbortController.signal.remainingBudgetMs;
+            let postLoopResult;
+            if (budgetAbortController.signal.aborted || (remainingBudget !== undefined && remainingBudget <= 0)) {
+                info("[improve] post-loop maintenance skipped (wall-clock budget exhausted)");
+                postLoopResult = emptyPostLoopResult;
+            }
+            else {
+                postLoopResult = await runImprovePostLoopStageImpl({
+                    scope,
+                    options,
+                    primaryStashDir,
+                    actionableRefs: preparation.actionableRefs,
+                    appliedCleanup: preparation.appliedCleanup,
+                    cleanupWarnings: preparation.cleanupWarnings,
+                    memoryRefsForInference,
+                    reindexFn,
+                    eventsCtx,
+                    budgetSignal: budgetAbortController.signal,
+                    improveProfile,
+                    resolvedPlan,
+                    consolidationRan: preparation.consolidationRan,
+                    // R5: floor violations from this run's consolidate pass + the
+                    // auto-accepted volume so far (prep + loop gates) for churn detection.
+                    consolidationMergeFloorViolations: preparation.consolidation.mergeFloorViolations ?? 0,
+                    acceptedActions: preparation.gateAutoAcceptedCount + loopGateCountThisCycle,
+                });
+            }
             const postLoopGateCountThisCycle = postLoopResult.gateAutoAcceptedCount;
             // Last-wins point-in-time objects.
             memoryInference = postLoopResult.memoryInference;
@@ -916,9 +900,6 @@ export async function akmImprove(options = {}) {
         // O-1 (#364): Clear the budget abort timer so it does not keep the event
         // loop alive after the run completes.
         clearBudgetTimer();
-        // #607: release any per-process locks still held (backstop for error paths;
-        // the normal path already released each lock after its stage completed).
-        releaseAllProcessLocks();
         // Drop ONLY our own process.exit backstop so it does not fire later (or
         // accumulate across repeated in-process calls). Must NOT use
         // removeAllListeners("exit") here: in the in-process model (tests and
@@ -928,6 +909,7 @@ export async function akmImprove(options = {}) {
             process.removeListener("exit", exitBackstop);
             exitBackstop = undefined;
         }
+        releaseRunLock();
         // I1: close the long-lived state.db connection opened at the top of the run.
         try {
             eventsDb?.close();