pi-crew 0.9.41 → 0.9.44

package/src/ui/settings-overlay.ts

@@ -557,8 +557,8 @@ class TextinputSubmenu {
 			this.buffer = this.buffer.slice(0, -1);
 			return;
 		}
-		// Printable character
-		if (data.length === 1 && data >= " " && data <= "~") {
+		// Printable character (accept any non-control character, including Unicode)
+		if (data.length === 1 && data >= " ") {
 			this.buffer += data;
 			return;
 		}
@@ -704,7 +704,7 @@ class AgentOverridesSubmenu {
 			this.editBuffer = this.editBuffer.slice(0, -1);
 			return;
 		}
-		if (data.length === 1 && data >= " " && data <= "~") {
+		if (data.length === 1 && data >= " ") {
 			this.editBuffer += data;
 		}
 	}

package/src/ui/status-colors.ts

@@ -106,6 +106,11 @@ function glyphColor(glyph: string): CrewThemeColor {
 	}
 }
 
+/**
+ * Status glyph characters used in the fast-path check.
+ */
+const STATUS_GLYPH_CHARS = "\u2713\u2717\u25a0\u23f8\u25e6\u00b7\u25b6\u23f3\u26a0";
+
 /**
  * Colorize status glyphs embedded in a rendered line. Wraps every status glyph
  * (✓ ✗ ■ ⏸ ⏳ ⚠ ◦ · ▶ and braille spinner frames ⠁–⣿) in the appropriate theme
@@ -115,5 +120,24 @@ function glyphColor(glyph: string): CrewThemeColor {
  * and live-run-sidebar.ts with a single shared helper (F-1, F-2, V-3).
  */
 export function colorizeStatusGlyphs(line: string, theme: CrewTheme): string {
+	// Fast path: skip regex if line contains no status glyphs at all.
+	let hasGlyph = false;
+	for (let i = 0; i < STATUS_GLYPH_CHARS.length; i++) {
+		if (line.indexOf(STATUS_GLYPH_CHARS[i]) !== -1) {
+			hasGlyph = true;
+			break;
+		}
+	}
+	if (!hasGlyph) {
+		// Check for braille range (U+2800–U+28FF)
+		for (let i = 0; i < line.length; i++) {
+			const cp = line.codePointAt(i)!;
+			if (cp >= 0x2800 && cp <= 0x28ff) {
+				hasGlyph = true;
+				break;
+			}
+		}
+	}
+	if (!hasGlyph) return line;
 	return line.replace(/[✓✗■⏸◦·▶⏳⚠]|[\u2800-\u28FF]/g, (glyph) => theme.fg(glyphColor(glyph), glyph));
 }

package/src/ui/tool-progress-formatter.ts

@@ -81,7 +81,7 @@ export function formatCompactToolProgress(input: ToolProgressInput): string {
 			lines.push(`  tool: ${active.progress.currentTool}${count}`);
 		}
 		const recent = active.progress?.recentOutput?.at(-1);
