@oh-my-pi/pi-coding-agent 17.1.7 → 17.2.0

package/src/cleanse/progress.ts

@@ -0,0 +1,50 @@
+const BAR_WIDTH = 16;
+
+/** Minimal output contract used by the interactive cleanse progress reporter. */
+export interface CleanseProgressOutput {
+	isTTY?: boolean;
+	write(text: string): boolean;
+}
+
+/** Renders completed repair workers on one transient terminal line. */
+export interface CleanseProgressReporter {
+	readonly interactive: boolean;
+	start(total: number): void;
+	complete(): void;
+	finish(): void;
+}
+
+/** Create the TTY-only worker completion reporter used by `omp cleanse`. */
+export function createCleanseProgressReporter(output: CleanseProgressOutput = process.stdout): CleanseProgressReporter {
+	const interactive = output.isTTY === true;
+	let total = 0;
+	let completed = 0;
+	let rendered = false;
+
+	const render = (): void => {
+		if (!interactive || total === 0) return;
+		const ratio = Math.min(completed / total, 1);
+		const filled = Math.round(ratio * BAR_WIDTH);
+		const bar = `${"█".repeat(filled)}${"░".repeat(BAR_WIDTH - filled)}`;
+		output.write(`\rRepairing [${bar}] ${completed}/${total}\x1b[K`);
+		rendered = true;
+	};
+
+	return {
+		interactive,
+		start(nextTotal) {
+			total = Math.max(nextTotal, 0);
+			completed = 0;
+			render();
+		},
+		complete() {
+			completed = Math.min(completed + 1, total);
+			render();
+		},
+		finish() {
+			if (!rendered) return;
+			output.write("\n");
+			rendered = false;
+		},
+	};
+}

package/src/cleanse/prompts/assignment.md

@@ -0,0 +1,47 @@
+<critical>
+- You MUST fix every assigned diagnostic at its root cause.
+- You MUST stay inside the write scope below.
+- You NEVER suppress valid diagnostics to make checks pass.
+- You NEVER delegate or spawn another agent.
+- You NEVER run project-wide checks or formatters; the orchestrator reruns them.
+</critical>
+
+# Assignment
+
+Repair wave {{wave}}, worker {{worker}}.
+
+## Write scope
+
+{{write_scope}}
+
+Read related code freely. Project-level diagnostics MAY require the smallest necessary edit outside named files; use `hub` before touching a peer-owned file.
+
+## Diagnostics
+
+{{diagnostics}}
+
+## Checker commands
+
+{{checker_commands}}
+
+## Concurrent peer ownership
+
+{{peer_assignments}}
+
+<workflow>
+1. Inspect every assigned location and its local context.
+2. Fix causes, not emitted text or checker configuration.
+3. Preserve behavior unless a diagnostic proves it wrong.
+4. Run only targeted checks for assigned files when available.
+5. Re-read changed sections and resolve every assigned item.
+</workflow>
+
+<completeness>
+- Done means every assigned diagnostic has a concrete fix.
+- Blocked items MUST name the missing prerequisite in the final result.
+- Final output MUST list changed files and unresolved items.
+</completeness>
+
+<critical>
+You MUST leave peer-owned files untouched and complete the full assignment.
+</critical>

package/src/cleanse/types.ts

@@ -0,0 +1,72 @@
+/** Severity normalized across checker-specific output formats. */
+export type CleanseSeverity = "error" | "warning" | "info";
+
+/** One actionable problem reported by a project checker. */
+export interface CleanseDiagnostic {
+	checker: string;
+	file?: string;
+	line?: number;
+	column?: number;
+	endLine?: number;
+	endColumn?: number;
+	code?: string;
+	severity: CleanseSeverity;
+	message: string;
+	suggestion?: string;
+}
+
+/** Result metadata for one checker invocation. */
+export interface CleanseCheckResult {
+	id: string;
+	label: string;
+	language: string;
+	cwd: string;
+	command: string;
+	exitCode: number | null;
+	diagnostics: CleanseDiagnostic[];
+}
+
+/** Checker discovery result omitted because its required executable was unavailable. */
+export interface SkippedCleanseCheck {
+	label: string;
+	language: string;
+	reason: string;
+}
+
+/** Aggregate diagnostics from every checker selected for a project. */
+export interface CleanseDiagnosticReport {
+	checks: CleanseCheckResult[];
+	diagnostics: CleanseDiagnostic[];
+	skipped: SkippedCleanseCheck[];
+}
+
+/** All diagnostics attached to one file, which scheduling never splits across agents. */
+export interface CleanseFileIssues {
+	file?: string;
+	diagnostics: CleanseDiagnostic[];
+	weight: number;
+}
+
+/** One weighted, file-disjoint workload handed to a subagent. */
+export interface CleanseAssignment {
+	index: number;
+	groups: CleanseFileIssues[];
+	weight: number;
+}
+
+/** Settled result from one cleanse subagent. */
+export interface CleanseAgentOutcome {
+	name: string;
+	success: boolean;
+	output: string;
+	error?: string;
+	resolvedModel?: string;
+}
+
+/** Final state after one bounded repair wave and verification pass. */
+export interface CleanseLoopResult {
+	status: "clean" | "stalled" | "cancelled";
+	waves: number;
+	report: CleanseDiagnosticReport;
+	outcomes: CleanseAgentOutcome[];
+}

