@matthewfl/pi-contemplator 0.0.9 → 0.1.0

package/src/commands/view.ts

@@ -3,11 +3,13 @@ import type { Runtime } from "../runtime.js";
 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 { executeRecall, formatRecallResultForTui } from "../tools/recall-observation.js";
 import {
+	chronologicalMemories,
 	fullProjection,
 	observationToSummaryLine,
-	reflectionToSummaryLine,
+	summaryToSummaryLine,
 	visibleProjection,
 	type Entry,
 	type Projection,
@@ -44,12 +46,12 @@ function renderContentOnlyProjection(
 	projection: Projection,
 	emptyScope: "visible" | "recorded",
 ): string {
+	const memories = chronologicalMemories(projection.observations, projection.summaries);
 	const lines = [
-		"── Reflections ──",
-		renderList(projection.reflections, reflectionToSummaryLine, `No ${emptyScope} reflections.`),
-		"",
-		"── Observations ──",
-		renderList(projection.observations, observationToSummaryLine, `No ${emptyScope} observations.`),
+		"── Memories (chronological) ──",
+		memories.length > 0
+			? memories.map((item) => item.kind === "observation" ? observationToSummaryLine(item.memory) : summaryToSummaryLine(item.memory)).join("\n")
+			: `No ${emptyScope} memories.`,
 	];
 	if (projection.reviews?.length) lines.push("", "── Advisory reviews ──", ...projection.reviews.map(reviewSummaryLine));
 	return lines.join("\n");
@@ -57,7 +59,7 @@ function renderContentOnlyProjection(
 
 function hasMemory(projection: Projection): boolean {
 	return (
-		projection.reflections.length > 0 || projection.observations.length > 0 || (projection.reviews?.length ?? 0) > 0
+		projection.summaries.length > 0 || projection.observations.length > 0 || (projection.reviews?.length ?? 0) > 0
 	);
 }
 
@@ -74,7 +76,7 @@ export function registerViewCommand(
 
 	pi.registerCommand("om:view", {
 		description:
-			"Print and copy observational memory content (visible, full, memory, contemplator, reviewer, or reviews)",
+			"Print and copy pi-contemplator memory content (visible, full, memory, contemplator, summarizer, reviewer, or reviews)",
 		handler: async (args, ctx) => {
 			runtime.ensureConfig(ctx.cwd);
 			const entries = ctx.sessionManager.getBranch() as Entry[];
@@ -105,7 +107,7 @@ export function registerViewCommand(
 			}
 
 			if (mode === "contemplator") {
-				const output = renderContemplator(entries);
+				const output = renderContemplator(entries, runtime.contemplatorState);
 				const copied = await copyToClipboard(stripAnsi(output)).catch(() => false);
 				ctx.ui.notify(
 					`${output}\n\n${copied ? "Copied /om:view contemplator output to clipboard." : "Warning: failed to copy /om:view contemplator output to clipboard."}`,
@@ -114,6 +116,16 @@ export function registerViewCommand(
 				return;
 			}
 
+			if (mode === "summarizer") {
+				const output = renderSummarizer(runtime.lastSummarizerRun);
+				const copied = await copyToClipboard(stripAnsi(output)).catch(() => false);
+				ctx.ui.notify(
+					`${output}\n\n${copied ? "Copied /om:view summarizer output to clipboard." : "Warning: failed to copy /om:view summarizer output to clipboard."}`,
+					"info",
+				);
+				return;
+			}
+
 			if (mode === "reviewer") {
 				const output = renderReviewer(entries);
 				const copied = await copyToClipboard(stripAnsi(output)).catch(() => false);
@@ -142,7 +154,7 @@ export function registerViewCommand(
 			}
 
 			if (mode && mode !== "visible") {
-				ctx.ui.notify("Usage: /om:view [visible|full|memory <id>|contemplator|reviewer|reviews]", "info");
+				ctx.ui.notify("Usage: /om:view [visible|full|memory <id>|contemplator|summarizer|reviewer|reviews]", "info");
 				return;
 			}
 

package/src/config.ts

@@ -32,7 +32,6 @@ export type CompactAfterTokensMode = "calibrated" | "ratio";
 
 export interface Config {
 	observeAfterTokens: number;
-	reflectAfterTokens: number;
 	/**
 	 * Maximum estimated source tokens serialized into a single observer chunk.
 	 * Unset (default) derives the cap from the resolved memory model's context
@@ -42,8 +41,10 @@ export interface Config {
 	compactAfterTokens: number;
 	compactAfterTokensMode: CompactAfterTokensMode;
 	compactAfterTokensRatio: number;
-	observationsPoolMaxTokens: number;
-	observationsPoolTargetTokens: number;
+	/** Token budget for the protected newest-memory suffix; newest record always fits whole. */
+	newMemoryPoolMaxTokens: number;
+	/** Advisory token target for older summarizer-eligible memory. */
+	oldMemoryPoolTargetTokens: number;
 	agentMaxTurns: number;
 	model?: ConfiguredModel;
 	showWorkerNotifications: boolean;
@@ -59,19 +60,25 @@ export interface Config {
 	/** Optional model override used only by short-lived structural reviewers. */
 	reviewerModel?: ConfiguredModel;
 	contemplatorMinNewObservations: number;
-	contemplatorMinNewReflections: number;
+	contemplatorMinNewSummaries: number;
+	/** Minimum completed primary-model responses between contemplator runs. */
 	contemplatorMinTurns: number;
+	/** Stateless loss-aware summarizer for the old memory pool. */
+	summarizerEnabled: boolean;
+	/** Additional old-pool tokens required before retrying an above-target pool. */
+	summarizerRetriggerTokens: number;
+	/** Rendered old-memory tokens available before pressure-valve sampling. */
+	summarizerSamplingThresholdTokens: number;
 	debugLog: boolean;
 }
 
 export const DEFAULTS: Config = {
 	observeAfterTokens: 10_000,
-	reflectAfterTokens: 20_000,
 	compactAfterTokens: 81_000,
 	compactAfterTokensMode: "calibrated",
 	compactAfterTokensRatio: 0.68,
-	observationsPoolMaxTokens: 20_000,
-	observationsPoolTargetTokens: 10_000,
+	newMemoryPoolMaxTokens: 40_000,
+	oldMemoryPoolTargetTokens: 40_000,
 	agentMaxTurns: 16,
 	showWorkerNotifications: true,
 	passive: false,
@@ -80,8 +87,11 @@ export const DEFAULTS: Config = {
 	showContemplatorMessages: true,
 	reviewerEnabled: true,
 	contemplatorMinNewObservations: 8,
-	contemplatorMinNewReflections: 1,
+	contemplatorMinNewSummaries: 1,
 	contemplatorMinTurns: 10,
+	summarizerEnabled: true,
+	summarizerRetriggerTokens: 2_000,
+	summarizerSamplingThresholdTokens: 60_000,
 	debugLog: false,
 };
 
@@ -155,15 +165,6 @@ function positiveIntegerOrUndefined(value: unknown): number | undefined {
 	return Number.isInteger(value) && typeof value === "number" && value > 0 ? value : undefined;
 }
 
-function validTargetOrUndefined(value: unknown, maxTokens: number): number | undefined {
-	const target = positiveIntegerOrUndefined(value);
-	return target !== undefined && target < maxTokens ? target : undefined;
-}
-
-function derivedObservationPoolTarget(maxTokens: number): number {
-	return Math.floor(maxTokens / 2);
-}
-
 function isThinkingLevel(value: unknown): value is ModelThinkingLevel {
 	return typeof value === "string" && (THINKING_LEVEL_VALUES as readonly string[]).includes(value);
 }
@@ -203,15 +204,16 @@ function normalizeSettingsConfig(value: Record<string, unknown>): Partial<Config
 	const normalized: Partial<Config> = {};
 	const numberKeys = [
 		"observeAfterTokens",
-		"reflectAfterTokens",
 		"observerChunkMaxTokens",
 		"compactAfterTokens",
-		"observationsPoolMaxTokens",
-		"observationsPoolTargetTokens",
+		"newMemoryPoolMaxTokens",
+		"oldMemoryPoolTargetTokens",
 		"agentMaxTurns",
 		"contemplatorMinNewObservations",
-		"contemplatorMinNewReflections",
+		"contemplatorMinNewSummaries",
 		"contemplatorMinTurns",
+		"summarizerRetriggerTokens",
+		"summarizerSamplingThresholdTokens",
 	] as const;
 	for (const key of numberKeys) {
 		const normalizedValue = positiveIntegerOrUndefined(value[key]);
@@ -228,6 +230,7 @@ function normalizeSettingsConfig(value: Record<string, unknown>): Partial<Config
 	if (typeof value.contemplatorEnabled === "boolean") normalized.contemplatorEnabled = value.contemplatorEnabled;
 	if (typeof value.showContemplatorMessages === "boolean") normalized.showContemplatorMessages = value.showContemplatorMessages;
 	if (typeof value.reviewerEnabled === "boolean") normalized.reviewerEnabled = value.reviewerEnabled;
+	if (typeof value.summarizerEnabled === "boolean") normalized.summarizerEnabled = value.summarizerEnabled;
 	if (typeof value.debugLog === "boolean") normalized.debugLog = value.debugLog;
 	const model = normalizeModel(value.model);
 	if (model) normalized.model = model;
@@ -269,20 +272,10 @@ export function loadConfig(cwd: string, env: NodeJS.ProcessEnv = process.env): C
 	const globalConfig = readNamespacedConfig(globalPath);
 	const projectConfig = readNamespacedConfig(projectPath);
 	const envConfig = readEnvConfig(env);
-	const merged = {
+	return {
 		...DEFAULTS,
-		observationsPoolTargetTokens: undefined,
 		...globalConfig,
 		...projectConfig,
 		...envConfig,
 	};
-	const target = validTargetOrUndefined(
-		merged.observationsPoolTargetTokens,
-		merged.observationsPoolMaxTokens,
-	) ?? derivedObservationPoolTarget(merged.observationsPoolMaxTokens);
-
-	return {
-		...merged,
-		observationsPoolTargetTokens: target,
-	};
 }

package/src/hooks/compaction-hook.ts

@@ -1,26 +1,19 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
+import { debugLog } from "../debug-log.js";
 import { computeSessionSettings, type Runtime } from "../runtime.js";
 import { launchCompactionObserver, type ConsolidationCtx } from "./consolidation-trigger.js";
 import { buildCompactionProjection, renderSummary, type Entry } from "../session-ledger/index.js";
 import { watchForNativeCompactionResume } from "./compaction-resume.js";
 
-const DEFAULT_OBSERVATIONS_POOL_MAX_TOKENS = 20_000;
 const COMPACTION_STATUS_KEY = "observational-memory-compaction";
 
-function observationsPoolMaxTokens(runtime: Runtime): number {
-	const value = (runtime.config as { observationsPoolMaxTokens?: unknown }).observationsPoolMaxTokens;
-	return typeof value === "number" && Number.isFinite(value) && value > 0
-		? value
-		: DEFAULT_OBSERVATIONS_POOL_MAX_TOKENS;
-}
-
 export function registerCompactionHook(pi: ExtensionAPI, runtime: Runtime): void {
 	pi.on("session_before_compact", async (event: any, ctx: any) => {
 		if (runtime.compactHookInFlight) {
 			if (ctx.hasUI) {
 				ctx.ui.notify(
-					"Observational memory: another compaction is already in progress; cancelling duplicate",
+					"pi-contemplator: another compaction is already in progress; cancelling duplicate",
 					"warning",
 				);
 			}
@@ -29,14 +22,15 @@ export function registerCompactionHook(pi: ExtensionAPI, runtime: Runtime): void
 
 		const initiatedByOm = runtime.compactInFlight && event.reason === "manual";
 		const reason = initiatedByOm ? (runtime.compactOrigin ?? "proactive") : event.reason;
+		const omWillResume = initiatedByOm && (runtime.compactOrigin === "agent-requested" || runtime.compactOrigin === "length-stop");
 		if (ctx.hasUI) {
 			let pending = "";
 			if (event.willRetry) pending = ", retry pending";
-			else if (initiatedByOm) pending = ", resume pending";
+			else if (omWillResume) pending = ", resume pending";
 			ctx.ui.setStatus?.(COMPACTION_STATUS_KEY, `OM compaction: running (${reason}${pending})`);
 			if (!initiatedByOm) {
 				const continuation = event.willRetry ? "; the interrupted agent run will resume automatically" : "";
-				ctx.ui.notify(`Observational memory: compaction started (${reason})${continuation}`, "info");
+				ctx.ui.notify(`pi-contemplator: compaction started (${reason})${continuation}`, "info");
 			}
 		}
 		event.signal?.addEventListener?.("abort", () => {
@@ -54,12 +48,8 @@ export function registerCompactionHook(pi: ExtensionAPI, runtime: Runtime): void
 				launchCompactionObserver(pi, runtime, ctx as ConsolidationCtx, branch);
 			}
 			const { firstKeptEntryId, tokensBefore } = preparation;
-			const projection = buildCompactionProjection(
-				branch,
-				firstKeptEntryId,
-				{ observationsPoolMaxTokens: observationsPoolMaxTokens(runtime) },
-			);
-			const summary = renderSummary(projection.reflections, projection.observations);
+			const projection = buildCompactionProjection(branch, firstKeptEntryId);
+			const summary = renderSummary(projection.summaries, projection.observations);
 			// Compaction removes older custom entries from the active branch. Keep
 			// session-scoped overrides in the compaction details so they can be
 			// restored after a reload from the surviving branch. Bake the merged
@@ -88,12 +78,39 @@ export function registerCompactionHook(pi: ExtensionAPI, runtime: Runtime): void
 	pi.on("session_compact", (event: any, ctx: any) => {
 		const initiatedByOm = runtime.compactInFlight && event.reason === "manual";
 		const reason = initiatedByOm ? (runtime.compactOrigin ?? "proactive") : event.reason;
+		const omWillResume = initiatedByOm && (runtime.compactOrigin === "agent-requested" || runtime.compactOrigin === "length-stop");
 		if (event.willRetry) watchForNativeCompactionResume(pi, runtime, ctx);
 		if (!ctx.hasUI) return;
 		ctx.ui.setStatus?.(COMPACTION_STATUS_KEY, undefined);
 		let continuation = "";
 		if (event.willRetry) continuation = "; resuming the interrupted agent run";
-		else if (initiatedByOm) continuation = "; resuming the agent run";
-		ctx.ui.notify(`Observational memory: compaction complete (${reason})${continuation}`, "info");
+		else if (omWillResume) continuation = "; resuming the agent run";
+		ctx.ui.notify(`pi-contemplator: compaction complete (${reason})${continuation}`, "info");
+	});
+
+	pi.on("session_compact_failed", (event, ctx) => {
+		const initiatedByOm = runtime.compactInFlight && event.reason === "manual";
+		const reason = initiatedByOm ? (runtime.compactOrigin ?? "proactive") : event.reason;
+		debugLog("compaction.failed", {
+			reason,
+			piReason: event.reason,
+			errorMessage: event.errorMessage,
+			aborted: event.aborted,
+			willRetry: event.willRetry,
+			fromExtension: event.fromExtension,
+			initiatedByOm,
+		});
+
+		// OM-initiated ctx.compact() calls already have an onError callback that
+		// clears UI state and applies the origin-specific continuation policy. Do
+		// not duplicate that work here; Pi emits this event before invoking it.
+		if (initiatedByOm) return;
+		if (ctx.hasUI) ctx.ui.setStatus?.(COMPACTION_STATUS_KEY, undefined);
+		if (!event.aborted && ctx.hasUI) {
+			ctx.ui.notify(
+				`pi-contemplator: compaction failed (${reason}): ${event.errorMessage ?? "unknown error"}`,
+				"error",
+			);
+		}
 	});
 }

package/src/hooks/compaction-resume.ts

@@ -53,7 +53,7 @@ function sendResumeMessage(pi: ExtensionAPI, ctx: ResumeCtx, afterFailure: boole
 		});
 	} catch (error) {
 		const message = error instanceof Error ? error.message : String(error);
-		ctx.ui?.notify?.(`Observational memory: failed to request continuation: ${message}`, "error");
+		ctx.ui?.notify?.(`pi-contemplator: failed to request continuation: ${message}`, "error");
 	}
 }
 
@@ -72,7 +72,7 @@ function scheduleResumeRetries(
 			if (!isCurrentWatch(runtime, generation)) return;
 			clearResumeWatch(runtime);
 			ctx.ui?.notify?.(
-				"Observational memory: the agent did not acknowledge continuation after compaction",
+				"pi-contemplator: the agent did not acknowledge continuation after compaction",
 				"error",
 			);
 		}, RESUME_RETRY_DELAYS_MS.at(-1));
@@ -82,7 +82,7 @@ function scheduleResumeRetries(
 	runtime.compactionResumeTimer = setTimeout(() => {
 		if (!isCurrentWatch(runtime, generation)) return;
 		ctx.ui?.notify?.(
-			`Observational memory: continuation did not start; retrying (${retryIndex + 1}/${RESUME_RETRY_DELAYS_MS.length})`,
+			`pi-contemplator: continuation did not start; retrying (${retryIndex + 1}/${RESUME_RETRY_DELAYS_MS.length})`,
 			"warning",
 		);
 		sendResumeMessage(pi, ctx, afterFailure, shortContinuationPrompt);
@@ -118,7 +118,7 @@ export function watchForNativeCompactionResume(
 	runtime.compactionResumeTimer = setTimeout(() => {
 		if (!isCurrentWatch(runtime, generation)) return;
 		ctx.ui?.notify?.(
-			"Observational memory: native compaction did not resume the agent; sending fallback continuation",
+			"pi-contemplator: native compaction did not resume the agent; sending fallback continuation",
 			"warning",
 		);
 		sendResumeMessage(pi, ctx, false);

package/src/hooks/compaction-trigger.ts

@@ -9,52 +9,34 @@ import {
 } from "./compaction-resume.js";
 
 const COMPACTION_STATUS_KEY = "observational-memory-compaction";
+type CompactionOrigin = "agent-requested" | "length-stop" | "proactive";
 
-export function registerCompactionTrigger(pi: ExtensionAPI, runtime: Runtime): void {
-	registerCompactionResumeAcknowledgement(pi, runtime);
-	pi.on("agent_end", (event: any, ctx: any) => {
-		runtime.ensureConfig(ctx.cwd);
-		if (runtime.compactInFlight) return;
-
-		const agentRequested = runtime.compactRequested;
-		const shortContinuationPrompt = agentRequested ? runtime.compactContinuationPrompt : undefined;
-		if (agentRequested) runtime.compactRequested = false;
-		else if (runtime.config.passive === true) return;
+type TriggerOptions = {
+	origin: CompactionOrigin;
+	resume: boolean;
+	threshold?: number;
+	shortContinuationPrompt?: string;
+};
 
-		const contextWindow = typeof ctx.model?.contextWindow === "number" ? ctx.model.contextWindow : 0;
-		let threshold: number | undefined;
-		if (!agentRequested) {
-			// agent_end fires before Pi decides whether to retry or compact-and-retry an
-			// interrupted request. Starting ctx.compact() here turns it into a manual
-			// compaction (willRetry=false) and can consume Pi's overflow recovery, leaving
-			// the agent idle. Let Pi handle every failed/aborted/overflow response; OM's
-			// session_before_compact hook still supplies the actual memory compaction.
-			const lastAssistant = [...event.messages].reverse().find(
-				(m): m is Extract<typeof m, { role: "assistant" }> => m.role === "assistant",
-			);
-			if (
-				lastAssistant
-				&& (
-					lastAssistant.stopReason === "error"
-						|| lastAssistant.stopReason === "aborted"
-						|| isContextOverflow(lastAssistant, contextWindow)
-				)
-			) return;
+/** A stop with thinking but no text or tool call did not produce a usable turn. */
+function isEmptyNormalStop(message: any): boolean {
+	if (!message || message.role !== "assistant" || message.stopReason !== "stop") return false;
+	if (typeof message.content === "string") return message.content.trim().length === 0;
+	if (!Array.isArray(message.content)) return true;
+	return !message.content.some((part: any) =>
+		part?.type === "toolCall"
+		|| (part?.type === "text" && typeof part.text === "string" && part.text.trim().length > 0),
+	);
+}
 
-			const entries = ctx.sessionManager.getBranch() as Entry[];
-			const tokens = rawTokensSinceLastCompaction(entries);
-			// Resolve the proactive-compaction threshold from the active model's context
-			// window when ratio mode is configured. ctx.model is the current session model
-			// (Model<any> | undefined per ExtensionContext).
-			threshold = resolveCompactAfterTokens(runtime.config, contextWindow > 0 ? contextWindow : undefined);
-			if (tokens < threshold) return;
-		}
+export function registerCompactionTrigger(pi: ExtensionAPI, runtime: Runtime): void {
+	registerCompactionResumeAcknowledgement(pi, runtime);
+	let resumeEmptyStopAfterProactiveCompaction = false;
 
-		// Capture ctx properties synchronously — the setTimeout + async work below
-		// may outlive the extension ctx (stale after session replacement/reload).
+	const triggerCompaction = (ctx: any, options: TriggerOptions): void => {
+		const { origin, resume, threshold, shortContinuationPrompt } = options;
 		const hasUI = ctx.hasUI;
 		const ui = ctx.ui;
-		const origin = agentRequested ? "agent-requested" : "proactive";
 
 		runtime.compactInFlight = true;
 		runtime.compactOrigin = origin;
@@ -63,9 +45,9 @@ export function registerCompactionTrigger(pi: ExtensionAPI, runtime: Runtime): v
 				if (!ctx.isIdle()) {
 					runtime.compactInFlight = false;
 					runtime.compactOrigin = undefined;
-					if (agentRequested) runtime.compactRequested = true;
+					if (origin === "agent-requested") runtime.compactRequested = true;
 					if (hasUI) ui?.notify(
-						"Observational memory: compaction deferred — agent became busy before compaction",
+						"pi-contemplator: compaction deferred — agent became busy before compaction",
 						"info",
 					);
 					return;
@@ -76,50 +58,108 @@ export function registerCompactionTrigger(pi: ExtensionAPI, runtime: Runtime): v
 					runtime.compactInFlight = false;
 					runtime.compactOrigin = undefined;
 					if (hasUI) ui?.notify(
-						"Observational memory: compaction skipped — another compaction already ran before deferred compaction",
+						"pi-contemplator: compaction skipped — another compaction already ran before deferred compaction",
 						"info",
 					);
 					return;
 				}
 				if (hasUI) {
-					ui?.setStatus?.(COMPACTION_STATUS_KEY, `OM compaction: running (${origin}, resume pending)`);
-					const reason = agentRequested ? "agent-requested, " : "";
+					const pending = resume ? ", resume pending" : "";
+					ui?.setStatus?.(COMPACTION_STATUS_KEY, `OM compaction: running (${origin}${pending})`);
+					const reason = origin === "agent-requested" ? "agent-requested, " : origin === "length-stop" ? "length-stop, " : "";
+					const continuation = resume ? "; the interrupted agent run will resume automatically" : "";
 					ui?.notify(
-						`Observational memory: compaction started (${reason}~${currentTokens.toLocaleString()} tokens); the agent will resume automatically`,
+						`pi-contemplator: compaction started (${reason}~${currentTokens.toLocaleString()} tokens)${continuation}`,
 						"info",
 					);
 				}
-				if (agentRequested) runtime.compactContinuationPrompt = undefined;
+				if (origin === "agent-requested") runtime.compactContinuationPrompt = undefined;
 				ctx.compact({
 					onComplete: () => {
 						runtime.compactInFlight = false;
 						runtime.compactOrigin = undefined;
-						// Both explicit and proactive OM compactions are manual from Pi's
-						// perspective (willRetry=false), so Pi will not continue either one.
-						// Always enqueue a hidden continuation after OM finishes compacting.
-						resumeAfterCompaction(pi, runtime, { hasUI, ui }, false, shortContinuationPrompt);
+						if (hasUI && !resume) ui?.setStatus?.(COMPACTION_STATUS_KEY, undefined);
+						if (resume) resumeAfterCompaction(pi, runtime, { hasUI, ui }, false, shortContinuationPrompt);
 					},
 					onError: (error: { message: string }) => {
 						runtime.compactInFlight = false;
 						runtime.compactOrigin = undefined;
 						if (hasUI) ui?.setStatus?.(COMPACTION_STATUS_KEY, undefined);
 						if (error.message !== "Compaction cancelled" && hasUI) {
-							ui?.notify(`Observational memory: ${error.message}`, "error");
+							ui?.notify(`pi-contemplator: ${error.message}`, "error");
 						}
-						resumeAfterCompaction(pi, runtime, { hasUI, ui }, true, shortContinuationPrompt);
+						if (resume) resumeAfterCompaction(pi, runtime, { hasUI, ui }, true, shortContinuationPrompt);
 					},
 				});
 			} catch (error) {
 				runtime.compactInFlight = false;
-				if (agentRequested) runtime.compactContinuationPrompt = undefined;
+				if (origin === "agent-requested") runtime.compactContinuationPrompt = undefined;
 				runtime.compactOrigin = undefined;
 				const msg = error instanceof Error ? error.message : String(error);
 				if (hasUI) {
 					ui?.setStatus?.(COMPACTION_STATUS_KEY, undefined);
-					ui?.notify(`Observational memory: compact threw: ${msg}`, "error");
+					ui?.notify(`pi-contemplator: compact threw: ${msg}`, "error");
 				}
-				resumeAfterCompaction(pi, runtime, { hasUI, ui }, true, shortContinuationPrompt);
+				if (resume) resumeAfterCompaction(pi, runtime, { hasUI, ui }, true, shortContinuationPrompt);
 			}
 		}, 0);
+	};
+
+	pi.on("agent_end", (event: any, ctx: any) => {
+		runtime.ensureConfig(ctx.cwd);
+		if (runtime.compactInFlight) return;
+
+		const lastAssistant = [...event.messages].reverse().find(
+			(m): m is Extract<typeof m, { role: "assistant" }> => m.role === "assistant",
+		);
+		// Some providers occasionally return stop after spending output tokens but
+		// emit no text or tool call. Pi regards that as settled, yet it plainly is
+		// not a completed autonomous turn. Remember this only until agent_settled so
+		// threshold compaction can continue it; never resume an ordinary text stop.
+		resumeEmptyStopAfterProactiveCompaction = isEmptyNormalStop(lastAssistant);
+
+		const agentRequested = runtime.compactRequested;
+		if (agentRequested) {
+			const shortContinuationPrompt = runtime.compactContinuationPrompt;
+			runtime.compactRequested = false;
+			triggerCompaction(ctx, { origin: "agent-requested", resume: true, shortContinuationPrompt });
+			return;
+		}
+		if (runtime.config.passive === true) return;
+
+		// Pi owns error, abort, and overflow retry policy. OM's session hook still
+		// supplies the compaction contents when Pi performs a native retry.
+		const contextWindow = typeof ctx.model?.contextWindow === "number" ? ctx.model.contextWindow : 0;
+		if (
+			!lastAssistant
+			|| lastAssistant.stopReason === "error"
+			|| lastAssistant.stopReason === "aborted"
+			|| isContextOverflow(lastAssistant, contextWindow)
+		) return;
+
+		// A non-overflow length stop is interrupted work, not a normal completed
+		// turn. Preserve the older compact-and-resume behavior only for this case.
+		if (lastAssistant.stopReason !== "length") return;
+		const entries = ctx.sessionManager.getBranch() as Entry[];
+		const threshold = resolveCompactAfterTokens(runtime.config, contextWindow > 0 ? contextWindow : undefined);
+		if (rawTokensSinceLastCompaction(entries) < threshold) return;
+		triggerCompaction(ctx, { origin: "length-stop", resume: true, threshold });
+	});
+
+	// Proactive threshold compaction is maintenance after Pi has fully settled.
+	// It must not manufacture another agent turn after an ordinary completed
+	// response. The narrow exception is a provider's empty normal stop: there was
+	// no usable response, so compaction must preserve the autonomous run rather
+	// than making that provider failure look like successful completion.
+	pi.on("agent_settled", (_event: any, ctx: any) => {
+		const resume = resumeEmptyStopAfterProactiveCompaction;
+		resumeEmptyStopAfterProactiveCompaction = false;
+		runtime.ensureConfig(ctx.cwd);
+		if (runtime.config.passive === true || runtime.compactInFlight || runtime.compactRequested) return;
+		const entries = ctx.sessionManager.getBranch() as Entry[];
+		const contextWindow = typeof ctx.model?.contextWindow === "number" ? ctx.model.contextWindow : undefined;
+		const threshold = resolveCompactAfterTokens(runtime.config, contextWindow);
+		if (rawTokensSinceLastCompaction(entries) < threshold) return;
+		triggerCompaction(ctx, { origin: "proactive", resume, threshold });
 	});
 }