@bastani/atomic 0.9.12 → 0.9.13-alpha.2

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

@@ -1,9 +1,28 @@
+import {
+	type BridgeRequestSettlement,
+	emitBridgeEvent,
+	readBridgeRequestSettlement,
+	registerBridgeRequestSettlement,
+	rejectStoppedBridgeRequest,
+} from "./bridge-settlement.ts";
 export const PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT = "prompt-template:subagent:request";
 export const PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT = "prompt-template:subagent:started";
 export const PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT = "prompt-template:subagent:response";
 export const PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT = "prompt-template:subagent:update";
 export const PROMPT_TEMPLATE_SUBAGENT_CANCEL_EVENT = "prompt-template:subagent:cancel";
 
+/**
+ * Register the rejection path for an out-of-tree prompt-template requester.
+ * The requester must unregister this hook when its response or cancellation
+ * path settles; the hook is used only when a stale bridge drops an emit.
+ */
+export function registerPromptTemplateBridgeRequestSettlement(
+	requestId: string,
+	reject: (error: unknown) => void,
+): () => void {
+	return registerBridgeRequestSettlement("prompt-template", requestId, { reject });
+}
+
 interface PromptTemplateDelegationTask {
 	agent: string;
 	task: string;
@@ -77,9 +96,9 @@ interface PromptTemplateBridgeResult {
 	details?: {
 		results?: Array<{
 			agent?: string;
+			status?: "ok" | "error" | "skipped" | "interrupted" | "continued";
 			messages?: unknown[];
 			finalOutput?: string;
-			exitCode?: number;
 			error?: string;
 			model?: string;
 			toolCalls?: Array<{ text?: string; expandedText?: string }>;
@@ -294,6 +313,7 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 	dispose: () => void;
 } {
 	const controllers = new Map<string, AbortController>();
+	const activeSettlements = new Map<string, BridgeRequestSettlement>();
 	const pendingCancels = new Set<string>();
 	const subscriptions: Array<() => void> = [];
 
@@ -317,6 +337,7 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 	subscribe(PROMPT_TEMPLATE_SUBAGENT_REQUEST_EVENT, async (data) => {
 		const request = parsePromptTemplateRequest(data);
 		if (!request) return;
+		const settlement = readBridgeRequestSettlement(data, "prompt-template");
 
 		const ctx = options.getContext();
 		if (!ctx) {
@@ -326,12 +347,13 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 				isError: true,
 				errorText: "No active extension context for delegated subagent execution.",
 			};
-			options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response);
+			emitBridgeEvent(options.events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response, settlement);
 			return;
 		}
 
 		const controller = new AbortController();
 		controllers.set(request.requestId, controller);
+		if (settlement) activeSettlements.set(request.requestId, settlement);
 
 		if (pendingCancels.delete(request.requestId)) {
 			controller.abort();
@@ -341,18 +363,33 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 				isError: true,
 				errorText: "Delegated prompt cancelled.",
 			};
-			options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response);
+			emitBridgeEvent(options.events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response, settlement);
 			controllers.delete(request.requestId);
+			activeSettlements.delete(request.requestId);
 			return;
 		}
 
-		options.events.emit(PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT, { requestId: request.requestId });
+		if (
+			!emitBridgeEvent(
+				options.events,
+				PROMPT_TEMPLATE_SUBAGENT_STARTED_EVENT,
+				{ requestId: request.requestId },
+				settlement,
+			)
+		) {
+			controller.abort();
+			controllers.delete(request.requestId);
+			activeSettlements.delete(request.requestId);
+			return;
+		}
 
 		try {
 			const result = await options.execute(request.requestId, request, controller.signal, ctx, (update) => {
 				const payload = toDelegationUpdate(request.requestId, update);
 				if (!payload) return;
-				options.events.emit(PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT, payload);
+				if (!emitBridgeEvent(options.events, PROMPT_TEMPLATE_SUBAGENT_UPDATE_EVENT, payload, settlement)) {
+					controller.abort();
+				}
 			});
 			const contentText = firstTextContent(result.content);
 			const messages = buildDelegationMessages(result.details?.results?.[0] ?? {}, contentText);
@@ -367,12 +404,11 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 								errorText: "Missing result for delegated parallel task.",
 							};
 						}
-						const exitCode = typeof step.exitCode === "number" ? step.exitCode : undefined;
 						const errorText = step.error;
 						return {
 							agent: step.agent ?? task.agent,
 							messages: buildDelegationMessages(step),
-							isError: (exitCode !== undefined && exitCode !== 0) || !!errorText,
+							isError: step.status === "error" || !!errorText,
 							errorText: errorText || undefined,
 						};
 					})
