akm-cli 0.9.0-rc.0 → 0.9.0-rc.13

package/dist/commands/improve/consolidate.js

@@ -4,58 +4,47 @@
 import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import readline from "node:readline";
 import consolidateSystemPrompt from "../../assets/prompts/consolidate-system.md" with { type: "text" };
-import { parseAssetRef } from "../../core/asset/asset-ref.js";
+import { detectAdapterId } from "../../core/adapter/detect-adapter.js";
 import { assembleAssetFromString, serializeFrontmatter } from "../../core/asset/asset-serialize.js";
 import { parseFrontmatter } from "../../core/asset/frontmatter.js";
-import { resolveStashDir, timestampForFilename } from "../../core/common.js";
-import { getDefaultLlmConfig, getImproveProcessConfig, loadConfig } from "../../core/config/config.js";
-import { ConfigError } from "../../core/errors.js";
-// Note: appendEvent import removed (WS-3a: archive TTL machinery retired)
+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 { resolveStashStandards } from "../../core/standards/resolve-stash-standards.js";
-import { detectTruncatedDescription } from "../../core/text-truncation.js";
-import { DURATION_UNITS, parseDuration } from "../../core/time.js";
-import { createProposal, isProposalSkipped, listProposals } from "../proposal/repository.js";
-import { hasSupersededStatus, MERGE_ABSOLUTE_FLOOR_CHARS, MERGE_SHRINK_RATIO_MIN, validateProposalFrontmatter, } from "../proposal/validators/proposal-quality-validators.js";
-import { checkGenerationGuard, checkLexicalDiversity, checkMergeInformationFloor, computeMergedGeneration, readAssetGeneration, } from "./anti-collapse.js";
-import { cacheHash, runDeterministicDedup, stripFrontmatterBody } from "./dedup.js";
-import { shouldSkipHotProbationInLlm } from "./hot-probation.js";
-import { writeContradictEdge } from "./memory/memory-belief.js";
-// Re-export the moved helpers so existing test imports continue to resolve.
-export { hasSupersededStatus, validateProposalFrontmatter };
-import { openStateDatabase, withStateDb } from "../../core/state-db.js";
-import { warn } from "../../core/warn.js";
-import { commitWriteTargetBoundary, deleteAssetFromSource, resolveWriteTarget, writeAssetToSource, } from "../../core/write-source.js";
-import { closeDatabase, findEntryIdByRef, getAllEntries, getEntryById, getNeighborsByEntryId, openExistingDatabase, } from "../../indexer/db/db.js";
-import { resolveImproveProcessRunnerFromProfile, runnerIsLlm } from "../../integrations/agent/runner.js";
-import { chatCompletion } from "../../llm/client.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 { getDefaultLlmConfig } from "../../integrations/agent/engine-resolution.js";
+import { materializeLlmRunnerConnection, resolveImproveProcessRunner } from "../../integrations/agent/runner.js";
 import { cosineSimilarity, embedBatch, resolveEmbeddingModelId } from "../../llm/embedder.js";
-import { isLlmFeatureEnabled, tryLlmFeature } from "../../llm/feature-gate.js";
-import { getConsolidationJudgedMap, upsertConsolidationJudged, } from "../../storage/repositories/consolidation-repository.js";
+import { callStructured } from "../../llm/structured-call.js";
 import { getBodyEmbeddings, upsertBodyEmbeddings } from "../../storage/repositories/embeddings-repository.js";
+import { closeDatabase, openExistingDatabase } 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, proposalContent } from "../proposal/repository.js";
+import { hasSupersededStatus, validateProposalFrontmatter } from "../proposal/validators/proposal-quality-validators.js";
+import { cacheHash } from "./content-hash.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.
-// Imported for internal use by the orchestrator and re-exported for importers.
 import { buildChunkPrompt, computeSafeChunkSize, DEFAULT_CONTEXT_LENGTH_TOKENS } from "./consolidate/chunking.js";
-export { buildChunkPrompt, computeSafeChunkSize, DEFAULT_CONTEXT_LENGTH_TOKENS } from "./consolidate/chunking.js";
-// LLM-output sanitization (pure string/frontmatter transforms) lives in
-// ./consolidate/sanitize. Imported for internal use + re-exported for importers.
-import { normalizeUpdatedField, sanitizeMergedContent } from "./consolidate/sanitize.js";
-export { normalizeUpdatedField, sanitizeMergedContent, stripOuterCodeFence } from "./consolidate/sanitize.js";
-// Eligibility / safety predicates live in ./consolidate/eligibility. Imported
-// for internal guard use; the two public predicates are re-exported.
-import { consolidateGuardStatus, isConsolidationEligibleMemoryName, isHotCapturedMemory, } from "./consolidate/eligibility.js";
-export { isConsolidationEligibleMemoryName, isHotCapturedMemory } from "./consolidate/eligibility.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. Imported for internal use; mergePlans re-exported.
+// ./consolidate/merge.
 import { isValidOp, mergePlans } from "./consolidate/merge.js";
