@bastani/atomic 0.9.5-alpha.7 → 0.9.5-alpha.9

package/dist/builtin/subagents/src/extension/index.ts

@@ -7,21 +7,18 @@ import { APP_NAME, getEnvValue } from "@bastani/atomic";
 import { type ExtensionAPI, type ExtensionContext, type ToolDefinition } from "@bastani/atomic";
 import { Box, Container, Spacer, Text, truncateToWidth, visibleWidth, wrapTextWithAnsi, type Component } from "@earendil-works/pi-tui";
 import { discoverAgents } from "../agents/agents.ts";
-import { cleanupAllArtifactDirs, cleanupOldArtifacts, getArtifactsDir } from "../shared/artifacts.ts";
+import { getArtifactsDir } from "../shared/artifacts.ts";
 import { resolveCurrentSessionId } from "../shared/session-identity.ts";
-import { cleanupOldChainDirs } from "../shared/settings.ts";
 import { advanceResultPulseFrame, renderLiveSubagentResult, renderSubagentResult, stopResultAnimations, stopWidgetAnimation, type SubagentResultRenderState } from "../tui/render.ts";
 import { SubagentParams } from "./schemas.ts";
 import { createSubagentExecutor, type SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
 import { createAsyncJobTracker } from "../runs/background/async-job-tracker.ts";
-import { createResultWatcher } from "../runs/background/result-watcher.ts";
 import { registerSlashCommands } from "../slash/slash-commands.ts";
 import { registerPromptTemplateDelegationBridge } from "../slash/prompt-template-bridge.ts";
 import { registerSlashSubagentBridge } from "../slash/slash-bridge.ts";
 import { clearSlashSnapshots, getSlashRenderableSnapshot, resolveSlashMessageDetails, restoreSlashFinalSnapshots, type SlashMessageDetails } from "../slash/slash-live-state.ts";
 import { inspectSubagentStatus } from "../runs/background/run-status.ts";
 import registerSubagentNotify, { type SubagentNotifyDetails } from "../runs/background/notify.ts";
-import { cleanupOldNestedRuntimeDirs } from "../runs/shared/nested-events.ts";
 import { SUBAGENT_CHILD_ENV, SUBAGENT_FANOUT_CHILD_ENV } from "../runs/shared/pi-args.ts";
 import registerFanoutChildSubagentExtension from "./fanout-child.ts";
 import { formatDuration, shortenPath } from "../shared/formatters.ts";
@@ -29,6 +26,7 @@ import { loadConfig } from "./config.ts";
 import { DEFAULT_PROMPT_GUIDANCE } from "./prompt-guidance.ts";
 import { type Details, type SubagentState, ASYNC_DIR, DEFAULT_ARTIFACT_CONFIG, RESULTS_DIR, SLASH_RESULT_TYPE, SUBAGENT_ASYNC_COMPLETE_EVENT, SUBAGENT_ASYNC_STARTED_EVENT, SUBAGENT_CONTROL_EVENT, WIDGET_KEY } from "../shared/types.ts";
 import { clearPendingForegroundControlNotices, formatSubagentControlNotice, handleSubagentControlNotice, SUBAGENT_CONTROL_MESSAGE_TYPE, type SubagentControlMessageDetails } from "./control-notices.ts";
+import { createSubagentStartupMaintenance } from "./startup-maintenance.ts";
 export { loadConfig } from "./config.ts";
 function getSubagentSessionRoot(parentSessionFile: string | null): string {
 	if (parentSessionFile) {
@@ -171,12 +169,9 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 	}
 	ensureAccessibleDir(RESULTS_DIR);
 	ensureAccessibleDir(ASYNC_DIR);
-	cleanupOldChainDirs();
 	const config = loadConfig();
 	const asyncByDefault = config.asyncByDefault === true;
 	const tempArtifactsDir = getArtifactsDir(null);
-	cleanupAllArtifactDirs(DEFAULT_ARTIFACT_CONFIG.cleanupDays);
-	cleanupOldNestedRuntimeDirs(DEFAULT_ARTIFACT_CONFIG.cleanupDays);
 	const state: SubagentState = {
 		baseCwd: "",
 		currentSessionId: null,
@@ -197,16 +192,16 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 			clear: () => {},
 		},
 	};
-	const { startResultWatcher, primeExistingResults, stopResultWatcher } = createResultWatcher(
-		pi,
-		state,
-		RESULTS_DIR,
-		10 * 60 * 1000,
-	);
-	startResultWatcher();
-	primeExistingResults();
+	const maintenance = createSubagentStartupMaintenance(pi, state, {
+		resultsDir: RESULTS_DIR,
+		artifactCleanupDays: DEFAULT_ARTIFACT_CONFIG.cleanupDays,
+		resultTtlMs: 10 * 60 * 1000,
+	});
+	maintenance.scheduleStartupCleanup();
+	maintenance.startResultWatcherDeferred();
+	maintenance.primeExistingResultsDeferred();
 	const runtimeCleanup = () => {
-		stopResultWatcher();
+		maintenance.stop();
 		stopWidgetAnimation();
 		stopResultAnimations();
 		clearPendingForegroundControlNotices(state);
@@ -430,13 +425,7 @@ DIAGNOSTICS:
 		if (state.asyncJobs.size > 0) ensurePoller();
 	});
 	const cleanupSessionArtifacts = (ctx: ExtensionContext) => {
-		try {
-			const sessionFile = ctx.sessionManager.getSessionFile();
-			if (sessionFile) {
-				cleanupOldArtifacts(getArtifactsDir(sessionFile), DEFAULT_ARTIFACT_CONFIG.cleanupDays);
-			}
-		} catch {
-		}
+		maintenance.cleanupSessionArtifactsDeferred(ctx);
 	};
 	const resetSessionState = (ctx: ExtensionContext) => {
 		state.baseCwd = ctx.cwd;
@@ -447,7 +436,7 @@ DIAGNOSTICS:
 		resetJobs(ctx);
 		hydrateActiveJobs(ctx);
 		restoreSlashFinalSnapshots(ctx.sessionManager.getEntries());
-		primeExistingResults();
+		maintenance.primeExistingResultsDeferred();
 	};
 	pi.on("session_start", (_event, ctx) => {
 		resetSessionState(ctx);
@@ -462,7 +451,7 @@ DIAGNOSTICS:
 		if (globalStore[eventUnsubscribeStoreKey] === eventUnsubscribes) {
 			delete globalStore[eventUnsubscribeStoreKey];
 		}
-		stopResultWatcher();
+		maintenance.stop();
 		stopWidgetAnimation();
 		stopResultAnimations();
 		if (state.poller) clearInterval(state.poller);

package/dist/builtin/subagents/src/extension/startup-maintenance.ts

@@ -0,0 +1,89 @@
+import type { ExtensionAPI, ExtensionContext } from "@bastani/atomic";
+import type { SubagentState } from "../shared/types.ts";
+import { cleanupAllArtifactDirs, cleanupOldArtifacts, getArtifactsDir } from "../shared/artifacts.ts";
+import { cleanupOldChainDirs } from "../shared/settings.ts";
+import { cleanupOldNestedRuntimeDirs } from "../runs/shared/nested-events.ts";
+import { createResultWatcher } from "../runs/background/result-watcher.ts";
+
+export interface SubagentStartupMaintenance {
+  scheduleStartupCleanup(): void;
+  startResultWatcherDeferred(): void;
+  primeExistingResultsDeferred(): void;
+  cleanupSessionArtifactsDeferred(ctx: ExtensionContext): void;
+  stop(): void;
+}
+
+function scheduleMacrotask(task: () => void): () => void {
+  let cancelled = false;
+  const handle = setImmediate(() => {
+    if (!cancelled) task();
+  });
+  handle.unref?.();
+  return () => {
+    cancelled = true;
+    clearImmediate(handle);
+  };
+}
+
+function swallowCleanup(task: () => void): void {
+  try {
+    task();
+  } catch {
+  }
+}
+
+export function createSubagentStartupMaintenance(
+  pi: ExtensionAPI,
+  state: SubagentState,
+  options: {
+    resultsDir: string;
+    artifactCleanupDays: number;
+    resultTtlMs: number;
+  },
+): SubagentStartupMaintenance {
+  const { startResultWatcher, primeExistingResults, stopResultWatcher } = createResultWatcher(
+    pi,
+    state,
+    options.resultsDir,
+    options.resultTtlMs,
+  );
+  const cancelTasks = new Set<() => void>();
+  const schedule = (task: () => void): void => {
+    const cancel = scheduleMacrotask(() => {
+      cancelTasks.delete(cancel);
+      task();
+    });
+    cancelTasks.add(cancel);
+  };
+
+  return {
+    scheduleStartupCleanup() {
+      schedule(() => {
+        swallowCleanup(cleanupOldChainDirs);
+        swallowCleanup(() => cleanupAllArtifactDirs(options.artifactCleanupDays));
+        swallowCleanup(() => cleanupOldNestedRuntimeDirs(options.artifactCleanupDays));
+      });
+    },
+    startResultWatcherDeferred() {
+      schedule(startResultWatcher);
+    },
+    primeExistingResultsDeferred() {
+      schedule(primeExistingResults);
+    },
+    cleanupSessionArtifactsDeferred(ctx) {
+      let sessionFile: string | null | undefined;
+      try {
+        sessionFile = ctx.sessionManager.getSessionFile();
+      } catch {
+        return;
+      }
+      if (!sessionFile) return;
+      schedule(() => swallowCleanup(() => cleanupOldArtifacts(getArtifactsDir(sessionFile), options.artifactCleanupDays)));
+    },
+    stop() {
+      for (const cancel of cancelTasks) cancel();
+      cancelTasks.clear();
+      stopResultWatcher();
+    },
+  };
+}

package/dist/builtin/subagents/src/runs/background/async-execution-common.ts

@@ -4,7 +4,7 @@ import * as path from "node:path";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import { APP_NAME } from "@bastani/atomic";
-import { resolvePiPackageRoot } from "../shared/pi-spawn.ts";
+import { formatPiSpawnError, resolvePiPackageRoot, validatePiSpawnCwd } from "../shared/pi-spawn.ts";
 import { getAsyncConfigPath, TEMP_ROOT_DIR, type SubagentRunMode } from "../../shared/types.ts";
 import type { AsyncExecutionResult, AsyncSpawnResult } from "./async-execution-types.ts";
 
@@ -85,33 +85,38 @@ export function writeAsyncRunnerConfig(cfg: object, suffix: string): string {
 }
 
 export function spawnRunner(cfg: object, suffix: string, cwd: string): AsyncSpawnResult {
+	const cwdValidation = validatePiSpawnCwd(cwd);
+	if (!cwdValidation.ok) return { error: cwdValidation.error };
+
 	if (!jitiCliPath) {
 		return { error: "upstream jiti for TypeScript execution could not be found; ensure package dependencies are installed" };
 	}
 
-	try {
-		const cwdStats = fs.statSync(cwd);
-		if (!cwdStats.isDirectory()) {
-			return { error: `cwd is not a directory: ${cwd}` };
-		}
-	} catch {
-		return { error: `cwd does not exist: ${cwd}` };
-	}
-
 	const cfgPath = writeAsyncRunnerConfig(cfg, suffix);
 	const runner = path.join(path.dirname(fileURLToPath(import.meta.url)), "subagent-runner.ts");
 
-	const proc = spawn(process.execPath, [jitiCliPath, runner, cfgPath], {
-		cwd,
-		detached: true,
-		stdio: "ignore",
-		windowsHide: true,
-	});
+	const spawnSpec = { command: process.execPath, args: [jitiCliPath, runner, cfgPath] };
+	let proc: ReturnType<typeof spawn>;
+	try {
+		proc = spawn(spawnSpec.command, spawnSpec.args, {
+			cwd,
+			detached: true,
+			stdio: "ignore",
+			windowsHide: true,
+		});
+	} catch (error) {
+		const spawnError = error instanceof Error ? error : new Error(String(error));
+		return { error: formatPiSpawnError(spawnError, spawnSpec, cwd) };
+	}
 	proc.on("error", (error) => {
-		console.error(`[${APP_NAME}-subagents] async spawn failed: ${error.message}`);
+		console.error(`[${APP_NAME}-subagents] async spawn failed: ${formatPiSpawnError(error, spawnSpec, cwd)}`);
 	});
 	if (typeof proc.pid !== "number") {
-		return { error: `async runner did not produce a pid for cwd: ${cwd}` };
+		const noPidError = Object.assign(
+			new Error(`spawn ${spawnSpec.command} failed before assigning a pid`),
+			fs.existsSync(spawnSpec.command) ? {} : { code: "ENOENT" },
+		);
+		return { error: formatPiSpawnError(noPidError, spawnSpec, cwd) };
 	}
 	proc.unref();
 	return { pid: proc.pid };

package/dist/builtin/subagents/src/runs/background/result-watcher.ts

@@ -1,5 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { isSafeFsWatchPathError, watchWithErrorHandler } from "@bastani/atomic";
 import { buildCompletionKey, markSeenWithTtl } from "./completion-dedupe.ts";
 import { createFileCoalescer } from "../../shared/file-coalescer.ts";
 import {
@@ -21,7 +22,9 @@ import { projectNestedRegistryForRoot, sanitizeSummary } from "../shared/nested-
 const WATCHER_RESTART_DELAY_MS = 3000;
 const POLL_INTERVAL_MS = 3000;
 
-type ResultWatcherFs = Pick<typeof fs, "existsSync" | "readFileSync" | "unlinkSync" | "readdirSync" | "mkdirSync" | "watch">;
+type ResultWatcherFs = Pick<typeof fs, "existsSync" | "readFileSync" | "unlinkSync" | "readdirSync" | "mkdirSync" | "watch"> & {
+	realpathSync?: typeof fs.realpathSync;
+};
 
 type ResultWatcherTimers = {
 	setTimeout: typeof setTimeout;
@@ -30,9 +33,12 @@ type ResultWatcherTimers = {
 	clearInterval: typeof clearInterval;
 };
 
+type ResultWatcherSafeWatch = typeof watchWithErrorHandler;
+
 type ResultWatcherDeps = {
 	fs?: ResultWatcherFs;
 	timers?: ResultWatcherTimers;
+	safeWatch?: ResultWatcherSafeWatch;
 };
 
 type ResultFileChild = {
@@ -88,7 +94,7 @@ function isNotFoundError(error: unknown): boolean {
 
 function shouldFallBackToPolling(error: unknown): boolean {
 	const code = getErrorCode(error);
-	return code === "EMFILE" || code === "ENOSPC";
+	return code === "EMFILE" || code === "ENOSPC" || isSafeFsWatchPathError(error);
 }
 
 export function createResultWatcher(
@@ -104,6 +110,7 @@ export function createResultWatcher(
 } {
 	const fsApi = deps.fs ?? fs;
 	const timers = deps.timers ?? { setTimeout, clearTimeout, setInterval, clearInterval };
+	const safeWatch = deps.safeWatch ?? watchWithErrorHandler;
 
 	const handleResult = async (file: string) => {
 		const resultPath = path.join(resultsDir, file);
@@ -264,13 +271,7 @@ export function createResultWatcher(
 			state.watcherRestartTimer = null;
 		}
 		try {
-			state.watcher = fsApi.watch(resultsDir, (ev, file) => {
-				if (ev !== "rename" || !file) return;
-				const fileName = file.toString();
-				if (!fileName.endsWith(".json")) return;
-				state.resultFileCoalescer.schedule(fileName);
-			});
-			state.watcher.on("error", (error) => {
+			const handleWatcherError = (error: Error) => {
 				if (shouldFallBackToPolling(error)) {
 					startPollingFallback(error);
 					return;
@@ -279,8 +280,17 @@ export function createResultWatcher(
 				state.watcher?.close();
 				state.watcher = null;
 				scheduleRestart();
+			};
+			state.watcher = safeWatch(resultsDir, (ev, file) => {
+				if (ev !== "rename" || !file) return;
+				const fileName = file.toString();
+				if (!fileName.endsWith(".json")) return;
+				state.resultFileCoalescer.schedule(fileName);
+			}, handleWatcherError, {
+				watch: fsApi.watch,
+				realpathSyncNative: fsApi.realpathSync?.native,
 			});
-			state.watcher.unref?.();
+			state.watcher?.unref?.();
 		} catch (error) {
 			if (shouldFallBackToPolling(error)) {
 				startPollingFallback(error);

package/dist/builtin/subagents/src/runs/background/subagent-runner-streaming.ts

@@ -5,7 +5,7 @@ import { appendJsonl } from "../../shared/artifacts.ts";
 import { attachPostExitStdioGuard, trySignalChild } from "../../shared/post-exit-stdio-guard.ts";
 import { detectSubagentError, extractTextFromContent, extractToolArgsPreview, getFinalOutput } from "../../shared/utils.ts";
 import { getSubagentDepthEnv } from "../../shared/types.ts";
-import { getPiSpawnCommand } from "../shared/pi-spawn.ts";
+import { formatPiSpawnError, getPiSpawnCommand, validatePiSpawnCwd } from "../shared/pi-spawn.ts";
 import {
 	assistantStopReason,
 	isAssistantFailureStopReason,
@@ -29,6 +29,17 @@ export function runPiStreaming(
 	registerInterrupt?: (interrupt: (() => void) | undefined) => void,
 	onChildEvent?: (event: ChildEvent) => void,
 ): Promise<RunPiStreamingResult> {
+	const cwdValidation = validatePiSpawnCwd(cwd);
+	if (!cwdValidation.ok) {
+		return Promise.resolve({
+			stderr: "",
+			exitCode: 1,
+			messages: [],
+			usage: emptyUsage(),
+			error: cwdValidation.error,
+			finalOutput: "",
+		});
+	}
 	return new Promise((resolve) => {
 		const outputStream = fs.createWriteStream(outputFile, { flags: "w" });
 		const spawnEnv = {
@@ -273,8 +284,7 @@ export function runPiStreaming(
 			attemptWatchdog.clear();
 			outputStream.end();
 			const finalOutput = getFinalOutput(messages) || rawStdoutLines.join("\n").trim();
-			const spawnErrorMessage = spawnError instanceof Error ? spawnError.message : String(spawnError);
-			const finalError = error ?? assistantError ?? spawnErrorMessage;
+			const finalError = error ?? assistantError ?? formatPiSpawnError(spawnError, spawnSpec, cwd);
 			resolve({
 				stderr,
 				exitCode: 1,

package/dist/builtin/subagents/src/runs/foreground/execution-attempt.ts

@@ -14,7 +14,7 @@ import { extractTextFromContent, extractToolArgsPreview, getFinalOutput } from "
 import { createJsonlWriter } from "../../shared/jsonl-writer.ts";
 import { attachPostExitStdioGuard, trySignalChild } from "../../shared/post-exit-stdio-guard.ts";
 import { applyThinkingSuffix, buildPiArgs, cleanupTempDir } from "../shared/pi-args.ts";
-import { getPiSpawnCommand } from "../shared/pi-spawn.ts";
+import { formatPiSpawnError, getPiSpawnCommand, validatePiSpawnCwd } from "../shared/pi-spawn.ts";
 import { assistantStopReason, isAssistantFailureStopReason, shouldStartSubagentFinalDrain } from "../shared/final-drain.ts";
 import { modelFailureMessage } from "../shared/model-fallback.ts";
 import { createAttemptWatchdog } from "../shared/attempt-watchdog.ts";
@@ -124,6 +124,14 @@ export async function runSingleAttempt(
 			workflowStageSubagentGuard: options.workflowStageSubagentGuard,
 		}),
 	};
+	const cwdValidation = validatePiSpawnCwd(runCwd);
+	if (!cwdValidation.ok) {
+		cleanupTempDir(tempDir);
+		result.error = cwdValidation.error;
+		return finalizeSingleAttempt({
+			result, progress, exitCode: 1, interruptedByControl, allControlEvents: controlRuntime.allControlEvents, options, shared, startTime,
+		});
+	}
 	const exitCode = await new Promise<number>((resolve) => {
 		const spawnSpec = getPiSpawnCommand(args);
 		const proc = spawn(spawnSpec.command, spawnSpec.args, {
@@ -418,7 +426,7 @@ export async function runSingleAttempt(
 			attemptWatchdog.clear();
 			void jsonlWriter.close().catch(() => undefined);
 			cleanupTempDir(tempDir);
-			if (!result.error) result.error = error instanceof Error ? error.message : String(error);
+			if (!result.error) result.error = formatPiSpawnError(error, spawnSpec, runCwd);
 			finish(1);
 		});
 

package/dist/builtin/subagents/src/runs/shared/pi-spawn.ts

@@ -42,9 +42,36 @@ export interface PiSpawnDeps {
 	resolvePackageJson?: () => string;
 	resolvePackageEntry?: () => string;
 	piPackageRoot?: string;
+	statSync?: (filePath: string) => fs.Stats;
 }
 
-interface PiSpawnCommand {
+export type PiSpawnCwdValidationResult = { ok: true } | { ok: false; error: string };
+
+export function validatePiSpawnCwd(cwd: string, deps: PiSpawnDeps = {}): PiSpawnCwdValidationResult {
+	const statSync = deps.statSync ?? fs.statSync;
+	try {
+		const cwdStats = statSync(cwd);
+		if (!cwdStats.isDirectory()) return { ok: false, error: `cwd is not a directory: ${cwd}` };
+		return { ok: true };
+	} catch (error) {
+		const fsError = error as NodeJS.ErrnoException;
+		if (fsError.code === "ENOENT") return { ok: false, error: `cwd does not exist: ${cwd}` };
+		if (fsError.code === "ENOTDIR") return { ok: false, error: `cwd path contains a non-directory component: ${cwd}` };
+		const details = fsError.message ? ` (${fsError.message})` : "";
+		return { ok: false, error: `cwd is not accessible: ${cwd}${details}` };
+	}
+}
+
+export function formatPiSpawnError(error: Error, spawnSpec: PiSpawnCommand, cwd: string): string {
+	const spawnError = error as NodeJS.ErrnoException;
+	const message = error.message || String(error);
+	if (spawnError.code === "ENOENT") {
+		return `failed to spawn subagent runtime '${spawnSpec.command}' from cwd '${cwd}': runtime executable was not found or could not be launched (${message})`;
+	}
+	return `failed to spawn subagent runtime '${spawnSpec.command}' from cwd '${cwd}': ${message}`;
+}
+
+export interface PiSpawnCommand {
 	command: string;
 	args: string[];
 }

package/dist/builtin/subagents/src/tui/render-event-formatting.ts

@@ -5,7 +5,7 @@ import { formatDuration, formatModelThinking, shortenPath } from "../shared/form
 import { formatNestedAggregate } from "../runs/shared/nested-render.ts";
 import { formatAgentRunningLabel } from "../shared/status-format.ts";
 import { buildLiveStatusLine, formatCurrentToolLine, formatTokenStat, formatToolUseStat, statJoin } from "./render-status-progress.ts";
-import { runningGlyph, runningSeed, truncLine, type Theme } from "./render-layout.ts";
+import { runningGlyph, runningPulseGlyph, truncLine, type Theme } from "./render-layout.ts";
 
 export function formatWidgetAgents(agents: string[]): string {
 	const distinct = [...new Set(agents)];
@@ -40,47 +40,9 @@ export function widgetActivity(job: AsyncJobState): string {
 	return "Done";
 }
 
-export function widgetStepRunningSeed(step: NonNullable<AsyncJobState["steps"]>[number], fallbackIndex?: number): number | undefined {
-	return runningSeed(
-		fallbackIndex,
-		step.index,
-		step.toolCount,
-		step.turnCount,
-		step.tokens?.total,
-		step.lastActivityAt,
-		step.currentToolStartedAt,
-		step.durationMs,
-	);
-}
-
-export function widgetStepsRunningSeed(steps: Array<NonNullable<AsyncJobState["steps"]>[number]> | undefined): number | undefined {
-	let seed: number | undefined;
-	for (const [index, step] of (steps ?? []).entries()) seed = runningSeed(seed, widgetStepRunningSeed(step, index));
-	return seed;
-}
-
-export function widgetJobRunningSeed(job: AsyncJobState): number | undefined {
-	return runningSeed(
-		job.updatedAt,
-		job.lastActivityAt,
-		job.toolCount,
-		job.turnCount,
-		job.totalTokens?.total,
-		job.currentStep,
-		job.runningSteps,
-		job.completedSteps,
-		widgetStepsRunningSeed(job.steps),
-	);
-}
-
-export function widgetJobsRunningSeed(jobs: AsyncJobState[]): number | undefined {
-	let seed: number | undefined;
-	for (const job of jobs) seed = runningSeed(seed, widgetJobRunningSeed(job));
-	return seed;
-}
 
-export function widgetStatusGlyph(job: AsyncJobState, theme: Theme, now?: number): string {
-	if (job.status === "running") return theme.fg("accent", runningGlyph(widgetJobRunningSeed(job), now));
+export function widgetStatusGlyph(job: AsyncJobState, theme: Theme, pulseFrame?: number): string {
+	if (job.status === "running") return theme.fg("accent", runningPulseGlyph(pulseFrame));
 	if (job.status === "queued") return theme.fg("muted", "◦");
 	if (job.status === "complete") return theme.fg("success", "✓");
 	if (job.status === "paused") return theme.fg("warning", "■");
@@ -95,6 +57,14 @@ export function widgetStepGlyph(status: AsyncJobStep["status"], theme: Theme, se
 	return theme.fg("muted", "◦");
 }
 
+export function widgetStepPulseGlyph(status: AsyncJobStep["status"], theme: Theme, pulseFrame?: number): string {
+	if (status === "running") return theme.fg("accent", runningPulseGlyph(pulseFrame));
+	if (status === "complete" || status === "completed") return theme.fg("success", "✓");
+	if (status === "failed") return theme.fg("error", "✗");
+	if (status === "paused") return theme.fg("warning", "■");
+	return theme.fg("muted", "◦");
+}
+
 export function widgetStepStatus(status: AsyncJobStep["status"], theme: Theme): string {
 	if (status === "running") return theme.fg("accent", "running");
 	if (status === "complete" || status === "completed") return theme.fg("success", "complete");
@@ -186,17 +156,14 @@ export function nestedRunName(run: NestedRunSummary): string {
 	return run.id;
 }
 
-export function nestedStatusGlyph(state: NestedRunSummary["state"] | NestedStepSummary["status"], theme: Theme, seed?: number, now?: number): string {
-	if (state === "running") return theme.fg("accent", runningGlyph(seed, now));
+export function nestedStatusGlyph(state: NestedRunSummary["state"] | NestedStepSummary["status"], theme: Theme, pulseFrame?: number): string {
+	if (state === "running") return theme.fg("accent", runningPulseGlyph(pulseFrame));
 	if (state === "complete" || state === "completed") return theme.fg("success", "✓");
 	if (state === "failed") return theme.fg("error", "✗");
 	if (state === "paused") return theme.fg("warning", "■");
 	return theme.fg("muted", "◦");
 }
 
-export function nestedRunSeed(run: NestedRunSummary): number | undefined {
-	return runningSeed(run.lastUpdate, run.lastActivityAt, run.currentStep, run.toolCount, run.turnCount, run.totalTokens?.total, run.currentToolStartedAt);
-}
 
 export function nestedActivity(input: Pick<NestedRunSummary | NestedStepSummary, "activityState" | "lastActivityAt" | "currentTool" | "currentToolStartedAt" | "currentPath" | "turnCount" | "toolCount">, state: NestedRunSummary["state"] | NestedStepSummary["status"], snapshotNow?: number): string {
 	const facts: string[] = [];
@@ -240,7 +207,7 @@ export function formatNestedWidgetLines(children: NestedRunSummary[] | undefined
 			}
 			const activity = nestedActivity(child, child.state, snapshotNow ?? child.lastUpdate);
 			const error = child.error ? ` · ${child.error}` : "";
-			lines.push(theme.fg("dim", `${prefix}↳ ${nestedStatusGlyph(child.state, theme, nestedRunSeed(child), now)} ${nestedRunName(child)} · ${child.state} · ${activity}${error}`));
+			lines.push(theme.fg("dim", `${prefix}↳ ${nestedStatusGlyph(child.state, theme, now)} ${nestedRunName(child)} · ${child.state} · ${activity}${error}`));
 			if (depth === maxDepth) {
 				const aggregate = formatNestedAggregate([...(child.steps?.flatMap((step) => step.children ?? []) ?? []), ...(child.children ?? [])]);
 				if (aggregate && lines.length < lineBudget) lines.push(theme.fg("dim", `${prefix}  ↳ ${aggregate}`));
@@ -248,7 +215,7 @@ export function formatNestedWidgetLines(children: NestedRunSummary[] | undefined
 			}
 			for (const step of child.steps ?? []) {
 				if (lines.length >= lineBudget) return;
-				lines.push(theme.fg("dim", `${prefix}  ↳ ${nestedStatusGlyph(step.status, theme, undefined, now)} ${step.agent} · ${step.status} · ${nestedActivity(step, step.status, snapshotNow ?? child.lastUpdate)}`));
+				lines.push(theme.fg("dim", `${prefix}  ↳ ${nestedStatusGlyph(step.status, theme, now)} ${step.agent} · ${step.status} · ${nestedActivity(step, step.status, snapshotNow ?? child.lastUpdate)}`));
 				append(step.children, depth + 1, `${prefix}    `);
 			}
 			append(child.children, depth + 1, `${prefix}  `);

package/dist/builtin/subagents/src/tui/render-layout.ts

@@ -129,6 +129,15 @@ export function pulseGlyph(frame?: number): string {
 	return PULSE_FRAMES[index % PULSE_FRAMES.length]!;
 }
 
+/**
+ * Running async/background subagent pulse. It reuses the exact foreground pulse
+ * glyph frames while accepting an explicit frame advanced by the widget only on
+ * real async progress/status updates, matching foreground result semantics.
+ */
+export function runningPulseGlyph(frame?: number): string {
+	return pulseGlyph(frame);
+}
+
 export function progressRunningSeed(progress: ProgressSeedSource | undefined): number | undefined {
 	if (!progress) return undefined;
 	return runningSeed(