pi-crew 0.10.2 → 0.10.4

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;