@oh-my-pi/pi-coding-agent 16.2.3 → 16.2.4

package/dist/types/cli/update-cli.d.ts

@@ -27,6 +27,21 @@ interface UpdateMethodResolutionOptions {
     miseDataDir?: string;
 }
 export declare function resolveUpdateMethodForTest(ompPath: string, bunBinDir: string | undefined, options?: UpdateMethodResolutionOptions): UpdateMethod;
+interface BunInstallCachePruneResult {
+    scannedPackages: number;
+    removedEntries: number;
+}
+/**
+ * Prune Bun's package cache so each package keeps only its newest cached version.
+ *
+ * Bun stores package cache entries as both a package marker directory
+ * (`react/19.2.6@@@1`) and a materialized package directory
+ * (`react@19.2.6@@@1`). Global `omp` updates can leave one full copy per
+ * release. The marker and materialized entries are removed together so the
+ * cache stays internally consistent.
+ */
+export declare function pruneBunInstallCache(cacheDir: string, packageNames?: Set<string>): Promise<BunInstallCachePruneResult>;
+export declare function resolveBunGlobalNodeModulesDirFromLocations(globalBinDir: string | undefined, cacheDir: string | undefined): string | undefined;
 /**
  * Best-effort removal of binary-update backups left by earlier runs.
  *

package/dist/types/collab/replication-shrink.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Hard-cap helper for host→guest collab frames.
+ *
+ * The host wraps every {@link CollabFrame} in an AES-GCM envelope and ships it
+ * through the relay's WebSocket. WebSocket servers enforce a per-frame
+ * `maxPayloadLength` (Bun's default is 16 MB; many proxies cap lower). A
+ * single oversized payload — typically a `read`/`bash`/`search` tool result
+ * captured as one multi-megabyte string, or a tool result whose `content`
+ * array holds thousands of small blocks — would otherwise ship as its own
+ * oversized frame and trip that limit, killing the host's WebSocket with
+ * `1006 Received too big message`. `CollabSocket` treats 1006 as transient
+ * and reconnects, the next guest hello triggers the same oversized send, and
+ * the loop never breaks (issue #3739).
+ *
+ * This helper bounds any JSON-serializable payload below
+ * {@link MAX_REPLICATED_PAYLOAD_BYTES}. Already-small payloads pass through
+ * untouched; oversized ones are returned as a deep-cloned shadow where long
+ * strings are head-truncated AND long arrays are head-clipped, with
+ * `[…N chars elided for collab session]` / `[…N items elided for collab
+ * session]` markers. Both axes are needed: string truncation alone leaves
+ * the cap unenforced for a payload built of many short strings, where no
+ * field exceeds the per-string floor.
+ */
+/**
+ * Per-payload ceiling for host→guest frames. Bun's default WebSocket
+ * `maxPayloadLength` is 16 MB; we leave a generous margin so the AES-GCM
+ * envelope (+ IV + tag), the 4-byte peer header, and the outer wire wrapper
+ * fit comfortably under that on every reasonable relay.
+ */
+export declare const MAX_REPLICATED_PAYLOAD_BYTES: number;
+/**
+ * Return `value` unchanged when its JSON serialization already fits
+ * {@link MAX_REPLICATED_PAYLOAD_BYTES}; otherwise return a deep-cloned
+ * shadow shrunk along both string and array axes until the payload fits.
+ * The function is generic over `T` because the wire shape is preserved:
+ * only string leaves and array tails change; discriminator fields, ids, and
+ * other small metadata pass through untouched.
+ */
+export declare function shrinkForReplication<T>(value: T): T;

package/dist/types/config/provider-globals.d.ts

@@ -0,0 +1,7 @@
+interface ProviderGlobalSettings {
+    get(path: "providers.webSearchExclude"): unknown;
+    get(path: "providers.webSearch"): unknown;
+    get(path: "providers.image"): unknown;
+}
+export declare function applyProviderGlobalsFromSettings(settings: ProviderGlobalSettings): void;
+export {};

package/dist/types/memories/index.d.ts

@@ -14,10 +14,28 @@ export declare function startMemoryStartupTask(options: {
     agentDir: string;
     taskDepth: number;
 }): void;
