@oh-my-pi/pi-coding-agent 16.5.0 → 16.5.2

package/src/session/exit-diagnostics.ts

@@ -1,4 +1,5 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import type { AssistantMessage } from "@oh-my-pi/pi-ai";
 import type { SessionEntry } from "./session-entries";
 
 export const TOOL_EXECUTION_START_CUSTOM_TYPE = "tool_execution_start";
@@ -53,10 +54,117 @@ interface ToolCallContent {
 	arguments?: unknown;
 }
 
+export interface AssistantModelMetadata {
+	api: AssistantMessage["api"];
+	provider: string;
+	model: string;
+}
+
 function isObject(value: unknown): value is Record<string, unknown> {
 	if (typeof value !== "object") return false;
 	return value !== null;
 }
+function isPendingToolCallDiagnostic(value: unknown): value is PendingToolCallDiagnostic {
+	if (!isObject(value) || typeof value.toolName !== "string") return false;
+	if ("toolCallId" in value && typeof value.toolCallId !== "string") return false;
+	if ("intent" in value && typeof value.intent !== "string") return false;
+	if ("assistantTimestamp" in value && typeof value.assistantTimestamp !== "number") return false;
+	if ("startedAt" in value && typeof value.startedAt !== "string") return false;
+	return true;
+}
+
+function readPendingToolCalls(value: unknown): PendingToolCallDiagnostic[] | undefined {
+	if (!Array.isArray(value) || !value.every(isPendingToolCallDiagnostic)) return undefined;
+	return value;
+}
+
+function readSessionExit(entry: SessionEntry): SessionExitData | undefined {
+	if (entry.type !== "custom" || entry.customType !== SESSION_EXIT_CUSTOM_TYPE || !isObject(entry.data)) {
+		return undefined;
+	}
+	const { reason, kind, recordedAt } = entry.data;
+	if (
+		typeof reason !== "string" ||
+		(kind !== "normal" && kind !== "signal" && kind !== "fatal" && kind !== "process_exit") ||
+		typeof recordedAt !== "string"
+	) {
+		return undefined;
+	}
+	return {
+		reason,
+		kind,
+		recordedAt,
+		pendingToolCalls: readPendingToolCalls(entry.data.pendingToolCalls),
+	};
+}
+
+/**
+ * createInterruptedTurnAbortMessage returns a terminal assistant record when
+ * the latest persisted process exit follows a non-terminal conversation tail.
+ */
+export function createInterruptedTurnAbortMessage(
+	entries: readonly SessionEntry[],
+	fallbackModel?: AssistantModelMetadata,
+): AssistantMessage | undefined {
+	let exitIndex = -1;
+	let exit: SessionExitData | undefined;
+	for (let index = entries.length - 1; index >= 0; index--) {
+		const candidate = readSessionExit(entries[index]!);
+		if (!candidate) continue;
+		exitIndex = index;
+		exit = candidate;
+		break;
+	}
+	if (!exit || (exit.kind === "normal" && !exit.pendingToolCalls?.length)) return undefined;
+
+	let tailIndex = -1;
+	let tail: AgentMessage | undefined;
+	for (let index = entries.length - 1; index >= 0; index--) {
+		const entry = entries[index]!;
+		if (entry.type !== "message") continue;
+		tailIndex = index;
+		tail = entry.message;
+		break;
+	}
+	if (!tail || tailIndex > exitIndex) return undefined;
+	if (tail.role === "assistant" && !tail.content.some(isToolCallContent)) return undefined;
+
+	let previousAssistant: AssistantMessage | undefined;
+	for (let index = tailIndex; index >= 0; index--) {
+		const entry = entries[index]!;
+		if (entry.type !== "message" || entry.message.role !== "assistant") continue;
+		previousAssistant = entry.message;
+		break;
+	}
+	if (
+		tail.role === "toolResult" &&
+		(previousAssistant?.stopReason === "error" || previousAssistant?.stopReason === "aborted")
+	) {
+		return undefined;
+	}
+	const model = previousAssistant ?? fallbackModel;
+	if (!model) return undefined;
+
+	const recordedAt = Date.parse(exit.recordedAt);
+	return {
+		role: "assistant",
+		content: [],
+		api: model.api,
+		provider: model.provider,
+		model: model.model,
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: "aborted",
+		errorMessage: "Previous OMP process exited before completing the turn.",
+		timestamp: Number.isFinite(recordedAt) ? recordedAt : Date.now(),
+	};
+}
 
 function isToolCallContent(value: unknown): value is ToolCallContent {
 	if (!isObject(value)) return false;

package/src/session/messages.test.ts

@@ -5,6 +5,7 @@ import {
 	type CustomMessage,
 	convertToLlm,
 	INTERRUPTED_THINKING_MESSAGE_TYPE,
+	replaceLlmImagesWithText,
 	SKILL_PROMPT_MESSAGE_TYPE,
 	type SkillPromptDetails,
 } from "./messages";
@@ -123,3 +124,68 @@ describe("convertToLlm", () => {
 		]);
 	});
 });
