pi-blackhole 0.2.1 → 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 |
@@ -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

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.1",
+  "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",

package/src/commands/memory.ts

@@ -164,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`,
 			];
@@ -184,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

@@ -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");

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;

package/src/om/consolidation.ts

@@ -50,6 +50,7 @@ import {
 	reflectionToSummaryLine,
 	reflectionsCreatedAfterIndex,
 	type Entry,
+	type Observation,
 	type Reflection,
 } from "./ledger/index.js";
 
@@ -124,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
@@ -272,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";
@@ -379,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");
@@ -391,12 +518,15 @@ 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);
@@ -414,13 +544,21 @@ async function runReflectorStage(
 		// 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),
 			);
 
@@ -437,6 +575,7 @@ async function runReflectorStage(
 			});
 
 			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: [] };
@@ -474,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");
@@ -486,10 +647,13 @@ 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);
@@ -505,12 +669,23 @@ async function runDropperStage(
 		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") });
@@ -525,7 +700,9 @@ async function runDropperStage(
 				maxTurns: runtime.config.agentMaxTurns,
 				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/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);
 }