@oh-my-pi/pi-coding-agent 11.5.1 → 11.6.0

package/CHANGELOG.md

@@ -2,6 +2,30 @@
 
 ## [Unreleased]
 
+## [11.6.0] - 2026-02-07
+
+### Fixed
+
+- Fixed task tool renderer not sanitizing tabs, causing visual holes in TUI output
+- Fixed task tool expanded view showing redundant `<swarm_context>` block that is shared across all tasks
+- Fixed assistant message spacer appearing before tool executions when no visible content follows thinking block
+- Fixed extension runner `emit()` type safety with narrowed event/result types
+- Fixed extension runner `tool_result` event chaining across multiple extensions via dedicated `emitToolResult()`
+- Fixed queued messages not delivered after auto-compaction completes
+
+### Added
+
+- Added `/quit` slash command as alias for `/exit`
+- Added per-model overrides (`modelOverrides`) in `models.json` for customizing built-in model properties
+- Added `mergeCustomModels` to merge custom models with built-ins by provider+id instead of replacing
+
+## [11.5.2] - 2026-02-07
+
+### Fixed
+
+- Fixed TUI crash when ask tool renders long user input exceeding terminal width by using Text component for word wrapping instead of raw line output
+- Fixed TUI crash when todo_write tool renders long todo content exceeding terminal width by using Text component for word wrapping instead of truncation
+
 ## [11.5.0] - 2026-02-06
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "11.5.1",
+	"version": "11.6.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"ompConfig": {
@@ -90,12 +90,12 @@
 		"@mozilla/readability": "0.6.0",
 		"@oclif/core": "^4.8.0",
 		"@oclif/plugin-autocomplete": "^3.2.40",
-		"@oh-my-pi/omp-stats": "11.5.1",
-		"@oh-my-pi/pi-agent-core": "11.5.1",
-		"@oh-my-pi/pi-ai": "11.5.1",
-		"@oh-my-pi/pi-natives": "11.5.1",
-		"@oh-my-pi/pi-tui": "11.5.1",
-		"@oh-my-pi/pi-utils": "11.5.1",
+		"@oh-my-pi/omp-stats": "11.6.0",
+		"@oh-my-pi/pi-agent-core": "11.6.0",
+		"@oh-my-pi/pi-ai": "11.6.0",
+		"@oh-my-pi/pi-natives": "11.6.0",
+		"@oh-my-pi/pi-tui": "11.6.0",
+		"@oh-my-pi/pi-utils": "11.6.0",
 		"@sinclair/typebox": "^0.34.48",
 		"ajv": "^8.17.1",
 		"chalk": "^5.6.2",

package/src/config/model-registry.ts

@@ -85,6 +85,27 @@ const ModelDefinitionSchema = Type.Object({
 	compat: Type.Optional(OpenAICompatSchema),
 });
 