package/src/cli/args.ts

@@ -44,6 +44,8 @@ export interface Args {
 	advisor?: boolean;
 	continue?: boolean;
 	resume?: string | true;
+	fromClaude?: boolean;
+	fromCodex?: boolean;
 	help?: boolean;
 	version?: boolean;
 	mode?: Mode;
@@ -227,6 +229,10 @@ export function parseArgs(inputArgs: string[], extensionFlags?: Map<string, { ty
 			result.alias = arg.slice("--alias=".length);
 		} else if (arg === "--continue" || arg === "-c") {
 			result.continue = true;
+		} else if (arg === "--from-claude") {
+			result.fromClaude = true;
+		} else if (arg === "--from-codex") {
+			result.fromCodex = true;
 		} else if (arg === "--no-session") {
 			result.noSession = true;
 		} else if (arg === "--no-tools") {

package/src/cli/flag-tables.ts

@@ -290,6 +290,8 @@ export const VALUELESS_FLAGS: ReadonlySet<string> = new Set([
 	"--version",
 	"--allow-home",
 	"--continue",
+	"--from-claude",
+	"--from-codex",
 	"--no-session",
 	"--no-tools",
 	"--no-lsp",

package/src/cli/gallery-fixtures/fs.ts

@@ -1,5 +1,6 @@
 // biome-ignore-all lint/suspicious/noTemplateCurlyInString: sample source-code strings (read fixtures) intentionally contain literal ${...}.
 // Gallery fixtures for the filesystem tools (read, write, glob).
+import type { Usage } from "@oh-my-pi/pi-ai";
 import { ReadToolGroupComponent } from "../../modes/components/read-tool-group";
 import type { GalleryFixture, GalleryFixtureState, GalleryResult } from "./types";
 
@@ -47,6 +48,15 @@ const groupedReadDelimitedPath = groupedReadTargets.join(",");
 const groupedReadRepeatedFile = "packages/coding-agent/src/task/render.ts";
 const groupedReadRepeatedRanges = `${groupedReadRepeatedFile}:507-605,1070-1194,1210-1240,1270-1274`;
 
+const GROUPED_READ_USAGE: Usage = {
+	input: 2400,
+	output: 113,
+	cacheRead: 103_000,
+	cacheWrite: 0,
+	totalTokens: 105_513,
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+
 function textResult(text: string, details?: unknown, isError?: boolean): GalleryResult {
 	return { content: [{ type: "text", text }], details, isError };
 }
@@ -81,6 +91,13 @@ function renderReadGroupFixtureState(state: GalleryFixtureState, width: number,
 		false,
 		"read-delimited",
 	);
+	component.attachUsage(
+		["read-delimited"],
+		GROUPED_READ_USAGE,
+		5300,
+		2200,
+		new Date(2026, 6, 28, 21, 5, 47).getTime(),
+	);
 
 	if (state === "error") {
 		component.updateResult(
@@ -88,10 +105,18 @@ function renderReadGroupFixtureState(state: GalleryFixtureState, width: number,
 			false,
 			"read-ranges",
 		);
+		component.attachUsage(
+			["read-ranges"],
+			GROUPED_READ_USAGE,
+			4700,
+			1900,
+			new Date(2026, 6, 28, 21, 5, 52).getTime(),
+		);
 		return component.render(width);
 	}
 
 	component.updateResult(textResult("Read four render.ts ranges."), false, "read-ranges");
+	component.attachUsage(["read-ranges"], GROUPED_READ_USAGE, 4700, 1900, new Date(2026, 6, 28, 21, 5, 52).getTime());
 	return component.render(width);
 }
 

package/src/cli/session-picker.ts

@@ -6,16 +6,26 @@ import type { SessionInfo } from "../session/session-listing";
 import { SessionManager } from "../session/session-manager";
 import { FileSessionStorage } from "../session/session-storage";
 
+/** Presentation and capability controls for the standalone session picker. */
+export interface SessionPickerOptions {
+	allSessions?: SessionInfo[];
+	title?: string;
+	scopeLabel?: string | false;
+	showCwd?: boolean;
+	allowDelete?: boolean;
+	allowGlobalScope?: boolean;
+	historySearch?: boolean;
+}
+
 /**
  * Show the TUI session selector and return the selected session, or null if
- * cancelled. Rendered as a fullscreen overlay on the terminal's alternate
- * screen, so the list scrolls and rows are clickable with the mouse. Tab
- * toggles between current-folder and all-projects scope; the all-projects list
- * is loaded lazily via `SessionManager.listAll`.
+ * cancelled. The default OMP picker supports deletion, transcript-history
+ * search, and an all-projects scope; foreign import pickers disable those
+ * source-owned capabilities.
  */
 export async function selectSession(
 	sessions: SessionInfo[],
-	options?: { allSessions?: SessionInfo[] },
+	options: SessionPickerOptions = {},
 ): Promise<SessionInfo | null> {
 	const { promise, resolve } = Promise.withResolvers<SessionInfo | null>();
 	const ui = new TUI(new ProcessTerminal());
@@ -26,11 +36,13 @@ export async function selectSession(
 	// session-list prefix never sees. Best-effort: a missing/locked history.db
 	// must not break the picker.
 	let historyMatcher: ((query: string) => string[]) | undefined;
-	try {
-		const history = HistoryStorage.open();
-		historyMatcher = (query: string) => history.matchingSessionIds(query);
-	} catch (error) {
-		logger.warn("History storage unavailable for session ranking", { error: String(error) });
+	if (options.historySearch !== false) {
+		try {
+			const history = HistoryStorage.open();
+			historyMatcher = (query: string) => history.matchingSessionIds(query);
+		} catch (error) {
+			logger.warn("History storage unavailable for session ranking", { error: String(error) });
+		}
 	}
 
 	const showSelector = () => {
@@ -58,16 +70,21 @@ export async function selectSession(
 				}
 			},
 			{
-				onDelete: async (session: SessionInfo) => {
-					// Delete handler - SessionList will show confirmation internally
-					await storage.deleteSessionWithArtifacts(session.path);
-					return true;
-				},
+				onDelete:
+					options.allowDelete === false
+						? undefined
+						: async (session: SessionInfo) => {
+								await storage.deleteSessionWithArtifacts(session.path);
+								return true;
+							},
 				historyMatcher,
-				loadAllSessions: () => SessionManager.listAll(storage),
-				allSessions: options?.allSessions,
+				loadAllSessions: options.allowGlobalScope === false ? undefined : () => SessionManager.listAll(storage),
+				allSessions: options.allSessions,
 				getTerminalRows: () => ui.terminal.rows,
 				fillHeight: true,
+				title: options.title,
+				scopeLabel: options.scopeLabel,
+				showCwd: options.showCwd,
 			},
 		);
 		return selector;

package/src/cli/ttsr-cli.ts

@@ -94,12 +94,18 @@ interface TestReport {
 	evaluated: number;
 	triggered: RuleMatchDetail[];
 	notTriggered: RuleMatchDetail[];
+	/**
+	 * Set when a file path was supplied but the match source was inferred as
+	 * `text` (extension absent from {@link SOURCE_FILE_EXT}), so callers can
+	 * surface why a source file was evaluated against a prose context.
+	 */
+	inferenceNote?: string;
 }
 
 const STDIN_MARKER = "-";
 /** Extensions treated as source files for default tool-context inference. */
 const SOURCE_FILE_EXT =
-	/^\.(ts|tsx|js|jsx|mjs|cjs|rs|py|go|java|kt|swift|c|cc|cpp|h|hpp|rb|php|lua|css|scss|html|json|ya?ml|toml|md|mdc)$/i;
+	/^\.(ts|tsx|js|jsx|mjs|cjs|rs|py|go|java|kt|swift|c|cc|cpp|h|hpp|rb|php|lua|css|scss|html|json|ya?ml|toml|md|mdc|cs|razor|cshtml|fs|fsx|vb|sh|bash|sql|zig|dart|scala|ex|exs|proto|tf)$/i;
 
 const BINARY_PROBE_BYTES = 8192;
 const DEFAULT_MAX_SCAN_BYTES = 5 * 1024 * 1024;
@@ -342,6 +348,14 @@ async function runTest(args: TtsrTestArgs, json: boolean, cwd: string): Promise<
 		args.source ?? (filePath && SOURCE_FILE_EXT.test(path.extname(filePath)) ? "tool" : "text");
 	const tool = args.tool ?? (source === "tool" ? "edit" : undefined);
 
+	// A supplied source file whose extension is unknown falls through to the
+	// text (prose) context, where tool-scoped rules can never match. Surface
+	// that so a false negative reads as a context mismatch, not a bad regex.
+	const inferenceNote =
+		!args.source && filePath && source === "text"
+			? `inferred --source text from '${path.extname(filePath) || filePath}' (not in the source-file extension set); pass --source tool --tool edit to evaluate tool-scoped rules`
+			: undefined;
+
 	const context: TtsrMatchContext = {
 		source,
 		toolName: tool,
@@ -373,6 +387,7 @@ async function runTest(args: TtsrTestArgs, json: boolean, cwd: string): Promise<
 		evaluated: rules.length,
 		triggered,
 		notTriggered,
+		inferenceNote,
 	};
 
 	if (json) {
@@ -390,6 +405,9 @@ function renderTestReport(report: TestReport, verbose: boolean, isolated: boolea
 		`${chalk.bold("TTSR test")} — source=${chalk.cyan(ctxLabel)}${pathLabel} snippet=${chalk.dim(`${report.snippetBytes}b`)}\n`,
 	);
 	process.stdout.write(`${chalk.dim(`  "${report.snippetPreview}"`)}\n\n`);
+	if (report.inferenceNote) {
+		process.stdout.write(`${chalk.yellow(`note: ${report.inferenceNote}`)}\n\n`);
+	}
 
 	if (report.triggered.length === 0) {
 		process.stdout.write(`${chalk.red("No rules triggered.")} (evaluated ${report.evaluated})\n`);

package/src/cli/update-cli.ts

@@ -231,6 +231,9 @@ export async function downloadVerifiedBinary(options: VerifiedBinaryDownloadOpti
 		await fs.promises.chmod(options.targetPath, 0o755);
 	} catch (err) {
 		await unlinkIfExists(options.targetPath);
+		if (isTimeoutError(err)) {
+			throw new Error("Timed out downloading release binary after 15 minutes", { cause: err });
+		}
 		throw err;
 	}
 }

package/src/cli/usage-cli.ts

@@ -560,9 +560,34 @@ function formatReloginDeadline(
  * automatically (refresh failure, upstream invalidation). Rows the user
  * replaced or deleted deliberately are lifecycle noise, not lost capacity.
  */
-function isActionableDisable(summary: DisabledCredentialSummary): boolean {
+function isActionableDisable(summary: DisabledCredentialSummary, activeAccounts: UsageAccountIdentity[] = []): boolean {
 	if (summary.type !== "oauth") return false;
-	return !/^(replaced by|deleted by user)/i.test(summary.cause);
+	if (/^(replaced by|deleted by user)/i.test(summary.cause)) return false;
+
+	// Do not display tombstone if there is an active account for the same provider
+	// matching the same identity (email, accountId, or org).
+	const summaryEmail = summary.email?.toLowerCase();
+	const summaryAccountId = summary.accountId?.toLowerCase();
+	const summaryOrgId = summary.orgId?.toLowerCase();
+
+	const matchesActive = activeAccounts.some(account => {
+		if (account.provider !== summary.provider) return false;
+
+		const accountEmail = account.email?.toLowerCase();
+		const accountAccountId = account.accountId?.toLowerCase();
+		const accountOrgId = account.orgId?.toLowerCase();
+
+		// If email or accountId match, it's the same identity
+		if (summaryEmail && accountEmail && summaryEmail === accountEmail) return true;
+		if (summaryAccountId && accountAccountId && summaryAccountId === accountAccountId) return true;
+
+		// Fallback: if orgId matches and neither email nor accountId contradicts
+		if (summaryOrgId && accountOrgId && summaryOrgId === accountOrgId) return true;
+
+		return false;
+	});
+
+	return !matchesActive;
 }
 
 /** Human-sized disable cause: the upstream `error_description` when embedded, else the first clause. */
@@ -610,7 +635,7 @@ export function formatUsageBreakdown(
 	}
 	const disabledByProvider = new Map<string, DisabledCredentialSummary[]>();
 	for (const summary of disabled) {
-		if (!isActionableDisable(summary)) continue;
+		if (!isActionableDisable(summary, accounts)) continue;
 		const list = disabledByProvider.get(summary.provider) ?? [];
 		list.push(summary);
 		disabledByProvider.set(summary.provider, list);
@@ -1018,7 +1043,7 @@ export async function runUsageCommand(cmd: UsageCommandArgs): Promise<void> {
 				const stats = computeProviderWindowStats(filteredReports.filter(peer => peer.provider === report.provider));
 				if (stats.length > 0) capacity[report.provider] = stats;
 			}
-			let disabledForJson = disabled.filter(isActionableDisable);
+			let disabledForJson = disabled.filter(summary => isActionableDisable(summary, accounts));
 			if (redaction) {
 				disabledForJson = disabledForJson.map(summary => ({
 					...summary,

package/src/cli/worktree-cli.ts

@@ -8,8 +8,10 @@
  *     `<parent-repo>/.git/worktrees/<name>/`.
  *   - **Task-isolation dirs** (`task/worktree.ts`): a wrapper dir with a
  *     compact `m` subdir mounted/cloned by `natives.isoStart`. Legacy `merged`
- *     subdirs are still recognized. These are ephemeral; `ensureIsolation`
- *     removes the base before re-creating it, so leftovers are crashed runs.
+ *     subdirs are still recognized. `ensureIsolation` writes an ownership
+ *     marker naming the live omp process; a
+ *     sandbox whose owner is still running is reported `live` and never
+ *     removed without `--all`, so `clear` reclaims only crashed leftovers.
  *
  * Legacy entries from before the encoding change keep working because git still
  * tracks them by branch name. This command exists to GC them on demand.
@@ -18,6 +20,7 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { getWorktreesDir, isEnoent } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
+import { hasLiveIsolationOwner, ISOLATION_OWNER_FILE } from "../task/isolation-ownership";
 import * as git from "../utils/git";
 
 type WorktreeKind = "pr-checkout" | "task-isolation" | "empty" | "stray";
@@ -211,16 +214,30 @@ async function classifyDir(dir: string): Promise<WorktreeEntry | null> {
 	if (gitStat?.isFile()) {
 		return classifyPrCheckout(dir, gitEntry);
 	}
-	for (const mountDir of TASK_ISOLATION_MOUNT_DIRS) {
-		const mountStat = await fs.stat(path.join(dir, mountDir)).catch(() => null);
-		if (!mountStat?.isDirectory()) continue;
-		return {
-			path: dir,
-			kind: "task-isolation",
-			orphanReason: "task-isolation leftover (no live task owns it)",
-		};
+	// A task-isolation sandbox is identified by its ownership marker — written
+	// before the backend materialises the mount — or by the `m`/`merged` mount
+	// dir itself (legacy dirs and crashed pre-marker runs). Recognizing the
+	// marker alone keeps an in-progress sandbox from being mistaken for a stray
+	// during the window between marker creation and mount materialisation.
+	let isIsolation = await Bun.file(path.join(dir, ISOLATION_OWNER_FILE)).exists();
+	if (!isIsolation) {
+		for (const mountDir of TASK_ISOLATION_MOUNT_DIRS) {
+			const mountStat = await fs.stat(path.join(dir, mountDir)).catch(() => null);
+			if (mountStat?.isDirectory()) {
+				isIsolation = true;
+				break;
+			}
+		}
 	}
-	return null;
+	if (!isIsolation) return null;
+	const live = await hasLiveIsolationOwner(dir);
+	return {
+		path: dir,
+		kind: "task-isolation",
+		// Only after confirming no live owner is the "no live task" claim true.
+		// A running subagent's sandbox stays live so `clear` won't delete it.
+		orphanReason: live ? undefined : "task-isolation leftover (no live task owns it)",
+	};
 }
 
 async function classifyPrCheckout(dir: string, gitEntry: string): Promise<WorktreeEntry> {

package/src/cli-commands.ts

@@ -18,6 +18,7 @@ export const commands: CommandEntry[] = [
 	{ name: "auth-gateway", load: () => import("./commands/auth-gateway").then(m => m.default) },
 	{ name: "agents", load: () => import("./commands/agents").then(m => m.default) },
 	{ name: "bench", load: () => import("./commands/bench").then(m => m.default) },
+	{ name: "cleanse", load: () => import("./commands/cleanse").then(m => m.default) },
 	{ name: "commit", load: () => import("./commands/commit").then(m => m.default) },
 	{ name: "completions", load: () => import("./commands/completions").then(m => m.default) },
 	{ name: "__complete", load: () => import("./commands/complete").then(m => m.default) },

package/src/cli.ts

@@ -25,12 +25,14 @@ import {
 	VERSION,
 } from "@oh-my-pi/pi-utils/dirs";
 import { interceptUnhandledRejections } from "@oh-my-pi/pi-utils/postmortem";
+import { setProcessName } from "@oh-my-pi/pi-utils/process-name";
 import { declareWorkerHostEntry, installWorkerInbox, isWorkerHostSelector } from "@oh-my-pi/pi-utils/worker-host";
 import { installProfileAlias, resolveProfileAliasCommandFromProcess } from "./cli/profile-alias";
 import { extractProfileFlags } from "./cli/profile-bootstrap";
 import { startJsEvalProcess } from "./eval/js/process-entry";
 import type { WorkerInbound as JsWorkerInbound, WorkerOutbound as JsWorkerOutbound } from "./eval/js/worker-protocol";
 import { DAEMON_BROKER_WORKER_ARG } from "./launch/protocol";
+import { TERMINAL_OUTPUT_WORKER_ARG } from "./launch/terminal-output-worker-protocol";
 import { COMPUTER_WORKER_ARG } from "./tools/computer/protocol";
 import { smokeTestComputerWorker } from "./tools/computer/supervisor";
 import { startComputerWorker } from "./tools/computer/worker-entry";
@@ -42,7 +44,7 @@ if (Bun.semver.order(Bun.version, MIN_BUN_VERSION) < 0) {
 	process.exit(1);
 }
 
-process.title = APP_NAME;
+setProcessName(APP_NAME);
 
 // `Bun.build`-API compiled Windows executables report `import.meta.main ===
 // false`: the standalone loader keys the entry module with native backslashes
@@ -87,6 +89,7 @@ async function runSmokeTest(): Promise<void> {
 	const { smokeTestJsEvalWorker } = await import("./eval/js/context-manager");
 	// Other smoke dependencies stay lazy so normal CLI startup does not load their worker clients.
 	const { smokeTestDaemonBroker } = await import("./launch/client");
+	const { smokeTestTerminalOutputWorker } = await import("./launch/terminal-output-worker-client");
 	await smokeTestSyncWorker();
 
 	const statsServer = await startServer(0);
@@ -108,6 +111,7 @@ async function runSmokeTest(): Promise<void> {
 	await smokeTestTtsWorker();
 	await smokeTestMnemopiEmbedWorker();
 	await smokeTestDaemonBroker();
+	await smokeTestTerminalOutputWorker();
 	process.stdout.write("smoke-test: ok\n");
 }
 
@@ -194,6 +198,12 @@ async function runWorkerEntrypoint(arg: string | undefined): Promise<boolean> {
 		await runIpcSubprocessWorker(startMnemopiEmbedWorker);
 		return true;
 	}
+	if (arg === TERMINAL_OUTPUT_WORKER_ARG) {
+		if (parentPort) installWorkerInbox(parentPort);
+		// This selector is the isolation boundary; a static import would evaluate xterm in normal CLI startup.
+		await import("./launch/terminal-output-worker");
+		return true;
+	}
 	if (arg === DAEMON_BROKER_WORKER_ARG) {
 		// Worker selectors must dispatch before the normal command graph loads.
 		const { startDaemonBrokerFromEnvironment } = await import("./launch/broker");

package/src/collab/guest.ts

@@ -85,14 +85,15 @@ interface PendingSnapshot {
 /** Minimal context surface the idle-state reconciler mutates. */
 export interface GuestIdleReconcilerCtx {
 	statusLine: { markActivityEnd: () => void };
+	statusContainer: Pick<InteractiveModeContext["statusContainer"], "disposeChildren">;
 	loadingAnimation: { stop: () => void } | undefined;
 }
 
 /**
  * Close the guest UI state held open by an earlier `agent_start` whose
  * matching `agent_end` never reached us — most often because a reconnect
- * dropped the event mid-stream. Triggered from {@link CollabGuestLink}'s
- * `state` reconciler when the host reports `isStreaming === false`:
+ * dropped the event mid-stream. Reached via {@link reconcileGuestSnapshotHostState}
+ * (the live `state`-frame and welcome/resync reconciler) when the host reports `isStreaming === false`:
  * folds the in-flight active-time window into the per-session meter (so
  * `time_spent` stops ticking) and stops the `Working…` loader if one is
  * still animating. No-op when the host is still streaming.
@@ -106,17 +107,49 @@ export function reconcileGuestIdleHostState(ctx: GuestIdleReconcilerCtx, isStrea
 	if (ctx.loadingAnimation) {
 		ctx.loadingAnimation.stop();
 		ctx.loadingAnimation = undefined;
+		ctx.statusContainer.disposeChildren();
 	}
 }
 
 /** Reconcile a welcome/resync snapshot's host activity state into the guest meter. */
 export interface GuestSnapshotActivityReconcilerCtx extends GuestIdleReconcilerCtx {
 	statusLine: GuestIdleReconcilerCtx["statusLine"] & { markActivityStart: () => void };
+	/**
+	 * Start (or re-attach) the live "Working…" loader. Mirrors
+	 * `InteractiveModeContext.ensureLoadingAnimation`, which is what
+	 * `EventController` calls on `agent_start`. Required so a guest that
+	 * missed an earlier `agent_start` (a reconnect dropped it mid-stream)
+	 * starts its spinner when the host later reports it is streaming.
+	 */
+	ensureLoadingAnimation: InteractiveModeContext["ensureLoadingAnimation"];
+	autoCompactionLoader: InteractiveModeContext["autoCompactionLoader"];
+	retryLoader: InteractiveModeContext["retryLoader"];
+}
+
+/** Status-area state which cannot outlive removal of its child components. */
+export interface GuestTransientStatusCtx {
+	statusContainer: Pick<InteractiveModeContext["statusContainer"], "clear">;
+	autoCompactionLoader: InteractiveModeContext["autoCompactionLoader"];
+	retryLoader: InteractiveModeContext["retryLoader"];
+}
+
+/** Stop and forget status-area loaders before detaching their components. */
+export function clearGuestTransientStatus(ctx: GuestTransientStatusCtx): void {
+	if (ctx.autoCompactionLoader) {
+		ctx.autoCompactionLoader.stop();
+		ctx.autoCompactionLoader = undefined;
+	}
+	if (ctx.retryLoader) {
+		ctx.retryLoader.stop();
+		ctx.retryLoader = undefined;
+	}
+	ctx.statusContainer.clear();
 }
 
 export function reconcileGuestSnapshotHostState(ctx: GuestSnapshotActivityReconcilerCtx, isStreaming: boolean): void {
 	if (isStreaming) {
 		ctx.statusLine.markActivityStart();
+		if (!ctx.autoCompactionLoader && !ctx.retryLoader) ctx.ensureLoadingAnimation();
 		return;
 	}
 	reconcileGuestIdleHostState(ctx, false);
@@ -482,7 +515,7 @@ export class CollabGuestLink {
 				this.#applyHostState(frame.state);
 				setSessionTerminalTitle(frame.state.sessionName, frame.state.cwd);
 				this.#updateStatusSegment();
-				reconcileGuestIdleHostState(this.#ctx, frame.state.isStreaming);
+				reconcileGuestSnapshotHostState(this.#ctx, frame.state.isStreaming);
 				this.#ctx.statusLine.invalidate();
 				this.#ctx.ui.requestRender();
 				break;
@@ -681,7 +714,7 @@ export class CollabGuestLink {
 
 	#clearTransientUi(): void {
 		this.#clearUiRequests();
-		this.#ctx.statusContainer.clear();
+		clearGuestTransientStatus(this.#ctx);
 		this.#ctx.pendingMessagesContainer.clear();
 		this.#ctx.compactionQueuedMessages = [];
 		this.#ctx.streamingComponent = undefined;