anno-extension 0.1.0

package/src/engine-links.ts

@@ -0,0 +1,311 @@
+/**
+ * [WHO]: Provides AUTO_V2_LINK_PREFIX, buildProceduralChains, materializeV2Links, detectProceduralConflicts, detectSemanticConflicts, detectAlignmentConflicts, suggestConflictAction, explainConflictAction
+ * [FROM]: Depends on ./scoring.js for daysSince, extractTags, tagOverlap; ./types.js, ./types-v2.js
+ * [TO]: Consumed by engine.ts (rebuildV2Links, inspectV2Memory, getAlignmentSnapshot)
+ * [HERE]: packages/mem-core/src/engine-links.ts - V2 link materialization, conflict detection, procedural chain building
+ */
+
+import { daysSince, extractTags, tagOverlap } from "./scoring.js";
+import type { MemoryEntry } from "./types.js";
+import type { MemoryLink, ProceduralMemory, SemanticMemory } from "./types-v2.js";
+
+export const AUTO_V2_LINK_PREFIX = "auto:v2:";
+
+// ── Procedural chains ──────────────────────────────────────
+
+export function buildProceduralChains(entries: ProceduralMemory[]): Array<{
+	rootId: string;
+	name: string;
+	status: ProceduralMemory["status"];
+	versionDepth: number;
+	ids: string[];
+}> {
+	const byId = new Map(entries.map((entry) => [entry.id, entry]));
+	const roots = entries.filter((entry) => !entry.supersededById || !byId.has(entry.supersededById));
+	return roots
+			.map((root) => {
+			const ids = new Set<string>();
+			const stack = [root.id];
+			while (stack.length) {
+				const currentId = stack.pop();
+				if (!currentId || ids.has(currentId)) continue;
+				ids.add(currentId);
+				for (const entry of entries) {
+					if (entry.supersededById === currentId) stack.push(entry.id);
+					if (entry.supersedesIds?.includes(currentId)) stack.push(entry.id);
+				}
+			}
+			const chainEntries = [...ids].map((id) => byId.get(id)).filter((entry): entry is ProceduralMemory => Boolean(entry));
+			return {
+				rootId: root.id,
+				name: root.name,
+				status: root.status,
+				versionDepth: chainEntries.length,
+				ids: chainEntries
+					.sort((a, b) => {
+						const aVersion = a.version ?? 0;
+						const bVersion = b.version ?? 0;
+						if (aVersion !== bVersion) return bVersion - aVersion;
+						return a.updatedAt.localeCompare(b.updatedAt);
+					})
+					.map((entry) => entry.id),
+				};
+			})
+			.filter((chain) => chain.versionDepth > 1)
+		.sort((a, b) => b.versionDepth - a.versionDepth || a.name.localeCompare(b.name));
+}
+
+// ── V2 link materialization ────────────────────────────────
+
+export function materializeV2Links(
+	semantic: SemanticMemory[],
+	procedural: ProceduralMemory[],
+	existingLinks: MemoryLink[],
+	autoLinkPrefix: string,
+	now = new Date().toISOString(),
+): MemoryLink[] {
+	const manualLinks = existingLinks.filter((link) => !link.id.startsWith(autoLinkPrefix));
+	const autoLinks = new Map<string, MemoryLink>();
+	const proceduralConflicts = detectProceduralConflicts(
+		procedural.filter((entry) => entry.status !== "deprecated" && entry.status !== "superseded"),
+	);
+	const semanticConflicts = detectSemanticConflicts(semantic);
+
+	const addAutoLink = (
+		fromId: string,
+		toId: string,
+		type: MemoryLink["type"],
+		weight: number,
+		evidence: MemoryLink["evidence"] = [],
+	): void => {
+		if (!fromId || !toId || fromId === toId) return;
+		const directional = type === "supersedes";
+		const [normalizedFrom, normalizedTo] = directional || fromId < toId ? [fromId, toId] : [toId, fromId];
+		const id = `${autoLinkPrefix}${type}:${normalizedFrom}->${normalizedTo}`;
+		autoLinks.set(id, {
+			id,
+			fromId: normalizedFrom,
+			toId: normalizedTo,
+			type,
+			weight,
+			explicit: false,
+			createdAt: autoLinks.get(id)?.createdAt ?? now,
+			updatedAt: now,
+			evidence,
+		});
+	};
+
+	for (const entry of semantic) {
+		for (const supersededId of entry.supersedesIds ?? []) {
+			addAutoLink(entry.id, supersededId, "supersedes", 0.92);
+		}
+		if (entry.supersededById) {
+			addAutoLink(entry.supersededById, entry.id, "supersedes", 0.92);
+		}
+	}
+
+	for (const entry of procedural) {
+		for (const supersededId of entry.supersedesIds ?? []) {
+			addAutoLink(entry.id, supersededId, "supersedes", 0.94);
+		}
+		if (entry.supersededById) {
+			addAutoLink(entry.supersededById, entry.id, "supersedes", 0.94);
+		}
+	}
+
+	for (const conflict of semanticConflicts) {
+		addAutoLink(conflict.aId, conflict.bId, "conflicts-with", 0.88);
+	}
+
+	for (const conflict of proceduralConflicts) {
+		addAutoLink(conflict.aId, conflict.bId, "conflicts-with", Math.max(0.72, conflict.score));
+	}
+
+	return [...manualLinks, ...autoLinks.values()].sort((a, b) => a.id.localeCompare(b.id));
+}
+
+// ── Conflict detection ─────────────────────────────────────
+
+export function detectProceduralConflicts(entries: ProceduralMemory[]): Array<{
+	aId: string;
+	bId: string;
+	aName: string;
+	bName: string;
+	score: number;
+	reason: string;
+}> {
+	const conflicts: Array<{
+		aId: string;
+		bId: string;
+		aName: string;
+		bName: string;
+		score: number;
+		reason: string;
+	}> = [];
+	for (let i = 0; i < entries.length; i++) {
+		for (let j = i + 1; j < entries.length; j++) {
+			const a = entries[i];
+			const b = entries[j];
+			if (!a || !b || a.id === b.id) continue;
+			const tagScore = tagOverlap(a.tags ?? [], b.tags ?? []);
+			const lexicalScore = tagOverlap(
+				extractTags(`${a.name} ${a.searchText} ${a.summary}`),
+				extractTags(`${b.name} ${b.searchText} ${b.summary}`),
+			);
+			const similarity = Math.max(tagScore, lexicalScore);
+			const sameIntent =
+				a.searchText.trim().toLowerCase() === b.searchText.trim().toLowerCase() ||
+				a.name.trim().toLowerCase() === b.name.trim().toLowerCase();
+			const boundariesDiffer =
+				(a.boundaries ?? "").trim().toLowerCase() !== (b.boundaries ?? "").trim().toLowerCase() ||
+				(a.contextText ?? "").trim().toLowerCase() !== (b.contextText ?? "").trim().toLowerCase();
+			if ((similarity >= 0.72 || sameIntent) && boundariesDiffer) {
+				conflicts.push({
+					aId: a.id,
+					bId: b.id,
+					aName: a.name,
+					bName: b.name,
+					score: Number(similarity.toFixed(3)),
+					reason: "High-overlap active procedures differ in boundaries or context.",
+				});
+			}
+		}
+	}
+	return conflicts.sort((a, b) => b.score - a.score || a.aName.localeCompare(b.aName));
+}
+
+export function detectSemanticConflicts(entries: SemanticMemory[]): Array<{
+	aId: string;
+	bId: string;
+	aName: string;
+	bName: string;
+	reason: string;
+}> {
+	const byId = new Map(entries.map((entry) => [entry.id, entry]));
+	const seen = new Set<string>();
+	const conflicts: Array<{
+		aId: string;
+		bId: string;
+		aName: string;
+		bName: string;
+		reason: string;
+	}> = [];
+	for (const entry of entries) {
+		for (const conflictId of entry.conflictWithIds ?? []) {
+			const other = byId.get(conflictId);
+			if (!other) continue;
+			const pairKey = [entry.id, other.id].sort().join("::");
+			if (seen.has(pairKey)) continue;
+			seen.add(pairKey);
+			conflicts.push({
+				aId: entry.id,
+				bId: other.id,
+				aName: entry.name,
+				bName: other.name,
+				reason: "Explicit semantic conflict link.",
+			});
+		}
+	}
+	return conflicts.sort((a, b) => a.aName.localeCompare(b.aName) || a.bName.localeCompare(b.bName));
+}
+
+// ── Alignment conflict detection ───────────────────────────
+
+export function detectAlignmentConflicts(
+	entries: MemoryEntry[],
+): Array<{
+	aId: string;
+	bId: string;
+	reason: string;
+	severity: number;
+	recommendation: "merge" | "demote" | "forget" | "mark-situational";
+	rationale: string;
+}> {
+	const candidates = entries.filter(
+		(entry) =>
+			entry.stability !== "situational" &&
+			(entry.retention === "core" || entry.retention === "key-event") &&
+			!!(entry.summary || entry.detail || entry.name),
+	);
+	const conflicts: Array<{
+		aId: string;
+		bId: string;
+		reason: string;
+		severity: number;
+		recommendation: "merge" | "demote" | "forget" | "mark-situational";
+		rationale: string;
+	}> = [];
+	const seen = new Set<string>();
+	const positiveMarkers = ["prefer", "always", "use", "enable", "include", "like", "keep", "should"];
+	const negativeMarkers = ["avoid", "never", "disable", "remove", "dislike", "hate", "stop", "do not", "don't"];
+	const getText = (entry: MemoryEntry) =>
+		`${entry.name || ""} ${entry.summary || ""} ${entry.detail || ""}`.toLowerCase();
+	const polarity = (text: string): "positive" | "negative" | "neutral" => {
+		const hasPositive = positiveMarkers.some((marker) => text.includes(marker));
+		const hasNegative = negativeMarkers.some((marker) => text.includes(marker));
+		if (hasPositive && !hasNegative) return "positive";
+		if (hasNegative && !hasPositive) return "negative";
+		return "neutral";
+	};
+
+	for (let i = 0; i < candidates.length; i++) {
+		for (let j = i + 1; j < candidates.length; j++) {
+			const a = candidates[i]!;
+			const b = candidates[j]!;
+			if (a.id === b.id) continue;
+			const overlap = tagOverlap(a.tags, b.tags);
+			if (overlap < 0.45) continue;
+			const aPolarity = polarity(getText(a));
+			const bPolarity = polarity(getText(b));
+			if (aPolarity === "neutral" || bPolarity === "neutral" || aPolarity === bPolarity) continue;
+			const pairKey = [a.id, b.id].sort().join(":");
+			if (seen.has(pairKey)) continue;
+			seen.add(pairKey);
+			const severity = Math.min(
+				1,
+				overlap * 0.6 + ((a.salience ?? a.importance) + (b.salience ?? b.importance)) / 20 * 0.4,
+			);
+			const reason = `Potential conflict on shared context: ${aPolarity} vs ${bPolarity}`;
+			const recommendation = suggestConflictAction(a, b, severity);
+			const rationale = explainConflictAction(a, b, recommendation);
+			conflicts.push({ aId: a.id, bId: b.id, reason, severity, recommendation, rationale });
+		}
+	}
+
+	return conflicts.sort((a, b) => b.severity - a.severity);
+}
+
+export function suggestConflictAction(
+	a: MemoryEntry,
+	b: MemoryEntry,
+	severity: number,
+): "merge" | "demote" | "forget" | "mark-situational" {
+	const aStable = a.stability !== "situational";
+	const bStable = b.stability !== "situational";
+	const aRecent = daysSince(a.created) <= 14;
+	const bRecent = daysSince(b.created) <= 14;
+	const aLowSignal = (a.salience ?? a.importance) <= 4;
+	const bLowSignal = (b.salience ?? b.importance) <= 4;
+
+	if (aStable !== bStable) return "mark-situational";
+	if (severity >= 0.8 && (aLowSignal || bLowSignal)) return "forget";
+	if (severity >= 0.65 && (aRecent || bRecent)) return "demote";
+	return "merge";
+}
+
+export function explainConflictAction(
+	a: MemoryEntry,
+	b: MemoryEntry,
+	action: "merge" | "demote" | "forget" | "mark-situational",
+): string {
+	switch (action) {
+		case "mark-situational":
+			return "One side looks more temporary than the other, so this conflict likely comes from short-term context rather than true identity drift.";
+		case "forget":
+			return "One side has weak signal compared with the conflict risk, so forgetting the weaker memory is safer than keeping both.";
+		case "demote":
+			return "At least one side is recent enough that it may be an overfit; demoting it reduces the chance of personality drift.";
+		default:
+			return "Both memories may describe the same preference from different angles, so a merged memory is likely safer than keeping them separate.";
+	}
+}

