@matthewfl/pi-contemplator 0.3.1 → 0.4.1

package/README.md

@@ -157,7 +157,7 @@ The observer and summarizer provide the durable memory substrate. The contemplat
 
 ## Installation
 
-`pi-contemplator` 0.3.0 requires **Pi 0.87.x**.
+`pi-contemplator` 0.4.0 requires **Pi 1.0.0** or later.
 
 Install the published package through Pi:
 

package/package.json

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

package/src/agents/contemplator/agent.ts

@@ -1,5 +1,6 @@
 import { agentLoop, type AgentContext, type AgentLoopConfig, type AgentMessage, type AgentTool, type StreamFn } from "@earendil-works/pi-agent-core";
 import { Type, type Message, type Model } from "@earendil-works/pi-ai";
+import { isRetryableAssistantError } from "@earendil-works/pi-ai/utils/retry";
 import type { Static } from "typebox";
 import { estimateTokens as estimateAgentMessageTokens, generateSummaryWithUsage } from "@earendil-works/pi-coding-agent";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
@@ -23,6 +24,8 @@ const CONTEMPLATOR_HISTORY_MAX_TRIGGER_TOKENS = 40_000;
 const CONTEMPLATOR_HISTORY_CONTEXT_FRACTION = 0.25;
 const CONTEMPLATOR_HISTORY_KEEP_RECENT_TOKENS = 12_000;
 const CONTEMPLATOR_HISTORY_SUMMARY_RESERVE_TOKENS = 16_000;
