akm-cli 0.8.6 → 0.8.14

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

@@ -3,44 +3,50 @@
 // 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, releaseLockIfOwned, 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, releaseLockIfOwned, tryAcquireLockSync } from "../../core/file-lock.js";
+import { classifyImproveAction } from "../../core/improve-types.js";
+import { openLogsDatabase, purgeOldTaskLogs } from "../../core/logs-db.js";
+import { getDbPath, getStateDbPathInDataDir } from "../../core/paths.js";
+import { openStateDatabase, purgeOldEvents, purgeOldImproveRuns } from "../../core/state-db.js";
+import { 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 { installLlmUsagePersistence } from "../../llm/usage-persist.js";
+import { withLlmStage } from "../../llm/usage-telemetry.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 +57,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 +76,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 +96,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));
 }
@@ -103,7 +115,7 @@ async function collectEligibleRefs(scope, stashDir, improveProfile) {
             };
         }
         return {
-            plannedRefs: [{ ref: scope.value, reason: "scope-ref" }],
+            plannedRefs: [{ ref: scope.value, reason: "scope-ref", filePath }],
             memorySummary: {
                 eligible: parsed.type === "memory" ? 1 : 0,
                 derived: parsed.type === "memory" && parsed.name.endsWith(".derived") ? 1 : 0,
@@ -167,12 +179,14 @@ async function collectEligibleRefs(scope, stashDir, improveProfile) {
                     profileFiltered.set(ref, {
                         ref,
                         reason: "profile_filtered_all_passes",
+                        filePath: indexed.filePath,
                     });
                 }
                 else {
                     planned.set(ref, {
                         ref,
                         reason: scope.mode === "type" ? "scope-type" : indexed.entry.type === "memory" ? "memory-cleanup" : "scope-type",
+                        filePath: indexed.filePath,
                     });
                 }
             }
@@ -395,6 +409,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 +480,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
@@ -507,14 +575,14 @@ export async function akmImprove(options = {}) {
         }
         lockAcquired = false;
     };
-    // Signal-safe lock release (0.8.3 hotfix). The SIGTERM/SIGINT/SIGHUP handler
-    // in improve-cli.ts calls `process.exit()`, which does NOT run the `finally`
-    // below that owns lock release — so a cron-timeout SIGTERM leaked
-    // `improve.lock` every run. `process.exit()` DOES fire `'exit'` listeners,
-    // so we release the lock from one. `releaseLockIfOwned` only unlinks a lock
-    // still owned by this PID, so it is safe even if a later run re-acquired it.
-    // The listener is removed in the `finally` so the normal path stays single-release
-    // and repeated in-process `akmImprove` calls (tests) do not accumulate listeners.
+    // Signal-safe lock release. The SIGTERM/SIGINT/SIGHUP handler in improve-cli.ts
+    // calls `process.exit()`, which does NOT run the `finally` below that owns lock
+    // release — so a cron-timeout SIGTERM leaked `improve.lock` every run.
+    // `process.exit()` DOES fire `'exit'` listeners, so we release the lock from
+    // one. `releaseLockIfOwned` only unlinks a lock still owned by this PID, so it
+    // is safe even if a later run re-acquired it. The listener is removed in the
+    // `finally` so the normal path stays single-release and repeated in-process
+    // `akmImprove` calls (tests) do not accumulate listeners.
     const releaseLockOnExit = () => {
         releaseLockIfOwned(resolvedLockPath, process.pid);
     };