package/src/engine-recall-select.ts

@@ -0,0 +1,298 @@
+/**
+ * [WHO]: Provides selectRecallEntries — budget/tier/pick logic for progressive recall
+ * [FROM]: Depends on ./scoring.js for pickTop, scoreEntry, scoreEpisode, scoreWorkEntry, tierEntries; ./linking.js for getGraphNeighborhoodBySeeds; ./engine-scoring-v2.js for V2 scoring; ./engine-injection-text.js for conversation prefs
+ * [TO]: Consumed by engine.ts (getMemoryInjection)
+ * [HERE]: packages/mem-core/src/engine-recall-select.ts - recall entry selection and budget allocation
+ */
+
+import { selectConversationPreferences, mergeUniqueEntries } from "./engine-injection-text.js";
+import {
+	scoreEpisodeMemory,
+	scoreEpisodeFacet,
+	scoreV2SemanticMemory,
+	scoreProceduralMemory,
+} from "./engine-scoring-v2.js";
+import { getGraphNeighborhoodBySeeds, type GraphNeighbor } from "./linking.js";
+import {
+	pickTop,
+	scoreEntry,
+	scoreEpisode,
+	scoreWorkEntry,
+	tierEntries,
+} from "./scoring.js";
+import type { ProgressiveRecallConfig } from "./config.js";
+import type { MemoryEntry, MemoryScope, WorkEntry, Episode } from "./types.js";
+import type { EpisodeFacet, EpisodeMemory, ProceduralMemory, SemanticMemory } from "./types-v2.js";
+
+export interface RecallSelectionResult {
+	active: {
+		knowledge: MemoryEntry[];
+		lessons: MemoryEntry[];
+		events: MemoryEntry[];
+		preferences: MemoryEntry[];
+		facets: MemoryEntry[];
+		episodeMemories: EpisodeMemory[];
+		episodeFacets: EpisodeFacet[];
+		semanticMemories: SemanticMemory[];
+		procedural: ProceduralMemory[];
+	};
+	cue: {
+		knowledge: MemoryEntry[];
+		lessons: MemoryEntry[];
+		events: MemoryEntry[];
+		preferences: MemoryEntry[];
+		facets: MemoryEntry[];
+		episodes: Episode[];
+		work: WorkEntry[];
+		episodeMemories: EpisodeMemory[];
+		episodeFacets: EpisodeFacet[];
+		semanticMemories: SemanticMemory[];
+		procedural: ProceduralMemory[];
+	};
+	allEntries: MemoryEntry[];
+	graphContext: GraphNeighbor[];
+	// For reinforcement
+	injectedActiveKnowledge: MemoryEntry[];
+	injectedActiveLessons: MemoryEntry[];
+	injectedActiveEvents: MemoryEntry[];
+	injectedActivePrefs: MemoryEntry[];
+	injectedCueKnowledge: MemoryEntry[];
+	injectedCueLessons: MemoryEntry[];
+	injectedCueEvents: MemoryEntry[];
+	injectedCuePrefs: MemoryEntry[];
+	injectedCueEpisodes: Episode[];
+	legacyFacetBridgeActive: MemoryEntry[];
+	legacyFacetBridgeCue: MemoryEntry[];
+}
+
+export function selectRecallEntries(params: {
+	// Legacy entries (filtered)
+	knowledge: MemoryEntry[]; lessons: MemoryEntry[]; events: MemoryEntry[];
+	prefs: MemoryEntry[]; facets: MemoryEntry[]; work: WorkEntry[]; episodes: Episode[];
+	// V2 entries (filtered)
+	v2Episodes: EpisodeMemory[]; v2EpisodeFacets: EpisodeFacet[];
+	v2Semantic: SemanticMemory[]; procedural: ProceduralMemory[];
+	// Raw entries for graph context
+	allKnowledge: MemoryEntry[]; allLessons: MemoryEntry[]; allEvents: MemoryEntry[];
+	allPrefs: MemoryEntry[]; allFacets: MemoryEntry[];
+	// Semantic candidates from embedding search
+	semanticCandidates: Array<{ memoryId: string; memoryKind: string; score: number }>;
+	// Config
+	halfLife: Record<string, number>;
+	scoreWeights: { recency: number; importance: number; relevance: number };
+	progressiveRecall: ProgressiveRecallConfig;
+	tokenBudget: number;
+	structuralWeight: number;
+	project: string;
+	contextTags: string[];
+}): RecallSelectionResult {
+	const {
+		knowledge, lessons, events, prefs, facets, work, episodes,
+		v2Episodes, v2EpisodeFacets, v2Semantic, procedural,
+		allKnowledge, allLessons, allEvents, allPrefs, allFacets,
+		semanticCandidates, halfLife: hl, scoreWeights: sw, progressiveRecall: pr,
+		tokenBudget, structuralWeight, project, contextTags,
+	} = params;
+
+	const semanticEpisodeIds = new Set(
+		semanticCandidates.filter((item) => item.memoryKind === "episode").map((item) => item.memoryId),
+	);
+	const semanticFacetIds = new Set(
+		semanticCandidates.filter((item) => item.memoryKind === "facet").map((item) => item.memoryId),
+	);
+	const semanticProcedureIds = new Set(
+		semanticCandidates.filter((item) => item.memoryKind === "procedural").map((item) => item.memoryId),
+	);
+	const semanticV2SemanticIds = new Set(
+		semanticCandidates.filter((item) => item.memoryKind === "semantic").map((item) => item.memoryId),
+	);
+
+	// Tier all MemoryEntry categories
+	const tieredKnowledge = tierEntries(knowledge, project, contextTags, hl, sw, pr);
+	const tieredLessons = tierEntries(lessons, project, contextTags, hl, sw, pr);
+	const tieredEvents = tierEntries(events, project, contextTags, hl, sw, pr);
+	const tieredPrefs = tierEntries(prefs, project, contextTags, hl, sw, pr);
+	const tieredFacets = tierEntries(facets, project, contextTags, hl, sw, pr);
+	const forcedConversationPrefs = selectConversationPreferences(prefs);
+
+	// Budget calculation
+	const totalChars = tokenBudget * 4;
+	const activeChars = Math.floor(totalChars * pr.budgetActive);
+	const cueChars = Math.floor(totalChars * pr.budgetCue);
+	const proceduralChars = Math.floor(totalChars * 0.18);
+
+	// Entry length helpers
+	const activeLen = (e: MemoryEntry) =>
+		(e.name?.length || 0) + (e.summary?.length || 0) + (e.detail?.length || 0) + 30;
+	const cueLen = (e: MemoryEntry) => (e.name?.length || 0) + (e.summary?.length || 0) + 30;
+	const scoreFn = (e: MemoryEntry) => scoreEntry(e, project, contextTags, hl, sw);
+	const proceduralLen = (pItem: ProceduralMemory) =>
+		(pItem.name?.length || 0) + (pItem.summary?.length || 0) + pItem.steps.reduce((sum, step) => sum + step.text.length, 0) + 60;
+	const proceduralCueLen = (pItem: ProceduralMemory) =>
+		(pItem.name?.length || 0) + (pItem.summary?.length || 0) + 40;
+	const proceduralScoreFn = (pItem: ProceduralMemory) => scoreProceduralMemory(pItem, project, contextTags, structuralWeight);
+	const episodeMemoryLen = (item: EpisodeMemory) => (item.title?.length || 0) + item.summary.length + 40;
+	const episodeFacetLen = (item: EpisodeFacet) =>
+		item.searchText.length + (item.anchorText?.length || 0) + (item.summary?.length || 0) + 40;
+	const episodeCueLen = (item: EpisodeMemory) => (item.title?.length || 0) + item.summary.length + 36;
+	const episodeFacetCueLen = (item: EpisodeFacet) =>
+		item.searchText.length + (item.summary?.length || 0) + (item.anchorText?.length || 0) + 36;
+	const semanticMemoryLen = (item: SemanticMemory) =>
+		(item.name?.length || 0) + item.summary.length + (item.detail?.length || 0) + 40;
+	const semanticMemoryCueLen = (item: SemanticMemory) => (item.name?.length || 0) + item.summary.length + 36;
+	const episodeScoreFn = (item: EpisodeMemory) => scoreEpisodeMemory(item, project, contextTags, structuralWeight);
+	const episodeFacetScoreFn = (item: EpisodeFacet) => scoreEpisodeFacet(item, project, contextTags, structuralWeight);
+	const semanticMemoryScoreFn = (item: SemanticMemory) => scoreV2SemanticMemory(item, project, contextTags, structuralWeight);
+
+	// Active tier
+	const activeBudgetPer = Math.floor(activeChars / 5);
+	const activeKnowledge = pickTop(tieredKnowledge.active, scoreFn, activeLen, activeBudgetPer);
+	const activeLessons = pickTop(tieredLessons.active, scoreFn, activeLen, activeBudgetPer);
+	const activeEvents = pickTop(tieredEvents.active, scoreFn, activeLen, activeBudgetPer);
+	const activePrefs = mergeUniqueEntries(
+		forcedConversationPrefs,
+		pickTop(tieredPrefs.active, scoreFn, activeLen, activeBudgetPer),
+	);
+	const activeFacets = pickTop(tieredFacets.active, scoreFn, activeLen, activeBudgetPer);
+	const activeProcedural = pickTop(
+		procedural.filter((item) => semanticProcedureIds.has(item.id) || proceduralScoreFn(item) >= 0.45),
+		proceduralScoreFn,
+		proceduralLen,
+		Math.max(400, Math.floor(proceduralChars * 0.55)),
+	);
+	const activeEpisodeMemories = pickTop(
+		v2Episodes.filter((item) => semanticEpisodeIds.has(item.id) || episodeScoreFn(item) >= 0.45),
+		episodeScoreFn,
+		episodeMemoryLen,
+		Math.max(320, Math.floor(activeChars * 0.18)),
+	);
+	const activeEpisodeFacets = pickTop(
+		v2EpisodeFacets.filter((item) => semanticFacetIds.has(item.id) || episodeFacetScoreFn(item) >= 0.42),
+		episodeFacetScoreFn,
+		episodeFacetLen,
+		Math.max(320, Math.floor(activeChars * 0.18)),
+	);
+	const activeSemanticMemories = pickTop(
+		v2Semantic.filter((item) => semanticV2SemanticIds.has(item.id) || semanticMemoryScoreFn(item) >= 0.42),
+		semanticMemoryScoreFn,
+		semanticMemoryLen,
+		Math.max(280, Math.floor(activeChars * 0.16)),
+	);
+
+	const activeSeeds = [...activeKnowledge, ...activeLessons, ...activeEvents, ...activePrefs, ...activeFacets];
+	const allEntries = [...allKnowledge, ...allLessons, ...allEvents, ...allPrefs, ...allFacets];
+	const activeIds = new Set(activeSeeds.map((entry) => entry.id));
+	const graphContext = getGraphNeighborhoodBySeeds(activeSeeds, allEntries, 8).filter(
+		(neighbor) => !activeIds.has(neighbor.entry.id),
+	);
+
+	// Cue tier
+	const cueBudgetPer = Math.floor(cueChars / 7);
+	const cueKnowledge = pickTop(tieredKnowledge.cue, scoreFn, cueLen, cueBudgetPer);
+	const cueLessons = pickTop(tieredLessons.cue, scoreFn, cueLen, cueBudgetPer);
+	const cueEvents = pickTop(tieredEvents.cue, scoreFn, cueLen, cueBudgetPer);
+	const forcedConversationPrefIds = new Set(forcedConversationPrefs.map((entry) => entry.id));
+	const cuePrefs = pickTop(
+		tieredPrefs.cue.filter((entry) => !forcedConversationPrefIds.has(entry.id)),
+		scoreFn,
+		cueLen,
+		cueBudgetPer,
+	);
+	const cueFacets = pickTop(tieredFacets.cue, scoreFn, cueLen, cueBudgetPer);
+	const graphContextIds = new Set(graphContext.map((neighbor) => neighbor.entry.id));
+	const dedupeCue = (entries: MemoryEntry[]) => entries.filter((entry) => !graphContextIds.has(entry.id));
+	const dedupedCueKnowledge = dedupeCue(cueKnowledge);
+	const dedupedCueLessons = dedupeCue(cueLessons);
+	const dedupedCueEvents = dedupeCue(cueEvents);
+	const dedupedCuePrefs = dedupeCue(cuePrefs);
+	const dedupedCueFacets = dedupeCue(cueFacets);
+
+	const topEpisodes = pickTop(
+		episodes,
+		(ep) => scoreEpisode(ep, project, contextTags, hl, sw),
+		(ep) => ep.summary.length + 30,
+		cueBudgetPer,
+	);
+	const topWork = pickTop(
+		work,
+		(w) => scoreWorkEntry(w, project, contextTags, hl, sw),
+		(w) => w.goal.length + w.summary.length + 30,
+		cueBudgetPer,
+	);
+	const cueProcedural = pickTop(
+		procedural.filter((item) => !activeProcedural.some((activeItem) => activeItem.id === item.id)),
+		proceduralScoreFn,
+		proceduralCueLen,
+		Math.max(280, Math.floor(proceduralChars * 0.45)),
+	);
+	const cueEpisodeMemories = pickTop(
+		v2Episodes.filter((item) => !activeEpisodeMemories.some((activeItem) => activeItem.id === item.id)),
+		episodeScoreFn,
+		episodeCueLen,
+		Math.max(220, Math.floor(cueChars * 0.12)),
+	);
+	const cueEpisodeFacets = pickTop(
+		v2EpisodeFacets.filter((item) => !activeEpisodeFacets.some((activeItem) => activeItem.id === item.id)),
+		episodeFacetScoreFn,
+		episodeFacetCueLen,
+		Math.max(220, Math.floor(cueChars * 0.12)),
+	);
+	const cueSemanticMemories = pickTop(
+		v2Semantic.filter((item) => !activeSemanticMemories.some((activeItem) => activeItem.id === item.id)),
+		semanticMemoryScoreFn,
+		semanticMemoryCueLen,
+		Math.max(220, Math.floor(cueChars * 0.12)),
+	);
+
+	const legacyFacetBridgeActive = activeFacets.filter(
+		(entry) => entry.facetData?.kind === "pattern" || entry.facetData?.kind === "struggle",
+	);
+	const legacyFacetBridgeCue = dedupedCueFacets.filter(
+		(entry) => entry.facetData?.kind === "pattern" || entry.facetData?.kind === "struggle",
+	);
+	const v2SignalCount =
+		activeEpisodeMemories.length + activeEpisodeFacets.length + activeSemanticMemories.length + activeProcedural.length +
+		cueEpisodeMemories.length + cueEpisodeFacets.length + cueSemanticMemories.length + cueProcedural.length;
+	const useLegacyFallback = v2SignalCount === 0;
+	const injectedActiveKnowledge = useLegacyFallback ? activeKnowledge : [];
+	const injectedActiveLessons = useLegacyFallback ? activeLessons : [];
+	const injectedActiveEvents = useLegacyFallback ? activeEvents : [];
+	const injectedActivePrefs = useLegacyFallback ? activePrefs : [];
+	const injectedCueKnowledge = useLegacyFallback ? dedupedCueKnowledge : [];
+	const injectedCueLessons = useLegacyFallback ? dedupedCueLessons : [];
+	const injectedCueEvents = useLegacyFallback ? dedupedCueEvents : [];
+	const injectedCuePrefs = useLegacyFallback ? dedupedCuePrefs : [];
+	const injectedCueEpisodes = useLegacyFallback ? topEpisodes : [];
+
+	return {
+		active: {
+			knowledge: injectedActiveKnowledge,
+			lessons: injectedActiveLessons,
+			events: injectedActiveEvents,
+			preferences: injectedActivePrefs,
+			facets: legacyFacetBridgeActive,
+			episodeMemories: activeEpisodeMemories,
+			episodeFacets: activeEpisodeFacets,
+			semanticMemories: activeSemanticMemories,
+			procedural: activeProcedural,
+		},
+		cue: {
+			knowledge: injectedCueKnowledge,
+			lessons: injectedCueLessons,
+			events: injectedCueEvents,
+			preferences: injectedCuePrefs,
+			facets: legacyFacetBridgeCue,
+			episodes: injectedCueEpisodes,
+			work: topWork,
+			episodeMemories: cueEpisodeMemories,
+			episodeFacets: cueEpisodeFacets,
+			semanticMemories: cueSemanticMemories,
+			procedural: cueProcedural,
+		},
+		allEntries,
+		graphContext,
+		injectedActiveKnowledge, injectedActiveLessons, injectedActiveEvents, injectedActivePrefs,
+		injectedCueKnowledge, injectedCueLessons, injectedCueEvents, injectedCuePrefs, injectedCueEpisodes,
+		legacyFacetBridgeActive, legacyFacetBridgeCue,
+	};
+}