akm-cli 0.9.16 → 0.9.17-alpha.10

package/dist/commands/improve/consolidate.js

@@ -1,7 +1,23 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-import { createHash } from "node:crypto";
+/**
+ * `akm consolidate` — show the model the memory pool in chunks of similar
+ * memories and queue a knowledge proposal for each memory it says should be
+ * promoted. Promotion emits a reviewable proposal and never touches the
+ * memory directly; accepting it later retires the source memory (O1, in
+ * `proposal/repository.ts`). Memories the improve ledger judged recently and
+ * that have not changed since are not judged again.
+ *
+ * Accounting invariant (the promote pass only): `processed == promoted +
+ * judgedNoAction + Σ(skipReasons) + failedChunkMemories`.
+ *
+ * A second pass, the pair pass (`consolidate/pair-pass.ts`, alpha.9), runs
+ * alongside this one and keeps its own separate counters (`pairPass` on the
+ * result) — it judges near-duplicate and superseding pairs across the wider
+ * memory tier and mints `retire` proposals; see that module's own doc
+ * comment.
+ */
 import fs from "node:fs";
 import path from "node:path";
 import consolidateSystemPrompt from "../../assets/prompts/consolidate-system.md" with { type: "text" };
@@ -11,52 +27,64 @@ import { parseFrontmatter } from "../../core/asset/frontmatter.js";
 import { conceptIdFromTypeName, displayRef, parseRefInput } from "../../core/asset/resolve-ref.js";
 import { getImproveProcessConfig, loadConfig } from "../../core/config/config.js";
 import { parseEmbeddedJsonResponse } from "../../core/parse.js";
-import { resolveStandardsContext } from "../../core/standards/resolve-standards-context.js";
 import { openStateDatabase } from "../../core/state-db.js";
-import { parseSinceToIsoLenient } from "../../core/time.js";
 import { warn, warnVerbose } from "../../core/warn.js";
 import { resolveWriteTarget } from "../../core/write-source.js";
 import { deriveInstallations } from "../../indexer/installations.js";
 import { resolveSourceEntries } from "../../indexer/search/search-source.js";
-import { disposeLoweredExecutionDispatchLease, } from "../../integrations/agent/execution-lowering.js";
+import { USAGE_EVENT_RETENTION_DAYS } from "../../indexer/usage/usage-events.js";
+import { assertRunnerCredentials } from "../../integrations/agent/runner-dispatch.js";
 import { cosineSimilarity, embedBatch, resolveEmbeddingModelId } from "../../llm/embedder.js";
-import { callStructured, preflightStructuredLlmRunner } from "../../llm/structured-call.js";
 import { getBodyEmbeddings, upsertBodyEmbeddings } from "../../storage/repositories/embeddings-repository.js";
 import { closeDatabase, openExistingDatabase, openReadonlyExistingDatabase, } from "../../storage/repositories/index-connection.js";
-import { findEntryIdByRef, getAllEntries, getEntryById } from "../../storage/repositories/index-entries-repository.js";
-import { getNeighborsByEntryId } from "../../storage/repositories/index-vec-repository.js";
-import { isProposalSkipped, listProposals, listProposalsReadOnly, proposalContent, } from "../proposal/repository.js";
-import { hasSupersededStatus, validateProposalFrontmatter } from "../proposal/validators/proposal-quality-validators.js";
-import { DEFAULT_RANDOM_CLUSTER_FRACTION } from "./anti-collapse.js";
-import { cacheHash } from "./content-hash.js";
-import { resolveImproveLlmExecution } from "./execution.js";
-import { resolveImproveStrategy, resolveProcessEnabled } from "./improve-strategies.js";
-import { emitProposal } from "./proposal-envelope.js";
-import { createRunContext } from "./run-context.js";
-// Chunk sizing + per-chunk prompt assembly live in ./consolidate/chunking.
+import { getAllEntries } from "../../storage/repositories/index-entries-repository.js";
+import { listProposals, listProposalsReadOnly, proposalContent } from "../proposal/repository.js";
+import { hasHotCaptureMode, hasSupersededStatus, validateProposalFrontmatter, } from "../proposal/validators/proposal-quality-validators.js";
 import { buildChunkPrompt, computeSafeChunkSize, DEFAULT_CONTEXT_LENGTH_TOKENS } from "./consolidate/chunking.js";
-// Eligibility / safety predicates live in ./consolidate/eligibility.
-import { isConsolidationEligibleMemoryName, isHotCapturedMemory } from "./consolidate/eligibility.js";
-// Plan parsing / merging (pure op-reconciliation algebra) lives in
-// ./consolidate/merge.
-import { isValidOp, mergePlans } from "./consolidate/merge.js";
-// LLM-output sanitization (pure string/frontmatter transforms) lives in
-// ./consolidate/sanitize.
+import { runConsolidatePairPass } from "./consolidate/pair-pass.js";
 import { sanitizeMergedContent } from "./consolidate/sanitize.js";
