pi-crew 0.9.8 → 0.9.10

package/src/runtime/tool-output-pruner.ts

@@ -0,0 +1,334 @@
+/**
+ * Staleness-aware tool output pruning.
+ *
+ * Identifies tool results that have been superseded by a later result for the
+ * same target (same file read again, same search re-run) or invalidated by a
+ * later successful edit/write to a covered file, and replaces the stale
+ * content with a compact digest notice. Protect-window and minimum-savings
+ * hysteresis ensure recent results are preserved and pruning only fires when
+ * the savings justify it.
+ *
+ * Ported and adapted from gajae-code's compaction/pruning.ts to pi-crew's
+ * data shapes. Pi-crew delegates conversation management to child Pi
+ * processes, so this module operates on a generic {@link ToolResultEntry}
+ * sequence rather than SessionEntry[]. The primary integration point is
+ * task-output-context.ts (dependency output context injected into worker
+ * prompts), but the module is designed to be reusable for any in-process
+ * tool-result sequence.
+ */
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/**
+ * A single tool result in a sequence (oldest → newest).
+ * Adapted to pi-crew's shapes — does not depend on gajae-code's SessionEntry.
+ */
+export interface ToolResultEntry {
+	/** Stable identifier for deduplication and correlation. */
+	id: string;
+	/** Tool name: "read", "bash", "grep", "search", "edit", "write", etc. */
+	toolName: string;
+	/**
+	 * Target identity: file path for read/edit/write, search pattern for
+	 * grep/search, or undefined for tools without a natural target key.
+	 */
+	target?: string;
+	/** The tool result content text. */
+	content: string;
+	/** Whether the tool result represents an error. */
+	isError?: boolean;
+}
+
+/** A file mutation event (edit/write) that can invalidate earlier reads. */
+export interface FileEditEvent {
+	/** The file path that was mutated. */
+	target: string;
+	/**
+	 * Sequence index of this edit relative to tool results. A read at index
+	 * `i` is stale if an edit at index `j > i` touches the same file.
+	 */
+	index: number;
+}
+
+export interface PruneConfig {
+	/** Keep the most recent tool output tokens intact (protect window). */
+	protectTokens: number;
+	/** Only prune if total savings meets this threshold (hysteresis). */
+	minimumSavings: number;
+	/** Tool names that should never be pruned. */
+	protectedTools: string[];
+	/**
+	 * Tools in `protectedTools` whose protection is waived once the result is
+	 * superseded (a later result for the same target, or a later successful
+	 * edit/write to the covered file). The most recent result per target is
+	 * never considered superseded. Optional; defaults to none.
+	 */
+	staleOverridableTools?: string[];
+}
+
+export const DEFAULT_PRUNE_CONFIG: PruneConfig = {
+	protectTokens: 40_000,
+	minimumSavings: 20_000,
+	protectedTools: ["read"],
+	staleOverridableTools: ["read"],
+};
+
+export interface PruneResult {
+	/** Number of entries pruned. */
+	prunedCount: number;
+	/** Estimated tokens saved. */
+	tokensSaved: number;
+	/** The pruned result entries (same length as input, content replaced for pruned). */
+	results: ToolResultEntry[];
+	/** IDs of entries that were pruned. */
+	prunedIds: string[];
+}
+
+// ---------------------------------------------------------------------------
+// Token estimation (rough char/4 heuristic, matching gajae-code)
+// ---------------------------------------------------------------------------
+
+function estimateTokens(text: string): number {
+	return Math.ceil(text.length / 4);
+}
+
+// ---------------------------------------------------------------------------
+// Digest notice generation
+// ---------------------------------------------------------------------------
+
+const DIGEST_NOTICE_TOKEN_CAP_MULTIPLIER = 1.25;
+
+function firstErrorLine(text: string): string | undefined {
+	return text
+		.split(/\r?\n/)
+		.find((line) => /error|failed|exception|panic/i.test(line))
+		?.trim();
+}
+
+function truncateField(value: string, maxLength: number): string {
+	if (value.length <= maxLength) return value;
+	if (maxLength <= 1) return "…";
+	return `${value.slice(0, maxLength - 1)}…`;
+}
+
+/**
+ * Generate a compact digest of a tool result for the digest notice.
+ * Supports bash (exit code + tail line), grep/search (match/file counts),
+ * and falls back to undefined for tools without a known digest format.
+ */
+export function resultDigest(toolName: string, content: string, isError?: boolean): string | undefined {
+	const name = toolName.toLowerCase();
+	const text = content ?? "";
+	if (name === "bash") {
+		const exitCode = isError ? 1 : 0;
+		const tail = text.trim().split(/\r?\n/).filter(Boolean).at(-1) ?? "";
+		const error = firstErrorLine(text);
+		return [`exit=${exitCode}`, tail ? `tail=${tail}` : undefined, error ? `error=${error}` : undefined]
+			.filter((part): part is string => part !== undefined)
+			.join("; ");
+	}
+	if (name === "search" || name === "grep") {
+		const match = text.match(/(\d+)\s+matches?/i) ?? text.match(/totalMatches["']?:\s*(\d+)/i);
+		const files = text.match(/(\d+)\s+files?/i) ?? text.match(/filesWithMatches["']?:\s*(\d+)/i);
+		const error = firstErrorLine(text);
+		return (
+			[
+				match ? `matches=${match[1]}` : undefined,
+				files ? `files=${files[1]}` : undefined,
+				error ? `error=${error}` : undefined,
+			]
+				.filter((part): part is string => part !== undefined)
+				.join("; ") || "search digest unavailable"
+		);
+	}
+	return undefined;
+}
+
+function createPrunedNotice(tokens: number, entry: ToolResultEntry): string {
+	const generic = `[Output pruned — ${tokens} tokens]`;
+	const digest = resultDigest(entry.toolName, entry.content, entry.isError);
+	if (!digest) return generic;
+	const genericTokens = Math.ceil(generic.length / 4);
+	const maxTokens = Math.max(genericTokens, Math.floor(genericTokens * DIGEST_NOTICE_TOKEN_CAP_MULTIPLIER));
+	const prefix = `[Output pruned — ${tokens} tokens; `;
+	const suffix = "]";
+	const maxChars = Math.max(0, maxTokens * 4 - prefix.length - suffix.length);
+	return `${prefix}${truncateField(digest, maxChars)}${suffix}`;
+}
+
+// ---------------------------------------------------------------------------
+// Target key resolution
+// ---------------------------------------------------------------------------
+
+/**
+ * Trailing read selectors (`:50`, `:50-200`, `:50+150`, `:5-16,960-973`,
+ * `:raw`, `:conflicts`), possibly stacked. Stripped to resolve the
+ * underlying file for edit invalidation.
+ */
+const READ_SELECTOR_SUFFIX = /:(?:raw|conflicts|\d+(?:[-+]\d+)?(?:,\d+(?:[-+]\d+)?)*)$/;
+
+/** Base file path of a read target with any line/mode selectors stripped. */
+function readBasePath(filePath: string): string {
+	let base = filePath;
+	while (READ_SELECTOR_SUFFIX.test(base)) {
+		base = base.replace(READ_SELECTOR_SUFFIX, "");
+	}
+	return base;
+}
+
+/**
+ * Stable identity for "the same logical lookup": same tool re-targeting the
+ * same subject. A later result with the same key supersedes earlier ones.
+ */
+function toolTargetKey(entry: ToolResultEntry): string | undefined {
+	if (!entry.target || entry.target.length === 0) return undefined;
+	return JSON.stringify([entry.toolName, entry.target]);
+}
+
+// ---------------------------------------------------------------------------
+// Staleness index
+// ---------------------------------------------------------------------------
+
+export interface StalenessIndex {
+	/** Indices of tool results superseded by a later same-target result or edit. */
+	staleIndices: Set<number>;
+}
+
+/**
+ * Build a staleness index over a sequence of tool results (oldest → newest):
+ * - a tool result is stale when a later non-error result shares its target key;
+ * - a `read` result is stale when a later edit event touches its file.
+ * The most recent result per target is never stale.
+ *
+ * @param toolResults  Ordered tool result entries (oldest first).
+ * @param fileEdits    Optional file mutation events with sequence indices.
+ */
+export function buildStalenessIndex(toolResults: ToolResultEntry[], fileEdits: FileEditEvent[] = []): StalenessIndex {
+	// Map target key → last result index that has it.
+	const lastResultIndexByKey = new Map<string, number>();
+	for (let i = 0; i < toolResults.length; i++) {
+		const entry = toolResults[i]!;
+		if (entry.isError) continue;
+		const key = toolTargetKey(entry);
+		if (key !== undefined) lastResultIndexByKey.set(key, i);
+	}
+
+	// Map file path → last edit index.
+	const lastEditIndexByPath = new Map<string, number>();
+	for (const edit of fileEdits) {
+		lastEditIndexByPath.set(edit.target, edit.index);
+	}
+
+	const staleIndices = new Set<number>();
+	for (let i = 0; i < toolResults.length; i++) {
+		const entry = toolResults[i]!;
+		// Check superseded by same-target re-read.
+		const key = toolTargetKey(entry);
+		if (key !== undefined) {
+			const lastIndex = lastResultIndexByKey.get(key);
+			if (lastIndex !== undefined && lastIndex > i) {
+				staleIndices.add(i);
+				continue;
+			}
+		}
+		// Check invalidated by later file edit (read-specific).
+		if (entry.toolName.toLowerCase() === "read" && entry.target) {
+			const basePath = readBasePath(entry.target);
+			const editIndex = lastEditIndexByPath.get(basePath);
+			if (editIndex !== undefined && editIndex > i) {
+				staleIndices.add(i);
+			}
+		}
+	}
+
+	return { staleIndices };
+}
+
+// ---------------------------------------------------------------------------
+// Pruning
+// ---------------------------------------------------------------------------
+
+/**
+ * Prune stale tool outputs from a sequence, replacing superseded content with
+ * compact digest notices. Protect-window, protected-tools immunity, and
+ * minimum-savings hysteresis are all respected.
+ *
+ * OPT-IN by default: {@link DEFAULT_PRUNE_CONFIG} protects recent results via
+ * a generous `protectTokens` window. Only results outside the window AND not
+ * protected AND stale (or old enough) are pruned.
+ *
+ * @param results  Ordered tool result entries (oldest first).
+ * @param config   Prune configuration. Defaults to {@link DEFAULT_PRUNE_CONFIG}.
+ */
+export function pruneToolOutputs(results: ToolResultEntry[], config: PruneConfig = DEFAULT_PRUNE_CONFIG): PruneResult {
+	const { staleIndices } = buildStalenessIndex(results);
+	const staleOverridable = new Set(config.staleOverridableTools ?? []);
+
+	let accumulatedTokens = 0;
+	let tokensSaved = 0;
+	let prunedCount = 0;
+
+	interface Candidate {
+		index: number;
+		entry: ToolResultEntry;
+		tokens: number;
+		notice: string;
+		savings: number;
+	}
+	const candidates: Candidate[] = [];
+	const prunedIds: string[] = [];
+
+	// Iterate newest → oldest to accumulate the protect window from the tail.
+	for (let i = results.length - 1; i >= 0; i--) {
+		const entry = results[i]!;
+		const tokens = estimateTokens(entry.content);
+		const isStale = staleIndices.has(i);
+
+		// Staleness waives protected-tool immunity for overridable tools
+		// (e.g. a superseded `read`); the most recent result per target is
+		// never stale, so the latest read of each file stays protected.
+		const isProtected =
+			config.protectedTools.includes(entry.toolName) &&
+			!(isStale && staleOverridable.has(entry.toolName));
+
+		// Stale results are prunable even inside the recency protect window —
+		// they are superseded, so recency no longer implies relevance. They
+		// still count toward window accounting so non-stale protection is
+		// unchanged.
+		const insideProtectWindow = accumulatedTokens < config.protectTokens;
+		if ((insideProtectWindow && !isStale) || isProtected) {
+			accumulatedTokens += tokens;
+			continue;
+		}
+
+		const notice = createPrunedNotice(tokens, entry);
+		candidates.push({
+			index: i,
+			entry,
+			tokens,
+			notice,
+			savings: Math.max(0, tokens - Math.ceil(notice.length / 4)),
+		});
+		accumulatedTokens += tokens;
+	}
+
+	for (const candidate of candidates) {
+		tokensSaved += candidate.savings;
+	}
+
+	// Hysteresis: only prune if savings meet the threshold.
+	if (tokensSaved < config.minimumSavings || candidates.length === 0) {
+		return { prunedCount: 0, tokensSaved: 0, results, prunedIds: [] };
+	}
+
+	const prunedResults = [...results];
+	for (const candidate of candidates) {
+		prunedResults[candidate.index] = { ...candidate.entry, content: candidate.notice };
+		prunedIds.push(candidate.entry.id);
+		prunedCount++;
+	}
+
+	return { prunedCount, tokensSaved, results: prunedResults, prunedIds };
+}

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/state/types.ts

@@ -3,6 +3,7 @@ import type { TaskClaimState } from "./task-claims.ts";
 import type { WorkerHeartbeatState } from "../runtime/worker-heartbeat.ts";
 import type { CrewAgentProgress } from "../runtime/crew-agent-runtime.ts";
 import type { RolloutEntry, CoherenceMark } from "./decision-ledger.ts";
+import type { CrashClass } from "../runtime/crash-classification.ts";
 export type { RolloutEntry, CoherenceMark };
 export type { CrewAgentProgress };
 
@@ -116,6 +117,10 @@ export interface WorkerExitStatus {
 	signal?: string;
 	cleanupErrors: string[];
 	finalDrainMs: number;
+	/** Categorical classification of the exit (P0 crash taxonomy). Optional
+	 *  because it is populated by child-pi.ts at settle time; older/synthetic
+	 *  exit statuses may omit it. */
+	crashClass?: CrashClass;
 	/** Phase-0 diagnostic (HB-003a): final-drain race state for the exit-null
 	 *  disableTools bug. Optional + read-only — absent when no drain timer was
 	 *  ever armed. Phase 1 will use `finalDrainArmed` to decide whether a

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);