@gavin-hu/my-pi-agent 0.15.0 → 0.15.1

package/extensions/rewind/git.ts

@@ -20,6 +20,7 @@ import {
 	gitDir,
 	repoRoot,
 	revParse,
+	revParseMany,
 	runGitOrThrow as run,
 	type RunGit,
 } from "../../lib/git/index.ts";
@@ -27,7 +28,7 @@ import { parseNameStatus, parseNumStat, type ChangedPath, type PathStat } from "
 
 // Re-export exactly the shared helpers this extension consumes, so rewind code
 // has one git import surface instead of reaching into `lib/git` directly.
-export { GitError, currentBranch, gitDir, repoRoot, revParse, type RunGit };
+export { GitError, currentBranch, gitDir, repoRoot, revParse, revParseMany, type RunGit };
 
 /** Timeout budget for one git command issued by this extension. */
 const SNAPSHOT_TIMEOUT_MS = 30_000;
@@ -262,20 +263,32 @@ export async function applyPatchReverse(runGit: RunGit, cwd: string, patch: stri
 	}
 }
 
-/** Label of an in-progress git operation that a rewind must not clobber, if any. */
+/**
+ * The markers an interrupted git operation leaves, in precedence order: the
+ * first one present names the operation a rewind would clobber.
+ */
+const BUSY_MARKERS: ReadonlyArray<readonly [string, string]> = [
+	["MERGE_HEAD", "merge"],
+	["rebase-merge", "rebase"],
+	["rebase-apply", "rebase"],
+	["CHERRY_PICK_HEAD", "cherry-pick"],
+	["REVERT_HEAD", "revert"],
+	["BISECT_LOG", "bisect"],
+];
+
+/**
+ * Label of an in-progress git operation that a rewind must not clobber, if any.
+ *
+ * `rev-parse --git-path` prints one path per argument, so all six markers are one
+ * git call: a clean repository — the common case, where every one of them is
+ * missing — would otherwise pay six spawns to learn nothing is in progress.
+ */
 export async function busyGitState(runGit: RunGit, cwd: string): Promise<string | undefined> {
-	const markers: Array<[string, string]> = [
-		["MERGE_HEAD", "merge"],
-		["rebase-merge", "rebase"],
-		["rebase-apply", "rebase"],
-		["CHERRY_PICK_HEAD", "cherry-pick"],
-		["REVERT_HEAD", "revert"],
-		["BISECT_LOG", "bisect"],
-	];
-	for (const [name, label] of markers) {
-		const result = await runGit(["rev-parse", "--git-path", name], { cwd });
-		if (result.code !== 0) continue;
-		const path = result.stdout.trim();
+	const result = await runGit(["rev-parse", ...BUSY_MARKERS.flatMap(([name]) => ["--git-path", name])], { cwd });
+	if (result.code !== 0) return undefined;
+	const paths = result.stdout.split("\n");
+	for (const [index, [, label]] of BUSY_MARKERS.entries()) {
+		const path = paths[index]?.trim();
 		if (path && existsSync(resolve(cwd, path))) return label;
 	}
 	return undefined;

package/extensions/rewind/hunk-picker.ts

@@ -94,7 +94,7 @@ export class HunkPickerComponent extends ChecklistScreen<HunkRow> {
 
 	/** The focused hunk's first removed and added line. */
 	protected detailLines(width: number): string[] {
-		const focused = this.focused;
+		const focused = this.focusedRow;
 		if (!focused) return [];
 		return previewOf(focused.hunk).map((line) => {
 			const role = line.startsWith("+") ? "ok" : line.startsWith("-") ? "bad" : "meta";

package/extensions/rewind/path-picker.ts

@@ -137,7 +137,7 @@ export class PathPickerComponent extends ChecklistScreen<Row> {
 
 	/** What the focused row will do, in words. */
 	protected detailLines(width: number): string[] {
-		const row = this.focused;
+		const row = this.focusedRow;
 		if (!row) return [];
 		const text =
 			row.kind === "group"

package/extensions/rewind/review-tui.ts

@@ -133,7 +133,7 @@ export class ReviewListComponent extends ChecklistScreen<ReviewEntry> {
 	}
 
 	protected onEnter(): void {
-		const entry = this.focused;
+		const entry = this.focusedRow;
 		if (entry) this.close({ kind: "diff", path: entry.path });
 	}
 
@@ -142,7 +142,7 @@ export class ReviewListComponent extends ChecklistScreen<ReviewEntry> {
 	}
 
 	protected verb(data: string): void {
-		const entry = this.focused;
+		const entry = this.focusedRow;
 		if (!entry) return;
 		if (data === "r") {
 			const paths = this.chosen.size > 0 ? [...this.chosen] : [entry.path];
@@ -174,7 +174,7 @@ export class ReviewListComponent extends ChecklistScreen<ReviewEntry> {
 
 	protected detailLines(width: number): string[] {
 		const detail: string[] = [];
-		const focused = this.focused;
+		const focused = this.focusedRow;
 		if (focused) detail.push(clip(`  ${paint(this.theme, "meta", formatReviewDetail(focused))}`, width));
 		const selectionLine =
 			this.chosen.size > 0

package/extensions/rewind/snapshot.ts

@@ -8,7 +8,15 @@
  * touched: all staging happens in a temporary index.
  */
 
-import { commitTree, currentBranch, revParse, treeFromWorkingTree, updateRef, GitError, type RunGit } from "./git.ts";
+import {
+	commitTree,
+	currentBranch,
+	treeFromWorkingTree,
+	updateRef,
+	GitError,
+	revParseMany,
+	type RunGit,
+} from "./git.ts";
 import { encodeMessage, refFor, META_VERSION, type SnapshotMeta } from "./store.ts";
 import type { Snapshot, SnapshotReason } from "./types.ts";
 
@@ -44,11 +52,12 @@ function defaultId(now: number): string {
 /** Point a ref at the current working tree and return the recorded snapshot. */
 export async function createSnapshot(deps: SnapshotDeps, input: SnapshotInput): Promise<Snapshot> {
 	const { runGit } = deps;
-	const head = await revParse(runGit, input.root, "HEAD");
-	if (!head) throw new GitError("the repository has no commits to snapshot.", 1);
+	// One `rev-parse` for both ids: the snapshot needs HEAD to parent the commit
+	// and HEAD's tree to know whether the working tree is clean.
+	const [head, headTree] = await revParseMany(runGit, input.root, ["HEAD", "HEAD^{tree}"]);
+	if (!head || !headTree) throw new GitError("the repository has no commits to snapshot.", 1);
 
 	const tree = await treeFromWorkingTree(runGit, input.root, input.indexFile, input.includeUntracked);
-	const headTree = await revParse(runGit, input.root, "HEAD^{tree}");
 	const clean = tree === headTree;
 
 	const now = deps.now?.() ?? Date.now();

package/extensions/subagent/background-tui.ts

@@ -161,7 +161,7 @@ export class AgentsBoardComponent extends DockListScreen<BackgroundRun> {
 	}
 
 	protected listHints(): ScreenHint[] {
-		const focused = this.focused;
+		const focused = this.focusedRow;
 		const hints: ScreenHint[] = ["Esc close", { text: "Enter detail", color: "accent" }];
 		if (focused && canCollect(focused)) hints.push({ text: "c collect", color: "accent" });
 		if (focused?.status === "running") hints.push({ text: "x cancel", color: "warning" });

package/extensions/worktree/status.ts

@@ -6,9 +6,10 @@
 import { basename } from "node:path";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { realPathOfNearest } from "../../lib/path.ts";
+import { mapConcurrent } from "../../lib/pool.ts";
 import { loadConfig } from "./config.ts";
 import { gapLines, isolationGaps } from "./gaps.ts";
-import { type CheckoutCheck, defaultBranch, listManagedWorktrees, repoRoot } from "./git.ts";
+import { type CheckoutCheck, defaultBranch, listManagedWorktrees, type ManagedWorktree, repoRoot } from "./git.ts";
 import { reconcileRegistry, statusOf, type CheckoutStatus } from "./registry.ts";
 import { configFor, getActive, getInactiveOverrides, getUnverifiableCommands } from "./runtime.ts";
 import type { WorktreeState } from "./state.ts";
@@ -115,15 +116,19 @@ export async function worktreeStatus(pi: ExtensionAPI, ctx: ExtensionContext): P
 		const { registry } = reconcileRegistry(root, config, managed, { persist: false });
 		const baseBranch = await defaultBranch(pi, root);
 		const baseRef = baseBranch ? `origin/${baseBranch}` : undefined;
-		lines.push("", `Managed worktrees (${managed.length}):`);
-		for (const entry of managed) {
-			const record = registry.worktrees.find((candidate) => candidate.path === realPathOfNearest(entry.path));
-			const status = await statusOf(pi, entry, { baseRef, record });
+		// Keyed by the canonical path the registry stores, so a row's record is one
+		// lookup instead of a scan of every record.
+		const records = new Map(registry.worktrees.map((record) => [record.path, record]));
+		const row = async (entry: ManagedWorktree): Promise<string> => {
+			const path = realPathOfNearest(entry.path);
+			const status = await statusOf(pi, entry, { baseRef, record: records.get(path) });
 			const marks = statusMarks(status, current?.path === entry.path);
-			lines.push(
-				`  ${entry.path}  ${entry.branch ?? ""}${marks.length > 0 ? `  [${marks.join(", ")}]` : ""}`.trimEnd(),
-			);
-		}
+			return `  ${entry.path}  ${entry.branch ?? ""}${marks.length > 0 ? `  [${marks.join(", ")}]` : ""}`.trimEnd();
+		};
+		// Each row is up to four git reads; four at a time keeps the list in the order
+		// git reports while overlapping the waits. `statusOf` passes no `env`, which is
+		// what makes concurrent git calls safe here (see `RunGitOptions.env`).
+		lines.push("", `Managed worktrees (${managed.length}):`, ...(await mapConcurrent(managed, 4, row)));
 	}
 	return lines.join("\n");
 }

package/lib/README.md

@@ -27,10 +27,11 @@ belongs in that extension instead — see `extensions/web-access/http.ts` and
 | [`errors.ts`](./errors.ts) | `messageOf`: the one boundary that turns an unknown thrown value into a user-facing line (an `Error` yields its message, anything else is stringified). |
 | [`format.ts`](./format.ts) | Pure text/number formatting shared by renderers: `formatTokens`, `formatCount`, `formatDuration` (`450ms`, `3.2s`, `1m05s`, `2h03m`), `boundedTail` (the end of a joined tail with a `truncated` flag), `stripControlChars`, `sanitize`, `sanitizeLine` — the boundary for untrusted, single-line text — `lineOf` (a value read as one sanitized line), `sanitizeUntrustedLine` / `sanitizeUntrustedText` with `MAX_OUTPUT_LINE` for **program output** (OSC/CSI escapes removed whole, `\r` progress resolved, clipped), and `shortenPath`. |
 | [`lines.ts`](./lines.ts) | `LineSplitter`, the byte-safe splitter for a stream of program output: buffers bytes and decodes only at a newline, so a UTF-8 character split across two reads survives, and caps an over-long line instead of dropping it. Shared by `job`, `watch`, `check`, and `subagent`. |
+| [`pool.ts`](./pool.ts) | `mapConcurrent`: one async read per entry with at most `limit` calls in flight and results in input order, so a directory listing or a status sweep fans out without an unbounded burst or a per-entry round trip. Shared by `file-browse` and `worktree`. |
 | [`interaction.ts`](./interaction.ts) | Turn-affinity prompt contract: the channel a remote transport marks on the UI context it owns (`INTERACTION_TURN_KEY`), the `InteractionChannel` interface (`request` / `post` / `postFile`), and `remoteChannel` / `isRemoteTurn` / `supportsCustomUI` / `askHuman` (with an optional file, fallback text, and digest preface) plus the shared “Other” label. |
-| [`git/`](./git/) | Shared git plumbing. [`git/runner.ts`](./git/runner.ts) is the `RunGit` seam (`createExecRunner` with timeout/env handling, `runGitOrThrow`, `GitError`); [`git/read.ts`](./git/read.ts) holds the read helpers (`repoRoot`, `repoRootFor`, `gitDir`, `gitCommonDir`, `revParse`, `hasCommits`, `currentBranch`); [`git/index.ts`](./git/index.ts) is the barrel. |
+| [`git/`](./git/) | Shared git plumbing. [`git/runner.ts`](./git/runner.ts) is the `RunGit` seam (`createExecRunner` with timeout/env handling, `runGitOrThrow`, `GitError`); [`git/read.ts`](./git/read.ts) holds the read helpers (`repoRoot`, `repoRootFor`, `gitDir`, `gitCommonDir`, `revParse`, `revParseMany` for several revisions in one call, `hasCommits`, `currentBranch`); [`git/index.ts`](./git/index.ts) is the barrel. |
 | [`highlight.ts`](./highlight.ts) | First-party, escape-first syntax tokenizer (`detectLanguage`, `fenceLanguage`, `highlightLines`, `HighlightLanguage`, `TokenClass`) for js/ts, json, css, html, shell, python, java, yaml, and sql; shared by `file-browse` and plan's code blocks. |
-| [`http/`](./http/) | The loopback HTTP layer shared by `file-browse` and `plan`: [`http/headers.ts`](./http/headers.ts) (the page policy `PAGE_CSP` and the `pageHeaders` / `scriptHeaders` / `jsonHeaders` sets), [`http/response.ts`](./http/response.ts) (`ServeResponse` — a buffered body, a `filePath` stream, or an SSE `stream` — plus `htmlResponse` / `jsonResponse` / `jsonError` / `textResponse`), [`http/router.ts`](./http/router.ts) (`parseRequestUrl`, and `isLocalHostHeader` with the `required` mode each server chooses), [`http/server.ts`](./http/server.ts) (`bindLoopback` on `127.0.0.1` with the accept-error listener, `respond` for HEAD / streamed file / body, and the idempotent `createCloser`), and the [`http/index.ts`](./http/index.ts) barrel. |
+| [`http/`](./http/) | The loopback HTTP layer shared by `file-browse` and `plan`: [`http/headers.ts`](./http/headers.ts) (the page policy `PAGE_CSP` and the `pageHeaders` / `scriptHeaders` / `jsonHeaders` sets, plus `eventHeaders` for the one long-lived stream), [`http/response.ts`](./http/response.ts) (`ServeResponse` — a buffered body, a `filePath` stream, or an SSE `stream` — plus `htmlResponse` / `jsonResponse` / `jsonError` / `textResponse`), [`http/router.ts`](./http/router.ts) (`parseRequestUrl`, and `isLocalHostHeader` with the `required` mode each server chooses), [`http/server.ts`](./http/server.ts) (`bindLoopback` on `127.0.0.1` with the accept-error listener, `respond` for HEAD / streamed file / body, `openEventStream` for the head and reconnect hint of an SSE response, and the idempotent `createCloser`), and the [`http/index.ts`](./http/index.ts) barrel. |
 | [`tui/`](./tui/) | The Bytefly terminal design system shared by every interactive surface, whose conventions are its own doc, [`tui/README.md`](./tui/README.md). Modules: [`tui/tokens.ts`](./tui/tokens.ts) (semantic role -> theme color, `paint`), [`tui/glyphs.ts`](./tui/glyphs.ts) (`GLYPHS`, `SEPARATORS`, `STATUS_KEYS`, `EXPAND_KEYBINDING` with `expandKey` / `expandHint`, `GLYPH_GAP` — the vocabulary both sides of a status must agree on), [`tui/chrome.ts`](./tui/chrome.ts) (`screenHint`, `dockListFrame` (the docked-list frame) with `detailBlockRows` (the rows its detail block costs), `viewportRows`, `FULL_SCREEN_OVERLAY`, `reuseText`, `editorTheme`), [`tui/rules.ts`](./tui/rules.ts) (the rule glyph `RULE_GLYPH`, and `plainRule` / `titleRule` / `centeredRule`), [`tui/indent.ts`](./tui/indent.ts) (the transcript block indent: `BODY_INDENT`, an optional rail prefix that a wrapped call line is kept out of, and `bodyLines` / `indentBlockLines` / `indentedLines`), [`tui/rows.ts`](./tui/rows.ts) (`listRow`, `statusRow`, `checkbox`, `chip`, `keyValueRow`, `emptyState`, `byRunningFirst` for a live list's order), [`tui/columns.ts`](./tui/columns.ts) (`splitRow`, `fitCells`, `flowCells`, `padTo`, `clip`, `clipMiddle`, `labelLine` / `clipLabel` with `LABEL_WIDTH`), [`tui/gauge.ts`](./tui/gauge.ts) (`computeGauge`, `gaugeRole`, `gaugeBar`), [`tui/line-pane.ts`](./tui/line-pane.ts) (`LinePane`, the scrollable log/match pane), [`tui/status-controller.ts`](./tui/status-controller.ts) (`createStatusController`, the footer chips `job`, `watch`, and `subagent` share, with the attached-context `notify` and a `detach` that clears its keys), [`tui/dock-screen.ts`](./tui/dock-screen.ts) (`DockListScreen`, the two-mode docked list + detail-pane screen with navigation, wheel, range, and confirm), [`tui/confirm.ts`](./tui/confirm.ts) (`ConfirmState`, the y/N layer behind every destructive screen action), [`tui/tool.ts`](./tui/tool.ts) (`toolCallTitle`, the width-safe `ToolCallText` / `reuseCallText`, sanitized `errorLine` / `rejectionLine`, `moreHint` / `overflowHint` / `earlierHint`, the `TailResult` transcript block, `syncElapsedTimer`, `elapsedSuffix` — the tool-transcript kit), [`tui/render-cache.ts`](./tui/render-cache.ts) (`RenderCache`: the per-instance line memo a component that derives its lines from another component's output renders through, so a repeat frame is one comparison), and [`tui/cursor.ts`](./tui/cursor.ts) (scroll and navigation: `fitRows`, `keepVisible`, `clampScroll`, `navIntent`, `navigateList`, `navigateScroll`, `wheelDelta`, `scrollList`, `isCloseKey`, `selectionMarker`, `formatRange`, and the `ListCursor` (by index) and `IdCursor` (by stable id) state). |
 | [`path.ts`](./path.ts) | `isInside` (string containment) plus `realPathOfNearest` / `isInsideReal` (symlink-aware): the containment predicates the file-browse, worktree, doc, and plan guards share, and the canonical-path helper the worktree registry keys records by. |
 | [`pdf.ts`](./pdf.ts) | The optional `unpdf` seam shared by `web-access` and `document`: `pdfGuidance`, `PdfUnavailableError`, `pdfTextFromResult`, and the lazy `loadPdfExtractor` / `extractPdfText` (an injected extractor wins), so a missing package and a merged-pages result read the same way through either surface. |

package/lib/git/read.ts

@@ -70,6 +70,26 @@ export async function revParse(runGit: RunGit, cwd: string, rev: string): Promis
 	return id || undefined;
 }
 
+/**
+ * Resolve several revisions in one `git rev-parse`, in the order given.
+ *
+ * A snapshot needs `HEAD` and its tree, and two calls pay two spawns for one
+ * answer; `rev-parse` prints one line per argument, so one call is enough. A
+ * revision that does not resolve is not a shorter list — it is no answer, since
+ * the caller's indices would shift — so the result is `[]` unless every one
+ * resolved.
+ */
+export async function revParseMany(runGit: RunGit, cwd: string, revs: readonly string[]): Promise<string[]> {
+	if (revs.length === 0) return [];
+	const result = await runGit(["rev-parse", ...revs], { cwd });
+	if (result.code !== 0) return [];
+	const ids = result.stdout
+		.split("\n")
+		.map((line) => line.trim())
+		.filter((line) => line !== "");
+	return ids.length === revs.length ? ids : [];
+}
+
 /** Whether the repository has at least one commit. */
 export async function hasCommits(runGit: RunGit, cwd: string): Promise<boolean> {
 	return (await revParse(runGit, cwd, "HEAD")) !== undefined;

package/lib/http/headers.ts

@@ -52,3 +52,23 @@ export function scriptHeaders(): Record<string, string> {
 export function jsonHeaders(): Record<string, string> {
 	return secured("application/json; charset=utf-8");
 }
+
+/**
+ * Headers for a Server-Sent Events stream: the one response that is not the page
+ * policy, because it is a long-lived event stream rather than a document. It
+ * carries no policy of its own to relax — the page that opens it is the one
+ * governed by `PAGE_CSP` — but it is declared here so both loopback servers
+ * answer a stream the same way.
+ *
+ * `no-store` stops a cached stream from replaying stale status, `keep-alive`
+ * names the connection's intent, and `X-Accel-Buffering: no` is for any
+ * buffering reverse proxy in front of it, which would otherwise hold the frames.
+ */
+export function eventHeaders(): Record<string, string> {
+	return {
+		"Content-Type": "text/event-stream; charset=utf-8",
+		"Cache-Control": "no-store",
+		Connection: "keep-alive",
+		"X-Accel-Buffering": "no",
+	};
+}

package/lib/http/server.ts

@@ -5,9 +5,10 @@
  * Everything here is behavior a caller cannot get right by accident: a bind on
  * `127.0.0.1` only, an accept-level `error` listener so a transient failure
  * cannot take the host down, a `HEAD` that sends headers and no body, a `filePath`
- * response streamed instead of buffered, and a close that is safe to call twice
- * and drops keep-alive connections. What each server does *around* this — SSE
- * streams, request bodies, session settling — stays with that server.
+ * response streamed instead of buffered, a `stream` response opened as an event
+ * stream, and a close that is safe to call twice and drops keep-alive
+ * connections. What each server does *around* this — which frames an event
+ * stream carries, request bodies, session settling — stays with that server.
  */
 
 import { createReadStream } from "node:fs";
@@ -42,7 +43,7 @@ export async function bindLoopback(server: Server, port: number): Promise<number
  *
  * A `stream` response is deliberately not handled here: keeping a connection
  * open is the owning server's lifecycle, so it must check `stream` before
- * calling this.
+ * calling this and open the stream itself through {@link openEventStream}.
  *
  * `afterFlush` runs once a buffered body is on the wire, which is the point a
  * server may resolve a session without the client seeing a dropped connection.
@@ -68,6 +69,23 @@ export function respond(
 	response.end(result.body ?? "", afterFlush);
 }
 
+/**
+ * Write the head of a Server-Sent Events response and start its stream: the
+ * status and headers, then a `retry:` hint for the browser's own reconnect.
+ *
+ * The connection itself stays the calling server's lifecycle — `respond` must
+ * not be called after this, and the caller owns ending the response and any
+ * periodic frames.
+ */
+export function openEventStream(
+	response: ServerResponse,
+	result: Pick<ServeResponse, "status" | "headers">,
+	retryMs = 2000,
+): void {
+	response.writeHead(result.status, result.headers);
+	response.write(`retry: ${retryMs}\n\n`);
+}
+
 /**
  * An idempotent `close()` for `server`.
  *

package/lib/pool.ts

@@ -0,0 +1,62 @@
+/**
+ * Bounded concurrency for a fan-out over I/O.
+ *
+ * A directory listing and a managed-worktree status sweep both run one small
+ * read per entry — a `stat`, a git query — and each read is dominated by
+ * waiting, not by work. Run strictly in sequence, a directory of three thousand
+ * files pays three thousand round trips; run all at once, it hands the
+ * filesystem (or a git index lock) an unbounded burst. This is the middle: at
+ * most `limit` calls in flight, results in input order.
+ *
+ * The first rejection stops new work and is rethrown once every worker has
+ * settled, so a failure cannot leave a rejected promise unobserved.
+ *
+ * Value-only: one pure function over its arguments, no module state.
+ */
+
+/**
+ * Run `fn` over `items` with at most `limit` calls in flight, in input order.
+ *
+ * `limit` is clamped to `[1, items.length]`, so a caller may pass a configured
+ * width without guarding it. `fn` receives the item and its index; the returned
+ * array is in `items` order regardless of completion order. An empty input never
+ * calls `fn`.
+ */
+export async function mapConcurrent<T, R>(
+	items: readonly T[],
+	limit: number,
+	fn: (item: T, index: number) => Promise<R>,
+): Promise<R[]> {
+	const total = items.length;
+	if (total === 0) return [];
+	const width = Math.min(Math.max(1, Math.floor(limit)), total);
+	const results = new Array<R>(total);
+
+	let next = 0;
+	let failed = false;
+	let failure: unknown;
+
+	/** Take the next unclaimed index and run it; stop taking after a failure. */
+	const worker = async (): Promise<void> => {
+		for (;;) {
+			if (failed) return;
+			const index = next++;
+			if (index >= total) return;
+			try {
+				results[index] = await fn(items[index], index);
+			} catch (error) {
+				// Keep the first failure: a later one is a consequence of the work
+				// already in flight, not the cause the caller needs to read.
+				if (!failed) {
+					failed = true;
+					failure = error;
+				}
+				return;
+			}
+		}
+	};
+
+	await Promise.all(Array.from({ length: width }, worker));
+	if (failed) throw failure;
+	return results;
+}

package/lib/tui/dock-screen.ts

@@ -136,8 +136,16 @@ export abstract class DockListScreen<T> implements Component {
 		return this.options.theme;
 	}
 
-	/** The row under the cursor, if any. */
-	protected get focused(): T | undefined {
+	/**
+	 * The row under the cursor, if any.
+	 *
+	 * Not named `focused`: Pi's `Focusable` check is `"focused" in component`, and a
+	 * component that answers it is handed the focus flag by assignment
+	 * (`component.focused = true`). A read-only accessor under that name throws a
+	 * `TypeError` on the way back to the editor and takes the process with it. This
+	 * screen paints its own selection marker and needs no hardware cursor.
+	 */
+	protected get focusedRow(): T | undefined {
 		const rows = this.rows();
 		return rows[this.cursor.indexOf(rows, (row) => this.idOf(row))];
 	}
@@ -229,7 +237,7 @@ export abstract class DockListScreen<T> implements Component {
 	}
 
 	private openDetail(): void {
-		const row = this.focused;
+		const row = this.focusedRow;
 		if (!row) return;
 		const contents = this.detailFor(row);
 		this.mode = "detail";
@@ -274,7 +282,7 @@ export abstract class DockListScreen<T> implements Component {
 			this.openDetail();
 			return;
 		}
-		this.handleVerb(data, this.focused);
+		this.handleVerb(data, this.focusedRow);
 	}
 
 	private handleConfirmKey(data: string): void {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gavin-hu/my-pi-agent",
-  "version": "0.15.0",
+  "version": "0.15.1",
   "description": "Personal Pi customizations, packaged as a Pi package: worktree isolation and rewind snapshots, question, todo, goal, plan, subagent, job, watch, web-access, file-browse, file-open, document, check, memory, wechat, and bytefly.",
   "keywords": [
     "pi-package",