@bastani/atomic 0.9.11-alpha.8 → 0.9.11-alpha.9

package/dist/builtin/subagents/src/tui/render-status-progress.ts

@@ -1,7 +1,7 @@
-import type { AgentProgress, Details } from "../shared/types.ts";
 import { formatDuration, formatTokens, formatToolCall } from "../shared/formatters.ts";
-import { getDisplayItems } from "../shared/utils.ts";
 import { formatActivityLabel } from "../shared/status-format.ts";
+import type { AgentProgress, Details } from "../shared/types.ts";
+import { getDisplayItems } from "../shared/utils.ts";
 import { getTermWidth, pulseGlyph, type Theme } from "./render-layout.ts";
 
 export function extractOutputTarget(task: string): string | undefined {
@@ -28,14 +28,17 @@ export function getToolCallLines(
 			.filter((item): item is { type: "tool"; name: string; args: Record<string, unknown> } => item.type === "tool")
 			.map((item) => formatToolCall(item.name, item.args, expanded));
 	}
-	return result.toolCalls?.map((toolCall) => expanded ? toolCall.expandedText : toolCall.text) ?? [];
+	return result.toolCalls?.map((toolCall) => (expanded ? toolCall.expandedText : toolCall.text)) ?? [];
 }
 
-
-export function snapshotNowForProgress(progress: Pick<AgentProgress, "currentToolStartedAt" | "durationMs" | "lastActivityAt">, now?: number): number | undefined {
+export function snapshotNowForProgress(
+	progress: Pick<AgentProgress, "currentToolStartedAt" | "durationMs" | "lastActivityAt">,
+	now?: number,
+): number | undefined {
 	if (now !== undefined) return now;
 	if (progress.lastActivityAt !== undefined) return progress.lastActivityAt;
-	if (progress.currentToolStartedAt !== undefined && progress.durationMs !== undefined) return progress.currentToolStartedAt + progress.durationMs;
+	if (progress.currentToolStartedAt !== undefined && progress.durationMs !== undefined)
+		return progress.currentToolStartedAt + progress.durationMs;
 	return undefined;
 }
 
@@ -48,20 +51,25 @@ export function formatCurrentToolLine(
 	if (!progress.currentTool) return undefined;
 	const maxToolArgsLen = Math.max(50, availableWidth - 20);
 	const toolArgsPreview = progress.currentToolArgs
-		? (expanded || progress.currentToolArgs.length <= maxToolArgsLen
+		? expanded || progress.currentToolArgs.length <= maxToolArgsLen
 			? progress.currentToolArgs
-			: `${progress.currentToolArgs.slice(0, maxToolArgsLen)}...`)
-		: "";
-	const durationSuffix = progress.currentToolStartedAt !== undefined && snapshotNow !== undefined
-		? ` | ${formatDuration(Math.max(0, snapshotNow - progress.currentToolStartedAt))}`
+			: `${progress.currentToolArgs.slice(0, maxToolArgsLen)}...`
 		: "";
+	const durationSuffix =
+		progress.currentToolStartedAt !== undefined && snapshotNow !== undefined
+			? ` | ${formatDuration(Math.max(0, snapshotNow - progress.currentToolStartedAt))}`
+			: "";
 	return toolArgsPreview
 		? `${progress.currentTool}: ${toolArgsPreview}${durationSuffix}`
 		: `${progress.currentTool}${durationSuffix}`;
 }
 
-export function buildLiveStatusLine(progress: Pick<AgentProgress, "activityState" | "lastActivityAt">, snapshotNow?: number): string | undefined {
-	if (progress.lastActivityAt !== undefined && snapshotNow !== undefined) return formatActivityLabel(progress.lastActivityAt, progress.activityState, snapshotNow);
+export function buildLiveStatusLine(
+	progress: Pick<AgentProgress, "activityState" | "lastActivityAt">,
+	snapshotNow?: number,
+): string | undefined {
+	if (progress.lastActivityAt !== undefined && snapshotNow !== undefined)
+		return formatActivityLabel(progress.lastActivityAt, progress.activityState, snapshotNow);
 	if (progress.activityState === "needs_attention") return "needs attention";
 	if (progress.activityState === "active_long_running") return "active but long-running";
 	if (progress.lastActivityAt !== undefined) return "active";
@@ -69,11 +77,14 @@ export function buildLiveStatusLine(progress: Pick<AgentProgress, "activityState
 }
 
 export function themeBold(theme: Theme, text: string): string {
-	return ((theme as { bold?: (value: string) => string }).bold?.(text)) ?? text;
+	return (theme as { bold?: (value: string) => string }).bold?.(text) ?? text;
 }
 
 export function statJoin(theme: Theme, parts: string[]): string {
-	return parts.filter(Boolean).map((part) => theme.fg("dim", part)).join(` ${theme.fg("dim", "·")} `);
+	return parts
+		.filter(Boolean)
+		.map((part) => theme.fg("dim", part))
+		.join(` ${theme.fg("dim", "·")} `);
 }
 
 export function formatTokenStat(tokens: number): string {
@@ -84,7 +95,10 @@ export function formatToolUseStat(count: number): string {
 	return `${count} tool use${count === 1 ? "" : "s"}`;
 }
 
-export function displayProgressDurationMs(progress: Pick<AgentProgress, "durationMs"> & Partial<Pick<AgentProgress, "lastActivityAt" | "status">>, now?: number): number {
+export function displayProgressDurationMs(
+	progress: Pick<AgentProgress, "durationMs"> & Partial<Pick<AgentProgress, "lastActivityAt" | "status">>,
+	now?: number,
+): number {
 	if (progress.status === "running" && progress.lastActivityAt !== undefined && now !== undefined) {
 		return progress.durationMs + Math.max(0, now - progress.lastActivityAt);
 	}
@@ -93,7 +107,10 @@ export function displayProgressDurationMs(progress: Pick<AgentProgress, "duratio
 
 export function formatProgressStats(
 	theme: Theme,
-	progress: (Pick<AgentProgress, "toolCount" | "tokens" | "durationMs"> & Partial<Pick<AgentProgress, "lastActivityAt" | "status">>) | undefined,
+	progress:
+		| (Pick<AgentProgress, "toolCount" | "tokens" | "durationMs"> &
+				Partial<Pick<AgentProgress, "lastActivityAt" | "status">>)
+		| undefined,
 	includeDuration = true,
 	now?: number,
 ): string {
@@ -107,7 +124,12 @@ export function formatProgressStats(
 }
 
 export function firstOutputLine(text: string): string {
-	return text.split("\n").find((line) => line.trim())?.trim() ?? "";
+	return (
+		text
+			.split("\n")
+			.find((line) => line.trim())
+			?.trim() ?? ""
+	);
 }
 
 export function resultStatusLine(result: Details["results"][number], output: string): string {
@@ -118,7 +140,13 @@ export function resultStatusLine(result: Details["results"][number], output: str
 	return "Done";
 }
 
-export function resultGlyph(result: Details["results"][number], output: string, theme: Theme, running = result.progress?.status === "running", pulseFrame?: number): string {
+export function resultGlyph(
+	result: Details["results"][number],
+	output: string,
+	theme: Theme,
+	running = result.progress?.status === "running",
+	pulseFrame?: number,
+): string {
 	if (running) return theme.fg("accent", pulseGlyph(pulseFrame));
 	if (result.detached) return theme.fg("warning", "■");
 	if (result.interrupted) return theme.fg("warning", "■");
@@ -129,5 +157,9 @@ export function resultGlyph(result: Details["results"][number], output: string,
 
 export function compactCurrentActivity(progress: AgentProgress, now?: number): string {
 	const snapshotNow = snapshotNowForProgress(progress, now);
-	return formatCurrentToolLine(progress, getTermWidth() - 4, false, snapshotNow) ?? buildLiveStatusLine(progress, snapshotNow) ?? "thinking…";
+	return (
+		formatCurrentToolLine(progress, getTermWidth() - 4, false, snapshotNow) ??
+		buildLiveStatusLine(progress, snapshotNow) ??
+		"thinking…"
+	);
 }

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

@@ -1,14 +1,13 @@
 import { keyHintIfBound } from "@bastani/atomic";
-import type { AsyncJobState } from "../shared/types.ts";
 import { shortenPath } from "../shared/formatters.ts";
 import { aggregateStepStatus, formatParallelOutcome } from "../shared/status-format.ts";
+import type { AsyncJobState } from "../shared/types.ts";
 import { buildAsyncChainStepSpans } from "./render-chain-graph.ts";
-import { getTermWidth, truncLine, type Theme } from "./render-layout.ts";
-import { buildLiveStatusLine, themeBold } from "./render-status-progress.ts";
 import {
 	formatNestedWidgetLines,
 	modelThinkingBadge,
 	widgetActivity,
+	widgetJobName,
 	widgetOutputPath,
 	widgetStats,
 	widgetStatusGlyph,
@@ -17,10 +16,17 @@ import {
 	widgetStepPulseGlyph,
 	widgetStepStats,
 	widgetStepStatus,
-	widgetJobName,
 } from "./render-event-formatting.ts";
+import { getTermWidth, type Theme, truncLine } from "./render-layout.ts";
+import { buildLiveStatusLine, themeBold } from "./render-status-progress.ts";
 
-export function widgetChainDetails(job: AsyncJobState, theme: Theme, expanded = false, width = getTermWidth(), pulseFrame?: 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[] = [];
@@ -28,7 +34,9 @@ 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(`  ${widgetStepPulseGlyph(status, theme, pulseFrame)} 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];
@@ -36,15 +44,35 @@ 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, pulseFrame));
+		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, pulseFrame?: 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, pulseFrame);
+	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()) {
@@ -52,8 +80,19 @@ 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} ${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}`);
+		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;
 }
@@ -72,10 +111,20 @@ export function foregroundStyleWidgetStepLines(
 	const status = widgetStepStatus(step.status, theme);
 	const stats = widgetStepStats(theme, step);
 	const modelDisplay = modelThinkingBadge(theme, step.model, step.thinking, step.fastMode);
-	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 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, pulseFrame)) {
+	for (const nestedLine of formatNestedWidgetLines(
+		step.children,
+		theme,
+		width,
+		expanded,
+		job.updatedAt,
+		undefined,
+		pulseFrame,
+	)) {
 		lines.push(`    ${nestedLine}`);
 	}
 	if (step.status === "running") {
@@ -99,29 +148,63 @@ export function foregroundStyleWidgetStepLines(
 	return lines;
 }
 
-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, pulseFrame).map((line) => `  ${line}`),
-	];
-	if (job.mode === "chain" && !job.activeParallelGroup && job.parallelGroups?.length) return widgetChainDetails(job, theme, expanded, width, pulseFrame);
+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,
+				pulseFrame,
+			).map((line) => `  ${line}`),
+		];
+	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, pulseFrame));
+		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, pulseFrame)) {
+	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, pulseFrame?: 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 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 [
@@ -131,9 +214,16 @@ export function buildSingleWidgetLines(job: AsyncJobState, theme: Theme, width:
 	].map((line) => truncLine(line, width));
 }
 
-export function compactSingleWidgetLines(job: AsyncJobState, theme: Theme, width: number, _now?: number, pulseFrame?: number): string[] {
+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;
+	if (fullLines.length <= 10 || !job.steps?.length || (job.mode !== "parallel" && !job.activeParallelGroup))
+		return fullLines;
 
 	const total = job.stepsTotal ?? job.steps.length;
 	const itemTitle = job.mode === "parallel" || job.activeParallelGroup ? "Agent" : "Step";
@@ -144,15 +234,27 @@ 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(`  ${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}`);
+		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)}`)}`);
 		}
 	}
 	const expandHint = keyHintIfBound("app.tools.expand", "for live detail");
-	if (expandHint && job.steps.some((step) => step.status === "running")) lines.push(theme.fg("accent", `  Press ${expandHint}`));
+	if (expandHint && job.steps.some((step) => step.status === "running"))
+		lines.push(theme.fg("accent", `  Press ${expandHint}`));
 	return lines.map((line) => truncLine(line, width));
 }
 

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

@@ -1,23 +1,18 @@
-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, runningPulseGlyph, truncLine, type Theme } from "./render-layout.ts";
-import { themeBold } from "./render-status-progress.ts";
+import type { ExtensionContext } from "@bastani/atomic";
+import { type Component, Container, Text } from "@earendil-works/pi-tui";
+import { type AsyncJobState, MAX_WIDGET_JOBS, WIDGET_KEY } from "../shared/types.ts";
+import { widgetActivity, widgetJobName, widgetStats, widgetStatusGlyph } from "./render-event-formatting.ts";
+import { getTermWidth, runningPulseGlyph, type Theme, truncLine } from "./render-layout.ts";
 import { advanceResultPulseFrame } from "./render-result-animation.ts";
 import { widgetRenderKey } from "./render-stable-output.ts";
+import { themeBold } from "./render-status-progress.ts";
 import {
 	buildSingleWidgetLines,
 	compactSingleWidgetLines,
 	fitWidgetLineBudget,
 	widgetParallelAgentDetails,
 } from "./render-widget-graph.ts";
-import {
-	widgetActivity,
-	widgetJobName,
-	widgetStats,
-	widgetStatusGlyph,
-} from "./render-event-formatting.ts";
 
 class LiveWidgetComponent implements Component {
 	private readonly container = new Container();
@@ -37,11 +32,18 @@ class LiveWidgetComponent implements Component {
 		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));
+		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, pulseFrame: number | undefined): string[] {
+	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);
@@ -52,7 +54,12 @@ class LiveWidgetComponent implements Component {
 	}
 }
 
