pi-crew 0.9.41 → 0.9.44

package/src/state/locks.ts

@@ -1,7 +1,9 @@
+import { AsyncLocalStorage } from "node:async_hooks";
 import { randomUUID, timingSafeEqual } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { DEFAULT_LOCKS } from "../config/defaults.ts";
+import { logInternalError } from "../utils/internal-error.ts";
 import { sleepSync } from "../utils/sleep.ts";
 import { isSymlinkSafePath } from "./atomic-write.ts";
 import type { TeamRunManifest } from "./types.ts";
@@ -103,41 +105,56 @@ function isLockHolderAlive(filePath: string): boolean {
  *
  * See also: SECURITY-ISSUES.md SEC-008 for documented acceptance.
  */
-function readLockSnapshot(filePath: string, staleMs: number): { canSteal: boolean } {
+function readLockSnapshot(filePath: string, staleMs: number, options?: { treatOwnPidAsStealable?: boolean }): { canSteal: boolean } {
+	const treatOwnPidAsStealable = options?.treatOwnPidAsStealable === true;
 	let stat: fs.Stats | undefined;
 	let raw: string | undefined;
 	try {
 		stat = fs.statSync(filePath);
 		raw = fs.readFileSync(filePath, "utf-8");
-	} catch {
-		// File vanished between writeLockFile's EEXIST and now (holder released).
-		// Loop will retry the create; safe to signal "nothing to steal".
+	} catch (error) {
+		// FIX (CI flake): when the lock file vanishes between writeLockFile's
+		// EEXIST and our read here, the holder has released — return canSteal:true
+		// so the acquire loop retries the create instead of throwing a false
+		// "locked" error.
+		const code = (error as NodeJS.ErrnoException).code;
+		if (code === "ENOENT") {
+			return { canSteal: true };
+		}
+		// Transient I/O error — be conservative (don't steal, retry the read on
+		// next attempt).
 		return { canSteal: false };
 	}
 	// Staleness from a single snapshot.
 	let createdAt = parseCreatedAtFromLock(raw);
 	if (createdAt === undefined) createdAt = stat.mtimeMs;
 	const isStale = Date.now() - createdAt > staleMs;
-	// Holder liveness from the SAME snapshot.
-	let isAlive = true; // Unknown holder — assume alive to be safe (matches isLockHolderAlive).
+	let holderPid: number | undefined;
+	let isAlive = true;
 	try {
 		const parsed = JSON.parse(raw) as { pid?: unknown };
-		const pid = typeof parsed.pid === "number" ? parsed.pid : undefined;
-		if (pid !== undefined) {
-			try {
-				process.kill(pid, 0);
-				isAlive = true;
-			} catch (error) {
-				const code = (error as NodeJS.ErrnoException).code;
-				// EPERM/ESRCH → treat as not-alive (stealable), see isLockHolderAlive.
-				isAlive = false;
-			}
-		}
+		holderPid = typeof parsed.pid === "number" ? parsed.pid : undefined;
 	} catch {
 		/* malformed payload — keep isAlive=true */
 	}
-	// Steal if stale OR holder dead — matches the original intent.
-	return { canSteal: isStale || !isAlive };
+	if (holderPid !== undefined) {
+		try {
+			process.kill(holderPid, 0);
+			isAlive = true;
+		} catch (error) {
+			const code = (error as NodeJS.ErrnoException).code;
+			// EPERM/ESRCH → treat as not-alive (stealable), see isLockHolderAlive.
+			isAlive = false;
+		}
+	}
+	// Steal if stale OR holder dead. Optionally steal if holder is our own pid
+	// (used by withRunLock* which is single-process — a fresh lock with our pid
+	// between acquisitions is just a leftover from a previous call that
+	// releaseOwnLock didn't get to delete yet; safe to steal).
+	const isOurOwnHolder = holderPid === process.pid;
+	return {
+		canSteal: isStale || !isAlive || (treatOwnPidAsStealable && isOurOwnHolder),
+	};
 }
 
 /**
@@ -221,6 +238,34 @@ function timingSafeTokenMatch(a: string, b: string): boolean {
 	return timingSafeEqual(bufA, bufB);
 }
 
+/**
+ * Release the lock we (this process) just acquired. Unlike releaseLock, this
+ * unconditionally removes the file because we know we created it in the same
+ * withRunLock* call — token matching is only needed for multi-process scenarios
+ * (where a different holder's token must not be deleted). Within the same process
+ * the new acquire uses a fresh randomUUID token, so token matching would falsely
+ * fail and leak the file across releases.
+ *
+ * Symlink guard is preserved: if a symlink appeared since our writeLockFile, we
+ * don't rm it (defense against attacker-planted symlinks).
+ */
+export function releaseOwnLock(filePath: string, _token: string): void {
+	try {
+		const stat = fs.lstatSync(filePath);
+		if (stat.isSymbolicLink()) return;
+	} catch {
+		/* ENOENT is fine */
+	}
+	try {
+		fs.rmSync(filePath, { force: true });
+	} catch (error) {
+		const code = (error as NodeJS.ErrnoException).code;
+		if (code !== "ENOENT") {
+			logInternalError("lock-release-own", error, filePath, "warn");
+		}
+	}
+}
+
 function releaseLock(filePath: string, token: string): void {
 	// FIX: Do not delete a symlink — it may have been planted by an attacker
 	// after our lock was released. A legitimate lock file should never be a
@@ -265,7 +310,9 @@ function acquireLockWithRetry(filePath: string, staleMs: number, kind: LockKind
 			}
 			// Round 26 (BUG 1): single-snapshot read closes the TOCTOU window between
 			// separate stale + alive reads (which could race stale→fresh).
-			const { canSteal } = readLockSnapshot(filePath, staleMs);
+			// treatOwnPidAsStealable=false (this is the sync file-lock path used
+			// by withFileLockSync — never steal a fresh lock even if it has our pid).
+			const { canSteal } = readLockSnapshot(filePath, staleMs, { treatOwnPidAsStealable: false });
 			if (!canSteal) {
 				throw new Error(`Run '${path.basename(filePath)}' is locked by another operation.`);
 			}
@@ -300,7 +347,13 @@ async function acquireLockWithRetryAsync(filePath: string, staleMs: number, kind
 				throw new Error(`Run '${path.basename(filePath)}' is locked by another operation.`);
 			}
 			// Round 26 (BUG 1): single-snapshot read (see sync variant).
-			const { canSteal } = readLockSnapshot(filePath, staleMs);
+			// FIX (CI flake): treatOwnPidAsStealable=true for the run-lock async path
+			// (withRunLock). Between acquisitions in parallel-research scaffold mode,
+			// the previous releaseOwnLock leaves a microsecond window where the
+			// file still exists with our own pid. Stealing it avoids spurious 'locked'
+			// errors. The sync file-lock path (withFileLockSync) above uses false to
+			// preserve the multi-process safety guarantee.
+			const { canSteal } = readLockSnapshot(filePath, staleMs, { treatOwnPidAsStealable: true });
 			if (!canSteal) {
 				throw new Error(`Run '${path.basename(filePath)}' is locked by another operation.`);
 			}
@@ -379,48 +432,78 @@ export function withFileLockSync<T>(filePath: string, fn: () => T, options: RunL
 	}
 }
 
+// H-1: track re-entrant run-lock acquisitions PER ASYNC CONTEXT (not process-global).
+// Previously a module-global Map caused a bug: when withRunLock (async) yielded at
+// `await fn()`, a concurrent withRunLockSync for the same run — fired from a
+// different async context (e.g. a child stdout event handler) — saw the holder's
+// token and bypassed the file lock entirely, allowing two writers in the critical
+// section simultaneously. AsyncLocalStorage scopes the "held" set to the current
+// async context, so a call from a different async context no longer bypasses and
+// properly serializes against the on-disk lock. True nested calls in the SAME
+// async context (e.g. handleResume -> executeTeamRun -> executeTeamRunCore) still
+// bypass via lockCtx.getStore(), avoiding the deadlock the bypass was designed for.
+const lockCtx = new AsyncLocalStorage<Set<string>>();
+// 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 function withRunLockSync<T>(manifest: TeamRunManifest, fn: () => T, options: RunLockOptions = {}): T {
 	const filePath = lockPath(manifest);
 	const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
-	const existingToken = runLockHeldByUs.get(filePath);
-	if (existingToken) {
-		// Re-entrant: already hold this lock, just run the callback.
+	// H-1: re-entrance check is scoped to the current async context, not process-global.
+	// A call from a DIFFERENT async context (e.g. a child-stdout event handler that
+	// runs while an async holder is awaiting) sees no held set and properly serializes.
+	if (lockCtx.getStore()?.has(filePath)) {
+		// Re-entrant within the same async context — already hold this lock.
 		return fn();
 	}
 	fs.mkdirSync(path.dirname(filePath), { recursive: true });
 	const token = acquireLockWithRetry(filePath, staleMs, "run");
-	runLockHeldByUs.set(filePath, token);
-	try {
-		return fn();
-	} finally {
-		runLockHeldByUs.delete(filePath);
-		releaseLock(filePath, token);
-	}
+	const prevHeld = lockCtx.getStore() ?? new Set<string>();
+	const newHeld = new Set(prevHeld);
+	newHeld.add(filePath);
+	// Enter a new async context (or extend the current one) carrying the held set.
+	// On exit (sync return OR async resume after an awaited child), the context is
+	// restored — so the held set only contains locks acquired within fn()'s subtree.
+	return lockCtx.run(newHeld, () => {
+		try {
+			return fn();
+		} finally {
+			// FIX (CI flake): releaseLock uses token matching to prevent the
+			// "losing contender wipes winner's lock" race in multi-process scenarios.
+			// But within withRunLockSync/withRunLock (same process), the new acquire
+			// uses a FRESH random token — the previous stored token doesn't match the
+			// current token — and the lock file is never removed. Repeat acquisitions
+			// then keep failing with EEXIST because the file lingers.
+			// Since withRunLock* is always single-process, unconditionally delete
+			// (symlink guard is still applied for safety).
+			releaseOwnLock(filePath, token);
+		}
+	});
 }
 
-// Track re-entrant lock acquisitions per lock file path. When a lock is
-// 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);
 	const staleMs = options.staleMs ?? DEFAULT_STALE_MS;
-	const existingToken = runLockHeldByUs.get(filePath);
-	if (existingToken) {
-		// Re-entrant: already hold this lock, just run the callback.
+	if (lockCtx.getStore()?.has(filePath)) {
+		// Re-entrant within the same async context.
 		return await fn();
 	}
 	fs.mkdirSync(path.dirname(filePath), { recursive: true });
 	const token = await acquireLockWithRetryAsync(filePath, staleMs, "run");
-	runLockHeldByUs.set(filePath, token);
-	try {
-		return await fn();
-	} finally {
-		runLockHeldByUs.delete(filePath);
-		releaseLock(filePath, token);
-	}
+	const prevHeld = lockCtx.getStore() ?? new Set<string>();
+	const newHeld = new Set(prevHeld);
+	newHeld.add(filePath);
+	// AsyncLocalStorage propagates across await boundaries, so any code that
+	// resumes after an await inside fn() (including microtasks, timers, and
+	// awaited child Pi results) still sees newHeld.
+	return await lockCtx.run(newHeld, async () => {
+		try {
+			return await fn();
+		} finally {
+			// FIX (CI flake): see withRunLockSync above — use releaseOwnLock for
+			// unconditional deletion of the lock file we created (same process).
+			releaseOwnLock(filePath, token);
+		}
+	});
 }

package/src/state/mailbox.ts

@@ -3,7 +3,6 @@ import * as path from "node:path";
 import { DEFAULT_MAILBOX } from "../config/defaults.ts";
 import { logInternalError } from "../utils/internal-error.ts";
 import { redactSecrets } from "../utils/redaction.ts";
-import { resolveRealContainedPath } from "../utils/safe-paths.ts";
 import { atomicWriteFile } from "./atomic-write.ts";
 import { withEventLogLockSync } from "./event-log.ts";
 import { withFileLockSync } from "./locks.ts";
@@ -184,13 +183,13 @@ function ensureRunMailbox(manifest: TeamRunManifest): void {
 			// Ensure parent dir exists (may have been lost due to race or
 			// Windows path normalization mismatch)
 			fs.mkdirSync(path.dirname(filePath), { recursive: true });
-			fs.writeFileSync(filePath, "", "utf-8");
+			atomicWriteFile(filePath, "");
 		}
 	}
 	const delivery = deliveryFile(manifest, true);
 	if (!fs.existsSync(delivery)) {
 		fs.mkdirSync(path.dirname(delivery), { recursive: true });
-		fs.writeFileSync(delivery, `${JSON.stringify({ messages: {}, updatedAt: new Date().toISOString() }, null, 2)}\n`, "utf-8");
+		atomicWriteFile(delivery, `${JSON.stringify({ messages: {}, updatedAt: new Date().toISOString() }, null, 2)}\n`);
 	}
 }
 
