@oh-my-pi/pi-coding-agent 17.3.0 → 17.3.1

package/src/modes/utils/ui-helpers.ts

@@ -33,8 +33,8 @@ import {
 import { SkillMessageComponent } from "../../modes/components/skill-message";
 import { StrippedToolCallsPlaceholder } from "../../modes/components/stripped-tool-calls-placeholder";
 import { ToolActivityContainer } from "../../modes/components/tool-activity";
-import { ToolExecutionComponent } from "../../modes/components/tool-execution";
-import { TranscriptBlock } from "../../modes/components/transcript-container";
+import { ToolExecutionComponent, type ToolExecutionHandle } from "../../modes/components/tool-execution";
+import { TranscriptBlock, TranscriptContainer } from "../../modes/components/transcript-container";
 import { createUsageRowBlock } from "../../modes/components/usage-row";
 import { UserMessageComponent } from "../../modes/components/user-message";
 import { decodeStreamedToolArgs, streamingStringKeysForTool } from "../../modes/controllers/tool-args-reveal";
@@ -325,7 +325,7 @@ export class UiHelpers {
 		while (!steps.next().done) {}
 	}
 
-	/** Render a session context in bounded chunks so terminal input runs between transcript paints. */
+	/** Build a session context in bounded chunks so terminal input runs between event-loop turns. */
 	async renderSessionContextIncrementally(
 		sessionContext: SessionContext,
 		options: RenderSessionContextOptions,
@@ -729,18 +729,23 @@ export class UiHelpers {
 	}
 
 	async renderInitialMessages(options: RenderInitialMessagesOptions = {}): Promise<void> {
-		// This path is used to rebuild the visible chat transcript (e.g. after custom/debug UI).
-		// Clear existing rendered chat first to avoid duplicating the full session in the container.
-		// On a non-preserving rebuild the existing blocks are discarded for good, so
-		// dispose them (stopping any live timers/subscriptions) before clearing. When
-		// preserving, the same instances are re-added below, so detach without dispose.
-		const preservedChatChildren = options.preserveExistingChat ? this.ctx.chatContainer.children : undefined;
+		// Build against a detached container. Incremental construction still yields
+		// to terminal input, while paints keep using the complete visible transcript
+		// until the replacement is ready to swap in.
+		const visibleChatContainer = this.ctx.chatContainer;
+		const stagedChatContainer = new TranscriptContainer();
+		stagedChatContainer.setToolActivityVisible(!this.ctx.hideToolActivity);
+		const preservedChatChildren = options.preserveExistingChat ? [...visibleChatContainer.children] : undefined;
+		const previousTranscriptMessageComponents = this.ctx.transcriptMessageComponents;
+		const previousPendingTools = this.ctx.pendingTools;
+		const previousPendingBashComponents = this.ctx.pendingBashComponents;
+		const previousPendingPythonComponents = this.ctx.pendingPythonComponents;
+		const previousLastAssistantUsage = this.ctx.lastAssistantUsage;
 		const chatWasAlreadyRendered = this.ctx.initialChatRendered;
-		if (preservedChatChildren) {
-			this.ctx.chatContainer.clear();
-		} else {
-			this.ctx.resetTranscript();
-		}
+
+		this.ctx.chatContainer = stagedChatContainer;
+		this.ctx.transcriptMessageComponents = new WeakMap<AgentMessage, Component>();
+		this.ctx.pendingTools = new Map<string, ToolExecutionHandle>();
 		this.ctx.pendingMessagesContainer.disposeChildren();
 		this.ctx.pendingBashComponents = [];
 		this.ctx.pendingPythonComponents = [];
@@ -751,13 +756,6 @@ export class UiHelpers {
 		// (focus attach/unfocus while a tool executes) keep dangling toolCalls so
 		// the in-flight call re-renders as pending instead of vanishing;
 		// renderSessionContext then keeps it in `pendingTools` for live routing.
-		let terminalHistoryCleared = false;
-		const renderChunk = options.clearTerminalHistory
-			? () => {
-					this.ctx.ui.requestRender(true, { clearScrollback: !terminalHistoryCleared });
-					terminalHistoryCleared = true;
-				}
-			: undefined;
 		let context = this.ctx.viewSession.buildTranscriptSessionContext({
 			collapseCompactedHistory: settings.get("display.collapseCompacted"),
 			keepDanglingToolCalls: this.ctx.viewSession.isStreaming,
@@ -770,6 +768,7 @@ export class UiHelpers {
 			// every attempt.
 			populateHistory: false,
 		};
+		let committed = false;
 		this.ctx.initialChatRendered = false;
 		try {
 			while (true) {
@@ -777,8 +776,6 @@ export class UiHelpers {
 					// Live events mutate the same component maps; keep their replay atomic so
 					// a delta cannot land halfway through rebuilding its pending tool block.
 					this.ctx.renderSessionContext(context, renderOptions);
-				} else if (renderChunk) {
-					await this.ctx.renderSessionContextIncrementally(context, renderOptions, renderChunk);
 				} else {
 					await this.ctx.renderSessionContextIncrementally(context, renderOptions);
 				}
@@ -790,49 +787,73 @@ export class UiHelpers {
 				// yielded. The display callback stayed gated by initialChatRendered;
 				// discard the stale partial tree and replay the current session once
 				// more instead of letting a reentrant synchronous rebuild interleave.
-				this.ctx.resetTranscript();
+				stagedChatContainer.disposeChildren();
+				this.ctx.transcriptMessageComponents = new WeakMap<AgentMessage, Component>();
+				this.ctx.pendingTools.clear();
 				this.ctx.pendingBashComponents = [];
 				this.ctx.pendingPythonComponents = [];
-				terminalHistoryCleared = false;
 				context = this.ctx.viewSession.buildTranscriptSessionContext({
 					collapseCompactedHistory: settings.get("display.collapseCompacted"),
 					keepDanglingToolCalls: this.ctx.viewSession.isStreaming,
 				});
 				replayEntryCount = this.ctx.viewSession.sessionManager.getEntries().length;
 			}
-		} finally {
-			this.ctx.initialChatRendered = chatWasAlreadyRendered;
-		}
-		if (!this.ctx.focusedAgentId) {
-			for (const message of context.messages) {
-				if (message.role !== "user" || message.synthetic) continue;
-				const text = this.getUserMessageText(message);
-				if (text) this.ctx.editor.addToHistory(text);
+
+			const replayedChatChildren = [...stagedChatContainer.children];
+			stagedChatContainer.clear();
+			this.ctx.chatContainer = visibleChatContainer;
+			if (preservedChatChildren) {
+				visibleChatContainer.clear();
+			} else {
+				visibleChatContainer.disposeChildren();
 			}
-		}
+			for (const child of replayedChatChildren) {
+				visibleChatContainer.addChild(child);
+			}
+			if (preservedChatChildren) {
+				for (const child of preservedChatChildren) {
+					visibleChatContainer.addChild(child);
+				}
+			}
+			committed = true;
 
-		// Show compaction info if session was compacted
-		const allEntries = this.ctx.viewSession.sessionManager.getEntries();
-		let compactionCount = 0;
-		for (const entry of allEntries) {
-			if (entry.type === "compaction") {
-				compactionCount++;
+			if (!this.ctx.focusedAgentId) {
+				for (const message of context.messages) {
+					if (message.role !== "user" || message.synthetic) continue;
+					const text = this.getUserMessageText(message);
+					if (text) this.ctx.editor.addToHistory(text);
+				}
 			}
-		}
-		if (compactionCount > 0) {
-			const times = compactionCount === 1 ? "1 time" : `${compactionCount} times`;
-			this.ctx.showStatus(`Session compacted ${times}`);
-		}
-		if (options.clearTerminalHistory) {
-			this.ctx.ui.requestRender(true, { clearScrollback: !terminalHistoryCleared });
-		}
-		if (preservedChatChildren && preservedChatChildren.length > 0) {
-			for (const child of preservedChatChildren) {
-				this.ctx.chatContainer.addChild(child);
+
+			// Show compaction info if session was compacted.
+			const allEntries = this.ctx.viewSession.sessionManager.getEntries();
+			let compactionCount = 0;
+			for (const entry of allEntries) {
+				if (entry.type === "compaction") {
+					compactionCount++;
+				}
 			}
-			this.ctx.ui.requestRender();
+			if (compactionCount > 0) {
+				const times = compactionCount === 1 ? "1 time" : `${compactionCount} times`;
+				this.ctx.showStatus(`Session compacted ${times}`);
+			}
+			if (options.clearTerminalHistory) {
+				this.ctx.ui.requestRender(true, { clearScrollback: true });
+			} else {
+				this.ctx.ui.requestRender();
+			}
+		} finally {
+			if (!committed) {
+				this.ctx.chatContainer = visibleChatContainer;
+				this.ctx.transcriptMessageComponents = previousTranscriptMessageComponents;
+				this.ctx.pendingTools = previousPendingTools;
+				this.ctx.pendingBashComponents = previousPendingBashComponents;
+				this.ctx.pendingPythonComponents = previousPendingPythonComponents;
+				this.ctx.lastAssistantUsage = previousLastAssistantUsage;
+				stagedChatContainer.disposeChildren();
+			}
+			this.ctx.initialChatRendered = committed ? true : chatWasAlreadyRendered;
 		}
-		this.ctx.initialChatRendered = true;
 	}
 
 	clearEditor(): void {

package/src/session/agent-session.ts

@@ -5647,6 +5647,7 @@ export class AgentSession {
 
 		return {
 			ui: noOpUIContext,
+			mode: "print",
 			hasUI: false,
 			cwd: this.sessionManager.getCwd(),
 			sessionManager: this.sessionManager,

package/src/session/claude-session-store.ts

@@ -1,6 +1,5 @@
 import type * as fsTypes from "node:fs";
 import * as fs from "node:fs/promises";
-import * as os from "node:os";
 import * as path from "node:path";
 import type {
 	AssistantMessage,
@@ -13,6 +12,7 @@ import type {
 	UserMessage,
 } from "@oh-my-pi/pi-ai";
 import { isRecord } from "@oh-my-pi/pi-utils";
+import { resolveClaudePaths } from "../config/claude-paths";
 import { collectForeignJsonRecords, type ForeignJsonRecord, readForeignJsonRecords } from "./foreign-session-jsonl";
 import type { ForeignSessionInfo, ForeignSessionStore } from "./foreign-session-store";
 import type { ModelChangeEntry, SessionMessageEntry } from "./session-entries";
@@ -99,7 +99,8 @@ async function readHistoryIndex(file: string): Promise<Map<string, ClaudeHistory
 }
 
 async function readRegisteredProjects(root: string): Promise<string[]> {
-	const config = path.join(path.dirname(root), ".claude.json");
+	const { configDir, configFile } = resolveClaudePaths();
+	const config = root === configDir ? configFile : path.join(path.dirname(root), ".claude.json");
 	try {
 		const parsed: unknown = await Bun.file(config).json();
 		if (!isRecord(parsed) || !isRecord(parsed.projects)) return [];
@@ -306,7 +307,7 @@ export class ClaudeSessionStore implements ForeignSessionStore {
 	readonly #root: string;
 
 	/** Creates a store rooted at Claude's data directory, or at a fixture root when supplied. */
-	constructor(root: string = path.join(os.homedir(), ".claude")) {
+	constructor(root: string = resolveClaudePaths().configDir) {
 		this.#root = path.resolve(root);
 	}
 

package/src/task/executor.ts

@@ -493,6 +493,8 @@ export interface ExecutorOptions {
 	keepAlive?: boolean;
 	/** Internal ownership handoff for cleanup that outlives the visible Task result. */
 	onCleanupDeferred?: (completion: Promise<void>) => void;
+	/** Internal cleanup grace override for deterministic lifecycle tests. */
+	cleanupGraceMs?: number;
 }
 
 function parseStringifiedJson(value: unknown): unknown {
@@ -2657,6 +2659,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		signal,
 		onProgress,
 	} = options;
+	const cleanupGraceMs = options.cleanupGraceMs ?? TASK_ABORT_CLEANUP_GRACE_MS;
 	const startTime = Date.now();
 	// Set by the session's onFirstChatDispatch hook the first time the agent
 	// loop dispatches a chat request to the provider — the launch-complete boundary.
@@ -3328,7 +3331,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				error = err instanceof Error ? err.stack || err.message : String(err);
 			}
 		} finally {
-			const cleanupDeadlineAt = Date.now() + TASK_ABORT_CLEANUP_GRACE_MS;
+			const cleanupDeadlineAt = Date.now() + cleanupGraceMs;
 			const cleanupChangeStatus =
 				worktree === undefined
 					? "This task was not isolated, so its changes may remain in the working directory."
@@ -3339,8 +3342,8 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				lateCleanups.push(completion);
 				exitCode = 1;
 				aborted = true;
-				abortReasonText = `cleanup exceeded ${TASK_ABORT_CLEANUP_GRACE_MS} ms`;
-				error ??= `Task aborted. Cleanup did not finish within ${TASK_ABORT_CLEANUP_GRACE_MS} ms. ${cleanupChangeStatus}`;
+				abortReasonText = `cleanup exceeded ${cleanupGraceMs} ms`;
+				error ??= `Task aborted. Cleanup did not finish within ${cleanupGraceMs} ms. ${cleanupChangeStatus}`;
 			};
 			if (abortSignal.aborted) {
 				aborted = monitor.isAbortedRun();

package/src/tools/browser/launch.ts

@@ -204,6 +204,15 @@ function isExecutableFile(p: string): boolean {
 
 async function isChromiumExecutable(p: string): Promise<boolean> {
 	if (!isExecutableFile(p)) return false;
+	// The version probe below launches the candidate. It exists to reject
+	// non-Chromium `chrome`/`chromium` wrapper scripts that appear on a Linux
+	// PATH (ecb22957, "validate Linux browser executables"). On Windows and
+	// macOS the candidates are fixed GUI application paths, not PATH wrappers,
+	// and executing them is harmful: a GUI `chrome.exe --version` does not print
+	// to a detached stdout and can hand off to the user's running instance,
+	// opening/activating a normal browser window (#8445). Confine the probe to
+	// Linux and trust the executable-file check elsewhere.
+	if (process.platform !== "linux") return true;
 	try {
 		const probeTimeoutMs = 3000;
 		const proc = Bun.spawn([p, "--version"], {

package/src/utils/git.ts

@@ -226,6 +226,11 @@ export const GIT_COMMAND_OUTPUT_LIMIT_BYTES = 8 * 1024 * 1024;
  * degrades instead of freezing the UI indefinitely.
  */
 export const GIT_SPAWN_SYNC_TIMEOUT_MS = 5_000;
+/**
+ * Stat-poll interval for {@link head.watch}. One `stat` per interval keeps an
+ * always-on status line cheap while surfacing a branch switch within a second.
+ */
+export const HEAD_WATCH_INTERVAL_MS = 1000;
 
 const GIT_COMMAND_TIMEOUT_EXIT_CODE = 124;
 // Exit code returned when the `git` binary cannot be launched at all (spawn
@@ -2296,6 +2301,28 @@ export const head = {
 		if (result.exitCode !== 0) return null;
 		return result.stdout.trim() || null;
 	},
+
+	/**
+	 * Watch the repository's HEAD for branch moves. Returns a disposer.
+	 *
+	 * Deliberately stat-polls via `fs.watchFile` instead of `fs.watch`: git
+	 * swaps HEAD with `HEAD.lock` + atomic rename, which unlinks the HEAD inode
+	 * — and Bun's inotify-backed `fs.watch` permanently stops delivering events
+	 * after observing a rename in the watched directory (oven-sh/bun#24875), so
+	 * an event watcher fires once and then freezes on Linux (issue #8412 was
+	 * the same freeze for file-inode watches on every platform). A path-based
+	 * stat poll re-resolves the path each interval and survives inode swaps
+	 * everywhere. Reftable repos keep ref state in `<gitDir>/reftable` (their
+	 * HEAD file is a static stub), so the poll targets that directory instead.
+	 */
+	watch(repository: GitRepository, onChange: () => void): () => void {
+		const target = isReftableRepoSync(repository) ? path.join(repository.gitDir, "reftable") : repository.headPath;
+		const listener = (curr: fs.Stats, prev: fs.Stats) => {
+			if (curr.mtimeMs !== prev.mtimeMs || curr.ino !== prev.ino || curr.size !== prev.size) onChange();
+		};
+		fs.watchFile(target, { interval: HEAD_WATCH_INTERVAL_MS }, listener).unref();
+		return () => fs.unwatchFile(target, listener);
+	},
 };
 
 // ════════════════════════════════════════════════════════════════════════════

package/src/utils/shell-snapshot.ts

@@ -208,10 +208,14 @@ fi
 /**
  * Create a shell snapshot, caching the result.
  * Returns the path to the snapshot file, or null if creation failed.
+ *
+ * `timeoutMs` is configurable so callers exercising failure handling do not
+ * have to wait out the production startup budget.
  */
 export async function getOrCreateSnapshot(
 	shell: string,
 	env: Record<string, string | undefined>,
+	timeoutMs = SNAPSHOT_TIMEOUT_MS,
 ): Promise<string | null> {
 	const cacheKey = shell;
 	// Return cached snapshot if valid
@@ -284,7 +288,7 @@ export async function getOrCreateSnapshot(
 			stdin: "ignore",
 			stdout: "ignore",
 			stderr: "ignore",
-			timeout: SNAPSHOT_TIMEOUT_MS,
+			timeout: timeoutMs,
 			killSignal: "SIGKILL",
 		});