@@ -385,7 +421,7 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 				isError: result.isError === true,
 				errorText: result.isError ? contentText : undefined,
 			};
-			options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response);
+			emitBridgeEvent(options.events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response, settlement);
 		} catch (error) {
 			const response: PromptTemplateDelegationResponse = {
 				...request,
@@ -393,18 +429,21 @@ export function registerPromptTemplateDelegationBridge<Ctx extends { cwd?: strin
 				isError: true,
 				errorText: error instanceof Error ? error.message : String(error),
 			};
-			options.events.emit(PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response);
+			emitBridgeEvent(options.events, PROMPT_TEMPLATE_SUBAGENT_RESPONSE_EVENT, response, settlement);
 		} finally {
 			controllers.delete(request.requestId);
+			activeSettlements.delete(request.requestId);
 		}
 	});
 
 	return {
 		cancelAll: () => {
-			for (const controller of controllers.values()) {
+			for (const [requestId, controller] of controllers) {
+				rejectStoppedBridgeRequest(activeSettlements.get(requestId));
 				controller.abort();
 			}
 			controllers.clear();
+			activeSettlements.clear();
 			pendingCancels.clear();
 		},
 		dispose: () => {

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

@@ -9,6 +9,12 @@ import {
 	SLASH_SUBAGENT_STARTED_EVENT,
 	SLASH_SUBAGENT_UPDATE_EVENT,
 } from "../shared/types.ts";
+import {
+	type BridgeRequestSettlement,
+	emitBridgeEvent,
+	readBridgeRequestSettlement,
+	rejectStoppedBridgeRequest,
+} from "./bridge-settlement.ts";
 
 interface SlashSubagentRequest {
 	requestId: string;
@@ -51,6 +57,7 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 	dispose: () => void;
 } {
 	const controllers = new Map<string, AbortController>();
+	const activeSettlements = new Map<string, BridgeRequestSettlement>();
 	const pendingCancels = new Set<string>();
 	const subscriptions: Array<() => void> = [];
 
@@ -76,6 +83,7 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 		const request = data as Partial<SlashSubagentRequest>;
 		if (typeof request.requestId !== "string" || !request.params) return;
 		const { requestId, params } = request as SlashSubagentRequest;
+		const settlement = readBridgeRequestSettlement(data, "slash");
 
 		const ctx = options.getContext();
 		if (!ctx) {
@@ -88,12 +96,13 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 				isError: true,
 				errorText: "No active extension context.",
 			};
-			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, response);
+			emitBridgeEvent(options.events, SLASH_SUBAGENT_RESPONSE_EVENT, response, settlement);
 			return;
 		}
 
 		const controller = new AbortController();
 		controllers.set(requestId, controller);
+		if (settlement) activeSettlements.set(requestId, settlement);
 
 		if (pendingCancels.delete(requestId)) {
 			controller.abort();
@@ -106,12 +115,18 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 				isError: true,
 				errorText: "Cancelled before start.",
 			};
-			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, response);
+			emitBridgeEvent(options.events, SLASH_SUBAGENT_RESPONSE_EVENT, response, settlement);
 			controllers.delete(requestId);
+			activeSettlements.delete(requestId);
 			return;
 		}
 
