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

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(

package/dist/builtin/subagents/src/tui/render-widget-graph.ts

@@ -14,15 +14,13 @@ import {
 	widgetStatusGlyph,
 	widgetStepActivity,
 	widgetStepActivityLine,
-	widgetStepGlyph,
-	widgetStepRunningSeed,
+	widgetStepPulseGlyph,
 	widgetStepStats,
 	widgetStepStatus,
-	widgetStepsRunningSeed,
 	widgetJobName,
 } from "./render-event-formatting.ts";
 
-export function widgetChainDetails(job: AsyncJobState, theme: Theme, expanded = false, width = getTermWidth(), now?: number): string[] {
+export function widgetChainDetails(job: AsyncJobState, theme: Theme, expanded = false, width = getTermWidth(), pulseFrame?: number): string[] {
 	if (!job.steps?.length) return [];
 	const total = job.chainStepCount ?? job.steps.length;
 	const lines: string[] = [];
@@ -30,7 +28,7 @@ export function widgetChainDetails(job: AsyncJobState, theme: Theme, expanded =
 		const steps = job.steps.slice(span.start, span.start + span.count);
 		if (span.isParallel) {
 			const status = aggregateStepStatus(steps);
-			lines.push(`  ${widgetStepGlyph(status, theme, widgetStepsRunningSeed(steps), now)} Step ${span.stepIndex + 1}/${total}: ${themeBold(theme, "parallel group")} ${theme.fg("dim", "·")} ${theme.fg("dim", formatParallelOutcome(steps, span.count))}`);
+			lines.push(`  ${widgetStepPulseGlyph(status, theme, pulseFrame)} Step ${span.stepIndex + 1}/${total}: ${themeBold(theme, "parallel group")} ${theme.fg("dim", "·")} ${theme.fg("dim", formatParallelOutcome(steps, span.count))}`);
 			continue;
 		}
 		const step = steps[0];
@@ -38,15 +36,15 @@ export function widgetChainDetails(job: AsyncJobState, theme: Theme, expanded =
 			lines.push(`  ${theme.fg("dim", `◦ Step ${span.stepIndex + 1}/${total}: pending`)}`);
 			continue;
 		}
-		lines.push(...foregroundStyleWidgetStepLines(job, theme, step, "Step", span.stepIndex + 1, total, expanded, width, now));
+		lines.push(...foregroundStyleWidgetStepLines(job, theme, step, "Step", span.stepIndex + 1, total, expanded, width, pulseFrame));
 	}
 	return lines;
 }
 
-export function widgetParallelAgentDetails(job: AsyncJobState, theme: Theme, expanded = false, width = getTermWidth(), now?: number): string[] {
+export function widgetParallelAgentDetails(job: AsyncJobState, theme: Theme, expanded = false, width = getTermWidth(), _now?: number, pulseFrame?: number): string[] {
 	if (!job.steps?.length) return [];
 	if (job.mode !== "parallel" && job.mode !== "chain") return [];
-	if (job.mode === "chain" && !job.activeParallelGroup && job.parallelGroups?.length) return widgetChainDetails(job, theme, expanded, width, now);
+	if (job.mode === "chain" && !job.activeParallelGroup && job.parallelGroups?.length) return widgetChainDetails(job, theme, expanded, width, pulseFrame);
 	const total = job.stepsTotal ?? job.steps.length;
 	const lines: string[] = [];
 	for (const [index, step] of job.steps.entries()) {
@@ -54,8 +52,8 @@ export function widgetParallelAgentDetails(job: AsyncJobState, theme: Theme, exp
 		const activity = widgetStepActivity(step, job.updatedAt);
 		const itemTitle = job.mode === "parallel" || job.activeParallelGroup ? "Agent" : "Step";
 		const modelDisplay = modelThinkingBadge(theme, step.model, step.thinking, step.fastMode);
-		lines.push(`  ${theme.fg("dim", `${marker} ${widgetStepGlyph(step.status, theme, widgetStepRunningSeed(step, index), now)} ${itemTitle} ${index + 1}/${total}: ${step.agent} · ${widgetStepStatus(step.status, theme)}${modelDisplay}${activity ? ` · ${activity}` : ""}`)}`);
-		for (const nestedLine of formatNestedWidgetLines(step.children, theme, width, expanded, job.updatedAt, expanded ? 8 : 1, now)) lines.push(`    ${nestedLine}`);
+		lines.push(`  ${theme.fg("dim", `${marker} ${widgetStepPulseGlyph(step.status, theme, pulseFrame)} ${itemTitle} ${index + 1}/${total}: ${step.agent} · ${widgetStepStatus(step.status, theme)}${modelDisplay}${activity ? ` · ${activity}` : ""}`)}`);
+		for (const nestedLine of formatNestedWidgetLines(step.children, theme, width, expanded, job.updatedAt, expanded ? 8 : 1, pulseFrame)) lines.push(`    ${nestedLine}`);
 	}
 	return lines;
 }
@@ -69,15 +67,15 @@ export function foregroundStyleWidgetStepLines(
 	total: number,
 	expanded: boolean,
 	width: number,
-	now?: number,
+	pulseFrame?: number,
 ): string[] {
 	const status = widgetStepStatus(step.status, theme);
 	const stats = widgetStepStats(theme, step);
 	const modelDisplay = modelThinkingBadge(theme, step.model, step.thinking, step.fastMode);
-	const lines = [`  ${widgetStepGlyph(step.status, theme, widgetStepRunningSeed(step, index - 1), now)} ${itemTitle} ${index}/${total}: ${themeBold(theme, step.agent)} ${theme.fg("dim", "·")} ${status}${modelDisplay}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`];
+	const lines = [`  ${widgetStepPulseGlyph(step.status, theme, pulseFrame)} ${itemTitle} ${index}/${total}: ${themeBold(theme, step.agent)} ${theme.fg("dim", "·")} ${status}${modelDisplay}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`];
 	const activity = widgetStepActivityLine(step, width, expanded, job.updatedAt);
 	if (activity) lines.push(`    ${theme.fg("dim", `⎿  ${activity}`)}`);
-	for (const nestedLine of formatNestedWidgetLines(step.children, theme, width, expanded, job.updatedAt, undefined, now)) {
+	for (const nestedLine of formatNestedWidgetLines(step.children, theme, width, expanded, job.updatedAt, undefined, pulseFrame)) {
 		lines.push(`    ${nestedLine}`);
 	}
 	if (step.status === "running") {
@@ -100,40 +98,40 @@ export function foregroundStyleWidgetStepLines(
 	return lines;
 }
 
-export function foregroundStyleWidgetDetails(job: AsyncJobState, theme: Theme, expanded: boolean, width: number, now?: number): string[] {
+export function foregroundStyleWidgetDetails(job: AsyncJobState, theme: Theme, expanded: boolean, width: number, pulseFrame?: number): string[] {
 	if (!job.steps?.length) return [
 		`  ${theme.fg("dim", `⎿  ${widgetActivity(job)}`)}`,
-		...formatNestedWidgetLines(job.nestedChildren, theme, width, expanded, job.updatedAt, undefined, now).map((line) => `  ${line}`),
+		...formatNestedWidgetLines(job.nestedChildren, theme, width, expanded, job.updatedAt, undefined, pulseFrame).map((line) => `  ${line}`),
 	];
-	if (job.mode === "chain" && !job.activeParallelGroup && job.parallelGroups?.length) return widgetChainDetails(job, theme, expanded, width, now);
+	if (job.mode === "chain" && !job.activeParallelGroup && job.parallelGroups?.length) return widgetChainDetails(job, theme, expanded, width, pulseFrame);
 	const total = job.stepsTotal ?? job.steps.length;
 	const itemTitle = job.mode === "parallel" || job.activeParallelGroup ? "Agent" : "Step";
 	const lines: string[] = [];
 	for (const [index, step] of job.steps.entries()) {
-		lines.push(...foregroundStyleWidgetStepLines(job, theme, step, itemTitle, index + 1, total, expanded, width, now));
+		lines.push(...foregroundStyleWidgetStepLines(job, theme, step, itemTitle, index + 1, total, expanded, width, pulseFrame));
 	}
 	const attached = new Set(job.steps.flatMap((step) => step.children?.map((child) => child.id) ?? []));
 	const unattached = job.nestedChildren?.filter((child) => !attached.has(child.id)) ?? [];
-	for (const nestedLine of formatNestedWidgetLines(unattached, theme, width, expanded, job.updatedAt, undefined, now)) {
+	for (const nestedLine of formatNestedWidgetLines(unattached, theme, width, expanded, job.updatedAt, undefined, pulseFrame)) {
 		lines.push(`  ${nestedLine}`);
 	}
 	return lines;
 }
 
-export function buildSingleWidgetLines(job: AsyncJobState, theme: Theme, width: number, expanded: boolean, now?: number): string[] {
+export function buildSingleWidgetLines(job: AsyncJobState, theme: Theme, width: number, expanded: boolean, _now?: number, pulseFrame?: number): string[] {
 	const stats = widgetStats(job, theme);
 	const count = job.mode === "chain" ? job.chainStepCount : job.stepsTotal ?? job.agents?.length ?? job.steps?.length;
 	const mode = widgetJobName(job);
 	const title = `async subagent ${mode}${count && count > 1 ? ` (${count})` : ""}`;
 	return [
 		`${theme.fg("toolTitle", themeBold(theme, title))} ${theme.fg("dim", "· background")}`,
-		`${widgetStatusGlyph(job, theme, now)} ${themeBold(theme, mode)}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
-		...foregroundStyleWidgetDetails(job, theme, expanded, width, now),
+		`${widgetStatusGlyph(job, theme, pulseFrame)} ${themeBold(theme, mode)}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
+		...foregroundStyleWidgetDetails(job, theme, expanded, width, pulseFrame),
 	].map((line) => truncLine(line, width));
 }
 
-export function compactSingleWidgetLines(job: AsyncJobState, theme: Theme, width: number, now?: number): string[] {
-	const fullLines = buildSingleWidgetLines(job, theme, width, false, now);
+export function compactSingleWidgetLines(job: AsyncJobState, theme: Theme, width: number, _now?: number, pulseFrame?: number): string[] {
+	const fullLines = buildSingleWidgetLines(job, theme, width, false, _now, pulseFrame);
 	if (fullLines.length <= 10 || !job.steps?.length || (job.mode !== "parallel" && !job.activeParallelGroup)) return fullLines;
 
 	const total = job.stepsTotal ?? job.steps.length;
@@ -145,8 +143,12 @@ export function compactSingleWidgetLines(job: AsyncJobState, theme: Theme, width
 		const stepStats = widgetStepStats(theme, step);
 		const activitySuffix = activity ? ` ${theme.fg("dim", "·")} ${theme.fg("dim", activity)}` : "";
 		const modelDisplay = modelThinkingBadge(theme, step.model, step.thinking, step.fastMode);
-		lines.push(`  ${widgetStepGlyph(step.status, theme, widgetStepRunningSeed(step, index), now)} ${itemTitle} ${index + 1}/${total}: ${themeBold(theme, step.agent)} ${theme.fg("dim", "·")} ${status}${modelDisplay}${activitySuffix}${stepStats ? ` ${theme.fg("dim", "·")} ${stepStats}` : ""}`);
-		for (const nestedLine of formatNestedWidgetLines(step.children, theme, width, false, job.updatedAt, undefined, now)) lines.push(`    ${nestedLine}`);
+		lines.push(`  ${widgetStepPulseGlyph(step.status, theme, pulseFrame)} ${itemTitle} ${index + 1}/${total}: ${themeBold(theme, step.agent)} ${theme.fg("dim", "·")} ${status}${modelDisplay}${activitySuffix}${stepStats ? ` ${theme.fg("dim", "·")} ${stepStats}` : ""}`);
+		for (const nestedLine of formatNestedWidgetLines(step.children, theme, width, false, job.updatedAt, undefined, pulseFrame)) lines.push(`    ${nestedLine}`);
+		if (step.status === "running") {
+			const output = widgetOutputPath(job, step);
+			if (output) lines.push(`    ${theme.fg("dim", `output: ${shortenPath(output)}`)}`);
+		}
 	}
 	if (job.steps.some((step) => step.status === "running")) lines.push(theme.fg("accent", `  Press ${keyHint("app.tools.expand", "for live detail")}`));
 	return lines.map((line) => truncLine(line, width));

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

@@ -2,8 +2,10 @@ import type { ExtensionContext } from "@bastani/atomic";
 import { Container, Text, type Component } from "@earendil-works/pi-tui";
 import * as path from "node:path";
 import { MAX_WIDGET_JOBS, WIDGET_KEY, type AsyncJobState } from "../shared/types.ts";
-import { getTermWidth, RUNNING_ANIMATION_MS, runningGlyph, truncLine, type Theme } from "./render-layout.ts";
+import { getTermWidth, runningPulseGlyph, truncLine, type Theme } from "./render-layout.ts";
 import { themeBold } from "./render-status-progress.ts";
+import { advanceResultPulseFrame } from "./render-result-animation.ts";
+import { widgetRenderKey } from "./render-stable-output.ts";
 import {
 	buildSingleWidgetLines,
 	compactSingleWidgetLines,
@@ -13,7 +15,6 @@ import {
 import {
 	widgetActivity,
 	widgetJobName,
-	widgetJobsRunningSeed,
 	widgetStats,
 	widgetStatusGlyph,
 } from "./render-event-formatting.ts";
@@ -26,22 +27,24 @@ class LiveWidgetComponent implements Component {
 		private readonly theme: Theme,
 		private readonly getExpanded: () => boolean,
 		private readonly getNow: () => number,
+		private readonly getPulseFrame: () => number | undefined,
 	) {}
 
 	render(width: number): string[] {
 		const jobs = this.getJobs();
 		const expanded = this.getExpanded();
 		const now = this.getNow();
-		const lines = this.buildLines(jobs, width, expanded, now);
+		const pulseFrame = this.getPulseFrame();
+		const lines = this.buildLines(jobs, width, expanded, now, pulseFrame);
 		this.container.clear();
 		for (const line of fitWidgetLineBudget(lines, this.theme, width, expanded)) this.container.addChild(new Text(line, 1, 0));
 		return this.container.render(width);
 	}
 
-	private buildLines(jobs: AsyncJobState[], width: number, expanded: boolean, now: number): string[] {
-		if (expanded) return buildWidgetLines(jobs, this.theme, width, true, now);
-		if (jobs.length === 1) return compactSingleWidgetLines(jobs[0]!, this.theme, width, now);
-		return buildWidgetLines(jobs, this.theme, width, false, now);
+	private buildLines(jobs: AsyncJobState[], width: number, expanded: boolean, now: number, pulseFrame: number | undefined): string[] {
+		if (expanded) return buildWidgetLines(jobs, this.theme, width, true, now, pulseFrame);
+		if (jobs.length === 1) return compactSingleWidgetLines(jobs[0]!, this.theme, width, now, pulseFrame);
+		return buildWidgetLines(jobs, this.theme, width, false, now, pulseFrame);
 	}
 
 	invalidate(): void {
@@ -49,22 +52,23 @@ class LiveWidgetComponent implements Component {
 	}
 }
 
-function buildWidgetComponent(getJobs: () => AsyncJobState[], getExpanded: () => boolean, getNow: () => number): (_tui: unknown, theme: Theme) => Component {
-	return (_tui, theme) => new LiveWidgetComponent(getJobs, theme, getExpanded, getNow);
+function buildWidgetComponent(getJobs: () => AsyncJobState[], getExpanded: () => boolean, getNow: () => number, getPulseFrame: () => number | undefined): (_tui: unknown, theme: Theme) => Component {
+	return (_tui, theme) => new LiveWidgetComponent(getJobs, theme, getExpanded, getNow, getPulseFrame);
 }
 
 interface RenderRequestingContext {
 	ui: ExtensionContext["ui"] & { requestRender?: () => void };
 }
 
-// There is only ever one async-agents widget per host process, so the widget
-// ticker and mounted component read their driving context/jobs from module-level
+// There is only ever one async-agents widget per host process, so the mounted
+// component reads its driving context/jobs/pulse frame from module-level
 // singletons instead of remounting the widget for every visible update.
 let latestWidgetCtx: ExtensionContext | undefined;
 let latestWidgetJobs: AsyncJobState[] = [];
 let latestWidgetFrameNow = 0;
 let latestWidgetExpanded = false;
-let widgetTimer: ReturnType<typeof setInterval> | undefined;
+let latestWidgetSnapshotKey: string | undefined;
+let latestWidgetPulseFrame: number | undefined;
 let mountedWidgetCtx: ExtensionContext | undefined;
 let mountedWidgetOwnerKey: string | undefined;
 let widgetMounted = false;
@@ -77,6 +81,10 @@ function getLatestWidgetFrameNow(): number {
 	return latestWidgetFrameNow;
 }
 
+function getLatestWidgetPulseFrame(): number | undefined {
+	return latestWidgetPulseFrame;
+}
+
 function getLatestWidgetExpanded(): boolean {
 	// LiveWidgetComponent re-renders outside a specific renderWidget() call, so
 	// remember the last expansion state observed from a live host UI. Workflow
@@ -94,6 +102,8 @@ function clearLatestWidgetState(): void {
 	latestWidgetJobs = [];
 	latestWidgetFrameNow = 0;
 	latestWidgetExpanded = false;
+	latestWidgetSnapshotKey = undefined;
+	latestWidgetPulseFrame = undefined;
 	mountedWidgetCtx = undefined;
 	mountedWidgetOwnerKey = undefined;
 	widgetMounted = false;
@@ -142,63 +152,35 @@ function unmountWidgetBestEffort(ctx: ExtensionContext | undefined): void {
 	}
 }
 
-function hasAnimatedWidgetJobs(jobs: AsyncJobState[]): boolean {
-	// Animate while any job — or any of its nested steps — is still running so the
-	// header/step spinners never freeze before the work actually settles.
-	return jobs.some((job) => job.status === "running" || job.steps?.some((step) => step.status === "running"));
-}
-
-function refreshAnimatedWidget(): void {
-	if (!latestWidgetCtx?.hasUI) return;
-	try {
-		latestWidgetFrameNow = Date.now();
-		requestWidgetRender(latestWidgetCtx);
-	} catch {
-		// A stale render context means the cosmetic ticker can no longer update the
-		// mounted widget safely; tear it down best-effort and let the next status
-		// update remount on the active host context.
-		stopWidgetAnimation();
-	}
+function widgetSnapshotKey(jobs: AsyncJobState[]): string {
+	return jobs.map(widgetRenderKey).join("\n");
 }
 
-function ensureWidgetAnimation(): void {
-	if (widgetTimer) return;
-	widgetTimer = setInterval(() => {
-		if (!hasAnimatedWidgetJobs(latestWidgetJobs)) {
-			stopWidgetAnimation();
-			return;
-		}
-		refreshAnimatedWidget();
-	}, RUNNING_ANIMATION_MS);
-	widgetTimer.unref?.();
-}
-
-// Stop only the ticker, keeping the last-rendered widget context/jobs intact.
-function stopWidgetTicker(): void {
-	if (widgetTimer) {
-		clearInterval(widgetTimer);
-		widgetTimer = undefined;
-	}
+function refreshWidgetSnapshot(jobs: AsyncJobState[]): void {
+	const snapshotKey = widgetSnapshotKey(jobs);
+	if (snapshotKey === latestWidgetSnapshotKey) return;
+	latestWidgetSnapshotKey = snapshotKey;
+	latestWidgetFrameNow = Date.now();
+	latestWidgetPulseFrame = advanceResultPulseFrame(latestWidgetPulseFrame);
 }
 
-// Full teardown: stop the ticker, clear the mounted widget if possible, and
-// forget the driving context/jobs entirely.
+// Full teardown: clear the mounted widget if possible, and forget the driving
+// context/jobs entirely.
 export function stopWidgetAnimation(): void {
-	stopWidgetTicker();
 	if (widgetMounted) unmountWidgetBestEffort(mountedWidgetCtx);
 	clearLatestWidgetState();
 }
 
-export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = getTermWidth(), expanded = false, now: number = Date.now()): string[] {
+export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = getTermWidth(), expanded = false, now: number = Date.now(), pulseFrame?: number): string[] {
 	if (jobs.length === 0) return [];
-	if (jobs.length === 1) return buildSingleWidgetLines(jobs[0]!, theme, width, expanded, now);
+	if (jobs.length === 1) return buildSingleWidgetLines(jobs[0]!, theme, width, expanded, now, pulseFrame);
 	const running = jobs.filter((job) => job.status === "running");
 	const queued = jobs.filter((job) => job.status === "queued");
 	const finished = jobs.filter((job) => job.status !== "running" && job.status !== "queued");
 
 	const lines: string[] = [];
 	const hasActive = running.length > 0 || queued.length > 0;
-	const headerGlyph = running.length > 0 ? runningGlyph(widgetJobsRunningSeed(running), now) : hasActive ? "●" : "○";
+	const headerGlyph = running.length > 0 ? runningPulseGlyph(pulseFrame) : hasActive ? "●" : "○";
 	lines.push(truncLine(`${theme.fg(hasActive ? "accent" : "dim", headerGlyph)} ${theme.fg(hasActive ? "accent" : "dim", "Async agents")} ${theme.fg("dim", "· background")}`, width));
 
 	const items: string[][] = [];
@@ -211,9 +193,9 @@ export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = ge
 		if (slots <= 0) { hiddenRunning++; continue; }
 		const stats = widgetStats(job, theme);
 		items.push([
-			`${widgetStatusGlyph(job, theme, now)} ${themeBold(theme, widgetJobName(job))}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
+			`${widgetStatusGlyph(job, theme, pulseFrame)} ${themeBold(theme, widgetJobName(job))}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
 			`  ${theme.fg("dim", `⎿  ${widgetActivity(job)}`)}`,
-			...widgetParallelAgentDetails(job, theme, expanded, width, now),
+			...widgetParallelAgentDetails(job, theme, expanded, width, now, pulseFrame),
 		]);
 		slots--;
 	}
@@ -228,9 +210,9 @@ export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = ge
 		if (slots <= 0) { hiddenFinished++; continue; }
 		const stats = widgetStats(job, theme);
 		items.push([
-			`${widgetStatusGlyph(job, theme, now)} ${themeBold(theme, widgetJobName(job))}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
+			`${widgetStatusGlyph(job, theme, pulseFrame)} ${themeBold(theme, widgetJobName(job))}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
 			`  ${theme.fg("dim", `⎿  ${widgetActivity(job)}`)}`,
-			...widgetParallelAgentDetails(job, theme, expanded, width, now),
+			...widgetParallelAgentDetails(job, theme, expanded, width, now, pulseFrame),
 		]);
 		slots--;
 	}
@@ -280,7 +262,7 @@ export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[]): void
 	}
 	latestWidgetCtx = ctx;
 	latestWidgetJobs = [...jobs];
-	latestWidgetFrameNow = Date.now();
+	refreshWidgetSnapshot(jobs);
 	if (widgetMounted && mountedWidgetOwnerKey !== ownerKey) {
 		// Session rebinding can leave the previous host UI alive briefly; clear the
 		// old mount before installing the singleton widget on the new owner/context.
@@ -290,13 +272,10 @@ export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[]): void
 		widgetMounted = false;
 	}
 	if (!widgetMounted) {
-		// belowEditor: the widget animates a running glyph / elapsed labels on a
-		// timer. pi-tui full-clears the screen+scrollback whenever a changed line
-		// sits above the viewport fold, so an aboveEditor widget flickers once the
-		// bottom region grows tall and pushes it above the fold. Rendering below the
-		// editor keeps the live line within the bottom viewport (flicker-free), and
-		// matches the workflow companion widget's placement (#1109).
-		ctx.ui.setWidget(WIDGET_KEY, buildWidgetComponent(getLatestWidgetJobs, getLatestWidgetExpanded, getLatestWidgetFrameNow), {
+		// belowEditor keeps the live async widget pinned to the bottom viewport,
+		// matching the workflow companion widget's placement (#1109). The pulse frame
+		// is advanced only by semantic async status updates, not by a cosmetic timer.
+		ctx.ui.setWidget(WIDGET_KEY, buildWidgetComponent(getLatestWidgetJobs, getLatestWidgetExpanded, getLatestWidgetFrameNow, getLatestWidgetPulseFrame), {
 			placement: "belowEditor",
 		});
 		mountedWidgetCtx = ctx;
@@ -311,8 +290,6 @@ export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[]): void
 		mountedWidgetOwnerKey = ownerKey;
 		requestWidgetRender(ctx);
 	}
-	// Keep the just-rendered ctx/jobs as the last-rendered state; only the ticker
-	// is conditional on whether anything is still animating.
-	if (hasAnimatedWidgetJobs(jobs)) ensureWidgetAnimation();
-	else stopWidgetTicker();
+	// The async pulse is update-driven like foreground subagent results, so no
+	// periodic cosmetic ticker is needed.
 }

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

@@ -5,7 +5,7 @@
  * rendering responsibility across sibling modules.
  */
 
-export { PULSE_FRAMES, RUNNING_ANIMATION_MS, RUNNING_FRAMES, currentRunningFrame, pulseGlyph } from "./render-layout.ts";
+export { PULSE_FRAMES, RUNNING_ANIMATION_MS, RUNNING_FRAMES, currentRunningFrame, pulseGlyph, runningPulseGlyph } from "./render-layout.ts";
 export {
 	advanceResultPulseFrame,
 	clearLegacyResultAnimationTimer,

package/dist/builtin/web-access/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.5-alpha.7",
+  "version": "0.9.5-alpha.8",
   "private": true,
   "description": "Atomic extension for web search, URL fetching, GitHub repo cloning, PDF/video extraction. Fork of: https://github.com/nicobailon/pi-web-access",
   "contributors": [

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,17 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.5-alpha.8] - 2026-07-08
+
+### Fixed
+
+- Fixed builtin `goal` and `ralph` reviewer convergence reporting so review artifacts and reducer/controller decisions now persist explicit parse/convergence summaries (`parsed`, `approved`, `stopReviewLoop`, `nextAction`, `finalActionRemaining`, and diagnostics). Malformed or missing structured reviewer output is surfaced as a parse failure distinct from parsed reviewer rejection/findings; PR/MR/review creation is represented as a post-approval final action when it is the only remaining task; successful reviewer convergence records the final action (`pull-request` or `finish`) without consuming another implementation loop; and the workflow authoring docs, default workflow guidance, and create-spec prompt now tell custom reviewer-gated workflows to model authorized PR, release, deployment, or publication work as final actions rather than implementation blockers while writing local, action-oriented prompts that do not rely on workflow/stage names as hidden context.
+
+- Fixed workflow stage model fallback for unrecoverable context-window overflow: when Atomic's same-model auto-compaction exhausts its recovery attempt, the stage now advances to the next configured `fallbackModels` tier and, once all tiers are exhausted, stops with the terminal context-overflow error instead of compacting and retrying the same model indefinitely.
+- Fixed workflow controlled-pause ordering around unresolved context overflow: paused stages now honor the pause/resume handshake before surfacing the terminal overflow, and a resume message is not sent over an already-recorded unresolved-overflow signal.
+- Fixed reattached workflow stage fallback after unresolved context overflow: if the restored/resumed model tier exhausts context recovery, fallback now continues with the next tier after that resumed model (or stops terminally when it was the final tier) instead of replaying the primary model.
+- Fixed durable workflow resume hydration so replayed `ctx.parallel`/`ctx.task` fanout keeps its original branch parentage, completed stages restore persisted summaries, timing, session/model metadata, and DBOS/file checkpoints round-trip the richer stage metadata used by status and graph views.
+
 ## [0.9.5-alpha.6] - 2026-07-06
 
 ### Fixed

package/dist/builtin/workflows/README.md

@@ -326,7 +326,7 @@ Atomic registers the canonical `structured_output` tool only for schema-enabled
 
 ### Model fallbacks
 
-Stages and high-level task helpers can retry transient provider/model failures with an ordered `fallbackModels` list. The primary `model` is tried first, then each fallback, and finally the current Atomic-selected model when available. Fallbacks are only used for retryable model/provider failures such as rate limits, quota/auth/provider outages, unavailable models, network timeouts, and 5xx errors — ordinary tool, shell, validation, cancellation, and workflow-code failures are not retried.
+Stages and high-level task helpers can retry transient provider/model failures with an ordered `fallbackModels` list. The primary `model` is tried first, then each fallback, and finally the current Atomic-selected model when available. Fallbacks are only used for retryable model/provider failures such as rate limits, quota/auth/provider outages, unavailable models, network timeouts, context-window overflows that Atomic's auto-compaction cannot resolve on the current model, and 5xx errors — ordinary tool, shell, validation, cancellation, and workflow-code failures are not retried.
 
 ```typescript
 import { workflow } from "@bastani/workflows";
@@ -544,6 +544,8 @@ Input overrides are bare `key=value` tokens (no leading `--`). Values are JSON-p
 
 Workflows always run as **background tasks** in interactive sessions — the chat editor stays free while a run executes. Press **F2** (or `/workflow connect <run-id>`) to attach to the live graph viewer; HIL prompts (`ctx.ui.input/confirm/select/editor/custom`) appear as awaiting-input graph nodes. Press Enter on a focused node, or click a visible graph node directly, to open that stage and answer locally, never as a modal dialog over the chat. Attached stage chats capture mouse/trackpad wheel events by default so scrolling stays inside the active stage transcript or prompt instead of falling through to terminal/main-chat scrollback. Press `ctrl+t` to toggle **copy mode**: copy mode disables workflow-chat mouse reporting so normal terminal/tmux text selection can work; press `ctrl+t` again to leave copy mode and restore workflow-chat scrolling. While copy mode is on, wheel/trackpad gestures are handled by the terminal/tmux and may scroll terminal scrollback, so leave copy mode before using the wheel again. Human input is detected when those runtime `ctx.ui.*` calls execute; workflows no longer have a declaration-time HIL flag.
 
+Durable resume preserves the original completed-stage shape: replayed stage/task/parallel/child checkpoints retain summaries, durations, session/model metadata, and parallel branch parentage in the graph instead of flattening fanout branches into a sequential replay chain.
+
 Nested `ctx.workflow(...)` calls are displayed as an expanded graph within the top-level run. `/workflow status` and run pickers list only top-level user-launched workflows, not implementation-owned child runs. The `workflow` tool's `stages`, `stage`, `transcript`, `send`, `pause`, `interrupt`, and `resume` actions can still target visible child stage ids, prefixes, or names from the expanded graph; Atomic routes the control action to the owning nested run internally. (`stages`, `stage`, `transcript`, and `send` are `workflow` tool actions, not `/workflow` slash subcommands; the slash command exposes `connect`, `attach`, `pause`, `list`, `status`, `interrupt`, `kill`, `resume`, `reload`, and `inputs`.)
 
 Prompt answer replay is live-memory only. `StageSnapshot.promptAnswerState` reports whether continuation can replay a prompt answer (`available`), must ask again because the private ledger entry is gone (`unavailable`), or must ask again because multiple matching prompt nodes are ambiguous (`ambiguous`). Raw answers stay in a private `PromptAnswerRecord` ledger, are never serialized to snapshots or persistence, and remain resident in memory until the answer is cleared, the run is removed, or the store is cleared. Replay keys include prompt kind, message text, select choices, input/editor initial value, custom prompt identity hash, and hashed author callsite, so changing any of those inputs may intentionally re-ask on continuation. Empty `ctx.ui.select(..., [])` calls throw before creating a prompt node. Arbitrary custom-widget answers cannot be supplied with `workflow send`; focus the `custom` awaiting-input node in the interactive graph instead.

package/dist/builtin/workflows/builtin/goal-artifacts.ts

@@ -1,6 +1,7 @@
 import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import type { ReviewDecision, ReviewRecord } from "./goal-types.js";
+import type { ReviewConvergenceSummary } from "./review-convergence.js";
 
 export function artifactSafeName(value: string): string {
   const safe = value
@@ -21,6 +22,7 @@ export async function writeReviewArtifact(
   reviewer: string,
   decision: ReviewDecision,
   rawText: string,
+  convergenceDecision: ReviewConvergenceSummary,
 ): Promise<string> {
   const artifactPath = join(
     artifactDir,
@@ -28,7 +30,7 @@ export async function writeReviewArtifact(
   );
   await writeFile(
     artifactPath,
-    `${JSON.stringify({ reviewer, decision, raw_text: rawText }, null, 2)}\n`,
+    `${JSON.stringify({ reviewer, decision, convergence_decision: convergenceDecision, raw_text: rawText }, null, 2)}\n`,
     { encoding: "utf8" },
   );
   return artifactPath;