pi-blackhole 0.2.0 → 0.2.2

package/README.md

@@ -131,6 +131,7 @@ The tradeoff is simplicity vs cleanliness:
 |---|---|---|
 | Workers run? | Yes | Yes |
 | Observations go to | Conversation markers (invisible in TUI) | Disk (`pending.json`) |
+| Observations accumulate across runs | Branch markers (replaced each cycle) | Pending batches — `/memory` shows pending counts |
 | Auto-compact on `agent_end` | Yes | No |
 | `/blackhole` | Optional — use it whenever you want | Required to flush + compact |
 | Conversation history | OM marker entries between turns (they exist but do not clutter the display) | Clean — nothing between turns |
@@ -170,7 +171,7 @@ Set `memory: false` or run `/blackhole om-off` for pure pi-vcc compaction — no
 
 ## Configuration
 
-All settings in **`~/.pi/agent/pi-blackhole-config.json`** — auto-created with defaults on first startup. See [`CONFIG.md`](CONFIG.md) for the full reference and tuning guidance.
+All settings in **`~/.pi/agent/pi-blackhole/pi-blackhole-config.json`** — auto-created with defaults on first startup. See [`CONFIG.md`](CONFIG.md) for the full reference and tuning guidance. An annotated example config with explanations is at [`example-config.json`](example-config.json).
 
 Quick start with custom models:
 
@@ -198,6 +199,7 @@ Quick start with custom models:
 | `reflectAfterTokens` | `20000` | Token cadence for reflector and dropper |
 | `compactAfterTokens` | `81000` | Auto-compaction threshold |
 | `observerChunkMaxTokens` | `40000` | Max observer input per run (newest-first) |
+| `observerPreambleMaxTokens` | `0` (auto) | Max preamble tokens in observer prompt for `noAutoCompact` mode (auto = 30% of chunk) |
 | `observationsPoolMaxTokens` | `20000` | Max active observation pool before dropper prunes |
 | `reflectorInputMaxTokens` | `80000` | Max reflector input budget |
 | `dropperInputMaxTokens` | `80000` | Max dropper input budget |
@@ -220,6 +222,7 @@ Paste the appropriate block into your config to match your model's context size.
   "reflectAfterTokens": 10000,
   "compactAfterTokens": 30000,
   "observerChunkMaxTokens": 15000,
+  "observerPreambleMaxTokens": 0,
   "observationsPoolMaxTokens": 8000,
   "reflectorInputMaxTokens": 30000,
   "dropperInputMaxTokens": 30000
@@ -236,6 +239,7 @@ Our built-in defaults already target this tier. If you reset your config, these
   "reflectAfterTokens": 20000,
   "compactAfterTokens": 81000,
   "observerChunkMaxTokens": 40000,
+  "observerPreambleMaxTokens": 0,
   "observationsPoolMaxTokens": 20000,
   "reflectorInputMaxTokens": 80000,
   "dropperInputMaxTokens": 80000
@@ -250,6 +254,7 @@ Our built-in defaults already target this tier. If you reset your config, these
   "reflectAfterTokens": 40000,
   "compactAfterTokens": 180000,
   "observerChunkMaxTokens": 80000,
+  "observerPreambleMaxTokens": 0,
   "observationsPoolMaxTokens": 40000,
   "reflectorInputMaxTokens": 160000,
   "dropperInputMaxTokens": 160000
@@ -354,7 +359,7 @@ pnpm add pi-blackhole
 
 ```bash
 pi uninstall git:github.com/k0valik/pi-blackhole
-rm -rf ~/.pi/agent/pi-blackhole ~/.pi/agent/pi-blackhole-config.json
+rm -rf ~/.pi/agent/pi-blackhole
 ```
 
 ---

package/example-config.json

@@ -86,13 +86,14 @@
     }
   ],
 
-  "observeAfterTokens": 10000,
-  "reflectAfterTokens": 20000,
+  "observeAfterTokens": 15000,
+  "reflectAfterTokens": 25000,
   "compactAfterTokens": 81000,
   "observationsPoolMaxTokens": 20000,
   "reflectorInputMaxTokens": 80000,
   "dropperInputMaxTokens": 80000,
   "observerChunkMaxTokens": 40000,