-		if (recent && recent.trim()) lines.push(`  ${trimLine(recent)}`);
+		if (recent?.trim()) lines.push(`  ${trimLine(recent)}`);
 	} else if (input.runId && !counts) {
 		lines.push(`  run=${input.runId} (starting)`);
 	} else if (input.error) {

package/src/ui/tool-render.ts

@@ -7,7 +7,7 @@
  * Ports logic from pi-subagent4 adapted for pi-crew's data model.
  * Uses @earendil-works/pi-tui Components (Container, Text, Spacer) directly.
  */
-import { Container, Spacer, Text, visibleWidth } from "@earendil-works/pi-tui";
+import { Container, Spacer, Text } from "@earendil-works/pi-tui";
 import type { CrewAgentRecord } from "../runtime/crew-agent-runtime.ts";
 import { truncateToWidth } from "../utils/visual.ts";
 import { replaceTabs } from "./render-diff.ts";
@@ -444,10 +444,10 @@ function parseArgs(argsStr: string | undefined): Record<string, unknown> {
 function computeDurationMs(startedAt: string, completedAt?: string): number {
 	if (!startedAt) return 0;
 	const start = new Date(startedAt).getTime();
-	if (isNaN(start)) return 0;
+	if (Number.isNaN(start)) return 0;
 	if (completedAt) {
 		const end = new Date(completedAt).getTime();
-		return isNaN(end) ? 0 : Math.max(0, end - start);
+		return Number.isNaN(end) ? 0 : Math.max(0, end - start);
 	}
 	return Math.max(0, Date.now() - start);
 }

package/src/ui/transcript-cache.ts

@@ -112,17 +112,12 @@ export function readTranscriptLinesCached(
 			truncated: read.truncated,
 		};
 		transcriptCache.set(key, entry);
-		// Evict oldest entry if cache exceeds max size
+		// FIND-12: evict the oldest entry by Map insertion order. Map natively
+		// preserves insertion order, so the first key is the oldest — replaces
+		// the previous O(N) `parsedAt` min-scan that ran on every miss.
 		if (transcriptCache.size > MAX_CACHE_SIZE) {
-			let oldestKey: string | null = null;
-			let oldestParsedAt = Infinity;
-			for (const [k, v] of transcriptCache.entries()) {
-				if (v.parsedAt < oldestParsedAt) {
-					oldestParsedAt = v.parsedAt;
-					oldestKey = k;
-				}
-			}
-			if (oldestKey) transcriptCache.delete(oldestKey);
+			const oldestKey = transcriptCache.keys().next().value;
+			if (oldestKey !== undefined) transcriptCache.delete(oldestKey);
 		}
 		return lines;
 	} catch {

package/src/ui/transcript-entries.ts

@@ -97,71 +97,61 @@ export function parseTranscriptEntries(lines: string[]): TranscriptEntry[] {
 		}
 	}
 
-	let i = 0;
-	while (i < parsed.length) {
+	// FIND-18: single linear pass to match each tool_call with the next
+	// tool-flavored event after it. Replaces the previous O(n²) lookahead that
+	// re-scanned the suffix of the array for every tool_call. The pending slot
+	// holds the most recent tool_call awaiting its result. A new tool_call
+	// arriving before any result flushes the previous one as no-result (same
+	// semantic as the old lookahead hitting the next tool_call). Non-tool
+	// events are emitted in order and do not interrupt the pending slot,
+	// matching the old lookahead's behaviour of skipping over messages.
+	let pending: { obj: Record<string, unknown>; toolName: string; inputText: string; timestamp?: number } | null = null;
+
+	const flushPending = (isError: boolean, resultText: string, resultTimestamp: number | undefined): void => {
+		if (!pending) return;
+		const callSummary = summarize(
+			`🔧 ${pending.toolName}${pending.inputText ? `: ${summarize(pending.inputText, 60)}` : ""}`,
+			SUMMARY_MAX,
+		);
+		const callContent = [
+			`[Tool Call: ${pending.toolName}]`,
+			pending.inputText || "(no input)",
+			`[Result${isError ? " ✗" : " ✓"}]`,
+			resultText || "(no output)",
+		].join("\n");
+		entries.push({
+			id: id++,
+			type: "tool_call",
+			toolName: pending.toolName,
+			summary: callSummary,
+			content: callContent,
+			expanded: false,
+			timestamp: resultTimestamp ?? pending.timestamp,
+		});
+		pending = null;
+	};
+
+	for (let i = 0; i < parsed.length; i++) {
 		const { obj } = parsed[i]!;
 		const type = typeof obj.type === "string" ? obj.type : "";
 		const timestamp = typeof obj.timestamp === "number" ? obj.timestamp : undefined;
 
 		if (isToolCallType(type)) {
-			// Look ahead for matching tool_result
-			const toolName = extractToolName(obj) ?? "unknown";
+			// A new tool_call interrupts any pending one (same as the old
+			// lookahead breaking on the next tool_call). Flush as no-result.
+			if (pending) flushPending(false, "", undefined);
 			const inputText = typeof obj.input === "string" ? obj.input : obj.input !== undefined ? JSON.stringify(obj.input) : "";
-			let resultText = "";
-			let isError = false;
-			let resultTimestamp = timestamp;
-
-			// Consume consecutive tool_result lines
-			let j = i + 1;
-			while (j < parsed.length) {
-				const nextTypeVal = parsed[j]!.obj.type;
-				const nextType = typeof nextTypeVal === "string" ? nextTypeVal : "";
-				if (isToolResultType(nextType) || /tool/i.test(nextType)) {
-					const robj = parsed[j]!.obj;
-					const rt =
-						typeof robj.text === "string"
-							? robj.text
-							: typeof robj.result === "string"
-								? robj.result
-								: robj.result !== undefined
-									? JSON.stringify(robj.result)
-									: "";
-					resultText = rt;
-					isError = robj.isError === true;
-					resultTimestamp = typeof robj.timestamp === "number" ? robj.timestamp : resultTimestamp;
-					j++;
-					break;
-				}
-				if (isToolCallType(nextType)) break; // next tool call, stop looking
-				j++;
-			}
-
-			const callSummary = summarize(`🔧 ${toolName}${inputText ? ": " + summarize(inputText, 60) : ""}`, SUMMARY_MAX);
-			const callContent = [
-				`[Tool Call: ${toolName}]`,
-				inputText || "(no input)",
-				`[Result${isError ? " ✗" : " ✓"}]`,
-				resultText || "(no output)",
-			].join("\n");
-
-			entries.push({
-				id: id++,
-				type: "tool_call",
-				toolName,
-				summary: callSummary,
-				content: callContent,
-				expanded: false,
-				timestamp: resultTimestamp ?? timestamp,
-			});
-			i = j;
+			pending = {
+				obj,
+				toolName: extractToolName(obj) ?? "unknown",
+				inputText,
+				timestamp,
+			};
 			continue;
 		}
 
 		if (isToolResultType(type) || /tool/i.test(type)) {
-			// Standalone tool result (no preceding tool_call consumed it)
-			const toolName = extractToolName(obj) ?? "unknown";
-			const isError = obj.isError === true;
-			const text =
+			const rt =
 				typeof obj.text === "string"
 					? obj.text
 					: typeof obj.result === "string"
@@ -169,20 +159,25 @@ export function parseTranscriptEntries(lines: string[]): TranscriptEntry[] {
 						: obj.result !== undefined
 							? JSON.stringify(obj.result)
 							: "";
-
-			const summary = summarize(`${isError ? "✗" : "✓"} ${toolName}${text ? ": " + summarize(text, 60) : ""}`, SUMMARY_MAX);
-			const content = [`[Tool Result: ${toolName}${isError ? " (error)" : ""}]`, text || "(no output)"].join("\n");
-
-			entries.push({
-				id: id++,
-				type: "tool_result",
-				toolName,
-				summary,
-				content,
-				expanded: false,
-				timestamp,
-			});
-			i++;
+			const isError = obj.isError === true;
+			const resultTimestamp = typeof obj.timestamp === "number" ? obj.timestamp : undefined;
+			if (pending) {
+				flushPending(isError, rt, resultTimestamp);
+			} else {
+				// Standalone tool result (no preceding tool_call consumed it)
+				const toolName = extractToolName(obj) ?? "unknown";
+				const summary = summarize(`${isError ? "✗" : "✓"} ${toolName}${rt ? `: ${summarize(rt, 60)}` : ""}`, SUMMARY_MAX);
+				const content = [`[Tool Result: ${toolName}${isError ? " (error)" : ""}]`, rt || "(no output)"].join("\n");
+				entries.push({
+					id: id++,
+					type: "tool_result",
+					toolName,
+					summary,
+					content,
+					expanded: false,
+					timestamp,
+				});
+			}
 			continue;
 		}
 
@@ -194,7 +189,7 @@ export function parseTranscriptEntries(lines: string[]): TranscriptEntry[] {
 			const text = textFromContent(msg.content);
 
 			const label = role === "assistant" ? "🤖" : role === "user" ? "👤" : "💬";
-			const summary = summarize(`${label} ${role}${text ? ": " + summarize(text, 80) : ""}`, SUMMARY_MAX);
+			const summary = summarize(`${label} ${role}${text ? `: ${summarize(text, 80)}` : ""}`, SUMMARY_MAX);
 			const content = `[${role.charAt(0).toUpperCase()}${role.slice(1)}]:\n${text || "(empty)"}`;
 
 			entries.push({
@@ -206,7 +201,6 @@ export function parseTranscriptEntries(lines: string[]): TranscriptEntry[] {
 				expanded: false,
 				timestamp,
 			});
-			i++;
 			continue;
 		}
 
@@ -221,9 +215,11 @@ export function parseTranscriptEntries(lines: string[]): TranscriptEntry[] {
 			expanded: false,
 			timestamp,
 		});
-		i++;
 	}
 
+	// End of input: any pending tool_call never received a result.
+	if (pending) flushPending(false, "", undefined);
+
 	return entries;
 }
 

package/src/ui/transcript-viewer.ts

@@ -18,6 +18,38 @@ type Component = {
 
 type TranscriptTheme = CrewTheme;
 
+interface ReadRunTranscriptResult {
+	title: string;
+	path: string;
+	lines: string[];
+	bytesRead: number;
+	size: number;
+	truncated: boolean;
+}
+
+// FIND-06: short-TTL cache keyed by (runId, taskId, readOptions) so the ~500ms
+// render tick of `DurableTranscriptViewer` does not re-stat / re-read / re-parse
+// the underlying transcript on every call. The deeper `transcriptCache` only
+// reuses parsed lines when mtime/size are stable; during an actively-written
+// run, the file's mtime changes on every tick and the inner cache is
+// invalidated. This outer cache caps the per-tick re-parse cost at one parse
+// per ~500ms even while the file is growing.
+const READ_RUN_TRANSCRIPT_TTL_MS = 500;
+const READ_RUN_TRANSCRIPT_CACHE_MAX = 32;
+interface ReadRunTranscriptCacheEntry {
+	parsedAt: number;
+	result: ReadRunTranscriptResult;
+}
+const readRunTranscriptCache = new Map<string, ReadRunTranscriptCacheEntry>();
+
+function readRunTranscriptCacheKey(
+	manifest: TeamRunManifest,
+	taskId: string | undefined,
+	readOptions: { full: boolean; maxTailBytes: number },
+): string {
+	return `${manifest.runId}|${taskId ?? ""}|${readOptions.full ? "full" : "tail"}|${readOptions.maxTailBytes}`;
+}
+
 function asRecord(value: unknown): Record<string, unknown> | undefined {
 	return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : undefined;
 }
@@ -140,14 +172,17 @@ export function readRunTranscript(
 	manifest: TeamRunManifest,
 	taskId?: string,
 	options: { full?: boolean; maxTailBytes?: number } = {},
-): {
-	title: string;
-	path: string;
-	lines: string[];
-	bytesRead: number;
-	size: number;
-	truncated: boolean;
-} {
+): ReadRunTranscriptResult {
+	const now = Date.now();
+	const readOptions = {
+		full: options.full === true,
+		maxTailBytes: options.maxTailBytes ?? DEFAULT_TRANSCRIPT_TAIL_BYTES,
+	};
+	const cacheKey = readRunTranscriptCacheKey(manifest, taskId, readOptions);
+	const cached = readRunTranscriptCache.get(cacheKey);
+	if (cached && now - cached.parsedAt < READ_RUN_TRANSCRIPT_TTL_MS) {
+		return cached.result;
+	}
 	const agents = readCrewAgents(manifest);
 	const agent = taskId
 		? agents.find((item) => item.taskId === taskId || item.id === taskId)
@@ -172,13 +207,9 @@ export function readRunTranscript(
 			// Ignore untrusted transcript paths from mutable agent state and fall back to durable agent output.
 		}
 	}
-	const readOptions = {
-		full: options.full === true,
-		maxTailBytes: options.maxTailBytes ?? DEFAULT_TRANSCRIPT_TAIL_BYTES,
-	};
-	const lines = readTranscriptLinesCached(transcriptPath, (text) => formatTranscriptText(text), Date.now(), readOptions);
+	const lines = readTranscriptLinesCached(transcriptPath, (text) => formatTranscriptText(text), now, readOptions);
 	const entry = getTranscriptCacheEntry(transcriptPath, readOptions);
-	return {
+	const result: ReadRunTranscriptResult = {
 		title: `${manifest.runId}:${selectedTaskId}`,
 		path: transcriptPath,
 		lines: lines.length ? lines : ["(no transcript content)"],
@@ -186,6 +217,15 @@ export function readRunTranscript(
 		size: entry?.size ?? 0,
 		truncated: entry?.truncated ?? false,
 	};
+	// Map preserves insertion order; the first key is the oldest entry. Evict
+	// before insert so the cache stays at most READ_RUN_TRANSCRIPT_CACHE_MAX.
+	while (readRunTranscriptCache.size >= READ_RUN_TRANSCRIPT_CACHE_MAX) {
+		const oldest = readRunTranscriptCache.keys().next().value;
+		if (oldest === undefined) break;
+		readRunTranscriptCache.delete(oldest);
+	}
+	readRunTranscriptCache.set(cacheKey, { parsedAt: now, result });
+	return result;
 }
 
 interface ViewerState {

package/src/ui/widget/index.ts

@@ -12,13 +12,14 @@ import type { ManifestCache } from "../../runtime/manifest-cache.ts";
 import type { TeamRunManifest } from "../../state/types.ts";
 import { truncate } from "../../utils/visual.ts";
 import { requestRender, requestRenderTarget, setExtensionWidget } from "../pi-ui-compat.ts";
-import { runEventBus } from "../run-event-bus.ts";
-import type { RunSnapshotCache, RunUiSnapshot } from "../snapshot-types.ts";
+import { RenderScheduler } from "../render-scheduler.ts";
+import { runEventBusAsRenderScheduler } from "../run-event-bus.ts";
+import type { RunSnapshotCache } from "../snapshot-types.ts";
 import { spinnerBucket, spinnerFrame } from "../spinner.ts";
 import type { CrewTheme } from "../theme-adapter.ts";
 import { asCrewTheme, subscribeThemeChange } from "../theme-adapter.ts";
 import { activeWidgetRuns, statusSummary } from "./widget-model.ts";
-import { buildWidgetLines, colorWidgetLine, DEFAULT_WIDGET_WIDTH, renderLines, TASK_DESC_MAX } from "./widget-renderer.ts";
+import { buildWidgetLines, colorWidgetLine, DEFAULT_WIDGET_WIDTH, renderLines } from "./widget-renderer.ts";
 import type { CrewWidgetModel, CrewWidgetState, WidgetRun } from "./widget-types.ts";
 
 export { activeWidgetRuns, statusSummary } from "./widget-model.ts";
@@ -109,7 +110,7 @@ class CrewWidgetComponent implements WidgetComponent {
 	private cachedTheme: CrewTheme;
 	private readonly tui: unknown;
 	private readonly unsubscribeTheme: () => void;
-	private readonly unsubscribeEventBus: () => void;
+	private readonly renderScheduler: RenderScheduler;
 
 	constructor(model: CrewWidgetModel, themeLike: unknown, tui?: unknown) {
 		this.model = model;
@@ -123,16 +124,21 @@ class CrewWidgetComponent implements WidgetComponent {
 		activeResizeTarget = this;
 		installResizeListener();
 		this.unsubscribeTheme = subscribeThemeChange(themeLike, () => this.invalidate());
-		this.unsubscribeEventBus = (() => {
-			const unsub1 = runEventBus.onChannel("run:state", () => this.invalidate());
-			const unsub2 = runEventBus.onChannel("worker:lifecycle", () => this.invalidate());
-			const unsub3 = runEventBus.onChannel("ui:invalidate", () => this.invalidate());
-			return () => {
-				unsub1();
-				unsub2();
-				unsub3();
-			};
-		})();
+		// 1.10 (UI-P1-1): route run:state / worker:lifecycle / ui:invalidate
+		// through a RenderScheduler (debounce + fallback) instead of three
+		// direct runEventBus.onChannel subscriptions. With 3 overlays
+		// subscribing independently a single event triggered up to 9 callbacks
+		// and ~150 invalidates/sec under load. The scheduler collapses bursts
+		// into one debounced invalidate.
+		this.renderScheduler = new RenderScheduler(
+			runEventBusAsRenderScheduler(["run:state", "worker:lifecycle", "ui:invalidate"]),
+			() => this.invalidate(),
+			{
+				debounceMs: 75,
+				fallbackMs: 750,
+				events: ["run:state", "worker:lifecycle", "ui:invalidate"],
+			},
+		);
 	}
 
 	private buildSignature(runs: WidgetRun[]): string {
@@ -193,7 +199,7 @@ class CrewWidgetComponent implements WidgetComponent {
 
 	dispose(): void {
 		this.unsubscribeTheme();
-		this.unsubscribeEventBus();
+		this.renderScheduler.dispose();
 		if (activeResizeTarget === this) activeResizeTarget = undefined;
 	}
 
@@ -222,6 +228,11 @@ class CrewWidgetComponent implements WidgetComponent {
 
 		if (runs.length === 0) {
 			this.invalidate();
+			// P0-6: render from snapshots only — never read disk on every render tick.
+			// When the snapshot cache is provided but hasn't populated yet, paint a
+			// single "(loading…)" line so the pre-load frame is well-formed instead
+			// of an empty panel. Without a cache (legacy/tests) keep the empty result.
+			if (this.model.snapshotCache) return ["(loading…)"];
 			return [];
 		}
 

package/src/ui/widget/widget-model.ts

@@ -8,7 +8,7 @@ import { listRecentRuns } from "../../extension/run-index.ts";
 import { reconcileAllStaleRuns } from "../../runtime/crash-recovery.ts";
 import { readCrewAgents } from "../../runtime/crew-agent-records.ts";
 import type { CrewAgentRecord } from "../../runtime/crew-agent-runtime.ts";
-import { evictStaleLiveAgentHandles, listLiveAgents } from "../../runtime/live-agent-manager.ts";
+import { evictStaleLiveAgentHandles } from "../../runtime/live-agent-manager.ts";
 import type { ManifestCache } from "../../runtime/manifest-cache.ts";
 import { isDisplayActiveRun } from "../../runtime/process-status.ts";
 import type { TeamRunManifest } from "../../state/types.ts";
@@ -57,18 +57,27 @@ export function activeWidgetRuns(
 		.map((run) => {
 			try {
 				const snapshot = snapshotCache?.get(run.runId);
-				return snapshot
-					? {
-							run: snapshot.manifest,
-							agents: snapshot.agents,
-							snapshot,
-						}
-					: { run, agents: agentsFor(run) };
+				if (snapshot) {
+					return {
+						run: snapshot.manifest,
+						agents: snapshot.agents,
+						snapshot,
+					};
+				}
+				// P0-6: render from snapshots only — never read disk on every
+				// render tick. When the snapshot cache is provided but hasn't
+				// populated yet (first frame after `updateCrewWidget`), drop the
+				// run from the result so the widget paints "(loading…)" instead
+				// of calling `agentsFor(run) → readCrewAgents`. Legacy callers
+				// (no snapshotCache) keep the disk-read fallback for tests/dev.
+				if (snapshotCache) return null;
+				return { run, agents: agentsFor(run) };
 			} catch {
+				if (snapshotCache) return null;
 				return { run, agents: agentsFor(run) };
 			}
 		})
-		.filter((item) => isDisplayActiveRun(item.run, item.agents));
+		.filter((item): item is WidgetRun => item !== null && isDisplayActiveRun(item.run, item.agents));
 }
 
 /**

package/src/ui/widget/widget-renderer.ts

@@ -5,16 +5,13 @@
  */
 
 import { listLiveAgents } from "../../runtime/live-agent-manager.ts";
-import { computePhaseProgress, formatPhaseProgressLine } from "../../runtime/phase-progress.ts";
 import { isFinishedRunStatus } from "../../runtime/process-status.ts";
-import { getTaskUsage } from "../../runtime/usage-tracker.ts";
 import { truncate } from "../../utils/visual.ts";
 import { Box, Text } from "../layout-primitives.ts";
-import { computeLiveDurationMs } from "../live-duration.ts";
 import { spinnerFrame } from "../spinner.ts";
 import { colorizeStatusGlyphs, iconForStatus } from "../status-colors.ts";
 import type { CrewTheme } from "../theme-adapter.ts";
-import { agentActivity, agentStats, elapsed, formatTokensCompact, notificationBadge } from "./widget-formatters.ts";
+import { agentActivity, agentStats, notificationBadge } from "./widget-formatters.ts";
 import { activeWidgetRuns, shortRunLabel } from "./widget-model.ts";
 import type { WidgetRun } from "./widget-types.ts";
 
@@ -98,7 +95,7 @@ export function buildWidgetLines(
 		// reached its terminal status). The status label is also surfaced
 		// explicitly so the row cannot be misread as an active run.
 		const agentCountText = `${completed}/${agents.length} agents`;
-		const runEndMs = isTerminal ? new Date(run.updatedAt).getTime() : Date.now();
+		const runEndMs = isTerminal ? new Date(run.updatedAt).getTime() : now;
 		const runElapsedMs = Math.max(0, Number.isFinite(runEndMs) ? runEndMs - new Date(run.createdAt).getTime() : 0);
 		const runElapsedText = `${Math.floor(runElapsedMs / 1000)}s`;
 		const statusLabel = isTerminal ? ` · ${run.status}` : "";

package/src/utils/fingerprint.ts

@@ -7,7 +7,7 @@
  * Only STRUCTURAL changes trigger re-analysis.
  */
 
-import { createHash, type Hash } from "node:crypto";
+import { createHash } from "node:crypto";
 import { existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { logInternalError } from "../utils/internal-error.ts";
 

package/src/utils/paths.ts

@@ -44,7 +44,7 @@ export function userPiRoot(): string {
 	// "undefined/.pi/agent" relative to cwd and silently create a junk "undefined/"
 	// tree. Treat the literal "undefined" (and empty) as unset and fall back to
 	// os.homedir().
-	const rawHome = process.env.PI_TEAMS_HOME?.trim();
+	const rawHome = (process.env.PI_TEAMS_HOME ?? process.env.PI_CREW_HOME)?.trim();
 	const home = rawHome && rawHome !== "undefined" ? rawHome : os.homedir();
 	const resolved = path.join(home, ".pi", "agent");
 

package/src/utils/project-detector.ts

@@ -113,7 +113,7 @@ export function detectProjectId(cwd: string): ProjectInfo {
 
 	// Method 1: Check CLAUDE_PROJECT_DIR env var
 	const claudeProjectDir = process.env.CLAUDE_PROJECT_DIR;
-	if (claudeProjectDir && claudeProjectDir.trim()) {
+	if (claudeProjectDir?.trim()) {
 		const resolvedPath = path.resolve(claudeProjectDir.trim());
 		const projectName = path.basename(resolvedPath);
 		const projectId = hashPath(resolvedPath);