@selesai/code 0.3.0 → 0.3.1

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

@@ -17,6 +17,7 @@ import { readStatus } from "../../shared/utils.ts";
 import { normalizeParallelGroups } from "./parallel-groups.ts";
 import { reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.ts";
 import { hasLiveNestedDescendants, updateAsyncJobNestedProjection } from "../shared/nested-events.ts";
+import { listAsyncRuns, type AsyncRunSummary } from "./async-status.ts";
 
 interface AsyncJobTrackerOptions {
 	completionRetentionMs?: number;
@@ -35,6 +36,7 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 	handleStarted: (data: unknown) => void;
 	handleComplete: (data: unknown) => void;
 	resetJobs: (ctx?: ExtensionContext) => void;
+	restoreActiveJobs: (ctx?: ExtensionContext) => void;
 } {
 	const completionRetentionMs = options.completionRetentionMs ?? 10000;
 	const pollIntervalMs = options.pollIntervalMs ?? POLL_INTERVAL_MS;
@@ -43,6 +45,61 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 		renderWidget(ctx, jobs);
 		ctx.ui.requestRender?.();
 	};
+	const restoredControlEventCursor = (asyncDir: string) => {
+		try {
+			return fs.statSync(path.join(asyncDir, "events.jsonl")).size;
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code === "ENOENT") return 0;
+			throw error;
+		}
+	};
+	const summaryToJob = (run: AsyncRunSummary): AsyncJobState => {
+		const groups = normalizeParallelGroups(run.parallelGroups, run.steps.length, run.chainStepCount ?? run.steps.length);
+		const activeGroup = run.currentStep !== undefined
+			? groups.find((group) => run.currentStep! >= group.start && run.currentStep! < group.start + group.count)
+			: undefined;
+		const visibleSteps = activeGroup
+			? run.steps.slice(activeGroup.start, activeGroup.start + activeGroup.count).map((step, index) => ({ ...step, index: activeGroup.start + index }))
+			: run.steps.map((step, index) => ({ ...step, index }));
+		return {
+			asyncId: run.id,
+			asyncDir: run.asyncDir,
+			status: run.state,
+			sessionId: run.sessionId,
+			activityState: run.activityState,
+			lastActivityAt: run.lastActivityAt,
+			currentTool: run.currentTool,
+			currentToolStartedAt: run.currentToolStartedAt,
+			currentPath: run.currentPath,
+			turnCount: run.turnCount,
+			toolCount: run.toolCount,
+			mode: run.mode,
+			agents: visibleSteps.map((step) => step.agent),
+			currentStep: run.currentStep,
+			chainStepCount: run.chainStepCount,
+			parallelGroups: groups,
+			steps: visibleSteps,
+			stepsTotal: visibleSteps.length,
+			runningSteps: visibleSteps.filter((step) => step.status === "running").length,
+			completedSteps: visibleSteps.filter((step) => step.status === "complete" || step.status === "completed").length,
+			hasParallelGroups: groups.length > 0,
+			activeParallelGroup: Boolean(activeGroup),
+			startedAt: run.startedAt,
+			updatedAt: run.lastUpdate ?? run.startedAt,
+			timeoutMs: run.timeoutMs,
+			deadlineAt: run.deadlineAt,
+			timedOut: run.timedOut,
+			turnBudget: run.turnBudget,
+			turnBudgetExceeded: run.turnBudgetExceeded,
+			wrapUpRequested: run.wrapUpRequested,
+			sessionDir: run.sessionDir,
+			outputFile: run.outputFile,
+			totalTokens: run.totalTokens,
+			sessionFile: run.sessionFile,
+			controlEventCursor: restoredControlEventCursor(run.asyncDir),
+			nestedChildren: run.nestedChildren,
+		};
+	};
 	const cancelCleanup = (asyncId: string) => {
 		const existingTimer = state.cleanupTimers.get(asyncId);
 		if (!existingTimer) return;
@@ -248,6 +305,12 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 						job.sessionDir = status.sessionDir ?? job.sessionDir;
 						job.outputFile = status.outputFile ?? job.outputFile;
 						job.totalTokens = status.totalTokens ?? job.totalTokens;
+						job.timeoutMs = status.timeoutMs ?? job.timeoutMs;
+						job.deadlineAt = status.deadlineAt ?? job.deadlineAt;
+						job.timedOut = status.timedOut ?? job.timedOut;
+						job.turnBudget = status.turnBudget ?? job.turnBudget;
+						job.turnBudgetExceeded = status.turnBudgetExceeded ?? job.turnBudgetExceeded;
+						job.wrapUpRequested = status.wrapUpRequested ?? job.wrapUpRequested;
 						job.sessionFile = status.sessionFile ?? job.sessionFile;
 						if ((job.status === "complete" || job.status === "failed" || job.status === "paused") && !nestedRefreshFailed && !hasLiveNestedDescendants(job.nestedChildren) && (previousStatus !== job.status || !state.cleanupTimers.has(job.asyncId))) {
 							scheduleCleanup(job.asyncId);
@@ -280,6 +343,7 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 	const handleStarted = (data: unknown) => {
 		const info = data as AsyncStartedEvent;
 		if (!info.id) return;
+		if (typeof state.currentSessionId === "string" && info.sessionId !== state.currentSessionId) return;
 		const now = Date.now();
 		const asyncDir = info.asyncDir ?? path.join(asyncDirRoot, info.id);
 		const rawAgents = info.agents?.length ? info.agents : info.chain && info.chain.length > 0 ? info.chain : info.agent ? [info.agent] : undefined;
@@ -305,6 +369,9 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 			activeParallelGroup: Boolean(firstGroupCount && firstGroupCount > 0),
 			startedAt: now,
 			updatedAt: now,
+			timeoutMs: info.timeoutMs,
+			deadlineAt: info.deadlineAt,
+			turnBudget: info.turnBudget,
 			controlEventCursor: 0,
 		});
 		ensurePoller();
@@ -314,7 +381,8 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 	};
 
 	const handleComplete = (data: unknown) => {
-		const result = data as { id?: string; success?: boolean; asyncDir?: string };
+		const result = data as { id?: string; success?: boolean; asyncDir?: string; sessionId?: string };
+		if (typeof state.currentSessionId === "string" && result.sessionId !== state.currentSessionId) return;
 		const asyncId = result.id;
 		if (!asyncId) return;
 		const job = state.asyncJobs.get(asyncId);
@@ -351,5 +419,23 @@ export function createAsyncJobTracker(pi: Pick<ExtensionAPI, "events">, state: S
 		}
 	};
 
