@matthewfl/pi-contemplator 0.1.6 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matthewfl/pi-contemplator",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "A Pi extension that keeps long-running agentic sessions on track with background memory, contemplation, and structural review.",
   "type": "module",
   "license": "MIT",
@@ -41,7 +41,7 @@
     "typecheck": "tsc --noEmit",
     "test": "npm run test:unit && npm run test:e2e",
     "test:unit": "vitest run",
-    "test:e2e": "node tests/e2e/rpc-contemplator.mjs && node tests/e2e/rpc-summarizer.mjs && node tests/e2e/rpc-delivery.mjs && node tests/e2e/rpc-restore-review.mjs && node tests/e2e/rpc-compaction.mjs && node tests/e2e/rpc-compaction-resilience.mjs && node tests/e2e/rpc-memory-edges.mjs && node tests/e2e/rpc-observer-length.mjs && node tests/e2e/rpc-routing-isolation.mjs"
+    "test:e2e": "node tests/e2e/rpc-contemplator.mjs && node tests/e2e/rpc-contemplator-history.mjs && node tests/e2e/rpc-summarizer.mjs && node tests/e2e/rpc-delivery.mjs && node tests/e2e/rpc-restore-review.mjs && node tests/e2e/rpc-compaction.mjs && node tests/e2e/rpc-compaction-resilience.mjs && node tests/e2e/rpc-memory-edges.mjs && node tests/e2e/rpc-observer-length.mjs && node tests/e2e/rpc-routing-isolation.mjs"
   },
   "peerDependencies": {
     "@earendil-works/pi-agent-core": "*",
@@ -50,10 +50,10 @@
     "@earendil-works/pi-tui": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-agent-core": "^0.84.3",
-    "@earendil-works/pi-ai": "^0.84.3",
-    "@earendil-works/pi-coding-agent": "^0.84.3",
-    "@earendil-works/pi-tui": "^0.84.3",
+    "@earendil-works/pi-agent-core": "^0.84.4",
+    "@earendil-works/pi-ai": "^0.84.4",
+    "@earendil-works/pi-coding-agent": "^0.84.4",
+    "@earendil-works/pi-tui": "^0.84.4",
     "@types/node": "^22.0.0",
     "typebox": "^1.1.38",
     "typescript": "^5.6.0",

package/src/agents/contemplator/agent.ts

@@ -2,7 +2,7 @@ import { agentLoop, type AgentContext, type AgentLoopConfig, type AgentMessage,
 import { Type, type Message, type Model } from "@earendil-works/pi-ai";
 import type { Static } from "typebox";
 import { streamSimple } from "@earendil-works/pi-ai/compat";
-import { generateSummaryWithUsage } from "@earendil-works/pi-coding-agent";
+import { estimateTokens as estimateAgentMessageTokens, generateSummaryWithUsage } from "@earendil-works/pi-coding-agent";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Box, Text } from "@earendil-works/pi-tui";
 import { agentActiveTimeMs, assistantOutputTokens, assistantToolCallCount, fullProjection, isReviewRequestEntry, isReviewResultEntry, OM_AGENT_ACTIVITY, OM_REVIEWER_MESSAGE, OM_REVIEWER_NOTICE, OM_REVIEWER_STATE, OM_REVIEW_REQUEST, OM_REVIEW_RESULT, rawTokensSinceObservationCoverage, recallMemorySources, type Entry, type ReviewResult, type StructuralReviewRequest } from "../../session-ledger/index.js";
@@ -19,9 +19,68 @@ import { buildContemplatorSystemPrompt } from "./prompts.js";
 import { runStructuralReview } from "../reviewer/agent.js";
 import { createWorkerStallWatchdog } from "../../worker-watchdog.js";
 
+const CONTEMPLATOR_HISTORY_FALLBACK_TRIGGER_TOKENS = 20_000;
+const CONTEMPLATOR_HISTORY_MAX_TRIGGER_TOKENS = 40_000;
+const CONTEMPLATOR_HISTORY_CONTEXT_FRACTION = 0.25;
+const CONTEMPLATOR_HISTORY_KEEP_RECENT_TOKENS = 12_000;
+const CONTEMPLATOR_HISTORY_SUMMARY_RESERVE_TOKENS = 16_000;
+const CONTEMPLATOR_HISTORY_SUMMARY_INSTRUCTIONS = "This is an older prefix of a private contemplator transcript. Be concise. Preserve durable user intent, decisions, evidence, unresolved reasoning gaps, and review/probe outcomes. Newer transcript messages are retained verbatim after this checkpoint.";
+
+function contemplatorMessageTokens(message: AgentMessage): number {
+	try {
+		return Math.max(1, estimateAgentMessageTokens(message));
+	} catch {
+		return Math.max(1, Math.ceil(JSON.stringify(message).length / 4));
+	}
+}
+
+function contemplatorHistoryTokens(history: readonly AgentMessage[]): number {
+	return history.reduce((total, message) => total + contemplatorMessageTokens(message), 0);
+}
+
+function contemplatorHistoryTriggerTokens(model: Model<any>): number {
+	const contextWindow = Number(model.contextWindow);
+	if (!Number.isFinite(contextWindow) || contextWindow <= 0) return CONTEMPLATOR_HISTORY_FALLBACK_TRIGGER_TOKENS;
+	return Math.max(1, Math.min(CONTEMPLATOR_HISTORY_MAX_TRIGGER_TOKENS, Math.floor(contextWindow * CONTEMPLATOR_HISTORY_CONTEXT_FRACTION)));
+}
+
+/** Return a user-message boundary that leaves approximately targetTokens recent. */
+function recentHistoryStart(history: readonly AgentMessage[], entryIds: readonly (string | undefined)[], targetTokens: number): number | undefined {
+	let tokens = 0;
+	let start = history.length;
+	while (start > 0 && tokens < targetTokens) {
+		start--;
+		tokens += contemplatorMessageTokens(history[start]);
+	}
+	while (start > 0 && history[start].role !== "user") start--;
+	// Retained messages are durable pointers, not copied payloads. If a legacy
+	// snapshot supplied messages without entry ids, retain only the newer complete
+	// updates whose original om.contemplator.message entries can be referenced.
+	let lastMissingId = -1;
+	for (let index = start; index < entryIds.length; index++) {
+		if (entryIds[index] === undefined) lastMissingId = index;
+	}
+	if (lastMissingId >= 0) {
+		start = lastMissingId + 1;
+		while (start < history.length && history[start].role !== "user") start++;
+	}
+	return start > 0 && start < history.length ? start : undefined;
+}
+
+/** Pick a smaller complete oldest prefix after a length-truncated first attempt. */
+function smallerPrefixEnd(history: readonly AgentMessage[], initialEnd: number): number | undefined {
+	const target = Math.max(1, Math.floor(contemplatorHistoryTokens(history.slice(0, initialEnd)) / 2));
+	let tokens = 0;
+	for (let index = 0; index < initialEnd; index++) {
+		tokens += contemplatorMessageTokens(history[index]);
+		const next = index + 1;
+		if (tokens >= target && next < initialEnd && history[next].role === "user") return next;
+	}
+	return undefined;
+}
+
 interface PendingUpdate {
 	observations: string[];
-	summaries: string[];
 	reviews: string[];
 	mainAgentOutputTokens: number;
 	mainAgentToolCalls: number;
@@ -212,6 +271,8 @@ export function createRequestReviewTool(
 
 export class Contemplator {
 	private history: AgentMessage[] = [];
+	/** Ledger entry id for each private-history message; used by compact checkpoints to retain a suffix without copying it. */
+	private historyEntryIds: Array<string | undefined> = [];
 	private pending: PendingUpdate | undefined;
 	private running = false;
 	/** Invalidates stale/hard-timed-out flush finalizers across session changes. */
@@ -219,7 +280,6 @@ export class Contemplator {
 	/** Bounds retries of one poisoned memory update so future updates can run. */
 	private consecutiveFlushFailures = 0;
 	private seenObservationIds = new Set<string>();
-	private seenSummaryIds = new Set<string>();
 	private seenReviewIds = new Set<string>();
 	private inFlightReviewKeys = new Set<string>();
 	private inFlightReviewIds = new Set<string>();
@@ -302,9 +362,9 @@ export class Contemplator {
 			this.consecutiveFlushFailures = 0;
 			this.agentActiveSince = undefined;
 			this.history = [];
+			this.historyEntryIds = [];
 			this.pending = undefined;
 			this.seenObservationIds.clear();
-			this.seenSummaryIds.clear();
 			this.seenReviewIds.clear();
 			this.inFlightReviewKeys.clear();
 			this.inFlightReviewIds.clear();
@@ -321,7 +381,6 @@ export class Contemplator {
 			this.runtime.contemplatorState = {
 				running: false,
 				pendingObservations: 0,
-				pendingSummaries: 0,
 				pendingReviews: 0,
 				responsesSinceRun: 0,
 				waitingFor: "idle",
@@ -431,7 +490,6 @@ export class Contemplator {
 			...this.runtime.contemplatorState,
 			running: this.running,
 			pendingObservations: this.pending?.observations.length ?? 0,
-			pendingSummaries: this.pending?.summaries.length ?? 0,
 			pendingReviews: this.pending?.reviews.length ?? 0,
 			responsesSinceRun: this.turnsSinceRun,
 			waitingFor,
@@ -446,6 +504,8 @@ export class Contemplator {
 		if (this.running && !resetTracking) return;
 		if (tipId === this.restoredTipId && !resetTracking) return;
 		this.history = [];
+		this.historyEntryIds = [];
+		const historyMessagesByEntryId = new Map<string, AgentMessage>();
 		let resetProjection: ReturnType<typeof fullProjection> | undefined;
 		if (resetTracking) {
 			this.deliveredProbeIds.clear();
@@ -457,7 +517,6 @@ export class Contemplator {
 			this.reviewerSessions.clear();
 			resetProjection = fullProjection(entries);
 			this.seenObservationIds.clear();
-			this.seenSummaryIds.clear();
 			this.seenReviewIds.clear();
 			this.pending = undefined;
 			this.turnsSinceRun = 0;
@@ -465,7 +524,6 @@ export class Contemplator {
 			this.runtime.contemplatorState = {
 				running: false,
 				pendingObservations: 0,
-				pendingSummaries: 0,
 				pendingReviews: 0,
 				responsesSinceRun: 0,
 				waitingFor: "idle",
@@ -475,14 +533,27 @@ export class Contemplator {
 		for (const entry of entries) {
 			if (entry.customType === CONTEMPLATOR_STATE && entry.data && typeof entry.data === "object") {
 				const state = entry.data as { history?: unknown };
-				if (Array.isArray(state.history)) this.history = state.history.filter((message): message is AgentMessage => !!message && typeof message === "object");
+				if (Array.isArray(state.history)) {
+					this.history = state.history.filter((message): message is AgentMessage => !!message && typeof message === "object");
+					this.historyEntryIds = this.history.map(() => undefined);
+				}
 			}
 			if (entry.customType === CONTEMPLATOR_MESSAGE && entry.data && typeof entry.data === "object") {
-				const data = entry.data as { message?: unknown; compacted?: unknown };
+				const data = entry.data as { message?: unknown; compacted?: unknown; retainedMessageEntryIds?: unknown };
 				const message = data.message;
 				if (message && typeof message === "object") {
-					if (data.compacted === true) this.history = [message as AgentMessage];
-					else this.history.push(message as AgentMessage);
+					const typedMessage = message as AgentMessage;
+					historyMessagesByEntryId.set(entry.id, typedMessage);
+					if (data.compacted === true) {
+						const retainedIds = Array.isArray(data.retainedMessageEntryIds)
+							? data.retainedMessageEntryIds.filter((id): id is string => typeof id === "string" && historyMessagesByEntryId.has(id))
+							: [];
+						this.history = [typedMessage, ...retainedIds.map((id) => historyMessagesByEntryId.get(id)!)];
+						this.historyEntryIds = [entry.id, ...retainedIds];
+					} else {
+						this.history.push(typedMessage);
+						this.historyEntryIds.push(entry.id);
+					}
 				}
 			}
 			if (entry.customType === OM_REVIEWER_STATE && entry.data && typeof entry.data === "object") {
@@ -547,12 +618,10 @@ export class Contemplator {
 				for (const id of memoryReferenceIds(text)) coveredIds.add(id);
 			}
 			this.seenObservationIds = new Set(resetProjection.observations.filter((item) => coveredIds.has(item.id)).map((item) => item.id));
-			this.seenSummaryIds = new Set(resetProjection.summaries.filter((item) => coveredIds.has(item.id)).map((item) => item.id));
 			this.seenReviewIds = new Set((resetProjection.reviews ?? []).filter((item) => coveredIds.has(item.id)).map((item) => item.id));
 			const unprocessedObservations = resetProjection.observations.length - this.seenObservationIds.size;
-			const unprocessedSummaries = resetProjection.summaries.length - this.seenSummaryIds.size;
 			const unprocessedReviews = (resetProjection.reviews?.length ?? 0) - this.seenReviewIds.size;
-			if (unprocessedReviews > 0 || unprocessedObservations >= this.runtime.config.contemplatorMinNewObservations || unprocessedSummaries >= this.runtime.config.contemplatorMinNewSummaries) {
+			if (unprocessedReviews > 0 || unprocessedObservations >= this.runtime.config.contemplatorMinNewObservations) {
 				this.turnsSinceRun = this.runtime.config.contemplatorMinTurns;
 			}
 		}
@@ -607,31 +676,24 @@ export class Contemplator {
 		}
 		const projection = fullProjection(branchEntries);
 		const observations = projection.observations.map((item) => `[${item.id}] ${item.content}`);
-		const summaries = projection.summaries.map((item) => `[${item.id}] ${item.content}`);
 		const reviews = projection.reviews ?? [];
 		const newObservationItems = projection.observations.filter((item) => !this.seenObservationIds.has(item.id));
-		const newSummaryItems = projection.summaries.filter((item) => !this.seenSummaryIds.has(item.id));
 		const newReviewItems = reviews.filter((item) => !this.seenReviewIds.has(item.id));
 		const newObservations = newObservationItems.map((item) => `[${item.id}] ${item.content}`);
-		const newSummaries = newSummaryItems.map((item) => `[${item.id}] ${item.content}`);
 		const newReviews = newReviewItems.map(reviewSummaryLine);
 		for (const item of newObservationItems) this.seenObservationIds.add(item.id);
-		for (const item of newSummaryItems) this.seenSummaryIds.add(item.id);
 		for (const item of newReviewItems) this.seenReviewIds.add(item.id);
 		debugLog("contemplator.update", {
 			observationCount: observations.length,
-			summaryCount: summaries.length,
 			newObservationCount: newObservations.length,
-			newSummaryCount: newSummaries.length,
 			newReviewCount: newReviews.length,
 			turnsSinceRun: this.turnsSinceRun,
 			pending: this.pending !== undefined,
 			running: this.running,
 		});
-		if (newObservations.length > 0 || newSummaries.length > 0 || newReviews.length > 0) {
+		if (newObservations.length > 0 || newReviews.length > 0) {
 			this.pending = {
 				observations: mergeMemoryLines(this.pending?.observations ?? [], newObservations),
-				summaries: mergeMemoryLines(this.pending?.summaries ?? [], newSummaries),
 				reviews: mergeMemoryLines(this.pending?.reviews ?? [], newReviews),
 				mainAgentOutputTokens: assistantOutputTokens(branchEntries),
 				mainAgentToolCalls: assistantToolCallCount(branchEntries),
@@ -648,7 +710,7 @@ export class Contemplator {
 		this.pending.mainAgentOutputTokens = assistantOutputTokens(branchEntries);
 		this.pending.mainAgentToolCalls = assistantToolCallCount(branchEntries);
 		this.pending.mainAgentActiveTimeMs = agentActiveTimeMs(branchEntries);
-		const enoughMemories = this.pending.reviews.length > 0 || this.pending.observations.length >= this.runtime.config.contemplatorMinNewObservations || this.pending.summaries.length >= this.runtime.config.contemplatorMinNewSummaries;
+		const enoughMemories = this.pending.reviews.length > 0 || this.pending.observations.length >= this.runtime.config.contemplatorMinNewObservations;
 		if (this.probeCooldownPendingIds.size > 0) {
 			this.publishState("probe");
 			debugLog("contemplator.waiting", { reason: "probe_delivery", pendingProbeCount: this.probeCooldownPendingIds.size });
@@ -661,14 +723,12 @@ export class Contemplator {
 				turnsSinceRun: this.turnsSinceRun,
 				minTurns: this.runtime.config.contemplatorMinTurns,
 				minNewObservations: this.runtime.config.contemplatorMinNewObservations,
-				minNewSummaries: this.runtime.config.contemplatorMinNewSummaries,
 			});
 			return;
 		}
 		this.publishState(this.running ? "running" : "ready");
 		debugLog("contemplator.triggered", {
 			pendingObservationCount: this.pending.observations.length,
-			pendingSummaryCount: this.pending.summaries.length,
 			pendingReviewCount: this.pending.reviews.length,
 			turnsSinceRun: this.turnsSinceRun,
 		});
@@ -705,7 +765,6 @@ export class Contemplator {
 		this.publishState("running", { lastStartedAt: startedAt, lastError: undefined });
 		debugLog("contemplator.start", {
 			newObservationCount: update.observations.length,
-			newSummaryCount: update.summaries.length,
 			newReviewCount: update.reviews.length,
 			historyMessageCount: this.history.length,
 		});
@@ -727,14 +786,13 @@ export class Contemplator {
 						const pending = this.pending as PendingUpdate | undefined;
 						this.pending = {
 							observations: mergeMemoryLines(pending?.observations ?? [], update.observations),
-							summaries: mergeMemoryLines(pending?.summaries ?? [], update.summaries),
 							reviews: mergeMemoryLines(pending?.reviews ?? [], update.reviews),
 							mainAgentOutputTokens: update.mainAgentOutputTokens,
 							mainAgentToolCalls: update.mainAgentToolCalls,
 							mainAgentActiveTimeMs: update.mainAgentActiveTimeMs,
 						};
 					} else {
-						debugLog("contemplator.poisoned_update_released", { reason: resolved.reason, observationCount: update.observations.length, summaryCount: update.summaries.length, reviewCount: update.reviews.length });
+						debugLog("contemplator.poisoned_update_released", { reason: resolved.reason, observationCount: update.observations.length, reviewCount: update.reviews.length });
 						this.consecutiveFlushFailures = 0;
 					}
 					this.turnsSinceRun = 0; // Back off until fresh primary responses arrive; never retry every checkpoint.
@@ -759,7 +817,6 @@ export class Contemplator {
 			const reviewerEnabled = this.runtime.config.reviewerEnabled;
 			const updateSections: string[] = [];
 			if (update.observations.length > 0) updateSections.push(`OBSERVATIONS:\n${update.observations.join("\n")}`);
-			if (update.summaries.length > 0) updateSections.push(`SUMMARIES:\n${update.summaries.join("\n")}`);
 			if (update.reviews.length > 0) updateSections.push(`REVIEWS:\n${update.reviews.join("\n")}`);
 			const updateBody = updateSections.length > 0 ? updateSections.join("\n\n") : "(no new memories)";
 			const finalActionNames = reviewerEnabled
@@ -883,7 +940,7 @@ export class Contemplator {
 				for (const message of runMessages) {
 					if (message.role !== "user" && message.role !== "assistant") continue;
 					this.history.push(message);
-					this.pi.appendEntry(CONTEMPLATOR_MESSAGE, { version: 1, message });
+					this.historyEntryIds.push(this.appendContemplatorHistoryEntry(ctx, { version: 1, message }));
 					promptPersisted = true;
 					this.markTipPersisted(ctx);
 				}
@@ -913,7 +970,13 @@ export class Contemplator {
 			}
 			if (sessionGeneration === this.sessionGeneration) {
 				workerWatchdog.progress();
-				await workerWatchdog.race(this.compactHistory(resolved.model as Model<any>, resolved.apiKey, resolved.headers, sessionGeneration, flushEpoch));
+				try {
+					await workerWatchdog.race(this.compactHistory(ctx, resolved.model as Model<any>, resolved.apiKey, resolved.headers, sessionGeneration, flushEpoch, workerWatchdog.signal));
+				} catch (compactionError) {
+					// The intervention and its durable messages are already complete. Private
+					// history maintenance must never relabel that successful work as failed.
+					debugLog("contemplator.compaction_postponed", { reason: compactionError instanceof Error ? compactionError.message : String(compactionError) });
+				}
 			}
 		} catch (error) {
 			failed = true;
@@ -925,14 +988,13 @@ export class Contemplator {
 					const pending = this.pending as PendingUpdate | undefined;
 					this.pending = {
 						observations: mergeMemoryLines(pending?.observations ?? [], update.observations),
-						summaries: mergeMemoryLines(pending?.summaries ?? [], update.summaries),
 						reviews: mergeMemoryLines(pending?.reviews ?? [], update.reviews),
 						mainAgentOutputTokens: update.mainAgentOutputTokens,
 						mainAgentToolCalls: update.mainAgentToolCalls,
 						mainAgentActiveTimeMs: update.mainAgentActiveTimeMs,
 					};
 				} else {
-					debugLog("contemplator.poisoned_update_released", { reason: failureMessage, observationCount: update.observations.length, summaryCount: update.summaries.length, reviewCount: update.reviews.length });
+					debugLog("contemplator.poisoned_update_released", { reason: failureMessage, observationCount: update.observations.length, reviewCount: update.reviews.length });
 					this.consecutiveFlushFailures = 0;
 				}
 				this.turnsSinceRun = 0; // Back off until fresh primary responses arrive; never retry every checkpoint.
@@ -950,8 +1012,7 @@ export class Contemplator {
 			const waitingForProbe = this.probeCooldownPendingIds.size > 0;
 			const pendingHasEnoughMemories = this.pending !== undefined && (
 				this.pending.reviews.length > 0 ||
-				this.pending.observations.length >= this.runtime.config.contemplatorMinNewObservations ||
-				this.pending.summaries.length >= this.runtime.config.contemplatorMinNewSummaries
+				this.pending.observations.length >= this.runtime.config.contemplatorMinNewObservations
 			);
 			const waitingFor = waitingForProbe
 				? "probe"
@@ -1157,6 +1218,24 @@ export class Contemplator {
 		}
 	}
 
+	/**
+	 * Append one private-history entry and attribute its synchronous ledger id.
+	 * Pi does not return the id from appendEntry(), so prefer the exact data
+	 * object and accept a cloned payload only when exactly one matching entry was
+	 * appended. Ambiguity returns undefined rather than pointing at another
+	 * writer's message.
+	 */
+	private appendContemplatorHistoryEntry(ctx: MemoryUpdateCtx, data: Record<string, unknown>): string | undefined {
+		const branch = ctx.sessionManager.getBranch() as readonly Entry[];
+		const before = branch.length;
+		this.pi.appendEntry(CONTEMPLATOR_MESSAGE, data);
+		const candidates = (ctx.sessionManager.getBranch() as readonly Entry[])
+			.slice(before)
+			.filter((entry) => entry.customType === CONTEMPLATOR_MESSAGE);
+		return candidates.find((entry) => entry.data === data)?.id
+			?? (candidates.length === 1 ? candidates[0].id : undefined);
+	}
+
 	private markTipPersisted(ctx: MemoryUpdateCtx): string | undefined {
 		this.restoredTipId = (ctx.sessionManager.getBranch() as Entry[]).at(-1)?.id;
 		return this.restoredTipId;
@@ -1180,27 +1259,73 @@ export class Contemplator {
 		return own?.id;
 	}
 
-	private async compactHistory(model: Model<any>, apiKey: string, headers: Record<string, string> | undefined, sessionGeneration: number, flushEpoch: number): Promise<void> {
-		const serializedLength = this.history.reduce((total, message) => total + JSON.stringify(message).length, 0);
-		if (this.history.length < 12 || serializedLength < 60_000) return;
-		const previousMessageCount = this.history.length;
+	private async compactHistory(ctx: MemoryUpdateCtx, model: Model<any>, apiKey: string, headers: Record<string, string> | undefined, sessionGeneration: number, flushEpoch: number, signal?: AbortSignal): Promise<void> {
+		const history = this.history.slice();
+		const historyEntryIds = this.historyEntryIds.slice();
+		const historyTokens = contemplatorHistoryTokens(history);
+		const triggerTokens = contemplatorHistoryTriggerTokens(model);
+		if (history.length < 12 || historyTokens < triggerTokens) return;
+
+		const keepRecentTokens = Math.min(CONTEMPLATOR_HISTORY_KEEP_RECENT_TOKENS, Math.max(1, Math.floor(triggerTokens * 0.5)));
+		const initialPrefixEnd = recentHistoryStart(history, historyEntryIds, keepRecentTokens);
+		if (initialPrefixEnd === undefined) return;
+		const previousMessageCount = history.length;
 		debugLog("contemplator.compaction_start", {
 			historyMessageCount: previousMessageCount,
-			serializedLength,
+			historyTokens,
+			triggerTokens,
+			keepRecentTokens,
+			prefixMessageCount: initialPrefixEnd,
+			retainedMessageCount: history.length - initialPrefixEnd,
 		});
-		const history = this.history.slice();
-		const summaryWithUsage = await generateSummaryWithUsage(history as AgentMessage[], model, 4_000, apiKey, headers);
+
+		const summarizePrefix = async (prefixEnd: number) => generateSummaryWithUsage(
+			history.slice(0, prefixEnd),
+			model,
+			CONTEMPLATOR_HISTORY_SUMMARY_RESERVE_TOKENS,
+			apiKey,
+			headers,
+			signal,
+			CONTEMPLATOR_HISTORY_SUMMARY_INSTRUCTIONS,
+		);
+
+		let prefixEnd = initialPrefixEnd;
+		let summaryWithUsage: Awaited<ReturnType<typeof generateSummaryWithUsage>>;
+		try {
+			summaryWithUsage = await summarizePrefix(prefixEnd);
+		} catch (error) {
+			const failure = error instanceof Error ? error.message : String(error);
+			const fallbackEnd = /generation hit the token cap/i.test(failure)
+				? smallerPrefixEnd(history, initialPrefixEnd)
+				: undefined;
+			if (fallbackEnd === undefined) {
+				debugLog("contemplator.compaction_postponed", { reason: failure, historyTokens, prefixMessageCount: prefixEnd });
+				return;
+			}
+			prefixEnd = fallbackEnd;
+			debugLog("contemplator.compaction_retry_smaller_prefix", { reason: failure, prefixMessageCount: prefixEnd, retainedMessageCount: history.length - prefixEnd });
+			try {
+				summaryWithUsage = await summarizePrefix(prefixEnd);
+			} catch (fallbackError) {
+				debugLog("contemplator.compaction_postponed", {
+					reason: fallbackError instanceof Error ? fallbackError.message : String(fallbackError),
+					historyTokens,
+					prefixMessageCount: prefixEnd,
+				});
+				return;
+			}
+		}
+
 		this.runtime.recordAgentUsage(summaryWithUsage.usage);
 		if (sessionGeneration !== this.sessionGeneration || flushEpoch !== this.flushEpoch) {
 			debugLog("contemplator.compaction_stale", { reason: "session_or_branch_changed" });
 			return;
 		}
-		const summary = summaryWithUsage.text;
 		const summaryModel = model as Model<any> & { api?: unknown; provider?: string; id?: string };
 		const summaryUsage = summaryWithUsage.usage;
-		this.history = [{
+		const summaryMessage = {
 			role: "assistant",
-			content: [{ type: "text", text: `Previous contemplator context summary:\n${summary}` }],
+			content: [{ type: "text", text: `Previous contemplator context summary:\n${summaryWithUsage.text}` }],
 			api: summaryModel.api,
 			provider: summaryModel.provider ?? "unknown",
 			model: summaryModel.id ?? "contemplator",
@@ -1214,12 +1339,37 @@ export class Contemplator {
 			},
 			stopReason: "stop",
 			timestamp: Date.now(),
-		} as AgentMessage];
-		this.pi.appendEntry(CONTEMPLATOR_MESSAGE, { version: 1, compacted: true, message: this.history[0] });
+		} as AgentMessage;
+		// A flush currently owns private-history mutation while this awaits the
+		// model, and session/tree movement invalidates the generation above. Still,
+		// preserve any future append-only writer rather than replacing a stale
+		// snapshot and silently dropping messages. Non-append mutation is unsafe to
+		// merge, so postpone and let a later pass compact the live transcript.
+		const liveHistory = this.history;
+		const liveHistoryEntryIds = this.historyEntryIds;
+		const snapshotIsLivePrefix = liveHistory.length >= history.length
+			&& history.every((message, index) => liveHistory[index] === message && liveHistoryEntryIds[index] === historyEntryIds[index]);
+		if (!snapshotIsLivePrefix) {
+			debugLog("contemplator.compaction_postponed", { reason: "private history changed during compaction" });
+			return;
+		}
+		const retainedMessages = liveHistory.slice(prefixEnd);
+		const retainedMessageEntryIds = liveHistoryEntryIds.slice(prefixEnd).filter((id): id is string => typeof id === "string");
+		if (retainedMessageEntryIds.length !== retainedMessages.length) {
+			debugLog("contemplator.compaction_postponed", { reason: "retained history lacked durable entry ids", retainedMessageCount: retainedMessages.length, retainedReferenceCount: retainedMessageEntryIds.length });
+			return;
+		}
+		const checkpoint = { version: 2, compacted: true, message: summaryMessage, retainedMessageEntryIds };
+		const checkpointEntryId = this.appendContemplatorHistoryEntry(ctx, checkpoint);
+		this.history = [summaryMessage, ...retainedMessages];
+		this.historyEntryIds = [checkpointEntryId, ...retainedMessageEntryIds];
+		this.markTipPersisted(ctx);
 		debugLog("contemplator.compaction_complete", {
 			previousMessageCount,
 			newMessageCount: this.history.length,
-			summaryLength: summary.length,
+			prefixMessageCount: prefixEnd,
+			retainedMessageCount: retainedMessages.length,
+			summaryLength: summaryWithUsage.text.length,
 		});
 	}
 }

package/src/agents/contemplator/prompts.ts

@@ -6,7 +6,7 @@ export function buildContemplatorSystemPrompt(
 
 Neither you nor the primary agent should be assumed to know the correct solution. You are jointly exploring a problem space from different perspectives. The primary agent interacts with the actual environment and carries out the work. You maintain a longer-term view of the reasoning, evidence, assumptions, alternatives, unresolved questions${reviewerEnabled ? ", and recurring structural patterns" : ""} that emerge over time.
 
-You receive incremental observations and cited summaries produced by other agent loops. Some memories summarize user messages. Pay extra attention to memories about the user’s intent, priorities, constraints, corrections, and desired outcome.
+You receive incremental observations about primary-agent activity. Pay extra attention to memories about the user’s intent, priorities, constraints, corrections, and desired outcome. Older summarized memories remain available through search_memories and recall when you need historical context, but summary maintenance is not itself a new event.
 
 You see only the memory ledger, not the primary agent’s live activity. Your understanding may be incomplete or slightly stale. Do not infer inactivity, failure, or lack of progress from missing recent results. A result may simply not have reached memory yet.
 

package/src/commands/contemplator-view.ts

@@ -59,7 +59,7 @@ function renderMessage(message: StoredMessage, compacted: boolean): string {
 }
 
 function liveStateLine(state: ContemplatorRunState): string {
-	const pending = `${state.pendingObservations} observations / ${state.pendingSummaries} summaries / ${state.pendingReviews} reviews pending`;
+	const pending = `${state.pendingObservations} observations / ${state.pendingReviews} reviews pending`;
 	const timing = `Last start: ${state.lastStartedAt === undefined ? "not run this launch" : new Date(state.lastStartedAt).toISOString()} · Last end: ${state.lastCompletedAt === undefined ? "not completed this launch" : new Date(state.lastCompletedAt).toISOString()}`;
 	const error = state.lastError ? `\nLast error: ${state.lastError}` : "";
 	if (state.running) return `LIVE · running for ${Math.max(0, Math.floor((Date.now() - (state.lastStartedAt ?? Date.now())) / 60_000))}m · ${pending}\n${timing}${error}`;

package/src/commands/settings.ts

@@ -10,7 +10,7 @@ type ModelRegistryLike = {
 	getAll(): Array<{ provider: string; id: string }>;
 	find?(provider: string, id: string): { contextWindow?: number } | undefined;
 };
-type NumberSetting = "observeAfterTokens" | "compactAfterTokens" | "observerChunkMaxTokens" | "newMemoryPoolMaxTokens" | "oldMemoryPoolTargetTokens" | "agentMaxTurns" | "contemplatorMinNewObservations" | "contemplatorMinNewSummaries" | "contemplatorMinTurns" | "summarizerRetriggerTokens" | "summarizerSamplingThresholdTokens";
+type NumberSetting = "observeAfterTokens" | "compactAfterTokens" | "observerChunkMaxTokens" | "newMemoryPoolMaxTokens" | "oldMemoryPoolTargetTokens" | "agentMaxTurns" | "contemplatorMinNewObservations" | "contemplatorMinTurns" | "summarizerRetriggerTokens" | "summarizerSamplingThresholdTokens";
 type BooleanSetting = "contemplatorEnabled" | "showContemplatorMessages" | "reviewerEnabled" | "summarizerEnabled" | "compactionObserverEnabled" | "showWorkerNotifications" | "passive" | "debugLog";
 
 function modelLabel(model: ConfiguredModel | undefined): string {
@@ -216,7 +216,6 @@ export function registerSettingsCommand(pi: ExtensionAPI, runtime: Runtime): voi
 				`Contemplator model: ${hasOverride(settings, "contemplatorModel") ? modelLabel(runtime.config.contemplatorModel) : `${modelLabel(runtime.getDefaultConfig().contemplatorModel)} (default)`}`,
 				`Show contemplator messages: ${scalarLabel(runtime, "showContemplatorMessages")}`,
 				`Contemplator new-observation trigger (count): ${scalarLabel(runtime, "contemplatorMinNewObservations")}`,
-				`Contemplator new-summary trigger (count): ${scalarLabel(runtime, "contemplatorMinNewSummaries")}`,
 				`Contemplator response spacing (count): ${scalarLabel(runtime, "contemplatorMinTurns")}`,
 				`Summarizer enabled: ${scalarLabel(runtime, "summarizerEnabled")}`,
 				`New memory pool protection budget (tokens): ${scalarLabel(runtime, "newMemoryPoolMaxTokens")}`,
@@ -272,7 +271,6 @@ export function registerSettingsCommand(pi: ExtensionAPI, runtime: Runtime): voi
 					["New memory pool protection budget (tokens):", "newMemoryPoolMaxTokens", "New memory pool protection budget (tokens)"],
 					["Old memory pool target (tokens, advisory):", "oldMemoryPoolTargetTokens", "Old memory pool target (tokens, advisory)"],
 					["Contemplator new-observation trigger (count):", "contemplatorMinNewObservations", "Contemplator new-observation trigger (count)"],
-					["Contemplator new-summary trigger (count):", "contemplatorMinNewSummaries", "Contemplator new-summary trigger (count)"],
 					["Contemplator response spacing (count):", "contemplatorMinTurns", "Contemplator response spacing (count)"],
 					["Summarizer old-pool retrigger growth (tokens):", "summarizerRetriggerTokens", "Summarizer old-pool retrigger growth (tokens)"],
 					["Summarizer input cap before sampling (tokens):", "summarizerSamplingThresholdTokens", "Summarizer input cap before sampling (tokens)"],

package/src/commands/status.ts

@@ -130,7 +130,7 @@ export function registerStatusCommand(pi: ExtensionAPI, runtime: Runtime): void
 				`Cumulative agent time:   ${formatDuration(agentActiveTimeMs(entries))}`,
 				`Observe source during compaction: ${runtime.config.compactionObserverEnabled === false ? "disabled" : "enabled"}`,
 				`Contemplator:             ${runtime.config.contemplatorEnabled ? "enabled" : "disabled"}`,
-				`Contemplator trigger:     ${runtime.contemplatorState.pendingObservations} observations / ${runtime.contemplatorState.pendingSummaries} summaries / ${runtime.contemplatorState.pendingReviews} reviews pending; ${runtime.contemplatorState.responsesSinceRun} / ${runtime.config.contemplatorMinTurns} primary responses; ${contemplatorWaitingLabel(runtime.contemplatorState.waitingFor)}`,
+				`Contemplator trigger:     ${runtime.contemplatorState.pendingObservations} observations / ${runtime.contemplatorState.pendingReviews} reviews pending; ${runtime.contemplatorState.responsesSinceRun} / ${runtime.config.contemplatorMinTurns} primary responses; ${contemplatorWaitingLabel(runtime.contemplatorState.waitingFor)}`,
 				`Contemplator model:      ${runtime.config.contemplatorModel ? `${runtime.config.contemplatorModel.provider}/${runtime.config.contemplatorModel.id}` : "current session model"}`,
 				`Contemplator messages:   ${runtime.config.showContemplatorMessages ? "visible" : "hidden"}`,
 				`Structural reviewer:     ${runtime.config.reviewerEnabled === false ? "disabled" : "enabled"}`,

package/src/config.ts

@@ -60,7 +60,6 @@ export interface Config {
 	/** Optional model override used only by short-lived structural reviewers. */
 	reviewerModel?: ConfiguredModel;
 	contemplatorMinNewObservations: number;
-	contemplatorMinNewSummaries: number;
 	/** Minimum primary-model responses after contemplator completion, or after delivery of its probe, before the next run. */
 	contemplatorMinTurns: number;
 	/** Stateless loss-aware summarizer for the old memory pool. */
@@ -87,7 +86,6 @@ export const DEFAULTS: Config = {
 	showContemplatorMessages: true,
 	reviewerEnabled: true,
 	contemplatorMinNewObservations: 8,
-	contemplatorMinNewSummaries: 1,
 	contemplatorMinTurns: 10,
 	summarizerEnabled: true,
 	summarizerRetriggerTokens: 2_000,
@@ -210,7 +208,6 @@ function normalizeSettingsConfig(value: Record<string, unknown>): Partial<Config
 		"oldMemoryPoolTargetTokens",
 		"agentMaxTurns",
 		"contemplatorMinNewObservations",
-		"contemplatorMinNewSummaries",
 		"contemplatorMinTurns",
 		"summarizerRetriggerTokens",
 		"summarizerSamplingThresholdTokens",

package/src/hooks/consolidation-trigger.ts

@@ -393,7 +393,8 @@ export function scheduleSummarizer(pi: ExtensionAPI, runtime: Runtime, ctx: Cons
 				runtime.lastSummarizerRun = { ...runtime.lastSummarizerRun!, status: "completed", summary };
 				debugLog("summarizer.appended", { summaries: result.commit.summaries.length, consumed: result.commit.metrics.consumedMemoryCount, sampled: result.sample?.sampled ?? false });
 				if (shouldNotifyWorker(runtime, ctx)) ctx.ui?.notify(`pi-contemplator: summarizer completed — ${summary}`, "info");
-				runtime.notifyMemoryUpdate(ctx);
+				// Summaries compact older memories; they are not new events and must not
+				// wake or enter the contemplator's incremental update stream.
 			} else {
 				successfullyCompleted = true;
 				runtime.lastSummarizerRun = { ...runtime.lastSummarizerRun!, status: "completed", summary: "No safe summaries were created." };

package/src/runtime.ts

@@ -25,7 +25,7 @@ export type SessionSettings = Partial<Pick<Config,
 	| "compactAfterTokensMode" | "compactAfterTokensRatio"
 	| "newMemoryPoolMaxTokens" | "oldMemoryPoolTargetTokens" | "agentMaxTurns"
 	| "showWorkerNotifications" | "passive" | "compactionObserverEnabled" | "contemplatorEnabled" | "showContemplatorMessages" | "reviewerEnabled"
-	| "contemplatorMinNewObservations" | "contemplatorMinNewSummaries" | "contemplatorMinTurns"
+	| "contemplatorMinNewObservations" | "contemplatorMinTurns"
 	| "summarizerEnabled" | "summarizerRetriggerTokens" | "summarizerSamplingThresholdTokens"
 	| "debugLog"
 >> & {
@@ -80,7 +80,6 @@ export interface SummarizerRunView {
 export interface ContemplatorRunState {
 	running: boolean;
 	pendingObservations: number;
-	pendingSummaries: number;
 	pendingReviews: number;
 	/** Completed primary-model responses since the current completion/probe-delivery spacing anchor. */
 	responsesSinceRun: number;
@@ -140,7 +139,7 @@ export function computeSessionSettings(entries: readonly unknown[]): SessionSett
 		const numberKeys = [
 			"observeAfterTokens", "observerChunkMaxTokens", "compactAfterTokens",
 			"newMemoryPoolMaxTokens", "oldMemoryPoolTargetTokens", "agentMaxTurns",
-			"contemplatorMinNewObservations", "contemplatorMinNewSummaries", "contemplatorMinTurns",
+			"contemplatorMinNewObservations", "contemplatorMinTurns",
 			"summarizerRetriggerTokens", "summarizerSamplingThresholdTokens",
 		] as const;
 		for (const key of booleanKeys) if (typeof data[key] === "boolean") restored[key] = data[key];
@@ -209,7 +208,6 @@ export class Runtime {
 	contemplatorState: ContemplatorRunState = {
 		running: false,
 		pendingObservations: 0,
-		pendingSummaries: 0,
 		pendingReviews: 0,
 		responsesSinceRun: 0,
 		waitingFor: "idle",
@@ -299,7 +297,6 @@ export class Runtime {
 		this.contemplatorState = {
 			running: false,
 			pendingObservations: 0,
-			pendingSummaries: 0,
 			pendingReviews: 0,
 			responsesSinceRun: 0,
 			waitingFor: "idle",