pi-crew 0.10.2 → 0.10.3

package/src/ui/transcript-cache.ts

@@ -3,11 +3,25 @@ import * as fs from "node:fs";
 export interface TranscriptCacheEntry {
 	path: string;
 	mtimeMs: number;
+	/**
+	 * Byte offset of the END of the cached text. Equals `offset + raw.length`
+	 * (normally the file size at read time; only smaller if a concurrent
+	 * writer shrank the file mid-read, which forces a fresh read next time).
+	 */
 	size: number;
+	/**
+	 * Byte offset of the START of the cached text. Zero for whole-file reads;
+	 * positive once the tail cap front-trims, because the cached text then
+	 * starts partway into the file — not at offset 0.
+	 */
+	offset: number;
+	/** Undecoded bytes backing the cached text, spanning [offset, size). */
+	raw: Buffer;
 	lines: string[];
 	parsedAt: number;
 	readCount: number;
 	mode: "tail" | "full";
+	/** Bytes actually read from disk on the most recent read (delta for appends). */
 	bytesRead: number;
 	truncated: boolean;
 }
@@ -47,34 +61,100 @@ export function getTranscriptCacheEntry(path: string, options: TranscriptReadOpt
 	return transcriptCache.get(cacheKey(path, normalized)) ?? transcriptCache.get(path);
 }
 
+interface TranscriptReadResult {
+	raw: Buffer;
+	offset: number;
+	bytesRead: number;
+	truncated: boolean;
+}
+
+/**
+ * Fresh read: whole file, or the last `maxTailBytes` bytes with the leading
+ * partial line skipped. Operates on raw bytes so a later append can extend
+ * the buffer and decode exactly like a fresh read of the same byte range.
+ */
 function readTranscriptText(
 	path: string,
 	stat: fs.Stats,
 	options: Required<Pick<TranscriptReadOptions, "full">> & {
 		maxTailBytes: number;
 	},
-): { text: string; bytesRead: number; truncated: boolean } {
+): TranscriptReadResult {
 	if (options.full || stat.size <= options.maxTailBytes) {
-		return {
-			text: fs.readFileSync(path, "utf-8"),
-			bytesRead: stat.size,
-			truncated: false,
-		};
+		const raw = fs.readFileSync(path);
+		return { raw, offset: 0, bytesRead: raw.length, truncated: false };
 	}
 	const bytesToRead = Math.min(stat.size, options.maxTailBytes);
 	const fd = fs.openSync(path, "r");
 	try {
 		const buffer = Buffer.alloc(bytesToRead);
 		fs.readSync(fd, buffer, 0, bytesToRead, stat.size - bytesToRead);
-		let text = buffer.toString("utf-8");
-		const firstNewline = text.search(/\r?\n/);
-		if (firstNewline >= 0) text = text.slice(firstNewline + (text[firstNewline] === "\r" && text[firstNewline + 1] === "\n" ? 2 : 1));
-		return { text, bytesRead: bytesToRead, truncated: true };
+		// Skip through the first newline so the tail starts on a line boundary
+		// (0x0a is ASCII, so a byte scan matches the old decoded-text scan).
+		const firstNewline = buffer.indexOf(0x0a);
+		const start = firstNewline >= 0 ? firstNewline + 1 : 0;
+		return {
+			raw: buffer.subarray(start),
+			offset: stat.size - bytesToRead + start,
+			bytesRead: bytesToRead,
+			truncated: true,
+		};
 	} finally {
 		fs.closeSync(fd);
 	}
 }
 