-	return { ensurePoller, handleStarted, handleComplete, resetJobs };
+	const restoreActiveJobs = (ctx?: ExtensionContext) => {
+		if (ctx?.hasUI) state.lastUiContext = ctx;
+		if (!state.currentSessionId) return;
+		let runs: AsyncRunSummary[];
+		try {
+			runs = listAsyncRuns(asyncDirRoot, { states: ["queued", "running"], sessionId: state.currentSessionId, resultsDir, kill: options.kill, now: options.now });
+		} catch (error) {
+			console.error(`Failed to restore active async jobs from '${asyncDirRoot}':`, error);
+			return;
+		}
+		for (const run of runs) {
+			state.asyncJobs.set(run.id, summaryToJob(run));
+		}
+		if (runs.length === 0) return;
+		ensurePoller();
+		if (state.lastUiContext?.hasUI) rerenderWidget(state.lastUiContext);
+	};
+
+	return { ensurePoller, handleStarted, handleComplete, resetJobs, restoreActiveJobs };
 }

package/dist/extensions/pi-subagents/src/runs/background/async-status.ts

@@ -2,9 +2,9 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { formatDuration, formatModelThinking, formatTokens, shortenPath } from "../../shared/formatters.ts";
 import { formatActivityLabel, formatParallelOutcome } from "../../shared/status-format.ts";
-import { type ActivityState, type AsyncJobStep, type AsyncParallelGroupStatus, type AsyncStatus, type NestedRunSummary, type SubagentRunMode, type TokenUsage } from "../../shared/types.ts";
+import { type ActivityState, type AsyncJobStep, type AsyncParallelGroupStatus, type AsyncStatus, type CostSummary, type NestedRunSummary, type SubagentRunMode, type TokenUsage, type TurnBudgetState } from "../../shared/types.ts";
 import { readStatus } from "../../shared/utils.ts";
-import { attachRootChildrenToSteps, findNestedRouteForRootId, projectNestedRegistryForRoot } from "../shared/nested-events.ts";
+import { attachRootChildrenToSteps, buildNestedRouteIndex, type NestedRoute, projectNestedEvents } from "../shared/nested-events.ts";
 import { formatNestedRunStatusLines } from "../shared/nested-render.ts";
 import { flatToLogicalStepIndex, normalizeParallelGroups } from "./parallel-groups.ts";
 import { reconcileAsyncRun, reconcileNestedAsyncDescendants } from "./stale-run-reconciler.ts";
