pi-crew 0.9.9 → 0.9.10

package/src/runtime/task-runner.ts

@@ -763,7 +763,30 @@ export async function runTeamTask(
 					"",
 				);
 				if (!error) break;
-				const nextModel = attemptModels[i + 1];
+				let nextModel = attemptModels[i + 1];
+				// FIX 1 (task packet 01_01-agent): when the precomputed attempt
+				// chain is exhausted but the failure is retryable, do a one-shot
+				// re-resolve via buildConfiguredModelRouting with the failed
+				// model as parent. This finds alternative providers/models the
+				// original chain missed (e.g. a registry gained new fallbacks
+				// after the precompute, or the precompute ran before the parent
+				// model was known). If a different candidate is found, use it as
+				// nextModel; otherwise fall through to the existing break.
+				if (!nextModel && isRetryableModelFailure(error)) {
+					const reResolved = buildConfiguredModelRouting({
+						overrideModel: undefined,
+						stepModel: undefined,
+						teamRoleModel: undefined,
+						agentModel: undefined,
+						fallbackModels: undefined,
+						parentModel: attempt.model,
+						modelRegistry: input.modelRegistry,
+						cwd: task.cwd,
+						scopeModelsPatterns: await resolveTaskScopeModelsPatterns(task.cwd),
+					});
+					const alt = reResolved.candidates.find((c) => c !== attempt.model);
+					if (alt) nextModel = alt;
+				}
 				if (!nextModel || !isRetryableModelFailure(error)) break;
 				logs.push(formatModelAttemptNote(attempt, nextModel), "");
 			}