-export { mergePlans } from "./consolidate/merge.js";
+// LLM-output sanitization (pure string/frontmatter transforms) lives in
+// ./consolidate/sanitize.
+import { sanitizeMergedContent } from "./consolidate/sanitize.js";
 // ── Prompts ─────────────────────────────────────────────────────────────────
 const CONSOLIDATE_SYSTEM_PROMPT = consolidateSystemPrompt;
 /**
  * JSON Schema for structured consolidate plans (PR 1 of the asset-writers
- * decision — see knowledge:projects/akm/asset-writers-investigation/00-synthesis).
+ * 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"
@@ -86,6 +75,7 @@ export const CONSOLIDATE_PLAN_JSON_SCHEMA = {
                             secondaries: {
                                 type: "array",
                                 minItems: 1,
+                                maxItems: 1,
                                 items: { type: "string", minLength: 1 },
                             },
                             mergeStrategy: { type: "string", minLength: 1 },
@@ -138,7 +128,7 @@ export const CONSOLIDATE_PLAN_JSON_SCHEMA = {
         },
     },
 };
-async function clusterMemoriesBySimilarity(memories, config, stateDb) {
+async function clusterMemoriesBySimilarity(memories, config, stateDb, signal) {
     const noTelemetry = { embedMs: 0, cacheHits: 0, cacheMisses: 0 };
     if (memories.length < 3 || !config.embedding)
         return { ordered: memories, embedTelemetry: noTelemetry };
@@ -189,7 +179,7 @@ async function clusterMemoriesBySimilarity(memories, config, stateDb) {
     if (missTexts.length > 0) {
         const embedStart = Date.now();
         try {
-            missVecs = await embedBatch(missTexts, config.embedding);
+            missVecs = await embedBatch(missTexts, config.embedding, signal);
         }
         catch {
             // Fail open: embedding failures degrade gracefully to original order.
@@ -275,8 +265,8 @@ async function clusterMemoriesBySimilarity(memories, config, stateDb) {
  * 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 and `computeMemoryContentHash`. Empty set on any read/parse error
- * — fail-safe to "annotate nothing" so the LLM still proposes.
+ * cache. Empty set on any read/parse error — fail-safe to "annotate nothing"
+ * so the LLM still proposes.
  */
 function loadPendingConsolidateProposalHashes(stashDir) {
     const hashes = new Set();
@@ -284,7 +274,7 @@ function loadPendingConsolidateProposalHashes(stashDir) {
         const pending = listProposals(stashDir, { status: "pending" }).filter((p) => p.source === "consolidate");
         for (const p of pending) {
             try {
-                hashes.add(cacheHash(p.payload.content));
+                hashes.add(cacheHash(proposalContent(p)));
             }
             catch {
                 // skip malformed payloads — they can't dedup anyway
@@ -296,210 +286,41 @@ function loadPendingConsolidateProposalHashes(stashDir) {
     }
     return hashes;
 }
-function getJournalPath(stashDir) {
-    return path.join(stashDir, ".akm", "consolidate-journal.json");
-}
-function getBackupDir(stashDir, timestamp) {
-    return path.join(stashDir, ".akm", "consolidate-backup", timestamp);
-}
-function removeStaleJournal(stashDir, journal, warnings) {
-    const journalPath = getJournalPath(stashDir);
-    try {
-        fs.unlinkSync(journalPath);
-    }
-    catch {
-        warnings.push(`Failed to remove stale consolidate journal at ${journalPath}.`);
-    }
-    const backupTimestamp = typeof journal.backupTimestamp === "string" && journal.backupTimestamp.trim().length > 0
-        ? journal.backupTimestamp.trim()
-        : typeof journal.startedAt === "string" && journal.startedAt.trim().length > 0
-            ? journal.startedAt.replace(/[:.]/g, "-")
-            : "";
-    if (!backupTimestamp)
-        return;
-    const backupDir = getBackupDir(stashDir, backupTimestamp);
-    if (!fs.existsSync(backupDir))
-        return;
-    try {
-        fs.rmSync(backupDir, { recursive: true, force: true });
-    }
-    catch {
-        warnings.push(`Failed to remove stale consolidate backup at ${backupDir}.`);
-    }
-    warnings.push(`Cleared stale consolidate backup at ${backupDir}.`);
-}
-function checkForIncompleteJournal(stashDir, recoveryMode, warnings) {
-    const journalPath = getJournalPath(stashDir);
-    if (!fs.existsSync(journalPath))
-        return;
-    let journal;
-    try {
-        journal = JSON.parse(fs.readFileSync(journalPath, "utf8"));
-    }
-    catch {
-        if (recoveryMode === "clean") {
-            try {
-                fs.unlinkSync(journalPath);
-                warnings.push(`Removed unreadable consolidate journal at ${journalPath}.`);
-            }
-            catch {
-                warnings.push(`Failed to remove unreadable consolidate journal at ${journalPath}.`);
-            }
-            return;
-        }
-        throw new ConfigError(`Incomplete consolidation state detected: unreadable journal at ${journalPath}. Re-run with --consolidate-recovery clean to remove stale journal artifacts, or remove the file manually.`, "INVALID_CONFIG_FILE");
-    }
-    const operationCount = Array.isArray(journal.operations) ? journal.operations.length : 0;
-    const completedCount = Array.isArray(journal.completed) ? journal.completed.length : 0;
-    if (completedCount >= operationCount)
-        return;
-    if (recoveryMode === "clean") {
-        removeStaleJournal(stashDir, journal, warnings);
-        warnings.push(`Removed stale consolidation journal at ${journalPath} (${completedCount}/${operationCount} operations completed).`);
-        return;
-    }
-    const backupHint = typeof journal.backupTimestamp === "string" && journal.backupTimestamp.trim().length > 0
-        ? ` Backup dir: ${getBackupDir(stashDir, journal.backupTimestamp.trim())}.`
-        : "";
-    throw new ConfigError(`Incomplete consolidation run detected at ${journalPath} (${completedCount}/${operationCount} operations completed). Re-run with --consolidate-recovery clean to remove stale journal artifacts.${backupHint}`, "INVALID_CONFIG_FILE");
-}
-function writeJournal(stashDir, ops, backupTimestamp) {
-    const journalPath = getJournalPath(stashDir);
-    fs.mkdirSync(path.dirname(journalPath), { recursive: true });
-    const journal = {
-        startedAt: new Date().toISOString(),
-        operations: ops,
-        completed: [],
-        backupTimestamp,
-    };
-    fs.writeFileSync(journalPath, JSON.stringify(journal, null, 2), "utf8");
-}
-function markJournalCompleted(stashDir, opRef) {
-    const journalPath = getJournalPath(stashDir);
-    if (!fs.existsSync(journalPath))
-        return;
-    try {
-        const journal = JSON.parse(fs.readFileSync(journalPath, "utf8"));
-        journal.completed.push(opRef);
-        fs.writeFileSync(journalPath, JSON.stringify(journal, null, 2), "utf8");
-    }
-    catch {
-        // best-effort
-    }
-}
-function cleanupJournal(stashDir, timestamp) {
-    const journalPath = getJournalPath(stashDir);
-    try {
-        fs.unlinkSync(journalPath);
-    }
-    catch {
-        // ignore
-    }
-    const backupDir = getBackupDir(stashDir, timestamp);
-    try {
-        fs.rmSync(backupDir, { recursive: true, force: true });
-    }
-    catch {
-        // ignore
-    }
-}
-function backupFile(filePath, backupDir, name) {
+/** Parse a stored provenance ref and emit its canonical D-R5 display spelling. */
+function canonicalStoredXref(ref) {
     try {
-        fs.mkdirSync(backupDir, { recursive: true });
-        fs.copyFileSync(filePath, path.join(backupDir, `${name}.md`));
+        const p = parseRefInput(ref);
+        return displayRef({ type: p.type, name: p.name, bundleId: p.origin });
     }
     catch {
-        // best-effort
+        return undefined;
     }
 }
-// ── WS-3b: Generation frontmatter injection ───────────────────────────────────
-/**
- * Inject `generation` and `source_refs` into merged content.
- * generation = max(sourceGenerations) + 1.
- * source_refs = UNION of the provided provenance refs (participants + their
- * cited sources) with anything already present in the merged frontmatter —
- * R5 §4.2: the old set-if-absent behavior dropped second-generation
- * provenance whenever the LLM emitted its own (partial) source_refs.
- * Fails open — returns original content if frontmatter can't be parsed.
- */
-function injectGenerationFrontmatter(mergedContent, sourceGenerations, provenanceRefs) {
-    try {
-        const parsed = parseFrontmatter(mergedContent);
-        const existingFm = parsed.data;
-        const existingRefs = Array.isArray(existingFm.source_refs) ? existingFm.source_refs.map(String) : [];
-        const updatedFm = {
-            ...existingFm,
-            generation: computeMergedGeneration(sourceGenerations),
-            source_refs: [...new Set([...existingRefs, ...provenanceRefs])],
-        };
-        return assembleAssetFromString(serializeFrontmatter(updatedFm), parsed.content);
-    }
-    catch {
-        return mergedContent; // fail open
-    }
+function canonicalXref(ref) {
+    return canonicalStoredXref(ref) ?? ref;
 }
-// ── Archive helper (P1-B: soft-invalidation) ─────────────────────────────────
 /**
- * Move a memory asset to `.akm/archive/` with `status: superseded` frontmatter
- * instead of deleting it outright. The live stash delete still happens after
- * this call — this is belt-and-suspenders archival that survives the hard delete.
- *
- * Archive filename: `<iso-ts>-<opIndex>-<basename>.md`
- * New frontmatter fields: status, superseded_at, superseded_by (optional),
- * superseded_reason.
+ * 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 archiveMemory(filePath, stashDir, ref, reason, opIndex, supersededBy, warnings) {
-    const archiveDir = path.join(stashDir, ".akm", "archive");
-    fs.mkdirSync(archiveDir, { recursive: true });
-    let raw;
-    try {
-        raw = fs.readFileSync(filePath, "utf8");
-    }
-    catch {
-        if (warnings)
-            warnings.push(`archiveMemory: could not read ${ref} for archiving — skipping archive write`);
-        return;
-    }
-    let content = raw;
-    try {
-        const parsed = parseFrontmatter(raw);
-        const newFm = {
-            ...parsed.data,
-            status: "superseded",
-            superseded_at: new Date().toISOString(),
-            ...(supersededBy ? { superseded_by: supersededBy } : {}),
-            superseded_reason: reason,
-        };
-        content = assembleAssetFromString(serializeFrontmatter(newFm), parsed.content);
-    }
-    catch {
-        if (warnings)
-            warnings.push(`archiveMemory: could not parse frontmatter for ${ref} — archiving raw`);
-    }
-    const ts = timestampForFilename();
-    const safeName = path.basename(filePath, ".md");
-    const archivePath = path.join(archiveDir, `${ts}-${opIndex}-${safeName}.md`);
-    try {
-        fs.writeFileSync(archivePath, content, "utf8");
-    }
-    catch (e) {
-        if (warnings)
-            warnings.push(`archiveMemory: write failed for ${ref}: ${String(e)}`);
-    }
+function promoteProvenanceXrefs(existing, sourceRef) {
+    const priors = Array.isArray(existing) ? existing.map(String) : [];
+    return [...new Set([...priors, sourceRef].map(canonicalXref))];
 }
 // ── LLM resolution ──────────────────────────────────────────────────────────
 /**
  * Resolve the LLM connection for the consolidate pass.
  *
  * Priority order (mirrors extract / reflect / distill — see
- * `src/commands/extract.ts:421-438` and the canonical
- * `resolveImproveProcessRunnerFromProfile` pattern):
+ * `resolveExtractRunConfig` in `src/commands/improve/extract.ts` and the
+ * canonical `resolveImproveProcessRunner` pattern):
  *
- *   1. `profiles.improve.default.processes.consolidate.profile` (or `mode`)
- *      via {@link resolveImproveProcessRunnerFromProfile}. Lets the user pin
+ *   1. `improve.strategies.<name>.processes.consolidate.engine`
+ *      via {@link resolveImproveProcessRunner}. Lets the user pin
  *      a dedicated model (e.g. `ministral-3b`) for consolidation instead of
- *      whatever `defaults.llm` happens to be.
- *   2. `getDefaultLlmConfig(config)` — the baseline default LLM profile.
+ *      whatever `defaults.llmEngine` happens to be.
+ *   2. `getDefaultLlmConfig(config)` — the baseline default LLM engine.
  *
  * Regression guard (2026-05-26): before this resolver, `akmConsolidate`
  * called `getDefaultLlmConfig` directly and silently ignored a configured
@@ -509,44 +330,11 @@ function archiveMemory(filePath, stashDir, ref, reason, opIndex, supersededBy, w
  * `/tmp/akm-health-investigations/consolidation-no-op.md`.
  */
 function resolveConsolidateLlmConfig(config, activeProfile) {
-    const consolidateProcess = getImproveProcessConfig(config, "consolidate", activeProfile);
-    const runnerSpec = resolveImproveProcessRunnerFromProfile(consolidateProcess, config);
-    if (runnerSpec && runnerIsLlm(runnerSpec)) {
-        return runnerSpec.connection;
-    }
-    // Non-LLM runner modes (agent/sdk) don't apply to consolidate's HTTP path;
-    // fall back to the default LLM profile rather than disabling the pass.
+    const runnerSpec = resolveImproveProcessRunner(activeProfile, "consolidate", config);
+    if (runnerSpec)
+        return materializeLlmRunnerConnection(runnerSpec);
     return getDefaultLlmConfig(config);
 }
-// ── Judged-state cache (#581) ────────────────────────────────────────────────
-/**
- * Stable content hash for a memory file used by the judged-state cache (#581)
- * and the body-embedding cache (WS-3a). Uses `cacheHash` from dedup.ts
- * (sha256 of the case-preserving stripped body) plus the sorted `tags` list,
- * so semantic-metadata drift re-enters the judge while cosmetic frontmatter
- * touches (`updated:`, `inferenceProcessed:`) still hash identically and never
- * force a needless re-judge. Returns `undefined` on any read/parse error so
- * callers fail open (treat the memory as un-cached → it stays in the LLM pool).
- */
-function computeMemoryContentHash(filePath) {
-    try {
-        const raw = fs.readFileSync(filePath, "utf8");
-        let tagSuffix = "";
-        try {
-            const { data } = parseFrontmatter(raw);
-            const tags = Array.isArray(data?.tags) ? data.tags.map(String).sort() : [];
-            if (tags.length > 0)
-                tagSuffix = `\n\u0000tags:${tags.join(",")}`;
-        }
-        catch {
-            // Unparseable frontmatter → body-only hash (prior behaviour).
-        }
-        return cacheHash(raw + tagSuffix);
-    }
-    catch {
-        return undefined;
-    }
-}
 /**
  * Build a {@link ConsolidateResult} from partial overrides, filling the envelope
  * defaults (schemaVersion / ok / shape + the zeroed counters). Collapses the
@@ -571,6 +359,32 @@ export function makeConsolidateResult(overrides) {
     };
 }
 // ── Main entry point ─────────────────────────────────────────────────────────
+function resolveConsolidationWriteTarget(opts, config) {
+    if (opts.writeTarget) {
+        const root = path.resolve(opts.writeTarget.source.path);
+        return {
+            ...opts.writeTarget,
+            source: {
+                ...opts.writeTarget.source,
+                path: root,
+                adapterId: opts.writeTarget.source.adapterId ?? detectAdapterId(root),
+            },
+        };
+    }
+    if (opts.target) {
+        const target = resolveWriteTarget(config, opts.target);
+        return { ...target, source: { ...target.source, path: path.resolve(target.source.path) } };
+    }
+    if (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);
+    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)
@@ -578,16 +392,52 @@ export async function akmConsolidate(opts = {}) {
     // standalone `akm consolidate` gets a self-contained token.
     const sourceRun = opts.sourceRun ?? `consolidate-${startMs}`;
     const config = opts.config ?? loadConfig();
-    const stashDir = opts.stashDir ?? resolveStashDir();
-    if (!isLlmFeatureEnabled(config, "memory_consolidation")) {
+    const writeTarget = resolveConsolidationWriteTarget(opts, config);
+    opts = { ...opts, target: writeTarget.source.name, writeTarget };
+    opts = { ...opts, improveProfile: opts.improveProfile ?? resolveImproveStrategy(undefined, config).config };
+    const stashDir = writeTarget.source.path;
+    // 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). `getLlmConfig`
+    // mirrors `planConsolidation`'s own resolution (`resolveConsolidateLlmConfig`)
+    // verbatim but lazily and independently — nothing calls `ctx.getLlmConfig`
+    // yet this stage, so this never duplicates real work, only the (pure,
+    // side-effect-free) resolution logic if invoked. consolidate has no `chat`
+    // seam (it drives the LLM directly via the HTTP client path, never through
+    // `chatCompletion`), so that field is left to its default.
+    const runContext = createRunContext({
+        stashDir,
+        config,
+        eventsCtx: {},
+        proposalsCtx: {},
+        getLlmConfig: () => {
+            const resolved = Object.hasOwn(opts, "llmConfig")
+                ? (opts.llmConfig ?? undefined)
+                : resolveConsolidateLlmConfig(config, opts.improveProfile);
+            return resolved ?? null;
+        },
+        sourceRun,
+        dryRun: opts.dryRun ?? false,
+        signal: opts.signal,
+    });
+    const warnings = [];
+    if (!resolveProcessEnabled("consolidate", opts.improveProfile ?? resolveImproveStrategy(undefined, config).config)) {
         return makeConsolidateResult({
-            dryRun: opts.dryRun ?? false,
+            // 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,
         });
     }
-    const warnings = [];
-    checkForIncompleteJournal(stashDir, opts.recoveryMode ?? "abort", warnings);
     // 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.
@@ -600,7 +450,7 @@ export async function akmConsolidate(opts = {}) {
         // State DB unavailable → skip the embedding cache for this run.
     }
     try {
-        return await akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, warnings, sharedStateDb);
+        return await akmConsolidateInner(opts, config, stashDir, startMs, warnings, sharedStateDb);
     }
     finally {
         sharedStateDb?.close();
@@ -642,14 +492,13 @@ function createConsolidateAccounting() {
 }
 /**
  * Pass 1 — narrow the memory pool before any LLM work: drop stale DB entries,
- * partition hot-probation assets, run the deterministic dedup pre-pass, apply
- * incremental-since and judged-state-cache 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.
+ * 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, config, stashDir, startMs, warnings, sharedStateDb) {
-    let memories = loadMemoriesForSource(opts.target, stashDir, warnings);
+async function narrowConsolidationPool(opts, stashDir, startMs, warnings) {
+    let memories = loadMemoriesForSource(opts.writeTarget?.source.path, stashDir, warnings);
     // Pre-flight: filter out stale DB entries whose files no longer exist on
     // disk. Without this, memories deleted by a prior run (but not yet
     // reindexed) appear in chunk prompts, causing the LLM to generate plans
@@ -664,77 +513,12 @@ async function narrowConsolidationPool(opts, config, stashDir, startMs, warnings
     // 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.)
-    // ── WS-3b Step 0c: Filter hot-probation assets from LLM merge pool ─────────
-    // Hot-probation assets (system-generated, not yet graduated from intake pass)
-    // are processed by the dedup pre-pass but excluded from the LLM clustering.
-    // This prevents noisy extractions from polluting LLM context. The dedup pass
-    // below still runs against them so they're cleaned up deterministically.
-    // DEFAULT OFF — only active when `processes.extract.hotProbation.enabled === true`
-    // (the flag that causes extract to tag new extractions as hot-probation).
-    // Without that flag no assets will ever carry the hot-probation marker, so
-    // running the filter loop would be pure unnecessary I/O over the full corpus.
-    const hotProbationEnabled = getImproveProcessConfig(config, "extract", opts.improveProfile)?.hotProbation
-        ?.enabled === true;
-    let hotProbationCount = 0;
-    if (hotProbationEnabled) {
-        const hotProbationMemories = [];
-        const nonProbationMemories = [];
-        for (const m of memories) {
-            try {
-                const raw = fs.readFileSync(m.filePath, "utf8");
-                const parsed = parseFrontmatter(raw);
-                if (shouldSkipHotProbationInLlm(parsed.data)) {
-                    hotProbationMemories.push(m);
-                    hotProbationCount++;
-                }
-                else {
-                    nonProbationMemories.push(m);
-                }
-            }
-            catch {
-                nonProbationMemories.push(m); // fail open
-            }
-        }
-        if (hotProbationCount > 0) {
-            warnings.push(`Hot-probation: ${hotProbationCount} hot-probation asset(s) routed to dedup-only pass (excluded from LLM merge pool).`);
-            memories = nonProbationMemories;
-        }
-    }
-    // ── Deterministic dedup pre-pass (#617) ─────────────────────────────────────
-    // Cheap, no-LLM fast path that collapses the obvious near-duplicates
-    // (`.derived` ↔ origin pairs + content twins) BEFORE the embedding-clustered
-    // LLM consolidation. DEFAULT OFF — when `dedup.enabled !== true` this is a
-    // no-op and the pass behaves byte-identically to today. Collapsed variants
-    // are pruned from the LLM pool so the model only ever sees genuinely
-    // distinct-but-related memories. Each dropped variant is archived (soft
-    // invalidation) before deletion, matching the LLM merge path.
-    // Dry-run never mutates the filesystem, so the dedup pre-pass is skipped
-    // entirely under `--dry-run` (the LLM plan preview below is unaffected).
-    let dedupCollapsed = 0;
-    if (opts.dedup?.enabled && !opts.dryRun) {
-        const dedupTimestamp = timestampForFilename();
-        const dedupResult = await runDeterministicDedup(stashDir, opts.dedup, config, (variantFilePath, variantName) => {
-            archiveMemory(variantFilePath, stashDir, `memory:${variantName}`, "collapsed by deterministic dedup pre-pass", -1, undefined, warnings);
-            backupFile(variantFilePath, getBackupDir(stashDir, dedupTimestamp), variantName);
-        }, opts.signal, sharedStateDb);
-        dedupCollapsed = dedupResult.collapsed;
-        warnings.push(...dedupResult.warnings);
-        if (dedupResult.consumedRefs.length > 0) {
-            const consumed = new Set(dedupResult.consumedRefs);
-            memories = memories.filter((m) => !consumed.has(`memory:${m.name}`));
-            warnings.push(`Deterministic dedup: collapsed ${dedupResult.collapsed} near-duplicate memor${dedupResult.collapsed === 1 ? "y" : "ies"} (no LLM) before chunking.`);
-        }
-    }
     if (memories.length === 0) {
         return {
             done: true,
             result: makeConsolidateResult({
                 dryRun: opts.dryRun ?? false,
                 target: opts.target ?? stashDir,
-                // #617: the deterministic dedup pre-pass may have emptied the pool by
-                // collapsing every remaining memory into a canonical. Surface those
-                // collapses in `deleted` so the run reports the work it actually did.
-                deleted: dedupCollapsed,
                 warnings,
                 durationMs: Date.now() - startMs,
             }),
@@ -754,80 +538,11 @@ async function narrowConsolidationPool(opts, config, stashDir, startMs, warnings
             };
         }
     }
-    // WS-5 perf telemetry accumulators. These are collected throughout the run and
-    // merged into `perfTelemetry` on the final ConsolidateResult.
-    // `dedupPoolSize` = memories entering judgedCache narrowing (after dedup+incremental+limit).
-    // `judgedCacheSkipped` = memories skipped by the cache.
-    // `llmPoolSize` = memories actually sent to the LLM.
-    // `embedMs/cacheHits/cacheMisses` = accumulated from clusterMemoriesBySimilarity.
-    const perfMs = { dedupPoolSize: memories.length, judgedCacheSkipped: 0 };
-    // ── Judged-state cache narrowing (#581) ─────────────────────────────────────
-    // DEFAULT OFF. When enabled, skip every memory whose current content hash
-    // equals the hash recorded the last time the consolidate LLM judged it
-    // (judged-unchanged → no re-judge). This converts coverage from O(window) to
-    // O(changed/new) so one run can sweep the whole corpus while the LLM only
-    // sees genuinely new/changed memories. `currentHashByName` is populated for
-    // EVERY surviving memory (whether or not the cache is on) so the post-LLM
-    // recording step can upsert judged state without re-reading the files; when
-    // the cache is off it stays empty and the recording step is a no-op.
-    const judgedCacheEnabled = opts.judgedCache?.enabled !== false;
-    const currentHashByName = new Map();
-    if (judgedCacheEnabled) {
-        for (const m of memories) {
-            const h = computeMemoryContentHash(m.filePath);
-            if (h !== undefined)
-                currentHashByName.set(m.name, h);
-        }
-        let cachedMap = new Map();
-        {
-            // Use the shared state.db handle if available; open a local one otherwise.
-            const dbForJudged = sharedStateDb;
-            if (dbForJudged) {
-                try {
-                    cachedMap = getConsolidationJudgedMap(dbForJudged, memories.map((m) => `memory:${m.name}`));
-                }
-                catch {
-                    cachedMap = new Map();
-                }
-            }
-            else {
-                try {
-                    cachedMap = withStateDb((localDb) => getConsolidationJudgedMap(localDb, memories.map((m) => `memory:${m.name}`)));
-                }
-                catch {
-                    // State DB unavailable → fail open: judge the full pool this run.
-                    cachedMap = new Map();
-                }
-            }
-        }
-        const beforeCount = memories.length;
-        memories = memories.filter((m) => {
-            const cur = currentHashByName.get(m.name);
-            // No readable hash → keep (fail open; let the LLM judge it).
-            if (cur === undefined)
-                return true;
-            const cached = cachedMap.get(`memory:${m.name}`);
-            // Skip only when previously judged AND content is byte-identical since.
-            return !(cached !== undefined && cached.content_hash === cur);
-        });
-        const skipped = beforeCount - memories.length;
-        perfMs.judgedCacheSkipped = skipped; // WS-5 perf telemetry
-        if (skipped > 0) {
-            warnings.push(`Judged-state cache: skipped ${skipped} memor${skipped === 1 ? "y" : "ies"} judged-unchanged (no LLM); ${memories.length} remain for judging.`);
-        }
-        if (memories.length === 0) {
-            return {
-                done: true,
-                result: makeConsolidateResult({
-                    dryRun: opts.dryRun ?? false,
-                    target: opts.target ?? stashDir,
-                    deleted: dedupCollapsed,
-                    warnings,
-                    durationMs: Date.now() - startMs,
-                }),
-            };
-        }
-    }
+    // WS-5 perf telemetry: `dedupPoolSize` = memories entering the LLM pool
+    // (after incremental narrowing, before the limit cap). `llmPoolSize` =
+    // memories actually sent to the LLM. `embedMs/cacheHits/cacheMisses` =
+    // accumulated from clusterMemoriesBySimilarity.
+    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.`);
     }
@@ -852,147 +567,56 @@ async function narrowConsolidationPool(opts, config, stashDir, startMs, warnings
         warnings.push(`Consolidation: pool capped at ${opts.limit} of ${memories.length} memories (limit option, oldest-modified first).`);
         memories = memories.slice(0, opts.limit);
     }
-    return { done: false, memories, dedupCollapsed, perfMs, judgedCacheEnabled, currentHashByName };
+    return { done: false, memories, 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), records judged-state
- * cache outcomes, 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 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.
  */
-async function planConsolidation(opts, config, stashDir, startMs, memories, warnings, sharedStateDb, judgedCacheEnabled, currentHashByName, 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.
-    //
-    // Honor `profiles.improve.default.processes.consolidate.profile` first; fall
-    // back to the default LLM. See {@link resolveConsolidateLlmConfig}.
-    const llmConfig = resolveConsolidateLlmConfig(config, opts.improveProfile);
-    const isHttpPath = !!llmConfig;
-    // 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.
-    const bodyTruncation = 500;
-    const modelContextLength = llmConfig?.contextLength ?? DEFAULT_CONTEXT_LENGTH_TOKENS;
-    const chunkSize = computeSafeChunkSize(modelContextLength, bodyTruncation, opts.maxChunkSize);
-    // -- Phase A: plan generation -----------------------------------------------
-    const sourceName = opts.target ?? stashDir;
-    // WS-5: capture llmPoolSize = memories entering the LLM (after all filtering).
-    const llmPoolSize = memories.length;
-    // 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(memories, config, sharedStateDb);
-    // 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(config, "consolidate", opts.improveProfile)?.antiCollapse ?? {};
-        if (antiCollapseForCluster.enabled !== false && clusteredMemories.length > 2) {
-            const fraction = antiCollapseForCluster.randomClusterFraction ?? 0.05;
-            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}).`);
+/**
+ * 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);
         }
     }
-    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);
-    // ── Cold-start budget estimation ─────────────────────────────────────────────
-    // Estimate wall-clock cost BEFORE issuing any LLM calls. When a signal is
-    // provided and the estimated cost exceeds ~60% of the remaining budget we
-    // auto-reduce the pool and log the reduction so the run never starts work
-    // it cannot finish (avoiding SIGTERM mid-LLM-call).
-    //
-    // Formula: chunks.length × p90_chunk_seconds. The p90 comes from
-    // `opts.p90ChunkSecondsDefault` (caller-supplied, typically from the profile
-    // config); absent = 30 s (conservative default matching a medium local LLM).
-    //
-    // "Remaining budget" is read from a custom property on the AbortSignal if
-    // the caller (improve.ts) has attached one. Without it no auto-reduction
-    // fires but the check is still cheap to run.
-    if (chunks.length > 10 && opts.signal) {
-        const p90Chunk = opts.p90ChunkSecondsDefault ?? 30;
-        const estimatedSeconds = chunks.length * p90Chunk;
-        // remainingBudgetMs is a non-standard extension set by improve.ts when it
-        // creates the budget AbortController. Undefined = no budget information.
-        const budgetMs = opts.signal.remainingBudgetMs;
-        if (budgetMs !== undefined && budgetMs > 0) {
-            const remainingSeconds = budgetMs / 1000;
-            if (estimatedSeconds > remainingSeconds * 0.6) {
-                const safeCaps = Math.max(1, Math.floor((remainingSeconds * 0.6) / p90Chunk));
-                const removedChunks = chunks.length - safeCaps;
-                if (removedChunks > 0) {
-                    const msg = `[consolidate] cold-start budget: estimated ${estimatedSeconds.toFixed(0)}s > 60% of remaining ${remainingSeconds.toFixed(0)}s; ` +
-                        `reducing pool from ${chunks.length} to ${safeCaps} chunks (${removedChunks} deferred to next run).`;
-                    warn(msg);
-                    warnings.push(msg);
-                    chunks.splice(safeCaps);
-                }
-            }
+    let chunkNoAction = 0;
+    for (const m of chunk) {
+        const memRef = conceptIdFromTypeName("memory", m.name);
+        if (!targetRefs.has(memRef)) {
+            chunkNoAction++;
+            accounting.judgedNoActionRefs.add(memRef);
         }
     }
-    warn(`[consolidate] ${memories.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 = resolveStashStandards(stashDir);
+    accounting.judgedNoAction += chunkNoAction;
+}
+/**
+ * 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.
+ */
+async function judgeConsolidationChunks(args) {
+    const { chunks, opts, config, llmConfig, 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)`.
@@ -1000,14 +624,6 @@ async function planConsolidation(opts, config, stashDir, startMs, memories, warn
     // 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.
-    //
-    // Judged-state cache (#581): coarse outcome per memory NAME the LLM actually
-    // judged in a successfully-parsed chunk this run. "actioned" = an op targeted
-    // it; "no_action" = the LLM saw it and proposed nothing. Populated only when
-    // the cache is enabled (otherwise it stays empty and the post-loop recording
-    // step is a no-op). Memories in failed/aborted chunks are NOT recorded, so a
-    // transient LLM failure never poisons the cache into skipping them next run.
-    const judgedOutcomeByName = new Map();
     // 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.
@@ -1061,7 +677,7 @@ async function planConsolidation(opts, config, stashDir, startMs, memories, warn
         // 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(`memory:${m.name}`);
+                accounting.judgedNoActionRefs.add(conceptIdFromTypeName("memory", m.name));
             accounting.judgedNoAction += chunk.length;
             warn(`[consolidate] chunk ${chunkIdx + 1}/${chunks.length}: all ${chunk.length} memories are captureMode: hot — skipping LLM (judged no-action).`);
             continue;
@@ -1074,20 +690,34 @@ async function planConsolidation(opts, config, stashDir, startMs, memories, warn
         // asset-writers-investigation §5): providers with `supportsJsonSchema: true`
         // enforce the shape upstream; others fall through to
         // `parseEmbeddedJsonResponse` on the response side.
-        const callChunkLlm = (fallbackError) => tryLlmFeature("memory_consolidation", config, async () => {
+        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 (!llmConfig)
                 return { ok: false, error: "No LLM configured for consolidation" };
-            try {
-                const content = await chatCompletion(llmConfig, [
+            return callStructured({
+                feature: "memory_consolidation",
+                akmConfig: config,
+                enabled: true,
+                config: llmConfig,
+                messages: [
                     { role: "system", content: CONSOLIDATE_SYSTEM_PROMPT },
                     { role: "user", content: userPrompt },
-                ], { responseSchema: CONSOLIDATE_PLAN_JSON_SCHEMA, enableThinking: false });
-                return { ok: true, content };
-            }
-            catch (e) {
-                return { ok: false, error: String(e) };
-            }
-        }, { ok: false, error: fallbackError });
+                ],
+                request: {
+                    responseSchema: CONSOLIDATE_PLAN_JSON_SCHEMA,
+                    enableThinking: false,
+                    timeoutMs: llmConfig.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 },
+            });
+        };
         let raw = await callChunkLlm(`chunk ${chunkIdx + 1} failed`);
         if (!raw.ok) {
             // Single retry with 2s backoff before recording chunk as lost.
@@ -1109,9 +739,12 @@ async function planConsolidation(opts, config, stashDir, startMs, memories, warn
             }
             raw = retry;
         }
-        if (process.env.AKM_DEBUG_LLM) {
+        // 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);
-            warn(`[akm:consolidate] chunk ${chunkIdx + 1} raw response (first 500 chars): ${preview}`);
+            warnVerbose(`[akm:consolidate] chunk ${chunkIdx + 1} raw response (first 500 chars): ${preview}`);
         }
         const parsed = parseEmbeddedJsonResponse(raw.content);
         if (!parsed || !Array.isArray(parsed.operations)) {
@@ -1141,194 +774,179 @@ async function planConsolidation(opts, config, stashDir, startMs, memories, warn
                     warnings.push(w);
             }
         }
-        // Per-chunk judgedNoAction: count memories the LLM saw 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.
-        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 = `memory:${m.name}`;
-            if (!targetRefs.has(memRef)) {
-                chunkNoAction++;
-                accounting.judgedNoActionRefs.add(memRef);
-                // Judged-state cache (#581): the LLM saw this memory and proposed
-                // nothing → record judged-unchanged so the next run can skip it.
-                if (judgedCacheEnabled)
-                    judgedOutcomeByName.set(m.name, "no_action");
-            }
-            else if (judgedCacheEnabled) {
-                // An op targeted this memory → it was judged + actioned.
-                judgedOutcomeByName.set(m.name, "actioned");
-            }
-        }
-        accounting.judgedNoAction += chunkNoAction;
+        recordChunkJudgedNoAction(chunk, ops, accounting);
         chunkOpsArrays.push(ops);
     }
-    // ── Judged-state cache recording (#581) ─────────────────────────────────────
-    // Persist judged state for every memory the LLM actually judged this run so
-    // the next run can skip the unchanged ones. Keyed by current content hash so
-    // a later body edit (different hash) re-enters the LLM pool. DEFAULT OFF and
-    // skipped under --dry-run (dry-run mutates nothing). Failed/aborted chunks
-    // contributed no entries to `judgedOutcomeByName`, so a transient LLM outage
-    // never caches a memory as judged.
-    if (judgedCacheEnabled && !opts.dryRun && judgedOutcomeByName.size > 0) {
-        // Use the shared state.db handle; open a local one as fallback.
-        const doRecord = (db) => {
-            const judgedAt = new Date(startMs).toISOString();
-            for (const [name, outcome] of judgedOutcomeByName) {
-                const hash = currentHashByName.get(name);
-                if (hash === undefined)
-                    continue;
-                upsertConsolidationJudged(db, {
-                    entryKey: `memory:${name}`,
-                    contentHash: hash,
-                    judgedAt,
-                    outcome,
-                });
-            }
-        };
-        if (sharedStateDb) {
-            try {
-                doRecord(sharedStateDb);
-            }
-            catch (e) {
-                warnings.push(`Judged-state cache: failed to record judged state: ${String(e)}`);
-            }
-        }
-        else {
-            try {
-                withStateDb((localDb) => doRecord(localDb));
+    return chunkOpsArrays;
+}
+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.
+    //
+    // Improve supplies a frozen connection; standalone consolidate resolves its
+    // selected strategy/default engine here.
+    const llmConfig = Object.hasOwn(opts, "llmConfig")
+        ? (opts.llmConfig ?? undefined)
+        : resolveConsolidateLlmConfig(config, opts.improveProfile);
+    // 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.
+    const bodyTruncation = 500;
+    const modelContextLength = llmConfig?.contextLength ?? DEFAULT_CONTEXT_LENGTH_TOKENS;
+    const chunkSize = computeSafeChunkSize(modelContextLength, bodyTruncation, opts.maxChunkSize);
+    // -- Phase A: plan generation -----------------------------------------------
+    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);
             }
-            catch (e) {
-                warnings.push(`Judged-state cache: failed to record judged state: ${String(e)}`);
+        }
+    }
+    // WS-5: capture llmPoolSize after every pre-LLM cap.
+    const llmPoolSize = budgetedMemories.length;
+    // 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 ?? 0.05;
+            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,
+        llmConfig,
+        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(memories.map((m) => `memory:${m.name}`));
+    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, embedTelemetry, isHttpPath, sourceName };
-}
-/**
- * Pass 3 — execute the reconciled plan against the filesystem: resolve the
- * write target, journal the batch, dispatch each op to its handler, then commit
- * the batch at the boundary and clean up the journal. Mutates `accounting` via
- * the op-handlers' `pushSkipReason`. Behavior-identical to the former inlined
- * write block. Never invoked on the dry-run or aborted-confirm paths.
- */
-async function applyConsolidationPlan(config, stashDir, sourceRun, memories, warnings, allOps, accounting, dedupCollapsed, activeProfile) {
-    // -- Phase B + writes -------------------------------------------------------
-    const target = resolveWriteTarget(config);
-    const timestamp = timestampForFilename();
-    const backupDir = getBackupDir(stashDir, timestamp);
-    // Write journal before any mutations
-    writeJournal(stashDir, allOps, timestamp);
-    const counts = {
-        merged: 0,
-        deleted: 0,
-        contradicted: 0, // C-3 / #382: count of contradiction edges written
-        mergeFloorViolations: 0, // R5 §4.2: advisory merge-information-floor failures
-        mergedSecondaries: 0,
-    };
-    const promoted = [];
-    // Within-run dedup: track source refs for which a promote proposal was
-    // already created this run. The LLM can return multiple promote ops for
-    // different source memories that happen to have identical content (all are
-    // duplicate memories), so we also need a content-hash guard below.
-    const promotedSourceRefs = new Set();
-    // Build a lookup map: ref → MemoryEntry
-    const memoryByRef = new Map();
-    for (const m of memories) {
-        memoryByRef.set(`memory:${m.name}`, m);
-    }
-    const opCtx = {
-        config,
-        improveProfile: activeProfile,
-        stashDir,
-        sourceRun,
-        target,
-        backupDir,
-        memoryByRef,
-        promoted,
-        promotedSourceRefs,
-        warnings,
-        counts,
-        pushSkipReason: accounting.pushSkipReason,
+    return {
+        allOps,
+        totalChunks: chunks.length,
+        llmPoolSize,
+        deferredMemories: memories.length - budgetedMemories.length,
+        embedTelemetry,
+        sourceName,
     };
-    // Thin dispatch over the op discriminator — each branch is now an isolated,
-    // independently-testable handler that mutates `opCtx`.
-    for (let opIndex = 0; opIndex < allOps.length; opIndex++) {
-        const op = allOps[opIndex];
-        const opDisplayRef = op.op === "merge" ? op.primary : op.op === "contradict" ? `${op.ref} ↔ ${op.contradictedByRef}` : op.ref;
-        warn(`[consolidate] ${opIndex + 1}/${allOps.length} ${op.op} ${opDisplayRef}`);
-        switch (op.op) {
-            case "merge":
-                await handleMergeOp(op, opIndex, opCtx);
-                break;
-            case "delete":
-                await handleDeleteOp(op, opIndex, opCtx);
-                break;
-            case "promote":
-                await handlePromoteOp(op, opCtx);
-                break;
-            case "contradict":
-                await handleContradictOp(op, opCtx);
-                break;
-        }
-    }
-    const { merged, deleted, contradicted, mergeFloorViolations, mergedSecondaries } = counts;
-    // 0.9.0 (issue #507): batch-at-boundary commit. The merge/delete loop above
-    // wrote one merged primary and deleted N secondaries to the resolved target
-    // with NO per-asset commit. If the target is a writable git source and any
-    // asset was mutated, commit the whole batch ONCE here (stages .akm/ +
-    // siblings together). No-op for filesystem/primary-stash targets.
-    if (merged > 0 || deleted > 0) {
-        commitWriteTargetBoundary(target, `Consolidate: ${merged} merged, ${deleted} removed`);
-    }
-    cleanupJournal(stashDir, timestamp);
-    // [signoff 2026-06-15] TTL archive cleanup machinery RETIRED (WS-3a).
-    // The elaborate archiveRetentionDays / archive-dir scan existed only to satisfy
-    // the old irrecoverability constraint. Stashes are now git-backed, so git
-    // history is the recovery path — no bespoke archive TTL needed. Any files in
-    // .akm/archive/ will stay there harmlessly until the operator prunes them with
-    // `git rm` or `find .akm/archive -mtime +90 -delete`. Changed N files this
-    // run; recover any via `git show <sha>:<path>` or `git restore <path>`.
-    if (merged > 0 || deleted > 0 || dedupCollapsed > 0) {
-        const totalChanged = merged + deleted + dedupCollapsed;
-        warnings.push(`Changed ${totalChanged} file(s) this run. Recover any via git if needed (git history is the backstop).`);
-    }
-    return { merged, deleted, contradicted, mergeFloorViolations, mergedSecondaries, promoted };
 }
-async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, warnings, sharedStateDb) {
+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, config, stashDir, startMs, warnings, sharedStateDb);
+    const narrowed = await narrowConsolidationPool(opts, stashDir, startMs, warnings);
     if (narrowed.done)
         return narrowed.result;
-    const { memories, dedupCollapsed, perfMs, judgedCacheEnabled, currentHashByName } = narrowed;
+    const { memories, dedupPoolSize } = narrowed;
     // -- Pass 2: build the LLM plan (populates the shared accounting counters) ---
     const accounting = createConsolidateAccounting();
-    const { allOps, totalChunks, llmPoolSize, embedTelemetry, isHttpPath, sourceName } = await planConsolidation(opts, config, stashDir, startMs, memories, warnings, sharedStateDb, judgedCacheEnabled, currentHashByName, accounting);
+    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) {
         return makeConsolidateResult({
             dryRun: true,
             previewOnly: true,
             target: sourceName,
-            processed: memories.length,
+            processed: llmPoolSize,
             failedChunks: accounting.totalChunksFailed,
             totalChunks,
             judgedNoAction: accounting.judgedNoAction,
@@ -1337,407 +955,64 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
             // provably still 0 here (it only increments in the op-execution loop).
             mergedSecondaries: 0,
             failedChunkMemories: accounting.failedChunkMemories,
+            deferredMemories,
             planned: allOps,
             warnings,
             durationMs: Date.now() - startMs,
         });
     }
     warn(`[consolidate] plan: ${allOps.length} operation(s)`);
-    // -- HTTP path: warn about quality and confirm unless auto-accepted --------
-    if (isHttpPath) {
-        warnings.push("Running on HTTP path — plan generated from truncated memory excerpts; quality may vary.");
-        // Per-proposal confidence gating is handled by the caller (improve.ts)
-        // via runAutoAcceptGate after this function returns. The gate reads
-        // proposal.confidence (forwarded from op.confidence above) and applies
-        // a minimumThreshold floor of 95 for consolidate's destructive ops.
-        // Here we only gate the interactive-confirm path for manual/HTTP invocations.
-        if (opts.autoAccept === undefined && allOps.length > 0) {
-            const n = allOps.length;
-            // Non-interactive contexts (CI / test runners / piped stdin) must not
-            // block on an unanswerable prompt. Default to a non-destructive "no"
-            // so callers in those contexts get the same "aborted, preview only"
-            // shape they'd get from explicit user dismissal. AKM_NON_INTERACTIVE
-            // lets callers force this path even when stdin happens to be a TTY.
-            const nonInteractive = process.stdin.isTTY === false || process.env.AKM_NON_INTERACTIVE === "1";
-            const answer = nonInteractive ? false : await promptConfirm(`Apply ${n} operations? [y/N] `);
-            if (!answer) {
-                return makeConsolidateResult({
-                    previewOnly: true,
-                    target: sourceName,
-                    processed: memories.length,
-                    failedChunks: accounting.totalChunksFailed,
-                    totalChunks,
-                    judgedNoAction: accounting.judgedNoAction,
-                    skipReasons: accounting.skipReasons,
-                    // No merge executed on the abort path — mergedSecondaries is still 0.
-                    mergedSecondaries: 0,
-                    failedChunkMemories: accounting.failedChunkMemories,
-                    planned: allOps,
-                    warnings: [...warnings, nonInteractive ? "Non-interactive context: skipped apply." : "Aborted by user."],
-                    durationMs: Date.now() - startMs,
-                });
-            }
-        }
+    // 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 = {
+        config,
+        stashDir,
+        sourceRun: opts.sourceRun ?? `consolidate-${startMs}`,
+        proposalsCtx: opts.proposalsCtx,
+        target: opts.writeTarget,
+        memoryByRef,
+        promoted,
+        promotedSourceRefs: new Set(),
+        promotionFailures,
+        warnings,
+        pushSkipReason: accounting.pushSkipReason,
+        llmConfig: Object.hasOwn(opts, "llmConfig")
+            ? (opts.llmConfig ?? null)
+            : (resolveConsolidateLlmConfig(config, opts.improveProfile) ?? null),
+    };
+    for (const op of allOps) {
+        if (op.op === "promote")
+            await emitPromotionProposal(op, promoteContext);
     }
-    // -- Pass 3: execute the plan against the filesystem ------------------------
-    const { merged, deleted, contradicted, mergeFloorViolations, mergedSecondaries, promoted } = await applyConsolidationPlan(config, stashDir, sourceRun, memories, warnings, allOps, accounting, dedupCollapsed, opts.improveProfile);
-    const runDurationMs = Date.now() - startMs;
-    const budgetFraction = opts.runBudgetMs !== undefined && opts.runBudgetMs > 0 ? runDurationMs / opts.runBudgetMs : undefined;
-    return {
-        schemaVersion: 1,
-        ok: true,
-        shape: "consolidate-result",
-        dryRun: false,
-        previewOnly: false,
+    return makeConsolidateResult({
         target: sourceName,
-        processed: memories.length,
-        merged,
-        // #617: fold the deterministic dedup pre-pass collapses into the reported
-        // deleted count. Each collapse removed exactly one variant file with NO
-        // LLM call before the LLM pass ran on the pruned pool.
-        deleted: deleted + dedupCollapsed,
-        promoted,
-        contradicted,
-        mergeFloorViolations,
+        processed: llmPoolSize,
         failedChunks: accounting.totalChunksFailed,
         totalChunks,
         judgedNoAction: accounting.judgedNoAction,
         skipReasons: accounting.skipReasons,
-        mergedSecondaries,
+        mergedSecondaries: 0,
         failedChunkMemories: accounting.failedChunkMemories,
+        deferredMemories,
+        promoted,
+        failedPromotions: promotionFailures.count,
+        planned: allOps,
         warnings,
-        durationMs: runDurationMs,
+        durationMs: Date.now() - startMs,
         perfTelemetry: {
-            dedupPoolSize: perfMs.dedupPoolSize,
+            dedupPoolSize,
             llmPoolSize,
-            judgedCacheSkipped: perfMs.judgedCacheSkipped,
             embedMs: embedTelemetry.embedMs,
             embedCacheHits: embedTelemetry.cacheHits,
             embedCacheMisses: embedTelemetry.cacheMisses,
-            ...(budgetFraction !== undefined ? { estimatedBudgetFractionUsed: budgetFraction } : {}),
         },
-    };
-}
-/** Execute one `merge` op (behavior-identical to the former inlined branch). */
-export async function handleMergeOp(op, opIndex, ctx) {
-    const { config, stashDir, target, backupDir, memoryByRef, warnings, pushSkipReason, counts } = ctx;
-    // Accounting helper: emit a per-participant skipReason for failed
-    // merges so primary + every loaded-memory secondary land in the
-    // structured skip histogram. Pre-2026-05-26 only the primary was
-    // counted (1 skipReason per failed merge), leaving N secondaries
-    // unaccounted for in the `processed == actioned + noAction + Σskips`
-    // invariant — the source of the 4–11 silent leaks per run.
-    const emitMergeFailureSkips = (reason) => {
-        if (memoryByRef.has(op.primary))
-            pushSkipReason("merge", op.primary, reason);
-        for (const secRef of op.secondaries) {
-            if (memoryByRef.has(secRef))
-                pushSkipReason("merge", secRef, reason);
-        }
-    };
-    const primaryEntry = memoryByRef.get(op.primary);
-    if (!primaryEntry) {
-        // This fires when a prior op in the same run consumed this ref as a
-        // secondary and Fix-A pruned it from memoryByRef. It should NOT fire
-        // for hallucinated primaries (those are dropped by mergePlans() before
-        // reaching here). If this counter is non-zero, suspect an intra-run
-        // cross-chunk race, not a filter regression.
-        warnings.push(`Merge: primary ${op.primary} not found in loaded memories (pruned by prior op this run) — skipping.`);
-        emitMergeFailureSkips("merge_primary_missing");
-        return;
-    }
-    // Defense-in-depth: even if the entry is in memoryByRef (pre-flight ran
-    // before this run's own ops), the file may have been deleted by a
-    // concurrent process or an edge case the pre-flight filter missed.
-    if (!fs.existsSync(primaryEntry.filePath)) {
-        warnings.push(`Merge: primary ${op.primary} file gone at execution time (stale entry) — skipping.`);
-        emitMergeFailureSkips("merge_primary_file_gone");
-        return;
-    }
-    // Phase B: generate merged content
-    const secondaryBodies = [];
-    for (const secRef of op.secondaries) {
-        const secEntry = memoryByRef.get(secRef);
-        if (!secEntry) {
-            warnings.push(`Merge: secondary ${secRef} not found — skipping merge op.`);
-            // No accounting impact: a missing secondary is a phantom ref and
-            // never contributed to any chunk's targetRefs reduction. We still
-            // continue the loop to gather the remaining valid secondaries.
-            continue;
-        }
-        secondaryBodies.push(secRef);
-    }
-    if (secondaryBodies.length === 0) {
-        warnings.push(`Merge: ${op.primary} has no valid secondaries — skipping.`);
-        emitMergeFailureSkips("merge_no_valid_secondaries");
-        return;
-    }
-    // Pre-flight hot guard — skip the LLM call entirely if any participant
-    // is hot or unparseable. Without this, mixed chunks still send hot merges
-    // to the planner which proposes them; generateMergedContent() is then
-    // called, produces output without `description`, and the skip is
-    // misattributed to merge_missing_description instead of the real cause.
-    const preflightParticipants = [op.primary, ...op.secondaries];
-    const preflightBlocked = preflightParticipants.flatMap((ref) => {
-        const e = memoryByRef.get(ref);
-        if (!e)
-            return [];
-        const verdict = consolidateGuardStatus(e.filePath);
-        if (verdict === "hot" || verdict === "unparseable")
-            return [{ ref, verdict }];
-        return [];
     });
-    if (preflightBlocked.length > 0) {
-        const detail = preflightBlocked.map((p) => `${p.ref} (${p.verdict})`).join(", ");
-        warnings.push(`Merge: refused for ${op.primary} — ${preflightBlocked.length} participant(s) blocked by hot/unparseable frontmatter guard (pre-flight): ${detail}`);
-        emitMergeFailureSkips("merge_participant_blocked");
-        return;
-    }
-    let primaryBody = "";
-    try {
-        primaryBody = fs.readFileSync(primaryEntry.filePath, "utf8");
-    }
-    catch {
-        warnings.push(`Merge: could not read primary ${op.primary} — skipping.`);
-        emitMergeFailureSkips("merge_read_failed");
-        return;
-    }
-    const mergeResult = await generateMergedContent(config, op.primary, primaryBody, op.secondaries, memoryByRef, ctx.improveProfile);
-    if ("error" in mergeResult) {
-        warnings.push(`Merge: ${mergeResult.error} for ${mergeResult.detail}.`);
-        emitMergeFailureSkips(mergeResult.error);
-        return;
-    }
-    let mergedContent = mergeResult.content;
-    // Validate frontmatter of merged content — must have a `---` block
-    // with at minimum a `description` field. We parse via the hand-rolled
-    // parser (cheap) AND require non-empty description. This guards against
-    // the historical defect where merged memories were written back with
-    // empty `description` and later polluted the promote path.
-    let parsedMerged;
-    try {
-        parsedMerged = parseFrontmatter(mergedContent);
-    }
-    catch {
-        warnings.push(`Merge: merged content for ${op.primary} has invalid frontmatter — skipping.`);
-        emitMergeFailureSkips("merge_invalid_frontmatter");
-        return;
-    }
-    if (parsedMerged.frontmatter === null) {
-        warnings.push(`Merge: merged content for ${op.primary} has no frontmatter block — skipping.`);
-        emitMergeFailureSkips("merge_invalid_frontmatter");
-        return;
-    }
-    const mergedDesc = parsedMerged.data.description;
-    if (typeof mergedDesc !== "string" || mergedDesc.trim().length === 0) {
-        warnings.push(`Merge: merged content for ${op.primary} missing description — skipping.`);
-        emitMergeFailureSkips("merge_missing_description");
-        return;
-    }
-    const truncReason = detectTruncatedDescription(mergedDesc);
-    if (truncReason) {
-        warnings.push(`Merge: merged content for ${op.primary} has truncated description (${truncReason}) — skipping.`);
-        emitMergeFailureSkips("merge_truncated_description");
-        return;
-    }
-    // captureMode:hot guard — refuse the merge if ANY participating memory
-    // (primary or secondary) was user-captured or has unparseable frontmatter
-    // (could have hidden a hot flag). Hot memories are user-explicit and
-    // must not be deleted/overwritten by the consolidate LLM. 14 user
-    // memories were silent-deleted by consolidate before this guard landed;
-    // recovery required copying from .akm/archive/ by hand.
-    const mergeParticipants = [op.primary, ...op.secondaries];
-    const blockedParticipants = mergeParticipants.flatMap((ref) => {
-        const e = memoryByRef.get(ref);
-        if (!e)
-            return [];
-        const verdict = consolidateGuardStatus(e.filePath);
-        if (verdict === "hot" || verdict === "unparseable")
-            return [{ ref, verdict }];
-        return [];
-    });
-    if (blockedParticipants.length > 0) {
-        const detail = blockedParticipants.map((p) => `${p.ref} (${p.verdict})`).join(", ");
-        warnings.push(`Merge: refused for ${op.primary} — ${blockedParticipants.length} participant(s) blocked by hot/unparseable frontmatter guard: ${detail}`);
-        emitMergeFailureSkips("merge_participant_blocked");
-        return;
-    }
-    // WS-3b: Anti-collapse generation guard (step 8a).
-    // DEFAULT ON since R5 (opt out via antiCollapse.enabled: false). Refuses
-    // to merge two assets both above generation N (default 2) — prevents the
-    // pipeline from building ever-deeper LLM-merged trees that lose the
-    // source fidelity of the original episodes.
-    const antiCollapseConfig = getImproveProcessConfig(config, "consolidate", ctx.improveProfile)?.antiCollapse ?? {};
-    if (antiCollapseConfig.enabled !== false) {
-        const allParticipants = [op.primary, ...op.secondaries];
-        // One read per participant: generation counter, stripped body (for the
-        // information floor), and existing source_refs (for the provenance union).
-        const participantInfo = allParticipants.map((ref) => {
-            const e = memoryByRef.get(ref);
-            if (!e)
-                return { ref, generation: 0, body: "", sourceRefs: [] };
-            try {
-                const raw = fs.readFileSync(e.filePath, "utf8");
-                const parsed = parseFrontmatter(raw);
-                const fm = parsed.data;
-                const sourceRefs = Array.isArray(fm.source_refs) ? fm.source_refs.map(String) : [];
-                return { ref, generation: readAssetGeneration(fm), body: stripFrontmatterBody(raw), sourceRefs };
-            }
-            catch {
-                return { ref, generation: 0, body: "", sourceRefs: [] };
-            }
-        });
-        const sourceGenerations = participantInfo.map((p) => p.generation);
-        const generationCheck = checkGenerationGuard(sourceGenerations, antiCollapseConfig);
-        if (generationCheck.refused) {
-            warnings.push(`Merge: ${generationCheck.reason}`);
-            emitMergeFailureSkips("merge_generation_guard");
-            return;
-        }
-        // WS-3b: Lexical diversity check (step 8b).
-        // Low n-gram diversity ⇒ likely correlated-extraction artifact; raise merge threshold.
-        if (antiCollapseConfig.lexicalDiversityCheck !== false) {
-            const bodies = participantInfo.map((p) => p.body).filter((b) => b.length > 0);
-            const diversityCheck = checkLexicalDiversity(bodies, antiCollapseConfig);
-            if (diversityCheck.lowDiversity) {
-                // Low-diversity cluster: just warn (don't refuse merge since the dedup
-                // path handles exact twins). The warning surfaces in health telemetry.
-                warnings.push(`Merge: cluster around ${op.primary} has low lexical diversity (${diversityCheck.diversity?.toFixed(2) ?? "?"} < 0.30) — likely correlated extraction; merge proceeds but review is recommended.`);
-            }
-        }
-        // Inject generation counter into merged content frontmatter (step 8a).
-        // merged.generation = max(sourceGenerations) + 1. source_refs is the
-        // UNION of participants + everything they already cited (R5 §4.2 —
-        // the old set-if-absent behavior dropped second-generation provenance).
-        const provenanceUnion = [...new Set([...allParticipants, ...participantInfo.flatMap((p) => p.sourceRefs)])];
-        mergedContent = injectGenerationFrontmatter(mergedContent, sourceGenerations, provenanceUnion);
-        // R5 §4.2: merge-information floor — ADVISORY in v1. A merge that
-        // shrinks provenance or genericizes below the retention floor is
-        // counted + warned, never refused (promotion path: design doc §7).
-        try {
-            const mergedParsed = parseFrontmatter(mergedContent);
-            const mergedFm = mergedParsed.data;
-            const mergedSourceRefs = Array.isArray(mergedFm.source_refs) ? mergedFm.source_refs.map(String) : [];
-            const floorCheck = checkMergeInformationFloor(mergedParsed.content, mergedSourceRefs, participantInfo, antiCollapseConfig);
-            if (!floorCheck.passed) {
-                counts.mergeFloorViolations++;
-                warnings.push(`Merge: information floor advisory for ${op.primary}: ${floorCheck.reason ?? "unspecified"} — merge proceeds (v1 observe-only).`);
-            }
-        }
-        catch {
-            // Floor measurement is best-effort; never blocks the merge path.
-        }
-    }
-    // Backup secondaries before deleting
-    for (const secRef of op.secondaries) {
-        const secEntry = memoryByRef.get(secRef);
-        if (secEntry && fs.existsSync(secEntry.filePath)) {
-            backupFile(secEntry.filePath, backupDir, secEntry.name);
-        }
-    }
-    // Write merged primary
-    try {
-        const parsedPrimary = parseAssetRef(op.primary);
-        await writeAssetToSource(target.source, target.config, parsedPrimary, mergedContent);
-    }
-    catch (e) {
-        warnings.push(`Merge: write failed for ${op.primary}: ${String(e)}`);
-        emitMergeFailureSkips("merge_write_failed");
-        return;
-    }
-    // Archive and delete secondaries (P1-B: soft-invalidation)
-    for (const secRef of op.secondaries) {
-        const secEntry = memoryByRef.get(secRef);
-        if (!secEntry)
-            continue;
-        if (fs.existsSync(secEntry.filePath)) {
-            archiveMemory(secEntry.filePath, stashDir, secRef, "merged into primary", opIndex, op.primary, warnings);
-        }
-        try {
-            const parsedSec = parseAssetRef(secRef);
-            await deleteAssetFromSource(target.source, target.config, parsedSec);
-            markJournalCompleted(stashDir, secRef);
-        }
-        catch (e) {
-            warnings.push(`Merge: delete failed for ${secRef}: ${String(e)}`);
-        }
-    }
-    markJournalCompleted(stashDir, op.primary);
-    counts.merged++;
-    // 2026-05-26 accounting-leak fix: `merged` is op-level, but each
-    // successful merge actions `1 + secondaries.length` memories. Without
-    // this counter the accounting invariant breaks by `secondaries.length`
-    // per successful merge (chunk loop excluded all secondaries from
-    // judgedNoAction via targetRefs, but only the primary is credited to
-    // `merged`). Count only loaded-memory secondaries; phantom secondary
-    // refs never affected any chunk's targetRefs in the first place.
-    for (const secRef of op.secondaries) {
-        if (memoryByRef.has(secRef))
-            counts.mergedSecondaries++;
-    }
-    // Prune consumed refs from memoryByRef so later ops in this run cannot
-    // reference an absorbed secondary as a merge primary and proceed with a
-    // stale entry. Primary is rewritten (not deleted), so we only remove
-    // secondaries; the primary ref remains valid under its new content.
-    for (const secRef of op.secondaries) {
-        memoryByRef.delete(secRef);
-    }
 }
-/** Execute one `delete` op (behavior-identical to the former inlined branch). */
-export async function handleDeleteOp(op, opIndex, ctx) {
-    const { stashDir, target, backupDir, memoryByRef, warnings, pushSkipReason, counts } = ctx;
-    const entry = memoryByRef.get(op.ref);
-    if (!entry) {
-        warnings.push(`Delete: ${op.ref} not found in loaded memories — skipping.`);
-        // Phantom ref: not in the batch so not in processed. Pushing to
-        // skipReasons would inflate Σ(skipReasons) without a matching processed
-        // entry, breaking the accounting invariant. Visibility is preserved via
-        // the warnings array above.
-        return;
-    }
-    // captureMode:hot guard — refuse to delete user-captured memories OR
-    // memories whose frontmatter is unparseable (could have hidden the hot
-    // flag). The consolidate LLM was deleting hot-captured user memos as
-    // "redundant" — 14 such deletes were silently archived between
-    // 2026-05-19 and 2026-05-20 before this guard. Hot memories are
-    // user-explicit and may only be deleted by the user.
-    const guard = consolidateGuardStatus(entry.filePath);
-    if (guard === "hot" || guard === "unparseable") {
-        warnings.push(`Delete: refused for ${op.ref} — ${guard === "hot" ? "captureMode:hot (user-explicit; never auto-delete)" : "frontmatter unparseable (cannot verify hot flag absent)"}. Reason from LLM: "${op.reason ?? "n/a"}"`);
-        pushSkipReason("delete", op.ref, "captureMode_hot_refused");
-        return;
-    }
-    if (fs.existsSync(entry.filePath)) {
-        backupFile(entry.filePath, backupDir, entry.name);
-        // P1-B: soft-invalidation archive before hard delete
-        archiveMemory(entry.filePath, stashDir, op.ref, op.reason, opIndex, undefined, warnings);
-    }
-    try {
-        const parsedRef = parseAssetRef(op.ref);
-        await deleteAssetFromSource(target.source, target.config, parsedRef);
-        markJournalCompleted(stashDir, op.ref);
-        counts.deleted++;
-        // Prune from memoryByRef so later ops in this run cannot reference a
-        // deleted memory as a merge primary or secondary.
-        memoryByRef.delete(op.ref);
-    }
-    catch (e) {
-        // Distinguish "file already absent" from genuine failures. A prior run
-        // may have deleted the file but the DB was not yet re-indexed, so the
-        // ref still appeared in memoryByRef. The delete goal is already met.
-        const msg = e instanceof Error ? e.message : String(e);
-        if (msg.includes("not found in source")) {
-            warnings.push(`Delete: ${op.ref} — file already absent (stale DB entry); skipping.`);
-            pushSkipReason("delete", op.ref, "delete_already_gone");
-        }
-        else {
-            warnings.push(`Delete: failed for ${op.ref}: ${String(e)}`);
-            pushSkipReason("delete", op.ref, "delete_failed");
-        }
-    }
-}
-/** Execute one `promote` op (behavior-identical to the former inlined branch). */
-export async function handlePromoteOp(op, ctx) {
+/** Execute one reconciled promotion by emitting a reviewable proposal. */
+async function emitPromotionProposal(op, ctx) {
     const { config, stashDir, sourceRun, target, memoryByRef, warnings, pushSkipReason, promoted, promotedSourceRefs } = ctx;
     const entry = memoryByRef.get(op.ref);
     if (!entry) {
@@ -1755,27 +1030,28 @@ export async function handlePromoteOp(op, ctx) {
         pushSkipReason("promote", op.ref, "promote_already_promoted_this_run");
         return;
     }
-    let knowledgeRef = op.knowledgeRef;
-    try {
-        parseAssetRef(knowledgeRef);
-    }
-    catch {
-        const slug = op.knowledgeRef
-            .replace(/^knowledge:/, "")
-            .replace(/[^a-z0-9-]/gi, "-")
-            .toLowerCase();
-        knowledgeRef = `knowledge:${slug}`;
-        warnings.push(`Normalized invalid ref "${op.knowledgeRef}" → "${knowledgeRef}"`);
-    }
-    // Idempotency: check pending proposals by target ref
-    const existingProposals = listProposals(stashDir, { ref: knowledgeRef });
-    if (existingProposals.some((p) => p.status === "pending")) {
+    const proposedName = op.knowledgeRef.split("/").filter(Boolean).at(-1) ??
+        entry.name.split("/").filter(Boolean).at(-1) ??
+        "promoted-memory";
+    const slug = proposedName
+        .replace(/[^a-z0-9-]/gi, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "")
+        .toLowerCase();
+    const knowledgeRef = conceptIdFromTypeName("knowledge", slug);
+    parseRefInput(knowledgeRef);
+    if (knowledgeRef !== op.knowledgeRef) {
+        warnings.push(`Normalized generated ref "${op.knowledgeRef}" → "${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 = parseAssetRef(knowledgeRef);
+    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`);
@@ -1791,9 +1067,7 @@ export async function handlePromoteOp(op, ctx) {
         pushSkipReason("promote", op.ref, "promote_read_failed");
         return;
     }
-    // Defensive sanitization: legacy memory files written by older
-    // consolidate runs may still carry outer code fences or broken YAML.
-    // Strip them here so we never propose a polluted asset.
+    // 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}).`);
@@ -1839,7 +1113,7 @@ export async function handlePromoteOp(op, ctx) {
     const bodyHash = cacheHash(sourceBody);
     const allPendingConsolidateProposals = listProposals(stashDir, { status: "pending" }).filter((p) => p.source === "consolidate");
     const contentDupProposal = allPendingConsolidateProposals.find((p) => {
-        return cacheHash(p.payload.content) === bodyHash;
+        return cacheHash(proposalContent(p)) === bodyHash;
     });
     if (contentDupProposal) {
         warnings.push(`Skipping promote: identical body already pending as proposal ${contentDupProposal.id} (ref: ${contentDupProposal.ref}); skipping duplicate for ${op.ref} → ${knowledgeRef}`);
@@ -1876,9 +1150,10 @@ export async function handlePromoteOp(op, ctx) {
         const mergedBodyFm = {
             ...(parsedMemory.data ?? {}),
             description,
+            xrefs: promoteProvenanceXrefs(parsedMemory.data?.xrefs, op.ref),
         };
         const serializedMergedFm = serializeFrontmatter(mergedBodyFm);
-        const proposalContent = assembleAssetFromString(serializedMergedFm, parsedMemory.content);
+        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
@@ -1895,13 +1170,16 @@ export async function handlePromoteOp(op, ctx) {
             pushSkipReason("promote", op.ref, "promote_dedup_window");
             return;
         }
-        const proposalResult = createProposal(stashDir, {
+        const proposalResult = emitProposal({ stashDir, proposalsCtx: 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.llmConfig?.model ? { modelId: ctx.llmConfig.model } : {}),
             payload: {
-                content: proposalContent,
-                frontmatter: { description },
+                content: promotedAssetContent,
+                frontmatter: { description, xrefs: [canonicalXref(op.ref)] },
             },
             ...(typeof op.confidence === "number" ? { confidence: op.confidence } : {}),
         });
@@ -1912,56 +1190,14 @@ export async function handlePromoteOp(op, ctx) {
         else {
             promoted.push(proposalResult.id);
             promotedSourceRefs.add(op.ref);
-            markJournalCompleted(stashDir, op.ref);
         }
     }
     catch (e) {
+        ctx.promotionFailures.count++;
         warnings.push(`Promote: createProposal failed for ${op.ref}: ${String(e)}`);
         pushSkipReason("promote", op.ref, "promote_create_failed");
     }
 }
-/** Execute one `contradict` op (behavior-identical to the former inlined branch). */
-export async function handleContradictOp(op, ctx) {
-    const { stashDir, memoryByRef, warnings, pushSkipReason, counts } = ctx;
-    // Confidence gate: surface-level topic overlap causes false positives
-    // (investigation 2026-06-18). Require ≥0.92 confidence before writing
-    // contradiction edges. Missing confidence field defaults to 1.0 for
-    // backward compatibility with responses that predate this field.
-    const opConfidence = typeof op.confidence === "number" ? op.confidence : 1.0;
-    if (opConfidence < 0.92) {
-        warnings.push(`Contradict: confidence ${opConfidence.toFixed(2)} below 0.92 threshold for ${op.ref} <-> ${op.contradictedByRef} — skipping.`);
-        pushSkipReason("contradict", op.ref, "contradict_low_confidence");
-        return;
-    }
-    // C-3 / #382: Write contradictedBy edges so resolveFamilyContradictions
-    // (the SCC resolver in memory-improve.ts) has edges to work on.
-    // Zep arXiv:2501.13956 §3 — unified belief-revision with contradiction edges.
-    const entry = memoryByRef.get(op.ref);
-    const contradictorEntry = memoryByRef.get(op.contradictedByRef);
-    if (!entry) {
-        warnings.push(`Contradict: ${op.ref} not found in loaded memories — skipping.`);
-        // Phantom ref: not in processed, so no skipReason (same rationale as
-        // delete_ref_missing).
-        return;
-    }
-    if (!contradictorEntry) {
-        warnings.push(`Contradict: ${op.contradictedByRef} not found — skipping.`);
-        // op.ref IS in the batch (entry found above) so the skipReason is
-        // correctly charged against a real processed memory.
-        pushSkipReason("contradict", op.ref, "contradict_target_missing");
-        return;
-    }
-    try {
-        // Write the contradiction edge: op.ref is contradicted by op.contradictedByRef
-        writeContradictEdge(entry.filePath, op.contradictedByRef);
-        counts.contradicted++;
-        markJournalCompleted(stashDir, op.ref);
-    }
-    catch (e) {
-        warnings.push(`Contradict: failed to write edge for ${op.ref}: ${String(e)}`);
-        pushSkipReason("contradict", op.ref, "contradict_write_failed");
-    }
-}
 // ── Helpers ─────────────────────────────────────────────────────────────────
 /**
  * Normalise a knowledge slug for variant-aware deduplication. Collapses:
@@ -1973,8 +1209,23 @@ export async function handleContradictOp(op, ctx) {
  * 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 = ref.replace(/^[^:]+:/, "");
+    const slug = parseRefInput(ref).name;
     const monthRe = /(?:jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)/i;
     const tokens = slug
         .toLowerCase()
@@ -2029,22 +1280,10 @@ async function checkPreEmitDedup(opts) {
  * everything changed or the index can't answer (fail-open to preserve merge
  * correctness). `since` is an ISO timestamp.
  */
-/**
- * Parse a human-readable duration string (e.g. "30m", "24h", "7d") to an ISO
- * timestamp representing `now - duration`. Returns the input unchanged when it
- * doesn't match the pattern (assumed to already be an ISO timestamp).
- */
-function parseSinceToIso(since) {
-    // Canonical CLI unit grammar: `m` = minutes, `M` = months (see core/time.ts
-    // DURATION_UNITS). Non-matching input is returned unchanged (assumed to
-    // already be an ISO timestamp).
-    const ms = parseDuration(since, DURATION_UNITS);
-    if (ms === null)
-        return since;
-    return new Date(Date.now() - ms).toISOString();
-}
 export function narrowToIncrementalCandidates(memories, since, warnings, neighborsPerChanged = 5) {
-    const sinceIso = parseSinceToIso(since);
+    // 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;
@@ -2064,7 +1303,7 @@ export function narrowToIncrementalCandidates(memories, since, warnings, neighbo
     try {
         db = openExistingDatabase();
         for (const m of changed) {
-            const id = findEntryIdByRef(db, `memory:${m.name}`);
+            const id = findEntryIdByRef(db, conceptIdFromTypeName("memory", m.name));
             if (id === undefined)
                 continue;
             for (const hit of getNeighborsByEntryId(db, id, neighborsPerChanged + 1)) {
@@ -2131,14 +1370,22 @@ function loadMemoriesForSource(source, stashDir, warnings) {
         const memoriesDir = path.join(source ?? stashDir, "memories");
         const fsStashDir = source ?? stashDir;
         if (fs.existsSync(memoriesDir)) {
-            for (const fname of fs.readdirSync(memoriesDir)) {
-                if (!fname.endsWith(".md"))
-                    continue;
-                const filePath = path.join(memoriesDir, fname);
-                const name = fname.replace(/\.md$/, "");
-                if (!isConsolidationEligibleMemoryName(name))
-                    continue;
-                memories.push({ name, filePath, description: "", tags: [], stashDir: fsStashDir });
+            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()) {
+                        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 });
+                }
             }
         }
         if (memories.length > 0) {
@@ -2147,150 +1394,3 @@ function loadMemoriesForSource(source, stashDir, warnings) {
     }
     return memories;
 }
-async function generateMergedContent(config, primaryRef, primaryBody, secondaryRefs, memoryByRef, activeProfile) {
-    // Only handle single-secondary merges per design (one call per merge op)
-    const secRef = secondaryRefs[0];
-    const secEntry = memoryByRef.get(secRef);
-    if (!secEntry)
-        return { error: "merge_read_failed", detail: `secondary ${secRef} not in memoryByRef` };
-    let secBody = "";
-    try {
-        secBody = fs.readFileSync(secEntry.filePath, "utf8");
-    }
-    catch {
-        return { error: "merge_read_failed", detail: `could not read secondary ${secRef}` };
-    }
-    const primaryFmKeys = Object.keys(parseFrontmatter(primaryBody).data);
-    const secFmKeys = Object.keys(parseFrontmatter(secBody).data);
-    const requiredFmKeys = [...new Set([...primaryFmKeys, ...secFmKeys])];
-    const prompt = [
-        "Merge these two memory assets into one. Output ONLY the merged markdown (with YAML frontmatter). Do not explain, do not use code fences.",
-        "",
-        "## OUTPUT FORMAT (MANDATORY)",
-        "Return raw markdown content beginning DIRECTLY with the `---` frontmatter delimiter.",
-        "DO NOT wrap your entire response in a code fence.",
-        "",
-        'GOOD: "---\\ndescription: ...\\n---\\nBody content."',
-        'BAD:  "```markdown\\n---\\ndescription: ...\\n---\\nBody content.\\n```"',
-        'BAD:  "```yaml\\n---\\ndescription: ...\\n---\\nBody content.\\n```"',
-        "",
-        "## FRONTMATTER RULES (MANDATORY)",
-        "- The `updated:` field, if present, MUST be a real ISO date (e.g. `updated: 2026-05-20`). NEVER emit `updated: today`, `updated: now`, or `updated: {today: null}`. If you don't have a real date, OMIT the field — the post-processor will not invent one.",
-        "- REQUIRED: The merged frontmatter MUST include a `description` field with a concise one-sentence summary of the merged asset's content. If neither source has a `description` field, synthesize one from the content.",
-        requiredFmKeys.length > 0
-            ? `- CRITICAL: The merged frontmatter MUST include ALL of these keys from both source memories: ${requiredFmKeys.join(", ")}. Do NOT drop any of them.`
-            : null,
-        "",
-        `=== Primary memory (${primaryRef}) ===`,
-        primaryBody,
-        "",
-        `=== Secondary memory (${secRef}) ===`,
-        secBody,
-    ]
-        .filter((line) => line !== null)
-        .join("\n");
-    // Use the same per-process profile resolution as the chunk-plan call above
-    // so the merge generation step doesn't silently revert to the default LLM.
-    const llmConfig = resolveConsolidateLlmConfig(config, activeProfile);
-    const result = await tryLlmFeature("memory_consolidation", config, async () => {
-        if (!llmConfig)
-            return { ok: false, error: "No LLM configured for consolidation" };
-        try {
-            const content = await chatCompletion(llmConfig, [{ role: "user", content: prompt }], {
-                enableThinking: false,
-            });
-            return { ok: true, content };
-        }
-        catch (e) {
-            return { ok: false, error: String(e) };
-        }
-    }, { ok: false, error: `merge content generation failed for ${primaryRef}` });
-    if (!result.ok) {
-        return {
-            error: "merge_transport_failed",
-            detail: result.error ?? `merge content generation failed for ${primaryRef}`,
-        };
-    }
-    // Sanitize LLM output: strip outer code fences (defends against the
-    // ```markdown … ``` leak observed in production), re-serialise frontmatter
-    // through the yaml lib (fixes quote-escaping mistakes), and reject empty
-    // or fence-only responses.
-    const sanitized = sanitizeMergedContent(result.content ?? "");
-    if (!sanitized.ok) {
-        const reason = sanitized.reason;
-        const isFenceError = reason === "UNBALANCED_CODE_FENCE" ||
-            reason === "MISSING_FRONTMATTER_SENTINEL" ||
-            reason === "MALFORMED_FRONTMATTER_BLOCK" ||
-            reason === "FRONTMATTER_NOT_OBJECT";
-        const mergeReason = isFenceError ? "merge_fence_rejected" : "merge_yaml_invalid";
-        return { error: mergeReason, detail: `${primaryRef} — ${reason}` };
-    }
-    const mergedRaw = sanitized.result.content;
-    // C-4 / #383: Content-preservation lint (mem0 §3.2, arXiv:2504.19413).
-    // Guards against LLM-generated merged content that silently drops information
-    // from the source assets. Two checks:
-    //   1. Body size: merged body must be >= 50% of the larger source body.
-    //   2. Frontmatter superset: merged frontmatter must contain all keys present
-    //      in both source frontmatters.
-    // Failures return a discriminated error so the call site can emit a specific
-    // skip-reason key in the histogram.
-    try {
-        const primaryFm = parseFrontmatter(primaryBody);
-        const secFm = parseFrontmatter(secBody);
-        const mergedFm = parseFrontmatter(mergedRaw);
-        // Check body size — blended floor: max(ratio × largerLen, absoluteFloor).
-        // Deduplication is expected, so the ratio is lower than the reflect gate
-        // (0.3 vs 0.5). The absolute floor protects very short memory pairs where
-        // the ratio alone would produce a near-zero threshold.
-        const primaryBodyLen = (primaryFm.content ?? "").trim().length;
-        const secBodyLen = (secFm.content ?? "").trim().length;
-        const mergedBodyLen = (mergedFm.content ?? "").trim().length;
-        const largerBodyLen = Math.max(primaryBodyLen, secBodyLen);
-        const mergeFloor = Math.max(MERGE_SHRINK_RATIO_MIN * largerBodyLen, MERGE_ABSOLUTE_FLOOR_CHARS);
-        if (largerBodyLen > 0 && mergedBodyLen < mergeFloor) {
-            return {
-                error: "merge_content_too_short",
-                detail: `${primaryRef} — merged body (${mergedBodyLen} chars) is less than floor (${Math.round(mergeFloor)} chars; max(${MERGE_SHRINK_RATIO_MIN}×${largerBodyLen}, ${MERGE_ABSOLUTE_FLOOR_CHARS}))`,
-            };
-        }
-        // Check frontmatter superset — attempt repair before rejecting.
-        const primaryKeys = Object.keys(primaryFm.data ?? {});
-        const secKeys = Object.keys(secFm.data ?? {});
-        const mergedKeys = new Set(Object.keys(mergedFm.data ?? {}));
-        const missingKeys = [...new Set([...primaryKeys, ...secKeys])].filter((k) => !mergedKeys.has(k));
-        if (missingKeys.length > 0) {
-            // Inject missing keys from source FMs. Primary value wins on conflict.
-            const repairedFmData = { ...mergedFm.data };
-            for (const key of missingKeys) {
-                repairedFmData[key] =
-                    key in primaryFm.data
-                        ? primaryFm.data[key]
-                        : secFm.data[key];
-            }
-            normalizeUpdatedField(repairedFmData);
-            const repairedYaml = serializeFrontmatter(repairedFmData);
-            const bodyPart = typeof mergedFm.content === "string" ? mergedFm.content : "";
-            return { content: assembleAssetFromString(repairedYaml, bodyPart) };
-        }
-    }
-    catch {
-        // parseFrontmatter failures are non-fatal — allow the merge to proceed.
-    }
-    return { content: mergedRaw };
-}
-async function promptConfirm(message) {
-    process.stdout.write(message);
-    return new Promise((resolve) => {
-        let settled = false;
-        const done = (answer) => {
-            if (settled)
-                return;
-            settled = true;
-            rl.close();
-            resolve(answer);
-        };
-        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-        rl.once("line", (line) => done(line.trim().toLowerCase() === "y"));
-        rl.once("close", () => done(false));
-    });
-}