pi-blackhole 0.3.9 → 0.4.1

package/README.md

@@ -240,6 +240,10 @@ The agent gets a unified `recall` tool that handles three types of input:
 
 All settings in a single JSON file: **`~/.pi/agent/pi-blackhole/pi-blackhole-config.json`** — auto-created with defaults on first startup. See [`CONFIG.md`](CONFIG.md) for the full reference with detailed explanations for every knob. An annotated example config is at [`example-config.json`](example-config.json).
 
+**Invalid JSON protection:** If the config file has a syntax error (trailing comma, partial write, sync conflict), the overlay (`/blackhole configure`) shows a red error banner and blocks save to prevent wiping your model configs. A yellow warning is also shown in the TUI. Fix the JSON directly in the file, then reopen the overlay.
+
+**Overlay reload:** Changes saved via `/blackhole configure` take effect immediately — no session restart needed. The runtime reloads config from disk after every successful overlay save.
+
 Quick start — just set custom models (if you want):
 
 ```json
@@ -343,7 +347,7 @@ These are the built-in defaults. If you reset your config, these are what you ge
 
 ### Tip: comments in config
 
-The config preserves unknown keys, so you can add `_comment` or `_notes` fields to document your choices inline. They're ignored by the parser.
+The config preserves unknown keys when loaded, so you can add `_comment` or `_notes` fields to document your choices inline. They're ignored by the parser.
 
 ```json
 {
@@ -352,6 +356,8 @@ The config preserves unknown keys, so you can add `_comment` or `_notes` fields
 }
 ```
 
+**Note:** The `/blackhole configure` overlay only manages the keys it knows about. All other keys (including `observerModel`, `reflectorModel`, `dropperModel`, and their fallback arrays) are preserved on save when the file has valid JSON. If the file has invalid JSON, save is blocked entirely — the overlay will not overwrite the file.
+
 ---
 
 ## Model fallback chains

package/example-config.json

@@ -7,6 +7,7 @@
   "compaction": "auto",
   "compactionEngine": "blackhole",
   "tailBehavior": "minimal",
+  "midRunCompaction": "resume",
 
   "model": {
     "_comment": "Base model (last fallback before session model).",
@@ -110,6 +111,7 @@
     "  compaction (auto|manual|off) — how compaction triggers",
     "  compactionEngine (blackhole|pi-default) — who handles it",
     "  tailBehavior (pi-default|minimal) — how much stays visible",
+    "  midRunCompaction (resume|pause|off) — threshold check during tool loops",
     "  sessionFallback (true|false) — if false, skip session model as last-resort fallback",
     "  dropperPressureThreshold (0-1, default 0.70) — pressure relief valve: fraction of reflectorInputMaxTokens where dropper fires even without new data",
     "",

package/index.ts

@@ -34,12 +34,12 @@ export default (pi: ExtensionAPI) => {
 	const providerStreams: Map<string, Function> = (globalThis as any)[PROVIDER_STREAMS_KEY] ??= new Map();
 
 	const origRegisterProvider = pi.registerProvider.bind(pi);
-	pi.registerProvider = (name: string, config: any) => {
+	pi.registerProvider = ((name: string, config: any) => {
 		if (config && config.streamSimple && config.api) {
 			providerStreams.set(config.api, config.streamSimple);
 		}
 		origRegisterProvider(name, config);
-	};
+	}) as typeof pi.registerProvider;
 
 	// Fallback: on agent_start, capture providers that registered before our wrapper
 	// (handles the case where pi-blackhole loads after another provider extension).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-blackhole",
-  "version": "0.3.9",
+  "version": "0.4.1",
   "packageManager": "pnpm@11.2.2",
   "description": "Unified compaction + observational memory extension for Pi — compresses conversation context while preserving durable observations and reflections",
   "license": "MIT",
@@ -40,10 +40,10 @@
   },
   "dependencies": {},
   "peerDependencies": {
-    "@earendil-works/pi-agent-core": ">=0.75.5 <1.0.0",
-    "@earendil-works/pi-ai": ">=0.75.4 <1.0.0",
-    "@earendil-works/pi-coding-agent": ">=0.75.4 <1.0.0",
-    "@earendil-works/pi-tui": ">=0.75.5 <1.0.0"
+    "@earendil-works/pi-agent-core": ">=0.81.1 <1.0.0",
+    "@earendil-works/pi-ai": ">=0.81.1 <1.0.0",
+    "@earendil-works/pi-coding-agent": ">=0.81.1 <1.0.0",
+    "@earendil-works/pi-tui": ">=0.81.1 <1.0.0"
   },
   "pi": {
     "extensions": [
@@ -51,10 +51,10 @@
     ]
   },
   "devDependencies": {
-    "@earendil-works/pi-agent-core": "0.75.5",
-    "@earendil-works/pi-ai": "0.75.4",
-    "@earendil-works/pi-coding-agent": "0.75.4",
-    "@earendil-works/pi-tui": "0.75.5",
+    "@earendil-works/pi-agent-core": "0.81.1",
+    "@earendil-works/pi-ai": "0.81.1",
+    "@earendil-works/pi-coding-agent": "0.81.1",
+    "@earendil-works/pi-tui": "0.81.1",
     "@typescript-eslint/eslint-plugin": "8.60.0",
     "@typescript-eslint/parser": "8.60.0",
     "eslint": "9.39.4",
@@ -62,6 +62,6 @@
     "lint-staged": "15.5.2",
     "typebox": "1.1.38",
     "typescript": "5.9.3",
-    "vitest": "4.1.7"
+    "vitest": "4.1.9"
   }
 }

package/src/commands/cleanup.ts

@@ -0,0 +1,319 @@
+/**
+ * Cleanup handler — TUI picker for orphaned pending files.
+ *
+ * Called from /blackhole cleanup subcommand.
+ * Scans pi-blackhole pending files, cross-references against session JSONL
+ * files, and lets the user delete orphaned ones interactively.
+ *
+ * TUI picker (overlay) provides:
+ *   ↑↓  navigate
+ *   Enter  delete selected file
+ *   D      delete all orphaned (with inline confirmation)
+ *   Esc    cancel / close
+ *
+ * Non-TUI fallback (RPC / JSON / print modes): lists orphaned files as text
+ * notification. Use TUI mode to actually delete.
+ */
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { matchesKey, decodeKittyPrintable } from "@earendil-works/pi-tui";
+import { visibleWidth } from "../om/key-matcher.js";
+import {
+	analyzeOrphaned,
+	deletePendingFiles,
+	deleteOrphanedBatch,
+	describeFile,
+	type PendingFile,
+} from "../om/cleanup.js";
+
+// ── TUI Picker Component ────────────────────────────────────────────────────
+
+const LIST_ROWS = 10;
+
+/** Clamp a list index to [0, length-1]. */
+function clampIndex(idx: number, length: number): number {
+	if (length === 0) return 0;
+	return Math.max(0, Math.min(idx, length - 1));
+}
+
+/** Build the framed top border with optional title and right-aligned info. */
+function buildTopBorder(
+	width: number,
+	border: (s: string) => string,
+	dim: (s: string) => string,
+	title?: string,
+	right?: string,
+): string {
+	const innerW = Math.max(1, width - 2);
+	if (!title && !right) {
+		return border(`┏${"━".repeat(innerW)}┓`);
+	}
+	const rightText = right ? ` ${right} ` : "";
+	const titleBudget = Math.max(1, innerW - visibleWidth(rightText) - 1);
+	const titleFitted = title
+		? ` ${title.slice(0, Math.max(1, titleBudget - 2))}${title.length > titleBudget - 2 ? "…" : ""} `
+		: "";
+	const fill = Math.max(1, innerW - visibleWidth(titleFitted) - visibleWidth(rightText));
+	return border(`┏${titleFitted}${"━".repeat(fill)}${right ? dim(rightText) : ""}┓`);
+}
+
+// ── Component ───────────────────────────────────────────────────────────────
+
+/**
+ * Create the orphaned-files picker component for ctx.ui.custom().
+ *
+ * The component mutates the `orphaned` array in-place when single items are
+ * deleted (immediate feedback). The caller creates a copy if needed.
+ */
+function createCleanupPicker(
+	orphaned: PendingFile[],
+	theme: { fg: (s: string, t: string) => string; bg: (s: string, t: string) => string },
+	done: (result: "deleteAll" | "cancel") => void,
+): { render(width: number): string[]; handleInput(data: string): void; invalidate(): void } {
+	let selectedIndex = 0;
+	let scrollOffset = 0;
+	let confirmDeleteAll = false;
+
+	function clampScroll(): void {
+		const count = orphaned.length;
+		selectedIndex = clampIndex(selectedIndex, count);
+		const maxOffset = Math.max(0, count - LIST_ROWS);
+		scrollOffset = Math.max(0, Math.min(scrollOffset, maxOffset));
+		if (selectedIndex < scrollOffset) scrollOffset = selectedIndex;
+		if (selectedIndex >= scrollOffset + LIST_ROWS && count > 0) {
+			scrollOffset = selectedIndex - LIST_ROWS + 1;
+		}
+	}
+
+	const bdr = (t: string) => theme.fg("border", t);
+	const dim = (t: string) => theme.fg("dim", t);
+	const accent = (t: string) => theme.fg("accent", t);
+	const err = (t: string) => theme.fg("error", t);
+	const now = Date.now();
+
+	function itemLine(pf: PendingFile, isSel: boolean, cw: number): string {
+		const desc = describeFile(pf, now);
+		const prefix = isSel ? accent(" ▶") : "  ";
+		const main = isSel ? accent(desc) : desc;
+		const line = `${prefix} ${main}`;
+		return ` ${line}${" ".repeat(Math.max(0, cw - visibleWidth(line)))} `;
+	}
+
+	return {
+		invalidate(): void {
+			// No cache — render is always fresh
+		},
+
+		render(width: number): string[] {
+			const w = Math.max(40, width);
+			const innerW = Math.max(1, w - 2);
+			const PX = 1;
+			const cw = Math.max(1, innerW - PX * 2);
+			const lines: string[] = [];
+
+			// ── Confirm-delete-all ──
+			if (confirmDeleteAll) {
+				const title = `Delete ${orphaned.length} orphaned file${orphaned.length === 1 ? "" : "s"}?`;
+				lines.push(buildTopBorder(w, bdr, dim, "Cleanup Pending Files"));
+				lines.push(bdr(`┃${" ".repeat(innerW)}┃`));
+				lines.push(bdr(`┃ ${err(title)}${" ".repeat(Math.max(0, cw - visibleWidth(title)))} ┃`));
+				lines.push(bdr(`┃${" ".repeat(innerW)}┃`));
+				const hint = "Enter confirm · Esc cancel";
+				lines.push(bdr(`┃ ${dim(hint)}${" ".repeat(Math.max(0, cw - visibleWidth(hint)))} ┃`));
+				lines.push(bdr(`┗${"━".repeat(innerW)}┛`));
+				return lines;
+			}
+
+			// ── List ──
+			clampScroll();
+
+			const sizeLabel = `${orphaned.length} file${orphaned.length === 1 ? "" : "s"}`;
+			lines.push(buildTopBorder(w, bdr, dim, "Orphaned Pending Files", sizeLabel));
+			lines.push(bdr(`┃${" ".repeat(innerW)}┃`));
+
+			if (orphaned.length === 0) {
+				lines.push(bdr(`┃ ${dim("No orphaned pending files found")}${" ".repeat(Math.max(0, cw - 29))} ┃`));
+			} else {
+				const visible = orphaned.slice(scrollOffset, scrollOffset + LIST_ROWS);
+				for (let vi = 0; vi < visible.length; vi++) {
+					const idx = scrollOffset + vi;
+					const pf = visible[vi];
+					if (!pf) continue;
+					const isSel = idx === selectedIndex;
+					const row = itemLine(pf, isSel, cw);
+					lines.push(isSel
+						? theme.bg("selectedBg", bdr(`┃${row}┃`))
+						: bdr(`┃${row}┃`));
+				}
+			}
+
+			// Filler rows
+			for (let i = Math.min(orphaned.length, LIST_ROWS); i < LIST_ROWS; i++) {
+				lines.push(bdr(`┃${" ".repeat(innerW)}┃`));
+			}
+
+			lines.push(bdr(`┃${" ".repeat(innerW)}┃`));
+
+			if (orphaned.length > 0) {
+				const totalBytes = orphaned.reduce((s, pf) => s + pf.sizeBytes, 0);
+				const kb = totalBytes > 0 ? (totalBytes / 1024).toFixed(1) : "0.0";
+				const totalStr = `Total: ${kb} KB`;
+				const hint = "↑↓ navigate  Enter delete  D delete all  Esc cancel";
+				lines.push(bdr(`┃ ${dim(totalStr)}${" ".repeat(Math.max(0, cw - visibleWidth(totalStr)))} ┃`));
+				lines.push(bdr(`┃ ${dim(hint)}${" ".repeat(Math.max(0, cw - visibleWidth(hint)))} ┃`));
+			} else {
+				const hint = "Esc close";
+				lines.push(bdr(`┃ ${dim(hint)}${" ".repeat(Math.max(0, cw - visibleWidth(hint)))} ┃`));
+			}
+			lines.push(bdr(`┗${"━".repeat(innerW)}┛`));
+			return lines;
+		},
+
+		handleInput(data: string): void {
+			const key = decodeKittyPrintable(data) ?? data;
+
+			if (confirmDeleteAll) {
+				if (matchesKey(data, "enter") || matchesKey(data, "return")) {
+					done("deleteAll");
+					return;
+				}
+				if (matchesKey(data, "escape")) {
+					confirmDeleteAll = false;
+					return;
+				}
+				return;
+			}
+
+			if (orphaned.length === 0) {
+				if (matchesKey(data, "escape")) done("cancel");
+				return;
+			}
+
+			if (matchesKey(data, "up")) {
+				selectedIndex = clampIndex(selectedIndex - 1, orphaned.length);
+				clampScroll();
+				return;
+			}
+			if (matchesKey(data, "down")) {
+				selectedIndex = clampIndex(selectedIndex + 1, orphaned.length);
+				clampScroll();
+				return;
+			}
+			if (matchesKey(data, "pageUp") || key === "-") {
+				selectedIndex = clampIndex(selectedIndex - LIST_ROWS, orphaned.length);
+				clampScroll();
+				return;
+			}
+			if (matchesKey(data, "pageDown") || key === "=") {
+				selectedIndex = clampIndex(selectedIndex + LIST_ROWS, orphaned.length);
+				clampScroll();
+				return;
+			}
+			if (matchesKey(data, "home")) {
+				selectedIndex = 0;
+				scrollOffset = 0;
+				return;
+			}
+			if (matchesKey(data, "end")) {
+				selectedIndex = Math.max(0, orphaned.length - 1);
+				clampScroll();
+				return;
+			}
+			if (matchesKey(data, "enter") || matchesKey(data, "return")) {
+				const pf = orphaned[selectedIndex];
+				if (pf) {
+					deletePendingFiles(pf.sessionId);
+					orphaned.splice(selectedIndex, 1);
+					if (orphaned.length === 0) {
+						done("cancel");
+						return;
+					}
+					selectedIndex = clampIndex(selectedIndex, orphaned.length);
+					clampScroll();
+				}
+				return;
+			}
+			if (key === "d" || key === "D") {
+				confirmDeleteAll = true;
+				return;
+			}
+			if (matchesKey(data, "escape")) {
+				done("cancel");
+				return;
+			}
+		},
+	};
+}
+
+// ── Public handler ──────────────────────────────────────────────────────────
+
+/**
+ * Handle the /blackhole cleanup subcommand.
+ *
+ * Runs the full analysis pipeline (scan pending → scan sessions → cross-ref),
+ * then opens the TUI picker if there are orphaned files.
+ *
+ * In non-TUI modes (RPC/JSON/print): lists orphaned files as a notification
+ * without deleting anything.
+ */
+export async function handleCleanup(ctx: ExtensionContext): Promise<void> {
+	const { orphaned } = analyzeOrphaned();
+
+	if (orphaned.length === 0) {
+		ctx.ui.notify("pi-blackhole: No orphaned pending files found.", "info");
+		return;
+	}
+
+	const isRpc = ctx.mode === "rpc" || ctx.mode === "json" || ctx.mode === "print";
+	if (isRpc) {
+		// Non-TUI: list only
+		const totalSize = orphaned.reduce((s, pf) => s + pf.sizeBytes, 0);
+		const lines = [
+			`Orphaned pending files: ${orphaned.length} (${(totalSize / 1024).toFixed(1)} KB)`,
+			"",
+			...orphaned.map((pf) => `  ${describeFile(pf)}`),
+			"",
+			"Use /blackhole cleanup in TUI mode to delete these files.",
+		];
+		ctx.ui.notify(lines.join("\n"), "warning");
+		return;
+	}
+
+	// Work on a copy — the picker mutates the array for inline deletes.
+	const items = [...orphaned];
+	const result = await ctx.ui.custom<"deleteAll" | "cancel" | null>(
+		(_tui, theme, _kb, done) => {
+			return createCleanupPicker(items, theme as any, done);
+		},
+		{ overlay: true },
+	);
+
+	if (result === "deleteAll") {
+		const deleted = deleteOrphanedBatch(items);
+		const intended = items.length;
+		if (deleted === intended) {
+			ctx.ui.notify(
+				`pi-blackhole: Deleted ${intended} orphaned pending file${intended === 1 ? "" : "s"}.`,
+				"info",
+			);
+		} else {
+			ctx.ui.notify(
+				`pi-blackhole: Deleted ${deleted}/${intended} orphaned pending file${intended === 1 ? "" : "s"} (${intended - deleted} failed).`,
+				"warning",
+			);
+		}
+	} else if (items.length > 0 && items.length < orphaned.length) {
+		// Some were deleted inline, some remain
+		const remainingSize = items.reduce((s, pf) => s + pf.sizeBytes, 0);
+		ctx.ui.notify(
+			`pi-blackhole: ${orphaned.length - items.length} deleted, ${items.length} remain (${(remainingSize / 1024).toFixed(1)} KB).`,
+			"info",
+		);
+	} else if (items.length === 0 && orphaned.length > 0) {
+		// All were deleted inline
+		ctx.ui.notify(
+			`pi-blackhole: All ${orphaned.length} orphaned pending file${orphaned.length === 1 ? "" : "s"} removed.`,
+			"info",
+		);
+	}
+	// If nothing was deleted (user just pressed Esc), stay silent
+}

package/src/commands/memory.ts

@@ -72,9 +72,9 @@ function renderContentOnlyProjection(projection: Projection, emptyScope: "visibl
 
 export function registerMemoryCommand(pi: ExtensionAPI, runtime: Runtime): void {
 	pi.registerCommand("blackhole-memory", {
-		description: "Show memory pipeline status & token counters. /blackhole-memory for overview, /blackhole-memory view for visible observations & reflections, /blackhole-memory full for complete recorded memory (copies to clipboard).",
+		description: "Show memory pipeline status & token counters. /blackhole-memory [view] visible observations & reflections, [full] complete recorded memory (copies to clipboard).",
 		handler: async (args, ctx) => {
-			runtime.ensureConfig(ctx.cwd);
+			runtime.ensureConfig(ctx.cwd, (msg) => ctx.ui?.notify?.(msg, "warning"));
 			const entries = ctx.sessionManager.getBranch() as Entry[];
 			const sessionId = ctx.sessionManager.getSessionId();
 			const mode = firstArg(args);

package/src/commands/pi-vcc.ts

@@ -8,7 +8,7 @@
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { Runtime } from "../om/runtime.js";
-import { PI_VCC_COMPACT_INSTRUCTION, notifyMigrationReminder } from "../hooks/before-compact";
+import { PI_VCC_COMPACT_INSTRUCTION, notifyMigrationReminder, formatCompactionStats } from "../hooks/before-compact";
 import { saveUnifiedConfig, configPath } from "../core/unified-config.js";
 import { readPendingState, clearPendingState, hasPendingData } from "../om/pending.js";
 import { createConfigureOverlay } from "../om/configure-overlay.js";
@@ -17,11 +17,7 @@ import {
 	OM_OBSERVATIONS_RECORDED,
 	OM_REFLECTIONS_RECORDED,
 } from "../om/ledger/index.js";
-
-const formatTokens = (n: number): string => {
-	if (n >= 1000) return `${(n / 1000).toFixed(1)}k`;
-	return String(n);
-};
+import { handleCleanup } from "./cleanup.js";
 
 export const registerPiVccCommand = (pi: ExtensionAPI, runtime: Runtime) => {
 	const prefixMatch = (value: string, prefix: string): boolean => {
@@ -31,11 +27,12 @@ export const registerPiVccCommand = (pi: ExtensionAPI, runtime: Runtime) => {
 	pi.registerCommand("blackhole", {
 		description:
 			"Compact conversation — structured summary (with observational memory when enabled). " +
-			"Subcommands: /blackhole configure (open settings overlay), " +
-			"/blackhole om-off (disable memory), /blackhole om-on (re-enable memory).",
+			"Subcommands: [configure] settings overlay, [cleanup] remove orphaned files, " +
+			"[om-off] / [om-on] disable / re-enable memory.",
 		getArgumentCompletions: (prefix: string) => {
 			const subcommands = [
 				{ value: "configure", label: "Open configuration overlay to edit settings [configure]" },
+				{ value: "cleanup", label: "Find and remove orphaned pending files [cleanup]" },
 				{ value: "om-off", label: "Disable observational memory [om-off]" },
 				{ value: "om-on", label: "Enable observational memory [om-on]" },
 			];
@@ -49,12 +46,15 @@ export const registerPiVccCommand = (pi: ExtensionAPI, runtime: Runtime) => {
 			const trimmed = (typeof args === "string" ? args : "").trim();
 			if (trimmed === "configure") {
 				// Open the config overlay
-				const result = await ctx.ui.custom<{ saved: boolean; path: string } | undefined>(
+				const result = await ctx.ui.custom<{ saved: boolean; path: string; error?: string } | undefined>(
 					(tui, theme, _kb, done) => createConfigureOverlay(configPath(), theme, tui, done),
 					{ overlay: true },
 				);
 				if (result) {
-					if (result.saved) {
+					if (result.error) {
+						ctx.ui.notify(result.error, "warning");
+					} else if (result.saved) {
+						runtime.reloadConfig(ctx.cwd, (msg) => ctx.ui?.notify?.(msg, "warning"));
 						ctx.ui.notify("Configuration saved.", "info");
 					} else {
 						ctx.ui.notify("Failed to save configuration — the config file may be read-only (e.g., managed by Nix).", "warning");
@@ -62,6 +62,10 @@ export const registerPiVccCommand = (pi: ExtensionAPI, runtime: Runtime) => {
 				}
 				return;
 			}
+			if (trimmed === "cleanup") {
+				await handleCleanup(ctx);
+				return;
+			}
 			if (trimmed === "om-off") {
 				const saved = saveUnifiedConfig({ memory: false });
 				runtime.config.memory = false;
@@ -91,6 +95,21 @@ export const registerPiVccCommand = (pi: ExtensionAPI, runtime: Runtime) => {
 				return;
 			}
 
+			// Warn if input starts with a known subcommand but isn't an exact match.
+			// Prevents "/blackhole configure foo" from silently becoming a follow-up.
+			const SUBCOMMAND_NAMES = ["configure", "cleanup", "om-off", "om-on"];
+			const nearMiss = SUBCOMMAND_NAMES.find(
+				name => trimmed.toLowerCase().startsWith(name.toLowerCase()) && trimmed.length > name.length
+			);
+			if (nearMiss) {
+				ctx.ui.notify(`/blackhole ${nearMiss} accepts no arguments. Did you mean \"/blackhole ${nearMiss}\"?`, "warning");
+				return;
+			}
+
+			// Extract follow-up prompt: everything after the subcommand check
+			// that isn't a known subcommand is treated as follow-up text.
+			const followUpPrompt = trimmed ? trimmed : null;
+
 			// If compaction is manual (or legacy noAutoCompact): flush pending OM entries
 			// into the branch before compacting so the summary includes accumulated memory.
 			if (runtime.config.compaction === "manual" && hasPendingData(sessionId)) {
@@ -128,14 +147,18 @@ export const registerPiVccCommand = (pi: ExtensionAPI, runtime: Runtime) => {
 				onComplete: () => {
 					const stats = runtime.compactionStats;
 					if (stats) {
-						ctx.ui.notify(
-							`blackhole: ${stats.summarized} source entries processed; tail kept ${stats.kept} (~${formatTokens(stats.keptTokensEst)} tok).`,
-							"info",
-						);
+						ctx.ui.notify(formatCompactionStats(stats), "info");
 					} else {
 						ctx.ui.notify("Compacted with blackhole", "info");
 					}
 					notifyMigrationReminder(sessionId, (msg, level) => ctx.ui.notify(msg, level as any));
+
+					// Fire follow-up prompt after compaction completes
+					if (followUpPrompt) {
+						try {
+							void Promise.resolve(pi.sendUserMessage(followUpPrompt)).catch(() => {});
+						} catch {}
+					}
 				},
 				onError: (err) => {
 					if (err.message === "Compaction cancelled" || err.message === "Already compacted") {

package/src/core/format.ts

@@ -31,7 +31,6 @@ export const wrapLongLines = (text: string, maxChars = TUI_SAFE_LINE_CHARS): str
 export const capBrief = (text: string): string => {
   const lines = text.split("\n");
   if (lines.length <= BRIEF_MAX_LINES) return text;
-  const omitted = lines.length - BRIEF_MAX_LINES;
   const kept = lines.slice(-BRIEF_MAX_LINES);
   // Find first section header to avoid cutting mid-section
   let firstHeader = kept.findIndex((l) => /^\[.+\]/.test(l));
@@ -42,6 +41,7 @@ export const capBrief = (text: string): string => {
     if (anyAnchor > 0) firstHeader = anyAnchor;
   }
   const clean = firstHeader > 0 ? kept.slice(firstHeader) : kept;
+  const omitted = lines.length - clean.length;
   return `...(${omitted} earlier lines omitted)\n\n${clean.join("\n")}`;
 };
 

package/src/core/summarize.ts

@@ -71,7 +71,11 @@ const mergeHeaderSection = (header: string, prev: string, fresh: string): string
   const freshLines = fresh.split("\n").filter(isClean);
   const combined = [...new Set([...prevLines, ...freshLines])];
   const CAP = header === "Session Goal" ? 8 : header === "Commits" ? 8 : 15;
-  const capped = combined.length > CAP ? combined.slice(-CAP) : combined;
+  // Session Goal: keep first items so the original first message persists
+  // Other sections: keep last items (fresh overrides stale)
+  const capped = combined.length > CAP
+    ? (header === "Session Goal" ? combined.slice(0, CAP) : combined.slice(-CAP))
+    : combined;
   if (capped.length === 0) return "";
   return `[${header}]\n${capped.join("\n")}`;
 };
@@ -154,38 +158,41 @@ export const compile = (input: CompileInput): string => {
   const blocks = filterNoise(normalize(input.messages));
   const data = buildSections({ blocks });
   const fresh = formatSummary(data);
-  // Strip any legacy RECALL_NOTE baked into prev summary (pre-fix format)
-  // so merge doesn't re-stack it inside the brief.
-  // Also strip OM content (## Reflections / ## Observations) from previous
-  // compactions — these are re-rendered fresh by the before-compact hook.
+
+  // Strip OM content first (## Reflections / ## Observations + preamble),
+  // then strip ALL recall notes from the previous summary using paragraph-level
+  // matching. Order matters: OM sections appear before the recall note in the
+  // stored summary, so we must remove them first to avoid leaving the recall
+  // stripper with fragments.
   let prev = input.previousSummary
-    ? stripRecallNote(input.previousSummary)
+    ? stripOMContent(input.previousSummary)
     : undefined;
-  prev = prev ? stripOMContent(prev) : undefined;
+  prev = prev ? stripRecallNotes(prev) : undefined;
   const merged = prev ? mergePrevious(prev, fresh) : fresh;
   if (!merged) return "";
-  return wrapLongLines(merged + SEPARATOR + RECALL_NOTE);
-};
-
-const stripRecallNote = (text: string): string => {
-  // Remove trailing RECALL_NOTE (and any separators surrounding it) if present.
-  // Handles both current format (---\n\nNOTE) and bare trailing NOTE.
-  const idx = text.lastIndexOf(RECALL_NOTE);
-  if (idx < 0) return text;
-  return text.slice(0, idx).replace(/\s*(?:\n\n---\n\n)?\s*$/, "").trimEnd();
+  // Defensive: remove any recall notes that survived the above (e.g. nested
+  // inside the brief transcript after a prior merge).
+  const cleaned = stripRecallNotes(merged);
+  return wrapLongLines(cleaned + SEPARATOR + RECALL_NOTE);
 };
 
 /**
- * Strip OM content and recall-guidance footers from a previous compaction summary.
+ * Strip ALL recall-note paragraphs from text using paragraph-level matching.
  *
- * OM content (## Reflections / ## Observations + instructions) is appended after
- * compile() by the before-compact hook, so it must be stripped from the previous
- * summary to prevent compounding across compactions. The fresh OM projection is
- * re-rendered each time.
+ * The recall note is identified by the sentence:
+ *   "The conversation before this point has been compacted"
  *
- * Also strips the basic recall-guidance footer that is always appended when OM
- * is off or has no entries.
+ * After wrapLongLines runs, the recall note may be split across multiple lines,
+ * so exact string matching against RECALL_NOTE fails. Instead, split the text
+ * into paragraphs (double-newline boundaries) and drop any paragraph that
+ * contains the identifying sentence.
  */
+const stripRecallNotes = (text: string): string => {
+  const paragraphs = text.split(/\n\n+/);
+  const kept = paragraphs.filter((p) => !p.includes("The conversation before this point has been compacted"));
+  return kept.join("\n\n");
+};
+
 const stripOMContent = (text: string): string => {
   // Remove everything from "## Reflections" or "## Observations" onward,
   // plus the instructions preamble that precedes them.