@@ -312,7 +311,7 @@ function rotateMailboxFileIfNeeded(filePath: string, thresholdBytes = MAILBOX_AR
 		const ts = new Date().toISOString().replace(/[:.]/g, "-");
 		const archivePath = `${filePath}.${ts}.archive.jsonl`;
 		fs.renameSync(filePath, archivePath);
-		fs.writeFileSync(filePath, "", "utf-8");
+		atomicWriteFile(filePath, "");
 		// FIX: Prune old archives so total per-direction count stays bounded.
 		pruneOldMailboxArchives(filePath);
 		return true;

package/src/state/observation-store.ts

@@ -1,16 +1,4 @@
-/**
- * Observation capture and compression system.
- *
- * Pattern origin: claude-mem — captures tool usage across sessions,
- * compresses via AI, injects into future sessions.
- *
- * This module provides the observation store and compression logic.
- * Actual capture hooks into the lifecycle events (Pattern 12).
- */
-
-import * as fs from "node:fs";
-import { appendFileSync, existsSync, readFileSync } from "node:fs";
-import * as path from "node:path";
+import { existsSync, readFileSync } from "node:fs";
 import { logInternalError } from "../utils/internal-error.ts";
 import { atomicWriteJson } from "./atomic-write.ts";
 

package/src/state/run-cache.ts

@@ -2,7 +2,7 @@ import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { projectCrewRoot } from "../utils/paths.ts";
-import { atomicWriteFile } from "./atomic-write.ts";
+import { atomicWriteJson } from "./atomic-write.ts";
 import { withFileLockSync } from "./locks.ts";
 import type { TeamTaskState } from "./types.ts";
 
@@ -67,7 +67,7 @@ export function getCachedRun(cwd: string, cacheKey: string): CacheEntry | null {
 				}
 				const updatedIndex = JSON.parse(fs.readFileSync(indexPath, "utf-8")) as CacheIndex;
 				delete updatedIndex[cacheKey];
-				atomicWriteFile(indexPath, JSON.stringify(updatedIndex));
+				atomicWriteJson(indexPath, updatedIndex);
 			});
 			return null;
 		}