+
+describe("replaceLlmImagesWithText", () => {
+	it("replaces image blocks in user, developer, and tool-result messages with the placeholder", () => {
+		const converted = convertToLlm([
+			{
+				role: "user",
+				content: [
+					{ type: "text", text: "look" },
+					{ type: "image", data: "aaaa", mimeType: "image/png" },
+				],
+				attribution: "user",
+				timestamp: 1,
+			},
+			{
+				role: "toolResult",
+				toolCallId: "c1",
+				toolName: "inspect_image",
+				content: [{ type: "image", data: "bbbb", mimeType: "image/png" }],
+				isError: false,
+				timestamp: 2,
+			},
+		]);
+
+		const scrubbed = replaceLlmImagesWithText(converted, "[image omitted]");
+
+		expect(scrubbed).not.toBe(converted);
+		const types = scrubbed.flatMap(m => (Array.isArray(m.content) ? m.content.map(b => b.type) : []));
+		expect(types).not.toContain("image");
+		const user = scrubbed.find(m => m.role === "user");
+		expect(Array.isArray(user?.content) && user.content.map(b => (b.type === "text" ? b.text : b.type))).toEqual([
+			"look",
+			"[image omitted]",
+		]);
+		const toolResult = scrubbed.find(m => m.role === "toolResult");
+		expect(Array.isArray(toolResult?.content) && toolResult.content).toEqual([
+			{ type: "text", text: "[image omitted]" },
+		]);
+	});
+
+	it("collapses consecutive image blocks into a single placeholder", () => {
+		const converted = convertToLlm([
+			{
+				role: "user",
+				content: [
+					{ type: "image", data: "aaaa", mimeType: "image/png" },
+					{ type: "image", data: "bbbb", mimeType: "image/png" },
+				],
+				attribution: "user",
+				timestamp: 1,
+			},
+		]);
+
+		const scrubbed = replaceLlmImagesWithText(converted, "[image omitted]");
+		const user = scrubbed.find(m => m.role === "user");
+		expect(Array.isArray(user?.content) && user.content).toEqual([{ type: "text", text: "[image omitted]" }]);
+	});
+
+	it("returns the same array reference when there are no image blocks", () => {
+		const converted = convertToLlm([
+			{ role: "user", content: [{ type: "text", text: "hi" }], attribution: "user", timestamp: 1 },
+		]);
+
+		expect(replaceLlmImagesWithText(converted, "[image omitted]")).toBe(converted);
+	});
+});

package/src/session/messages.ts

@@ -512,6 +512,43 @@ export function stripImagesFromMessage(message: AgentMessage): number {
 	}
 }
 
+/**
+ * Replace every `ImageContent` block in already-converted LLM {@link Message}s
+ * with a text placeholder, returning a new array only when something changed.
+ *
+ * Unlike {@link stripImagesFromMessage} (which mutates persisted `AgentMessage`s
+ * in place), this operates on the ephemeral provider-request view produced by
+ * {@link convertToLlm}, so history on disk keeps its images while the outbound
+ * request is scrubbed. Used to keep image blocks off the wire when the active
+ * model has no vision support (or `images.blockImages` is set) — e.g. after
+ * switching from a vision model to a text-only one mid-session (#5400).
+ *
+ * Consecutive placeholder texts collapse into one so a message that was nothing
+ * but images does not balloon into a run of identical notes.
+ */
+export function replaceLlmImagesWithText(messages: Message[], placeholder: string): Message[] {
+	let out: Message[] | undefined;
+	for (let i = 0; i < messages.length; i++) {
+		const msg = messages[i];
+		if (msg.role !== "user" && msg.role !== "developer" && msg.role !== "toolResult") continue;
+		const content = msg.content;
+		if (!Array.isArray(content) || !content.some(part => part.type === "image")) continue;
+		const replaced: (TextContent | ImageContent)[] = [];
+		for (const part of content) {
+			if (part.type !== "image") {
+				replaced.push(part);
+				continue;
+			}
+			const prev = replaced[replaced.length - 1];
+			if (prev?.type === "text" && prev.text === placeholder) continue;
+			replaced.push({ type: "text", text: placeholder });
+		}
+		if (out === undefined) out = messages.slice();
+		out[i] = { ...msg, content: replaced } as Message;
+	}
+	return out ?? messages;
+}
+
 /**
  * Message type for bash executions via the ! command.
  */