+  "observerPreambleMaxTokens": 0,
   "agentMaxTurns": 16,
 
   "passive": false,
@@ -110,6 +111,16 @@
     "After all candidates exhausted, the stage aborts. 30s retry gate prevents spam.",
     "Cooldowns persist in ~/.pi/agent/pi-blackhole/pi-blackhole-cooldown.json (survives pi restarts).",
     "Valid thinking values: off, minimal, low, medium, high, xhigh.",
-    "Env override for passive mode: PI_BLACKHOLE_PASSIVE=true."
+    "Env override for passive mode: PI_BLACKHOLE_PASSIVE=true.",
+    "",
+    "noAutoCompact mode accumulates observationBatches/reflectionBatches in",
+    "pending.json across pipeline runs. The observer preamble (CURRENT OBSERVATIONS)",
+    "is capped to observerPreambleMaxTokens (default 0 = auto 30% of observerChunkMaxTokens).",
+    "This is a soft safety valve — it only trims when accumulated observations exceed",
+    "the budget. High-relevance observations are always kept. Reflections are never trimmed.",
+    "",
+    "agentMaxTurns controls how many agent-loop turns each worker gets per chunk.",
+    "Lower-context models can reduce this (e.g., 8) so the observer doesn't waste",
+    "turns trying to extract more than it can reliably handle per run."
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-blackhole",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Unified compaction + observational memory extension for Pi — compresses conversation context while preserving durable observations and reflections",
   "license": "MIT",
   "main": "index.ts",
@@ -36,12 +36,12 @@
     "type": "git",
     "url": "git+https://github.com/k0valik/pi-blackhole.git"
   },
