@matthewfl/pi-contemplator 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matthewfl/pi-contemplator",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "A Pi extension that keeps long-running agentic sessions on track with background memory, contemplation, and structural review.",
   "type": "module",
   "license": "MIT",

package/src/agents/contemplator/agent.ts

@@ -5,7 +5,7 @@ import { streamSimple } from "@earendil-works/pi-ai/compat";
 import { 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, recallMemorySources, type Entry, type ReviewResult, type StructuralReviewRequest } from "../../session-ledger/index.js";
+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";
 import { hashId } from "../../ids.js";
 import { createSearchMemoriesAgentTool } from "../../tools/search-memories.js";
 import { createRecallAgentTool } from "../../tools/recall-observation.js";
@@ -17,6 +17,7 @@ import { forceRequiredToolPayload, requiredToolChoice } from "../../required-too
 import { memoryReferenceIds } from "../../memory-citations.js";
 import { buildContemplatorSystemPrompt } from "./prompts.js";
 import { runStructuralReview } from "../reviewer/agent.js";
+import { createWorkerStallWatchdog } from "../../worker-watchdog.js";
 
 interface PendingUpdate {
 	observations: string[];
@@ -213,6 +214,10 @@ export class Contemplator {
 	private history: AgentMessage[] = [];
 	private pending: PendingUpdate | undefined;
 	private running = false;
+	/** Invalidates stale/hard-timed-out flush finalizers across session changes. */
+	private flushEpoch = 0;
+	/** 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>();
@@ -263,6 +268,9 @@ export class Contemplator {
 		});
 		this.pi.on("session_start", (event: any, ctx: ExtensionContext) => {
 			this.sessionGeneration++;
+			this.flushEpoch++;
+			this.running = false;
+			this.consecutiveFlushFailures = 0;
 			const generation = this.sessionGeneration;
 			this.agentActiveSince = undefined;
 			// AgentSession preserves its steering queue across extension reloads. An
@@ -278,12 +286,18 @@ export class Contemplator {
 		});
 		this.pi.on("session_tree", (_event: any, ctx: ExtensionContext) => {
 			this.sessionGeneration++;
+			this.flushEpoch++;
+			this.running = false;
+			this.consecutiveFlushFailures = 0;
 			this.agentActiveSince = undefined;
 			// Pending steering messages remain queued while navigating the tree.
 			this.restore(ctx, true, true);
 		});
 		this.pi.on("session_shutdown", () => {
 			this.sessionGeneration++;
+			this.flushEpoch++;
+			this.running = false;
+			this.consecutiveFlushFailures = 0;
 			this.agentActiveSince = undefined;
 			this.history = [];
 			this.pending = undefined;
@@ -555,6 +569,23 @@ export class Contemplator {
 			return;
 		}
 		const branchEntries = ctx.sessionManager.getBranch() as Entry[];
+		const observerBacklogTokens = rawTokensSinceObservationCoverage(branchEntries);
+		if (
+			observerBacklogTokens >= this.runtime.config.observeAfterTokens &&
+			(this.runtime.consolidationInFlight || this.runtime.lastObserverError === undefined)
+		) {
+			// 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.
+			this.publishState("observer");
+			debugLog("contemplator.waiting", {
+				reason: "observer_backlog",
+				observerBacklogTokens,
+				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}`);
@@ -637,6 +668,7 @@ export class Contemplator {
 		this.pending = undefined;
 		const turnsBeforeRun = this.turnsSinceRun;
 		const sessionGeneration = this.sessionGeneration;
+		const flushEpoch = ++this.flushEpoch;
 		this.running = true;
 		this.turnsSinceRun = 0;
 		const startedAt = Date.now();
@@ -644,6 +676,7 @@ export class Contemplator {
 		let failureMessage: string | undefined;
 		let workerNotified = false;
 		let promptPersisted = false;
+		let workerWatchdog: ReturnType<typeof createWorkerStallWatchdog> | undefined;
 		this.publishState("running", { lastStartedAt: startedAt, lastError: undefined });
 		debugLog("contemplator.start", {
 			newObservationCount: update.observations.length,
@@ -664,16 +697,22 @@ export class Contemplator {
 				failureMessage = resolved.reason;
 				debugLog("contemplator.model_unavailable", { reason: resolved.reason });
 				if (sessionGeneration === this.sessionGeneration) {
-					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,
-					};
-					this.turnsSinceRun = turnsBeforeRun;
+					this.consecutiveFlushFailures++;
+					if (this.consecutiveFlushFailures < 2) {
+						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 });
+						this.consecutiveFlushFailures = 0;
+					}
+					this.turnsSinceRun = 0; // Back off until fresh primary responses arrive; never retry every checkpoint.
 				}
 				return;
 			}
@@ -687,6 +726,7 @@ export class Contemplator {
 				modelId: selectedModel.id,
 				contextWindow: selectedModel.contextWindow,
 			});
+			workerWatchdog = createWorkerStallWatchdog("contemplator");
 			if (this.runtime.config.showWorkerNotifications && ctx.hasUI) {
 				ctx.ui?.notify("pi-contemplator: contemplator running", "info");
 				workerNotified = true;
@@ -774,9 +814,15 @@ export class Contemplator {
 				// while individual provider APIs also support required/any. Preserve the
 				// runtime hint and final-payload enforcement without weakening base types.
 				if (invocation > 1) (invocationConfig as any).toolChoice = requiredToolChoice(api);
-				const stream = agentLoop([nextPrompt], context, invocationConfig, undefined, streamSimple);
-				for await (const event of stream) logAgentStreamError("contemplator", event);
-				const result = await stream.result();
+				workerWatchdog.progress();
+				const stream = agentLoop([nextPrompt], context, invocationConfig, workerWatchdog.signal, streamSimple);
+				const result = await workerWatchdog.race((async () => {
+					for await (const event of stream) {
+						workerWatchdog!.progress();
+						logAgentStreamError("contemplator", event);
+					}
+					return stream.result();
+				})());
 				// agentLoop returns its input prompt as the first new message. We already
 				// added nextPrompt above, so do not duplicate each update in the durable
 				// contemplator history or in a subsequent retry's context.
@@ -840,25 +886,37 @@ export class Contemplator {
 					});
 				}
 			}
-			if (sessionGeneration === this.sessionGeneration) await this.compactHistory(resolved.model as Model<any>, resolved.apiKey, resolved.headers, sessionGeneration);
+			if (sessionGeneration === this.sessionGeneration) {
+				workerWatchdog.progress();
+				await workerWatchdog.race(this.compactHistory(resolved.model as Model<any>, resolved.apiKey, resolved.headers, sessionGeneration, flushEpoch));
+			}
 		} catch (error) {
 			failed = true;
 			failureMessage = error instanceof Error ? error.message : String(error);
 			debugLog("contemplator.error", { errorMessage: failureMessage });
 			if (sessionGeneration === this.sessionGeneration && !promptPersisted) {
-				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,
-				};
-				this.turnsSinceRun = turnsBeforeRun;
+				this.consecutiveFlushFailures++;
+				if (this.consecutiveFlushFailures < 2) {
+					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 });
+					this.consecutiveFlushFailures = 0;
+				}
+				this.turnsSinceRun = 0; // Back off until fresh primary responses arrive; never retry every checkpoint.
 			}
 		} finally {
+			workerWatchdog?.dispose();
+			if (flushEpoch !== this.flushEpoch) return;
 			this.running = false;
+			if (!failed) this.consecutiveFlushFailures = 0;
 			const pendingHasEnoughMemories = this.pending !== undefined && (
 				this.pending.reviews.length > 0 ||
 				this.pending.observations.length >= this.runtime.config.contemplatorMinNewObservations ||
@@ -951,15 +1009,20 @@ export class Contemplator {
 		const session = this.reviewerSessions.get(request.id) ?? { scope: request.scope, history: options.history ?? [], messageEntryIds: [], foldedEntryIds: new Set() };
 		this.reviewerSessions.set(request.id, session);
 		const task = this.runtime.launchReviewTask(ctx, async () => {
+			const watchdog = createWorkerStallWatchdog("structural reviewer");
+			let acceptsMessages = true;
 			try {
 				debugLog("reviewer.started", { reviewRequestId: request.id, scope: request.scope, resumed: session.history.length > 0 });
-				const result = await runStructuralReview({
+				const result = await watchdog.race(runStructuralReview({
 					request, model, apiKey, headers,
+					signal: watchdog.signal,
+					onProgress: watchdog.progress,
 					getBranch: () => ctx.sessionManager.getBranch() as Entry[],
 					recordUsage: (usage) => this.runtime.recordAgentUsage(usage),
 					history: session.history,
 					onMessages: (messages) => {
-						if (sessionGeneration !== this.sessionGeneration || !this.reviewIsPending(ctx, request.id)) return;
+						watchdog.progress();
+						if (!acceptsMessages || sessionGeneration !== this.sessionGeneration || !this.reviewIsPending(ctx, request.id)) return;
 						for (const message of messages) {
 							session.history.push(message);
 							const entryId = this.appendEntryWithId(ctx, OM_REVIEWER_MESSAGE, { version: 1, reviewRequestId: request.id, scope: request.scope, message }, request.id);
@@ -969,7 +1032,7 @@ export class Contemplator {
 							}
 						}
 					},
-				});
+				}));
 				if (sessionGeneration !== this.sessionGeneration) {
 					debugLog("reviewer.failed", { reviewRequestId: request.id, reason: "session_changed" });
 					return;
@@ -997,6 +1060,8 @@ export class Contemplator {
 				}
 				this.runtime.notifyMemoryUpdate(ctx);
 			} finally {
+				acceptsMessages = false;
+				watchdog.dispose();
 				this.inFlightReviewIds.delete(request.id);
 				if (key) this.inFlightReviewKeys.delete(key);
 			}
@@ -1080,7 +1145,7 @@ export class Contemplator {
 		return own?.id;
 	}
 
-	private async compactHistory(model: Model<any>, apiKey: string, headers: Record<string, string> | undefined, sessionGeneration: number): Promise<void> {
+	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;
@@ -1091,7 +1156,7 @@ export class Contemplator {
 		const history = this.history.slice();
 		const summaryWithUsage = await generateSummaryWithUsage(history as AgentMessage[], model, 4_000, apiKey, headers);
 		this.runtime.recordAgentUsage(summaryWithUsage.usage);
-		if (sessionGeneration !== this.sessionGeneration) {
+		if (sessionGeneration !== this.sessionGeneration || flushEpoch !== this.flushEpoch) {
 			debugLog("contemplator.compaction_stale", { reason: "session_or_branch_changed" });
 			return;
 		}

package/src/agents/observer/agent.ts

@@ -1,11 +1,11 @@
-import { agentLoop, type AgentContext, type AgentLoopConfig, type AgentTool } from "@earendil-works/pi-agent-core";
+import { agentLoop, type AgentContext, type AgentLoopConfig, type AgentMessage, type AgentTool } from "@earendil-works/pi-agent-core";
 import type { Message, Model, ModelThinkingLevel } from "@earendil-works/pi-ai";
 import { Type } from "@earendil-works/pi-ai";
 import { streamSimple } from "@earendil-works/pi-ai/compat";
 import type { Static } from "typebox";
 import { hashId } from "../../ids.js";
 import { logAgentStreamError } from "../stream-errors.js";
-import { AGENT_LOOP_MAX_TOKENS, boundedMaxTokens } from "../../model-budget.js";
+import { OBSERVER_AGENT_LOOP_MAX_TOKENS, boundedMaxTokens } from "../../model-budget.js";
 import { OBSERVER_SYSTEM } from "./prompts.js";
 import { nowTimestamp, truncateRecordContent } from "../../serialize.js";
 import type { Observation, Relevance, Retention } from "../../session-ledger/index.js";
@@ -25,6 +25,7 @@ interface RunObserverArgs {
 	maxTurns?: number;
 	thinkingLevel?: ModelThinkingLevel;
 	recordUsage?: (usage: LlmUsageInput) => void;
+	onProgress?: () => void;
 }
 
 const RelevanceSchema = Type.Union([
@@ -71,6 +72,16 @@ const RecordObservationsSchema = Type.Object({
 
 type RecordObservationsArgs = Static<typeof RecordObservationsSchema>;
 
+/** A terminal provider/agent-loop failure that must not advance observation coverage. */
+export class ObserverStreamError extends Error {
+	readonly stopReason: string;
+	constructor(stopReason: string, errorMessage?: string) {
+		super(`observer stream ended with stopReason "${stopReason}"${errorMessage ? `: ${errorMessage}` : ""}`);
+		this.name = "ObserverStreamError";
+		this.stopReason = stopReason;
+	}
+}
+
 function joinOrEmpty(items: string[]): string {
 	return items.length ? items.join("\n") : "(none yet)";
 }
@@ -98,14 +109,15 @@ export async function runObserver(args: RunObserverArgs): Promise<Observation[]
 	if (!conversation) return undefined;
 
 	const accumulated = new Map<string, Observation>();
+	let rejectedTotal = 0;
+	let doneCalled = false;
 
 	const recordObservations: AgentTool<typeof RecordObservationsSchema> = {
 		name: "record_observations",
 		label: "Record observations",
 		description:
 			"Record a batch of new observations distilled from the conversation chunk. " +
-			"Call this multiple times as you work through the chunk. Stop calling when coverage is complete, " +
-			"then emit a short plain-text confirmation to end the run.",
+			"Call this multiple times as you work through the chunk, then call done alone when coverage is complete.",
 		parameters: RecordObservationsSchema,
 		execute: async (_id, params: RecordObservationsArgs) => {
 			let added = 0;
@@ -134,6 +146,7 @@ export async function runObserver(args: RunObserverArgs): Promise<Observation[]
 				});
 				added++;
 			}
+			rejectedTotal += rejected;
 			const rejectedPart = rejected > 0
 				? ` ${rejected} observation${rejected === 1 ? "" : "s"} rejected for missing or invalid sourceEntryIds.`
 				: "";
@@ -142,11 +155,22 @@ export async function runObserver(args: RunObserverArgs): Promise<Observation[]
 				(duplicates > 0 ? `(${duplicates} duplicate${duplicates === 1 ? "" : "s"} skipped).` : ".") +
 				rejectedPart +
 				` Total so far this run: ${accumulated.size}. ` +
-				`Continue if the chunk still has uncovered content; otherwise stop calling the tool and emit a short plain-text confirmation.`;
+				`Continue if the chunk still has uncovered content; otherwise call done alone.`;
 			return { content: [{ type: "text", text: ack }], details: { added, duplicates, rejected, total: accumulated.size } };
 		},
 	};
 
