@matthewfl/pi-contemplator 0.0.10 → 0.1.1

package/src/session-ledger/render-summary.ts

@@ -1,31 +1,32 @@
-import type { Observation, Reflection } from "./types.js";
+import { chronologicalMemories } from "./pools.js";
+import type { Observation, Summary } from "./types.js";
 
-const CONTEXT_USAGE_INSTRUCTIONS = `These are condensed memories from earlier in this session.
+const CONTEXT_USAGE_INSTRUCTIONS = `These are memories from earlier in this session, shown together in chronological order.
 
-- Reflections: stable, long-lived facts about the user, project, decisions, and constraints. New reflection lines may include ids in brackets.
-- Observations: timestamped events from the conversation history, in chronological order. Observation lines include ids in brackets.
+- Summaries are cited, compressed memories. Their lines include their own ids in leading brackets and source citations inside the text.
+- Observations are timestamped records from conversation history. Their lines include ids in leading brackets.
 
-Treat these as past records. When entries conflict, the most recent observation reflects the latest known state. Work that prior observations describe as completed should not be redone unless the user explicitly asks to revisit it.
+Treat these as past records. When entries conflict, the most recent memory reflects the latest known state. Work that a memory describes as completed should not be redone unless the user explicitly asks to revisit it.
 
-When exact source context is needed for precision or traceability, use the recall tool with the relevant observation or reflection id. This is especially useful when a reflection materially affects a decision or is too compressed to continue confidently. Do not use recall as broad search or inject raw source unless it is needed.`;
+When exact source context is needed for precision or traceability, use the recall tool with the relevant observation or summary id. A summary's inline citations can be followed with recall. Do not use recall as broad search or inject raw source unless it is needed.`;
 
 export function observationToSummaryLine(observation: Observation): string {
 	return `[${observation.id}] ${observation.timestamp} [${observation.relevance}] ${observation.content}`;
 }
 