+/**
+ * Incremental read for append-only growth: read only [previous.size, size) and
+ * extend the cached bytes, then re-apply the tail cap by trimming the FRONT.
+ * Returns null when the delta could not be read completely (concurrent
+ * shrink/rotation) so the caller falls back to a fresh read.
+ */
+function appendTranscriptText(
+	path: string,
+	previous: TranscriptCacheEntry,
+	stat: fs.Stats,
+	options: Required<Pick<TranscriptReadOptions, "full">> & {
+		maxTailBytes: number;
+	},
+): TranscriptReadResult | null {
+	const deltaLength = stat.size - previous.size;
+	const fd = fs.openSync(path, "r");
+	let delta: Buffer;
+	try {
+		delta = Buffer.alloc(deltaLength);
+		let read = 0;
+		while (read < deltaLength) {
+			const n = fs.readSync(fd, delta, read, deltaLength - read, previous.size + read);
+			if (n <= 0) break;
+			read += n;
+		}
+		if (read < deltaLength) return null;
+	} finally {
+		fs.closeSync(fd);
+	}
+	let raw = Buffer.concat([previous.raw, delta], previous.raw.length + deltaLength);
+	let offset = previous.offset;
+	const endOffset = previous.size + deltaLength;
+	if (!options.full && endOffset - offset > options.maxTailBytes) {
+		// Keep the tail bounded: drop to the start of the new window, then
+		// through the first newline so the front stays a complete line.
+		const windowStart = endOffset - options.maxTailBytes;
+		const firstNewline = raw.indexOf(0x0a, windowStart - offset);
+		const drop = firstNewline >= 0 ? firstNewline + 1 : windowStart - offset;
+		// Copy (not subarray) so a huge append does not keep its pre-trim
+		// buffer alive through the retained view.
+		raw = Buffer.from(raw.subarray(drop));
+		offset += drop;
+	}
+	return {
+		raw,
+		offset,
+		bytesRead: deltaLength,
+		truncated: !options.full && offset > 0,
+	};
+}
+
 export function readTranscriptLinesCached(
 	path: string,
 	parse: (text: string) => string[],
@@ -98,12 +178,20 @@ export function readTranscriptLinesCached(
 		return previous.lines;
 	}
 	try {
-		const read = readTranscriptText(path, stat, normalized);
-		const lines = parse(read.text);
+		// Append-only growth (size grew, mtime not older): read only the new
+		// bytes and extend the cached range. Any shrink or backdated mtime
+		// falls through to a fresh read below.
+		const read =
+			previous && stat.size > previous.size && stat.mtimeMs >= previous.mtimeMs
+				? (appendTranscriptText(path, previous, stat, normalized) ?? readTranscriptText(path, stat, normalized))
+				: readTranscriptText(path, stat, normalized);
+		const lines = parse(read.raw.toString("utf-8"));
 		const entry: TranscriptCacheEntry = {
 			path,
 			mtimeMs: stat.mtimeMs,
-			size: stat.size,
+			size: read.offset + read.raw.length,
+			offset: read.offset,
+			raw: read.raw,
 			lines,
 			parsedAt: now,
 			readCount: (previous?.readCount ?? 0) + 1,

package/src/ui/transcript-viewer.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import { agentOutputPath, readCrewAgents } from "../runtime/crew-agent-records.ts";
 import type { TeamRunManifest } from "../state/types.ts";
 import { resolveRealContainedPath } from "../utils/safe-paths.ts";
-import { pad, truncate, truncateToVisualLines } from "../utils/visual.ts";
+import { pad, truncate, truncateToVisualLines, truncateToVisualLinesTail } from "../utils/visual.ts";
 import type { InteractiveComponent } from "./component.ts";
 import { renderDiff } from "./render-diff.ts";
 import { colorForStatus, iconForStatus, type RunStatus } from "./status-colors.ts";
@@ -234,17 +234,60 @@ interface ViewerState {
 	autoScroll: boolean;
 	lastHeight: number;
 	scroll: number;
+	// PERF (2026-08-24): full-wrap cache for the scroll-up path. ViewerState is
+	// built per render, so these are per-render scratch: the tail branch is the
+	// hot path (bottom-pinned ~500ms re-render) and never needs the full wrap;
+	// renders that fall to the else branch pay one full wrap each — the same
+	// price the pre-optimization code paid on EVERY render.
+	fullVisual: string[] | null;
+	sourceLen: number;
 }
 
 function renderViewerBase(state: ViewerState, width: number, lines: string[], title: string, subtitle: string): string[] {
 	const inner = Math.max(20, width - 4);
+	// PERF (2026-08-24): transcripts grow to thousands of lines; wrapping every
+	// grapheme of the whole tail to display 16 rows was the largest CPU sink in
+	// the UI. Bottom-pinned (autoScroll) renders use the tail window — O(visible
+	// rows); scrolling up pays one full wrap per render (what the old code paid
+	// on EVERY render) and can page through the whole transcript.
 	const bodyText = lines.join("\n");
-	const { visualLines, skippedCount } = truncateToVisualLines(bodyText, state.lastHeight, inner);
-	const maxScroll = Math.max(0, visualLines.length - state.lastHeight);
+	let visualLines: string[];
+	let skippedCount: number;
+	let maxScroll: number;
+	let tailWindow = false;
+	if (state.autoScroll && (state.fullVisual === null || state.sourceLen !== lines.length)) {
+		const tail = truncateToVisualLinesTail(bodyText, state.lastHeight, inner);
+		visualLines = tail.visualLines;
+		skippedCount = tail.skippedCount;
+		maxScroll = skippedCount; // bottom-pinned: everything above the window
+		state.fullVisual = null;
+		state.sourceLen = lines.length;
+		tailWindow = true;
+	} else {
+		if (state.fullVisual === null || state.sourceLen !== lines.length) {
+			// MAX_SAFE_INTEGER is never a real allocation: truncateToVisualLines
+			// returns early while visualLines.length <= limit (always true), so
+			// slice(-limit) never runs — this is just "wrap everything".
+			const full = truncateToVisualLines(bodyText, Number.MAX_SAFE_INTEGER, inner);
+			state.fullVisual = full.visualLines;
+			state.sourceLen = lines.length;
+		}
+		visualLines = state.fullVisual!;
+		skippedCount = 0;
+		maxScroll = Math.max(0, visualLines.length - state.lastHeight);
+	}
 	if (state.autoScroll) state.scroll = maxScroll;
 	state.scroll = Math.min(state.scroll, maxScroll);
-	const visible = visualLines.slice(state.scroll, state.scroll + state.lastHeight);
-	const statusLine = `${visualLines.length} lines · ${visualLines.length ? Math.round(((state.scroll + visible.length) / visualLines.length) * 100) : 100}% · auto-scroll ${state.autoScroll ? "on" : "off"}`;
+	// The tail window IS the bottom-pinned view: state.scroll holds the offset
+	// into the FULL wrap (skippedCount lines above), so slicing the ≤ lastHeight
+	// window at it would render an empty body. Display the window directly.
+	const visible = tailWindow ? visualLines : visualLines.slice(state.scroll, state.scroll + state.lastHeight);
+	// Tail-branch total is a lower bound: skippedCount counts SOURCE lines and
+	// each may wrap to several visual lines. "≥" flags that (short transcripts
+	// and the full-wrap branch keep the exact count).
+	const totalLines = tailWindow ? skippedCount + visible.length : visualLines.length;
+	const totalLabel = tailWindow && skippedCount > 0 ? `≥ ${totalLines}` : `${totalLines}`;
+	const statusLine = `${totalLabel} lines · ${totalLines ? Math.round(((state.scroll + visible.length) / totalLines) * 100) : 100}% · auto-scroll ${state.autoScroll ? "on" : "off"}`;
 	const fg = (color: Parameters<TranscriptTheme["fg"]>[0], text: string) => state.theme.fg(color, text);
 	const row = (text: string) => `${fg("border", "│")} ${pad(truncate(text, inner), inner)} ${fg("border", "│")}`;
 	const linesOut: string[] = [
@@ -267,6 +310,11 @@ export class DurableTextViewer implements Component {
 	private scroll = 0;
 	private lastHeight = 16;
 	private autoScroll = true;
+	// PERF (2026-08-24): whether the PREVIOUS render was bottom-pinned. The
+	// tail branch tracks `scroll` in source-line units, which is not a valid
+	// index into the full wrap — the first manual render after a pinned one
+	// clamps to the exact visual bottom instead of slicing at that stale value.
+	private prevAutoScroll = true;
 	private title: string;
 	private subtitle: string;
 	private lines: string[];
@@ -312,6 +360,7 @@ export class DurableTextViewer implements Component {
 		} else if (data === "g" || data === "\u001b[H") {
 			this.scroll = 0;
 			this.autoScroll = false;
+			this.prevAutoScroll = false; // explicit top — do not pin to bottom
 		} else if (data === "G" || data === "\u001b[F") {
 			this.scroll = maxScroll;
 			this.autoScroll = true;
@@ -321,18 +370,23 @@ export class DurableTextViewer implements Component {
 	}
 
 	render(width: number): string[] {
-		return renderViewerBase(
-			{
-				theme: this.theme,
-				autoScroll: this.autoScroll,
-				lastHeight: this.lastHeight,
-				scroll: this.scroll,
-			},
-			width,
-			this.lines,
-			this.title,
-			this.subtitle,
-		);
+		// Leaving the pinned state (k/PgUp/a): the stale source-unit scroll
+		// would slice the full wrap in the wrong place — clamp to its bottom.
+		if (!this.autoScroll && this.prevAutoScroll) this.scroll = Number.MAX_SAFE_INTEGER;
+		const state: ViewerState = {
+			theme: this.theme,
+			autoScroll: this.autoScroll,
+			lastHeight: this.lastHeight,
+			scroll: this.scroll,
+			fullVisual: null,
+			sourceLen: 0,
+		};
+		const rendered = renderViewerBase(state, width, this.lines, this.title, this.subtitle);
+		// Write the clamped/updated scroll back so handleInput's scroll math
+		// starts from the position the user actually saw.
+		this.scroll = state.scroll;
+		this.prevAutoScroll = this.autoScroll;
+		return rendered;
 	}
 }
 
@@ -340,6 +394,8 @@ export class DurableTranscriptViewer implements Component {
 	private scroll = 0;
 	private lastHeight = 16;
 	private autoScroll = true;
+	// See DurableTextViewer.prevAutoScroll — same pinned→manual transition guard.
+	private prevAutoScroll = true;
 	private manifest: TeamRunManifest;
 	private theme: TranscriptTheme;
 	private done: (result: undefined) => void;
@@ -406,6 +462,7 @@ export class DurableTranscriptViewer implements Component {
 		} else if (data === "g" || data === "\u001b[H") {
 			this.scroll = 0;
 			this.autoScroll = false;
+			this.prevAutoScroll = false; // explicit top — do not pin to bottom
 		} else if (data === "G" || data === "\u001b[F") {
 			this.scroll = maxScroll;
 			this.autoScroll = true;
@@ -415,6 +472,7 @@ export class DurableTranscriptViewer implements Component {
 			this.fullTranscript = !this.fullTranscript;
 			this.scroll = 0;
 			this.autoScroll = !this.fullTranscript;
+			this.prevAutoScroll = this.autoScroll; // explicit reset — no bottom pin
 			// The full/tail toggle changes the read options, so refresh the cache
 			// with a single explicit read rather than per keystroke.
 			this.cached = this.readTranscript(this.manifest, this.taskId, {
@@ -432,17 +490,27 @@ export class DurableTranscriptViewer implements Component {
 		// Keep the per-keypress cache in sync with the latest rendered content
 		// (the read is TTL-cached at ~500ms, so this stays cheap on each tick).
 		this.cached = data;
-		return renderViewerBase(
-			{
-				theme: this.theme,
-				autoScroll: this.autoScroll,
-				lastHeight: this.lastHeight,
-				scroll: this.scroll,
-			},
+		// Leaving the pinned state (k/PgUp/a): the stale source-unit scroll
+		// would slice the full wrap in the wrong place — clamp to its bottom.
+		if (!this.autoScroll && this.prevAutoScroll) this.scroll = Number.MAX_SAFE_INTEGER;
+		const state: ViewerState = {
+			theme: this.theme,
+			autoScroll: this.autoScroll,
+			lastHeight: this.lastHeight,
+			scroll: this.scroll,
+			fullVisual: null,
+			sourceLen: 0,
+		};
+		const rendered = renderViewerBase(
+			state,
 			width,
 			data.lines,
 			"pi-crew transcript",
 			`${data.title} · ${data.truncated ? `tail ${Math.round(data.bytesRead / 1024)}KB/${Math.round(data.size / 1024)}KB` : `full ${Math.round(data.size / 1024)}KB`} · f ${this.fullTranscript ? "tail" : "full"}`,
 		);
+		// Write the clamped/updated scroll back (see DurableTextViewer.render).
+		this.scroll = state.scroll;
+		this.prevAutoScroll = this.autoScroll;
+		return rendered;
 	}
 }

package/src/ui/widget/index.ts

@@ -177,6 +177,14 @@ class CrewWidgetComponent implements WidgetComponent {
 	private cachedWidth = 0;
 	private cachedLines: string[] = [];
 	private cachedBaseLines: string[] = [];
+	/**
+	 * PERF (2026-08-24): truncate at build time, re-truncate only on width
+	 * change — cache hits returned a fresh array + ANSI-aware width measurement
+	 * per line on every frame. `cachedLines` stays raw (unclipped) so a width
+	 * change can re-clip without a full rebuild; -1 marks "not truncated yet".
+	 */
+	private truncatedLines: string[] = [];
+	private lastTruncateWidth = -1;
 	private cachedTheme: CrewTheme;
 	private readonly tui: unknown;
 	private readonly unsubscribeTheme: () => void;
@@ -274,10 +282,23 @@ class CrewWidgetComponent implements WidgetComponent {
 		this.cacheSignature = "";
 		this.cachedBaseLines = [];
 		this.cachedLines = [];
+		this.truncatedLines = [];
+		this.lastTruncateWidth = -1;
 		this.cachedBuildSignature = "";
 		this.cachedBuildSignatureAt = 0;
 	}
 
+	/**
+	 * PERF (2026-08-24): clip `cachedLines` to `width` only when the width
+	 * changed since the last clip — the raw lines are stored unclipped so a
+	 * resize re-clips them without rebuilding the whole cache.
+	 */
+	private ensureTruncated(width: number): void {
+		if (width === this.lastTruncateWidth) return;
+		this.truncatedLines = this.cachedLines.map((line) => truncate(line, width));
+		this.lastTruncateWidth = width;
+	}
+
 	/** Poke the host TUI to repaint immediately (defensive: no-op if unavailable). */
 	requestRepaint(): void {
 		requestRenderTarget(this.tui);
@@ -326,12 +347,14 @@ class CrewWidgetComponent implements WidgetComponent {
 				this.cachedWidth = width;
 				this.cachedTheme = this.theme;
 				this.cacheSignature = signature;
+				this.lastTruncateWidth = -1;
 			}
 			if (runs.length === 0) {
 				this.invalidate();
 				return [];
 			}
-			return this.cachedLines.map((line) => truncate(line, width));
+			this.ensureTruncated(width);
+			return this.truncatedLines;
 		}
 
 		// Panel cursor/pane state is part of the rendered output, so it belongs in
@@ -361,6 +384,7 @@ class CrewWidgetComponent implements WidgetComponent {
 			this.cachedWidth = width;
 			this.cachedTheme = this.theme;
 			this.cacheSignature = signatureWithPanel;
+			this.lastTruncateWidth = -1;
 		}
 
 		if (runs.length === 0) {
@@ -373,11 +397,13 @@ class CrewWidgetComponent implements WidgetComponent {
 			return [];
 		}
 
+		this.ensureTruncated(width);
 		if (!compactDock) {
 			const updatedHeader = `${runningGlyph}${this.cachedBaseLines[0]?.slice(1) ?? ""}`;
 			this.cachedLines[0] = truncate(colorWidgetLine(updatedHeader, 0, this.theme), width);
+			this.truncatedLines[0] = truncate(this.cachedLines[0], width);
 		}
-		return this.cachedLines.map((line) => truncate(line, width));
+		return this.truncatedLines;
 	}
 }
 
@@ -441,10 +467,6 @@ export function updateCrewWidget(
 	// the only place already holding the manifest/snapshot caches — so the row
 	// projection is registered here instead of re-reading state on every keypress.
 	setPanelRowsProvider(() => panelRowsFromRuns(activeWidgetRuns(ctx.cwd, manifestCache, snapshotCache, preloadedManifests, workspaceId)));
-	const lines = buildWidgetLines(ctx.cwd, state.frame, maxLines, runs, state.notificationCount ?? 0, getRenderWidth(), {
-		rowStyle,
-		...panelDisplayState(),
-	});
 	const placement = config?.widgetPlacement ?? DEFAULT_UI.widgetPlacement;
 	// `bottom` is not a pi widget slot: the dock then renders inside the
 	// crew-vibes footer (dock-footer registry). pi's slot calls always use a
@@ -453,7 +475,9 @@ export function updateCrewWidget(
 	const dockInFooter = bottomMode && isFooterDockSinkActive();
 	const piPlacement: "aboveEditor" | "belowEditor" = bottomMode ? "belowEditor" : placement;
 
-	ctx.ui.setStatus(STATUS_KEY, lines.length ? statusSummary(runs) : undefined);
+	// PERF (2026-08-24): the persistent CrewWidgetComponent renders itself from
+	// state.frame; the built line set was only ever used for its .length.
+	ctx.ui.setStatus(STATUS_KEY, runs.length > 0 ? statusSummary(runs) : undefined);
 
 	const shouldClearLegacy = state.legacyCleared !== true || state.lastPlacement !== placement;
 	if (shouldClearLegacy) {
@@ -461,7 +485,7 @@ export function updateCrewWidget(
 		state.legacyCleared = true;
 	}
 
-	if (!lines.length) {
+	if (runs.length === 0) {
 		if (state.lastVisibility !== "hidden" || state.lastPlacement !== placement) {
 			setExtensionWidget(ctx, WIDGET_KEY, undefined, { placement: piPlacement });
 			setExtensionWidget(ctx, TASKS_WIDGET_KEY, undefined, { placement: "aboveEditor" });

package/src/utils/visual.ts

@@ -4,6 +4,12 @@ export const ANSI_PATTERN = /\u001b\[[0-?]*[ -/]*[@-~]/g;
 
 const WIDTH_CACHE_LIMIT = 256;
 const widthCache = new Map<string, number>();
+// PERF (2026-08-24): truncateToWidth/wrapHard measure ONE codepoint at a time;
+// those 1-2 char keys thrashed the 256-entry LRU, evicting every long-string
+// entry that could actually hit. Short keys get their own cache (bounded
+// alphabet — hit rate ~100%) so the LRU serves only whole lines/segments.
+const SHORT_WIDTH_CACHE_LIMIT = 1024;
+const shortWidthCache = new Map<string, number>();
 
 // NOTE: width measurement is delegated to pi-tui's `visibleWidth` (see below).
 // pi-tui is the renderer that HARD-ABORTS the session if any line exceeds the
@@ -20,6 +26,17 @@ export function visibleWidth(value: string): number {
 	// LRU cache on top (pi-tui caches too, but this avoids repeated calls for the
 	// hot render path).
 	if (value.length > 4096) return tuiVisibleWidth(value);
+	if (value.length <= 2) {
+		const s = shortWidthCache.get(value);
+		if (s !== undefined) return s;
+		const w = tuiVisibleWidth(value);
+		if (shortWidthCache.size >= SHORT_WIDTH_CACHE_LIMIT) {
+			const first = shortWidthCache.keys().next().value;
+			if (first !== undefined) shortWidthCache.delete(first);
+		}
+		shortWidthCache.set(value, w);
+		return w;
+	}
 	const cached = widthCache.get(value);
 	if (cached !== undefined) return cached;
 	const length = tuiVisibleWidth(value);
@@ -33,6 +50,7 @@ export function visibleWidth(value: string): number {
 
 export function __test__clearVisibleWidthCache(): void {
 	widthCache.clear();
+	shortWidthCache.clear();
 }
 
 export function __test__visibleWidthCacheSize(): number {
@@ -205,3 +223,28 @@ export function truncateToVisualLines(text: string, maxVisualLines: number, widt
 	const truncated = visualLines.slice(-limit);
 	return { visualLines: truncated, skippedCount: visualLines.length - limit };
 }
+
+/**
+ * PERF (2026-08-24): tail-windowed twin of truncateToVisualLines. Wraps lines
+ * from the END backwards and stops as soon as `maxVisualLines` visual lines
+ * exist — O(visible window) instead of O(whole transcript). `skippedCount`
+ * counts skipped SOURCE lines (a lower bound on skipped visual lines; the
+ * caller's total display therefore reads "≥ N lines" when scrolled to bottom).
+ */
+export function truncateToVisualLinesTail(text: string, maxVisualLines: number, width: number, paddingX = 0): VisualTruncateResult {
+	if (!text) return { visualLines: [], skippedCount: 0 };
+	const effectiveWidth = Math.max(1, width - paddingX * 2);
+	const limit = Math.max(1, maxVisualLines);
+	const sourceLines = text.split("\n");
+	const wrapped: string[][] = [];
+	let collected = 0;
+	let index = sourceLines.length - 1;
+	while (index >= 0 && collected < limit) {
+		const w = wrapHard(pad(sourceLines[index]!, Math.max(0, effectiveWidth)).trimEnd(), effectiveWidth);
+		wrapped.push(w);
+		collected += w.length;
+		index -= 1;
+	}
+	const visualLines = wrapped.reverse().flat().slice(-limit);
+	return { visualLines, skippedCount: index + 1 };
+}

package/src/worktree/worktree-manager.ts

@@ -129,19 +129,59 @@ function sanitizeBranchPart(value: string): string {
 	);
 }
 
+// PERF (2026-08-24): the sync path (prepareTaskWorkspace — per task!) ran
+// findGitRoot (rev-parse spawn) + assertCleanLeader (status --porcelain spawn)
+// on every call, and the reuse path ran assertCleanLeader twice. Mirror the
+// async caches below (_gitRootCache/_cleanLeaderCache): same repoRoot → same
+// answer within a run.
+//
+// Mirrored invalidation semantics (from the async caches below):
+// - gitRoot: plain Map, NO TTL — the async _gitRootCache is process-lifetime with
+//   a FIFO cap; a cwd's repo root cannot change without moving .git itself.
+// - cleanLeader: ONLY clean verdicts are cached — the async _cleanLeaderCache is
+//   a Set of verified-clean repoRoots and a dirty verdict throws BEFORE caching,
+//   so every call while dirty re-probes (mirrored here). The async cache has NO
+//   TTL (a clean verdict is trusted for the whole process), so the 30s TTL below
+//   is strictly MORE conservative than the async path: a leader dirtied after a
+//   cached clean verdict can slip through for at most 30s here vs. forever on
+//   the async path. The reuse-path re-check in prepareTaskWorkspace deletes the
+//   entry first, mirroring `_cleanLeaderCache.delete(repoRoot)` in the async variant.
+const SYNC_WT_CACHE_TTL_MS = 30_000;
+const MAX_SYNC_GIT_ROOT_CACHE = 256;
+const MAX_SYNC_CLEAN_LEADER_CACHE = 256;
+const syncGitRootCache = new Map<string, string>();
+const syncCleanLeaderCache = new Map<string, { clean: boolean; expiresAt: number }>();
+
 export function findGitRoot(cwd: string): string {
-	return git(cwd, ["rev-parse", "--show-toplevel"]);
+	const cached = syncGitRootCache.get(cwd);
+	if (cached) return cached;
+	const root = git(cwd, ["rev-parse", "--show-toplevel"]);
+	syncGitRootCache.set(cwd, root);
+	if (syncGitRootCache.size > MAX_SYNC_GIT_ROOT_CACHE) {
+		const oldest = syncGitRootCache.keys().next().value;
+		if (oldest !== undefined) syncGitRootCache.delete(oldest);
+	}
+	return root;
 }
 
 export function assertCleanLeader(repoRoot: string): void {
+	const cached = syncCleanLeaderCache.get(repoRoot);
+	if (cached?.clean && Date.now() < cached.expiresAt) return;
 	// H-7 follow-up: --untracked-files=no so pi-crew's own auto-created .gitignore
 	// (and any other untracked files the user hasn't staged) doesn't block worktree mode.
 	// The worktree contract is "no tracked changes" — untracked files are safe since
 	// they're either in .gitignore or the user can decide later.
 	const status = git(repoRoot, ["status", "--porcelain", "--untracked-files=no"]);
 	if (status.trim()) {
+		// Dirty verdicts are never cached (async mirror): the user may commit/stash
+		// seconds later, so the next call must re-probe.
 		throw new Error("Worktree mode requires a clean leader repository. Commit/stash changes or use workspaceMode: 'single'.");
 	}
+	syncCleanLeaderCache.set(repoRoot, { clean: true, expiresAt: Date.now() + SYNC_WT_CACHE_TTL_MS });
+	if (syncCleanLeaderCache.size > MAX_SYNC_CLEAN_LEADER_CACHE) {
+		const oldest = syncCleanLeaderCache.keys().next().value;
+		if (oldest !== undefined) syncCleanLeaderCache.delete(oldest);
+	}
 }
 
 // --- Async versions ---
@@ -453,6 +493,25 @@ function pruneStaleWorktrees(repoRoot: string): void {
 	}
 }
 
+// PERF (2026-08-24): worktree prune is a repo-level write; running it per
+// task in a 50-task run is 50 prunes. At most once per repoRoot per minute.
+// (The async variant memoizes at-most-once per process — see P1-11 above —
+// so a 60s window prunes strictly more often than the async path already does.)
+// R5-L2 mirror: FIFO-cap the key set so the map cannot grow unbounded.
+const PRUNE_MIN_INTERVAL_MS = 60_000;
+const MAX_PRUNE_THROTTLE_KEYS = 128;
+const lastPruneAt = new Map<string, number>();
+function pruneStaleWorktreesThrottled(repoRoot: string): void {
+	const last = lastPruneAt.get(repoRoot) ?? 0;
+	if (Date.now() - last < PRUNE_MIN_INTERVAL_MS) return;
+	lastPruneAt.set(repoRoot, Date.now());
+	if (lastPruneAt.size > MAX_PRUNE_THROTTLE_KEYS) {
+		const oldest = lastPruneAt.keys().next().value;
+		if (oldest !== undefined) lastPruneAt.delete(oldest);
+	}
+	pruneStaleWorktrees(repoRoot); // original body — best-effort, failures swallowed
+}
+
 async function branchExistsAsync(repoRoot: string, branch: string): Promise<{ local: boolean; remoteOnly: boolean }> {
 	let local = false;
 	try {
@@ -818,11 +877,13 @@ export function prepareTaskWorkspace(manifest: TeamRunManifest, task: TeamTaskSt
 		if (mergedReused.length > 0) {
 			overlaySeedPaths(repoRoot, worktreePath, mergedReused);
 		}
-		// Re-validate leader is still clean before reusing — leader state may have changed since first preparation
+		// Re-validate leader is still clean before reusing — leader state may have changed since first preparation.
+		// Mirrors prepareTaskWorkspaceAsync: delete the cached verdict so this re-check probes live state.
+		syncCleanLeaderCache.delete(repoRoot);
 		assertCleanLeader(repoRoot);
 		return { cwd: worktreePath, worktreePath, branch, reused: true };
 	}
-	pruneStaleWorktrees(repoRoot);
+	pruneStaleWorktreesThrottled(repoRoot);
 	const exists = branchExists(repoRoot, branch);
 	let worktreeCreated = false;
 	try {
@@ -1141,7 +1202,7 @@ export function prepareAgentWorktree(manifest: TeamRunManifest, agentId: string)
 	const stamp = `${Date.now()}-${randomBytes(4).toString("hex")}`;
 	const worktreePath = path.join(worktreeRoot, `${sanitizedAgentId}-${stamp}`);
 	const branch = `pi-crew/${sanitizedRunId}/${sanitizedAgentId}-${stamp}`;
-	pruneStaleWorktrees(repoRoot);
+	pruneStaleWorktreesThrottled(repoRoot);
 	git(repoRoot, ["worktree", "add", "-b", branch, worktreePath, "HEAD"]);
 	const nodeModulesLinked =
 		loadedConfig.config.worktree?.linkNodeModules === true ? linkNodeModulesIfPresent(repoRoot, worktreePath) : false;