pi-blackhole 0.4.0 → 0.4.1

package/example-config.json

@@ -7,6 +7,7 @@
   "compaction": "auto",
   "compactionEngine": "blackhole",
   "tailBehavior": "minimal",
+  "midRunCompaction": "resume",
 
   "model": {
     "_comment": "Base model (last fallback before session model).",
@@ -110,6 +111,7 @@
     "  compaction (auto|manual|off) — how compaction triggers",
     "  compactionEngine (blackhole|pi-default) — who handles it",
     "  tailBehavior (pi-default|minimal) — how much stays visible",
+    "  midRunCompaction (resume|pause|off) — threshold check during tool loops",
     "  sessionFallback (true|false) — if false, skip session model as last-resort fallback",
     "  dropperPressureThreshold (0-1, default 0.70) — pressure relief valve: fraction of reflectorInputMaxTokens where dropper fires even without new data",
     "",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-blackhole",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "packageManager": "pnpm@11.2.2",
   "description": "Unified compaction + observational memory extension for Pi — compresses conversation context while preserving durable observations and reflections",
   "license": "MIT",

package/src/commands/pi-vcc.ts

@@ -8,7 +8,7 @@
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { Runtime } from "../om/runtime.js";
-import { PI_VCC_COMPACT_INSTRUCTION, notifyMigrationReminder } from "../hooks/before-compact";
+import { PI_VCC_COMPACT_INSTRUCTION, notifyMigrationReminder, formatCompactionStats } from "../hooks/before-compact";
 import { saveUnifiedConfig, configPath } from "../core/unified-config.js";
 import { readPendingState, clearPendingState, hasPendingData } from "../om/pending.js";
 import { createConfigureOverlay } from "../om/configure-overlay.js";
@@ -19,11 +19,6 @@ import {
 } from "../om/ledger/index.js";
 import { handleCleanup } from "./cleanup.js";
 
-const formatTokens = (n: number): string => {
-	if (n >= 1000) return `${(n / 1000).toFixed(1)}k`;
-	return String(n);
-};
-
 export const registerPiVccCommand = (pi: ExtensionAPI, runtime: Runtime) => {
 	const prefixMatch = (value: string, prefix: string): boolean => {
 		return value.toLowerCase().startsWith(prefix.toLowerCase());
@@ -100,6 +95,21 @@ export const registerPiVccCommand = (pi: ExtensionAPI, runtime: Runtime) => {
 				return;
 			}
 
+			// Warn if input starts with a known subcommand but isn't an exact match.
+			// Prevents "/blackhole configure foo" from silently becoming a follow-up.
+			const SUBCOMMAND_NAMES = ["configure", "cleanup", "om-off", "om-on"];
+			const nearMiss = SUBCOMMAND_NAMES.find(
+				name => trimmed.toLowerCase().startsWith(name.toLowerCase()) && trimmed.length > name.length
+			);
+			if (nearMiss) {
+				ctx.ui.notify(`/blackhole ${nearMiss} accepts no arguments. Did you mean \"/blackhole ${nearMiss}\"?`, "warning");
+				return;
+			}
+
+			// Extract follow-up prompt: everything after the subcommand check
+			// that isn't a known subcommand is treated as follow-up text.
+			const followUpPrompt = trimmed ? trimmed : null;
+
 			// If compaction is manual (or legacy noAutoCompact): flush pending OM entries
 			// into the branch before compacting so the summary includes accumulated memory.
 			if (runtime.config.compaction === "manual" && hasPendingData(sessionId)) {
@@ -137,14 +147,18 @@ export const registerPiVccCommand = (pi: ExtensionAPI, runtime: Runtime) => {
 				onComplete: () => {
 					const stats = runtime.compactionStats;
 					if (stats) {
-						ctx.ui.notify(
-							`blackhole: ${stats.summarized} source entries processed; tail kept ${stats.kept} (~${formatTokens(stats.keptTokensEst)} tok).`,
-							"info",
-						);
+						ctx.ui.notify(formatCompactionStats(stats), "info");
 					} else {
 						ctx.ui.notify("Compacted with blackhole", "info");
 					}
 					notifyMigrationReminder(sessionId, (msg, level) => ctx.ui.notify(msg, level as any));
+
+					// Fire follow-up prompt after compaction completes
+					if (followUpPrompt) {
+						try {
+							void Promise.resolve(pi.sendUserMessage(followUpPrompt)).catch(() => {});
+						} catch {}
+					}
 				},
 				onError: (err) => {
 					if (err.message === "Compaction cancelled" || err.message === "Already compacted") {

package/src/core/format.ts

@@ -31,7 +31,6 @@ export const wrapLongLines = (text: string, maxChars = TUI_SAFE_LINE_CHARS): str
 export const capBrief = (text: string): string => {
   const lines = text.split("\n");
   if (lines.length <= BRIEF_MAX_LINES) return text;
-  const omitted = lines.length - BRIEF_MAX_LINES;
   const kept = lines.slice(-BRIEF_MAX_LINES);
   // Find first section header to avoid cutting mid-section
   let firstHeader = kept.findIndex((l) => /^\[.+\]/.test(l));
@@ -42,6 +41,7 @@ export const capBrief = (text: string): string => {
     if (anyAnchor > 0) firstHeader = anyAnchor;
   }
   const clean = firstHeader > 0 ? kept.slice(firstHeader) : kept;
+  const omitted = lines.length - clean.length;
   return `...(${omitted} earlier lines omitted)\n\n${clean.join("\n")}`;
 };
 

package/src/core/unified-config.ts

@@ -62,6 +62,14 @@ export interface UnifiedConfig {
 	 *  "pi-default" — Pi's built-in summarization */
 	compactionEngine: "blackhole" | "pi-default";
 
+	/** Mid-run auto-compaction (turn_end trigger, fires while the agent is still
+	 *  executing tool loops — agent_end alone never fires during long runs).
+	 *  "resume" — compact at threshold and inject a resume message so the agent
+	 *             continues the task (default)
+	 *  "pause"  — compact at threshold but stop; user continues manually
+	 *  "off"    — only evaluate the threshold when the agent finishes a run */
+	midRunCompaction: "resume" | "pause" | "off";
+
 	/** How much recent transcript to keep visible after compaction.
 	 *  "pi-default" — use Pi's firstKeptEntryId (respects Pi's keepRecentTokens)
 	 *  "minimal"    — keep only last user message (current agressive pi-vcc behavior)
@@ -149,6 +157,7 @@ export const DEFAULTS: UnifiedConfig = {
 	compaction: "auto",
 	compactionEngine: "blackhole",
 	tailBehavior: "minimal",
+	midRunCompaction: "resume",
 
 	observeAfterTokens: 15_000,
 	reflectAfterTokens: 25_000,
@@ -175,6 +184,7 @@ const THINKING_LEVELS: readonly string[] = ["off", "minimal", "low", "medium", "
 const COMPACTION_VALUES = ["auto", "manual", "off"] as const;
 const COMPACTION_ENGINE_VALUES = ["blackhole", "pi-default"] as const;
 const TAIL_BEHAVIOR_VALUES = ["pi-default", "minimal"] as const;
+const MID_RUN_COMPACTION_VALUES = ["resume", "pause", "off"] as const;
 
 function isCompaction(v: unknown): v is "auto" | "manual" | "off" {
 	return typeof v === "string" && (COMPACTION_VALUES as readonly string[]).includes(v);
@@ -185,6 +195,9 @@ function isCompactionEngine(v: unknown): v is "blackhole" | "pi-default" {
 function isTailBehavior(v: unknown): v is "pi-default" | "minimal" {
 	return typeof v === "string" && (TAIL_BEHAVIOR_VALUES as readonly string[]).includes(v);
 }
+function isMidRunCompaction(v: unknown): v is "resume" | "pause" | "off" {
+	return typeof v === "string" && (MID_RUN_COMPACTION_VALUES as readonly string[]).includes(v);
+}
 
 function isRecord(v: unknown): v is Record<string, unknown> {
 	return typeof v === "object" && v !== null;
@@ -234,6 +247,7 @@ function parseConfig(raw: Record<string, unknown>): Partial<UnifiedConfig> {
 	if (isCompaction(raw.compaction)) c.compaction = raw.compaction;
 	if (isCompactionEngine(raw.compactionEngine)) c.compactionEngine = raw.compactionEngine;
 	if (isTailBehavior(raw.tailBehavior)) c.tailBehavior = raw.tailBehavior;
+	if (isMidRunCompaction(raw.midRunCompaction)) c.midRunCompaction = raw.midRunCompaction;
 
 	// Booleans — pi-vcc
 	if (typeof raw.overrideDefaultCompaction === "boolean") c.overrideDefaultCompaction = raw.overrideDefaultCompaction;

package/src/hooks/before-compact.ts

@@ -48,6 +48,37 @@ const formatTokens = (n: number): string => {
   return String(n);
 };
 
+export interface CompactionStats {
+  summarized: number;
+  kept: number;
+  keptTokensEst: number;
+  compactAll: boolean;
+  totalUserTurns: number;
+  keptUserTurns: number;
+  requestedKeepUserTurns: number;
+  keepUserTurnsExplicit: boolean;
+  keepFallbackToCompactAll: boolean;
+  smartKeepAdjusted: boolean;
+  smartFromKeep: number;
+}
+
+/**
+ * Format compaction stats for user-visible notification.
+ * Example output:
+ *   blackhole: 6 source entries processed; tail kept 1/4 user turns (~0.5k tok).
+ */
+export const formatCompactionStats = (stats: CompactionStats): string => {
+  const parts: string[] = [`${stats.summarized} source entries processed`];
+  parts.push(`tail kept ${stats.keptUserTurns}/${stats.totalUserTurns} user turns`);
+  if (stats.smartKeepAdjusted) {
+    parts.push(`smart keep:${stats.smartFromKeep}→${stats.keptUserTurns}`);
+  }
+  if (stats.keepFallbackToCompactAll) {
+    parts.push(`compact-all`);
+  }
+  return `blackhole: ${parts.join("; ")} (~${formatTokens(stats.keptTokensEst)} tok).`;
+};
+
 const dbg = (debug: boolean, data: Record<string, unknown>) => {
   if (!debug) return;
   try { writeFileSync("/tmp/pi-blackhole-debug.json", JSON.stringify(data, null, 2)); } catch {}
@@ -291,9 +322,7 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI, omRuntime: Runtime)
     // Determine effective tail behavior for buildOwnCut
     // Both /blackhole and auto-triggered default to "minimal" (aggressive cut);
     // users can opt into "pi-default" (gentler) by setting tailBehavior in config.
-    const effectiveTailBehavior = isPiVcc
-      ? (omRuntime.config.tailBehavior ?? "minimal")
-      : (omRuntime.config.tailBehavior ?? "minimal");
+    const effectiveTailBehavior = omRuntime.config.tailBehavior ?? "minimal";
 
     trace("before_compact.tail_behavior", {
       effectiveTailBehavior,
@@ -400,10 +429,22 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI, omRuntime: Runtime)
       }, 0);
       return sum;
     }, 0);
+    const totalUserTurns = (branchEntries as any[]).filter((e: any) => e.type === "message" && e.message?.role === "user").length;
+    const keptUserTurns = ownCut.compactAll
+      ? 0
+      : (branchEntries as any[]).slice(keptIdx).filter((e: any) => e.type === "message" && e.message?.role === "user").length;
     omRuntime.compactionStats = {
       summarized: agentMessages.length,
       kept: keptEntries.length,
       keptTokensEst: Math.round(keptChars / 4),
+      compactAll: ownCut.compactAll,
+      totalUserTurns,
+      keptUserTurns,
+      requestedKeepUserTurns: 1,
+      keepUserTurnsExplicit: false,
+      keepFallbackToCompactAll: ownCut.compactAll,
+      smartKeepAdjusted: false,
+      smartFromKeep: 1,
     };
 
     const summary = compile({
@@ -491,10 +532,7 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI, omRuntime: Runtime)
     const sessionId = ctx.sessionManager.getSessionId();
     setTimeout(() => {
       try {
-        ctx?.ui?.notify?.(
-          `blackhole: ${stats.summarized} source entries processed; tail kept ${stats.kept} (~${formatTokens(stats.keptTokensEst)} tok).`,
-          "info",
-        );
+        ctx?.ui?.notify?.(formatCompactionStats(stats), "info");
         notifyMigrationReminder(sessionId, (msg, level) => ctx?.ui?.notify?.(msg, level as any));
       } catch {}
     }, 500);

package/src/om/compaction-trigger.ts

@@ -26,6 +26,36 @@ function notifySafely(hasUI: boolean, ui: any, message: string, level: "info" |
 	}
 }
 
+/**
+ * Message injected after a mid-run compaction so the agent resumes the task
+ * instead of stopping (ctx.compact() aborts the in-flight run and Pi does not
+ * auto-continue).
+ */
+export const MID_RUN_RESUME_CUSTOM_TYPE = "blackhole-resume";
+export const MID_RUN_RESUME_MESSAGE =
+	"Context was auto-compacted mid-task to stay under the token threshold. "
+	+ "The summary above preserves prior progress. Continue the task from where you left off.";
+
+/**
+ * Shared config gating for auto-compaction (agent_end and turn_end paths).
+ * Returns null when compaction may proceed, or a skip reason string.
+ */
+function autoCompactionSkipReason(runtime: Runtime): string | null {
+	if (runtime.config.compaction === "off") return "compaction_off";
+	if (runtime.config.compaction === "manual") return "compaction_manual";
+	if (runtime.config.compactionEngine === "pi-default") return "compactionEngine_pi_default";
+	// NOTE: memory does not gate compaction — memory:false + compaction:auto = compact without OM
+
+	// LEGACY: old config key guards — only apply when new keys are absent (unmigrated config)
+	if (runtime.config.compaction === undefined && runtime.config.compactionEngine === undefined) {
+		if (runtime.config.passive === true) return "passive";
+		if (runtime.config.noAutoCompact === true) return "noAutoCompact";
+		// Don't force Pi to compact unless the user explicitly opted into blackhole's pipeline.
+		if (runtime.config.overrideDefaultCompaction === false) return "overrideDefaultCompaction_false";
+	}
+	return null;
+}
+
 export function registerCompactionTrigger(pi: ExtensionAPI, runtime: Runtime): void {
 	pi.on("agent_start", () => {
 		// Reset the info gate — allow one info notification during the new turn.
@@ -49,6 +79,106 @@ export function registerCompactionTrigger(pi: ExtensionAPI, runtime: Runtime): v
 			throw error;
 		}
 	});
+
+	// Mid-run trigger: turn_end fires after every assistant-message + tool-execution
+	// cycle while the agent is still working. agent_end only fires when the run
+	// exits, so during long tool loops the threshold would otherwise never be
+	// evaluated (the configured compactAfterTokens could be exceeded many times
+	// over before compaction had a chance to run).
+	pi.on("turn_end", (_event: any, ctx: any) => {
+		try {
+			handleTurnEnd(ctx, runtime, pi);
+		} catch (error) {
+			if (isStaleExtensionContextError(error)) return;
+			throw error;
+		}
+	});
+}
+
+function handleTurnEnd(ctx: any, runtime: Runtime, pi: ExtensionAPI): void {
+	runtime.ensureConfig(ctx.cwd, (msg) => ctx.ui?.notify?.(msg, "warning"));
+	const dbg = (ev: string, d?: Record<string, unknown>) => debugLog(ev, d, runtime.config.debugLog === true);
+
+	const mode = runtime.config.midRunCompaction ?? "resume";
+	if (mode === "off") {
+		dbg("compaction_trigger.turn_end.skip", { reason: "midRunCompaction_off" });
+		return;
+	}
+	const skipReason = autoCompactionSkipReason(runtime);
+	if (skipReason) {
+		dbg("compaction_trigger.turn_end.skip", { reason: skipReason });
+		return;
+	}
+	if (runtime.compactInFlight) {
+		dbg("compaction_trigger.turn_end.skip", { reason: "compactInFlight" });
+		return;
+	}
+
+	const entries = ctx.sessionManager.getBranch() as Entry[];
+	const tokens = rawTokensSinceLastCompaction(entries);
+	if (tokens < runtime.config.compactAfterTokens) {
+		// Pressure relieved (a compaction ran) — lift any failure suspension.
+		runtime.midRunCompactionSuspended = false;
+		return;
+	}
+	if (runtime.midRunCompactionSuspended) {
+		// A previous mid-run attempt failed/cancelled at this pressure level.
+		// Re-triggering every turn would thrash (each attempt aborts the run).
+		// Stay suspended until a compaction lowers pressure below the threshold.
+		dbg("compaction_trigger.turn_end.skip", { reason: "suspended_after_failure", tokens });
+		return;
+	}
+
+	const hasUI = ctx.hasUI;
+	const ui = ctx.ui;
+	dbg("compaction_trigger.turn_end.threshold_reached", { tokens, threshold: runtime.config.compactAfterTokens, mode });
+	runtime.tryEmitInfo(hasUI, ui,
+		`Observational memory: compaction threshold reached mid-run (~${tokens.toLocaleString()} tokens); compacting${mode === "resume" ? " and resuming" : ""}`);
+
+	// ctx.compact() aborts the in-flight agent run before compacting — that is
+	// the intended trade: turn_end is a clean boundary (tool results are already
+	// persisted; at most one just-started LLM call is wasted).
+	runtime.compactInFlight = true;
+	ctx.compact({
+		onComplete: (_result: any) => {
+			runtime.compactInFlight = false;
+			dbg("compaction_trigger.turn_end.onComplete", { mode });
+			if (mode === "resume") {
+				try {
+					pi.sendMessage(
+						{ customType: MID_RUN_RESUME_CUSTOM_TYPE, content: MID_RUN_RESUME_MESSAGE, display: true },
+						{ triggerTurn: true },
+					);
+				} catch (error) {
+					if (!isStaleExtensionContextError(error)) throw error;
+				}
+			}
+			runtime.tryEmitInfo(hasUI, ui, "Observational memory: mid-run compaction complete");
+		},
+		onError: (error: { message: string }) => {
+			runtime.compactInFlight = false;
+			// Don't retry at this pressure level — the next attempt would abort the
+			// run again just to fail the same way. Cleared when pressure drops.
+			runtime.midRunCompactionSuspended = true;
+			dbg("compaction_trigger.turn_end.onError", { message: error?.message ?? String(error) });
+			if (error.message !== "Compaction cancelled") {
+				notifySafely(hasUI, ui, `Observational memory: mid-run compaction failed: ${error.message}`, "error");
+			}
+			// ctx.compact() already aborted the run. In resume mode the agent must
+			// continue regardless of the failed compaction — otherwise it stalls
+			// mid-task with no one at the wheel.
+			if (mode === "resume") {
+				try {
+					pi.sendMessage(
+						{ customType: MID_RUN_RESUME_CUSTOM_TYPE, content: MID_RUN_RESUME_MESSAGE, display: true },
+						{ triggerTurn: true },
+					);
+				} catch (sendError) {
+					if (!isStaleExtensionContextError(sendError)) throw sendError;
+				}
+			}
+		},
+	});
 }
 
 function handleAgentEnd(event: any, ctx: any, runtime: Runtime): void {
@@ -70,39 +200,12 @@ function handleAgentEnd(event: any, ctx: any, runtime: Runtime): void {
 			compactAfterTokens: runtime.config.compactAfterTokens,
 		});
 
-		// NEW: Unified compaction guards
-		if (runtime.config.compaction === "off") {
-			dbg("compaction_trigger.skip", { reason: "compaction_off" });
+		// Unified + legacy compaction guards (shared with the turn_end path)
+		const skipReason = autoCompactionSkipReason(runtime);
+		if (skipReason) {
+			dbg("compaction_trigger.skip", { reason: skipReason });
 			return;
 		}
-		if (runtime.config.compaction === "manual") {
-			dbg("compaction_trigger.skip", { reason: "compaction_manual" });
-			return;
-		}
-		if (runtime.config.compactionEngine === "pi-default") {
-			dbg("compaction_trigger.skip", { reason: "compactionEngine_pi_default" });
-			return;
-		}
-		// NOTE: memory no longer gates compaction — memory:false + compaction:auto = compact without OM
-
-		// LEGACY: old config key guards — only apply when new keys are absent (unmigrated config)
-		if (runtime.config.compaction === undefined && runtime.config.compactionEngine === undefined) {
-			if (runtime.config.passive === true) {
-				dbg("compaction_trigger.skip", { reason: "passive" });
-				return;
-			}
-			if (runtime.config.noAutoCompact === true) {
-				dbg("compaction_trigger.skip", { reason: "noAutoCompact" });
-				return;
-			}
-			// Don't force Pi to compact unless the user explicitly opted into blackhole's pipeline.
-			// When overrideDefaultCompaction is false (default), blackhole stays out of the way
-			// and lets Pi handle its own compaction naturally.
-			if (runtime.config.overrideDefaultCompaction === false) {
-				dbg("compaction_trigger.skip", { reason: "overrideDefaultCompaction_false" });
-				return;
-			}
-		}
 		if (runtime.compactInFlight) {
 			dbg("compaction_trigger.skip", { reason: "compactInFlight" });
 			return;

package/src/om/configure-overlay.ts

@@ -44,6 +44,8 @@ const FIELDS: FieldDef[] = [
 		helpText: "blackhole=structured summary+OM, pi-default=built-in Pi summarization" },
 	{ key: "tailBehavior", label: "Visible tail", type: "enum", section: "Compaction", enumValues: ["minimal", "pi-default"],
 		helpText: "minimal=keep last user message only (default), pi-default=keep Pi's preserved visible context" },
+	{ key: "midRunCompaction", label: "Mid-run compaction", type: "enum", section: "Compaction", enumValues: ["resume", "pause", "off"],
+		helpText: "resume=compact at threshold during tool loops and continue (default), pause=compact and stop, off=only check when run ends" },
 	{ key: "compactAfterTokens", label: "Auto-compact threshold", type: "number", section: "Compaction",
 		helpText: "Token count that triggers auto-compaction when reached" },
 

package/src/om/consolidation.ts

@@ -15,7 +15,7 @@ import type { ModelThinkingLevel } from "@earendil-works/pi-ai";
 import type { ConfiguredModel } from "./config.js";
 import { debugLog, withDebugLogContext } from "./debug-log.js";
 import { type ResolveResult, type Runtime } from "./runtime.js";
-import { isRetryableError } from "./retryable-error.js";
+import { isRetryableError, isStaleExtensionContextError } from "./retryable-error.js";
 import { effectiveContextWindow } from "./model-budget.js";
 import { serializeSourceAddressedBranchEntries } from "./serialize.js";
 
@@ -430,12 +430,24 @@ function maybeLaunchConsolidation(pi: ExtensionAPI, runtime: Runtime, ctx: Conso
 	if (runtime.isConsolidationRetryGated()) return;
 
 	// Load and validate cursors from pending file (once per session; re-load on fork)
-	const sessionId = ctx.sessionManager.getSessionId();
+	let sessionId: string;
+	try {
+		sessionId = ctx.sessionManager.getSessionId();
+	} catch (error) {
+		if (isStaleExtensionContextError(error)) return;
+		throw error;
+	}
 	if (runtime.cursorsLoadedSessionId !== sessionId) {
 		if (typeof runtime.loadCursorsFromPending === "function") {
 			runtime.loadCursorsFromPending(sessionId);
 		}
-		const entries = ctx.sessionManager.getBranch() as Entry[];
+		let entries: Entry[];
+		try {
+			entries = ctx.sessionManager.getBranch() as Entry[];
+		} catch (error) {
+			if (isStaleExtensionContextError(error)) return;
+			throw error;
+		}
 		validateCursors(entries, runtime);
 		runtime.cursorsLoadedSessionId = sessionId;
 		const c = runtime.cursors ?? {};
@@ -446,7 +458,13 @@ function maybeLaunchConsolidation(pi: ExtensionAPI, runtime: Runtime, ctx: Conso
 		});
 	}
 
-	const entries = ctx.sessionManager.getBranch() as Entry[];
+	let entries: Entry[];
+	try {
+		entries = ctx.sessionManager.getBranch() as Entry[];
+	} catch (error) {
+		if (isStaleExtensionContextError(error)) return;
+		throw error;
+	}
 	// In manual mode, the branch has no OM markers — pending state provides
 	// pool fullness and new‑data visibility for reflector/dropper checks.
 	const pending = runtime.config.noAutoCompact ? readPendingState(sessionId) : undefined;
@@ -509,7 +527,16 @@ export async function runConsolidationPipeline(
 	}
 
 	// Flush cursors to pending file after all stages complete (non‑blocking)
-	const sessionId = ctx.sessionManager.getSessionId();
+	let sessionId: string;
+	try {
+		sessionId = ctx.sessionManager.getSessionId();
+	} catch (error) {
+		if (isStaleExtensionContextError(error)) {
+			debugLog("pipeline.stale_ctx", { error: String(error) });
+			return;
+		}
+		throw error;
+	}
 	runtime.scheduleCursorFlush(sessionId);
 	const c = runtime.cursors ?? {};
 	debugLog("cursor.saved", {
@@ -527,8 +554,18 @@ async function runObserverStage(
 	ctx: ConsolidationCtx,
 	resolveModel: (stage: "observer") => Promise<ResolvedModel | undefined>,
 ): Promise<StageOutcome> {
-	const entries = ctx.sessionManager.getBranch() as Entry[];
-	const sessionId = ctx.sessionManager.getSessionId();
+	let entries: Entry[];
+	let sessionId: string;
+	try {
+		entries = ctx.sessionManager.getBranch() as Entry[];
+		sessionId = ctx.sessionManager.getSessionId();
+	} catch (error) {
+		if (isStaleExtensionContextError(error)) {
+			debugLog("observer.stale_ctx", { error: String(error) });
+			return "abort";
+		}
+		throw error;
+	}
 
 	// Determine start index: cursor takes priority, fall back to coverage markers
 	const observerCursor = runtime.getCursor("observer");
@@ -692,6 +729,10 @@ async function runObserverStage(
 			}
 			return "continue";
 		} catch (error) {
+			if (isStaleExtensionContextError(error)) {
+				debugLog("observer.stale_ctx", { error: String(error) });
+				return "abort";
+			}
 			// Always try next fallback — don't abort pipeline for a single model failure.
 			// Record cooldown so resolveModel skips this model in the next iteration.
 			const candidateConfig = runtime.findCandidateConfig(resolved.model, { model: ctx.model, modelRegistry: ctx.modelRegistry, hasUI: ctx.hasUI, ui: ctx.ui, stageModel: stageModelConfig(runtime, "observer"), stageFallbacks: stageFallbackModels(runtime, "observer") });
@@ -715,8 +756,18 @@ async function runReflectorStage(
 	ctx: ConsolidationCtx,
 	resolveModel: (stage: "reflector") => Promise<ResolvedModel | undefined>,
 ): Promise<ReflectorStageResult> {
-	const sessionId = ctx.sessionManager.getSessionId();
-	const entries = ctx.sessionManager.getBranch() as Entry[];
+	let entries: Entry[];
+	let sessionId: string;
+	try {
+		entries = ctx.sessionManager.getBranch() as Entry[];
+		sessionId = ctx.sessionManager.getSessionId();
+	} catch (error) {
+		if (isStaleExtensionContextError(error)) {
+			debugLog("reflector.stale_ctx", { error: String(error) });
+			return { outcome: "abort", sameRunReflections: [] };
+		}
+		throw error;
+	}
 	let reflectionTokens = 0;
 	let observationCoverageId: string | undefined;
 	if (runtime.config.noAutoCompact) {
@@ -847,6 +898,10 @@ async function runReflectorStage(
 				effectiveReflectionCoverageId: data.coversUpToId,
 			};
 		} catch (error) {
+			if (isStaleExtensionContextError(error)) {
+				debugLog("reflector.stale_ctx", { error: String(error) });
+				return { outcome: "abort", sameRunReflections: [] };
+			}
 			const candidateConfig = runtime.findCandidateConfig(resolved.model, { model: ctx.model, modelRegistry: ctx.modelRegistry, hasUI: ctx.hasUI, ui: ctx.ui, stageModel: stageModelConfig(runtime, "reflector"), stageFallbacks: stageFallbackModels(runtime, "reflector") });
 			runtime.recordRetryableError(candidateConfig, error, "reflector");
 			debugLog("reflector.error", { error: String(error), retryable: isRetryableError(error) });
@@ -868,8 +923,18 @@ async function runDropperStage(
 	sameRunReflections: Reflection[],
 	sameRunReflectionCoverageId: string | undefined,
 ): Promise<StageOutcome> {
-	const sessionId = ctx.sessionManager.getSessionId();
-	const entries = ctx.sessionManager.getBranch() as Entry[];
+	let entries: Entry[];
+	let sessionId: string;
+	try {
+		entries = ctx.sessionManager.getBranch() as Entry[];
+		sessionId = ctx.sessionManager.getSessionId();
+	} catch (error) {
+		if (isStaleExtensionContextError(error)) {
+			debugLog("dropper.stale_ctx", { error: String(error) });
+			return "abort";
+		}
+		throw error;
+	}
 	let dropTokens = 0;
 	let observationCoverageId: string | undefined;
 	if (runtime.config.noAutoCompact) {
@@ -989,6 +1054,10 @@ async function runDropperStage(
 			}
 			return "continue";
 		} catch (error) {
+			if (isStaleExtensionContextError(error)) {
+				debugLog("dropper.stale_ctx", { error: String(error) });
+				return "abort";
+			}
 			const candidateConfig = runtime.findCandidateConfig(resolved.model, { model: ctx.model, modelRegistry: ctx.modelRegistry, hasUI: ctx.hasUI, ui: ctx.ui, stageModel: stageModelConfig(runtime, "dropper"), stageFallbacks: stageFallbackModels(runtime, "dropper") });
 			runtime.recordRetryableError(candidateConfig, error, "dropper");
 			debugLog("dropper.error", { error: String(error), retryable: isRetryableError(error) });

package/src/om/retryable-error.ts

@@ -24,3 +24,17 @@ export function isRetryableError(error: unknown): boolean {
  * @see @earendil-works/pi-ai/dist/utils/overflow.d.ts
  */
 export { isContextOverflow } from "@earendil-works/pi-ai";
+
+/** Detect Pi's "extension ctx is stale" error from session replacement/reload.
+ *  These are not model errors and must not be recorded as cooldowns. */
+export function isStaleExtensionContextError(error: unknown): boolean {
+	let message: string;
+	if (error instanceof Error) {
+		message = error.message;
+	} else if (error && typeof error === "object" && "message" in error) {
+		message = String((error as { message: unknown }).message);
+	} else {
+		message = String(error || "");
+	}
+	return message.includes("extension ctx is stale") || message.includes("ctx is stale");
+}

package/src/om/runtime.ts

@@ -10,6 +10,7 @@
  * - markConsolidationError sets 30s retry gate for failed runs.
  */
 import { type Config, type ConfiguredModel, DEFAULTS, loadConfig } from "./config.js";
+import type { CompactionStats } from "../hooks/before-compact.js";
 import { isCooldownActive, getCooldownEntry, recordCooldown, expireCooldowns, modelKey } from "./cooldown.js";
 import { readPendingCursors, writePendingCursors } from "./pending.js";
 import type { PendingOMState } from "./pending.js";
@@ -73,6 +74,10 @@ export class Runtime {
 	 * Set when handleAgentEnd schedules a wait; cleared on abort, success, or terminal bail.
 	 * agent_start handlers read this to abort the pending wait when a new turn starts. */
 	autoCompactionController: AbortController | null = null;
+	/** Mid-run (turn_end) compaction is suspended after a failed/cancelled attempt
+	 * at the current pressure level. Cleared when accumulated tokens drop below
+	 * the threshold again (i.e. a compaction ran). Prevents abort/cancel thrash. */
+	midRunCompactionSuspended = false;
 	resolveFailureNotified = false;
 	lastObserverError: string | undefined;
 	lastReflectorError: string | undefined;
@@ -80,7 +85,7 @@ export class Runtime {
 	/** Epoch ms of the last failed consolidation run (any stage). */
 	lastConsolidationErrorAt: number | undefined;
 	/** Stats from the most recent compaction run (session-scoped via handler closure). */
-	compactionStats: { summarized: number; kept: number; keptTokensEst: number } | null = null;
+	compactionStats: CompactionStats | null = null;
 	/** Whether the most recent compaction was triggered by /blackhole (vs auto-compact). */
 	compactWasPiVcc = false;
 	/** In‑memory pipeline cursors — authoritative copy for gating decisions. */
@@ -369,7 +374,13 @@ export class Runtime {
 		if (phase === "observer") this.lastObserverError = message;
 		if (phase === "reflector") this.lastReflectorError = message;
 		if (phase === "dropper") this.lastDropperError = message;
-		if (ctx.hasUI && ctx.ui) ctx.ui.notify(`Observational memory: ${phase} failed: ${message}`, "warning");
+		if (ctx.hasUI && ctx.ui) {
+			try {
+				ctx.ui.notify(`Observational memory: ${phase} failed: ${message}`, "warning");
+			} catch {
+				// Stale extension context — harmless.
+			}
+		}
 		this.markConsolidationError();
 		return message;
 	}
@@ -388,7 +399,13 @@ export class Runtime {
 				await work();
 			} catch (error) {
 				errorMessage = error instanceof Error ? error.message : String(error);
-				if (hasUI && ui) ui.notify(`Observational memory: ${label} failed: ${errorMessage}`, "warning");
+				if (hasUI && ui) {
+					try {
+						ui.notify(`Observational memory: ${label} failed: ${errorMessage}`, "warning");
+					} catch {
+						// Stale extension context — harmless.
+					}
+				}
 			} finally {
 				onFinally(errorMessage);
 			}