@@ -27,13 +27,20 @@ interface AsyncRunStepSummary {
 	recentOutput?: string[];
 	turnCount?: number;
 	toolCount?: number;
+	steerCount?: number;
+	lastSteerAt?: number;
 	durationMs?: number;
 	tokens?: TokenUsage;
+	totalCost?: CostSummary;
 	skills?: string[];
 	model?: string;
 	thinking?: string;
 	attemptedModels?: string[];
 	error?: string;
+	timedOut?: boolean;
+	turnBudget?: TurnBudgetState;
+	turnBudgetExceeded?: boolean;
+	wrapUpRequested?: boolean;
 	children?: NestedRunSummary[];
 }
 
@@ -42,6 +49,7 @@ export interface AsyncRunSummary {
 	asyncDir: string;
 	sessionId?: string;
 	state: "queued" | "running" | "complete" | "failed" | "paused";
+	error?: string;
 	activityState?: ActivityState;
 	lastActivityAt?: number;
 	currentTool?: string;
@@ -49,11 +57,19 @@ export interface AsyncRunSummary {
 	currentPath?: string;
 	turnCount?: number;
 	toolCount?: number;
+	steerCount?: number;
+	lastSteerAt?: number;
 	mode: SubagentRunMode;
 	cwd?: string;
 	startedAt: number;
 	lastUpdate?: number;
 	endedAt?: number;
+	timeoutMs?: number;
+	deadlineAt?: number;
+	timedOut?: boolean;
+	turnBudget?: TurnBudgetState;
+	turnBudgetExceeded?: boolean;
+	wrapUpRequested?: boolean;
 	currentStep?: number;
 	chainStepCount?: number;
 	pendingAppends?: number;
@@ -62,6 +78,7 @@ export interface AsyncRunSummary {
 	sessionDir?: string;
 	outputFile?: string;
 	totalTokens?: TokenUsage;
+	totalCost?: CostSummary;
 	sessionFile?: string;
 	nestedChildren?: NestedRunSummary[];
 	nestedWarnings?: string[];
@@ -122,7 +139,7 @@ function deriveAsyncActivityState(asyncDir: string, status: AsyncStatus): { acti
 	};
 }
 
-function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string }, nestedWarnings: string[] = []): AsyncRunSummary {
+function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string }, nestedWarnings: string[] = [], nestedRoute?: NestedRoute): AsyncRunSummary {
 	if (status.sessionId !== undefined && typeof status.sessionId !== "string") {
 		throw new Error(`Invalid async status '${path.join(asyncDir, "status.json")}': sessionId must be a string.`);
 	}
@@ -131,9 +148,11 @@ function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string
 	const chainStepCount = status.chainStepCount ?? steps.length;
 	const parallelGroups = normalizeParallelGroups(status.parallelGroups, steps.length, chainStepCount);
 	let nestedChildren: NestedRunSummary[] = [];
-	if (nestedWarnings.length === 0) {
+	if (nestedWarnings.length === 0 && nestedRoute) {
 		try {
-			nestedChildren = projectNestedRegistryForRoot(status.runId || path.basename(asyncDir))?.children ?? [];
+			// The route is resolved by the caller via buildNestedRouteIndex, so this
+			// avoids a fresh scan of the nested-events directory per run.
+			nestedChildren = projectNestedEvents(nestedRoute)?.children ?? [];
 		} catch (error) {
 			nestedWarnings.push(`Nested status unavailable: ${getErrorMessage(error)}`);
 		}
@@ -159,13 +178,20 @@ function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string
 			...(step.recentOutput ? { recentOutput: [...step.recentOutput] } : {}),
 			...(step.turnCount !== undefined ? { turnCount: step.turnCount } : {}),
 			...(step.toolCount !== undefined ? { toolCount: step.toolCount } : {}),
+			...(step.steerCount !== undefined ? { steerCount: step.steerCount } : {}),
+			...(step.lastSteerAt !== undefined ? { lastSteerAt: step.lastSteerAt } : {}),
 			...(step.durationMs !== undefined ? { durationMs: step.durationMs } : {}),
 			...(step.tokens ? { tokens: step.tokens } : {}),
+			...(step.totalCost ? { totalCost: step.totalCost } : {}),
 			...(step.skills ? { skills: step.skills } : {}),
 			...(step.model ? { model: step.model } : {}),
 			...(step.thinking ? { thinking: step.thinking } : {}),
 			...(step.attemptedModels ? { attemptedModels: step.attemptedModels } : {}),
 			...(step.error ? { error: step.error } : {}),
+			...(step.timedOut !== undefined ? { timedOut: step.timedOut } : {}),
+			...(step.turnBudget ? { turnBudget: step.turnBudget } : {}),
+			...(step.turnBudgetExceeded !== undefined ? { turnBudgetExceeded: step.turnBudgetExceeded } : {}),
+			...(step.wrapUpRequested !== undefined ? { wrapUpRequested: step.wrapUpRequested } : {}),
 			...(step.children?.length ? { children: step.children } : {}),
 		};
 	});