-  "dependencies": {
-    "@earendil-works/pi-agent-core": "0.75.5",
-    "@earendil-works/pi-ai": "0.75.4",
-    "@earendil-works/pi-coding-agent": "0.75.4",
-    "@earendil-works/pi-tui": "0.75.5",
-    "typebox": "^1.1.38"
+  "dependencies": {},
+  "peerDependencies": {
+    "@earendil-works/pi-agent-core": ">=0.75.5 <1.0.0",
+    "@earendil-works/pi-ai": ">=0.75.4 <1.0.0",
+    "@earendil-works/pi-coding-agent": ">=0.75.4 <1.0.0",
+    "@earendil-works/pi-tui": ">=0.75.5 <1.0.0"
   },
   "pi": {
     "extensions": [
@@ -49,6 +49,11 @@
     ]
   },
   "devDependencies": {
+    "@earendil-works/pi-agent-core": "0.75.5",
+    "@earendil-works/pi-ai": "0.75.4",
+    "@earendil-works/pi-coding-agent": "0.75.4",
+    "@earendil-works/pi-tui": "0.75.5",
+    "typebox": "^1.1.38",
     "typescript": "^5.7.3",
     "vitest": "^4.1.7"
   }

package/src/commands/memory.ts

@@ -9,9 +9,11 @@ import { copyTextToClipboard } from "../om/clipboard.js";
 import type { Runtime } from "../om/runtime.js";
 import {
 	diffProjection,
+	entryIndexForId,
 	foldLedger,
 	fullProjection,
 	observationToSummaryLine,
+	rawTokensAfterIndex,
 	rawTokensSinceDropCoverage,
 	rawTokensSinceLastCompaction,
 	rawTokensSinceObservationCoverage,
@@ -125,11 +127,29 @@ export function registerMemoryCommand(pi: ExtensionAPI, runtime: Runtime): void
 				`Reflections:  ${folded.reflections.length} recorded / ${visible.reflections.length} visible`,
 				[addedSuffix(drift.reflectionsOnlyInFull.length)],
 			);
-			const obsProgress = rawTokensSinceObservationCoverage(entries);
-			const reflectionProgress = rawTokensSinceReflectionCoverage(entries);
-			const dropProgress = rawTokensSinceDropCoverage(entries);
+			let obsProgress = rawTokensSinceObservationCoverage(entries);
+			let reflectionProgress = rawTokensSinceReflectionCoverage(entries);
+			let dropProgress = rawTokensSinceDropCoverage(entries);
 			const compactionProgress = rawTokensSinceLastCompaction(entries);
 
+			// In noAutoCompact mode, pending coversUpToId entries act as virtual coverage markers
+			// that aren't reflected in the branch. Adjust accumulated counts accordingly.
+			if (runtime.config.noAutoCompact) {
+				const pending = readPendingState(sessionId);
+				if (pending.observation?.coversUpToId) {
+					const idx = entryIndexForId(entries, pending.observation.coversUpToId);
+					if (idx >= 0) obsProgress = rawTokensAfterIndex(entries, idx);
+				}
+				if (pending.reflection?.coversUpToId) {
+					const idx = entryIndexForId(entries, pending.reflection.coversUpToId);
+					if (idx >= 0) reflectionProgress = rawTokensAfterIndex(entries, idx);
+				}
+				if (pending.dropped?.coversUpToId) {
+					const idx = entryIndexForId(entries, pending.dropped.coversUpToId);
+					if (idx >= 0) dropProgress = rawTokensAfterIndex(entries, idx);
+				}
+			}
+
 			const passiveLines = runtime.config.passive === true
 				? [
 					"── Mode ──",
@@ -144,11 +164,12 @@ export function registerMemoryCommand(pi: ExtensionAPI, runtime: Runtime): void
 				observationLine,
 				reflectionLine,
 				"",
-				"── Activity ──",
-				`Observer:       ~${obsProgress.toLocaleString()} / ${runtime.config.observeAfterTokens.toLocaleString()} tokens (${pct(obsProgress, runtime.config.observeAfterTokens)}%)`,
-				`Reflector:      ~${reflectionProgress.toLocaleString()} / ${runtime.config.reflectAfterTokens.toLocaleString()} tokens (${pct(reflectionProgress, runtime.config.reflectAfterTokens)}%)`,
-				`Dropper:        ~${dropProgress.toLocaleString()} / ${runtime.config.reflectAfterTokens.toLocaleString()} tokens (${pct(dropProgress, runtime.config.reflectAfterTokens)}%)`,
-				`Compaction:     ~${compactionProgress.toLocaleString()} / ${runtime.config.compactAfterTokens.toLocaleString()} tokens (${pct(compactionProgress, runtime.config.compactAfterTokens)}%)`,
+				"── Pipeline ──",
+				"Transcript accumulated since last run. Triggers when exceeding threshold.",
+				`Observer:       ~${obsProgress.toLocaleString()} tokens (triggers at ${runtime.config.observeAfterTokens.toLocaleString()})`,
+				`Reflector:      ~${reflectionProgress.toLocaleString()} tokens (triggers at ${runtime.config.reflectAfterTokens.toLocaleString()})`,
+				`Dropper:        ~${dropProgress.toLocaleString()} tokens (triggers at ${runtime.config.reflectAfterTokens.toLocaleString()})`,
+				`Compaction:     ~${compactionProgress.toLocaleString()} tokens` + (runtime.config.noAutoCompact ? " [auto-disabled]" : ` (triggers at ${runtime.config.compactAfterTokens.toLocaleString()})`),
 				`Obs pool:       ~${visibleObservationTokens.toLocaleString()} / ${runtime.config.observationsPoolMaxTokens.toLocaleString()} tokens (${pct(visibleObservationTokens, runtime.config.observationsPoolMaxTokens)}%)`,
 				`Reflect pool:   ~${visibleReflectionTokens.toLocaleString()} tokens`,
 			];
@@ -164,6 +185,13 @@ export function registerMemoryCommand(pi: ExtensionAPI, runtime: Runtime): void
 					if (hasObs) lines.push("Observation:  waiting in pending.json");
 					if (hasRef) lines.push("Reflection:   waiting in pending.json");
 					if (hasDrop) lines.push("Dropper:      waiting in pending.json");
+					const preambleCap = runtime.config.observerPreambleMaxTokens > 0
+						? runtime.config.observerPreambleMaxTokens
+						: Math.round(runtime.config.observerChunkMaxTokens * 0.3);
+					const pctNote = runtime.config.observerPreambleMaxTokens > 0
+						? ""
+						: ` (30% of ${runtime.config.observerChunkMaxTokens.toLocaleString()} chunk)`;
+					lines.push(`Preamble cap: ${preambleCap.toLocaleString()} tokens for observations${pctNote}`);
 					lines.push("Run /blackhole to flush and compact.");
 				}
 			}

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 { getLastCompactionStats, PI_VCC_COMPACT_INSTRUCTION } from "../hooks/before-compact";
+import { PI_VCC_COMPACT_INSTRUCTION } from "../hooks/before-compact";
 import { saveUnifiedConfig } from "../core/unified-config.js";
 import { readPendingState, clearPendingState, hasPendingData } from "../om/pending.js";
 import {
@@ -55,14 +55,29 @@ export const registerPiVccCommand = (pi: ExtensionAPI, runtime: Runtime) => {
 			// before compacting so the summary includes accumulated memory.
 			if (runtime.config.noAutoCompact && hasPendingData(sessionId)) {
 				const pending = readPendingState(sessionId);
-				if (pending.observation) {
-					pi.appendEntry(OM_OBSERVATIONS_RECORDED, pending.observation.data);
+				// Write all accumulated observation batches (or latest single batch
+				// as fallback for legacy pending.json without batch arrays).
+				const obsBatches = pending.observationBatches?.length
+					? pending.observationBatches
+					: (pending.observation ? [pending.observation] : []);
+				for (const batch of obsBatches) {
+					pi.appendEntry(OM_OBSERVATIONS_RECORDED, batch.data);
 				}
-				if (pending.reflection) {
-					pi.appendEntry(OM_REFLECTIONS_RECORDED, pending.reflection.data);
+				// Write all accumulated reflection batches (or latest single batch
+				// as fallback for legacy pending.json without batch arrays).
+				const reflBatches = pending.reflectionBatches?.length
+					? pending.reflectionBatches
+					: (pending.reflection ? [pending.reflection] : []);
+				for (const batch of reflBatches) {
+					pi.appendEntry(OM_REFLECTIONS_RECORDED, batch.data);
 				}
-				if (pending.dropped) {
-					pi.appendEntry(OM_OBSERVATIONS_DROPPED, pending.dropped.data);
+				// Write all accumulated dropper batches (or latest single batch
+				// as fallback for legacy pending.json without batch arrays).
+				const dropBatches = pending.droppedBatches?.length
+					? pending.droppedBatches
+					: (pending.dropped ? [pending.dropped] : []);
+				for (const batch of dropBatches) {
+					pi.appendEntry(OM_OBSERVATIONS_DROPPED, batch.data);
 				}
 				clearPendingState(sessionId);
 				ctx.ui.notify("Observational memory: pending entries flushed", "info");
@@ -71,7 +86,7 @@ export const registerPiVccCommand = (pi: ExtensionAPI, runtime: Runtime) => {
 			ctx.compact({
 				customInstructions: PI_VCC_COMPACT_INSTRUCTION,
 				onComplete: () => {
-					const stats = getLastCompactionStats();
+					const stats = runtime.compactionStats;
 					if (stats) {
 						ctx.ui.notify(
 							`blackhole: ${stats.summarized} source entries processed; tail kept ${stats.kept} (~${formatTokens(stats.keptTokensEst)} tok).`,

package/src/core/brief.ts

@@ -19,8 +19,38 @@ const isNoiseUser = (text: string): boolean => {
 
 // ── truncation ──
 
-// Unicode-aware word segmentation via Intl.Segmenter (built-in, zero dependency)
-const segmenter = new Intl.Segmenter(undefined, { granularity: "word" });
+// Unicode-aware word segmentation via Intl.Segmenter with lazy init & fallback
+let _segmenter: Intl.Segmenter | null | undefined = undefined;
+const wordSegments = (text: string): Array<{ segment: string; index: number; isWordLike?: boolean }> => {
+  // Available: fast path
+  if (_segmenter) return Array.from(_segmenter.segment(text));
+  // Fallback already established: don't retry the constructor
+  if (_segmenter === null) {
+    const parts: Array<{ segment: string; index: number; isWordLike?: boolean }> = [];
+    let idx = 0;
+    for (const part of text.split(/(\s+)/)) {
+      if (!part) continue;
+      parts.push({ segment: part, index: idx, isWordLike: /\S/.test(part) });
+      idx += part.length;
+    }
+    return parts;
+  }
+  // _segmenter === undefined: first call — attempt construction
+  try {
+    _segmenter = new Intl.Segmenter(undefined, { granularity: "word" });
+    return Array.from(_segmenter.segment(text));
+  } catch {
+    _segmenter = null; // permanently fallback
+    const parts: Array<{ segment: string; index: number; isWordLike?: boolean }> = [];
+    let idx = 0;
+    for (const part of text.split(/(\s+)/)) {
+      if (!part) continue;
+      parts.push({ segment: part, index: idx, isWordLike: /\S/.test(part) });
+      idx += part.length;
+    }
+    return parts;
+  }
+};
 
 /** Check if segment is a word (Bun's isWordLike is unreliable for alphanumeric tokens) */
 const isWord = (seg: { segment: string; isWordLike?: boolean }): boolean =>
@@ -47,7 +77,7 @@ const truncateTokens = (text: string, limit: number): string => {
   const flat = text.replace(/\s+/g, " ").trim();
   let count = 0;
   let lastEnd = 0;
-  for (const seg of segmenter.segment(flat)) {
+  for (const seg of wordSegments(flat)) {
     if (isWord(seg)) {
       if (!STOP_WORDS.has(seg.segment.toLowerCase())) {
         count++;

package/src/core/load-messages.ts

@@ -15,9 +15,13 @@ export const loadAllMessages = (
 ): LoadedMessages => {
   const content = readFileSync(sessionFile, "utf-8");
   const entries: any[] = [];
+  let parseErrors = 0;
   for (const line of content.split("\n")) {
     if (!line.trim()) continue;
-    try { entries.push(JSON.parse(line)); } catch {}
+    try { entries.push(JSON.parse(line)); } catch { parseErrors++; }
+  }
+  if (parseErrors > 0) {
+    console.warn(`blackhole: ${parseErrors} malformed JSONL line(s) in ${sessionFile}`);
   }
   const rendered: RenderedEntry[] = [];
   const rawMessages: Message[] = [];

package/src/core/settings.ts

@@ -13,11 +13,6 @@ export interface PiVccSettings {
 	debug: boolean;
 }
 
-export const DEFAULT_SETTINGS: PiVccSettings = {
-	overrideDefaultCompaction: false,
-	debug: false,
-};
-
 export function loadSettings(): PiVccSettings {
 	const config = loadUnifiedConfig(process.cwd());
 	return {
@@ -30,5 +25,4 @@ export function scaffoldSettings(): void {
 	scaffoldConfig();
 }
 
-// For compatibility with code that imports saveSettings
-export { loadUnifiedConfig as loadConfig } from "./unified-config.js";
+

package/src/core/unified-config.ts

@@ -50,6 +50,11 @@ export interface UnifiedConfig {
 	dropperInputMaxTokens: number;
 	/** Max source entries tokens sent to observer per chunk. */
 	observerChunkMaxTokens: number;
+	/** Max preamble tokens (CURRENT REFLECTIONS / OBSERVATIONS) in the observer prompt.
+	 *  Default 0 means auto-compute from observerChunkMaxTokens (30%). Only applied in
+	 *  noAutoCompact mode where accumulated batch history can grow unbounded.
+	 *  Set to an explicit value to override the auto-computed budget. */
+	observerPreambleMaxTokens: number;
 	/** Shared turn cap for background memory agents. */
 	agentMaxTurns: number;
 
@@ -87,13 +92,14 @@ export const DEFAULTS: UnifiedConfig = {
 	overrideDefaultCompaction: false,
 	debug: false,
 
-	observeAfterTokens: 10_000,
-	reflectAfterTokens: 20_000,
+	observeAfterTokens: 15_000,
+	reflectAfterTokens: 25_000,
 	compactAfterTokens: 81_000,
 	observationsPoolMaxTokens: 20_000,
 	reflectorInputMaxTokens: 80_000,
 	dropperInputMaxTokens: 80_000,
 	observerChunkMaxTokens: 40_000,
+	observerPreambleMaxTokens: 0,
 	agentMaxTurns: 16,
 
 	noAutoCompact: false,
@@ -154,7 +160,7 @@ function parseConfig(raw: Record<string, unknown>): Partial<UnifiedConfig> {
 	if (typeof raw.debugLog === "boolean") c.debugLog = raw.debugLog;
 
 	// Positive integers
-	const numKeys = ["observeAfterTokens", "reflectAfterTokens", "compactAfterTokens", "observationsPoolMaxTokens", "reflectorInputMaxTokens", "dropperInputMaxTokens", "observerChunkMaxTokens", "agentMaxTurns"] as const;
+	const numKeys = ["observeAfterTokens", "reflectAfterTokens", "compactAfterTokens", "observationsPoolMaxTokens", "reflectorInputMaxTokens", "dropperInputMaxTokens", "observerChunkMaxTokens", "observerPreambleMaxTokens", "agentMaxTurns"] as const;
 	for (const k of numKeys) {
 		const v = positiveInt(raw[k]);
 		if (v !== undefined) (c as Record<string, unknown>)[k] = v;
@@ -279,7 +285,7 @@ export function scaffoldConfig(): void {
 			}
 		}
 		if (changed) writeFileSync(path, `${JSON.stringify(next, null, 2)}\n`);
-	} catch {
-		// best-effort
+	} catch (e) {
+		console.error("blackhole: config scaffold failed", e);
 	}
 }

package/src/hooks/before-compact.ts

@@ -11,30 +11,19 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { convertToLlm } from "@earendil-works/pi-coding-agent";
 import { writeFileSync } from "fs";
 import { compile } from "../core/summarize";
-import { loadSettings, type PiVccSettings } from "../core/settings";
 import type { PiVccCompactionDetails } from "../details";
 import { buildCompactionProjection, renderSummary } from "../om/ledger/index.js";
 import type { Runtime } from "../om/runtime.js";
 
 export const PI_VCC_COMPACT_INSTRUCTION = "__pi_vcc__";
 
-export interface CompactionStats {
-  summarized: number;
-  kept: number;
-  keptTokensEst: number;
-}
-
-let lastStats: CompactionStats | null = null;
-let lastCompactWasPiVcc = false;
-export const getLastCompactionStats = () => lastStats;
-
 const formatTokens = (n: number): string => {
   if (n >= 1000) return `${(n / 1000).toFixed(1)}k`;
   return String(n);
 };
 
-const dbg = (settings: PiVccSettings, data: Record<string, unknown>) => {
-  if (!settings.debug) return;
+const dbg = (debug: boolean, data: Record<string, unknown>) => {
+  if (!debug) return;
   try { writeFileSync("/tmp/pi-blackhole-debug.json", JSON.stringify(data, null, 2)); } catch {}
 };
 
@@ -151,16 +140,15 @@ const REASON_MESSAGES: Record<OwnCutCancelReason, string> = {
 export const registerBeforeCompactHook = (pi: ExtensionAPI, omRuntime: Runtime) => {
   pi.on("session_before_compact", (event, ctx) => {
     const { preparation, branchEntries, customInstructions } = event;
-    const settings = loadSettings();
+    omRuntime.ensureConfig(ctx.cwd ?? process.cwd());
 
     // Always handle explicit /blackhole marker.
     // Otherwise, only handle when user opted in via settings.
     const isPiVcc = customInstructions === PI_VCC_COMPACT_INSTRUCTION;
-    if (!isPiVcc && !settings.overrideDefaultCompaction) return;
+    if (!isPiVcc && !omRuntime.config.overrideDefaultCompaction) return;
 
     // When noAutoCompact is active, only /blackhole can trigger compaction
-    const unifiedSettings = omRuntime.config;
-    if (unifiedSettings.noAutoCompact && !isPiVcc) {
+    if (omRuntime.config.noAutoCompact && !isPiVcc) {
       return { cancel: true };
     }
 
@@ -192,7 +180,7 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI, omRuntime: Runtime)
       }
       const userIndices = liveRoles.reduce<number[]>((acc, r, i) => (r === "user" ? (acc.push(i), acc) : acc), []);
 
-      dbg(settings, {
+      dbg(omRuntime.config.debug, {
         cancelled: true,
         reason: ownCut.reason,
         isPiVcc,
@@ -250,14 +238,12 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI, omRuntime: Runtime)
       }, 0);
       return sum;
     }, 0);
-    lastStats = {
+    omRuntime.compactionStats = {
       summarized: agentMessages.length,
       kept: keptEntries.length,
       keptTokensEst: Math.round(keptChars / 4),
     };
 
-    const config = settings;
-
     const summary = compile({
       messages,
       previousSummary: preparation.previousSummary,
@@ -278,7 +264,7 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI, omRuntime: Runtime)
         }))
       : [];
 
-    dbg(config, {
+    dbg(omRuntime.config.debug, {
       usedOwnCut: true,
       messagesToSummarize: agentMessages.length,
       messagesPreviewHead: agentMessages.slice(0, 3).map((m: any) => ({ role: m.role, preview: previewContent(m.content) })),
@@ -300,10 +286,9 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI, omRuntime: Runtime)
       previousSummaryUsed: Boolean(preparation.previousSummary),
     };
 
-    lastCompactWasPiVcc = isPiVcc;
+    omRuntime.compactWasPiVcc = isPiVcc;
 
     // ── Inject observational-memory content ───────────────────────────
-    omRuntime.ensureConfig(ctx.cwd ?? process.cwd());
     let omContent = "";
     let omDetails: Record<string, unknown> | undefined;
     if (omRuntime.config.memory !== false) {
@@ -330,8 +315,8 @@ export const registerBeforeCompactHook = (pi: ExtensionAPI, omRuntime: Runtime)
   // /blackhole path uses its own onComplete callback in the command handler.
   pi.on("session_compact", (event, ctx) => {
     if (!event.fromExtension) return;
-    if (lastCompactWasPiVcc) return; // /blackhole handles its own toast via onComplete
-    const stats = lastStats;
+    if (omRuntime.compactWasPiVcc) return; // /blackhole handles its own toast via onComplete
+    const stats = omRuntime.compactionStats;
     if (!stats) return;
     setTimeout(() => {
       try {

package/src/om/compaction-trigger.ts

@@ -37,10 +37,11 @@ export function registerCompactionTrigger(pi: ExtensionAPI, runtime: Runtime): v
 		const tokens = rawTokensSinceLastCompaction(entries);
 		if (tokens < runtime.config.compactAfterTokens) return;
 
-		// Capture ctx properties synchronously — the setTimeout + async work below
+		// Capture ctx properties synchronously — the deferred callback below
 		// may outlive the extension ctx (stale after session replacement/reload).
 		const hasUI = ctx.hasUI;
 		const ui = ctx.ui;
+		const sessionId = ctx.sessionManager.getSessionId();
 
 		if (hasUI) ui?.notify(
 			`Observational memory: compaction threshold reached (~${tokens.toLocaleString()} tokens); triggering compaction`,
@@ -48,8 +49,19 @@ export function registerCompactionTrigger(pi: ExtensionAPI, runtime: Runtime): v
 		);
 
 		runtime.compactInFlight = true;
-		setTimeout(() => {
+		queueMicrotask(() => {
 			try {
+				// Validate session identity — bail if the session was replaced/reloaded.
+				const currentSessionId = ctx.sessionManager.getSessionId();
+				if (currentSessionId !== sessionId) {
+					runtime.compactInFlight = false;
+					if (hasUI) ui?.notify(
+						"Observational memory: compaction cancelled — session changed before compaction",
+						"info",
+					);
+					return;
+				}
+
 				if (!ctx.isIdle()) {
 					runtime.compactInFlight = false;
 					if (hasUI) ui?.notify(
@@ -87,6 +99,6 @@ export function registerCompactionTrigger(pi: ExtensionAPI, runtime: Runtime): v
 				const msg = error instanceof Error ? error.message : String(error);
 				if (hasUI) ui?.notify(`Observational memory: compact threw: ${msg}`, "error");
 			}
-		}, 0);
+		});
 	});
 }