anno-extension 0.1.0

package/src/engine-reinforce.ts

@@ -0,0 +1,154 @@
+/**
+ * [WHO]: Provides reinforceProcedural, reinforceEpisodeMemories, reinforceEpisodeFacets, reinforceV2SemanticMemories, reinforceWork, reconsolidateV2AfterRecall, reconsolidateIfNeeded
+ * [FROM]: Depends on ./store.js, ./store-v2.js, ./eviction.js, ./linking.js, ./scoring.js, ./reconsolidate-v2.js, ./i18n.js, ./types.js, ./types-v2.js
+ * [TO]: Consumed by engine.ts (getMemoryInjection)
+ * [HERE]: packages/mem-core/src/engine-reinforce.ts - memory reinforcement and reconsolidation after recall
+ */
+
+import { PROMPTS } from "./i18n.js";
+import { reinforceRelations } from "./linking.js";
+import { reconsolidateV2Memories } from "./reconsolidate-v2.js";
+import { extractTags, tagOverlap } from "./scoring.js";
+import { saveEntries, saveWork } from "./store.js";
+import {
+	loadV2Meta,
+	saveV2Episodes,
+	saveV2Facets,
+	saveV2Meta,
+	saveV2Procedural,
+	saveV2Semantic,
+	type NanoMemV2Paths,
+} from "./store-v2.js";
+import type { LlmFn, MemoryEntry, WorkEntry } from "./types.js";
+import type { EpisodeFacet, EpisodeMemory, ProceduralMemory, SemanticMemory } from "./types-v2.js";
+import { utilityEntry, utilityWork } from "./eviction.js";
+import type { NanomemConfig } from "./config.js";
+
+export async function reinforceProcedural(recalled: ProceduralMemory[], all: ProceduralMemory[], v2Paths: NanoMemV2Paths): Promise<void> {
+	if (!recalled.length) return;
+	const ids = new Set(recalled.map((entry) => entry.id));
+	const now = new Date().toISOString();
+	for (const entry of all) {
+		if (!ids.has(entry.id)) continue;
+		entry.accessCount = (entry.accessCount ?? 0) + 1;
+		entry.lastAccessedAt = now;
+		entry.updatedAt = entry.updatedAt || now;
+	}
+	await saveV2Procedural(v2Paths, all);
+}
+
+export async function reinforceEpisodeMemories(recalled: EpisodeMemory[], all: EpisodeMemory[], v2Paths: NanoMemV2Paths): Promise<void> {
+	if (!recalled.length) return;
+	const ids = new Set(recalled.map((entry) => entry.id));
+	const now = new Date().toISOString();
+	for (const entry of all) {
+		if (!ids.has(entry.id)) continue;
+		entry.accessCount = (entry.accessCount ?? 0) + 1;
+		entry.lastAccessedAt = now;
+		entry.updatedAt = entry.updatedAt || now;
+	}
+	await saveV2Episodes(v2Paths, all);
+}
+
+export async function reinforceEpisodeFacets(recalled: EpisodeFacet[], all: EpisodeFacet[], v2Paths: NanoMemV2Paths): Promise<void> {
+	if (!recalled.length) return;
+	const ids = new Set(recalled.map((entry) => entry.id));
+	const now = new Date().toISOString();
+	for (const entry of all) {
+		if (!ids.has(entry.id)) continue;
+		entry.accessCount = (entry.accessCount ?? 0) + 1;
+		entry.lastAccessedAt = now;
+		entry.updatedAt = entry.updatedAt || now;
+	}
+	await saveV2Facets(v2Paths, all);
+}
+
+export async function reinforceV2SemanticMemories(recalled: SemanticMemory[], all: SemanticMemory[], v2Paths: NanoMemV2Paths): Promise<void> {
+	if (!recalled.length) return;
+	const ids = new Set(recalled.map((entry) => entry.id));
+	const now = new Date().toISOString();
+	for (const entry of all) {
+		if (!ids.has(entry.id)) continue;
+		entry.accessCount = (entry.accessCount ?? 0) + 1;
+		entry.lastAccessedAt = now;
+		entry.updatedAt = entry.updatedAt || now;
+	}
+	await saveV2Semantic(v2Paths, all);
+}
+
+export async function reinforceWork(
+	recalled: WorkEntry[], all: WorkEntry[],
+	workPath: string, cfg: NanomemConfig,
+): Promise<void> {
+	const ids = new Set(recalled.map((w) => w.id));
+	const now = new Date().toISOString();
+	for (const w of all) {
+		if (ids.has(w.id)) {
+			w.accessCount = (w.accessCount ?? 0) + 1;
+			w.lastAccessed = now;
+			w.strength = (w.strength || 45) * cfg.strengthGrowthFactor;
+		}
+	}
+	await saveWork(workPath, all, cfg.maxEntries.work, (w) =>
+		utilityWork(w, cfg.halfLife, cfg.evictionWeights),
+	);
+}
+
+export async function reconsolidateV2AfterRecall(
+	episodes: EpisodeMemory[],
+	facets: EpisodeFacet[],
+	procedural: ProceduralMemory[],
+	recalledEpisodes: EpisodeMemory[],
+	recalledFacets: EpisodeFacet[],
+	recalledProcedural: ProceduralMemory[],
+	v2Paths: NanoMemV2Paths,
+	rebuildLinksFn: () => Promise<void>,
+): Promise<void> {
+	const reconsolidated = reconsolidateV2Memories(
+		episodes,
+		facets,
+		procedural,
+		recalledEpisodes.map((entry) => entry.id),
+		recalledFacets.map((entry) => entry.id),
+		recalledProcedural.map((entry) => entry.id),
+	);
+	await Promise.all([
+		saveV2Episodes(v2Paths, reconsolidated.episodes),
+		saveV2Facets(v2Paths, reconsolidated.facets),
+		saveV2Procedural(v2Paths, reconsolidated.procedural),
+		saveV2Meta(v2Paths, {
+			...(await loadV2Meta(v2Paths)),
+			lastReconsolidationAt: new Date().toISOString(),
+		}),
+	]);
+	await rebuildLinksFn();
+}
+
+export async function reconsolidateIfNeeded(
+	recalled: MemoryEntry[],
+	contextTags: string[],
+	locale: string,
+	llmFn: LlmFn,
+): Promise<void> {
+	const p = PROMPTS[locale];
+	for (const entry of recalled) {
+		const overlap = tagOverlap(entry.tags, contextTags);
+		if (overlap >= 0.3) continue;
+		try {
+			const memText = entry.detail || entry.summary || entry.content || "";
+			const updated = await llmFn(
+				p.reconsolidationSystem,
+				`Original memory: ${memText}\n\nCurrent context tags: ${contextTags.join(", ")}`,
+			);
+			if (updated && updated.length > 10) {
+				const trimmed = updated.trim();
+				entry.detail = trimmed;
+				entry.content = trimmed;
+				entry.summary = trimmed.length <= 150 ? trimmed : `${trimmed.slice(0, 147)}...`;
+				entry.tags = extractTags(trimmed);
+			}
+		} catch {
+			/* graceful degradation */
+		}
+	}
+}

