@matthewfl/pi-contemplator 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matthewfl/pi-contemplator",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "A Pi extension that keeps long-running agentic sessions on track with background memory, contemplation, and structural review.",
   "type": "module",
   "license": "MIT",
@@ -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

@@ -21,7 +21,6 @@ import { createWorkerStallWatchdog } from "../../worker-watchdog.js";
 
 interface PendingUpdate {
 	observations: string[];
-	summaries: string[];
 	reviews: string[];
 	mainAgentOutputTokens: number;
 	mainAgentToolCalls: number;
@@ -219,7 +218,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>();
@@ -304,7 +302,6 @@ export class Contemplator {
 			this.history = [];
 			this.pending = undefined;
 			this.seenObservationIds.clear();
-			this.seenSummaryIds.clear();
 			this.seenReviewIds.clear();
 			this.inFlightReviewKeys.clear();
 			this.inFlightReviewIds.clear();
@@ -321,7 +318,6 @@ export class Contemplator {
 			this.runtime.contemplatorState = {
 				running: false,
 				pendingObservations: 0,
-				pendingSummaries: 0,
 				pendingReviews: 0,
 				responsesSinceRun: 0,
 				waitingFor: "idle",
@@ -431,7 +427,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,
@@ -457,7 +452,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 +459,6 @@ export class Contemplator {
 			this.runtime.contemplatorState = {
 				running: false,
 				pendingObservations: 0,
-				pendingSummaries: 0,
 				pendingReviews: 0,
 				responsesSinceRun: 0,
 				waitingFor: "idle",
@@ -547,12 +540,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;
 			}
 		}
@@ -586,49 +577,45 @@ export class Contemplator {
 		}
 		const branchEntries = ctx.sessionManager.getBranch() as Entry[];
 		const observerBacklogTokens = rawTokensSinceObservationCoverage(branchEntries);
-		if (
+		const waitingForCapturedObserverBacklog = this.runtime.observerBacklogBlocking || (
+			!this.runtime.consolidationInFlight &&
 			observerBacklogTokens >= this.runtime.config.observeAfterTokens &&
-			(this.runtime.consolidationInFlight || this.runtime.lastObserverError === undefined)
-		) {
+			this.runtime.lastObserverError === undefined
+		);
+		if (waitingForCapturedObserverBacklog) {
 			// A catch-up observer pipeline may append several partial batches while it
-			// drains old source. Do not let primary-agent checkpoints feed those
-			// fragments to the contemplator one at a time. The pipeline emits one
-			// memory update after the backlog falls below the observer trigger.
+			// drains the finite source snapshot captured at launch. Do not feed those
+			// fragments to the contemplator one at a time. Source appended concurrently
+			// belongs to the next snapshot and must not extend this waiting period.
 			this.publishState("observer");
 			debugLog("contemplator.waiting", {
 				reason: "observer_backlog",
 				observerBacklogTokens,
+				observerBacklogBlocking: this.runtime.observerBacklogBlocking,
 				observeAfterTokens: this.runtime.config.observeAfterTokens,
 			});
 			return;
 		}
 		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),
@@ -645,7 +632,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 });
@@ -658,14 +645,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,
 		});
@@ -702,7 +687,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,
 		});
@@ -724,14 +708,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.
@@ -756,7 +739,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
@@ -922,14 +904,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.
@@ -947,8 +928,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"

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

@@ -18,6 +18,7 @@ import {
 	observationToSummaryLine,
 	partitionMemoryPools,
 	rawTokensSinceObservationCoverage,
+	rawTokensSinceObservationCoverageThrough,
 	summaryToSummaryLine,
 	type Entry,
 } from "../session-ledger/index.js";
@@ -51,8 +52,12 @@ export function createSummarizerStallWatchdog(
 	return watchdog;
 }
 