@@ -109,18 +109,18 @@ export function saveRunToCache(
 	};
 
 	const entryPath = path.join(dir, `${cacheKey}.json`);
-	fs.writeFileSync(entryPath, JSON.stringify(entry), "utf-8");
+	// ST-4: atomic entry write (was raw writeFileSync — inverted priority vs the index).
+	atomicWriteJson(entryPath, entry);
 
-	// Update index with atomic write: write to temp file then rename
+	// Update index under a file lock (prevents concurrent saveCache from racing on the
+	// RMW) and write atomically (unique temp + rename — fixes the fixed "index.json.tmp"
+	// name collision the old manual temp+rename had).
 	const indexPath = path.join(dir, "index.json");
-	const index: CacheIndex = fs.existsSync(indexPath) ? JSON.parse(fs.readFileSync(indexPath, "utf-8")) : {};
-
-	index[cacheKey] = entryPath;
-
-	// Atomic write: write to temp file first, then rename
-	const tempPath = path.join(dir, "index.json.tmp");
-	fs.writeFileSync(tempPath, JSON.stringify(index), "utf-8");
-	fs.renameSync(tempPath, indexPath);
+	withFileLockSync(indexPath, () => {
+		const index: CacheIndex = fs.existsSync(indexPath) ? JSON.parse(fs.readFileSync(indexPath, "utf-8")) : {};
+		index[cacheKey] = entryPath;
+		atomicWriteJson(indexPath, index);
+	});
 }
 
 /**

package/src/state/run-graph.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { projectCrewRoot } from "../utils/paths.ts";
 import { assertSafePathId } from "../utils/safe-paths.ts";
+import { atomicWriteFile } from "./atomic-write.ts";
 import type { TeamRunManifest, TeamTaskState } from "./types.ts";
 
 export interface RunGraphNode {
@@ -138,7 +139,7 @@ export function saveRunGraph(graph: RunGraph, cwd: string): string {
 	}
 
 	const graphPath = path.join(graphsDir, `${graph.runId}.json`);
-	fs.writeFileSync(graphPath, JSON.stringify(graph, null, 2), "utf-8");
+	atomicWriteFile(graphPath, JSON.stringify(graph, null, 2));
 
 	return graphPath;
 }

package/src/state/run-metrics.ts

@@ -66,7 +66,7 @@ export function collectRunMetrics(cwd: string, runId: string): RunMetrics | unde
 	// Duration: from run createdAt to updatedAt (manifest timestamps), or 0 if unavailable.
 	const createdAt = new Date(manifest.createdAt).getTime();
 	const updatedAt = new Date(manifest.updatedAt).getTime();
-	const durationMs = isNaN(createdAt) || isNaN(updatedAt) ? 0 : Math.max(0, updatedAt - createdAt);
+	const durationMs = Number.isNaN(createdAt) || Number.isNaN(updatedAt) ? 0 : Math.max(0, updatedAt - createdAt);
 
 	// Consistency score: proportion of tasks that completed successfully among all non-skipped tasks.
 	const nonSkippedTasks = tasks.filter((t) => t.status !== "skipped");

package/src/state/schedule.ts

@@ -10,6 +10,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { logInternalError } from "../utils/internal-error.ts";
+import { atomicWriteJson } from "./atomic-write.ts";
 
 import type { ScheduledTask, ScheduleStoreData } from "./types.ts";
 
@@ -112,7 +113,12 @@ export class ScheduleStore {
 	private save(): void {
 		try {
 			fs.mkdirSync(path.dirname(this.path), { recursive: true });
-			fs.writeFileSync(this.path, JSON.stringify(this.data, null, 2), "utf-8");
+			// Atomic (temp + rename + fsync) — matches the class docstring's "atomic JSON
+			// persistence" claim. A raw writeFileSync could truncate schedules.json on
+			// crash and the constructor silently resets to {jobs:[]} on parse failure.
+			// NOTE: this class is currently not instantiated in production (scheduling
+			// persists via settings-store updateCrewSettings); kept consistent for safety.
+			atomicWriteJson(this.path, this.data);
 		} catch (error) {
 			// FIX (Round 21, L1): Use logInternalError for consistency with
 			// the rest of the codebase. Previously console.warn may not be

package/src/state/state-store.ts

@@ -14,7 +14,6 @@ import { unregisterActiveRun } from "./active-run-registry.ts";
 import { atomicWriteJson, atomicWriteJsonAsync, atomicWriteJsonCoalesced, flushPendingAtomicWrites, readJsonFile } from "./atomic-write.ts";
 import { canTransitionRunStatus } from "./contracts.ts";
 import { appendEvent } from "./event-log.ts";
-import { HealthStore } from "./health-store.ts";
 import { withRunLock, withRunLockSync } from "./locks.ts";
 import type { TeamRunManifest, TeamTaskState } from "./types.ts";
 
@@ -477,9 +476,16 @@ export function saveRunTasks(manifest: TeamRunManifest, tasks: TeamTaskState[]):
  * (perf review 2026-07 F4) — now used by persistSingleTaskUpdate's
  * non-terminal checkpoint path; that caller calls flushPendingAtomicWrites()
  * before its read-modify-write load to defeat the stale-read window.
+ *
+ * ST-7: pass `skipCoalesce: true` for terminal task status transitions
+ * (completed/failed/cancelled/needs_attention/skipped) to bypass the
+ * 50ms coalesce window — a SIGKILL in that window would otherwise leave
+ * tasks.json stale (showing "running") while events.jsonl already shows
+ * the terminal event, causing false zombie detection / double-execution
+ * on crash recovery.
  */
 /** @internal */