@@ -1368,19 +1391,57 @@ async function resolveTaskScopeModelsPatterns(cwd: string): Promise<string[]> {
  * or when there are no retryable error messages.
  */
 export function detectRetryableModelFailureFromOutput(parsed: ParsedPiJsonOutput): string | undefined {
+	// Primary signal: pre-extracted `errorMessages` (from pi-json-output parser).
+	// The parser already filters to non-empty trimmed strings from message_end
+	// events.
 	const messages = parsed.errorMessages;
-	if (!messages || messages.length === 0) return undefined;
-	// Find the first retryable model-failure message (429 / rate-limit / overloaded / 5xx / ...).
-	const retryable = messages.find((m) => isRetryableModelFailure(m));
-	if (!retryable) return undefined;
-	// Did the run actually produce real output despite the transient errors?
-	// If finalText / textEvents / patches exist, the model recovered and we
-	// should NOT mark the run as failed — only flag it when the worker yielded
-	// nothing (the 429-only case from the bug report).
-	const hasRealOutput =
-		(parsed.finalText?.trim().length ?? 0) > 0 ||
-		parsed.textEvents.some((t) => t.trim().length > 0) ||
-		(parsed.patches?.length ?? 0) > 0;
-	if (hasRealOutput) return undefined;
-	return `Model returned only retryable errors and no output: ${retryable}`;
+	if (messages && messages.length > 0) {
+		// Find the first retryable model-failure message
+		// (429 / rate-limit / overloaded / 5xx / ...).
+		const retryable = messages.find((m) => isRetryableModelFailure(m));
+		if (retryable) {
+			// Did the run actually produce real output despite the transient errors?
+			// If finalText / textEvents / patches exist, the model recovered and we
+			// should NOT mark the run as failed — only flag it when the worker
+			// yielded nothing (the 429-only case from the bug report).
+			const hasRealOutput =
+				(parsed.finalText?.trim().length ?? 0) > 0 ||
+				parsed.textEvents.some((t) => t.trim().length > 0) ||
+				(parsed.patches?.length ?? 0) > 0;
+			if (hasRealOutput) return undefined;
+			return `Model returned only retryable errors and no output: ${retryable}`;
+		}
+	}
+	// Secondary signal (FIX 3, task packet 01_01-agent): inspect a raw
+	// `messageEndEvents` (or `transcript`) array on the parsed output. The
+	// ParsedPiJsonOutput type does not currently declare this field, so we
+	// read it through a local extension cast. Callers that pass it (tests, a
+	// future parser that captures the full event stream) get a second chance
+	// to surface retryable failures. Primary path still wins when it matches.
+	const raw = parsed as ParsedPiJsonOutput & {
+		messageEndEvents?: unknown;
+		transcript?: unknown;
+	};
+	const eventSource = Array.isArray(raw.messageEndEvents)
+		? raw.messageEndEvents
+		: Array.isArray(raw.transcript)
+			? raw.transcript
+			: undefined;
+	if (!eventSource || eventSource.length === 0) return undefined;
+	for (const candidate of eventSource) {
+		if (!candidate || typeof candidate !== "object") continue;
+		const event = candidate as { stopReason?: unknown; errorMessage?: unknown };
+		if (event.stopReason !== "error") continue;
+		if (typeof event.errorMessage !== "string" || event.errorMessage.length === 0) continue;
+		if (!isRetryableModelFailure(event.errorMessage)) continue;
+		// Same real-output gate as the primary signal — don't flag runs that
+		// recovered with real final text / patches.
+		const hasRealOutput =
+			(parsed.finalText?.trim().length ?? 0) > 0 ||
+			parsed.textEvents.some((t) => t.trim().length > 0) ||
+			(parsed.patches?.length ?? 0) > 0;
+		if (hasRealOutput) return undefined;
+		return `Model returned only retryable errors and no output: ${event.errorMessage}`;
+	}
+	return undefined;
 }

package/src/state/locks.ts

@@ -292,6 +292,17 @@ export function withFileLockSync<T>(filePath: string, fn: () => T, options: RunL
 	// append, or even the lock acquisition itself) would race with the lock.
 	const lockFile = `${filePath}.lock`;
 	const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
+	// FIX (Round 29): re-entrance guard — mirrors withRunLockSync below.
+	// When the same call stack already holds the file lock (e.g.
+	// registerWorker -> cleanupOrphanWorkers -> readRegistry), the second
+	// acquisition would otherwise read its own freshly-written lock file
+	// (same pid, fresh createdAt), fail the steal check, and deadlock for
+	// the full staleMs window. Strace-confirmed in
+	// .github/issues/pre-existing-2026-06-10/04-orphan-worker-registry-tests.md:75-86.
+	const existingToken = fileLockHeldByUs.get(lockFile);
+	if (existingToken) {
+		return fn();
+	}
 	// FIX: Validate the parent directory is not a symlink BEFORE calling mkdirSync.
 	// Between mkdir and lock acquisition, an attacker could plant a symlink.
 	if (!isSymlinkSafePath(path.dirname(lockFile))) throw new Error("Refusing: parent of lock directory is a symlink");
@@ -322,10 +333,12 @@ export function withFileLockSync<T>(filePath: string, fn: () => T, options: RunL
 		}
 	}
 	if (token === "") throw new Error(`Run '${path.basename(lockFile)}' is locked by another operation.`);
+	fileLockHeldByUs.set(lockFile, token);
 	try {
 		return fn();
 	} finally {
 		// Token-guarded release: don't rm the lock if it has been stolen.
+		fileLockHeldByUs.delete(lockFile);
 		releaseLock(lockFile, token);
 	}
 }
