@gajae-code/coding-agent 0.5.2 → 0.5.3

package/src/session/blob-store.ts

@@ -167,19 +167,49 @@ export class EphemeralBlobStore extends BlobStore {
 }
 
 export class MemoryBlobStore extends BlobStore {
+	/**
+	 * Generous byte/count LRU bound (F8). Content-addressed resident blobs are fail-closed
+	 * on miss (callers raise/handle {@link ResidentBlobMissingError}), so evicting the
+	 * least-recently-used entry on an extremely large session is preferable to unbounded
+	 * RAM growth. The caps sit well above normal usage and only trip on pathological sizes.
+	 */
+	static readonly #MAX_BYTES = 64 * 1024 * 1024;
+	static readonly #MAX_COUNT = 4096;
+
 	#blobs = new Map<string, Buffer>();
+	#bytes = 0;
 
 	constructor() {
 		super(":memory:");
 	}
 
+	#store(hash: string, data: Buffer): void {
+		const existing = this.#blobs.get(hash);
+		if (existing) {
+			this.#blobs.delete(hash);
+			this.#bytes -= existing.byteLength;
+		}
+		this.#blobs.set(hash, data);
+		this.#bytes += data.byteLength;
+		while (
+			(this.#bytes > MemoryBlobStore.#MAX_BYTES || this.#blobs.size > MemoryBlobStore.#MAX_COUNT) &&
+			this.#blobs.size > 1
+		) {
+			const oldest = this.#blobs.keys().next().value;
+			if (oldest === undefined) break;
+			const evicted = this.#blobs.get(oldest);
+			this.#blobs.delete(oldest);
+			if (evicted) this.#bytes -= evicted.byteLength;
+		}
+	}
+
 	async put(data: Buffer): Promise<BlobPutResult> {
 		return this.putSync(data);
 	}
 
 	putSync(data: Buffer): BlobPutResult {
 		const hash = new Bun.SHA256().update(data).digest("hex");
-		this.#blobs.set(hash, Buffer.from(data));
+		this.#store(hash, Buffer.from(data));
 		return {
 			hash,
 			path: `memory:${hash}`,
@@ -195,7 +225,11 @@ export class MemoryBlobStore extends BlobStore {
 
 	getSync(hash: string): Buffer | null {
 		const data = this.#blobs.get(hash);
-		return data ? Buffer.from(data) : null;
+		if (!data) return null;
+		// Refresh LRU recency on hit so hot blobs survive eviction.
+		this.#blobs.delete(hash);
+		this.#blobs.set(hash, data);
+		return Buffer.from(data);
 	}
 
 	async has(hash: string): Promise<boolean> {

package/src/session/session-manager.ts

@@ -889,8 +889,27 @@ async function resolvePersistedBlobRefs(value: unknown, blobStore: BlobStore, ke
 	);
 }
 
+/**
+ * Run async tasks with bounded concurrency so an image-heavy resume never materializes
+ * every blob's base64 simultaneously (F8: avoids the transient OOM spike of an unbounded
+ * Promise.all over all historical images).
+ */
+const BLOB_RESOLVE_CONCURRENCY = 8;
+async function runWithConcurrency(tasks: Array<() => Promise<void>>, limit: number): Promise<void> {
+	let next = 0;
+	const worker = async (): Promise<void> => {
+		while (next < tasks.length) {
+			const index = next;
+			next += 1;
+			await tasks[index]!();
+		}
+	};
+	const workerCount = Math.max(1, Math.min(limit, tasks.length));
+	await Promise.all(Array.from({ length: workerCount }, () => worker()));
+}
+
 async function resolveBlobRefsInEntries(entries: FileEntry[], blobStore: BlobStore): Promise<void> {
-	const promises: Promise<void>[] = [];
+	const tasks: Array<() => Promise<void>> = [];
 
 	for (const entry of entries) {
 		if (entry.type === "session") continue;
@@ -902,22 +921,19 @@ async function resolveBlobRefsInEntries(entries: FileEntry[], blobStore: BlobSto
 			contentArray = entry.content;
 		}
 
-		if (contentArray) {
-			for (const block of contentArray) {
-				if (isImageBlock(block) && isBlobRef(block.data)) {
-					promises.push(
-						resolveImageData(blobStore, block.data).then(resolved => {
-							block.data = resolved;
-						}),
-					);
+		tasks.push(async () => {
+			if (contentArray) {
+				for (const block of contentArray) {
+					if (isImageBlock(block) && isBlobRef(block.data)) {
+						block.data = await resolveImageData(blobStore, block.data);
+					}
 				}
 			}
-		}
-
-		promises.push(resolvePersistedBlobRefs(entry, blobStore));
+			await resolvePersistedBlobRefs(entry, blobStore);
+		});
 	}
 
-	await Promise.all(promises);
+	await runWithConcurrency(tasks, BLOB_RESOLVE_CONCURRENCY);
 }
 
 /**

package/src/session/streaming-output.ts

@@ -15,6 +15,7 @@ function sanitizeOutputChunk(rawChunk: string): string {
 export const DEFAULT_MAX_LINES = 3000;
 export const DEFAULT_MAX_BYTES = 50 * 1024; // 50KB
 export const DEFAULT_MAX_COLUMN = 1024; // Max chars per grep match line
+export const DEFAULT_ARTIFACT_MAX_BYTES = 10 * 1024 * 1024; // 10MB
 
 const NL = "\n";
 
@@ -41,6 +42,8 @@ export interface OutputSummary {
 	columnTruncatedLines?: number;
 	/** Artifact ID for internal URL access (artifact://<id>) when truncated */
 	artifactId?: string;
+	/** Bytes omitted from artifact storage after the artifact hard cap was reached. */
+	artifactTruncatedBytes?: number;
 }
 
 export interface OutputSinkOptions {
@@ -61,6 +64,8 @@ export interface OutputSinkOptions {
 	 * writes still respect the budget. Default 0 = no per-line cap.
 	 */
 	maxColumns?: number;
+	/** Hard cap for artifact writes/pending replay. Default DEFAULT_ARTIFACT_MAX_BYTES. */
+	artifactMaxBytes?: number;
 	onChunk?: (chunk: string) => void;
 	/** Minimum ms between onChunk calls. 0 = every chunk (default). */
 	chunkThrottleMs?: number;
@@ -668,6 +673,9 @@ export class OutputSink {
 	#sawData = false;
 	#truncated = false;
 	#lastChunkTime = 0;
+	#artifactBytes = 0;
+	#artifactTruncatedBytes = 0;
+	#artifactTruncationNoticeWritten = false;
 
 	// Per-line column cap streaming state (persists across `push` calls so a
 	// long line split across chunks still trips the same trigger).
@@ -697,6 +705,7 @@ export class OutputSink {
 	readonly #onRawChunk?: (chunk: string) => void;
 	readonly #chunkThrottleMs: number;
 	readonly #maxColumns: number;
+	readonly #artifactMaxBytes: number;
 
 	constructor(options?: OutputSinkOptions) {
 		const {
@@ -708,6 +717,7 @@ export class OutputSink {
 			onChunk,
 			chunkThrottleMs = 0,
 			onRawChunk,
+			artifactMaxBytes = DEFAULT_ARTIFACT_MAX_BYTES,
 		} = options ?? {};
 		this.#artifactPath = artifactPath;
 		this.#artifactId = artifactId;
@@ -717,6 +727,7 @@ export class OutputSink {
 		this.#onChunk = onChunk;
 		this.#onRawChunk = onRawChunk;
 		this.#chunkThrottleMs = chunkThrottleMs;
+		this.#artifactMaxBytes = Math.max(0, artifactMaxBytes);
 	}
 
 	#headText(): string {
@@ -907,6 +918,40 @@ export class OutputSink {
 		}
 	}
 
+	#artifactTruncationNotice(droppedBytes: number): string {
+		return `\n[artifact truncated after ${this.#artifactBytes} bytes; omitted at least ${droppedBytes} bytes]\n`;
+	}
+
+	#capArtifactChunk(chunk: string, bytes: number): { chunk: string; bytes: number } | null {
+		if (bytes === 0) return null;
+		if (this.#artifactMaxBytes <= 0 || this.#artifactBytes >= this.#artifactMaxBytes) {
+			this.#artifactTruncatedBytes += bytes;
+			return null;
+		}
+		const room = this.#artifactMaxBytes - this.#artifactBytes;
+		if (bytes <= room) {
+			return { chunk, bytes };
+		}
+		const kept = truncateHeadBytes(chunk, room);
+		this.#artifactTruncatedBytes += bytes - kept.bytes;
+		return kept.bytes > 0 ? { chunk: kept.text, bytes: kept.bytes } : null;
+	}
+
+	#writeArtifactTruncationNotice(): void {
+		if (this.#artifactTruncatedBytes <= 0 || this.#artifactTruncationNoticeWritten) return;
+		const notice = this.#artifactTruncationNotice(this.#artifactTruncatedBytes);
+		try {
+			if (this.#fileReady && this.#file) {
+				this.#file.sink.write(notice);
+			} else {
+				this.#queuePendingFileWrite(notice, Buffer.byteLength(notice, "utf-8"));
+			}
+			this.#artifactTruncationNoticeWritten = true;
+		} catch {
+			/* ignore */
+		}
+	}
+
 	#queuePendingFileWrite(chunk: string, bytes = Buffer.byteLength(chunk, "utf-8")): void {
 		if (!this.#pendingFileWrites) this.#pendingFileWrites = [chunk];
 		else this.#pendingFileWrites.push(chunk);
@@ -915,14 +960,17 @@ export class OutputSink {
 	}
 
 	#enqueueFileWrite(chunk: string, bytes: number): void {
+		const capped = this.#capArtifactChunk(chunk, bytes);
+		if (!capped) return;
+		this.#artifactBytes += capped.bytes;
 		if (!this.#fileReady || !this.#file) {
-			this.#queuePendingFileWrite(chunk, bytes);
+			this.#queuePendingFileWrite(capped.chunk, capped.bytes);
 			if (this.#willOverflow(bytes) || this.#pendingFileWriteBytes > this.#spillThreshold) this.#createFileSink();
 			return;
 		}
 
 		try {
-			this.#file.sink.write(chunk);
+			this.#file.sink.write(capped.chunk);
 		} catch {
 			try {
 				void this.#file.sink.end();
@@ -931,7 +979,7 @@ export class OutputSink {
 			}
 			this.#file = undefined;
 			this.#fileReady = false;
-			this.#queuePendingFileWrite(chunk, bytes);
+			this.#queuePendingFileWrite(capped.chunk, capped.bytes);
 			this.#createFileSink();
 		}
 	}
@@ -1019,6 +1067,8 @@ export class OutputSink {
 		const totalLines = this.#sawData ? this.#totalLines + 1 : 0;
 
 		let artifactId: string | undefined;
+		if (this.#artifactTruncatedBytes > 0) this.#createFileSink();
+		this.#writeArtifactTruncationNotice();
 		if (this.#file) {
 			artifactId = this.#file.artifactId;
 			await this.#file.sink.end();
@@ -1095,6 +1145,7 @@ export class OutputSink {
 			elidedLines,
 			columnDroppedBytes: this.#columnDroppedBytes > 0 ? this.#columnDroppedBytes : undefined,
 			columnTruncatedLines: this.#columnTruncatedLines > 0 ? this.#columnTruncatedLines : undefined,
+			artifactTruncatedBytes: this.#artifactTruncatedBytes > 0 ? this.#artifactTruncatedBytes : undefined,
 			artifactId,
 		};
 	}

package/src/slash-commands/builtin-registry.ts

@@ -3,6 +3,7 @@ import * as path from "node:path";
 import type { ThinkingLevel } from "@gajae-code/agent-core";
 import { type Model, modelsAreEqual } from "@gajae-code/ai";
 import { getOAuthProviders } from "@gajae-code/ai/utils/oauth";
+import { Spacer, Text } from "@gajae-code/tui";
 import { setProjectDir } from "@gajae-code/utils";
 import { jobElapsedMs } from "../async";
 import {
@@ -13,6 +14,8 @@ import {
 import { extractExplicitThinkingSelector, formatModelSelectorValue, parseModelPattern } from "../config/model-resolver";
 import { clearPluginRootsAndCaches, resolveActiveProjectRegistryPath } from "../discovery/helpers.js";
 import { resolveMemoryBackend } from "../memory-backend";
+import { DynamicBorder } from "../modes/components/dynamic-border";
+import { theme } from "../modes/theme/theme";
 import type { InteractiveModeContext } from "../modes/types";
 import { formatModelOnboardingGuidance } from "../setup/model-onboarding-guidance";
 import {
@@ -23,6 +26,7 @@ import {
 } from "../setup/provider-onboarding";
 import { parseThinkingLevel } from "../thinking";
 import { buildContextReportText } from "./helpers/context-report";
+import { buildFastStatusReport } from "./helpers/fast-status-report";
 import { formatDuration } from "./helpers/format";
 import { commandConsumed, errorMessage, parseSlashCommand, usage } from "./helpers/parse";
 import { handleSshAcp } from "./helpers/ssh";
@@ -41,6 +45,14 @@ export type { BuiltinSlashCommand, SubcommandDef } from "./types";
 /** TUI-specific runtime accepted by `executeBuiltinSlashCommand`. */
 export type BuiltinSlashCommandRuntime = TuiSlashCommandRuntime;
 
+function fastStatusRoleTargets(): Array<{ id: GjcModelAssignmentTargetId; label: string; isSubagentRole: boolean }> {
+	return GJC_MODEL_ASSIGNMENT_TARGET_IDS.map(id => ({
+		id,
+		label: GJC_MODEL_ASSIGNMENT_TARGETS[id].tag ?? id.toUpperCase(),
+		isSubagentRole: GJC_MODEL_ASSIGNMENT_TARGETS[id].settingsPath === "task.agentModelOverrides",
+	}));
+}
+
 function parseProviderSetupSlashArgs(args: string): {
 	preset?: string;
 	compat?: string;
@@ -357,7 +369,13 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 				return commandConsumed();
 			}
 			if (arg === "status") {
-				await runtime.output(`Fast mode is ${runtime.session.isFastModeEnabled() ? "on" : "off"}.`);
+				await runtime.output(
+					buildFastStatusReport({
+						session: runtime.session,
+						roleTargets: fastStatusRoleTargets(),
+						iconFast: theme.icon.fast,
+					}),
+				);
 				return commandConsumed();
 			}
 			return usage("Usage: /fast [on|off|status]", runtime);
@@ -386,8 +404,17 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 				return;
 			}
 			if (arg === "status") {
-				const enabled = runtime.ctx.session.isFastModeEnabled();
-				runtime.ctx.showStatus(`Fast mode is ${enabled ? "on" : "off"}.`);
+				const report = buildFastStatusReport({
+					session: runtime.ctx.session,
+					roleTargets: fastStatusRoleTargets(),
+					iconFast: theme.icon.fast,
+					formatInactive: text => theme.fg("dim", text),
+				});
+				runtime.ctx.chatContainer.addChild(new Spacer(1));
+				runtime.ctx.chatContainer.addChild(new DynamicBorder());
+				runtime.ctx.chatContainer.addChild(new Text(report, 1, 0));
+				runtime.ctx.chatContainer.addChild(new DynamicBorder());
+				runtime.ctx.ui.requestRender();
 				runtime.ctx.editor.setText("");
 				return;
 			}

package/src/slash-commands/helpers/fast-status-report.ts

@@ -0,0 +1,111 @@
+import type { Model } from "@gajae-code/ai";
+
+/**
+ * A single line in the `/fast status` report: a labelled model and whether fast
+ * mode is effective for it. The `fast` flag is resolved by the caller
+ * (`buildFastStatusReport`) so each row can use the correct service tier — the
+ * main session tier for the current model / `modelRoles` roles, or the subagent
+ * tier (`task.serviceTier`) for `task.agentModelOverrides` roles.
+ */
+export interface FastStatusRow {
+	/** Display label, e.g. "현재 모델", "DEFAULT", "EXECUTOR". */
+	label: string;
+	/** Resolved model for this row, if any. */
+	model?: Model;
+	/** Whether fast mode is effective for this row's model. */
+	fast: boolean;
+}
+
+export interface FormatFastStatusReportArgs {
+	rows: FastStatusRow[];
+	/** The active theme's fast icon token (`theme.icon.fast`). */
+	iconFast: string;
+	/** Optional decorator for inactive ("off") text, e.g. theme dim in the TUI. */
+	formatInactive?: (text: string) => string;
+}
+
+/** Title line of the `/fast status` report. */
+export const FAST_STATUS_TITLE = "Fast 모드 상태";
+
+/** The inactive marker shown for rows where fast mode does not apply. */
+export const FAST_STATUS_OFF = "off";
+
+/**
+ * Format a multiline `/fast status` report. Pure and shared by the CLI
+ * (`handle`) and TUI (`handleTui`) command branches so the two never drift.
+ * Each row's fast/off state is decided by the caller (see
+ * {@link buildFastStatusReport}) so per-row service-tier differences are honored.
+ */
+export function formatFastStatusReport(args: FormatFastStatusReportArgs): string {
+	const { rows, iconFast } = args;
+	const formatInactive = args.formatInactive ?? ((text: string) => text);
+	const lines: string[] = [FAST_STATUS_TITLE];
+	for (const row of rows) {
+		if (!row.model) {
+			lines.push(`${row.label}: ${formatInactive(FAST_STATUS_OFF)}`);
+			continue;
+		}
+		const ref = `${row.model.provider}/${row.model.id}`;
+		lines.push(`${row.label}: ${ref} ${row.fast ? iconFast : formatInactive(FAST_STATUS_OFF)}`);
+	}
+	return lines.join("\n");
+}
+
+/** Minimal session surface needed to build the `/fast status` report. */
+export interface FastStatusSessionLike {
+	readonly model?: Model;
+	/** Fast predicate against the main session tier (current model + `modelRoles`). */
+	isFastForProvider(provider?: string): boolean;
+	/** Fast predicate against the effective subagent tier (`task.agentModelOverrides` roles). */
+	isFastForSubagentProvider(provider?: string): boolean;
+	resolveRoleModelWithThinking(role: string): { model?: Model };
+}
+
+/** A role to enumerate in the report, with the tier source its subagent runs under. */
+export interface FastStatusRoleTarget {
+	id: string;
+	label: string;
+	/**
+	 * True for `task.agentModelOverrides` roles (executor/architect/planner/critic)
+	 * that run under `task.serviceTier`; false for `modelRoles` roles (default)
+	 * that run under the main session tier.
+	 */
+	isSubagentRole: boolean;
+}
+
+export interface BuildFastStatusReportArgs {
+	session: FastStatusSessionLike;
+	/** Role targets to enumerate, in display order. */
+	roleTargets: ReadonlyArray<FastStatusRoleTarget>;
+	/** The active theme's fast icon token (`theme.icon.fast`). */
+	iconFast: string;
+	/** Optional decorator for inactive ("off") text, e.g. theme dim in the TUI. */
+	formatInactive?: (text: string) => string;
+}
+
+/**
+ * Build the `/fast status` report from a live session: the active/current model
+ * followed by each assigned role (subagent) model. Unassigned roles are skipped
+ * so the report mirrors the `/model` selector, which only badges assigned roles.
+ *
+ * Subagent roles (`task.agentModelOverrides`) are evaluated against the
+ * effective subagent tier (`task.serviceTier`), while the current model and
+ * `modelRoles` roles use the main session tier — matching where each model
+ * actually runs.
+ */
+export function buildFastStatusReport(args: BuildFastStatusReportArgs): string {
+	const { session, roleTargets, iconFast, formatInactive } = args;
+	const rows: FastStatusRow[] = [
+		{ label: "현재 모델", model: session.model, fast: session.isFastForProvider(session.model?.provider) },
+	];
+	for (const target of roleTargets) {
+		const resolved = session.resolveRoleModelWithThinking(target.id);
+		if (resolved.model) {
+			const fast = target.isSubagentRole
+				? session.isFastForSubagentProvider(resolved.model.provider)
+				: session.isFastForProvider(resolved.model.provider);
+			rows.push({ label: target.label, model: resolved.model, fast });
+		}
+	}
+	return formatFastStatusReport({ rows, iconFast, formatInactive });
+}

package/src/tools/archive-reader.ts

@@ -315,7 +315,16 @@ export async function openArchive(filePath: string): Promise<ArchiveReader> {
 		throw new ToolError(`Unsupported archive format: ${filePath}`);
 	}
 
-	const bytes = await Bun.file(filePath).bytes();
+	// F20: cap the compressed archive read so opening a multi-GB archive cannot buffer it
+	// whole into memory. (Zip-bomb expanded-size bounding would need a streaming inflate.)
+	const MAX_ARCHIVE_BYTES = 256 * 1024 * 1024;
+	const file = Bun.file(filePath);
+	if (file.size > MAX_ARCHIVE_BYTES) {
+		throw new ToolError(
+			`Archive too large to open: ${filePath} is ${file.size} bytes (limit ${MAX_ARCHIVE_BYTES}). Extract a subset with a dedicated tool.`,
+		);
+	}
+	const bytes = await file.bytes();
 	const entries = format === "zip" ? await readZipEntries(bytes) : await readTarEntries(bytes);
 	return new ArchiveReader(format, entries);
 }

package/src/tools/bash.ts

@@ -37,8 +37,13 @@ export const BASH_DEFAULT_PREVIEW_LINES = 10;
 const BASH_ENV_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 const DEFAULT_AUTO_BACKGROUND_THRESHOLD_MS = 60_000;
 
-async function saveBashOriginalArtifact(session: ToolSession, originalText: string): Promise<string | undefined> {
+export async function saveBashOriginalArtifactForTests(
+	session: ToolSession,
+	originalText: string,
+): Promise<string | undefined> {
 	try {
+		const manager = session.getArtifactManager?.();
+		if (manager) return await manager.save(originalText, "bash-original");
 		const alloc = await session.allocateOutputArtifact?.("bash-original");
 		if (!alloc?.path || !alloc.id) return undefined;
 		await Bun.write(alloc.path, originalText);
@@ -375,6 +380,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 						env: options.resolvedEnv,
 						artifactPath,
 						artifactId,
+						oneShot: true,
 						onChunk: chunk => {
 							tailBuffer.append(chunk);
 							latestText = tailBuffer.text();
@@ -387,7 +393,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 							// path above.
 							manager.appendOutput(jobId, chunk);
 						},
-						onMinimizedSave: originalText => saveBashOriginalArtifact(this.session, originalText),
+						onMinimizedSave: originalText => saveBashOriginalArtifactForTests(this.session, originalText),
 					});
 					const finalResult = this.#buildCompletedResult(result, options.timeoutSec, {
 						requestedTimeoutSec: options.requestedTimeoutSec,
@@ -675,6 +681,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 						env: prepared.resolvedEnv,
 						artifactPath,
 						artifactId,
+						oneShot: true,
 						onChunk: chunk => {
 							tailBuffer.append(chunk);
 							void reportProgress(tailBuffer.text(), {
@@ -688,7 +695,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 							cursorOffset = slice.nextOffset;
 							dispatchLines(slice.text);
 						},
-						onMinimizedSave: originalText => saveBashOriginalArtifact(this.session, originalText),
+						onMinimizedSave: originalText => saveBashOriginalArtifactForTests(this.session, originalText),
 					});
 					flushTrailingLine();
 					this.#buildResultText(result, prepared.timeoutSec, result.output || "(no output)");
@@ -996,7 +1003,7 @@ export class BashTool implements AgentTool<BashToolSchema, BashToolDetails> {
 					artifactPath,
 					artifactId,
 					onChunk: streamTailUpdates(tailBuffer, onUpdate),
-					onMinimizedSave: originalText => saveBashOriginalArtifact(this.session, originalText),
+					onMinimizedSave: originalText => saveBashOriginalArtifactForTests(this.session, originalText),
 				});
 		if (result.cancelled) {
 			if (signal?.aborted) {

package/src/tools/browser/tab-supervisor.ts

@@ -55,6 +55,8 @@ export interface TabSession {
 	pending: Map<string, PendingRun>;
 	dialogPolicy?: DialogPolicy;
 	kindTag: BrowserKindTag;
+	/** Session that acquired this tab; used for session-scoped teardown (F13). */
+	ownerId?: string;
 }
 
 export interface AcquireTabOptions {
@@ -65,6 +67,8 @@ export interface AcquireTabOptions {
 	signal?: AbortSignal;
 	timeoutMs: number;
 	dialogs?: DialogPolicy;
+	/** Owning session id so dispose can release only this session's tabs (F13). */
+	ownerId?: string;
 }
 
 export interface AcquireTabResult {
@@ -161,6 +165,7 @@ export async function acquireTab(
 		pending: new Map(),
 		dialogPolicy: opts.dialogs,
 		kindTag: browser.kind.kind,
+		ownerId: opts.ownerId,
 	};
 	worker.onMessage(msg => handleTabMessage(tab, msg));
 	tabs.set(name, tab);
@@ -254,6 +259,23 @@ export async function releaseAllTabs(opts: ReleaseTabOptions = {}): Promise<numb
 	return count;
 }
 
+/**
+ * Release only the tabs owned by `ownerId` (F13 session-scoped teardown). Tabs acquired
+ * by other sessions (or with no owner) are left untouched. No-op for a null/empty owner.
+ */
+export async function releaseTabsForOwner(
+	ownerId: string | null | undefined,
+	opts: ReleaseTabOptions = {},
+): Promise<number> {
+	if (!ownerId) return 0;
+	const names = [...tabs.entries()].filter(([, tab]) => tab.ownerId === ownerId).map(([name]) => name);
+	let count = 0;
+	for (const name of names) {
+		if (await releaseTab(name, opts)) count++;
+	}
+	return count;
+}
+
 export async function dropHeadlessTabs(): Promise<void> {
 	const names = [...tabs.values()].filter(tab => tab.kindTag === "headless").map(tab => tab.name);
 	for (const name of names) await releaseTab(name);

package/src/tools/browser.ts

@@ -213,6 +213,7 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 
 		const result = await untilAborted(signal, () =>
 			acquireTab(name, browser, {
+				ownerId: this.session.getSessionId?.() ?? undefined,
 				url: params.url,
 				waitUntil: params.wait_until,
 				viewport: params.viewport
@@ -381,11 +382,44 @@ function sameBrowserKind(a: BrowserKind, b: BrowserKind): boolean {
 	return false;
 }
 
+/** Max chars of a browser return value surfaced into the tool result (F22). */
+const MAX_BROWSER_RETURN_CHARS = 256 * 1024;
+
+const BROWSER_RETURN_BUDGET_EXCEEDED = Symbol("browser-return-budget-exceeded");
+
+/** Hard-cap any surfaced browser return string at the byte/char limit with a notice. */
+function capBrowserReturn(text: string): string {
+	if (text.length <= MAX_BROWSER_RETURN_CHARS) return text;
+	return `${text.slice(0, MAX_BROWSER_RETURN_CHARS)}\n\n[Browser return value truncated: ${text.length} chars exceeds the ${MAX_BROWSER_RETURN_CHARS}-char cap.]`;
+}
+
 function stringifyReturnValue(value: unknown): string {
-	if (typeof value === "string") return value;
+	if (typeof value === "string") return capBrowserReturn(value);
+	// F22: bound the serialization itself — the replacer tracks running size and aborts early so a
+	// huge object/array cannot build megabytes before truncation — AND hard-cap the final string,
+	// since pretty-print structural overhead (indent/braces/commas) is not counted by the budget.
+	let budget = MAX_BROWSER_RETURN_CHARS;
 	try {
-		return JSON.stringify(value, null, 2) ?? String(value);
-	} catch {
-		return String(value);
+		const text = JSON.stringify(
+			value,
+			(_key, val) => {
+				if (typeof val === "string") budget -= val.length + 4;
+				else if (typeof val === "number" || typeof val === "boolean") budget -= 8;
+				else budget -= 2;
+				if (budget < 0) throw BROWSER_RETURN_BUDGET_EXCEEDED;
+				return val;
+			},
+			2,
+		);
+		return text === undefined ? capBrowserReturn(String(value)) : capBrowserReturn(text);
+	} catch (error) {
+		if (error === BROWSER_RETURN_BUDGET_EXCEEDED) {
+			return `[Browser return value too large to serialize (exceeds the ${MAX_BROWSER_RETURN_CHARS}-char cap). Return a smaller or summarized value from the page script.]`;
+		}
+		try {
+			return capBrowserReturn(String(value));
+		} catch {
+			return "[unserializable browser return value]";
+		}
 	}
 }

package/src/tools/read.ts

@@ -1270,19 +1270,18 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 				}
 				case "raw": {
 					const result = executeReadQuery(db, selector.sql);
+					const table = renderTable(result.columns, result.rows, {
+						totalCount: result.rows.length,
+						offset: 0,
+						limit: result.rows.length || DEFAULT_MAX_LINES,
+						table: "query",
+						dbPath: resolvedSqlitePath.absolutePath,
+					});
+					const body = result.truncated
+						? `${table}\n\n[Output truncated to the first ${result.rows.length} rows; add a LIMIT clause to the query to bound or page the result.]`
+						: table;
 					return toolResult<ReadToolDetails>(details)
-						.text(
-							prependSuffixResolutionNotice(
-								renderTable(result.columns, result.rows, {
-									totalCount: result.rows.length,
-									offset: 0,
-									limit: result.rows.length || DEFAULT_MAX_LINES,
-									table: "query",
-									dbPath: resolvedSqlitePath.absolutePath,
-								}),
-								resolvedSqlitePath.suffixResolution,
-							),
-						)
+						.text(prependSuffixResolutionNotice(body, resolvedSqlitePath.suffixResolution))
 						.sourcePath(resolvedSqlitePath.absolutePath)
 						.done();
 				}