package/src/engine-scoring-v2.ts

@@ -0,0 +1,188 @@
+/**
+ * [WHO]: Provides currentStructuralAnchor, computeStructuralBoost, scoreEpisodeMemory, scoreEpisodeFacet, scoreV2SemanticMemory, scoreProceduralMemory
+ * [FROM]: Depends on ./scoring.js for daysSince, extractTags, tagOverlap; ./types-v2.js for V2 memory types; ./turn-context.js for the generic per-turn hint bus
+ * [TO]: Consumed by engine.ts, engine-recall-select.ts, engine-episode-sync.ts, engine-v2-mapping.ts
+ * [HERE]: packages/mem-core/src/engine-scoring-v2.ts - V2 memory scoring and structural proximity computation; reads structural anchors from any extension that publishes to the turn-context bus
+ */
+
+import { daysSince, extractTags, tagOverlap } from "./scoring.js";
+import { getTurnContext } from "./turn-context.js";
+import type { BaseMemoryV2, EpisodeFacet, EpisodeMemory, ProceduralMemory, SemanticMemory } from "./types-v2.js";
+
+type MemoryWithModifiedFiles = BaseMemoryV2 & { filesModified?: unknown };
+
+/** Read the current structural anchor (or undefined when no producer has published one). */
+export function currentStructuralAnchor(): { modulePath?: string; filePath?: string } | undefined {
+	const anchor = getTurnContext("structuralAnchor");
+	if (!anchor || (!anchor.modulePath && !anchor.filePath)) return undefined;
+	return {
+		modulePath: anchor.modulePath,
+		filePath: anchor.filePath,
+	};
+}
+
+/** Match two paths that may differ in absolute/relative form. */
+function pathsOverlap(a: string, b: string): boolean {
+	if (a === b) return true;
+	if (a.startsWith(b + "/") || b.startsWith(a + "/")) return true;
+	// Suffix alignment: absolute vs relative (e.g. "/root/proj/core/x.ts" vs "core/x.ts")
+	if (a.endsWith("/" + b) || b.endsWith("/" + a)) return true;
+	return false;
+}
+
+/**
+ * Compute structural proximity boost from the active turn's structural anchor.
+ * Reads from the generic turn-context bus; returns 0 when no anchor has been
+ * published or when no overlap with the entry's paths is found. Producer-agnostic.
+ */
+export function computeStructuralBoost(entry: BaseMemoryV2): number {
+	const anchor = getTurnContext("structuralAnchor");
+	const anchorPaths = anchor?.candidatePaths;
+	if (!anchorPaths || anchorPaths.length === 0) return 0;
+
+	const entryPaths: string[] = [];
+	if (entry.structuralAnchor) {
+		if (entry.structuralAnchor.modulePath) entryPaths.push(entry.structuralAnchor.modulePath);
+		if (entry.structuralAnchor.filePath) entryPaths.push(entry.structuralAnchor.filePath);
+	}
+	if (entry.evidence) {
+		for (const ev of entry.evidence) {
+			if (ev.filePath) entryPaths.push(ev.filePath);
+		}
+	}
+	const modifiedFiles = (entry as MemoryWithModifiedFiles).filesModified;
+	if (Array.isArray(modifiedFiles)) {
+		for (const f of modifiedFiles) {
+			if (typeof f === "string") entryPaths.push(f);
+		}
+	}
+
+	// Fallback: infer module paths from tags when no explicit paths exist.
+	// Tags often contain path segments like "core/platform/config" or filenames.
+	// Use a weak match (0.5× weight via reduced return) to avoid conflating
+	// with the relevance signal which already scores tag overlap.
+	if (entryPaths.length === 0) {
+		const PATH_LIKE = /^[a-z][\w-]*(?:\/[\w.-]+)+$/;
+		const tagPaths = entry.tags.filter((t) => PATH_LIKE.test(t));
+		if (tagPaths.length === 0) return 0;
+		let tagHits = 0;
+		for (const t of tagPaths) {
+			for (const a of anchorPaths) {
+				if (pathsOverlap(t, a)) { tagHits++; break; }
+			}
+		}
+		// Attenuate: tag-inferred paths are weaker evidence than explicit anchors
+		return Math.min(tagHits / tagPaths.length, 1) * 0.5;
+	}
+
+	let hits = 0;
+	for (const p of entryPaths) {
+		for (const a of anchorPaths) {
+			if (pathsOverlap(p, a)) { hits++; break; }
+		}
+	}
+	return Math.min(hits / entryPaths.length, 1);
+}
+
+/** Score breakdown for eval collection. All fields are the raw component values before final combination. */
+export interface V2ScoreBreakdown {
+	recency: number;
+	importance: number;
+	relevance: number;
+	structural: number;
+	final: number;
+}
+
+export function breakdownEpisodeMemory(entry: EpisodeMemory, project: string, contextTags: string[], structuralWeight: number): V2ScoreBreakdown {
+	const projectBoost = !project ? 0.8 : entry.scope?.project === project ? 1 : 0.55;
+	const tagScore = tagOverlap(entry.tags, contextTags);
+	const summaryTags = extractTags(`${entry.title ?? ""} ${entry.summary} ${entry.userGoal ?? ""} ${entry.outcome ?? ""}`);
+	const semanticScore = tagOverlap(summaryTags, contextTags);
+	const recency = 1 / (1 + daysSince(entry.updatedAt || entry.createdAt));
+	const salienceBoost = (entry.salience ?? entry.importance) / 10;
+	const structural = computeStructuralBoost(entry);
+	const relevance = projectBoost * (0.45 + 0.55 * Math.max(tagScore, semanticScore));
+	const final = relevance + recency * 0.18 + salienceBoost * 0.22 + structural * structuralWeight;
+	return { recency, importance: salienceBoost, relevance, structural, final };
+}
+
+export function breakdownEpisodeFacet(entry: EpisodeFacet, project: string, contextTags: string[], structuralWeight: number): V2ScoreBreakdown {
+	const projectBoost = !project ? 0.8 : entry.scope?.project === project ? 1 : 0.55;
+	const tagScore = tagOverlap(entry.tags, contextTags);
+	const semanticTags = extractTags(`${entry.searchText} ${entry.anchorText ?? ""} ${entry.summary ?? ""}`);
+	const semanticScore = tagOverlap(semanticTags, contextTags);
+	const recency = 1 / (1 + daysSince(entry.updatedAt || entry.createdAt));
+	const salienceBoost = (entry.salience ?? entry.importance) / 10;
+	const structural = computeStructuralBoost(entry);
+	const relevance = projectBoost * (0.45 + 0.55 * Math.max(tagScore, semanticScore));
+	const final = relevance + recency * 0.15 + salienceBoost * 0.24 + structural * structuralWeight;
+	return { recency, importance: salienceBoost, relevance, structural, final };
+}
+
+export function breakdownV2Semantic(entry: SemanticMemory, project: string, contextTags: string[], structuralWeight: number): V2ScoreBreakdown {
+	const projectBoost = !project ? 0.8 : entry.scope?.project === project ? 1 : 0.55;
+	const tagScore = tagOverlap(entry.tags, contextTags);
+	const semanticTags = extractTags(`${entry.name} ${entry.summary} ${entry.detail ?? ""}`);
+	const semanticScore = tagOverlap(semanticTags, contextTags);
+	const recency = 1 / (1 + daysSince(entry.updatedAt || entry.createdAt));
+	const salienceBoost = (entry.salience ?? entry.importance) / 10;
+	const structural = computeStructuralBoost(entry);
+	const relevance = projectBoost * (0.45 + 0.55 * Math.max(tagScore, semanticScore));
+	const final = relevance + recency * 0.14 + salienceBoost * 0.2 + structural * structuralWeight;
+	return { recency, importance: salienceBoost, relevance, structural, final };
+}
+
+export function breakdownProcedural(entry: ProceduralMemory, project: string, contextTags: string[], structuralWeight: number): V2ScoreBreakdown {
+	const projectBoost = !project ? 0.8 : entry.scope?.project === project ? 1 : 0.55;
+	const tagScore = tagOverlap(entry.tags, contextTags);
+	const summaryTags = extractTags(`${entry.searchText} ${entry.summary} ${entry.contextText ?? ""}`);
+	const semanticScore = tagOverlap(summaryTags, contextTags);
+	const recency = 1 / (1 + daysSince(entry.updatedAt || entry.createdAt));
+	const statusBoost = entry.status === "active" ? 0.2 : entry.status === "draft" ? 0.05 : -0.2;
+	const salienceBoost = (entry.salience ?? entry.importance) / 10;
+	const structural = computeStructuralBoost(entry);
+	const relevance = projectBoost * (0.45 + 0.55 * Math.max(tagScore, semanticScore));
+	const final = relevance + recency * 0.15 + salienceBoost * 0.2 + statusBoost + structural * structuralWeight;
+	return { recency, importance: salienceBoost, relevance, structural, final };
+}
+
+export function scoreEpisodeMemory(entry: EpisodeMemory, project: string, contextTags: string[], structuralWeight: number): number {
+	const projectBoost = !project ? 0.8 : entry.scope?.project === project ? 1 : 0.55;
+	const tagScore = tagOverlap(entry.tags, contextTags);
+	const summaryTags = extractTags(`${entry.title ?? ""} ${entry.summary} ${entry.userGoal ?? ""} ${entry.outcome ?? ""}`);
+	const semanticScore = tagOverlap(summaryTags, contextTags);
+	const recency = 1 / (1 + daysSince(entry.updatedAt || entry.createdAt));
+	const salienceBoost = (entry.salience ?? entry.importance) / 10;
+	return projectBoost * (0.45 + 0.55 * Math.max(tagScore, semanticScore)) + recency * 0.18 + salienceBoost * 0.22 + computeStructuralBoost(entry) * structuralWeight;
+}
+
+export function scoreEpisodeFacet(entry: EpisodeFacet, project: string, contextTags: string[], structuralWeight: number): number {
+	const projectBoost = !project ? 0.8 : entry.scope?.project === project ? 1 : 0.55;
+	const tagScore = tagOverlap(entry.tags, contextTags);
+	const semanticTags = extractTags(`${entry.searchText} ${entry.anchorText ?? ""} ${entry.summary ?? ""}`);
+	const semanticScore = tagOverlap(semanticTags, contextTags);
+	const recency = 1 / (1 + daysSince(entry.updatedAt || entry.createdAt));
+	const salienceBoost = (entry.salience ?? entry.importance) / 10;
+	return projectBoost * (0.45 + 0.55 * Math.max(tagScore, semanticScore)) + recency * 0.15 + salienceBoost * 0.24 + computeStructuralBoost(entry) * structuralWeight;
+}
+
+export function scoreV2SemanticMemory(entry: SemanticMemory, project: string, contextTags: string[], structuralWeight: number): number {
+	const projectBoost = !project ? 0.8 : entry.scope?.project === project ? 1 : 0.55;
+	const tagScore = tagOverlap(entry.tags, contextTags);
+	const semanticTags = extractTags(`${entry.name} ${entry.summary} ${entry.detail ?? ""}`);
+	const semanticScore = tagOverlap(semanticTags, contextTags);
+	const recency = 1 / (1 + daysSince(entry.updatedAt || entry.createdAt));
+	const salienceBoost = (entry.salience ?? entry.importance) / 10;
+	return projectBoost * (0.45 + 0.55 * Math.max(tagScore, semanticScore)) + recency * 0.14 + salienceBoost * 0.2 + computeStructuralBoost(entry) * structuralWeight;
+}
+
+export function scoreProceduralMemory(entry: ProceduralMemory, project: string, contextTags: string[], structuralWeight: number): number {
+	const projectBoost = !project ? 0.8 : entry.scope?.project === project ? 1 : 0.55;
+	const tagScore = tagOverlap(entry.tags, contextTags);
+	const summaryTags = extractTags(`${entry.searchText} ${entry.summary} ${entry.contextText ?? ""}`);
+	const semanticScore = tagOverlap(summaryTags, contextTags);
+	const recency = 1 / (1 + daysSince(entry.updatedAt || entry.createdAt));
+	const statusBoost = entry.status === "active" ? 0.2 : entry.status === "draft" ? 0.05 : -0.2;
+	const salienceBoost = (entry.salience ?? entry.importance) / 10;
+	return projectBoost * (0.45 + 0.55 * Math.max(tagScore, semanticScore)) + recency * 0.15 + salienceBoost * 0.2 + statusBoost + computeStructuralBoost(entry) * structuralWeight;
+}

