@oh-my-pi/pi-coding-agent 16.2.2 → 16.2.3

package/src/debug/log-viewer.ts

@@ -3,11 +3,13 @@ import {
 	extractPrintableText,
 	matchesKey,
 	padding,
+	parseSgrMouse,
 	replaceTabs,
 	truncateToWidth,
 	visibleWidth,
 } from "@oh-my-pi/pi-tui";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
+import { bottomBorder, divider, row, topBorder } from "../modes/components/overlay-box";
 import { theme } from "../modes/theme/theme";
 import { copyToClipboard } from "../utils/clipboard";
 import {
@@ -23,6 +25,8 @@ export const LOAD_OLDER_LABEL = "### MOVE UP TO LOAD MORE...";
 
 const INITIAL_LOG_CHUNK = 50;
 const LOAD_OLDER_CHUNK = 50;
+const MIN_LOG_VIEWER_WIDTH = 48;
+const LOG_VIEWER_CHROME_LINES = 8;
 
 type LogEntry = {
 	rawLine: string;
@@ -184,6 +188,31 @@ export class DebugLogViewerModel {
 		}
 	}
 
+	moveCursorToRow(rowIndex: number, extendSelection: boolean): boolean {
+		const selectableIndex = this.#selectableRowIndices.indexOf(rowIndex);
+		if (selectableIndex < 0) {
+			return false;
+		}
+
+		if (extendSelection && this.#selectionAnchorSelectableIndex === undefined) {
+			const row = this.#getCursorRow();
+			if (row?.kind === "log") {
+				this.#selectionAnchorSelectableIndex = this.#cursorSelectableIndex;
+			}
+		}
+
+		this.#cursorSelectableIndex = selectableIndex;
+
+		if (!extendSelection) {
+			this.#selectionAnchorSelectableIndex = undefined;
+		}
+
+		if (this.#getCursorRow()?.kind !== "log" && !extendSelection) {
+			this.#selectionAnchorSelectableIndex = undefined;
+		}
+		return true;
+	}
+
 	getSelectedLogIndices(): number[] {
 		if (this.#selectableRowIndices.length === 0) {
 			return [];
@@ -484,6 +513,9 @@ export class DebugLogViewerComponent implements Component {
 	#scrollRowOffset = 0;
 	#statusMessage: string | undefined;
 	#loadingOlder = false;
+	#bodyRowStart = 0;
+	#bodyRowCount = 0;
+	#bodyLineToRowIndex: Array<number | undefined> = [];
 
 	constructor(options: DebugLogViewerComponentOptions) {
 		this.#logSource = options.logSource;
@@ -501,6 +533,10 @@ export class DebugLogViewerComponent implements Component {
 	}
 
 	handleInput(keyData: string): void {
+		if (keyData.startsWith("\x1b[<") && this.#handleMouse(keyData)) {
+			return;
+		}
+
 		if (matchesKey(keyData, "escape") || matchesKey(keyData, "esc")) {
 			this.#onExit();
 			return;
@@ -598,59 +634,99 @@ export class DebugLogViewerComponent implements Component {
 		}
 	}
 
+	#handleMouse(keyData: string): boolean {
+		const event = parseSgrMouse(keyData);
+		if (!event) return false;
+
+		const overBody = event.row >= this.#bodyRowStart && event.row < this.#bodyRowStart + this.#bodyRowCount;
+		if (event.wheel !== null && overBody) {
+			this.#statusMessage = undefined;
+			const maxOffset = Math.max(0, this.#model.rows.length - this.#bodyHeight());
+			this.#scrollRowOffset = Math.max(0, Math.min(maxOffset, this.#scrollRowOffset + event.wheel * 3));
+			this.#onUpdate?.();
+			return true;
+		}
+
+		if (!event.leftClick || !overBody) return false;
+		const rowIndex = this.#bodyLineToRowIndex[event.row - this.#bodyRowStart];
+		if (rowIndex === undefined) return false;
+
+		const target = this.#model.rows[rowIndex];
+		if (!target || target.kind === "warning") return false;
+		this.#statusMessage = undefined;
+		this.#model.moveCursorToRow(rowIndex, false);
+		if (target.kind === "load-older") {
+			void this.#handleLoadOlder();
+			return true;
+		}
+
+		if (this.#model.isExpanded(target.logIndex)) {
+			this.#model.collapseSelected();
+		} else {
+			this.#model.expandSelected();
+		}
+		this.#ensureCursorVisible();
+		this.#onUpdate?.();
+		return true;
+	}
+
 	invalidate(): void {
 		// no cached child state
 	}
 
 	render(width: number): readonly string[] {
-		this.#lastRenderWidth = Math.max(20, width);
+		this.#lastRenderWidth = Math.max(MIN_LOG_VIEWER_WIDTH, width);
 		this.#ensureCursorVisible();
 
-		const innerWidth = Math.max(1, this.#lastRenderWidth - 2);
+		const contentWidth = Math.max(1, this.#lastRenderWidth - 4);
 		const bodyHeight = this.#bodyHeight();
 
-		const rows = this.#renderRows(innerWidth);
-		const visibleBodyLines = this.#renderVisibleBodyLines(rows, innerWidth, bodyHeight);
+		const rows = this.#renderRows(contentWidth);
+		this.#bodyRowStart = 4;
+		this.#bodyRowCount = bodyHeight;
+		const visibleBodyLines = this.#renderVisibleBodyLines(rows, bodyHeight);
 
 		return [
-			this.#frameTop(innerWidth),
-			this.#frameLine(this.#summaryText(), innerWidth),
-			this.#frameSeparator(innerWidth),
-			this.#frameLine(this.#filterText(), innerWidth),
-			this.#frameSeparator(innerWidth),
+			topBorder(this.#lastRenderWidth, "Recent Logs"),
+			row(this.#summaryText(), this.#lastRenderWidth),
+			row(this.#filterText(), this.#lastRenderWidth),
+			divider(this.#lastRenderWidth),
 			...visibleBodyLines,
-			this.#frameLine(this.#statusText(), innerWidth),
-			this.#frameBottom(innerWidth),
+			divider(this.#lastRenderWidth),
+			row(this.#statusText(), this.#lastRenderWidth),
+			row(theme.fg("dim", this.#controlsText()), this.#lastRenderWidth),
+			bottomBorder(this.#lastRenderWidth),
 		];
 	}
 
 	#summaryText(): string {
-		return ` # ${this.#model.visibleLogCount}/${this.#model.logCount} logs | ${this.#controlsText()}`;
+		const selected = this.#model.getSelectedCount();
+		const expanded = this.#model.expandedCount;
+		return `${theme.fg("muted", "showing")} ${theme.fg("accent", `${this.#model.visibleLogCount}/${this.#model.logCount}`)}  ${theme.fg("muted", "selected")} ${theme.fg(selected > 0 ? "accent" : "muted", String(selected))}  ${theme.fg("muted", "expanded")} ${theme.fg(expanded > 0 ? "accent" : "muted", String(expanded))}`;
 	}
 
 	#controlsText(): string {
-		return "Esc: back  Ctrl+C: copy  Up/Down: move  Shift+Up/Down: select range  Left/Right: collapse/expand  Ctrl+A: select all  Ctrl+O: load older  Ctrl+P: pid filter";
+		return "Esc close · Ctrl+C copy · ↑/↓/wheel move · click toggle · Shift+↑/↓ select · ←/→ collapse/expand · Ctrl+A all · Ctrl+O older · Ctrl+P pid";
 	}
 
 	#filterText(): string {
 		const sanitized = replaceTabs(sanitizeText(this.#model.filterQuery));
-		const query = sanitized.length === 0 ? "" : theme.fg("accent", sanitized);
+		const query = sanitized.length === 0 ? theme.fg("muted", "type to filter") : theme.fg("accent", sanitized);
 		const pidStatus = this.#model.isProcessFilterEnabled()
-			? theme.fg("success", "pid:on")
-			: theme.fg("muted", "pid:off");
-		return ` filter: ${query}  ${pidStatus}`;
+			? theme.fg("success", "pid on")
+			: theme.fg("muted", "pid off");
+		const loading = this.#loadingOlder ? `  ${theme.fg("warning", "loading older…")}` : "";
+		return `${theme.fg("muted", "filter")} ${query}  ${pidStatus}${loading}`;
 	}
 
 	#statusText(): string {
-		const base = ` Selected: ${this.#model.getSelectedCount()}  Expanded: ${this.#model.expandedCount}`;
-		if (this.#statusMessage) {
-			return `${base}  ${this.#statusMessage}`;
-		}
-		return base;
+		return this.#statusMessage
+			? theme.fg("success", this.#statusMessage)
+			: theme.fg("dim", "Enter loads older when highlighted; printable keys update filter");
 	}
 
 	#bodyHeight(): number {
-		return Math.max(3, this.#terminalRows - 8);
+		return Math.max(3, (process.stdout.rows || this.#terminalRows || 24) - LOG_VIEWER_CHROME_LINES);
 	}
 
 	async #handleLoadOlder(additionalCount: number = LOAD_OLDER_CHUNK): Promise<void> {
@@ -780,26 +856,25 @@ export class DebugLogViewerComponent implements Component {
 		return rendered;
 	}
 
-	#renderVisibleBodyLines(
-		rows: Array<{ lines: string[]; rowIndex: number }>,
-		innerWidth: number,
-		bodyHeight: number,
-	): string[] {
+	#renderVisibleBodyLines(rows: Array<{ lines: string[]; rowIndex: number }>, bodyHeight: number): string[] {
+		this.#bodyLineToRowIndex = [];
 		const lines: string[] = [];
 		if (rows.length === 0) {
-			lines.push(this.#frameLine(theme.fg("muted", "no matches"), innerWidth));
+			this.#bodyLineToRowIndex.push(undefined);
+			lines.push(row(theme.fg("muted", "no matches"), this.#lastRenderWidth));
 		}
 		for (let i = this.#scrollRowOffset; i < rows.length; i++) {
-			const row = rows[i];
-			if (!row) {
+			const renderedRow = rows[i];
+			if (!renderedRow) {
 				continue;
 			}
 
-			for (const line of row.lines) {
+			for (const line of renderedRow.lines) {
 				if (lines.length >= bodyHeight) {
 					break;
 				}
-				lines.push(this.#frameLine(line, innerWidth));
+				this.#bodyLineToRowIndex.push(renderedRow.rowIndex);
+				lines.push(row(line, this.#lastRenderWidth));
 			}
 
 			if (lines.length >= bodyHeight) {
@@ -808,7 +883,8 @@ export class DebugLogViewerComponent implements Component {
 		}
 
 		while (lines.length < bodyHeight) {
-			lines.push(this.#frameLine("", innerWidth));
+			this.#bodyLineToRowIndex.push(undefined);
+			lines.push(row("", this.#lastRenderWidth));
 		}
 
 		return lines;
@@ -840,7 +916,7 @@ export class DebugLogViewerComponent implements Component {
 			return;
 		}
 		const bodyHeight = Math.max(1, this.#bodyHeight());
-		const innerWidth = Math.max(1, this.#lastRenderWidth - 2);
+		const innerWidth = Math.max(1, this.#lastRenderWidth - 4);
 
 		// Scroll up: cursor is above viewport
 		if (cursorRowIndex < this.#scrollRowOffset) {
@@ -865,24 +941,6 @@ export class DebugLogViewerComponent implements Component {
 		}
 	}
 
-	#frameTop(innerWidth: number): string {
-		return `${theme.boxRound.topLeft}${theme.boxRound.horizontal.repeat(innerWidth)}${theme.boxRound.topRight}`;
-	}
-
-	#frameSeparator(innerWidth: number): string {
-		return `${theme.boxRound.teeRight}${theme.boxRound.horizontal.repeat(innerWidth)}${theme.boxRound.teeLeft}`;
-	}
-
-	#frameBottom(innerWidth: number): string {
-		return `${theme.boxRound.bottomLeft}${theme.boxRound.horizontal.repeat(innerWidth)}${theme.boxRound.bottomRight}`;
-	}
-
-	#frameLine(content: string, innerWidth: number): string {
-		const truncated = truncateToWidth(content, innerWidth);
-		const remaining = Math.max(0, innerWidth - visibleWidth(truncated));
-		return `${theme.boxRound.vertical}${truncated}${padding(remaining)}${theme.boxRound.vertical}`;
-	}
-
 	#copySelected() {
 		const selectedPayload = buildLogCopyPayload(this.#model.getSelectedRawLines());
 		const selected = selectedPayload.length === 0 ? [] : selectedPayload.split("\n");

package/src/debug/raw-sse.ts

@@ -1,13 +1,6 @@
-import {
-	type Component,
-	matchesKey,
-	padding,
-	replaceTabs,
-	ScrollView,
-	truncateToWidth,
-	visibleWidth,
-} from "@oh-my-pi/pi-tui";
+import { type Component, matchesKey, parseSgrMouse, replaceTabs, ScrollView, truncateToWidth } from "@oh-my-pi/pi-tui";
 import { sanitizeText } from "@oh-my-pi/pi-utils";
+import { bottomBorder, divider, row, topBorder } from "../modes/components/overlay-box";
 import { theme } from "../modes/theme/theme";
 import { copyToClipboard } from "../utils/clipboard";
 import {
@@ -17,8 +10,8 @@ import {
 	rawSseRecordLines,
 } from "./raw-sse-buffer";
 
-const MIN_VIEWER_WIDTH = 20;
-const VIEWER_FRAME_LINES = 5;
+const MIN_VIEWER_WIDTH = 40;
+const VIEWER_CHROME_LINES = 6;
 // `data:` lines below this width render fine on a single row; anything wider gets pretty-printed
 // across multiple `data:` lines so streamed JSON blobs stop getting clipped by `truncateToWidth`.
 const PRETTY_PRINT_DATA_THRESHOLD = 100;
@@ -79,6 +72,8 @@ export class RawSseViewerComponent implements Component {
 	#followTail = true;
 	#lastRenderWidth = MIN_VIEWER_WIDTH;
 	#statusMessage: string | undefined;
+	#bodyRowStart = 0;
+	#bodyRowCount = 0;
 	// Pretty-printed wire lines keyed by `record.sequence`. Pretty-printing is
 	// the JSON.parse + JSON.stringify per `data:` line, so we cache the result —
 	// the render path runs on every keypress and from `#maxScrollOffset()`.
@@ -98,9 +93,17 @@ export class RawSseViewerComponent implements Component {
 		});
 	}
 
+	dispose(): void {
+		this.#unsubscribe();
+	}
+
 	handleInput(keyData: string): void {
+		if (keyData.startsWith("\x1b[<") && this.#handleMouse(keyData)) {
+			return;
+		}
+
 		if (matchesKey(keyData, "escape") || matchesKey(keyData, "esc")) {
-			this.#unsubscribe();
+			this.dispose();
 			this.#onExit();
 			return;
 		}
@@ -145,15 +148,44 @@ export class RawSseViewerComponent implements Component {
 		}
 	}
 
+	#handleMouse(keyData: string): boolean {
+		const event = parseSgrMouse(keyData);
+		if (!event) return false;
+
+		const overBody = event.row >= this.#bodyRowStart && event.row < this.#bodyRowStart + this.#bodyRowCount;
+		if (event.wheel !== null && overBody) {
+			this.#followTail = false;
+			this.#scrollOffset = Math.max(0, Math.min(this.#maxScrollOffset(), this.#scrollOffset + event.wheel * 3));
+			this.#onUpdate?.();
+			return true;
+		}
+
+		if (!event.leftClick) return false;
+		if (event.row === 1) {
+			this.#followTail = !this.#followTail;
+			this.#followIfNeeded();
+			this.#onUpdate?.();
+			return true;
+		}
+		if (overBody) {
+			this.#followTail = false;
+			const clickedOffset = this.#scrollOffset + event.row - this.#bodyRowStart;
+			this.#scrollOffset = Math.max(0, Math.min(this.#maxScrollOffset(), clickedOffset));
+			this.#onUpdate?.();
+			return true;
+		}
+		return false;
+	}
+
 	invalidate(): void {}
 
 	render(width: number): readonly string[] {
 		this.#lastRenderWidth = Math.max(MIN_VIEWER_WIDTH, width);
 		this.#followIfNeeded();
 
-		const innerWidth = Math.max(1, this.#lastRenderWidth - 2);
+		const contentWidth = Math.max(1, this.#lastRenderWidth - 4);
 		const bodyHeight = this.#bodyHeight();
-		const rawLines = this.#renderRawLines(innerWidth);
+		const rawLines = this.#renderRawLines(contentWidth);
 		const sv = new ScrollView(rawLines.slice(this.#scrollOffset, this.#scrollOffset + bodyHeight), {
 			height: bodyHeight,
 			scrollbar: "auto",
@@ -161,15 +193,18 @@ export class RawSseViewerComponent implements Component {
 			theme: { track: t => theme.fg("muted", t), thumb: t => theme.fg("accent", t) },
 		});
 		sv.setScrollOffset(this.#scrollOffset);
-		const bodyRows = sv.render(innerWidth);
+		const bodyRows = sv.render(contentWidth);
+		this.#bodyRowStart = 3;
+		this.#bodyRowCount = bodyHeight;
 
 		return [
-			this.#frameTop(innerWidth),
-			this.#frameLine(this.#summaryText(), innerWidth),
-			this.#frameSeparator(innerWidth),
-			...bodyRows.map(line => this.#frameLine(line, innerWidth)),
-			this.#frameLine(this.#statusText(), innerWidth),
-			this.#frameBottom(innerWidth),
+			topBorder(this.#lastRenderWidth, "Raw Provider Stream"),
+			row(this.#summaryText(), this.#lastRenderWidth),
+			divider(this.#lastRenderWidth),
+			...bodyRows.map(line => row(line, this.#lastRenderWidth)),
+			divider(this.#lastRenderWidth),
+			row(this.#statusText(), this.#lastRenderWidth),
+			bottomBorder(this.#lastRenderWidth),
 		];
 	}
 
@@ -221,22 +256,25 @@ export class RawSseViewerComponent implements Component {
 			if (key < firstSequence) this.#prettyLinesCache.delete(key);
 		}
 	}
-
 	#summaryText(): string {
 		const snapshot = this.#buffer.snapshot();
-		const last = snapshot.lastUpdatedAt ? ` last=${formatRawSseIsoTime(snapshot.lastUpdatedAt)}` : "";
-		const follow = this.#followTail ? "follow:on" : "follow:off";
-		return ` # raw provider stream (SSE + WS) | events=${snapshot.totalEvents} records=${snapshot.records.length}${last} | ${follow} | Esc back Ctrl+C copy End follow`;
+		const last = snapshot.lastUpdatedAt
+			? `${theme.fg("muted", "last")} ${theme.fg("accent", formatRawSseIsoTime(snapshot.lastUpdatedAt))}`
+			: theme.fg("muted", "waiting for first frame");
+		const follow = this.#followTail ? theme.fg("success", "follow on") : theme.fg("warning", "follow off");
+		return `${theme.fg("muted", "events")} ${theme.fg("accent", String(snapshot.totalEvents))}  ${theme.fg("muted", "records")} ${theme.fg("accent", String(snapshot.records.length))}  ${last}  ${follow}`;
 	}
 
 	#statusText(): string {
-		return this.#statusMessage ?? " Up/Down scroll  PgUp/PgDn page";
+		const help = "Esc close · Ctrl+C copy raw · End follow tail · wheel scroll · click summary toggles follow";
+		return this.#statusMessage
+			? `${theme.fg("success", this.#statusMessage)}  ${theme.fg("dim", help)}`
+			: theme.fg("dim", help);
 	}
 
 	#bodyHeight(): number {
-		return Math.max(3, this.#terminalRows - VIEWER_FRAME_LINES);
+		return Math.max(3, (process.stdout.rows || this.#terminalRows || 24) - VIEWER_CHROME_LINES);
 	}
-
 	#followIfNeeded(): void {
 		if (this.#followTail) this.#scrollToTail();
 	}
@@ -246,8 +284,8 @@ export class RawSseViewerComponent implements Component {
 	}
 
 	#maxScrollOffset(): number {
-		const innerWidth = Math.max(1, this.#lastRenderWidth - 2);
-		return Math.max(0, this.#renderRawLines(innerWidth).length - this.#bodyHeight());
+		const contentWidth = Math.max(1, this.#lastRenderWidth - 4);
+		return Math.max(0, this.#renderRawLines(contentWidth).length - this.#bodyHeight());
 	}
 
 	#copyAll(): void {
@@ -271,22 +309,4 @@ export class RawSseViewerComponent implements Component {
 		}
 		this.#onUpdate?.();
 	}
-
-	#frameTop(innerWidth: number): string {
-		return `${theme.boxRound.topLeft}${theme.boxRound.horizontal.repeat(innerWidth)}${theme.boxRound.topRight}`;
-	}
-
-	#frameSeparator(innerWidth: number): string {
-		return `${theme.boxRound.teeRight}${theme.boxRound.horizontal.repeat(innerWidth)}${theme.boxRound.teeLeft}`;
-	}
-
-	#frameBottom(innerWidth: number): string {
-		return `${theme.boxRound.bottomLeft}${theme.boxRound.horizontal.repeat(innerWidth)}${theme.boxRound.bottomRight}`;
-	}
-
-	#frameLine(content: string, innerWidth: number): string {
-		const truncated = truncateToWidth(content, innerWidth);
-		const remaining = Math.max(0, innerWidth - visibleWidth(truncated));
-		return `${theme.boxRound.vertical}${truncated}${padding(remaining)}${theme.boxRound.vertical}`;
-	}
 }

package/src/discovery/codex.ts

@@ -342,12 +342,20 @@ async function loadHooks(ctx: LoadContext): Promise<LoadResult<Hook>> {
 	const codexDir = getProjectCodexDir(ctx);
 	const projectHooksDir = path.join(codexDir, "hooks");
 
+	// OMP hooks must be named `pre-<tool>.<ts|js>` or `post-<tool>.<ts|js>`.
+	// Files without that prefix are not OMP hooks (e.g. the standalone Codex
+	// hook scripts users keep alongside) — silently dropping the prefix and
+	// defaulting to `pre:<basename>` caused those scripts to be imported as
+	// extension factories and any top-level `process.exit()` killed startup
+	// (#3680).
 	const transformHook =
-		(level: "user" | "project") => (name: string, _content: string, path: string, source: SourceMeta) => {
+		(level: "user" | "project") =>
+		(name: string, _content: string, path: string, source: SourceMeta): Hook | null => {
 			const baseName = name.replace(/\.(ts|js)$/, "");
 			const match = baseName.match(/^(pre|post)-(.+)$/);
-			const hookType = (match?.[1] as "pre" | "post") || "pre";
-			const toolName = match?.[2] || baseName;
+			if (!match) return null;
+			const hookType = match[1] as "pre" | "post";
+			const toolName = match[2];
 			return {
 				name,
 				path,
@@ -359,11 +367,11 @@ async function loadHooks(ctx: LoadContext): Promise<LoadResult<Hook>> {
 		};
 
 	const results = await Promise.all([
-		loadFilesFromDir(ctx, userHooksDir, PROVIDER_ID, "user", {
+		loadFilesFromDir<Hook>(ctx, userHooksDir, PROVIDER_ID, "user", {
 			extensions: ["ts", "js"],
 			transform: transformHook("user"),
 		}),
-		loadFilesFromDir(ctx, projectHooksDir, PROVIDER_ID, "project", {
+		loadFilesFromDir<Hook>(ctx, projectHooksDir, PROVIDER_ID, "project", {
 			extensions: ["ts", "js"],
 			transform: transformHook("project"),
 		}),

package/src/edit/hashline/diff.ts

@@ -9,6 +9,7 @@
  * match is accepted even when the tag was minted by a source that did not keep
  * history, and stale tags recover through the session snapshot store when possible.
  */
+import * as path from "node:path";
 import {
 	type ApplyResult,
 	applyEdits,
@@ -30,6 +31,7 @@ import {
 } from "@oh-my-pi/hashline";
 import { resolveToCwd } from "../../tools/path-utils";
 import { generateDiffString } from "../diff";
+import { canonicalSnapshotKey } from "../file-snapshot-store";
 import { readEditFileText } from "../read-file";
 import { nativeBlockResolver } from "./block-resolver";
 
@@ -90,6 +92,54 @@ async function readSectionTextCached(absolutePath: string, sectionPath: string):
 	return rawContent;
 }
 
+/**
+ * Resolve a missing authored path to a file read this session by matching its
+ * basename and snapshot tag, mirroring {@link Patcher}'s apply-time recovery so
+ * a bare/wrong-directory `[basename#tag]` header previews against the same file
+ * the edit will land on. Returns `undefined` when no unique basename+tag match
+ * exists, leaving the caller to surface the original read error.
+ */
+function recoverSectionPathFromTag(
+	section: PatchSection,
+	authoredAbsolutePath: string,
+	snapshots: SnapshotStore,
+): string | undefined {
+	if (section.fileHash === undefined) return undefined;
+	const authoredName = path.basename(section.path);
+	const authoredKey = canonicalSnapshotKey(authoredAbsolutePath);
+	const candidates = [
+		...new Set(
+			snapshots
+				.findByHash(section.fileHash)
+				.filter(snapshot => path.basename(snapshot.path) === authoredName)
+				.map(snapshot => snapshot.path),
+		),
+	].filter(candidate => candidate !== authoredKey);
+	return candidates.length === 1 ? candidates[0] : undefined;
+}
+
+/**
+ * Read the section's target file for a preview, recovering a bare/mis-typed
+ * `[basename#tag]` path onto the file its tag uniquely names. Recovery fires
+ * only when the authored path is absent — matching {@link Patcher}'s apply-time
+ * order — so a permission/parse error on an existing file surfaces against the
+ * authored path instead of silently previewing a different tagged file. Returns
+ * the path actually read so callers key snapshot lookups off the same file.
+ */
+async function readSectionForPreview(
+	section: PatchSection,
+	authoredAbsolutePath: string,
+	snapshots: SnapshotStore,
+	streaming: boolean | undefined,
+): Promise<{ absolutePath: string; rawContent: string }> {
+	const read = streaming ? readSectionTextCached : readSectionText;
+	const recovered = (await Bun.file(authoredAbsolutePath).exists())
+		? undefined
+		: recoverSectionPathFromTag(section, authoredAbsolutePath, snapshots);
+	const target = recovered ?? authoredAbsolutePath;
+	return { absolutePath: target, rawContent: await read(target, section.path) };
+}
+
 function hasAnchorScopedEdit(edits: readonly Edit[]): boolean {
 	return edits.some(edit => {
 		if (edit.kind === "delete") return true;
@@ -258,10 +308,13 @@ export async function computeHashlineSectionDiff(
 	options: HashlineDiffOptions = {},
 ): Promise<{ diff: string; firstChangedLine: number | undefined } | { error: string }> {
 	try {
-		const absolutePath = resolveToCwd(section.path, cwd);
-		const rawContent = options.streaming
-			? await readSectionTextCached(absolutePath, section.path)
-			: await readSectionText(absolutePath, section.path);
+		const authoredPath = resolveToCwd(section.path, cwd);
+		const { absolutePath, rawContent } = await readSectionForPreview(
+			section,
+			authoredPath,
+			snapshots,
+			options.streaming,
+		);
 		const { text: content } = stripBom(rawContent);
 		const normalized = normalizeToLF(content);
 		// Streaming favors a stable, monotonic preview over an exact unified

package/src/eval/js/shared/local-module-loader.ts

@@ -29,6 +29,7 @@ export class LocalModuleLoader {
 	#externalModules = new Map<string, Promise<vm.Module>>();
 	#requireCache = new Map<string, NodeJS.Require>();
 	#modulePaths = new WeakMap<vm.Module, string>();
+	#linkChain: Promise<void> = Promise.resolve();
 
 	constructor(sessionId: string) {
 		this.#context = vm.createContext(globalThis);
@@ -147,7 +148,17 @@ export class LocalModuleLoader {
 	async #linkAndEvaluate(entry: LocalModuleEntry, modulePath: string): Promise<void> {
 		const { module } = entry;
 		try {
-			if (module.status === "unlinked") await module.link(this.#linkResolve);
+			// Serialize the link phase across every graph root. Bun's node:vm linker
+			// segfaults (getImportedModule on a null record) when two link passes
+			// instantiate overlapping module instances concurrently — e.g.
+			// Promise.all([import("./a"), import("./b")]) over a graph that shares
+			// dependencies. Holding the lock for the whole module.link() (including its
+			// async resolver callbacks) guarantees the linker is never re-entered
+			// mid-instantiation. The lock is released before evaluate(), so a dynamic
+			// import during evaluation can re-acquire it without deadlock.
+			await this.#serializeLink(async () => {
+				if (module.status === "unlinked") await module.link(this.#linkResolve);
+			});
 			if (module.status === "linked") await module.evaluate();
 		} catch (error) {
 			this.#invalidateFailedLoad(modulePath);
@@ -159,6 +170,17 @@ export class LocalModuleLoader {
 		}
 	}
 
+	// Promise-chain mutex serializing node:vm link passes (see #linkAndEvaluate).
+	// #linkChain is kept non-rejecting so a failed link never wedges the queue.
+	#serializeLink<T>(run: () => Promise<T>): Promise<T> {
+		const result = this.#linkChain.then(run);
+		this.#linkChain = result.then(
+			() => undefined,
+			() => undefined,
+		);
+		return result;
+	}
+
 	// Shared static-link resolver for `module.link()`. node:vm passes the referencing
 	// module and reuses this one resolver for the entire graph, so the referrer path is
 	// recovered from `#modulePaths`. Local dependencies are constructed but NOT linked or

package/src/export/html/template.js

@@ -1236,7 +1236,7 @@
         let html = `
           <div class="header">
             <h1>Session: ${escapeHtml(header?.id || 'unknown')}</h1>
-            <div class="help-bar">Ctrl+T toggle thinking · Ctrl+O toggle tools</div>
+            <div class="help-bar">T toggle thinking · O toggle tools</div>
             <div class="header-info">
               <div class="info-item"><span class="info-label">Date:</span><span class="info-value">${header?.timestamp ? new Date(header.timestamp).toLocaleString() : 'unknown'}</span></div>
               <div class="info-item"><span class="info-label">Models:</span><span class="info-value">${globalStats.models.join(', ') || 'unknown'}</span></div>
@@ -1580,13 +1580,19 @@
           searchQuery = '';
           navigateTo(leafId, 'bottom');
         }
-        if (e.ctrlKey && e.key === 't') {
+        if (e.key === 't' || e.key === 'T' || e.key === 'o' || e.key === 'O') {
+          // Skip when typing in the sidebar search (or any other editable target)
+          // so the chord can't fire on a user's letter input. Avoid Ctrl/Cmd-based
+          // chords entirely — every major browser reserves Ctrl+T (new tab) and
+          // Ctrl+O (open file), so the shortcut would never reach the page.
+          const t = e.target;
+          const editable =
+            t && (t.tagName === 'INPUT' || t.tagName === 'TEXTAREA' || t.isContentEditable);
+          if (editable) return;
+          if (e.ctrlKey || e.metaKey || e.altKey) return;
           e.preventDefault();
-          toggleThinking();
-        }
-        if (e.ctrlKey && e.key === 'o') {
-          e.preventDefault();
-          toggleToolOutputs();
+          if (e.key === 't' || e.key === 'T') toggleThinking();
+          else toggleToolOutputs();
         }
       });