package/src/session/streaming-output.ts

@@ -735,6 +735,7 @@ export class OutputSink {
 	#truncated = false;
 	#lastChunkTime = 0;
 	#pendingChunk = "";
+	#pendingChunkTimer: Timer | undefined;
 
 	// Per-line column cap streaming state (persists across `push` calls so a
 	// long line split across chunks still trips the same trigger).
@@ -806,20 +807,18 @@ export class OutputSink {
 	push(chunk: string): void {
 		chunk = sanitizeWithOptionalSixelPassthrough(chunk, sanitizeText);
 
-		// Throttled onChunk: coalesce chunks arriving inside the throttle window
-		// and flush the buffered concatenation on the next eligible tick (plus a
-		// final flush in dump()) so the preview never has silent gaps.
+		// Throttled onChunk: coalesce chunks arriving inside the throttle window.
+		// A timer flushes quiet tails at the throttle boundary; dump() catches a
+		// final pending chunk when the process exits before that timer fires.
 		// Live preview gets the raw (pre-cap) chunk so the TUI never lags behind
 		// what reached the sink — the column cap is for the persisted LLM view.
 		if (this.#onChunk) {
 			const now = Date.now();
 			if (now - this.#lastChunkTime >= this.#chunkThrottleMs) {
-				this.#lastChunkTime = now;
-				const merged = this.#pendingChunk + chunk;
-				this.#pendingChunk = "";
-				this.#onChunk(merged);
+				this.#emitPendingChunkWith(chunk, now);
 			} else {
 				this.#pendingChunk += chunk;
+				this.#schedulePendingChunkFlush();
 			}
 		}
 
@@ -1121,6 +1120,7 @@ export class OutputSink {
 	 * branch in `dump()` against stale totals.
 	 */
 	replace(text: string): void {
+		this.#clearPendingChunkTimer();
 		this.#buffer = text;
 		this.#bufferBytes = Buffer.byteLength(text, "utf-8");
 		this.#head = "";
@@ -1138,6 +1138,38 @@ export class OutputSink {
 		this.#pendingChunk = "";
 	}
 
+	#clearPendingChunkTimer(): void {
+		if (!this.#pendingChunkTimer) return;
+		clearTimeout(this.#pendingChunkTimer);
+		this.#pendingChunkTimer = undefined;
+	}
+
+	#emitPendingChunkWith(chunk: string, now: number): void {
+		this.#clearPendingChunkTimer();
+		this.#lastChunkTime = now;
+		const merged = this.#pendingChunk + chunk;
+		this.#pendingChunk = "";
+		this.#onChunk?.(merged);
+	}
+
+	#flushPendingChunk(): void {
+		if (this.#pendingChunk.length === 0) {
+			this.#clearPendingChunkTimer();
+			return;
+		}
+		this.#emitPendingChunkWith("", Date.now());
+	}
+
+	#schedulePendingChunkFlush(): void {
+		if (this.#chunkThrottleMs <= 0 || this.#pendingChunkTimer) return;
+		const elapsed = Date.now() - this.#lastChunkTime;
+		const delay = Math.max(0, this.#chunkThrottleMs - elapsed);
+		this.#pendingChunkTimer = setTimeout(() => {
+			this.#pendingChunkTimer = undefined;
+			this.#flushPendingChunk();
+		}, delay);
+	}
+
 	/**
 	 * Replay the rolling tail ring back into the artifact sink. When bytes
 	 * were actually dropped from the middle (the head budget was exhausted
@@ -1179,11 +1211,7 @@ export class OutputSink {
 
 		// Flush any chunk still held back by the throttle so the live preview
 		// ends with the complete stream.
-		if (this.#onChunk && this.#pendingChunk.length > 0) {
-			const pending = this.#pendingChunk;
-			this.#pendingChunk = "";
-			this.#onChunk(pending);
-		}
+		this.#flushPendingChunk();
 		const totalLines = this.#sawData ? this.#totalLines + 1 : 0;
 
 		if (this.#file) {

package/src/slash-commands/helpers/active-oauth-account.ts

@@ -9,6 +9,17 @@ function normalizeIdentityValue(value: unknown): string | undefined {
  * True when a single usage-limit column belongs to the given OAuth identity.
  *
  * Single definition of the matching rules for both `/usage` renderers:
+ * - `orgId`     ↔ report metadata `orgId` — a GATE that QUALIFIES the base
+ *   identity, never a replacement for it. Mismatched org presence or
+ *   different orgs never match: two subscriptions (orgs) can share one
+ *   email, so an org-scoped identity matches only its own org's reports and
+ *   an org-less legacy identity never claims an org-attributed report via
+ *   the shared email. A SHARED org still requires the base-identity match
+ *   below — Anthropic Team seats have per-user pools yet share the org id
+ *   in report metadata. Only an org-only identity (no base identifiers
+ *   recovered at all) matches on the org alone. When neither side carries
+ *   an org, the base fallback applies unchanged (providers without orgs
+ *   keep their former behavior).
  * - `accountId` ↔ report metadata `accountId`/`account_id` or `limit.scope.accountId`
  * - `email`     ↔ report metadata `email`
  * - `projectId` ↔ report metadata `projectId` or `limit.scope.projectId`
@@ -22,14 +33,23 @@ export function limitMatchesActiveAccount(
 	if (!identity) return false;
 	const metadata = report.metadata ?? {};
 	const activeAccountId = normalizeIdentityValue(identity.accountId);
+	const activeEmail = normalizeIdentityValue(identity.email);
+	const activeProjectId = normalizeIdentityValue(identity.projectId);
+	const activeOrgId = normalizeIdentityValue(identity.orgId);
+	const reportOrgId = normalizeIdentityValue(metadata.orgId);
+	// Org gate (see doc comment above): different/mismatched-presence orgs
+	// never match; a shared org falls through to the base checks unless the
+	// identity is org-only.
+	if (activeOrgId || reportOrgId) {
+		if (activeOrgId !== reportOrgId) return false;
+		if (!activeAccountId && !activeEmail && !activeProjectId) return true;
+	}
 	if (activeAccountId) {
 		const reportAccountId = normalizeIdentityValue(metadata.accountId) ?? normalizeIdentityValue(metadata.account_id);
 		if (reportAccountId === activeAccountId) return true;
 		if (normalizeIdentityValue(limit.scope.accountId) === activeAccountId) return true;
 	}
-	const activeEmail = normalizeIdentityValue(identity.email);
 	if (activeEmail && normalizeIdentityValue(metadata.email) === activeEmail) return true;
-	const activeProjectId = normalizeIdentityValue(identity.projectId);
 	if (activeProjectId) {
 		if (normalizeIdentityValue(metadata.projectId) === activeProjectId) return true;
 		if (normalizeIdentityValue(limit.scope.projectId) === activeProjectId) return true;

package/src/slash-commands/helpers/logout.ts

@@ -22,13 +22,16 @@ function nonEmpty(value: string | undefined): string | undefined {
 function oauthLabel(row: StoredAuthCredential): string {
 	const credential = row.credential;
 	if (credential.type !== "oauth") return `API key #${row.id}`;
-	return (
+	const base =
 		nonEmpty(credential.email) ??
 		nonEmpty(credential.accountId) ??
 		nonEmpty(credential.projectId) ??
 		nonEmpty(credential.enterpriseUrl) ??
-		`OAuth credential #${row.id}`
-	);
+		`OAuth credential #${row.id}`;
+	// Two subscriptions (orgs) can share one email — the org is the only
+	// user-visible way to tell which row a logout will remove.
+	const org = nonEmpty(credential.orgName) ?? nonEmpty(credential.orgId);
+	return org && org !== base ? `${base} (${org})` : base;
 }
 
 function oauthDetail(row: StoredAuthCredential, label: string): string {
@@ -53,6 +56,23 @@ function oauthMatchesActiveIdentity(
 ): boolean {
 	if (!activeIdentity || row.credential.type !== "oauth") return false;
 	const credential = row.credential;
+	// The org GATES the base identity rather than replacing it: mismatched org
+	// presence or different orgs never match — an org-scoped active session
+	// must not preselect the bare-email legacy row, and a bare-email active
+	// row must not mark org-scoped siblings active via the shared email. A
+	// SHARED org still requires the base-identity match below: two Team seats
+	// share one orgId yet own distinct rows. Only an org-only active identity
+	// (no base identifiers recovered at all) matches on the org alone.
+	if (activeIdentity.orgId !== undefined || credential.orgId !== undefined) {
+		if (credential.orgId !== activeIdentity.orgId) return false;
+		if (
+			activeIdentity.accountId === undefined &&
+			activeIdentity.email === undefined &&
+			activeIdentity.projectId === undefined
+		) {
+			return true;
+		}
+	}
 	return (
 		(activeIdentity.accountId !== undefined && credential.accountId === activeIdentity.accountId) ||
 		(activeIdentity.email !== undefined && credential.email === activeIdentity.email) ||

package/src/slash-commands/helpers/usage-report.ts

@@ -25,14 +25,26 @@ function formatUsageAmount(limit: UsageLimit): string {
 }
 
 function formatUsageReportAccount(report: UsageReport, limit: UsageLimit, index: number): string {
+	const metaOrgName = report.metadata?.orgName;
+	const metaOrgId = report.metadata?.orgId;
+	const org =
+		typeof metaOrgName === "string" && metaOrgName
+			? metaOrgName
+			: typeof metaOrgId === "string" && metaOrgId
+				? metaOrgId
+				: undefined;
+	// Two subscriptions (orgs) can share one email — suffix the org so the rows
+	// are tellable apart.
 	const email = report.metadata?.email;
-	if (typeof email === "string" && email) return email;
+	if (typeof email === "string" && email) return org ? `${email} (${org})` : email;
 	// Guard metadata values for truthiness before using, then fall back to scope.
 	// ?? won't help here: empty string is not null/undefined, so it would suppress
 	// a valid scoped fallback (e.g. metadata.accountId="" hides limit.scope.accountId).
 	const metaAccountId = report.metadata?.accountId;
 	const accountId = typeof metaAccountId === "string" && metaAccountId ? metaAccountId : limit.scope.accountId;
-	if (typeof accountId === "string" && accountId) return accountId;
+	if (typeof accountId === "string" && accountId) {
+		return org && org !== accountId ? `${accountId} (${org})` : accountId;
+	}
 	const metaProjectId = report.metadata?.projectId;
 	const projectId = typeof metaProjectId === "string" && metaProjectId ? metaProjectId : limit.scope.projectId;
 	if (typeof projectId === "string" && projectId) return projectId;

package/src/subprocess/worker-client.ts

@@ -159,6 +159,12 @@ export function createWorkerSubprocess<Outbound>(options: {
 	spawnCommand: WorkerSpawnCommand;
 	env: Record<string, string>;
 	exitLabel: string;
+	/** Start the child as a new process-group/session leader where Bun supports it. */
+	detached?: boolean;
+	/** Treat exit code 0 as unexpected; eval cells can call process.exit(0). */
+	reportCleanExit?: boolean;
+	/** Whether an idle worker should stop keeping the parent event loop alive. */
+	unref?: boolean;
 }): SpawnedSubprocess<Outbound> {
 	const inbound = new Set<(message: Outbound) => void>();
 	const errors = new Set<(error: Error) => void>();
@@ -175,6 +181,7 @@ export function createWorkerSubprocess<Outbound>(options: {
 	const proc = Bun.spawn({
 		cmd: options.spawnCommand.cmd,
 		cwd: options.spawnCommand.cwd,
+		detached: options.detached,
 		env: options.env,
 		stdin: "ignore",
 		stdout: "ignore",
@@ -186,7 +193,7 @@ export function createWorkerSubprocess<Outbound>(options: {
 		},
 		onExit(_proc, exitCode, signalCode) {
 			startStderrDrain();
-			if (exitCode === 0) return;
+			if (exitCode === 0 && !options.reportCleanExit) return;
 			// Swallow only the expected SIGKILL from `terminate()`; every other
 			// signal exit (SIGSEGV from a native fault, OOM SIGKILL, operator
 			// `kill -9`) is a real worker death that must fault in-flight
@@ -206,7 +213,7 @@ export function createWorkerSubprocess<Outbound>(options: {
 	// Don't keep the parent event loop alive on an idle worker; the dispose
 	// path calls `terminate()` explicitly. Bun's test runner starves IPC for
 	// unref'd subprocesses, so keep it referenced only under tests.
-	if (!isBunTestRuntime()) proc.unref();
+	if (!isBunTestRuntime() && options.unref !== false) proc.unref();
 	return { proc, inbound, errors, intentionalExit, stderrDrained: stderrDrained.promise };
 }
 

package/src/system-prompt.test.ts

@@ -198,3 +198,39 @@ describe.skipIf(process.platform !== "linux")("system prompt CPU model", () => {
 		}
 	});
 });
+
+describe("non-Linux system prompt CPU model", () => {
+	it("includes the model returned by os.cpus", async () => {
+		const originalPlatform = process.platform;
+		Object.defineProperty(process, "platform", { value: "darwin" });
+		const cpus = spyOn(os, "cpus").mockImplementation(() => [
+			{
+				model: "Synthetic Non-Linux CPU",
+				speed: 0,
+				times: { user: 0, nice: 0, sys: 0, idle: 0, irq: 0 },
+			},
+		]);
+		try {
+			const systemPrompt = await buildSystemPrompt({
+				resolvedCustomPrompt: "Base prompt",
+				contextFiles: [],
+				skills: [],
+				rules: [],
+				workspaceTree: {
+					rootPath: import.meta.dir,
+					rendered: "",
+					truncated: false,
+					totalLines: 0,
+					agentsMdFiles: [],
+				},
+				activeRepoContext: null,
+			});
+
+			expect(cpus).toHaveBeenCalledTimes(1);
+			expect(systemPrompt.systemPrompt.join("\n")).toContain("- CPU: Synthetic Non-Linux CPU");
+		} finally {
+			cpus.mockRestore();
+			Object.defineProperty(process, "platform", { value: originalPlatform });
+		}
+	});
+});

package/src/system-prompt.ts

@@ -254,7 +254,7 @@ async function getCachedGpu(): Promise<string | undefined> {
 }
 
 async function getCpuModel(): Promise<string | undefined> {
-	if (process.platform !== "linux") return undefined;
+	if (process.platform !== "linux") return os.cpus()[0]?.model;
 	try {
 		const cpuInfo = await Bun.file("/proc/cpuinfo").text();
 		const match = /^model name\s*:\s*(.+)$/m.exec(cpuInfo);

package/src/task/executor.ts

@@ -2325,14 +2325,22 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				thinkingLevel: resolvedThinkingLevel,
 				explicitThinkingLevel,
 				authFallbackUsed,
+				warning: modelResolutionWarning,
 			} = await awaitAbortable(
 				resolveModelOverrideWithAuthFallback(
 					modelPatterns,
 					options.parentActiveModelPattern,
 					modelRegistry,
 					settings,
+					id,
 				),
 			);
+			if (modelResolutionWarning) {
+				logger.warn("Subagent model resolution warning", {
+					warning: modelResolutionWarning,
+					requested: modelPatterns,
+				});
+			}
 			if (authFallbackUsed && model) {
 				logger.warn("Subagent model has no working credentials; falling back to parent session model", {
 					requested: modelPatterns,

package/src/task/render.test.ts

@@ -184,6 +184,42 @@ describe("task live progress rendering", () => {
 		expect(collapsedText).not.toContain("line 1");
 		expect(collapsedText).not.toContain("raw output:");
 	});
+	it("sanitizes control sequences from expanded subagent recent output", () => {
+		setViewportRows(40);
+		const progress = makeProgress(["safe after \x1b[2Kclear", "raw\rprompt"]);
+
+		const text = renderProgressText(progress, true, uiTheme);
+
+		expect(text).toContain("safe after clear");
+		expect(text).toContain("rawprompt");
+		expect(text).not.toContain("\x1b[2K");
+		expect(text).not.toContain("\r");
+	});
+	it("sanitizes control sequences from finalized subagent results", () => {
+		const output = JSON.stringify({ "\x1b[2Kkey": "safe value" });
+		const details: TaskToolDetails = {
+			projectAgentsDir: null,
+			results: [
+				makeSingleResult(0, {
+					id: "Final\x1b[2KAgent",
+					description: "description\rtext",
+					aborted: true,
+					abortReason: "aborted \x1b[2Kreason",
+					output,
+				}),
+			],
+			totalDurationMs: 1,
+		};
+
+		const text = renderResultText(details, true, uiTheme);
+
+		expect(text).toContain("FinalAgent");
+		expect(text).toContain("descriptiontext");
+		expect(text).toContain("aborted reason");
+		expect(text).toContain("key");
+		expect(text).not.toContain("\x1b[2K");
+		expect(text).not.toContain("\r");
+	});
 
 	it("caps collapsed nested task progress at four rows plus an elision line", () => {
 		setViewportRows(40);