gsd-pi 2.26.0 → 2.27.0

package/packages/pi-tui/src/components/editor.ts

@@ -559,7 +559,9 @@ export class Editor implements Component, Focusable {
 					this.state.cursorLine = result.cursorLine;
 					this.setCursorCol(result.cursorCol);
 
-					if (this.autocompletePrefix.startsWith("/")) {
+					if (this.autocompletePrefix.startsWith("/") || this.isInSlashCommandContext(
+						(this.state.lines[this.state.cursorLine] || "").slice(0, this.state.cursorCol),
+					)) {
 						this.cancelAutocomplete();
 						// Fall through to submit
 					} else {

package/scripts/link-workspace-packages.cjs

@@ -10,8 +10,12 @@
  * to resolve. This script bridges the gap.
  *
  * Runs as part of postinstall (before any ESM code that imports @gsd/*).
+ *
+ * On Windows without Developer Mode or administrator rights, creating symlinks
+ * (even NTFS junctions) can fail with EPERM. In that case we fall back to
+ * cpSync (directory copy) which works universally.
  */
-const { existsSync, mkdirSync, symlinkSync, lstatSync, readlinkSync, unlinkSync, readdirSync } = require('fs')
+const { existsSync, mkdirSync, symlinkSync, cpSync, lstatSync, readlinkSync, unlinkSync } = require('fs')
 const { resolve, join } = require('path')
 
 const root = resolve(__dirname, '..')
@@ -33,6 +37,7 @@ if (!existsSync(nodeModulesGsd)) {
 }
 
 let linked = 0
+let copied = 0
 for (const [dir, name] of Object.entries(packageMap)) {
   const source = join(packagesDir, dir)
   const target = join(nodeModulesGsd, name)
@@ -50,21 +55,32 @@ for (const [dir, name] of Object.entries(packageMap)) {
         }
         unlinkSync(target) // Wrong target, relink
       } else {
-        continue // Real directory (e.g., from bundleDependencies), don't touch
+        continue // Real directory (e.g., copied or from bundleDependencies), don't touch
       }
     } catch {
       continue
     }
   }
 
+  let symlinkOk = false
   try {
     symlinkSync(source, target, 'junction') // junction works on Windows too
+    symlinkOk = true
     linked++
   } catch {
-    // Non-fatal — may fail in read-only environments
+    // Symlink failed — common on Windows without Developer Mode or admin rights.
+    // Fall back to a directory copy so the package is still resolvable.
   }
-}
 
-if (linked > 0) {
-  process.stderr.write(`  Linked ${linked} workspace packages\n`)
+  if (!symlinkOk) {
+    try {
+      cpSync(source, target, { recursive: true })
+      copied++
+    } catch {
+      // Non-fatal — loader.ts will emit a clearer error if resolution still fails
+    }
+  }
 }
+
+if (linked > 0) process.stderr.write(`  Linked ${linked} workspace package${linked !== 1 ? 's' : ''}\n`)
+if (copied > 0) process.stderr.write(`  Copied ${copied} workspace package${copied !== 1 ? 's' : ''} (symlinks unavailable)\n`)

package/src/resources/extensions/bg-shell/index.ts

@@ -52,6 +52,7 @@ import {
 	getGroupStatus,
 	pruneDeadProcesses,
 	cleanupAll,
+	cleanupSessionProcesses,
 	persistManifest,
 	loadManifest,
 	pushAlert,
@@ -71,7 +72,7 @@ import { toPosixPath } from "../shared/path-display.js";
 // ── Re-exports for consumers ───────────────────────────────────────────────
 
 export type { ProcessStatus, ProcessType, BgProcess, BgProcessInfo, OutputDigest, OutputLine, ProcessEvent } from "./types.js";
-export { processes, startProcess, killProcess, restartProcess, cleanupAll } from "./process-manager.js";
+export { processes, startProcess, killProcess, restartProcess, cleanupAll, cleanupSessionProcesses } from "./process-manager.js";
 export { generateDigest, getHighlights, getOutput, formatDigestText } from "./output-formatter.js";
 export { waitForReady, probePort } from "./readiness-detector.js";
 export { sendAndWait, runOnSession, queryShellEnv } from "./interaction.js";
@@ -136,7 +137,13 @@ export default function (pi: ExtensionAPI) {
 	});
 
 	// Session switch resets the agent's context.
-	pi.on("session_switch", async () => {
+	pi.on("session_switch", async (event, ctx) => {
+		latestCtx = ctx;
+		if (event.reason === "new" && event.previousSessionFile) {
+			await cleanupSessionProcesses(event.previousSessionFile);
+			syncLatestCtxCwd();
+			if (latestCtx) persistManifest(latestCtx.cwd);
+		}
 		buildProcessStateAlert("Session was switched.");
 	});
 
@@ -232,6 +239,7 @@ export default function (pi: ExtensionAPI) {
 			"Use 'run' to execute a command on a persistent shell session and block until it completes — returns structured output + exit code. Shell state (env vars, cwd, virtualenvs) persists across runs.",
 			"Use 'send_and_wait' for interactive CLIs: send input and wait for expected output pattern.",
 			"Use 'env' to check the current working directory and active environment variables of a shell session — useful after cd, source, or export commands.",
+			"Background processes are session-scoped by default: a new session reaps them unless you set persist_across_sessions:true.",
 			"Use 'restart' to kill and relaunch with the same config — preserves restart count.",
 			"Background processes are auto-classified (server/build/test/watcher) based on the command.",
 			"Process crashes and errors are automatically surfaced as alerts at the start of your next turn — you don't need to poll.",
@@ -300,6 +308,12 @@ export default function (pi: ExtensionAPI) {
 			group: Type.Optional(
 				Type.String({ description: "Group name for related processes (for start, group_status)" }),
 			),
+			persist_across_sessions: Type.Optional(
+				Type.Boolean({
+					description: "Keep this process running after a new session starts. Default: false.",
+					default: false,
+				}),
+			),
 		}),
 
 		async execute(_toolCallId, params, signal, _onUpdate, ctx) {
@@ -318,6 +332,8 @@ export default function (pi: ExtensionAPI) {
 					const bg = startProcess({
 						command: params.command,
 						cwd: ctx.cwd,
+						ownerSessionFile: ctx.sessionManager.getSessionFile() ?? null,
+						persistAcrossSessions: params.persist_across_sessions ?? false,
 						label: params.label,
 						type: params.type as ProcessType | undefined,
 						readyPattern: params.ready_pattern,
@@ -341,6 +357,7 @@ export default function (pi: ExtensionAPI) {
 					text += `  cwd: ${toPosixPath(bg.cwd)}`;
 
 					if (bg.group) text += `\n  group: ${bg.group}`;
+					if (bg.persistAcrossSessions) text += `\n  persist_across_sessions: true`;
 					if (bg.readyPort) text += `\n  ready_port: ${bg.readyPort}`;
 					if (bg.readyPattern) text += `\n  ready_pattern: ${bg.readyPattern}`;
 					if (bg.ports.length > 0) text += `\n  detected ports: ${bg.ports.join(", ")}`;

package/src/resources/extensions/bg-shell/process-manager.ts

@@ -67,6 +67,8 @@ export function getInfo(p: BgProcess): BgProcessInfo {
 		label: p.label,
 		command: p.command,
 		cwd: p.cwd,
+		ownerSessionFile: p.ownerSessionFile,
+		persistAcrossSessions: p.persistAcrossSessions,
 		startedAt: p.startedAt,
 		alive: p.alive,
 		exitCode: p.exitCode,
@@ -138,6 +140,8 @@ export function startProcess(opts: StartOptions): BgProcess {
 		label: opts.label || command.slice(0, 60),
 		command,
 		cwd: opts.cwd,
+		ownerSessionFile: opts.ownerSessionFile ?? null,
+		persistAcrossSessions: opts.persistAcrossSessions ?? false,
 		startedAt: Date.now(),
 		proc,
 		output: [],
@@ -170,6 +174,8 @@ export function startProcess(opts: StartOptions): BgProcess {
 			cwd: opts.cwd,
 			label: opts.label || command.slice(0, 60),
 			processType,
+			ownerSessionFile: opts.ownerSessionFile ?? null,
+			persistAcrossSessions: opts.persistAcrossSessions ?? false,
 			readyPattern: opts.readyPattern || null,
 			readyPort: opts.readyPort || null,
 			group: opts.group || null,
@@ -312,6 +318,8 @@ export async function restartProcess(id: string): Promise<BgProcess | null> {
 		cwd: config.cwd,
 		label: config.label,
 		type: config.processType,
+		ownerSessionFile: config.ownerSessionFile,
+		persistAcrossSessions: config.persistAcrossSessions,
 		readyPattern: config.readyPattern || undefined,
 		readyPort: config.readyPort || undefined,
 		group: config.group || undefined,
@@ -367,6 +375,41 @@ export function cleanupAll(): void {
 	processes.clear();
 }
 
+async function waitForProcessExit(bg: BgProcess, timeoutMs: number): Promise<boolean> {
+	if (!bg.alive) return true;
+	await new Promise<void>((resolve) => {
+		const done = () => resolve();
+		const timer = setTimeout(done, timeoutMs);
+		bg.proc.once("exit", () => {
+			clearTimeout(timer);
+			resolve();
+		});
+	});
+	return !bg.alive;
+}
+
+export async function cleanupSessionProcesses(
+	sessionFile: string,
+	options?: { graceMs?: number },
+): Promise<string[]> {
+	const graceMs = Math.max(0, options?.graceMs ?? 300);
+	const matches = Array.from(processes.values()).filter(
+		(bg) => bg.alive && !bg.persistAcrossSessions && bg.ownerSessionFile === sessionFile,
+	);
+	if (matches.length === 0) return [];
+
+	for (const bg of matches) {
+		killProcess(bg.id, "SIGTERM");
+	}
+	if (graceMs > 0) {
+		await Promise.all(matches.map((bg) => waitForProcessExit(bg, graceMs)));
+	}
+	for (const bg of matches) {
+		if (bg.alive) killProcess(bg.id, "SIGKILL");
+	}
+	return matches.map((bg) => bg.id);
+}
+
 // ── Persistence ────────────────────────────────────────────────────────────
 
 export function getManifestPath(cwd: string): string {
@@ -384,6 +427,8 @@ export function persistManifest(cwd: string): void {
 				label: p.label,
 				command: p.command,
 				cwd: p.cwd,
+				ownerSessionFile: p.ownerSessionFile,
+				persistAcrossSessions: p.persistAcrossSessions,
 				startedAt: p.startedAt,
 				processType: p.processType,
 				group: p.group,

package/src/resources/extensions/bg-shell/types.ts

@@ -53,6 +53,10 @@ export interface BgProcess {
 	label: string;
 	command: string;
 	cwd: string;
+	/** Session file that created this process (used for per-session cleanup) */
+	ownerSessionFile: string | null;
+	/** Whether this process should survive a new-session boundary */
+	persistAcrossSessions: boolean;
 	startedAt: number;
 	proc: import("node:child_process").ChildProcess;
 	/** Unified chronologically-interleaved output buffer */
@@ -103,7 +107,17 @@ export interface BgProcess {
 	/** Restart count */
 	restartCount: number;
 	/** Original start config for restart */
-	startConfig: { command: string; cwd: string; label: string; processType: ProcessType; readyPattern: string | null; readyPort: number | null; group: string | null };
+	startConfig: {
+		command: string;
+		cwd: string;
+		label: string;
+		processType: ProcessType;
+		ownerSessionFile: string | null;
+		persistAcrossSessions: boolean;
+		readyPattern: string | null;
+		readyPort: number | null;
+		group: string | null;
+	};
 }
 
 export interface BgProcessInfo {
@@ -111,6 +125,8 @@ export interface BgProcessInfo {
 	label: string;
 	command: string;
 	cwd: string;
+	ownerSessionFile: string | null;
+	persistAcrossSessions: boolean;
 	startedAt: number;
 	alive: boolean;
 	exitCode: number | null;
@@ -133,6 +149,8 @@ export interface BgProcessInfo {
 export interface StartOptions {
 	command: string;
 	cwd: string;
+	ownerSessionFile?: string | null;
+	persistAcrossSessions?: boolean;
 	label?: string;
 	type?: ProcessType;
 	readyPattern?: string;
@@ -154,6 +172,8 @@ export interface ProcessManifest {
 	label: string;
 	command: string;
 	cwd: string;
+	ownerSessionFile: string | null;
+	persistAcrossSessions: boolean;
 	startedAt: number;
 	processType: ProcessType;
 	group: string | null;

package/src/resources/extensions/gsd/auto/session.ts

@@ -0,0 +1,224 @@
+/**
+ * AutoSession — encapsulates all mutable auto-mode state into a single instance.
+ *
+ * Replaces ~40 module-level variables scattered across auto.ts with typed
+ * properties on a class instance. Benefits:
+ *
+ * - reset() clears everything in one call (was 25+ manual resets in stopAuto)
+ * - toJSON() provides diagnostic snapshots
+ * - grep `s.` shows every state access
+ * - Constructable for testing
+ */
+
+import type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import type { GitServiceImpl } from "../git-service.js";
+import type { CaptureEntry } from "../captures.js";
+import type { BudgetAlertLevel } from "../auto-budget.js";
+
+// ─── Exported Types ──────────────────────────────────────────────────────────
+
+export interface CompletedUnit {
+  type: string;
+  id: string;
+  startedAt: number;
+  finishedAt: number;
+}
+
+export interface CurrentUnit {
+  type: string;
+  id: string;
+  startedAt: number;
+}
+
+export interface UnitRouting {
+  tier: string;
+  modelDowngraded: boolean;
+}
+
+export interface StartModel {
+  provider: string;
+  id: string;
+}
+
+export interface PendingVerificationRetry {
+  unitId: string;
+  failureContext: string;
+  attempt: number;
+}
+
+// ─── Constants ───────────────────────────────────────────────────────────────
+
+export const MAX_UNIT_DISPATCHES = 3;
+export const STUB_RECOVERY_THRESHOLD = 2;
+export const MAX_LIFETIME_DISPATCHES = 6;
+export const MAX_CONSECUTIVE_SKIPS = 3;
+export const DISPATCH_GAP_TIMEOUT_MS = 5_000;
+export const MAX_SKIP_DEPTH = 20;
+
+// ─── AutoSession ─────────────────────────────────────────────────────────────
+
+export class AutoSession {
+  // ── Lifecycle ────────────────────────────────────────────────────────────
+  active = false;
+  paused = false;
+  stepMode = false;
+  verbose = false;
+  cmdCtx: ExtensionCommandContext | null = null;
+
+  // ── Paths ────────────────────────────────────────────────────────────────
+  basePath = "";
+  originalBasePath = "";
+  gitService: GitServiceImpl | null = null;
+
+  // ── Dispatch counters ────────────────────────────────────────────────────
+  readonly unitDispatchCount = new Map<string, number>();
+  readonly unitLifetimeDispatches = new Map<string, number>();
+  readonly unitRecoveryCount = new Map<string, number>();
+  readonly unitConsecutiveSkips = new Map<string, number>();
+  readonly completedKeySet = new Set<string>();
+
+  // ── Timers ───────────────────────────────────────────────────────────────
+  unitTimeoutHandle: ReturnType<typeof setTimeout> | null = null;
+  wrapupWarningHandle: ReturnType<typeof setTimeout> | null = null;
+  idleWatchdogHandle: ReturnType<typeof setInterval> | null = null;
+  continueHereHandle: ReturnType<typeof setInterval> | null = null;
+  dispatchGapHandle: ReturnType<typeof setTimeout> | null = null;
+
+  // ── Current unit ─────────────────────────────────────────────────────────
+  currentUnit: CurrentUnit | null = null;
+  currentUnitRouting: UnitRouting | null = null;
+  completedUnits: CompletedUnit[] = [];
+  currentMilestoneId: string | null = null;
+
+  // ── Model state ──────────────────────────────────────────────────────────
+  autoModeStartModel: StartModel | null = null;
+  originalModelId: string | null = null;
+  originalModelProvider: string | null = null;
+  lastBudgetAlertLevel: BudgetAlertLevel = 0;
+
+  // ── Recovery ─────────────────────────────────────────────────────────────
+  pendingCrashRecovery: string | null = null;
+  pendingVerificationRetry: PendingVerificationRetry | null = null;
+  readonly verificationRetryCount = new Map<string, number>();
+  pausedSessionFile: string | null = null;
+  resourceVersionOnStart: string | null = null;
+  lastStateRebuildAt = 0;
+
+  // ── Guards ───────────────────────────────────────────────────────────────
+  handlingAgentEnd = false;
+  dispatching = false;
+  skipDepth = 0;
+  readonly recentlyEvictedKeys = new Set<string>();
+
+  // ── Metrics ──────────────────────────────────────────────────────────────
+  autoStartTime = 0;
+  lastPromptCharCount: number | undefined;
+  lastBaselineCharCount: number | undefined;
+  pendingQuickTasks: CaptureEntry[] = [];
+
+  // ── Signal handler ───────────────────────────────────────────────────────
+  sigtermHandler: (() => void) | null = null;
+
+  // ── Methods ──────────────────────────────────────────────────────────────
+
+  clearTimers(): void {
+    if (this.unitTimeoutHandle) { clearTimeout(this.unitTimeoutHandle); this.unitTimeoutHandle = null; }
+    if (this.wrapupWarningHandle) { clearTimeout(this.wrapupWarningHandle); this.wrapupWarningHandle = null; }
+    if (this.idleWatchdogHandle) { clearInterval(this.idleWatchdogHandle); this.idleWatchdogHandle = null; }
+    if (this.continueHereHandle) { clearInterval(this.continueHereHandle); this.continueHereHandle = null; }
+    if (this.dispatchGapHandle) { clearTimeout(this.dispatchGapHandle); this.dispatchGapHandle = null; }
+  }
+
+  resetDispatchCounters(): void {
+    this.unitDispatchCount.clear();
+    this.unitLifetimeDispatches.clear();
+    this.unitConsecutiveSkips.clear();
+  }
+
+  get lockBasePath(): string {
+    return this.originalBasePath || this.basePath;
+  }
+
+  completeCurrentUnit(): CompletedUnit | null {
+    if (!this.currentUnit) return null;
+    const done: CompletedUnit = { ...this.currentUnit, finishedAt: Date.now() };
+    this.completedUnits.push(done);
+    this.currentUnit = null;
+    return done;
+  }
+
+  reset(): void {
+    this.clearTimers();
+
+    // Lifecycle
+    this.active = false;
+    this.paused = false;
+    this.stepMode = false;
+    this.verbose = false;
+    this.cmdCtx = null;
+
+    // Paths
+    this.basePath = "";
+    this.originalBasePath = "";
+    this.gitService = null;
+
+    // Dispatch
+    this.unitDispatchCount.clear();
+    this.unitLifetimeDispatches.clear();
+    this.unitRecoveryCount.clear();
+    this.unitConsecutiveSkips.clear();
+    // Note: completedKeySet is intentionally NOT cleared — it persists
+    // across restarts to prevent re-dispatching completed units.
+
+    // Unit
+    this.currentUnit = null;
+    this.currentUnitRouting = null;
+    this.completedUnits = [];
+    this.currentMilestoneId = null;
+
+    // Model
+    this.autoModeStartModel = null;
+    this.originalModelId = null;
+    this.originalModelProvider = null;
+    this.lastBudgetAlertLevel = 0;
+
+    // Recovery
+    this.pendingCrashRecovery = null;
+    this.pendingVerificationRetry = null;
+    this.verificationRetryCount.clear();
+    this.pausedSessionFile = null;
+    this.resourceVersionOnStart = null;
+    this.lastStateRebuildAt = 0;
+
+    // Guards
+    this.handlingAgentEnd = false;
+    this.dispatching = false;
+    this.skipDepth = 0;
+    this.recentlyEvictedKeys.clear();
+
+    // Metrics
+    this.autoStartTime = 0;
+    this.lastPromptCharCount = undefined;
+    this.lastBaselineCharCount = undefined;
+    this.pendingQuickTasks = [];
+
+    // Signal handler
+    this.sigtermHandler = null;
+  }
+
+  toJSON(): Record<string, unknown> {
+    return {
+      active: this.active,
+      paused: this.paused,
+      stepMode: this.stepMode,
+      basePath: this.basePath,
+      currentMilestoneId: this.currentMilestoneId,
+      currentUnit: this.currentUnit,
+      completedUnits: this.completedUnits.length,
+      completedKeySet: this.completedKeySet.size,
+      unitDispatchCount: Object.fromEntries(this.unitDispatchCount),
+      dispatching: this.dispatching,
+      skipDepth: this.skipDepth,
+    };
+  }
+}

package/src/resources/extensions/gsd/auto-budget.ts

@@ -0,0 +1,32 @@
+/**
+ * Budget alert level tracking and enforcement for auto-mode.
+ * Pure functions — no module state or side effects.
+ */
+
+import type { BudgetEnforcementMode } from "./types.js";
+
+export type BudgetAlertLevel = 0 | 75 | 80 | 90 | 100;
+
+export function getBudgetAlertLevel(budgetPct: number): BudgetAlertLevel {
+  if (budgetPct >= 1.0) return 100;
+  if (budgetPct >= 0.90) return 90;
+  if (budgetPct >= 0.80) return 80;
+  if (budgetPct >= 0.75) return 75;
+  return 0;
+}
+
+export function getNewBudgetAlertLevel(previousLevel: BudgetAlertLevel, budgetPct: number): BudgetAlertLevel | null {
+  const currentLevel = getBudgetAlertLevel(budgetPct);
+  if (currentLevel === 0 || currentLevel <= previousLevel) return null;
+  return currentLevel;
+}
+
+export function getBudgetEnforcementAction(
+  enforcement: BudgetEnforcementMode,
+  budgetPct: number,
+): "none" | "warn" | "pause" | "halt" {
+  if (budgetPct < 1.0) return "none";
+  if (enforcement === "halt") return "halt";
+  if (enforcement === "pause") return "pause";
+  return "warn";
+}

package/src/resources/extensions/gsd/auto-dashboard.ts

@@ -6,7 +6,7 @@
  * or AutoContext dependency. State accessors are passed as callbacks.
  */
 
-import type { ExtensionContext, ExtensionCommandContext } from "@gsd/pi-coding-agent";
+import type { ExtensionContext, ExtensionCommandContext, SessionMessageEntry } from "@gsd/pi-coding-agent";
 import type { GSDState } from "./types.js";
 import { getCurrentBranch } from "./worktree.js";
 import { getActiveHook } from "./post-unit-hooks.js";
@@ -159,6 +159,49 @@ export function formatWidgetTokens(count: number): string {
   return `${Math.round(count / 1000000)}M`;
 }
 
+// ─── ETA Estimation ──────────────────────────────────────────────────────────
+
+/**
+ * Estimate remaining time based on average unit duration from the metrics ledger.
+ * Returns a formatted string like "~12m remaining" or null if insufficient data.
+ */
+export function estimateTimeRemaining(): string | null {
+  const ledger = getLedger();
+  if (!ledger || ledger.units.length < 2) return null;
+
+  const sliceProgress = getRoadmapSlicesSync();
+  if (!sliceProgress || sliceProgress.total === 0) return null;
+
+  const remainingSlices = sliceProgress.total - sliceProgress.done;
+  if (remainingSlices <= 0) return null;
+
+  // Compute average duration per completed slice from the ledger
+  const completedSliceUnits = ledger.units.filter(
+    u => u.finishedAt > 0 && u.startedAt > 0,
+  );
+  if (completedSliceUnits.length < 2) return null;
+
+  const totalDuration = completedSliceUnits.reduce(
+    (sum, u) => sum + (u.finishedAt - u.startedAt), 0,
+  );
+  const avgDuration = totalDuration / completedSliceUnits.length;
+
+  // Rough estimate: remaining slices × average units per slice × avg duration
+  const completedSlices = sliceProgress.done || 1;
+  const unitsPerSlice = completedSliceUnits.length / completedSlices;
+  const estimatedMs = remainingSlices * unitsPerSlice * avgDuration;
+
+  if (estimatedMs < 5_000) return null; // Too small to display
+
+  const s = Math.floor(estimatedMs / 1000);
+  if (s < 60) return `~${s}s remaining`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `~${m}m remaining`;
+  const h = Math.floor(m / 60);
+  const rm = m % 60;
+  return rm > 0 ? `~${h}h ${rm}m remaining` : `~${h}h remaining`;
+}
+
 // ─── Slice Progress Cache ─────────────────────────────────────────────────────
 
 /** Cached slice progress for the widget — avoid async in render */
@@ -277,15 +320,16 @@ export function updateProgressWidget(
       tui.requestRender();
     }, 800);
 
-    // Refresh progress cache from disk every 5s so the widget reflects
+    // Refresh progress cache from disk every 15s so the widget reflects
     // task/slice completion mid-unit. Without this, the progress bar only
     // updates at dispatch time, appearing frozen during long-running units.
+    // 15s (vs 5s) reduces synchronous file I/O on the hot path.
     const progressRefreshTimer = mid ? setInterval(() => {
       try {
         updateSliceProgressCache(accessors.getBasePath(), mid.id, slice?.id);
         cachedLines = undefined;
       } catch { /* non-fatal */ }
-    }, 5_000) : null;
+    }, 15_000) : null;
 
     return {
       render(width: number): string[] {
@@ -346,6 +390,12 @@ export function updateProgressWidget(
               meta += theme.fg("dim", `  ·  task ${taskNum}/${activeSliceTasks.total}`);
             }
 
+            // ETA estimate
+            const eta = estimateTimeRemaining();
+            if (eta) {
+              meta += theme.fg("dim", `  ·  ${eta}`);
+            }
+
             lines.push(truncateToWidth(`${pad}${bar}  ${meta}`, width));
           }
         }
@@ -370,13 +420,16 @@ export function updateProgressWidget(
           let totalCacheRead = 0, totalCacheWrite = 0;
           if (cmdCtx) {
             for (const entry of cmdCtx.sessionManager.getEntries()) {
-              if (entry.type === "message" && (entry as any).message?.role === "assistant") {
-                const u = (entry as any).message.usage;
-                if (u) {
-                  totalInput += u.input || 0;
-                  totalOutput += u.output || 0;
-                  totalCacheRead += u.cacheRead || 0;
-                  totalCacheWrite += u.cacheWrite || 0;
+              if (entry.type === "message") {
+                const msgEntry = entry as SessionMessageEntry;
+                if (msgEntry.message?.role === "assistant") {
+                  const u = (msgEntry.message as any).usage;
+                  if (u) {
+                    totalInput += u.input || 0;
+                    totalOutput += u.output || 0;
+                    totalCacheRead += u.cacheRead || 0;
+                    totalCacheWrite += u.cacheWrite || 0;
+                  }
                 }
               }
             }