-export function reflectionToSummaryLine(reflection: Reflection): string {
-	return `[${reflection.id}] ${reflection.content}`;
+export function summaryToSummaryLine(summary: Summary): string {
+	return `[${summary.id}] ${summary.timestamp} [summary] ${summary.content}`;
 }
 
-export function renderSummary(reflections: Reflection[], observations: Observation[]): string {
-	if (reflections.length === 0 && observations.length === 0) return "";
-
-	const parts: string[] = [CONTEXT_USAGE_INSTRUCTIONS];
-	if (reflections.length > 0) {
-		parts.push(`## Reflections\n${reflections.map(reflectionToSummaryLine).join("\n")}`);
-	}
-	if (observations.length > 0) {
-		parts.push(`## Observations\n${observations.map(observationToSummaryLine).join("\n")}`);
-	}
-	return parts.join("\n\n");
+export function renderSummary(summaries: Summary[], observations: Observation[]): string {
+	if (summaries.length === 0 && observations.length === 0) return "";
+
+	const memories = chronologicalMemories(observations, summaries).map((item) =>
+		item.kind === "observation" ? observationToSummaryLine(item.memory) : summaryToSummaryLine(item.memory),
+	);
+	return [
+		CONTEXT_USAGE_INSTRUCTIONS,
+		`## Memories (chronological)\n${memories.join("\n")}`,
+		"Remember: you can look up the details of a memory by using the recall tool with a memory id contained in square brackets.",
+	].join("\n\n");
 }

package/src/session-ledger/search.ts

@@ -1,21 +1,30 @@
 import {
-	isObservationsDroppedEntry,
+	isMemoryDetails,
 	isObservationsRecordedEntry,
-	isReflectionsRecordedEntry,
 	isReviewResultEntry,
+	isSummarizerCommitEntry,
+	observationRetention,
 	type Entry,
+	type MemoryVisibility,
 	type Relevance,
+	type Retention,
 	type ReviewOutcome,
 	type ReviewScope,
 } from "./types.js";
+import { foldLedger } from "./fold.js";
 
 export type MemorySearchResult = {
-	kind: "observation" | "reflection" | "review";
+	kind: "observation" | "summary" | "review";
 	id: string;
 	content: string;
 	relevance?: Relevance;
+	retention?: Retention;
 	timestamp?: string;
-	status?: "active" | "dropped";
+	visibility?: MemoryVisibility;
+	consumedBySummaryId?: string;
+	citedBySummaryIds?: string[];
+	sourceMemoryIds?: string[];
+	consumedMemoryIds?: string[];
 	scope?: ReviewScope;
 	outcome?: ReviewOutcome;
 	title?: string;
@@ -26,149 +35,124 @@ export type MemorySearch = {
 	query: string;
 	results: MemorySearchResult[];
 	observationsSearched: number;
-	reflectionsSearched: number;
+	summariesSearched: number;
 	reviewsSearched: number;
 };
 
-type SearchCandidate = Omit<MemorySearchResult, "score"> & {
-	sourceIndex: number;
-};
+export type SearchMemoriesOptions = Record<string, never>;
 
-const RELEVANCE_BOOST: Record<Relevance, number> = {
-	low: 1,
-	medium: 2,
-	high: 3,
-	critical: 4,
-};
+type SearchCandidate = Omit<MemorySearchResult, "score"> & { sourceIndex: number };
+
+const RELEVANCE_BOOST: Record<Relevance, number> = { low: 1, medium: 2, high: 3, critical: 4 };
 
 function normalizeSearchText(value: string): string {
 	return value.normalize("NFKC").toLocaleLowerCase();
 }
 
 function terms(value: string): string[] {
-	return Array.from(
-		new Set(normalizeSearchText(value).match(/[\p{L}\p{N}][\p{L}\p{N}\p{M}_./:-]*/gu) ?? []),
-	);
+	return Array.from(new Set(normalizeSearchText(value).match(/[\p{L}\p{N}][\p{L}\p{N}\p{M}_./:-]*/gu) ?? []));
 }
 
-function relevanceScore(
-	content: string,
-	query: string,
-	queryTerms: string[],
-): number {
+function relevanceScore(content: string, query: string, queryTerms: string[]): number {
 	const normalizedContent = normalizeSearchText(content);
 	const phrase = normalizeSearchText(query.trim());
-	const termMatches = queryTerms.reduce(
-		(total, term) => total + (normalizedContent.includes(term) ? 1 : 0),
-		0,
-	);
-	const phraseBoost =
-		phrase.length > 0 && normalizedContent.includes(phrase) ? 5 : 0;
+	const termMatches = queryTerms.reduce((total, term) => total + (normalizedContent.includes(term) ? 1 : 0), 0);
+	const phraseBoost = phrase.length > 0 && normalizedContent.includes(phrase) ? 5 : 0;
 	if (termMatches === 0 && phraseBoost === 0) return 0;
 	return termMatches * 10 + phraseBoost;
 }
 
+function reviewSearchContent(review: ReturnType<typeof foldLedger>["reviews"][number]): string {
+	return review.outcome === "proposal"
+		? [review.scope, "proposal", review.title, review.summary, review.evidence, review.conceptualDesign].join("\n")
+		: [review.scope, "review concluded with no proposal", review.reason, review.evidenceReviewed, review.reconsiderIf ?? ""].join("\n");
+}
+
+function sourceIndexes(entries: Entry[]): Map<string, number> {
+	const indexes = new Map<string, number>();
+	const add = (id: string, index: number): void => { if (!indexes.has(id)) indexes.set(id, index); };
+	for (let index = 0; index < entries.length; index++) {
+		const entry = entries[index];
+		if (entry.type === "compaction" && isMemoryDetails(entry.details)) {
+			for (const memory of entry.details.archive?.observations ?? entry.details.observations) add(memory.id, index);
+			for (const memory of entry.details.archive?.summaries ?? entry.details.summaries) add(memory.id, index);
+			for (const review of entry.details.reviews ?? []) add(review.id, index);
+			continue;
+		}
+		if (isObservationsRecordedEntry(entry)) for (const memory of entry.data.observations) add(memory.id, index);
+		else if (isSummarizerCommitEntry(entry)) for (const memory of entry.data.summaries) add(memory.id, index);
+		else if (isReviewResultEntry(entry)) add(entry.data.result.id, index);
+	}
+	return indexes;
+}
+
 function candidates(entries: Entry[]): {
 	items: SearchCandidate[];
 	observations: number;
-	reflections: number;
+	summaries: number;
 	reviews: number;
 } {
-	const dropped = new Set<string>();
-	for (const entry of entries) {
-		if (isObservationsDroppedEntry(entry)) {
-			for (const id of entry.data.observationIds) dropped.add(id);
-		}
-	}
-
+	const folded = foldLedger(entries);
+	const indexes = sourceIndexes(entries);
 	const items: SearchCandidate[] = [];
-	let observations = 0;
-	let reflections = 0;
-	let reviews = 0;
-	for (let sourceIndex = 0; sourceIndex < entries.length; sourceIndex++) {
-		const entry = entries[sourceIndex];
-		if (isObservationsRecordedEntry(entry)) {
-			observations += entry.data.observations.length;
-			for (const observation of entry.data.observations) {
-				items.push({
-					kind: "observation",
-					id: observation.id,
-					content: observation.content,
-					relevance: observation.relevance,
-					timestamp: observation.timestamp,
-					status: dropped.has(observation.id) ? "dropped" : "active",
-					sourceIndex,
-				});
-			}
-		}
-		if (isReflectionsRecordedEntry(entry)) {
-			reflections += entry.data.reflections.length;
-			for (const reflection of entry.data.reflections) {
-				items.push({
-					kind: "reflection",
-					id: reflection.id,
-					content: reflection.content,
-					sourceIndex,
-				});
-			}
-			continue;
-		}
-		if (isReviewResultEntry(entry)) {
-			const review = entry.data.result;
-			reviews++;
-			const content = review.outcome === "proposal"
-				? [review.scope, "proposal", review.title, review.summary, review.evidence, review.conceptualDesign].join("\n")
-				: [review.scope, "review concluded with no proposal", review.reason, review.evidenceReviewed, review.reconsiderIf ?? ""].join("\n");
-			items.push({
-				kind: "review",
-				id: review.id,
-				content,
-				scope: review.scope,
-				outcome: review.outcome,
-				title: review.outcome === "proposal" ? review.title : undefined,
-				sourceIndex,
-			});
-		}
+
+	for (const observation of folded.observations) {
+		const consumedBySummaryId = folded.consumedBySummaryId.get(observation.id);
+		items.push({
+			kind: "observation",
+			id: observation.id,
+			content: observation.content,
+			relevance: observation.relevance,
+			retention: observationRetention(observation),
+			timestamp: observation.timestamp,
+			visibility: consumedBySummaryId ? "summarized" : "visible",
+			...(consumedBySummaryId ? { consumedBySummaryId } : {}),
+			citedBySummaryIds: folded.citedBySummaryIds.get(observation.id) ?? [],
+			sourceIndex: indexes.get(observation.id) ?? 0,
+		});
+	}
+	for (const summary of folded.summaries) {
+		const consumedBySummaryId = folded.consumedBySummaryId.get(summary.id);
+		items.push({
+			kind: "summary",
+			id: summary.id,
+			content: summary.content,
+			visibility: consumedBySummaryId ? "summarized" : "visible",
+			...(consumedBySummaryId ? { consumedBySummaryId } : {}),
+			citedBySummaryIds: folded.citedBySummaryIds.get(summary.id) ?? [],
+			sourceMemoryIds: summary.sourceMemoryIds,
+			consumedMemoryIds: summary.consumedMemoryIds,
+			sourceIndex: indexes.get(summary.id) ?? 0,
+		});
+	}
+	for (const review of folded.reviews) {
+		items.push({
+			kind: "review",
+			id: review.id,
+			content: reviewSearchContent(review),
+			citedBySummaryIds: folded.citedBySummaryIds.get(review.id) ?? [],
+			scope: review.scope,
+			outcome: review.outcome,
+			title: review.outcome === "proposal" ? review.title : undefined,
+			sourceIndex: indexes.get(review.id) ?? 0,
+		});
 	}
-	return { items, observations, reflections, reviews };
+	return { items, observations: folded.observations.length, summaries: folded.summaries.length, reviews: folded.reviews.length };
 }
 
-export function searchMemories(
-	entries: Entry[],
-	query: string,
-	limit = 8,
-): MemorySearch {
+export function searchMemories(entries: Entry[], query: string, limit = 8, _options: SearchMemoriesOptions = {}): MemorySearch {
 	const normalizedQuery = query.trim();
 	const queryTerms = terms(normalizedQuery);
 	const searched = candidates(entries);
 	const results = searched.items
 		.map((candidate): MemorySearchResult | undefined => {
-			const lexical = relevanceScore(
-				candidate.content,
-				normalizedQuery,
-				queryTerms,
-			);
+			const lexical = relevanceScore(candidate.content, normalizedQuery, queryTerms);
 			if (lexical === 0) return undefined;
-			const relevanceBoost = candidate.relevance
-				? RELEVANCE_BOOST[candidate.relevance]
-				: 0;
-			const kindBoost = candidate.kind === "reflection" ? 3 : 0;
-			const recencyBoost = Math.min(
-				candidate.sourceIndex / Math.max(entries.length, 1),
-				1,
-			);
-			return {
-				kind: candidate.kind,
-				id: candidate.id,
-				content: candidate.content,
-				relevance: candidate.relevance,
-				timestamp: candidate.timestamp,
-				status: candidate.status,
-				scope: candidate.scope,
-				outcome: candidate.outcome,
-				title: candidate.title,
-				score: lexical + relevanceBoost + kindBoost + recencyBoost,
-			} satisfies MemorySearchResult;
+			const relevanceBoost = candidate.relevance ? RELEVANCE_BOOST[candidate.relevance] : 0;
+			const kindBoost = candidate.kind === "summary" ? 3 : 0;
+			const recencyBoost = Math.min(candidate.sourceIndex / Math.max(entries.length, 1), 1);
+			const { sourceIndex: _sourceIndex, ...result } = candidate;
+			return { ...result, score: lexical + relevanceBoost + kindBoost + recencyBoost };
 		})
 		.filter((result): result is MemorySearchResult => result !== undefined)
 		.sort((a, b) => b.score - a.score || a.id.localeCompare(b.id))
@@ -178,7 +162,7 @@ export function searchMemories(
 		query: normalizedQuery,
 		results,
 		observationsSearched: searched.observations,
-		reflectionsSearched: searched.reflections,
+		summariesSearched: searched.summaries,
 		reviewsSearched: searched.reviews,
 	};
 }

package/src/session-ledger/types.ts

@@ -1,6 +1,6 @@
 export const OM_OBSERVATIONS_RECORDED = "om.observations.recorded";
-export const OM_REFLECTIONS_RECORDED = "om.reflections.recorded";
-export const OM_OBSERVATIONS_DROPPED = "om.observations.dropped";
+/** Atomic output of one summarizer pass: new summaries and their consumption edges. */
+export const OM_SUMMARIZER_COMMIT = "om.summarizer.commit";
 export const OM_REVIEW_REQUEST = "om.review.request";
 export const OM_REVIEW_RESULT = "om.review.result";
 /** Persisted assistant/tool output from a short-lived structural reviewer. */
@@ -16,6 +16,10 @@ export const OM_FOLDED = "om.folded";
 export const RELEVANCE_VALUES = ["low", "medium", "high", "critical"] as const;
 export type Relevance = (typeof RELEVANCE_VALUES)[number];
 
+export const RETENTION_VALUES = ["ephemeral", "contextual", "durable"] as const;
+export type Retention = (typeof RETENTION_VALUES)[number];
+export type MemoryVisibility = "visible" | "summarized";
+
 export const MEMORY_ID_PATTERN = /^[a-f0-9]{12}$/;
 
 export type Entry = {
@@ -37,29 +41,44 @@ export type Observation = {
 	content: string;
 	timestamp: string;
 	relevance: Relevance;
+	/** Missing values safely default to contextual. */
+	retention?: Retention;
 	sourceEntryIds: string[];
 	tokenCount: number;
 };
 
-export type Reflection = {
+/** A durable, cited summary. Its source bodies remain elsewhere in the ledger. */
+export type Summary = {
 	id: string;
 	content: string;
-	supportingObservationIds: string[];
+	/** Newest effective timestamp among the cited source memories. */
+	timestamp: string;
+	/** Every inline-cited memory id, deduplicated in first-occurrence order. */
+	sourceMemoryIds: string[];
+	/** Sources newly removed from automatic visibility by this summary. */
+	consumedMemoryIds: string[];
 	tokenCount: number;
 };
 
-export type ObservationsRecordedEntryData = {
-	observations: Observation[];
-	coversUpToId: string;
+export type SummarizerCommitMetrics = {
+	consumedMemoryCount: number;
+	sourceTokens: number;
+	summaryTokens: number;
+	estimatedTokenReduction: number;
 };
 
-export type ReflectionsRecordedEntryData = {
-	reflections: Reflection[];
+export type SummarizerCommitEntryData = {
+	version: 1;
+	summaries: Summary[];
+	/** Entry id of the newest observation batch included in the run snapshot. */
 	coversUpToId: string;
+	createdAt: number;
+	completedWithDone: boolean;
+	metrics: SummarizerCommitMetrics;
 };
 
-export type ObservationsDroppedEntryData = {
-	observationIds: string[];
+export type ObservationsRecordedEntryData = {
+	observations: Observation[];
 	coversUpToId: string;
 };
 
@@ -127,29 +146,44 @@ export type ReviewResult = WorkflowReviewProposal | SoftwareReviewProposal | Rev
 export type ReviewRequestEntryData = { request: StructuralReviewRequest };
 export type ReviewResultEntryData = { result: ReviewResult };
 
+/** Full durable memory state at a compaction boundary. Bodies occur once in this archive. */
+export type MemoryArchive = {
+	observations: Observation[];
+	summaries: Summary[];
+};
+
 export type MemoryDetails = {
 	type: typeof OM_FOLDED;
-	version: 1;
+	/** Version 2 intentionally breaks the unpublished reflections/lifecycle format. */
+	version: 2;
 	fullFold: boolean;
+	/** Visible memories injected by this compaction. */
 	observations: Observation[];
-	reflections: Reflection[];
-	/** Optional so compactions written before review results remain readable. */
+	summaries: Summary[];
+	/** Complete durable graph nodes at this compaction boundary. */
+	archive?: MemoryArchive;
+	/** Reviews remain recallable/searchable but are never automatically injected. */
 	reviews?: ReviewResult[];
 };
 
-export type V3MemoryCustomType =
+export type MemoryCoverageCustomType =
 	| typeof OM_OBSERVATIONS_RECORDED
-	| typeof OM_REFLECTIONS_RECORDED
-	| typeof OM_OBSERVATIONS_DROPPED
-	| typeof OM_REVIEW_REQUEST
-	| typeof OM_REVIEW_RESULT;
+	| typeof OM_SUMMARIZER_COMMIT;
 
 export function isRelevance(value: unknown): value is Relevance {
 	return typeof value === "string" && (RELEVANCE_VALUES as readonly string[]).includes(value);
 }
 
+export function isRetention(value: unknown): value is Retention {
+	return typeof value === "string" && (RETENTION_VALUES as readonly string[]).includes(value);
+}
+
+export function observationRetention(observation: Observation): Retention {
+	return observation.retention ?? "contextual";
+}
+
 export function isNonEmptyString(value: unknown): value is string {
-	return typeof value === "string" && value.length > 0;
+	return typeof value === "string" && value.trim().length > 0;
 }
 
 export function isNonEmptyStringArray(value: unknown): value is string[] {
@@ -164,8 +198,16 @@ function isTokenCount(value: unknown): value is number {
 	return typeof value === "number" && Number.isFinite(value) && value >= 0;
 }
 
+function isCount(value: unknown): value is number {
+	return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+
 function isPlainRecord(value: unknown): value is Record<string, unknown> {
-	return !!value && typeof value === "object";
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function hasUniqueMemoryIds(value: unknown, minimum = 0): value is string[] {
+	return Array.isArray(value) && value.length >= minimum && value.every(isMemoryId) && new Set(value).size === value.length;
 }
 
 export function isObservation(value: unknown): value is Observation {
@@ -175,45 +217,41 @@ export function isObservation(value: unknown): value is Observation {
 		isNonEmptyString(value.content) &&
 		isNonEmptyString(value.timestamp) &&
 		isRelevance(value.relevance) &&
+		(value.retention === undefined || isRetention(value.retention)) &&
 		isNonEmptyStringArray(value.sourceEntryIds) &&
 		isTokenCount(value.tokenCount)
 	);
 }
 
-export function isReflection(value: unknown): value is Reflection {
+export function isSummary(value: unknown): value is Summary {
 	if (!isPlainRecord(value)) return false;
-	return (
-		isMemoryId(value.id) &&
-		isNonEmptyString(value.content) &&
-		!/\r|\n/.test(value.content) &&
-		isNonEmptyStringArray(value.supportingObservationIds) &&
-		isTokenCount(value.tokenCount)
-	);
+	if (!isMemoryId(value.id) || !isNonEmptyString(value.content) || !isNonEmptyString(value.timestamp) || !isTokenCount(value.tokenCount)) return false;
+	if (!hasUniqueMemoryIds(value.sourceMemoryIds, 2) || !hasUniqueMemoryIds(value.consumedMemoryIds, 2)) return false;
+	const sourceIds = new Set(value.sourceMemoryIds);
+	return value.consumedMemoryIds.every((id) => sourceIds.has(id));
 }
 
 export function isObservationsRecordedData(value: unknown): value is ObservationsRecordedEntryData {
 	if (!isPlainRecord(value)) return false;
 	return (
 		Array.isArray(value.observations) &&
-		value.observations.length > 0 &&
 		value.observations.every(isObservation) &&
 		isNonEmptyString(value.coversUpToId)
 	);
 }
 
-export function isReflectionsRecordedData(value: unknown): value is ReflectionsRecordedEntryData {
+function isSummarizerCommitMetrics(value: unknown): value is SummarizerCommitMetrics {
 	if (!isPlainRecord(value)) return false;
-	return (
-		Array.isArray(value.reflections) &&
-		value.reflections.length > 0 &&
-		value.reflections.every(isReflection) &&
-		isNonEmptyString(value.coversUpToId)
-	);
+	return isCount(value.consumedMemoryCount) && isTokenCount(value.sourceTokens) &&
+		isTokenCount(value.summaryTokens) && isTokenCount(value.estimatedTokenReduction);
 }
 
-export function isObservationsDroppedData(value: unknown): value is ObservationsDroppedEntryData {
+export function isSummarizerCommitData(value: unknown): value is SummarizerCommitEntryData {
 	if (!isPlainRecord(value)) return false;
-	return isNonEmptyStringArray(value.observationIds) && isNonEmptyString(value.coversUpToId);
+	return value.version === 1 && Array.isArray(value.summaries) && value.summaries.length > 0 &&
+		value.summaries.every(isSummary) && isNonEmptyString(value.coversUpToId) &&
+		typeof value.createdAt === "number" && Number.isFinite(value.createdAt) &&
+		typeof value.completedWithDone === "boolean" && isSummarizerCommitMetrics(value.metrics);
 }
 
 function isReviewScope(value: unknown): value is ReviewScope {
@@ -252,18 +290,22 @@ export function isReviewResult(value: unknown): value is ReviewResult {
 		isNonEmptyString(value.preservedBehavior) && isNonEmptyString(value.expectedEffect) && isNonEmptyString(value.uncertainties);
 }
 
+function isMemoryArchive(value: unknown): value is MemoryArchive {
+	if (!isPlainRecord(value)) return false;
+	return Array.isArray(value.observations) && value.observations.every(isObservation) &&
+		Array.isArray(value.summaries) && value.summaries.every(isSummary);
+}
+
 export function isMemoryDetails(value: unknown): value is MemoryDetails {
 	if (!isPlainRecord(value)) return false;
-	return (
-		value.type === OM_FOLDED &&
-		value.version === 1 &&
-		typeof value.fullFold === "boolean" &&
-		Array.isArray(value.observations) &&
-		value.observations.every(isObservation) &&
-		Array.isArray(value.reflections) &&
-		value.reflections.every(isReflection) &&
-		(value.reviews === undefined || (Array.isArray(value.reviews) && value.reviews.every(isReviewResult)))
-	);
+	// No v1 migration is intentional: that format belonged to the unpublished
+	// librarian/reflection design and is not semantically compatible with the
+	// summarizer consumption graph.
+	return value.type === OM_FOLDED && value.version === 2 && typeof value.fullFold === "boolean" &&
+		Array.isArray(value.observations) && value.observations.every(isObservation) &&
+		Array.isArray(value.summaries) && value.summaries.every(isSummary) &&
+		(value.archive === undefined || isMemoryArchive(value.archive)) &&
+		(value.reviews === undefined || (Array.isArray(value.reviews) && value.reviews.every(isReviewResult)));
 }
 
 export function isObservationsRecordedEntry(entry: Entry): entry is Entry & {
@@ -274,20 +316,12 @@ export function isObservationsRecordedEntry(entry: Entry): entry is Entry & {
 	return entry.type === "custom" && entry.customType === OM_OBSERVATIONS_RECORDED && isObservationsRecordedData(entry.data);
 }
 
-export function isReflectionsRecordedEntry(entry: Entry): entry is Entry & {
+export function isSummarizerCommitEntry(entry: Entry): entry is Entry & {
 	type: "custom";
-	customType: typeof OM_REFLECTIONS_RECORDED;
-	data: ReflectionsRecordedEntryData;
+	customType: typeof OM_SUMMARIZER_COMMIT;
+	data: SummarizerCommitEntryData;
 } {
-	return entry.type === "custom" && entry.customType === OM_REFLECTIONS_RECORDED && isReflectionsRecordedData(entry.data);
-}
-
-export function isObservationsDroppedEntry(entry: Entry): entry is Entry & {
-	type: "custom";
-	customType: typeof OM_OBSERVATIONS_DROPPED;
-	data: ObservationsDroppedEntryData;
-} {
-	return entry.type === "custom" && entry.customType === OM_OBSERVATIONS_DROPPED && isObservationsDroppedData(entry.data);
+	return entry.type === "custom" && entry.customType === OM_SUMMARIZER_COMMIT && isSummarizerCommitData(entry.data);
 }
 
 export function isReviewRequestEntry(entry: Entry): entry is Entry & {
@@ -310,22 +344,14 @@ export function buildObservationsRecordedData(
 	observations: Observation[],
 	coversUpToId: string,
 ): ObservationsRecordedEntryData | undefined {
-	if (observations.length === 0 || !isNonEmptyString(coversUpToId)) return undefined;
-	return { observations, coversUpToId };
+	if (!isNonEmptyString(coversUpToId)) return undefined;
+	const candidate = { observations, coversUpToId };
+	return isObservationsRecordedData(candidate) ? candidate : undefined;
 }
 
-export function buildReflectionsRecordedData(
-	reflections: Reflection[],
-	coversUpToId: string,
-): ReflectionsRecordedEntryData | undefined {
-	if (reflections.length === 0 || !isNonEmptyString(coversUpToId)) return undefined;
-	return { reflections, coversUpToId };
-}
-
-export function buildObservationsDroppedData(
-	observationIds: string[],
-	coversUpToId: string,
-): ObservationsDroppedEntryData | undefined {
-	if (observationIds.length === 0 || !isNonEmptyString(coversUpToId)) return undefined;
-	return { observationIds, coversUpToId };
+export function buildSummarizerCommitData(
+	data: Omit<SummarizerCommitEntryData, "version">,
+): SummarizerCommitEntryData | undefined {
+	const candidate: SummarizerCommitEntryData = { version: 1, ...data };
+	return isSummarizerCommitData(candidate) ? candidate : undefined;
 }

package/src/tools/compact-context.ts

@@ -20,7 +20,7 @@ export function createCompactContextTool(runtime: Runtime) {
 		promptGuidelines: [
 			"Use compact_context sparingly when either substantial additional work remains and there is not enough context left to complete it, or accumulated past context has become noisy, stale, or distracting enough that you are struggling to focus on the current task or reason about it reliably.",
 			"Do not use compact_context routinely, for short tasks, or merely because the conversation is long; use it for genuine context-capacity pressure or context degradation that is interfering with the work.",
-			"Call compact_context by itself, provide short_continuation_prompt with concrete instructions for the next agent step, and stop the current turn; observational memory will compact the context and automatically resume with those instructions.",
+			"Call compact_context by itself, provide short_continuation_prompt with concrete instructions for the next agent step, and stop the current turn; pi-contemplator will compact the context and automatically resume with those instructions.",
 		],
 		parameters: Type.Object({
 			short_continuation_prompt: Type.String({