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

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;
@@ -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);
@@ -384,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,
@@ -392,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";
 
@@ -75,17 +80,10 @@ const parseAgentToken = (token: string): { name: string; config: InlineConfig }
 	};
 };
 
-const extractExecutionFlags = (rawArgs: string): { args: string; bg: boolean; fork: boolean } => {
+const extractExecutionFlags = (rawArgs: string): { args: string; fork: boolean } => {
 	let args = rawArgs.trim();
-	let bg = false;
 	let fork = false;
-
 	while (true) {
-		if (args.endsWith(" --bg") || args === "--bg") {
-			bg = true;
-			args = args === "--bg" ? "" : args.slice(0, -5).trim();
-			continue;
-		}
 		if (args.endsWith(" --fork") || args === "--fork") {
 			fork = true;
 			args = args === "--fork" ? "" : args.slice(0, -7).trim();
@@ -93,8 +91,7 @@ const extractExecutionFlags = (rawArgs: string): { args: string; bg: boolean; fo
 		}
 		break;
 	}
-
-	return { args, bg, fork };
+	return { args, fork };
 };
 
 const makeAgentCompletions = (state: SubagentState, multiAgent: boolean) => (prefix: string) => {
@@ -121,21 +118,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 +168,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 +182,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 +192,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 +304,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 +340,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 +397,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;
@@ -403,14 +405,14 @@ const parseAgentArgs = (
 };
 export function registerSlashCommands(pi: ExtensionAPI, state: SubagentState): void {
 	pi.registerCommand("run", {
-		description: "Run a subagent directly: /run agent[output=file] [task] [--bg] [--fork]",
+		description: "Run a subagent directly: /run agent[output=file] [task] [--fork]",
 		getArgumentCompletions: makeAgentCompletions(state, false),
 		handler: async (args, ctx) => {
-			const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
+			const { args: cleanedArgs, fork } = extractExecutionFlags(args);
 			const input = cleanedArgs.trim();
 			const firstSpace = input.indexOf(" ");
 			if (!input) {
-				ctx.ui.notify("Usage: /run <agent> [task] [--bg] [--fork]", "error");
+				ctx.ui.notify("Usage: /run <agent> [task] [--fork]", "error");
 				return;
 			}
 			const { name: agentName, config: inline } = parseAgentToken(
@@ -432,71 +434,15 @@ export function registerSlashCommands(pi: ExtensionAPI, state: SubagentState): v
 			if (inline.outputMode !== undefined) params.outputMode = inline.outputMode;
 			if (inline.skill !== undefined) params.skill = inline.skill;
 			if (inline.model) params.model = inline.model;
-			if (bg) params.async = true;
-			if (fork) params.context = "fork";
-			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]',
+		description: 'Run agents in parallel: /parallel scout "task1" -> reviewer "task2" [--fork]',
 		getArgumentCompletions: makeAgentCompletions(state, true),
 		handler: async (args, ctx) => {
-			const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
+			const { args: cleanedArgs, fork } = extractExecutionFlags(args);
 			const parsed = parseAgentArgs(state, cleanedArgs, "parallel", ctx);
 			if (!parsed) return;
 			const tasks = parsed.steps.map(({ name, config, task: stepTask }) => ({
@@ -510,7 +456,6 @@ export function registerSlashCommands(pi: ExtensionAPI, state: SubagentState): v
 				...(config.progress !== undefined ? { progress: config.progress } : {}),
 			}));
 			const params: SubagentParamsLike = { tasks, agentScope: "both" };
-			if (bg) params.async = true;
 			if (fork) params.context = "fork";
 			await runSlashSubagent(pi, ctx, params);
 		},

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> {
@@ -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: {