-// ── Prompts ─────────────────────────────────────────────────────────────────
-const CONSOLIDATE_SYSTEM_PROMPT = consolidateSystemPrompt;
+import { contentHash } from "./content-hash.js";
+import { resolveImproveStrategy, resolveProcessEnabled } from "./improve-strategies.js";
+import { isLedgerBlocked, ledgerKey, loadLedgerSnapshot, recordLedgerAttempt } from "./ledger.js";
+import { isInRetrievalScope, loadRetrievalScope } from "./retrieval-scope.js";
+import { callStage, mintProposal, noticeSet, stageRunner } from "./stage.js";
+/** A plan op worth acting on. Retired advisory ops (merge/delete/contradict) are dropped, never thrown on. */
+export function isValidOp(op) {
+    if (typeof op !== "object" || op === null)
+        return false;
+    const o = op;
+    return o.op === "promote" && typeof o.ref === "string" && typeof o.knowledgeRef === "string";
+}
+/** Reconcile the per-chunk plans: one promotion per source memory, the last chunk's wins. */
+export function mergePlans(chunks) {
+    const byRef = new Map();
+    for (const chunk of chunks)
+        for (const op of chunk)
+            byRef.set(op.ref, op);
+    return [...byRef.values()];
+}
+export function isConsolidationEligibleMemoryName(name) {
+    return !name.endsWith(".derived");
+}
 /**
- * JSON Schema for structured consolidate plans (PR 1 of the asset-writers
- * decision — see knowledge/projects/akm/asset-writers-investigation/00-synthesis).
- * Mirrors the {ops[], warnings?[]} shape currently described in
- * CONSOLIDATE_SYSTEM_PROMPT. Providers with `supportsJsonSchema: true` enforce
- * the shape upstream so the chunk-level "invalid plan from AI — skipping"
- * branch in `runConsolidate` becomes unreachable on schema-honouring providers.
- *
- * The four operation variants (merge / delete / promote / contradict) are
- * modeled as a oneOf so a structured-output provider can still tell them apart
- * by the required `op` discriminator. `parseEmbeddedJsonResponse` keeps
- * working as a fallback parser for providers that ignore the schema.
+ * A `captureMode: hot` memory (written deliberately with `akm remember`). A
+ * missing file is not hot; an unreadable one is treated as hot — the check is
+ * a protection and must not fail open.
+ */
+export function isHotCapturedMemory(filePath) {
+    if (!fs.existsSync(filePath))
+        return false;
+    try {
+        return hasHotCaptureMode(parseFrontmatter(fs.readFileSync(filePath, "utf8")).data);
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Structured-output schema for a plan. Promote-only: merge/delete/contradict
+ * were removed in 0.9.17-alpha.1 (`e82eec811`) after running in production —
+ * they cost thousands of completion tokens.
  */
 export const CONSOLIDATE_PLAN_JSON_SCHEMA = {
     type: "object",
@@ -65,191 +93,91 @@ export const CONSOLIDATE_PLAN_JSON_SCHEMA = {
     properties: {
         operations: {
             type: "array",
-            description: "Ordered list of consolidate operations the planner proposes.",
+            description: "Ordered list of promote operations the planner proposes.",
             items: {
-                oneOf: [
-                    {
-                        type: "object",
-                        required: ["op", "primary", "secondaries", "mergeStrategy"],
-                        additionalProperties: false,
-                        properties: {
-                            op: { type: "string", enum: ["merge"] },
-                            primary: { type: "string", minLength: 1 },
-                            secondaries: {
-                                type: "array",
-                                minItems: 1,
-                                maxItems: 1,
-                                items: { type: "string", minLength: 1 },
-                            },
-                            mergeStrategy: { type: "string", minLength: 1 },
-                            confidence: { type: "number", minimum: 0, maximum: 1 },
-                        },
-                    },
-                    {
-                        type: "object",
-                        required: ["op", "ref", "reason"],
-                        additionalProperties: false,
-                        properties: {
-                            op: { type: "string", enum: ["delete"] },
-                            ref: { type: "string", minLength: 1 },
-                            reason: { type: "string", minLength: 1 },
-                            confidence: { type: "number", minimum: 0, maximum: 1 },
-                        },
-                    },
-                    {
-                        type: "object",
-                        required: ["op", "ref", "knowledgeRef", "reason"],
-                        additionalProperties: false,
-                        properties: {
-                            op: { type: "string", enum: ["promote"] },
-                            ref: { type: "string", minLength: 1 },
-                            knowledgeRef: { type: "string", minLength: 1 },
-                            reason: { type: "string", minLength: 1 },
-                            description: { type: "string" },
-                            confidence: { type: "number", minimum: 0, maximum: 1 },
-                        },
-                    },
-                    {
-                        type: "object",
-                        required: ["op", "ref", "contradictedByRef", "reason"],
-                        additionalProperties: false,
-                        properties: {
-                            op: { type: "string", enum: ["contradict"] },
-                            ref: { type: "string", minLength: 1 },
-                            contradictedByRef: { type: "string", minLength: 1 },
-                            reason: { type: "string", minLength: 1 },
-                            confidence: { type: "number", minimum: 0, maximum: 1 },
-                        },
-                    },
-                ],
+                type: "object",
+                required: ["op", "ref", "knowledgeRef", "reason"],
+                additionalProperties: false,
+                properties: {
+                    op: { type: "string", enum: ["promote"] },
+                    ref: { type: "string", minLength: 1 },
+                    knowledgeRef: { type: "string", minLength: 1 },
+                    reason: { type: "string", minLength: 1, maxLength: 200 },
+                    description: { type: "string" },
+                    confidence: { type: "number", minimum: 0, maximum: 1 },
+                },
             },
         },
-        warnings: {
-            type: "array",
-            description: "Optional list of human-readable concerns the planner wants to surface.",
-            items: { type: "string" },
-        },
     },
 };
+/**
+ * Order memories so similar ones sit together and land in the same chunk:
+ * a greedy nearest-neighbour chain over description+tag embeddings (cached in
+ * `body_embeddings` under the text's hash). Keeps the original order without
+ * an embedding config, for fewer than three memories, or when embedding fails.
+ */
 async function clusterMemoriesBySimilarity(memories, config, stateDb, signal) {
-    const noTelemetry = { embedMs: 0, cacheHits: 0, cacheMisses: 0 };
+    const telemetry = { embedMs: 0, cacheHits: 0, cacheMisses: 0 };
     if (memories.length < 3 || !config.embedding)
-        return { ordered: memories, embedTelemetry: noTelemetry };
-    // WS-3a: cluster uses description+tags as the embedding input (NOT the raw
-    // body) — this is intentionally different from the dedup/body cache because
-    // the clustering goal is semantic grouping, not dedup twin detection.
-    // The body_embeddings cache is keyed by cacheHash(body); clustering inputs
-    // are keyed by cacheHash(description+tags text). Re-use the same table with
-    // a distinct hash so the two lookup sets never collide.
+        return { ordered: memories, embedTelemetry: telemetry };
     const modelId = resolveEmbeddingModelId(config.embedding);
-    const texts = memories.map((m) => {
-        const parts = [];
-        if (m.description)
-            parts.push(m.description);
-        if (m.tags.length > 0)
-            parts.push(m.tags.join(" "));
-        return parts.join(". ") || m.name;
-    });
-    // Compute content hashes for the cluster texts (not bodies — different input).
-    const contentHashes = texts.map((t) => createHash("sha256").update(t, "utf8").digest("hex"));
-    // WS-5: track embed cache hits/misses for perf telemetry.
-    let embedMs = 0;
-    let cacheHits = 0;
-    let cacheMisses = 0;
-    let cachedVecs = new Map();
+    const texts = memories.map((m) => [m.description, m.tags.join(" ")].filter(Boolean).join(". ") || m.name);
+    const hashes = texts.map((t) => contentHash(t));
+    let cached = new Map();
     if (stateDb) {
         try {
-            cachedVecs = getBodyEmbeddings(stateDb, contentHashes, modelId);
+            cached = getBodyEmbeddings(stateDb, hashes, modelId);
         }
         catch {
-            // Fail open.
-            cachedVecs = new Map();
+            cached = new Map();
         }
     }
-    const missIndices = [];
-    const missTexts = [];
-    for (let i = 0; i < texts.length; i++) {
-        if (!cachedVecs.has(contentHashes[i])) {
-            missIndices.push(i);
-            missTexts.push(texts[i]);
-            cacheMisses++;
-        }
-        else {
-            cacheHits++;
-        }
-    }
-    let missVecs = [];
-    if (missTexts.length > 0) {
+    const missIndices = hashes.flatMap((hash, i) => (cached.has(hash) ? [] : [i]));
+    telemetry.cacheHits = memories.length - missIndices.length;
+    telemetry.cacheMisses = missIndices.length;
+    const vectors = new Map(cached);
+    if (missIndices.length > 0) {
         const embedStart = Date.now();
+        let missVecs;
         try {
-            missVecs = await embedBatch(missTexts, config.embedding, signal);
+            missVecs = await embedBatch(missIndices.map((i) => texts[i]), config.embedding, signal);
         }
         catch {
-            // Fail open: embedding failures degrade gracefully to original order.
-            return { ordered: memories, embedTelemetry: { embedMs, cacheHits, cacheMisses } };
+            return { ordered: memories, embedTelemetry: telemetry };
         }
         finally {
-            embedMs += Date.now() - embedStart;
+            telemetry.embedMs += Date.now() - embedStart;
         }
-        // Upsert newly computed vectors into the cache. A skipped document
-        // (embedBatch reports it via `undefined` rather than throwing, #874) has
-        // no vector to cache — omit it rather than writing a bogus embedding.
-        if (stateDb && missVecs.length === missTexts.length) {
+        const fresh = missIndices.flatMap((idx, pos) => {
+            const embedding = missVecs[pos];
+            return embedding ? [{ contentHash: hashes[idx], embedding, modelId }] : [];
+        });
+        for (const entry of fresh)
+            vectors.set(entry.contentHash, entry.embedding);
+        // A document the embedder skipped has no vector to cache.
+        if (stateDb && missVecs.length === missIndices.length) {
             try {
-                const toUpsert = missIndices.flatMap((idx, pos) => {
-                    const embedding = missVecs[pos];
-                    return embedding ? [{ contentHash: contentHashes[idx], embedding, modelId }] : [];
-                });
-                upsertBodyEmbeddings(stateDb, toUpsert);
+                upsertBodyEmbeddings(stateDb, fresh);
             }
             catch {
-                // Fail open: cache write errors are non-fatal.
-            }
-        }
-    }
-    // Assemble the full embedding array in memories order.
-    let embeddings = null;
-    {
-        const assembled = [];
-        let ok = true;
-        for (let i = 0; i < memories.length; i++) {
-            const hash = contentHashes[i];
-            const cached = cachedVecs.get(hash);
-            if (cached) {
-                assembled.push(cached);
-                continue;
-            }
-            const missPos = missIndices.indexOf(i);
-            const vec = missPos >= 0 ? missVecs[missPos] : undefined;
-            if (vec) {
-                assembled.push(vec);
+                // Cache writes are best-effort.
             }
-            else {
-                ok = false;
-                break;
-            }
-        }
-        if (ok && assembled.length === memories.length) {
-            embeddings = assembled;
         }
     }
-    const embedTelemetry = { embedMs, cacheHits, cacheMisses };
-    if (!embeddings || embeddings.length !== memories.length)
-        return { ordered: memories, embedTelemetry };
-    // Greedy nearest-neighbour chain.
+    const embeddings = hashes.map((hash) => vectors.get(hash));
+    if (embeddings.some((vec) => !vec))
+        return { ordered: memories, embedTelemetry: telemetry };
     const used = new Array(memories.length).fill(false);
-    const ordered = [];
-    let current = 0; // start from the first memory
-    ordered.push(memories[current]);
-    used[current] = true;
+    const ordered = [memories[0]];
+    used[0] = true;
+    let current = 0;
     for (let step = 1; step < memories.length; step++) {
-        const currentEmb = embeddings[current];
         let bestIdx = -1;
         let bestSim = -Infinity;
         for (let j = 0; j < memories.length; j++) {
             if (used[j])
                 continue;
-            const sim = cosineSimilarity(currentEmb, embeddings[j]);
+            const sim = cosineSimilarity(embeddings[current], embeddings[j]);
             if (sim > bestSim) {
                 bestSim = sim;
                 bestIdx = j;
@@ -261,49 +189,64 @@ async function clusterMemoriesBySimilarity(memories, config, stateDb, signal) {
         used[bestIdx] = true;
         current = bestIdx;
     }
-    return { ordered, embedTelemetry };
+    return { ordered, embedTelemetry: telemetry };
 }
-// ── Chunk helpers ────────────────────────────────────────────────────────────
 /**
- * Precompute body-hashes of all currently-pending consolidate proposals so
- * the per-chunk prompt can annotate memories whose body would just produce
- * a deterministic `dedup_pending_proposal` skip. Uses `cacheHash` (case-
- * preserving stripped body) — the same domain used by the body-embedding
- * cache. Empty set on any read/parse error — fail-safe to "annotate nothing"
- * so the LLM still proposes.
+ * Anti-collapse (default on, `antiCollapse.enabled: false` opts out): a small
+ * deterministic sample of the pool is spread through the similarity order so
+ * consolidation is not purely similarity-driven.
  */
+function injectRandomClusterMembers(memories, profile, warnings) {
+    const config = getImproveProcessConfig("consolidate", profile)?.antiCollapse ?? {};
+    if (config.enabled === false || memories.length <= 2)
+        return memories;
+    const fraction = config.randomClusterFraction ?? 0.05;
+    const randomCount = Math.max(1, Math.floor(memories.length * fraction));
+    const sample = [...memories]
+        .sort((a, b) => contentHash(a.name).localeCompare(contentHash(b.name)))
+        .slice(0, randomCount);
+    const sampled = new Set(sample.map((m) => m.name));
+    const interval = Math.max(2, Math.floor(memories.length / randomCount));
+    const out = [];
+    let next = 0;
+    for (let i = 0; i < memories.length; i++) {
+        const m = memories[i];
+        if (m && !sampled.has(m.name))
+            out.push(m);
+        if (i > 0 && i % interval === 0 && next < sample.length)
+            out.push(sample[next++]);
+    }
+    while (next < sample.length)
+        out.push(sample[next++]);
+    warnings.push(`Anti-collapse: injected ${randomCount} random (non-similarity-driven) cluster member(s) into consolidation pool (fraction=${fraction}).`);
+    return out;
+}
+/** Body hashes of pending consolidate proposals, so the prompt can mark memories already queued. */
 function loadPendingConsolidateProposalHashes(stashDir) {
     const hashes = new Set();
     try {
-        const pending = listProposalsReadOnly(stashDir, { status: "pending" }).filter((proposal) => proposal.source === "consolidate");
-        for (const p of pending) {
+        for (const p of listProposalsReadOnly(stashDir, { status: "pending" })) {
+            if (p.source !== "consolidate")
+                continue;
             try {
-                hashes.add(cacheHash(proposalContent(p)));
+                hashes.add(contentHash(proposalContent(p), "body"));
             }
             catch {
-                // skip malformed payloads — they can't dedup anyway
+                // A malformed payload cannot dedup anyway.
             }
         }
     }
     catch {
-        // listProposals throws on missing stash dir during tests — empty set is safe
+        // Annotate nothing; the model still proposes.
     }
     return hashes;
 }
 /**
- * Hash the bodies of live knowledge assets once per consolidation run.
- *
- * Pending-proposal dedup prevents repeated queue entries, but accepted
- * proposals leave that set. Without a live-asset guard, the next run can copy
- * the same memory body into a new knowledge slug indefinitely. Scan the target
- * tree directly (rather than trusting the asynchronously refreshed index) so
- * an already-written asset suppresses recurrence immediately.
+ * Body hashes of the live knowledge assets, read from disk (the index may lag
+ * a just-written asset), so an accepted promotion is not proposed again.
  */
 export function loadExistingKnowledgeBodyHashes(targetRoot) {
     const hashes = new Set();
-    const knowledgeRoot = path.join(targetRoot, "knowledge");
-    if (!fs.existsSync(knowledgeRoot))
-        return hashes;
     const visit = (dir) => {
         let entries;
         try {
@@ -314,84 +257,31 @@ export function loadExistingKnowledgeBodyHashes(targetRoot) {
         }
         for (const entry of entries) {
             const entryPath = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
+            if (entry.isDirectory())
                 visit(entryPath);
-            }
             else if (entry.isFile() && entry.name.endsWith(".md")) {
                 try {
-                    hashes.add(cacheHash(fs.readFileSync(entryPath, "utf8")));
+                    hashes.add(contentHash(fs.readFileSync(entryPath, "utf8"), "body"));
                 }
                 catch {
-                    // An unreadable asset cannot provide reliable duplicate evidence.
+                    // An unreadable asset is no duplicate evidence.
                 }
             }
         }
     };
-    visit(knowledgeRoot);
+    visit(path.join(targetRoot, "knowledge"));
     return hashes;
 }
-/** Parse a stored provenance ref and emit its canonical D-R5 display spelling. */
-function canonicalStoredXref(ref) {
+/** A provenance ref in its canonical display spelling. */
+function canonicalXref(ref) {
     try {
         const p = parseRefInput(ref);
         return displayRef({ type: p.type, name: p.name, bundleId: p.origin });
     }
     catch {
-        return undefined;
+        return ref;
     }
 }
-function canonicalXref(ref) {
-    return canonicalStoredXref(ref) ?? ref;
-}
-/**
- * The promoted asset's provenance xref set: existing body-frontmatter xrefs +
- * the promoted source ref, deduped after canonicalization (WI-8.5b: emitted in
- * the D-R5 new grammar via {@link canonicalXref}).
- */
-function promoteProvenanceXrefs(existing, sourceRef) {
-    const priors = Array.isArray(existing) ? existing.map(String) : [];
-    return [...new Set([...priors, sourceRef].map(canonicalXref))];
-}
-// ── LLM resolution ──────────────────────────────────────────────────────────
-/**
- * Resolve the symbolic LLM runner for the consolidate pass.
- *
- * Priority order (mirrors extract / reflect / distill — see
- * `resolveExtractRunConfig` in `src/commands/improve/extract.ts` and the
- * canonical improve execution-cascade pattern):
- *
- *   1. `improve.strategies.<name>.processes.consolidate.engine`
- *      via the common execution planner. Lets the user pin
- *      a dedicated model (e.g. `ministral-3b`) for consolidation instead of
- *      whatever `defaults.llmEngine` happens to be.
- *   2. the baseline default LLM engine.
- *
- * All consolidate execution crosses the same improve engine-resolution
- * boundary as extract, reflect, and distill.
- */
-function resolveConsolidateLlmRunner(config, activeProfile) {
-    return resolveImproveLlmExecution({
-        config,
-        profile: activeProfile,
-        process: getImproveProcessConfig("consolidate", activeProfile),
-        processName: "consolidate",
-    });
-}
-function consolidateRunnerFromOptions(opts, config) {
-    if (Object.hasOwn(opts, "llmRunner"))
-        return opts.llmRunner ?? undefined;
-    const resolved = resolveConsolidateLlmRunner(config, opts.improveProfile);
-    if (resolved)
-        opts.onNotices?.(resolved.notices);
-    return resolved?.runner;
-}
-/**
- * Build a {@link ConsolidateResult} from partial overrides, filling the envelope
- * defaults (schemaVersion / ok / shape + the zeroed counters). Collapses the
- * ~7 near-identical result literals that previously appeared verbatim at every
- * early-return site and the final return of `akmConsolidateInner`. Callers pass
- * only the fields that differ from the all-zero, ok, non-preview baseline.
- */
 export function makeConsolidateResult(overrides) {
     return {
         schemaVersion: 1,
@@ -408,7 +298,6 @@ export function makeConsolidateResult(overrides) {
         ...overrides,
     };
 }
-// ── Main entry point ─────────────────────────────────────────────────────────
 function resolveConsolidationWriteTarget(opts, config) {
     if (opts.writeTarget) {
         const root = path.resolve(opts.writeTarget.source.path);
@@ -421,140 +310,78 @@ function resolveConsolidationWriteTarget(opts, config) {
             },
         };
     }
-    if (opts.target) {
-        const target = resolveWriteTarget(config, opts.target);
-        return { ...target, source: { ...target.source, path: path.resolve(target.source.path) } };
-    }
-    if (opts.stashDir) {
+    if (!opts.target && opts.stashDir) {
         const root = path.resolve(opts.stashDir);
         return {
             source: { kind: "filesystem", name: "stash", path: root, adapterId: detectAdapterId(root) },
             config: { type: "filesystem", name: "stash", path: root, writable: true },
         };
     }
-    const target = resolveWriteTarget(config);
+    const target = resolveWriteTarget(config, opts.target);
     return { ...target, source: { ...target.source, path: path.resolve(target.source.path) } };
 }
 export async function akmConsolidate(opts = {}) {
     const startMs = Date.now();
-    // Derive a stable PROV-DM token for this run. Callers (e.g. akmImprove)
-    // should pass opts.sourceRun to tie proposals back to the parent run;
-    // standalone `akm consolidate` gets a self-contained token.
-    const sourceRun = opts.sourceRun ?? `consolidate-${startMs}`;
     const config = opts.config ?? loadConfig();
     const writeTarget = resolveConsolidationWriteTarget(opts, config);
-    opts = { ...opts, target: writeTarget.source.name, writeTarget };
-    const activeProfile = opts.improveProfile ?? resolveImproveStrategy(undefined, config).config;
-    opts = { ...opts, improveProfile: activeProfile };
+    const profile = opts.improveProfile ?? resolveImproveStrategy(undefined, config).config;
     const stashDir = writeTarget.source.path;
-    const executionNotices = new Map();
-    const externalOnNotices = opts.onNotices;
-    const collectNotices = (notices) => {
-        for (const notice of notices)
-            executionNotices.set(JSON.stringify(notice), notice);
-        externalOnNotices?.(notices);
+    const notices = noticeSet(opts.onNotices);
+    const enabled = resolveProcessEnabled("consolidate", profile);
+    const runner = enabled ? stageRunner(opts, config, profile, "consolidate", notices.add) : undefined;
+    opts = {
+        ...opts,
+        target: writeTarget.source.name,
+        writeTarget,
+        improveProfile: profile,
+        onNotices: notices.add,
+        sourceRun: opts.sourceRun ?? `consolidate-${startMs}`,
+        // Every later reader sees this one runner snapshot.
+        llmRunner: runner ?? null,
     };
-    opts = { ...opts, onNotices: collectNotices };
-    const consolidateEnabled = resolveProcessEnabled("consolidate", activeProfile);
-    const frozenLlmRunner = consolidateEnabled ? consolidateRunnerFromOptions(opts, config) : undefined;
-    // Own the field even when no runner exists. Every downstream reader now
-    // observes this one symbolic snapshot instead of re-running config/model-map
-    // selection during the same invocation.
-    opts = { ...opts, llmRunner: frozenLlmRunner ?? null };
-    const withNotices = (result) => executionNotices.size > 0 ? { ...result, notices: Object.freeze([...executionNotices.values()]) } : result;
-    // WI-9.10: construct this run's RunContext from values already resolved
-    // above (sourceRun, config, stashDir) — no second config load, no new db
-    // handle. consolidate.ts has no `eventsCtx`/proposals-`ctx` option at all
-    // (WS-3a retired its only appendEvent usage; `emitProposal` here is always
-    // called with the default, seam-less ProposalsContext — see
-    // emitPromotionProposal below), so both get the safe empty-object default,
-    // behaviorally identical to `undefined` (EventsContext/ProposalsContext
-    // fields are all optional-chained by their consumers). LLM work uses the
-    // already-frozen symbolic runner through the shared dispatch seam.
-    const runContext = createRunContext({
-        stashDir,
-        config,
-        eventsCtx: {},
-        proposalsCtx: {},
-        getLlmRunner: () => opts.llmRunner ?? null,
-        sourceRun,
-        dryRun: opts.dryRun ?? false,
-        signal: opts.signal,
-    });
-    const warnings = [];
-    if (!consolidateEnabled) {
-        return withNotices(makeConsolidateResult({
-            // Sourced from runContext (identical value to `opts.dryRun ?? false`)
-            // so the constructed RunContext has a genuine downstream reference —
-            // consolidate's own content-read sites are out of this stage's stated
-            // item-2 scope (reflect + distill only; see the WI-9.10c report).
-            dryRun: runContext.dryRun,
-            target: opts.target ?? stashDir,
-            durationMs: Date.now() - startMs,
-            warnings,
-        }));
+    if (!enabled) {
+        const target = opts.target ?? stashDir;
+        return {
+            ...makeConsolidateResult({ dryRun: opts.dryRun ?? false, target, durationMs: Date.now() - startMs }),
+            ...notices.fields(),
+        };
     }
-    // WS-3a: open one state.db handle shared by the body-embedding cache (dedup
-    // + cluster) and the judged-state cache. All callers in the function body
-    // receive this handle; it is closed in the `finally` block below.
-    // Fail-open: any open error leaves it `undefined` and all cache paths skip.
-    let sharedStateDb;
+    // One state.db handle for the embedding cache; unavailable means no cache.
+    let stateDb;
     if (config.embedding) {
         try {
-            sharedStateDb = openStateDatabase();
+            stateDb = openStateDatabase();
         }
         catch {
-            // State DB unavailable → skip the embedding cache for this run.
+            stateDb = undefined;
         }
     }
     try {
-        return withNotices(await akmConsolidateInner(opts, config, stashDir, startMs, warnings, sharedStateDb));
+        return { ...(await consolidate(opts, config, stashDir, startMs, stateDb)), ...notices.fields() };
     }
     finally {
-        sharedStateDb?.close();
+        stateDb?.close();
     }
 }
-/** Fresh, zeroed accounting accumulators for one consolidate run. */
-function createConsolidateAccounting() {
-    const acc = {
-        judgedNoAction: 0,
-        failedChunkMemories: 0,
-        totalChunksFailed: 0,
-        skipReasons: [],
-        skipReasonByRef: new Map(),
-        judgedNoActionRefs: new Set(),
-        pushSkipReason: () => { },
-    };
-    acc.pushSkipReason = (op, ref, reason) => {
-        // 2026-05-27 cross-chunk double-count fix: if `ref` already contributed
-        // to judgedNoAction in its own chunk (a different chunk proposed an op
-        // for it that is now being rejected here), promote it from the
-        // judgedNoAction bucket into the more specific skipReason bucket.
-        // Preserves the invariant: processed == actioned + judgedNoAction +
-        // Σ(skipReasons) + failedChunkMemories.
-        if (acc.judgedNoActionRefs.delete(ref))
-            acc.judgedNoAction--;
-        const existing = acc.skipReasonByRef.get(ref);
-        if (existing) {
-            // Already counted once for accounting. Append the extra skip to the
-            // ref's grouped entry for observability without adding a new array
-            // entry (which would break the accounting invariant).
-            existing.skips.push({ op, reason });
-            return;
-        }
-        const entry = { ref, skips: [{ op, reason }] };
-        acc.skipReasonByRef.set(ref, entry);
-        acc.skipReasons.push(entry);
-    };
-    return acc;
+function pushSkipReason(acc, op, ref, reason) {
+    if (acc.judgedNoActionRefs.delete(ref))
+        acc.judgedNoAction--;
+    const existing = acc.skipReasonByRef.get(ref);
+    if (existing) {
+        // One entry per ref keeps the invariant; the extra reason is kept for observability.
+        existing.skips.push({ op, reason });
+        return;
+    }
+    const entry = { ref, skips: [{ op, reason }] };
+    acc.skipReasonByRef.set(ref, entry);
+    acc.skipReasons.push(entry);
 }
 function resolveConsolidationSourceOwner(opts, stashDir) {
     const targetRoot = path.resolve(opts.writeTarget?.source.path ?? stashDir);
     try {
         const sources = resolveSourceEntries(stashDir, opts.config);
-        const installations = deriveInstallations(sources);
         const targetIndex = sources.findIndex((source) => path.resolve(source.path) === targetRoot);
-        const target = installations[targetIndex];
+        const target = deriveInstallations(sources)[targetIndex];
         if (!target)
             return undefined;
         return {
@@ -570,872 +397,511 @@ function resolveConsolidationSourceOwner(opts, stashDir) {
         return undefined;
     }
 }
+const mtimeMsOf = (memory) => {
+    try {
+        return fs.statSync(memory.filePath).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+};
 /**
- * Read and narrow the exact pool the live pass consumes, without embedding,
- * LLM, proposal, event, or asset writes. Used by both preview and execution.
+ * The exact pool the live pass consumes, with no embedding, model call or
+ * write: on-disk eligible memories, minus those the ledger holds, narrowed
+ * incrementally, minus bodies already in `knowledge/`, capped to `limit`
+ * (oldest-modified first). Shared by preview and execution.
  */
-export function inspectConsolidationPool(opts, stashDir, warnings, access) {
+export function inspectConsolidationPool(opts, stashDir, warnings, existingKnowledgeBodyHashes = new Set(), access) {
     const readOnly = access?.readOnly === true;
-    const sourceOwner = resolveConsolidationSourceOwner(opts, stashDir);
-    let memories = loadMemoriesForSource(sourceOwner, warnings, readOnly);
+    let memories = loadMemoriesForSource(resolveConsolidationSourceOwner(opts, stashDir), warnings, readOnly);
     const staleCount = memories.filter((memory) => !fs.existsSync(memory.filePath)).length;
     if (staleCount > 0) {
         warnings.push(`Pre-flight: filtered ${staleCount} stale DB entr${staleCount === 1 ? "y" : "ies"} (file absent on disk) from memory pool before chunking.`);
     }
     memories = memories.filter((memory) => fs.existsSync(memory.filePath));
     const poolSize = memories.length;
-    if (opts.incrementalSince && memories.length > 0) {
-        memories = narrowToIncrementalCandidates(memories, opts.incrementalSince, warnings, opts.neighborsPerChanged, readOnly);
+    // A memory judged within its revisit window comes back once it is edited.
+    const ledger = loadLedgerSnapshot({ proposalsCtx: opts.proposalsCtx, readOnly }, stashDir, ["consolidate"]);
+    if (ledger.size > 0) {
+        const nowIso = new Date().toISOString();
+        memories = memories.filter((memory) => {
+            const row = ledger.get(ledgerKey("consolidate", conceptIdFromTypeName("memory", memory.name)));
+            let changedAt;
+            try {
+                changedAt = fs.statSync(memory.filePath).mtime.toISOString();
+            }
+            catch {
+                changedAt = undefined;
+            }
+            return !row || !isLedgerBlocked(row, nowIso, changedAt);
+        });
     }
+    const judgedUnchanged = poolSize - memories.length;
+    // Only what retrieval returned or new material improve never processed (#986).
+    const retrievalScope = loadRetrievalScope({ proposalsCtx: opts.proposalsCtx, readOnly }, stashDir);
+    const beforeScope = memories.length;
+    memories = memories.filter((memory) => isInRetrievalScope(retrievalScope, conceptIdFromTypeName("memory", memory.name), memory.filePath));
+    const outsideRetrievalScope = beforeScope - memories.length;
     const dedupPoolSize = memories.length;
     if (opts.limit === undefined && memories.length > 150) {
         warnings.push(`Consolidation: pool has ${memories.length} memories and no limit is set. Consider adding a limit to your consolidate config to prevent timeouts on slow LLM endpoints.`);
     }
-    if (opts.limit !== undefined && memories.length > opts.limit) {
-        const mtimeOf = (memory) => {
+    // Before the limit, so the cap picks from memories the run can act on.
+    let prefilteredAlreadyPromoted = 0;
+    if (existingKnowledgeBodyHashes.size > 0) {
+        memories = memories.filter((memory) => {
+            let raw;
             try {
-                return fs.statSync(memory.filePath).mtimeMs;
+                raw = fs.readFileSync(memory.filePath, "utf8");
             }
             catch {
-                return 0;
+                return true;
             }
-        };
-        const mtimeCache = new Map(memories.map((memory) => [memory.filePath, mtimeOf(memory)]));
-        memories = [...memories].sort((a, b) => (mtimeCache.get(a.filePath) ?? 0) - (mtimeCache.get(b.filePath) ?? 0));
+            const duplicate = existingKnowledgeBodyHashes.has(contentHash(raw, "body"));
+            if (duplicate)
+                prefilteredAlreadyPromoted++;
+            return !duplicate;
+        });
+    }
+    if (opts.limit !== undefined && memories.length > opts.limit) {
+        const mtimes = new Map(memories.map((memory) => [memory.filePath, mtimeMsOf(memory)]));
+        memories = [...memories].sort((a, b) => (mtimes.get(a.filePath) ?? 0) - (mtimes.get(b.filePath) ?? 0));
         warnings.push(`Consolidation: pool capped at ${opts.limit} of ${memories.length} memories (limit option, oldest-modified first).`);
         memories = memories.slice(0, opts.limit);
     }
-    return { poolSize, candidatePoolSize: memories.length, dedupPoolSize, memories };
-}
-/**
- * Pass 1 — narrow the memory pool before any LLM work: drop stale DB entries,
- * apply incremental-since narrowing, and cap to `opts.limit` (oldest-modified
- * first). Returns an early envelope when the pool empties at any stage;
- * otherwise returns the narrowed pool and the state the plan/apply passes
- * consume. Behavior-identical to the former inlined narrowing block.
- */
-async function narrowConsolidationPool(opts, stashDir, startMs, warnings) {
-    const snapshot = inspectConsolidationPool(opts, stashDir, warnings);
-    const memories = snapshot.memories;
-    // (The former WS-3b Step 0a homeostatic demotion pass was removed — R4:
-    // it was default-off and self-undoing (the next salience recompute
-    // unconditionally overwrote the demoted values). Continuous decay now lives
-    // in computeSalience's recency term, whose floor decays on a long half-life.)
-    if (memories.length === 0) {
-        return {
-            done: true,
-            result: makeConsolidateResult({
-                dryRun: opts.dryRun ?? false,
-                target: opts.target ?? stashDir,
-                warnings,
-                durationMs: Date.now() - startMs,
-            }),
-        };
-    }
-    return { done: false, memories, dedupPoolSize: snapshot.dedupPoolSize };
-}
-/**
- * Pass 2 — turn the narrowed pool into an executable plan. Sizes chunks to the
- * model context window, clusters by embedding similarity, injects the
- * anti-collapse random fraction, applies the cold-start budget cap, runs the
- * per-chunk LLM calls (with retry + failure-rate abort), and reconciles the
- * per-chunk op arrays via {@link mergePlans}. Populates `accounting` in place.
- * Behavior-identical to the former inlined plan-generation block.
- */
-/**
- * Per-chunk judgedNoAction accounting: count memories the LLM saw inside a chunk
- * but proposed no op for. Membership is by `memory:<name>` ref against the
- * targets of each op (primary + secondaries for merge; ref otherwise). 2026-05-26:
- * pre-fix this was a 78/119 (66%) silent drop in the cron run — no warning,
- * event, or counter. See tuning investigation §Q2. Moved verbatim.
- */
-function recordChunkJudgedNoAction(chunk, ops, accounting) {
-    const targetRefs = new Set();
-    for (const op of ops) {
-        if (op.op === "merge") {
-            targetRefs.add(op.primary);
-            for (const s of op.secondaries)
-                targetRefs.add(s);
-        }
-        else {
-            targetRefs.add(op.ref);
-        }
-    }
-    let chunkNoAction = 0;
-    for (const m of chunk) {
-        const memRef = conceptIdFromTypeName("memory", m.name);
-        if (!targetRefs.has(memRef)) {
-            chunkNoAction++;
-            accounting.judgedNoActionRefs.add(memRef);
-        }
-    }
-    accounting.judgedNoAction += chunkNoAction;
+    return {
+        poolSize,
+        candidatePoolSize: memories.length,
+        dedupPoolSize,
+        memories,
+        prefilteredAlreadyPromoted,
+        judgedUnchanged,
+        outsideRetrievalScope,
+    };
 }
+const ABORT_MIN_CHUNKS = 4;
+const ABORT_FAILURE_RATE = 0.5;
 /**
- * Per-chunk LLM judge loop — the heart of plan generation. Iterates the sized
- * chunks, applies the budget-abort/failure-rate/all-hot guards, calls the model
- * (with one retry), validates the returned ops, and accumulates the per-chunk
- * judgedNoAction accounting. Extracted verbatim from `planConsolidation`: the
- * abort-rate policy, all-hot early-exit, and the 2026-05-26 accounting invariant
- * (`processed == actioned + judgedNoAction + Σ(skipReasons) + failedChunkMemories`)
- * are byte-identical, and every counter-increment point is unmoved.
+ * The chunk loop: stop cleanly on the budget signal, abort once ≥50% of at
+ * least 4 chunks failed (the model is likely down), skip an all-hot chunk
+ * without a call (the only thing the model could do with it is refused), and
+ * count every memory into exactly one accounting bucket.
  */
 async function judgeConsolidationChunks(args) {
-    const { chunks, opts, config, llmRunner, lease, sourceName, bodyTruncation, pendingProposalBodyHashes, standardsContext, warnings, accounting, } = args;
-    const chunkOpsArrays = [];
-    // judgedNoAction tracks memories the LLM saw inside a chunk but proposed
-    // no op for. Computed per chunk as `chunk.length − unique(targetRefs in ops)`.
-    // The structured skip-reason histogram (2026-05-26) plus the cross-chunk
-    // double-count fixes now live on `accounting`; every deterministic post-LLM
-    // op rejection site calls `accounting.pushSkipReason`. See
-    // `/tmp/akm-health-investigations/tuning-reasons-investigation.md` §Q2.
-    // C-6 / #392: Replace two-consecutive-failures abort with failure-rate threshold.
-    // Consecutive-count policies are brittle against transient LM Studio reloads:
-    // two transient failures abort the run even though the next chunk would succeed.
-    // Rate-based abort (≥50% failure over ≥4 chunks) is more robust.
-    // Tanenbaum, Distributed Systems §8 — rate-based policies with minimum sample sizes.
-    let totalChunksProcessed = 0;
-    const ABORT_MIN_CHUNKS = 4;
-    const ABORT_FAILURE_RATE = 0.5;
+    const { chunks, opts, config, warnings, acc } = args;
+    const llmRunner = opts.llmRunner ?? undefined;
+    const memRef = (m) => conceptIdFromTypeName("memory", m.name);
+    const failChunk = (message, chunk) => {
+        warn(message);
+        warnings.push(message);
+        acc.totalChunksFailed++;
+        acc.failedChunkMemories += chunk.length;
+    };
+    const skipRemaining = (from) => {
+        for (let i = from; i < chunks.length; i++)
+            acc.failedChunkMemories += chunks[i].length;
+    };
+    const planned = [];
+    let processed = 0;
     for (let chunkIdx = 0; chunkIdx < chunks.length; chunkIdx++) {
-        // Budget-signal check: break cleanly before the next LLM call if the
-        // caller's budget has been exhausted. Commits work done so far.
+        const label = `chunk ${chunkIdx + 1}`;
         if (opts.signal?.aborted) {
-            const skipped = chunks.length - chunkIdx;
-            const msg = `[consolidate] budget signal aborted before chunk ${chunkIdx + 1}/${chunks.length}; ${skipped} chunk(s) not processed (partial_timeout — work done so far committed).`;
+            const msg = `[consolidate] budget signal aborted before chunk ${chunkIdx + 1}/${chunks.length}; ${chunks.length - chunkIdx} chunk(s) not processed (partial_timeout — work done so far committed).`;
             warn(msg);
             warnings.push(msg);
-            // Account for memories in unprocessed chunks.
-            for (let i = chunkIdx; i < chunks.length; i++) {
-                accounting.failedChunkMemories += chunks[i].length;
-            }
+            skipRemaining(chunkIdx);
             break;
         }
-        // Abort if failure rate >= 50% over at least 4 processed chunks.
-        if (totalChunksProcessed >= ABORT_MIN_CHUNKS) {
-            const failureRate = accounting.totalChunksFailed / totalChunksProcessed;
+        if (processed >= ABORT_MIN_CHUNKS) {
+            const failureRate = acc.totalChunksFailed / processed;
             if (failureRate >= ABORT_FAILURE_RATE) {
-                const skipped = chunks.length - chunkIdx;
-                const abortMsg = `Consolidation aborted — failure rate ${(failureRate * 100).toFixed(0)}% over ${totalChunksProcessed} chunks (>= ${ABORT_FAILURE_RATE * 100}% threshold). LLM may be unavailable. ${skipped} chunk(s) skipped.`;
-                warn(abortMsg);
-                warnings.push(abortMsg);
-                // Account for memories in chunks we never attempted: they are
-                // neither judgedNoAction (no plan parsed) nor skipReason (no op
-                // rejected). Without this, the accounting invariant fails by
-                // `Σ(unattempted_chunk.length)` whenever the abort fires.
-                for (let i = chunkIdx; i < chunks.length; i++) {
-                    accounting.failedChunkMemories += chunks[i].length;
-                }
+                const msg = `Consolidation aborted — failure rate ${(failureRate * 100).toFixed(0)}% over ${processed} chunks (>= ${ABORT_FAILURE_RATE * 100}% threshold). LLM may be unavailable. ${chunks.length - chunkIdx} chunk(s) skipped.`;
+                warn(msg);
+                warnings.push(msg);
+                skipRemaining(chunkIdx);
                 break;
             }
         }
         const chunk = chunks[chunkIdx];
-        // All-hot chunk early-exit. The per-prompt hot-list block (see
-        // buildChunkPrompt) only *discourages* delete proposals on a mixed chunk;
-        // when EVERY memory in the chunk is captureMode: hot, the only ops the LLM
-        // could ever propose are deletes — all of which the downstream guard
-        // refuses unconditionally. Calling the model is therefore pure token waste.
-        // Skip the request entirely and bucket every memory as judgedNoAction (we
-        // judged "no action" without spending an LLM call), preserving the
-        // accounting invariant `processed == actioned + judgedNoAction +
-        // Σ(skipReasons) + failedChunkMemories`. Not counted toward the
-        // LLM-failure-rate abort policy — no request was attempted.
         if (chunk.length > 0 && chunk.every((m) => isHotCapturedMemory(m.filePath))) {
-            for (const m of chunk)
-                accounting.judgedNoActionRefs.add(conceptIdFromTypeName("memory", m.name));
-            accounting.judgedNoAction += chunk.length;
+            for (const m of chunk) {
+                acc.judgedNoActionRefs.add(memRef(m));
+                acc.judgedRefs.add(memRef(m));
+            }
+            acc.judgedNoAction += chunk.length;
             warn(`[consolidate] chunk ${chunkIdx + 1}/${chunks.length}: all ${chunk.length} memories are captureMode: hot — skipping LLM (judged no-action).`);
             continue;
         }
         warn(`[consolidate] chunk ${chunkIdx + 1}/${chunks.length} (${chunk.length} memories) …`);
-        const userPrompt = buildChunkPrompt(sourceName, chunk, chunkIdx, chunks.length, bodyTruncation, pendingProposalBodyHashes, standardsContext);
-        // Single chunk LLM call, wrapped in the feature gate. Deduplicated across
-        // the first attempt and the retry below (the two blocks were byte-identical
-        // apart from their fallback error string). responseSchema lift (PR 1,
-        // asset-writers-investigation §5): providers with `supportsJsonSchema: true`
-        // enforce the shape upstream; others fall through to
-        // `parseEmbeddedJsonResponse` on the response side.
-        const callChunkLlm = async (fallbackError) => {
-            // The gate runs with enabled:true (always open), so this guard is
-            // exactly the envelope the gated fn used to return first thing.
-            if (!llmRunner)
-                return { ok: false, error: "No LLM configured for consolidation" };
-            return callStructured({
-                feature: "memory_consolidation",
-                akmConfig: config,
-                enabled: true,
-                runner: llmRunner,
-                ...(lease ? { lease } : {}),
-                messages: [
-                    { role: "system", content: CONSOLIDATE_SYSTEM_PROMPT },
-                    { role: "user", content: userPrompt },
-                ],
-                request: {
-                    responseSchema: CONSOLIDATE_PLAN_JSON_SCHEMA,
-                    enableThinking: false,
-                    timeoutMs: llmRunner.timeoutMs,
-                    signal: opts.signal,
-                },
-                parse: (raw) => ({ ok: true, content: raw ?? "" }),
-                // A transport throw was caught INSIDE the gated fn and returned as an
-                // {ok:false} envelope (never reaching the gate's fallback); onError
-                // reproduces that. The fallback fires only on wrapper timeout.
-                onError: (_cls, e) => ({ ok: false, error: String(e) }),
-                fallback: { ok: false, error: fallbackError },
-                ...(opts.onNotices ? { onNotices: opts.onNotices } : {}),
-            });
-        };
-        // callChunkLlm already retries once internally (llm/client.ts's
-        // chatCompletion, jittered 200-800ms backoff) — a second, outer retry
-        // here stacked an uncoordinated fixed 2s backoff on top of it. Removed;
-        // only mark the chunk failed once the single retry the client already
-        // performs has been exhausted.
-        const raw = await callChunkLlm(`chunk ${chunkIdx + 1} failed`);
-        if (!raw.ok) {
-            warn(raw.error ?? `chunk ${chunkIdx + 1} failed`);
-            warnings.push(raw.error ?? `chunk ${chunkIdx + 1} failed`);
-            totalChunksProcessed++;
-            accounting.totalChunksFailed++;
-            // Account for the chunk's memories under the failed-chunk bucket.
-            // judgedNoAction does NOT run on this path (it's after the success
-            // guards) so without this the accounting invariant breaks on every
-            // chunk-level transport/parse failure.
-            accounting.failedChunkMemories += chunk.length;
+        processed++;
+        if (!llmRunner) {
+            failChunk("No LLM configured for consolidation", chunk);
             continue;
         }
-        // C9 action 1: AKM_DEBUG_LLM was a separate, undocumented env var for this
-        // one diagnostic; folded into the standard AKM_VERBOSE gate (warnVerbose)
-        // rather than kept as its own toggle.
-        {
-            const preview = (raw.content ?? "").slice(0, 500);
-            warnVerbose(`[akm:consolidate] chunk ${chunkIdx + 1} raw response (first 500 chars): ${preview}`);
+        // The transport already retries once; a failed chunk is not retried here.
+        const outcome = await callStage({
+            feature: "memory_consolidation",
+            runner: llmRunner,
+            system: consolidateSystemPrompt,
+            prompt: buildChunkPrompt(args.sourceName, chunk, chunkIdx, chunks.length, args.bodyTruncation, args.pendingProposalBodyHashes),
+            gate: { config, enabled: true },
+            request: {
+                responseSchema: CONSOLIDATE_PLAN_JSON_SCHEMA,
+                enableThinking: false,
+                timeoutMs: llmRunner.timeoutMs,
+                signal: opts.signal,
+            },
+            ...(opts.onNotices ? { onNotices: opts.onNotices } : {}),
+        });
+        if (!outcome.ok) {
+            failChunk(outcome.reason === "error" && outcome.error ? outcome.error : `${label} failed`, chunk);
+            continue;
         }
-        const parsed = parseEmbeddedJsonResponse(raw.content);
+        warnVerbose(`[akm:consolidate] ${label} raw response (first 500 chars): ${outcome.raw.slice(0, 500)}`);
+        const parsed = parseEmbeddedJsonResponse(outcome.raw);
         if (!parsed || !Array.isArray(parsed.operations)) {
-            const hint = raw.content !== undefined && raw.content.trim() === ""
-                ? " (empty response — if using a thinking model, disable thinking mode)"
-                : "";
-            warn(`Chunk ${chunkIdx + 1}: invalid plan from AI — skipping.${hint}`);
-            warnings.push(`Chunk ${chunkIdx + 1}: invalid plan from AI — skipping.${hint}`);
-            totalChunksProcessed++;
-            accounting.totalChunksFailed++;
-            accounting.failedChunkMemories += chunk.length;
+            const hint = outcome.raw.trim() === "" ? " (empty response — if using a thinking model, disable thinking mode)" : "";
+            const msg = `Chunk ${chunkIdx + 1}: invalid plan from AI — skipping.${hint}`;
+            warn(msg);
+            warnings.push(msg);
+            acc.totalChunksFailed++;
+            acc.failedChunkMemories += chunk.length;
             continue;
         }
-        totalChunksProcessed++; // success
         const ops = [];
         for (const op of parsed.operations) {
-            if (isValidOp(op)) {
+            if (isValidOp(op))
                 ops.push(op);
-            }
-            else {
+            else
                 warnings.push(`Chunk ${chunkIdx + 1}: skipping invalid operation: ${JSON.stringify(op)}`);
-            }
         }
-        if (Array.isArray(parsed.warnings)) {
-            for (const w of parsed.warnings) {
-                if (typeof w === "string")
-                    warnings.push(w);
-            }
+        for (const w of Array.isArray(parsed.warnings) ? parsed.warnings : [])
+            if (typeof w === "string")
+                warnings.push(w);
+        // Memories the model saw but proposed nothing for.
+        const targeted = new Set(ops.map((op) => op.ref));
+        for (const m of chunk) {
+            acc.judgedRefs.add(memRef(m));
+            if (targeted.has(memRef(m)))
+                continue;
+            acc.judgedNoAction++;
+            acc.judgedNoActionRefs.add(memRef(m));
         }
-        recordChunkJudgedNoAction(chunk, ops, accounting);
-        chunkOpsArrays.push(ops);
+        planned.push(ops);
     }
-    return chunkOpsArrays;
+    return planned;
 }
-async function planConsolidation(opts, config, stashDir, _startMs, memories, warnings, sharedStateDb, accounting) {
-    // Consolidation always uses the HTTP LLM client directly — never the agent
-    // CLI. The agent CLI is for interactive agent sessions (reflect, propose);
-    // structured JSON generation works better and faster via HTTP.
-    //
-    // The outer invocation freezes standalone and improve-owned selection once.
+/**
+ * The model's plan for the narrowed pool: chunk size from the context window,
+ * an up-front cap when the remaining budget cannot cover every chunk (oldest
+ * first, the rest deferred), similarity clustering, anti-collapse, then the
+ * chunk loop.
+ */
+async function planConsolidation(opts, config, stashDir, memories, warnings, stateDb, acc) {
     const llmRunner = opts.llmRunner ?? undefined;
-    // Chunk sizing: derive a safe chunk size from the configured model context
-    // window so that the full prompt (system prompt + chunk user prompt) never
-    // exceeds the model's n_ctx limit.  When no context length is configured we
-    // fall back to DEFAULT_CONTEXT_LENGTH_TOKENS (8 000) which is conservative
-    // enough for most 8K–16K local models.
-    //
-    // bodyTruncation caps the body excerpt included per memory in the prompt.
-    // Reducing it further than 500 chars degrades consolidation quality, so we
-    // keep it fixed and let computeSafeChunkSize vary the number of memories
-    // per chunk instead.
+    // 500 body chars per memory keep the judgement useful; chunk size varies instead.
     const bodyTruncation = 500;
-    const modelContextLength = llmRunner?.connection.contextLength ?? DEFAULT_CONTEXT_LENGTH_TOKENS;
-    const chunkSize = computeSafeChunkSize(modelContextLength, bodyTruncation, opts.maxChunkSize);
-    // -- Phase A: plan generation -----------------------------------------------
+    const chunkSize = computeSafeChunkSize(llmRunner?.connection.contextLength ?? DEFAULT_CONTEXT_LENGTH_TOKENS, bodyTruncation, opts.maxChunkSize);
     const sourceName = opts.target ?? stashDir;
-    let budgetedMemories = memories;
-    if (opts.signal) {
-        const budgetMs = opts.signal.remainingBudgetMs;
-        if (budgetMs !== undefined) {
-            const p90Chunk = opts.p90ChunkSecondsDefault ?? 30;
-            const safeChunks = Math.max(0, Math.floor((Math.max(0, budgetMs) / 1000 / p90Chunk) * 0.6));
-            const cap = safeChunks * chunkSize;
-            if (cap < memories.length) {
-                budgetedMemories = memories
-                    .map((entry) => {
-                    let mtimeMs = 0;
-                    try {
-                        mtimeMs = fs.statSync(entry.filePath).mtimeMs;
-                    }
-                    catch {
-                        // Missing files sort first and are filtered by the existing guards.
-                    }
-                    return { entry, mtimeMs };
-                })
-                    .sort((a, b) => a.mtimeMs - b.mtimeMs || a.entry.name.localeCompare(b.entry.name))
-                    .map(({ entry }) => entry)
-                    .slice(0, cap);
-                const msg = `[consolidate] cold-start budget: reducing pool from ${memories.length} to ${budgetedMemories.length} memories (${safeChunks} safe chunks; remainder deferred).`;
-                warn(msg);
-                warnings.push(msg);
-            }
-        }
-    }
-    // WS-5: capture llmPoolSize after every pre-LLM cap.
-    const llmPoolSize = budgetedMemories.length;
-    const dispatchingChunks = [];
-    for (let i = 0; i < budgetedMemories.length; i += chunkSize) {
-        const chunk = budgetedMemories.slice(i, i + chunkSize);
-        if (chunk.length > 0 && !chunk.every((memory) => isHotCapturedMemory(memory.filePath))) {
-            dispatchingChunks.push(chunk);
+    let budgeted = memories;
+    const budgetMs = opts.signal?.remainingBudgetMs;
+    if (opts.signal && budgetMs !== undefined) {
+        const safeChunks = Math.max(0, Math.floor((Math.max(0, budgetMs) / 1000 / (opts.p90ChunkSecondsDefault ?? 30)) * 0.6));
+        if (safeChunks * chunkSize < memories.length) {
+            budgeted = [...memories]
+                .sort((a, b) => mtimeMsOf(a) - mtimeMsOf(b) || a.name.localeCompare(b.name))
+                .slice(0, safeChunks * chunkSize);
+            const msg = `[consolidate] cold-start budget: reducing pool from ${memories.length} to ${budgeted.length} memories (${safeChunks} safe chunks; remainder deferred).`;
+            warn(msg);
+            warnings.push(msg);
         }
     }
-    const dispatchLease = llmRunner && dispatchingChunks.length > 0 ? await preflightStructuredLlmRunner(llmRunner) : undefined;
-    try {
-        // C-1 / #380: Pre-cluster memories by embedding similarity before chunking.
-        // This ensures that semantically similar memories land in the same LLM
-        // context window, allowing the model to detect and merge duplicates that
-        // would otherwise be split across chunks and survive indefinitely.
-        // mem0 arXiv:2504.19413, A-MEM arXiv:2502.12110.
-        // Fails open: if embeddings are unavailable or fail, original order is used.
-        const { ordered: clusteredMemories, embedTelemetry } = await clusterMemoriesBySimilarity(budgetedMemories, config, sharedStateDb, opts.signal);
-        // WS-3b Anti-collapse step 8c: inject random (non-similar) clusters.
-        // A small fraction (default 5%) of the pool is shuffled into random positions
-        // so the pipeline isn't PURELY similarity-driven. This prevents rich-get-richer
-        // entrenchment where only the most-retrieved assets ever get consolidated.
-        // DEFAULT ON since R5 — opt out via antiCollapse.enabled: false.
-        let finalClusteredMemories = clusteredMemories;
-        {
-            const antiCollapseForCluster = getImproveProcessConfig("consolidate", opts.improveProfile)?.antiCollapse ??
-                {};
-            if (antiCollapseForCluster.enabled !== false && clusteredMemories.length > 2) {
-                const fraction = antiCollapseForCluster.randomClusterFraction ?? DEFAULT_RANDOM_CLUSTER_FRACTION;
-                const randomCount = Math.max(1, Math.floor(clusteredMemories.length * fraction));
-                // Pick `randomCount` positions to inject random (un-clustered) members.
-                // Use a seeded-ish shuffle: sort by hash of the name so it's deterministic
-                // per run but not strictly similarity-driven.
-                const shuffled = [...clusteredMemories].sort((a, b) => {
-                    // Deterministic shuffle: compare sha256-ish (use name hash as proxy).
-                    const ha = a.name.split("").reduce((acc, c) => ((acc << 5) - acc + c.charCodeAt(0)) | 0, 0);
-                    const hb = b.name.split("").reduce((acc, c) => ((acc << 5) - acc + c.charCodeAt(0)) | 0, 0);
-                    return ha - hb;
-                });
-                const randomSlice = shuffled.slice(0, randomCount);
-                const randomSet = new Set(randomSlice.map((m) => m.name));
-                // Insert random members at intervals through the clustered sequence.
-                const withRandom = [];
-                const interval = Math.max(2, Math.floor(clusteredMemories.length / randomCount));
-                let randomIdx = 0;
-                for (let i = 0; i < clusteredMemories.length; i++) {
-                    const m = clusteredMemories[i];
-                    if (m && !randomSet.has(m.name))
-                        withRandom.push(m);
-                    if (i > 0 && i % interval === 0 && randomIdx < randomSlice.length) {
-                        const r = randomSlice[randomIdx++];
-                        if (r)
-                            withRandom.push(r);
-                    }
-                }
-                // Append any remaining random members not yet inserted.
-                while (randomIdx < randomSlice.length) {
-                    const r = randomSlice[randomIdx++];
-                    if (r)
-                        withRandom.push(r);
-                }
-                finalClusteredMemories = withRandom;
-                warnings.push(`Anti-collapse: injected ${randomCount} random (non-similarity-driven) cluster member(s) into consolidation pool (fraction=${fraction}).`);
-            }
-        }
-        const chunks = [];
-        for (let i = 0; i < finalClusteredMemories.length; i += chunkSize) {
-            chunks.push(finalClusteredMemories.slice(i, i + chunkSize));
-        }
-        // 2026-05-27 prompt-context fix: precompute body-hashes of pending
-        // consolidate proposals once, so the per-chunk prompt can annotate
-        // memories whose body would just produce a deterministic
-        // `dedup_pending_proposal` skip. Cuts ~110 wasted LLM proposals per
-        // 4h on this user's stack. See
-        // /tmp/akm-health-investigations/tuning-reasons-investigation.md §Q3.
-        const pendingProposalBodyHashes = loadPendingConsolidateProposalHashes(stashDir);
-        warn(`[consolidate] ${budgetedMemories.length} memories / ${chunks.length} chunk(s) / chunk_size=${chunkSize}` +
-            ` / pending-proposal hashes: ${pendingProposalBodyHashes.size}`);
-        // Consolidate output merges memories (non-wiki) → stash authoring standards.
-        // Resolved ONCE per run and passed to each chunk prompt (facts not re-read
-        // per chunk).
-        const standardsContext = resolveStandardsContext("memories/_consolidated", stashDir);
-        const chunkOpsArrays = await judgeConsolidationChunks({
-            chunks,
-            opts,
-            config,
-            llmRunner,
-            lease: dispatchLease,
-            sourceName,
-            bodyTruncation,
-            pendingProposalBodyHashes,
-            standardsContext,
-            warnings,
-            accounting,
-        });
-        // Build the known-refs set from the already-filtered memory pool so
-        // mergePlans() can reject LLM-hallucinated primary refs before execution.
-        const knownRefs = new Set(budgetedMemories.map((m) => conceptIdFromTypeName("memory", m.name)));
-        const { ops: allOps, warnings: mergeWarnings } = mergePlans(chunkOpsArrays, knownRefs);
-        warnings.push(...mergeWarnings);
-        return {
-            allOps,
-            totalChunks: chunks.length,
-            llmPoolSize,
-            deferredMemories: memories.length - budgetedMemories.length,
-            embedTelemetry,
-            sourceName,
-        };
-    }
-    finally {
-        if (dispatchLease)
-            disposeLoweredExecutionDispatchLease(dispatchLease);
-    }
+    const slice = (list) => Array.from({ length: Math.ceil(list.length / chunkSize) }, (_, i) => list.slice(i * chunkSize, (i + 1) * chunkSize));
+    const willDispatch = slice(budgeted).some((chunk) => chunk.length > 0 && !chunk.every((memory) => isHotCapturedMemory(memory.filePath)));
+    if (llmRunner && willDispatch)
+        assertRunnerCredentials(llmRunner);
+    const { ordered, embedTelemetry } = await clusterMemoriesBySimilarity(budgeted, config, stateDb, opts.signal);
+    const chunks = slice(injectRandomClusterMembers(ordered, opts.improveProfile, warnings));
+    const pendingProposalBodyHashes = loadPendingConsolidateProposalHashes(stashDir);
+    warn(`[consolidate] ${budgeted.length} memories / ${chunks.length} chunk(s) / chunk_size=${chunkSize}` +
+        ` / pending-proposal hashes: ${pendingProposalBodyHashes.size}`);
+    const planned = await judgeConsolidationChunks({
+        chunks,
+        opts,
+        config,
+        sourceName,
+        bodyTruncation,
+        pendingProposalBodyHashes,
+        warnings,
+        acc,
+    });
+    return {
+        allOps: mergePlans(planned),
+        totalChunks: chunks.length,
+        llmPoolSize: budgeted.length,
+        deferredMemories: memories.length - budgeted.length,
+        embedTelemetry,
+        sourceName,
+    };
 }
-async function akmConsolidateInner(opts, config, stashDir, startMs, warnings, sharedStateDb) {
-    // -- Pass 1: narrow the memory pool (may early-return an envelope) ----------
-    const narrowed = await narrowConsolidationPool(opts, stashDir, startMs, warnings);
-    if (narrowed.done)
-        return narrowed.result;
-    const { memories, dedupPoolSize } = narrowed;
-    // -- Pass 2: build the LLM plan (populates the shared accounting counters) ---
-    const accounting = createConsolidateAccounting();
-    const { allOps, totalChunks, llmPoolSize, deferredMemories, embedTelemetry, sourceName } = await planConsolidation(opts, config, stashDir, startMs, memories, warnings, sharedStateDb, accounting);
-    // -- Dry-run: show AI plan without executing any writes --------------------
-    if (opts.dryRun) {
+async function consolidate(opts, config, stashDir, startMs, stateDb) {
+    const warnings = [];
+    const existingKnowledgeBodyHashes = opts.existingKnowledgeBodyHashes ?? loadExistingKnowledgeBodyHashes(stashDir);
+    const pool = inspectConsolidationPool(opts, stashDir, warnings, existingKnowledgeBodyHashes);
+    const { memories, prefilteredAlreadyPromoted } = pool;
+    const plural = (n) => `memor${n === 1 ? "y" : "ies"}`;
+    if (pool.judgedUnchanged > 0) {
+        warnings.push(`Consolidation: skipped ${pool.judgedUnchanged} ${plural(pool.judgedUnchanged)} judged within the revisit window and unchanged since.`);
+    }
+    if (pool.outsideRetrievalScope > 0) {
+        warnings.push(`Consolidation: skipped ${pool.outsideRetrievalScope} ${plural(pool.outsideRetrievalScope)} already judged that retrieval has not returned in the last ${USAGE_EVENT_RETENTION_DAYS} days.`);
+    }
+    if (prefilteredAlreadyPromoted > 0) {
+        warnings.push(`Consolidation: pre-filtered ${prefilteredAlreadyPromoted} ${plural(prefilteredAlreadyPromoted)} whose body already exists verbatim in knowledge/ before chunking.`);
+    }
+    const target = opts.target ?? stashDir;
+    // The pair pass (alpha.9) has its own initiator/candidate selection (it
+    // sees .derived memories, flat knowledge and lessons, not just the
+    // promote pool above), so it runs regardless of whether the promote pool
+    // is empty — every return path below carries its result.
+    const pairPassBundleId = resolveConsolidationSourceOwner(opts, stashDir)?.bundleId;
+    const pairPass = await runConsolidatePairPass(opts, config, stashDir, pairPassBundleId, warnings);
+    if (memories.length === 0) {
         return makeConsolidateResult({
-            dryRun: true,
-            previewOnly: true,
-            target: sourceName,
-            processed: llmPoolSize,
-            failedChunks: accounting.totalChunksFailed,
-            totalChunks,
-            judgedNoAction: accounting.judgedNoAction,
-            skipReasons: accounting.skipReasons,
-            // No merge has executed on the preview path — the per-secondary tally is
-            // provably still 0 here (it only increments in the op-execution loop).
-            mergedSecondaries: 0,
-            failedChunkMemories: accounting.failedChunkMemories,
-            deferredMemories,
-            planned: allOps,
+            dryRun: opts.dryRun ?? false,
+            target,
             warnings,
             durationMs: Date.now() - startMs,
+            prefilteredAlreadyPromoted,
+            pairPass,
         });
     }
-    warn(`[consolidate] plan: ${allOps.length} operation(s)`);
-    // Destructive operations remain advisory. Promote is safe to execute because
-    // it emits a reviewable proposal rather than mutating an asset.
-    const promoted = [];
-    const promotionFailures = { count: 0 };
-    const memoryByRef = new Map(memories.map((memory) => [conceptIdFromTypeName("memory", memory.name), memory]));
-    const promoteContext = {
+    const acc = {
+        judgedNoAction: 0,
+        failedChunkMemories: 0,
+        totalChunksFailed: 0,
+        skipReasons: [],
+        skipReasonByRef: new Map(),
+        judgedNoActionRefs: new Set(),
+        judgedRefs: new Set(),
+    };
+    const plan = await planConsolidation(opts, config, stashDir, memories, warnings, stateDb, acc);
+    // Evaluated at return time: a promotion skip can move a ref out of judgedNoAction.
+    const summary = () => ({
+        target: plan.sourceName,
+        processed: plan.llmPoolSize,
+        failedChunks: acc.totalChunksFailed,
+        totalChunks: plan.totalChunks,
+        judgedNoAction: acc.judgedNoAction,
+        skipReasons: acc.skipReasons,
+        mergedSecondaries: 0,
+        failedChunkMemories: acc.failedChunkMemories,
+        deferredMemories: plan.deferredMemories,
+        planned: plan.allOps,
+        warnings,
+        prefilteredAlreadyPromoted,
+        durationMs: Date.now() - startMs,
+    });
+    if (opts.dryRun)
+        return makeConsolidateResult({ ...summary(), dryRun: true, previewOnly: true, pairPass });
+    warn(`[consolidate] plan: ${plan.allOps.length} operation(s)`);
+    const ctx = {
         config,
         stashDir,
         sourceRun: opts.sourceRun ?? `consolidate-${startMs}`,
         proposalsCtx: opts.proposalsCtx,
         target: opts.writeTarget,
-        memoryByRef,
-        promoted,
+        memoryByRef: new Map(memories.map((memory) => [conceptIdFromTypeName("memory", memory.name), memory])),
+        promoted: [],
         promotedSourceRefs: new Set(),
-        existingKnowledgeBodyHashes: loadExistingKnowledgeBodyHashes(opts.writeTarget.source.path),
-        promotionFailures,
+        existingKnowledgeBodyHashes,
+        promotionFailures: { count: 0 },
         warnings,
-        pushSkipReason: accounting.pushSkipReason,
-        llmRunner: opts.llmRunner ?? null,
+        pushSkipReason: (op, ref, reason) => pushSkipReason(acc, op, ref, reason),
     };
-    for (const op of allOps) {
-        if (op.op === "promote")
-            await emitPromotionProposal(op, promoteContext);
-    }
+    for (const op of plan.allOps)
+        await emitPromotionProposal(op, ctx);
+    // Every other judged memory waits out its revisit window (or its next edit);
+    // a promotion that failed to persist is retried next run.
+    recordLedgerAttempt({ proposalsCtx: opts.proposalsCtx }, [...acc.judgedRefs]
+        .filter((ref) => !ctx.promotedSourceRefs.has(ref) &&
+        !acc.skipReasonByRef.get(ref)?.skips.some((skip) => skip.reason === "promote_create_failed"))
+        .map((ref) => ({ stashDir, ref, source: "consolidate", outcome: "judged_no_action" })));
     return makeConsolidateResult({
-        target: sourceName,
-        processed: llmPoolSize,
-        failedChunks: accounting.totalChunksFailed,
-        totalChunks,
-        judgedNoAction: accounting.judgedNoAction,
-        skipReasons: accounting.skipReasons,
-        mergedSecondaries: 0,
-        failedChunkMemories: accounting.failedChunkMemories,
-        deferredMemories,
-        promoted,
-        failedPromotions: promotionFailures.count,
-        planned: allOps,
-        warnings,
-        durationMs: Date.now() - startMs,
+        ...summary(),
+        promoted: ctx.promoted,
+        failedPromotions: ctx.promotionFailures.count,
+        pairPass,
         perfTelemetry: {
-            dedupPoolSize,
-            llmPoolSize,
-            embedMs: embedTelemetry.embedMs,
-            embedCacheHits: embedTelemetry.cacheHits,
-            embedCacheMisses: embedTelemetry.cacheMisses,
+            dedupPoolSize: pool.dedupPoolSize,
+            llmPoolSize: plan.llmPoolSize,
+            embedMs: plan.embedTelemetry.embedMs,
+            embedCacheHits: plan.embedTelemetry.cacheHits,
+            embedCacheMisses: plan.embedTelemetry.cacheMisses,
         },
     });
 }
-/** Reject a promotion when its body already exists in knowledge or the queue. */
-function shouldSkipPromotionBodyDuplicate(args) {
-    const { bodyHash, op, knowledgeRef, ctx } = args;
-    if (ctx.existingKnowledgeBodyHashes.has(bodyHash)) {
-        ctx.warnings.push(`Skipping promote: identical body already exists in knowledge; skipping duplicate for ${op.ref} → ${knowledgeRef}`);
-        ctx.pushSkipReason("promote", op.ref, "dedup_existing_knowledge");
-        return true;
+/** The conceptId a ref maps to, or undefined for an invalid ref. */
+function conceptIdForRef(ref) {
+    try {
+        const p = parseRefInput(ref);
+        return conceptIdFromTypeName(p.type, p.name);
+    }
+    catch {
+        return undefined;
     }
-    const contentDupProposal = listProposals(ctx.stashDir, { status: "pending" })
-        .filter((proposal) => proposal.source === "consolidate")
-        .find((proposal) => cacheHash(proposalContent(proposal)) === bodyHash);
-    if (!contentDupProposal)
-        return false;
-    ctx.warnings.push(`Skipping promote: identical body already pending as proposal ${contentDupProposal.id} (ref: ${contentDupProposal.ref}); skipping duplicate for ${op.ref} → ${knowledgeRef}`);
-    ctx.pushSkipReason("promote", op.ref, "dedup_pending_proposal");
-    return true;
 }
-/** Execute one reconciled promotion by emitting a reviewable proposal. */
-/** @internal Executes the real proposal-emission path for one promote operation. */
+/** A slug with dates, counters and word order folded away, for spotting variants. */
+function normalizeSlugForDedup(ref) {
+    const monthRe = /(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i;
+    return parseRefInput(ref)
+        .name.toLowerCase()
+        .split("-")
+        .filter((tok) => tok.length > 0 && !/^\d+$/.test(tok) && !monthRe.test(tok))
+        .sort()
+        .join("-");
+}
+const PROMOTE_BODY_MIN_CHARS = 100;
+/**
+ * Queue one promotion as a proposal. Refused (with a skip reason) when the
+ * memory is unknown, already promoted this run, already pending or present
+ * as knowledge (by concept, body hash or slug variant), unreadable, fails
+ * sanitization, is superseded, has a body too small to be knowledge, or has
+ * no valid description.
+ * @internal Exported for promotion-path integration tests.
+ */
 export async function emitPromotionProposal(op, ctx) {
-    const { config, stashDir, sourceRun, target, memoryByRef, warnings, pushSkipReason, promoted, promotedSourceRefs } = ctx;
-    const entry = memoryByRef.get(op.ref);
+    const { stashDir, target, warnings, pushSkipReason } = ctx;
+    const entry = ctx.memoryByRef.get(op.ref);
     if (!entry) {
+        // A phantom ref was never counted as processed, so it gets no skip reason.
         warnings.push(`Promote: ${op.ref} not found in loaded memories — skipping.`);
-        // Phantom ref: not in processed, so no skipReason (same rationale as
-        // delete_ref_missing above).
         return;
     }
-    // Within-run source-ref dedup: skip if this source memory was already
-    // promoted earlier in this run (safety belt — mergePlans already
-    // deduplicates promote ops by source ref via Map, but this guard also
-    // catches any future code paths that bypass mergePlans).
-    if (promotedSourceRefs.has(op.ref)) {
-        warnings.push(`Skipping promote: ${op.ref} already promoted in this run`);
-        pushSkipReason("promote", op.ref, "promote_already_promoted_this_run");
-        return;
+    const skip = (reason, message) => {
+        warnings.push(message);
+        pushSkipReason("promote", op.ref, reason);
+    };
+    if (ctx.promotedSourceRefs.has(op.ref)) {
+        return skip("promote_already_promoted_this_run", `Skipping promote: ${op.ref} already promoted in this run`);
     }
-    const proposedName = op.knowledgeRef.split("/").filter(Boolean).at(-1) ??
+    const slug = (op.knowledgeRef.split("/").filter(Boolean).at(-1) ??
         entry.name.split("/").filter(Boolean).at(-1) ??
-        "promoted-memory";
-    const slug = proposedName
+        "promoted-memory")
         .replace(/[^a-z0-9-]/gi, "-")
         .replace(/-+/g, "-")
         .replace(/^-|-$/g, "")
         .toLowerCase();
     const knowledgeRef = conceptIdFromTypeName("knowledge", slug);
-    parseRefInput(knowledgeRef);
-    if (knowledgeRef !== op.knowledgeRef) {
+    const parsedKnowledgeRef = parseRefInput(knowledgeRef);
+    if (knowledgeRef !== op.knowledgeRef)
         warnings.push(`Normalized generated ref "${op.knowledgeRef}" → "${knowledgeRef}"`);
+    const pending = listProposals(stashDir, { status: "pending" });
+    const wantConcept = conceptIdForRef(knowledgeRef);
+    if (wantConcept !== undefined && pending.some((p) => conceptIdForRef(p.ref) === wantConcept)) {
+        return skip("promote_pending_proposal_exists", `Skipping promote: pending proposal already exists for ${knowledgeRef}`);
     }
-    // A pending proposal may carry a qualified item_ref, so compare its parsed
-    // conceptId rather than exact display spelling.
-    if (hasPendingProposalForConcept(stashDir, knowledgeRef)) {
-        warnings.push(`Skipping promote: pending proposal already exists for ${knowledgeRef}`);
-        pushSkipReason("promote", op.ref, "promote_pending_proposal_exists");
-        return;
-    }
-    // Idempotency: check if knowledge asset already exists
-    const parsedKnowledgeRef = parseRefInput(knowledgeRef);
-    const destPath = path.join(target.source.path, "knowledge", `${parsedKnowledgeRef.name}.md`);
-    if (fs.existsSync(destPath)) {
-        warnings.push(`Skipping promote: ${knowledgeRef} already exists in source`);
-        pushSkipReason("promote", op.ref, "promote_already_exists");
-        return;
+    if (fs.existsSync(path.join(target.source.path, "knowledge", `${parsedKnowledgeRef.name}.md`))) {
+        return skip("promote_already_exists", `Skipping promote: ${knowledgeRef} already exists in source`);
     }
-    let memoryContent = "";
+    let memoryContent;
     try {
         memoryContent = fs.readFileSync(entry.filePath, "utf8");
     }
     catch (e) {
-        warnings.push(`Promote: could not read ${op.ref}: ${String(e)}`);
-        pushSkipReason("promote", op.ref, "promote_read_failed");
-        return;
+        return skip("promote_read_failed", `Promote: could not read ${op.ref}: ${String(e)}`);
+    }
+    // O1 hash nit: the RAW body, before sanitization — accept re-reads the
+    // source with a plain fs.readFileSync and never re-sanitizes, so hashing
+    // anything else here would compare two different representations of the
+    // same unedited memory and report a false "changed since mint" (measured:
+    // 3 of 767 real memories sanitize to different bytes than their raw body).
+    const sourceRawBodyHash = contentHash(memoryContent, "body");
+    const sanitized = sanitizeMergedContent(memoryContent);
+    if (!sanitized.ok) {
+        return skip("promote_sanitization_failed", `Promote: rejected ${op.ref} — source memory failed sanitization (${sanitized.reason}).`);
+    }
+    memoryContent = sanitized.result.content;
+    if (hasSupersededStatus(sanitized.result.frontmatter)) {
+        return skip("promote_superseded", `Promote: refused for ${op.ref} → ${knowledgeRef} — source memory has status:superseded; superseded memories are not promotable knowledge.`);
     }
-    // Validate and normalize source content before proposing a promoted asset.
-    const promoteSanitized = sanitizeMergedContent(memoryContent);
-    if (!promoteSanitized.ok) {
-        warnings.push(`Promote: rejected ${op.ref} — source memory failed sanitization (${promoteSanitized.reason}).`);
-        pushSkipReason("promote", op.ref, "promote_sanitization_failed");
-        return;
-    }
-    memoryContent = promoteSanitized.result.content;
-    // SOURCE_SUPERSEDED guard: refuse to promote a memory whose source
-    // frontmatter carries `status: superseded`. Predicate at module top
-    // (`hasSupersededStatus`) so tests can exercise it directly.
-    if (hasSupersededStatus(promoteSanitized.result.frontmatter)) {
-        warnings.push(`Promote: refused for ${op.ref} → ${knowledgeRef} — source memory has status:superseded; superseded memories are not promotable knowledge.`);
-        pushSkipReason("promote", op.ref, "promote_superseded");
-        return;
-    }
-    // Parse the source memory up-front so the body/frontmatter checks below
-    // share the same parsed view.
     const parsedMemory = parseFrontmatter(memoryContent);
-    // Reject sources whose body is too small to make useful knowledge.
-    // Observed failure: memory files whose body is literally a tags string
-    // ("discord,notification,send-notification") get promoted to knowledge
-    // proposals that no reviewer would accept. Threshold is conservative —
-    // 100 chars catches single-line tag dumps without rejecting genuinely
-    // terse but valid notes.
-    const PROMOTE_BODY_MIN_CHARS = 100;
     const sourceBody = parsedMemory.content.trim();
     if (sourceBody.length < PROMOTE_BODY_MIN_CHARS) {
-        warnings.push(`Promote: rejected ${op.ref} → ${knowledgeRef} — source memory body is too small (${sourceBody.length} chars; need ≥${PROMOTE_BODY_MIN_CHARS}) to make useful knowledge.`);
-        pushSkipReason("promote", op.ref, "promote_source_too_small");
-        return;
+        return skip("promote_source_too_small", `Promote: rejected ${op.ref} → ${knowledgeRef} — source memory body is too small (${sourceBody.length} chars; need ≥${PROMOTE_BODY_MIN_CHARS}) to make useful knowledge.`);
+    }
+    // The body is the load-bearing content: twins that differ only in
+    // bookkeeping frontmatter, or an earlier run's differently-slugged proposal,
+    // are the same promotion.
+    const bodyHash = contentHash(memoryContent, "body");
+    if (ctx.existingKnowledgeBodyHashes.has(bodyHash)) {
+        return skip("dedup_existing_knowledge", `Skipping promote: identical body already exists in knowledge; skipping duplicate for ${op.ref} → ${knowledgeRef}`);
+    }
+    const pendingConsolidate = listProposals(stashDir, { status: "pending" }).filter((p) => p.source === "consolidate");
+    const sameBody = pendingConsolidate.find((p) => contentHash(proposalContent(p), "body") === bodyHash);
+    if (sameBody) {
+        return skip("dedup_pending_proposal", `Skipping promote: identical body already pending as proposal ${sameBody.id} (ref: ${sameBody.ref}); skipping duplicate for ${op.ref} → ${knowledgeRef}`);
     }
-    // Cross-run + within-run content dedup: if an identical body already
-    // exists in ANY pending consolidate proposal (regardless of target ref),
-    // skip. This prevents duplicate proposals when:
-    //   (a) Multiple source memories have identical bodies but differ only
-    //       in noise frontmatter (`inferenceProcessed: true` twin alongside
-    //       the original; differing `updated:` timestamps; etc.) — the body
-    //       is the load-bearing content, so dedup must hash on body only.
-    //   (b) A prior run created a proposal for the same body under a
-    //       different knowledgeRef slug.
-    // Use cacheHash (case-preserving stripped body) to match the canonical
-    // hash domain used by the body-embedding cache and pending-proposal set.
-    const bodyHash = cacheHash(sourceBody);
-    if (shouldSkipPromotionBodyDuplicate({ bodyHash, op, knowledgeRef, ctx }))
-        return;
     try {
-        // Use LLM-provided description; fall back to memory's own description
-        // (post-sanitization frontmatter is authoritative).
         const description = (typeof op.description === "string" && op.description.trim()
             ? op.description.trim()
             : parsedMemory.data?.description?.trim()) ?? "";
-        // Validate the resolved frontmatter before emitting a proposal.
-        // Required field: non-empty description. Reject obvious truncation
-        // markers (description ends with `,`/`;`/`:`/`...`/hanging connector)
-        // so the queue never sees half-formed metadata that the reviewer
-        // would only reject.
         const fmCheck = validateProposalFrontmatter({ description });
         if (!fmCheck.ok) {
-            warnings.push(`Promote: rejected ${op.ref} → ${knowledgeRef} — ${fmCheck.reason}.`);
-            pushSkipReason("promote", op.ref, "promote_invalid_frontmatter");
-            return;
+            return skip("promote_invalid_frontmatter", `Promote: rejected ${op.ref} → ${knowledgeRef} — ${fmCheck.reason}.`);
         }
-        // Merge `description` INTO the body's YAML frontmatter so it lands in
-        // the on-disk asset when the proposal is accepted. The descriptionQuality
-        // validator parses `payload.content` body (not the envelope
-        // `payload.frontmatter`), and a memory's native frontmatter has
-        // `captureMode`/`beliefState`/etc. but never `description` — without
-        // this merge, 60+ pending proposals were blocked at accept-time with
-        // MISSING_FRONTMATTER_DESCRIPTION even though the envelope had it.
-        // (The body-frontmatter assumption baked into the 2026-05-20 comment
-        // below was wrong: body fm and envelope fm only converge when the
-        // writer explicitly merges them, which it now does.)
-        const mergedBodyFm = {
+        // The description goes into the body frontmatter, which accept-time validation reads.
+        const xrefs = Array.isArray(parsedMemory.data?.xrefs) ? parsedMemory.data.xrefs.map(String) : [];
+        const mergedFrontmatter = {
             ...(parsedMemory.data ?? {}),
             description,
-            xrefs: promoteProvenanceXrefs(parsedMemory.data?.xrefs, op.ref),
+            xrefs: [...new Set([...xrefs, op.ref].map(canonicalXref))],
         };
-        const serializedMergedFm = serializeFrontmatter(mergedBodyFm);
-        const promotedAssetContent = assembleAssetFromString(serializedMergedFm, parsedMemory.content);
-        // Pre-emit dedup against pending consolidate proposals from the
-        // same improve run (slug-variant match). The cross-run content-hash
-        // dedup inside `mergePlans` handles duplicates against existing
-        // stash assets — see commit history for the deletion of the
-        // unbounded embedding + cross-type slug branches.
-        const dedup = await checkPreEmitDedup({
-            candidateRef: knowledgeRef,
-            candidateText: `${description}. ${memoryContent}`,
-            stashDir,
-            config,
-        });
-        if (dedup.duplicate) {
-            warnings.push(`Promote: skipped ${op.ref} → ${knowledgeRef} — ${dedup.reason}.`);
-            pushSkipReason("promote", op.ref, "promote_dedup_window");
-            return;
+        const normalized = normalizeSlugForDedup(knowledgeRef);
+        const variant = pendingConsolidate.find((p) => normalizeSlugForDedup(p.ref) === normalized);
+        if (variant) {
+            return skip("promote_dedup_window", `Promote: skipped ${op.ref} → ${knowledgeRef} — slug-variant of pending proposal ${variant.id} (${variant.ref}).`);
         }
-        const proposalResult = emitProposal({ stashDir, proposalsCtx: ctx.proposalsCtx }, {
+        const proposal = mintProposal(stashDir, ctx.proposalsCtx, {
             ref: knowledgeRef,
             target: { source: target.source.name, root: target.source.path },
             source: "consolidate",
-            sourceRun,
-            // §23.6 fingerprint model-id term (WI-6.4).
-            ...(ctx.llmRunner?.connection.model ? { modelId: ctx.llmRunner.connection.model } : {}),
+            sourceRun: ctx.sourceRun,
             payload: {
-                content: promotedAssetContent,
+                content: assembleAssetFromString(serializeFrontmatter(mergedFrontmatter), parsedMemory.content),
                 frontmatter: { description, xrefs: [canonicalXref(op.ref)] },
             },
             ...(typeof op.confidence === "number" ? { confidence: op.confidence } : {}),
+            // The ledger keys the attempt by the source memory.
+            attemptedRefs: [op.ref],
+            // O1 (alpha.9): on accept, promoteProposal retires this source memory
+            // (and its .derived twin) so promotion no longer leaves a duplicate.
+            promotionSource: op.ref,
+            // B3: recorded so accept can refuse to archive a source that was
+            // edited after this promotion was queued — the RAW body hash (see
+            // sourceRawBodyHash's own comment above), not `bodyHash`, which is the
+            // sanitized-for-knowledge representation accept never re-derives.
+            promotionSourceHash: sourceRawBodyHash,
         });
-        if (isProposalSkipped(proposalResult)) {
-            warnings.push(`Promote: skipped proposal for ${op.ref} (${proposalResult.reason}): ${proposalResult.message}`);
-            pushSkipReason("promote", op.ref, `promote_proposal_${proposalResult.reason}`);
-        }
-        else {
-            promoted.push(proposalResult.id);
-            promotedSourceRefs.add(op.ref);
-        }
+        ctx.promoted.push(proposal.id);
+        ctx.promotedSourceRefs.add(op.ref);
     }
     catch (e) {
         ctx.promotionFailures.count++;
-        warnings.push(`Promote: createProposal failed for ${op.ref}: ${String(e)}`);
-        pushSkipReason("promote", op.ref, "promote_create_failed");
+        skip("promote_create_failed", `Promote: createProposal failed for ${op.ref}: ${String(e)}`);
     }
 }
-// ── Helpers ─────────────────────────────────────────────────────────────────
-/**
- * Normalise a knowledge slug for variant-aware deduplication. Collapses:
- *   - date suffixes (`-may-2026`, `-2026-05-03`, `-2026`)
- *   - numeric counter suffixes (`-2`, `-3`)
- *   - trailing -patterns / -2026-05-03 styles
- *   - word reorderings via alphabetical sort of the remaining tokens.
- *
- * Two slugs that normalise to the same string are considered the same asset
- * for dedup purposes even if they don't share an exact ref.
- */
-/** The conceptId a proposal ref maps to, or undefined for an invalid ref. */
-function conceptIdForRef(ref) {
-    try {
-        const p = parseRefInput(ref);
-        return conceptIdFromTypeName(p.type, p.name);
-    }
-    catch {
-        return undefined;
-    }
-}
-/** Is a pending proposal already queued for `conceptRef`'s concept? */
-function hasPendingProposalForConcept(stashDir, conceptRef) {
-    const want = conceptIdForRef(conceptRef);
-    return (want !== undefined && listProposals(stashDir, { status: "pending" }).some((p) => conceptIdForRef(p.ref) === want));
-}
-function normalizeSlugForDedup(ref) {
-    const slug = parseRefInput(ref).name;
-    const monthRe = /(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i;
-    const tokens = slug
-        .toLowerCase()
-        .split("-")
-        .filter((tok) => tok.length > 0)
-        // Strip purely-numeric tokens (years, dates, counter suffixes like -2 / -3).
-        // Numbers carry no semantic information for our dedup purposes — every
-        // observed defective slug variant differs only in dates or counters.
-        .filter((tok) => !/^\d+$/.test(tok))
-        .filter((tok) => !monthRe.test(tok));
-    // Sort to absorb word reorderings.
-    tokens.sort();
-    return tokens.join("-");
-}
-/**
- * Pre-emit dedup check: compare the candidate ref against pending consolidate
- * proposals only. Returns a reason string if a slug-variant match is found,
- * else null.
- *
- * Historical context (REMOVED 2026-05-20): this function previously also ran
- *   (a) a normalised-slug match against existing knowledge AND memory entries
- *       in the DB, and
- *   (b) an embedding cosine-similarity check (>= 0.85) against ALL knowledge
- *       and non-derived memory entries.
- * Both branches had ZERO observed fires across 30 sampled runs in the
- * post-fix window. The 29 actual dedup catches all came from the SEPARATE
- * content-hash dedup inside `mergePlans` (the older SHA-256 helper). The
- * embedding branch in particular had unbounded cost per promote (embedded
- * every knowledge + non-derived memory entry, every time) with no observed
- * benefit. Empirical signal → deleted.
- *
- * What remains: a check against pending consolidate proposals in the SAME
- * improve run. This catches duplicates queued back-to-back within a single
- * improve invocation — a different concern from the cross-run content-hash
- * dedup, and cheap (no embeddings, no DB query).
- */
-async function checkPreEmitDedup(opts) {
-    const normCandidate = normalizeSlugForDedup(opts.candidateRef);
-    // Pending consolidate proposals (slug match) — within the same improve run.
-    const pendingConsolidate = listProposals(opts.stashDir, { status: "pending" }).filter((p) => p.source === "consolidate");
-    for (const p of pendingConsolidate) {
-        if (normalizeSlugForDedup(p.ref) === normCandidate) {
-            return { duplicate: true, reason: `slug-variant of pending proposal ${p.id} (${p.ref})` };
-        }
-    }
-    return { duplicate: false };
-}
-/**
- * Incremental candidate set: {changed} ∪ {top-k persisted-vector neighbours of
- * each changed memory}, intersected with the loaded pool. Returns [] when
- * nothing changed (caller emits a no-op envelope), the full pool when
- * everything changed or the index can't answer (fail-open to preserve merge
- * correctness). `since` is an ISO timestamp.
- */
-export function narrowToIncrementalCandidates(memories, since, warnings, neighborsPerChanged = 5, readOnly = false) {
-    // Lenient by design: garbage `since` passes through unchanged and the ISO
-    // string comparison below then selects nothing (see core/time.ts doc).
-    const sinceIso = parseSinceToIsoLenient(since);
-    const isChanged = (m) => {
-        try {
-            return fs.statSync(m.filePath).mtime.toISOString() > sinceIso;
-        }
-        catch {
-            return true; // never silently drop a memory we cannot stat
-        }
-    };
-    const changed = memories.filter(isChanged);
-    if (changed.length === 0)
-        return [];
-    if (changed.length === memories.length)
-        return memories;
-    const byName = new Map(memories.map((m) => [m.name, m]));
-    const keep = new Set(changed.map((m) => m.name));
-    let db;
-    try {
-        db = readOnly ? openReadonlyExistingDatabase(undefined, { isolatedSnapshot: true }) : openExistingDatabase();
-        if (!db)
-            return memories;
-        for (const m of changed) {
-            const id = findEntryIdByRef(db, conceptIdFromTypeName("memory", m.name));
-            if (id === undefined)
-                continue;
-            for (const hit of getNeighborsByEntryId(db, id, neighborsPerChanged + 1)) {
-                if (hit.id === id)
-                    continue;
-                const entry = getEntryById(db, hit.id);
-                if (!entry)
-                    continue;
-                const name = entry.entry.name;
-                if (byName.has(name))
-                    keep.add(name); // only neighbours present in the loaded pool
-            }
-        }
-    }
-    catch {
-        warnings.push("Incremental consolidation: index unavailable — processing full pool.");
-        return memories;
-    }
-    finally {
-        if (db)
-            closeDatabase(db);
-    }
-    const candidates = memories.filter((m) => keep.has(m.name));
-    warnings.push(`Incremental consolidation: ${changed.length} changed + neighbours → ${candidates.length}/${memories.length} memories considered (since ${since}${sinceIso !== since ? ` = ${sinceIso}` : ""}).`);
-    return candidates;
-}
+/** The target bundle's eligible memories from the index, else walked from disk. */
 function loadMemoriesForSource(source, warnings, readOnly) {
-    // Load from DB first
     let memories = [];
     let db;
     try {
         db = readOnly ? openReadonlyExistingDatabase(undefined, { isolatedSnapshot: true }) : openExistingDatabase();
         if (!db)
             throw new Error("index unavailable");
-        const entries = getAllEntries(db, "memory");
-        memories = entries
-            .filter((entry) => source !== undefined && entry.bundleId === source.bundleId)
-            .filter((e) => isConsolidationEligibleMemoryName(e.entry.name))
-            // Skip stale DB entries whose file was deleted by a prior run but not yet
-            // re-indexed. Without this guard the deleted file's ref appears in chunks
-            // sent to the LLM, which then proposes a second delete → delete_failed
-            // because the file is already gone. Re-indexing runs on a cron cadence so
-            // several successful deletes can accumulate before the DB catches up.
-            .filter((e) => fs.existsSync(e.filePath))
+        memories = getAllEntries(db, "memory")
+            .filter((e) => source !== undefined && e.bundleId === source.bundleId)
+            .filter((e) => isConsolidationEligibleMemoryName(e.entry.name) && fs.existsSync(e.filePath))
             .map((e) => ({
             name: e.entry.name,
             filePath: e.filePath,
@@ -1451,34 +917,30 @@ function loadMemoriesForSource(source, warnings, readOnly) {
         if (db)
             closeDatabase(db);
     }
-    if (memories.length === 0 && source) {
-        // DB fallback: walk filesystem
-        const memoriesDir = path.join(source.sourceRoot, "memories");
-        const fsStashDir = source.sourceRoot;
-        if (fs.existsSync(memoriesDir)) {
-            const pending = [memoriesDir];
-            while (pending.length > 0) {
-                const current = pending.pop();
-                for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
-                    const filePath = path.join(current, entry.name);
-                    if (entry.isDirectory()) {
-                        if (source.excludedSourceRoots.has(path.resolve(filePath)))
-                            continue;
+    if (memories.length > 0 || !source)
+        return memories;
+    const memoriesDir = path.join(source.sourceRoot, "memories");
+    if (fs.existsSync(memoriesDir)) {
+        const pending = [memoriesDir];
+        while (pending.length > 0) {
+            const current = pending.pop();
+            for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+                const filePath = path.join(current, entry.name);
+                if (entry.isDirectory()) {
+                    if (!source.excludedSourceRoots.has(path.resolve(filePath)))
                         pending.push(filePath);
-                        continue;
-                    }
-                    if (!entry.isFile() || !entry.name.endsWith(".md"))
-                        continue;
-                    const name = path.relative(memoriesDir, filePath).replace(/\.md$/, "").split(path.sep).join("/");
-                    if (!isConsolidationEligibleMemoryName(name))
-                        continue;
-                    memories.push({ name, filePath, description: "", tags: [], stashDir: fsStashDir });
+                    continue;
+                }
+                if (!entry.isFile() || !entry.name.endsWith(".md"))
+                    continue;
+                const name = path.relative(memoriesDir, filePath).replace(/\.md$/, "").split(path.sep).join("/");
+                if (isConsolidationEligibleMemoryName(name)) {
+                    memories.push({ name, filePath, description: "", tags: [], stashDir: source.sourceRoot });
                 }
             }
         }
-        if (memories.length > 0) {
-            warnings.push("DB not found or empty — loaded memories directly from filesystem.");
-        }
     }
+    if (memories.length > 0)
+        warnings.push("DB not found or empty — loaded memories directly from filesystem.");
     return memories;
 }