pi-blackhole 0.2.0 → 0.2.1

package/README.md

@@ -170,7 +170,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:
 
@@ -354,7 +354,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-blackhole",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "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 ──",

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 {
@@ -71,7 +71,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

@@ -279,7 +279,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);
+		});
 	});
 }

package/src/om/consolidation.ts

@@ -18,6 +18,7 @@ import { type ResolveResult, type Runtime } from "./runtime.js";
 import { isRetryableError } from "./cooldown.js";
 import { serializeSourceAddressedBranchEntries } from "./serialize.js";
 import {
+	readPendingState,
 	savePendingObservation,
 	savePendingReflection,
 	savePendingDropped,
@@ -33,6 +34,7 @@ import {
 	buildObservationsRecordedData,
 	buildReflectionsRecordedData,
 	earlierCoverageMarkerId,
+	entryIndexForId,
 	foldLedger,
 	findLastCompactionIndex,
 	fullProjection,
@@ -41,6 +43,7 @@ import {
 	latestCoverageMarkerId,
 	observationsCreatedAfterIndex,
 	observationToSummaryLine,
+	rawTokensAfterIndex,
 	rawTokensSinceDropCoverage,
 	rawTokensSinceObservationCoverage,
 	rawTokensSinceReflectionCoverage,
@@ -139,8 +142,8 @@ function stageFallbackModels(runtime: Runtime, stage: "observer" | "reflector" |
 	return runtime.config.dropperFallbackModels ?? [];
 }
 
-function stageThinkingLevel(runtime: Runtime, stage: "observer" | "reflector" | "dropper"): ModelThinkingLevel {
-	const stageModel = stageModelConfig(runtime, stage);
+function stageThinkingLevel(runtime: Runtime, stage: "observer" | "reflector" | "dropper", modelConfig?: ConfiguredModel): ModelThinkingLevel {
+	const stageModel = modelConfig ?? stageModelConfig(runtime, stage);
 	return stageModel?.thinking ?? runtime.config.model?.thinking ?? "low";
 }
 
@@ -284,12 +287,23 @@ async function runObserverStage(
 		const resolved = await resolveModel("observer");
 		if (!resolved) return "abort";
 
+		// Adjust accumulated for pending coverage in noAutoCompact mode
+		let effectiveTokens = tokens;
+		if (runtime.config.noAutoCompact) {
+			const pending = readPendingState(sessionId);
+			if (pending.observation?.coversUpToId) {
+				const idx = entryIndexForId(entries, pending.observation.coversUpToId);
+				if (idx >= 0) effectiveTokens = rawTokensAfterIndex(entries, idx);
+			}
+		}
 		if (ctx.hasUI) ctx.ui?.notify(
-			`Observational memory: observer running on ~${chunkTokens.toLocaleString()}-token chunk (of ${tokens.toLocaleString()} accumulated)`,
+			`Observational memory: observer running on ~${chunkTokens.toLocaleString()}-token chunk (of ${effectiveTokens.toLocaleString()} accumulated)`,
 			"info",
 		);
 		debugLog("observer.start", { tokens, coversUpToId, sourceEntryIds, sourceEntryCount: sourceEntryIds.length, priorReflections: priorReflections.length, priorObservations: priorObservations.length });
 
+		// Resolve thinking level for the specific model (fallbacks may have their own thinking config)
+		const stageModelForThinking = runtime.findCandidateConfig(resolved.model, { model: ctx.model, modelRegistry: ctx.modelRegistry, hasUI: ctx.hasUI, ui: ctx.ui, stageModel: stageModelConfig(runtime, "observer"), stageFallbacks: stageFallbackModels(runtime, "observer") });
 		try {
 			const result = await runObserver({
 				model: resolved.model as any,
@@ -300,7 +314,7 @@ async function runObserverStage(
 				chunk,
 				allowedSourceEntryIds: sourceEntryIds,
 				maxTurns: runtime.config.agentMaxTurns,
-				thinkingLevel: stageThinkingLevel(runtime, "observer"),
+				thinkingLevel: stageThinkingLevel(runtime, "observer", stageModelForThinking),
 			});
 
 			if (result.observations && result.observations.length > 0) {
@@ -386,8 +400,19 @@ async function runReflectorStage(
 		);
 		const summaryBudget = Math.floor(runtime.config.reflectorInputMaxTokens * 0.15) * 2;
 		const reflectorInputTokens = Math.min(newItemsTokens + summaryBudget, runtime.config.reflectorInputMaxTokens);
-		if (ctx.hasUI) ctx.ui?.notify(`Observational memory: reflector running (~${reflectionTokens.toLocaleString()} tokens accumulated, ~${reflectorInputTokens.toLocaleString()}-token input)`, "info");
+		// Adjust accumulated for pending coverage in noAutoCompact mode
+		let effectiveReflectionTokens = reflectionTokens;
+		if (runtime.config.noAutoCompact) {
+			const pending = readPendingState(sessionId);
+			if (pending.reflection?.coversUpToId) {
+				const idx = entryIndexForId(entries, pending.reflection.coversUpToId);
+				if (idx >= 0) effectiveReflectionTokens = rawTokensAfterIndex(entries, idx);
+			}
+		}
+		if (ctx.hasUI) ctx.ui?.notify(`Observational memory: reflector running (~${effectiveReflectionTokens.toLocaleString()} tokens accumulated, ~${reflectorInputTokens.toLocaleString()}-token input)`, "info");
 
+		// Resolve thinking level for the specific model (fallbacks may have their own thinking config)
+		const stageModelForThinking = runtime.findCandidateConfig(resolved.model, { model: ctx.model, modelRegistry: ctx.modelRegistry, hasUI: ctx.hasUI, ui: ctx.ui, stageModel: stageModelConfig(runtime, "reflector"), stageFallbacks: stageFallbackModels(runtime, "reflector") });
 		try {
 			// Existing memory summaries for context (capped)
 			const existingReflectionsSummary = buildExistingReflectionsSummary(
@@ -408,7 +433,7 @@ async function runReflectorStage(
 				existingReflectionsSummary: existingReflectionsSummary || undefined,
 				existingObservationsSummary: existingObservationsSummary || undefined,
 				maxTurns: runtime.config.agentMaxTurns,
-				thinkingLevel: stageThinkingLevel(runtime, "reflector"),
+				thinkingLevel: stageThinkingLevel(runtime, "reflector", stageModelForThinking),
 			});
 
 			if (!reflections || reflections.length === 0) return { outcome: "continue", sameRunReflections: [] };
@@ -468,7 +493,16 @@ async function runDropperStage(
 		);
 		const dropperSummaryBudget = Math.floor(runtime.config.dropperInputMaxTokens * 0.2);
 		const dropperInputTokens = Math.min(dropperNewObsTokens + dropperSummaryBudget, runtime.config.dropperInputMaxTokens);
-		if (ctx.hasUI) ctx.ui?.notify(`Observational memory: dropper running (~${dropTokens.toLocaleString()} tokens accumulated, ~${dropperInputTokens.toLocaleString()}-token input)`, "info");
+		// Adjust accumulated for pending coverage in noAutoCompact mode
+		let effectiveDropTokens = dropTokens;
+		if (runtime.config.noAutoCompact) {
+			const pending = readPendingState(sessionId);
+			if (pending.dropped?.coversUpToId) {
+				const idx = entryIndexForId(entries, pending.dropped.coversUpToId);
+				if (idx >= 0) effectiveDropTokens = rawTokensAfterIndex(entries, idx);
+			}
+		}
+		if (ctx.hasUI) ctx.ui?.notify(`Observational memory: dropper running (~${effectiveDropTokens.toLocaleString()} tokens accumulated, ~${dropperInputTokens.toLocaleString()}-token input)`, "info");
 
 		try {
 			// Existing active observations summary for context (capped)
@@ -478,6 +512,8 @@ async function runDropperStage(
 			);
 			const reflectionsForDropper = mergeReflections(folded.reflections, sameRunReflections);
 
+			// Resolve thinking level for the specific model (fallbacks may have their own thinking config)
+			const stageModelForThinking = runtime.findCandidateConfig(resolved.model, { model: ctx.model, modelRegistry: ctx.modelRegistry, hasUI: ctx.hasUI, ui: ctx.ui, stageModel: stageModelConfig(runtime, "dropper"), stageFallbacks: stageFallbackModels(runtime, "dropper") });
 			const droppedIds = await runDropper({
 				model: resolved.model as any,
 				apiKey: resolved.apiKey,
@@ -487,7 +523,7 @@ async function runDropperStage(
 				existingObservationsSummary: existingObservationsSummary || undefined,
 				budgetTokens: runtime.config.observationsPoolMaxTokens,
 				maxTurns: runtime.config.agentMaxTurns,
-				thinkingLevel: stageThinkingLevel(runtime, "dropper"),
+				thinkingLevel: stageThinkingLevel(runtime, "dropper", stageModelForThinking),
 			});
 			const latestReflectionCoverageId = latestCoverageMarkerId(entries, OM_REFLECTIONS_RECORDED);
 			const effectiveReflectionCoverageId = sameRunReflectionCoverageId ?? latestReflectionCoverageId;

package/src/om/ledger/projection.ts

@@ -157,7 +157,10 @@ export function fullProjection(entries: Entry[], upToEntryId?: string): Projecti
 export function visibleProjection(entries: Entry[], upToEntryId?: string): Projection {
 	if (!upToEntryId) {
 		const details = latestV3CompactionDetails(entries);
-		return details ? projectionFromMemoryDetails(details) : { observations: [], reflections: [] };
+		if (details) return projectionFromMemoryDetails(details);
+		// No compaction has run yet — show everything so the user sees
+		// recorded data until first /blackhole creates a proper snapshot.
+		return fullProjection(entries);
 	}
 
 	return buildCompactionProjection(entries, upToEntryId, { observationsPoolMaxTokens: Number.POSITIVE_INFINITY });

package/src/om/ledger/recall.ts

@@ -188,7 +188,7 @@ export function recallMemorySources(entries: Entry[], memoryId: string): RecallR
 	}
 
 	const recalledByKey = new Map<string, RecalledObservation>();
-	const missingSupportingObservationIds: string[] = [];
+	const rawMissingSupportingObservationIds: string[] = [];
 
 	function addObservation(indexed: IndexedObservation): void {
 		const key = `${indexed.entryId}:${indexed.recordIndex}`;
@@ -204,7 +204,7 @@ export function recallMemorySources(entries: Entry[], memoryId: string): RecallR
 		for (const observationId of uniqueStrings(reflection.supportingObservationIds)) {
 			const indexed = observationsById.get(observationId);
 			if (!indexed) {
-				missingSupportingObservationIds.push(observationId);
+				rawMissingSupportingObservationIds.push(observationId);
 				continue;
 			}
 			addObservation(indexed);
@@ -220,7 +220,7 @@ export function recallMemorySources(entries: Entry[], memoryId: string): RecallR
 	const sourceEntries = uniqueById(recalledObservations.flatMap((match) => match.sourceEntries));
 	const missingSourceEntryIds = uniqueStrings(recalledObservations.flatMap((match) => match.missingSourceEntryIds));
 	const nonSourceEntryIds = uniqueStrings(recalledObservations.flatMap((match) => match.nonSourceEntryIds));
-	const uniqueMissingSupportingObservationIds = uniqueStrings(missingSupportingObservationIds);
+	const uniqueMissingSupportingObservationIds = uniqueStrings(rawMissingSupportingObservationIds);
 	const matchCount = directObservationMatches.length + reflectionMatches.length;
 
 	return {

package/src/om/reverse-recall.ts

@@ -58,11 +58,10 @@ export function findReflectionsForEntryIds(
 	targetEntryIds: string[],
 ): RelatedReflection[] {
 	if (targetEntryIds.length === 0) return [];
-	const { reflections } = indexLedger(entries);
+	const { reflections, observations } = indexLedger(entries);
 	// Reflections don't directly reference entry IDs — they reference observation IDs.
 	// So we only match indirectly: first find observations for these entry IDs,
 	// then find reflections that support those observations.
-	const { observations } = indexLedger(entries);
 	const targetSet = new Set(targetEntryIds);
 	const matchingObsIds = new Set<string>();
 	for (const indexed of observations) {

package/src/om/runtime.ts

@@ -53,6 +53,10 @@ export class Runtime {
 	lastDropperError: string | undefined;
 	/** 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;
+	/** Whether the most recent compaction was triggered by /blackhole (vs auto-compact). */
+	compactWasPiVcc = false;
 
 	ensureConfig(cwd: string): void {
 		if (this.configLoaded) return;

package/src/core/report.ts

@@ -1,237 +0,0 @@
-import type { Message } from "@earendil-works/pi-ai";
-import { buildSections } from "./build-sections";
-import { clip } from "./content";
-import { normalize } from "./normalize";
-import { renderMessage } from "./render-entries";
-import { searchEntries } from "./search-entries";
-import { type CompileInput, compile } from "./summarize";
-
-const SECTION_HEADERS = ["Session Goal", "Files And Changes", "Commits", "Outstanding Context"];
-
-interface RoleCounts {
-  user: number;
-  assistant: number;
-  toolResult: number;
-}
-
-interface BlockCounts {
-  user: number;
-  assistant: number;
-  toolCalls: number;
-  toolResults: number;
-  thinking: number;
-}
-
-export interface RecallProbe {
-  label: string;
-  sourceText: string;
-  query: string;
-  summaryMentioned: boolean;
-  recallHits: number;
-}
-
-export interface CompactReport {
-  summary: string;
-  before: {
-    messageCount: number;
-    roleCounts: RoleCounts;
-    blockCounts: BlockCounts;
-    inputChars: number;
-    estimatedTokens: number;
-    topFiles: string[];
-    preview: string;
-  };
-  after: {
-    summaryLength: number;
-    estimatedTokens: number;
-    sectionCount: number;
-    summaryPreview: string;
-    goalsCount: number;
-    blockersCount: number;
-    briefTranscriptLines: number;
-  };
-  compression: {
-    charsBefore: number;
-    charsAfter: number;
-    ratio: number;
-    messagesBefore: number;
-  };
-  recall: {
-    probes: RecallProbe[];
-  };
-}
-
-const estimateTokensFromChars = (chars: number): number =>
-  Math.ceil(chars / 4);
-
-const countRoles = (messages: Message[]): RoleCounts => {
-  const counts: RoleCounts = { user: 0, assistant: 0, toolResult: 0 };
-  for (const msg of messages) {
-    if (msg.role === "user") counts.user += 1;
-    else if (msg.role === "assistant") counts.assistant += 1;
-    else if (msg.role === "toolResult") counts.toolResult += 1;
-  }
-  return counts;
-};
-
-const countBlocks = (messages: Message[]): BlockCounts => {
-  const counts: BlockCounts = {
-    user: 0,
-    assistant: 0,
-    toolCalls: 0,
-    toolResults: 0,
-    thinking: 0,
-  };
-
-  for (const block of normalize(messages)) {
-    if (block.kind === "user") counts.user += 1;
-    else if (block.kind === "assistant") counts.assistant += 1;
-    else if (block.kind === "tool_call") counts.toolCalls += 1;
-    else if (block.kind === "tool_result") counts.toolResults += 1;
-    else if (block.kind === "thinking") counts.thinking += 1;
-  }
-
-  return counts;
-};
-
-const inputCharsOf = (messages: Message[]): number =>
-  messages
-    .map((msg, index) => renderMessage(msg, index, "", true).summary.length)
-    .reduce((sum, len) => sum + len, 0);
-
-const topFilesOf = (messages: Message[]): string[] => {
-  const files = new Set<string>();
-  for (const block of normalize(messages)) {
-    if (block.kind === "tool_call") {
-      for (const key of ["path", "file_path", "filePath", "file"]) {
-        const val = block.args[key];
-        if (typeof val === "string") { files.add(val); break; }
-      }
-    }
-  }
-  return [...files].slice(0, 10);
-};
-
-const previewOf = (messages: Message[], edgeCount = 3): string => {
-  const rendered = messages.map((msg, index) => renderMessage(msg, index, ""));
-  if (rendered.length === 0) return "(empty)";
-  if (rendered.length <= edgeCount * 2) {
-    return rendered
-      .map((entry) => `#${entry.index} [${entry.role}] ${clip(entry.summary, 220)}`)
-      .join("\n");
-  }
-
-  const first = rendered.slice(0, edgeCount);
-  const last = rendered.slice(-edgeCount);
-  return [
-    ...first.map((entry) => `#${entry.index} [${entry.role}] ${clip(entry.summary, 220)}`),
-    "...",
-    ...last.map((entry) => `#${entry.index} [${entry.role}] ${clip(entry.summary, 220)}`),
-  ].join("\n");
-};
-
-const sectionCountOf = (summary: string): number =>
-  SECTION_HEADERS.filter((header) => summary.includes(`[${header}]`)).length;
-
-const briefLineCountOf = (summary: string): number => {
-  const sep = "\n\n---\n\n";
-  const idx = summary.indexOf(sep);
-  if (idx < 0) return 0;
-  return summary.slice(idx + sep.length).split("\n").length;
-};
-
-const queryTermsOf = (text: string): string[] =>
-  (text.match(/[\p{L}\p{N}_./-]{3,}/gu) ?? [])
-    .map((part) => part.trim())
-    .filter(Boolean);
-
-const queryOf = (text: string): string => {
-  const terms = queryTermsOf(text);
-  return terms.slice(0, 6).join(" ");
-};
-
-const matchesQuery = (text: string, query: string): boolean => {
-  const hay = text.toLowerCase();
-  return query
-    .toLowerCase()
-    .split(/\s+/)
-    .filter(Boolean)
-    .every((term) => hay.includes(term));
-};
-
-const probesOf = (messages: Message[], summary: string): RecallProbe[] => {
-  const blocks = normalize(messages);
-  const data = buildSections({ blocks });
-
-  // Find first file from tool calls
-  let firstFile = "";
-  for (const b of blocks) {
-    if (b.kind === "tool_call") {
-      for (const key of ["path", "file_path", "filePath", "file"]) {
-        if (typeof b.args[key] === "string") { firstFile = b.args[key] as string; break; }
-      }
-      if (firstFile) break;
-    }
-  }
-
-  const rawProbes = [
-    { label: "goal", text: data.sessionGoal[0] ?? "" },
-    { label: "file", text: firstFile },
-    { label: "problem", text: data.outstandingContext[0] ?? "" },
-  ];
-
-  const rendered = messages.map((msg, index) => renderMessage(msg, index, ""));
-
-  return rawProbes
-    .map(({ label, text }) => {
-      const sourceText = text.trim();
-      const query = queryOf(sourceText);
-      if (!query) return null;
-      return {
-        label,
-        sourceText,
-        query,
-        summaryMentioned: matchesQuery(summary, query),
-        recallHits: searchEntries(rendered, messages, query).length,
-      };
-    })
-    .filter((probe): probe is RecallProbe => probe !== null);
-};
-
-export const buildCompactReport = (input: CompileInput): CompactReport => {
-  const summary = compile(input);
-  const data = buildSections({ blocks: normalize(input.messages) });
-  const inputChars = inputCharsOf(input.messages);
-  const topFiles = topFilesOf(input.messages);
-
-  return {
-    summary,
-    before: {
-      messageCount: input.messages.length,
-      roleCounts: countRoles(input.messages),
-      blockCounts: countBlocks(input.messages),
-      inputChars,
-      estimatedTokens: estimateTokensFromChars(inputChars),
-      topFiles,
-      preview: previewOf(input.messages),
-    },
-    after: {
-      summaryLength: summary.length,
-      estimatedTokens: estimateTokensFromChars(summary.length),
-      sectionCount: sectionCountOf(summary),
-      summaryPreview: summary,
-      goalsCount: data.sessionGoal.length,
-      blockersCount: data.outstandingContext.length,
-      briefTranscriptLines: briefLineCountOf(summary),
-    },
-    compression: {
-      charsBefore: inputChars,
-      charsAfter: summary.length,
-      ratio: summary.length === 0 ? 0 : Number((inputChars / summary.length).toFixed(2)),
-      messagesBefore: input.messages.length,
-    },
-    recall: {
-      probes: probesOf(input.messages, summary),
-    },
-  };
-};

package/src/om/compaction-hook.ts

@@ -1,63 +0,0 @@
-/**
- * Observational memory compaction hook — injects OM content into pi-vcc summaries.
- *
- * Upstream: https://github.com/elpapi42/pi-observational-memory (src/hooks/compaction-hook.ts)
- * NOTE: This hook is intentionally NOT registered in index.ts.
- * The joining point is in src/hooks/before-compact.ts which handles both
- * pi-vcc compilation AND OM projection in a single pass.
- * Kept as reference for the original standalone behavior.
- */
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-
-import type { Runtime } from "./runtime.js";
-import { buildCompactionProjection, renderSummary, type Entry } from "./ledger/index.js";
-
-const DEFAULT_OBSERVATIONS_POOL_MAX_TOKENS = 20_000;
-
-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) => {
-		// Dead code — this hook is intentionally not registered in index.ts.
-		// Kept as reference for the original observational-memory behavior.
-		if ((runtime.config as any).disableCompactionHook) return;
-		if (runtime.compactHookInFlight) {
-			if (ctx.hasUI) {
-				ctx.ui.notify(
-					"Observational memory: another compaction is already in progress; cancelling duplicate",
-					"warning",
-				);
-			}
-			return { cancel: true };
-		}
-
-		runtime.compactHookInFlight = true;
-		try {
-			runtime.ensureConfig(ctx.cwd);
-			const { preparation, branchEntries } = event;
-			const { firstKeptEntryId, tokensBefore } = preparation;
-			const projection = buildCompactionProjection(
-				branchEntries as Entry[],
-				firstKeptEntryId,
-				{ observationsPoolMaxTokens: observationsPoolMaxTokens(runtime) },
-			);
-			const summary = renderSummary(projection.reflections, projection.observations);
-
-			return {
-				compaction: {
-					summary,
-					firstKeptEntryId,
-					tokensBefore,
-					details: projection.details,
-				},
-			};
-		} finally {
-			runtime.compactHookInFlight = false;
-		}
-	});
-}