pi-blackhole 0.2.1 → 0.2.3

package/README.md

@@ -5,8 +5,14 @@ Algorithmic compaction + session-aware observational memory for [Pi](https://git
 Combines [pi-vcc](https://github.com/sting8k/pi-vcc) and [pi-observational-memory](https://github.com/elpapi42/pi-observational-memory) with unified configuration, per-worker model fallback chains, persisted cooldowns, and a manual flush mode.
 
 > This is a frankenmerge. I liked both extensions but they were not compatible - observational memory hooked into Pi's default compaction and prevented pi-vcc from working. So I merged them, made them share the same hook and output, and added the things both were missing: fallback chains, cooldowns, and a toggle between them.
+> Please also see the [`CHANGELOG.md`](CHANGELOG.md)
+
+### Lockstep with upstreams
+
+pi-blackhole tracks both upstream repositories via a [lockstep audit system](https://github.com/k0valik/pi-blackhole/tree/lockstep/2026-05-27/.pi/skills/lockstep) that classifies every new upstream commit as safe-to-port, modified (needs review), rewritten (skip), or orphan (needs mapping). The goal is to lift bugfixes, prompts improvements, and compatible features without breaking existing users or rolling back intentional divergences. Ported changes are reviewed per-commit with human approval — nothing is blindly merged. See [SKILL.md](.pi/skills/lockstep/SKILL.md) for the full workflow. An example execution (including rationale for skipped changes) is documented in [PR #8](https://github.com/k0valik/pi-blackhole/pull/8).
+
+#### For easy setup pass the [`llms.txt`](llms.txt) llms.txt to your agent and it will guide you through the config without needing to read all the docs if you're as lazy as me.
 
-#### For easy setup pass the [`llms.txt`](llms.txt) llms.txt to your agent and it will guide you through the config without needing to read all the docs if you're as lazy as me
 
 # Demo
 
@@ -131,6 +137,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 +205,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 +228,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 +245,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 +260,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.3",
   "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

@@ -44,12 +44,27 @@ export interface UnifiedConfig {
 	compactAfterTokens: number;
 	/** Observation pool token pressure for full fold. */
 	observationsPoolMaxTokens: number;
+	/** Target token budget for the observation pool (dropper aims here).
+	 *  Optional; defaults to half of observationsPoolMaxTokens when unset.
+	 *  Must be less than observationsPoolMaxTokens.
+	 *
+	 *  NOTE: Ported from upstream as forward-compat (no-op in our pool algorithm).
+	 *  Upstream renamed budgetTokens→targetTokens (52b5844) and uses this
+	 *  for their tokensOverTarget / avgTokensPerObservation drop calculation.
+	 *  We keep our ratio-based urgency algorithm; this knob exists so future
+	 *  lockstep iterations don't diverge on the config shape. */
+	observationsPoolTargetTokens: number;
 	/** Max prompt tokens for reflector model input (rolling window cap). */
 	reflectorInputMaxTokens: number;
 	/** Max prompt tokens for dropper model input (rolling window cap). */
 	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 +102,15 @@ 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,
+	observationsPoolTargetTokens: 10_000,
 	reflectorInputMaxTokens: 80_000,
 	dropperInputMaxTokens: 80_000,
 	observerChunkMaxTokens: 40_000,
+	observerPreambleMaxTokens: 0,
 	agentMaxTurns: 16,
 
 	noAutoCompact: false,
@@ -154,7 +171,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", "observationsPoolTargetTokens", "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;
@@ -232,7 +249,15 @@ export function loadUnifiedConfig(cwd: string): UnifiedConfig {
 		else if (["0", "false", "no", "off"].includes(v)) parsed.passive = false;
 	}
 
-	return { ...DEFAULTS, ...parsed };
+	// Merge defaults then override
+	const merged = { ...DEFAULTS, ...parsed };
+
+	// Derive observationsPoolTargetTokens if unset or invalid (must be < max)
+	if (merged.observationsPoolTargetTokens >= merged.observationsPoolMaxTokens) {
+		merged.observationsPoolTargetTokens = Math.floor(merged.observationsPoolMaxTokens / 2);
+	}
+
+	return merged;
 }
 
 /**

package/src/om/agents/dropper/agent.ts

@@ -9,9 +9,18 @@ import { agentLoop, type AgentContext, type AgentLoopConfig, type AgentTool } fr
 import type { Message, Model, ModelThinkingLevel } from "@earendil-works/pi-ai";
 import { Type } from "@earendil-works/pi-ai";
 import type { Static } from "typebox";
+import { debugLog } from "../../debug-log.js";
 import { AGENT_LOOP_MAX_TOKENS, boundedMaxTokens } from "../../model-budget.js";
-import { observationToSummaryLine, reflectionToSummaryLine, type Observation, type Reflection } from "../../ledger/index.js";
+import { reflectionToSummaryLine, type Observation, type Reflection } from "../../ledger/index.js";
 import { DROPPER_SYSTEM } from "./prompts.js";
+import {
+	REFLECTION_COVERAGE_DROP_RANK,
+	coverageTierForObservation,
+	observationToDropperLine,
+	reflectionCoverageMap,
+	summarizeCoverageByRelevance,
+	summarizeCoverageByRelevanceForIds,
+} from "./coverage.js";
 
 interface RunDropperArgs {
 	model: Model<any>;
@@ -81,6 +90,13 @@ export function maxDropCountForPool(observations: readonly Observation[], observ
 	return Math.max(1, Math.floor(droppableCount * dropRatio));
 }
 
+function relevanceCounts(observations: readonly Observation[]): Record<Observation["relevance"], number> {
+	return observations.reduce<Record<Observation["relevance"], number>>((counts, observation) => {
+		if (observation.relevance in counts) counts[observation.relevance]++;
+		return counts;
+	}, { low: 0, medium: 0, high: 0, critical: 0 });
+}
+
 export function normalizeDropObservationIds(
 	ids: readonly string[] | undefined,
 	observations: readonly Observation[],
@@ -92,7 +108,6 @@ export function normalizeDropObservationIds(
 	for (const id of ids) {
 		const observation = allowed.get(id);
 		if (!observation) continue;
-		if (observation.relevance === "critical") continue;
 		if (seen.has(id)) continue;
 		seen.add(id);
 		result.push(id);
@@ -100,14 +115,21 @@ export function normalizeDropObservationIds(
 	return result.length > 0 ? result : undefined;
 }
 
+function timestampRank(timestamp: string): number {
+	const parsed = Date.parse(timestamp);
+	return Number.isFinite(parsed) ? parsed : Number.POSITIVE_INFINITY;
+}
+
 export function selectDropCandidates(
 	ids: readonly string[],
 	observations: readonly Observation[],
 	maxDrops: number,
+	reflections: readonly Reflection[] = [],
 ): string[] {
 	if (maxDrops <= 0 || ids.length === 0) return [];
 
 	const byId = new Map(observations.map((observation) => [observation.id, observation]));
+	const coverageById = reflectionCoverageMap(observations, reflections);
 	const firstProposalIndex = new Map<string, number>();
 	for (let i = 0; i < ids.length; i++) {
 		const id = ids[i];
@@ -117,11 +139,16 @@ export function selectDropCandidates(
 	return Array.from(firstProposalIndex.entries())
 		.map(([id, index]) => ({ id, index, observation: byId.get(id) }))
 		.filter((candidate): candidate is { id: string; index: number; observation: Observation } =>
-			candidate.observation !== undefined && candidate.observation.relevance !== "critical"
+			candidate.observation !== undefined
 		)
 		.sort((a, b) => {
+			const coverageDelta = REFLECTION_COVERAGE_DROP_RANK[coverageTierForObservation(a.observation, coverageById)]
+				- REFLECTION_COVERAGE_DROP_RANK[coverageTierForObservation(b.observation, coverageById)];
 			const relevanceDelta = RELEVANCE_DROP_RANK[a.observation.relevance] - RELEVANCE_DROP_RANK[b.observation.relevance];
-			return relevanceDelta || a.index - b.index;
+			const aAge = timestampRank(a.observation.timestamp);
+			const bAge = timestampRank(b.observation.timestamp);
+			const ageDelta = aAge === bAge ? 0 : aAge - bAge;
+			return coverageDelta || relevanceDelta || ageDelta || a.index - b.index;
 		})
 		.slice(0, maxDrops)
 		.map((candidate) => candidate.id);
@@ -135,10 +162,42 @@ export async function runDropper(args: RunDropperArgs): Promise<string[] | undef
 	const fullness = observationPoolFullness(observationTokens, budgetTokens);
 	const urgency = dropUrgencyForFullness(fullness);
 	const maxDropsAllowed = maxDropCountForPool(observations, observationTokens, budgetTokens);
-	if (maxDropsAllowed <= 0) return undefined;
+	const coverageById = reflectionCoverageMap(observations, reflections);
+	const coverageSummaryByRelevance = summarizeCoverageByRelevance(observations, coverageById);
+	debugLog("dropper.agent_start", {
+		activeObservationCount: observations.length,
+		reflectionCount: reflections.length,
+		observationTokens,
+		budgetTokens,
+		fullness,
+		urgency,
+		maxDropsAllowed,
+		relevanceCounts: relevanceCounts(observations),
+		coverageSummaryByRelevance,
+	});
+	if (maxDropsAllowed <= 0) {
+		debugLog("dropper.result", {
+			reason: "not_over_target",
+			toolCallCount: 0,
+			rawRequestedIdsCount: 0,
+			acceptedCandidateCount: 0,
+			selectedDropsCount: 0,
+			selectedDropTokens: 0,
+			selectedCoverageSummaryByRelevance: summarizeCoverageByRelevanceForIds([], observations, coverageById),
+			maxDropsAllowed,
+		});
+		return undefined;
+	}
 
 	const proposedDropIds: string[] = [];
 	const proposed = new Set<string>();
+	const allowed = new Map(observations.map((observation) => [observation.id, observation]));
+	let toolCallCount = 0;
+	let rawRequestedIdsCount = 0;
+	let missingIdsCount = 0;
+	let criticalCandidateIdsCount = 0;
+	let duplicateInRequestCount = 0;
+	let duplicateInRunCount = 0;
 
 	const dropObservations: AgentTool<typeof DropObservationsSchema> = {
 		name: "drop_observations",
@@ -146,14 +205,51 @@ export async function runDropper(args: RunDropperArgs): Promise<string[] | undef
 		description: "Propose active observation ids that are safe to remove from compacted memory.",
 		parameters: DropObservationsSchema,
 		execute: async (_id, params: DropObservationsArgs) => {
-			const normalized = normalizeDropObservationIds(params.ids, observations) ?? [];
+			toolCallCount++;
+			rawRequestedIdsCount += params.ids.length;
+			const seenInRequest = new Set<string>();
 			let added = 0;
-			for (const id of normalized) {
-				if (proposed.has(id)) continue;
+			let requestMissingIds = 0;
+			let requestCriticalCandidateIds = 0;
+			let requestDuplicateIds = 0;
+			let requestDuplicateInRunIds = 0;
+			for (const id of params.ids) {
+				const observation = allowed.get(id);
+				if (!observation) {
+					missingIdsCount++;
+					requestMissingIds++;
+					continue;
+				}
+				if (seenInRequest.has(id)) {
+					duplicateInRequestCount++;
+					requestDuplicateIds++;
+					continue;
+				}
+				seenInRequest.add(id);
+				if (proposed.has(id)) {
+					duplicateInRunCount++;
+					requestDuplicateInRunIds++;
+					continue;
+				}
 				proposed.add(id);
 				proposedDropIds.push(id);
+				if (observation.relevance === "critical") {
+					criticalCandidateIdsCount++;
+					requestCriticalCandidateIds++;
+				}
 				added++;
 			}
+			debugLog("dropper.tool_call", {
+				toolCallCount,
+				rawRequestedIdsCount: params.ids.length,
+				acceptedIdsCount: added,
+				missingIdsCount: requestMissingIds,
+				criticalCandidateIdsCount: requestCriticalCandidateIds,
+				duplicateInRequestCount: requestDuplicateIds,
+				duplicateInRunCount: requestDuplicateInRunIds,
+				totalCandidates: proposedDropIds.length,
+				maxDropsAllowed,
+			});
 			return {
 				content: [{ type: "text", text: `Queued ${added} drop candidate${added === 1 ? "" : "s"}. Candidates this run: ${proposedDropIds.length}. Maximum drops allowed: ${maxDropsAllowed}.` }],
 				details: { added, totalCandidates: proposedDropIds.length, maxDropsAllowed },
@@ -166,7 +262,7 @@ export async function runDropper(args: RunDropperArgs): Promise<string[] | undef
 		? `EXISTING ACTIVE OBSERVATIONS (for context only — these are NOT candidates for dropping):\n${args.existingObservationsSummary}\n\n`
 		: '';
 
-	const userText = `CURRENT REFLECTIONS:\n${joinOrEmpty(reflections.map(reflectionToSummaryLine))}\n\n${existingObservationsContext}NEW OBSERVATIONS TO EVALUATE FOR DROPPING:\n${joinOrEmpty(observations.map(observationToSummaryLine))}\n\nObservation pool pressure: ~${observationTokens.toLocaleString()} tokens; target budget: ~${budgetTokens.toLocaleString()} tokens; fullness: ~${fullnessPercent.toLocaleString()}%.\nDrop urgency: ${urgency}.\nMaximum drops allowed this run: ${maxDropsAllowed.toLocaleString()} observation${maxDropsAllowed === 1 ? "" : "s"}.\nThis maximum is a hard upper bound, not a target. Drop fewer or none if fewer observations are clearly safe.`;
+	const userText = `CURRENT REFLECTIONS:\n${joinOrEmpty(reflections.map(reflectionToSummaryLine))}\n\n${existingObservationsContext}NEW OBSERVATIONS TO EVALUATE FOR DROPPING:\n${joinOrEmpty(observations.map((observation) => observationToDropperLine(observation, coverageTierForObservation(observation, coverageById))))}\n\nObservation pool pressure: ~${observationTokens.toLocaleString()} tokens; target budget: ~${budgetTokens.toLocaleString()} tokens; fullness: ~${fullnessPercent.toLocaleString()}%.\nDrop urgency: ${urgency}.\nMaximum drops allowed this run: ${maxDropsAllowed.toLocaleString()} observation${maxDropsAllowed === 1 ? "" : "s"}.\nThis maximum is a hard upper bound, not a target. Drop fewer or none if fewer observations are clearly safe.`;
 	const prompts: Message[] = [{ role: "user", content: [{ type: "text", text: userText }], timestamp: Date.now() }];
 	const context: AgentContext = { systemPrompt: DROPPER_SYSTEM, messages: [], tools: [dropObservations as AgentTool<any>] };
 	const reasoning = (model as { reasoning?: unknown }).reasoning;
@@ -199,6 +295,28 @@ export async function runDropper(args: RunDropperArgs): Promise<string[] | undef
 	}
 	await stream.result();
 	if (agentError && proposedDropIds.length === 0) throw new Error(`Dropper API error: ${agentError}`);
-	const droppedIds = selectDropCandidates(proposedDropIds, observations, maxDropsAllowed);
+	const droppedIds = selectDropCandidates(proposedDropIds, observations, maxDropsAllowed, reflections);
+	const reason = droppedIds.length > 0
+		? "selected_nonempty"
+		: toolCallCount === 0
+			? "no_tool_call"
+			: proposedDropIds.length === 0
+				? "all_filtered"
+				: "selected_empty";
+	const selectedDropTokens = droppedIds.reduce((sum, id) => sum + (allowed.get(id)?.tokenCount ?? 0), 0);
+	debugLog("dropper.result", {
+		reason,
+		toolCallCount,
+		rawRequestedIdsCount,
+		missingIdsCount,
+		criticalCandidateIdsCount,
+		duplicateInRequestCount,
+		duplicateInRunCount,
+		acceptedCandidateCount: proposedDropIds.length,
+		selectedDropsCount: droppedIds.length,
+		selectedDropTokens,
+		selectedCoverageSummaryByRelevance: summarizeCoverageByRelevanceForIds(droppedIds, observations, coverageById),
+		maxDropsAllowed,
+	});
 	return droppedIds.length > 0 ? droppedIds : undefined;
 }

package/src/om/agents/dropper/coverage.ts

@@ -0,0 +1,128 @@
+import type { Observation, Reflection } from "../../ledger/index.js";
+
+export const REFLECTION_COVERAGE_TIERS = ["none", "partial", "strong"] as const;
+export type ReflectionCoverageTier = typeof REFLECTION_COVERAGE_TIERS[number];
+
+type Relevance = Observation["relevance"];
+
+type CoverageBucket = Record<ReflectionCoverageTier, { count: number; tokens: number }>;
+export type CoverageSummaryByRelevance = Record<Relevance, CoverageBucket>;
+export type CoverageTransitionSummaryByRelevance = Record<Relevance, Record<string, { count: number; tokens: number }>>;
+
+export const REFLECTION_COVERAGE_DROP_RANK: Record<ReflectionCoverageTier, number> = {
+	strong: 0,
+	partial: 1,
+	none: 2,
+};
+
+export function reflectionSupportCounts(reflections: readonly Reflection[]): Map<string, number> {
+	const counts = new Map<string, number>();
+	for (const reflection of reflections) {
+		const uniqueIds = new Set(reflection.supportingObservationIds);
+		for (const id of uniqueIds) counts.set(id, (counts.get(id) ?? 0) + 1);
+	}
+	return counts;
+}
+
+export function reflectionCoverageTierForCount(count: number): ReflectionCoverageTier {
+	if (count <= 0) return "none";
+	if (count === 1) return "partial";
+	return "strong";
+}
+
+export function reflectionCoverageMap(
+	observations: readonly Observation[],
+	reflections: readonly Reflection[],
+): Map<string, ReflectionCoverageTier> {
+	const counts = reflectionSupportCounts(reflections);
+	return new Map(observations.map((observation) => [
+		observation.id,
+		reflectionCoverageTierForCount(counts.get(observation.id) ?? 0),
+	]));
+}
+
+function emptyCoverageBucket(): CoverageBucket {
+	return {
+		none: { count: 0, tokens: 0 },
+		partial: { count: 0, tokens: 0 },
+		strong: { count: 0, tokens: 0 },
+	};
+}
+
+export function emptyCoverageSummaryByRelevance(): CoverageSummaryByRelevance {
+	return {
+		low: emptyCoverageBucket(),
+		medium: emptyCoverageBucket(),
+		high: emptyCoverageBucket(),
+		critical: emptyCoverageBucket(),
+	};
+}
+
+export function summarizeCoverageByRelevance(
+	observations: readonly Observation[],
+	coverageById: ReadonlyMap<string, ReflectionCoverageTier>,
+): CoverageSummaryByRelevance {
+	const summary = emptyCoverageSummaryByRelevance();
+	for (const observation of observations) {
+		const tier = coverageById.get(observation.id) ?? "none";
+		const bucket = summary[observation.relevance][tier];
+		bucket.count++;
+		bucket.tokens += observation.tokenCount;
+	}
+	return summary;
+}
+
+export function summarizeCoverageByRelevanceForIds(
+	ids: readonly string[],
+	observations: readonly Observation[],
+	coverageById: ReadonlyMap<string, ReflectionCoverageTier>,
+): CoverageSummaryByRelevance {
+	const byId = new Map(observations.map((observation) => [observation.id, observation]));
+	const selected = ids.flatMap((id) => {
+		const observation = byId.get(id);
+		return observation ? [observation] : [];
+	});
+	return summarizeCoverageByRelevance(selected, coverageById);
+}
+
+export function emptyCoverageTransitionSummaryByRelevance(): CoverageTransitionSummaryByRelevance {
+	return {
+		low: {},
+		medium: {},
+		high: {},
+		critical: {},
+	};
+}
+
+export function summarizeCoverageTransitionsByRelevance(
+	observations: readonly Observation[],
+	beforeCoverageById: ReadonlyMap<string, ReflectionCoverageTier>,
+	afterCoverageById: ReadonlyMap<string, ReflectionCoverageTier>,
+): CoverageTransitionSummaryByRelevance {
+	const summary = emptyCoverageTransitionSummaryByRelevance();
+	for (const observation of observations) {
+		const before = beforeCoverageById.get(observation.id) ?? "none";
+		const after = afterCoverageById.get(observation.id) ?? "none";
+		if (before === after) continue;
+		const key = `${before}->${after}`;
+		const bucket = summary[observation.relevance][key] ?? { count: 0, tokens: 0 };
+		bucket.count++;
+		bucket.tokens += observation.tokenCount;
+		summary[observation.relevance][key] = bucket;
+	}
+	return summary;
+}
+
+export function observationToDropperLine(
+	observation: Observation,
+	coverage: ReflectionCoverageTier,
+): string {
+	return `[${observation.id}] ${observation.timestamp} [${observation.relevance}] [coverage: ${coverage}] ${observation.content}`;
+}
+
+export function coverageTierForObservation(
+	observation: Observation,
+	coverageById: ReadonlyMap<string, ReflectionCoverageTier>,
+): ReflectionCoverageTier {
+	return coverageById.get(observation.id) ?? "none";
+}

package/src/om/agents/dropper/prompts.ts

@@ -6,30 +6,30 @@ Your job is to identify only the safest active observations to remove from compa
 
 Active-memory framing. Dropping an observation removes it from active compacted memory; it does not erase the ledger history or source evidence. Still, future compressed context will no longer show the observation, so only drop it when its durable meaning is safely captured elsewhere or it is genuinely low-signal and carries no unique future value.
 
-The user message includes drop urgency and "Maximum drops allowed this run". The maximum is a hard upper bound, not a target. Never try to hit it. Drop fewer or none when fewer observations are safely removable.
-
-Urgency guidance:
-- low urgency: only propose trivially safe drops, usually low-signal observations with no unique detail.
-- medium urgency: perform conservative cleanup; prefer low observations and clearly redundant medium observations.
-- high urgency: cleanup is more useful, but preservation rules do not weaken and load-bearing memory must still be kept.
+The user message includes the active observation pool target and "Maximum drops allowed this run". The maximum is a hard upper bound sized to move the pool toward the target if every proposed drop is clearly safe. It is not a target. Do not try to fill it. Drop fewer or none when fewer observations are safely removable. When the active pool is far over target, make a thorough pass over safe candidates rather than stopping after a few obvious examples.
 
 What to drop, in priority order:
 - Redundant observations whose durable meaning is already captured by current reflections with equivalent fidelity.
 - Superseded observations where a later observation clearly replaces the older state.
 - Repeated routine tool acknowledgements or low-signal progress updates that do not carry decisions, constraints, exact errors, or user-specific facts.
-- Older medium observations that no longer carry working context and are covered by a reflection or a newer observation.
+- Older observations that no longer carry working context and are covered by a reflection or a newer observation.
+
+Age-gradient rule. Recent observations carry working context the assistant may still need; older observations have usually been summarized elsewhere or are no longer load-bearing. Prefer older safe drops before newer working context, but age alone is not enough to drop important or uniquely load-bearing observations.
 
-Age-gradient rule. Recent observations carry working context the assistant may still need; older observations have usually been summarized elsewhere or are no longer load-bearing. Prefer older safe drops before newer working context.
+Reflection coverage guidance. Each observation line includes [coverage: none|partial|strong]. Coverage is evidence, not an automatic decision:
+- none: no current reflection cites this observation id. Be cautious, especially for high or critical observations.
+- partial: one current reflection cites this observation id. Compare the observation to the reflection before dropping.
+- strong: two or more current reflections cite this observation id. This is stronger evidence that the durable meaning is preserved, but you must still keep uniquely load-bearing or uncertain observations.
 
-Relevance guidance:
+Relevance guidance. Relevance is importance/resistance, not an absolute keep/drop lock:
 - low: consider first, but drop only when it carries no unique detail, decision, state, error, identifier, or user-specific fact.
 - medium: drop when redundant with reflections or other observations, or when the work state is clearly obsolete.
 - high: drop only when clearly superseded or already captured by a reflection with equivalent fidelity.
-- critical: NEVER drop. Code also rejects critical ids, but you must avoid proposing them.
+- critical: highest importance and strongest resistance. Do not drop fresh or uniquely load-bearing critical observations. Critical observations may be dropped only with strong semantic evidence such as age plus partial/strong reflection coverage, supersession by newer memory, redundancy, or clear obsolescence.
 
-User assertions and concrete completions are never droppable, even at non-critical relevance, unless a current reflection preserves the exact assertion/completion and its important details with equivalent fidelity.
+User assertions and concrete completions must be preserved unless a current reflection or newer observation preserves the exact assertion/completion and its important details with equivalent fidelity.
 
-Preservation floor. Regardless of relevance label, urgency, budget pressure, or age, do not drop observations that uniquely carry any of the following:
+Preservation floor. Regardless of relevance label, budget pressure, coverage, or age, do not drop observations that uniquely carry any of the following:
 - User preferences, constraints, corrections, or identity/role facts.
 - Concrete completions that future runs must not redo.
 - Named identifiers, file paths, function names, package names, tickets, commit SHAs, handles, or exact commands.

package/src/om/agents/observer/prompts.ts

@@ -101,7 +101,7 @@ If a detail is non-obvious from the code or git history, it belongs in the obser
 
 Relevance levels (pick one per observation; this field drives future dropping):
 
-- critical: user assertions about identity, role, or persistent preferences; explicit corrections ("no, don't do X"); concrete completions that future runs MUST NOT redo. These are load-bearing and will NEVER be dropped. Why this matters: if a "critical" item is lost, the assistant may redo finished work, contradict a correction, or misrepresent who the user is.
+- critical: user assertions about identity, role, or persistent preferences; explicit corrections ("no, don't do X"); concrete completions that future runs MUST NOT redo. These are highest-resistance, load-bearing observations and require the strongest evidence before leaving active memory. Why this matters: if a "critical" item is lost, the assistant may redo finished work, contradict a correction, or misrepresent who the user is.
 - high: non-trivial technical decisions, architectural direction, unresolved blockers, key constraints. Worth keeping across many compactions.
 - medium: task-level context that helps within the current work but isn't durable. The default when you are unsure between medium and high.
 - low: routine tool-call acks, repetitive status updates, content trivially re-derivable from recent messages. The dropper will drop these first.

package/src/om/agents/reflector/prompts.ts

@@ -6,7 +6,8 @@ Your task is different from the observer's: you are not recording events, you ar
 
 You receive:
 - Current reflections: durable facts already crystallized.
-- Current observations: active timestamped evidence lines, each shown as "[id] YYYY-MM-DD HH:MM [relevance] content".
+- Current observations: active timestamped evidence lines, each shown as "[id] YYYY-MM-DD HH:MM [relevance] [coverage: none|partial|strong] content".
+- Coverage tiers are review context: none means no current reflection supports the observation id, partial means exactly one current reflection supports it, and strong means two or more current reflections support it. Coverage is not a quota, target, priority score, or instruction to emit reflections.
 
 What to emit:
 - Emit only new durable reflections not already present in current reflections.
@@ -39,13 +40,16 @@ Focus on:
 - Completed outcomes future runs must not redo.
 - Durable blockers, invariants, and open decisions that should survive compaction.
 
-Support ids:
+Support ids and coverage stewardship:
 - Every reflection must include supportingObservationIds from the current observations list.
-- supportingObservationIds are a coverage/provenance set: include current observation ids whose durable meaning is preserved by the reflection and can later be treated as redundant active-memory detail.
-- supportingObservationIds are not a checklist to cover every observation. They are evidence for a reflection that already passed the durable-value bar.
+- First decide whether the reflection content passes the durable-value bar. Then audit support ids for that already-worthy reflection.
+- supportingObservationIds are a coverage/provenance set and downstream dropper coverage evidence: include all current observation ids whose durable meaning is preserved by the reflection with equivalent fidelity and can later be treated as redundant active-memory detail.
+- supportingObservationIds are not a checklist to cover every observation. Do not add ids merely to improve coverage counts, maximize support ids, maximize strong coverage, or unlock the dropper.
+- False or inflated support ids can cause unsafe downstream dropper pruning, including removal of high-resistance active observations whose meaning was not actually preserved.
 - Include additional observation ids only when the reflection preserves their durable meaning with equivalent fidelity.
 - Leave observations unsupported when their details are still active working state, too specific to compress safely, or not yet durable enough.
 - Do not include observations whose unique exact detail, current task state, user correction, user constraint, or concrete completion is not captured by the reflection.
+- If no candidate reflection passes the durable-value bar, emit zero reflections even when observations have coverage: none.
 - Never invent observation ids. Proposals with missing, empty, or invalid supportingObservationIds are rejected.
 
 User assertions are authoritative. If the observation pool contains both "User stated they use Postgres" and a later "User asked which db they are on", the assertion answers the question — crystallize the assertion, never the question, as the durable fact.

package/src/om/consolidation.ts

@@ -49,7 +49,10 @@ import {
 	rawTokensSinceReflectionCoverage,
 	reflectionToSummaryLine,
 	reflectionsCreatedAfterIndex,
+	scoreObservation,
+	selectPriorObservations,
 	type Entry,
+	type Observation,
 	type Reflection,
 } from "./ledger/index.js";
 
@@ -124,6 +127,35 @@ function mergeReflections(existing: Reflection[], additional: Reflection[]): Ref
 	return merged;
 }
 
+
+
+/**
+ * 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 +304,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 +439,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 +473,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 +499,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 +530,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 +568,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 +602,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 +624,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 +655,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/ledger/projection.ts

@@ -4,6 +4,7 @@
  * Upstream: https://github.com/elpapi42/pi-observational-memory (src/session-ledger/projection.ts)
  * Unmodified.
  */
+import { selectPriorObservations } from "./render-summary.js";
 import {
 	OM_FOLDED,
 	isMemoryDetails,
@@ -207,10 +208,21 @@ export function buildCompactionProjection(
 		0,
 	);
 	const fullFold = observationTokens >= config.observationsPoolMaxTokens;
-	const projection = fullFold
+	let projection = fullFold
 		? fullProjection(entries, firstKeptEntryId)
 		: normalProjection;
 
+	// Cap observations to budget using relevance-tiered + recency scoring.
+	// Even if the dropper determined some old observations are worth keeping,
+	// this safety valve ensures the compaction output never exceeds the pool
+	// token budget. Observations survive in the branch regardless.
+	if (config.observationsPoolMaxTokens > 0 && observationTokens >= config.observationsPoolMaxTokens) {
+		projection = {
+			observations: selectPriorObservations(projection.observations, config.observationsPoolMaxTokens),
+			reflections: projection.reflections,
+		};
+	}
+
 	const details: MemoryDetails = {
 		type: OM_FOLDED,
 		version: 1,

package/src/om/ledger/render-summary.ts

@@ -25,6 +25,57 @@ export function observationToSummaryLine(observation: Observation): string {
 	return `[${observation.id}] ${observation.timestamp} [${observation.relevance}] ${observation.content}`;
 }
 
+/** Score an observation for cap/trim 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. */
+export 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 up to a token budget, keeping all high-relevance items
+ *  unconditionally and filling the remaining budget with the best-scoring
+ *  medium and low observations (relevance-tiered + recency).
+ *
+ *  Reflections are never trimmed — they are inherently rare and always stay.
+ *  Observations stay in the branch either way; this only caps what is rendered
+ *  in the compaction summary output. */
+export 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);
+}
+
 export function reflectionToSummaryLine(reflection: Reflection): string {
 	return `[${reflection.id}] ${reflection.content}`;
 }

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);
 }