@matthewfl/pi-contemplator 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matthewfl/pi-contemplator",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "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

@@ -229,9 +229,11 @@ export class Contemplator {
 	private deliveredProbeIds = new Set<string>();
 	/** Probe ids passed to pi.sendMessage by this live extension runtime. */
 	private queuedProbeIds = new Set<string>();
+	/** Probes whose provider-context delivery will establish the next response-spacing anchor. */
+	private probeCooldownPendingIds = new Set<string>();
 	private sessionGeneration = 0;
 	private latestCtx: MemoryUpdateCtx | undefined;
-	/** Completed primary-model responses since the previous contemplator run. */
+	/** Completed primary-model responses since the current completion/probe-delivery spacing anchor. */
 	private turnsSinceRun = 0;
 	/** Used to avoid counting the final turn_end after its assistant message_end. */
 	private assistantResponsesInCurrentTurn = 0;
@@ -311,6 +313,7 @@ export class Contemplator {
 			this.reviewerSessions.clear();
 			this.deliveredProbeIds.clear();
 			this.queuedProbeIds.clear();
+			this.probeCooldownPendingIds.clear();
 			this.latestCtx = undefined;
 			this.turnsSinceRun = 0;
 			this.assistantResponsesInCurrentTurn = 0;
@@ -359,9 +362,12 @@ export class Contemplator {
 		});
 		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") ?? [];
+			let cooldownAnchored = false;
 			for (const delivered of deliveredMessages) {
 				if (this.deliveredProbeIds.has(delivered.details.probeId)) continue;
 				this.deliveredProbeIds.add(delivered.details.probeId);
+				this.probeCooldownPendingIds.delete(delivered.details.probeId);
+				cooldownAnchored = true;
 				// Once Pi includes the probe in a provider context it is no longer in
 				// either in-memory delivery queue. Keeping this id indefinitely caused
 				// later tree restores to suppress a genuinely needed requeue.
@@ -375,6 +381,12 @@ export class Contemplator {
 				this.markTipPersisted(ctx);
 				debugLog("contemplator.suggestion_delivered", { probeId: delivered.details.probeId });
 			}
+			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.turnsSinceRun = 0;
+				this.withDebugContext(ctx, () => this.observeTurn(ctx));
+			}
 		});
 		this.pi.on("turn_end", (_event: any, ctx: ExtensionContext) => {
 			this.persistAgentActivity(ctx);
@@ -437,6 +449,7 @@ export class Contemplator {
 		let resetProjection: ReturnType<typeof fullProjection> | undefined;
 		if (resetTracking) {
 			this.deliveredProbeIds.clear();
+			this.probeCooldownPendingIds.clear();
 			if (!retainQueuedIds) this.queuedProbeIds.clear();
 			this.inFlightReviewIds.clear();
 			this.resolvingReviewIds.clear();
@@ -545,6 +558,9 @@ export class Contemplator {
 		}
 		this.restoredTipId = tipId;
 		for (const [probeId, question] of undeliveredSuggestions) {
+			// An undelivered durable probe remains the cooldown anchor even when Pi's
+			// live queue survived an extension reload and must not be duplicated.
+			this.probeCooldownPendingIds.add(probeId);
 			// A durable custom_message proves only that Pi inserted the probe at some
 			// point; it does not prove an in-memory queue still owns it, and compaction
 			// may have removed it from active model context. Suppress requeue only for
@@ -620,7 +636,7 @@ export class Contemplator {
 			};
 		}
 		if (!this.pending) {
-			this.publishState(this.running ? "running" : "idle");
+			this.publishState(this.running ? "running" : this.probeCooldownPendingIds.size > 0 ? "probe" : "idle");
 			return;
 		}
 		// Activity values are cumulative send-time snapshots, not values frozen when
@@ -630,6 +646,11 @@ export class Contemplator {
 		this.pending.mainAgentToolCalls = assistantToolCallCount(branchEntries);
 		this.pending.mainAgentActiveTimeMs = agentActiveTimeMs(branchEntries);
 		const enoughMemories = this.pending.reviews.length > 0 || this.pending.observations.length >= this.runtime.config.contemplatorMinNewObservations || this.pending.summaries.length >= this.runtime.config.contemplatorMinNewSummaries;
+		if (this.probeCooldownPendingIds.size > 0) {
+			this.publishState("probe");
+			debugLog("contemplator.waiting", { reason: "probe_delivery", pendingProbeCount: this.probeCooldownPendingIds.size });
+			return;
+		}
 		if (!enoughMemories || this.turnsSinceRun < this.runtime.config.contemplatorMinTurns) {
 			this.publishState(!enoughMemories ? "memories" : "responses");
 			debugLog("contemplator.waiting", {
@@ -676,6 +697,7 @@ export class Contemplator {
 		let failureMessage: string | undefined;
 		let workerNotified = false;
 		let promptPersisted = false;
+		let emittedProbeId: string | undefined;
 		let workerWatchdog: ReturnType<typeof createWorkerStallWatchdog> | undefined;
 		this.publishState("running", { lastStartedAt: startedAt, lastError: undefined });
 		debugLog("contemplator.start", {
@@ -863,7 +885,7 @@ export class Contemplator {
 					this.markTipPersisted(ctx);
 				}
 			}
-			if (intervention?.kind === "probe" && sessionGeneration === this.sessionGeneration) this.queueProbe(ctx, intervention.question, "send_probe");
+			if (intervention?.kind === "probe" && sessionGeneration === this.sessionGeneration) emittedProbeId = this.queueProbe(ctx, intervention.question, "send_probe");
 			if (intervention?.kind === "review" && this.runtime.config.reviewerEnabled && sessionGeneration === this.sessionGeneration) {
 				const reviewerModel = await this.runtime.resolveModel({
 					model: ctx.model,
@@ -917,13 +939,21 @@ export class Contemplator {
 			if (flushEpoch !== this.flushEpoch) return;
 			this.running = false;
 			if (!failed) this.consecutiveFlushFailures = 0;
+			// Normal runs establish their spacing anchor at completion. A probe run
+			// instead anchors at provider-context delivery: if delivery already occurred
+			// during this run, retain responses counted since it; otherwise the pending
+			// probe gate blocks launches until the context event resets the counter.
+			if (emittedProbeId === undefined) this.turnsSinceRun = 0;
+			const waitingForProbe = this.probeCooldownPendingIds.size > 0;
 			const pendingHasEnoughMemories = this.pending !== undefined && (
 				this.pending.reviews.length > 0 ||
 				this.pending.observations.length >= this.runtime.config.contemplatorMinNewObservations ||
 				this.pending.summaries.length >= this.runtime.config.contemplatorMinNewSummaries
 			);
-			const waitingFor = !this.pending
-				? "idle"
+			const waitingFor = waitingForProbe
+				? "probe"
+				: !this.pending
+					? "idle"
 				: !pendingHasEnoughMemories
 					? "memories"
 					: this.turnsSinceRun < this.runtime.config.contemplatorMinTurns
@@ -948,7 +978,7 @@ export class Contemplator {
 		}
 	}
 
-	private queueProbe(ctx: MemoryUpdateCtx, question: string, source: "send_probe" | "restore", existingProbeId?: string): void {
+	private queueProbe(ctx: MemoryUpdateCtx, question: string, source: "send_probe" | "restore", existingProbeId?: string): string {
 		const probeId = existingProbeId ?? `${Date.now().toString(36)}-${Math.random().toString(16).slice(2, 8)}`;
 		// Persist intent before touching Pi's in-memory queue. A crash in between
 		// leaves a recoverable pending probe rather than an invisible lost one.
@@ -967,6 +997,7 @@ export class Contemplator {
 		// unrelated observer update or compaction callback cannot restore and enqueue
 		// a duplicate while the original idle steer is still pending.
 		this.queuedProbeIds.add(probeId);
+		this.probeCooldownPendingIds.add(probeId);
 		this.pi.sendMessage({
 			customType: CONTEMPLATOR_SUGGESTION,
 			content: `Background contemplator probe (advisory):\n${question}\n\nReferenced memories can be reviewed using the recall tool.`,
@@ -981,6 +1012,7 @@ export class Contemplator {
 			triggerTurn: "omitted",
 			source,
 		});
+		return probeId;
 	}
 
 	private queueStructuralReview(options: QueueStructuralReviewOptions): void {

package/src/agents/observer/agent.ts

@@ -26,6 +26,7 @@ interface RunObserverArgs {
 	thinkingLevel?: ModelThinkingLevel;
 	recordUsage?: (usage: LlmUsageInput) => void;
 	onProgress?: () => void;
+	onMessages?: (messages: readonly AgentMessage[]) => void;
 }
 
 const RelevanceSchema = Type.Union([
@@ -223,6 +224,10 @@ IMPORTANT: Now call record_observations to record the useful new observations fr
 			messages: history.slice(),
 			tools: [recordObservations as AgentTool<any>, doneTool],
 		};
+		// Publish a live launch-local transcript for /om:view observer. Keep an
+		// invocation-local list because agentLoop owns its internal context copy.
+		let liveMessages: AgentMessage[] = [...history, prompt];
+		args.onMessages?.(liveMessages.slice());
 		const invocationConfig: AgentLoopConfig = afterLength && reasoning
 			? { ...baseConfig, reasoning: "minimal" }
 			: baseConfig;
@@ -230,7 +235,17 @@ IMPORTANT: Now call record_observations to record the useful new observations fr
 		for await (const event of stream) {
 			args.onProgress?.();
 			logAgentStreamError("observer", event);
-			const message = (event as { message?: { role?: string; stopReason?: string; errorMessage?: string } }).message;
+			const typedEvent = event as { type?: string; message?: AgentMessage & { role?: string; stopReason?: string; errorMessage?: string } };
+			const message = typedEvent.message;
+			if (message && message !== prompt && message.role !== "user") {
+				if (typedEvent.type === "message_start") liveMessages.push(message);
+				else if (typedEvent.type === "message_update" || typedEvent.type === "message_end") {
+					const index = liveMessages.map((item) => item.role).lastIndexOf(message.role);
+					if (index >= 0) liveMessages[index] = message;
+					else liveMessages.push(message);
+				}
+				args.onMessages?.(liveMessages.slice());
+			}
 			if (message?.role === "assistant" && ["error", "aborted", "length"].includes(message.stopReason ?? "")) {
 				terminalFailure = { stopReason: message.stopReason!, errorMessage: message.errorMessage };
 			}
@@ -238,6 +253,8 @@ IMPORTANT: Now call record_observations to record the useful new observations fr
 		const result = await stream.result();
 		if (!Array.isArray(result)) return;
 		history.push(...result);
+		liveMessages = history.slice();
+		args.onMessages?.(liveMessages);
 		for (const message of result) {
 			if (message.role === "assistant" && ["error", "aborted", "length"].includes(message.stopReason ?? "")) {
 				terminalFailure = { stopReason: message.stopReason, errorMessage: message.errorMessage };

package/src/commands/contemplator-view.ts

@@ -65,6 +65,8 @@ function liveStateLine(state: ContemplatorRunState): string {
 	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"
 		? "waiting for observer backlog"
+		: state.waitingFor === "probe"
+			? "waiting for queued probe delivery"
 		: state.waitingFor === "memories"
 			? "waiting for memory threshold"
 			: state.waitingFor === "responses"
@@ -76,7 +78,7 @@ function liveStateLine(state: ContemplatorRunState): string {
 					: state.waitingFor === "passive"
 						? "passive mode"
 						: "idle";
-	return `LIVE · ${reason} · ${pending} · ${state.responsesSinceRun} primary responses since last run\n${timing}${error}`;
+	return `LIVE · ${reason} · ${pending} · ${state.responsesSinceRun} primary responses since cooldown anchor\n${timing}${error}`;
 }
 
 export function renderContemplator(entries: Entry[], state?: ContemplatorRunState): string {

package/src/commands/observer-view.ts

@@ -0,0 +1,59 @@
+import type { ObserverRunView } from "../runtime.js";
+
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+
+type StoredMessage = { role?: unknown; content?: unknown };
+type ContentPart = { type?: unknown; text?: unknown; thinking?: unknown; name?: unknown; arguments?: unknown; content?: unknown };
+
+function renderValue(value: unknown): string {
+	if (typeof value === "string") return value;
+	if (value === undefined || value === null) return "";
+	return JSON.stringify(value, null, 2);
+}
+
+function renderContent(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return renderValue(content);
+	return content.map((part: ContentPart) => {
+		if (part.type === "text") return typeof part.text === "string" ? part.text : "";
+		if (part.type === "thinking") {
+			const thinking = typeof part.thinking === "string" ? part.thinking : typeof part.text === "string" ? part.text : renderValue(part);
+			return `[thinking]\n${thinking}`;
+		}
+		if (part.type === "toolCall" || part.type === "tool_use" || part.type === "toolUse") {
+			const name = typeof part.name === "string" ? part.name : "unknown tool";
+			return `[tool call: ${name}${part.arguments === undefined ? "" : ` ${renderValue(part.arguments)}`}]`;
+		}
+		if (part.type === "toolResult" || part.type === "tool_result") return `[tool result]\n${renderValue(part.content)}`;
+		return `[${String(part.type ?? "content")}] ${renderValue(part)}`;
+	}).filter(Boolean).join("\n");
+}
+
+function estimateTokens(value: unknown): number {
+	return Math.max(1, Math.ceil(JSON.stringify(value).length / 4));
+}
+
+/** Render the currently active observer chunk, or the most recently completed chunk. */
+export function renderObserver(run: ObserverRunView | undefined, now = Date.now()): string {
+	if (!run) return `${DIM}OBSERVER${RESET}\n\n${DIM}Observer has not run yet during this launch.${RESET}`;
+	const messages = run.messages.filter((message): message is StoredMessage => !!message && typeof message === "object");
+	const totalTokens = messages.reduce((sum, message) => sum + estimateTokens(message), 0);
+	const elapsedMs = Math.max(0, (run.completedAt ?? now) - run.startedAt);
+	const lines = [
+		`${DIM}OBSERVER · ${run.status} · ${messages.length} messages · ~${totalTokens.toLocaleString()} estimated transcript tokens${RESET}`,
+		`${DIM}Chunk ~${run.chunkTokens.toLocaleString()} tokens · backlog at start ~${run.backlogTokens.toLocaleString()} tokens · ${run.sourceEntryIds.length} source entr${run.sourceEntryIds.length === 1 ? "y" : "ies"}${RESET}`,
+		`${DIM}Started ${new Date(run.startedAt).toISOString()} · ${run.completedAt === undefined ? `running for ${Math.floor(elapsedMs / 1000)}s` : `ended ${new Date(run.completedAt).toISOString()} after ${Math.floor(elapsedMs / 1000)}s`}${RESET}`,
+		"",
+	];
+	if (messages.length === 0) lines.push(`${DIM}(no observer messages captured yet)${RESET}`);
+	for (const [index, message] of messages.entries()) {
+		if (index > 0) lines.push("");
+		const role = typeof message.role === "string" ? message.role : "unknown";
+		lines.push(`${DIM}── ${role} · ~${estimateTokens(message).toLocaleString()} tokens ──${RESET}`);
+		lines.push(renderContent(message.content) || `${DIM}(empty message)${RESET}`);
+	}
+	if (run.summary) lines.push("", `${DIM}── Completion summary ──${RESET}`, run.summary);
+	if (run.error) lines.push("", `${DIM}── Failure ──${RESET}`, run.error);
+	return lines.join("\n");
+}

package/src/commands/status.ts

@@ -43,6 +43,7 @@ function formatRunAge(timestamp: number): string {
 function contemplatorWaitingLabel(waitingFor: Runtime["contemplatorState"]["waitingFor"]): string {
 	switch (waitingFor) {
 		case "observer": return "waiting for observer backlog";
+		case "probe": return "waiting for queued probe delivery";
 		case "memories": return "waiting for memory threshold";
 		case "responses": return "waiting for response spacing";
 		case "ready": return "ready to launch";
@@ -142,8 +143,8 @@ export function registerStatusCommand(pi: ExtensionAPI, runtime: Runtime): void
 			}
 
 			lines.push("", "── Last worker runs ──");
-			lines.push(`Last observer start:     ${runtime.lastObserverStartedAt === undefined ? "not run this launch" : formatRunAge(runtime.lastObserverStartedAt)}`);
-			lines.push(`Last observer end:       ${runtime.lastObserverCompletedAt === undefined ? "not completed this launch" : formatRunAge(runtime.lastObserverCompletedAt)}`);
+			lines.push(`Observer chunk start:    ${runtime.lastObserverStartedAt === undefined ? "not run this launch" : formatRunAge(runtime.lastObserverStartedAt)}`);
+			lines.push(`Observer chunk end:      ${runtime.lastObserverCompletedAt === undefined ? runtime.lastObserverRun?.status === "running" ? "running" : "not completed this launch" : formatRunAge(runtime.lastObserverCompletedAt)}`);
 			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)}`);

package/src/commands/view.ts

@@ -4,6 +4,7 @@ import { copyTextToClipboard } from "../clipboard.js";
 import { renderContemplator, stripAnsi } from "./contemplator-view.js";
 import { renderReviewer } from "./reviewer-view.js";
 import { renderSummarizer } from "./summarizer-view.js";
+import { renderObserver } from "./observer-view.js";
 import { executeRecall, formatRecallResultForTui } from "../tools/recall-observation.js";
 import {
 	chronologicalMemories,
@@ -76,7 +77,7 @@ export function registerViewCommand(
 
 	pi.registerCommand("om:view", {
 		description:
-			"Print and copy pi-contemplator memory content (visible, full, memory, contemplator, summarizer, reviewer, or reviews)",
+			"Print and copy pi-contemplator memory content (visible, full, memory, contemplator, observer, summarizer, reviewer, or reviews)",
 		handler: async (args, ctx) => {
 			runtime.ensureConfig(ctx.cwd);
 			const entries = ctx.sessionManager.getBranch() as Entry[];
@@ -116,6 +117,18 @@ export function registerViewCommand(
 				return;
 			}
 
+			if (mode === "observer") {
+				const output = renderObserver(runtime.lastObserverRun);
+				const copied = await copyToClipboard(stripAnsi(output)).catch(() => false);
+				ctx.ui.notify(
+					`${output}
+
+${copied ? "Copied /om:view observer output to clipboard." : "Warning: failed to copy /om:view observer output to clipboard."}`,
+					"info",
+				);
+				return;
+			}
+
 			if (mode === "summarizer") {
 				const output = renderSummarizer(runtime.lastSummarizerRun);
 				const copied = await copyToClipboard(stripAnsi(output)).catch(() => false);
@@ -154,7 +167,7 @@ export function registerViewCommand(
 			}
 
 			if (mode && mode !== "visible") {
-				ctx.ui.notify("Usage: /om:view [visible|full|memory <id>|contemplator|summarizer|reviewer|reviews]", "info");
+				ctx.ui.notify("Usage: /om:view [visible|full|memory <id>|contemplator|observer|summarizer|reviewer|reviews]", "info");
 				return;
 			}
 

package/src/config.ts

@@ -61,7 +61,7 @@ export interface Config {
 	reviewerModel?: ConfiguredModel;
 	contemplatorMinNewObservations: number;
 	contemplatorMinNewSummaries: number;
-	/** Minimum completed primary-model responses between contemplator runs. */
+	/** Minimum primary-model responses after contemplator completion, or after delivery of its probe, before the next run. */
 	contemplatorMinTurns: number;
 	/** Stateless loss-aware summarizer for the old memory pool. */
 	summarizerEnabled: boolean;

package/src/hooks/consolidation-trigger.ts

@@ -227,7 +227,6 @@ export async function runConsolidationPipeline(
 
 	const beforeFold = foldLedger(ctx.sessionManager.getBranch() as Entry[]);
 	runtime.consolidationPhase = "observer";
-	runtime.lastObserverStartedAt = Date.now();
 	try {
 		// A large backlog is drained in bounded, oldest-first chunks. The normal
 		// trigger threshold controls when the batch stops; a static compaction
@@ -253,8 +252,6 @@ export async function runConsolidationPipeline(
 	} catch (error) {
 		debugLog("observer.error", { errorMessage: runtime.recordConsolidationStageError(ctx, "observer", error) });
 		return;
-	} finally {
-		runtime.lastObserverCompletedAt = Date.now();
 	}
 	const afterFold = foldLedger(ctx.sessionManager.getBranch() as Entry[]);
 	const beforeIds = new Set(beforeFold.observations.map((item) => item.id));
@@ -477,6 +474,20 @@ async function runObserverStage(
 		priorObservations: priorObservations.length,
 	});
 
+	const observerStartedAt = Date.now();
+	runtime.lastObserverStartedAt = observerStartedAt;
+	// Clear the previous end when a new chunk starts so /om:status never pairs
+	// this chunk's start with the preceding chunk's completion.
+	runtime.lastObserverCompletedAt = undefined;
+	runtime.lastObserverRun = {
+		startedAt: observerStartedAt,
+		status: "running",
+		messages: [],
+		chunkTokens,
+		backlogTokens: tokens,
+		sourceEntryIds: sourceEntryIds.slice(),
+	};
+	let acceptsObserverMessages = true;
 	let observations;
 	let failedMessage: string | undefined;
 	const observerWatchdog = createWorkerStallWatchdog("observer");
@@ -493,6 +504,17 @@ async function runObserverStage(
 			thinkingLevel: runtime.config.model?.thinking ?? "low",
 			recordUsage: (usage) => runtime.recordAgentUsage(usage),
 			onProgress: observerWatchdog.progress,
+			onMessages: (messages) => {
+				if (!acceptsObserverMessages || options.contextGeneration !== undefined && options.contextGeneration !== runtime.getContextGeneration()) return;
+				runtime.lastObserverRun = {
+					startedAt: observerStartedAt,
+					status: "running",
+					messages: messages.slice(),
+					chunkTokens,
+					backlogTokens: tokens,
+					sourceEntryIds: sourceEntryIds.slice(),
+				};
+			},
 			signal: observerWatchdog.signal,
 		}));
 	} catch (error) {
@@ -509,8 +531,19 @@ async function runObserverStage(
 			chunkTokens,
 		});
 		observations = undefined;
+		if (runtime.lastObserverRun?.startedAt === observerStartedAt) {
+			runtime.lastObserverRun = { ...runtime.lastObserverRun, status: "failed", error: failedMessage };
+		}
 	} finally {
+		acceptsObserverMessages = false;
 		observerWatchdog.dispose();
+		if (options.contextGeneration === undefined || options.contextGeneration === runtime.getContextGeneration()) {
+			const completedAt = Date.now();
+			runtime.lastObserverCompletedAt = completedAt;
+			if (runtime.lastObserverRun?.startedAt === observerStartedAt) {
+				runtime.lastObserverRun = { ...runtime.lastObserverRun, completedAt };
+			}
+		}
 	}
 	if (options.contextGeneration !== undefined && options.contextGeneration !== runtime.getContextGeneration()) {
 		debugLog("observer.stale", { reason: "session_or_branch_changed" });
@@ -531,6 +564,15 @@ async function runObserverStage(
 		});
 	}
 	const accepted = observations ?? [];
+	if (!failedMessage && runtime.lastObserverRun?.startedAt === observerStartedAt) {
+		runtime.lastObserverRun = {
+			...runtime.lastObserverRun,
+			status: "completed",
+			summary: accepted.length > 0
+				? `${accepted.length} observation${accepted.length === 1 ? "" : "s"} recorded; chunk covered through ${effectiveCoversUpToId}.`
+				: `No observations recorded; chunk covered through ${effectiveCoversUpToId}.`,
+		};
+	}
 	const data = buildObservationsRecordedData(accepted, effectiveCoversUpToId);
 	if (!data) return "continue";
 	debugLog(failedMessage ? "observer.failed_coverage" : accepted.length > 0 ? "observer.records" : "observer.coverage_only", {

package/src/runtime.ts

@@ -56,6 +56,18 @@ export interface MemoryUpdateCtx extends LaunchCtx {
 
 export type SettingsUpdate = Partial<SessionSettings>;
 
+export interface ObserverRunView {
+	startedAt: number;
+	completedAt?: number;
+	status: "running" | "completed" | "failed";
+	messages: readonly unknown[];
+	chunkTokens: number;
+	backlogTokens: number;
+	sourceEntryIds: readonly string[];
+	summary?: string;
+	error?: string;
+}
+
 export interface SummarizerRunView {
 	startedAt: number;
 	completedAt?: number;
@@ -70,9 +82,9 @@ export interface ContemplatorRunState {
 	pendingObservations: number;
 	pendingSummaries: number;
 	pendingReviews: number;
-	/** Completed primary-model responses since the previous contemplator run. */
+	/** Completed primary-model responses since the current completion/probe-delivery spacing anchor. */
 	responsesSinceRun: number;
-	waitingFor: "disabled" | "passive" | "observer" | "memories" | "responses" | "ready" | "running" | "idle";
+	waitingFor: "disabled" | "passive" | "observer" | "probe" | "memories" | "responses" | "ready" | "running" | "idle";
 	lastStartedAt?: number;
 	lastCompletedAt?: number;
 	lastError?: string;
@@ -187,6 +199,8 @@ export class Runtime {
 	lastObserverCompletedAt: number | undefined;
 	lastSummarizerStartedAt: number | undefined;
 	lastSummarizerCompletedAt: number | undefined;
+	/** Current or most recent observer chunk transcript in this launch/session context. */
+	lastObserverRun: ObserverRunView | undefined;
 	/** Most recent summarizer transcript in this extension launch/session context. */
 	lastSummarizerRun: SummarizerRunView | undefined;
 	/** Launch-local liveness and trigger diagnostics published by the contemplator. */
@@ -277,6 +291,7 @@ export class Runtime {
 		this.lastObserverCompletedAt = undefined;
 		this.lastSummarizerStartedAt = undefined;
 		this.lastSummarizerCompletedAt = undefined;
+		this.lastObserverRun = undefined;
 		this.lastSummarizerRun = undefined;
 		this.contemplatorState = {
 			running: false,