@matthewfl/pi-contemplator 0.0.9 → 0.1.0

package/src/agents/summarizer/sampling.ts

@@ -0,0 +1,80 @@
+import { estimateStringTokens } from "../../tokens.js";
+import type { Observation, Summary } from "../../session-ledger/index.js";
+
+export type SummarizerMemory =
+	| { kind: "observation"; memory: Observation }
+	| { kind: "summary"; memory: Summary };
+
+export type SummarizerSample = {
+	memories: SummarizerMemory[];
+	sampled: boolean;
+	eligibleCount: number;
+	selectedCount: number;
+	eligibleTokens: number;
+	selectedTokens: number;
+	budgetTokens: number;
+};
+
+export type SummarizerSamplingArgs = {
+	memories: SummarizerMemory[];
+	/** Maximum rendered old-memory input tokens before sampling. */
+	samplingThresholdTokens?: number;
+	random?: () => number;
+};
+
+type Candidate = {
+	item: SummarizerMemory;
+	tokens: number;
+	weight: number;
+};
+
+export function renderSummarizerMemory(item: SummarizerMemory): string {
+	if (item.kind === "observation") {
+		const memory = item.memory;
+		return `[${memory.id}] observation ${memory.timestamp} relevance=${memory.relevance}: ${memory.content}`;
+	}
+	return `[${item.memory.id}] summary ${item.memory.timestamp} sources=[${item.memory.sourceMemoryIds.join(", ")}]: ${item.memory.content}`;
+}
+
+function tokenCost(item: SummarizerMemory): number {
+	return Math.max(1, estimateStringTokens(renderSummarizerMemory(item)) + 4);
+}
+
+/** Weighted random order without replacement. Weight is exactly inverse length. */
+function weightedOrder(candidates: Candidate[], random: () => number): Candidate[] {
+	return candidates
+		.map((candidate) => ({ candidate, priority: -Math.log(Math.max(Number.EPSILON, random())) / candidate.weight }))
+		.sort((a, b) => a.priority - b.priority || a.candidate.item.memory.id.localeCompare(b.candidate.item.memory.id))
+		.map(({ candidate }) => candidate);
+}
+
+export function sampleSummarizerMemories(args: SummarizerSamplingArgs): SummarizerSample {
+	const random = args.random ?? Math.random;
+	const budgetTokens = Math.max(1, Math.floor(args.samplingThresholdTokens ?? 60_000));
+	const candidates = args.memories.map((item): Candidate => {
+		const tokens = tokenCost(item);
+		return { item, tokens, weight: 1 / tokens };
+	});
+	const eligibleTokens = candidates.reduce((sum, candidate) => sum + candidate.tokens, 0);
+	const sampled = eligibleTokens > budgetTokens;
+	const selected = sampled ? [] as Candidate[] : candidates;
+	if (sampled) {
+		let used = 0;
+		for (const candidate of weightedOrder(candidates, random)) {
+			if (candidate.tokens > budgetTokens - used) continue;
+			selected.push(candidate);
+			used += candidate.tokens;
+		}
+	}
+	const selectedIds = new Set(selected.map((candidate) => candidate.item.memory.id));
+	const memories = args.memories.filter((item) => selectedIds.has(item.memory.id));
+	return {
+		memories,
+		sampled,
+		eligibleCount: candidates.length,
+		selectedCount: selected.length,
+		eligibleTokens,
+		selectedTokens: selected.reduce((sum, candidate) => sum + candidate.tokens, 0),
+		budgetTokens,
+	};
+}

package/src/commands/contemplator-view.ts

@@ -1,3 +1,4 @@
+import type { ContemplatorRunState } from "../runtime.js";
 import type { Entry } from "../session-ledger/index.js";
 
 const CONTEMPLATOR_MESSAGE = "om.contemplator.message";
@@ -57,7 +58,26 @@ function renderMessage(message: StoredMessage, compacted: boolean): string {
 	return `${DIM}── ${role}${marker} · ~${tokens} tokens ──${RESET}\n${renderContent(message.content) || `${DIM}(empty message)${RESET}`}`;
 }
 
