pi-blackhole 0.2.0 → 0.2.2

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,12 +43,14 @@ import {
 	latestCoverageMarkerId,
 	observationsCreatedAfterIndex,
 	observationToSummaryLine,
+	rawTokensAfterIndex,
 	rawTokensSinceDropCoverage,
 	rawTokensSinceObservationCoverage,
 	rawTokensSinceReflectionCoverage,
 	reflectionToSummaryLine,
 	reflectionsCreatedAfterIndex,
 	type Entry,
+	type Observation,
 	type Reflection,
 } from "./ledger/index.js";
 
@@ -121,6 +125,82 @@ function mergeReflections(existing: Reflection[], additional: Reflection[]): Ref
 	return merged;
 }
 
+/** Score an observation for preamble cap selection.
+ *  Relevance tier dominates: medium (5+) always outranks low (max 2).
+ *  Recency is based on position in the flat-mapped array (0 = oldest, N-1 = newest),
+ *  avoiding wall-clock dependency that punishes sessions spanning days or weeks. */
+function scoreObservation(obs: Observation, index: number, total: number): number {
+	const base = obs.relevance === "high" || obs.relevance === "critical" ? 10
+		: obs.relevance === "medium" ? 5 : 1;
+	const recency = total > 1 ? index / (total - 1) : 1;
+	return base + recency;
+}
+
+/** Select observations for the observer preamble, keeping all high-relevance items
+ *  unconditionally and filling the remaining token budget with the best-scoring
+ *  medium and low observations (relevance-tiered + recency).
+ *
+ *  Reflections are never trimmed — they are inherently rare and always stay. */
+function selectPriorObservations(observations: Observation[], maxTokens: number): Observation[] {
+	// Track original indices so we can restore chronological order after scoring
+	const indexed = observations.map((obs, i) => ({ obs, originalIndex: i }));
+	const high = indexed.filter(item => item.obs.relevance === "high" || item.obs.relevance === "critical");
+	const rest = indexed.filter(item => item.obs.relevance !== "high" && item.obs.relevance !== "critical");
+
+	// High always kept — consume budget first
+	let budget = maxTokens;
+	const selected = new Set<{ obs: Observation; originalIndex: number }>();
+	for (const item of high) {
+		const lineTokens = Math.ceil(observationToSummaryLine(item.obs).length / 4);
+		selected.add(item);
+		budget -= lineTokens;
+	}
+
+	// Score medium + low and select best within remaining budget
+	if (rest.length > 0 && budget > 0) {
+		const scored = rest.map((item, i) => ({ item, score: scoreObservation(item.obs, i, rest.length) }));
+		scored.sort((a, b) => b.score - a.score); // highest score first
+		for (const { item } of scored) {
+			const lineTokens = Math.ceil(observationToSummaryLine(item.obs).length / 4);
+			if (budget - lineTokens < 0) break;
+			selected.add(item);
+			budget -= lineTokens;
+		}
+	}
+
+	// Restore original chronological order before returning
+	return Array.from(selected)
+		.sort((a, b) => a.originalIndex - b.originalIndex)
+		.map(item => item.obs);
+}
+
+/**
+ * Extract all pending observations from accumulated batches that were recorded
+ * after a given coverage ID (e.g., the last reflection or drop coverage ID).
+ * This is needed in noAutoCompact mode because the reflector/dropper may skip
+ * a pipeline cycle, leaving unprocessed batches in observationBatches that
+ * should still be served as "new" on subsequent runs.
+ */
+function pendingObservationsCreatedAfter(
+	pending: any,
+	entries: Entry[],
+	afterCoversUpToId: string | undefined,
+): Observation[] {
+	const batches = pending.observationBatches ?? [];
+	if (!afterCoversUpToId || entryIndexForId(entries, afterCoversUpToId) < 0) {
+		return batches.flatMap((b: any) => (b.data as any)?.observations ?? []);
+	}
+	const afterIdx = entryIndexForId(entries, afterCoversUpToId);
+	const newObs: Observation[] = [];
+	for (const batch of batches) {
+		const batchIdx = entryIndexForId(entries, batch.coversUpToId);
+		if (batchIdx >= 0 && batchIdx > afterIdx) {
+			newObs.push(...((batch.data as any)?.observations ?? []));
+		}
+	}
+	return newObs;
+}
+
 function anyStageDue(entries: Entry[], runtime: Runtime): boolean {
 	return rawTokensSinceObservationCoverage(entries) >= runtime.config.observeAfterTokens
 		|| rawTokensSinceReflectionCoverage(entries) >= runtime.config.reflectAfterTokens
@@ -139,8 +219,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";
 }
 