+const CONTEMPLATOR_UPDATE_MAX_TOKENS = 20_000;
+const CONTEMPLATOR_UPDATE_CONTEXT_FRACTION = 0.2;
 const CONTEMPLATOR_HISTORY_SUMMARY_INSTRUCTIONS = "This is an older prefix of a private contemplator transcript. Be concise. Preserve durable user intent, decisions, evidence, unresolved reasoning gaps, and review/probe outcomes. Newer transcript messages are retained verbatim after this checkpoint.";
 
 function contemplatorMessageTokens(message: AgentMessage): number {
@@ -84,6 +87,8 @@ interface PendingUpdate {
 	mainAgentOutputTokens: number;
 	mainAgentToolCalls: number;
 	mainAgentActiveTimeMs: number;
+	/** True when cumulative active work, rather than memory volume, forced this update. */
+	activeTimeFallback: boolean;
 }
 
 type Intervention =
@@ -143,6 +148,72 @@ function reviewSummaryLine(review: ReviewResult): string {
 		: `[${review.id}] ${review.scope} review concluded with no proposal — ${review.reason}`;
 }
 
+function memoryLineId(line: string): string | undefined {
+	return line.match(/^\[([0-9a-f]{12})\]/)?.[1];
+}
+
+function contemplatorUpdateBudgetTokens(model: Model<any>): number {
+	const contextWindow = Number(model.contextWindow);
+	if (!Number.isFinite(contextWindow) || contextWindow <= 0) return CONTEMPLATOR_UPDATE_MAX_TOKENS;
+	return Math.max(1_024, Math.min(CONTEMPLATOR_UPDATE_MAX_TOKENS, Math.floor(contextWindow * CONTEMPLATOR_UPDATE_CONTEXT_FRACTION)));
+}
+
+/**
+ * Keep the newest pending records within a bounded request budget. The complete
+ * ids are persisted as coverage separately, so intentionally omitted old
+ * records do not reappear after reload even though their bodies are not copied
+ * into the private contemplator transcript.
+ */
+function boundedContemplatorUpdate(observations: string[], reviews: string[], budgetTokens: number): {
+	observations: string[];
+	reviews: string[];
+	omitted: number;
+} {
+	type Candidate = { kind: "observation" | "review"; index: number; line: string };
+	// Reviews are rare terminal outcomes and get first claim on the budget. Within
+	// each section, newest records are selected first and rendered chronologically.
+	const candidates: Candidate[] = [
+		...reviews.map((line, index) => ({ kind: "review" as const, index, line })).reverse(),
+		...observations.map((line, index) => ({ kind: "observation" as const, index, line })).reverse(),
+	];
+	const selected = new Map<Candidate, string>();
+	let remaining = budgetTokens;
+	for (const candidate of candidates) {
+		const tokens = Math.max(1, Math.ceil(candidate.line.length / 4));
+		if (tokens <= remaining) {
+			selected.set(candidate, candidate.line);
+			remaining -= tokens;
+			continue;
+		}
+		// Always expose at least the newest record. An individually enormous memory
+		// is excerpted rather than defeating the safety cap; recall retains the full
+		// source under the id shown at the beginning of the excerpt.
+		if (selected.size === 0 && remaining > 0) {
+			const maxChars = Math.max(256, remaining * 4);
+			selected.set(candidate, `${candidate.line.slice(0, Math.max(1, maxChars - 96))}\n… [memory excerpt capped; use recall for the full record]`);
+			remaining = 0;
+		}
+	}
+	const selectedObservations = candidates
+		.filter((candidate) => candidate.kind === "observation" && selected.has(candidate))
+		.sort((left, right) => left.index - right.index)
+		.map((candidate) => selected.get(candidate)!);
+	const selectedReviews = candidates
+		.filter((candidate) => candidate.kind === "review" && selected.has(candidate))
+		.sort((left, right) => left.index - right.index)
+		.map((candidate) => selected.get(candidate)!);
+	return {
+		observations: selectedObservations,
+		reviews: selectedReviews,
+		omitted: observations.length + reviews.length - selected.size,
+	};
+}
+
+function retryableContemplatorFailure(message: string): boolean {
+	return isRetryableAssistantError({ stopReason: "error", errorMessage: message } as any)
+		|| /produced no progress|runtime ceiling/i.test(message);
+}
+
 function reviewRequestKey(request: RequestReviewArgs): string {
 	return `${request.scope}:${hashId(`${request.evidence}\n${request.concern}`)}`;
 }
@@ -171,6 +242,8 @@ function coarseAgentTime(durationMs: number): string {
 }
 const CONTEMPLATOR_MESSAGE = "om.contemplator.message";
 const CONTEMPLATOR_STATE = "om.contemplator.state";
+/** Durable per-branch baseline for the cumulative active-work fallback trigger. */
+const CONTEMPLATOR_RUN = "om.contemplator.run";
 const CONTEMPLATOR_SUGGESTION = "om.contemplator.suggestion";
 const REVIEW_PROPOSAL_MESSAGE = "om.review.proposal";
 const SendProbeSchema = Type.Object({ question: Type.String({ minLength: 1, description: "One concise, memory-grounded probing question, optionally preceded by one short sentence of context. Cite relevant memory identifiers." }) });
@@ -292,6 +365,8 @@ export class Contemplator {
 	private queuedProbeIds = new Set<string>();
 	/** Probes whose provider-context delivery will establish the next response-spacing anchor. */
 	private probeCooldownPendingIds = new Set<string>();
+	/** Preserve the configured response gap after a probe actually reaches provider context. */
+	private probeDeliverySpacingActive = false;
 	private sessionGeneration = 0;
 	private latestCtx: MemoryUpdateCtx | undefined;
 	/** Completed primary-model responses since the current completion/probe-delivery spacing anchor. */
@@ -301,6 +376,10 @@ export class Contemplator {
 	private restoredTipId: string | undefined;
 	/** Start of the unpersisted portion of the current main-agent run. */
 	private agentActiveSince: number | undefined;
+	/** Cumulative active time at the latest contemplator attempt on this branch. */
+	private lastContemplatorActiveTimeMs = 0;
+	/** Fires while the primary agent remains active, including inside one long tool call. */
+	private activeTimeFallbackTimer: ReturnType<typeof setTimeout> | undefined;
 
 	constructor(private readonly pi: ExtensionAPI, private readonly runtime: Runtime) {}
 
@@ -322,12 +401,14 @@ export class Contemplator {
 			return box;
 		});
 		this.runtime.setMemoryUpdateListener((ctx) => this.withDebugContext(ctx, () => this.observeTurn(ctx)));
-		this.pi.on("agent_start", () => {
+		this.pi.on("agent_start", (_event: unknown, ctx: ExtensionContext) => {
 			this.agentActiveSince = Date.now();
+			this.withDebugContext(ctx, () => this.scheduleActiveTimeFallback(ctx));
 		});
 		this.pi.on("agent_end", (_event: unknown, ctx: ExtensionContext) => {
 			this.persistAgentActivity(ctx);
 			this.agentActiveSince = undefined;
+			this.clearActiveTimeFallbackTimer();
 		});
 		this.pi.on("session_start", (event: any, ctx: ExtensionContext) => {
 			this.sessionGeneration++;
@@ -336,11 +417,20 @@ export class Contemplator {
 			this.consecutiveFlushFailures = 0;
 			const generation = this.sessionGeneration;
 			this.agentActiveSince = undefined;
+			this.clearActiveTimeFallbackTimer();
 			// AgentSession preserves its steering queue across extension reloads. An
 			// undelivered tracking entry therefore still has a live queued message;
 			// restoring it here would enqueue the same probe a second time.
 			const reload = event?.reason === "reload";
 			this.restore(ctx, true, reload, reload);
+			// Reload replaces the extension runtime without restarting an already-active
+			// agent run, so no new agent_start event is guaranteed. Recover the clock
+			// from Pi's live state; elapsed time before reload may be unavailable, but
+			// the current run remains monitored rather than going unarmed indefinitely.
+			if (!ctx.isIdle()) {
+				this.agentActiveSince = Date.now();
+				this.withDebugContext(ctx, () => this.scheduleActiveTimeFallback(ctx));
+			}
 			// Reconstruct and schedule durable memory immediately. In particular, a
 			// reload after a failed run must not silently mark its pending backlog seen.
 			queueMicrotask(() => {
@@ -353,15 +443,22 @@ export class Contemplator {
 			this.running = false;
 			this.consecutiveFlushFailures = 0;
 			this.agentActiveSince = undefined;
+			this.clearActiveTimeFallbackTimer();
 			// Pending steering messages remain queued while navigating the tree.
 			this.restore(ctx, true, true);
 		});
-		this.pi.on("session_shutdown", () => {
+		this.pi.on("session_shutdown", (_event: unknown, ctx: ExtensionContext) => {
+			// On extension reload Pi shuts down the old runtime before starting the
+			// replacement. Persist its final live interval without launching workers,
+			// so the replacement can continue from the exact cumulative clock.
+			this.persistAgentActivity(ctx, false, false);
 			this.sessionGeneration++;
 			this.flushEpoch++;
 			this.running = false;
 			this.consecutiveFlushFailures = 0;
 			this.agentActiveSince = undefined;
+			this.clearActiveTimeFallbackTimer();
+			this.lastContemplatorActiveTimeMs = 0;
 			this.history = [];
 			this.historyEntryIds = [];
 			this.pending = undefined;
@@ -375,6 +472,7 @@ export class Contemplator {
 			this.deliveredProbeIds.clear();
 			this.queuedProbeIds.clear();
 			this.probeCooldownPendingIds.clear();
+			this.probeDeliverySpacingActive = false;
 			this.latestCtx = undefined;
 			this.turnsSinceRun = 0;
 			this.assistantResponsesInCurrentTurn = 0;
@@ -384,6 +482,7 @@ export class Contemplator {
 				pendingObservations: 0,
 				pendingReviews: 0,
 				responsesSinceRun: 0,
+				activeTimeSinceRunMs: 0,
 				waitingFor: "idle",
 			};
 		});
@@ -419,6 +518,9 @@ export class Contemplator {
 			// This records one wall-clock interval regardless of how many tools were
 			// running concurrently; persistAgentActivity restarts the shared clock.
 			this.persistAgentActivity(ctx);
+			// A long autonomous turn can perform many tools without ending a model
+			// turn. Recheck the active-work fallback at each completed tool batch.
+			this.withDebugContext(ctx, () => this.observeTurn(ctx));
 		});
 		this.pi.on("context", (event: any, ctx: ExtensionContext) => {
 			const deliveredMessages = event.messages?.filter((message: any) => message?.role === "custom" && message.customType === CONTEMPLATOR_SUGGESTION && typeof message.details?.probeId === "string") ?? [];
@@ -444,6 +546,7 @@ export class Contemplator {
 			if (cooldownAnchored) {
 				// Probe spacing begins only once Pi proves the probe reached an actual
 				// provider context. Responses generated before this point do not count.
+				this.probeDeliverySpacingActive = true;
 				this.turnsSinceRun = 0;
 				this.withDebugContext(ctx, () => this.observeTurn(ctx));
 			}
@@ -458,18 +561,46 @@ export class Contemplator {
 		});
 	}
 
-	private persistAgentActivity(ctx: MemoryUpdateCtx): void {
+	private clearActiveTimeFallbackTimer(): void {
+		if (this.activeTimeFallbackTimer !== undefined) clearTimeout(this.activeTimeFallbackTimer);
+		this.activeTimeFallbackTimer = undefined;
+	}
+
+	private scheduleActiveTimeFallback(ctx: MemoryUpdateCtx): void {
+		this.clearActiveTimeFallbackTimer();
+		if (this.agentActiveSince === undefined || !this.runtime.config.contemplatorEnabled || this.runtime.config.passive) return;
+		const persistedActiveMs = agentActiveTimeMs(ctx.sessionManager.getBranch() as Entry[]);
+		const liveActiveMs = Math.max(0, Date.now() - this.agentActiveSince);
+		const elapsedMs = Math.max(0, persistedActiveMs + liveActiveMs - this.lastContemplatorActiveTimeMs);
+		const thresholdMs = this.runtime.config.contemplatorMaxActiveMinutes * 60_000;
+		const delayMs = Math.max(1, thresholdMs - elapsedMs);
+		this.activeTimeFallbackTimer = setTimeout(() => {
+			this.activeTimeFallbackTimer = undefined;
+			if (this.agentActiveSince === undefined) return;
+			this.withDebugContext(ctx, () => {
+				// Materialize the live interval before observeTurn reads the ledger. This
+				// lets a sleep/long tool trigger contemplation while it is still running.
+				this.persistAgentActivity(ctx, false);
+				this.observeTurn(ctx);
+			});
+		}, delayMs);
+		(this.activeTimeFallbackTimer as { unref?: () => void }).unref?.();
+	}
+
+	private persistAgentActivity(ctx: MemoryUpdateCtx, reschedule = true, notify = true): void {
 		const startedAt = this.agentActiveSince;
 		if (startedAt === undefined) return;
 		const endedAt = Date.now();
 		this.agentActiveSince = endedAt;
 		const durationMs = Math.max(0, endedAt - startedAt);
-		if (durationMs === 0) return;
-		this.pi.appendEntry(OM_AGENT_ACTIVITY, { version: 1, durationMs, endedAt });
-		// Notify only after appendEntry so active-time schedulers always observe the
-		// checkpoint, regardless of Pi's ordering between independent event handlers.
-		this.runtime.notifyAgentActivity(ctx);
-		debugLog("agent.activity_recorded", { durationMs });
+		if (durationMs > 0) {
+			this.pi.appendEntry(OM_AGENT_ACTIVITY, { version: 1, durationMs, endedAt });
+			// Notify only after appendEntry so active-time schedulers always observe the
+			// checkpoint, regardless of Pi's ordering between independent event handlers.
+			if (notify) this.runtime.notifyAgentActivity(ctx);
+			debugLog("agent.activity_recorded", { durationMs });
+		}
+		if (reschedule) this.scheduleActiveTimeFallback(ctx);
 	}
 
 	private withDebugContext<T>(ctx: MemoryUpdateCtx, fn: () => T): T {
@@ -493,6 +624,7 @@ export class Contemplator {
 			pendingObservations: this.pending?.observations.length ?? 0,
 			pendingReviews: this.pending?.reviews.length ?? 0,
 			responsesSinceRun: this.turnsSinceRun,
+			activeTimeSinceRunMs: this.runtime.contemplatorState.activeTimeSinceRunMs,
 			waitingFor,
 			...overrides,
 		};
@@ -509,10 +641,13 @@ export class Contemplator {
 		const historyMessagesByEntryId = new Map<string, AgentMessage>();
 		const checkpointCoveredObservationIds = new Set<string>();
 		const checkpointCoveredReviewIds = new Set<string>();
+		let latestRunActiveTimeMs: number | undefined;
+		let probeDeliveredAfterLatestRun = false;
 		let resetProjection: ReturnType<typeof fullProjection> | undefined;
 		if (resetTracking) {
 			this.deliveredProbeIds.clear();
 			this.probeCooldownPendingIds.clear();
+			this.probeDeliverySpacingActive = false;
 			if (!retainQueuedIds) this.queuedProbeIds.clear();
 			this.inFlightReviewIds.clear();
 			this.resolvingReviewIds.clear();
@@ -529,11 +664,19 @@ export class Contemplator {
 				pendingObservations: 0,
 				pendingReviews: 0,
 				responsesSinceRun: 0,
+				activeTimeSinceRunMs: 0,
 				waitingFor: "idle",
 			};
 		}
 		const undeliveredSuggestions = new Map<string, string>();
 		for (const entry of entries) {
+			if (entry.customType === CONTEMPLATOR_RUN && entry.data && typeof entry.data === "object") {
+				const activeTimeMs = (entry.data as { mainAgentActiveTimeMs?: unknown }).mainAgentActiveTimeMs;
+				if (typeof activeTimeMs === "number" && Number.isFinite(activeTimeMs) && activeTimeMs >= 0) {
+					latestRunActiveTimeMs = activeTimeMs;
+					probeDeliveredAfterLatestRun = false;
+				}
+			}
 			if (entry.customType === CONTEMPLATOR_STATE && entry.data && typeof entry.data === "object") {
 				const state = entry.data as { history?: unknown };
 				if (Array.isArray(state.history)) {
@@ -543,6 +686,11 @@ export class Contemplator {
 			}
 			if (entry.customType === CONTEMPLATOR_MESSAGE && entry.data && typeof entry.data === "object") {
 				const data = entry.data as { message?: unknown; compacted?: unknown; retainedMessageEntryIds?: unknown; coveredObservationIds?: unknown; coveredReviewIds?: unknown };
+				// Coverage may be broader than the rendered prompt when a long-dead
+				// contemplator returns to a large backlog. Persisting compact id lists
+				// avoids copying every old memory body while keeping restore stable.
+				if (Array.isArray(data.coveredObservationIds)) for (const id of data.coveredObservationIds) if (typeof id === "string") checkpointCoveredObservationIds.add(id);
+				if (Array.isArray(data.coveredReviewIds)) for (const id of data.coveredReviewIds) if (typeof id === "string") checkpointCoveredReviewIds.add(id);
 				const message = data.message;
 				if (message && typeof message === "object") {
 					const typedMessage = message as AgentMessage;
@@ -553,8 +701,6 @@ export class Contemplator {
 							: [];
 						this.history = [typedMessage, ...retainedIds.map((id) => historyMessagesByEntryId.get(id)!)];
 						this.historyEntryIds = [entry.id, ...retainedIds];
-						if (Array.isArray(data.coveredObservationIds)) for (const id of data.coveredObservationIds) if (typeof id === "string") checkpointCoveredObservationIds.add(id);
-						if (Array.isArray(data.coveredReviewIds)) for (const id of data.coveredReviewIds) if (typeof id === "string") checkpointCoveredReviewIds.add(id);
 					} else {
 						this.history.push(typedMessage);
 						this.historyEntryIds.push(entry.id);
@@ -607,12 +753,19 @@ export class Contemplator {
 				if (typeof data.probeId !== "string") continue;
 				if (data.delivered === true) {
 					this.deliveredProbeIds.add(data.probeId);
+					probeDeliveredAfterLatestRun = true;
 					undeliveredSuggestions.delete(data.probeId);
 				} else if (typeof data.suggestion === "string") {
 					undeliveredSuggestions.set(data.probeId, data.suggestion);
 				}
 			}
 		}
+		// A malformed/foreign marker must not regress a valid live baseline during
+		// an ordinary tip refresh. A true session/tree restore with no valid marker
+		// intentionally starts this branch's cumulative baseline at zero.
+		if (latestRunActiveTimeMs !== undefined) this.lastContemplatorActiveTimeMs = latestRunActiveTimeMs;
+		else if (resetTracking) this.lastContemplatorActiveTimeMs = 0;
+		this.probeDeliverySpacingActive = probeDeliveredAfterLatestRun;
 		if (resetTracking && resetProjection) {
 			// Successful update prompts and private-history compaction checkpoints are
 			// the durable coverage record. Checkpoints carry ids from prompts replaced
@@ -681,6 +834,10 @@ export class Contemplator {
 			});
 			return;
 		}
+		const cumulativeActiveTimeMs = agentActiveTimeMs(branchEntries) + (this.agentActiveSince === undefined ? 0 : Math.max(0, Date.now() - this.agentActiveSince));
+		const activeTimeSinceRunMs = Math.max(0, cumulativeActiveTimeMs - this.lastContemplatorActiveTimeMs);
+		const activeTimeThresholdMs = this.runtime.config.contemplatorMaxActiveMinutes * 60_000;
+		const activeTimeDue = activeTimeSinceRunMs >= activeTimeThresholdMs;
 		const projection = fullProjection(branchEntries);
 		const observations = projection.observations.map((item) => `[${item.id}] ${item.content}`);
 		const reviews = projection.reviews ?? [];
@@ -704,11 +861,25 @@ export class Contemplator {
 				reviews: mergeMemoryLines(this.pending?.reviews ?? [], newReviews),
 				mainAgentOutputTokens: assistantOutputTokens(branchEntries),
 				mainAgentToolCalls: assistantToolCallCount(branchEntries),
-				mainAgentActiveTimeMs: agentActiveTimeMs(branchEntries),
+				mainAgentActiveTimeMs: cumulativeActiveTimeMs,
+				activeTimeFallback: this.pending?.activeTimeFallback ?? false,
+			};
+		}
+		if (activeTimeDue && !this.pending) {
+			this.pending = {
+				observations: [],
+				reviews: [],
+				mainAgentOutputTokens: assistantOutputTokens(branchEntries),
+				mainAgentToolCalls: assistantToolCallCount(branchEntries),
+				mainAgentActiveTimeMs: cumulativeActiveTimeMs,
+				activeTimeFallback: true,
 			};
+		} else if (activeTimeDue && this.pending) {
+			this.pending.activeTimeFallback = true;
 		}
 		if (!this.pending) {
-			this.publishState(this.running ? "running" : this.probeCooldownPendingIds.size > 0 ? "probe" : "idle");
+			this.scheduleActiveTimeFallback(ctx);
+			this.publishState(this.running ? "running" : this.probeCooldownPendingIds.size > 0 ? "probe" : "idle", { activeTimeSinceRunMs });
 			return;
 		}
 		// Activity values are cumulative send-time snapshots, not values frozen when
@@ -716,15 +887,17 @@ export class Contemplator {
 		// while that batch waits for its memory/turn thresholds.
 		this.pending.mainAgentOutputTokens = assistantOutputTokens(branchEntries);
 		this.pending.mainAgentToolCalls = assistantToolCallCount(branchEntries);
-		this.pending.mainAgentActiveTimeMs = agentActiveTimeMs(branchEntries);
+		this.pending.mainAgentActiveTimeMs = cumulativeActiveTimeMs;
 		const enoughMemories = this.pending.reviews.length > 0 || this.pending.observations.length >= this.runtime.config.contemplatorMinNewObservations;
+		const forcedByActiveTime = this.pending.activeTimeFallback;
 		if (this.probeCooldownPendingIds.size > 0) {
-			this.publishState("probe");
+			this.publishState("probe", { activeTimeSinceRunMs });
 			debugLog("contemplator.waiting", { reason: "probe_delivery", pendingProbeCount: this.probeCooldownPendingIds.size });
 			return;
 		}
-		if (!enoughMemories || this.turnsSinceRun < this.runtime.config.contemplatorMinTurns) {
-			this.publishState(!enoughMemories ? "memories" : "responses");
+		const waitingForDeliveredProbeResponses = this.probeDeliverySpacingActive && this.turnsSinceRun < this.runtime.config.contemplatorMinTurns;
+		if (waitingForDeliveredProbeResponses || (!forcedByActiveTime && (!enoughMemories || this.turnsSinceRun < this.runtime.config.contemplatorMinTurns))) {
+			this.publishState(waitingForDeliveredProbeResponses || enoughMemories ? "responses" : "memories", { activeTimeSinceRunMs });
 			debugLog("contemplator.waiting", {
 				enoughMemories,
 				turnsSinceRun: this.turnsSinceRun,
@@ -733,11 +906,13 @@ export class Contemplator {
 			});
 			return;
 		}
-		this.publishState(this.running ? "running" : "ready");
+		this.publishState(this.running ? "running" : "ready", { activeTimeSinceRunMs });
 		debugLog("contemplator.triggered", {
 			pendingObservationCount: this.pending.observations.length,
 			pendingReviewCount: this.pending.reviews.length,
 			turnsSinceRun: this.turnsSinceRun,
+			forcedByActiveTime,
+			activeTimeSinceRunMs,
 		});
 		void this.flush(ctx);
 	}
@@ -756,6 +931,19 @@ export class Contemplator {
 		update.mainAgentOutputTokens = assistantOutputTokens(branchEntriesAtStart);
 		update.mainAgentToolCalls = assistantToolCallCount(branchEntriesAtStart);
 		update.mainAgentActiveTimeMs = agentActiveTimeMs(branchEntriesAtStart);
+		const activeTimeSinceLastRunMs = Math.max(0, update.mainAgentActiveTimeMs - this.lastContemplatorActiveTimeMs);
+		// Reset the active-work interval at attempt start, including failed attempts,
+		// so a broken provider cannot create an immediate background retry loop. The
+		// tiny durable marker makes reloads and tree navigation preserve that backoff.
+		this.lastContemplatorActiveTimeMs = update.mainAgentActiveTimeMs;
+		this.probeDeliverySpacingActive = false;
+		this.scheduleActiveTimeFallback(ctx);
+		this.pi.appendEntry(CONTEMPLATOR_RUN, {
+			version: 1,
+			mainAgentActiveTimeMs: update.mainAgentActiveTimeMs,
+			startedAt: Date.now(),
+		});
+		this.markTipPersisted(ctx);
 		this.pending = undefined;
 		const turnsBeforeRun = this.turnsSinceRun;
 		const sessionGeneration = this.sessionGeneration;
@@ -764,6 +952,7 @@ export class Contemplator {
 		this.turnsSinceRun = 0;
 		const startedAt = Date.now();
 		let failed = false;
+		let transientFailure = false;
 		let failureMessage: string | undefined;
 		let workerNotified = false;
 		let promptPersisted = false;
@@ -797,6 +986,7 @@ export class Contemplator {
 							mainAgentOutputTokens: update.mainAgentOutputTokens,
 							mainAgentToolCalls: update.mainAgentToolCalls,
 							mainAgentActiveTimeMs: update.mainAgentActiveTimeMs,
+							activeTimeFallback: update.activeTimeFallback,
 						};
 					} else {
 						debugLog("contemplator.poisoned_update_released", { reason: resolved.reason, observationCount: update.observations.length, reviewCount: update.reviews.length });
@@ -823,17 +1013,41 @@ export class Contemplator {
 				workerNotified = true;
 			}
 			const reviewerEnabled = this.runtime.config.reviewerEnabled;
+			const boundedUpdate = boundedContemplatorUpdate(
+				update.observations,
+				update.reviews,
+				contemplatorUpdateBudgetTokens(resolved.model as Model<any>),
+			);
 			const updateSections: string[] = [];
-			if (update.observations.length > 0) updateSections.push(`OBSERVATIONS:\n${update.observations.join("\n")}`);
-			if (update.reviews.length > 0) updateSections.push(`REVIEWS:\n${update.reviews.join("\n")}`);
+			if (boundedUpdate.observations.length > 0) updateSections.push(`OBSERVATIONS:\n${boundedUpdate.observations.join("\n")}`);
+			if (boundedUpdate.reviews.length > 0) updateSections.push(`REVIEWS:\n${boundedUpdate.reviews.join("\n")}`);
+			if (boundedUpdate.omitted > 0) updateSections.push(`BACKLOG SAFETY CAP: ${boundedUpdate.omitted} older pending memory record${boundedUpdate.omitted === 1 ? " was" : "s were"} omitted from this update. They remain searchable and recallable; focus on the newest records shown here.`);
 			const updateBody = updateSections.length > 0 ? updateSections.join("\n\n") : "(no new memories)";
+			const coveredObservationIds = update.observations.map(memoryLineId).filter((id): id is string => id !== undefined);
+			const coveredReviewIds = update.reviews.map(memoryLineId).filter((id): id is string => id !== undefined);
+			debugLog("contemplator.update_bounded", {
+				observationCount: update.observations.length,
+				reviewCount: update.reviews.length,
+				renderedObservationCount: boundedUpdate.observations.length,
+				renderedReviewCount: boundedUpdate.reviews.length,
+				omittedCount: boundedUpdate.omitted,
+			});
+			const sparseMemoryDescription = update.observations.length + update.reviews.length === 0
+				? "No new memories were created during this interval."
+				: `Only ${update.observations.length + update.reviews.length} new memory record${update.observations.length + update.reviews.length === 1 ? " was" : "s were"} created during this interval.`;
+			const reviewerHistoryHint = reviewerEnabled
+				? " If a recurring concern warrants structural review, remember that the reviewer can inspect the primary agent's recorded chat directly with its chat-history tools; it is not limited to these sparse memories."
+				: "";
+			const activeTimeNotice = update.activeTimeFallback
+				? `\n\nACTIVE-WORK FALLBACK: ${sparseMemoryDescription} The primary agent has been actively working for ${coarseAgentTime(activeTimeSinceLastRunMs)} since the last contemplator run. Check whether it is productively making progress rather than being stuck in an unproductive loop.${reviewerHistoryHint} Prefer no_intervention if there is no grounded, useful action.`
+				: "";
 			const finalActionNames = reviewerEnabled
 				? "send_probe, request_review, or no_intervention"
 				: "send_probe or no_intervention";
 			const interventionInstruction = reviewerEnabled
 				? `You must end this update by calling exactly one final-action tool: ${finalActionNames}. The tool requirement is bookkeeping, not a reason to intervene. Prefer the argument-free no_intervention whenever no specific, grounded, materially useful intervention is clearly warranted or usefulness is uncertain. Use send_probe only for one unusually useful focused question, and request_review only when a deeper workflow or software review is justified. Never send a probe merely to satisfy the final-action requirement. If a tool warns about a bad memory citation, use search_memories and recall, then call a final-action tool again to replace it.`
 				: `You must end this update by calling exactly one final-action tool: ${finalActionNames}. The tool requirement is bookkeeping, not a reason to intervene. Prefer the argument-free no_intervention whenever no specific, grounded, materially useful probe is clearly warranted or usefulness is uncertain. Use send_probe only for one unusually useful focused question. Never send a probe merely to satisfy the final-action requirement. If send_probe warns about a bad memory citation, use search_memories and recall, then call a final-action tool again to replace it.`;
-			const prompt: Message = { role: "user", content: [{ type: "text", text: `NEW MEMORY UPDATE\n\n${updateBody}\n\nCUMULATIVE ACTIVITY: ${update.mainAgentOutputTokens} generated tokens; ${update.mainAgentToolCalls} tool calls; ${coarseAgentTime(update.mainAgentActiveTimeMs)} active.\n\nConsider these updates in the context of the accumulated memories. Prioritize reasoning gaps, contradictions, user-intent alignment, relevant overlooked alternatives, well-supported loops, and recurring structural patterns. ${interventionInstruction}` }], timestamp: Date.now() };
+			const prompt: Message = { role: "user", content: [{ type: "text", text: `NEW MEMORY UPDATE\n\n${updateBody}${activeTimeNotice}\n\nCUMULATIVE ACTIVITY: ${update.mainAgentOutputTokens} generated tokens; ${update.mainAgentToolCalls} tool calls; ${coarseAgentTime(update.mainAgentActiveTimeMs)} active.\n\nConsider these updates in the context of the accumulated memories. Prioritize reasoning gaps, contradictions, user-intent alignment, relevant overlooked alternatives, well-supported loops, and recurring structural patterns. ${interventionInstruction}` }], timestamp: Date.now() };
 			let intervention: Intervention | undefined;
 			let finalActionWarned = false;
 			const branchEntries = ctx.sessionManager.getBranch() as Entry[];
@@ -935,6 +1149,7 @@ export class Contemplator {
 					const errorMessage = "errorMessage" in assistant && typeof assistant.errorMessage === "string"
 						? assistant.errorMessage
 						: `Contemplator model ${assistant.stopReason}`;
+					transientFailure = assistant.stopReason === "error" && retryableContemplatorFailure(errorMessage);
 					throw new Error(errorMessage);
 				}
 				if (!intervention && invocation < CONTEMPLATOR_MAX_INVOCATIONS) {
@@ -949,7 +1164,9 @@ export class Contemplator {
 				for (const message of runMessages) {
 					if (message.role !== "user" && message.role !== "assistant") continue;
 					this.history.push(message);
-					this.historyEntryIds.push(this.appendContemplatorHistoryEntry(ctx, { version: 1, message }));
+					this.historyEntryIds.push(this.appendContemplatorHistoryEntry(ctx, message === prompt
+						? { version: 2, message, coveredObservationIds, coveredReviewIds }
+						: { version: 1, message }));
 					promptPersisted = true;
 					this.markTipPersisted(ctx);
 				}
@@ -989,10 +1206,12 @@ export class Contemplator {
 		} catch (error) {
 			failed = true;
 			failureMessage = error instanceof Error ? error.message : String(error);
-			debugLog("contemplator.error", { errorMessage: failureMessage });
+			transientFailure ||= retryableContemplatorFailure(failureMessage);
+			debugLog("contemplator.error", { errorMessage: failureMessage, transientFailure });
 			if (sessionGeneration === this.sessionGeneration && !promptPersisted) {
-				this.consecutiveFlushFailures++;
-				if (this.consecutiveFlushFailures < 2) {
+				if (transientFailure) this.consecutiveFlushFailures = 0;
+				else this.consecutiveFlushFailures++;
+				if (transientFailure || this.consecutiveFlushFailures < 2) {
 					const pending = this.pending as PendingUpdate | undefined;
 					this.pending = {
 						observations: mergeMemoryLines(pending?.observations ?? [], update.observations),
@@ -1000,6 +1219,7 @@ export class Contemplator {
 						mainAgentOutputTokens: update.mainAgentOutputTokens,
 						mainAgentToolCalls: update.mainAgentToolCalls,
 						mainAgentActiveTimeMs: update.mainAgentActiveTimeMs,
+						activeTimeFallback: update.activeTimeFallback,
 					};
 				} else {
 					debugLog("contemplator.poisoned_update_released", { reason: failureMessage, observationCount: update.observations.length, reviewCount: update.reviews.length });
@@ -1031,8 +1251,14 @@ export class Contemplator {
 					: this.turnsSinceRun < this.runtime.config.contemplatorMinTurns
 						? "responses"
 						: "ready";
+			const activeTimeSinceRunMs = Math.max(
+				0,
+				agentActiveTimeMs(ctx.sessionManager.getBranch() as Entry[]) - this.lastContemplatorActiveTimeMs,
+			);
+			const finishedAt = Date.now();
 			this.publishState(waitingFor, {
-				lastCompletedAt: Date.now(),
+				activeTimeSinceRunMs,
+				...(failed ? { lastFailedAt: finishedAt } : { lastCompletedAt: finishedAt, lastFailedAt: undefined }),
 				lastError: failureMessage,
 			});
 			debugLog("contemplator.complete", {
@@ -1378,13 +1604,24 @@ export class Contemplator {
 		// per checkpoint, and restore unions checkpoints, avoiding cumulative O(n²)
 		// id duplication across a very long session.
 		const prefixCoveredIds = new Set<string>();
-		for (const message of history.slice(0, prefixEnd)) {
-			if (message.role !== "user") continue;
-			const text = customMessageText(message.content);
-			if (!text.includes("NEW MEMORY UPDATE")) continue;
-			for (const id of memoryReferenceIds(text)) prefixCoveredIds.add(id);
+		const branchEntries = ctx.sessionManager.getBranch() as Entry[];
+		const branchById = new Map(branchEntries.map((entry) => [entry.id, entry]));
+		for (let index = 0; index < prefixEnd; index++) {
+			const message = history[index];
+			if (message.role === "user") {
+				const text = customMessageText(message.content);
+				if (text.includes("NEW MEMORY UPDATE")) for (const id of memoryReferenceIds(text)) prefixCoveredIds.add(id);
+			}
+			// A safety-capped prompt intentionally covers records whose bodies were
+			// omitted. Carry those compact id references into the replacement
+			// checkpoint before its original message entry becomes unreachable.
+			const entryId = historyEntryIds[index];
+			const data = entryId === undefined ? undefined : branchById.get(entryId)?.data as { coveredObservationIds?: unknown; coveredReviewIds?: unknown } | undefined;
+			for (const ids of [data?.coveredObservationIds, data?.coveredReviewIds]) {
+				if (Array.isArray(ids)) for (const id of ids) if (typeof id === "string") prefixCoveredIds.add(id);
+			}
 		}
-		const currentProjection = fullProjection(ctx.sessionManager.getBranch() as Entry[]);
+		const currentProjection = fullProjection(branchEntries);
 		const checkpoint = {
 			version: 2,
 			compacted: true,

package/src/commands/contemplator-view.ts

@@ -60,7 +60,7 @@ function renderMessage(message: StoredMessage, compacted: boolean): string {
 
 function liveStateLine(state: ContemplatorRunState): string {
 	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 timing = `Last start: ${state.lastStartedAt === undefined ? "not run this launch" : new Date(state.lastStartedAt).toISOString()} · Last success: ${state.lastCompletedAt === undefined ? "none this launch" : new Date(state.lastCompletedAt).toISOString()} · Last failure: ${state.lastFailedAt === undefined ? "none this launch" : new Date(state.lastFailedAt).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 === "observer"

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" | "contemplatorMinTurns" | "summarizerRetriggerTokens" | "summarizerSamplingThresholdTokens";
+type NumberSetting = "observeAfterTokens" | "compactAfterTokens" | "observerChunkMaxTokens" | "newMemoryPoolMaxTokens" | "oldMemoryPoolTargetTokens" | "agentMaxTurns" | "contemplatorMinNewObservations" | "contemplatorMinTurns" | "contemplatorMaxActiveMinutes" | "summarizerRetriggerTokens" | "summarizerSamplingThresholdTokens";
 type BooleanSetting = "contemplatorEnabled" | "showContemplatorMessages" | "reviewerEnabled" | "summarizerEnabled" | "compactionObserverEnabled" | "showWorkerNotifications" | "passive" | "debugLog";
 
 function modelLabel(model: ConfiguredModel | undefined): string {
@@ -239,6 +239,7 @@ export function registerSettingsCommand(pi: ExtensionAPI, runtime: Runtime): voi
 				`Show contemplator messages: ${scalarLabel(runtime, "showContemplatorMessages")}`,
 				`Contemplator new-observation trigger (count): ${scalarLabel(runtime, "contemplatorMinNewObservations")}`,
 				`Contemplator response spacing (count): ${scalarLabel(runtime, "contemplatorMinTurns")}`,
+				`Contemplator maximum active-work interval (minutes): ${scalarLabel(runtime, "contemplatorMaxActiveMinutes")}`,
 				`Summarizer enabled: ${scalarLabel(runtime, "summarizerEnabled")}`,
 				`Summarizer model: ${memoryWorkerModelSettingLabel(runtime, "summarizer")}`,
 				`New memory pool protection budget (tokens): ${scalarLabel(runtime, "newMemoryPoolMaxTokens")}`,
@@ -298,6 +299,7 @@ export function registerSettingsCommand(pi: ExtensionAPI, runtime: Runtime): voi
 					["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 response spacing (count):", "contemplatorMinTurns", "Contemplator response spacing (count)"],
+					["Contemplator maximum active-work interval (minutes):", "contemplatorMaxActiveMinutes", "Contemplator maximum active-work interval (minutes)"],
 					["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

@@ -129,7 +129,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.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; ${formatDuration(runtime.contemplatorState.activeTimeSinceRunMs)} / ${formatDuration(runtime.config.contemplatorMaxActiveMinutes * 60_000)} active-work fallback; ${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"}`,
@@ -147,7 +147,8 @@ export function registerStatusCommand(pi: ExtensionAPI, runtime: Runtime): void
 			lines.push(`Last summarizer start:   ${runtime.lastSummarizerStartedAt === undefined ? "not run this launch" : formatRunAge(runtime.lastSummarizerStartedAt)}`);
 			lines.push(`Last summarizer end:     ${runtime.lastSummarizerCompletedAt === undefined ? "not completed this launch" : formatRunAge(runtime.lastSummarizerCompletedAt)}`);
 			lines.push(`Last contemplator start: ${runtime.contemplatorState.lastStartedAt === undefined ? "not run this launch" : formatRunAge(runtime.contemplatorState.lastStartedAt)}`);
-			lines.push(`Last contemplator end:   ${runtime.contemplatorState.lastCompletedAt === undefined ? "not completed this launch" : formatRunAge(runtime.contemplatorState.lastCompletedAt)}`);
+			lines.push(`Last contemplator success: ${runtime.contemplatorState.lastCompletedAt === undefined ? "not completed this launch" : formatRunAge(runtime.contemplatorState.lastCompletedAt)}`);
+			lines.push(`Last contemplator failure: ${runtime.contemplatorState.lastFailedAt === undefined ? "none this launch" : formatRunAge(runtime.contemplatorState.lastFailedAt)}`);
 
 			lines.push("", "── Interventions ──");
 			// Probe stats come from the branch ledger (like /om:view contemplator):

package/src/config.ts

@@ -67,6 +67,8 @@ export interface Config {
 	contemplatorMinNewObservations: number;
 	/** Minimum primary-model responses after contemplator completion, or after delivery of its probe, before the next run. */
 	contemplatorMinTurns: number;
+	/** Maximum cumulative main-agent active time between contemplator attempts, excluding time spent waiting for the user. */
+	contemplatorMaxActiveMinutes: number;
 	/** Stateless loss-aware summarizer for the old memory pool. */
 	summarizerEnabled: boolean;
 	/** Additional old-pool tokens required before retrying an above-target pool. */
@@ -92,6 +94,7 @@ export const DEFAULTS: Config = {
 	reviewerEnabled: true,
 	contemplatorMinNewObservations: 8,
 	contemplatorMinTurns: 10,
+	contemplatorMaxActiveMinutes: 60,
 	summarizerEnabled: true,
 	summarizerRetriggerTokens: 2_000,
 	summarizerSamplingThresholdTokens: 60_000,
@@ -214,6 +217,7 @@ function normalizeSettingsConfig(value: Record<string, unknown>): Partial<Config
 		"agentMaxTurns",
 		"contemplatorMinNewObservations",
 		"contemplatorMinTurns",
+		"contemplatorMaxActiveMinutes",
 		"summarizerRetriggerTokens",
 		"summarizerSamplingThresholdTokens",
 	] as const;

package/src/hooks/consolidation-trigger.ts

@@ -131,6 +131,11 @@ export function registerConsolidationTrigger(pi: ExtensionAPI, runtime: Runtime)
 		scheduleSummarizer(pi, runtime, ctx as ConsolidationCtx);
 	});
 	runtime.setSettingsUpdateListener((ctx, settings) => {
+		if (settings.contemplatorMaxActiveMinutes !== undefined) {
+			// Re-evaluate immediately when the user lowers the maximum interval;
+			// otherwise it would wait for an unrelated primary-agent checkpoint.
+			runtime.notifyMemoryUpdate(ctx);
+		}
 		const affectsScheduling = settings.summarizerEnabled !== undefined ||
 			settings.newMemoryPoolMaxTokens !== undefined ||
 			settings.oldMemoryPoolTargetTokens !== undefined ||

package/src/runtime.ts

@@ -32,7 +32,7 @@ export type SessionSettings = Partial<Pick<Config,
 	| "compactAfterTokensMode" | "compactAfterTokensRatio"
 	| "newMemoryPoolMaxTokens" | "oldMemoryPoolTargetTokens" | "agentMaxTurns"
 	| "showWorkerNotifications" | "passive" | "compactionObserverEnabled" | "contemplatorEnabled" | "showContemplatorMessages" | "reviewerEnabled"
-	| "contemplatorMinNewObservations" | "contemplatorMinTurns"
+	| "contemplatorMinNewObservations" | "contemplatorMinTurns" | "contemplatorMaxActiveMinutes"
 	| "summarizerEnabled" | "summarizerRetriggerTokens" | "summarizerSamplingThresholdTokens"
 	| "debugLog"
 >> & {
@@ -92,9 +92,14 @@ export interface ContemplatorRunState {
 	pendingReviews: number;
 	/** Completed primary-model responses since the current completion/probe-delivery spacing anchor. */
 	responsesSinceRun: number;
+	/** Cumulative main-agent active time since the latest contemplator attempt. */
+	activeTimeSinceRunMs: number;
 	waitingFor: "disabled" | "passive" | "observer" | "probe" | "memories" | "responses" | "ready" | "running" | "idle";
 	lastStartedAt?: number;
+	/** Most recent successful final-action completion. */
 	lastCompletedAt?: number;
+	/** Most recent failed attempt; distinct so a timeout is never shown as success. */
+	lastFailedAt?: number;
 	lastError?: string;
 }
 
@@ -148,7 +153,7 @@ export function computeSessionSettings(entries: readonly unknown[]): SessionSett
 		const numberKeys = [
 			"observeAfterTokens", "observerChunkMaxTokens", "compactAfterTokens",
 			"newMemoryPoolMaxTokens", "oldMemoryPoolTargetTokens", "agentMaxTurns",
-			"contemplatorMinNewObservations", "contemplatorMinTurns",
+			"contemplatorMinNewObservations", "contemplatorMinTurns", "contemplatorMaxActiveMinutes",
 			"summarizerRetriggerTokens", "summarizerSamplingThresholdTokens",
 		] as const;
 		for (const key of booleanKeys) if (typeof data[key] === "boolean") restored[key] = data[key];
@@ -225,6 +230,7 @@ export class Runtime {
 		pendingObservations: 0,
 		pendingReviews: 0,
 		responsesSinceRun: 0,
+		activeTimeSinceRunMs: 0,
 		waitingFor: "idle",
 	};
 	agentUsage: LlmUsageTotals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, runs: 0 };
@@ -325,6 +331,7 @@ export class Runtime {
 			pendingObservations: 0,
 			pendingReviews: 0,
 			responsesSinceRun: 0,
+			activeTimeSinceRunMs: 0,
 			waitingFor: "idle",
 		};
 	}