+interface MemoryInstructionSession {
+    sessionManager: Pick<AgentSession["sessionManager"], "getSessionFile">;
+}
+/**
+ * Drop the per-session memory instruction snapshot after explicit memory state
+ * changes that must affect the active conversation immediately, such as
+ * `/memory clear`.
+ */
+export declare function clearMemoryToolDeveloperInstructionsCache(session: MemoryInstructionSession | undefined): void;
+/**
+ * Refresh the active session's consolidated-memory snapshot after startup maintenance.
+ *
+ * Startup may finish after the first prompt build and write `memory_summary.md`;
+ * the active session should see that summary. It must not reread `learned.md`,
+ * because a `learn` call racing with startup belongs to the next session's
+ * memory prompt, not the active prompt-cache prefix.
+ */
+export declare function refreshMemoryToolDeveloperInstructionsCacheAfterStartup(session: MemoryInstructionSession, agentDir: string, settings: Settings): Promise<void>;
 /**
  * Build memory usage instructions for prompt injection.
  */
-export declare function buildMemoryToolDeveloperInstructions(agentDir: string, settings: Settings): Promise<string | undefined>;
+export declare function buildMemoryToolDeveloperInstructions(agentDir: string, settings: Settings, session?: MemoryInstructionSession): Promise<string | undefined>;
 /**
  * Clear all persisted memory state and generated artifacts.
  */
@@ -33,3 +51,4 @@ export declare function getMemoryRoot(agentDir: string, cwd: string): string;
  * tool when `memory.backend` is `local`.
  */
 export declare function saveLearnedLesson(agentDir: string, cwd: string, input: MemoryBackendSaveInput): Promise<MemoryBackendSaveResult>;
+export {};

package/dist/types/modes/components/status-line/component.d.ts

