akm-cli 0.9.0-rc.2 → 0.9.0-rc.4

package/dist/commands/health/windows.js

@@ -146,7 +146,7 @@ export function buildWindowMetrics(db, stateDbPath, since, until, now = () => Da
     });
     const { withLogs: taskRowsWithLogs, backed: existingLogRows } = partitionLogBackedRows(taskRows, logsDb);
     const failedTaskRows = taskRows.filter((row) => row.status === "failed");
-    const activeRows = taskRows.filter((row) => row.status === "active");
+    const activeRows = taskRows.filter((row) => row.status === "active" && row.completed_at === null);
     const stuckActiveRuns = activeRows.filter((row) => now() - new Date(row.started_at).getTime() > ACTIVE_RUN_WARN_MS).length;
     const promptRows = taskRows.filter((row) => row.target_kind === "prompt");
     const promptFailures = promptRows.filter((row) => {

package/dist/commands/health.js

@@ -94,7 +94,7 @@ export function akmHealth(options = {}) {
         const taskRows = queryTaskHistory(db, { since });
         const { withLogs: taskRowsWithLogs, backed: existingLogRows } = partitionLogBackedRows(taskRows, logsDb);
         const failedTaskRows = taskRows.filter((row) => row.status === "failed");
-        const activeRows = taskRows.filter((row) => row.status === "active");
+        const activeRows = taskRows.filter((row) => row.status === "active" && row.completed_at === null);
         const stuckActiveRuns = activeRows.filter((row) => now() - new Date(row.started_at).getTime() > ACTIVE_RUN_WARN_MS).length;
         const promptRows = taskRows.filter((row) => row.target_kind === "prompt");
         const promptFailures = promptRows.filter((row) => {

package/dist/commands/improve/anti-collapse.js

@@ -72,8 +72,8 @@ function distinctTokens(text) {
 }
 /**
  * A merge must strictly increase information (R5 §4.2):
- *  1. Provenance: the merged asset's `source_refs` must be a superset of the
- *     union of all participants' `source_refs` plus the participant refs
+ *  1. Provenance: the merged asset's `xrefs` must be a superset of the union of
+ *     all participants' `xrefs` plus the participant refs
  *     themselves — provenance never shrinks through a merge.
  *  2. Specificity: distinctTokens(mergedBody) ≥ minSpecificityRetention ×
  *     |union(distinctTokens(participant bodies))| — a merge that only
@@ -111,7 +111,7 @@ export function checkMergeInformationFloor(mergedBody, mergedSourceRefs, partici
     const specificityOk = specificityRetention >= minRetention;
     const reasons = [];
     if (!provenanceOk) {
-        reasons.push(`provenance shrank: merged source_refs missing ${missing.length} ref(s) (e.g. ${missing[0]})`);
+        reasons.push(`provenance shrank: merged xrefs missing ${missing.length} ref(s) (e.g. ${missing[0]})`);
     }
     if (!specificityOk) {
         reasons.push(`specificity retention ${specificityRetention.toFixed(2)} < ${minRetention} (merge genericized/shortened)`);

package/dist/commands/improve/collapse-detector.js

@@ -175,10 +175,10 @@ export function normHash(text) {
     return hash.toString(16);
 }
 /**
- * Score one canary against the live index, merge-following via `source_refs`:
- * a hit is the anchor ref itself OR any returned entry whose `source_refs`
- * frontmatter contains the anchor (ONE level — provenance dropped on a
- * second-generation merge is a miss by design; that IS the information loss).
+ * Score one canary against the live index, merge-following via canonical
+ * `xrefs`. Legacy `source_refs` remains readable for assets written before the
+ * xref cutover. A hit is the anchor ref itself OR any returned entry whose
+ * provenance contains the anchor.
  * Returns the 0-based rank of the first hit, or -1.
  */
 function scoreCanary(indexDb, canary, k) {
@@ -188,7 +188,7 @@ function scoreCanary(indexDb, canary, k) {
         const ref = makeAssetRef(r.entry.type, r.entry.name);
         if (ref === canary.anchor_ref)
             return i;
-        if (r.entry.sourceRefs?.includes(canary.anchor_ref))
+        if (r.entry.xrefs?.includes(canary.anchor_ref) || r.entry.sourceRefs?.includes(canary.anchor_ref))
             return i;
     }
     return -1;

package/dist/commands/improve/consolidate.js

@@ -6,15 +6,15 @@ 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 { parseAssetRef, refToString } from "../../core/asset/asset-ref.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 { 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 { parseEmbeddedJsonResponse } from "../../core/parse.js";
-import { resolveStashStandards } from "../../core/standards/resolve-stash-standards.js";
+import { resolveStandardsContext } from "../../core/standards/resolve-standards-context.js";
 import { detectTruncatedDescription } from "../../core/text-truncation.js";
 import { DURATION_UNITS, parseDuration } from "../../core/time.js";
 import { createProposal, isProposalSkipped, listProposals } from "../proposal/repository.js";
@@ -36,6 +36,7 @@ import { tryLlmFeature } from "../../llm/feature-gate.js";
 import { getConsolidationJudgedMap, upsertConsolidationJudged, } from "../../storage/repositories/consolidation-repository.js";
 import { getBodyEmbeddings, upsertBodyEmbeddings } from "../../storage/repositories/embeddings-repository.js";
 import { resolveImproveStrategy, resolveProcessEnabled } from "./improve-strategies.js";
+import { durableImproveRef } from "./source-identity.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";
@@ -415,24 +416,36 @@ function backupFile(filePath, backupDir, name) {
 }
 // ── WS-3b: Generation frontmatter injection ───────────────────────────────────
 /**
- * Inject `generation` and `source_refs` into merged content.
+ * Inject `generation` and canonical `xrefs` 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 —
+ * xrefs = UNION of the provided provenance refs (participants + their cited
+ * sources) with anything already present in xrefs or legacy source_refs —
  * 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) {
+export 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 existingRefs = [
+            ...(Array.isArray(existingFm.xrefs) ? existingFm.xrefs.map(String) : []),
+            ...(Array.isArray(existingFm.source_refs) ? existingFm.source_refs.map(String) : []),
+        ];
+        const canonicalRefs = [...existingRefs, ...provenanceRefs].flatMap((ref) => {
+            try {
+                return [refToString(parseAssetRef(ref))];
+            }
+            catch {
+                return [];
+            }
+        });
         const updatedFm = {
             ...existingFm,
             generation: computeMergedGeneration(sourceGenerations),
-            source_refs: [...new Set([...existingRefs, ...provenanceRefs])],
+            xrefs: [...new Set(canonicalRefs)],
         };
+        delete updatedFm.source_refs;
         return assembleAssetFromString(serializeFrontmatter(updatedFm), parsed.content);
     }
     catch {
@@ -568,6 +581,30 @@ export function makeConsolidateResult(overrides) {
     };
 }
 // ── Main entry point ─────────────────────────────────────────────────────────
+function resolveConsolidationWriteTarget(opts, config) {
+    if (opts.writeTarget) {
+        return {
+            ...opts.writeTarget,
+            source: { ...opts.writeTarget.source, path: path.resolve(opts.writeTarget.source.path) },
+        };
+    }
+    if (opts.target && !path.isAbsolute(opts.target)) {
+        const target = resolveWriteTarget(config, opts.target);
+        return { ...target, source: { ...target.source, path: path.resolve(target.source.path) } };
+    }
+    // Programmatic callers historically supplied an absolute stash path. Normalize
+    // it immediately into the same unambiguous write-target shape used by named sources.
+    const explicitRoot = opts.target ?? opts.stashDir;
+    if (explicitRoot) {
+        const root = path.resolve(explicitRoot);
+        return {
+            source: { kind: "filesystem", name: "stash", path: 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)
@@ -575,8 +612,10 @@ 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 writeTarget = resolveConsolidationWriteTarget(opts, config);
+    opts = { ...opts, target: writeTarget.source.name, writeTarget };
     opts = { ...opts, improveProfile: opts.improveProfile ?? resolveImproveStrategy(undefined, config).config };
-    const stashDir = opts.stashDir ?? resolveStashDir();
+    const stashDir = writeTarget.source.path;
     if (!resolveProcessEnabled("consolidate", opts.improveProfile ?? resolveImproveStrategy(undefined, config).config)) {
         return makeConsolidateResult({
             dryRun: opts.dryRun ?? false,
@@ -647,7 +686,7 @@ function createConsolidateAccounting() {
  * 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);
+    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
@@ -782,7 +821,7 @@ async function narrowConsolidationPool(opts, config, stashDir, startMs, warnings
             const dbForJudged = sharedStateDb;
             if (dbForJudged) {
                 try {
-                    cachedMap = getConsolidationJudgedMap(dbForJudged, memories.map((m) => `memory:${m.name}`));
+                    cachedMap = getConsolidationJudgedMap(dbForJudged, memories.map((m) => durableImproveRef(`memory:${m.name}`, opts.target)));
                 }
                 catch {
                     cachedMap = new Map();
@@ -790,7 +829,7 @@ async function narrowConsolidationPool(opts, config, stashDir, startMs, warnings
             }
             else {
                 try {
-                    cachedMap = withStateDb((localDb) => getConsolidationJudgedMap(localDb, memories.map((m) => `memory:${m.name}`)));
+                    cachedMap = withStateDb((localDb) => getConsolidationJudgedMap(localDb, memories.map((m) => durableImproveRef(`memory:${m.name}`, opts.target))));
                 }
                 catch {
                     // State DB unavailable → fail open: judge the full pool this run.
@@ -804,7 +843,7 @@ async function narrowConsolidationPool(opts, config, stashDir, startMs, warnings
             // No readable hash → keep (fail open; let the LLM judge it).
             if (cur === undefined)
                 return true;
-            const cached = cachedMap.get(`memory:${m.name}`);
+            const cached = cachedMap.get(durableImproveRef(`memory:${m.name}`, opts.target));
             // Skip only when previously judged AND content is byte-identical since.
             return !(cached !== undefined && cached.content_hash === cur);
         });
@@ -992,7 +1031,7 @@ async function planConsolidation(opts, config, stashDir, startMs, memories, warn
     // 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);
+    const standardsContext = resolveStandardsContext("memory:_consolidated", stashDir);
     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)`.
@@ -1192,7 +1231,7 @@ async function planConsolidation(opts, config, stashDir, startMs, memories, warn
                 if (hash === undefined)
                     continue;
                 upsertConsolidationJudged(db, {
-                    entryKey: `memory:${name}`,
+                    entryKey: durableImproveRef(`memory:${name}`, opts.target),
                     contentHash: hash,
                     judgedAt,
                     outcome,
@@ -1230,9 +1269,8 @@ async function planConsolidation(opts, config, stashDir, startMs, memories, warn
  * 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, llmConfig) {
+async function applyConsolidationPlan(config, stashDir, target, sourceRun, memories, warnings, allOps, accounting, dedupCollapsed, activeProfile, llmConfig) {
     // -- Phase B + writes -------------------------------------------------------
-    const target = resolveWriteTarget(config);
     const timestamp = timestampForFilename();
     const backupDir = getBackupDir(stashDir, timestamp);
     // Write journal before any mutations
@@ -1381,7 +1419,7 @@ async function akmConsolidateInner(opts, config, stashDir, startMs, sourceRun, w
         }
     }
     // -- 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, Object.hasOwn(opts, "llmConfig")
+    const { merged, deleted, contradicted, mergeFloorViolations, mergedSecondaries, promoted } = await applyConsolidationPlan(config, stashDir, opts.writeTarget, sourceRun, memories, warnings, allOps, accounting, dedupCollapsed, opts.improveProfile, Object.hasOwn(opts, "llmConfig")
         ? (opts.llmConfig ?? null)
         : (resolveConsolidateLlmConfig(config, opts.improveProfile) ?? null));
     const runDurationMs = Date.now() - startMs;
@@ -1505,7 +1543,7 @@ export async function handleMergeOp(op, opIndex, ctx) {
         emitMergeFailureSkips("merge_read_failed");
         return;
     }
-    const mergeResult = await generateMergedContent(config, op.primary, primaryBody, op.secondaries, memoryByRef, ctx.improveProfile, ctx.llmConfig);
+    const mergeResult = await (ctx.generateMergedContentFn ?? generateMergedContent)(config, op.primary, primaryBody, op.secondaries, memoryByRef, ctx.improveProfile, ctx.llmConfig);
     if ("error" in mergeResult) {
         warnings.push(`Merge: ${mergeResult.error} for ${mergeResult.detail}.`);
         emitMergeFailureSkips(mergeResult.error);
@@ -1565,6 +1603,28 @@ export async function handleMergeOp(op, opIndex, ctx) {
         emitMergeFailureSkips("merge_participant_blocked");
         return;
     }
+    const allParticipants = [op.primary, ...op.secondaries];
+    // Generation and provenance are mandatory merge metadata, independent of
+    // whether the optional anti-collapse refusal/advisory checks are enabled.
+    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.xrefs) ? fm.xrefs.map(String) : []),
+                ...(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);
     // 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
@@ -1572,25 +1632,6 @@ export async function handleMergeOp(op, opIndex, ctx) {
     // 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}`);
@@ -1608,19 +1649,19 @@ export async function handleMergeOp(op, opIndex, ctx) {
                 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);
+    }
+    // merged.generation = max(sourceGenerations) + 1. xrefs is the UNION of
+    // participants + canonical and legacy provenance already carried by them.
+    const provenanceUnion = [...new Set([...allParticipants, ...participantInfo.flatMap((p) => p.sourceRefs)])];
+    mergedContent = injectGenerationFrontmatter(mergedContent, sourceGenerations, provenanceUnion);
+    if (antiCollapseConfig.enabled !== false) {
         // 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 mergedSourceRefs = Array.isArray(mergedFm.xrefs) ? mergedFm.xrefs.map(String) : [];
             const floorCheck = checkMergeInformationFloor(mergedParsed.content, mergedSourceRefs, participantInfo, antiCollapseConfig);
             if (!floorCheck.passed) {
                 counts.mergeFloorViolations++;
@@ -1758,17 +1799,22 @@ 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}"`);
+    const proposedName = op.knowledgeRef
+        .replace(/^knowledge:/, "")
+        .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 = `knowledge:${slug}`;
+    parseAssetRef(knowledgeRef);
+    if (knowledgeRef !== op.knowledgeRef) {
+        warnings.push(`Normalized generated ref "${op.knowledgeRef}" → "${knowledgeRef}"`);
     }
     // Idempotency: check pending proposals by target ref
     const existingProposals = listProposals(stashDir, { ref: knowledgeRef });
@@ -1879,6 +1925,9 @@ export async function handlePromoteOp(op, ctx) {
         const mergedBodyFm = {
             ...(parsedMemory.data ?? {}),
             description,
+            xrefs: [
+                ...new Set([...(Array.isArray(parsedMemory.data?.xrefs) ? parsedMemory.data.xrefs.map(String) : []), op.ref]),
+            ],
         };
         const serializedMergedFm = serializeFrontmatter(mergedBodyFm);
         const proposalContent = assembleAssetFromString(serializedMergedFm, parsedMemory.content);
@@ -1904,7 +1953,7 @@ export async function handlePromoteOp(op, ctx) {
             sourceRun,
             payload: {
                 content: proposalContent,
-                frontmatter: { description },
+                frontmatter: { description, xrefs: [op.ref] },
             },
             ...(typeof op.confidence === "number" ? { confidence: op.confidence } : {}),
         });
@@ -2134,14 +2183,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) {

package/dist/commands/improve/distill/promote-memory.js

@@ -22,6 +22,7 @@ import { appendEvent } from "../../../core/events.js";
 import { parseEmbeddedJsonResponse } from "../../../llm/client.js";
 import { createProposal, isProposalSkipped } from "../../proposal/repository.js";
 import { assessMemoryKnowledgePromotionCandidate } from "../distill-promotion-policy.js";
+import { durableImproveRef } from "../source-identity.js";
 import { persistOutputEncodingSalience, runLessonQualityJudge, writeQualityRejection } from "./quality-gate.js";
 /**
  * Run the memory→knowledge promotion branch. Returns the finished distill
@@ -31,10 +32,11 @@ import { persistOutputEncodingSalience, runLessonQualityJudge, writeQualityRejec
  */
 export async function promoteMemoryToKnowledge(ctx) {
     const { targetKind, inputRef, assetContent, config, chat, stash, lookup, fetchSimilarLessonsFn, existingRefVocabulary, outcomeWeightEnabled, eligMeta, exclusionSetSize, filteredFeedbackCount, feedbackFullyFiltered, } = ctx;
+    const durableInputRef = ctx.durableInputRef ?? inputRef;
     const promotion = targetKind === "lesson"
         ? null
         : assessMemoryKnowledgePromotionCandidate({
-            inputRef,
+            inputRef: durableInputRef,
             assetContent,
             feedbackEvents: ctx.filteredEvents.map((event) => ({
                 ...(event.metadata !== undefined ? { metadata: event.metadata } : {}),
@@ -48,7 +50,7 @@ export async function promoteMemoryToKnowledge(ctx) {
     // overwriting. Follows mem0 ADD/UPDATE/DELETE/NOOP pattern (arXiv:2504.19413 §3.2)
     // and A-MEM dynamic linking (arXiv:2502.12110).
     let resolvedPromotionContent = promotion.content;
-    const existingKnowledgePath = await lookup(promotion.knowledgeRef);
+    const existingKnowledgePath = await lookup(durableImproveRef(promotion.knowledgeRef, ctx.sourceName));
     const existingKnowledgeContent = existingKnowledgePath && fs.existsSync(existingKnowledgePath)
         ? (() => {
             try {
@@ -87,7 +89,7 @@ export async function promoteMemoryToKnowledge(ctx) {
                 // Existing content is authoritative — no update needed.
                 appendEvent({
                     eventType: "distill_invoked",
-                    ref: inputRef,
+                    ref: durableInputRef,
                     metadata: {
                         outcome: "skipped",
                         lessonRef: promotion.knowledgeRef,
@@ -168,7 +170,7 @@ export async function promoteMemoryToKnowledge(ctx) {
     if (isProposalSkipped(proposalResult)) {
         appendEvent({
             eventType: "distill_invoked",
-            ref: inputRef,
+            ref: durableInputRef,
             metadata: {
                 outcome: "skipped",
                 lessonRef: promotion.knowledgeRef,
@@ -189,10 +191,10 @@ export async function promoteMemoryToKnowledge(ctx) {
     const proposal = proposalResult;
     // G4: content-score the distilled OUTPUT so it carries a real encoding
     // salience (encoding_source='content') from creation.
-    persistOutputEncodingSalience(promotion.knowledgeRef, resolvedPromotionContent, existingRefVocabulary, outcomeWeightEnabled);
+    persistOutputEncodingSalience(durableImproveRef(promotion.knowledgeRef, ctx.sourceName), resolvedPromotionContent, existingRefVocabulary, outcomeWeightEnabled);
     appendEvent({
         eventType: "distill_invoked",
-        ref: inputRef,
+        ref: durableInputRef,
         metadata: {
             outcome: "queued",
             lessonRef: promotion.knowledgeRef,

package/dist/commands/improve/distill/quality-gate.js

@@ -169,7 +169,7 @@ export function writeQualityRejection(stash, inputRef, lessonRef, content, score
     const rejectDir = path.join(stash, ".akm", "distill-rejected");
     fs.mkdirSync(rejectDir, { recursive: true });
     const ts = timestampForFilename();
-    fs.writeFileSync(path.join(rejectDir, `${ts}-${lessonRef}.md`), `---\nscore: ${score}\nreason: ${reason}\noutcome: ${outcome}\n---\n\n${content}`, "utf8");
+    fs.writeFileSync(path.join(rejectDir, `${ts}-${lessonRef.replace(/[:/\\]/g, "-")}.md`), `---\nscore: ${score}\nreason: ${reason}\noutcome: ${outcome}\n---\n\n${content}`, "utf8");
     appendEvent({
         eventType: "distill_invoked",
         ref: inputRef,

package/dist/commands/improve/distill-guards.js

@@ -96,7 +96,7 @@ export function checkDistillFidelity(proposalBody, sourceBodies, config) {
             }
         }
     }
-    // Also flag proposals whose source_refs are empty (broken provenance).
+    // Also flag proposals whose xrefs are empty (broken provenance).
     // This is a degradation signal, not a contradiction, but worth surfacing.
     return { contradictionDetected: false };
 }