akm-cli 0.8.1 → 0.9.0-beta.0

package/dist/commands/{improve.js → improve/improve.js}

@@ -3,44 +3,47 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import fs from "node:fs";
 import path from "node:path";
-import { makeAssetRef, parseAssetRef } from "../core/asset-ref";
-import { daysToMs, isAssetType } from "../core/common";
-import { getDefaultLlmConfig, loadConfig } from "../core/config";
-import { ConfigError, NotFoundError, rethrowIfTestIsolationError, UsageError } from "../core/errors";
-import { appendEvent, readEvents } from "../core/events";
-import { probeLock, releaseLock, tryAcquireLockSync } from "../core/file-lock";
-import { parseFrontmatter } from "../core/frontmatter";
-import { detectAndWriteContradictions } from "../core/memory-contradiction-detect";
-import { analyzeMemoryCleanup, applyMemoryCleanup, } from "../core/memory-improve";
-import { getDbPath } from "../core/paths";
-import { createProposal, expireStaleProposals, getProposal, isProposalSkipped, listProposals, purgeOrphanProposals, } from "../core/proposals";
-import { openStateDatabase, purgeOldEvents, purgeOldImproveRuns } from "../core/state-db";
-import { info, warn } from "../core/warn";
-import { closeDatabase, getAllEntries, getEntryCount, getRetrievalCounts, getUtilityScoresByIds, getZeroResultSearches, openDatabase, openExistingDatabase, } from "../indexer/db";
-import { ensureIndex } from "../indexer/ensure-index";
-import { runGraphExtractionPass } from "../indexer/graph-extraction";
-import { akmIndex } from "../indexer/indexer";
-import { runMemoryInferencePass, } from "../indexer/memory-inference";
-import { resolveAssetPath } from "../indexer/path-resolver";
-import { getWritableStashDirs, resolveSourceEntries } from "../indexer/search-source";
-import { runStalenessDetectionPass } from "../indexer/staleness-detect";
-import { resolveImproveProcessRunnerFromProfile, resolveTriageJudgmentRunner } from "../integrations/agent/runner";
-import { getAvailableHarnesses } from "../integrations/session-logs";
-import { isLlmFeatureEnabled, isProcessEnabled } from "../llm/feature-gate";
-import { isGitBackedStash, resolveWritableOverride, saveGitStash } from "../sources/providers/git";
-import { akmConsolidate } from "./consolidate";
-import { akmDistill, deriveLessonRef, isDistillRefusedInputType } from "./distill";
-import { deriveKnowledgeRef } from "./distill-promotion-policy";
-import { countEvalCases, writeEvalCase } from "./eval-cases";
-import { akmExtract } from "./extract";
-import { makeGateConfig, resolveExtractConfidence, runAutoAcceptGate } from "./improve-auto-accept";
-import { isProfileFilteredForAllPasses, resolveImproveProfile, resolveProcessEnabled, shouldSkipRef, } from "./improve-profiles";
-import { akmLint } from "./lint/index";
-import { drainProposals } from "./proposal-drain";
-import { resolveDrainPolicy } from "./proposal-drain-policies";
-import { akmReflect } from "./reflect";
-import { runSchemaRepairPass } from "./schema-repair";
-import { checkDeadUrls } from "./url-checker";
+import { assertNever } from "../../core/assert.js";
+import { makeAssetRef, parseAssetRef } from "../../core/asset/asset-ref.js";
+import { parseFrontmatter } from "../../core/asset/frontmatter.js";
+import { daysToMs, isAssetType } from "../../core/common.js";
+import { getDefaultLlmConfig, loadConfig } from "../../core/config/config.js";
+import { ConfigError, NotFoundError, rethrowIfTestIsolationError, UsageError } from "../../core/errors.js";
+import { appendEvent, readEvents } from "../../core/events.js";
+import { probeLock, releaseLock, tryAcquireLockSync } from "../../core/file-lock.js";
+import { classifyImproveAction } from "../../core/improve-types.js";
+import { getDbPath, getStateDbPathInDataDir } from "../../core/paths.js";
+import { openStateDatabase, 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";
+import { runGraphExtractionPass } from "../../indexer/graph/graph-extraction.js";
+import { akmIndex } from "../../indexer/indexer.js";
+import { runMemoryInferencePass } from "../../indexer/passes/memory-inference.js";
+import { runStalenessDetectionPass } from "../../indexer/passes/staleness-detect.js";
+import { getWritableStashDirs, resolveSourceEntries } from "../../indexer/search/search-source.js";
+import { countUsageEventsByType } from "../../indexer/usage/usage-events.js";
+import { resolveAssetPath } from "../../indexer/walk/path-resolver.js";
+import { resolveImproveProcessRunnerFromProfile, resolveTriageJudgmentRunner } from "../../integrations/agent/runner.js";
+import { getAvailableHarnesses } from "../../integrations/session-logs/index.js";
+import { isLlmFeatureEnabled, isProcessEnabled } from "../../llm/feature-gate.js";
+import { isGitBackedStash, resolveWritableOverride, saveGitStash } from "../../sources/providers/git.js";
+import { akmLint } from "../lint/index.js";
+import { drainProposals } from "../proposal/drain.js";
+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 { 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 { 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 { akmReflect } from "./reflect.js";
 function resolveImproveScope(scope) {
     const trimmed = scope?.trim();
     if (!trimmed)
@@ -51,7 +54,7 @@ function resolveImproveScope(scope) {
     }
     catch {
         if (!isAssetType(trimmed)) {
-            throw new UsageError(`Unknown asset type: "${trimmed}". Valid types: memory, knowledge, skill, lesson, workflow, agent, command, script, wiki, env, vault, task.\n` +
+            throw new UsageError(`Unknown asset type: "${trimmed}". Valid types: memory, knowledge, skill, lesson, workflow, agent, command, script, wiki, env, secret, task.\n` +
                 `If you passed --format to akm improve, that flag is not supported — use it with akm search or akm show instead.`, "INVALID_FLAG_VALUE");
         }
         return { mode: "type", value: trimmed };
@@ -70,6 +73,9 @@ function resolveImproveScope(scope) {
  *   {scope}      scope value (e.g. a ref/type) or the scope mode (`all`)
  *   {refs}       number of planned refs this run processed
  *   {accepted}   number of proposals auto-accepted by the confidence gate
+ *   {triage_promoted}  proposals promoted by the triage pre-pass (0 if triage did not run)
+ *   {triage_rejected}  proposals rejected by the triage pre-pass (0 if triage did not run)
+ *   {runId}      this run's id (empty string when absent)
  *
  * The result is still passed through `sanitizeCommitMessage` downstream in
  * `saveGitStash`, so token values never widen the commit-message attack surface
@@ -87,6 +93,9 @@ export function renderSyncCommitMessage(template, result, nowMs) {
         scope: result.scope.value ?? result.scope.mode,
         refs: String(result.plannedRefs.length),
         accepted: String(result.gateAutoAcceptedCount ?? 0),
+        triage_promoted: String(result.triage?.promoted ?? 0),
+        triage_rejected: String(result.triage?.rejected ?? 0),
+        runId: result.runId ?? "",
     };
     return template.replace(/\{(\w+)\}/g, (match, key) => (Object.hasOwn(tokens, key) ? tokens[key] : match));
 }
@@ -395,6 +404,51 @@ function isSignalDeltaEligible(ref, latestFeedback, lastProposal) {
         return true;
     return fb > lp;
 }
+/**
+ * H7 (#566): cooperative budget watchdog with a captured, RAII-cleared hard-kill.
+ *
+ * When the wall-clock budget expires, `onExhausted` (normally an
+ * `AbortController.abort`) signals cooperative cancellation so the run can drain
+ * its in-flight log/`state.db` flush and unwind naturally. A second hard-kill
+ * timer is then armed as a watchdog: it only `exit(0)`s if the drain itself
+ * overruns `hardKillGraceMs`, preventing the process from outliving the task
+ * timeout window (lock-cascade fix).
+ *
+ * Both timers are captured; the returned dispose() clears whichever is still
+ * pending. Callers invoke it from a `finally`, so a *clean* drain reaches the
+ * `finally` and cancels the pending hard-kill before it can fire — the previous
+ * detached `setTimeout(() => process.exit(0), 5000)` always fired, truncating a
+ * clean flush. The hard-kill timer is `unref()`-ed so it never keeps the event
+ * loop alive on its own: once the run drains it exits with its own code, not the
+ * forced 0.
+ *
+ * Dependencies are injectable purely so the concurrency-sensitive timing
+ * contract can be exercised deterministically in unit tests.
+ */
+export function armBudgetWatchdog(budgetMs, controller, deps) {
+    const setTimeoutFn = deps?.setTimeoutFn ?? setTimeout;
+    const clearTimeoutFn = deps?.clearTimeoutFn ?? clearTimeout;
+    const exitFn = deps?.exitFn ?? ((code) => process.exit(code));
+    const hardKillGraceMs = deps?.hardKillGraceMs ?? 5_000;
+    let hardKillTimer;
+    const budgetTimer = setTimeoutFn(() => {
+        // Cooperative cancellation first: let the run drain.
+        controller.abort("improve budget exhausted");
+        // Watchdog: only force-exit if the drain itself overruns the grace period.
+        // Exit 0: budget exhaustion is a normal scheduled-task condition, not an error.
+        hardKillTimer = setTimeoutFn(() => exitFn(0), hardKillGraceMs);
+        // Never keep the event loop alive solely for the watchdog.
+        hardKillTimer.unref?.();
+    }, budgetMs);
+    // RAII dispose: clears whichever timer is still pending. Idempotent.
+    return () => {
+        clearTimeoutFn(budgetTimer);
+        if (hardKillTimer !== undefined) {
+            clearTimeoutFn(hardKillTimer);
+            hardKillTimer = undefined;
+        }
+    };
+}
 export async function akmImprove(options = {}) {
     const scope = resolveImproveScope(options.scope);
     const reflectFn = options.reflectFn ?? akmReflect;
@@ -421,6 +475,15 @@ export async function akmImprove(options = {}) {
     catch {
         primaryStashDir = undefined;
     }
+    // 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
+    // to this snapshot via `eventsCtx.dbPath`, so a parallel test file mutating
+    // `process.env.XDG_DATA_HOME` across an await boundary can never redirect this
+    // run's DB opens to a wrong/just-deleted tmpdir mid-flight (the parallel-load
+    // 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();
     // Phase 4 lock hoist (§7): the `improve.lock` setup is hoisted ABOVE
     // ensureIndex/collectEligibleRefs so the triage pre-pass (and improve's own
     // queue writes) run fully serialized under the lock. The dry-run early-return
@@ -503,6 +566,7 @@ export async function akmImprove(options = {}) {
     let profileFilteredRefs;
     let memoryCleanupPlan;
     let guidance;
+    let triageDrain;
     try {
         // Acquire the lock and run the triage pre-pass for non-dry-run executions.
         // The dry-run branch below produces plannedRefs/memorySummary WITHOUT the lock
@@ -531,7 +595,7 @@ export async function akmImprove(options = {}) {
                         const judgment = triageConfig?.judgment
                             ? resolveTriageJudgmentRunner(triageConfig.judgment, _earlyConfig)
                             : null;
-                        await drainProposalsFn({
+                        triageDrain = await drainProposalsFn({
                             stashDir: primaryStashDir,
                             policy,
                             applyMode,
@@ -672,24 +736,27 @@ export async function akmImprove(options = {}) {
     let eventsDb;
     // `eventsCtx` is read by the main catch (improve_failed) and finally, so it
     // lives in the outer scope. It is always assigned at the top of the try.
-    let eventsCtx = {};
+    // Pinned to the boundary snapshot so the fallback per-call `appendEvent`
+    // opens (when the long-lived handle below fails to open) never re-read env.
+    let eventsCtx = { dbPath: resolvedStateDbPath };
     try {
-        const budgetTimer = setTimeout(() => {
-            budgetAbortController.abort("improve budget exhausted");
-            // Grace period: let finally run to release improve.lock, then hard-exit
-            // to prevent the process outliving the task timeout window (lock-cascade fix).
-            setTimeout(() => process.exit(1), 5_000);
-        }, budgetMs);
-        // Clear the timer when the run ends to avoid keeping the event loop alive.
-        clearBudgetTimer = () => clearTimeout(budgetTimer);
+        // 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();
+            eventsDb = openStateDatabase(resolvedStateDbPath);
             eventsCtx = { db: eventsDb };
         }
         catch (err) {
             rethrowIfTestIsolationError(err);
-            // If we cannot open state.db up-front, fall back to per-call opens.
-            eventsCtx = {};
+            // If we cannot open state.db up-front, fall back to per-call opens — but
+            // still pinned to the boundary-resolved path, never a live env re-read.
+            eventsCtx = { dbPath: resolvedStateDbPath };
         }
         // 2026-05-27: emit `improve_skipped` audit events for refs the planner
         // pre-filtered (reflect AND distill both refuse them under the active
@@ -729,7 +796,7 @@ export async function akmImprove(options = {}) {
                 rejectedProposalsByRef.set(e.ref, e);
             }
         }
-        const { reflectsWithErrorContext, memoryRefsForInference, gateAutoAcceptedCount: loopGateCount, } = await runImproveLoopStage({
+        const { reflectsWithErrorContext, memoryRefsForInference, gateAutoAcceptedCount: loopGateCount, gateAutoAcceptFailedCount: loopGateFailedCount, } = await runImproveLoopStage({
             scope,
             options,
             primaryStashDir,
@@ -748,20 +815,23 @@ export async function akmImprove(options = {}) {
             eventsCtx,
             improveProfile,
         });
-        const { allWarnings, consolidation, deadUrls, memoryInference, graphExtraction, stalenessDetection, maintenanceActions, memoryInferenceDurationMs, graphExtractionDurationMs, orphansPurged, proposalsExpired, gateAutoAcceptedCount: postLoopGateCount, } = await runImprovePostLoopStage({
+        // #551: consolidation now runs in the preparation stage (before extract);
+        // its result and run-flag are read from `preparation`, not the post-loop.
+        const consolidation = preparation.consolidation;
+        const { allWarnings, deadUrls, memoryInference, graphExtraction, stalenessDetection, maintenanceActions, memoryInferenceDurationMs, graphExtractionDurationMs, orphansPurged, proposalsExpired, gateAutoAcceptedCount: postLoopGateCount, gateAutoAcceptFailedCount: postLoopGateFailedCount, } = await runImprovePostLoopStage({
             scope,
             options,
             primaryStashDir,
             actionableRefs: preparation.actionableRefs,
             appliedCleanup: preparation.appliedCleanup,
             cleanupWarnings: preparation.cleanupWarnings,
-            memorySummary,
             memoryRefsForInference,
             reindexFn,
             eventsCtx,
             // O-1 (#364): propagate wall-clock budget signal to post-loop maintenance.
             budgetSignal: budgetAbortController.signal,
             improveProfile,
+            consolidationRan: preparation.consolidationRan,
         });
         const finalActions = maintenanceActions && maintenanceActions.length > 0
             ? [...preparation.actions, ...maintenanceActions]
@@ -833,6 +903,21 @@ export async function akmImprove(options = {}) {
                 const t = preparation.gateAutoAcceptedCount + loopGateCount + postLoopGateCount;
                 return t > 0 ? { gateAutoAcceptedCount: t } : {};
             })(),
+            ...(() => {
+                const f = preparation.gateAutoAcceptFailedCount + loopGateFailedCount + postLoopGateFailedCount;
+                return f > 0 ? { gateAutoAcceptFailedCount: f } : {};
+            })(),
+            ...(triageDrain
+                ? {
+                    triage: {
+                        promoted: triageDrain.promoted.length,
+                        rejected: triageDrain.rejected.length,
+                        deferred: triageDrain.deferred.length,
+                        skippedByCap: triageDrain.skippedByCap.length,
+                    },
+                }
+                : {}),
+            ...(options.runId !== undefined ? { runId: options.runId } : {}),
         };
         if (!result.dryRun)
             emitImproveCompletedEvent(result, {
@@ -932,6 +1017,7 @@ function emitImproveCompletedEvent(result, durations, eventsCtx) {
         reflectFailed: 0,
         reflectCooldown: 0,
         reflectSkipped: 0,
+        reflectGuardRejected: 0,
         distill: 0,
         distillSkipped: 0,
         memoryPrune: 0,
@@ -939,7 +1025,16 @@ function emitImproveCompletedEvent(result, durations, eventsCtx) {
         graphExtraction: 0,
         error: 0,
     };
+    // Coarse audit buckets, derived from the SAME classifyImproveAction the
+    // persisted metrics_json uses (state-db.ts#computeImproveRunMetrics) so the
+    // emitted event and the stored row can never disagree.
+    const classCounts = { accepted: 0, rejected: 0, error: 0, noop: 0 };
     for (const action of result.actions ?? []) {
+        classCounts[classifyImproveAction(action.mode)] += 1;
+        // Per-variant counters for the event metadata. The default arm makes any
+        // new ImproveActionMode variant a compile error so a future variant cannot
+        // be silently dropped from the improve_completed event (the `reflect-guard-
+        // rejected` case below was previously missing here entirely).
         switch (action.mode) {
             case "reflect":
                 actionCounts.reflect += 1;
@@ -953,6 +1048,9 @@ function emitImproveCompletedEvent(result, durations, eventsCtx) {
             case "reflect-skipped":
                 actionCounts.reflectSkipped += 1;
                 break;
+            case "reflect-guard-rejected":
+                actionCounts.reflectGuardRejected += 1;
+                break;
             case "distill":
                 actionCounts.distill += 1;
                 break;
@@ -971,6 +1069,8 @@ function emitImproveCompletedEvent(result, durations, eventsCtx) {
             case "error":
                 actionCounts.error += 1;
                 break;
+            default:
+                assertNever(action.mode);
         }
     }
     appendEvent({
@@ -990,6 +1090,12 @@ function emitImproveCompletedEvent(result, durations, eventsCtx) {
             reflectFailedActions: actionCounts.reflectFailed,
             reflectCooldownActions: actionCounts.reflectCooldown,
             reflectSkippedActions: actionCounts.reflectSkipped,
+            // Previously dropped from the event entirely; now emitted so the guard
+            // rejections are visible in improve_completed telemetry.
+            reflectGuardRejectedActions: actionCounts.reflectGuardRejected,
+            acceptedActions: classCounts.accepted,
+            rejectedActions: classCounts.rejected,
+            noopActions: classCounts.noop,
             reflectsWithErrorContext: result.reflectsWithErrorContext ?? 0,
             coverageGapCount: result.coverageGaps?.length ?? 0,
             evalCasesWritten: result.evalCasesWritten ?? 0,
@@ -1022,12 +1128,261 @@ function emitImproveCompletedEvent(result, durations, eventsCtx) {
         },
     }, eventsCtx);
 }
+/**
+ * Run (or gate-skip) the memory consolidation pass.
+ *
+ * #551 — two coordinated changes live here:
+ *
+ *   1. STRUCTURAL: this runs before extract in the improve pipeline (see
+ *      `runImprovePreparationStage`). Consolidation therefore only ever judges
+ *      PRIOR-run memories; current-run extract promotions are invisible to it.
+ *
+ *   2. SMARTER POOL-DELTA GATE: even among on-disk files, a memory whose only
+ *      post-`lastConsolidateTs` mtime bump came from its OWN auto-accept
+ *      promotion (i.e. it was just promoted by extract in the immediately
+ *      preceding run and has not had a full improve cycle to settle) does NOT
+ *      count as "work to do". We exclude those paths from the pool-delta check
+ *      using the `promoted` events already emitted with each promotion's
+ *      `assetPath`. A genuinely-settled prior memory — one edited by feedback,
+ *      reflect, manual edit, or simply older than the last consolidate — still
+ *      triggers the run. This is gate-option (a) from the issue (same-run /
+ *      adjacent-run promotion exclusion), chosen over option (b) because there
+ *      is no `extract_completed` event in the data model to gate against;
+ *      `promoted` events with `assetPath` already carry exactly the signal we
+ *      need, so the fix is non-invasive and provably correct.
+ */
+async function runConsolidationPass(args) {
+    const { options, primaryStashDir, memorySummary, improveProfile, eventsCtx } = args;
+    const baseConfig = options.config ?? loadConfig();
+    const MEMORY_VOLUME_THRESHOLD = options.memoryVolumeConsolidationThreshold ?? 100;
+    const hasLlm = !!(baseConfig.defaults?.llm || baseConfig.defaults?.agent);
+    const volumeTriggered = typeof memorySummary.eligible === "number" && memorySummary.eligible > MEMORY_VOLUME_THRESHOLD && hasLlm;
+    // When volume triggers a consolidation pass, force-enable the consolidate
+    // process on the default improve profile so the gate accepts the run even
+    // if the user's config disabled it. We synthesise a new profile override
+    // rather than mutating connection settings.
+    const consolidationConfig = volumeTriggered
+        ? {
+            ...baseConfig,
+            profiles: {
+                ...(baseConfig.profiles ?? {}),
+                improve: {
+                    ...(baseConfig.profiles?.improve ?? {}),
+                    default: {
+                        ...(baseConfig.profiles?.improve?.default ?? {}),
+                        processes: {
+                            ...(baseConfig.profiles?.improve?.default?.processes ?? {}),
+                            consolidate: {
+                                ...(baseConfig.profiles?.improve?.default?.processes?.consolidate ?? {}),
+                                enabled: true,
+                            },
+                        },
+                    },
+                },
+            },
+        }
+        : baseConfig;
+    // 0.8.0 pool-delta gate for consolidate: re-eligible iff at least one
+    // memory file has been updated since the most recent successful
+    // consolidate_completed event. Time-based cooldowns produced the same
+    // synchronised-wave failure mode the reflect/distill cooldowns did; the
+    // pool-delta gate ties consolidation to actual work-to-do.
+    const recentConsolidations = readEvents({ type: "consolidate_completed" });
+    const lastConsolidation = recentConsolidations.events
+        .filter((e) => e.metadata?.processed && Number(e.metadata.processed) > 0)
+        .sort((a, b) => new Date(b.ts ?? 0).getTime() - new Date(a.ts ?? 0).getTime())[0];
+    const lastConsolidateTs = lastConsolidation?.ts;
+    // #551 smarter gate: build the set of memory asset paths whose only delta
+    // since the last consolidate is their OWN auto-accept promotion. Those files
+    // have not had a full improve cycle to settle, so they offer no merge /
+    // contradiction candidates yet — excluding them stops the gate firing on
+    // freshly-promoted single-source memories. We read `promoted` events emitted
+    // after the last consolidate; each carries the written `assetPath`.
+    const promotedSinceConsolidate = (() => {
+        const paths = new Set();
+        try {
+            const promoted = readEvents({
+                type: "promoted",
+                ...(lastConsolidateTs ? { since: lastConsolidateTs } : {}),
+            }).events;
+            for (const e of promoted) {
+                const ap = e.metadata?.assetPath;
+                if (typeof ap === "string" && ap.length > 0)
+                    paths.add(path.resolve(ap));
+            }
+        }
+        catch {
+            // best-effort: if the events query fails, fall back to no exclusions
+            // (preserves pre-#551 behaviour rather than over-skipping).
+        }
+        return paths;
+    })();
+    // Pool-delta: any memory file with mtime > lastConsolidateTs flags work to do,
+    // EXCEPT files whose only post-consolidate change was their own promotion.
+    // Using file mtime keeps this query DB-free and matches what the indexer
+    // already uses as the canonical `memory.updated_at` proxy.
+    //
+    // Bootstrap: when no successful consolidate_completed event has ever been
+    // recorded, we cannot evaluate the pool-delta — treat as eligible so a
+    // fresh stash runs consolidate once before the steady-state gate kicks in.
+    const memoryUpdatedAfterLastConsolidate = (() => {
+        if (volumeTriggered)
+            return true; // volume override forces the run regardless.
+        if (!lastConsolidateTs)
+            return true; // bootstrap path: never consolidated.
+        if (!primaryStashDir)
+            return false;
+        const memoriesDir = path.join(primaryStashDir, "memories");
+        if (!fs.existsSync(memoriesDir))
+            return false;
+        try {
+            return fs.readdirSync(memoriesDir).some((f) => {
+                if (!f.endsWith(".md"))
+                    return false;
+                const filePath = path.join(memoriesDir, f);
+                // #551: skip files that were only touched by their own promotion this
+                // cohort — they have no settled merge/contradiction candidates yet.
+                if (promotedSinceConsolidate.has(path.resolve(filePath)))
+                    return false;
+                try {
+                    return fs.statSync(filePath).mtime.toISOString() > lastConsolidateTs;
+                }
+                catch {
+                    return false;
+                }
+            });
+        }
+        catch {
+            return false;
+        }
+    })();
+    const consolidationOnCooldown = !volumeTriggered && !memoryUpdatedAfterLastConsolidate;
+    // Profile gate: if profile explicitly disables consolidate, skip the entire pass.
+    const consolidateDisabledByProfile = improveProfile?.processes?.consolidate?.enabled === false;
+    // #553 minPoolSize guard: skip consolidation when the eligible memory pool is
+    // below a minimum size, rather than spending an LLM pass on a handful of
+    // memories. This is an INDEPENDENT skip condition from #551's mtime pool-delta
+    // gate — either can skip. Default 500; `minPoolSize: 0` disables the guard.
+    // Evaluated against the eligible-pool count BEFORE entering the LLM loop so a
+    // skip costs ZERO LLM calls.
+    const CONSOLIDATE_DEFAULT_MIN_POOL_SIZE = 500;
+    const configuredMinPoolSize = improveProfile?.processes?.consolidate?.minPoolSize;
+    const minPoolSize = typeof configuredMinPoolSize === "number" ? configuredMinPoolSize : CONSOLIDATE_DEFAULT_MIN_POOL_SIZE;
+    const eligiblePoolSize = typeof memorySummary.eligible === "number" ? memorySummary.eligible : 0;
+    // volumeTriggered means the pool already exceeds the volume threshold (100),
+    // so a force-triggered run never trips the pool-size guard. The guard only
+    // engages when minPoolSize > 0 and the eligible pool is strictly below it.
+    const poolBelowMinSize = !volumeTriggered && minPoolSize > 0 && eligiblePoolSize < minPoolSize;
+    let consolidation = {
+        schemaVersion: 1,
+        ok: true,
+        shape: "consolidate-result",
+        dryRun: false,
+        previewOnly: false,
+        target: "",
+        processed: 0,
+        merged: 0,
+        deleted: 0,
+        promoted: [],
+        contradicted: 0,
+        warnings: [],
+        durationMs: 0,
+    };
+    let gateAutoAcceptedCount = 0;
+    let gateAutoAcceptFailedCount = 0;
+    const consolidateGateCfg = makeGateConfig("consolidate", {
+        globalThreshold: options.autoAccept,
+        dryRun: options.dryRun ?? false,
+        stashDir: primaryStashDir,
+        config: consolidationConfig,
+        eventsCtx,
+    }, { minimumThreshold: 95 });
+    if (consolidateDisabledByProfile) {
+        info("[improve] consolidation skipped (disabled by improve profile)");
+    }
+    else if (poolBelowMinSize) {
+        // #553: eligible pool below the configured minimum — skip with zero LLM
+        // calls. Reuse the #551 `improve_skipped` emission path so health surfaces
+        // it via the dynamic skipReasons aggregation under `pool_below_min_size`.
+        appendEvent({
+            eventType: "improve_skipped",
+            ref: "memory:_consolidation",
+            metadata: {
+                reason: "pool_below_min_size",
+                poolSize: eligiblePoolSize,
+                minPoolSize,
+            },
+        }, eventsCtx);
+        info(`[improve] consolidation skipped (pool ${eligiblePoolSize} < minPoolSize ${minPoolSize})`);
+    }
+    else if (!consolidationOnCooldown) {
+        consolidation = await akmConsolidate({
+            ...options.consolidateOptions,
+            config: consolidationConfig,
+            stashDir: options.stashDir,
+            autoTriggered: volumeTriggered,
+            // Tie consolidate proposals back to this improve invocation so
+            // accept-rate-per-run aggregation works. Mirrors reflect/propose/extract.
+            sourceRun: `consolidate-${Date.now()}`,
+            // Incremental consolidation: pass the last-consolidation timestamp so
+            // akmConsolidate skips chunks with no memory changed since then. Converts
+            // consolidation cost from O(pool) to O(changed clusters) — the fix for
+            // the rising p95 tail where full-pool re-judging produced 5–10 min runs
+            // that promoted ~0. undefined → full pass on first-ever run (bootstrap).
+            // volumeTriggered correctly forces the run past cooldown but must NOT
+            // override incrementalSince — the stash has ~1400 eligible memories so
+            // volumeTriggered=true on every run, permanently forcing full 12-chunk
+            // scans (~264s) instead of the intended 1-2 chunk incremental path (~44s).
+            incrementalSince: lastConsolidateTs,
+            maxChunkSize: improveProfile?.processes?.consolidate?.maxChunkSize,
+            // Honor profile.autoAccept (already merged into options.autoAccept at the
+            // top of akmImprove). The CLI parser always supplies 90 when --auto-accept
+            // is absent, so ?? 90 is not needed here and would prevent --auto-accept=false
+            // (which maps to undefined) from disabling consolidation auto-accept.
+            // options.consolidateOptions.autoAccept (if explicitly provided by caller)
+            // still wins because the spread above runs first.
+            autoAccept: options.consolidateOptions?.autoAccept ?? options.autoAccept,
+        });
+        {
+            const consolidateGr = await runAutoAcceptGate(consolidation.promoted.map((proposalId) => {
+                try {
+                    if (!primaryStashDir)
+                        return { proposalId, confidence: undefined };
+                    const proposal = getProposal(primaryStashDir, proposalId);
+                    return { proposalId, confidence: proposal.confidence };
+                }
+                catch {
+                    return { proposalId, confidence: undefined };
+                }
+            }), consolidateGateCfg);
+            gateAutoAcceptedCount += consolidateGr.promoted.length;
+            gateAutoAcceptFailedCount += consolidateGr.failed.length;
+        }
+        if (consolidation.processed > 0) {
+            appendEvent({
+                eventType: "consolidate_completed",
+                ref: "memory:_consolidation",
+                metadata: { processed: consolidation.processed, merged: consolidation.merged },
+            }, eventsCtx);
+        }
+    }
+    else {
+        appendEvent({
+            eventType: "improve_skipped",
+            ref: "memory:_consolidation",
+            metadata: {
+                reason: "consolidation_no_memory_updates",
+                lastEventTs: lastConsolidation?.ts ?? null,
+            },
+        }, eventsCtx);
+        info("[improve] consolidation skipped (no memory updates since last run)");
+    }
+    // D9: track whether consolidation wrote any data so graph extraction can reindex if needed
+    const consolidationRan = !consolidateDisabledByProfile && !poolBelowMinSize && !consolidationOnCooldown && consolidation.processed > 0;
+    return { consolidation, consolidationRan, gateAutoAcceptedCount, gateAutoAcceptFailedCount };
+}
 async function runImprovePreparationStage(args) {
-    const { scope, options, plannedRefs, memoryCleanupPlan, primaryStashDir, reindexFn, startMs, budgetMs, eventsCtx, initialCleanupWarnings, 
-    // improveProfile is part of the preparation-stage signature for future use
-    // (per-process gating moved into the in-loop stage). Kept here so the
-    // signature does not drift away from the rest of the planner stack.
-    improveProfile: _improveProfile, } = args;
+    const { scope, options, plannedRefs, memoryCleanupPlan, primaryStashDir, memorySummary, reindexFn, startMs, budgetMs, eventsCtx, initialCleanupWarnings, improveProfile, } = args;
     const actions = [];
     const cleanupWarnings = initialCleanupWarnings ? [...initialCleanupWarnings] : [];
     // Phase 0 — MEMORY.md budget check (200-line cap; warn at 180)
@@ -1048,6 +1403,23 @@ async function runImprovePreparationStage(args) {
             }
         }
     }
+    // Phase 0.3 — memory consolidation pass (#551).
+    //
+    // Consolidation runs BEFORE the session-extract pass. This is the structural
+    // half of the #551 fix: extract auto-accept writes brand-new memory .md files
+    // on every run, which previously made the consolidation pool-delta gate fire
+    // unconditionally (any new file => "memory updated since last consolidate").
+    // By running consolidation first, the gate and akmConsolidate only ever see
+    // memories that existed at the start of the run — current-run extract
+    // promotions are not on disk yet. The complementary smarter-gate logic
+    // (excluding adjacent-run promotions) lives in `runConsolidationPass`.
+    const consolidationPass = await runConsolidationPass({
+        options,
+        primaryStashDir,
+        memorySummary,
+        improveProfile,
+        eventsCtx,
+    });
     // Phase 0.4 — session-extract pass.
     //
     // Reads native session files (claude-code JSONL, opencode storage tree)
@@ -1065,7 +1437,11 @@ async function runImprovePreparationStage(args) {
     // Failures are non-fatal — one harness throwing doesn't abort improve.
     // The extract envelope's own `warnings` field surfaces what went wrong.
     let extractResults;
-    let gateAutoAcceptedCount = 0;
+    // Seed the preparation-stage gate counters with consolidation's auto-accept
+    // gate results (#551: consolidation now runs in this stage), then accumulate
+    // extract's gate results on top.
+    let gateAutoAcceptedCount = consolidationPass.gateAutoAcceptedCount;
+    let gateAutoAcceptFailedCount = consolidationPass.gateAutoAcceptFailedCount;
     const extractConfig = options.config ?? loadConfig();
     const extractGateCfg = makeGateConfig("extract", {
         globalThreshold: options.autoAccept,
@@ -1074,9 +1450,47 @@ async function runImprovePreparationStage(args) {
         config: extractConfig,
         eventsCtx,
     });
+    // #554 minNewSessions gate: skip the entire extract pass (ensureIndex was
+    // already done upstream; here we elide every akmExtract/processSession call)
+    // when the NEW (unseen, in-window) candidate-session pool is below a minimum.
+    // 22% of improve runs produce zero memory-inference writes because extract
+    // finds no new sessions, yet still burns the full extract pipeline. Default 0
+    // (disabled) preserves existing always-run behaviour; only opted-in profiles
+    // (e.g. `frequent`) set it. Evaluated BEFORE any LLM call so a skip costs zero
+    // LLM work AND writes nothing — which also means no extract auto-accept bumps
+    // memory mtimes, so a skipped extract never flags work for the NEXT run's
+    // consolidation mtime-gate (the downstream trigger #554 asks us to suppress).
+    const EXTRACT_DEFAULT_MIN_NEW_SESSIONS = 0;
+    const configuredMinNewSessions = extractConfig.profiles?.improve?.default?.processes?.extract?.minNewSessions;
+    const minNewSessions = typeof configuredMinNewSessions === "number" ? configuredMinNewSessions : EXTRACT_DEFAULT_MIN_NEW_SESSIONS;
     if (isLlmFeatureEnabled(extractConfig, "session_extraction")) {
-        const availableHarnesses = getAvailableHarnesses();
-        if (availableHarnesses.length > 0) {
+        const availableHarnesses = options.extractHarnesses ?? getAvailableHarnesses();
+        // The guard engages only when minNewSessions > 0; 0 disables it entirely.
+        let belowMinNewSessions = false;
+        if (minNewSessions > 0 && availableHarnesses.length > 0) {
+            const countFn = options.extractCandidateCountFn ?? countNewExtractCandidates;
+            const newCandidateCount = countFn(extractConfig, {
+                ...(options.extractHarnesses ? { harnesses: options.extractHarnesses } : {}),
+                // C2: pin the candidate-count state.db open to the boundary-resolved path.
+                ...(eventsCtx?.dbPath ? { stateDbPath: eventsCtx.dbPath } : {}),
+            });
+            if (newCandidateCount < minNewSessions) {
+                belowMinNewSessions = true;
+                // Reuse the #551/#553 `improve_skipped` emission path so health's dynamic
+                // skipReasons aggregation surfaces this under `below_min_new_sessions`.
+                appendEvent({
+                    eventType: "improve_skipped",
+                    ref: "memory:_extract",
+                    metadata: {
+                        reason: "below_min_new_sessions",
+                        newSessions: newCandidateCount,
+                        minNewSessions,
+                    },
+                }, eventsCtx);
+                info(`[improve] extract skipped (new sessions ${newCandidateCount} < minNewSessions ${minNewSessions})`);
+            }
+        }
+        if (!belowMinNewSessions && availableHarnesses.length > 0) {
             extractResults = [];
             for (const h of availableHarnesses) {
                 try {
@@ -1085,14 +1499,21 @@ async function runImprovePreparationStage(args) {
                         ...(primaryStashDir !== undefined ? { stashDir: primaryStashDir } : {}),
                         config: extractConfig,
                         dryRun: options.dryRun ?? false,
+                        ...(options.extractHarnesses ? { harnesses: options.extractHarnesses } : {}),
+                        // C2: pin extract's skip-tracking state.db open to the boundary path.
+                        ...(eventsCtx?.dbPath ? { stateDbPath: eventsCtx.dbPath } : {}),
                     });
                     extractResults.push(result);
-                    gateAutoAcceptedCount += (await runAutoAcceptGate(primaryStashDir
-                        ? result.proposals.map((proposalId) => {
-                            const proposal = getProposal(primaryStashDir, proposalId);
-                            return { proposalId, confidence: resolveExtractConfidence(proposal) };
-                        })
-                        : [], extractGateCfg)).promoted.length;
+                    {
+                        const gr = await runAutoAcceptGate(primaryStashDir
+                            ? result.proposals.map((proposalId) => {
+                                const proposal = getProposal(primaryStashDir, proposalId);
+                                return { proposalId, confidence: resolveExtractConfidence(proposal) };
+                            })
+                            : [], extractGateCfg);
+                        gateAutoAcceptedCount += gr.promoted.length;
+                        gateAutoAcceptFailedCount += gr.failed.length;
+                    }
                 }
                 catch (err) {
                     const msg = err instanceof Error ? err.message : String(err);
@@ -1118,7 +1539,9 @@ async function runImprovePreparationStage(args) {
                 proposalId: p.id,
                 confidence: resolveExtractConfidence(p),
             }));
-            gateAutoAcceptedCount += (await runAutoAcceptGate(backlogCandidates, extractGateCfg)).promoted.length;
+            const backlogGr = await runAutoAcceptGate(backlogCandidates, extractGateCfg);
+            gateAutoAcceptedCount += backlogGr.promoted.length;
+            gateAutoAcceptFailedCount += backlogGr.failed.length;
         }
     }
     // eligibleCount = raw pre-filter count (before cooldown/signal/cleanup filters).
@@ -1391,7 +1814,7 @@ async function runImprovePreparationStage(args) {
     let dbForRetrieval;
     try {
         dbForRetrieval = openExistingDatabase();
-        const showEventCount = dbForRetrieval.prepare("SELECT COUNT(*) AS cnt FROM usage_events WHERE event_type = 'show'").get().cnt;
+        const showEventCount = countUsageEventsByType(dbForRetrieval, "show");
         if (showEventCount === 0) {
             warn("Warning: show events not yet in usage_events — zero-feedback fallback will match only search-retrieved assets.");
         }
@@ -1544,9 +1967,11 @@ async function runImprovePreparationStage(args) {
         recentErrors,
         utilityMap,
         gateAutoAcceptedCount,
+        gateAutoAcceptFailedCount,
+        consolidation: consolidationPass.consolidation,
+        consolidationRan: consolidationPass.consolidationRan,
     };
 }
-// TODO(refactor): 13 args including `actions`/`recentErrors` mutation channels. Restructure into immutable plan + mutable context objects — deferred to dedicated refactor with isolated testing.
 async function runImproveLoopStage(args) {
     const { scope, options, primaryStashDir, reflectFn, distillFn, loopRefs, actions, signalBearingSet, distillCooledRefs, distillOnlyRefs, recentErrors, rejectedProposalsByRef, utilityMap, startMs, budgetMs, eventsCtx, improveProfile, } = args;
     // O-1 (#364): compute remaining budget at call time so each sub-call
@@ -1627,6 +2052,7 @@ async function runImproveLoopStage(args) {
         ? listProposals(dedupeStashDirForProposals, { status: "pending" }).map((p) => p.ref)
         : []);
     let gateAutoAcceptedCount = 0;
+    let gateAutoAcceptFailedCount = 0;
     const reflectGateCfg = makeGateConfig("reflect", {
         globalThreshold: options.autoAccept,
         dryRun: options.dryRun ?? false,
@@ -1679,7 +2105,7 @@ async function runImproveLoopStage(args) {
             // path is also a no-op for them — we just avoid unnecessary agent spawns.
             // D2: distillOnlyRefs also skip the reflect call (reflect-cooled, distill path only).
             if (!isDistillOnly && !planned.ref.endsWith(".derived")) {
-                // Type guard: skip reflect for unsupported types (script, vault, task, etc.)
+                // Type guard: skip reflect for unsupported types (script, env, task, etc.)
                 // and raw wiki directories, driven by the active improve profile.
                 const reflectSkip = shouldSkipRef(planned.ref, "reflect", improveProfile);
                 if (reflectSkip.skip) {
@@ -1761,7 +2187,7 @@ async function runImproveLoopStage(args) {
                     // true LLM failures. See
                     // `/tmp/akm-health-investigations/metrics-taxonomy-review.md` §1a.
                     const isGuardReject = !reflectResult.ok && reflectResult.reason === "content_policy_reject";
-                    // Type-guard rejection (reflect refused a script/vault/task ref) is
+                    // Type-guard rejection (reflect refused a script/env/task ref) is
                     // also NOT an LLM failure — the LLM is never invoked. Route to the
                     // existing `reflect-skipped` bucket so it does not inflate the
                     // failure-rate numerator. ~9% of `reflect-failed` events in the
@@ -1803,7 +2229,9 @@ async function runImproveLoopStage(args) {
                         },
                     }, eventsCtx);
                     if (reflectResult.ok) {
-                        gateAutoAcceptedCount += (await runAutoAcceptGate([{ proposalId: reflectResult.proposal.id, confidence: reflectResult.proposal.confidence }], reflectGateCfg)).promoted.length;
+                        const reflectGr = await runAutoAcceptGate([{ proposalId: reflectResult.proposal.id, confidence: reflectResult.proposal.confidence }], reflectGateCfg);
+                        gateAutoAcceptedCount += reflectGr.promoted.length;
+                        gateAutoAcceptFailedCount += reflectGr.failed.length;
                     }
                 } // end else (reflect type/profile check)
             }
@@ -1914,7 +2342,9 @@ async function runImproveLoopStage(args) {
                 });
                 actions.push({ ref: planned.ref, mode: "distill", result: distillResult });
                 if (distillResult.outcome === "queued" && distillResult.proposal) {
-                    gateAutoAcceptedCount += (await runAutoAcceptGate([{ proposalId: distillResult.proposal.id, confidence: distillResult.proposal.confidence }], distillGateCfg)).promoted.length;
+                    const distillGr = await runAutoAcceptGate([{ proposalId: distillResult.proposal.id, confidence: distillResult.proposal.confidence }], distillGateCfg);
+                    gateAutoAcceptedCount += distillGr.promoted.length;
+                    gateAutoAcceptFailedCount += distillGr.failed.length;
                 }
                 if (parsedPlannedRef.type === "memory") {
                     const promotedToKnowledge = distillResult.outcome === "queued" && distillResult.proposalKind === "knowledge";
@@ -1987,172 +2417,11 @@ async function runImproveLoopStage(args) {
         completedCount++;
         info(`[improve] ${completedCount}/${loopRefs.length} ${planned.ref}`);
     }
-    return { reflectsWithErrorContext, memoryRefsForInference, gateAutoAcceptedCount };
+    return { reflectsWithErrorContext, memoryRefsForInference, gateAutoAcceptedCount, gateAutoAcceptFailedCount };
 }
 async function runImprovePostLoopStage(args) {
-    const { scope, options, primaryStashDir, actionableRefs, appliedCleanup, cleanupWarnings, memorySummary, memoryRefsForInference, reindexFn, eventsCtx, budgetSignal, improveProfile, } = args;
+    const { scope, options, primaryStashDir, actionableRefs, appliedCleanup, cleanupWarnings, memoryRefsForInference, reindexFn, eventsCtx, budgetSignal, improveProfile, consolidationRan, } = args;
     const allWarnings = [...cleanupWarnings, ...(appliedCleanup?.warnings ?? [])];
-    const baseConfig = options.config ?? loadConfig();
-    const MEMORY_VOLUME_THRESHOLD = options.memoryVolumeConsolidationThreshold ?? 100;
-    const hasLlm = !!(baseConfig.defaults?.llm || baseConfig.defaults?.agent);
-    const volumeTriggered = typeof memorySummary.eligible === "number" && memorySummary.eligible > MEMORY_VOLUME_THRESHOLD && hasLlm;
-    // When volume triggers a consolidation pass, force-enable the consolidate
-    // process on the default improve profile so the gate accepts the run even
-    // if the user's config disabled it. We synthesise a new profile override
-    // rather than mutating connection settings.
-    const consolidationConfig = volumeTriggered
-        ? {
-            ...baseConfig,
-            profiles: {
-                ...(baseConfig.profiles ?? {}),
-                improve: {
-                    ...(baseConfig.profiles?.improve ?? {}),
-                    default: {
-                        ...(baseConfig.profiles?.improve?.default ?? {}),
-                        processes: {
-                            ...(baseConfig.profiles?.improve?.default?.processes ?? {}),
-                            consolidate: {
-                                ...(baseConfig.profiles?.improve?.default?.processes?.consolidate ?? {}),
-                                enabled: true,
-                            },
-                        },
-                    },
-                },
-            },
-        }
-        : baseConfig;
-    // 0.8.0 pool-delta gate for consolidate: re-eligible iff at least one
-    // memory file has been updated since the most recent successful
-    // consolidate_completed event. Time-based cooldowns produced the same
-    // synchronised-wave failure mode the reflect/distill cooldowns did; the
-    // pool-delta gate ties consolidation to actual work-to-do.
-    const recentConsolidations = readEvents({ type: "consolidate_completed" });
-    const lastConsolidation = recentConsolidations.events
-        .filter((e) => e.metadata?.processed && Number(e.metadata.processed) > 0)
-        .sort((a, b) => new Date(b.ts ?? 0).getTime() - new Date(a.ts ?? 0).getTime())[0];
-    const lastConsolidateTs = lastConsolidation?.ts;
-    // Pool-delta: any memory file with mtime > lastConsolidateTs flags work to do.
-    // Using file mtime keeps this query DB-free and matches what the indexer
-    // already uses as the canonical `memory.updated_at` proxy.
-    //
-    // Bootstrap: when no successful consolidate_completed event has ever been
-    // recorded, we cannot evaluate the pool-delta — treat as eligible so a
-    // fresh stash runs consolidate once before the steady-state gate kicks in.
-    const memoryUpdatedAfterLastConsolidate = (() => {
-        if (volumeTriggered)
-            return true; // volume override forces the run regardless.
-        if (!lastConsolidateTs)
-            return true; // bootstrap path: never consolidated.
-        if (!primaryStashDir)
-            return false;
-        const memoriesDir = path.join(primaryStashDir, "memories");
-        if (!fs.existsSync(memoriesDir))
-            return false;
-        try {
-            return fs.readdirSync(memoriesDir).some((f) => {
-                if (!f.endsWith(".md"))
-                    return false;
-                try {
-                    return fs.statSync(path.join(memoriesDir, f)).mtime.toISOString() > lastConsolidateTs;
-                }
-                catch {
-                    return false;
-                }
-            });
-        }
-        catch {
-            return false;
-        }
-    })();
-    const consolidationOnCooldown = !volumeTriggered && !memoryUpdatedAfterLastConsolidate;
-    // Profile gate: if profile explicitly disables consolidate, skip the entire pass.
-    const consolidateDisabledByProfile = improveProfile?.processes?.consolidate?.enabled === false;
-    let consolidation = {
-        schemaVersion: 1,
-        ok: true,
-        shape: "consolidate-result",
-        dryRun: false,
-        previewOnly: false,
-        target: "",
-        processed: 0,
-        merged: 0,
-        deleted: 0,
-        promoted: [],
-        contradicted: 0,
-        warnings: [],
-        durationMs: 0,
-    };
-    let gateAutoAcceptedCount = 0;
-    const consolidateGateCfg = makeGateConfig("consolidate", {
-        globalThreshold: options.autoAccept,
-        dryRun: options.dryRun ?? false,
-        stashDir: primaryStashDir,
-        config: consolidationConfig,
-        eventsCtx,
-    }, { minimumThreshold: 95 });
-    if (consolidateDisabledByProfile) {
-        info("[improve] consolidation skipped (disabled by improve profile)");
-    }
-    else if (!consolidationOnCooldown) {
-        consolidation = await akmConsolidate({
-            ...options.consolidateOptions,
-            config: consolidationConfig,
-            stashDir: options.stashDir,
-            autoTriggered: volumeTriggered,
-            // Tie consolidate proposals back to this improve invocation so
-            // accept-rate-per-run aggregation works. Mirrors reflect/propose/extract.
-            sourceRun: `consolidate-${Date.now()}`,
-            // Incremental consolidation: pass the last-consolidation timestamp so
-            // akmConsolidate skips chunks with no memory changed since then. Converts
-            // consolidation cost from O(pool) to O(changed clusters) — the fix for
-            // the rising p95 tail where full-pool re-judging produced 5–10 min runs
-            // that promoted ~0. undefined → full pass on first-ever run (bootstrap).
-            // volumeTriggered correctly forces the run past cooldown but must NOT
-            // override incrementalSince — the stash has ~1400 eligible memories so
-            // volumeTriggered=true on every run, permanently forcing full 12-chunk
-            // scans (~264s) instead of the intended 1-2 chunk incremental path (~44s).
-            incrementalSince: lastConsolidateTs,
-            maxChunkSize: improveProfile?.processes?.consolidate?.maxChunkSize,
-            // Honor profile.autoAccept (already merged into options.autoAccept at the
-            // top of akmImprove). The CLI parser always supplies 90 when --auto-accept
-            // is absent, so ?? 90 is not needed here and would prevent --auto-accept=false
-            // (which maps to undefined) from disabling consolidation auto-accept.
-            // options.consolidateOptions.autoAccept (if explicitly provided by caller)
-            // still wins because the spread above runs first.
-            autoAccept: options.consolidateOptions?.autoAccept ?? options.autoAccept,
-        });
-        gateAutoAcceptedCount += (await runAutoAcceptGate(consolidation.promoted.map((proposalId) => {
-            try {
-                if (!primaryStashDir)
-                    return { proposalId, confidence: undefined };
-                const proposal = getProposal(primaryStashDir, proposalId);
-                return { proposalId, confidence: proposal.confidence };
-            }
-            catch {
-                return { proposalId, confidence: undefined };
-            }
-        }), consolidateGateCfg)).promoted.length;
-        if (consolidation.processed > 0) {
-            appendEvent({
-                eventType: "consolidate_completed",
-                ref: "memory:_consolidation",
-                metadata: { processed: consolidation.processed, merged: consolidation.merged },
-            }, eventsCtx);
-        }
-    }
-    else {
-        appendEvent({
-            eventType: "improve_skipped",
-            ref: "memory:_consolidation",
-            metadata: {
-                reason: "consolidation_no_memory_updates",
-                lastEventTs: lastConsolidation?.ts ?? null,
-            },
-        }, eventsCtx);
-        info("[improve] consolidation skipped (no memory updates since last run)");
-    }
-    // D9: track whether consolidation wrote any data so graph extraction can reindex if needed
-    const consolidationRan = !consolidateDisabledByProfile && !consolidationOnCooldown && consolidation.processed > 0;
     info("[improve] post-loop maintenance starting");
     const maintenanceResult = await runImproveMaintenancePasses({
         options,
@@ -2193,7 +2462,6 @@ async function runImprovePostLoopStage(args) {
     }
     return {
         allWarnings,
-        consolidation,
         deadUrls,
         ...(maintenanceResult.memoryInference ? { memoryInference: maintenanceResult.memoryInference } : {}),
         ...(maintenanceResult.graphExtraction ? { graphExtraction: maintenanceResult.graphExtraction } : {}),
@@ -2205,7 +2473,10 @@ async function runImprovePostLoopStage(args) {
         graphExtractionDurationMs: maintenanceResult.graphExtractionDurationMs,
         orphansPurged: maintenanceResult.orphansPurged,
         proposalsExpired: maintenanceResult.proposalsExpired,
-        gateAutoAcceptedCount,
+        // Consolidation's auto-accept gate counts now accrue in the preparation
+        // stage (#551); post-loop no longer runs an auto-accept gate of its own.
+        gateAutoAcceptedCount: 0,
+        gateAutoAcceptFailedCount: 0,
     };
 }
 // TODO(refactor): mutates the passed-in `allWarnings` array as a hidden side channel. Return warnings in ImproveMaintenanceResult and merge in caller — invasive signature change deferred to next refactor pass.
@@ -2255,9 +2526,16 @@ async function runImproveMaintenancePasses(args) {
             const inferenceStart = Date.now();
             try {
                 // O-1 (#364): pass budget signal so a hung inference call is cancelled.
-                memoryInference = await memoryInferenceFn(config, sources, budgetSignal, db, false, (event) => {
-                    const current = event.currentRef ? ` ${event.currentRef}` : "";
-                    info(`[improve] memory inference ${event.processed}/${event.total}${current} (written ${event.writtenFacts}, skipped ${event.skippedNoFacts})`);
+                memoryInference = await memoryInferenceFn({
+                    config,
+                    sources,
+                    signal: budgetSignal,
+                    db,
+                    reEnrich: false,
+                    onProgress: (event) => {
+                        const current = event.currentRef ? ` ${event.currentRef}` : "";
+                        info(`[improve] memory inference ${event.processed}/${event.total}${current} (written ${event.writtenFacts}, skipped ${event.skippedNoFacts})`);
+                    },
                 });
                 memoryInferenceDurationMs = Date.now() - inferenceStart;
                 actions.push({ ref: "memory:_inference", mode: "memory-inference", result: memoryInference });
@@ -2338,8 +2616,14 @@ async function runImproveMaintenancePasses(args) {
                     info(`[improve] graph extraction ${event.processed}/${event.total}${current} (extracted ${event.extracted}, entities ${event.totalEntities}, relations ${event.totalRelations})`);
                 };
                 // O-1 (#364): pass budget signal so a hung graph extraction call is cancelled.
-                graphExtraction = await graphExtractionFn(config, sources, budgetSignal, db, false, progressHandler, {
-                    candidatePaths,
+                graphExtraction = await graphExtractionFn({
+                    config,
+                    sources,
+                    signal: budgetSignal,
+                    db,
+                    reEnrich: false,
+                    onProgress: progressHandler,
+                    options: { candidatePaths },
                 });
                 graphExtractionDurationMs = Date.now() - extractionStart;
                 actions.push({ ref: "graph:_artifact", mode: "graph-extraction", result: graphExtraction });
@@ -2418,7 +2702,11 @@ async function runImproveMaintenancePasses(args) {
             if (retentionDays > 0) {
                 let stateDb;
                 try {
-                    stateDb = openStateDatabase();
+                    // C2: reuse the boundary-pinned state.db path carried on eventsCtx so
+                    // this purge open never re-reads `process.env` live mid-run. The path
+                    // is always set by akmImprove; openStateDatabase() falls back to the
+                    // env-derived default only if a caller omitted it entirely.
+                    stateDb = openStateDatabase(eventsCtx?.dbPath);
                     const purgedCount = purgeOldEvents(stateDb, retentionDays);
                     if (purgedCount > 0) {
                         info(`[improve] events purge: ${purgedCount} event(s) older than ${retentionDays}d removed from state.db`);
@@ -2463,7 +2751,7 @@ async function runImproveMaintenancePasses(args) {
         // and before the URL check (which lives in the outer caller).
         if (sources.length > 0) {
             try {
-                stalenessDetection = await stalenessDetectionFn(config, sources, budgetSignal, db);
+                stalenessDetection = await stalenessDetectionFn({ config, sources, signal: budgetSignal, db });
                 if (stalenessDetection.considered > 0) {
                     info(`[improve] staleness detection complete (considered ${stalenessDetection.considered}, ` +
                         `deprecated ${stalenessDetection.deprecated}, confirmed ${stalenessDetection.confirmed}, ` +