@oh-my-pi/pi-coding-agent 13.11.1 → 13.12.3

package/src/session/blob-store.ts

@@ -74,6 +74,21 @@ export function parseBlobRef(data: string): string | null {
 	return data.slice(BLOB_PREFIX.length);
 }
 
+/** Identify provider transport image data URLs so persistence can externalize and restore them losslessly. */
+export function isImageDataUrl(data: string): boolean {
+	return data.startsWith("data:image/") && data.includes(";base64,");
+}
+
+/**
+ * Externalize a provider image data URL to the blob store, returning a blob reference.
+ * The full data URL string is preserved so transport-native history can be reconstructed on resume.
+ */
+export async function externalizeImageDataUrl(blobStore: BlobStore, dataUrl: string): Promise<string> {
+	if (isBlobRef(dataUrl)) return dataUrl;
+	const { ref } = await blobStore.put(Buffer.from(dataUrl, "utf8"));
+	return ref;
+}
+
 /**
  * Externalize an image's base64 data to the blob store, returning a blob reference.
  * If the data is already a blob reference, returns it unchanged.
@@ -85,6 +100,23 @@ export async function externalizeImageData(blobStore: BlobStore, base64Data: str
 	return ref;
 }
 
+/**
+ * Resolve an externalized provider image data URL back to its original string.
+ * If the data is not a blob reference, returns it unchanged.
+ * If the blob is missing, logs a warning and returns the reference as-is.
+ */
+export async function resolveImageDataUrl(blobStore: BlobStore, data: string): Promise<string> {
+	const hash = parseBlobRef(data);
+	if (!hash) return data;
+
+	const buffer = await blobStore.get(hash);
+	if (!buffer) {
+		logger.warn("Blob not found for persisted image data URL", { hash });
+		return data;
+	}
+	return buffer.toString("utf8");
+}
+
 /**
  * Resolve a blob reference back to base64 data.
  * If the data is not a blob reference, returns it unchanged.

package/src/session/compaction/compaction.ts

@@ -5,7 +5,14 @@
  * and after compaction the session is reloaded.
  */
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
-import { type AssistantMessage, completeSimple, Effort, type Model, type Usage } from "@oh-my-pi/pi-ai";
+import {
+	type AssistantMessage,
+	completeSimple,
+	Effort,
+	type MessageAttribution,
+	type Model,
+	type Usage,
+} from "@oh-my-pi/pi-ai";
 import {
 	CODEX_BASE_URL,
 	getCodexAccountId,
@@ -129,6 +136,7 @@ export interface CompactionSettings {
 	enabled: boolean;
 	strategy?: "context-full" | "handoff" | "off";
 	thresholdPercent?: number;
+	thresholdTokens?: number;
 	reserveTokens: number;
 	keepRecentTokens: number;
 	autoContinue?: boolean;
@@ -140,6 +148,7 @@ export const DEFAULT_COMPACTION_SETTINGS: CompactionSettings = {
 	enabled: true,
 	strategy: "context-full",
 	thresholdPercent: -1,
+	thresholdTokens: -1,
 	reserveTokens: 16384,
 	keepRecentTokens: 20000,
 	autoContinue: true,
@@ -211,6 +220,14 @@ export function shouldCompact(contextTokens: number, contextWindow: number, sett
 }
 
 function resolveThresholdTokens(contextWindow: number, settings: CompactionSettings): number {
+	// Fixed token limit takes priority over percentage
+	const thresholdTokens = settings.thresholdTokens;
+	if (typeof thresholdTokens === "number" && Number.isFinite(thresholdTokens) && thresholdTokens > 0) {
+		// Clamp to [1, contextWindow - 1] so there's always room
+		return Math.min(contextWindow - 1, Math.max(1, thresholdTokens));
+	}
+
+	// Percentage-based threshold
 	const thresholdPercent = settings.thresholdPercent;
 	if (typeof thresholdPercent !== "number" || !Number.isFinite(thresholdPercent) || thresholdPercent <= 0) {
 		return contextWindow - effectiveReserveTokens(contextWindow, settings);
@@ -935,6 +952,7 @@ export interface SummaryOptions {
 	extraContext?: string[];
 	remoteEndpoint?: string;
 	remoteInstructions?: string;
+	initiatorOverride?: MessageAttribution;
 }
 
 export async function generateSummary(
@@ -990,7 +1008,7 @@ export async function generateSummary(
 	const response = await completeSimple(
 		model,
 		{ systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages },
-		{ maxTokens, signal, apiKey, reasoning: Effort.High },
+		{ maxTokens, signal, apiKey, reasoning: Effort.High, initiatorOverride: options?.initiatorOverride },
 	);
 
 	if (response.stopReason === "error") {
@@ -1039,7 +1057,7 @@ async function generateShortSummary(
 			systemPrompt: SUMMARIZATION_SYSTEM_PROMPT,
 			messages: [{ role: "user", content: [{ type: "text", text: promptText }], timestamp: Date.now() }],
 		},
-		{ maxTokens, signal, apiKey, reasoning: Effort.High },
+		{ maxTokens, signal, apiKey, reasoning: Effort.High, initiatorOverride: options?.initiatorOverride },
 	);
 
 	if (response.stopReason === "error") {
@@ -1218,6 +1236,7 @@ export async function compact(
 		extraContext: options?.extraContext,
 		remoteEndpoint: settings.remoteEnabled === false ? undefined : settings.remoteEndpoint,
 		remoteInstructions: options?.remoteInstructions,
+		initiatorOverride: options?.initiatorOverride,
 	};
 
 	let preserveData = withOpenAiRemoteCompactionPreserveData(previousPreserveData, undefined);
@@ -1266,7 +1285,14 @@ export async function compact(
 						summaryOptions,
 					)
 				: Promise.resolve("No prior history."),
-			generateTurnPrefixSummary(turnPrefixMessages, model, settings.reserveTokens, apiKey, signal),
+			generateTurnPrefixSummary(
+				turnPrefixMessages,
+				model,
+				settings.reserveTokens,
+				apiKey,
+				signal,
+				summaryOptions.initiatorOverride,
+			),
 		]);
 		// Merge into single summary
 		summary = `${historyResult}\n\n---\n\n**Turn Context (split turn):**\n\n${turnPrefixResult}`;
@@ -1297,7 +1323,11 @@ export async function compact(
 		settings.reserveTokens,
 		apiKey,
 		signal,
-		{ extraContext: options?.extraContext, remoteEndpoint: summaryOptions.remoteEndpoint },
+		{
+			extraContext: options?.extraContext,
+			remoteEndpoint: summaryOptions.remoteEndpoint,
+			initiatorOverride: summaryOptions.initiatorOverride,
+		},
 	);
 
 	// Compute file lists and append to summary
@@ -1327,6 +1357,7 @@ async function generateTurnPrefixSummary(
 	reserveTokens: number,
 	apiKey: string,
 	signal?: AbortSignal,
+	initiatorOverride?: MessageAttribution,
 ): Promise<string> {
 	const maxTokens = Math.floor(0.5 * reserveTokens); // Smaller budget for turn prefix
 
@@ -1344,7 +1375,7 @@ async function generateTurnPrefixSummary(
 	const response = await completeSimple(
 		model,
 		{ systemPrompt: SUMMARIZATION_SYSTEM_PROMPT, messages: summarizationMessages },
-		{ maxTokens, signal, apiKey, reasoning: Effort.High },
+		{ maxTokens, signal, apiKey, reasoning: Effort.High, initiatorOverride },
 	);
 
 	if (response.stopReason === "error") {

package/src/session/history-storage.ts

@@ -1,7 +1,7 @@
 import { Database, type Statement } from "bun:sqlite";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { getAgentDir, logger } from "@oh-my-pi/pi-utils";
+import { getHistoryDbPath, logger } from "@oh-my-pi/pi-utils";
 
 export interface HistoryEntry {
 	id: number;
@@ -78,7 +78,7 @@ END;
 		this.#lastPromptCache = last?.prompt ?? null;
 	}
 
-	static open(dbPath: string = path.join(getAgentDir(), "history.db")): HistoryStorage {
+	static open(dbPath: string = getHistoryDbPath()): HistoryStorage {
 		if (!HistoryStorage.#instance) {
 			HistoryStorage.#instance = new HistoryStorage(dbPath);
 		}

package/src/session/session-manager.ts

@@ -16,6 +16,8 @@ import {
 	getBlobsDir,
 	getAgentDir as getDefaultAgentDir,
 	getProjectDir,
+	getSessionsDir,
+	getTerminalSessionsDir,
 	isEnoent,
 	logger,
 	parseJsonlLenient,
@@ -23,7 +25,16 @@ import {
 	toError,
 } from "@oh-my-pi/pi-utils";
 import { ArtifactManager } from "./artifacts";
-import { type BlobPutResult, BlobStore, externalizeImageData, isBlobRef, resolveImageData } from "./blob-store";
+import {
+	type BlobPutResult,
+	BlobStore,
+	externalizeImageData,
+	externalizeImageDataUrl,
+	isBlobRef,
+	isImageDataUrl,
+	resolveImageData,
+	resolveImageDataUrl,
+} from "./blob-store";
 import {
 	type BashExecutionMessage,
 	type CustomMessage,
@@ -348,7 +359,7 @@ function migrateHomeSessionDirs(): void {
 	const homeEncoded = home.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-");
 	const oldPrefix = `--${homeEncoded}-`;
 	const oldExact = `--${homeEncoded}--`;
-	const sessionsRoot = path.join(getDefaultAgentDir(), "sessions");
+	const sessionsRoot = getSessionsDir();
 
 	let entries: string[];
 	try {
@@ -608,8 +619,7 @@ function encodeSessionDirName(cwd: string): string {
  */
 function getDefaultSessionDir(cwd: string, storage: SessionStorage): string {
 	migrateHomeSessionDirs();
-	const dirName = encodeSessionDirName(cwd);
-	const sessionDir = path.join(getDefaultAgentDir(), "sessions", dirName);
+	const sessionDir = path.join(getSessionsDir(), encodeSessionDirName(cwd));
 	storage.ensureDirSync(sessionDir);
 	return sessionDir;
 }
@@ -618,8 +628,6 @@ function getDefaultSessionDir(cwd: string, storage: SessionStorage): string {
 // Terminal breadcrumbs: maps terminal (TTY) -> last session file for --continue
 // =============================================================================
 
-const TERMINAL_SESSIONS_DIR = "terminal-sessions";
-
 /**
  * Write a breadcrumb linking the current terminal to a session file.
  * The breadcrumb contains the cwd and session path so --continue can
@@ -629,7 +637,7 @@ function writeTerminalBreadcrumb(cwd: string, sessionFile: string): void {
 	const terminalId = getTerminalId();
 	if (!terminalId) return;
 
-	const breadcrumbDir = path.join(getDefaultAgentDir(), TERMINAL_SESSIONS_DIR);
+	const breadcrumbDir = getTerminalSessionsDir();
 	const breadcrumbFile = path.join(breadcrumbDir, terminalId);
 	const content = `${cwd}\n${sessionFile}\n`;
 	// Best-effort — don't break session creation if breadcrumb fails
@@ -645,7 +653,7 @@ async function readTerminalBreadcrumb(cwd: string): Promise<string | null> {
 	if (!terminalId) return null;
 
 	try {
-		const breadcrumbFile = path.join(getDefaultAgentDir(), TERMINAL_SESSIONS_DIR, terminalId);
+		const breadcrumbFile = path.join(getTerminalSessionsDir(), terminalId);
 		const content = await Bun.file(breadcrumbFile).text();
 		const lines = content.trim().split("\n");
 		if (lines.length < 2) return null;
@@ -691,35 +699,54 @@ export async function loadEntriesFromFile(
 }
 
 /**
- * Resolve blob references in loaded entries, replacing `blob:sha256:<hash>` data fields
- * with the actual base64 content from the blob store. Mutates entries in place.
+ * Resolve blob references in loaded entries, restoring both session image blocks and persisted
+ * provider image URLs back to the inline data expected by downstream transports. Mutates entries in place.
  */
+function hasImageUrl(value: unknown): value is { image_url: string } {
+	return typeof value === "object" && value !== null && "image_url" in value && typeof value.image_url === "string";
+}
+
+async function resolvePersistedImageUrlRefs(value: unknown, blobStore: BlobStore): Promise<void> {
+	if (Array.isArray(value)) {
+		await Promise.all(value.map(item => resolvePersistedImageUrlRefs(item, blobStore)));
+		return;
+	}
+
+	if (typeof value !== "object" || value === null) return;
+
+	if (hasImageUrl(value) && isBlobRef(value.image_url)) {
+		value.image_url = await resolveImageDataUrl(blobStore, value.image_url);
+	}
+
+	await Promise.all(Object.values(value).map(item => resolvePersistedImageUrlRefs(item, blobStore)));
+}
+
 async function resolveBlobRefsInEntries(entries: FileEntry[], blobStore: BlobStore): Promise<void> {
 	const promises: Promise<void>[] = [];
 
 	for (const entry of entries) {
 		if (entry.type === "session") continue;
 
-		// Resolve image blocks in message content arrays
 		let contentArray: unknown[] | undefined;
-		if (entry.type === "message") {
-			const content = (entry.message as { content?: unknown }).content;
-			if (Array.isArray(content)) contentArray = content;
+		if (entry.type === "message" && "content" in entry.message && Array.isArray(entry.message.content)) {
+			contentArray = entry.message.content;
 		} else if (entry.type === "custom_message" && Array.isArray(entry.content)) {
 			contentArray = entry.content;
 		}
 
-		if (!contentArray) continue;
-
-		for (const block of contentArray) {
-			if (isImageBlock(block) && isBlobRef(block.data)) {
-				promises.push(
-					resolveImageData(blobStore, block.data).then(resolved => {
-						(block as { data: string }).data = resolved;
-					}),
-				);
+		if (contentArray) {
+			for (const block of contentArray) {
+				if (isImageBlock(block) && isBlobRef(block.data)) {
+					promises.push(
+						resolveImageData(blobStore, block.data).then(resolved => {
+							block.data = resolved;
+						}),
+					);
+				}
 			}
 		}
+
+		promises.push(resolvePersistedImageUrlRefs(entry, blobStore));
 	}
 
 	await Promise.all(promises);
@@ -891,19 +918,34 @@ function isImageBlock(value: unknown): value is { type: "image"; data: string; m
 	);
 }
 
-async function truncateForPersistence<T>(obj: T, blobStore: BlobStore, key?: string): Promise<T> {
+async function truncateForPersistence(obj: FileEntry, blobStore: BlobStore, key?: string): Promise<FileEntry>;
+async function truncateForPersistence(obj: string, blobStore: BlobStore, key?: string): Promise<string>;
+async function truncateForPersistence(obj: unknown[], blobStore: BlobStore, key?: string): Promise<unknown[]>;
+async function truncateForPersistence(obj: object, blobStore: BlobStore, key?: string): Promise<object>;
+async function truncateForPersistence(
+	obj: null | undefined,
+	blobStore: BlobStore,
+	key?: string,
+): Promise<null | undefined>;
+async function truncateForPersistence(obj: unknown, blobStore: BlobStore, key?: string): Promise<unknown> {
 	if (obj === null || obj === undefined) return obj;
 
 	if (typeof obj === "string") {
+		if (key === "image_url" && isImageDataUrl(obj)) {
+			return externalizeImageDataUrl(blobStore, obj);
+		}
+
 		if (obj.length > MAX_PERSIST_CHARS) {
 			// Cryptographic signatures must be preserved exactly or cleared entirely — never truncated.
 			// Truncation would produce an invalid signature that the API rejects.
 			if (key === "thinkingSignature" || key === "thoughtSignature" || key === "textSignature") {
-				return "" as T;
+				return "";
 			}
+
 			const limit = Math.max(0, MAX_PERSIST_CHARS - TRUNCATION_NOTICE.length);
-			return `${truncateString(obj, limit)}${TRUNCATION_NOTICE}` as T;
+			return `${truncateString(obj, limit)}${TRUNCATION_NOTICE}`;
 		}
+
 		return obj;
 	}
 
@@ -919,34 +961,54 @@ async function truncateForPersistence<T>(obj: T, blobStore: BlobStore, key?: str
 						return { ...item, data: blobRef };
 					}
 				}
+
 				const newItem = await truncateForPersistence(item, blobStore, key);
 				if (newItem !== item) changed = true;
 				return newItem;
 			}),
 		);
-		return changed ? (result as T) : obj;
+		return changed ? result : obj;
 	}
 
 	if (typeof obj === "object") {
 		let changed = false;
-		const result: Record<string, unknown> = {};
-		for (const [k, v] of Object.entries(obj as Record<string, unknown>)) {
-			// Strip transient/redundant properties that shouldn't be persisted
-			// - partialJson: streaming accumulator for tool call JSON parsing
-			// - jsonlEvents: raw subprocess streaming events (already saved to artifact files)
-			if (k === "partialJson" || k === "jsonlEvents") {
-				changed = true;
-				continue;
-			}
-			const newV = await truncateForPersistence(v, blobStore, k);
-			result[k] = newV;
-			if (newV !== v) changed = true;
-		}
-		// Update lineCount if content was truncated (for FileMentionFile)
-		if (changed && "lineCount" in result && "content" in result && typeof result.content === "string") {
-			result.lineCount = result.content.split("\n").length;
+		const entries: Array<readonly [string, unknown]> = await Promise.all(
+			Object.entries(obj).flatMap(([childKey, value]) => {
+				// Strip transient/redundant properties that shouldn't be persisted.
+				// - partialJson: streaming accumulator for tool call JSON parsing
+				// - jsonlEvents: raw subprocess streaming events (already saved to artifact files)
+				if (childKey === "partialJson" || childKey === "jsonlEvents") {
+					changed = true;
+					return [];
+				}
+
+				return [
+					(async () => {
+						const newValue = await truncateForPersistence(value, blobStore, childKey);
+						if (newValue !== value) changed = true;
+						return [childKey, newValue] as const;
+					})(),
+				];
+			}),
+		);
+
+		if (!changed) return obj;
+
+		const contentEntry = entries.find(([childKey]) => childKey === "content");
+		const lineCountEntry = entries.find(([childKey]) => childKey === "lineCount");
+		if (
+			contentEntry &&
+			typeof contentEntry[1] === "string" &&
+			lineCountEntry &&
+			typeof lineCountEntry[1] === "number"
+		) {
+			const content = contentEntry[1];
+			const updatedEntries = entries.map(([childKey, value]) =>
+				childKey === "lineCount" ? ([childKey, content.split("\n").length] as const) : ([childKey, value] as const),
+			);
+			return Object.fromEntries(updatedEntries);
 		}
-		return changed ? (result as T) : obj;
+		return Object.fromEntries(entries);
 	}
 
 	return obj;
@@ -1387,6 +1449,7 @@ export class SessionManager {
 		if (resolvedCwd === this.cwd) return;
 
 		const newSessionDir = getDefaultSessionDir(resolvedCwd, this.storage);
+		let hadSessionFile = false;
 
 		if (this.persist && this.#sessionFile) {
 			// Close the persist writer before moving files
@@ -1399,12 +1462,16 @@ export class SessionManager {
 			const newSessionFile = path.join(newSessionDir, path.basename(oldSessionFile));
 			const oldArtifactDir = oldSessionFile.slice(0, -6); // strip .jsonl
 			const newArtifactDir = newSessionFile.slice(0, -6);
+			hadSessionFile = this.storage.existsSync(oldSessionFile);
 			let movedSessionFile = false;
 			let movedArtifactDir = false;
 
 			try {
-				await fs.promises.rename(oldSessionFile, newSessionFile);
-				movedSessionFile = true;
+				// Guard: session file may not exist yet (no assistant messages persisted)
+				if (hadSessionFile) {
+					await fs.promises.rename(oldSessionFile, newSessionFile);
+					movedSessionFile = true;
+				}
 
 				try {
 					const stat = await fs.promises.stat(oldArtifactDir);
@@ -1449,8 +1516,12 @@ export class SessionManager {
 			header.cwd = resolvedCwd;
 		}
 
-		// Rewrite the session file at its new location with updated header
-		if (this.persist && this.#sessionFile) {
+		// Rewrite the session file at its new location with updated header.
+		// hadSessionFile: file existed before move → must rewrite to update cwd
+		// hasAssistant: assistant messages in memory but file missing → recreate from memory
+		// Neither true → fresh session, never written → preserve lazy-persist
+		const hasAssistant = this.#fileEntries.some(e => e.type === "message" && e.message.role === "assistant");
+		if (this.persist && this.#sessionFile && (hadSessionFile || hasAssistant)) {
 			await this.#rewriteFile();
 		}
 
@@ -1633,7 +1704,6 @@ export class SessionManager {
 
 	/** Flush pending writes to disk. Call before switching sessions or on shutdown. */
 	async flush(): Promise<void> {
-		if (!this.#persistWriter) return;
 		await this.#queuePersistTask(async () => {
 			if (this.#persistWriter) {
 				await this.#persistWriter.flush();
@@ -1643,6 +1713,16 @@ export class SessionManager {
 		if (this.#persistError) throw this.#persistError;
 	}
 
+	/** Close the persistent writer after flushing all pending data. */
+	async close(): Promise<void> {
+		if (!this.#persistWriter) return;
+		await this.#queuePersistTask(async () => {
+			await this.#closePersistWriterInternal();
+			this.#flushed = true;
+		});
+		if (this.#persistError) throw this.#persistError;
+	}
+
 	getCwd(): string {
 		return this.cwd;
 	}

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

@@ -465,6 +465,17 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<BuiltinSlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "btw",
+		description: "Ask an ephemeral side question using the current session context",
+		inlineHint: "<question>",
+		allowArgs: true,
+		handle: async (command, runtime) => {
+			const question = command.text.slice(`/${command.name}`.length).trim();
+			runtime.ctx.editor.setText("");
+			await runtime.ctx.handleBtwCommand(question);
+		},
+	},
 	{
 		name: "background",
 		aliases: ["bg"],

package/src/system-prompt.ts

@@ -447,22 +447,9 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		skills = prepResult.value.skills;
 	}
 
-	const now = new Date();
-	const date = now.toLocaleDateString("en-CA", {
-		year: "numeric",
-		month: "2-digit",
-		day: "2-digit",
-	});
-	const dateTime = now.toLocaleString("en-US", {
-		weekday: "long",
-		year: "numeric",
-		month: "long",
-		day: "numeric",
-		hour: "2-digit",
-		minute: "2-digit",
-		second: "2-digit",
-		timeZoneName: "short",
-	});
+	const date = new Date().toISOString().slice(0, 10);
+	const dateTime = date;
+	const promptCwd = resolvedCwd.replace(/\\/g, "/");
 
 	// Build tool metadata for system prompt rendering
 	// Priority: explicit list > tools map > defaults
@@ -504,7 +491,7 @@ export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}):
 		rules: rules ?? [],
 		date,
 		dateTime,
-		cwd: resolvedCwd,
+		cwd: promptCwd,
 		intentTracing: !!intentField,
 		intentField: intentField ?? "",
 		eagerTasks,

package/src/task/agents.ts

@@ -53,7 +53,7 @@ const EMBEDDED_AGENT_DEFS: EmbeddedAgentDef[] = [
 			name: "task",
 			description: "General-purpose subagent with full capabilities for delegated multi-step tasks",
 			spawns: "*",
-			model: "default",
+			model: "pi/task",
 			thinkingLevel: Effort.Medium,
 		},
 		template: taskMd,

package/src/task/index.ts

@@ -20,7 +20,7 @@ import type { Usage } from "@oh-my-pi/pi-ai";
 import { $env, Snowflake } from "@oh-my-pi/pi-utils";
 import { $ } from "bun";
 import type { ToolSession } from "..";
-import { isDefaultModelAlias } from "../config/model-resolver";
+import { resolveAgentModelPatterns } from "../config/model-resolver";
 import { renderPromptTemplate } from "../config/prompt-templates";
 import type { Theme } from "../modes/theme/theme";
 import planModeSubagentPrompt from "../prompts/system/plan-mode-subagent.md" with { type: "text" };
@@ -507,14 +507,15 @@ export class TaskTool implements AgentTool<TaskSchema, TaskToolDetails, Theme> {
 			: agent;
 
 		// Apply per-agent model override from settings (highest priority)
-		const agentModelOverrides = this.session.settings.get("task.agentModelOverrides") as Record<string, string>;
+		const agentModelOverrides = this.session.settings.get("task.agentModelOverrides");
 		const settingsModelOverride = agentModelOverrides[agentName];
-		const effectiveAgentModel = isDefaultModelAlias(effectiveAgent.model) ? undefined : effectiveAgent.model;
-		const modelOverride =
-			settingsModelOverride ??
-			effectiveAgentModel ??
-			this.session.getActiveModelString?.() ??
-			this.session.getModelString?.();
+		const modelOverride = resolveAgentModelPatterns({
+			settingsOverride: settingsModelOverride,
+			agentModel: effectiveAgent.model,
+			settings: this.session.settings,
+			activeModelPattern: this.session.getActiveModelString?.(),
+			fallbackModelPattern: this.session.getModelString?.(),
+		});
 		const thinkingLevelOverride = effectiveAgent.thinkingLevel;
 
 		// Output schema priority: agent frontmatter > params > inherited from parent session

package/src/tools/browser.ts

@@ -526,6 +526,17 @@ export class BrowserTool implements AgentTool<typeof browserSchema, BrowserToolD
 		const proxy = process.env.PUPPETEER_PROXY;
 		if (proxy) {
 			launchArgs.push(`--proxy-server=${proxy}`);
+			// Chrome (since v72) bypasses proxies for localhost by default. When PUPPETEER_PROXY_BYPASS_LOOPBACK
+			// is true, add <-loopback> so traffic to localhost reaches the proxy (e.g. for mitmdump/auth capture).
+			const bypassLoopback = process.env.PUPPETEER_PROXY_BYPASS_LOOPBACK?.toLowerCase();
+			if (
+				bypassLoopback === "true" ||
+				bypassLoopback === "1" ||
+				bypassLoopback === "yes" ||
+				bypassLoopback === "on"
+			) {
+				launchArgs.push("--proxy-bypass-list=<-loopback>");
+			}
 		}
 		const ignoreCert = process.env.PUPPETEER_PROXY_IGNORE_CERT_ERRORS?.toLowerCase();
 		if (ignoreCert === "true" || ignoreCert === "1" || ignoreCert === "yes" || ignoreCert === "on") {