+	const doneTool: AgentTool<any> = {
+		name: "done",
+		label: "Done",
+		description: "Confirm that the entire provided conversation chunk has been inspected and all useful new observations have been recorded. Call alone, including when there is nothing new to record.",
+		parameters: Type.Object({}),
+		execute: async () => {
+			doneCalled = true;
+			return { content: [{ type: "text", text: "Observer coverage confirmed." }], details: {}, terminate: true };
+		},
+	};
+
 	const now = nowTimestamp();
 	const userText = `Current local time: ${now}
 
@@ -156,60 +180,88 @@ ${joinOrEmpty(priorSummaries)}
 CURRENT OBSERVATIONS:
 ${joinOrEmpty(priorObservations)}
 
-Compress the following new conversation chunk into observations by calling record_observations one or more times. Do not restate facts already present in current summaries or current observations. Prefer inline conversation timestamps when assigning times; fall back to the current local time above only if no message timestamp applies. Stop calling the tool and reply with a short plain-text confirmation once the chunk is fully covered.
+Compress the following new conversation chunk into observations by calling record_observations one or more times. Do not restate facts already present in current summaries or current observations. Prefer inline conversation timestamps when assigning times; fall back to the current local time above only if no message timestamp applies. When the chunk is fully covered, call done alone. If the chunk contains no useful new information, call done without calling record_observations.
 
 NEW CONVERSATION CHUNK:
-${conversation}`;
+${conversation}
 