-function buildWidgetComponent(getJobs: () => AsyncJobState[], getExpanded: () => boolean, getNow: () => number, getPulseFrame: () => number | undefined): (_tui: unknown, theme: Theme) => Component {
+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);
 }
 
@@ -144,9 +151,7 @@ function getWidgetOwnerKey(ctx: ExtensionContext): string {
 	try {
 		const sessionFile = ctx.sessionManager.getSessionFile?.();
 		if (sessionFile) {
-			const resolvedSessionFile = resolvedCwd
-				? path.resolve(resolvedCwd, sessionFile)
-				: path.resolve(sessionFile);
+			const resolvedSessionFile = resolvedCwd ? path.resolve(resolvedCwd, sessionFile) : path.resolve(sessionFile);
 			sessionOwner = `sessionFile:${resolvedSessionFile}`;
 		}
 	} catch {
@@ -240,7 +245,14 @@ export function stopWidgetAnimation(ownerCtx?: ExtensionContext, owner: object =
 	releaseMountedWidget(state, owner);
 }
 
-export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = getTermWidth(), expanded = false, now: number = Date.now(), pulseFrame?: number): 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, pulseFrame);
 	const running = jobs.filter((job) => job.status === "running");
@@ -250,7 +262,12 @@ export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = ge
 	const lines: string[] = [];
 	const hasActive = running.length > 0 || queued.length > 0;
 	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));
