pi-subagents 0.52.0 → 0.53.0

package/src/shared/settings.ts

@@ -282,7 +282,7 @@ export function resolveStepBehavior(
 		}
 	}
 
-	const outputMode = stepOverrides.outputMode ?? "inline";
+	const outputMode = stepOverrides.outputMode ?? agentConfig.outputMode ?? "inline";
 	const model = stepOverrides.model ?? agentConfig.model;
 	return { output, outputMode, reads, progress, skills, model };
 }
@@ -465,7 +465,7 @@ export function resolveParallelBehaviors(
 			}
 		}
 
-		const outputMode = task.outputMode ?? "inline";
+		const outputMode = task.outputMode ?? config.outputMode ?? "inline";
 		const model = task.model ?? config.model;
 		return { output, outputMode, reads, progress, skills, model };
 	});

package/src/shared/types.ts

@@ -71,6 +71,29 @@ export interface WorkflowGraphSnapshot {
 	currentNodeId?: string;
 }
 
+export type WorkflowReceiptState = "complete" | "failed" | "paused" | "stopped";
+
+type WorkflowReceiptEntryResumability =
+	| { latestRunId: string; resumability: { state: "resumable" } }
+	| { latestRunId?: string; resumability: { state: "not-resumable"; reason: string } };
+
+export type WorkflowReceiptEntry = WorkflowReceiptEntryResumability & {
+	key: string;
+	agent?: string;
+	requestedContext?: "fresh" | "fork";
+	resolvedContext?: "fresh" | "fork" | "mixed";
+	outputReference?: string;
+	continuation: { runIds: string[] };
+};
+
+export interface WorkflowReceipt {
+	version: 1;
+	workflowRunId: string;
+	state: WorkflowReceiptState;
+	createdAt: number;
+	entries: Record<string, WorkflowReceiptEntry>;
+}
+
 export interface SavedOutputReference {
 	path: string;
 	bytes: number;
@@ -161,6 +184,7 @@ export interface ControlConfig {
 export interface ResolvedControlConfig {
 	enabled: boolean;
 	needsAttentionAfterMs: number;
+	needsAttentionAfterMsIsExplicit?: boolean;
 	activeNoticeAfterMs: number;
 	activeNoticeAfterTurns?: number;
 	activeNoticeAfterTokens?: number;
@@ -529,6 +553,8 @@ export interface SteeringRecoveryDescriptor {
 	structuredOutputSchema?: JsonSchemaObject;
 	acceptance?: AcceptanceInput;
 	controlConfig?: ResolvedControlConfig;
+	/** Resolved launch context for this async child. */
+	context?: "fresh" | "fork";
 	/** Raw per-run bridge override. Omitted descriptors continue to use global config. */
 	intercomBridge?: IntercomBridgeConfig;
 	absoluteDeadlineAt?: number;
@@ -1099,6 +1125,8 @@ export interface Details {
 		}>;
 		emits: unknown[];
 		console: Array<{ level: "log" | "info" | "warn" | "error"; text: string }>;
+		/** Terminal keyed child receipt. Async workflows also persist it beside status.json. */
+		receipt?: WorkflowReceipt;
 	};
 	chatProgress?: {
 		mode: "off" | "live-card";
@@ -2026,6 +2054,13 @@ export interface ExtensionConfig {
 	/** Artifact cleanup retention. Set cleanupDays to 0 to disable cleanup. */
 	artifactConfig?: Pick<ArtifactConfig, "cleanupDays">;
 	intercomBridge?: IntercomBridgeConfig;
+	/** Control how slow result-index scans are logged. Defaults to \"all\".
+	 *  - \"all\": log every slow scan, including scans that find nothing.
+	 *  - \"activity\": log only slow scans that found or scheduled work. Silences
+	 *    the periodic healthy rescan that inspects zero files while no async runs
+	 *    are pending, which otherwise spams the session transcript.
+	 *  - \"off\": never log slow result-index scans. */
+	resultScanLogging?: "all" | "activity" | "off";
 	proactiveSkillSubagents?: ProactiveSkillSubagentsConfig | false;
 	scheduledRuns?: ScheduledRunsConfig;
 	/** Durable mission behavior. Missions are automatic by default; set enabled:false to disable auto-create. Explicit mission actions/fields still work. */

package/src/slash/slash-commands.ts

@@ -3,7 +3,8 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { keyText, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Key, matchesKey, truncateToWidth, type Component, type KeyId, type TUI } from "@earendil-works/pi-tui";
-import { BUILTIN_AGENT_NAMES, discoverAgents, findBlockingAgentDiagnostic, resolveAgentName } from "../agents/agents.ts";
+import { BUILTIN_AGENT_NAMES, discoverAgents, discoverAgentsAll, findBlockingAgentDiagnostic, resolveAgentName, type AgentConfig, type AgentDiscoveryDiagnostic, type AgentScope } from "../agents/agents.ts";
+import { listRuntimeAgentConfigs, mergeRuntimeAgents } from "../agents/runtime-agent-registry.ts";
 import { resolveExistingReadPaths } from "../shared/settings.ts";
 import {
 	DEFAULT_PROVIDER_MODELS_MAX_AGE_DAYS,
@@ -107,9 +108,22 @@ const extractExecutionFlags = (rawArgs: string): { args: string; bg: boolean; fo
 	return { args, bg, fork };
 };
 
-const makeAgentCompletions = (state: SubagentState) => (prefix: string) => {
+function discoverSlashAgents(pi: ExtensionAPI, cwd: string, scope: AgentScope): { agents: AgentConfig[]; agentDiagnostics?: AgentDiscoveryDiagnostic[] } {
+	const discovered = discoverAgents(cwd, scope);
+	if (listRuntimeAgentConfigs(pi).length === 0) return discovered;
+	const all = discoverAgentsAll(cwd);
+	const configuredAgents: AgentConfig[] = [
+		...all.builtin,
+		...all.package,
+		...(scope !== "project" ? all.user : []),
+		...(scope !== "user" ? all.project : []),
+	];
+	return mergeRuntimeAgents(pi, discovered, configuredAgents);
+}
+
+const makeAgentCompletions = (pi: ExtensionAPI, state: SubagentState) => (prefix: string) => {
 	if (!state.baseCwd || prefix.includes(" ")) return null;
-	return discoverAgents(state.baseCwd, "both").agents
+	return discoverSlashAgents(pi, state.baseCwd, "both").agents
 		.filter((agent) => agent.name.startsWith(prefix))
 		.map((agent) => ({ value: agent.name, label: agent.name }));
 };
@@ -662,7 +676,7 @@ export function registerSlashCommands(
 
 	pi.registerCommand("run", {
 		description: "Run one subagent through workflowScript: /run agent[output=file] [task] [--bg] [--fork]",
-		getArgumentCompletions: makeAgentCompletions(state),
+		getArgumentCompletions: makeAgentCompletions(pi, state),
 		handler: async (args, ctx) => {
 			const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
 			const input = cleanedArgs.trim();
@@ -672,7 +686,7 @@ export function registerSlashCommands(
 			const task = firstSpace === -1 ? "" : input.slice(firstSpace + 1).trim();
 
 			if (!state.baseCwd) { ctx.ui.notify("Subagent session cwd is not initialized yet", "error"); return; }
-			const discovered = discoverAgents(state.baseCwd, "both");
+			const discovered = discoverSlashAgents(pi, state.baseCwd, "both");
 			const resolvedAgent = resolveAgentName(agentName, discovered.agents);
 			const candidates = resolvedAgent.error
 				? discovered.agents.filter((agent) => resolveAgentName(agentName, [agent]).agent)
@@ -746,7 +760,7 @@ export function registerSlashCommands(
 
 	pi.registerCommand("subagents-refine", {
 		description: "Generate a bounded project-local refinement overlay for one subagent",
-		getArgumentCompletions: makeAgentCompletions(state),
+		getArgumentCompletions: makeAgentCompletions(pi, state),
 		handler: async (args, ctx) => {
 			const parts = args.trim().split(/\s+/).filter(Boolean);
 			if (parts.length !== 1) {

package/src/slash/slash-live-state.ts

@@ -82,7 +82,7 @@ function buildParallelInitialResult(params: SubagentParamsLike): AgentToolResult
 		details: {
 			mode: "parallel",
 			...(params.async ? { background: true } : {}),
-			...(params.context ? { context: params.context } : {}),
+			...(params.context === "fresh" || params.context === "fork" ? { context: params.context } : {}),
 			results: tasks.map((task, index) => createPlaceholderResult(task.agent, task.task, "running", index)),
 			progress: tasks.map((task, index) => ({
 				index,
@@ -138,7 +138,7 @@ function buildChainInitialResult(params: SubagentParamsLike): AgentToolResult<De
 		details: {
 			mode: "chain",
 			...(params.async ? { background: true } : {}),
-			...(params.context ? { context: params.context } : {}),
+			...(params.context === "fresh" || params.context === "fork" ? { context: params.context } : {}),
 			results,
 			progress: results.map((result, index) => ({
 				index,
@@ -167,7 +167,7 @@ function buildSingleInitialResult(params: SubagentParamsLike): AgentToolResult<D
 		details: {
 			mode: "single",
 			...(params.async ? { background: true } : {}),
-			...(params.context ? { context: params.context } : {}),
+			...(params.context === "fresh" || params.context === "fork" ? { context: params.context } : {}),
 			results: [createPlaceholderResult(agent, task, "running", 0)],
 			progress: [{
 				index: 0,

package/src/tui/fleet-status.ts

@@ -27,6 +27,17 @@ type FleetStatusEntry = {
 	state: string;
 	external?: true;
 	nestedChildren?: NestedRunSummary[];
+	workflowRows?: FleetWorkflowRow[];
+};
+
+type FleetWorkflowRow = {
+	name: string;
+	state: AsyncJobStep["status"];
+	modelThinking?: string;
+	activity?: string;
+	startedAt?: number;
+	tokens?: number;
+	overflow?: number;
 };
 
 type FleetNestedRow = {
@@ -42,6 +53,7 @@ type FleetNestedRow = {
 type FleetTreeRow =
 	| { kind: "owner"; entry: FleetStatusEntry }
 	| { kind: "child"; entry: FleetStatusEntry; last: boolean }
+	| { kind: "workflow"; ownerKey: string; row: FleetWorkflowRow; last: boolean }
 	| { kind: "nested"; ownerKey: string; row: FleetNestedRow; last: boolean };
 
 export interface FleetStatusOptions {
@@ -92,6 +104,51 @@ function nestedActivity(node: NestedRunSummary | NestedStepSummary): string | un
 	return undefined;
 }
 
+function workflowStepActivity(step: AsyncJobStep): string | undefined {
+	if (step.currentTool) return `tool ${step.currentTool}`;
+	if (step.currentPath) return step.currentPath.split(/[\\/]/).at(-1);
+	if (step.activityState === "needs_attention") return "needs attention";
+	if (step.activityState === "active_long_running") return "long-running";
+	if (step.turnCount !== undefined) return `${step.turnCount} turns`;
+	if (step.toolCount !== undefined) return `${step.toolCount} tools`;
+	return undefined;
+}
+
+function workflowStepName(step: AsyncJobStep, index: number): string {
+	const key = step.workflowKey ?? `step ${index + 1}`;
+	const label = step.label && step.label !== key ? ` · ${step.label}` : "";
+	const phase = step.phase ? `${step.phase}: ` : "";
+	return `${phase}${key}${label} (${step.agent})`;
+}
+
+function workflowFleetRows(steps: AsyncJobStep[] | undefined): FleetWorkflowRow[] {
+	return (steps ?? []).map((step, index) => {
+		const modelThinking = formatModelThinking(step.model, step.thinking) || undefined;
+		const activity = workflowStepActivity(step);
+		return {
+			name: workflowStepName(step, index),
+			state: step.status,
+			...(modelThinking ? { modelThinking } : {}),
+			...(activity ? { activity } : {}),
+			...(step.startedAt !== undefined ? { startedAt: step.startedAt } : {}),
+			...(step.tokens?.total !== undefined ? { tokens: step.tokens.total } : {}),
+		};
+	});
+}
+
+function visibleWorkflowRows(rows: FleetWorkflowRow[] | undefined, visibleLimit: number): FleetWorkflowRow[] {
+	if (!rows?.length) return [];
+	if (rows.length <= visibleLimit) return rows;
+	const selected = new Set<number>();
+	for (const [index, row] of rows.entries()) {
+		if (row.state !== "complete" && row.state !== "completed") selected.add(index);
+		if (selected.size >= visibleLimit) break;
+	}
+	for (let index = rows.length - 1; index >= 0 && selected.size < visibleLimit; index--) selected.add(index);
+	const visible = [...selected].sort((left, right) => left - right).map((index) => rows[index]!);
+	return [{ name: `… +${rows.length - visible.length} hidden workflow steps`, state: "complete", overflow: rows.length - visible.length }, ...visible];
+}
+
 function nestedStatusGlyph(state: FleetNestedRow["state"], theme: Theme): string {
 	if (state === "running") return theme.fg("accent", "●");
 	if (state === "queued" || state === "pending") return theme.fg("muted", "◦");
@@ -194,9 +251,10 @@ function fleetTreeRows(entries: FleetStatusEntry[]): FleetTreeRow[] {
 		if (entry.parentKey && entryKeys.has(entry.parentKey)) continue;
 		rows.push({ kind: "owner", entry });
 		const attached = childrenByParent.get(entry.key) ?? [];
+		const workflowRows = visibleWorkflowRows(entry.workflowRows, attached.length > 0 ? 2 : 4);
 		for (const [index, child] of attached.entries()) {
 			const nested = nestedFleetRows(child.nestedChildren, 3);
-			const laterRows = index < attached.length - 1 || Boolean(entry.nestedChildren?.length);
+			const laterRows = index < attached.length - 1 || workflowRows.length > 0 || Boolean(entry.nestedChildren?.length);
 			rows.push({ kind: "child", entry: child, last: !laterRows && nested.length === 0 });
 			for (const [nestedIndex, row] of nested.entries()) rows.push({
 				kind: "nested",
@@ -205,6 +263,7 @@ function fleetTreeRows(entries: FleetStatusEntry[]): FleetTreeRow[] {
 				last: nestedIndex === nested.length - 1 && !laterRows,
 			});
 		}
+		for (const [index, row] of workflowRows.entries()) rows.push({ kind: "workflow", ownerKey: entry.key, row, last: index === workflowRows.length - 1 && !entry.nestedChildren?.length });
 		const nested = nestedFleetRows(entry.nestedChildren, attached.length > 0 ? 3 : 4);
 		for (const [index, row] of nested.entries()) rows.push({ kind: "nested", ownerKey: entry.key, row, last: index === nested.length - 1 });
 	}
@@ -282,6 +341,7 @@ export function collectFleetStatusEntries(state: SubagentState): FleetStatusEntr
 				startedAt,
 				tokens: job.totalTokens?.total ?? 0,
 				state: job.status,
+				...(job.steps?.length ? { workflowRows: workflowFleetRows(job.steps) } : {}),
 				...(job.nestedChildren?.length ? { nestedChildren: job.nestedChildren } : {}),
 			});
 			continue;
@@ -548,6 +608,8 @@ export class SubagentFleetStatus {
 			if (row.kind === "owner" || row.kind === "child") {
 				const ownerIndex = this.entries.findIndex((entry) => entry.key === row.entry.key);
 				lines.push(this.renderEntry(ownerIndex + 1, selectedIndex, row.entry, width, theme, row.kind === "child" ? (row.last ? "└─" : "├─") : undefined));
+			} else if (row.kind === "workflow") {
+				lines.push(this.renderWorkflowRow(row.row, row.last, width, theme));
 			} else {
 				lines.push(this.renderNestedRow(row.row, row.last, width, theme));
 			}
@@ -576,6 +638,20 @@ export class SubagentFleetStatus {
 		return truncateToWidth(`${left}${theme.fg("dim", elapsed)}`, width);
 	}
 
+	private renderWorkflowRow(row: FleetWorkflowRow, last: boolean, width: number, theme: Theme): string {
+		const marker = last ? "└─" : "├─";
+		const indent = "    ";
+		if (row.overflow !== undefined) return truncateToWidth(`${indent}${marker} ${theme.fg("dim", `+${row.overflow} hidden workflow steps`)}`, width);
+		const modelThinking = row.modelThinking ? ` (${row.modelThinking})` : "";
+		const activity = row.activity ? ` · ${row.activity}` : "";
+		const left = `${indent}${marker} ${nestedStatusGlyph(row.state, theme)} ${theme.fg("muted", `${row.name}${modelThinking}`)} · ${row.state}${activity}`;
+		const details = [
+			row.startedAt !== undefined ? formatFleetElapsed(Date.now() - row.startedAt) : undefined,
+			row.tokens !== undefined ? formatFleetTokens(row.tokens) : undefined,
+		].filter(Boolean).join(" · ");
+		return truncateToWidth(`${left}${details ? theme.fg("dim", ` · ${details}`) : ""}`, width);
+	}
+
 	private bullet(rosterIndex: number, selectedIndex: number, theme: Theme): string {
 		return rosterIndex === selectedIndex ? theme.fg("accent", ">") : " ";
 	}
@@ -624,6 +700,15 @@ export class SubagentFleetStatus {
 					entry.external,
 					Math.round((now - entry.startedAt) / 1000),
 					entry.tokens,
+					visibleWorkflowRows(entry.workflowRows, entry.parentKey ? 2 : 4).map((row) => [
+						row.name,
+						row.state,
+						row.modelThinking,
+						row.activity,
+						row.startedAt,
+						row.tokens,
+						row.overflow,
+					]),
 					nestedFleetRows(entry.nestedChildren, entry.parentKey ? 3 : 4).map((row) => [
 						row.name,
 						row.state,

package/src/tui/fleet.ts

@@ -6,7 +6,7 @@ import { matchesKey, truncateToWidth, visibleWidth, wrapTextWithAnsi, type Compo
 import { snapshotExternalRuns, type ExternalRun } from "../api/external-runs.ts";
 import { getArtifactPaths, getArtifactsDir } from "../shared/artifacts.ts";
 import { formatDuration, formatModelThinking, formatTokens, shortenPath } from "../shared/formatters.ts";
-import { DIRS, type AsyncJobState, type Details, type FleetKeybindingAction, type FleetKeybindingsConfig, type ForegroundChildControl, type ForegroundResumeChild, type ForegroundResumeRun, type ForegroundRunControl, type SubagentState } from "../shared/types.ts";
+import { DIRS, type AsyncJobState, type AsyncJobStep, type Details, type FleetKeybindingAction, type FleetKeybindingsConfig, type ForegroundChildControl, type ForegroundResumeChild, type ForegroundResumeRun, type ForegroundRunControl, type SubagentState } from "../shared/types.ts";
 import { decodeUtf8Tail } from "../shared/utf8.ts";
 import { readStatus } from "../shared/utils.ts";
 import { formatAsyncRunTranscript } from "../runs/background/fleet-view.ts";
@@ -494,15 +494,68 @@ function externalElapsedEnd(run: ExternalRun): number {
 	return terminal ? (run.endedAt ?? run.updatedAt ?? Date.now()) : Date.now();
 }
 
+function workflowStepLabel(step: AsyncJobStep, index: number): string {
+	const key = step.workflowKey ?? `step ${index + 1}`;
+	const label = step.label && step.label !== key ? ` · ${step.label}` : "";
+	const phase = step.phase ? `${step.phase}: ` : "";
+	return `${phase}${key}${label} (${step.agent})`;
+}
+
+function workflowStepActivity(step: AsyncJobStep): string | undefined {
+	if (step.currentTool) return `tool ${step.currentTool}`;
+	if (step.currentPath) return shortenPath(step.currentPath);
+	if (step.activityState === "needs_attention") return "needs attention";
+	if (step.activityState === "active_long_running") return "long-running";
+	if (step.turnCount !== undefined) return `${step.turnCount} turns`;
+	if (step.toolCount !== undefined) return `${step.toolCount} tools`;
+	return undefined;
+}
+
+function visibleWorkflowProgressSteps(steps: AsyncJobStep[], visibleLimit: number): Array<{ step: AsyncJobStep; index: number } | { hidden: number }> {
+	if (steps.length <= visibleLimit) return steps.map((step, index) => ({ step, index }));
+	const selected = new Set<number>();
+	for (const [index, step] of steps.entries()) {
+		if (step.status !== "complete" && step.status !== "completed") selected.add(index);
+		if (selected.size >= visibleLimit) break;
+	}
+	for (let index = steps.length - 1; index >= 0 && selected.size < visibleLimit; index--) selected.add(index);
+	const visible = [...selected].sort((left, right) => left - right).map((index) => ({ step: steps[index]!, index }));
+	return [{ hidden: steps.length - visible.length }, ...visible];
+}
+
+function workflowProgressLines(steps: AsyncJobStep[] | undefined): string[] {
+	if (!steps?.length) return [];
+	const lines = ["Workflow progress:"];
+	for (const row of visibleWorkflowProgressSteps(steps, 8)) {
+		if ("hidden" in row) {
+			lines.push(`  +${row.hidden} hidden workflow steps`);
+			continue;
+		}
+		const activity = workflowStepActivity(row.step);
+		const context = contextModeLabel(row.step.context);
+		const details = [row.step.status, activity, context, row.step.tokens?.total !== undefined ? formatTokens(row.step.tokens.total) : undefined].filter(Boolean).join(" · ");
+		lines.push(`  ${row.index + 1}. ${workflowStepLabel(row.step, row.index)}${details ? ` — ${details}` : ""}`);
+	}
+	return lines;
+}
+
 function asyncDetail(item: Extract<FleetItem, { kind: "async" }>, state: SubagentState): string[] {
 	const status = readStatus(item.run.asyncDir);
 	if (status) {
 		const trackedJob = state.fleetJobs?.get(item.runId) ?? state.asyncJobs.get(item.runId);
-		return formatAsyncRunTranscript(status, item.run.asyncDir, {
+		const lines = formatAsyncRunTranscript(status, item.run.asyncDir, {
 			index: item.index,
 			lines: TRANSCRIPT_LINES,
 			sessionRoots: uniquePaths([...(state.trustedSessionRoots ?? []), trackedJob?.sessionRoot]),
 		}).split("\n");
+		if (status.mode === "workflow" && item.index === undefined) {
+			const progress = workflowProgressLines((status.steps ?? item.run.steps) as AsyncJobStep[]);
+			if (progress.length) {
+				const modeIndex = lines.findIndex((line) => line.startsWith("Mode:"));
+				lines.splice(modeIndex >= 0 ? modeIndex + 1 : 0, 0, "", ...progress);
+			}
+		}
+		return lines;
 	}
 	const outputPath = item.index !== undefined ? path.join(item.run.asyncDir, `output-${item.index}.log`) : undefined;
 	return [

package/src/tui/render.ts

@@ -3,6 +3,7 @@
  */
 
 import * as path from "node:path";
+import { createHash } from "node:crypto";
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import { getMarkdownTheme, keyText, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { Container, Markdown, Spacer, Text, visibleWidth, type Component } from "@earendil-works/pi-tui";
@@ -535,7 +536,76 @@ function compactCurrentActivity(progress: AgentProgress): string {
 	return formatCurrentToolLine(progress, getTermWidth() - 4, false, snapshotNow) ?? buildLiveStatusLine(progress, snapshotNow) ?? "thinking…";
 }
 
-export function widgetRenderKey(job: AsyncJobState): string {
+function textDigest(text: string): string {
+	return createHash("sha256").update(text).digest("hex").slice(0, 16);
+}
+
+function displayTextRenderKey(text: string): unknown[] {
+	const normalized = sanitizeDisplayText(text);
+	return [normalized.length, textDigest(normalized)];
+}
+
+function expandedStepActivityRenderKey(step: AsyncJobStep): unknown[] {
+	return [
+		step.recentTools?.slice(-3).map((tool) => [tool.tool, displayTextRenderKey(tool.args), tool.endMs]),
+		compactRecentOutputLines(step.recentOutput).map(displayTextRenderKey),
+	];
+}
+
+function widgetStepRenderKey(step: AsyncJobStep, index: number, expanded = false): unknown[] {
+	return [
+		step.index ?? index,
+		step.agent,
+		step.workflowKey,
+		step.phase,
+		step.label,
+		step.status,
+		step.activityState,
+		step.lastActivityAt,
+		step.currentTool,
+		step.currentToolArgs,
+		step.currentToolStartedAt,
+		step.currentPath,
+		step.turnCount,
+		step.toolCount,
+		step.startedAt,
+		step.endedAt,
+		step.durationMs,
+		step.tokens?.total,
+		step.model,
+		step.thinking,
+		step.context,
+		step.error,
+		expanded ? expandedStepActivityRenderKey(step) : undefined,
+		nestedRenderKey(step.children, expanded),
+	];
+}
+
+function nestedRenderKey(children: NestedRunSummary[] | undefined, expanded = false): unknown[] {
+	return (children ?? []).map((child) => [
+		child.id,
+		child.state,
+		child.agent,
+		child.model,
+		child.thinking,
+		child.activityState,
+		child.lastActivityAt,
+		child.currentTool,
+		child.currentToolStartedAt,
+		child.currentPath,
+		child.turnCount,
+		child.toolCount,
+		child.startedAt,
+		child.endedAt,
+		child.lastUpdate,
+		child.error,
+		child.totalTokens?.total,
+		child.steps?.map((step, index) => widgetStepRenderKey({ ...step, agent: step.agent, status: step.status }, index, expanded)),
+		nestedRenderKey(child.children, expanded),
+	]);
+}
+
+export function widgetRenderKey(job: AsyncJobState, expanded = false): string {
 	return JSON.stringify({
 		asyncDir: job.asyncDir,
 		status: job.status,
@@ -551,8 +621,8 @@ export function widgetRenderKey(job: AsyncJobState): string {
 		currentStep: job.currentStep,
 		chainStepCount: job.chainStepCount,
 		parallelGroups: job.parallelGroups,
-		steps: job.steps,
-		nestedChildren: job.nestedChildren,
+		steps: job.steps?.map((step, index) => widgetStepRenderKey(step, index, expanded)),
+		nestedChildren: nestedRenderKey(job.nestedChildren, expanded),
 		stepsTotal: job.stepsTotal,
 		runningSteps: job.runningSteps,
 		completedSteps: job.completedSteps,