-	const prompts: Message[] = [
-		{
-			role: "user",
-			content: [{ type: "text", text: userText }],
-			timestamp: Date.now(),
-		},
-	];
+END NEW CONVERSATION CHUNK
 
-	const context: AgentContext = {
-		systemPrompt: OBSERVER_SYSTEM,
-		messages: [],
-		tools: [recordObservations as AgentTool<any>],
+IMPORTANT: Now call record_observations to record the useful new observations from this conversation chunk. When the chunk is covered, call done; if there are no useful observations, call done without recording any.`;
+
+	const initialPrompt: Message = {
+		role: "user",
+		content: [{ type: "text", text: userText }],
+		timestamp: Date.now(),
 	};
 
 	const reasoning = (model as { reasoning?: unknown }).reasoning;
 	const thinkingLevel = args.thinkingLevel ?? "low";
 	const effectiveMaxTurns = args.maxTurns && args.maxTurns > 0 ? args.maxTurns : undefined;
 	let turnCount = 0;
-	const config: AgentLoopConfig = {
+	const baseConfig: AgentLoopConfig = {
 		model,
 		apiKey,
 		headers,
-		maxTokens: boundedMaxTokens(model, AGENT_LOOP_MAX_TOKENS),
+		maxTokens: boundedMaxTokens(model, OBSERVER_AGENT_LOOP_MAX_TOKENS),
 		convertToLlm: (msgs) => msgs as Message[],
 		toolExecution: "sequential",
+		shouldStopAfterTurn: () => {
+			turnCount++;
+			return doneCalled || (effectiveMaxTurns !== undefined && turnCount >= effectiveMaxTurns);
+		},
 		...(reasoning && thinkingLevel !== "off" ? { reasoning: thinkingLevel } : {}),
-		...(effectiveMaxTurns !== undefined
-			? {
-				shouldStopAfterTurn: () => {
-					turnCount++;
-					return turnCount >= effectiveMaxTurns;
-				},
-			}
-			: {}),
 	};
 
 	const loop = args.agentLoop ?? agentLoop;
-	const stream = loop(prompts, context, config, signal, streamSimple);
-	for await (const event of stream) {
-		// Drain events; the tool's execute already collects records.
-		logAgentStreamError("observer", event);
-	}
-	const result = await stream.result();
-	if (args.recordUsage) {
+	const history: AgentMessage[] = [];
+	let terminalFailure: { stopReason: string; errorMessage?: string } | undefined;
+	const runInvocation = async (prompt: Message): Promise<void> => {
+		const context: AgentContext = {
+			systemPrompt: OBSERVER_SYSTEM,
+			messages: history.slice(),
+			tools: [recordObservations as AgentTool<any>, doneTool],
+		};
+		const stream = loop([prompt], context, baseConfig, signal, streamSimple);
+		for await (const event of stream) {
+			args.onProgress?.();
+			logAgentStreamError("observer", event);
+			const message = (event as { message?: { role?: string; stopReason?: string; errorMessage?: string } }).message;
+			if (message?.role === "assistant" && ["error", "aborted", "length"].includes(message.stopReason ?? "")) {
+				terminalFailure = { stopReason: message.stopReason!, errorMessage: message.errorMessage };
+			}
+		}
+		const result = await stream.result();
+		if (!Array.isArray(result)) return;
+		history.push(...result);
 		for (const message of result) {
-			if (message.role === "assistant" && message.usage) args.recordUsage(message.usage);
+			if (message.role === "assistant" && ["error", "aborted", "length"].includes(message.stopReason ?? "")) {
+				terminalFailure = { stopReason: message.stopReason, errorMessage: message.errorMessage };
+			}
+			if (args.recordUsage && message.role === "assistant" && message.usage) args.recordUsage(message.usage);
 		}
+	};
+
+	await runInvocation(initialPrompt);
+	if (accumulated.size === 0 && !doneCalled && !terminalFailure && rejectedTotal === 0) {
+		const reminder: Message = {
+			role: "user",
+			content: [{ type: "text", text: `You stopped without confirming coverage. Observations recorded so far: ${accumulated.size}. If the chunk is fully covered, call done now. Otherwise call record_observations for anything still missing, then call done.` }],
+			timestamp: Date.now(),
+		};
+		await runInvocation(reminder);
 	}
 
+	// `done` is a behavioral aid and terminal shortcut, not a transaction gate.
+	// Accepted observations commit even if it was omitted. A second prose-only
+	// zero-observation stop is also a valid empty result after the reminder;
+	// actual stream failures, truncation, and malformed records still throw.
+	if (accumulated.size === 0 && terminalFailure) {
+		throw new ObserverStreamError(terminalFailure.stopReason, terminalFailure.errorMessage);
+	}
+	if (accumulated.size === 0 && rejectedTotal > 0) {
+		throw new ObserverStreamError("invalid_observations", `${rejectedTotal} proposed observation${rejectedTotal === 1 ? " was" : "s were"} rejected`);
+	}
 	if (accumulated.size === 0) return undefined;
 	return Array.from(accumulated.values());
 }

package/src/agents/observer/prompts.ts

@@ -15,7 +15,7 @@ How you work:
 2. Read the conversation chunk and identify what new information it contains.
 3. Call record_observations with a batch covering part (or all) of the chunk.
 4. Read the progress receipt. If content remains uncovered, call again. You may call the tool many times.
-5. When the chunk is fully covered, STOP calling the tool and reply with a brief plain-text confirmation (one short sentence). That ends the run.
+5. When the chunk is fully covered, call done alone. If there is no useful new information, call done without calling record_observations. Prose does not confirm coverage.
 
 What to emit:
 - Produce NEW observations for the new chunk only. Do not restate facts already present in summaries or current observations unless something has materially changed.
@@ -25,7 +25,7 @@ What to emit:
 - For every observation, choose retention independently from relevance. Recording the observation correctly comes first; never skip useful evidence because retention is uncertain.
 - Observations with missing, empty, or invalid sourceEntryIds will be rejected and not recorded, so do not call record_observations until you can cite valid source ids.
 - Group repeated similar tool calls into a single observation rather than one per call.
-- Skip routine, low-information events. It is fine to emit zero observations if the chunk carries no new information — in that case, simply do not call the tool and end with a plain-text confirmation.
+- Skip routine, low-information events. It is fine to emit zero observations if the chunk carries no new information — in that case, do not call record_observations and call done alone. Ignoring a chunk or replying in prose does not mark it covered.
 
 Observation content rules:
 
@@ -125,4 +125,4 @@ A critical exact blocker can be contextual; a medium stable preference can be du
 
 Timestamp format: "YYYY-MM-DD HH:MM" (local time, 24-hour, to the minute). This goes in the timestamp field, not the content.
 
-Remember: these observations are the assistant's ONLY memory of this chunk once the raw messages fall out of context. Make them count.`;
+Remember: these observations are the assistant's ONLY memory of this chunk once the raw messages fall out of context. Make them count. Always finish by calling done alone.`;

package/src/agents/reviewer/agent.ts

@@ -30,6 +30,7 @@ export interface RunStructuralReviewArgs {
 	recordUsage?: (usage: LlmUsageInput) => void;
 	/** Receives the reviewer's assistant output for durable debug/view rendering. */
 	onMessages?: (messages: AgentMessage[]) => void;
+	onProgress?: () => void;
 	/** Previously persisted reviewer transcript; a non-empty history resumes work. */
 	history?: AgentMessage[];
 }
@@ -177,7 +178,10 @@ export async function runStructuralReview(args: RunStructuralReviewArgs): Promis
 		history.push(promptMessage);
 		args.onMessages?.([promptMessage]);
 		const stream = loop([prompt], context, config, args.signal, budgetedStreamSimple);
-		for await (const event of stream) logAgentStreamError("reviewer", event);
+		for await (const event of stream) {
+			args.onProgress?.();
+			logAgentStreamError("reviewer", event);
+		}
 		const newMessages = await stream.result();
 		history.push(...newMessages);
 		args.onMessages?.(newMessages);

package/src/commands/contemplator-view.ts

@@ -63,11 +63,13 @@ function liveStateLine(state: ContemplatorRunState): string {
 	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}`;
-	const reason = state.waitingFor === "memories"
-		? "waiting for memory threshold"
-		: state.waitingFor === "responses"
-			? "waiting for response spacing"
-			: state.waitingFor === "ready"
+	const reason = state.waitingFor === "observer"
+		? "waiting for observer backlog"
+		: state.waitingFor === "memories"
+			? "waiting for memory threshold"
+			: state.waitingFor === "responses"
+				? "waiting for response spacing"
+				: state.waitingFor === "ready"
 				? "ready to launch"
 				: state.waitingFor === "disabled"
 					? "disabled"

package/src/commands/settings.ts

@@ -1,13 +1,14 @@
 import { DynamicBorder, getSelectListTheme } from "@earendil-works/pi-coding-agent";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Container, getKeybindings, Input, SelectList, Spacer, Text, fuzzyFilter, type Focusable, type SelectItem } from "@earendil-works/pi-tui";
-import type { ConfiguredModel } from "../config.js";
+import { OBSERVER_CHUNK_CONTEXT_RATIO, resolveObserverChunkMaxTokens, type ConfiguredModel } from "../config.js";
 import { OM_SETTINGS, type Runtime, type SessionSettings } from "../runtime.js";
 
 type ModelRegistryLike = {
 	refresh?(): Promise<void>;
 	getAvailable(): Array<{ provider: string; id: string }>;
 	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 BooleanSetting = "contemplatorEnabled" | "showContemplatorMessages" | "reviewerEnabled" | "summarizerEnabled" | "compactionObserverEnabled" | "showWorkerNotifications" | "passive" | "debugLog";
@@ -44,6 +45,26 @@ function extensionEnabledLabel(runtime: Runtime): string {
 	return hasOverride(runtime.getSessionSettings(), "passive") ? String(enabled) : `${enabled} (default)`;
 }
 
+export function observerInputCapLabel(runtime: Runtime, contextWindow: number | undefined): string {
+	const explicit = runtime.config.observerChunkMaxTokens;
+	if (explicit !== undefined) {
+		return `${explicit.toLocaleString()} tokens${hasOverride(runtime.getSessionSettings(), "observerChunkMaxTokens") ? "" : " (default)"}`;
+	}
+	const cap = resolveObserverChunkMaxTokens(runtime.config, contextWindow);
+	if (typeof contextWindow === "number" && Number.isFinite(contextWindow) && contextWindow > 0) {
+		const percent = OBSERVER_CHUNK_CONTEXT_RATIO * 100;
+		return `${percent}% of ${contextWindow.toLocaleString()} = ${cap.toLocaleString()} tokens (derived default)`;
+	}
+	return `${cap.toLocaleString()} tokens (fallback default; model context unavailable)`;
+}
+
+function observerContextWindow(runtime: Runtime, ctx: ExtensionContext): number | undefined {
+	const configured = runtime.config.model;
+	const registry = ctx.modelRegistry as unknown as ModelRegistryLike;
+	const model = configured ? registry.find?.(configured.provider, configured.id) ?? ctx.model : ctx.model;
+	return (model as { contextWindow?: number } | undefined)?.contextWindow;
+}
+
 interface ModelOption extends SelectItem {
 	configuredModel: ConfiguredModel | null;
 }
@@ -207,7 +228,7 @@ export function registerSettingsCommand(pi: ExtensionAPI, runtime: Runtime): voi
 				`Observe source during compaction: ${scalarLabel(runtime, "compactionObserverEnabled")}`,
 				`Observer and summarizer model: ${hasOverride(settings, "model") ? modelLabel(runtime.config.model) : `${modelLabel(runtime.getDefaultConfig().model)} (default)`}`,
 				`Observer source backlog trigger (tokens): ${scalarLabel(runtime, "observeAfterTokens")}`,
-				`Observer input cap (tokens): ${scalarLabel(runtime, "observerChunkMaxTokens")}`,
+				`Observer input cap: ${observerInputCapLabel(runtime, observerContextWindow(runtime, ctx))}`,
 				`Observer and summarizer max rounds: ${scalarLabel(runtime, "agentMaxTurns")}`,
 				`Automatic compaction source backlog trigger (tokens): ${scalarLabel(runtime, "compactAfterTokens")}`,
 				`Automatic compaction threshold mode: ${hasOverride(settings, "compactAfterTokensMode") ? runtime.config.compactAfterTokensMode : `${runtime.getDefaultConfig().compactAfterTokensMode} (default)`}`,
@@ -245,7 +266,7 @@ export function registerSettingsCommand(pi: ExtensionAPI, runtime: Runtime): voi
 			} else {
 				const numberChoice: Array<[string, NumberSetting, string]> = [
 					["Observer source backlog trigger (tokens):", "observeAfterTokens", "Observer source backlog trigger (tokens)"],
-					["Observer input cap (tokens):", "observerChunkMaxTokens", "Observer input cap (tokens)"],
+					["Observer input cap:", "observerChunkMaxTokens", "Observer input cap (tokens)"],
 					["Observer and summarizer max rounds:", "agentMaxTurns", "Observer and summarizer max rounds"],
 					["Automatic compaction source backlog trigger (tokens):", "compactAfterTokens", "Automatic compaction source backlog trigger (tokens)"],
 					["New memory pool protection budget (tokens):", "newMemoryPoolMaxTokens", "New memory pool protection budget (tokens)"],

package/src/commands/status.ts

@@ -42,6 +42,7 @@ function formatRunAge(timestamp: number): string {
 
 function contemplatorWaitingLabel(waitingFor: Runtime["contemplatorState"]["waitingFor"]): string {
 	switch (waitingFor) {
+		case "observer": return "waiting for observer backlog";
 		case "memories": return "waiting for memory threshold";
 		case "responses": return "waiting for response spacing";
 		case "ready": return "ready to launch";

package/src/config.ts

@@ -125,11 +125,11 @@ export const OBSERVER_CHUNK_MIN_TOKENS = 256;
 /**
  * Fraction of the memory model's context window used for the derived observer
  * chunk cap. Chunk sizes are estimated at ~4 chars/token, which can undercount
- * real tokens by up to ~4x on non-ASCII content, so 0.2 keeps even the worst
- * case at ~80% of the window with room left for the system prompt, prior
- * memory, and the response.
+ * real tokens substantially on non-ASCII content. The estimator remains
+ * approximate; the remaining 75% of the advertised window accommodates injected memory, the
+ * system prompt, and model output.
  */
-export const OBSERVER_CHUNK_CONTEXT_RATIO = 0.2;
+export const OBSERVER_CHUNK_CONTEXT_RATIO = 0.25;
 
 /**
  * Resolve the maximum estimated tokens the observer serializes into one chunk.
@@ -143,7 +143,7 @@ export const OBSERVER_CHUNK_CONTEXT_RATIO = 0.2;
  * after repeated observer failures, or when the extension is enabled mid-way
  * into a long session) makes every observer call fail, so coverage never
  * advances and the session can never recover. With the cap, oversized backlogs
- * are drained oldest-first across successive runs.
+ * are drained oldest-first across successive bounded passes.
  */
 export function resolveObserverChunkMaxTokens(config: Config, contextWindow: number | undefined): number {
 	if (config.observerChunkMaxTokens !== undefined && config.observerChunkMaxTokens > 0) {

package/src/hooks/compaction-trigger.ts

@@ -9,6 +9,7 @@ import {
 } from "./compaction-resume.js";
 
 const COMPACTION_STATUS_KEY = "observational-memory-compaction";
+export const COMPACTION_CALLBACK_TIMEOUT_MS = 30 * 60_000;
 type CompactionOrigin = "agent-requested" | "length-stop" | "proactive";
 
 type TriggerOptions = {
@@ -37,6 +38,7 @@ export function registerCompactionTrigger(pi: ExtensionAPI, runtime: Runtime): v
 		const { origin, resume, threshold, shortContinuationPrompt } = options;
 		const hasUI = ctx.hasUI;
 		const ui = ctx.ui;
+		const generation = runtime.getContextGeneration?.() ?? 0;
 
 		runtime.compactInFlight = true;
 		runtime.compactOrigin = origin;
@@ -74,23 +76,39 @@ export function registerCompactionTrigger(pi: ExtensionAPI, runtime: Runtime): v
 					);
 				}
 				if (origin === "agent-requested") runtime.compactContinuationPrompt = undefined;
-				ctx.compact({
-					onComplete: () => {
-						runtime.compactInFlight = false;
-						runtime.compactOrigin = undefined;
-						if (hasUI && !resume) ui?.setStatus?.(COMPACTION_STATUS_KEY, undefined);
-						if (resume) resumeAfterCompaction(pi, runtime, { hasUI, ui }, false, shortContinuationPrompt);
-					},
-					onError: (error: { message: string }) => {
-						runtime.compactInFlight = false;
-						runtime.compactOrigin = undefined;
-						if (hasUI) ui?.setStatus?.(COMPACTION_STATUS_KEY, undefined);
-						if (error.message !== "Compaction cancelled" && hasUI) {
-							ui?.notify(`pi-contemplator: ${error.message}`, "error");
-						}
-						if (resume) resumeAfterCompaction(pi, runtime, { hasUI, ui }, true, shortContinuationPrompt);
-					},
-				});
+				let settled = false;
+				const callbackTimeout = setTimeout(() => {
+					if (settled || generation !== (runtime.getContextGeneration?.() ?? 0)) return;
+					settled = true;
+					runtime.compactInFlight = false;
+					runtime.compactOrigin = undefined;
+					if (hasUI) {
+						ui?.setStatus?.(COMPACTION_STATUS_KEY, undefined);
+						ui?.notify("pi-contemplator: compaction callback timed out; releasing the compaction lock", "error");
+					}
+					if (resume) resumeAfterCompaction(pi, runtime, { hasUI, ui }, true, shortContinuationPrompt);
+				}, COMPACTION_CALLBACK_TIMEOUT_MS);
+				(callbackTimeout as ReturnType<typeof setTimeout> & { unref?: () => void }).unref?.();
+				const settle = (failed: boolean, error?: { message: string }) => {
+					if (settled || generation !== (runtime.getContextGeneration?.() ?? 0)) return;
+					settled = true;
+					clearTimeout(callbackTimeout);
+					runtime.compactInFlight = false;
+					runtime.compactOrigin = undefined;
+					if (hasUI && (failed || !resume)) ui?.setStatus?.(COMPACTION_STATUS_KEY, undefined);
+					if (failed && error?.message !== "Compaction cancelled" && hasUI) ui?.notify(`pi-contemplator: ${error?.message ?? "compaction failed"}`, "error");
+					if (resume) resumeAfterCompaction(pi, runtime, { hasUI, ui }, failed, shortContinuationPrompt);
+				};
+				try {
+					ctx.compact({
+						onComplete: () => settle(false),
+						onError: (error: { message: string }) => settle(true, error),
+					});
+				} catch (error) {
+					settled = true;
+					clearTimeout(callbackTimeout);
+					throw error;
+				}
 			} catch (error) {
 				runtime.compactInFlight = false;
 				if (origin === "agent-requested") runtime.compactContinuationPrompt = undefined;

package/src/hooks/consolidation-trigger.ts

@@ -4,6 +4,7 @@ import { runObserver } from "../agents/observer/agent.js";
 import { debugLog, withDebugLogContext } from "../debug-log.js";
 import { resolveObserverChunkMaxTokens } from "../config.js";
 import type { ResolveResult, Runtime } from "../runtime.js";
+import { createWorkerStallWatchdog } from "../worker-watchdog.js";
 import { serializeSourceAddressedBranchEntries } from "../serialize.js";
 import {
 	OM_SUMMARIZER_COMMIT,
@@ -43,28 +44,10 @@ export const SUMMARIZER_STALL_TIMEOUT_MS = 15 * 60_000;
 export function createSummarizerStallWatchdog(
 	timeoutMs: number,
 	onStall: (signal: AbortSignal) => void,
-): { signal: AbortSignal; progress: () => void; dispose: () => void } {
-	const controller = new AbortController();
-	let timer: ReturnType<typeof setTimeout> | undefined;
-	const progress = () => {
-		if (controller.signal.aborted) return;
-		if (timer !== undefined) clearTimeout(timer);
-		timer = setTimeout(() => {
-			timer = undefined;
-			controller.abort(new Error(`summarizer produced no progress for ${Math.round(timeoutMs / 60_000)} minutes`));
-			onStall(controller.signal);
-		}, timeoutMs);
-		(timer as ReturnType<typeof setTimeout> & { unref?: () => void }).unref?.();
-	};
-	progress();
-	return {
-		signal: controller.signal,
-		progress,
-		dispose: () => {
-			if (timer !== undefined) clearTimeout(timer);
-			timer = undefined;
-		},
-	};
+) {
+	let watchdog!: ReturnType<typeof createWorkerStallWatchdog>;
+	watchdog = createWorkerStallWatchdog("summarizer", timeoutMs, () => onStall(watchdog.signal));
+	return watchdog;
 }
 
 function sourceEntriesAfter(entries: Entry[], index: number): Entry[] {
@@ -96,6 +79,7 @@ function makeModelResolver(runtime: Runtime, ctx: ConsolidationCtx): (stage: "ob
 			runtime.resolveFailureNotified = false;
 			return cached;
 		}
+		runtime.lastObserverError = cached.reason;
 		debugLog(`${stage}.model_unavailable`, { reason: cached.reason });
 		if (!runtime.resolveFailureNotified && ctx.hasUI && ctx.ui) {
 			ctx.ui.notify(`pi-contemplator: ${stage} skipped — ${cached.reason}`, "warning");
@@ -109,6 +93,14 @@ export function registerConsolidationTrigger(pi: ExtensionAPI, runtime: Runtime)
 	const launch = (_event: unknown, ctx: ConsolidationCtx) => {
 		maybeLaunchConsolidation(pi, runtime, ctx);
 	};
+	pi.on("session_start", (event, ctx) => {
+		launch(event, ctx);
+		syncAndScheduleSummarizer(pi, runtime, ctx as ConsolidationCtx);
+	});
+	pi.on("session_tree", (event, ctx) => {
+		launch(event, ctx);
+		syncAndScheduleSummarizer(pi, runtime, ctx as ConsolidationCtx);
+	});
 	pi.on("agent_start", (event, ctx) => {
 		launch(event, ctx);
 		syncAndScheduleSummarizer(pi, runtime, ctx as ConsolidationCtx);
@@ -119,8 +111,10 @@ export function registerConsolidationTrigger(pi: ExtensionAPI, runtime: Runtime)
 	});
 	runtime.setAgentActivityListener((ctx) => {
 		runtime.ensureConfig(ctx.cwd);
-		// Token pools are re-evaluated at every primary-agent progress checkpoint;
-		// idle wall-clock time has no scheduling meaning.
+		// Long autonomous turns may run for hours without agent_start/turn_end.
+		// Re-evaluate both source coverage and memory pressure at every primary
+		// progress checkpoint so neither worker can silently stop for the turn.
+		maybeLaunchConsolidation(pi, runtime, ctx as ConsolidationCtx);
 		scheduleSummarizer(pi, runtime, ctx as ConsolidationCtx);
 	});
 	runtime.setSettingsUpdateListener((ctx, settings) => {
@@ -166,7 +160,7 @@ function maybeLaunchConsolidation(pi: ExtensionAPI, runtime: Runtime, ctx: Conso
 	};
 
 	const sessionMetadata = debugSessionMetadata(ctx);
-	void runtime.launchConsolidationTask(ctx, async () => withDebugLogContext({
+	const task = runtime.launchConsolidationTask(ctx, async () => withDebugLogContext({
 		enabled: runtime.config.debugLog === true,
 		cwd: ctx.cwd,
 		...sessionMetadata,
@@ -174,6 +168,13 @@ function maybeLaunchConsolidation(pi: ExtensionAPI, runtime: Runtime, ctx: Conso
 	}, async () => {
 		await runConsolidationPipeline(pi, runtime, consolidationCtx);
 	}));
+	// launchTrackedTask releases its lock before this continuation. If observer
+	// setup failed before coverage could move, wake the contemplator once in
+	// 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);
+	});
 }
 
 export function launchCompactionObserver(
@@ -227,12 +228,27 @@ export async function runConsolidationPipeline(
 	runtime.consolidationPhase = "observer";
 	runtime.lastObserverStartedAt = Date.now();
 	try {
-		const observerOutcome = await runObserverStage(pi, runtime, ctx, resolveModel, {
-			force: options.forceObserver === true,
-			entries: options.observerEntries,
-			contextGeneration,
-		});
-		if (observerOutcome === "abort") return;
+		// 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.
+		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,
+				contextGeneration,
+			});
+			if (observerOutcome === "abort") return;
+			if (options.observerEntries) break;
+
+			const afterEntries = ctx.sessionManager.getBranch() as Entry[];
+			const afterCoverage = latestCoverageIndex(afterEntries, OM_OBSERVATIONS_RECORDED);
+			const remainingTokens = rawTokensSinceObservationCoverage(afterEntries);
+			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;
@@ -299,7 +315,9 @@ export function scheduleSummarizer(pi: ExtensionAPI, runtime: Runtime, ctx: Cons
 	}, async () => {
 		let stalled = false;
 		let successfullyCompleted = false;
+		let modelRunAttempted = false;
 		let disposeStallWatchdog = () => {};
+		let acceptsSummarizerMessages = true;
 		const startedAt = Date.now();
 		runtime.lastSummarizerStartedAt = startedAt;
 		runtime.lastSummarizerRun = { startedAt, status: "running", messages: [] };
@@ -319,7 +337,8 @@ export function scheduleSummarizer(pi: ExtensionAPI, runtime: Runtime, ctx: Cons
 				if (shouldNotifyWorker(runtime, ctx)) ctx.ui?.notify(`pi-contemplator: ${reason}; cancelling and leaving the backlog eligible for retry`, "warning");
 			});
 			disposeStallWatchdog = watchdog.dispose;
-			const result = await runSummarizer({
+			modelRunAttempted = true;
+			const result = await watchdog.race(runSummarizer({
 				signal: watchdog.signal,
 				model: resolved.model as any,
 				apiKey: resolved.apiKey,
@@ -333,9 +352,9 @@ export function scheduleSummarizer(pi: ExtensionAPI, runtime: Runtime, ctx: Cons
 				recordUsage: (usage) => runtime.recordAgentUsage(usage),
 				onMessages: (messages) => {
 					watchdog.progress();
-					if (generation === runtime.getContextGeneration()) runtime.lastSummarizerRun = { startedAt, status: "running", messages: messages.slice() };
+					if (acceptsSummarizerMessages && generation === runtime.getContextGeneration()) runtime.lastSummarizerRun = { startedAt, status: "running", messages: messages.slice() };
 				},
-			});
+			}));
 			if (generation !== runtime.getContextGeneration()) return;
 			if (!result.completed) {
 				runtime.lastSummarizerRun = stalled
@@ -362,6 +381,7 @@ export function scheduleSummarizer(pi: ExtensionAPI, runtime: Runtime, ctx: Cons
 			}
 			throw error;
 		} finally {
+			acceptsSummarizerMessages = false;
 			disposeStallWatchdog();
 			if (generation === runtime.getContextGeneration()) {
 				const completedAt = Date.now();
@@ -370,7 +390,11 @@ export function scheduleSummarizer(pi: ExtensionAPI, runtime: Runtime, ctx: Cons
 				const postRunPools = currentMemoryPools(runtime, ctx.sessionManager.getBranch() as Entry[]);
 				const target = runtime.config.oldMemoryPoolTargetTokens;
 				runtime.summarizerNextTriggerTokens = summarizerTriggerAfterRun(
-					successfullyCompleted,
+					// A failed/no-progress model pass must not be retried with the
+					// identical pool at every primary-agent checkpoint. Require fresh
+					// old-memory growth before trying another (potentially different)
+					// sample. Model-resolution failures spend no tokens and stay eligible.
+					successfullyCompleted || modelRunAttempted,
 					runtime.summarizerNextTriggerTokens,
 					target,
 					postRunPools.oldTokens,
@@ -449,31 +473,45 @@ async function runObserverStage(
 		priorObservations: priorObservations.length,
 	});
 
-	const observations = await runObserver({
-		model: resolved.model as any,
-		apiKey: resolved.apiKey,
-		headers: resolved.headers,
-		priorSummaries,
-		priorObservations,
-		chunk,
-		allowedSourceEntryIds: sourceEntryIds,
-		maxTurns: runtime.config.agentMaxTurns,
-		thinkingLevel: runtime.config.model?.thinking ?? "low",
-		recordUsage: (usage) => runtime.recordAgentUsage(usage),
-	});
+	let observations;
+	let failedMessage: string | undefined;
+	const observerWatchdog = createWorkerStallWatchdog("observer");
+	try {
+		observations = await observerWatchdog.race(runObserver({
+			model: resolved.model as any,
+			apiKey: resolved.apiKey,
+			headers: resolved.headers,
+			priorSummaries,
+			priorObservations,
+			chunk,
+			allowedSourceEntryIds: sourceEntryIds,
+			maxTurns: runtime.config.agentMaxTurns,
+			thinkingLevel: runtime.config.model?.thinking ?? "low",
+			recordUsage: (usage) => runtime.recordAgentUsage(usage),
+			onProgress: observerWatchdog.progress,
+			signal: observerWatchdog.signal,
+		}));
+	} catch (error) {
+		// A permanently pathological old chunk must not pin every newer source
+		// entry and block the contemplator forever. Accepted observations are
+		// already returned normally by runObserver; only a zero-progress failure
+		// reaches here. Record the failure visibly, then advance this bounded
+		// range with an empty coverage marker so catch-up can continue.
+		failedMessage = runtime.recordConsolidationStageError(ctx, "observer", error);
+		debugLog("observer.failed_chunk_advanced", {
+			failedMessage,
+			coversUpToId,
+			sourceEntryIds,
+			chunkTokens,
+		});
+		observations = undefined;
+	} finally {
+		observerWatchdog.dispose();
+	}
 	if (options.contextGeneration !== undefined && options.contextGeneration !== runtime.getContextGeneration()) {
 		debugLog("observer.stale", { reason: "session_or_branch_changed" });
 		return "abort";
 	}
-	if (!observations || observations.length === 0) {
-		debugLog("observer.empty", { coversUpToId });
-		if (ctx.hasUI) ctx.ui?.notify(
-			"pi-contemplator: observer returned no observations",
-			"warning",
-		);
-		return "continue";
-	}
-
 	const currentEntries = ctx.sessionManager.getBranch() as Entry[];
 	let effectiveCoversUpToId = coversUpToId;
 	if (!currentEntries.some((entry) => entry.id === coversUpToId)) {
@@ -488,17 +526,24 @@ async function runObserverStage(
 			compactionId: compaction?.id,
 		});
 	}
-	const data = buildObservationsRecordedData(observations, effectiveCoversUpToId);
+	const accepted = observations ?? [];
+	const data = buildObservationsRecordedData(accepted, effectiveCoversUpToId);
 	if (!data) return "continue";
-	debugLog("observer.records", {
-		count: observations.length,
-		observationTokens: observations.reduce((sum, observation) => sum + observation.tokenCount, 0),
+	debugLog(failedMessage ? "observer.failed_coverage" : accepted.length > 0 ? "observer.records" : "observer.coverage_only", {
+		count: accepted.length,
+		observationTokens: accepted.reduce((sum, observation) => sum + observation.tokenCount, 0),
 		coversUpToId: effectiveCoversUpToId,
+		...(failedMessage ? { failedMessage } : {}),
 	});
+	// A clean zero-observation verdict and a zero-progress failed chunk both use
+	// an empty coverage marker. This prevents low-information or pathological old
+	// source from pinning the entire observer/contemplator pipeline forever.
 	appendEntry(pi, OM_OBSERVATIONS_RECORDED, data);
-	debugLog("observer.appended", { count: observations.length, coversUpToId: effectiveCoversUpToId });
-	if (shouldNotifyWorker(runtime, ctx)) ctx.ui?.notify(
-		`pi-contemplator: ${observations.length} observation${observations.length === 1 ? "" : "s"} recorded`,
+	debugLog("observer.appended", { count: accepted.length, coversUpToId: effectiveCoversUpToId });
+	if (!failedMessage && shouldNotifyWorker(runtime, ctx)) ctx.ui?.notify(
+		accepted.length > 0
+			? `pi-contemplator: ${accepted.length} observation${accepted.length === 1 ? "" : "s"} recorded`
+			: "pi-contemplator: observer found no new information; processed chunk marked covered",
 		"info",
 	);
 	return "continue";

package/src/model-budget.ts

@@ -2,6 +2,9 @@ import type { Model } from "@earendil-works/pi-ai";
 
 export const AGENT_LOOP_MAX_TOKENS = 32_000;
 
+/** Observer output allowance for difficult, high-volume source chunks. */
+export const OBSERVER_AGENT_LOOP_MAX_TOKENS = 160_000;
+
 /**
  * Lifetime output-token budget for one structural review request.
  * Persisted reviewer transcripts carry usage across keep-going iterations,

package/src/runtime.ts

@@ -72,7 +72,7 @@ export interface ContemplatorRunState {
 	pendingReviews: number;
 	/** Completed primary-model responses since the previous contemplator run. */
 	responsesSinceRun: number;
-	waitingFor: "disabled" | "passive" | "memories" | "responses" | "ready" | "running" | "idle";
+	waitingFor: "disabled" | "passive" | "observer" | "memories" | "responses" | "ready" | "running" | "idle";
 	lastStartedAt?: number;
 	lastCompletedAt?: number;
 	lastError?: string;
@@ -254,6 +254,16 @@ export class Runtime {
 		// against a different branch and would otherwise leak across sessions
 		// (e.g. a request made in session A compacting session B's branch, or a
 		// never-cleared compactInFlight bricking all future compactions).
+		// Detach stale background tasks immediately. Their promise finalizers are
+		// identity-guarded below, so an old session can never retain or later clear
+		// a lock owned by the new session.
+		this.consolidationInFlight = false;
+		this.consolidationPromise = null;
+		this.consolidationPhase = undefined;
+		this.summarizerInFlight = false;
+		this.summarizerPromise = null;
+		this.reviewInFlight = false;
+		this.reviewPromise = null;
 		this.compactInFlight = false;
 		this.compactRequested = false;
 		this.compactContinuationPrompt = undefined;
@@ -336,9 +346,10 @@ export class Runtime {
 		this.consolidationPhase = undefined;
 		this.lastObserverError = undefined;
 		const promise = this.launchTrackedTask(ctx, "consolidation", work, () => {
+			if (this.consolidationPromise !== promise) return;
 			this.consolidationInFlight = false;
 			this.consolidationPhase = undefined;
-			if (this.consolidationPromise === promise) this.consolidationPromise = null;
+			this.consolidationPromise = null;
 		});
 		this.consolidationPromise = promise;
 		return promise;
@@ -351,9 +362,10 @@ export class Runtime {
 		this.summarizerInFlight = true;
 		this.lastSummarizerError = undefined;
 		const promise = this.launchTrackedTask(ctx, "summarizer", work, (error) => {
+			if (this.summarizerPromise !== promise) return;
 			this.summarizerInFlight = false;
 			this.lastSummarizerError = error;
-			if (this.summarizerPromise === promise) this.summarizerPromise = null;
+			this.summarizerPromise = null;
 		});
 		this.summarizerPromise = promise;
 		return promise;
@@ -365,8 +377,9 @@ export class Runtime {
 		if (this.reviewInFlight) return undefined;
 		this.reviewInFlight = true;
 		const promise = this.launchTrackedTask(ctx, "structural review", work, () => {
+			if (this.reviewPromise !== promise) return;
 			this.reviewInFlight = false;
-			if (this.reviewPromise === promise) this.reviewPromise = null;
+			this.reviewPromise = null;
 		});
 		this.reviewPromise = promise;
 		return promise;

package/src/session-ledger/progress.ts

@@ -74,7 +74,7 @@ function isNonEmptyArray(value: unknown): value is unknown[] {
 function isValidCoverageEntry(entry: Entry, customType: MemoryCoverageCustomType): entry is Entry & { data: { coversUpToId: string } } {
 	if (entry.type !== "custom" || entry.customType !== customType) return false;
 	if (!isObject(entry.data) || typeof entry.data.coversUpToId !== "string") return false;
-	if (customType === OM_OBSERVATIONS_RECORDED) return isNonEmptyArray(entry.data.observations);
+	if (customType === OM_OBSERVATIONS_RECORDED) return Array.isArray(entry.data.observations);
 	return customType === OM_SUMMARIZER_COMMIT && isNonEmptyArray(entry.data.summaries);
 }
 

package/src/session-ledger/types.ts

@@ -235,7 +235,6 @@ export function isObservationsRecordedData(value: unknown): value is Observation
 	if (!isPlainRecord(value)) return false;
 	return (
 		Array.isArray(value.observations) &&
-		value.observations.length > 0 &&
 		value.observations.every(isObservation) &&
 		isNonEmptyString(value.coversUpToId)
 	);
@@ -345,7 +344,7 @@ export function buildObservationsRecordedData(
 	observations: Observation[],
 	coversUpToId: string,
 ): ObservationsRecordedEntryData | undefined {
-	if (observations.length === 0 || !isNonEmptyString(coversUpToId)) return undefined;
+	if (!isNonEmptyString(coversUpToId)) return undefined;
 	const candidate = { observations, coversUpToId };
 	return isObservationsRecordedData(candidate) ? candidate : undefined;
 }

package/src/worker-watchdog.ts

@@ -0,0 +1,63 @@
+export const BACKGROUND_WORKER_STALL_TIMEOUT_MS = 15 * 60_000;
+export const BACKGROUND_WORKER_MAX_RUNTIME_MS = 6 * 60 * 60_000;
+
+/**
+ * No-progress watchdog for background model workers.
+ *
+ * Aborting the provider is the cooperative path. `race()` is the hard liveness
+ * boundary: even a provider that ignores AbortSignal cannot retain a worker's
+ * single-flight lock forever. The abandoned promise has handlers installed by
+ * Promise.race, so a later rejection is not unhandled.
+ */
+export function createWorkerStallWatchdog(
+	label: string,
+	timeoutMs = BACKGROUND_WORKER_STALL_TIMEOUT_MS,
+	onStall?: (error: Error) => void,
+	maxRuntimeMs = BACKGROUND_WORKER_MAX_RUNTIME_MS,
+): {
+	signal: AbortSignal;
+	progress: () => void;
+	race: <T>(work: Promise<T>) => Promise<T>;
+	dispose: () => void;
+} {
+	const controller = new AbortController();
+	let timer: ReturnType<typeof setTimeout> | undefined;
+	let maxRuntimeTimer: ReturnType<typeof setTimeout> | undefined;
+	let rejectStall!: (error: Error) => void;
+	let settled = false;
+	const stalled = new Promise<never>((_resolve, reject) => { rejectStall = reject; });
+	// Some callers use only the cooperative AbortSignal. Keep the hard-boundary
+	// promise observed even before/without a race() call.
+	void stalled.catch(() => {});
+	const trip = (error: Error) => {
+		if (settled || controller.signal.aborted) return;
+		controller.abort(error);
+		onStall?.(error);
+		rejectStall(error);
+	};
+	maxRuntimeTimer = setTimeout(() => trip(new Error(`${label} exceeded its ${Math.round(maxRuntimeMs / 3_600_000)}-hour runtime ceiling`)), maxRuntimeMs);
+	(maxRuntimeTimer as ReturnType<typeof setTimeout> & { unref?: () => void }).unref?.();
+	const progress = () => {
+		if (settled || controller.signal.aborted) return;
+		if (timer !== undefined) clearTimeout(timer);
+		timer = setTimeout(() => {
+			timer = undefined;
+			if (settled) return;
+			trip(new Error(`${label} produced no progress for ${Math.round(timeoutMs / 60_000)} minutes`));
+		}, timeoutMs);
+		(timer as ReturnType<typeof setTimeout> & { unref?: () => void }).unref?.();
+	};
+	progress();
+	return {
+		signal: controller.signal,
+		progress,
+		race: async <T>(work: Promise<T>) => Promise.race([work, stalled]),
+		dispose: () => {
+			settled = true;
+			if (timer !== undefined) clearTimeout(timer);
+			if (maxRuntimeTimer !== undefined) clearTimeout(maxRuntimeTimer);
+			timer = undefined;
+			maxRuntimeTimer = undefined;
+		},
+	};
+}