+	lines.push(
+		truncLine(
+			`${theme.fg(hasActive ? "accent" : "dim", headerGlyph)} ${theme.fg(hasActive ? "accent" : "dim", "Async agents")} ${theme.fg("dim", "· background")}`,
+			width,
+		),
+	);
 
 	const items: string[][] = [];
 	let hiddenRunning = 0;
@@ -259,7 +276,10 @@ export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = ge
 	let slots = MAX_WIDGET_JOBS;
 
 	for (const job of running) {
-		if (slots <= 0) { hiddenRunning++; continue; }
+		if (slots <= 0) {
+			hiddenRunning++;
+			continue;
+		}
 		const stats = widgetStats(job, theme);
 		items.push([
 			`${widgetStatusGlyph(job, theme, pulseFrame)} ${themeBold(theme, widgetJobName(job))}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
@@ -276,7 +296,10 @@ export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = ge
 	}
 
 	for (const job of finished) {
-		if (slots <= 0) { hiddenFinished++; continue; }
+		if (slots <= 0) {
+			hiddenFinished++;
+			continue;
+		}
 		const stats = widgetStats(job, theme);
 		items.push([
 			`${widgetStatusGlyph(job, theme, pulseFrame)} ${themeBold(theme, widgetJobName(job))}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`,
@@ -344,12 +367,16 @@ export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[], owner
 	if (!state.mounted) {
 		const surface = getSurfaceState(requestedSurfaceKey);
 		if (surface.activeOwner && surface.activeOwner !== owner) return;
-		ctx.ui.setWidget(WIDGET_KEY, buildWidgetComponent(
-			() => state.latestJobs,
-			() => getExpanded(state),
-			() => state.frameNow,
-			() => state.pulseFrame,
-		), { placement: "belowEditor" });
+		ctx.ui.setWidget(
+			WIDGET_KEY,
+			buildWidgetComponent(
+				() => state.latestJobs,
+				() => getExpanded(state),
+				() => state.frameNow,
+				() => state.pulseFrame,
+			),
+			{ placement: "belowEditor" },
+		);
 		state.mountedCtx = ctx;
 		state.mountedOwnerKey = ownerKey;
 		state.surfaceKey = requestedSurfaceKey;

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

@@ -5,14 +5,21 @@
  * rendering responsibility across sibling modules.
  */
 
-export { PULSE_FRAMES, RUNNING_ANIMATION_MS, RUNNING_FRAMES, currentRunningFrame, pulseGlyph, runningPulseGlyph } from "./render-layout.ts";
+export {
+	currentRunningFrame,
+	PULSE_FRAMES,
+	pulseGlyph,
+	RUNNING_ANIMATION_MS,
+	RUNNING_FRAMES,
+	runningPulseGlyph,
+} from "./render-layout.ts";
+export { renderLiveSubagentResult, renderSubagentResult } from "./render-result.ts";
+export type { SubagentResultRenderState } from "./render-result-animation.ts";
 export {
 	advanceResultPulseFrame,
 	clearLegacyResultAnimationTimer,
 	clearResultAnimationTimer,
 	stopResultAnimations,
 } from "./render-result-animation.ts";
-export type { SubagentResultRenderState } from "./render-result-animation.ts";
 export { widgetRenderKey } from "./render-stable-output.ts";
 export { buildWidgetLines, renderWidget, stopWidgetAnimation } from "./render-widget.ts";
-export { renderLiveSubagentResult, renderSubagentResult } from "./render-result.ts";

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

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/web-access",
-  "version": "0.9.11-alpha.8",
+  "version": "0.9.11-alpha.9",
   "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": [
@@ -31,7 +31,7 @@
   },
   "peerDependencies": {
     "@bastani/atomic": "*",
-    "@earendil-works/pi-tui": "^0.82.1"
+    "@earendil-works/pi-tui": "^0.83.0"
   },
   "peerDependenciesMeta": {
     "@bastani/atomic": {

package/dist/builtin/workflows/CHANGELOG.md

@@ -6,6 +6,36 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [0.9.11-alpha.9] - 2026-08-01
+
+### Added
+
+- Added per-node cancellation to `ctx.tool`. Every callback now receives a `WorkflowToolContext` (`{ signal }`) derived from a per-invocation `AbortController` combined with the run signal, so a run abort still cascades to every node while one node can be aborted alone. All retries of a call share that one signal, and existing zero-argument callbacks keep compiling and running unchanged. `WorkflowToolContext` is exported from the authoring surface ([#2078](https://github.com/bastani-inc/atomic/issues/2078)).
+- Added tool nodes as addressable abort targets for `workflow({ action: "quit"|"interrupt", runId, stageId })`. A node resolves by expanded id, local `tool:<argsHash>` id, or tool name with the same exact-then-unique precedence and ambiguity diagnostics stages get. Aborting one node marks it `cancelled` and leaves sibling stages and tool nodes running; tool nodes stay non-attachable, so this adds abort, not chat. The result reports the node outcome and the run separately — `status: "cancelled"` with the observed `workflowStatus` — instead of claiming the run was paused. `pause` on a tool node is now rejected explicitly instead of resolving to nothing ([#2078](https://github.com/bastani-inc/atomic/issues/2078)).
+
+### Changed
+
+- Declared `handlesCtrlC` on every workflow surface mounted through `ctx.ui.custom()` — the graph pane (which hosts stage chat, prompt cards, and the inline form) and the inputs picker. In isolated interactive sessions the terminal host now closes an undeclared remote component on the first Ctrl+C, so the declaration is what keeps `ctrl+c Skip`, `ctrl+c Close`, and picker cancel working.
+- Documented deterministic delivery timing for workflow stage messages. `steer` (and `auto` against a streaming stage) is consumed after the current assistant response finishes its whole tool batch and before the next model request — never between two tool calls of the same response; `followUp` is consumed only when the agent would otherwise stop. Each queue is FIFO in admission order, and steering keeps priority over an earlier-submitted follow-up, so there is no global FIFO across the two queues ([#2074](https://github.com/bastani-inc/atomic/issues/2074)).
+
+### Fixed
+
+- Fixed `open-claude-design` converting a failed `user-feedback-*` stage into design approval (the [#1499](https://github.com/bastani-inc/atomic/issues/1499) catch-then-approve path). A rejected feedback stage — provider errors, model-fallback exhaustion, broken session forks — now propagates and fails the run instead of silently setting `approved_for_export` and exporting an unreviewed design. Resolved results are unchanged: a stage that runs and reports no meaningful notes, including degraded manual/headless display paths, still legitimately reads as approval, and browser/tooling trouble continues to resolve gracefully rather than reject (playwright-cli auto-install, the early browser exit, and the stage's degradation contract are unaffected) ([#2123](https://github.com/bastani-inc/atomic/issues/2123)).
+- Fixed `open-claude-design` embedding unbounded research context inline in single stage prompts, the same single-message overflow class as the [#1499](https://github.com/bastani-inc/atomic/issues/1499) `413 request_too_large`. The composed project design context now persists to `<artifact_dir>/design-context.md` and the curated references brief always persists to `<artifact_dir>/references.md` (with the no-references fallback when discovery is skipped); `reference-discovery` reads the design context, and the generate and exporter stages read both files via `reads` with explicit read-the-file instructions instead of inline `design_system`/`reference_inspiration` embeds. The joined research results are no longer injected as `previous` payloads into `generate-1` or `reference-discovery`. Because the files are required stage inputs, a failed write no longer passes silently: the run exits `blocked` through `ctx.exit` with the artifact paths surfaced (or propagates the error when `ctx.exit` is unavailable) instead of dispatching stages against nonexistent context. Deliberately small inline payloads are unchanged: verbatim-threaded user annotations (the #1464 guardrail) and the word-capped prior design summary ([#2121](https://github.com/bastani-inc/atomic/issues/2121)).
+- Fixed `open-claude-design` blocking on browser live review while reporting `running`, leaving the user with no input affordance. Each refinement round now raises a deterministic run-level `ctx.ui` prompt before its `user-feedback-*` stage starts, so the needs-attention badge fires and the prompt names the preview path and `file://` URL; choosing the skip option accepts the current design and proceeds to export. Only the executor's unavailable-UI rejection (headless mode or a missing UI adapter) degrades to running the review directly; any other gate failure — interruption, a failed durable checkpoint — propagates and stops the run. The feedback-stage prompt additionally instructs the agent to print the live `http://` review URL before starting any long-poll wait, so the URL is visible at the top of the stage output when attaching mid-run ([#2060](https://github.com/bastani-inc/atomic/issues/2060)).
+- Hardened the bundled `impeccable` live-mode scripts against four CodeQL security findings, preserving behavior for all valid inputs: live-edit session ids now fall back to `crypto.getRandomValues` instead of `Math.random` outside secure contexts (`js/insecure-randomness`); the live server clamps the client-supplied poll timeout to the 10-minute default ceiling (`js/resource-exhaustion`); `live-accept` escapes the `--variant` value before splicing it into a `RegExp` (`js/regex-injection`); and manual-edit evidence decodes `&amp;` last so crafted input cannot be double-unescaped (`js/double-escaping`).
+- Fixed worktree setup hooks being reported as failed when they never read their stdin. The hook's JSON input is written to its stdin, but nothing requires a hook to consume it; a hook that exited before that write flushed made `spawnSync` report `EPIPE` and the whole worktree creation was torn down, even though the hook had run to completion and its stdout was captured in full. The child's exit status and output are now authoritative, so only a spawn that never produced a status is treated as a hook failure. Timeouts and every other spawn error stay fatal as before. This race was lost far more often on loaded machines, making it look intermittent.
+- Fixed graceful quit ignoring in-flight `ctx.tool` calls. A run whose only in-flight work was a durable tool node reported `No controllable stages on run <id>; the run remains active` and left the callback running with no way to stop it. Quit now counts running tool nodes as controllable work; after stage pauses acknowledge it closes the root-shared tool-admission boundary, so a call admitted during that wait is still included and none can start afterwards — not even while the durable write is in flight. It then aborts the complete root/nested set, waits a bounded interval for settlement, and only then records the durable paused/resumable transition, so quit is again an exact durability boundary rather than a pause declared while a callback is still mutating the world. A call attempted after the close is refused with the graceful-quit signal and never runs. A callback that ignores its signal is abandoned instead of pinning quit, and the result reports cancelled and abandoned calls by owning `{runId, nodeId}` identity, so two nested children sharing one local node id stay distinguishable ([#2078](https://github.com/bastani-inc/atomic/issues/2078)).
+- Fixed resume after quitting an unfinished `ctx.tool` call. A cancelled call now writes no replayable checkpoint and no `return_failure` outcome, so a cancellation can never replay as data; under `failureMode: "return"` it keeps exactly one inspection-only `tool-failure:` record, which stays out of the replay cache. Resume recomputes the same ordinal and `argsHash` and re-executes exactly that callback at the same `tool:<argsHash>` node, while completed sibling tools still replay from cache. A late value returned by an abandoned callback is discarded before persistence ([#2078](https://github.com/bastani-inc/atomic/issues/2078)).
+- Fixed a quit-time hole where workflow code that caught the tool cancellation could still publish a completed run over quit's paused record: the executor now suspends whenever its own tool work was aborted or refused by a whole-run quit, whichever path the author's code takes afterwards. A catch may clean up, but it is not an opt-out; targeted node abort remains the way to abort one call and keep a run going ([#2078](https://github.com/bastani-inc/atomic/issues/2078)).
+- Fixed resume adopting the stale executor after a callback was abandoned. Quit now detaches that background job, so resume relaunches a fresh executor under the same workflow id and actually re-runs the unfinished call instead of flipping the run to running with nothing driving it. Job and cancellation cleanup are identity-conditional and tool-node store writes are generation-owned, so a late zombie callback can neither evict the replacement's registrations nor mutate its graph node, and registering a second job for one live run id is now a loud error instead of silent double dispatch ([#2078](https://github.com/bastani-inc/atomic/issues/2078)).
+- Fixed a quit whose durable paused transition failed or was refused leaving the run reported as running with nothing running it. Aborting an in-flight `ctx.tool` call commits its executor to suspending, so quit now records the local pause whatever the durable write does; only the resumable promise follows the durable outcome, and the reported error names the durable failure and what it left behind instead of just failing. The run stays controllable, so a retried `/workflow quit` re-attempts the transition and upgrades the pause to resumable — previously the tool handles were already gone, so the retry answered `No controllable stages on run <id>` and the run could never be quit, resumed, or ended ([#2078](https://github.com/bastani-inc/atomic/issues/2078)).
+- Fixed a typed message in an attached workflow stage chat being demoted to a follow-up. When the chat read the stage as idle while workflow message admission still owned the retiring turn, Enter fell through to the unspecified-delivery default and landed at the end of the turn instead of at the next steering boundary, so mid-run correction did not work. Typed Enter now names steering explicitly, matching normal session steering. The choice is scoped to one submission — it travels with the submitting key through the chat host — so a slow in-flight Ctrl+F cannot make a later Enter a follow-up. Ctrl+F still queues a follow-up, a genuinely idle stage still starts a fresh turn, and the authored `stage.sendUserMessage()` default is unchanged ([#2074](https://github.com/bastani-inc/atomic/issues/2074)).
+- Fixed queued steering and follow-up rows disappearing when you left a stage. The queue lives on the stage session, but its display lived in the chat pane that detach destroys, so reattaching showed nothing even though the messages were still queued. The stage handle now keeps its own projection of the session's `queue_update` snapshots for its whole lifetime, and reattaching rehydrates the pending rows from it. Because the projection is fed by the events rather than by a concrete Atomic `AgentSession`, a stage backed by a custom `AgentSessionAdapter` keeps its rows too ([#2074](https://github.com/bastani-inc/atomic/issues/2074)).
+- Fixed a queued stage message being invisible from the workflow graph. A stage node with pending queued messages now shows a `✉ N queued` badge read from that same handle projection, so a message queued before detaching stays visible without reattaching. The badge claims the node's dim metadata row, or the redundant `waiting for response` row on an awaiting-input node so its `↵ enter to respond` hint survives. Nested child stages resolve to their real run and stage identity, tool nodes are never asked, card geometry is unchanged, and no queue state enters a store snapshot ([#2074](https://github.com/bastani-inc/atomic/issues/2074)).
+- Fixed a stage session that arrives already holding queued messages showing an empty queue. A session announces its queue by event, so a queue that exists before this stage's listeners are bound to that session was announced to nobody: a retiring stage session hands its pending messages to the session replacing it, and a retained session reopened for post-mortem chat is restored with whatever it was holding. Both published that queue while the handle's projection was attached to nothing, so the badge read zero and a reattached chat redrew no rows even though the messages were still pending. Attaching a session now replays the one snapshot its listeners missed, read from the session itself; every later change still arrives as an ordinary `queue_update`, and a runtime that does not expose its queues is unaffected ([#2074](https://github.com/bastani-inc/atomic/issues/2074)).
+- Fixed Ctrl+F losing its follow-up intent on a stage handle that predates the delivery-aware send. The compatibility path submitted the message as an ordinary prompt, so a follow-up typed while the stage streamed a retiring turn was admitted with prompt delivery instead of waiting in the follow-up queue. Ctrl+F now reaches the follow-up queue exactly while the stage streams, and still starts a turn on a genuinely idle stage — matching what the delivery-aware path does, rather than parking text no turn would consume ([#2074](https://github.com/bastani-inc/atomic/issues/2074)).
+
 ## [0.9.11-alpha.6] - 2026-07-28
 
 ### Added