-		options.events.emit(SLASH_SUBAGENT_STARTED_EVENT, { requestId });
+		if (!emitBridgeEvent(options.events, SLASH_SUBAGENT_STARTED_EVENT, { requestId }, settlement)) {
+			controller.abort();
+			controllers.delete(requestId);
+			activeSettlements.delete(requestId);
+			return;
+		}
 
 		try {
 			const result = await options.execute(
@@ -127,7 +142,9 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 						currentTool: first?.currentTool,
 						toolCount: first?.toolCount,
 					};
-					options.events.emit(SLASH_SUBAGENT_UPDATE_EVENT, payload);
+					if (!emitBridgeEvent(options.events, SLASH_SUBAGENT_UPDATE_EVENT, payload, settlement)) {
+						controller.abort();
+					}
 				},
 				ctx,
 			);
@@ -140,7 +157,7 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 					? result.content.find((c) => c.type === "text")?.text
 					: undefined,
 			};
-			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, response);
+			emitBridgeEvent(options.events, SLASH_SUBAGENT_RESPONSE_EVENT, response, settlement);
 		} catch (error) {
 			const response: SlashSubagentResponse = {
 				requestId,
@@ -151,18 +168,21 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 				isError: true,
 				errorText: error instanceof Error ? error.message : String(error),
 			};
-			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, response);
+			emitBridgeEvent(options.events, SLASH_SUBAGENT_RESPONSE_EVENT, response, settlement);
 		} finally {
 			controllers.delete(requestId);
+			activeSettlements.delete(requestId);
 		}
 	});
 
 	return {
 		cancelAll: () => {
-			for (const controller of controllers.values()) {
+			for (const [requestId, controller] of controllers) {
+				rejectStoppedBridgeRequest(activeSettlements.get(requestId));
 				controller.abort();
 			}
 			controllers.clear();
+			activeSettlements.clear();
 			pendingCancels.clear();
 		},
 		dispose: () => {

package/dist/builtin/subagents/src/slash/slash-commands.ts

@@ -1,9 +1,14 @@
 import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { type ExtensionAPI, type ExtensionContext, keyHintIfBound } from "@bastani/atomic";
+import {
+	type ExtensionAPI,
+	type ExtensionContext,
+	isStaleExtensionContextError,
+	keyHintIfBound,
+} from "@bastani/atomic";
 import { Key, matchesKey } from "@earendil-works/pi-tui";
-import { type ChainConfig, discoverAgents, discoverAgentsAll } from "../agents/agents.ts";
+import { discoverAgents } from "../agents/agents.ts";
 import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
 import {
 	type SingleResult,
@@ -15,7 +20,7 @@ import {
 	SLASH_SUBAGENT_UPDATE_EVENT,
 	type SubagentState,
 } from "../shared/types.ts";
-import { mapSavedChainSteps } from "./saved-chain-mapping.ts";
+import { registerBridgeRequestSettlement } from "./bridge-settlement.ts";
 import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.ts";
 import { applySlashUpdate, buildSlashInitialResult, failSlashResult, finalizeSlashResult } from "./slash-live-state.ts";
 
@@ -121,21 +126,6 @@ const makeAgentCompletions = (state: SubagentState, multiAgent: boolean) => (pre
 		.map((a) => ({ value: `${beforeLastWord}${a.name}`, label: a.name }));
 };
 
-const discoverSavedChains = (cwd: string): ChainConfig[] => {
-	const chainsByName = new Map<string, ChainConfig>();
-	for (const chain of discoverAgentsAll(cwd).chains) {
-		chainsByName.set(chain.name, chain);
-	}
-	return Array.from(chainsByName.values());
-};
-
-const makeChainCompletions = (state: SubagentState) => (prefix: string) => {
-	if (prefix.includes(" ") || !state.baseCwd) return null;
-	return discoverSavedChains(state.baseCwd)
-		.filter((chain) => chain.name.startsWith(prefix))
-		.map((chain) => ({ value: chain.name, label: chain.name }));
-};
-
 async function requestSlashRun(
 	pi: ExtensionAPI,
 	ctx: ExtensionContext,
@@ -186,8 +176,12 @@ async function requestSlashRun(
 		const onTerminalInput = ctx.hasUI
 			? ctx.ui.onTerminalInput((input) => {
 					if (!matchesKey(input, Key.escape)) return undefined;
-					pi.events.emit(SLASH_SUBAGENT_CANCEL_EVENT, { requestId });
-					finish(() => reject(new Error("Cancelled")));
+					try {
+						pi.events.emit(SLASH_SUBAGENT_CANCEL_EVENT, { requestId });
+						finish(() => reject(new Error("Cancelled")));
+					} catch (error) {
+						finish(() => reject(error));
+					}
 					return { consume: true };
 				})
 			: undefined;
@@ -196,6 +190,8 @@ async function requestSlashRun(
 		const unsubResponse = pi.events.on(SLASH_SUBAGENT_RESPONSE_EVENT, onResponse);
 		const unsubUpdate = pi.events.on(SLASH_SUBAGENT_UPDATE_EVENT, onUpdate);
 
+		let unregisterSettlement: (() => void) | undefined;
+		let reportedStop = false;
 		const finish = (next: () => void) => {
 			if (done) return;
 			done = true;
@@ -204,10 +200,29 @@ async function requestSlashRun(
 			unsubResponse();
 			unsubUpdate();
 			onTerminalInput?.();
+			unregisterSettlement?.();
 			next();
 		};
 
-		pi.events.emit(SLASH_SUBAGENT_REQUEST_EVENT, { requestId, params });
+		unregisterSettlement = registerBridgeRequestSettlement("slash", requestId, {
+			reject: (error: unknown) => {
+				if (!reportedStop) {
+					reportedStop = true;
+					console.error(
+						isStaleExtensionContextError(error)
+							? "Subagent slash command stopped because its response runtime was replaced or reloaded."
+							: "Subagent slash command stopped before its response was delivered.",
+					);
+				}
+				finish(() => reject(error));
+			},
+		});
+		try {
+			pi.events.emit(SLASH_SUBAGENT_REQUEST_EVENT, { requestId, params });
+		} catch (error) {
+			finish(() => reject(error));
+			return;
+		}
 
 		// Bridge emits STARTED synchronously during REQUEST emit.
 		// If not started, no bridge received the request.
@@ -297,6 +312,7 @@ async function runSlashSubagent(pi: ExtensionAPI, ctx: ExtensionContext, params:
 			ctx.ui.notify(response.errorText || "Subagent failed", "error");
 		}
 	} catch (error) {
+		if (isStaleExtensionContextError(error)) throw error;
 		const message = error instanceof Error ? error.message : String(error);
 		const failedDetails = failSlashResult(requestId, params, message, pi);
 		pi.sendMessage({
@@ -332,9 +348,7 @@ const parseAgentArgs = (
 	const usage = `Usage: /${command} agent1 "task1" -> agent2 "task2"`;
 	let steps: ParsedStep[];
 	let sharedTask: string;
-	let perStep = false;
 	if (input.includes(" -> ")) {
-		perStep = true;
 		const segments = input.split(" -> ");
 		steps = [];
 		for (const seg of segments) {
@@ -391,10 +405,6 @@ const parseAgentArgs = (
 			return null;
 		}
 	}
-	if (command === "chain" && !steps[0]?.task && (perStep || !sharedTask)) {
-		ctx.ui.notify(`First step must have a task: /chain agent "task" -> agent2`, "error");
-		return null;
-	}
 	if (command === "parallel" && !steps.some((s) => s.task) && !sharedTask) {
 		ctx.ui.notify("At least one step must have a task", "error");
 		return null;
@@ -437,61 +447,6 @@ export function registerSlashCommands(pi: ExtensionAPI, state: SubagentState): v
 			await runSlashSubagent(pi, ctx, params);
 		},
 	});
-	pi.registerCommand("chain", {
-		description: 'Run agents in sequence: /chain scout "task" -> planner [--bg] [--fork]',
-		getArgumentCompletions: makeAgentCompletions(state, true),
-		handler: async (args, ctx) => {
-			const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
-			const parsed = parseAgentArgs(state, cleanedArgs, "chain", ctx);
-			if (!parsed) return;
-			const chain = parsed.steps.map(({ name, config, task: stepTask }, i) => ({
-				agent: name,
-				...(stepTask ? { task: stepTask } : i === 0 && parsed.task ? { task: parsed.task } : {}),
-				...(config.output !== undefined ? { output: config.output } : {}),
-				...(config.outputMode !== undefined ? { outputMode: config.outputMode } : {}),
-				...(config.reads !== undefined ? { reads: config.reads } : {}),
-				...(config.model ? { model: config.model } : {}),
-				...(config.skill !== undefined ? { skill: config.skill } : {}),
-				...(config.progress !== undefined ? { progress: config.progress } : {}),
-			}));
-			const params: SubagentParamsLike = { chain, task: parsed.task, agentScope: "both" };
-			if (bg) params.async = true;
-			if (fork) params.context = "fork";
-			await runSlashSubagent(pi, ctx, params);
-		},
-	});
-	pi.registerCommand("run-chain", {
-		description: "Run a saved chain: /run-chain chainName -- task [--bg] [--fork]",
-		getArgumentCompletions: makeChainCompletions(state),
-		handler: async (args, ctx) => {
-			const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
-			const delimiterIndex = cleanedArgs.indexOf(" -- ");
-			const usage = "Usage: /run-chain <chainName> -- <task> [--bg] [--fork]";
-			if (delimiterIndex === -1) {
-				ctx.ui.notify(usage, "error");
-				return;
-			}
-			const chainName = cleanedArgs.slice(0, delimiterIndex).trim();
-			const task = cleanedArgs.slice(delimiterIndex + 4).trim();
-			if (!chainName || !task) {
-				ctx.ui.notify(usage, "error");
-				return;
-			}
-			if (!state.baseCwd) {
-				ctx.ui.notify("Subagent session cwd is not initialized yet", "error");
-				return;
-			}
-			const chain = discoverSavedChains(state.baseCwd).find((candidate) => candidate.name === chainName);
-			if (!chain) {
-				ctx.ui.notify(`Unknown chain: ${chainName}`, "error");
-				return;
-			}
-			const params: SubagentParamsLike = { chain: mapSavedChainSteps(chain), task, agentScope: "both" };
-			if (bg) params.async = true;
-			if (fork) params.context = "fork";
-			await runSlashSubagent(pi, ctx, params);
-		},
-	});
 	pi.registerCommand("parallel", {
 		description: 'Run agents in parallel: /parallel scout "task1" -> reviewer "task2" [--bg] [--fork]',
 		getArgumentCompletions: makeAgentCompletions(state, true),

package/dist/builtin/subagents/src/slash/slash-live-state.ts

@@ -20,17 +20,6 @@ export interface SlashSnapshotStore {
 	versionCounter: number;
 }
 
-interface SequentialChainStepLike {
-	agent: string;
-	task?: string;
-}
-
-interface ParallelChainStepLike {
-	parallel: Array<{ agent: string; task?: string }>;
-}
-
-type ChainStepLike = SequentialChainStepLike | ParallelChainStepLike;
-
 const defaultStoreOwner = {};
 
 function getStoreRegistry(): WeakMap<object, SlashSnapshotStore> {
@@ -79,7 +68,7 @@ function createPlaceholderResult(
 	return {
 		agent,
 		task,
-		exitCode: 0,
+		status: "continued",
 		messages: EMPTY_MESSAGES,
 		usage: cloneUsage(),
 		progress: {
@@ -119,80 +108,6 @@ function buildParallelInitialResult(params: SubagentParamsLike): AgentToolResult
 	};
 }
 
-function isParallelChainStep(step: ChainStepLike): step is ParallelChainStepLike {
-	return "parallel" in step && Array.isArray(step.parallel);
-}
-
-function chainStepLabel(step: ChainStepLike): string {
-	if (isParallelChainStep(step)) {
-		return `[${step.parallel.map((entry) => entry.agent).join("+")}]`;
-	}
-	return step.agent;
-}
-
-function flattenChainResults(chain: ChainStepLike[], fallbackTask: string | undefined): SingleResult[] {
-	const results: SingleResult[] = [];
-	let flatIndex = 0;
-	for (const step of chain) {
-		if (isParallelChainStep(step)) {
-			for (const task of step.parallel) {
-				results.push(
-					createPlaceholderResult(
-						task.agent,
-						task.task ?? fallbackTask ?? "",
-						results.length === 0 ? "running" : "pending",
-						flatIndex,
-					),
-				);
-				flatIndex++;
-			}
-			continue;
-		}
-		results.push(
-			createPlaceholderResult(
-				step.agent,
-				step.task ?? fallbackTask ?? "",
-				results.length === 0 ? "running" : "pending",
-				flatIndex,
-			),
-		);
-		flatIndex++;
-	}
-	return results;
-}
-
-function buildChainInitialResult(params: SubagentParamsLike): AgentToolResult<Details> {
-	const chain = (params.chain ?? []) as ChainStepLike[];
-	const results = flattenChainResults(chain, params.task);
-	return {
-		content: [
-			{
-				type: "text",
-				text: results.map((result, index) => `Step ${index + 1}: ${result.agent}\n${result.task}`).join("\n\n"),
-			},
-		],
-		details: {
-			mode: "chain",
-			...(params.context ? { context: params.context } : {}),
-			results,
-			progress: results.map((result, index) => ({
-				index,
-				agent: result.agent,
-				status: index === 0 ? ("running" as const) : ("pending" as const),
-				task: result.task,
-				recentTools: [],
-				recentOutput: [],
-				toolCount: 0,
-				tokens: 0,
-				durationMs: 0,
-			})),
-			chainAgents: chain.map((step) => chainStepLabel(step)),
-			totalSteps: chain.length,
-			currentStepIndex: 0,
-		},
-	};
-}
-
 function buildSingleInitialResult(params: SubagentParamsLike): AgentToolResult<Details> {
 	const agent = params.agent ?? "subagent";
 	const task = params.task ?? "";
@@ -226,11 +141,7 @@ export function buildSlashInitialResult(
 ): SlashMessageDetails {
 	const store = getSlashSnapshotStore(owner);
 	const result =
-		(params.tasks?.length ?? 0) > 0
-			? buildParallelInitialResult(params)
-			: (params.chain?.length ?? 0) > 0
-				? buildChainInitialResult(params)
-				: buildSingleInitialResult(params);
+		(params.tasks?.length ?? 0) > 0 ? buildParallelInitialResult(params) : buildSingleInitialResult(params);
 	store.liveSnapshots.set(requestId, { result, version: nextVersion(store) });
 	store.finalSnapshots.delete(requestId);
 	return { requestId, result };
@@ -252,12 +163,10 @@ export function applySlashUpdate(requestId: string, update: SlashSubagentUpdate,
 	if (!snapshot) return;
 	const progress = update.progress;
 	if (!progress || !snapshot.result.details) return;
-	const currentStepIndex = progress.findIndex((entry) => entry.status === "running");
 	const nextDetails: Details = {
 		...snapshot.result.details,
 		progress,
 		results: cloneResultsWithProgress(snapshot.result.details.results, progress),
-		...(snapshot.result.details.mode === "chain" && currentStepIndex >= 0 ? { currentStepIndex } : {}),
 	};
 	store.liveSnapshots.set(requestId, {
 		result: {
@@ -292,7 +201,7 @@ export function failSlashResult(
 	const initial = buildSlashInitialResult(requestId, params, owner).result;
 	const failedResults = initial.details.results.map((result) => ({
 		...result,
-		exitCode: 1,
+		status: "error" as const,
 		error: message,
 		progress: result.progress ? { ...result.progress, status: "failed" as const } : result.progress,
 	}));

package/dist/builtin/subagents/src/tui/render-event-formatting.ts

@@ -1,6 +1,4 @@
-import * as path from "node:path";
-import { flatToLogicalStepIndex } from "../runs/background/parallel-groups.ts";
-import { formatNestedAggregate } from "../runs/shared/nested-render.ts";
+import { formatNestedAggregate } from "../runs/inprocess/runtime-support/nested-rendering.ts";
 import { formatDuration, formatModelThinking, shortenPath } from "../shared/formatters.ts";
 import { formatAgentRunningLabel } from "../shared/status-format.ts";
 import {
@@ -28,7 +26,6 @@ export function formatWidgetAgents(agents: string[]): string {
 
 export function widgetJobName(job: AsyncJobState): string {
 	if (job.mode === "parallel") return "parallel";
-	if (job.mode === "chain") return "chain";
 	if (job.mode === "single" && job.agents?.length === 1) return job.agents[0]!;
 	if (job.agents?.length) return formatWidgetAgents(job.agents);
 	return job.mode ?? "subagent";
@@ -106,29 +103,8 @@ export function widgetStats(job: AsyncJobState, theme: Theme): string {
 	if (job.activeParallelGroup) {
 		const running = job.runningSteps ?? (job.status === "running" ? 1 : 0);
 		const done = job.completedSteps ?? (job.status === "complete" ? stepsTotal : 0);
-		if (job.mode === "parallel") {
-			if (job.status === "running" && running > 0) parts.push(formatAgentRunningLabel(running));
-			if (stepsTotal > 0) parts.push(`${done}/${stepsTotal} done`);
-		} else {
-			const activeGroup =
-				job.currentStep !== undefined
-					? job.parallelGroups?.find(
-							(group) => job.currentStep! >= group.start && job.currentStep! < group.start + group.count,
-						)
-					: job.parallelGroups?.find((group) => group.start === 0);
-			const logicalStep = activeGroup?.stepIndex ?? job.currentStep ?? 0;
-			const total = job.chainStepCount ?? stepsTotal;
-			const groupParts = [`${done}/${stepsTotal} done`];
-			if (job.status === "running" && running > 0) groupParts.unshift(formatAgentRunningLabel(running));
-			parts.push(`step ${logicalStep + 1}/${total} · parallel group: ${groupParts.join(" · ")}`);
-		}
-	} else if (job.currentStep !== undefined) {
-		if (job.mode === "chain" && job.parallelGroups?.length) {
-			const total = job.chainStepCount ?? stepsTotal;
-			parts.push(`step ${flatToLogicalStepIndex(job.currentStep, total, job.parallelGroups) + 1}/${total}`);
-		} else {
-			parts.push(`step ${job.currentStep + 1}/${stepsTotal}`);
-		}
+		if (job.status === "running" && running > 0) parts.push(formatAgentRunningLabel(running));
+		if (stepsTotal > 0) parts.push(`${done}/${stepsTotal} done`);
 	} else if (stepsTotal > 1) {
 		parts.push(`steps ${stepsTotal}`);
 	}
@@ -167,14 +143,6 @@ export function widgetStepActivityLine(
 	return "";
 }
 
-export function widgetOutputPath(
-	job: AsyncJobState,
-	step: NonNullable<AsyncJobState["steps"]>[number],
-): string | undefined {
-	if (typeof step.index !== "number") return undefined;
-	return path.join(job.asyncDir, `output-${step.index}.log`);
-}
-
 export function nestedRunName(run: NestedRunSummary): string {
 	if (run.agent) return run.agent;
 	if (run.agents?.length) return formatWidgetAgents(run.agents);