-export function saveRunTasksCoalesced(manifest: TeamRunManifest, tasks: TeamTaskState[]): void {
+export function saveRunTasksCoalesced(manifest: TeamRunManifest, tasks: TeamTaskState[], skipCoalesce: boolean = false): void {
 	// FIX: Invalidate cache BEFORE atomic write to prevent stale cache serving.
 	invalidateRunCache(manifest.stateRoot);
 	try {
@@ -487,7 +493,7 @@ export function saveRunTasksCoalesced(manifest: TeamRunManifest, tasks: TeamTask
 	} catch {
 		return;
 	}
-	atomicWriteJsonCoalesced(manifest.tasksPath, tasks);
+	atomicWriteJsonCoalesced(manifest.tasksPath, tasks, undefined, undefined, skipCoalesce);
 }
 
 export async function saveRunTasksAsync(manifest: TeamRunManifest, tasks: TeamTaskState[]): Promise<void> {

package/src/state/tiered-eval.ts

@@ -142,7 +142,7 @@ export class TieredEvalRunner {
 		if (config?.tierConfigs) {
 			for (const [tierStr, tierConfig] of Object.entries(config.tierConfigs)) {
 				const tier = Number(tierStr) as EvalTier;
-				if (tierConfig && !isNaN(tier)) {
+				if (tierConfig && !Number.isNaN(tier)) {
 					this.tierConfigs[tier] = {
 						...this.tierConfigs[tier],
 						...tierConfig,

package/src/state/worker-atomic-writer.ts

@@ -137,6 +137,7 @@ function getWorker(): Worker {
 		// Reject ALL pending requests — worker died.
 		for (const [, entry] of pending) entry.reject(error);
 		pending.clear();
+		worker = undefined;
 	});
 	worker.unref(); // don't keep event loop alive (unless tests request it)
 	if (keepRefForTests) worker.ref();

package/src/ui/dynamic-border.ts

@@ -9,6 +9,8 @@ export class DynamicCrewBorder {
 	private readonly theme: CrewTheme;
 	private readonly color?: (value: string) => string;
 	private readonly char: string;
+	private cachedWidth = -1;
+	private cachedLine = "";
 
 	constructor(theme: CrewTheme, options: DynamicCrewBorderOptions = {}) {
 		this.theme = theme;
@@ -17,9 +19,17 @@ export class DynamicCrewBorder {
 	}
 
 	render(width: number): string[] {
-		const line = this.char.repeat(Math.max(0, width));
-		return [this.color ? this.color(line) : this.theme.fg("border", line)];
+		const w = Math.max(0, width);
+		if (w !== this.cachedWidth) {
+			const line = this.char.repeat(w);
+			this.cachedLine = this.color ? this.color(line) : this.theme.fg("border", line);
+			this.cachedWidth = w;
+		}
+		return [this.cachedLine];
 	}
 
-	invalidate(): void {}
+	invalidate(): void {
+		this.cachedWidth = -1;
+		this.cachedLine = "";
+	}
 }

package/src/ui/live-conversation-overlay.ts

@@ -6,6 +6,7 @@
  */
 import type { LiveAgentHandle } from "../runtime/live-agent-manager.ts";
 import { pad, truncate } from "../utils/visual.ts";
+import { computeLiveDurationMs } from "./live-duration.ts";
 import { spinnerFrame } from "./spinner.ts";
 import { iconForStatus } from "./status-colors.ts";
 import type { CrewTheme } from "./theme-adapter.ts";
@@ -17,7 +18,6 @@ export class LiveConversationOverlay {
 	private scrollOffset = 0;
 	private autoScroll = true;
 	private closed = false;
-	private frame = 0;
 	private pollTimer: ReturnType<typeof setInterval> | undefined;
 	cachedLines: string[] = [];
 	// H-4 fix (code-review 2026-06-23): cap the in-memory line buffer to avoid
@@ -53,10 +53,12 @@ export class LiveConversationOverlay {
 				/* ignore */
 			}
 		}
-		// Also poll for summary updates
+		// Also poll for summary updates. Skip when the user has scrolled up
+		// (autoScroll === false): the summary refresh also bumps scrollOffset
+		// to the tail, which would yank the viewport out from under them.
 		this.pollTimer = setInterval(() => {
 			if (this.closed) return;
-			this.frame++;
+			if (!this.autoScroll) return;
 			try {
 				this.refreshSummary();
 			} catch {
@@ -82,31 +84,9 @@ export class LiveConversationOverlay {
 
 	private static readonly SUMMARY_PREFIX = "\u200B"; // zero-width space as summary sentinel
 
-	private safeElapsedMs(act: typeof this.handle.activity): number {
-		const rawStarted = act.startedAtMs || 0;
-		const rawCompleted = act.completedAtMs || 0;
-		const nowMs = Date.now();
-		const nowSec = Math.floor(nowMs / 1000);
-		// Simple fix: detect if value is Unix seconds and convert properly
-		const toMs = (v: number): number => {
-			if (v <= 0) return 0;
-			// If 10 digits (or 9 with recent), treat as seconds
-			if (v > 1000000000 && v < 10000000000) return v * 1000;
-			// If 13 digits, treat as ms
-			if (v > 100000000000 && v < 10000000000000) return v;
-			// Fallback: use as-is
-			return v;
-		};
-		const startedMs = toMs(rawStarted);
-		const completedMs = rawCompleted > 0 ? toMs(rawCompleted) : 0;
-		// Validate bounds
-		const isValidStarted = startedMs > 0 && startedMs < nowMs + 60000 && startedMs > nowMs - 3155692600000;
-		const isValidCompleted = completedMs === 0 || (completedMs > 0 && completedMs < nowMs + 60000);
-		return (isValidCompleted ? completedMs : nowMs) - (isValidStarted ? startedMs : nowMs);
-	}
 	private refreshSummary(): void {
 		const act = this.handle.activity;
-		const summary = `${LiveConversationOverlay.SUMMARY_PREFIX}[${act.turnCount} turns · ${act.toolUses} tools · ${(this.safeElapsedMs(act) / 1000).toFixed(1)}s]`;
+		const summary = `${LiveConversationOverlay.SUMMARY_PREFIX}[${act.turnCount} turns · ${act.toolUses} tools · ${(computeLiveDurationMs(act) / 1000).toFixed(1)}s]`;
 		const lastLine = this.cachedLines[this.cachedLines.length - 1];
 		if (lastLine?.startsWith(LiveConversationOverlay.SUMMARY_PREFIX)) {
 			this.cachedLines[this.cachedLines.length - 1] = summary;
@@ -140,7 +120,7 @@ export class LiveConversationOverlay {
 				: iconForStatus(this.handle.status);
 		const name = this.handle.agent ?? this.handle.taskId;
 		const act = this.handle.activity;
-		const elapsed = `${(this.safeElapsedMs(act) / 1000).toFixed(1)}s`;
+		const elapsed = `${(computeLiveDurationMs(act) / 1000).toFixed(1)}s`;
 		const headerParts: string[] = [];
 		if (act.maxTurns != null) headerParts.push(`turn ${act.turnCount}/${act.maxTurns}`);
 		else if (act.turnCount > 0) headerParts.push(`turn ${act.turnCount}`);

package/src/ui/live-duration.ts

@@ -21,8 +21,8 @@ function toMs(v: number): number {
 	if (v <= 0) return 0;
 	// 1e9 < seconds < 1e10  → seconds, scale up
 	if (v > 1_000_000_000 && v < 10_000_000_000) return v * 1000;
-	// 1e11 < ms < 1e13      → already ms
-	if (v > 100_000_000_000 && v < 10_000_000_000_000) return v;
+	// 1e10 < ms < 1e13      → already ms (>=10B seconds is 317+ years, implausible)
+	if (v > 10_000_000_000 && v < 10_000_000_000_000) return v;
 	return v;
 }