-function sourceEntriesAfter(entries: Entry[], index: number): Entry[] {
-	return entries.slice(index + 1).filter(isSourceEntry);
+function sourceEntriesAfter(entries: Entry[], index: number, throughEntryId?: string): Entry[] {
+	const throughIndex = throughEntryId === undefined
+		? entries.length - 1
+		: entries.findIndex((entry) => entry.id === throughEntryId);
+	if (throughIndex < 0 || throughIndex <= index) return [];
+	return entries.slice(index + 1, throughIndex + 1).filter(isSourceEntry);
 }
 
 function appendEntry(pi: ExtensionAPI, customType: string, data: unknown): void {
@@ -161,6 +166,7 @@ function maybeLaunchConsolidation(pi: ExtensionAPI, runtime: Runtime, ctx: Conso
 	};
 
 	const sessionMetadata = debugSessionMetadata(ctx);
+	const launchGeneration = runtime.getContextGeneration();
 	const task = runtime.launchConsolidationTask(ctx, async () => withDebugLogContext({
 		enabled: runtime.config.debugLog === true,
 		cwd: ctx.cwd,
@@ -174,7 +180,15 @@ function maybeLaunchConsolidation(pi: ExtensionAPI, runtime: Runtime, ctx: Conso
 	// degraded mode rather than leaving all advisory work gated forever. Future
 	// primary activity still retries the observer.
 	void task.then(() => {
-		if (runtime.lastObserverError) runtime.notifyMemoryUpdate(ctx);
+		if (launchGeneration !== runtime.getContextGeneration()) return;
+		if (runtime.lastObserverError) {
+			runtime.notifyMemoryUpdate(ctx);
+			return;
+		}
+		// Source appended while the finite catch-up snapshot was running belongs
+		// to a later snapshot. Recheck after the lock is released; the completed
+		// pipeline has already given the contemplator its memory-update opportunity.
+		maybeLaunchConsolidation(pi, runtime, ctx);
 	});
 }
 
@@ -225,19 +239,25 @@ export async function runConsolidationPipeline(
 	const resolveModel = makeModelResolver(runtime, ctx);
 	const contextGeneration = runtime.getContextGeneration();
 
+	const pipelineEntries = options.observerEntries ?? (ctx.sessionManager.getBranch() as Entry[]);
+	const initialCoverage = latestCoverageIndex(pipelineEntries, OM_OBSERVATIONS_RECORDED);
+	const catchUpThroughId = sourceEntriesAfter(pipelineEntries, initialCoverage).at(-1)?.id;
 	const beforeFold = foldLedger(ctx.sessionManager.getBranch() as Entry[]);
 	runtime.consolidationPhase = "observer";
+	runtime.observerBacklogBlocking = catchUpThroughId !== undefined;
 	try {
-		// A large backlog is drained in bounded, oldest-first chunks. The normal
-		// trigger threshold controls when the batch stops; a static compaction
-		// snapshot is intentionally processed only once. Coverage must advance on
-		// every iteration, otherwise stop rather than spin on a failed chunk.
+		// Drain only the finite source snapshot captured at pipeline launch, using
+		// bounded oldest-first chunks. Concurrent source belongs to a later pipeline,
+		// so a fast primary agent cannot indefinitely extend this blocking backlog.
+		// A static compaction snapshot is intentionally processed only once. Coverage
+		// must advance on every iteration, otherwise stop rather than spin.
 		while (true) {
 			const beforeEntries = ctx.sessionManager.getBranch() as Entry[];
 			const beforeCoverage = latestCoverageIndex(beforeEntries, OM_OBSERVATIONS_RECORDED);
 			const observerOutcome = await runObserverStage(pi, runtime, ctx, resolveModel, {
 				force: options.forceObserver === true,
 				entries: options.observerEntries,
+				throughSourceEntryId: options.observerEntries ? undefined : catchUpThroughId,
 				contextGeneration,
 			});
 			if (observerOutcome === "abort") return;
@@ -245,13 +265,19 @@ export async function runConsolidationPipeline(
 
 			const afterEntries = ctx.sessionManager.getBranch() as Entry[];
 			const afterCoverage = latestCoverageIndex(afterEntries, OM_OBSERVATIONS_RECORDED);
-			const remainingTokens = rawTokensSinceObservationCoverage(afterEntries);
+			const remainingTokens = catchUpThroughId === undefined
+				? 0
+				: rawTokensSinceObservationCoverageThrough(afterEntries, catchUpThroughId);
 			if (afterCoverage <= beforeCoverage || remainingTokens < runtime.config.observeAfterTokens) break;
 			debugLog("observer.backlog_continue", { remainingTokens, afterCoverage });
 		}
 	} catch (error) {
 		debugLog("observer.error", { errorMessage: runtime.recordConsolidationStageError(ctx, "observer", error) });
 		return;
+	} finally {
+		// New source appended after catchUpThroughId was never part of this
+		// pipeline's blocking backlog. Clear before notifying the contemplator.
+		if (contextGeneration === runtime.getContextGeneration()) runtime.observerBacklogBlocking = false;
 	}
 	const afterFold = foldLedger(ctx.sessionManager.getBranch() as Entry[]);
 	const beforeIds = new Set(beforeFold.observations.map((item) => item.id));
@@ -367,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." };
@@ -408,10 +435,12 @@ async function runObserverStage(
 	runtime: Runtime,
 	ctx: ConsolidationCtx,
 	resolveModel: (stage: "observer") => Promise<ResolvedModel | undefined>,
-	options: { force?: boolean; entries?: Entry[]; contextGeneration?: number } = {},
+	options: { force?: boolean; entries?: Entry[]; throughSourceEntryId?: string; contextGeneration?: number } = {},
 ): Promise<StageOutcome> {
 	const entries = options.entries ?? (ctx.sessionManager.getBranch() as Entry[]);
-	const tokens = rawTokensSinceObservationCoverage(entries);
+	const tokens = options.throughSourceEntryId === undefined
+		? rawTokensSinceObservationCoverage(entries)
+		: rawTokensSinceObservationCoverageThrough(entries, options.throughSourceEntryId);
 	if (!options.force && tokens < runtime.config.observeAfterTokens) return "continue";
 
 	// Resolve the model before building the chunk: the default chunk cap
@@ -424,7 +453,7 @@ async function runObserverStage(
 	}
 
 	const lastCoverageIdx = latestCoverageIndex(entries, OM_OBSERVATIONS_RECORDED);
-	const backlogEntries = sourceEntriesAfter(entries, lastCoverageIdx);
+	const backlogEntries = sourceEntriesAfter(entries, lastCoverageIdx, options.throughSourceEntryId);
 
 	// Budget the text that is actually sent to the observer, including source
 	// labels and rendered message content. Complete entries are kept intact.

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];
@@ -182,6 +181,8 @@ export class Runtime {
 	private settingsUpdateListener: ((ctx: MemoryUpdateCtx, settings: SettingsUpdate) => void) | undefined;
 	private contextGeneration = 0;
 	consolidationPhase: ConsolidationPhase | undefined;
+	/** True only while the observer is draining the finite source snapshot captured at pipeline start. */
+	observerBacklogBlocking = false;
 	compactInFlight = false;
 	compactRequested = false;
 	/** Agent-authored instructions to deliver after an explicit compact_context request. */
@@ -207,7 +208,6 @@ export class Runtime {
 	contemplatorState: ContemplatorRunState = {
 		running: false,
 		pendingObservations: 0,
-		pendingSummaries: 0,
 		pendingReviews: 0,
 		responsesSinceRun: 0,
 		waitingFor: "idle",
@@ -274,6 +274,7 @@ export class Runtime {
 		this.consolidationInFlight = false;
 		this.consolidationPromise = null;
 		this.consolidationPhase = undefined;
+		this.observerBacklogBlocking = false;
 		this.summarizerInFlight = false;
 		this.summarizerPromise = null;
 		this.reviewInFlight = false;
@@ -296,7 +297,6 @@ export class Runtime {
 		this.contemplatorState = {
 			running: false,
 			pendingObservations: 0,
-			pendingSummaries: 0,
 			pendingReviews: 0,
 			responsesSinceRun: 0,
 			waitingFor: "idle",

package/src/session-ledger/progress.ts

@@ -138,6 +138,23 @@ export function rawTokensSinceObservationCoverage(entries: Entry[]): number {
 	return rawTokensSinceCoverage(entries, OM_OBSERVATIONS_RECORDED);
 }
 
+/**
+ * Sum uncovered observer source only through a fixed branch entry. Source
+ * appended after that boundary is intentionally excluded so one catch-up pass
+ * has a finite backlog even while the primary agent keeps producing output.
+ */
+export function rawTokensSinceObservationCoverageThrough(entries: Entry[], throughEntryId: string): number {
+	const throughIndex = entryIndexForId(entries, throughEntryId);
+	if (throughIndex < 0) return 0;
+	const coverageIndex = latestCoverageIndex(entries, OM_OBSERVATIONS_RECORDED);
+	if (coverageIndex >= throughIndex) return 0;
+	let total = 0;
+	for (let i = Math.max(0, coverageIndex + 1); i <= throughIndex; i++) {
+		if (isSourceEntry(entries[i])) total += estimateEntryTokens(entries[i]);
+	}
+	return total;
+}
+
 export function findLastCompactionIndex(entries: Entry[]): number {
 	for (let i = entries.length - 1; i >= 0; i--) {
 		if (entries[i].type === "compaction") return i;