package/src/engine-v2-mapping.ts

@@ -0,0 +1,204 @@
+/**
+ * [WHO]: Provides inferSemanticRetention/Stability/Importance, mapExtractedItemToSemanticType, upsertSemanticFromExtractedItem, semanticKindToLegacyType, semanticToRuntimeEntry, proceduralToRuntimeEntry
+ * [FROM]: Depends on ./privacy.js for filterPII; ./scoring.js for extractTags, tagOverlap; ./types.js, ./types-v2.js; ./engine-scoring-v2.js for currentStructuralAnchor
+ * [TO]: Consumed by engine.ts (extractAndStore, buildRuntimeMemoryView)
+ * [HERE]: packages/mem-core/src/engine-v2-mapping.ts - V2 type mapping and extraction-to-semantic conversion
+ */
+
+import { currentStructuralAnchor } from "./engine-scoring-v2.js";
+import { extractTags, tagOverlap } from "./scoring.js";
+import { filterPII } from "./privacy.js";
+import type { ExtractedItem, MemoryEntry, MemoryScope } from "./types.js";
+import type { ProceduralMemory, SemanticMemory } from "./types-v2.js";
+
+export function inferSemanticRetention(item: ExtractedItem): SemanticMemory["retention"] {
+	if (item.retention) return item.retention;
+	if (item.stability === "situational" || item.stateData) return "ambient";
+	switch (item.type) {
+		case "preference":
+		case "pattern":
+			return "core";
+		case "lesson":
+		case "decision":
+		case "event":
+		case "struggle":
+			return "key-event";
+		default:
+			return "ambient";
+	}
+}
+
+export function inferSemanticStability(item: ExtractedItem): SemanticMemory["stability"] {
+	if (item.stability === "situational") return "situational";
+	if (item.stateData) return "volatile";
+	switch (item.type) {
+		case "preference":
+		case "pattern":
+			return "stable";
+		case "event":
+		case "struggle":
+			return "situational";
+		default:
+			return "stable";
+	}
+}
+
+export function inferSemanticImportance(item: ExtractedItem): number {
+	switch (item.type) {
+		case "struggle":
+		case "event":
+			return 9;
+		case "lesson":
+		case "decision":
+			return 8;
+		case "pattern":
+			return 7;
+		case "preference":
+			return 6;
+		default:
+			return 5;
+	}
+}
+
+export function mapExtractedItemToSemanticType(item: ExtractedItem): SemanticMemory["semanticType"] {
+	switch (item.type) {
+		case "lesson":
+			return "lesson";
+		case "preference":
+			return "preference";
+		case "decision":
+			return "decision";
+		case "pattern":
+			return "pattern";
+		case "struggle":
+			return "struggle";
+		case "event":
+			return "event";
+		default:
+			return "fact";
+	}
+}
+
+export function upsertSemanticFromExtractedItem(
+	semantic: SemanticMemory[],
+	item: ExtractedItem,
+	project: string,
+	defaultScope: MemoryScope | undefined,
+): void {
+	if (item.type === "retract") return;
+	const detail = filterPII(item.detail || item.content || "");
+	const name = item.name || detail.slice(0, 30) || item.summary || "memory";
+	const summary = item.summary || detail.slice(0, 150) || name;
+	const semanticType = mapExtractedItemToSemanticType(item);
+	const tags = extractTags(`${name} ${summary} ${detail}`);
+	const now = new Date().toISOString();
+	const existing = semantic.find(
+		(entry) =>
+			entry.semanticType === semanticType &&
+			entry.scope?.project === project &&
+			(tagOverlap(entry.tags, tags) >= 0.72 ||
+				`${entry.name} ${entry.summary}`.trim().toLowerCase() === `${name} ${summary}`.trim().toLowerCase()),
+	);
+	if (existing) {
+		existing.name = name;
+		existing.summary = summary;
+		existing.detail = detail || existing.detail;
+		existing.tags = [...new Set(tags)];
+		existing.updatedAt = now;
+		existing.retention = inferSemanticRetention(item);
+		existing.stability = inferSemanticStability(item);
+		existing.salience = Math.max(existing.salience, inferSemanticImportance(item));
+		existing.importance = Math.max(existing.importance, inferSemanticImportance(item));
+		return;
+	}
+
+	semantic.push({
+		id: `semantic:extract:${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+		kind: "semantic",
+		semanticType,
+		name,
+		summary,
+		detail,
+		accessCount: 0,
+		importance: inferSemanticImportance(item),
+		salience: Math.max(4, inferSemanticImportance(item)),
+		confidence: 0.8,
+		retention: inferSemanticRetention(item),
+		stability: inferSemanticStability(item),
+		tags,
+		evidence: [],
+		scope: { ...defaultScope, project },
+		createdAt: now,
+		updatedAt: now,
+		abstractionLevel: semanticType === "event" ? "instance" : "generalization",
+		structuralAnchor: currentStructuralAnchor(),
+	});
+}
+
+export function semanticKindToLegacyType(kind: SemanticMemory["semanticType"]): MemoryEntry["type"] {
+	switch (kind) {
+		case "lesson":
+			return "lesson";
+		case "preference":
+			return "preference";
+		case "decision":
+			return "decision";
+		case "event":
+			return "event";
+		case "pattern":
+			return "pattern";
+		case "struggle":
+			return "struggle";
+		default:
+			return "fact";
+	}
+}
+
+export function semanticToRuntimeEntry(entry: SemanticMemory): MemoryEntry {
+	const type = semanticKindToLegacyType(entry.semanticType);
+	return {
+		id: entry.id,
+		type,
+		name: entry.name,
+		summary: entry.summary,
+		detail: entry.detail,
+		content: entry.detail || entry.summary,
+		tags: entry.tags,
+		project: entry.scope?.project || "default",
+		importance: entry.importance,
+		strength: undefined,
+		created: entry.createdAt,
+		eventTime: entry.validFrom ?? entry.createdAt,
+		lastAccessed: entry.lastAccessedAt,
+		accessCount: entry.accessCount,
+		relatedIds: [...new Set([...(entry.supersedesIds ?? []), ...(entry.conflictWithIds ?? [])])],
+		scope: entry.scope,
+		retention: entry.retention === "ambient" ? "ambient" : entry.retention === "core" ? "core" : "key-event",
+		salience: entry.salience,
+		stability: entry.stability === "volatile" ? "situational" : entry.stability === "stable" ? "stable" : "situational",
+	};
+}
+
+export function proceduralToRuntimeEntry(entry: ProceduralMemory): MemoryEntry {
+	return {
+		id: entry.id,
+		type: "decision",
+		name: entry.name,
+		summary: entry.summary,
+		detail: [entry.contextText, entry.boundaries, entry.steps.map((step) => step.text).join("\n")].filter(Boolean).join("\n"),
+		content: entry.summary,
+		tags: entry.tags,
+		project: entry.scope?.project || "default",
+		importance: entry.importance,
+		strength: undefined,
+		created: entry.createdAt,
+		eventTime: entry.validFrom ?? entry.createdAt,
+		lastAccessed: entry.lastAccessedAt,
+		accessCount: entry.accessCount,
+		relatedIds: entry.supersedesIds,
+		scope: entry.scope,
+		retention: entry.retention === "ambient" ? "ambient" : entry.retention === "core" ? "core" : "key-event",
+		salience: entry.salience,
+		stability: entry.stability === "volatile" ? "situational" : entry.stability === "stable" ? "stable" : "situational",
+	};
+}