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

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/cli/worktree-cli.ts

@@ -7,9 +7,9 @@
  *     containing a `.git` *file* that points back at
  *     `<parent-repo>/.git/worktrees/<name>/`.
  *   - **Task-isolation dirs** (`task/worktree.ts`): a wrapper dir with a
- *     `merged` subdir mounted/cloned by `natives.isoStart`. These are ephemeral
- *     — `ensureIsolation` always `rm -rf`s the base before re-creating it, so
- *     any leftover on disk is a leak from a crashed run.
+ *     compact `m` subdir mounted/cloned by `natives.isoStart`. Legacy `merged`
+ *     subdirs are still recognized. These are ephemeral; `ensureIsolation`
+ *     removes the base before re-creating it, so leftovers are crashed runs.
  *
  * Legacy entries from before the encoding change keep working because git still
  * tracks them by branch name. This command exists to GC them on demand.
@@ -22,6 +22,8 @@ import * as git from "../utils/git";
 
 type WorktreeKind = "pr-checkout" | "task-isolation" | "empty" | "stray";
 
+const TASK_ISOLATION_MOUNT_DIRS = ["m", "merged"] as const;
+
 export interface WorktreeEntry {
 	/** Absolute path to the worktree dir (or stray container) under `~/.omp/wt/`. */
 	path: string;
@@ -209,8 +211,9 @@ async function classifyDir(dir: string): Promise<WorktreeEntry | null> {
 	if (gitStat?.isFile()) {
 		return classifyPrCheckout(dir, gitEntry);
 	}
-	const mergedStat = await fs.stat(path.join(dir, "merged")).catch(() => null);
-	if (mergedStat?.isDirectory()) {
+	for (const mountDir of TASK_ISOLATION_MOUNT_DIRS) {
+		const mountStat = await fs.stat(path.join(dir, mountDir)).catch(() => null);
+		if (!mountStat?.isDirectory()) continue;
 		return {
 			path: dir,
 			kind: "task-isolation",

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

package/src/collab/replication-shrink.ts

@@ -0,0 +1,111 @@
+/**
+ * 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 const MAX_REPLICATED_PAYLOAD_BYTES = 1 * 1024 * 1024;
+
+/**
+ * Progressive shrink passes. Each pass tightens both the per-string cap and
+ * the per-array head limit; the loop stops at the first pass whose output
+ * fits {@link MAX_REPLICATED_PAYLOAD_BYTES}. The schedule is concrete (not
+ * recomputed) so the failure modes the helper guards against are visible:
+ *
+ * - One giant string → the first pass already truncates it under 64 KB.
+ * - Array of many small blocks (e.g. a tool result with thousands of
+ *   `{type:"text", text:"..."}` content items) → later passes head-clip the
+ *   array to a small sample with a `[…N items elided]` summary element.
+ *
+ * The final pass clamps every string to 64 B and every array to one element,
+ * so even pathological mixes converge.
+ */
+interface ShrinkPass {
+	stringCap: number;
+	arrayLimit: number;
+}
+
+const SHRINK_PASSES: readonly ShrinkPass[] = [
+	{ stringCap: 64 * 1024, arrayLimit: 256 },
+	{ stringCap: 16 * 1024, arrayLimit: 128 },
+	{ stringCap: 4 * 1024, arrayLimit: 64 },
+	{ stringCap: 1 * 1024, arrayLimit: 32 },
+	{ stringCap: 256, arrayLimit: 16 },
+	{ stringCap: 256, arrayLimit: 4 },
+	{ stringCap: 64, arrayLimit: 1 },
+];
+
+const STRING_ELISION_RESERVE = 80;
+
+/**
+ * Recursively walk `value`, head-truncating any string longer than
+ * `stringCap` and head-clipping any array longer than `arrayLimit`. Returns
+ * a freshly built deep clone — every object/array is rebuilt so the
+ * recursive output can be safely serialized in isolation. Cheap to call on
+ * small values: short strings, numbers, and booleans pass through without
+ * allocation.
+ */
+function shrinkWalk(value: unknown, stringCap: number, arrayLimit: number): unknown {
+	if (typeof value === "string") {
+		if (value.length <= stringCap) return value;
+		const headLen = Math.max(0, stringCap - STRING_ELISION_RESERVE);
+		return `${value.slice(0, headLen)}\n…[${value.length - headLen} chars elided for collab session]`;
+	}
+	if (Array.isArray(value)) {
+		const keep = Math.min(value.length, arrayLimit);
+		const elided = value.length - keep;
+		const out: unknown[] = new Array(elided > 0 ? keep + 1 : keep);
+		for (let i = 0; i < keep; i++) out[i] = shrinkWalk(value[i], stringCap, arrayLimit);
+		if (elided > 0) out[keep] = `…[${elided} items elided for collab session]`;
+		return out;
+	}
+	if (value && typeof value === "object") {
+		const src = value as Record<string, unknown>;
+		const out: Record<string, unknown> = {};
+		for (const k in src) out[k] = shrinkWalk(src[k], stringCap, arrayLimit);
+		return out;
+	}
+	return value;
+}
+
+/**
+ * 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 function shrinkForReplication<T>(value: T): T {
+	if (JSON.stringify(value).length <= MAX_REPLICATED_PAYLOAD_BYTES) return value;
+	let shrunk: unknown = value;
+	for (const pass of SHRINK_PASSES) {
+		shrunk = shrinkWalk(value, pass.stringCap, pass.arrayLimit);
+		if (JSON.stringify(shrunk).length <= MAX_REPLICATED_PAYLOAD_BYTES) return shrunk as T;
+	}
+	return shrunk as T;
+}

package/src/config/model-discovery.ts

@@ -126,7 +126,8 @@ type LlamaCppDiscoveredServerMetadata = {
 
 type LlamaCppModelListEntry = {
 	id: string;
-	contextWindow?: number;
+	runtimeContextWindow?: number;
+	trainingContextWindow?: number;
 };
 
 function toPositiveNumberOrUndefined(value: unknown): number | undefined {
@@ -142,7 +143,21 @@ function toPositiveNumberOrUndefined(value: unknown): number | undefined {
 	return undefined;
 }
 
+function extractOllamaRuntimeContextWindow(payload: Record<string, unknown>): number | undefined {
+	const parameters = payload.parameters;
+	if (typeof parameters !== "string") {
+		return undefined;
+	}
+	const match = parameters.match(/(?:^|\n)\s*num_ctx\s+(\d+)\s*(?:$|\n)/m);
+	return match ? toPositiveNumberOrUndefined(match[1]) : undefined;
+}
+
 function extractOllamaContextWindow(payload: Record<string, unknown>): number | undefined {
+	const runtimeContextWindow = extractOllamaRuntimeContextWindow(payload);
+	if (runtimeContextWindow !== undefined) {
+		return runtimeContextWindow;
+	}
+
 	const modelInfo = payload.model_info;
 	if (isRecord(modelInfo)) {
 		for (const [key, value] of Object.entries(modelInfo)) {
@@ -155,12 +170,7 @@ function extractOllamaContextWindow(payload: Record<string, unknown>): number |
 		}
 	}
 
-	const parameters = payload.parameters;
-	if (typeof parameters !== "string") {
-		return undefined;
-	}
-	const match = parameters.match(/(?:^|\n)\s*num_ctx\s+(\d+)\s*(?:$|\n)/m);
-	return match ? toPositiveNumberOrUndefined(match[1]) : undefined;
+	return undefined;
 }
 
 function extractLlamaCppContextWindow(payload: Record<string, unknown>): number | undefined {
@@ -174,12 +184,17 @@ function extractLlamaCppContextWindow(payload: Record<string, unknown>): number
 	return toPositiveNumberOrUndefined(payload.n_ctx);
 }
 
-function extractLlamaCppModelContextWindow(item: Record<string, unknown>): number | undefined {
+function extractLlamaCppModelContextWindows(
+	item: Record<string, unknown>,
+): Pick<LlamaCppModelListEntry, "runtimeContextWindow" | "trainingContextWindow"> {
 	const meta = item.meta;
 	if (!isRecord(meta)) {
-		return undefined;
+		return {};
 	}
-	return toPositiveNumberOrUndefined(meta.n_ctx) ?? toPositiveNumberOrUndefined(meta.n_ctx_train);
+	return {
+		runtimeContextWindow: toPositiveNumberOrUndefined(meta.n_ctx),
+		trainingContextWindow: toPositiveNumberOrUndefined(meta.n_ctx_train),
+	};
 }
 
 function parseLlamaCppModelList(payload: unknown): LlamaCppModelListEntry[] {
@@ -190,7 +205,7 @@ function parseLlamaCppModelList(payload: unknown): LlamaCppModelListEntry[] {
 		if (!isRecord(item) || typeof item.id !== "string" || !item.id) {
 			return [];
 		}
-		return [{ id: item.id, contextWindow: extractLlamaCppModelContextWindow(item) }];
+		return [{ id: item.id, ...extractLlamaCppModelContextWindows(item) }];
 	});
 }
 
@@ -378,7 +393,11 @@ export async function discoverLlamaCppModels(
 	for (const item of models) {
 		const { id } = item;
 		if (!id) continue;
-		const contextWindow = item.contextWindow ?? serverMetadata?.contextWindow ?? DISCOVERY_DEFAULT_CONTEXT_WINDOW;
+		const contextWindow =
+			item.runtimeContextWindow ??
+			serverMetadata?.contextWindow ??
+			item.trainingContextWindow ??
+			DISCOVERY_DEFAULT_CONTEXT_WINDOW;
 		discovered.push(
 			buildModel({
 				id,
@@ -420,7 +439,8 @@ export async function discoverLlamaCppModelContextWindow(
 			return undefined;
 		}
 		const entries = parseLlamaCppModelList(await response.json());
-		return entries.find(entry => entry.id === model.id)?.contextWindow;
+		const entry = entries.find(entry => entry.id === model.id);
+		return entry?.runtimeContextWindow ?? entry?.trainingContextWindow;
 	};
 	try {
 		const apiKey = await ctx.getBearerApiKeyResolver(model.provider);

package/src/config/provider-globals.ts

@@ -0,0 +1,25 @@
+import * as imageGen from "../tools/image-gen";
+import * as webSearch from "../web/search";
+
+interface ProviderGlobalSettings {
+	get(path: "providers.webSearchExclude"): unknown;
+	get(path: "providers.webSearch"): unknown;
+	get(path: "providers.image"): unknown;
+}
+
+export function applyProviderGlobalsFromSettings(settings: ProviderGlobalSettings): void {
+	const excludedWebSearchProviders = settings.get("providers.webSearchExclude");
+	if (Array.isArray(excludedWebSearchProviders)) {
+		webSearch.setExcludedSearchProviders(excludedWebSearchProviders.filter(webSearch.isSearchProviderId));
+	}
+
+	const webSearchProvider = settings.get("providers.webSearch");
+	if (typeof webSearchProvider === "string" && webSearch.isSearchProviderPreference(webSearchProvider)) {
+		webSearch.setPreferredSearchProvider(webSearchProvider);
+	}
+
+	const imageProvider = settings.get("providers.image");
+	if (imageGen.isImageProviderPreference(imageProvider)) {
+		imageGen.setPreferredImageProvider(imageProvider);
+	}
+}

package/src/config/settings-schema.ts

@@ -317,8 +317,11 @@ export const DEFAULT_BASH_INTERCEPTOR_RULES: BashInterceptorRule[] = [
 		// `>` must sit outside quoted regions (so `echo "a -> b"` passes) and be
 		// followed by a plausible filename — including `$VAR` targets; `>|`
 		// (clobber) counts as a redirect; `>&2`/`2>&1` style fd duplication is
-		// not matched.
-		pattern: "^\\s*(echo|printf|cat\\s*<<)\\s+(?:[^\"'>]|\"[^\"]*\"|'[^']*')*(?<!\\|)>{1,2}\\|?\\s*[$\\w./~\"'-]",
+		// not matched. Allowed device sinks are consumed while looking for later
+		// real file redirects because the write tool cannot replace shell
+		// output/discard targets.
+		pattern:
+			"^\\s*(echo|printf|cat\\s*<<)\\s+(?:(?:[^\"'>]|\"[^\"]*\"|'[^']*')|(?<!\\|)>{1,2}\\|?\\s*(?:\"/dev/(?:null|tty|stdout|stderr)\"|'/dev/(?:null|tty|stdout|stderr)'|/dev/(?:null|tty|stdout|stderr))(?:[\\s;&|]|$))*(?<!\\|)>{1,2}\\|?\\s*(?!(?:\"/dev/(?:null|tty|stdout|stderr)\"|'/dev/(?:null|tty|stdout|stderr)'|/dev/(?:null|tty|stdout|stderr))(?:[\\s;&|]|$))[$\\w./~\"'-]",
 		tool: "write",
 		message: "Use the `write` tool instead of echo/cat redirection. It handles encoding and provides confirmation.",
 	},

package/src/eval/__tests__/julia-prelude.test.ts

@@ -9,7 +9,7 @@ const OWNER_ID = "julia-prelude-tests";
 describe.skipIf(!HAS_JULIA)("eval Julia prelude helpers", () => {
 	afterEach(async () => {
 		await disposeJuliaKernelSessionsByOwner(OWNER_ID);
-	});
+	}, 30_000);
 
 	it("supports output ranges, JSON queries, metadata, and ANSI stripping", async () => {
 		using tempDir = TempDir.createSync("@omp-eval-julia-output-");
@@ -44,7 +44,7 @@ nothing
 		expect(result.output).toContain("STRIPPED=red");
 		expect(result.output).toContain("META=alpha:true");
 		expect(result.output).toContain("MULTI=2:alpha:json");
-	}, 30_000);
+	}, 60_000);
 
 	it("surfaces the exception type and message in the error output, not just stack frames", async () => {
 		using tempDir = TempDir.createSync("@omp-eval-julia-error-");