@@ -175,6 +201,7 @@ function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string
 		asyncDir,
 		...(status.sessionId ? { sessionId: status.sessionId } : {}),
 		state: status.state,
+		...(status.error ? { error: status.error } : {}),
 		activityState,
 		lastActivityAt,
 		currentTool: status.currentTool,
@@ -182,11 +209,19 @@ function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string
 		currentPath: status.currentPath,
 		turnCount: status.turnCount,
 		toolCount: status.toolCount,
+		steerCount: status.steerCount,
+		lastSteerAt: status.lastSteerAt,
 		mode: status.mode,
 		cwd: status.cwd,
 		startedAt: status.startedAt,
 		lastUpdate: status.lastUpdate,
 		endedAt: status.endedAt,
+		...(status.timeoutMs !== undefined ? { timeoutMs: status.timeoutMs } : {}),
+		...(status.deadlineAt !== undefined ? { deadlineAt: status.deadlineAt } : {}),
+		...(status.timedOut !== undefined ? { timedOut: status.timedOut } : {}),
+		...(status.turnBudget ? { turnBudget: status.turnBudget } : {}),
+		...(status.turnBudgetExceeded !== undefined ? { turnBudgetExceeded: status.turnBudgetExceeded } : {}),
+		...(status.wrapUpRequested !== undefined ? { wrapUpRequested: status.wrapUpRequested } : {}),
 		currentStep: status.currentStep,
 		...(status.chainStepCount !== undefined ? { chainStepCount: status.chainStepCount } : {}),
 		...(status.pendingAppends !== undefined ? { pendingAppends: status.pendingAppends } : {}),
@@ -197,6 +232,7 @@ function statusToSummary(asyncDir: string, status: AsyncStatus & { cwd?: string
 		...(status.sessionDir ? { sessionDir: status.sessionDir } : {}),
 		...(status.outputFile ? { outputFile: status.outputFile } : {}),
 		...(status.totalTokens ? { totalTokens: status.totalTokens } : {}),
+		...(status.totalCost ? { totalCost: status.totalCost } : {}),
 		...(status.sessionFile ? { sessionFile: status.sessionFile } : {}),
 	};
 }
@@ -233,6 +269,16 @@ export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions
 
 	const allowedStates = options.states ? new Set(options.states) : undefined;
 	const runs: AsyncRunSummary[] = [];
+	// Route resolution for every run shares a single index built from the
+	// nested-events directory, so the per-run lookup is O(1) instead of scanning
+	// the directory once per run. The index is built lazily on first use, so
+	// load-time restoration (which only wants queued/running runs) skips it
+	// entirely when no active runs match.
+	let nestedRouteIndex: Map<string, NestedRoute> | undefined;
+	const resolveNestedRoute = (rootRunId: string): NestedRoute | undefined => {
+		if (!nestedRouteIndex) nestedRouteIndex = buildNestedRouteIndex();
+		return nestedRouteIndex.get(rootRunId);
+	};
 	for (const entry of entries) {
 		const asyncDir = path.join(asyncDirRoot, entry);
 		const reconciliation = options.reconcile === false
@@ -240,16 +286,21 @@ export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions
 			: reconcileAsyncRun(asyncDir, { resultsDir: options.resultsDir, kill: options.kill, now: options.now });
 		const status = (reconciliation?.status ?? readStatus(asyncDir)) as (AsyncStatus & { cwd?: string }) | null;
 		if (!status) continue;
+		// Filter before the nested-route lookup: the lookup builds an index over
+		// the nested-events directory, so deferring it for filtered-out runs keeps
+		// restoration at load from scanning that directory when no active runs
+		// match.
+		if (allowedStates && !allowedStates.has(status.state)) continue;
+		if (options.sessionId && status.sessionId !== options.sessionId) continue;
 		const nestedWarnings: string[] = [];
+		let nestedRoute: NestedRoute | undefined;
 		try {
-			const nestedRoute = findNestedRouteForRootId(status.runId || path.basename(asyncDir));
+			nestedRoute = resolveNestedRoute(status.runId || path.basename(asyncDir));
 			if (nestedRoute) reconcileNestedAsyncDescendants(nestedRoute, { resultsDir: options.resultsDir, kill: options.kill, now: options.now });
 		} catch (error) {
 			nestedWarnings.push(`Nested status unavailable: ${getErrorMessage(error)}`);
 		}
-		const summary = statusToSummary(asyncDir, status, nestedWarnings);
-		if (allowedStates && !allowedStates.has(summary.state)) continue;
-		if (options.sessionId && summary.sessionId !== options.sessionId) continue;
+		const summary = statusToSummary(asyncDir, status, nestedWarnings, nestedRoute);
 		runs.push(summary);
 	}
 