-export function renderContemplator(entries: Entry[]): string {
+function liveStateLine(state: ContemplatorRunState): string {
+	const pending = `${state.pendingObservations} observations / ${state.pendingSummaries} summaries / ${state.pendingReviews} reviews pending`;
+	const timing = `Last start: ${state.lastStartedAt === undefined ? "not run this launch" : new Date(state.lastStartedAt).toISOString()} · Last end: ${state.lastCompletedAt === undefined ? "not completed this launch" : new Date(state.lastCompletedAt).toISOString()}`;
+	const error = state.lastError ? `\nLast error: ${state.lastError}` : "";
+	if (state.running) return `LIVE · running for ${Math.max(0, Math.floor((Date.now() - (state.lastStartedAt ?? Date.now())) / 60_000))}m · ${pending}\n${timing}${error}`;
+	const reason = state.waitingFor === "memories"
+		? "waiting for memory threshold"
+		: state.waitingFor === "responses"
+			? "waiting for response spacing"
+			: state.waitingFor === "ready"
+				? "ready to launch"
+				: state.waitingFor === "disabled"
+					? "disabled"
+					: state.waitingFor === "passive"
+						? "passive mode"
+						: "idle";
+	return `LIVE · ${reason} · ${pending} · ${state.responsesSinceRun} primary responses since last run\n${timing}${error}`;
+}
+
+export function renderContemplator(entries: Entry[], state?: ContemplatorRunState): string {
 	const messages: Array<{ message: StoredMessage; compacted: boolean }> = [];
 	const suggestions: Array<{ suggestion: string; delivered: boolean }> = [];
 	const reviews: Array<{ requestId: string; scope: string; outcome: string; memoryId?: string }> = [];
@@ -102,6 +122,7 @@ export function renderContemplator(entries: Entry[]): string {
 	const totalTokens = messages.reduce((total, item) => total + estimateTokens(item.message), 0);
 	const lines = [
 		`${DIM}CONTEMPLATOR · ${messages.length} messages · ~${totalTokens} estimated tokens${RESET}`,
+		...(state ? [`${DIM}${liveStateLine(state)}${RESET}`] : []),
 		"",
 	];
 	if (messages.length === 0) {

package/src/commands/settings.ts

@@ -9,8 +9,8 @@ type ModelRegistryLike = {
 	getAvailable(): Array<{ provider: string; id: string }>;
 	getAll(): Array<{ provider: string; id: string }>;
 };
-type NumberSetting = "observeAfterTokens" | "reflectAfterTokens" | "compactAfterTokens" | "observerChunkMaxTokens" | "observationsPoolMaxTokens" | "observationsPoolTargetTokens" | "agentMaxTurns" | "contemplatorMinNewObservations" | "contemplatorMinNewReflections" | "contemplatorMinTurns";
-type BooleanSetting = "contemplatorEnabled" | "showContemplatorMessages" | "reviewerEnabled" | "compactionObserverEnabled" | "showWorkerNotifications" | "passive" | "debugLog";
+type NumberSetting = "observeAfterTokens" | "compactAfterTokens" | "observerChunkMaxTokens" | "newMemoryPoolMaxTokens" | "oldMemoryPoolTargetTokens" | "agentMaxTurns" | "contemplatorMinNewObservations" | "contemplatorMinNewSummaries" | "contemplatorMinTurns" | "summarizerRetriggerTokens" | "summarizerSamplingThresholdTokens";
+type BooleanSetting = "contemplatorEnabled" | "showContemplatorMessages" | "reviewerEnabled" | "summarizerEnabled" | "compactionObserverEnabled" | "showWorkerNotifications" | "passive" | "debugLog";
 
 function modelLabel(model: ConfiguredModel | undefined): string {
 	return model ? `${model.provider}/${model.id}` : "current session model";
@@ -20,9 +20,12 @@ function branch(ctx: ExtensionContext): readonly unknown[] {
 	return ctx.sessionManager.getBranch() as readonly unknown[];
 }
 
-function appendSettings(pi: ExtensionAPI, runtime: Runtime, settings: SessionSettings): void {
+function appendSettings(pi: ExtensionAPI, runtime: Runtime, settings: SessionSettings, ctx?: ExtensionContext): void {
 	runtime.setSessionSettings(settings);
 	pi.appendEntry(OM_SETTINGS, { version: 1, ...settings });
+	// Settings that affect worker eligibility should take effect immediately,
+	// rather than waiting for an unrelated observer batch or session restart.
+	if (ctx) runtime.notifySettingsUpdate(ctx, settings);
 }
 
 function hasOverride(settings: SessionSettings, key: string): boolean {
@@ -33,7 +36,12 @@ function scalarLabel(runtime: Runtime, key: NumberSetting | BooleanSetting | "co
 	const current = runtime.config[key];
 	const defaultValue = runtime.getDefaultConfig()[key];
 	const renderedDefault = defaultValue === undefined ? "derived" : String(defaultValue);
-	return hasOverride(runtime.getSessionSettings(), key) ? String(current) : `default (${renderedDefault})`;
+	return hasOverride(runtime.getSessionSettings(), key) ? String(current) : `${renderedDefault} (default)`;
+}
+
+function extensionEnabledLabel(runtime: Runtime): string {
+	const enabled = !runtime.config.passive;
+	return hasOverride(runtime.getSessionSettings(), "passive") ? String(enabled) : `${enabled} (default)`;
 }
 
 interface ModelOption extends SelectItem {
@@ -124,28 +132,17 @@ async function chooseModel(ctx: ExtensionContext, current: ConfiguredModel | und
 }
 
 async function editNumber(ctx: ExtensionContext, runtime: Runtime, key: NumberSetting, title: string): Promise<number | undefined> {
-	const value = await ctx.ui.input(`${title} (current: ${scalarLabel(runtime, key)})`, "positive integer; blank cancels");
+	const requirement = "positive integer";
+	const value = await ctx.ui.input(`${title} (current: ${scalarLabel(runtime, key)})`, `${requirement}; blank cancels`);
 	if (value === undefined || value.trim() === "") return undefined;
 	const parsed = Number(value.trim());
 	if (!Number.isInteger(parsed) || parsed <= 0) {
-		ctx.ui.notify("Value must be a positive integer.", "warning");
+		ctx.ui.notify(`Value must be a ${requirement}.`, "warning");
 		return undefined;
 	}
 	return parsed;
 }
 
-function validObservationPoolOverride(ctx: ExtensionContext, runtime: Runtime, key: NumberSetting, value: number): boolean {
-	if (key === "observationsPoolMaxTokens" && value <= runtime.config.observationsPoolTargetTokens) {
-		ctx.ui.notify("Observation pool max must be greater than the current target. Lower the target first.", "warning");
-		return false;
-	}
-	if (key === "observationsPoolTargetTokens" && value >= runtime.config.observationsPoolMaxTokens) {
-		ctx.ui.notify("Observation pool target must be less than the current maximum.", "warning");
-		return false;
-	}
-	return true;
-}
-
 export function registerSettingsCommand(pi: ExtensionAPI, runtime: Runtime): void {
 	const restoreSettings = (_event: unknown, ctx: ExtensionContext) => {
 		runtime.ensureConfig(ctx.cwd);
@@ -155,19 +152,24 @@ export function registerSettingsCommand(pi: ExtensionAPI, runtime: Runtime): voi
 	pi.on("session_tree", restoreSettings);
 
 	pi.registerCommand("om:settings", {
-		description: "Configure observational memory for this session",
+		description: "Configure pi-contemplator for this session",
 		handler: async (args, ctx) => {
 		runtime.ensureConfig(ctx.cwd);
 		runtime.restoreSessionSettings(branch(ctx));
 		const argument = typeof args === "string" ? args.trim().toLowerCase() : "";
 		if (argument === "on" || argument === "off") {
 			appendSettings(pi, runtime, { contemplatorEnabled: argument === "on" });
-			ctx.ui.notify(`Contemplation: ${argument === "on" ? "enabled" : "disabled"} for this session.`, "info");
+			ctx.ui.notify(`Contemplator: ${argument === "on" ? "enabled" : "disabled"} for this session.`, "info");
 			return;
 		}
 		if (argument === "compaction on" || argument === "compaction off") {
 			appendSettings(pi, runtime, { compactionObserverEnabled: argument.endsWith("on") });
-			ctx.ui.notify(`Compaction observer: ${argument.endsWith("on") ? "enabled" : "disabled"} for this session.`, "info");
+			ctx.ui.notify(`Observe source during compaction: ${argument.endsWith("on") ? "enabled" : "disabled"} for this session.`, "info");
+			return;
+		}
+		if (argument === "summarizer on" || argument === "summarizer off") {
+			appendSettings(pi, runtime, { summarizerEnabled: argument.endsWith("on") }, ctx);
+			ctx.ui.notify(`Summarizer: ${argument.endsWith("on") ? "enabled" : "disabled"} for this session.`, "info");
 			return;
 		}
 		if (argument === "reviewer on" || argument === "reviewer off") {
@@ -181,81 +183,83 @@ export function registerSettingsCommand(pi: ExtensionAPI, runtime: Runtime): voi
 			return;
 		}
 		if (argument) {
-			ctx.ui.notify("Usage: /om:settings [on|off|messages on|messages off|reviewer on|reviewer off|compaction on|compaction off]", "info");
+			ctx.ui.notify("Usage: /om:settings [on|off|messages on|messages off|summarizer on|summarizer off|reviewer on|reviewer off|compaction on|compaction off]", "info");
 			return;
 		}
 
 		while (true) {
 			const settings = runtime.getSessionSettings();
-			const choice = await ctx.ui.select("Observational memory settings (session overrides)", [
-				`Contemplation: ${scalarLabel(runtime, "contemplatorEnabled")}`,
-				`Contemplation model: ${hasOverride(settings, "contemplatorModel") ? modelLabel(runtime.config.contemplatorModel) : `default (${modelLabel(runtime.getDefaultConfig().contemplatorModel)})`}`,
-				`Contemplator messages visible: ${scalarLabel(runtime, "showContemplatorMessages")}`,
-				`Structural reviewer: ${scalarLabel(runtime, "reviewerEnabled")}`,
-				`Structural reviewer model: ${hasOverride(settings, "reviewerModel") ? modelLabel(runtime.config.reviewerModel) : `default (${modelLabel(runtime.getDefaultConfig().reviewerModel)})`}`,
-				`Compaction observer: ${scalarLabel(runtime, "compactionObserverEnabled")}`,
-				`Memory worker model: ${hasOverride(settings, "model") ? modelLabel(runtime.config.model) : `default (${modelLabel(runtime.getDefaultConfig().model)})`}`,
-				`Observation threshold: ${scalarLabel(runtime, "observeAfterTokens")}`,
-				`Reflection threshold: ${scalarLabel(runtime, "reflectAfterTokens")}`,
-				`Compaction threshold: ${scalarLabel(runtime, "compactAfterTokens")}`,
-				`Compaction mode: ${hasOverride(settings, "compactAfterTokensMode") ? runtime.config.compactAfterTokensMode : `default (${runtime.getDefaultConfig().compactAfterTokensMode})`}`,
-				`Compaction ratio: ${hasOverride(settings, "compactAfterTokensRatio") ? runtime.config.compactAfterTokensRatio : `default (${runtime.getDefaultConfig().compactAfterTokensRatio})`}`,
-				`Observer chunk limit: ${scalarLabel(runtime, "observerChunkMaxTokens")}`,
-				`Observation pool max: ${scalarLabel(runtime, "observationsPoolMaxTokens")}`,
-				`Observation pool target: ${scalarLabel(runtime, "observationsPoolTargetTokens")}`,
-				`Worker max turns: ${scalarLabel(runtime, "agentMaxTurns")}`,
-				`Contemplation observation trigger: ${scalarLabel(runtime, "contemplatorMinNewObservations")}`,
-				`Contemplation reflection trigger: ${scalarLabel(runtime, "contemplatorMinNewReflections")}`,
-				`Contemplation turn interval: ${scalarLabel(runtime, "contemplatorMinTurns")}`,
+			const choice = await ctx.ui.select("pi-contemplator settings (session overrides)", [
+				`Pi-contemplator Enabled: ${extensionEnabledLabel(runtime)}`,
+				`Contemplator enabled: ${scalarLabel(runtime, "contemplatorEnabled")}`,
+				`Contemplator model: ${hasOverride(settings, "contemplatorModel") ? modelLabel(runtime.config.contemplatorModel) : `${modelLabel(runtime.getDefaultConfig().contemplatorModel)} (default)`}`,
+				`Show contemplator messages: ${scalarLabel(runtime, "showContemplatorMessages")}`,
+				`Contemplator new-observation trigger (count): ${scalarLabel(runtime, "contemplatorMinNewObservations")}`,
+				`Contemplator new-summary trigger (count): ${scalarLabel(runtime, "contemplatorMinNewSummaries")}`,
+				`Contemplator response spacing (count): ${scalarLabel(runtime, "contemplatorMinTurns")}`,
+				`Summarizer enabled: ${scalarLabel(runtime, "summarizerEnabled")}`,
+				`New memory pool protection budget (tokens): ${scalarLabel(runtime, "newMemoryPoolMaxTokens")}`,
+				`Old memory pool target (tokens, advisory): ${scalarLabel(runtime, "oldMemoryPoolTargetTokens")}`,
+				`Summarizer old-pool retrigger growth (tokens): ${scalarLabel(runtime, "summarizerRetriggerTokens")}`,
+				`Summarizer input cap before sampling (tokens): ${scalarLabel(runtime, "summarizerSamplingThresholdTokens")}`,
+				`Structural reviewer enabled: ${scalarLabel(runtime, "reviewerEnabled")}`,
+				`Structural reviewer model: ${hasOverride(settings, "reviewerModel") ? modelLabel(runtime.config.reviewerModel) : `${modelLabel(runtime.getDefaultConfig().reviewerModel)} (default)`}`,
+				`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 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)`}`,
+				`Automatic compaction source-backlog context ratio: ${hasOverride(settings, "compactAfterTokensRatio") ? runtime.config.compactAfterTokensRatio : `${runtime.getDefaultConfig().compactAfterTokensRatio} (default)`}`,
 				`Worker notifications: ${scalarLabel(runtime, "showWorkerNotifications")}`,
-				`Passive mode: ${scalarLabel(runtime, "passive")}`,
 				`Debug logging: ${scalarLabel(runtime, "debugLog")}`,
 				"Done",
 			]);
 			if (!choice || choice === "Done") return;
-			if (choice.startsWith("Contemplation:")) appendSettings(pi, runtime, { contemplatorEnabled: !runtime.config.contemplatorEnabled });
-			else if (choice.startsWith("Contemplator messages visible:")) appendSettings(pi, runtime, { showContemplatorMessages: !runtime.config.showContemplatorMessages });
-			else if (choice.startsWith("Structural reviewer:")) appendSettings(pi, runtime, { reviewerEnabled: !runtime.config.reviewerEnabled });
-			else if (choice.startsWith("Compaction observer:")) appendSettings(pi, runtime, { compactionObserverEnabled: !runtime.config.compactionObserverEnabled });
+			if (choice.startsWith("Pi-contemplator Enabled:")) appendSettings(pi, runtime, { passive: !runtime.config.passive });
+			else if (choice.startsWith("Contemplator enabled:")) appendSettings(pi, runtime, { contemplatorEnabled: !runtime.config.contemplatorEnabled });
+			else if (choice.startsWith("Summarizer enabled:")) appendSettings(pi, runtime, { summarizerEnabled: !runtime.config.summarizerEnabled }, ctx);
+			else if (choice.startsWith("Show contemplator messages:")) appendSettings(pi, runtime, { showContemplatorMessages: !runtime.config.showContemplatorMessages });
+			else if (choice.startsWith("Structural reviewer enabled:")) appendSettings(pi, runtime, { reviewerEnabled: !runtime.config.reviewerEnabled });
+			else if (choice.startsWith("Observe source during compaction:")) appendSettings(pi, runtime, { compactionObserverEnabled: !runtime.config.compactionObserverEnabled });
 			else if (choice.startsWith("Worker notifications:")) appendSettings(pi, runtime, { showWorkerNotifications: !runtime.config.showWorkerNotifications });
-			else if (choice.startsWith("Passive mode:")) appendSettings(pi, runtime, { passive: !runtime.config.passive });
 			else if (choice.startsWith("Debug logging:")) appendSettings(pi, runtime, { debugLog: !runtime.config.debugLog });
-			else if (choice.startsWith("Contemplation model:")) {
-				const model = await chooseModel(ctx, runtime.config.contemplatorModel, "Contemplation model");
+			else if (choice.startsWith("Contemplator model:")) {
+				const model = await chooseModel(ctx, runtime.config.contemplatorModel, "Contemplator model");
 				if (model !== undefined) appendSettings(pi, runtime, { contemplatorModel: model });
 			} else if (choice.startsWith("Structural reviewer model:")) {
 				const model = await chooseModel(ctx, runtime.config.reviewerModel, "Structural reviewer model");
 				if (model !== undefined) appendSettings(pi, runtime, { reviewerModel: model });
-			} else if (choice.startsWith("Memory worker model:")) {
-				const model = await chooseModel(ctx, runtime.config.model, "Memory worker model");
+			} else if (choice.startsWith("Observer and summarizer model:")) {
+				const model = await chooseModel(ctx, runtime.config.model, "Observer and summarizer model");
 				if (model !== undefined) appendSettings(pi, runtime, { model });
-			} else if (choice.startsWith("Compaction mode:")) {
-				const mode = await ctx.ui.select("Compaction threshold mode", ["calibrated", "ratio"]);
+			} else if (choice.startsWith("Automatic compaction threshold mode:")) {
+				const mode = await ctx.ui.select("Automatic compaction threshold mode", ["calibrated", "ratio"]);
 				if (mode === "calibrated" || mode === "ratio") appendSettings(pi, runtime, { compactAfterTokensMode: mode });
-			} else if (choice.startsWith("Compaction ratio:")) {
-				const value = await ctx.ui.input(`Compaction ratio (current: ${scalarLabel(runtime, "compactAfterTokensRatio")})`, "decimal between 0 and 1");
+			} else if (choice.startsWith("Automatic compaction context ratio:")) {
+				const value = await ctx.ui.input(`Automatic compaction source-backlog context ratio (current: ${scalarLabel(runtime, "compactAfterTokensRatio")})`, "decimal between 0 and 1");
 				const ratio = value === undefined ? undefined : Number(value.trim());
 				if (ratio !== undefined && Number.isFinite(ratio) && ratio > 0 && ratio < 1) appendSettings(pi, runtime, { compactAfterTokensRatio: ratio });
 				else if (value !== undefined) ctx.ui.notify("Ratio must be a number between 0 and 1.", "warning");
 			} else {
 				const numberChoice: Array<[string, NumberSetting, string]> = [
-					["Observation threshold:", "observeAfterTokens", "Observation threshold"],
-					["Reflection threshold:", "reflectAfterTokens", "Reflection threshold"],
-					["Compaction threshold:", "compactAfterTokens", "Compaction threshold"],
-					["Observer chunk limit:", "observerChunkMaxTokens", "Observer chunk limit"],
-					["Observation pool max:", "observationsPoolMaxTokens", "Observation pool max"],
-					["Observation pool target:", "observationsPoolTargetTokens", "Observation pool target"],
-					["Worker max turns:", "agentMaxTurns", "Worker max turns"],
-					["Contemplation observation trigger:", "contemplatorMinNewObservations", "Contemplation observation trigger"],
-					["Contemplation reflection trigger:", "contemplatorMinNewReflections", "Contemplation reflection trigger"],
-					["Contemplation turn interval:", "contemplatorMinTurns", "Contemplation turn interval"],
+					["Observer source backlog trigger (tokens):", "observeAfterTokens", "Observer source backlog trigger (tokens)"],
+					["Observer input cap (tokens):", "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)"],
+					["Old memory pool target (tokens, advisory):", "oldMemoryPoolTargetTokens", "Old memory pool target (tokens, advisory)"],
+					["Contemplator new-observation trigger (count):", "contemplatorMinNewObservations", "Contemplator new-observation trigger (count)"],
+					["Contemplator new-summary trigger (count):", "contemplatorMinNewSummaries", "Contemplator new-summary trigger (count)"],
+					["Contemplator response spacing (count):", "contemplatorMinTurns", "Contemplator response spacing (count)"],
+					["Summarizer old-pool retrigger growth (tokens):", "summarizerRetriggerTokens", "Summarizer old-pool retrigger growth (tokens)"],
+					["Summarizer input cap before sampling (tokens):", "summarizerSamplingThresholdTokens", "Summarizer input cap before sampling (tokens)"],
 				];
 				const selected = numberChoice.find(([prefix]) => choice.startsWith(prefix));
 				if (selected) {
 					const value = await editNumber(ctx, runtime, selected[1], selected[2]);
-					if (value !== undefined && validObservationPoolOverride(ctx, runtime, selected[1], value)) {
-						appendSettings(pi, runtime, { [selected[1]]: value } as SessionSettings);
-					}
+					if (value !== undefined) appendSettings(pi, runtime, { [selected[1]]: value } as SessionSettings, ctx);
 				}
 			}
 		}

package/src/commands/status.ts

@@ -1,5 +1,4 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { observationPoolMetrics } from "../agents/dropper/pool.js";
 import { resolveCompactAfterTokens } from "../config.js";
 import type { Runtime } from "../runtime.js";
 import {
@@ -7,9 +6,9 @@ import {
 	diffProjection,
 	foldLedger,
 	fullProjection,
+	partitionMemoryPools,
 	rawTokensSinceLastCompaction,
 	rawTokensSinceObservationCoverage,
-	rawTokensSinceReflectionCoverage,
 	visibleProjection,
 	type Entry,
 } from "../session-ledger/index.js";
@@ -37,6 +36,22 @@ function formatDuration(durationMs: number): string {
 	return `${seconds}s`;
 }
 
+function formatRunAge(timestamp: number): string {
+	return `${new Date(timestamp).toISOString()} (${formatDuration(Math.max(0, Date.now() - timestamp))} ago)`;
+}
+
+function contemplatorWaitingLabel(waitingFor: Runtime["contemplatorState"]["waitingFor"]): string {
+	switch (waitingFor) {
+		case "memories": return "waiting for memory threshold";
+		case "responses": return "waiting for response spacing";
+		case "ready": return "ready to launch";
+		case "running": return "running";
+		case "disabled": return "disabled";
+		case "passive": return "passive mode";
+		default: return "idle; no pending memories";
+	}
+}
+
 function truncateStatusText(value: string, limit = 1_000): string {
 	return value.length <= limit ? value : `${value.slice(0, limit - 1)}…`;
 }
@@ -60,7 +75,7 @@ function appendSuffixes(line: string, suffixes: (string | undefined)[]): string
 
 export function registerStatusCommand(pi: ExtensionAPI, runtime: Runtime): void {
 	pi.registerCommand("om:status", {
-		description: "Show observational memory status",
+		description: "Show pi-contemplator status",
 		handler: async (_args, ctx) => {
 			runtime.ensureConfig(ctx.cwd);
 			const entries = ctx.sessionManager.getBranch() as Entry[];
@@ -70,21 +85,17 @@ export function registerStatusCommand(pi: ExtensionAPI, runtime: Runtime): void
 			const drift = diffProjection(visible, full);
 
 			const visibleObservationTokens = tokenSum(visible.observations);
-			const visibleReflectionTokens = tokenSum(visible.reflections);
-			const activeObservationPool = observationPoolMetrics(folded.activeObservations, runtime.config.observationsPoolTargetTokens);
+			const visibleSummaryTokens = tokenSum(visible.summaries);
+			const pools = partitionMemoryPools(folded.activeObservations, folded.activeSummaries, runtime.config.newMemoryPoolMaxTokens);
 			const observationLine = appendSuffixes(
-				`Observations: ${folded.observations.length} recorded / ${folded.droppedObservationIds.size} dropped / ${folded.activeObservations.length} active / ${visible.observations.length} visible`,
-				[
-					addedSuffix(drift.observationsOnlyInFull.length),
-					removedSuffix(drift.droppedOnlyInFull.length),
-				],
+				`Observations: ${folded.observations.length} recorded / ${folded.activeObservations.length} active / ${visible.observations.length} visible`,
+				[addedSuffix(drift.observationsOnlyInFull.length), removedSuffix(drift.observationsOnlyInVisible.length)],
 			);
-			const reflectionLine = appendSuffixes(
-				`Reflections:  ${folded.reflections.length} recorded / ${visible.reflections.length} visible`,
-				[addedSuffix(drift.reflectionsOnlyInFull.length)],
+			const summaryLine = appendSuffixes(
+				`Summaries:    ${folded.summaries.length} recorded / ${folded.activeSummaries.length} active / ${visible.summaries.length} visible`,
+				[addedSuffix(drift.summariesOnlyInFull.length), removedSuffix(drift.summariesOnlyInVisible.length)],
 			);
 			const obsProgress = rawTokensSinceObservationCoverage(entries);
-			const reflectionProgress = rawTokensSinceReflectionCoverage(entries);
 			const compactionProgress = rawTokensSinceLastCompaction(entries);
 			const contextWindow = typeof ctx.model?.contextWindow === "number" ? ctx.model.contextWindow : undefined;
 			const compactThreshold = resolveCompactAfterTokens(runtime.config, contextWindow);
@@ -97,22 +108,27 @@ export function registerStatusCommand(pi: ExtensionAPI, runtime: Runtime): void
 				]
 				: [];
 
+			const summarizerTrigger = runtime.summarizerNextTriggerTokens ?? runtime.config.oldMemoryPoolTargetTokens;
+			const summarizerSamplingTokens = runtime.config.summarizerSamplingThresholdTokens;
 			const lines = [
 				...passiveLines,
 				"── Memory ──",
 				observationLine,
-				reflectionLine,
+				summaryLine,
 				"",
 				"── Activity ──",
-				`Next observation: ~${obsProgress.toLocaleString()} / ${runtime.config.observeAfterTokens.toLocaleString()} tokens (${pct(obsProgress, runtime.config.observeAfterTokens)}%)`,
-				`Next reflection:  ~${reflectionProgress.toLocaleString()} / ${runtime.config.reflectAfterTokens.toLocaleString()} tokens (${pct(reflectionProgress, runtime.config.reflectAfterTokens)}%)`,
-				`Next compaction:  ~${compactionProgress.toLocaleString()} / ${compactThreshold.toLocaleString()} tokens (${pct(compactionProgress, compactThreshold)}%)`,
-				`Visible observation pool: ~${visibleObservationTokens.toLocaleString()} / ${runtime.config.observationsPoolMaxTokens.toLocaleString()} tokens (${pct(visibleObservationTokens, runtime.config.observationsPoolMaxTokens)}%)`,
-				`Active observation pool: ~${activeObservationPool.observationTokens.toLocaleString()} / ${runtime.config.observationsPoolTargetTokens.toLocaleString()} target tokens (${pct(activeObservationPool.observationTokens, runtime.config.observationsPoolTargetTokens)}%)`,
-				`Reflection pool:         ~${visibleReflectionTokens.toLocaleString()} tokens`,
+				`Observer source backlog: ~${obsProgress.toLocaleString()} / ${runtime.config.observeAfterTokens.toLocaleString()} tokens (${pct(obsProgress, runtime.config.observeAfterTokens)}%)`,
+				`Summarizer trigger:      old pool ~${pools.oldTokens.toLocaleString()} / ${summarizerTrigger.toLocaleString()} tokens (${pct(pools.oldTokens, summarizerTrigger)}%)`,
+				`Automatic compaction source backlog: ~${compactionProgress.toLocaleString()} / ${compactThreshold.toLocaleString()} tokens (${pct(compactionProgress, compactThreshold)}%; injected memory excluded)`,
+				`Visible observation pool: ~${visibleObservationTokens.toLocaleString()} tokens`,
+				`New memory pool:         ~${pools.newTokens.toLocaleString()} / ${runtime.config.newMemoryPoolMaxTokens.toLocaleString()} protection-budget tokens (${pct(pools.newTokens, runtime.config.newMemoryPoolMaxTokens)}%; newest memory always protected whole)`,
+				`Old memory pool:         ~${pools.oldTokens.toLocaleString()} / ${runtime.config.oldMemoryPoolTargetTokens.toLocaleString()} advisory target tokens (${pct(pools.oldTokens, runtime.config.oldMemoryPoolTargetTokens)}%)`,
+				`Summary pool:            ~${visibleSummaryTokens.toLocaleString()} visible tokens`,
+				`Summarizer:              ${runtime.config.summarizerEnabled === false ? "disabled" : "enabled"}; retrigger after +${runtime.config.summarizerRetriggerTokens.toLocaleString()} old-pool tokens / sample above ~${summarizerSamplingTokens.toLocaleString()} tokens`,
 				`Cumulative agent time:   ${formatDuration(agentActiveTimeMs(entries))}`,
-				`Compaction observer:     ${runtime.config.compactionObserverEnabled === false ? "disabled" : "enabled"}`,
+				`Observe source during compaction: ${runtime.config.compactionObserverEnabled === false ? "disabled" : "enabled"}`,
 				`Contemplator:             ${runtime.config.contemplatorEnabled ? "enabled" : "disabled"}`,
+				`Contemplator trigger:     ${runtime.contemplatorState.pendingObservations} observations / ${runtime.contemplatorState.pendingSummaries} summaries / ${runtime.contemplatorState.pendingReviews} reviews pending; ${runtime.contemplatorState.responsesSinceRun} / ${runtime.config.contemplatorMinTurns} primary responses; ${contemplatorWaitingLabel(runtime.contemplatorState.waitingFor)}`,
 				`Contemplator 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"}`,
@@ -124,6 +140,15 @@ export function registerStatusCommand(pi: ExtensionAPI, runtime: Runtime): void
 				lines.push(`Token usage:            ↑${formatTokens(u.input)} ↓${formatTokens(u.output)}${u.cacheRead ? ` R${formatTokens(u.cacheRead)}` : ""}${u.cacheWrite ? ` W${formatTokens(u.cacheWrite)}` : ""} $${u.cost.toFixed(3)} (${u.runs} call${u.runs === 1 ? "" : "s"})`);
 			}
 
+			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(`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("", "── Interventions ──");
 			// Probe stats come from the branch ledger (like /om:view contemplator):
 			// deduped by probeId so restore re-queues don't inflate the count, and
 			// entries without a probeId (sent before probe tracking existed) count
@@ -146,12 +171,12 @@ export function registerStatusCommand(pi: ExtensionAPI, runtime: Runtime): void
 					probeSuggestions[existingIndex] = { suggestion: data.suggestion };
 				}
 			}
-			if (probeSuggestions.length > 0) {
-				lines.push(`Probes sent:            ${probeSuggestions.length}`);
-				lines.push(`Last probe:             ${probeSuggestions[probeSuggestions.length - 1].suggestion}`);
-			}
+			lines.push(`Probes sent:            ${probeSuggestions.length}`);
+			if (probeSuggestions.length > 0) lines.push(`Last probe:             ${probeSuggestions[probeSuggestions.length - 1].suggestion}`);
 
-			const latestReview = full.reviews?.at(-1);
+			const reviews = full.reviews ?? [];
+			lines.push(`Reviews completed:      ${reviews.length}`);
+			const latestReview = reviews.at(-1);
 			if (latestReview) {
 				lines.push(`Last review:            [${latestReview.id}] ${latestReview.scope} ${latestReview.outcome}`);
 				if (latestReview.outcome === "proposal") lines.push(`Last review summary:    ${truncateStatusText(latestReview.summary)}`);
@@ -165,22 +190,21 @@ export function registerStatusCommand(pi: ExtensionAPI, runtime: Runtime): void
 			}
 			if (latestNotice) lines.push(`Last reviewer notice:  ${truncateStatusText(latestNotice)}`);
 
-			if (runtime.consolidationInFlight || runtime.compactInFlight || runtime.compactHookInFlight || runtime.reviewInFlight) {
+			if (runtime.consolidationInFlight || runtime.summarizerInFlight || runtime.contemplatorState.running || runtime.compactInFlight || runtime.compactHookInFlight || runtime.reviewInFlight) {
 				lines.push("", "── In flight ──");
-				if (runtime.consolidationInFlight) {
-					const phase = runtime.consolidationPhase ? ` (${runtime.consolidationPhase})` : "";
-					lines.push(`Consolidation: running${phase}`);
-				}
-				if (runtime.compactInFlight) lines.push("Auto-compaction: running");
+				if (runtime.consolidationInFlight) lines.push("Observer: running");
+				if (runtime.summarizerInFlight) lines.push("Summarizer: running");
+				if (runtime.contemplatorState.running) lines.push("Contemplator: running");
+				if (runtime.compactInFlight) lines.push("Automatic compaction: running");
 				if (runtime.compactHookInFlight) lines.push("Compaction hook: running");
 				if (runtime.reviewInFlight) lines.push("Structural review: running");
 			}
 
-			if (runtime.lastObserverError || runtime.lastReflectorError || runtime.lastDropperError) {
+			if (runtime.lastObserverError || runtime.lastSummarizerError || runtime.contemplatorState.lastError) {
 				lines.push("", "── Last error ──");
 				if (runtime.lastObserverError) lines.push(`Observer: ${runtime.lastObserverError}`);
-				if (runtime.lastReflectorError) lines.push(`Reflector: ${runtime.lastReflectorError}`);
-				if (runtime.lastDropperError) lines.push(`Dropper: ${runtime.lastDropperError}`);
+				if (runtime.lastSummarizerError) lines.push(`Summarizer: ${runtime.lastSummarizerError}`);
+				if (runtime.contemplatorState.lastError) lines.push(`Contemplator: ${runtime.contemplatorState.lastError}`);
 			}
 
 			ctx.ui.notify(lines.join("\n"), "info");

package/src/commands/summarizer-view.ts

@@ -0,0 +1,58 @@
+import type { SummarizerRunView } 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 most recent launch-local summarizer transcript. */
+export function renderSummarizer(run: SummarizerRunView | undefined): string {
+	if (!run) return `${DIM}SUMMARIZER${RESET}\n\n${DIM}Summarizer 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 lines = [
+		`${DIM}SUMMARIZER · ${run.status} · ${messages.length} messages · ~${totalTokens.toLocaleString()} estimated tokens${RESET}`,
+		`${DIM}Started ${new Date(run.startedAt).toISOString()}${RESET}`,
+		`${DIM}${run.completedAt === undefined ? "Not completed" : `Ended ${new Date(run.completedAt).toISOString()}`}${RESET}`,
+		"",
+	];
+	if (messages.length === 0) lines.push(`${DIM}(no summarizer 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");
+}