@bastani/atomic 0.9.3-alpha.1 → 0.9.3-alpha.3

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

@@ -10,7 +10,7 @@ import { discoverAgents } from "../agents/agents.ts";
 import { cleanupAllArtifactDirs, cleanupOldArtifacts, getArtifactsDir } from "../shared/artifacts.ts";
 import { resolveCurrentSessionId } from "../shared/session-identity.ts";
 import { cleanupOldChainDirs } from "../shared/settings.ts";
-import { renderLiveSubagentResult, renderSubagentResult, stopResultAnimations, stopWidgetAnimation, type SubagentResultRenderState } from "../tui/render.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";
@@ -69,7 +69,7 @@ type SubagentToolRenderState = SubagentResultRenderState;
 function rebuildSlashResultContainer(
 	container: Container,
 	result: AgentToolResult<Details>,
-	options: { expanded: boolean; now?: number },
+	options: { expanded: boolean; now?: number; pulseFrame?: number },
 	theme: ExtensionContext["ui"]["theme"],
 ): void {
 	container.clear();
@@ -87,12 +87,14 @@ function createSlashResultComponent(
 	const container = new Container();
 	let lastVersion = -1;
 	let lastSnapshotNow = 0;
+	let pulseFrame = 0;
 	container.render = (width: number): string[] => {
 		const snapshot = getSlashRenderableSnapshot(details);
 		if (snapshot.version !== lastVersion) {
 			lastVersion = snapshot.version;
 			lastSnapshotNow = Date.now();
-			rebuildSlashResultContainer(container, snapshot.result, { ...options, now: lastSnapshotNow }, theme);
+			pulseFrame = advanceResultPulseFrame(pulseFrame);
+			rebuildSlashResultContainer(container, snapshot.result, { ...options, now: lastSnapshotNow, pulseFrame }, theme);
 		}
 		return Container.prototype.render.call(container, width);
 	};
@@ -179,6 +181,7 @@ export default function registerSubagentExtension(pi: ExtensionAPI): void {
 		baseCwd: "",
 		currentSessionId: null,
 		asyncJobs: new Map(),
+		subagentInProgress: false,
 		foregroundRuns: new Map(),
 		foregroundControls: new Map(),
 		lastForegroundControlId: null,

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

@@ -137,11 +137,6 @@ const ChainItem = Type.Object({
 }, {
 	description: "Chain step: use {agent, task?, ...} for sequential, {parallel: [...]} for static concurrent execution, or {expand, parallel: {...}, collect} for dynamic fanout.",
 	additionalProperties: false,
-	allOf: [
-		{ if: { required: ["expand"] }, then: { required: ["parallel", "collect"], properties: { parallel: { type: "object" } } } },
-		{ if: { required: ["collect"] }, then: { required: ["expand", "parallel"], properties: { parallel: { type: "object" } } } },
-		{ not: { required: ["expand"], properties: { parallel: { type: "array", items: {} } } } },
-	],
 });
 
 const ControlOverrides = Type.Object({

package/dist/builtin/subagents/src/runs/background/async-job-tracker.ts

@@ -395,10 +395,7 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 		state.foregroundControls?.clear();
 		state.lastForegroundControlId = null;
 		state.resultFileCoalescer.clear();
-		if (ctx?.hasUI) {
-			state.lastUiContext = ctx;
-			rerenderWidget(ctx, []);
-		}
+		if (ctx?.hasUI) state.lastUiContext = ctx;
 	};
 
 	return { ensurePoller, handleStarted, handleComplete, resetJobs, hydrateActiveJobs };

package/dist/builtin/subagents/src/runs/foreground/subagent-executor-single.ts

@@ -25,11 +25,25 @@ import {
 	wrapForkTask,
 	type AgentProgress,
 	type ArtifactPaths,
+	type SingleResult,
 	type SubagentToolResult,
 } from "../../shared/types.ts";
 import type { ExecutionContextData, ResolvedExecutorDeps } from "./subagent-executor-types.ts";
 import { createForegroundControlNotifier, maybeBuildForegroundIntercomReceipt, rememberForegroundRun } from "./subagent-executor-status.ts";
 
+function formatFailedSingleRunOutput(result: SingleResult, displayOutput: string): string {
+	const error = result.error || "Failed";
+	const output = displayOutput.trim();
+	const lines = [error];
+	if (output && output !== error.trim()) {
+		lines.push("", "Output:", output);
+	}
+	if (result.artifactPaths?.outputPath) {
+		lines.push("", `Output artifact: ${result.artifactPaths.outputPath}`);
+	}
+	return lines.join("\n");
+}
+
 export async function runSinglePath(data: ExecutionContextData, deps: ResolvedExecutorDeps): Promise<SubagentToolResult> {
 	const {
 		params,
@@ -309,7 +323,7 @@ export async function runSinglePath(data: ExecutionContextData, deps: ResolvedEx
 
 	if (r.exitCode !== 0)
 		return {
-			content: [{ type: "text", text: r.error || "Failed" }],
+			content: [{ type: "text", text: formatFailedSingleRunOutput(r, finalizedOutput.displayOutput) }],
 			details,
 			isError: true,
 		};

package/dist/builtin/subagents/src/runs/foreground/subagent-executor.ts

@@ -172,6 +172,23 @@ async function handleInterruptRequest(input: {
 	};
 }
 
+function inferExecutionMode(params: SubagentParamsLike): "single" | "parallel" | "chain" {
+	if ((params.chain?.length ?? 0) > 0) return "chain";
+	if ((params.tasks?.length ?? 0) > 0) return "parallel";
+	return "single";
+}
+
+function duplicateSubagentCallResult(params: SubagentParamsLike): SubagentToolResult {
+	return {
+		content: [{
+			type: "text",
+			text: "Rejected: a subagent call is already in progress. Issue exactly ONE subagent call per turn.",
+		}],
+		isError: true,
+		details: { mode: inferExecutionMode(params), results: [] },
+	};
+}
+
 export function createSubagentExecutor(rawDeps: ExecutorDeps): {
 	execute: (
 		id: string,
@@ -249,5 +266,22 @@ export function createSubagentExecutor(rawDeps: ExecutorDeps): {
 		}, prepared.effectiveParams.context);
 	};
 
-	return { execute };
+	const executeWithSingleDispatchGuard = async (
+		id: string,
+		params: SubagentParamsLike,
+		signal: AbortSignal,
+		onUpdate: ((r: SubagentToolResult) => void) | undefined,
+		ctx: ExtensionContext,
+	): Promise<SubagentToolResult> => {
+		if (params.action) return execute(id, params, signal, onUpdate, ctx);
+		if (deps.state.subagentInProgress === true) return duplicateSubagentCallResult(params);
+		deps.state.subagentInProgress = true;
+		try {
+			return await execute(id, params, signal, onUpdate, ctx);
+		} finally {
+			deps.state.subagentInProgress = false;
+		}
+	};
+
+	return { execute: executeWithSingleDispatchGuard };
 }

package/dist/builtin/subagents/src/runs/shared/subagent-prompt-runtime.ts

@@ -31,6 +31,7 @@ export const CHILD_FANOUT_BOUNDARY_INSTRUCTIONS = [
 const PARENT_ONLY_CUSTOM_MESSAGE_TYPES = new Set([
 	"subagent-orchestration-instructions",
 	"subagent-slash-result",
+	"subagent-slash-text-result",
 	"subagent-notify",
 	"subagent_control_notice",
 	"subagent-control",
@@ -130,14 +131,15 @@ function stripAssistantSubagentToolCallBlocks(message: unknown): unknown | undef
 }
 
 export function stripParentOnlySubagentMessages(messages: unknown[]): unknown[] {
+	const preserveCurrentFanoutToolHistory = process.env[SUBAGENT_FANOUT_CHILD_ENV] === "1";
 	let changed = false;
 	const filtered: unknown[] = [];
 	for (const message of messages) {
-		if (isParentOnlySubagentMessage(message) || isSubagentToolResultMessage(message)) {
+		if (isParentOnlySubagentMessage(message) || (!preserveCurrentFanoutToolHistory && isSubagentToolResultMessage(message))) {
 			changed = true;
 			continue;
 		}
-		const stripped = stripAssistantSubagentToolCallBlocks(message);
+		const stripped = preserveCurrentFanoutToolHistory ? message : stripAssistantSubagentToolCallBlocks(message);
 		if (stripped === undefined) {
 			changed = true;
 			continue;

package/dist/builtin/subagents/src/shared/types-async.ts

@@ -230,6 +230,7 @@ export interface SubagentState {
 	baseCwd: string;
 	currentSessionId: string | null;
 	asyncJobs: Map<string, AsyncJobState>;
+	subagentInProgress?: boolean;
 	foregroundRuns?: Map<string, ForegroundResumeRun>;
 	foregroundControls: Map<string, {
 		runId: string;

package/dist/builtin/subagents/src/slash/prompt-template-bridge.ts

@@ -82,6 +82,7 @@ interface PromptTemplateBridgeResult {
 			exitCode?: number;
 			error?: string;
 			model?: string;
+			toolCalls?: Array<{ text?: string; expandedText?: string }>;
 		}>;
 		progress?: Array<{
 			index?: number;
@@ -147,10 +148,13 @@ function parsePromptTemplateRequest(data: unknown): PromptTemplateDelegationRequ
 	if (!hasSingle && tasks.length === 0) return undefined;
 
 	const fallbackTask = tasks[0];
+	const agent = hasSingle ? value.agent : fallbackTask?.agent;
+	const task = hasSingle ? value.task : fallbackTask?.task;
+	if (!agent || !task) return undefined;
 	return {
 		requestId: value.requestId,
-		agent: hasSingle ? value.agent : fallbackTask!.agent,
-		task: hasSingle ? value.task : fallbackTask!.task,
+		agent,
+		task,
 		...(tasks.length > 0 ? { tasks } : {}),
 		context: value.context,
 		model: value.model,
@@ -209,13 +213,31 @@ function resolveProgressModel(
 	return firstWithModel?.model;
 }
 
-function buildDelegationMessages(result: { messages?: unknown[]; finalOutput?: string }, fallbackText?: string): unknown[] {
+function toolCallSummaryText(summary: { text?: string; expandedText?: string }): string | undefined {
+	const text = typeof summary.expandedText === "string" && summary.expandedText.trim().length > 0
+		? summary.expandedText.trim()
+		: typeof summary.text === "string"
+			? summary.text.trim()
+			: "";
+	return text || undefined;
+}
+
+function buildDelegationMessages(
+	result: { messages?: unknown[]; finalOutput?: string; toolCalls?: Array<{ text?: string; expandedText?: string }> },
+	fallbackText?: string,
+): unknown[] {
 	if (Array.isArray(result.messages) && result.messages.length > 0) return result.messages;
+	const toolCallSummaries = (result.toolCalls ?? []).flatMap((summary) => {
+		const text = toolCallSummaryText(summary);
+		return text ? [`- ${text}`] : [];
+	});
+	const toolCallText = toolCallSummaries.length > 0 ? `Tool calls:\n${toolCallSummaries.join("\n")}` : undefined;
 	const text = typeof result.finalOutput === "string" && result.finalOutput.trim().length > 0
 		? result.finalOutput.trim()
 		: fallbackText;
-	if (!text) return [];
-	return [{ role: "assistant", content: [{ type: "text", text }] }];
+	const contentText = [toolCallText, text].filter((part): part is string => Boolean(part)).join("\n\n");
+	if (!contentText) return [];
+	return [{ role: "assistant", content: [{ type: "text", text: contentText }] }];
 }
 
 function toDelegationUpdate(requestId: string, update: PromptTemplateBridgeResult): PromptTemplateDelegationUpdate | undefined {

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

@@ -66,16 +66,22 @@ export function truncLine(text: string, maxWidth: number): string {
 	return result + activeStyles.join("") + "…";
 }
 
-const RUNNING_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export const RUNNING_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 
 /**
  * Spinner cadence (ms per frame). The running glyph is derived from wall-clock
  * time so every active spinner advances smoothly and in lockstep, independent
  * of how often (or how irregularly) progress data updates arrive. The animation
  * timers below only schedule re-renders; the displayed frame always comes from
- * the clock. This fixes the frozen/stuttering spinner from issue #1084 while
- * keeping per-frame diffs to a single glyph cell so the differential renderer
- * never needs a full-clear (no flicker).
+ * the clock. This fixes the frozen/stuttering spinner from issue #1084.
+ *
+ * IMPORTANT: a wall-clock spinner only stays flicker-free for widgets pinned to
+ * the bottom of the buffer (e.g. the below-editor async widget), where every
+ * tick stays inside the viewport. Content rendered into chat scrollback (live
+ * foreground subagent results) can scroll above the viewport fold; there, even
+ * a single-cell spinner diff forces pi-tui into a destructive full-screen +
+ * scrollback clear on every tick. Such surfaces must NOT animate on a timer —
+ * see pulseGlyph(), which is advanced once per real progress update instead.
  */
 export const RUNNING_ANIMATION_MS = 80;
 
@@ -106,6 +112,23 @@ export function runningGlyph(seed?: number, now?: number): string {
 	return RUNNING_FRAMES[Math.abs(animatedSeed) % RUNNING_FRAMES.length]!;
 }
 
+export const PULSE_FRAMES = ["·", "•", "●", "•"];
+
+/**
+ * Activity "heartbeat" glyph for live foreground subagent results. Unlike
+ * runningGlyph(), the frame is NOT derived from wall-clock time: the caller
+ * advances `frame` exactly once per real progress update (see
+ * renderLiveSubagentResult). With no animation timer, the only line diffs this
+ * produces coincide with progress data that genuinely changed, so the pulse can
+ * live in chat scrollback (above or below the fold) without ever triggering
+ * pi-tui's full-screen/scrollback clear. Returns a steady breathing dot that
+ * grows and settles as the subagent reports activity.
+ */
+export function pulseGlyph(frame?: number): string {
+	const index = Number.isFinite(frame) ? Math.abs(Math.trunc(frame as number)) : 0;
+	return PULSE_FRAMES[index % PULSE_FRAMES.length]!;
+}
+
 export function progressRunningSeed(progress: ProgressSeedSource | undefined): number | undefined {
 	if (!progress) return undefined;
 	return runningSeed(

package/dist/builtin/subagents/src/tui/render-result-animation.ts

@@ -1,56 +1,47 @@
-import { RUNNING_ANIMATION_MS } from "./render-layout.ts";
-
 type ResultAnimationTimer = ReturnType<typeof setInterval>;
 
 export interface SubagentResultRenderState {
 	subagentResultAnimationTimer?: ResultAnimationTimer;
+	subagentResultAnimationCleanup?: () => void;
 	subagentResultSnapshotKey?: string;
 	/** Stable semantic/content timestamp used for durations and activity text. */
 	subagentResultSnapshotNow?: number;
-	/** Timer-driven timestamp used only for spinner glyph frames. */
-	subagentResultSpinnerFrameNow?: number;
+	/** Monotonic pulse frame, advanced once per progress update (no timer). */
+	subagentResultPulseFrame?: number;
 }
 
 export type ResultAnimationContext = {
 	state: SubagentResultRenderState;
 	invalidate: () => void;
 };
-type LegacyResultAnimationContext = { state: { subagentResultAnimationTimer?: ResultAnimationTimer } };
-
-const activeResultAnimationTimers = new Map<ResultAnimationTimer, SubagentResultRenderState>();
+type LegacyResultAnimationContext = {
+	state: {
+		subagentResultAnimationTimer?: ResultAnimationTimer;
+		subagentResultAnimationCleanup?: () => void;
+	};
+};
 
+/**
+ * Legacy safety net for render state objects created by earlier timer-driven
+ * foreground result rendering. New code never schedules result timers, but
+ * clearing the field prevents a stale interval from surviving across upgrades.
+ */
 export function clearResultAnimationTimer(context: LegacyResultAnimationContext): void {
 	const timer = context.state.subagentResultAnimationTimer;
-	if (timer) {
-		clearInterval(timer);
-		activeResultAnimationTimers.delete(timer);
-	}
+	if (timer) clearInterval(timer);
 	context.state.subagentResultAnimationTimer = undefined;
+	context.state.subagentResultAnimationCleanup = undefined;
 }
 
-export function clearLegacyResultAnimationTimer(context: LegacyResultAnimationContext): void {
-	clearResultAnimationTimer(context);
+export function advanceResultPulseFrame(frame: number | undefined): number {
+	return (frame ?? 0) + 1;
 }
 
-export function ensureResultAnimation(context: ResultAnimationContext): void {
-	if (context.state.subagentResultAnimationTimer) return;
-	const timer = setInterval(() => {
-		context.state.subagentResultSpinnerFrameNow = Date.now();
-		try {
-			context.invalidate();
-		} catch {
-			clearResultAnimationTimer(context);
-		}
-	}, RUNNING_ANIMATION_MS);
-	timer.unref?.();
-	context.state.subagentResultAnimationTimer = timer;
-	activeResultAnimationTimers.set(timer, context.state);
+export function clearLegacyResultAnimationTimer(context: LegacyResultAnimationContext): void {
+	clearResultAnimationTimer(context);
 }
 
 export function stopResultAnimations(): void {
-	for (const [timer, state] of activeResultAnimationTimers) {
-		clearInterval(timer);
-		if (state.subagentResultAnimationTimer === timer) state.subagentResultAnimationTimer = undefined;
-	}
-	activeResultAnimationTimers.clear();
+	// Retained for extension teardown compatibility; result rendering no longer
+	// registers global animation timers.
 }

package/dist/builtin/subagents/src/tui/render-result-compact.ts

@@ -2,7 +2,7 @@ import { Container, Text, type Component } from "@earendil-works/pi-tui";
 import type { AgentProgress, AsyncJobStep, Details } from "../shared/types.ts";
 import { shortenPath } from "../shared/formatters.ts";
 import { getSingleResultOutput } from "../shared/utils.ts";
-import { getTermWidth, progressRunningSeed, runningGlyph, runningSeed, truncLine, type Theme } from "./render-layout.ts";
+import { getTermWidth, pulseGlyph, truncLine, type Theme } from "./render-layout.ts";
 import {
 	buildLiveStatusLine,
 	compactCurrentActivity,
@@ -25,7 +25,7 @@ import {
 } from "./render-chain-graph.ts";
 import { modelThinkingBadge, widgetStepGlyph, widgetStepStatus } from "./render-event-formatting.ts";
 
-export function renderSingleCompact(d: Details, r: Details["results"][number], theme: Theme, now?: number, spinnerNow?: number): Component {
+export function renderSingleCompact(d: Details, r: Details["results"][number], theme: Theme, now?: number, pulseFrame?: number): Component {
 	const output = r.truncation?.text || getSingleResultOutput(r);
 	const progress = r.progress || r.progressSummary;
 	const isRunning = r.progress?.status === "running";
@@ -37,7 +37,7 @@ export function renderSingleCompact(d: Details, r: Details["results"][number], t
 	const c = new Container();
 	const width = getTermWidth() - 4;
 	const modelDisplay = modelThinkingBadge(theme, r.model, undefined, r.fastMode);
-	c.addChild(new Text(truncLine(`${resultGlyph(r, output, theme, isRunning, progressRunningSeed(r.progress ?? r.progressSummary), spinnerNow ?? now)} ${theme.fg("toolTitle", theme.bold(r.agent))}${modelDisplay}${contextBadge}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`, width), 0, 0));
+	c.addChild(new Text(truncLine(`${resultGlyph(r, output, theme, isRunning, pulseFrame)} ${theme.fg("toolTitle", theme.bold(r.agent))}${modelDisplay}${contextBadge}${stats ? ` ${theme.fg("dim", "·")} ${stats}` : ""}`, width), 0, 0));
 
 	if (isRunning && r.progress) {
 		const progressSnapshotNow = snapshotNowForProgress(r.progress, now);
@@ -61,7 +61,7 @@ export function renderSingleCompact(d: Details, r: Details["results"][number], t
 	return c;
 }
 
-export function renderMultiCompact(d: Details, theme: Theme, now?: number, spinnerNow?: number): Component {
+export function renderMultiCompact(d: Details, theme: Theme, now?: number, pulseFrame?: number): Component {
 	const hasRunning = d.progress?.some((p) => p.status === "running")
 		|| d.results.some((r) => r.progress?.status === "running")
 		|| workflowGraphHasStatus(d, ["running"]);
@@ -87,7 +87,7 @@ export function renderMultiCompact(d: Details, theme: Theme, now?: number, spinn
 	const itemTitle = multiLabel.itemTitle;
 	const stats = statJoin(theme, [multiLabel.headerLabel, formatProgressStats(theme, totalSummary, true, now)]);
 	const glyph = hasRunning
-		? theme.fg("accent", runningGlyph(runningSeed(progressRunningSeed(totalSummary), d.currentStepIndex), spinnerNow ?? now))
+		? theme.fg("accent", pulseGlyph(pulseFrame))
 		: failed
 			? theme.fg("error", "✗")
 			: paused
@@ -133,7 +133,7 @@ export function renderMultiCompact(d: Details, theme: Theme, now?: number, spinn
 		const rPending = rProg && "status" in rProg && rProg.status === "pending";
 		const stepNumber = r.progress?.index !== undefined ? r.progress.index + 1 : progressFromArray?.index !== undefined ? progressFromArray.index + 1 : i + 1;
 		const stepStats = formatProgressStats(theme, rProg, true, now);
-		const glyph = rPending ? theme.fg("dim", "◦") : resultGlyph(r, output, theme, rRunning, progressRunningSeed(rProg), spinnerNow ?? now);
+		const glyph = rPending ? theme.fg("dim", "◦") : resultGlyph(r, output, theme, rRunning, pulseFrame);
 		const pendingLabel = rPending ? ` ${theme.fg("dim", "· pending")}` : "";
 		const stepLabel = resultRowLabel(d, multiLabel, i, stepNumber);
 		const line = `${glyph} ${stepLabel}: ${themeBold(theme, agentName)}${stepStats ? ` ${theme.fg("dim", "·")} ${stepStats}` : ""}${pendingLabel}`;

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

@@ -5,10 +5,10 @@ import type { AgentProgress, AsyncJobStep, Details } from "../shared/types.ts";
 import { formatDuration, formatTokens, formatUsage, shortenPath } from "../shared/formatters.ts";
 import { getSingleResultOutput } from "../shared/utils.ts";
 import { getTermWidth, truncLine, type Theme } from "./render-layout.ts";
-import { clearResultAnimationTimer, ensureResultAnimation, type ResultAnimationContext } from "./render-result-animation.ts";
+import { advanceResultPulseFrame, clearResultAnimationTimer, type ResultAnimationContext } from "./render-result-animation.ts";
 import { renderMultiCompact, renderSingleCompact } from "./render-result-compact.ts";
 import { buildChainRenderEntries, buildMultiProgressLabel, resultRowLabel, workflowGraphHasStatus, type ChainRenderEntry } from "./render-chain-graph.ts";
-import { isRunningSubagentResult, subagentResultRenderKey } from "./render-stable-output.ts";
+import { subagentResultRenderKey } from "./render-stable-output.ts";
 import { modelThinkingBadge, widgetStepStatus } from "./render-event-formatting.ts";
 import {
 	buildLiveStatusLine,
@@ -28,26 +28,27 @@ export function renderLiveSubagentResult(
 ): Component {
 	const nextKey = subagentResultRenderKey(result, options);
 	if (context.state.subagentResultSnapshotKey !== nextKey) {
-		const frameNow = Date.now();
 		context.state.subagentResultSnapshotKey = nextKey;
-		context.state.subagentResultSnapshotNow = frameNow;
-		context.state.subagentResultSpinnerFrameNow = frameNow;
+		context.state.subagentResultSnapshotNow = Date.now();
+		// Advance the activity pulse exactly once per real progress update.
+		// Foreground subagent results render into chat scrollback, which can sit
+		// above the viewport fold. Animating on a timer there forces pi-tui into a
+		// destructive full-screen/scrollback clear on every tick (the flicker that
+		// scaled with widget height). Driving the pulse off genuine updates keeps
+		// the only line diffs tied to content that actually changed, so the
+		// differential renderer repaints exactly as it would for any progress
+		// update — no extra above-fold churn between updates.
+		context.state.subagentResultPulseFrame = advanceResultPulseFrame(context.state.subagentResultPulseFrame);
 	}
 	context.state.subagentResultSnapshotNow ??= Date.now();
-	context.state.subagentResultSpinnerFrameNow ??= context.state.subagentResultSnapshotNow;
-	// Foreground subagent results render inside chat scrollback. Keep semantic
-	// content time stable between tool/progress updates, but let the spinner tick
-	// independently. That limits timer-driven diffs to spinner glyph cells instead
-	// of updating elapsed/tool/activity text and causing broad chatbox churn.
-	if (options.isPartial && isRunningSubagentResult(result)) {
-		ensureResultAnimation(context);
-	} else {
-		clearResultAnimationTimer(context);
-	}
+	context.state.subagentResultPulseFrame ??= 0;
+	// Never schedule timer-driven re-renders for scrollback content; clear any
+	// stale timer a previous version may have installed for this render slot.
+	clearResultAnimationTimer(context);
 	return renderSubagentResult(result, {
 		...options,
 		now: context.state.subagentResultSnapshotNow,
-		spinnerNow: context.state.subagentResultSpinnerFrameNow,
+		pulseFrame: context.state.subagentResultPulseFrame,
 	}, theme);
 }
 
@@ -56,7 +57,7 @@ export function renderLiveSubagentResult(
  */
 export function renderSubagentResult(
 	result: AgentToolResult<Details>,
-	options: { expanded: boolean; now?: number; spinnerNow?: number },
+	options: { expanded: boolean; now?: number; pulseFrame?: number },
 	theme: Theme,
 ): Component {
 	const d = result.details;
@@ -72,7 +73,7 @@ export function renderSubagentResult(
 
 	if (d.mode === "single" && d.results.length === 1) {
 		const r = d.results[0];
-		if (!expanded) return renderSingleCompact(d, r, theme, options.now, options.spinnerNow);
+		if (!expanded) return renderSingleCompact(d, r, theme, options.now, options.pulseFrame);
 		const isRunning = r.progress?.status === "running";
 		const icon = isRunning
 			? theme.fg("warning", "running")
@@ -166,7 +167,7 @@ export function renderSubagentResult(
 		return c;
 	}
 
-	if (!expanded) return renderMultiCompact(d, theme, options.now, options.spinnerNow);
+	if (!expanded) return renderMultiCompact(d, theme, options.now, options.pulseFrame);
 
 	const hasRunning = d.progress?.some((p) => p.status === "running")
 		|| d.results.some((r) => r.progress?.status === "running")

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

@@ -2,7 +2,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 { getTermWidth, progressRunningSeed, runningGlyph, type Theme } from "./render-layout.ts";
+import { getTermWidth, pulseGlyph, type Theme } from "./render-layout.ts";
 
 export function extractOutputTarget(task: string): string | undefined {
 	const writeToMatch = task.match(/\[Write to:\s*([^\]\n]+)\]/i);
@@ -118,8 +118,8 @@ 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", seed = progressRunningSeed(result.progress ?? result.progressSummary), now?: number): string {
-	if (running) return theme.fg("accent", runningGlyph(seed, now));
+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", "■");
 	if (result.exitCode !== 0) return theme.fg("error", "✗");

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

@@ -1,5 +1,6 @@
 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 { themeBold } from "./render-status-progress.ts";
@@ -64,6 +65,7 @@ let latestWidgetJobs: AsyncJobState[] = [];
 let latestWidgetFrameNow = 0;
 let widgetTimer: ReturnType<typeof setInterval> | undefined;
 let mountedWidgetCtx: ExtensionContext | undefined;
+let mountedWidgetOwnerKey: string | undefined;
 let widgetMounted = false;
 
 function getLatestWidgetJobs(): AsyncJobState[] {
@@ -87,9 +89,38 @@ function clearLatestWidgetState(): void {
 	latestWidgetJobs = [];
 	latestWidgetFrameNow = 0;
 	mountedWidgetCtx = undefined;
+	mountedWidgetOwnerKey = undefined;
 	widgetMounted = false;
 }
 
+function getWidgetOwnerKey(ctx: ExtensionContext): string {
+	const resolvedCwd = ctx.cwd ? path.resolve(ctx.cwd) : undefined;
+	const cwdOwner = resolvedCwd ?? "cwd:unknown";
+	let sessionOwner = "session:unknown";
+	try {
+		const sessionFile = ctx.sessionManager.getSessionFile?.();
+		if (sessionFile) {
+			const resolvedSessionFile = resolvedCwd
+				? path.resolve(resolvedCwd, sessionFile)
+				: path.resolve(sessionFile);
+			sessionOwner = `sessionFile:${resolvedSessionFile}`;
+		}
+	} catch {
+		// Fall through to the session id fallback below.
+	}
+	if (sessionOwner === "session:unknown") {
+		try {
+			const sessionId = ctx.sessionManager.getSessionId?.();
+			if (sessionId) sessionOwner = `sessionId:${sessionId}`;
+		} catch {
+			// Keep the unknown marker; cwd still scopes ownership.
+		}
+	}
+	// If no session identifier is available, cwd is the best available owner
+	// boundary and may intentionally coalesce concurrent sessions in one folder.
+	return `${sessionOwner}|cwd:${cwdOwner}`;
+}
+
 function requestWidgetRender(ctx: ExtensionContext): void {
 	(ctx as RenderRequestingContext).ui.requestRender?.();
 }
@@ -226,10 +257,12 @@ export function buildWidgetLines(jobs: AsyncJobState[], theme: Theme, width = ge
  * Render the async jobs widget
  */
 export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[]): void {
+	const ownerKey = getWidgetOwnerKey(ctx);
 	if (jobs.length === 0) {
-		if (widgetMounted && mountedWidgetCtx !== ctx) {
-			// Empty updates from stale contexts must not clear the active context's
-			// widget. The mounted context owns the eventual teardown.
+		if (widgetMounted && mountedWidgetOwnerKey !== ownerKey) {
+			// With no visible job frame, stale-owner empty updates and newly-active
+			// empty owners are indistinguishable here. Preserve active-widget safety;
+			// host session disposal owns cross-owner empty-session teardown.
 			return;
 		}
 		stopWidgetAnimation();
@@ -242,11 +275,12 @@ export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[]): void
 	latestWidgetCtx = ctx;
 	latestWidgetJobs = [...jobs];
 	latestWidgetFrameNow = Date.now();
-	if (widgetMounted && mountedWidgetCtx !== ctx) {
-		// Context rebinding can leave the previous host UI alive briefly; clear the
-		// old mount before installing the singleton widget on the new context.
+	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.
 		unmountWidgetBestEffort(mountedWidgetCtx);
 		mountedWidgetCtx = undefined;
+		mountedWidgetOwnerKey = undefined;
 		widgetMounted = false;
 	}
 	if (!widgetMounted) {
@@ -260,10 +294,15 @@ export function renderWidget(ctx: ExtensionContext, jobs: AsyncJobState[]): void
 			placement: "belowEditor",
 		});
 		mountedWidgetCtx = ctx;
+		mountedWidgetOwnerKey = ownerKey;
 		widgetMounted = true;
 	} else {
 		// The mounted widget reads latestWidgetJobs via getLatestWidgetJobs(), so a
-		// visible->visible update only needs to ask the host to render in place.
+		// visible->visible update only needs to ask the host to render in place. Keep
+		// teardown pointed at the freshest same-owner wrapper because older wrappers
+		// can go stale after host session/context rebinding.
+		mountedWidgetCtx = ctx;
+		mountedWidgetOwnerKey = ownerKey;
 		requestWidgetRender(ctx);
 	}
 	// Keep the just-rendered ctx/jobs as the last-rendered state; only the ticker

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

@@ -5,11 +5,11 @@
  * rendering responsibility across sibling modules.
  */
 
-export { RUNNING_ANIMATION_MS, currentRunningFrame } from "./render-layout.ts";
+export { PULSE_FRAMES, RUNNING_ANIMATION_MS, RUNNING_FRAMES, currentRunningFrame, pulseGlyph } from "./render-layout.ts";
 export {
+	advanceResultPulseFrame,
 	clearLegacyResultAnimationTimer,
 	clearResultAnimationTimer,
-	ensureResultAnimation,
 	stopResultAnimations,
 } from "./render-result-animation.ts";
 export type { SubagentResultRenderState } from "./render-result-animation.ts";