@@ -257,13 +308,18 @@ export function listAsyncRuns(asyncDirRoot: string, options: AsyncRunListOptions
 	return options.limit !== undefined ? sorted.slice(0, options.limit) : sorted;
 }
 
-function formatActivityFacts(input: { activityState?: ActivityState; lastActivityAt?: number; currentTool?: string; currentToolStartedAt?: number; currentPath?: string; turnCount?: number; toolCount?: number }): string | undefined {
+function formatActivityFacts(input: { activityState?: ActivityState; lastActivityAt?: number; currentTool?: string; currentToolStartedAt?: number; currentPath?: string; turnCount?: number; toolCount?: number; steerCount?: number; lastSteerAt?: number; turnBudget?: TurnBudgetState; turnBudgetExceeded?: boolean; wrapUpRequested?: boolean }): string | undefined {
 	const facts: string[] = [];
 	if (input.currentTool && input.currentToolStartedAt !== undefined) facts.push(`tool ${input.currentTool} ${formatDuration(Math.max(0, Date.now() - input.currentToolStartedAt))}`);
 	else if (input.currentTool) facts.push(`tool ${input.currentTool}`);
 	if (input.currentPath) facts.push(shortenPath(input.currentPath));
 	if (input.turnCount !== undefined) facts.push(`${input.turnCount} turns`);
+	if (input.turnBudgetExceeded && input.turnBudget) facts.push(`turn budget exceeded ${input.turnBudget.turnCount}/${input.turnBudget.maxTurns}+${input.turnBudget.graceTurns}`);
+	else if (input.wrapUpRequested && input.turnBudget) facts.push(`wrap-up requested ${input.turnBudget.turnCount}/${input.turnBudget.maxTurns}`);
+	else if (input.turnBudget) facts.push(`turn budget ${input.turnBudget.turnCount}/${input.turnBudget.maxTurns}+${input.turnBudget.graceTurns}`);
 	if (input.toolCount !== undefined) facts.push(`${input.toolCount} tools`);
+	if (input.steerCount !== undefined) facts.push(`${input.steerCount} steers`);
+	if (typeof input.lastSteerAt === "number" && Number.isFinite(input.lastSteerAt)) facts.push(`last steer ${new Date(input.lastSteerAt).toISOString()}`);
 	const activity = formatActivityLabel(input.lastActivityAt, input.activityState);
 	return activity || facts.length ? [activity, ...facts].filter(Boolean).join(" | ") : undefined;
 }
@@ -328,6 +384,7 @@ export function formatAsyncRunList(runs: AsyncRunSummary[], heading = "Active as
 		const attached = new Set(run.steps.flatMap((step) => step.children?.map((child) => child.id) ?? []));
 		const unattached = run.nestedChildren?.filter((child) => !attached.has(child.id)) ?? [];
 		lines.push(...formatNestedRunStatusLines(unattached, { indent: "  ", maxLines: 12 }));
+		if (run.error) lines.push(`  Error: ${run.error}`);
 		for (const warning of run.nestedWarnings ?? []) lines.push(`  Warning: ${warning}`);
 		const outputPath = formatAsyncRunOutputPath(run);
 		if (outputPath) lines.push(`  output: ${shortenPath(outputPath)}`);

package/dist/extensions/pi-subagents/src/runs/background/chain-root-attachment.ts

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import type { AcceptanceLedger, AsyncStatus, ModelAttempt } from "../../shared/types.ts";
+import type { AcceptanceLedger, AsyncStatus, CostSummary, ModelAttempt } from "../../shared/types.ts";
 import { readStatus } from "../../shared/utils.ts";
 
 export interface ImportedAsyncRoot {
@@ -21,26 +21,32 @@ export interface ImportedAsyncRootResult {
 	model?: string;
 	attemptedModels?: string[];
 	modelAttempts?: ModelAttempt[];
+	totalCost?: CostSummary;
 	structuredOutput?: unknown;
 	structuredOutputPath?: string;
 	structuredOutputSchemaPath?: string;
 	acceptance?: AcceptanceLedger;
+	timedOut?: boolean;
 }
 
 interface AsyncResultFile {
 	state?: string;
 	success?: boolean;
 	summary?: string;
+	error?: string;
+	timedOut?: boolean;
 	results?: Array<{
 		agent?: string;
 		output?: string;
 		error?: string;
 		success?: boolean;
+		timedOut?: boolean;
 		sessionFile?: string;
 		intercomTarget?: string;
 		model?: string;
 		attemptedModels?: string[];
 		modelAttempts?: ModelAttempt[];
+		totalCost?: CostSummary;
 		structuredOutput?: unknown;
 		structuredOutputPath?: string;
 		structuredOutputSchemaPath?: string;
@@ -85,6 +91,7 @@ function resultState(result: AsyncResultFile | undefined, child: NonNullable<Asy
 
 function outputFromTerminalStatus(root: ImportedAsyncRoot, status: AsyncStatus, step: NonNullable<AsyncStatus["steps"]>[number] | undefined): ImportedAsyncRootResult {
 	const agent = step?.agent ?? status.steps?.[root.index]?.agent ?? "subagent";
+	const timedOut = step?.timedOut === true || status.timedOut === true;
 	const message = step?.error ?? status.error ?? `Attached async root ${root.runId} ended without a result file at ${root.resultPath}.`;
 	return {
 		agent,
@@ -92,10 +99,12 @@ function outputFromTerminalStatus(root: ImportedAsyncRoot, status: AsyncStatus,
 		success: false,
 		exitCode: 1,
 		error: message,
+		...(timedOut ? { timedOut: true } : {}),
 		...(step?.sessionFile ?? status.sessionFile ? { sessionFile: step?.sessionFile ?? status.sessionFile } : {}),
 		...(step?.model ? { model: step.model } : {}),
 		...(step?.attemptedModels ? { attemptedModels: step.attemptedModels } : {}),
 		...(step?.modelAttempts ? { modelAttempts: step.modelAttempts } : {}),
+		...(step?.totalCost ? { totalCost: step.totalCost } : {}),
 		...(step?.structuredOutput !== undefined ? { structuredOutput: step.structuredOutput } : {}),
 		...(step?.structuredOutputPath ? { structuredOutputPath: step.structuredOutputPath } : {}),
 		...(step?.structuredOutputSchemaPath ? { structuredOutputSchemaPath: step.structuredOutputSchemaPath } : {}),
@@ -103,25 +112,45 @@ function outputFromTerminalStatus(root: ImportedAsyncRoot, status: AsyncStatus,
 	};
 }
 
+function outputFromTimeout(root: ImportedAsyncRoot, status: AsyncStatus | null, message: string): ImportedAsyncRootResult {
+	const step = selectedStatusStep(status, root.index);
+	return {
+		agent: step?.agent ?? status?.steps?.[root.index]?.agent ?? "subagent",
+		output: message,
+		success: false,
+		exitCode: 1,
+		error: message,
+		timedOut: true,
+		...(step?.sessionFile ?? status?.sessionFile ? { sessionFile: step?.sessionFile ?? status?.sessionFile } : {}),
+		...(step?.model ? { model: step.model } : {}),
+		...(step?.attemptedModels ? { attemptedModels: step.attemptedModels } : {}),
+		...(step?.modelAttempts ? { modelAttempts: step.modelAttempts } : {}),
+		...(step?.totalCost ? { totalCost: step.totalCost } : {}),
+	};
+}
+
 function buildImportedResult(root: ImportedAsyncRoot, status: AsyncStatus | null, result: AsyncResultFile): ImportedAsyncRootResult {
 	const child = result.results?.[root.index];
 	const step = selectedStatusStep(status, root.index);
 	const state = resultState(result, child);
 	const agent = child?.agent ?? step?.agent ?? status?.steps?.[root.index]?.agent ?? "subagent";
 	const output = child?.output ?? result.summary ?? "";
-	const success = state === "complete";
-	const error = child?.error ?? (success ? undefined : result.summary ?? status?.error ?? `Attached async root ${root.runId} did not complete successfully.`);
+	const timedOut = child?.timedOut === true || step?.timedOut === true || result.timedOut === true || status?.timedOut === true;
+	const success = state === "complete" && !timedOut;
+	const error = child?.error ?? (success ? undefined : result.error ?? result.summary ?? status?.error ?? `Attached async root ${root.runId} did not complete successfully.`);
 	return {
 		agent,
 		output: success ? output : (output || error || ""),
 		success,
 		exitCode: success ? 0 : 1,
 		...(error ? { error } : {}),
+		...(timedOut ? { timedOut: true } : {}),
 		...(child?.sessionFile ?? step?.sessionFile ?? status?.sessionFile ? { sessionFile: child?.sessionFile ?? step?.sessionFile ?? status?.sessionFile } : {}),
 		...(child?.intercomTarget ? { intercomTarget: child.intercomTarget } : {}),
 		...(child?.model ?? step?.model ? { model: child?.model ?? step?.model } : {}),
 		...(child?.attemptedModels ?? step?.attemptedModels ? { attemptedModels: child?.attemptedModels ?? step?.attemptedModels } : {}),
 		...(child?.modelAttempts ?? step?.modelAttempts ? { modelAttempts: child?.modelAttempts ?? step?.modelAttempts } : {}),
+		...(child?.totalCost ?? step?.totalCost ? { totalCost: child?.totalCost ?? step?.totalCost } : {}),
 		...(child?.structuredOutput !== undefined ? { structuredOutput: child.structuredOutput } : step?.structuredOutput !== undefined ? { structuredOutput: step.structuredOutput } : {}),
 		...(child?.structuredOutputPath ?? step?.structuredOutputPath ? { structuredOutputPath: child?.structuredOutputPath ?? step?.structuredOutputPath } : {}),
 		...(child?.structuredOutputSchemaPath ?? step?.structuredOutputSchemaPath ? { structuredOutputSchemaPath: child?.structuredOutputSchemaPath ?? step?.structuredOutputSchemaPath } : {}),
@@ -131,7 +160,7 @@ function buildImportedResult(root: ImportedAsyncRoot, status: AsyncStatus | null
 
 export async function waitForImportedAsyncRoot(
 	root: ImportedAsyncRoot,
-	options: { pollIntervalMs?: number; terminalResultGraceMs?: number; now?: () => number } = {},
+	options: { pollIntervalMs?: number; terminalResultGraceMs?: number; now?: () => number; shouldAbort?: () => boolean; timeoutMessage?: string } = {},
 ): Promise<ImportedAsyncRootResult> {
 	const pollIntervalMs = options.pollIntervalMs ?? 500;
 	const terminalResultGraceMs = options.terminalResultGraceMs ?? 1_000;
@@ -139,6 +168,7 @@ export async function waitForImportedAsyncRoot(
 	let terminalSince: number | undefined;
 	for (;;) {
 		const status = readStatus(root.asyncDir);
+		if (options.shouldAbort?.()) return outputFromTimeout(root, status, options.timeoutMessage ?? "Subagent timed out.");
 		const result = readResultFile(root.resultPath);
 		if (result) return buildImportedResult(root, status, result);
 		if (isTerminalStatus(status, root.index)) {

package/dist/extensions/pi-subagents/src/runs/background/completion-batcher.ts

@@ -0,0 +1,166 @@
+/**
+ * Smart completion batching with straggler handling.
+ *
+ * Holds successful async-completion notifications briefly so sibling jobs that
+ * finish within a short window arrive as a single grouped message. A hard
+ * max-wait cap (measured from the first item in a group) prevents holding
+ * notifications indefinitely. After a group is emitted, late-finishing
+ * siblings that arrive within the straggler window join a shorter "straggler"
+ * group with reduced debounce and max-wait timers.
+ *
+ * Failure and attention signals bypass this batcher entirely. Callers must
+ * flush() held items and emit those signals immediately so failures and
+ * needs-attention notices are never delayed.
+ */
+
+import type { CompletionBatchConfig } from "../../shared/types.ts";
+
+export type { CompletionBatchConfig };
+
+export interface ResolvedCompletionBatchConfig {
+	enabled: boolean;
+	debounceMs: number;
+	maxWaitMs: number;
+	stragglerDebounceMs: number;
+	stragglerMaxWaitMs: number;
+	stragglerWindowMs: number;
+}
+
+export const DEFAULT_COMPLETION_BATCH_CONFIG: ResolvedCompletionBatchConfig = {
+	enabled: true,
+	debounceMs: 150,
+	maxWaitMs: 1000,
+	stragglerDebounceMs: 75,
+	stragglerMaxWaitMs: 400,
+	stragglerWindowMs: 2000,
+};
+
+function parsePositiveInt(value: unknown): number | undefined {
+	if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value < 1) return undefined;
+	return value;
+}
+
+export function resolveCompletionBatchConfig(
+	globalConfig?: CompletionBatchConfig,
+	override?: CompletionBatchConfig,
+): ResolvedCompletionBatchConfig {
+	const enabled = typeof override?.enabled === "boolean"
+		? override.enabled
+		: typeof globalConfig?.enabled === "boolean"
+			? globalConfig.enabled
+			: DEFAULT_COMPLETION_BATCH_CONFIG.enabled;
+	return {
+		enabled,
+		debounceMs: parsePositiveInt(override?.debounceMs) ?? parsePositiveInt(globalConfig?.debounceMs) ?? DEFAULT_COMPLETION_BATCH_CONFIG.debounceMs,
+		maxWaitMs: parsePositiveInt(override?.maxWaitMs) ?? parsePositiveInt(globalConfig?.maxWaitMs) ?? DEFAULT_COMPLETION_BATCH_CONFIG.maxWaitMs,
+		stragglerDebounceMs: parsePositiveInt(override?.stragglerDebounceMs) ?? parsePositiveInt(globalConfig?.stragglerDebounceMs) ?? DEFAULT_COMPLETION_BATCH_CONFIG.stragglerDebounceMs,
+		stragglerMaxWaitMs: parsePositiveInt(override?.stragglerMaxWaitMs) ?? parsePositiveInt(globalConfig?.stragglerMaxWaitMs) ?? DEFAULT_COMPLETION_BATCH_CONFIG.stragglerMaxWaitMs,
+		stragglerWindowMs: parsePositiveInt(override?.stragglerWindowMs) ?? parsePositiveInt(globalConfig?.stragglerWindowMs) ?? DEFAULT_COMPLETION_BATCH_CONFIG.stragglerWindowMs,
+	};
+}
+
+type TimerHandle = unknown;
+
+interface TimerApi {
+	setTimeout(handler: () => void, delayMs: number): TimerHandle;
+	clearTimeout(handle: TimerHandle): void;
+}
+
+const defaultTimers: TimerApi = {
+	setTimeout: (handler, delayMs) => setTimeout(handler, delayMs),
+	clearTimeout: (handle) => clearTimeout(handle as ReturnType<typeof setTimeout>),
+};
+
+function unrefHandle(handle: TimerHandle): void {
+	if (handle && typeof handle === "object" && "unref" in handle && typeof (handle as { unref: unknown }).unref === "function") {
+		(handle as { unref: () => void }).unref();
+	}
+}
+
+export interface CompletionBatcherOptions<T> {
+	config: ResolvedCompletionBatchConfig;
+	emit: (items: T[]) => void;
+	timers?: TimerApi;
+	now?: () => number;
+}
+
+export interface CompletionBatcher<T> {
+	/** Add a batchable item. Emits immediately when batching is disabled. */
+	push(item: T): void;
+	/** Emit any held items immediately as a single group. */
+	flush(): void;
+	/** Clear timers without emitting. */
+	dispose(): void;
+}
+
+/**
+ * Create a completion batcher. The batcher is single-use per registration: it
+ * holds at most one open group. `flush` forces emission; `dispose` tears down
+ * timers for reload/shutdown without emitting.
+ */
+export function createCompletionBatcher<T>(options: CompletionBatcherOptions<T>): CompletionBatcher<T> {
+	const timers = options.timers ?? defaultTimers;
+	const now = options.now ?? Date.now;
+	const config = options.config;
+
+	if (!config.enabled) {
+		return {
+			push(item: T) {
+				options.emit([item]);
+			},
+			flush() {},
+			dispose() {},
+		};
+	}
+
+	let pending: T[] = [];
+	let debounceTimer: TimerHandle | null = null;
+	let maxWaitTimer: TimerHandle | null = null;
+	let straggler = false;
+	let lastEmitAt: number | null = null;
+
+	const clearTimers = () => {
+		if (debounceTimer) {
+			timers.clearTimeout(debounceTimer);
+			debounceTimer = null;
+		}
+		if (maxWaitTimer) {
+			timers.clearTimeout(maxWaitTimer);
+			maxWaitTimer = null;
+		}
+	};
+
+	const emitGroup = () => {
+		clearTimers();
+		if (pending.length === 0) return;
+		const items = pending;
+		pending = [];
+		lastEmitAt = now();
+		options.emit(items);
+	};
+
+	return {
+		push(item: T) {
+			if (pending.length === 0) {
+				straggler = lastEmitAt !== null && (now() - lastEmitAt) < config.stragglerWindowMs;
+			}
+			pending.push(item);
+
+			if (debounceTimer) timers.clearTimeout(debounceTimer);
+			const debounceDelay = straggler ? config.stragglerDebounceMs : config.debounceMs;
+			debounceTimer = timers.setTimeout(emitGroup, debounceDelay);
+			unrefHandle(debounceTimer);
+
+			if (!maxWaitTimer) {
+				const maxWaitDelay = straggler ? config.stragglerMaxWaitMs : config.maxWaitMs;
+				maxWaitTimer = timers.setTimeout(emitGroup, maxWaitDelay);
+				unrefHandle(maxWaitTimer);
+			}
+		},
+		flush: emitGroup,
+		dispose() {
+			clearTimers();
+			pending = [];
+		},
+	};
+}