@@ -524,6 +592,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
@@ -569,7 +638,7 @@ export async function akmImprove(options = {}) {
                         const judgment = triageConfig?.judgment
                             ? resolveTriageJudgmentRunner(triageConfig.judgment, _earlyConfig)
                             : null;
-                        await drainProposalsFn({
+                        triageDrain = await drainProposalsFn({
                             stashDir: primaryStashDir,
                             policy,
                             applyMode,
@@ -653,7 +722,7 @@ export async function akmImprove(options = {}) {
         if (primaryStashDir && shouldAnalyzeMemoryCleanup(scope, memorySummary.eligible, primaryStashDir)) {
             try {
                 // Reuse the config resolved at the top of the run instead of a second load.
-                await detectAndWriteContradictions(primaryStashDir, _earlyConfig);
+                await withLlmStage("memory-contradiction", () => detectAndWriteContradictions(primaryStashDir, _earlyConfig));
             }
             catch (err) {
                 // Non-fatal: contradiction detection is a best-effort pass.
@@ -710,37 +779,51 @@ 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 };
+    // #576: clears the per-run LLM usage sink. Defaults to a no-op until the sink
+    // is installed inside the try; the `finally` always calls it.
+    let disposeLlmUsageSink = () => { };
     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).
-            // Exit 0: budget exhaustion is a normal scheduled-task condition, not an error.
-            setTimeout(() => process.exit(0), 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 = {};
-        }
-        // 2026-05-27: emit `improve_skipped` audit events for refs the planner
+            // 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 };
+        }
+        // #576: persist per-call LLM usage telemetry for this run as `llm_usage`
+        // events, reusing the same boundary-pinned events context (and long-lived
+        // handle when available). Disposed in `finally` so the sink never leaks
+        // across runs. Wrapping is best-effort end to end — see usage-telemetry.ts.
+        disposeLlmUsageSink = installLlmUsagePersistence(eventsCtx);
+        // 2026-05-27: emit an `improve_skipped` audit event for refs the planner
         // pre-filtered (reflect AND distill both refuse them under the active
-        // profile). One event per ref so the existing improve_skipped histogram in
-        // `health.ts#improveSummary.skipReasons` accumulates the right count under
-        // the new `profile_filtered_all_passes` reason code. See
-        // `/tmp/akm-health-investigations/planner-profile-metrics-deep-analysis.md`.
-        for (const filtered of profileFilteredRefs) {
+        // profile). Emitted as a single summary event (count only) rather than one
+        // event per ref (#592) — the per-ref loop caused O(n) sequential state.db
+        // writes that consumed ~500 s on a 9 000-ref stash. No downstream consumer
+        // needs the per-ref audit trail: health's skip histogram reads the
+        // `profile_filtered_all_passes` counters from `improve_completed` metadata.
+        if (profileFilteredRefs.length > 0) {
             appendEvent({
                 eventType: "improve_skipped",
-                ref: filtered.ref,
-                metadata: { reason: "profile_filtered_all_passes" },
+                ref: undefined,
+                metadata: {
+                    reason: "profile_filtered_all_passes",
+                    count: profileFilteredRefs.length,
+                },
             }, eventsCtx);
         }
         const preparation = await runImprovePreparationStage({
@@ -787,20 +870,23 @@ export async function akmImprove(options = {}) {
             eventsCtx,
             improveProfile,
         });
-        const { allWarnings, consolidation, deadUrls, memoryInference, graphExtraction, stalenessDetection, maintenanceActions, memoryInferenceDurationMs, graphExtractionDurationMs, orphansPurged, proposalsExpired, gateAutoAcceptedCount: postLoopGateCount, gateAutoAcceptFailedCount: postLoopGateFailedCount, } = 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]
@@ -876,6 +962,17 @@ export async function akmImprove(options = {}) {
                 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, {
@@ -951,6 +1048,9 @@ export async function akmImprove(options = {}) {
         throw err;
     }
     finally {
+        // #576: clear the per-run LLM usage sink BEFORE closing `eventsDb` below, so
+        // no late sink invocation can write through a closed handle.
+        disposeLlmUsageSink();
         // O-1 (#364): Clear the budget abort timer so it does not keep the event
         // loop alive after the run completes.
         clearBudgetTimer();
@@ -978,6 +1078,7 @@ function emitImproveCompletedEvent(result, durations, eventsCtx) {
         reflectFailed: 0,
         reflectCooldown: 0,
         reflectSkipped: 0,
+        reflectGuardRejected: 0,
         distill: 0,
         distillSkipped: 0,
         memoryPrune: 0,
@@ -985,7 +1086,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;
@@ -999,6 +1109,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;
@@ -1017,6 +1130,8 @@ function emitImproveCompletedEvent(result, durations, eventsCtx) {
             case "error":
                 actionCounts.error += 1;
                 break;
+            default:
+                assertNever(action.mode);
         }
     }
     appendEvent({
@@ -1036,6 +1151,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,
@@ -1068,12 +1189,258 @@ 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 withLlmStage("consolidate", () => 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()}`,
+            // Full-pool sweep: consolidation only runs on the nightly default-profile
+            // pass (quick/frequent disable it), so a complete re-cluster is correct and
+            // affordable here. Do NOT pass incrementalSince — the time-window narrowing
+            // it triggers permanently excludes stale-but-unmerged duplicate clusters,
+            // starving merge recall and letting the pool grow unbounded. (The narrowing
+            // was a band-aid for an every-30-min consolidation cadence that the profile
+            // split has since eliminated.) lastConsolidateTs still gates whether we run.
+            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)
@@ -1094,6 +1461,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)
@@ -1103,7 +1487,9 @@ async function runImprovePreparationStage(args) {
     // / `akm feedback` invocations. Replaces the akm-plugin session-checkpoint
     // hook with an on-demand pull pipeline.
     //
-    // Default-on; opt out via `profiles.improve.default.processes.extract.enabled: false`.
+    // Default-on; opt out via the ACTIVE profile's `processes.extract.enabled: false`
+    // (#593: the gate respects the resolved improve profile, not just the
+    // hardcoded `default` profile path the legacy feature flag reads).
     // Each available harness gets one call with the default --since window;
     // already-seen sessions (tracked in state.db.extract_sessions_seen) are
     // skipped automatically so re-runs don't burn LLM calls on unchanged data.
@@ -1111,8 +1497,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;
-    let gateAutoAcceptFailedCount = 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,
@@ -1121,18 +1510,65 @@ async function runImprovePreparationStage(args) {
         config: extractConfig,
         eventsCtx,
     });
-    if (isLlmFeatureEnabled(extractConfig, "session_extraction")) {
-        const availableHarnesses = getAvailableHarnesses();
-        if (availableHarnesses.length > 0) {
+    // #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;
+    // #593: gate on BOTH the legacy feature flag (which only reads
+    // `profiles.improve.default.processes.extract.enabled` — kept for back-compat
+    // with users who disable extract via the default-profile path) AND the active
+    // resolved profile. Without the second check a non-default profile setting
+    // `extract.enabled: false` (e.g. the built-in `quick`) was silently ignored
+    // and extract ran on every improve call regardless.
+    if (isLlmFeatureEnabled(extractConfig, "session_extraction") && resolveProcessEnabled("extract", improveProfile)) {
+        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 {
-                    const result = await akmExtract({
+                    const result = await withLlmStage("session-extraction", () => akmExtract({
                         type: h.name,
                         ...(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);
                     {
                         const gr = await runAutoAcceptGate(primaryStashDir
@@ -1223,7 +1659,13 @@ async function runImprovePreparationStage(args) {
     const validationFailures = [];
     for (const candidate of postCleanupRefs) {
         try {
-            const filePath = await findAssetFilePath(candidate.ref, options.stashDir);
+            // #591: use the path pre-resolved at planning time when it is still on
+            // disk — a serial async DB lookup per ref cost ~500 s on a 9 000-ref
+            // stash. Fall back to findAssetFilePath only for refs that bypassed
+            // collectEligibleRefs' index scan or whose file moved since planning.
+            const filePath = candidate.filePath && fs.existsSync(candidate.filePath)
+                ? candidate.filePath
+                : await findAssetFilePath(candidate.ref, options.stashDir);
             if (!filePath) {
                 validationFailures.push({ ref: candidate.ref, reason: "file not found on disk" });
                 continue;
@@ -1444,7 +1886,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.");
         }
@@ -1531,15 +1973,32 @@ async function runImprovePreparationStage(args) {
     const assetMissingOnDisk = [];
     const existsCheckedActionable = [];
     for (const candidate of sorted) {
-        const filePath = await findAssetFilePath(candidate.ref, options.stashDir);
+        // #591: prefer the path pre-resolved at planning time (synchronous
+        // existsSync) over a serial async DB lookup per ref.
+        const filePath = candidate.filePath && fs.existsSync(candidate.filePath)
+            ? candidate.filePath
+            : await findAssetFilePath(candidate.ref, options.stashDir);
         if (filePath && fs.existsSync(filePath)) {
             existsCheckedActionable.push(candidate);
         }
         else {
             assetMissingOnDisk.push(candidate.ref);
-            appendEvent({ eventType: "improve_skipped", ref: candidate.ref, metadata: { reason: "asset_missing_on_disk" } }, eventsCtx);
         }
     }
+    // #592 audit: one summary event instead of one per missing ref. Normally
+    // tiny, but a stash deletion racing the run could make this O(n) sequential
+    // state.db writes. `refs` is capped so the metadata row stays bounded.
+    if (assetMissingOnDisk.length > 0) {
+        appendEvent({
+            eventType: "improve_skipped",
+            ref: undefined,
+            metadata: {
+                reason: "asset_missing_on_disk",
+                count: assetMissingOnDisk.length,
+                refs: assetMissingOnDisk.slice(0, 50),
+            },
+        }, eventsCtx);
+    }
     const actionableRefs = existsCheckedActionable;
     // Re-split actionableRefs (sorted) into reflect-path vs distill-only-path while
     // preserving sort order. distillOnlyRefs participate in the sort so --limit
@@ -1598,9 +2057,10 @@ async function runImprovePreparationStage(args) {
         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
@@ -1734,7 +2194,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) {
@@ -1779,9 +2239,11 @@ async function runImproveLoopStage(args) {
                             if (remainingBudgetMs() <= 0)
                                 break;
                             // draftMode: skip DB write so each sample doesn't create a proposal.
-                            samples.push(await reflectFn({ ...reflectCallArgs, draftMode: true }));
+                            samples.push(await withLlmStage("reflect", () => reflectFn({ ...reflectCallArgs, draftMode: true })));
                         }
-                        const winner = pickMajorityVote(samples.length > 0 ? samples : [await reflectFn({ ...reflectCallArgs, draftMode: true })]);
+                        const winner = pickMajorityVote(samples.length > 0
+                            ? samples
+                            : [await withLlmStage("reflect", () => reflectFn({ ...reflectCallArgs, draftMode: true }))]);
                         // Persist only the majority-vote winner as a single real proposal.
                         if (winner.ok && primaryStashDir) {
                             const persistResult = createProposal(primaryStashDir, {
@@ -1806,7 +2268,7 @@ async function runImproveLoopStage(args) {
                         }
                     }
                     else {
-                        reflectResult = await reflectFn(reflectCallArgs);
+                        reflectResult = await withLlmStage("reflect", () => reflectFn(reflectCallArgs));
                     }
                     const isCooldown = !reflectResult.ok && reflectResult.reason === "cooldown";
                     // Content-policy guard hits (reflect size-rail rejections) are NOT
@@ -1816,13 +2278,19 @@ 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
                     // user's stack were this case; see review §1a row "Reflect refused
                     // asset type".
                     const isTypeRefused = !reflectResult.ok && reflectResult.reason === "unsupported_type";
+                    // Noise-gate suppression (#580): the candidate edit was an empty
+                    // diff or a cosmetic-only reformat of the current asset. Like
+                    // `unsupported_type`, this is a deterministic skip — not an LLM
+                    // fault — so it routes to the `reflect-skipped` bucket and stays
+                    // out of recentErrors/avoidPatterns.
+                    const isNoChange = !reflectResult.ok && reflectResult.reason === "no_change";
                     actions.push({
                         ref: planned.ref,
                         mode: reflectResult.ok
@@ -1831,18 +2299,19 @@ async function runImproveLoopStage(args) {
                                 ? "reflect-cooldown"
                                 : isGuardReject
                                     ? "reflect-guard-rejected"
-                                    : isTypeRefused
+                                    : isTypeRefused || isNoChange
                                         ? "reflect-skipped"
                                         : "reflect-failed",
                         result: reflectResult,
                     });
-                    // Cooldown skips, guard rejects, and type-refused skips are not
-                    // failures — do not pollute recentErrors with them (those get
-                    // injected as `avoidPatterns` into the next reflect prompt). Guard
-                    // rejects ARE worth showing the LLM as a learn-signal so the next
-                    // iteration sees "your last expansion was too large"; type-refused
-                    // is deterministic and adds no learning signal.
-                    if (!reflectResult.ok && !isCooldown && !isTypeRefused) {
+                    // Cooldown skips, guard rejects, type-refused skips, and noise-gate
+                    // skips are not failures — do not pollute recentErrors with them
+                    // (those get injected as `avoidPatterns` into the next reflect
+                    // prompt). Guard rejects ARE worth showing the LLM as a learn-signal
+                    // so the next iteration sees "your last expansion was too large";
+                    // type-refused and no-change are deterministic and add no learning
+                    // signal.
+                    if (!reflectResult.ok && !isCooldown && !isTypeRefused && !isNoChange) {
                         const errMsg = reflectResult.error ?? reflectResult.reason ?? "unknown reflect error";
                         pushRecentError("reflect", errMsg);
                     }
@@ -1964,11 +2433,11 @@ async function runImproveLoopStage(args) {
                         }
                     }
                 }
-                const distillResult = await distillFn({
+                const distillResult = await withLlmStage("distill", () => distillFn({
                     ref: planned.ref,
                     ...(parsedPlannedRef.type === "memory" ? { proposalKind: "auto" } : {}),
                     ...(options.stashDir ? { stashDir: options.stashDir } : {}),
-                });
+                }));
                 actions.push({ ref: planned.ref, mode: "distill", result: distillResult });
                 if (distillResult.outcome === "queued" && distillResult.proposal) {
                     const distillGr = await runAutoAcceptGate([{ proposalId: distillResult.proposal.id, confidence: distillResult.proposal.confidence }], distillGateCfg);
@@ -2049,169 +2518,8 @@ async function runImproveLoopStage(args) {
     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;
-    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 (!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()}`,
-            // incrementalSince: when set in the profile config, narrows the candidate
-            // pool to memories modified within that window + their graph neighbours,
-            // keeping each pass focused on recent changes. Omit for a full-pool sweep
-            // (default for nightly passes). See config-schema.ts for guidance.
-            incrementalSince: improveProfile?.processes?.consolidate?.incrementalSince,
-            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 && !consolidationOnCooldown && consolidation.processed > 0;
     info("[improve] post-loop maintenance starting");
     const maintenanceResult = await runImproveMaintenancePasses({
         options,
@@ -2252,7 +2560,6 @@ async function runImprovePostLoopStage(args) {
     }
     return {
         allWarnings,
-        consolidation,
         deadUrls,
         ...(maintenanceResult.memoryInference ? { memoryInference: maintenanceResult.memoryInference } : {}),
         ...(maintenanceResult.graphExtraction ? { graphExtraction: maintenanceResult.graphExtraction } : {}),
@@ -2264,12 +2571,16 @@ async function runImprovePostLoopStage(args) {
         graphExtractionDurationMs: maintenanceResult.graphExtractionDurationMs,
         orphansPurged: maintenanceResult.orphansPurged,
         proposalsExpired: maintenanceResult.proposalsExpired,
-        gateAutoAcceptedCount,
-        gateAutoAcceptFailedCount,
+        // 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.
-async function runImproveMaintenancePasses(args) {
+// Exported for tests (#584/#585 DB-locking regression coverage); production
+// callers reach it only through akmImprove → runImprovePostLoopStage.
+export async function runImproveMaintenancePasses(args) {
     const { options, primaryStashDir, memoryRefsForInference, allWarnings, reindexFn, consolidationRan, budgetSignal, eventsCtx, improveProfile, } = args;
     if (!primaryStashDir)
         return { memoryInferenceDurationMs: 0, graphExtractionDurationMs: 0 };
@@ -2288,8 +2599,27 @@ async function runImproveMaintenancePasses(args) {
     let graphExtractionDurationMs = 0;
     let orphansPurged = 0;
     let proposalsExpired = 0;
+    const openIndexDb = () => openDatabase(getDbPath(), config.embedding?.dimension ? { embeddingDim: config.embedding.dimension } : undefined);
+    // #584: reindexFn opens its own write handle on the same index.db WAL file.
+    // Holding our handle across that call produced SQLITE_BUSY / "database is
+    // locked" failures in production, so the handle is closed BEFORE every
+    // reindex and reopened after — the fresh handle also sees the post-reindex
+    // state that graph extraction and staleness detection below rely on. The
+    // reopen runs in `finally` so a failed reindex still leaves a usable handle.
+    const reindexWithIndexDbReleased = async (stashDir) => {
+        if (db) {
+            closeDatabase(db);
+            db = undefined;
+        }
+        try {
+            await reindexFn({ stashDir });
+        }
+        finally {
+            db = openIndexDb();
+        }
+    };
     try {
-        db = openDatabase(getDbPath(), config.embedding?.dimension ? { embeddingDim: config.embedding.dimension } : undefined);
+        db = openIndexDb();
         // Memory inference candidate-discovery (post-Item 9 fix from
         // memory:akm-improve-critical-review-2026-05-20). Previously this pass
         // was gated on memoryRefsForInference.size > 0 AND passed those refs as a
@@ -2315,10 +2645,17 @@ 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 withLlmStage("memory-inference", () => 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 });
                 info(`[improve] memory inference complete (${memoryInference.writtenFacts} facts written from ${memoryInference.splitParents} parents)`);
@@ -2331,7 +2668,7 @@ async function runImproveMaintenancePasses(args) {
         if (memoryInference && (memoryInference.splitParents > 0 || memoryInference.writtenFacts > 0)) {
             info("[improve] reindexing after memory inference writes");
             try {
-                await reindexFn({ stashDir: primaryStashDir });
+                await reindexWithIndexDbReleased(primaryStashDir);
                 reindexedAfterInference = true;
                 info("[improve] reindex after memory inference complete");
             }
@@ -2367,7 +2704,7 @@ async function runImproveMaintenancePasses(args) {
                 if (consolidationRan && !reindexedAfterInference) {
                     info("[improve] reindexing after consolidation (graph extraction needs current state)");
                     try {
-                        await reindexFn({ stashDir: primaryStashDir });
+                        await reindexWithIndexDbReleased(primaryStashDir);
                         reindexedAfterInference = true;
                         info("[improve] reindex after consolidation complete");
                     }
@@ -2375,10 +2712,8 @@ async function runImproveMaintenancePasses(args) {
                         allWarnings.push(`reindex after consolidation failed: ${err instanceof Error ? err.message : String(err)}`);
                     }
                 }
-                if (db && reindexedAfterInference) {
-                    closeDatabase(db);
-                    db = openDatabase(getDbPath(), config.embedding?.dimension ? { embeddingDim: config.embedding.dimension } : undefined);
-                }
+                // #584: no close/reopen needed here — reindexWithIndexDbReleased
+                // already swapped in a fresh post-reindex handle.
                 // Resolve touched refs to absolute file paths. Skipped for fullScan
                 // (candidatePaths stays undefined → extractor processes all files).
                 let candidatePaths;
@@ -2398,9 +2733,15 @@ 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 withLlmStage("graph-extraction", () => 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 });
                 info(`[improve] graph extraction complete (${graphExtraction.quality.extractedFiles} files, ${graphExtraction.quality.entityCount} entities, ${graphExtraction.quality.relationCount} relations)`);
@@ -2471,14 +2812,22 @@ async function runImproveMaintenancePasses(args) {
         // invocation, and every command surface emits at least one event besides —
         // without this trim, state.db is a permanent append-only log. Config key
         // `improve.eventRetentionDays` (default 90, set 0 to disable) controls the
-        // window. `purgeOldEvents()` opens its own state.db handle separate from
-        // the index `db` above (different SQLite file).
+        // window. The purge runs against state.db (a different SQLite file from
+        // the index `db` above).
         {
             const retentionDays = typeof config.improve?.eventRetentionDays === "number" ? config.improve.eventRetentionDays : 90;
             if (retentionDays > 0) {
+                // #585: reuse the long-lived eventsCtx.db connection when akmImprove
+                // opened one — opening a second state.db write connection while
+                // eventsDb is still live made two simultaneous writers contend on the
+                // same WAL file ("database is locked"). Only the eventsCtx.dbPath
+                // fallback path (state.db failed to open up-front) opens — and then
+                // owns and closes — its own handle. C2 still holds: the fallback uses
+                // the boundary-pinned path, never a live `process.env` re-read.
+                const ownsStateDb = !eventsCtx?.db;
                 let stateDb;
                 try {
-                    stateDb = openStateDatabase();
+                    stateDb = eventsCtx?.db ?? 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`);
@@ -2506,7 +2855,7 @@ async function runImproveMaintenancePasses(args) {
                     allWarnings.push(`events purge failed: ${err instanceof Error ? err.message : String(err)}`);
                 }
                 finally {
-                    if (stateDb) {
+                    if (ownsStateDb && stateDb) {
                         try {
                             stateDb.close();
                         }
@@ -2515,6 +2864,37 @@ async function runImproveMaintenancePasses(args) {
                         }
                     }
                 }
+                // task_logs in logs.db (#579) shares the same retention window as
+                // events/improve_runs — all three are observability data governed by
+                // the single improve.eventRetentionDays knob. Separate try/finally
+                // because logs.db is a different file: a locked/missing logs.db must
+                // not block the state.db purges above.
+                let logsDb;
+                try {
+                    logsDb = openLogsDatabase();
+                    const taskLogsPurged = purgeOldTaskLogs(logsDb, retentionDays);
+                    if (taskLogsPurged > 0) {
+                        info(`[improve] task_logs purge: ${taskLogsPurged} log line(s) older than ${retentionDays}d removed from logs.db`);
+                    }
+                    appendEvent({
+                        eventType: "task_logs_purged",
+                        ref: "task_logs:_purge",
+                        metadata: { purgedCount: taskLogsPurged, retentionDays },
+                    }, eventsCtx);
+                }
+                catch (err) {
+                    allWarnings.push(`task_logs purge failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+                finally {
+                    if (logsDb) {
+                        try {
+                            logsDb.close();
+                        }
+                        catch {
+                            // best-effort
+                        }
+                    }
+                }
             }
         }
         // Phase 4A (staleness detection). Activates the `deprecated` belief-state
@@ -2523,7 +2903,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 withLlmStage("staleness-detection", () => stalenessDetectionFn({ config, sources, signal: budgetSignal, db }));
                 if (stalenessDetection.considered > 0) {
                     info(`[improve] staleness detection complete (considered ${stalenessDetection.considered}, ` +
                         `deprecated ${stalenessDetection.deprecated}, confirmed ${stalenessDetection.confirmed}, ` +