@@ -269,12 +349,40 @@ async function runObserverStage(
 	if (!chunk.trim() || sourceEntryIds.length === 0) return "continue";
 	const chunkTokens = Math.ceil(chunk.length / 4);
 
+	const sessionId = ctx.sessionManager.getSessionId();
+
 	const memory = fullProjection(entries);
-	const priorReflections = memory.reflections.map(reflectionToSummaryLine);
-	const priorObservations = memory.observations.map(observationToSummaryLine);
+	let priorReflections = memory.reflections.map(reflectionToSummaryLine);
+	let priorObservations = memory.observations.map(observationToSummaryLine);
+
+	// In noAutoCompact, append accumulated batch history to whatever
+	// fullProjection found in the branch (preserving pre-switch markers
+	// when transitioning from autoCompact to noAutoCompact mid-session).
+	// The preamble is capped via observerPreambleMaxTokens so accumulated
+	// observations don't grow unbounded across turns.
+	if (runtime.config.noAutoCompact) {
+		const pendingCtx = readPendingState(sessionId);
+		const accumulatedReflections = (pendingCtx.reflectionBatches ?? [])
+			.flatMap(b => (b.data as any).reflections ?? []);
+		const accumulatedObservations = (pendingCtx.observationBatches ?? [])
+			.flatMap(b => (b.data as any).observations ?? []);
+
+		// Capped preamble: high always kept, medium/low scored by relevance + recency
+		const preambleMaxTokens = runtime.config.observerPreambleMaxTokens > 0
+			? runtime.config.observerPreambleMaxTokens
+			: Math.round(runtime.config.observerChunkMaxTokens * 0.3);
+		const allObservations = [...memory.observations, ...accumulatedObservations];
+		priorObservations = selectPriorObservations(allObservations, preambleMaxTokens)
+			.map(observationToSummaryLine);
+
+		// Reflections are never trimmed — rare and always kept
+		priorReflections = [
+			...priorReflections,
+			...accumulatedReflections.map(reflectionToSummaryLine),
+		];
+	}
 
 	// If noAutoCompact: skip if this exact chunk was already processed
-	const sessionId = ctx.sessionManager.getSessionId();
 	if (runtime.config.noAutoCompact && isObservationChunkPending(sessionId, coversUpToId)) {
 		debugLog("observer.pending_skip", { coversUpToId, sessionId });
 		return "continue";
@@ -284,12 +392,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 +419,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) {
@@ -365,11 +484,33 @@ async function runReflectorStage(
 ): Promise<ReflectorStageResult> {
 	const sessionId = ctx.sessionManager.getSessionId();
 	const entries = ctx.sessionManager.getBranch() as Entry[];
-	const reflectionTokens = rawTokensSinceReflectionCoverage(entries);
-	if (reflectionTokens < runtime.config.reflectAfterTokens) return { outcome: "continue", sameRunReflections: [] };
-
-	const observationCoverageId = latestCoverageMarkerId(entries, OM_OBSERVATIONS_RECORDED);
-	if (!observationCoverageId) return { outcome: "continue", sameRunReflections: [] };
+	let reflectionTokens: number;
+	let observationCoverageId: string | undefined;
+	if (runtime.config.noAutoCompact) {
+		const pending = readPendingState(sessionId);
+		// Check any accumulated batch for unprocessed observations, not just the latest
+		const hasPendingObs = (pending.observationBatches ?? []).some((b: any) => (b.data as any)?.observations?.length);
+		if (!hasPendingObs) return { outcome: "continue", sameRunReflections: [] };
+		observationCoverageId = pending.observation?.coversUpToId;
+		if (pending.reflection?.coversUpToId) {
+			const obsIdx = entryIndexForId(entries, pending.observation?.coversUpToId ?? "");
+			const refIdx = entryIndexForId(entries, pending.reflection.coversUpToId);
+			if (obsIdx >= 0 && refIdx >= 0 && obsIdx <= refIdx) return { outcome: "continue", sameRunReflections: [] };
+			if (refIdx >= 0) {
+				reflectionTokens = rawTokensAfterIndex(entries, refIdx);
+				if (reflectionTokens < runtime.config.reflectAfterTokens) return { outcome: "continue", sameRunReflections: [] };
+			} else {
+				reflectionTokens = rawTokensSinceObservationCoverage(entries);
+			}
+		} else {
+			reflectionTokens = rawTokensSinceObservationCoverage(entries);
+		}
+	} else {
+		reflectionTokens = rawTokensSinceReflectionCoverage(entries);
+		if (reflectionTokens < runtime.config.reflectAfterTokens) return { outcome: "continue", sameRunReflections: [] };
+		observationCoverageId = latestCoverageMarkerId(entries, OM_OBSERVATIONS_RECORDED);
+		if (!observationCoverageId) return { outcome: "continue", sameRunReflections: [] };
+	}
 
 	for (let attempt = 0; attempt < MAX_STAGE_ATTEMPTS; attempt++) {
 		const resolved = await resolveModel("reflector");
@@ -377,25 +518,47 @@ async function runReflectorStage(
 
 		// Compute ahead for an accurate notification
 		const folded = foldLedger(entries);
-		const lastReflectionIdx = latestCoverageIndex(entries, OM_REFLECTIONS_RECORDED);
-		const newObservations = observationsCreatedAfterIndex(entries, lastReflectionIdx);
-		const newReflections = reflectionsCreatedAfterIndex(entries, lastReflectionIdx);
+		const pending = runtime.config.noAutoCompact ? readPendingState(sessionId) : undefined;
+		const lastReflectionIdx = pending ? -1 : latestCoverageIndex(entries, OM_REFLECTIONS_RECORDED);
+		const newObservations = pending
+			? pendingObservationsCreatedAfter(pending, entries, pending.reflection?.coversUpToId)
+			: observationsCreatedAfterIndex(entries, lastReflectionIdx);
+		const newReflections = pending ? [] : reflectionsCreatedAfterIndex(entries, lastReflectionIdx);
 		const newItemsTokens = Math.ceil(
-			(newObservations.reduce((s, o) => s + o.content.length, 0) +
-				newReflections.reduce((s, r) => s + r.content.length, 0)) / 4
+			(newObservations.reduce((s: number, o: any) => s + o.content.length, 0) +
+				newReflections.reduce((s: number, r: any) => s + r.content.length, 0)) / 4
 		);
 		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)
+			// Existing memory summaries for context (capped).
+			// In noAutoCompact, merge accumulated pending batches with
+			// branch data (preserving pre-switch markers).
+			const sourceReflections = pending
+				? [...folded.reflections, ...(pending.reflectionBatches ?? []).flatMap((b: any) => (b.data as any)?.reflections ?? [])]
+				: folded.reflections;
+			const sourceObservations = pending
+				? [...folded.activeObservations, ...(pending.observationBatches ?? []).flatMap((b: any) => (b.data as any)?.observations ?? [])]
+				: folded.activeObservations;
 			const existingReflectionsSummary = buildExistingReflectionsSummary(
-				folded.reflections,
+				sourceReflections,
 				Math.floor(runtime.config.reflectorInputMaxTokens * 0.15),
 			);
 			const existingObservationsSummary = buildExistingObservationsSummary(
-				folded.activeObservations.filter(o => !newObservations.some(no => no.id === o.id)),
+				sourceObservations.filter((o: any) => !newObservations.some((no: any) => no.id === o.id)),
 				Math.floor(runtime.config.reflectorInputMaxTokens * 0.15),
 			);
 
@@ -408,10 +571,11 @@ 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: [] };
+			if (!observationCoverageId) return { outcome: "continue", sameRunReflections: [] };
 
 			const data = buildReflectionsRecordedData(reflections, observationCoverageId);
 			if (!data) return { outcome: "continue", sameRunReflections: [] };
@@ -449,11 +613,33 @@ async function runDropperStage(
 ): Promise<StageOutcome> {
 	const sessionId = ctx.sessionManager.getSessionId();
 	const entries = ctx.sessionManager.getBranch() as Entry[];
-	const dropTokens = rawTokensSinceDropCoverage(entries);
-	if (dropTokens < runtime.config.reflectAfterTokens) return "continue";
-
-	const observationCoverageId = latestCoverageMarkerId(entries, OM_OBSERVATIONS_RECORDED);
-	if (!observationCoverageId) return "continue";
+	let dropTokens: number;
+	let observationCoverageId: string | undefined;
+	if (runtime.config.noAutoCompact) {
+		const pending = readPendingState(sessionId);
+		// Check any accumulated batch for unprocessed observations, not just the latest
+		const hasPendingObs = (pending.observationBatches ?? []).some((b: any) => (b.data as any)?.observations?.length);
+		if (!hasPendingObs) return "continue";
+		observationCoverageId = pending.observation?.coversUpToId;
+		if (pending.dropped?.coversUpToId) {
+			const obsIdx = entryIndexForId(entries, pending.observation?.coversUpToId ?? "");
+			const dropIdx = entryIndexForId(entries, pending.dropped.coversUpToId);
+			if (obsIdx >= 0 && dropIdx >= 0 && obsIdx <= dropIdx) return "continue";
+			if (dropIdx >= 0) {
+				dropTokens = rawTokensAfterIndex(entries, dropIdx);
+				if (dropTokens < runtime.config.reflectAfterTokens) return "continue";
+			} else {
+				dropTokens = rawTokensSinceDropCoverage(entries);
+			}
+		} else {
+			dropTokens = rawTokensSinceDropCoverage(entries);
+		}
+	} else {
+		dropTokens = rawTokensSinceDropCoverage(entries);
+		if (dropTokens < runtime.config.reflectAfterTokens) return "continue";
+		observationCoverageId = latestCoverageMarkerId(entries, OM_OBSERVATIONS_RECORDED);
+		if (!observationCoverageId) return "continue";
+	}
 
 	for (let attempt = 0; attempt < MAX_STAGE_ATTEMPTS; attempt++) {
 		const resolved = await resolveModel("dropper");
@@ -461,23 +647,48 @@ async function runDropperStage(
 
 		// Compute ahead for an accurate notification
 		const folded = foldLedger(entries);
-		const lastDropIdx = latestCoverageIndex(entries, OM_OBSERVATIONS_DROPPED);
-		const newObservations = observationsCreatedAfterIndex(entries, lastDropIdx);
+		const pending = runtime.config.noAutoCompact ? readPendingState(sessionId) : undefined;
+		const lastDropIdx = pending ? -1 : latestCoverageIndex(entries, OM_OBSERVATIONS_DROPPED);
+		const newObservations = pending
+			? pendingObservationsCreatedAfter(pending, entries, pending.dropped?.coversUpToId)
+			: observationsCreatedAfterIndex(entries, lastDropIdx);
 		const dropperNewObsTokens = Math.ceil(
-			newObservations.reduce((s, o) => s + o.content.length, 0) / 4
+			newObservations.reduce((s: number, o: any) => s + o.content.length, 0) / 4
 		);
 		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)
+			// Existing active observations summary for context (capped).
+			// In noAutoCompact, merge accumulated pending batches with
+			// branch data (preserving pre-switch markers).
+			const sourceObsForDropper = pending
+				? [...folded.activeObservations, ...(pending.observationBatches ?? []).flatMap((b: any) => (b.data as any)?.observations ?? [])]
+				: folded.activeObservations;
 			const existingObservationsSummary = buildExistingObservationsSummary(
-				folded.activeObservations.filter(o => !newObservations.some(no => no.id === o.id)),
+				sourceObsForDropper.filter((o: any) => !newObservations.some((no: any) => no.id === o.id)),
 				Math.floor(runtime.config.dropperInputMaxTokens * 0.2),
 			);
-			const reflectionsForDropper = mergeReflections(folded.reflections, sameRunReflections);
-
+			// In noAutoCompact, merge accumulated reflection batches with
+			// branch data (preserving pre-switch markers), matching the
+			// dropper's full autoCompact context.
+			const pendingReflections = pending
+				? [...folded.reflections, ...(pending.reflectionBatches ?? []).flatMap((b: any) => (b.data as any)?.reflections ?? [])]
+				: folded.reflections;
+			const reflectionsForDropper = mergeReflections(pendingReflections, 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,9 +698,11 @@ 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 latestReflectionCoverageId = runtime.config.noAutoCompact
+				? pending?.reflection?.coversUpToId
+				: latestCoverageMarkerId(entries, OM_REFLECTIONS_RECORDED);
 			const effectiveReflectionCoverageId = sameRunReflectionCoverageId ?? latestReflectionCoverageId;
 			const coversUpToId = earlierCoverageMarkerId(entries, observationCoverageId, effectiveReflectionCoverageId);
 			const data = coversUpToId && droppedIds ? buildObservationsDroppedData(droppedIds, coversUpToId) : undefined;

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/pending.ts

@@ -16,6 +16,7 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import type { Observation, Reflection } from "./ledger/types.js";
 
 // ── Types ───────────────────────────────────────────────────────────────────
 
@@ -41,6 +42,25 @@ export interface PendingOMState {
 	reflection?: PendingReflection;
 	/** Latest dropper run (replaced each time, not accumulated). */
 	dropped?: PendingDropped;
+	/**
+	 * All observation batches accumulated across noAutoCompact pipeline runs.
+	 * Each batch preserves per-run coverage (coversUpToId) matching the normal
+	 * branch-marker pattern. Used for LLM context and /blackhole flush.
+	 */
+	observationBatches?: PendingObservation[];
+	/**
+	 * All reflection batches accumulated across noAutoCompact pipeline runs.
+	 * Preserves per-run coverage for LLM context and /blackhole flush.
+	 */
+	reflectionBatches?: PendingReflection[];
+	/**
+	 * All dropper batches accumulated across noAutoCompact pipeline runs.
+	 * Each batch preserves which observations were dropped in that run.
+	 * Without accumulation, earlier drops are lost when the next dropper
+	 * run overwrites pending.dropped, causing them to be "un-dropped" on
+	 * /blackhole flush.
+	 */
+	droppedBatches?: PendingDropped[];
 }
 
 // ── Persistence ─────────────────────────────────────────────────────────────
@@ -70,7 +90,10 @@ function defaultState(): PendingOMState {
 }
 
 function isEmptyState(s: PendingOMState): boolean {
-	return !s.observation && !s.reflection && !s.dropped;
+	return !s.observation && !s.reflection && !s.dropped
+		&& (!s.observationBatches || s.observationBatches.length === 0)
+		&& (!s.reflectionBatches || s.reflectionBatches.length === 0)
+		&& (!s.droppedBatches || s.droppedBatches.length === 0);
 }
 
 // ── Per-session file read/write ─────────────────────────────────────────────
@@ -145,6 +168,10 @@ function isPendingOMState(value: unknown): value is PendingOMState {
 export function savePendingObservation(sessionId: string, entry: PendingObservation): void {
 	const state = readSessionState(sessionId);
 	state.observation = entry;
+	// Append to accumulated batches for LLM context and /blackhole flush.
+	// Each batch preserves per-run coverage (coversUpToId) matching the
+	// normal branch-marker pattern.
+	state.observationBatches = [...(state.observationBatches ?? []), entry];
 	writeSessionState(sessionId, state);
 }
 
@@ -154,15 +181,20 @@ export function savePendingObservation(sessionId: string, entry: PendingObservat
 export function savePendingReflection(sessionId: string, entry: PendingReflection): void {
 	const state = readSessionState(sessionId);
 	state.reflection = entry;
+	// Append to accumulated batches for LLM context and /blackhole flush.
+	state.reflectionBatches = [...(state.reflectionBatches ?? []), entry];
 	writeSessionState(sessionId, state);
 }
 
 /**
- * Save (replace) the latest dropper result for a session.
+ * Save (replace) the latest dropper result for a session and
+ * append to droppedBatches so no drops are lost across cycles
+ * before /blackhole flush.
  */
 export function savePendingDropped(sessionId: string, entry: PendingDropped): void {
 	const state = readSessionState(sessionId);
 	state.dropped = entry;
+	state.droppedBatches = [...(state.droppedBatches ?? []), entry];
 	writeSessionState(sessionId, state);
 }
 

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;