@@ -14,6 +14,11 @@ export declare class StatusLineComponent implements Component {
     getEffectiveSettingsForTest(): EffectiveStatusLineSettings;
     setAutoCompactEnabled(enabled: boolean): void;
     setSubagentCount(count: number): void;
+    /**
+     * Compatibility shim for callers predating the simplified subagent badge.
+     * The status line now intentionally shows only the active count.
+     */
+    setSubagentHubHint(_hint: string | undefined): void;
     /** Active subagent count as currently displayed (collab state mirroring). */
     get subagentCount(): number;
     /**

package/dist/types/modes/controllers/command-controller.d.ts

@@ -30,13 +30,13 @@ export declare class CommandController {
     handleDropCommand(): Promise<void>;
     handleForkCommand(): Promise<void>;
     /**
-     * `/move` — switch to a fresh empty session in a different directory.
+     * `/move` — relocate the current session to a different directory.
      *
      * With no `targetPath` (TUI only), opens an autocomplete overlay so the user
      * can pick or type a directory. With a `targetPath`, resolves it directly.
      * If the target directory does not exist, the user is asked whether to create
-     * it. A brand-new empty session is then started in the target directory and
-     * the current session is left behind (resumable via `/resume`).
+     * it. The active session file and artifacts are moved into the target
+     * directory's session bucket so `/resume` from that directory can find it.
      */
     handleMoveCommand(targetPath?: string): Promise<void>;
     handleRenameCommand(title: string): Promise<void>;

package/dist/types/modes/interactive-mode.d.ts

@@ -83,6 +83,7 @@ export declare class InteractiveMode implements InteractiveModeContext {
     chatContainer: TranscriptContainer;
     pendingMessagesContainer: Container;
     statusContainer: Container;
+    todoReminderContainer: Container;
     todoContainer: Container;
     subagentContainer: Container;
     btwContainer: Container;

package/dist/types/modes/types.d.ts

@@ -81,6 +81,7 @@ export interface InteractiveModeContext {
     chatContainer: TranscriptContainer;
     pendingMessagesContainer: Container;
     statusContainer: Container;
+    todoReminderContainer: Container;
     todoContainer: Container;
     subagentContainer: Container;
     btwContainer: Container;
@@ -104,7 +105,7 @@ export interface InteractiveModeContext {
     focusParentSession(): Promise<void>;
     /** Return the view to the main session (delegates to SessionFocusController.unfocus). */
     unfocusSession(): Promise<void>;
-    /** Clear loader, status/pending containers, streaming state, and pending tools. */
+    /** Clear loader, transient HUD/pending containers, streaming state, and pending tools. */
     clearTransientSessionUi(): void;
     settings: Settings;
     keybindings: KeybindingsManager;

package/dist/types/session/session-manager.d.ts

@@ -242,9 +242,8 @@ export declare class SessionManager {
     /**
      * Create a fresh empty session file in the default session directory for
      * `cwd`, writing only the session header. The returned path can be passed to
-     * `setSessionFile` / `AgentSession.switchSession` to start a new empty
-     * session in that directory. Used by `/move` to switch projects without
-     * dragging the current conversation along.
+     * `setSessionFile` / `AgentSession.switchSession` when a caller explicitly
+     * needs a brand-new persisted session at a cwd-derived path.
      */
     static createEmptySessionFile(cwd: string, storage?: SessionStorage): string;
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.2.3",
+	"version": "16.2.4",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -55,17 +55,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.2.3",
-		"@oh-my-pi/omp-stats": "16.2.3",
-		"@oh-my-pi/pi-agent-core": "16.2.3",
-		"@oh-my-pi/pi-ai": "16.2.3",
-		"@oh-my-pi/pi-catalog": "16.2.3",
-		"@oh-my-pi/pi-mnemopi": "16.2.3",
-		"@oh-my-pi/pi-natives": "16.2.3",
-		"@oh-my-pi/pi-tui": "16.2.3",
-		"@oh-my-pi/pi-utils": "16.2.3",
-		"@oh-my-pi/pi-wire": "16.2.3",
-		"@oh-my-pi/snapcompact": "16.2.3",
+		"@oh-my-pi/hashline": "16.2.4",
+		"@oh-my-pi/omp-stats": "16.2.4",
+		"@oh-my-pi/pi-agent-core": "16.2.4",
+		"@oh-my-pi/pi-ai": "16.2.4",
+		"@oh-my-pi/pi-catalog": "16.2.4",
+		"@oh-my-pi/pi-mnemopi": "16.2.4",
+		"@oh-my-pi/pi-natives": "16.2.4",
+		"@oh-my-pi/pi-tui": "16.2.4",
+		"@oh-my-pi/pi-utils": "16.2.4",
+		"@oh-my-pi/pi-wire": "16.2.4",
+		"@oh-my-pi/snapcompact": "16.2.4",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/autolearn/controller.ts

@@ -2,9 +2,9 @@
  * Auto-learn session controller (experimental).
  *
  * Subscribes to the session event stream and, after a substantive turn,
- * nudges the agent to capture reusable lessons. Default posture is passive
- * (a hidden reminder rides the next real turn); with `autolearn.autoContinue`
- * it auto-runs exactly one synthetic capture turn at stop.
+ * optionally auto-runs a synthetic capture turn. Passive mode is intentionally
+ * prompt-cache neutral: the standing system guidance remains available, but no
+ * hidden mid-session reminder is inserted into the conversation.
  *
  * Installed once per top-level session (taskDepth 0). The subscription lives
  * for the session's lifetime — `newSession` resets the session in place
@@ -14,11 +14,9 @@ import { logger } from "@oh-my-pi/pi-utils";
 import type { Settings } from "../config/settings";
 import autolearnGuidance from "../prompts/system/autolearn-guidance.md" with { type: "text" };
 import autolearnGuidanceLearn from "../prompts/system/autolearn-guidance-learn.md" with { type: "text" };
-import autolearnNudge from "../prompts/system/autolearn-nudge.md" with { type: "text" };
 import autolearnNudgeAutoContinue from "../prompts/system/autolearn-nudge-autocontinue.md" with { type: "text" };
 import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
 
-const AUTOLEARN_NUDGE_PASSIVE = autolearnNudge.trim();
 const AUTOLEARN_NUDGE_AUTOCONTINUE = autolearnNudgeAutoContinue.trim();
 const DEFAULT_MIN_TOOL_CALLS = 5;
 
@@ -110,28 +108,21 @@ export class AutoLearnController {
 		// auto-continue would compete with it.
 		if (startedInGoalMode || this.#session.getGoalModeState()?.enabled) return;
 
-		// Auto-run a capture turn only when explicitly enabled; otherwise the
-		// hidden reminder rides the next real turn passively.
-		//
-		// The two paths get DIFFERENT nudge text:
-		// - Auto-continue spawns a synthetic turn with the nudge as its only
-		//   user-role payload, so the prompt must be terminal — it tells the
-		//   agent to capture and STOP, and must not be read as the user's
-		//   reply to any pending question. Without that contract, the agent
-		//   conflates the synthetic prompt with user approval and resumes
-		//   prior work (e.g. commits/pushes an unanswered "want me to push?"
-		//   question — #3504).
-		// - Passive mode appends the nudge to the user's real next message,
-		//   so the agent must answer the user normally and treat the capture
-		//   as additive — not as the whole turn's job.
+		// Auto-run a capture turn only when explicitly enabled. Passive mode used to
+		// queue a hidden custom message for the next real turn, but that mutates the
+		// persisted conversation prefix after providers have cached it. The standing
+		// auto-learn system guidance is stable; keep passive mode to that guidance
+		// so Anthropic prompt-cache prefixes survive long sessions.
 		const autoContinue = this.#settings.get("autolearn.autoContinue") === true;
-		const content = autoContinue ? AUTOLEARN_NUDGE_AUTOCONTINUE : AUTOLEARN_NUDGE_PASSIVE;
+		if (!autoContinue) return;
+
+		const content = AUTOLEARN_NUDGE_AUTOCONTINUE;
 		// Arm suppression synchronously: the synthetic capture turn's agent_end
 		// fires inside sendCustomMessage (before it resolves), so the flag must be
 		// set before then. Disarm when no turn actually started — a deferred/queued
 		// dispatch or a failed send produces no agent_end, and a latched flag would
 		// otherwise swallow the next real stop.
-		if (autoContinue) this.#suppressNext = true;
+		this.#suppressNext = true;
 
 		this.#session
 			.sendCustomMessage(
@@ -141,7 +132,7 @@ export class AutoLearnController {
 					display: false,
 					attribution: "user",
 				},
-				{ deliverAs: "nextTurn", triggerTurn: autoContinue },
+				{ deliverAs: "nextTurn", triggerTurn: true },
 			)
 			.then(started => {
 				if (!started) this.#suppressNext = false;

package/src/cli/update-cli.ts

@@ -272,6 +272,252 @@ function compareVersions(a: string, b: string): number {
 	return 0;
 }
 
+interface BunInstallCachePruneResult {
+	scannedPackages: number;
+	removedEntries: number;
+}
+
+interface BunCachePackageGroup {
+	actualDirs: Map<string, string[]>;
+	markerDir?: string;
+	markerEntries: Map<string, string[]>;
+}
+
+function stripBunCacheVersionSuffix(name: string): string {
+	const metadataIndex = name.indexOf("@@");
+	return metadataIndex === -1 ? name : name.slice(0, metadataIndex);
+}
+
+function compareSemverIdentifier(a: string, b: string): number {
+	const aNumber = /^\d+$/.test(a);
+	const bNumber = /^\d+$/.test(b);
+	if (aNumber && bNumber) return Number(a) - Number(b);
+	if (aNumber) return -1;
+	if (bNumber) return 1;
+	return a.localeCompare(b);
+}
+
+function compareSemverLikeVersions(a: string, b: string): number {
+	const [aCoreWithPrerelease] = a.split("+", 1);
+	const [bCoreWithPrerelease] = b.split("+", 1);
+	const [aCore, aPrerelease] = aCoreWithPrerelease.split("-", 2);
+	const [bCore, bPrerelease] = bCoreWithPrerelease.split("-", 2);
+	const aParts = aCore.split(".");
+	const bParts = bCore.split(".");
+	for (let i = 0; i < Math.max(aParts.length, bParts.length); i++) {
+		const diff = Number(aParts[i] ?? 0) - Number(bParts[i] ?? 0);
+		if (diff !== 0 && Number.isFinite(diff)) return diff;
+	}
+	if (!aPrerelease && !bPrerelease) return 0;
+	if (!aPrerelease) return 1;
+	if (!bPrerelease) return -1;
+	const aPrereleaseParts = aPrerelease.split(".");
+	const bPrereleaseParts = bPrerelease.split(".");
+	for (let i = 0; i < Math.max(aPrereleaseParts.length, bPrereleaseParts.length); i++) {
+		const aPart = aPrereleaseParts[i];
+		const bPart = bPrereleaseParts[i];
+		if (aPart === undefined) return -1;
+		if (bPart === undefined) return 1;
+		const diff = compareSemverIdentifier(aPart, bPart);
+		if (diff !== 0) return diff;
+	}
+	return 0;
+}
+
+async function readdirIfExists(dir: string): Promise<fs.Dirent[]> {
+	try {
+		return await fs.promises.readdir(dir, { withFileTypes: true });
+	} catch (err) {
+		if (isEnoent(err)) return [];
+		throw err;
+	}
+}
+
+function getBunCacheGroup(groups: Map<string, BunCachePackageGroup>, packageName: string): BunCachePackageGroup {
+	let group = groups.get(packageName);
+	if (!group) {
+		group = { actualDirs: new Map(), markerEntries: new Map() };
+		groups.set(packageName, group);
+	}
+	return group;
+}
+
+function addVersionPath(entries: Map<string, string[]>, version: string, entryPath: string): void {
+	const paths = entries.get(version);
+	if (paths) {
+		paths.push(entryPath);
+		return;
+	}
+	entries.set(version, [entryPath]);
+}
+
+async function addBunCacheActualDir(
+	groups: Map<string, BunCachePackageGroup>,
+	dirPath: string,
+	packageNames: Set<string> | undefined,
+): Promise<void> {
+	try {
+		const manifest = (await Bun.file(path.join(dirPath, "package.json")).json()) as Partial<
+			Record<"name" | "version", unknown>
+		>;
+		if (typeof manifest.name !== "string" || typeof manifest.version !== "string") return;
+		if (packageNames && !packageNames.has(manifest.name)) return;
+		const group = getBunCacheGroup(groups, manifest.name);
+		addVersionPath(group.actualDirs, manifest.version, dirPath);
+	} catch (err) {
+		if (isEnoent(err)) return;
+		throw err;
+	}
+}
+
+async function addBunCacheMarkerDir(
+	groups: Map<string, BunCachePackageGroup>,
+	packageName: string,
+	markerDir: string,
+	packageNames: Set<string> | undefined,
+): Promise<void> {
+	if (packageNames && !packageNames.has(packageName)) return;
+	const markerEntries = await readdirIfExists(markerDir);
+	const group = getBunCacheGroup(groups, packageName);
+	group.markerDir = markerDir;
+	for (const entry of markerEntries) {
+		const cacheVersion = stripBunCacheVersionSuffix(entry.name);
+		addVersionPath(group.markerEntries, cacheVersion, path.join(markerDir, entry.name));
+	}
+}
+
+async function collectBunCacheGroups(
+	cacheDir: string,
+	packageNames: Set<string> | undefined,
+): Promise<Map<string, BunCachePackageGroup>> {
+	const groups = new Map<string, BunCachePackageGroup>();
+	for (const entry of await readdirIfExists(cacheDir)) {
+		if (!entry.isDirectory()) continue;
+		const entryPath = path.join(cacheDir, entry.name);
+		if (entry.name.startsWith("@")) {
+			for (const scopedEntry of await readdirIfExists(entryPath)) {
+				if (!scopedEntry.isDirectory()) continue;
+				const scopedEntryPath = path.join(entryPath, scopedEntry.name);
+				const versionSeparator = scopedEntry.name.lastIndexOf("@");
+				if (versionSeparator === -1) {
+					await addBunCacheMarkerDir(groups, `${entry.name}/${scopedEntry.name}`, scopedEntryPath, packageNames);
+				} else {
+					await addBunCacheActualDir(groups, scopedEntryPath, packageNames);
+				}
+			}
+			continue;
+		}
+		const versionSeparator = entry.name.lastIndexOf("@");
+		if (versionSeparator === -1) {
+			await addBunCacheMarkerDir(groups, entry.name, entryPath, packageNames);
+		} else {
+			await addBunCacheActualDir(groups, entryPath, packageNames);
+		}
+	}
+	return groups;
+}
+
+async function removeCacheEntries(paths: string[]): Promise<number> {
+	for (const entryPath of paths) {
+		await fs.promises.rm(entryPath, { recursive: true, force: true });
+	}
+	return paths.length;
+}
+
+/**
+ * Prune Bun's package cache so each package keeps only its newest cached version.
+ *
+ * Bun stores package cache entries as both a package marker directory
+ * (`react/19.2.6@@@1`) and a materialized package directory
+ * (`react@19.2.6@@@1`). Global `omp` updates can leave one full copy per
+ * release. The marker and materialized entries are removed together so the
+ * cache stays internally consistent.
+ */
+export async function pruneBunInstallCache(
+	cacheDir: string,
+	packageNames?: Set<string>,
+): Promise<BunInstallCachePruneResult> {
+	const groups = await collectBunCacheGroups(cacheDir, packageNames);
+	let scannedPackages = 0;
+	let removedEntries = 0;
+	for (const group of groups.values()) {
+		if (group.actualDirs.size === 0) continue;
+		scannedPackages++;
+		let latestVersion: string | undefined;
+		for (const version of group.actualDirs.keys()) {
+			if (!latestVersion || compareSemverLikeVersions(version, latestVersion) > 0) latestVersion = version;
+		}
+		if (!latestVersion) continue;
+		for (const [version, paths] of group.actualDirs) {
+			if (version !== latestVersion) removedEntries += await removeCacheEntries(paths);
+		}
+		for (const [version, paths] of group.markerEntries) {
+			if (version !== latestVersion) removedEntries += await removeCacheEntries(paths);
+		}
+	}
+	return { scannedPackages, removedEntries };
+}
+
+async function resolveBunInstallCacheDir(): Promise<string | undefined> {
+	try {
+		const result = await $`bun pm cache`.quiet().nothrow();
+		if (result.exitCode !== 0) return undefined;
+		const output = result.text().trim();
+		return output.length > 0 ? output : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export function resolveBunGlobalNodeModulesDirFromLocations(
+	globalBinDir: string | undefined,
+	cacheDir: string | undefined,
+): string | undefined {
+	if (globalBinDir && globalBinDir.length > 0) {
+		return path.join(path.dirname(globalBinDir), "install", "global", "node_modules");
+	}
+	if (cacheDir && cacheDir.length > 0) {
+		return path.join(path.dirname(cacheDir), "global", "node_modules");
+	}
+	return undefined;
+}
+
+async function resolveBunGlobalNodeModulesDir(cacheDir: string): Promise<string | undefined> {
+	try {
+		const result = await $`bun pm bin -g`.quiet().nothrow();
+		const globalBinDir = result.exitCode === 0 ? result.text().trim() : undefined;
+		return resolveBunGlobalNodeModulesDirFromLocations(globalBinDir, cacheDir);
+	} catch {
+		return resolveBunGlobalNodeModulesDirFromLocations(undefined, cacheDir);
+	}
+}
+
+async function collectInstalledPackageNames(nodeModulesDir: string): Promise<Set<string>> {
+	const packageNames = new Set<string>();
+	for (const entry of await readdirIfExists(nodeModulesDir)) {
+		if (!entry.isDirectory() || entry.name === ".bin") continue;
+		if (entry.name.startsWith("@")) {
+			for (const scopedEntry of await readdirIfExists(path.join(nodeModulesDir, entry.name))) {
+				if (scopedEntry.isDirectory()) packageNames.add(`${entry.name}/${scopedEntry.name}`);
+			}
+			continue;
+		}
+		packageNames.add(entry.name);
+	}
+	return packageNames;
+}
+
+async function pruneBunCacheAfterGlobalInstall(): Promise<BunInstallCachePruneResult | undefined> {
+	const cacheDir = await resolveBunInstallCacheDir();
+	if (!cacheDir) return undefined;
+	const globalNodeModulesDir = await resolveBunGlobalNodeModulesDir(cacheDir);
+	const packageNames = globalNodeModulesDir
+		? await collectInstalledPackageNames(globalNodeModulesDir)
+		: new Set<string>();
+	if (packageNames.size === 0 && !path.basename(cacheDir).toLowerCase().includes("omp")) return undefined;
+	return await pruneBunInstallCache(cacheDir, packageNames.size === 0 ? undefined : packageNames);
+}
+
 /**
  * Get the appropriate binary name for this platform.
  */
@@ -524,6 +770,14 @@ async function updateViaBun(expectedVersion: string): Promise<void> {
 	}
 
 	await printVerification(expectedVersion);
+	try {
+		const pruneResult = await pruneBunCacheAfterGlobalInstall();
+		if (pruneResult && pruneResult.removedEntries > 0) {
+			console.log(chalk.dim(`Pruned ${pruneResult.removedEntries} stale Bun cache entries`));
+		}
+	} catch (err) {
+		console.log(chalk.yellow(`Warning: could not prune stale Bun cache entries: ${err}`));
+	}
 }
 
 async function updateViaHomebrew(expectedVersion: string, force: boolean): Promise<void> {

package/src/collab/host.ts

@@ -37,6 +37,7 @@ import {
 	parseCollabLink,
 } from "./protocol";
 import { CollabSocket } from "./relay-client";
+import { shrinkForReplication } from "./replication-shrink";
 
 /** Events that change the footer state guests render. */
 const STATE_TRIGGER_EVENTS: Record<string, true> = {
@@ -212,7 +213,7 @@ export class CollabHost {
 		}
 
 		this.#unsubscribe = this.#ctx.session.subscribe(event => {
-			if (isWireAgentEvent(event)) this.#broadcast({ t: "event", event });
+			if (isWireAgentEvent(event)) this.#broadcast({ t: "event", event: shrinkForReplication(event) });
 			this.#onEventForState(event);
 		});
 		const bus = this.#ctx.eventBus;
@@ -223,7 +224,7 @@ export class CollabHost {
 		}
 		this.#registryUnsubscribe = AgentRegistry.global().onChange(() => this.#scheduleAgentsBroadcast());
 		this.#ctx.sessionManager.onEntryAppended = entry => {
-			if (isWireSessionEntry(entry)) this.#broadcast({ t: "entry", entry });
+			if (isWireSessionEntry(entry)) this.#broadcast({ t: "entry", entry: shrinkForReplication(entry) });
 			// Model/thinking/title changes land as entries while idle; refresh
 			// guest state promptly (debounce + JSON diff dedupe).
 			this.#scheduleStateBroadcast();
@@ -358,10 +359,13 @@ export class CollabHost {
 
 	/**
 	 * Slice {@link entries} into byte-bounded `snapshot-chunk` frames targeted
-	 * at {@link fromPeer}. Every batch carries at least one entry (a single
-	 * oversize entry ships alone), and the last batch is tagged `final: true`
-	 * so the guest can finalize the replica. An empty snapshot still emits one
-	 * `final` chunk so the guest never blocks on a missing terminator.
+	 * at {@link fromPeer}. Each entry is first run through
+	 * {@link shrinkForReplication} so a single oversized tool-result entry
+	 * cannot ship as an oversized chunk that trips the relay's per-frame
+	 * `maxPayloadLength` (issue #3739). Every batch carries at least one
+	 * entry, and the last batch is tagged `final: true` so the guest can
+	 * finalize the replica. An empty snapshot still emits one `final` chunk
+	 * so the guest never blocks on a missing terminator.
 	 */
 	#sendSnapshotChunks(entries: (StoredSessionEntry & WireSessionEntry)[], fromPeer: number): void {
 		const socket = this.#socket;
@@ -377,9 +381,10 @@ export class CollabHost {
 			while (i < entries.length) {
 				const entry = entries[i];
 				if (!entry) break;
-				const entryBytes = JSON.stringify(entry).length;
+				const shrunk = shrinkForReplication(entry);
+				const entryBytes = JSON.stringify(shrunk).length;
 				if (batch.length > 0 && batchBytes + entryBytes > SNAPSHOT_CHUNK_BYTES) break;
-				batch.push(entry);
+				batch.push(shrunk);
 				batchBytes += entryBytes;
 				i++;
 			}