+// Schema for per-model overrides (all fields optional, merged with built-in model)
+const ModelOverrideSchema = Type.Object({
+	name: Type.Optional(Type.String({ minLength: 1 })),
+	reasoning: Type.Optional(Type.Boolean()),
+	input: Type.Optional(Type.Array(Type.Union([Type.Literal("text"), Type.Literal("image")]))),
+	cost: Type.Optional(
+		Type.Object({
+			input: Type.Optional(Type.Number()),
+			output: Type.Optional(Type.Number()),
+			cacheRead: Type.Optional(Type.Number()),
+			cacheWrite: Type.Optional(Type.Number()),
+		}),
+	),
+	contextWindow: Type.Optional(Type.Number()),
+	maxTokens: Type.Optional(Type.Number()),
+	headers: Type.Optional(Type.Record(Type.String(), Type.String())),
+	compat: Type.Optional(OpenAICompatSchema),
+});
+
+type ModelOverride = Static<typeof ModelOverrideSchema>;
+
 const ProviderConfigSchema = Type.Object({
 	baseUrl: Type.Optional(Type.String({ minLength: 1 })),
 	apiKey: Type.Optional(Type.String({ minLength: 1 })),
@@ -102,6 +123,7 @@ const ProviderConfigSchema = Type.Object({
 	headers: Type.Optional(Type.Record(Type.String(), Type.String())),
 	authHeader: Type.Optional(Type.Boolean()),
 	models: Type.Optional(Type.Array(ModelDefinitionSchema)),
+	modelOverrides: Type.Optional(Type.Record(Type.String(), ModelOverrideSchema)),
 });
 
 const ModelsConfigSchema = Type.Object({
@@ -118,11 +140,11 @@ export const ModelsConfigFile = new ConfigFile<ModelsConfig>("models", ModelsCon
 			const models = providerConfig.models ?? [];
 
 			if (models.length === 0) {
-				// Override-only config: just needs baseUrl (to override built-in)
-				if (!providerConfig.baseUrl) {
-					throw new Error(
-						`Provider ${providerName}: must specify either "baseUrl" (for override) or "models" (for replacement).`,
-					);
+				// Override-only config: needs baseUrl or modelOverrides
+				const hasModelOverrides =
+					providerConfig.modelOverrides && Object.keys(providerConfig.modelOverrides).length > 0;
+				if (!providerConfig.baseUrl && !hasModelOverrides) {
+					throw new Error(`Provider ${providerName}: must specify "baseUrl", "modelOverrides", or "models".`);
 				}
 			} else {
 				// Full replacement: needs baseUrl and apiKey
@@ -172,10 +194,8 @@ export interface SerializedModelRegistry {
 /** Result of loading custom models from models.json */
 interface CustomModelsResult {
 	models?: Model<Api>[];
-	/** Providers with custom models (full replacement) */
-	replacedProviders?: Set<string>;
-	/** Providers with only baseUrl/headers override (no custom models) */
 	overrides?: Map<string, ProviderOverride>;
+	modelOverrides?: Map<string, Map<string, ModelOverride>>;
 	error?: ConfigError;
 	found: boolean;
 }
@@ -190,6 +210,45 @@ function resolveApiKeyConfig(keyConfig: string): string | undefined {
 	return keyConfig;
 }
 
+function mergeCompat(
+	baseCompat: Model<Api>["compat"],
+	overrideCompat: ModelOverride["compat"],
+): Model<Api>["compat"] | undefined {
+	if (!overrideCompat) return baseCompat;
+	const base = baseCompat as any;
+	const override = overrideCompat as any;
+	const merged = { ...base, ...override };
+	if (base?.openRouterRouting || override.openRouterRouting) {
+		merged.openRouterRouting = { ...base?.openRouterRouting, ...override.openRouterRouting };
+	}
+	if (base?.vercelGatewayRouting || override.vercelGatewayRouting) {
+		merged.vercelGatewayRouting = { ...base?.vercelGatewayRouting, ...override.vercelGatewayRouting };
+	}
+	return merged;
+}
+
+function applyModelOverride(model: Model<Api>, override: ModelOverride): Model<Api> {
+	const result = { ...model };
+	if (override.name !== undefined) result.name = override.name;
+	if (override.reasoning !== undefined) result.reasoning = override.reasoning;
+	if (override.input !== undefined) result.input = override.input as ("text" | "image")[];
+	if (override.contextWindow !== undefined) result.contextWindow = override.contextWindow;
+	if (override.maxTokens !== undefined) result.maxTokens = override.maxTokens;
+	if (override.cost) {
+		result.cost = {
+			input: override.cost.input ?? model.cost.input,
+			output: override.cost.output ?? model.cost.output,
+			cacheRead: override.cost.cacheRead ?? model.cost.cacheRead,
+			cacheWrite: override.cost.cacheWrite ?? model.cost.cacheWrite,
+		};
+	}
+	if (override.headers) {
+		result.headers = { ...model.headers, ...override.headers };
+	}
+	result.compat = mergeCompat(model.compat, override.compat);
+	return result;
+}
+
 /**
  * Model registry - loads and manages models, resolves API keys via AuthStorage.
  */
@@ -272,17 +331,17 @@ export class ModelRegistry {
 	}
 
 	private loadModels() {
-		// Load custom models from models.json first (to know which providers to skip/override)
+		// Load custom models from models.json first (to know which providers to override)
 		const {
 			models: customModels = [],
-			replacedProviders = new Set(),
 			overrides = new Map(),
+			modelOverrides = new Map(),
 			error: configError,
 		} = this.loadCustomModels();
 		this.configError = configError;
 
-		const builtInModels = this.loadBuiltInModels(replacedProviders, overrides);
-		const combined = [...builtInModels, ...customModels];
+		const builtInModels = this.loadBuiltInModels(overrides, modelOverrides);
+		const combined = this.mergeCustomModels(builtInModels, customModels);
 
 		// Update github-copilot base URL based on OAuth credentials
 		const copilotCred = this.authStorage.getOAuthCredential("github-copilot");
@@ -297,56 +356,86 @@ export class ModelRegistry {
 		}
 	}
 
-	/** Load built-in models, skipping replaced providers and applying overrides */
-	private loadBuiltInModels(replacedProviders: Set<string>, overrides: Map<string, ProviderOverride>): Model<Api>[] {
-		return getProviders()
-			.filter(provider => !replacedProviders.has(provider))
-			.flatMap(provider => {
-				const models = getModels(provider as any) as Model<Api>[];
-				const override = overrides.get(provider);
-				if (!override) return models;
-
-				// Apply baseUrl/headers override to all models of this provider
-				return models.map(m => ({
-					...m,
-					baseUrl: override.baseUrl ?? m.baseUrl,
-					headers: override.headers ? { ...m.headers, ...override.headers } : m.headers,
-				}));
+	/** Load built-in models, applying provider and per-model overrides */
+	private loadBuiltInModels(
+		overrides: Map<string, ProviderOverride>,
+		modelOverrides: Map<string, Map<string, ModelOverride>>,
+	): Model<Api>[] {
+		return getProviders().flatMap(provider => {
+			const models = getModels(provider as any) as Model<Api>[];
+			const providerOverride = overrides.get(provider);
+			const perModelOverrides = modelOverrides.get(provider);
+
+			return models.map(m => {
+				let model = m;
+				if (providerOverride) {
+					model = {
+						...model,
+						baseUrl: providerOverride.baseUrl ?? model.baseUrl,
+						headers: providerOverride.headers ? { ...model.headers, ...providerOverride.headers } : model.headers,
+					};
+				}
+				const modelOverride = perModelOverrides?.get(m.id);
+				if (modelOverride) {
+					model = applyModelOverride(model, modelOverride);
+				}
+				return model;
 			});
+		});
+	}
+
+	/** Merge custom models with built-in, replacing by provider+id match */
+	private mergeCustomModels(builtInModels: Model<Api>[], customModels: Model<Api>[]): Model<Api>[] {
+		const merged = [...builtInModels];
+		for (const customModel of customModels) {
+			const existingIndex = merged.findIndex(m => m.provider === customModel.provider && m.id === customModel.id);
+			if (existingIndex >= 0) {
+				merged[existingIndex] = customModel;
+			} else {
+				merged.push(customModel);
+			}
+		}
+		return merged;
 	}
 
 	private loadCustomModels(): CustomModelsResult {
 		const { value, error, status } = this.modelsConfigFile.tryLoad();
 
 		if (status === "error") {
-			return { models: [], replacedProviders: new Set(), overrides: new Map(), error, found: true };
+			return { models: [], overrides: new Map(), modelOverrides: new Map(), error, found: true };
 		} else if (status === "not-found") {
-			return { models: [], replacedProviders: new Set(), overrides: new Map(), found: false };
+			return { models: [], overrides: new Map(), modelOverrides: new Map(), found: false };
 		}
 
-		// Separate providers into "full replacement" (has models) vs "override-only" (no models)
-		const replacedProviders = new Set<string>();
 		const overrides = new Map<string, ProviderOverride>();
+		const allModelOverrides = new Map<string, Map<string, ModelOverride>>();
 
 		for (const [providerName, providerConfig] of Object.entries(value.providers)) {
-			if (providerConfig.models && providerConfig.models.length > 0) {
-				// Has custom models -> full replacement
-				replacedProviders.add(providerName);
-			} else {
-				// No models -> just override baseUrl/headers on built-in
+			// Always set overrides when baseUrl/headers present
+			if (providerConfig.baseUrl || providerConfig.headers || providerConfig.apiKey) {
 				overrides.set(providerName, {
 					baseUrl: providerConfig.baseUrl,
 					headers: providerConfig.headers,
 					apiKey: providerConfig.apiKey,
 				});
-				// Store API key for fallback resolver
-				if (providerConfig.apiKey) {
-					this.customProviderApiKeys.set(providerName, providerConfig.apiKey);
+			}
+
+			// Always store API key for fallback resolver
+			if (providerConfig.apiKey) {
+				this.customProviderApiKeys.set(providerName, providerConfig.apiKey);
+			}
+
+			// Parse per-model overrides
+			if (providerConfig.modelOverrides) {
+				const perModel = new Map<string, ModelOverride>();
+				for (const [modelId, override] of Object.entries(providerConfig.modelOverrides)) {
+					perModel.set(modelId, override);
 				}
+				allModelOverrides.set(providerName, perModel);
 			}
 		}
 
-		return { models: this.parseModels(value), replacedProviders, overrides, found: true };
+		return { models: this.parseModels(value), overrides, modelOverrides: allModelOverrides, found: true };
 	}
 
 	private parseModels(config: ModelsConfig): Model<Api>[] {

package/src/extensibility/extensions/runner.ts

@@ -34,11 +34,14 @@ import type {
 	RegisteredTool,
 	ResourcesDiscoverEvent,
 	ResourcesDiscoverResult,
+	SessionBeforeBranchResult,
 	SessionBeforeCompactResult,
+	SessionBeforeSwitchResult,
 	SessionBeforeTreeResult,
 	SessionCompactingResult,
 	ToolCallEvent,
 	ToolCallEventResult,
+	ToolResultEvent,
 	ToolResultEventResult,
 	UserBashEvent,
 	UserBashEventResult,
@@ -54,6 +57,44 @@ interface BeforeAgentStartCombinedResult {
 
 export type ExtensionErrorListener = (error: ExtensionError) => void;
 
+/**
+ * Events handled by the generic emit() method.
+ * Events with dedicated emitXxx() methods are excluded for stronger type safety.
+ */
+type RunnerEmitEvent = Exclude<
+	ExtensionEvent,
+	| ToolCallEvent
+	| ToolResultEvent
+	| UserBashEvent
+	| ContextEvent
+	| BeforeAgentStartEvent
+	| ResourcesDiscoverEvent
+	| InputEvent
+>;
+
+type SessionBeforeEvent = Extract<
+	RunnerEmitEvent,
+	{ type: "session_before_switch" | "session_before_branch" | "session_before_compact" | "session_before_tree" }
+>;
+
+type SessionBeforeEventResult =
+	| SessionBeforeSwitchResult
+	| SessionBeforeBranchResult
+	| SessionBeforeCompactResult
+	| SessionBeforeTreeResult;
+
+type RunnerEmitResult<TEvent extends RunnerEmitEvent> = TEvent extends { type: "session_before_switch" }
+	? SessionBeforeSwitchResult | undefined
+	: TEvent extends { type: "session_before_branch" }
+		? SessionBeforeBranchResult | undefined
+		: TEvent extends { type: "session_before_compact" }
+			? SessionBeforeCompactResult | undefined
+			: TEvent extends { type: "session_before_tree" }
+				? SessionBeforeTreeResult | undefined
+				: TEvent extends { type: "session.compacting" }
+					? SessionCompactingResult | undefined
+					: undefined;
+
 export type NewSessionHandler = (options?: {
 	parentSession?: string;
 	setup?: (sessionManager: SessionManager) => Promise<void>;
@@ -368,29 +409,18 @@ export class ExtensionRunner {
 		};
 	}
 
-	private isSessionBeforeEvent(
-		type: string,
-	): type is "session_before_switch" | "session_before_branch" | "session_before_compact" | "session_before_tree" {
+	private isSessionBeforeEvent(event: RunnerEmitEvent): event is SessionBeforeEvent {
 		return (
-			type === "session_before_switch" ||
-			type === "session_before_branch" ||
-			type === "session_before_compact" ||
-			type === "session_before_tree"
+			event.type === "session_before_switch" ||
+			event.type === "session_before_branch" ||
+			event.type === "session_before_compact" ||
+			event.type === "session_before_tree"
 		);
 	}
 
-	async emit(
-		event: ExtensionEvent,
-	): Promise<
-		SessionBeforeCompactResult | SessionBeforeTreeResult | SessionCompactingResult | ToolResultEventResult | undefined
-	> {
+	async emit<TEvent extends RunnerEmitEvent>(event: TEvent): Promise<RunnerEmitResult<TEvent>> {
 		const ctx = this.createContext();
-		let result:
-			| SessionBeforeCompactResult
-			| SessionBeforeTreeResult
-			| SessionCompactingResult
-			| ToolResultEventResult
-			| undefined;
+		let result: SessionBeforeEventResult | SessionCompactingResult | undefined;
 
 		for (const ext of this.extensions) {
 			const handlers = ext.handlers.get(event.type);
@@ -400,16 +430,13 @@ export class ExtensionRunner {
 				try {
 					const handlerResult = await handler(event, ctx);
 
-					if (this.isSessionBeforeEvent(event.type) && handlerResult) {
-						result = handlerResult as SessionBeforeCompactResult | SessionBeforeTreeResult;
+					if (this.isSessionBeforeEvent(event) && handlerResult) {
+						result = handlerResult as SessionBeforeEventResult;
 						if (result.cancel) {
-							return result;
+							return result as RunnerEmitResult<TEvent>;
 						}
 					}
 
-					if (event.type === "tool_result" && handlerResult) {
-						result = handlerResult as ToolResultEventResult;
-					}
 					if (event.type === "session.compacting" && handlerResult) {
 						result = handlerResult as SessionCompactingResult;
 					}
@@ -426,7 +453,55 @@ export class ExtensionRunner {
 			}
 		}
 
-		return result;
+		return result as RunnerEmitResult<TEvent>;
+	}
+
+	async emitToolResult(event: ToolResultEvent): Promise<ToolResultEventResult | undefined> {
+		const ctx = this.createContext();
+		const currentEvent: ToolResultEvent = { ...event };
+		let modified = false;
+
+		for (const ext of this.extensions) {
+			const handlers = ext.handlers.get("tool_result");
+			if (!handlers || handlers.length === 0) continue;
+
+			for (const handler of handlers) {
+				try {
+					const handlerResult = (await handler(currentEvent, ctx)) as ToolResultEventResult | undefined;
+					if (!handlerResult) continue;
+
+					if (handlerResult.content !== undefined) {
+						currentEvent.content = handlerResult.content;
+						modified = true;
+					}
+					if (handlerResult.details !== undefined) {
+						currentEvent.details = handlerResult.details;
+						modified = true;
+					}
+					if (handlerResult.isError !== undefined) {
+						currentEvent.isError = handlerResult.isError;
+						modified = true;
+					}
+				} catch (err) {
+					const message = err instanceof Error ? err.message : String(err);
+					const stack = err instanceof Error ? err.stack : undefined;
+					this.emitError({
+						extensionPath: ext.path,
+						event: "tool_result",
+						error: message,
+						stack,
+					});
+				}
+			}
+		}
+
+		if (!modified) return undefined;
+
+		return {
+			content: currentEvent.content,
+			details: currentEvent.details,
+			isError: currentEvent.isError,
+		};
 	}
 
 	async emitToolCall(event: ToolCallEvent): Promise<ToolCallEventResult | undefined> {

package/src/extensibility/extensions/wrapper.ts

@@ -7,7 +7,7 @@ import type { Static, TSchema } from "@sinclair/typebox";
 import type { Theme } from "../../modes/theme/theme";
 import { applyToolProxy } from "../tool-proxy";
 import type { ExtensionRunner } from "./runner";
-import type { RegisteredTool, ToolCallEventResult, ToolResultEventResult } from "./types";
+import type { RegisteredTool, ToolCallEventResult } from "./types";
 
 /**
  * Adapts a RegisteredTool into an AgentTool.
@@ -137,7 +137,7 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 
 		// Emit tool_result event - extensions can modify the result and error status
 		if (this.runner.hasHandlers("tool_result")) {
-			const resultResult = (await this.runner.emit({
+			const resultResult = await this.runner.emitToolResult({
 				type: "tool_result",
 				toolName: this.tool.name,
 				toolCallId,
@@ -145,7 +145,7 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 				content: result.content,
 				details: result.details,
 				isError: !!executionError,
-			})) as ToolResultEventResult | undefined;
+			});
 
 			if (resultResult) {
 				const modifiedContent: (TextContent | ImageContent)[] = resultResult.content ?? result.content;

package/src/extensibility/slash-commands.ts

@@ -41,6 +41,7 @@ export const BUILTIN_SLASH_COMMANDS: ReadonlyArray<BuiltinSlashCommand> = [
 	{ name: "background", description: "Detach UI and continue running in background" },
 	{ name: "debug", description: "Write debug log (TUI state and messages)" },
 	{ name: "exit", description: "Exit the application" },
+	{ name: "quit", description: "Quit the application" },
 ];
 
 import { slashCommandCapability } from "../capability/slash-command";

package/src/modes/components/assistant-message.ts

@@ -84,13 +84,16 @@ export class AssistantMessageComponent extends Container {
 				// Set paddingY=0 to avoid extra spacing before tool executions
 				this.contentContainer.addChild(new Markdown(content.text.trim(), 1, 0, getMarkdownTheme()));
 			} else if (content.type === "thinking" && content.thinking.trim()) {
-				// Check if there's text content after this thinking block
-				const hasTextAfter = message.content.slice(i + 1).some(c => c.type === "text" && c.text.trim());
+				// Add spacing only when another visible assistant content block follows.
+				// This avoids a superfluous blank line before separately-rendered tool execution blocks.
+				const hasVisibleContentAfter = message.content
+					.slice(i + 1)
+					.some(c => (c.type === "text" && c.text.trim()) || (c.type === "thinking" && c.thinking.trim()));
 
 				if (this.hideThinkingBlock) {
 					// Show static "Thinking..." label when hidden
 					this.contentContainer.addChild(new Text(theme.italic(theme.fg("thinkingText", "Thinking...")), 1, 0));
-					if (hasTextAfter) {
+					if (hasVisibleContentAfter) {
 						this.contentContainer.addChild(new Spacer(1));
 					}
 				} else {
@@ -101,7 +104,9 @@ export class AssistantMessageComponent extends Container {
 							italic: true,
 						}),
 					);
-					this.contentContainer.addChild(new Spacer(1));
+					if (hasVisibleContentAfter) {
+						this.contentContainer.addChild(new Spacer(1));
+					}
 				}
 			}
 		}

package/src/modes/controllers/input-controller.ts

@@ -332,7 +332,7 @@ export class InputController {
 				this.ctx.editor.setText("");
 				return;
 			}
-			if (text === "/exit") {
+			if (text === "/quit" || text === "/exit") {
 				this.ctx.editor.setText("");
 				void this.ctx.shutdown();
 				return;

package/src/session/agent-session.ts

@@ -2884,6 +2884,12 @@ Be thorough - include exact file paths, function names, error messages, and tech
 					this.agent.replaceMessages(messages.slice(0, -1));
 				}
 
+				setTimeout(() => {
+					this.agent.continue().catch(() => {});
+				}, 100);
+			} else if (this.agent.hasQueuedMessages()) {
+				// Auto-compaction can complete while follow-up/steering/custom messages are waiting.
+				// Kick the loop so queued messages are actually delivered.
 				setTimeout(() => {
 					this.agent.continue().catch(() => {});
 				}, 100);

package/src/task/render.ts

@@ -15,6 +15,7 @@ import {
 	formatMoreItems,
 	formatStatusIcon,
 	formatTokens,
+	replaceTabs,
 	truncateToWidth,
 } from "../tools/render-utils";
 import {
@@ -300,7 +301,7 @@ function renderOutputSection(
 		const outputLines = output.trimEnd().split("\n");
 		const previewCount = expanded ? maxExpanded : maxCollapsed;
 		for (const line of outputLines.slice(0, previewCount)) {
-			lines.push(`${continuePrefix}  ${theme.fg("dim", truncateToWidth(line, 70))}`);
+			lines.push(`${continuePrefix}  ${theme.fg("dim", truncateToWidth(replaceTabs(line), 70))}`);
 		}
 
 		if (outputLines.length > previewCount) {
@@ -344,7 +345,7 @@ function renderOutputSection(
 	const outputLines = output.trimEnd().split("\n");
 	const previewCount = expanded ? maxExpanded : maxCollapsed;
 	for (const line of outputLines.slice(0, previewCount)) {
-		lines.push(`${continuePrefix}  ${theme.fg("dim", truncateToWidth(line, 70))}`);
+		lines.push(`${continuePrefix}  ${theme.fg("dim", truncateToWidth(replaceTabs(line), 70))}`);
 	}
 
 	if (outputLines.length > previewCount) {
@@ -365,10 +366,15 @@ function renderTaskSection(
 	const trimmed = task.trimEnd();
 	if (!expanded || !trimmed) return lines;
 
+	// Strip the shared <swarm_context>...</swarm_context> block — it's the same
+	// across all tasks and just adds noise when expanded.
+	const stripped = trimmed.replace(/<swarm_context>[\s\S]*?<\/swarm_context>\s*/, "").trimStart();
+	if (!stripped) return lines;
+
 	lines.push(`${continuePrefix}${theme.fg("dim", "Task")}`);
-	const taskLines = trimmed.split("\n");
+	const taskLines = stripped.split("\n");
 	for (const line of taskLines.slice(0, maxExpanded)) {
-		lines.push(`${continuePrefix}  ${theme.fg("dim", truncateToWidth(line, 70))}`);
+		lines.push(`${continuePrefix}  ${theme.fg("dim", truncateToWidth(replaceTabs(line), 70))}`);
 	}
 	if (taskLines.length > maxExpanded) {
 		lines.push(`${continuePrefix}  ${theme.fg("dim", formatMoreItems(taskLines.length - maxExpanded, "line"))}`);
@@ -454,7 +460,7 @@ export function renderCall(args: TaskParams, theme: Theme): Component {
 	if (hasContext) {
 		lines.push(` ${branch} ${theme.fg("dim", "Context")}`);
 		for (const line of context.split("\n")) {
-			const content = line ? theme.fg("muted", line) : "";
+			const content = line ? theme.fg("muted", replaceTabs(line)) : "";
 			lines.push(` ${vertical}  ${content}`);
 		}
 		const taskPrefix = showIsolated ? branch : last;
@@ -635,7 +641,7 @@ function renderReviewResult(
 			lines.push(`${continuePrefix}${theme.fg("dim", "Summary")}`);
 			const explanationLines = summary.explanation.split("\n");
 			for (const line of explanationLines) {
-				lines.push(`${continuePrefix}  ${theme.fg("dim", line)}`);
+				lines.push(`${continuePrefix}  ${theme.fg("dim", replaceTabs(line))}`);
 			}
 		} else {
 			// Preview: first sentence or ~100 chars
@@ -690,7 +696,7 @@ function renderFindings(
 			// Wrap body text
 			const bodyLines = finding.body.split("\n");
 			for (const bodyLine of bodyLines) {
-				lines.push(`${continuePrefix}${findingContinue}${theme.fg("dim", bodyLine)}`);
+				lines.push(`${continuePrefix}${findingContinue}${theme.fg("dim", replaceTabs(bodyLine))}`);
 			}
 		}
 	}

package/src/tools/ask.ts

@@ -454,18 +454,11 @@ export const askToolRenderer = {
 			const txt = result.content[0];
 			const fallback = txt?.type === "text" && txt.text ? txt.text : "";
 			const header = renderStatusLine({ icon: "warning", title: "Ask" }, uiTheme);
-			const renderedLines = [header, uiTheme.fg("dim", fallback)];
-			return {
-				render() {
-					return renderedLines;
-				},
-				invalidate() {},
-			};
+			return new Text(`${header}\n${uiTheme.fg("dim", fallback)}`, 0, 0);
 		}
 
 		// Multi-part results
 		if (details.results && details.results.length > 0) {
-			const lines: string[] = [];
 			const hasAnySelection = details.results.some(
 				r => r.customInput || (r.selectedOptions && r.selectedOptions.length > 0),
 			);
@@ -477,7 +470,7 @@ export const askToolRenderer = {
 				},
 				uiTheme,
 			);
-			lines.push(header);
+			let text = header;
 
 			for (let i = 0; i < details.results.length; i++) {
 				const r = details.results[i];
@@ -489,47 +482,29 @@ export const askToolRenderer = {
 					? uiTheme.styledSymbol("status.success", "success")
 					: uiTheme.styledSymbol("status.warning", "warning");
 
-				lines.push(
-					` ${uiTheme.fg("dim", branch)} ${statusIcon} ${uiTheme.fg("dim", `[${r.id}]`)} ${uiTheme.fg("accent", r.question)}`,
-				);
+				text += `\n ${uiTheme.fg("dim", branch)} ${statusIcon} ${uiTheme.fg("dim", `[${r.id}]`)} ${uiTheme.fg("accent", r.question)}`;
 
 				if (r.customInput) {
-					lines.push(
-						`${continuation}${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.styledSymbol("status.success", "success")} ${uiTheme.fg("toolOutput", r.customInput)}`,
-					);
+					text += `\n${continuation}${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.styledSymbol("status.success", "success")} ${uiTheme.fg("toolOutput", r.customInput)}`;
 				} else if (r.selectedOptions.length > 0) {
 					for (let j = 0; j < r.selectedOptions.length; j++) {
 						const isLast = j === r.selectedOptions.length - 1;
 						const optBranch = isLast ? uiTheme.tree.last : uiTheme.tree.branch;
-						lines.push(
-							`${continuation}${uiTheme.fg("dim", optBranch)} ${uiTheme.fg("success", uiTheme.checkbox.checked)} ${uiTheme.fg("toolOutput", r.selectedOptions[j])}`,
-						);
+						text += `\n${continuation}${uiTheme.fg("dim", optBranch)} ${uiTheme.fg("success", uiTheme.checkbox.checked)} ${uiTheme.fg("toolOutput", r.selectedOptions[j])}`;
 					}
 				} else {
-					lines.push(
-						`${continuation}${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.styledSymbol("status.warning", "warning")} ${uiTheme.fg("warning", "Cancelled")}`,
-					);
+					text += `\n${continuation}${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.styledSymbol("status.warning", "warning")} ${uiTheme.fg("warning", "Cancelled")}`;
 				}
 			}
 
-			return {
-				render() {
-					return lines;
-				},
-				invalidate() {},
-			};
+			return new Text(text, 0, 0);
 		}
 
 		// Single question result
 		if (!details.question) {
 			const txt = result.content[0];
-			const renderedLines = txt?.type === "text" && txt.text ? txt.text.split("\n") : [""];
-			return {
-				render() {
-					return renderedLines;
-				},
-				invalidate() {},
-			};
+			const fallback = txt?.type === "text" && txt.text ? txt.text : "";
+			return new Text(fallback, 0, 0);
 		}
 
 		const hasSelection = details.customInput || (details.selectedOptions && details.selectedOptions.length > 0);
@@ -552,12 +527,6 @@ export const askToolRenderer = {
 			text += `\n ${uiTheme.fg("dim", uiTheme.tree.last)} ${uiTheme.styledSymbol("status.warning", "warning")} ${uiTheme.fg("warning", "Cancelled")}`;
 		}
 
-		const renderedLines = text.split("\n");
-		return {
-			render() {
-				return renderedLines;
-			},
-			invalidate() {},
-		};
+		return new Text(text, 0, 0);
 	},
 };

package/src/tools/todo-write.ts

@@ -11,7 +11,7 @@ import type { RenderResultOptions } from "../extensibility/custom-tools/types";
 import type { Theme } from "../modes/theme/theme";
 import todoWriteDescription from "../prompts/tools/todo-write.md" with { type: "text" };
 import type { ToolSession } from "../sdk";
-import { Ellipsis, Hasher, type RenderCache, renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
+import { renderStatusLine, renderTreeList } from "../tui";
 import { PREVIEW_LIMITS } from "./render-utils";
 
 const todoWriteSchema = Type.Object({
@@ -234,39 +234,22 @@ export const todoWriteToolRenderer = {
 		);
 		if (todos.length === 0) {
 			const fallback = result.content?.find(c => c.type === "text")?.text ?? "No todos";
-			const renderedLines = [header, uiTheme.fg("dim", fallback)];
-			return {
-				render() {
-					return renderedLines;
-				},
-				invalidate() {},
-			};
+			return new Text(`${header}\n${uiTheme.fg("dim", fallback)}`, 0, 0);
 		}
-		let cached: RenderCache | undefined;
 
-		return {
-			render(width) {
-				const { expanded } = options;
-				const key = new Hasher().bool(expanded).u32(width).digest();
-				if (cached?.key === key) return cached.lines;
-				const treeLines = renderTreeList(
-					{
-						items: todos,
-						expanded,
-						maxCollapsed: PREVIEW_LIMITS.COLLAPSED_ITEMS,
-						itemType: "todo",
-						renderItem: todo => formatTodoLine(todo, uiTheme, ""),
-					},
-					uiTheme,
-				);
-				const lines = [header, ...treeLines].map(l => truncateToWidth(l, width, Ellipsis.Omit));
-				cached = { key, lines };
-				return lines;
-			},
-			invalidate() {
-				cached = undefined;
+		const { expanded } = options;
+		const treeLines = renderTreeList(
+			{
+				items: todos,
+				expanded,
+				maxCollapsed: PREVIEW_LIMITS.COLLAPSED_ITEMS,
+				itemType: "todo",
+				renderItem: todo => formatTodoLine(todo, uiTheme, ""),
 			},
-		};
+			uiTheme,
+		);
+		const text = [header, ...treeLines].join("\n");
+		return new Text(text, 0, 0);
 	},
 	mergeCallAndResult: true,
 };