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

package/dist/commands/improve/memory/derived-ref.js

@@ -0,0 +1,124 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * The single, keyed-on-ref implementation of "is this a derived memory?" and
+ * "which parent does it derive from?" (R12).
+ *
+ * Two divergent copies previously lived side by side — the CONSUMER
+ * (`memory-improve.ts`, keyed on the memory name) and the PRODUCER
+ * (`memory-contradiction-detect.ts`, keyed on the file path). The producer's
+ * copy was strictly narrower: it ignored `derivedFrom` entirely and matched
+ * `source:` through a separate parser. That let the producer and consumer
+ * disagree on a memory's parent — the exact defect plan §6 calls out
+ * ("producer/consumer cannot disagree").
+ *
+ * Both sides now share this one impl, keyed on the memory NAME (the stash-
+ * relative path without the `.md` extension, e.g. `nested/foo.derived`). The
+ * producer converts its file path to a name via `toMemoryRef` before calling
+ * in. Adopting it on the producer side is an INTENTIONAL widening, pinned by
+ * `tests/commands/improve/derived-ref.test.ts`:
+ *   - `derivedFrom`-keyed families now resolve a parent (and so participate in
+ *     contradiction detection); and
+ *   - `source:` is parsed through `parseRefInput` so current bundle-qualified
+ *     refs resolve consistently.
+ *
+ * Resolution order (source → derivedFrom → `.derived` suffix) matches the
+ * consumer's prior behaviour exactly, so the consumer side is a pure move.
+ */
+import { conceptIdFromTypeName, parseRefInput } from "../../../core/asset/resolve-ref.js";
+import { asNonEmptyString } from "../../../core/common.js";
+import { DERIVED_SUFFIX } from "../../../core/recognition-util.js";
+/**
+ * Parse a belief edge (`supersededBy` / `contradictedBy` / `currentBeliefRefs`)
+ * to the bare memory name the identity channel keys on.
+ *
+ * Accepts BOTH spellings, because both reach this function:
+ *   - `memory:<name>` — the internal identity spelling, and what belief edges
+ *     written before 0.9.0 carry on disk;
+ *   - `memories/<name>` / `<bundle>//memories/<name>` — the conceptId grammar
+ *     the current writers emit (`akm remember --supersedes` and `akm import
+ *     --supersedes` go through `writeSupersededEdge` with the write result's
+ *     `ref`, which is fully qualified).
+ *
+ * Accepting only the first spelling silently reduced every edge written by the
+ * current code path to nothing, so a superseded memory read back as active.
+ * Both normalize to the bare name; the caller re-mints the internal
+ * `memory:<name>` form via {@link memoryIdentityRef}, so there is still exactly
+ * one identity spelling downstream.
+ */
+export function parseMemoryName(value) {
+    if (!value)
+        return undefined;
+    const trimmed = value.trim();
+    const MEMORY_PREFIX = "memory:";
+    if (trimmed.startsWith(MEMORY_PREFIX)) {
+        const name = trimmed.slice(MEMORY_PREFIX.length);
+        return name.length > 0 ? name : undefined;
+    }
+    try {
+        const parsed = parseRefInput(trimmed);
+        return parsed.type === "memory" && parsed.name.length > 0 ? parsed.name : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Parse a current `source:` backref and return its canonical memory conceptId,
+ * or `undefined` when it is empty, invalid, or not a memory ref.
+ */
+export function parseMemoryRef(value) {
+    if (!value)
+        return undefined;
+    try {
+        const parsed = parseRefInput(value.trim());
+        return parsed.type === "memory" ? conceptIdFromTypeName("memory", parsed.name) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Format a bare memory name into the belief-edge IDENTITY channel ref
+ * `memory:<name>` — the ONE implementation of that spelling.
+ *
+ * Belief-edge / identity
+ * channel (`contradictedBy` / `supersededBy` / `currentBeliefRefs`, and a derived
+ * memory's own `record.ref`) uses `memory:<name>` and is compared against a
+ * derived memory's identity ref. This channel is separate from `source:` asset
+ * refs, which use `memories/<name>`. Both `memory-improve.ts` (`refArray`) and
+ * `memory-contradiction-detect.ts` (`toMemoryRef`) emit through here so the
+ * identity spelling has one implementation.
+ */
+export function memoryIdentityRef(name) {
+    return `memory:${name}`;
+}
+/**
+ * True when the named memory is a derived/inferred child — either it carries
+ * `inferred: true` in its frontmatter or its name ends with the structural
+ * `.derived` suffix.
+ */
+export function isDerivedMemory(name, frontmatter) {
+    return frontmatter.inferred === true || name.endsWith(DERIVED_SUFFIX);
+}
+/**
+ * Resolve the parent (source) memory ref for a derived memory as a canonical
+ * `memories/<name>` conceptId, or `undefined` when none
+ * can be determined. Precedence:
+ *   1. `frontmatter.source` (normalised through {@link parseMemoryRef});
+ *   2. `frontmatter.derivedFrom` (a bare memory name → `memories/<name>`);
+ *   3. the `.derived` name suffix, stripped → `memories/<name>`.
+ */
+export function resolveParentRef(name, frontmatter) {
+    const fromSource = parseMemoryRef(asNonEmptyString(frontmatter.source));
+    if (fromSource)
+        return fromSource;
+    const derivedFrom = asNonEmptyString(frontmatter.derivedFrom);
+    if (derivedFrom)
+        return conceptIdFromTypeName("memory", derivedFrom);
+    if (name.endsWith(DERIVED_SUFFIX)) {
+        return conceptIdFromTypeName("memory", name.slice(0, -DERIVED_SUFFIX.length));
+    }
+    return undefined;
+}

package/dist/commands/improve/memory/memory-belief.js

@@ -28,6 +28,25 @@
  * - MemOS (arXiv:2507.03724) — formal archive/merge/transition with shared state model
  */
 import { mutateFrontmatter } from "../../../core/asset/frontmatter.js";
+// ── Shared edge-list reader ───────────────────────────────────────────────────
+/**
+ * Read a frontmatter edge value (`supersededBy` / `contradictedBy`) as a
+ * string list, promoting a scalar string to a one-element list.
+ *
+ * Scalar edges are LIVE data: the indexer's `normalizeNonEmptyStringList`
+ * accepts them and lint deliberately never flags them. An Array.isArray-only
+ * read treats a scalar as "no existing edges" and silently destroys the edge
+ * on the next merge — mirror `mergeXrefsIntoContent`'s scalar promotion
+ * instead.
+ */
+function readEdgeList(value) {
+    if (Array.isArray(value)) {
+        return value.filter((v) => typeof v === "string" && v.trim().length > 0);
+    }
+    if (typeof value === "string" && value.trim())
+        return [value.trim()];
+    return [];
+}
 // ── Contradiction edge writer ─────────────────────────────────────────────────
 /**
  * Write `contradictedBy` and `beliefState: contradicted` edges to a memory
@@ -38,24 +57,77 @@ import { mutateFrontmatter } from "../../../core/asset/frontmatter.js";
  *   - `memory-contradiction-detect.ts` for the M-1 automated contradiction pass
  *   - `resolveFamilyContradictions` in `memory-improve.ts` for SCC resolution
  *
- * Idempotent: if the `contradictedByRef` is already in `contradictedBy`,
- * the file is not rewritten.
+ * Idempotent: if the `contradictedByRef` is already in `contradictedBy` AND
+ * the file already carries the demotion state, the file is not rewritten. The
+ * guard is state-aware like its sibling {@link writeSupersededEdge}: an edge
+ * present WITHOUT the demotion (e.g. a hand-written `contradictedBy:` line,
+ * or a beliefState lost to a partial edit) is repaired, not skipped — an
+ * edge-only guard would make such a file a permanent no-op while
+ * contradiction writers report the contradiction as applied.
+ *
+ * Never weakens a stronger demotion: `archived` ranks BELOW `contradicted`
+ * (see `BELIEF_STATE_SCORE_CEILINGS` in
+ * src/indexer/search/ranking-contributors.ts), so contradicting an archived
+ * memory keeps `archived` and only appends the edge.
  *
  * @param filePath          - Absolute path to the memory markdown file.
  * @param contradictedByRef - The ref that contradicts this memory.
  */
 export function writeContradictEdge(filePath, contradictedByRef) {
     mutateFrontmatter(filePath, (parsed) => {
-        const existing = Array.isArray(parsed.data.contradictedBy)
-            ? parsed.data.contradictedBy
-            : [];
-        if (existing.includes(contradictedByRef))
+        const existing = readEdgeList(parsed.data.contradictedBy);
+        const currentState = parsed.data.beliefState;
+        const nextState = currentState === "archived" ? currentState : "contradicted";
+        if (existing.includes(contradictedByRef) && currentState === nextState) {
             return null; // Already written — idempotent.
+        }
         const nextContradictedBy = [...new Set([...existing, contradictedByRef])].sort();
         return {
             ...parsed.data,
             contradictedBy: nextContradictedBy,
-            beliefState: "contradicted",
+            beliefState: nextState,
+        };
+    });
+}
+// ── Supersession edge writer ─────────────────────────────────────────────────
+/**
+ * Write `supersededBy` and `beliefState: superseded` edges to an asset file's
+ * frontmatter (SPEC-5, stash-conventions-code-spec.md).
+ *
+ * Sibling of {@link writeContradictEdge}: the shared primitive for the
+ * conventions' corrections pattern — when a new asset supersedes an old one,
+ * the old asset gets a METADATA-ONLY demotion edit (every other frontmatter
+ * key and the body are preserved) so the ranker's beliefStateBoost demotes the
+ * stale incumbent and `--belief current` hides it. Used by
+ * `akm remember --supersedes` / `akm import --supersedes`.
+ *
+ * Idempotent: if `supersededByRef` is already in `supersededBy` and the file
+ * is already demoted, the file is not rewritten. Multiple corrections
+ * sorted-set-append their refs.
+ *
+ * Never WEAKENS an existing demotion: `contradicted` and `archived` rank
+ * BELOW `superseded` (severity order deprecated > superseded > contradicted >
+ * archived — see `BELIEF_STATE_SCORE_CEILINGS` in
+ * src/indexer/search/ranking-contributors.ts), so superseding an already
+ * contradicted/archived asset keeps the stronger state and only appends the
+ * `supersededBy` edge.
+ *
+ * @param filePath        - Absolute path to the asset markdown file.
+ * @param supersededByRef - The ref of the correction that supersedes this asset.
+ */
+export function writeSupersededEdge(filePath, supersededByRef) {
+    mutateFrontmatter(filePath, (parsed) => {
+        const existing = readEdgeList(parsed.data.supersededBy);
+        const currentState = parsed.data.beliefState;
+        const nextState = currentState === "contradicted" || currentState === "archived" ? currentState : "superseded";
+        if (existing.includes(supersededByRef) && currentState === nextState) {
+            return null; // Already written — idempotent.
+        }
+        const nextSupersededBy = [...new Set([...existing, supersededByRef])].sort();
+        return {
+            ...parsed.data,
+            supersededBy: nextSupersededBy,
+            beliefState: nextState,
         };
     });
 }

package/dist/commands/improve/memory/memory-contradiction-detect.js

@@ -22,7 +22,7 @@
  *
  * # LLM Feature Gate
  *
- * The pass is gated behind `profiles.improve.default.processes.consolidate.contradictionDetection.enabled`.
+ * The pass is gated by the selected strategy's consolidate contradiction setting.
  * When the gate is disabled or no LLM is configured,
  * the pass is a no-op and `analyzeMemoryCleanup` proceeds with only manually
  * annotated edges.
@@ -37,9 +37,12 @@ import fs from "node:fs";
 import path from "node:path";
 import contradictionJudgeTemplate from "../../../assets/prompts/contradiction-judge.md" with { type: "text" };
 import { mutateFrontmatter, parseFrontmatter } from "../../../core/asset/frontmatter.js";
-import { getDefaultLlmConfig } from "../../../core/config/config.js";
-import { chatCompletion, parseEmbeddedJsonResponse } from "../../../llm/client.js";
-import { tryLlmFeature } from "../../../llm/feature-gate.js";
+import { parseEmbeddedJsonResponse } from "../../../core/parse.js";
+import { getDefaultLlmConfig } from "../../../integrations/agent/engine-resolution.js";
+import { materializeLlmRunnerConnection, resolveImproveProcessRunner } from "../../../integrations/agent/runner.js";
+import { chatCompletion } from "../../../llm/client.js";
+import { callStructured } from "../../../llm/structured-call.js";
+import { isDerivedMemory, memoryIdentityRef, resolveParentRef } from "./derived-ref.js";
 // ── Constants ────────────────────────────────────────────────────────────────
 /**
  * Maximum family size for pairwise contradiction checking. Families larger
@@ -54,8 +57,7 @@ const MAX_PAIRS_PER_RUN = 20;
 /**
  * Minimum confidence required to write a contradiction edge. Below this
  * threshold the LLM may be flagging topic-overlap rather than genuine logical
- * exclusivity (investigation 2026-06-18). Absent confidence fields default to
- * 1.0 for backward compatibility with older judge responses.
+ * exclusivity (investigation 2026-06-18).
  */
 const CONTRADICT_CONFIDENCE_THRESHOLD = 0.92;
 /**
@@ -85,37 +87,17 @@ function* walkMarkdownFilesLocal(root) {
             yield full;
     }
 }
+// Build the derived memory's own belief-edge IDENTITY ref from its file path.
+// Emits through the shared {@link memoryIdentityRef} so this — the former THIRD
+// hand-rolled copy of the identity-channel spelling — no longer diverges from
+// memory-improve's `refArray` (ref-grammar decision D-R3 identity-channel
+// exception, documented at `memoryIdentityRef`).
 function toMemoryRef(memoriesDir, filePath) {
     const rel = path.relative(memoriesDir, filePath);
     if (!rel || rel.startsWith(".."))
         return undefined;
     const name = rel.replace(/\\/g, "/").replace(/\.md$/i, "");
-    return `memory:${name}`;
-}
-function isDerivedMemory(filePath, frontmatter) {
-    // Name-based guard (M-2): the .derived suffix is structural and immutable.
-    const base = path.basename(filePath, ".md");
-    if (base.endsWith(".derived"))
-        return true;
-    // Frontmatter-based guard: inferred: true marks explicit child memories.
-    return frontmatter.inferred === true;
-}
-function resolveParentRef(filePath, frontmatter, memoriesRootDir) {
-    // Prefer the explicit source: frontmatter.
-    const source = frontmatter.source;
-    if (typeof source === "string" && source.startsWith("memory:"))
-        return source;
-    // Fall back to deriving parent from the file name (strip .derived suffix).
-    const base = path.basename(filePath, ".md");
-    if (base.endsWith(".derived")) {
-        const parentName = base.slice(0, -".derived".length);
-        // Use the stash memories root so nested paths (e.g. memories/nested/foo.derived.md)
-        // resolve to the correct relative ref (memory:nested/foo, not memory:foo).
-        const rootDir = memoriesRootDir ?? path.dirname(filePath);
-        const rel = path.relative(rootDir, path.join(path.dirname(filePath), parentName));
-        return `memory:${rel.replace(/\\/g, "/")}`;
-    }
-    return undefined;
+    return memoryIdentityRef(name);
 }
 // ── Edge writing ─────────────────────────────────────────────────────────────
 /**
@@ -173,14 +155,20 @@ function pickContradictionLoser(a, b) {
  * @param config   - Loaded AKM config (used to access LLM settings).
  * @param chat     - Optional chat seam for testing (defaults to chatCompletion).
  */
-export async function detectAndWriteContradictions(stashDir, config, chat = chatCompletion) {
+export async function detectAndWriteContradictions(stashDir, config, chat = chatCompletion, strategy, resolvedLlmConfig) {
     const result = {
         familiesExamined: 0,
         pairsChecked: 0,
         edgesWritten: 0,
         warnings: [],
     };
-    const contradictionLlm = getDefaultLlmConfig(config);
+    const contradictionLlm = resolvedLlmConfig === null
+        ? undefined
+        : (resolvedLlmConfig ??
+            (() => {
+                const runner = resolveImproveProcessRunner(strategy, "consolidate", config);
+                return runner ? materializeLlmRunnerConnection(runner) : getDefaultLlmConfig(config);
+            })());
     if (!contradictionLlm)
         return result;
     // Collect derived memories grouped by parent.
@@ -195,14 +183,20 @@ export async function detectAndWriteContradictions(stashDir, config, chat = chat
             continue;
         }
         const parsed = parseFrontmatter(raw);
-        if (!isDerivedMemory(filePath, parsed.data))
-            continue;
-        const parentRef = resolveParentRef(filePath, parsed.data, memoriesDir);
-        if (!parentRef)
-            continue;
         const ref = toMemoryRef(memoriesDir, filePath);
         if (!ref)
             continue;
+        // Key the shared derived-ref helpers on the memory NAME (stash-relative, no
+        // extension) — the same key the consumer uses — so producer and consumer
+        // resolve the identical parent (R12). This intentionally widens the producer
+        // to honour `derivedFrom` and normalised `source:` values it previously
+        // dropped (pinned by derived-ref.test.ts).
+        const name = ref.slice("memory:".length);
+        if (!isDerivedMemory(name, parsed.data))
+            continue;
+        const parentRef = resolveParentRef(name, parsed.data);
+        if (!parentRef)
+            continue;
         const entry = {
             filePath,
             ref,
@@ -236,11 +230,6 @@ export async function detectAndWriteContradictions(stashDir, config, chat = chat
                 // edge already exists (no new information; avoids re-judging resolved
                 // pairs across runs).
                 //
-                // Legacy mutual A↔B edges written by the pre-fix pass self-heal: the
-                // skip fires this run, but the SCC resolver treats the 2-cycle as a sink
-                // and refreshes both to active — DELETING both `contradictedBy` arrays
-                // (memory-improve.ts persistBeliefStateTransition). The next detection
-                // run then sees no edge, re-judges, and writes the single canonical edge.
                 const aParsed = parseFrontmatter(fs.readFileSync(a.filePath, "utf8"));
                 const bParsed = parseFrontmatter(fs.readFileSync(b.filePath, "utf8"));
                 const { loser, winnerRef } = pickContradictionLoser(a, b);
@@ -249,12 +238,23 @@ export async function detectAndWriteContradictions(stashDir, config, chat = chat
                 if (loserCB.includes(winnerRef))
                     continue;
                 const prompt = buildContradictionJudgePrompt(a, b);
-                const judgeResult = await tryLlmFeature("memory_contradiction_detection", config, async () => {
-                    return chat(contradictionLlm, [
+                const judgeResult = await callStructured({
+                    feature: "memory_contradiction_detection",
+                    akmConfig: config,
+                    // Resolver-less key: the strategy decision IS the gate (default-off).
+                    enabled: strategy?.processes?.consolidate?.contradictionDetection?.enabled ?? false,
+                    config: contradictionLlm,
+                    messages: [
                         { role: "system", content: "Return only valid JSON. No prose." },
                         { role: "user", content: prompt },
-                    ]);
-                }, null);
+                    ],
+                    request: { chat },
+                    parse: (raw) => raw ?? null,
+                    // A transport throw used to escape the gated fn into the gate's
+                    // catch and take the null fallback ("skip"); onError reproduces it.
+                    onError: () => null,
+                    fallback: null, // null means "skip" — gate disabled or LLM call failed.
+                });
                 totalPairsChecked++;
                 result.pairsChecked++;
                 if (!judgeResult)
@@ -269,10 +269,7 @@ export async function detectAndWriteContradictions(stashDir, config, chat = chat
                 }
                 if (!parsed?.contradicts)
                     continue;
-                // Confidence gate: absent field defaults to 1.0 (backward compat with
-                // pre-confidence responses). Do NOT default to 0 — that would silently
-                // disable all detection during the rollout period.
-                const confidence = typeof parsed.confidence === "number" ? parsed.confidence : 1.0;
+                const confidence = typeof parsed.confidence === "number" ? parsed.confidence : 0;
                 if (confidence < CONTRADICT_CONFIDENCE_THRESHOLD) {
                     result.warnings.push(`Pair ${a.ref} / ${b.ref}: confidence ${confidence.toFixed(2)} below ${CONTRADICT_CONFIDENCE_THRESHOLD} threshold — skipped.`);
                     continue;

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

@@ -3,11 +3,12 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import fs from "node:fs";
 import path from "node:path";
-import { makeAssetRef, parseAssetRef } from "../../../core/asset/asset-ref.js";
 import { assembleAsset } from "../../../core/asset/asset-serialize.js";
 import { mutateFrontmatter, parseFrontmatter } from "../../../core/asset/frontmatter.js";
+import { conceptIdFromTypeName } from "../../../core/asset/resolve-ref.js";
 import { asNonEmptyString, groupBy, stringArray } from "../../../core/common.js";
-const DERIVED_SUFFIX = ".derived";
+import { DERIVED_SUFFIX } from "../../../core/recognition-util.js";
+import { isDerivedMemory, memoryIdentityRef, parseMemoryName, resolveParentRef } from "./derived-ref.js";
 export function analyzeMemoryCleanup(stashDir, options = {}) {
     const records = collectDerivedMemories(stashDir, options.parentRef);
     const byRef = new Map(records.map((record) => [record.ref, record]));
@@ -87,6 +88,8 @@ export function analyzeMemoryCleanup(stashDir, options = {}) {
             if (duplicates.length < 2)
                 continue;
             const [survivor, ...rest] = sortRecordsForSurvival(duplicates);
+            if (survivor === undefined)
+                continue;
             for (const duplicate of rest) {
                 planPrune(duplicate, "duplicate-derived", survivor.ref);
             }
@@ -587,7 +590,7 @@ function collectDerivedMemories(stashDir, parentRefFilter) {
         const body = parsed.content.trim();
         const signalKey = normalizeSignal(firstNonEmpty([title, description, searchHints[0]]));
         records.push({
-            ref: makeAssetRef("memory", name),
+            ref: `memory:${name}`,
             name,
             filePath,
             parentRef,
@@ -596,7 +599,11 @@ function collectDerivedMemories(stashDir, parentRefFilter) {
             tags,
             searchHints,
             body,
-            canonicalName: name === `${parentRef.slice("memory:".length)}${DERIVED_SUFFIX}`,
+            // parentRef is the 0.9.0 `memories/<name>` conceptId (Group-C item 2), so
+            // the canonical-child test compares the minted conceptId of the suffix-
+            // stripped name against it rather than slicing a fixed `memory:` prefix.
+            canonicalName: name.endsWith(DERIVED_SUFFIX) &&
+                parentRef === conceptIdFromTypeName("memory", name.slice(0, -DERIVED_SUFFIX.length)),
             signalScore: computeSignalScore(title, description, tags, searchHints, body),
             fingerprint: buildFingerprint(title, description, tags, searchHints, body),
             ...(signalKey ? { signalKey } : {}),
@@ -647,25 +654,19 @@ function resolveBeliefState(frontmatter) {
     }
     return "active";
 }
-function isDerivedMemory(name, frontmatter) {
-    return frontmatter.inferred === true || name.endsWith(DERIVED_SUFFIX);
-}
-function resolveParentRef(name, frontmatter) {
-    const fromSource = parseMemoryRef(asNonEmptyString(frontmatter.source));
-    if (fromSource)
-        return fromSource;
-    const derivedFrom = asNonEmptyString(frontmatter.derivedFrom);
-    if (derivedFrom)
-        return makeAssetRef("memory", derivedFrom);
-    if (name.endsWith(DERIVED_SUFFIX)) {
-        return makeAssetRef("memory", name.slice(0, -DERIVED_SUFFIX.length));
-    }
-    return undefined;
-}
+// Belief-edge refs (contradictedBy / supersededBy / currentBeliefRefs) are the
+// IDENTITY channel: they are compared against a derived memory's own
+// `memory:<name>` ref (resolveFamilyContradictions' familyRefSet,
+// firstExistingRef's byRef map), so they are NORMALIZED to `memory:<name>` here.
+// On disk they arrive in either spelling — `memory:<name>` from pre-0.9.0
+// writes, or the `[<bundle>//]memories/<name>` conceptId that
+// `writeSupersededEdge`/`writeContradictEdge` persist today — and
+// `parseMemoryName` accepts both. Reading only the first spelling silently
+// dropped every edge the current write path produces.
 function refArray(value) {
     if (typeof value === "string") {
-        const parsed = parseMemoryRef(value);
-        return parsed ? [parsed] : [];
+        const name = parseMemoryName(value);
+        return name === undefined ? [] : [memoryIdentityRef(name)];
     }
     if (!Array.isArray(value))
         return [];
@@ -673,25 +674,12 @@ function refArray(value) {
     for (const item of value) {
         if (typeof item !== "string")
             continue;
-        const parsed = parseMemoryRef(item);
-        if (parsed)
-            refs.add(parsed);
+        const name = parseMemoryName(item);
+        if (name !== undefined)
+            refs.add(memoryIdentityRef(name));
     }
     return [...refs].sort();
 }
-function parseMemoryRef(value) {
-    if (!value)
-        return undefined;
-    try {
-        const parsed = parseAssetRef(value.trim());
-        if (parsed.type !== "memory")
-            return undefined;
-        return makeAssetRef(parsed.type, parsed.name);
-    }
-    catch {
-        return undefined;
-    }
-}
 function buildFingerprint(title, description, tags, searchHints, body) {
     return JSON.stringify({
         title: normalizeSignal(title),