@matthewfl/pi-contemplator 0.0.9 → 0.1.0

package/src/session-ledger/projection.ts

@@ -1,32 +1,26 @@
 import {
 	OM_FOLDED,
 	isMemoryDetails,
-	isObservationsDroppedEntry,
-	isObservationsRecordedEntry,
-	isReflectionsRecordedEntry,
-	isReviewResultEntry,
 	type Entry,
 	type MemoryDetails,
 	type Observation,
-	type Reflection,
 	type ReviewResult,
+	type Summary,
 } from "./types.js";
+import { foldLedger } from "./fold.js";
 
 export type Projection = {
 	observations: Observation[];
-	reflections: Reflection[];
-	/** Optional for compatibility with older callers; projections produced here always populate it. */
+	summaries: Summary[];
+	/** Reviews are retained for search/recall and are never rendered into automatic memory. */
 	reviews?: ReviewResult[];
 };
 
 export type ProjectionDiff = {
 	observationsOnlyInFull: Observation[];
-	reflectionsOnlyInFull: Reflection[];
-	droppedOnlyInFull: Observation[];
-};
-
-export type CompactionProjectionConfig = {
-	observationsPoolMaxTokens: number;
+	summariesOnlyInFull: Summary[];
+	observationsOnlyInVisible: Observation[];
+	summariesOnlyInVisible: Summary[];
 };
 
 export type CompactionProjection = Projection & {
@@ -34,108 +28,12 @@ export type CompactionProjection = Projection & {
 	details: MemoryDetails;
 };
 
-type ProjectionBoundary =
-	| { kind: "entry"; entryId: string }
-	| { kind: "tip" }
-	| { kind: "none" };
-
-type ProjectionFoldOptions = {
-	observationsBoundary: ProjectionBoundary;
-	reflectionsBoundary: ProjectionBoundary;
-	dropsBoundary: ProjectionBoundary;
-	reviewsBoundary: ProjectionBoundary;
-};
-
-function entryIndexById(entries: Entry[]): Map<string, number> {
-	const indexes = new Map<string, number>();
-	for (let i = 0; i < entries.length; i++) indexes.set(entries[i].id, i);
-	return indexes;
-}
-
-function entryBoundary(entryId: string): ProjectionBoundary {
-	return { kind: "entry", entryId };
-}
-
-function tipBoundary(): ProjectionBoundary {
-	return { kind: "tip" };
-}
-
-function noneBoundary(): ProjectionBoundary {
-	return { kind: "none" };
-}
-
-function boundaryIndex(entries: Entry[], indexes: Map<string, number>, boundary: ProjectionBoundary): number {
-	if (boundary.kind === "tip") return entries.length - 1;
-	if (boundary.kind === "none") return -1;
-	return indexes.get(boundary.entryId) ?? -1;
-}
-
-function coverageIndex(entry: Entry & { data: { coversUpToId: string } }, indexes: Map<string, number>): number {
-	return indexes.get(entry.data.coversUpToId) ?? -1;
-}
-
-function isAtOrBefore(index: number, boundaryIndex: number): boolean {
-	return index >= 0 && boundaryIndex >= 0 && index <= boundaryIndex;
-}
-
-function isCoveredAtOrBefore(
-	entry: Entry & { data: { coversUpToId: string } },
-	indexes: Map<string, number>,
-	boundaryIndex: number,
-): boolean {
-	return isAtOrBefore(coverageIndex(entry, indexes), boundaryIndex);
-}
-
-function foldProjection(entries: Entry[], options: ProjectionFoldOptions): Projection {
-	const indexes = entryIndexById(entries);
-	const observationsBoundary = boundaryIndex(entries, indexes, options.observationsBoundary);
-	const reflectionsBoundary = boundaryIndex(entries, indexes, options.reflectionsBoundary);
-	const dropsBoundary = boundaryIndex(entries, indexes, options.dropsBoundary);
-	const reviewsBoundary = boundaryIndex(entries, indexes, options.reviewsBoundary);
-	const observations: Observation[] = [];
-	const reflections: Reflection[] = [];
-	const reviews: ReviewResult[] = [];
-	const observationsById = new Set<string>();
-	const reflectionsById = new Set<string>();
-	const reviewIds = new Set<string>();
-	const droppedObservationIds = new Set<string>();
-
-	for (const entry of entries) {
-		if (isObservationsRecordedEntry(entry) && isCoveredAtOrBefore(entry, indexes, observationsBoundary)) {
-			for (const observation of entry.data.observations) {
-				if (observationsById.has(observation.id)) continue;
-				observationsById.add(observation.id);
-				observations.push(observation);
-			}
-			continue;
-		}
-
-		if (isReflectionsRecordedEntry(entry) && isCoveredAtOrBefore(entry, indexes, reflectionsBoundary)) {
-			for (const reflection of entry.data.reflections) {
-				if (reflectionsById.has(reflection.id)) continue;
-				reflectionsById.add(reflection.id);
-				reflections.push(reflection);
-			}
-			continue;
-		}
-
-		if (isObservationsDroppedEntry(entry) && isCoveredAtOrBefore(entry, indexes, dropsBoundary)) {
-			for (const observationId of entry.data.observationIds) droppedObservationIds.add(observationId);
-			continue;
-		}
-
-		if (isReviewResultEntry(entry) && isAtOrBefore(indexes.get(entry.id) ?? -1, reviewsBoundary)) {
-			if (!reviewIds.has(entry.data.result.id)) {
-				reviewIds.add(entry.data.result.id);
-				reviews.push(entry.data.result);
-			}
-		}
-	}
-
+function projectionFromFold(entries: Entry[], upToEntryId?: string): Projection {
+	const folded = foldLedger(entries, { upToEntryId });
 	return {
-		observations: observations.filter((observation) => !droppedObservationIds.has(observation.id)),
-		reflections,
-		...(reviews.length > 0 ? { reviews } : {}),
+		observations: folded.activeObservations,
+		summaries: folded.activeSummaries,
+		...(folded.reviews.length > 0 ? { reviews: folded.reviews } : {}),
 	};
 }
 
@@ -143,101 +41,71 @@ function projectionFromMemoryDetails(details: MemoryDetails): Projection {
 	const reviews = details.reviews ?? [];
 	return {
 		observations: [...details.observations],
-		reflections: [...details.reflections],
+		summaries: [...details.summaries],
 		...(reviews.length > 0 ? { reviews: [...reviews] } : {}),
 	};
 }
 
-function latestV3CompactionDetails(entries: Entry[]): MemoryDetails | undefined {
+function latestCompactionDetails(entries: Entry[]): MemoryDetails | undefined {
 	for (let i = entries.length - 1; i >= 0; i--) {
 		const entry = entries[i];
-		if (entry.type !== "compaction") continue;
-		if (isMemoryDetails(entry.details)) return entry.details;
+		if (entry.type === "compaction" && isMemoryDetails(entry.details)) return entry.details;
 	}
 	return undefined;
 }
 
 export function fullProjection(entries: Entry[], upToEntryId?: string): Projection {
-	const boundary = upToEntryId ? entryBoundary(upToEntryId) : tipBoundary();
-	return foldProjection(entries, {
-		observationsBoundary: boundary,
-		reflectionsBoundary: boundary,
-		dropsBoundary: boundary,
-		reviewsBoundary: boundary,
-	});
+	return projectionFromFold(entries, upToEntryId);
 }
 
+/** Memories already present in the latest compacted context. */
 export function visibleProjection(entries: Entry[], upToEntryId?: string): Projection {
-	if (!upToEntryId) {
-		const details = latestV3CompactionDetails(entries);
-		return details ? projectionFromMemoryDetails(details) : { observations: [], reflections: [] };
-	}
-
-	return buildCompactionProjection(entries, upToEntryId, { observationsPoolMaxTokens: Number.POSITIVE_INFINITY });
-}
-
-export function latestFullFoldBoundaryId(entries: Entry[]): string | undefined {
-	const indexes = entryIndexById(entries);
-	for (let i = entries.length - 1; i >= 0; i--) {
-		const entry = entries[i];
-		if (entry.type !== "compaction") continue;
-		if (!isMemoryDetails(entry.details)) continue;
-		if (!entry.details.fullFold) continue;
-		if (!entry.firstKeptEntryId) continue;
-		if (!indexes.has(entry.firstKeptEntryId)) continue;
-		return entry.firstKeptEntryId;
-	}
-	return undefined;
+	if (upToEntryId) return projectionFromFold(entries, upToEntryId);
+	const details = latestCompactionDetails(entries);
+	return details ? projectionFromMemoryDetails(details) : { observations: [], summaries: [] };
 }
 
 export function buildCompactionProjection(
 	entries: Entry[],
 	firstKeptEntryId: string,
-	config: CompactionProjectionConfig,
 ): CompactionProjection {
-	const fullFoldBoundaryId = latestFullFoldBoundaryId(entries);
-	const maintenanceBoundary = fullFoldBoundaryId ? entryBoundary(fullFoldBoundaryId) : noneBoundary();
-	const normalProjection = foldProjection(entries, {
-		observationsBoundary: entryBoundary(firstKeptEntryId),
-		reflectionsBoundary: maintenanceBoundary,
-		dropsBoundary: maintenanceBoundary,
-		reviewsBoundary: entryBoundary(firstKeptEntryId),
-	});
-	const observationTokens = normalProjection.observations.reduce(
-		(total, observation) => total + observation.tokenCount,
-		0,
-	);
-	const fullFold = observationTokens >= config.observationsPoolMaxTokens;
-	const projection = fullFold
-		? fullProjection(entries, firstKeptEntryId)
-		: normalProjection;
-
+	const durable = foldLedger(entries, { upToEntryId: firstKeptEntryId });
+	const observations = durable.activeObservations;
+	const summaries = durable.activeSummaries;
+	// Retained in the v2 detail shape for schema stability. The old observation-
+	// pool pressure mode no longer exists; summarizer consumption controls visibility.
+	const fullFold = false;
 	const details: MemoryDetails = {
 		type: OM_FOLDED,
-		version: 1,
+		version: 2,
 		fullFold,
-		observations: projection.observations,
-		reflections: projection.reflections,
-		...(projection.reviews?.length ? { reviews: projection.reviews } : {}),
+		observations,
+		summaries,
+		archive: {
+			observations: durable.observations,
+			summaries: durable.summaries,
+		},
+		...(durable.reviews.length > 0 ? { reviews: durable.reviews } : {}),
 	};
 
 	return {
 		fullFold,
-		observations: projection.observations,
-		reflections: projection.reflections,
-		...(projection.reviews?.length ? { reviews: projection.reviews } : {}),
+		observations,
+		summaries,
+		...(durable.reviews.length > 0 ? { reviews: durable.reviews } : {}),
 		details,
 	};
 }
 
 export function diffProjection(visible: Projection, full: Projection): ProjectionDiff {
-	const visibleObservationIds = new Set(visible.observations.map((observation) => observation.id));
-	const fullObservationIds = new Set(full.observations.map((observation) => observation.id));
-	const visibleReflectionIds = new Set(visible.reflections.map((reflection) => reflection.id));
-
+	const visibleObservationIds = new Set(visible.observations.map((memory) => memory.id));
+	const fullObservationIds = new Set(full.observations.map((memory) => memory.id));
+	const visibleSummaryIds = new Set(visible.summaries.map((memory) => memory.id));
+	const fullSummaryIds = new Set(full.summaries.map((memory) => memory.id));
 	return {
-		observationsOnlyInFull: full.observations.filter((observation) => !visibleObservationIds.has(observation.id)),
-		reflectionsOnlyInFull: full.reflections.filter((reflection) => !visibleReflectionIds.has(reflection.id)),
-		droppedOnlyInFull: visible.observations.filter((observation) => !fullObservationIds.has(observation.id)),
+		observationsOnlyInFull: full.observations.filter((memory) => !visibleObservationIds.has(memory.id)),
+		summariesOnlyInFull: full.summaries.filter((memory) => !visibleSummaryIds.has(memory.id)),
+		observationsOnlyInVisible: visible.observations.filter((memory) => !fullObservationIds.has(memory.id)),
+		summariesOnlyInVisible: visible.summaries.filter((memory) => !fullSummaryIds.has(memory.id)),
 	};
 }

package/src/session-ledger/recall.ts

@@ -1,25 +1,21 @@
 import {
-	isObservationsDroppedEntry,
+	isMemoryDetails,
 	isObservationsRecordedEntry,
-	isReflectionsRecordedEntry,
 	isReviewResultEntry,
+	isSummarizerCommitEntry,
 	type Entry,
+	type MemoryVisibility,
 	type Observation,
-	type Reflection,
 	type ReviewResult,
+	type Summary,
 } from "./types.js";
+import { foldLedger } from "./fold.js";
 
 const SOURCE_TYPES = new Set(["message", "custom_message", "branch_summary"]);
 
-export type { Entry, Observation, Reflection };
+export type { Entry, Observation, Summary };
 
-type ObservationLedgerLocation = {
-	entryId: string;
-	entryIndex: number;
-	recordIndex: number;
-};
-
-type ReflectionLedgerLocation = {
+type LedgerLocation = {
 	entryId: string;
 	entryIndex: number;
 	recordIndex: number;
@@ -29,22 +25,31 @@ export type RecalledObservation = {
 	observation: Observation;
 	observationEntryId: string;
 	observationRecordIndex: number;
-	status: "active" | "dropped";
+	visibility: MemoryVisibility;
+	consumedBySummaryId?: string;
+	citedBySummaryIds: string[];
 	sourceEntryIds: string[];
 	sourceEntries: Entry[];
 	missingSourceEntryIds: string[];
 	nonSourceEntryIds: string[];
 };
 
-export type RecalledReflection = {
-	reflection: Reflection;
-	reflectionEntryId: string;
-	reflectionRecordIndex: number;
+export type RecalledSummary = {
+	summary: Summary;
+	summaryEntryId: string;
+	summaryRecordIndex: number;
+	visibility: MemoryVisibility;
+	consumedBySummaryId?: string;
+	citedBySummaryIds: string[];
+	sourceMemoryIds: string[];
+	consumedMemoryIds: string[];
+	missingSourceMemoryIds: string[];
 };
 
 export type RecalledReviewResult = {
 	review: ReviewResult;
 	reviewEntryId: string;
+	citedBySummaryIds: string[];
 };
 
 export type RecallResult =
@@ -52,34 +57,34 @@ export type RecallResult =
 			status: "not_found";
 			memoryId: string;
 			kind: undefined;
-			reflections: [];
+			summaries: [];
 			reviews: [];
 			observations: [];
 			sourceEntries: [];
 			missingSourceEntryIds: [];
 			nonSourceEntryIds: [];
-			missingSupportingObservationIds: [];
+			missingSourceMemoryIds: [];
 			collision: false;
 			partial: false;
 	  }
 	| {
 			status: "found";
 			memoryId: string;
-			kind: "observation" | "reflection" | "review" | "mixed";
-			reflections: RecalledReflection[];
+			kind: "observation" | "summary" | "review" | "mixed";
+			summaries: RecalledSummary[];
 			reviews: RecalledReviewResult[];
 			observations: RecalledObservation[];
 			sourceEntries: Entry[];
 			missingSourceEntryIds: string[];
 			nonSourceEntryIds: string[];
-			missingSupportingObservationIds: string[];
+			missingSourceMemoryIds: string[];
 			collision: boolean;
 			partial: boolean;
 	  };
 
-type IndexedObservation = ObservationLedgerLocation & { observation: Observation };
-type IndexedReflection = ReflectionLedgerLocation & { reflection: Reflection };
-type IndexedReviewResult = { review: ReviewResult; entryId: string };
+type IndexedObservation = LedgerLocation & { observation: Observation };
+type IndexedSummary = LedgerLocation & { summary: Summary };
+type IndexedReviewResult = { review: ReviewResult; entryId: string; entryIndex: number };
 
 function isSourceEntry(entry: Entry): boolean {
 	return SOURCE_TYPES.has(entry.type);
@@ -87,79 +92,85 @@ function isSourceEntry(entry: Entry): boolean {
 
 function uniqueById(entries: Entry[]): Entry[] {
 	const seen = new Set<string>();
-	const result: Entry[] = [];
-	for (const entry of entries) {
-		if (seen.has(entry.id)) continue;
+	return entries.filter((entry) => {
+		if (seen.has(entry.id)) return false;
 		seen.add(entry.id);
-		result.push(entry);
-	}
-	return result;
+		return true;
+	});
 }
 
-function uniqueStrings(values: string[]): string[] {
+function uniqueStrings(values: readonly string[]): string[] {
 	return Array.from(new Set(values));
 }
 
 function indexLedger(entries: Entry[]): {
 	observations: IndexedObservation[];
-	reflections: IndexedReflection[];
+	summaries: IndexedSummary[];
 	reviews: IndexedReviewResult[];
-	droppedIds: Set<string>;
 } {
 	const observations: IndexedObservation[] = [];
-	const reflections: IndexedReflection[] = [];
+	const summaries: IndexedSummary[] = [];
 	const reviews: IndexedReviewResult[] = [];
-	const droppedIds = new Set<string>();
+	const observationKeys = new Set<string>();
+	const summaryKeys = new Set<string>();
+	const reviewKeys = new Set<string>();
+	const addObservation = (observation: Observation, location: LedgerLocation): void => {
+		const key = `${observation.id}:${uniqueStrings(observation.sourceEntryIds).sort().join(",")}`;
+		if (observationKeys.has(key)) return;
+		observationKeys.add(key);
+		observations.push({ observation, ...location });
+	};
+	const addSummary = (summary: Summary, location: LedgerLocation): void => {
+		const key = `${summary.id}:${summary.sourceMemoryIds.join(",")}:${summary.consumedMemoryIds.join(",")}`;
+		if (summaryKeys.has(key)) return;
+		summaryKeys.add(key);
+		summaries.push({ summary, ...location });
+	};
+	const addReview = (review: ReviewResult, entryId: string, entryIndex: number): void => {
+		if (reviewKeys.has(review.id)) return;
+		reviewKeys.add(review.id);
+		reviews.push({ review, entryId, entryIndex });
+	};
 
 	for (let entryIndex = 0; entryIndex < entries.length; entryIndex++) {
 		const entry = entries[entryIndex];
-		if (isObservationsRecordedEntry(entry)) {
-			entry.data.observations.forEach((observation, recordIndex) => {
-				observations.push({ observation, entryId: entry.id, entryIndex, recordIndex });
-			});
+		if (entry.type === "compaction" && isMemoryDetails(entry.details)) {
+			const archivedObservations = entry.details.archive?.observations ?? entry.details.observations;
+			const archivedSummaries = entry.details.archive?.summaries ?? entry.details.summaries;
+			archivedObservations.forEach((observation, recordIndex) => addObservation(observation, { entryId: entry.id, entryIndex, recordIndex }));
+			archivedSummaries.forEach((summary, recordIndex) => addSummary(summary, { entryId: entry.id, entryIndex, recordIndex }));
+			for (const review of entry.details.reviews ?? []) addReview(review, entry.id, entryIndex);
 			continue;
 		}
-		if (isReflectionsRecordedEntry(entry)) {
-			entry.data.reflections.forEach((reflection, recordIndex) => {
-				reflections.push({ reflection, entryId: entry.id, entryIndex, recordIndex });
-			});
+		if (isObservationsRecordedEntry(entry)) {
+			entry.data.observations.forEach((observation, recordIndex) => addObservation(observation, { entryId: entry.id, entryIndex, recordIndex }));
 			continue;
 		}
-		if (isObservationsDroppedEntry(entry)) {
-			entry.data.observationIds.forEach((id) => droppedIds.add(id));
+		if (isSummarizerCommitEntry(entry)) {
+			entry.data.summaries.forEach((summary, recordIndex) => addSummary(summary, { entryId: entry.id, entryIndex, recordIndex }));
 			continue;
 		}
-		if (isReviewResultEntry(entry)) reviews.push({ review: entry.data.result, entryId: entry.id });
+		if (isReviewResultEntry(entry)) addReview(entry.data.result, entry.id, entryIndex);
 	}
-
-	return { observations, reflections, reviews, droppedIds };
+	return { observations, summaries, reviews };
 }
 
-function resolveObservationSources(entries: Entry[], observation: Observation, location: ObservationLedgerLocation): RecalledObservation {
-	const sourceEntryIds = uniqueStrings(observation.sourceEntryIds);
+function resolveObservationSources(entries: Entry[], indexed: IndexedObservation): Omit<RecalledObservation, "visibility" | "consumedBySummaryId" | "citedBySummaryIds"> {
+	const sourceEntryIds = uniqueStrings(indexed.observation.sourceEntryIds);
 	const byId = new Map(entries.map((entry) => [entry.id, entry]));
 	const sourceEntries: Entry[] = [];
 	const missingSourceEntryIds: string[] = [];
 	const nonSourceEntryIds: string[] = [];
-
 	for (const sourceEntryId of sourceEntryIds) {
 		const sourceEntry = byId.get(sourceEntryId);
-		if (!sourceEntry) {
-			missingSourceEntryIds.push(sourceEntryId);
-			continue;
-		}
-		if (!isSourceEntry(sourceEntry)) {
-			nonSourceEntryIds.push(sourceEntryId);
-			continue;
-		}
-		sourceEntries.push(sourceEntry);
+		if (!sourceEntry) missingSourceEntryIds.push(sourceEntryId);
+		else if (!isSourceEntry(sourceEntry)) nonSourceEntryIds.push(sourceEntryId);
+		else sourceEntries.push(sourceEntry);
 	}
-
 	return {
-		observation,
-		observationEntryId: location.entryId,
-		observationRecordIndex: location.recordIndex,
-		status: "active",
+		observation: indexed.observation,
+		observationEntryId: indexed.entryId,
+		observationRecordIndex: indexed.recordIndex,
 		sourceEntryIds,
 		sourceEntries,
 		missingSourceEntryIds,
@@ -172,87 +183,78 @@ function notFound(memoryId: string): RecallResult {
 		status: "not_found",
 		memoryId,
 		kind: undefined,
-		reflections: [],
+		summaries: [],
 		reviews: [],
 		observations: [],
 		sourceEntries: [],
 		missingSourceEntryIds: [],
 		nonSourceEntryIds: [],
-		missingSupportingObservationIds: [],
+		missingSourceMemoryIds: [],
 		collision: false,
 		partial: false,
 	};
 }
 
+/** Recall exactly one graph node plus immediate backward/forward pointers. */
 export function recallMemorySources(entries: Entry[], memoryId: string): RecallResult {
-	const { observations: indexedObservations, reflections: indexedReflections, reviews: indexedReviews, droppedIds } = indexLedger(entries);
-	const directObservationMatches = indexedObservations.filter(({ observation }) => observation.id === memoryId);
-	const reflectionMatches = indexedReflections.filter(({ reflection }) => reflection.id === memoryId);
-	const reviewMatches = indexedReviews.filter(({ review }) => review.id === memoryId);
-
-	if (directObservationMatches.length === 0 && reflectionMatches.length === 0 && reviewMatches.length === 0) return notFound(memoryId);
-
-	const observationsById = new Map<string, IndexedObservation>();
-	for (const indexed of indexedObservations) {
-		if (!observationsById.has(indexed.observation.id)) observationsById.set(indexed.observation.id, indexed);
-	}
-
-	const recalledByKey = new Map<string, RecalledObservation>();
-	const missingSupportingObservationIds: string[] = [];
+	const indexed = indexLedger(entries);
+	const folded = foldLedger(entries);
+	const observationMatches = indexed.observations.filter(({ observation }) => observation.id === memoryId);
+	const summaryMatches = indexed.summaries.filter(({ summary }) => summary.id === memoryId);
+	const reviewMatches = indexed.reviews.filter(({ review }) => review.id === memoryId);
+	if (observationMatches.length === 0 && summaryMatches.length === 0 && reviewMatches.length === 0) return notFound(memoryId);
 
-	function addObservation(indexed: IndexedObservation): void {
-		const key = `${indexed.entryId}:${indexed.recordIndex}`;
-		if (recalledByKey.has(key)) return;
-		const recalled = resolveObservationSources(entries, indexed.observation, indexed);
-		recalled.status = droppedIds.has(indexed.observation.id) ? "dropped" : "active";
-		recalledByKey.set(key, recalled);
-	}
-
-	for (const match of directObservationMatches) addObservation(match);
-
-	for (const { reflection } of reflectionMatches) {
-		for (const observationId of uniqueStrings(reflection.supportingObservationIds)) {
-			const indexed = observationsById.get(observationId);
-			if (!indexed) {
-				missingSupportingObservationIds.push(observationId);
-				continue;
-			}
-			addObservation(indexed);
-		}
-	}
-
-	const recalledObservations = Array.from(recalledByKey.values());
-	const recalledReflections: RecalledReflection[] = reflectionMatches.map(({ reflection, entryId, recordIndex }) => ({
-		reflection,
-		reflectionEntryId: entryId,
-		reflectionRecordIndex: recordIndex,
+	const knownMemoryIds = new Set([
+		...folded.observationsById.keys(),
+		...folded.summariesById.keys(),
+		...folded.reviewsById.keys(),
+	]);
+	const observations: RecalledObservation[] = observationMatches.map((match) => {
+		const consumedBySummaryId = folded.consumedBySummaryId.get(match.observation.id);
+		return {
+			...resolveObservationSources(entries, match),
+			visibility: consumedBySummaryId ? "summarized" : "visible",
+			...(consumedBySummaryId ? { consumedBySummaryId } : {}),
+			citedBySummaryIds: folded.citedBySummaryIds.get(match.observation.id) ?? [],
+		};
+	});
+	const summaries: RecalledSummary[] = summaryMatches.map((match) => {
+		const consumedBySummaryId = folded.consumedBySummaryId.get(match.summary.id);
+		return {
+			summary: match.summary,
+			summaryEntryId: match.entryId,
+			summaryRecordIndex: match.recordIndex,
+			visibility: consumedBySummaryId ? "summarized" : "visible",
+			...(consumedBySummaryId ? { consumedBySummaryId } : {}),
+			citedBySummaryIds: folded.citedBySummaryIds.get(match.summary.id) ?? [],
+			sourceMemoryIds: match.summary.sourceMemoryIds,
+			consumedMemoryIds: match.summary.consumedMemoryIds,
+			missingSourceMemoryIds: match.summary.sourceMemoryIds.filter((id) => !knownMemoryIds.has(id)),
+		};
+	});
+	const reviews: RecalledReviewResult[] = reviewMatches.map(({ review, entryId }) => ({
+		review,
+		reviewEntryId: entryId,
+		citedBySummaryIds: folded.citedBySummaryIds.get(review.id) ?? [],
 	}));
-	const recalledReviews: RecalledReviewResult[] = reviewMatches.map(({ review, entryId }) => ({ review, reviewEntryId: entryId }));
-	const sourceEntries = uniqueById(recalledObservations.flatMap((match) => match.sourceEntries));
-	const missingSourceEntryIds = uniqueStrings(recalledObservations.flatMap((match) => match.missingSourceEntryIds));
-	const nonSourceEntryIds = uniqueStrings(recalledObservations.flatMap((match) => match.nonSourceEntryIds));
-	const uniqueMissingSupportingObservationIds = uniqueStrings(missingSupportingObservationIds);
-	const matchCount = directObservationMatches.length + reflectionMatches.length + reviewMatches.length;
-	const kinds = [directObservationMatches.length > 0, reflectionMatches.length > 0, reviewMatches.length > 0].filter(Boolean).length;
-
+	const sourceEntries = uniqueById(observations.flatMap((match) => match.sourceEntries));
+	const missingSourceEntryIds = uniqueStrings(observations.flatMap((match) => match.missingSourceEntryIds));
+	const nonSourceEntryIds = uniqueStrings(observations.flatMap((match) => match.nonSourceEntryIds));
+	const missingSourceMemoryIds = uniqueStrings(summaries.flatMap((match) => match.missingSourceMemoryIds));
+	const kinds = [observationMatches.length > 0, summaryMatches.length > 0, reviewMatches.length > 0].filter(Boolean).length;
+	const matchCount = observationMatches.length + summaryMatches.length + reviewMatches.length;
 	return {
 		status: "found",
 		memoryId,
-		kind: kinds > 1
-			? "mixed"
-			: reviewMatches.length > 0
-				? "review"
-				: reflectionMatches.length > 0
-					? "reflection"
-					: "observation",
-		reflections: recalledReflections,
-		reviews: recalledReviews,
-		observations: recalledObservations,
+		kind: kinds > 1 ? "mixed" : reviewMatches.length > 0 ? "review" : summaryMatches.length > 0 ? "summary" : "observation",
+		summaries,
+		reviews,
+		observations,
 		sourceEntries,
 		missingSourceEntryIds,
 		nonSourceEntryIds,
-		missingSupportingObservationIds: uniqueMissingSupportingObservationIds,
+		missingSourceMemoryIds,
 		collision: matchCount > 1,
-		partial: missingSourceEntryIds.length > 0 || nonSourceEntryIds.length > 0 || uniqueMissingSupportingObservationIds.length > 0,
+		partial: missingSourceEntryIds.length > 0 || nonSourceEntryIds.length > 0 || missingSourceMemoryIds.length > 0,
 	};
 }