@@ -353,6 +366,9 @@ export function withRunLockSync<T>(manifest: TeamRunManifest, fn: () => T, optio
 // already held by this call stack (handleResume -> executeTeamRun ->
 // executeTeamRunCore), we skip re-acquisition to avoid deadlock.
 const runLockHeldByUs = new Map<string, string>(); // filePath -> token
+// Round 29: parallel map for withFileLockSync re-entrance. See the comment
+// at the top of withFileLockSync for the full deadlock mechanism.
+const fileLockHeldByUs = new Map<string, string>(); // lockFile -> token
 
 export async function withRunLock<T>(manifest: TeamRunManifest, fn: () => Promise<T>, options: RunLockOptions = {}): Promise<T> {
 	const filePath = lockPath(manifest);

package/src/state/state-store.ts

@@ -634,7 +634,10 @@ export function loadRunManifestById(cwd: string, runId: string): { manifest: Tea
 	// between the final stat and the read. Callers needing strict consistency
 	// MUST use withRunLock() around load+modify+save.
 	if (attempts > 0) {
-		console.warn(`[state-store] loadRunManifestById: retry loop detected instability for run ${runId} after ${attempts} attempt(s) — best-effort only, use withRunLock() for strict consistency`);
+		// Round 19: downgrade to debug — retry-loop instability is expected under
+		// concurrent writes (live team runs constantly append to tasks.json).
+		// This is best-effort by design; strict consistency requires withRunLock().
+		console.debug(`[state-store] loadRunManifestById: retry loop detected instability for run ${runId} after ${attempts} attempt(s) — best-effort only, use withRunLock() for strict consistency`);
 	}
 	// NOTE: manifest mtime may legitimately be >= tasks mtime because
 	// saveManifestAndTasksAtomicSync writes manifest before tasks. However,
@@ -724,7 +727,10 @@ export async function loadRunManifestByIdAsync(cwd: string, runId: string): Prom
 	// between the final stat and the read. Callers needing strict consistency
 	// MUST use withRunLock() around load+modify+save.
 	if (attempts > 0) {
-		console.warn(`[state-store] loadRunManifestByIdAsync: retry loop detected instability for run ${runId} after ${attempts} attempt(s) — best-effort only, use withRunLock() for strict consistency`);
+		// Round 19: downgrade to debug — retry-loop instability is expected under
+		// concurrent writes (live team runs constantly append to tasks.json).
+		// This is best-effort by design; strict consistency requires withRunLock().
+		console.debug(`[state-store] loadRunManifestByIdAsync: retry loop detected instability for run ${runId} after ${attempts} attempt(s) — best-effort only, use withRunLock() for strict consistency`);
 	}
 	// NOTE: manifest mtime may legitimately be >= tasks mtime because
 	// saveManifestAndTasksAtomicSync writes manifest before tasks. However,

package/src/ui/live-run-sidebar.ts

@@ -76,7 +76,12 @@ export class LiveRunSidebar {
 		this.config = input.config ?? {};
 		this.snapshotCache = input.snapshotCache;
 		this.unsubscribeTheme = subscribeThemeChange(input.theme, () => this.invalidate());
-		this.unsubscribeEventBus = runEventBus.onAny(() => 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(); };
+	})();
 	}
 
 	private buildSignature(manifestStatus: string, tasks: TeamTaskState[], agents: ReturnType<typeof readCrewAgents>, waitingCount: number, snapshot?: RunUiSnapshot): string {

package/src/ui/loaders.ts

@@ -113,23 +113,43 @@ export class CountdownTimer {
 	private readonly timeoutMs: number;
 	private timer: ReturnType<typeof setTimeout> | undefined;
 	private expired = false;
+	private lastEmittedSeconds = -1;
 
 	constructor(options: CountdownTimerOptions) {
 		this.timeoutMs = Math.max(0, options.timeoutMs);
 		this.onTick = options.onTick;
 		this.onExpire = options.onExpire;
 		this.startedAt = Date.now();
-		this.onTick(this.secondsLeft());
+		this.lastEmittedSeconds = this.secondsLeft();
+		this.onTick(this.lastEmittedSeconds);
 		if (this.timeoutMs === 0) {
 			this.emitExpire();
 			return;
 		}
-		this.timer = setInterval(() => {
+		this.scheduleNextTick();
+	}
+
+	/**
+	 * Schedule the next tick via recursive setTimeout. Each tick re-emits the
+	 * current `secondsLeft()` only if it differs from the last emitted value
+	 * (lastEmittedSeconds guard). This makes the countdown correct even under
+	 * event-loop pressure: if the previous tick fired 1.2s late, the next
+	 * tick still emits the right value for the current second rather than
+	 * skipping it (the pre-fix `setInterval` could SKIP a second value when
+	 * the loop was busy, producing [3,2,0] instead of [3,2,1,0] in tests).
+	 */
+	private scheduleNextTick(): void {
+		this.timer = setTimeout(() => {
 			const seconds = this.secondsLeft();
-			this.onTick(seconds);
+			if (seconds !== this.lastEmittedSeconds) {
+				this.lastEmittedSeconds = seconds;
+				this.onTick(seconds);
+			}
 			if (seconds <= 0) {
 				this.emitExpire();
+				return;
 			}
+			this.scheduleNextTick();
 		}, 1000);
 		// Defense-in-depth: never let the countdown timer keep the event loop
 		// alive. If dispose() is missed (e.g. UI unmount race), the timer must
@@ -151,7 +171,7 @@ export class CountdownTimer {
 
 	dispose(): void {
 		if (this.timer === undefined) return;
-		clearInterval(this.timer);
+		clearTimeout(this.timer);
 		this.timer = undefined;
 	}
 }

package/src/ui/run-dashboard.ts

@@ -294,7 +294,12 @@ export class RunDashboard implements DashboardComponent {
 		this.theme = asCrewTheme(theme);
 		this.options = options;
 		this.unsubscribeTheme = subscribeThemeChange(theme, () => this.invalidateAndRender());
-		this.unsubscribeEventBus = runEventBus.onAny(() => this.invalidateAndRender());
+		this.unsubscribeEventBus = (() => {
+		const unsub1 = runEventBus.onChannel("run:state", () => this.invalidateAndRender());
+		const unsub2 = runEventBus.onChannel("worker:lifecycle", () => this.invalidateAndRender());
+		const unsub3 = runEventBus.onChannel("ui:invalidate", () => this.invalidateAndRender());
+		return () => { unsub1(); unsub2(); unsub3(); };
+	})();
 	}
 
 	/**

package/src/ui/run-event-bus.ts

@@ -40,7 +40,7 @@ const RUN_STATE_TYPES = new Set([
 	"manifest.saved", "task.claimed", "task.unclaimed", "mailbox_updated",
 ]);
 const UI_INVALIDATE_TYPES = new Set([
-	"effectiveness_changed", "snapshot_stale",
+	"effectiveness_changed", "snapshot_stale", "run.cache_invalidated",
 ]);
 
 /** Classify an event type string into a typed channel. */

package/src/ui/run-snapshot-cache.ts

@@ -787,11 +787,55 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 		}
 	}
 
-	const unsubscribe = runEventBus.onAny((event) => {
-		if (entries.has(event.runId)) {
-			entries.delete(event.runId);
-		}
+	// Coalesced eager refresh on event-bus signals. Previously every
+	// `run:state` / `worker:lifecycle` event deleted the cache entry, leaving
+	// a window where `widget-model.ts: snapshotCache.get(runId)` returned
+	// `undefined`. The widget then fell back to `agentsFor(run)` (a disk read
+	// with no snapshot.tasks) and rendered the "0/1 done" branch of
+	// `widget-renderer.ts:39-41` instead of the "Phase 1/1 default: 0% (0/3)"
+	// branch — producing the live flicker between those two progressPart
+	// values every render tick. Replacing the delete with a coalesced
+	// refreshIfStale keeps the cache populated so the widget always sees the
+	// same logical snapshot between stamp changes; multiple events for the
+	// same runId within INVAL_COALESCE_MS are batched into one refresh.
+	function localRefresh(runId: string): RunUiSnapshot {
+		const previous = entries.get(runId);
+		const entry = build(runId, previous);
+		entries.set(runId, entry);
+		evictIfNeeded();
+		return entry.snapshot;
+	}
+	function localRefreshIfStale(runId: string): RunUiSnapshot {
+		const previous = entries.get(runId);
+		if (!previous) return localRefresh(runId);
+		const now = Date.now();
+		if (now - previous.loadedAtMs < ttlMs) return touch(runId, previous);
+		const stamps = currentStamps(previous);
+		if (sameStamps(stamps, previous.stamps)) return touch(runId, previous);
+		return localRefresh(runId);
+	}
+	const pendingRefreshes = new Map<string, ReturnType<typeof setTimeout>>();
+	const INVAL_COALESCE_MS = 80;
+	const scheduleRefresh = (runId: string): void => {
+		const existing = pendingRefreshes.get(runId);
+		if (existing) clearTimeout(existing);
+		pendingRefreshes.set(runId, setTimeout(() => {
+			pendingRefreshes.delete(runId);
+			try { localRefreshIfStale(runId); } catch { /* best-effort; widget falls back gracefully */ }
+		}, INVAL_COALESCE_MS));
+	};
+	const unsubState = runEventBus.onChannel("run:state", (event) => {
+		if (entries.has(event.runId)) scheduleRefresh(event.runId);
 	});
+	const unsubLifecycle = runEventBus.onChannel("worker:lifecycle", (event) => {
+		if (entries.has(event.runId)) scheduleRefresh(event.runId);
+	});
+	const unsubscribe = () => {
+		unsubState();
+		unsubLifecycle();
+		for (const timer of pendingRefreshes.values()) clearTimeout(timer);
+		pendingRefreshes.clear();
+	};
 
 	return {
 		get(runId: string): RunUiSnapshot | undefined {
@@ -799,20 +843,10 @@ export function createRunSnapshotCache(cwd: string, options: RunSnapshotCacheOpt
 			return entry ? touch(runId, entry) : undefined;
 		},
 		refresh(runId: string): RunUiSnapshot {
-			const previous = entries.get(runId);
-			const entry = build(runId, previous);
-			entries.set(runId, entry);
-			evictIfNeeded();
-			return entry.snapshot;
+			return localRefresh(runId);
 		},
 		refreshIfStale(runId: string): RunUiSnapshot {
-			const previous = entries.get(runId);
-			if (!previous) return this.refresh(runId);
-			const now = Date.now();
-			if (now - previous.loadedAtMs < ttlMs) return touch(runId, previous);
-			const stamps = currentStamps(previous);
-			if (sameStamps(stamps, previous.stamps)) return touch(runId, previous);
-			return this.refresh(runId);
+			return localRefreshIfStale(runId);
 		},
 		preloadStale,
 		preloadAllStale,

package/src/ui/widget/index.ts

@@ -18,13 +18,30 @@ import { spinnerBucket, spinnerFrame } from "../spinner.ts";
 import { runEventBus } from "../run-event-bus.ts";
 import { DEFAULT_UI } from "../../config/defaults.ts";
 import { activeWidgetRuns, statusSummary } from "./widget-model.ts";
-import { buildWidgetLines, colorWidgetLine, renderLines } from "./widget-renderer.ts";
+import { buildWidgetLines, colorWidgetLine, renderLines, DEFAULT_WIDGET_WIDTH, TASK_DESC_MAX } from "./widget-renderer.ts";
 import type { CrewWidgetModel, CrewWidgetState, WidgetRun } from "./widget-types.ts";
 
 // Re-export types and helpers for backward compatibility
 export type { WidgetRun, CrewWidgetModel, CrewWidgetState } from "./widget-types.ts";
 export { activeWidgetRuns, statusSummary } from "./widget-model.ts";
-export { buildWidgetLines as buildCrewWidgetLines, widgetHeader } from "./widget-renderer.ts";
+export { buildWidgetLines as buildCrewWidgetLines, widgetHeader, DEFAULT_WIDGET_WIDTH, TASK_DESC_MAX } from "./widget-renderer.ts";
+
+/**
+ * Resolve the real render width for widget lines, in priority order:
+ *   1. explicit `width` argument (e.g. from caller that already knows terminal width)
+ *   2. `process.stdout.columns` (works in Node when stdout is a TTY)
+ *   3. `DEFAULT_WIDGET_WIDTH` (100) — last-resort fallback so we never paint
+ *      a line wider than the smallest expected TUI.
+ *
+ * Callers SHOULD pass the width they already hold (e.g. `WidgetRender.render(width)`
+ * in this file already receives one). This helper exists for paths that don't.
+ */
+export function getRenderWidth(width?: number): number {
+	if (Number.isFinite(width) && width! > 0) return Math.floor(width!);
+	const stdoutCols = (globalThis as { process?: { stdout?: { columns?: number } } }).process?.stdout?.columns;
+	if (Number.isFinite(stdoutCols) && stdoutCols! > 0) return Math.floor(stdoutCols!);
+	return DEFAULT_WIDGET_WIDTH;
+}
 export { notificationBadge } from "./widget-formatters.ts";
 
 // ── Constants ─────────────────────────────────────────────────────────
@@ -57,7 +74,12 @@ class CrewWidgetComponent implements WidgetComponent {
 		this.theme = asCrewTheme(themeLike);
 		this.cachedTheme = this.theme;
 		this.unsubscribeTheme = subscribeThemeChange(themeLike, () => this.invalidate());
-		this.unsubscribeEventBus = runEventBus.onAny(() => 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(); };
+	})();
 	}
 
 	private buildSignature(runs: WidgetRun[]): string {
@@ -103,7 +125,7 @@ class CrewWidgetComponent implements WidgetComponent {
 		const runningGlyph = spinnerFrame("widget-header");
 
 		if (this.cacheSignature !== signature || width !== this.cachedWidth || this.cachedTheme !== this.theme) {
-			this.cachedBaseLines = buildWidgetLines(this.model.cwd, 0, this.model.maxLines, runs, this.model.notificationCount ?? 0).map((line, index) => {
+			this.cachedBaseLines = buildWidgetLines(this.model.cwd, 0, this.model.maxLines, runs, this.model.notificationCount ?? 0, width).map((line, index) => {
 				if (index === 0 && line.length > 0) return `${runningGlyph}${line.slice(1)}`;
 				return line;
 			});
@@ -150,7 +172,7 @@ export function updateCrewWidget(
 	}
 
 	const runs = activeWidgetRuns(ctx.cwd, manifestCache, snapshotCache, preloadedManifests, workspaceId);
-	const lines = buildWidgetLines(ctx.cwd, state.frame, maxLines, runs, state.notificationCount ?? 0);
+	const lines = buildWidgetLines(ctx.cwd, state.frame, maxLines, runs, state.notificationCount ?? 0, getRenderWidth());
 	const placement = config?.widgetPlacement ?? DEFAULT_UI.widgetPlacement;
 
 	ctx.ui.setStatus(STATUS_KEY, lines.length ? statusSummary(runs) : undefined);

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

@@ -11,12 +11,21 @@ import { Box, Text } from "../layout-primitives.ts";
 import { listLiveAgents } from "../../runtime/live-agent-manager.ts";
 import { computePhaseProgress, formatPhaseProgressLine } from "../../runtime/phase-progress.ts";
 import { spinnerFrame } from "../spinner.ts";
-import { agentActivity, agentStats, notificationBadge } from "./widget-formatters.ts";
-import { shortRunLabel } from "./widget-model.ts";
+import { computeLiveDurationMs } from "../live-duration.ts";
+import { getTaskUsage } from "../../runtime/usage-tracker.ts";
+import { agentActivity, agentStats, elapsed, formatTokensCompact, notificationBadge } from "./widget-formatters.ts";
+import { activeWidgetRuns, shortRunLabel } from "./widget-model.ts";
 import type { WidgetRun } from "./widget-types.ts";
 
 const MAX_AGENTS_DISPLAY = 3;
 const FINISHED_LINGER_MAX_AGE = 1;
+/** Default terminal width when caller doesn't pass one explicitly. Keep <= 116
+ * (the same default used elsewhere in pi-crew tool renderers) so we never paint
+ * a line wider than the smallest expected TUI. Callers SHOULD pass the real
+ * width when known (via ctx.width || process.stdout.columns). */
+export const DEFAULT_WIDGET_WIDTH = 100;
+/** Cap per-component text so a single field cannot blow past width on its own. */
+export const TASK_DESC_MAX = 60;
 const ERROR_LINGER_MAX_AGE = 2;
 const ERROR_STATUSES = new Set(["failed", "cancelled", "stopped", "needs_attention"]);
 
@@ -37,8 +46,12 @@ export function widgetHeader(runs: WidgetRun[], runningGlyph: string, maxLines =
 
 // ── Line builder ──────────────────────────────────────────────────────
 
-export function buildWidgetLines(cwd: string, frame = 0, maxLines = 8, providedRuns?: WidgetRun[], notificationCount = 0): string[] {
-	const runs = providedRuns ?? [];
+export function buildWidgetLines(cwd: string, frame = 0, maxLines = 8, providedRuns?: WidgetRun[], notificationCount = 0, width = DEFAULT_WIDGET_WIDTH): string[] {
+	// Match the legacy `buildCrewWidgetLines` API: when no runs are supplied,
+	// auto-fetch via activeWidgetRuns(cwd). Otherwise widgets calling with
+	// only `(cwd, frame)` would render an empty line set (regression vs. the
+	// pre-refactor implementation that called activeWidgetRuns here).
+	const runs = providedRuns ?? activeWidgetRuns(cwd);
 	if (!runs.length) return [];
 
 	const runningGlyph = spinnerFrame("widget-header");
@@ -56,9 +69,23 @@ export function buildWidgetLines(cwd: string, frame = 0, maxLines = 8, providedR
 		});
 		const completed = agents.filter((a) => a.status === "completed").length;
 		const runGlyph = iconForStatus(run.status, { runningGlyph });
-		const phaseLine = snapshot ? formatPhaseProgressLine(computePhaseProgress(snapshot.tasks)) : "";
-		const progressPart = phaseLine || `${completed}/${agents.length} done`;
-		lines.push(`├─ ${runGlyph} ${shortRunLabel(run)} · ${progressPart} · ${run.runId.slice(-8)}`);
+		// Run progress line. v1–v3 flickered on snapshot.tasks state, v4 was
+		// too minimal (`0/1 agents` only), v5 duplicated the worker activity
+		// line (tools/tokens/duration already shown one row below). v6 (this)
+		// shows only data that is RUN-level (not already in the per-agent
+		// activity line) and is GUARANTEED stable across ticks:
+		//   - agents count — from `agents` array, always populated, never empty.
+		//   - run elapsed   — from `run.createdAt`, always set on manifest.
+		// Both come from sources with no race window — `agents` is read from
+		// snapshot.agents OR agentsFor(run) (both always return same length
+		// for a healthy run), and `run.createdAt` is immutable. The format
+		// shape `"X/Y agents · Ns"` is therefore truly invariant: same number
+		// of `·`-separated fields, same field meanings, every render tick.
+		const agentCountText = `${completed}/${agents.length} agents`;
+		const runElapsedMs = Math.max(0, Date.now() - new Date(run.createdAt).getTime());
+		const runElapsedText = `${Math.floor(runElapsedMs / 1000)}s`;
+		const progressPart = `${agentCountText} · ${runElapsedText}`;
+		lines.push(truncate(`├─ ${runGlyph} ${shortRunLabel(run)} · ${progressPart} · ${run.runId.slice(-8)}`, width));
 
 		const liveForRun = listLiveAgents().filter((a) => a.runId === run.runId);
 
@@ -67,8 +94,9 @@ export function buildWidgetLines(cwd: string, frame = 0, maxLines = 8, providedR
 			const name = liveHandle?.agent ?? agent.agent;
 			const icon = agent.status === "completed" ? "✓" : agent.status === "failed" ? "✗" : agent.status === "needs_attention" ? "⚠" : "▪";
 			const stats = agentStats(agent, liveHandle);
-			const desc = liveHandle?.description ?? agent.role;
-			lines.push(`│  ├─ ${icon} ${name} · ${desc}${stats ? ` · ${stats}` : ""}`);
+			const desc = truncate(liveHandle?.description ?? agent.role ?? "", TASK_DESC_MAX);
+			const _finished = truncate(`│  ├─ ${icon} ${name} · ${desc}${stats ? ` · ${stats}` : ""}`, width);
+			lines.push(_finished);
 		}
 
 		const visibleAgents = activeAgents.slice(0, MAX_AGENTS_DISPLAY);
@@ -79,13 +107,15 @@ export function buildWidgetLines(cwd: string, frame = 0, maxLines = 8, providedR
 			const liveHandle = liveForRun.find((h) => h.taskId === agent.taskId);
 			const stats = agentStats(agent, liveHandle);
 			const name = liveHandle?.agent ?? agent.agent;
-			const desc = liveHandle?.description ?? agent.role;
-			lines.push(`│  ${branch} ${agentGlyph} ${name}${desc ? ` · ${desc}` : ` · ${agent.role}`}`);
-			lines.push(`│     ⊶ ${agentActivity(agent, liveHandle)}${stats ? ` · ${stats}` : ""}`);
+			const desc = truncate(liveHandle?.description ?? agent.role ?? "", TASK_DESC_MAX);
+			const _activeMain = truncate(`│  ${branch} ${agentGlyph} ${name}${desc ? ` · ${desc}` : ` · ${agent.role}`}`, width);
+			lines.push(_activeMain);
+			const _activity = truncate(`│     ⊶ ${agentActivity(agent, liveHandle)}${stats ? ` · ${stats}` : ""}`, width);
+			lines.push(_activity);
 		}
 
 		if (activeAgents.length > MAX_AGENTS_DISPLAY) {
-			lines.push(`│  └─ … +${activeAgents.length - MAX_AGENTS_DISPLAY} more agents`);
+			lines.push(truncate(`│  └─ … +${activeAgents.length - MAX_AGENTS_DISPLAY} more agents`, width));
 		}
 
 		if (lines.length >= maxLines) break;

package/src/utils/redaction.ts

@@ -208,6 +208,22 @@ export function redactSecretString(value: string): string {
 // i++ (advance 1 char) and re-scanned from i+1, so a long run was rescanned O(n)
 // times = O(n^2). The P1f ReDoS test (300KB no-dot input) surfaced this pre-existing
 // bug. Now advances past the whole run when it isn't a redactable secret -> O(n).
+// FIX (BG2 follow-up): the inner-loop regex test /[a-zA-Z0-9_-]/.test(value[j])
+// is O(1) per call but with measurable regex-engine overhead — for a 100KB
+// underscore run that's 100K regex calls, well over the 200ms budget the
+// P1f regression test allows. Replaced with a charCodeAt check (~5x faster
+// in practice, O(1) per call with no regex allocation/eval cost).
+function isKeyChar(c: string): boolean {
+	const code = c.charCodeAt(0);
+	return (
+		(code >= 48 && code <= 57) ||  // 0-9
+		(code >= 65 && code <= 90) ||  // A-Z
+		(code >= 97 && code <= 122) || // a-z
+		code === 95 || // _
+		code === 45 // -
+	);
+}
+
 function redactInlineSecrets(value: string): string {
 	const result: string[] = [];
 	let i = 0;
@@ -215,7 +231,7 @@ function redactInlineSecrets(value: string): string {
 	while (i < value.length) {
 		// Collect a run of key characters (alphanumeric, underscore, hyphen).
 		let j = i;
-		while (j < value.length && /[a-zA-Z0-9_-]/.test(value[j])) {
+		while (j < value.length && isKeyChar(value[j])) {
 			j++;
 		}
 		const keyLen = j - i;

package/src/utils/visual.ts

@@ -29,6 +29,12 @@ const WIDE_RANGES: Array<[number, number]> = [
 	[0x274C, 0x274C], [0x274E, 0x274E], [0x2753, 0x2755], [0x2757, 0x2757],
 	[0x2763, 0x2764], [0x2795, 0x2797], [0x27A1, 0x27A1], [0x27B0, 0x27B0],
 	[0x27BF, 0x27BF],
+	// Geometric Shapes / Misc Symbols-Arrows emoji that pi-tui upstream counts as
+	// width=2 (RGI emoji). Mismatch here caused the "Rendered line N exceeds
+	// terminal width (160 > 159)" TUI crash: pi-crew truncated to width 159 by
+	// its own (mismatched) measure, then Box padded to 159 chars, but pi-tui
+	// re-measured the padded line at 160 because ⬜ counts as 2 upstream.
+	[0x2B1B, 0x2B1C], // ⬛ BLACK LARGE SQUARE, ⬜ WHITE LARGE SQUARE
 	[0x1F300, 0x1F9FF], // Misc Symbols, Emoticons, Transport, Map, Supplement
 	[0x1FA00, 0x1FAFF], // Symbols Extended-A
 	[0x1F000, 0x1F02F], // Mahjong, Dominos