@selesai/code 0.8.3 → 0.8.5

package/dist/extensions/pi-subagents/src/slash/prompt-workflows.ts

@@ -1,10 +1,11 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { fileURLToPath } from "node:url";
 import type { ExtensionAPI, ExtensionContext } from "@selesai/code";
 import { parseFrontmatter } from "../agents/frontmatter.ts";
+import { discoverAgents, discoverAgentsAll, resolveAgentName, type ChainConfig, type ChainStepConfig } from "../agents/agents.ts";
 import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
-import { getAgentDir, getProjectConfigDir } from "../shared/utils.ts";
+import type { ChainStep } from "../shared/settings.ts";
+import { getPromptDirectories } from "../shared/prompt-resources.ts";
 
 interface PromptWorkflow {
 	name: string;
@@ -32,21 +33,9 @@ const RESERVED_COMMAND_NAMES = new Set([
 	"subagents-models",
 ]);
 
-function packagePromptsDir(): string {
-	return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "prompts");
-}
-
-function promptDirs(cwd: string): string[] {
-	return [
-		packagePromptsDir(),
-		path.join(getAgentDir(), "prompts"),
-		path.join(getProjectConfigDir(cwd), "prompts"),
-	];
-}
-
 function readPromptFiles(cwd: string): string[] {
 	const files: string[] = [];
-	for (const dir of promptDirs(cwd)) {
+	for (const dir of Object.values(getPromptDirectories(cwd))) {
 		let entries: fs.Dirent[];
 		try {
 			entries = fs.readdirSync(dir, { withFileTypes: true });
@@ -85,7 +74,7 @@ function parseSkill(value: string | undefined): string | string[] | false | unde
 
 function parseAgent(frontmatter: Record<string, string>): string {
 	const subagent = stringField(frontmatter, "subagent");
-	if (!subagent || subagent === "true") return "explorer";
+	if (!subagent || subagent === "true") return "delegate";
 	return subagent;
 }
 
@@ -213,13 +202,19 @@ function workflowParams(workflow: PromptWorkflow, args: string[], runtime: Retur
 	return {
 		agent: runtime.agentOverride ?? workflow.agent,
 		task,
-		clarify: false,
 		agentScope: "both",
 		...(context ? { context } : {}),
 		...(workflow.model ? { model: workflow.model } : {}),
 		...(workflow.skill !== undefined ? { skill: workflow.skill } : {}),
 		...(workflow.cwd ? { cwd: workflow.cwd } : {}),
-		...(runtime.bg ? { async: true } : {}),
+	};
+}
+
+function promptWorkflowExecutionParams(workflows: PromptWorkflow[], args: string[], runtime: ReturnType<typeof parseRuntimeOptions>): SubagentParamsLike {
+	return {
+		workflowScript: promptWorkflowScript(workflows, args, runtime),
+		agentScope: "both",
+		async: runtime.bg ? true : false,
 	};
 }
 
@@ -228,7 +223,7 @@ function promptWorkflowScript(workflows: PromptWorkflow[], args: string[], runti
 		const params = workflowParams(workflow, args, runtime);
 		const task = params.task ?? "";
 		const child = {
-			agent: params.agent ?? "explorer",
+			agent: params.agent ?? "delegate",
 			task,
 			...(params.model ? { model: params.model } : {}),
 			...(params.skill !== undefined ? { skill: params.skill } : {}),
@@ -252,6 +247,75 @@ function formatWorkflowList(workflows: PromptWorkflow[]): string {
 	].join("\n");
 }
 
+// --- Selesai additions: native chain / parallel / saved-chain slash commands ---
+
+/**
+ * Parse `agent task | agent task | ...` into chain steps. Runtime flags
+ * (`--bg`, `--fork`, `--fresh`) are stripped before splitting on `|`.
+ */
+function parseStepList(input: string): { agent: string; task: string }[] {
+	const words = shellWords(input);
+	const args: string[] = [];
+	let fork = false;
+	let fresh = false;
+	let bg = false;
+	for (let i = 0; i < words.length; i++) {
+		const word = words[i]!;
+		if (word === "--fork") { fork = true; continue; }
+		if (word === "--fresh") { fresh = true; continue; }
+		if (word === "--bg" || word === "--async") { bg = true; continue; }
+		args.push(word);
+	}
+	const steps: { agent: string; task: string }[] = [];
+	let current = "";
+	for (const word of args) {
+		if (word === "|") {
+			if (current.trim()) steps.push(parseStep(current));
+			current = "";
+			continue;
+		}
+		current += (current ? " " : "") + word;
+	}
+	if (current.trim()) steps.push(parseStep(current));
+	return steps.map((step) => ({ ...step, ...(fork ? { context: "fork" as const } : {}), ...(fresh ? { context: "fresh" as const } : {}) }));
+}
+
+function parseStep(stepText: string): { agent: string; task: string } {
+	const space = stepText.indexOf(" ");
+	if (space === -1) return { agent: stepText, task: "" };
+	return { agent: stepText.slice(0, space), task: stepText.slice(space + 1).trim() };
+}
+
+function resolveStepsAgents(steps: { agent: string; task: string }[], cwd: string): { agent: string; task: string }[] {
+	const agents = discoverAgents(cwd, "both").agents;
+	return steps.map((step) => {
+		const resolved = resolveAgentName(step.agent, agents);
+		if (resolved.error || !resolved.agent) throw new Error(`Unknown agent: ${step.agent}`);
+		return { agent: resolved.agent.name, task: step.task };
+	});
+}
+
+function normalizeChainStep(step: ChainStepConfig): Record<string, unknown> {
+	const normalized: Record<string, unknown> = {};
+	for (const [key, value] of Object.entries(step)) {
+		if (value === undefined) continue;
+		if (key === "skills") {
+			if (value !== false) normalized.skill = value;
+			continue;
+		}
+		normalized[key] = value;
+	}
+	return normalized;
+}
+
+function formatChainList(chains: ChainConfig[]): string {
+	if (chains.length === 0) return "No saved chains found in user or project chains.";
+	return [
+		"Saved chains:",
+		...chains.map((chain) => `- ${chain.name}: ${chain.description ?? chain.filePath}`),
+	].join("\n");
+}
+
 export function registerPromptWorkflowCommands(input: {
 	pi: ExtensionAPI;
 	run: PromptWorkflowRunner;
@@ -281,14 +345,105 @@ export function registerPromptWorkflowCommands(input: {
 						if (!step) throw new Error(`Unknown prompt workflow in chain '${workflow.name}': ${stepName}`);
 						return step;
 					});
-					await run({ workflowScript: promptWorkflowScript(chain, runtime.args, runtime), clarify: false, agentScope: "both", ...(runtime.bg ? { async: true } : {}) }, ctx);
+					await run(promptWorkflowExecutionParams(chain, runtime.args, runtime), ctx);
+					return;
+				}
+				await run(promptWorkflowExecutionParams([workflow], runtime.args, runtime), ctx);
+			} catch (error) {
+				ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+			}
+		},
+	});
+
+	pi.registerCommand("chain", {
+		description: "Launch a chain of steps: /chain <agent> <task> | <agent> <task> [--bg] [--fork] [--fresh]",
+		handler: async (rawArgs, ctx) => {
+			try {
+				const steps = resolveStepsAgents(parseStepList(rawArgs), ctx.cwd);
+				if (steps.length === 0) {
+					ctx.ui.notify("Usage: /chain <agent> <task> | <agent> <task> [--bg] [--fork] [--fresh]", "error");
 					return;
 				}
-				await run(workflowParams(workflow, runtime.args, runtime), ctx);
+				const bg = rawArgs.includes("--bg") || rawArgs.includes("--async");
+				await run({ chain: steps as ChainStep[], agentScope: "both", ...(bg ? { async: true } : {}) }, ctx);
 			} catch (error) {
 				ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
 			}
 		},
 	});
 
+	pi.registerCommand("parallel", {
+		description: "Launch top-level parallel tasks: /parallel <agent> <task> | <agent> <task> [--bg]",
+		handler: async (rawArgs, ctx) => {
+			try {
+				const steps = resolveStepsAgents(parseStepList(rawArgs), ctx.cwd);
+				if (steps.length === 0) {
+					ctx.ui.notify("Usage: /parallel <agent> <task> | <agent> <task> [--bg]", "error");
+					return;
+				}
+				const bg = rawArgs.includes("--bg") || rawArgs.includes("--async");
+				await run({ tasks: steps, agentScope: "both", ...(bg ? { async: true } : {}) }, ctx);
+			} catch (error) {
+				ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+			}
+		},
+	});
+
+	pi.registerCommand("run-chain", {
+		description: "Run a saved .chain.md/.chain.json workflow: /run-chain <name> [--bg]",
+		handler: async (rawArgs, ctx) => {
+			const words = shellWords(rawArgs);
+			const name = words.find((word) => !word.startsWith("--"));
+			const bg = words.includes("--bg") || words.includes("--async");
+			const chains = discoverAgentsAll(ctx.cwd).chains;
+			if (!name || name === "list") {
+				pi.sendMessage({ content: formatChainList(chains), display: true } as Parameters<typeof pi.sendMessage>[0]);
+				return;
+			}
+			const chain = chains.find((candidate) => candidate.name === name || candidate.localName === name);
+			if (!chain) {
+				ctx.ui.notify(`Unknown saved chain: ${name}`, "error");
+				return;
+			}
+			try {
+				await run({ chain: chain.steps.map(normalizeChainStep) as unknown as ChainStep[], agentScope: "both", ...(bg ? { async: true } : {}) }, ctx);
+			} catch (error) {
+				ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+			}
+		},
+	});
+
+	pi.registerCommand("chain-prompts", {
+		description: "Run a prompt template whose frontmatter declares a chain, as a native chain: /chain-prompts <name> [args]",
+		handler: async (rawArgs, ctx) => {
+			const words = shellWords(rawArgs);
+			const name = words.shift();
+			const workflows = discoverPromptWorkflows(ctx.cwd);
+			if (!name || name === "list") {
+				pi.sendMessage({ content: formatWorkflowList(workflows), display: true } as Parameters<typeof pi.sendMessage>[0]);
+				return;
+			}
+			const workflow = findWorkflow(workflows, name);
+			if (!workflow) {
+				ctx.ui.notify(`Unknown prompt workflow: ${name}`, "error");
+				return;
+			}
+			const runtime = parseRuntimeOptions(words);
+			try {
+				if (workflow.chain) {
+					const steps = splitPromptChain(workflow.chain).map((stepName) => {
+						const step = findWorkflow(workflows, stepName);
+						if (!step) throw new Error(`Unknown prompt workflow in chain '${workflow.name}': ${stepName}`);
+						const params = workflowParams(step, runtime.args, runtime);
+						return { agent: params.agent, task: params.task };
+					});
+					await run({ chain: steps as ChainStep[], agentScope: "both", ...(runtime.bg ? { async: true } : {}) }, ctx);
+					return;
+				}
+				ctx.ui.notify(`Prompt workflow '${name}' has no chain frontmatter; use /prompt-workflow for single-step templates.`, "warning");
+			} catch (error) {
+				ctx.ui.notify(error instanceof Error ? error.message : String(error), "error");
+			}
+		},
+	});
 }

package/dist/extensions/pi-subagents/src/slash/slash-bridge.ts

@@ -1,5 +1,6 @@
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type { ExtensionContext } from "@selesai/code";
+import { normalizePublicSubagentExecution } from "../extension/public-execution.ts";
 import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
 import {
 	SLASH_SUBAGENT_CANCEL_EVENT,
@@ -27,6 +28,8 @@ export interface SlashSubagentResponse {
 export interface SlashSubagentUpdate {
 	requestId: string;
 	progress?: Details["progress"];
+	workflow?: Details["workflow"];
+	chatProgress?: Details["chatProgress"];
 	currentTool?: string;
 	toolCount?: number;
 }
@@ -77,21 +80,22 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 		if (!data || typeof data !== "object") return;
 		const request = data as Partial<SlashSubagentRequest>;
 		if (typeof request.requestId !== "string" || !request.params) return;
-		const { requestId, params } = request as SlashSubagentRequest;
-		if (params.tasks !== undefined || params.chain !== undefined || params.concurrency !== undefined || params.worktree !== undefined || params.chainDir !== undefined) {
-			const message = "Legacy slash-event chain and parallel inputs were removed; use workflowScript.";
+		const { requestId } = request as SlashSubagentRequest;
+		const normalized = normalizePublicSubagentExecution((request as SlashSubagentRequest).params);
+		if (!normalized.ok) {
 			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, {
 				requestId,
 				result: {
-					content: [{ type: "text", text: message }],
+					content: [{ type: "text", text: normalized.error }],
 					isError: true,
-					details: { mode: "management", results: [] },
+					details: { mode: normalized.mode, results: [] },
 				},
 				isError: true,
-				errorText: message,
+				errorText: normalized.error,
 			} satisfies SlashSubagentResponse);
 			return;
 		}
+		const params = normalized.params;
 
 		const ctx = request.ctx ?? options.getContext();
 		if (!ctx) {
@@ -140,6 +144,8 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 					const payload: SlashSubagentUpdate = {
 						requestId,
 						progress,
+						workflow: update.details?.workflow,
+						chatProgress: update.details?.chatProgress,
 						currentTool: first?.currentTool,
 						toolCount: first?.toolCount,
 					};

package/dist/extensions/pi-subagents/src/slash/slash-commands.ts

@@ -2,9 +2,10 @@ import { randomUUID } from "node:crypto";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { keyText, type ExtensionAPI, type ExtensionContext } from "@selesai/code";
-import { Key, matchesKey, type Component, type TUI } from "@earendil-works/pi-tui";
+import { Key, matchesKey, truncateToWidth, type Component, type TUI } from "@earendil-works/pi-tui";
 import { BUILTIN_AGENT_NAMES, discoverAgents } from "../agents/agents.ts";
 import { registerInlineSubagentInvocation } from "./inline-subagents.ts";
+import { resolveExistingReadPaths } from "../shared/settings.ts";
 import {
 	DEFAULT_PROVIDER_MODELS_MAX_AGE_DAYS,
 	applySubagentProfile,
@@ -23,6 +24,7 @@ import { SUBAGENT_FANOUT_CHILD_ENV } from "../runs/shared/pi-args.ts";
 import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.ts";
 import { registerPromptWorkflowCommands } from "./prompt-workflows.ts";
 import { openSubagentsAdmin } from "./subagents-admin.ts";
+import { SUBAGENT_GUIDE_TOPICS } from "../extension/subagent-guide.ts";
 import { openSubagentFleet } from "../tui/fleet.ts";
 import {
 	applySlashUpdate,
@@ -41,6 +43,7 @@ import {
 	SLASH_SUBAGENT_UPDATE_EVENT,
 	DIRS,
 	type Details,
+	type FleetKeybindingsConfig,
 	type JsonSchemaObject,
 	type SingleResult,
 	type SubagentState,
@@ -282,7 +285,7 @@ class SubagentsStopSelector implements Component {
 	invalidate(): void {}
 
 	render(width: number): string[] {
-		const contentWidth = Math.max(40, Math.min(this.width, width || this.width));
+		const contentWidth = Math.max(0, Math.min(this.width, Math.floor(width)));
 		const lines = [this.theme.bold("Stop subagent run"), this.theme.fg("dim", "Select a current-session async run to stop, or a scheduled run to cancel."), ""];
 		const maxRows = 10;
 		const start = Math.max(0, Math.min(this.selected - maxRows + 1, Math.max(0, this.targets.length - maxRows)));
@@ -306,7 +309,7 @@ class SubagentsStopSelector implements Component {
 		} else {
 			lines.push(this.theme.fg("dim", "↑↓/jk select · Enter confirm · Esc cancel"));
 		}
-		return lines;
+		return lines.map((line) => truncateToWidth(line, contentWidth));
 	}
 }
 
@@ -424,7 +427,7 @@ function parseSingleRequiredArg(args: string, usage: string): { ok: true; value:
 }
 
 function getProfileWorkerModel(profile: { subagents?: { agentOverrides?: Record<string, { model?: string }> } }): string | undefined {
-	const model = profile.subagents?.agentOverrides?.builder?.model;
+	const model = profile.subagents?.agentOverrides?.worker?.model;
 	return typeof model === "string" && model.trim() ? model.trim() : undefined;
 }
 
@@ -622,13 +625,16 @@ export function launchSlashSubagent(
 	void runSlashSubagent(pi, ctx, params);
 }
 
+function slashRunWorkflowScript(key: string, child: Record<string, unknown>): string {
+	return `return runs.run(${JSON.stringify(key)}, ${JSON.stringify(child)})`;
+}
 
 export function registerSlashCommands(
 	pi: ExtensionAPI,
 	state: SubagentState,
+	options: { fleetKeybindings?: FleetKeybindingsConfig } = {},
 ): void {
 	registerInlineSubagentInvocation(pi, state);
-
 	let fleetOpen = false;
 	const showFleet = async (ctx: ExtensionContext) => {
 		state.lastUiContext = ctx;
@@ -642,7 +648,7 @@ export function registerSlashCommands(
 		}
 		fleetOpen = true;
 		try {
-			await openSubagentFleet(ctx, state, { asyncDirRoot: DIRS.async, resultsDir: DIRS.results });
+			await openSubagentFleet(ctx, state, { asyncDirRoot: DIRS.async, resultsDir: DIRS.results, fleetKeybindings: options.fleetKeybindings });
 		} finally {
 			fleetOpen = false;
 		}
@@ -656,7 +662,7 @@ export function registerSlashCommands(
 	});
 
 	pi.registerCommand("run", {
-		description: "Run a subagent directly: /run agent[output=file] [task] [--bg] [--fork]",
+		description: "Run one subagent through workflowScript: /run agent[output=file] [task] [--bg] [--fork]",
 		getArgumentCompletions: makeAgentCompletions(state),
 		handler: async (args, ctx) => {
 			const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
@@ -672,16 +678,16 @@ export function registerSlashCommands(
 
 			let finalTask = task;
 			if (inline.reads && Array.isArray(inline.reads) && inline.reads.length > 0) {
-				finalTask = `[Read from: ${inline.reads.join(", ")}]\n\n${finalTask}`;
+				const existingReads = inline.reads.filter((read) => resolveExistingReadPaths([read], state.baseCwd).length > 0);
+				if (existingReads.length > 0) finalTask = `[Read from: ${existingReads.join(", ")}]\n\n${finalTask}`;
 			}
-			const params: SubagentParamsLike = { agent: agentName, task: finalTask, clarify: false, agentScope: "both" };
-			if (inline.output !== undefined) params.output = inline.output;
-			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";
-			launchSlashSubagent(pi, ctx, params);
+			const child: Record<string, unknown> = { agent: agentName, task: finalTask, agentScope: "both" };
+			if (inline.output !== undefined) child.output = inline.output;
+			if (inline.outputMode !== undefined) child.outputMode = inline.outputMode;
+			if (inline.skill !== undefined) child.skill = inline.skill;
+			if (inline.model) child.model = inline.model;
+			if (fork) child.context = "fork";
+			launchSlashSubagent(pi, ctx, { workflowScript: slashRunWorkflowScript("run", child), async: bg ? true : false });
 		},
 	});
 
@@ -699,6 +705,34 @@ export function registerSlashCommands(
 		},
 	});
 
+	pi.registerCommand("subagents-guide", {
+		description: "Show a packaged subagents guide topic",
+		getArgumentCompletions: (prefix) => prefix.includes(" ") ? null : SUBAGENT_GUIDE_TOPICS
+			.filter((topic) => topic.startsWith(prefix))
+			.map((topic) => ({ value: topic, label: topic })),
+		handler: async (args, ctx) => {
+			const topic = args.trim();
+			if (topic.includes(" ")) {
+				ctx.ui.notify("Usage: /subagents-guide [topic]", "error");
+				return;
+			}
+			await runSlashSubagent(pi, ctx, { action: "guide", ...(topic ? { topic } : {}) });
+		},
+	});
+
+	pi.registerCommand("subagents-refine", {
+		description: "Generate a bounded project-local refinement overlay for one subagent",
+		getArgumentCompletions: makeAgentCompletions(state),
+		handler: async (args, ctx) => {
+			const parts = args.trim().split(/\s+/).filter(Boolean);
+			if (parts.length !== 1) {
+				ctx.ui.notify("Usage: /subagents-refine <agent>", "error");
+				return;
+			}
+			await runSlashSubagent(pi, ctx, { action: "refine", agent: parts[0] });
+		},
+	});
+
 	pi.registerCommand("subagents-fleet", {
 		description: "Open the live subagent fleet inspector",
 		handler: async (_args, ctx) => showFleet(ctx),
@@ -850,7 +884,7 @@ export function registerSlashCommands(
 					if (workerModel && typeof pi.setModel === "function" && typeof ctx.modelRegistry?.find === "function" && typeof ctx.modelRegistry?.getAvailable === "function") {
 						const shouldSwitch = await ctx.ui.confirm(
 							"",
-							`Profile loaded. Also switch this session to the profile builder model?\n\n${workerModel}`,
+							`Profile loaded. Also switch this session to the profile worker model?\n\n${workerModel}`,
 						);
 						if (shouldSwitch) {
 							const modelInfo = findModelInfo(workerModel, ctx.modelRegistry.getAvailable().map(toModelInfo));
@@ -864,7 +898,7 @@ export function registerSlashCommands(
 							}
 						}
 					} else if (workerModel) {
-						lines.push(`Profile builder model: ${workerModel}`);
+						lines.push(`Profile worker model: ${workerModel}`);
 					}
 
 					sendSlashText(pi, lines.join("\n"));

package/dist/extensions/pi-subagents/src/slash/slash-live-state.ts

@@ -1,6 +1,7 @@
 import type { AgentToolResult } from "@earendil-works/pi-agent-core";
 import type { Message } from "@earendil-works/pi-ai";
 import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts";
+import { previewSimpleWorkflowRun } from "../workflows/scripted-workflow.ts";
 import type { SlashSubagentResponse, SlashSubagentUpdate } from "./slash-bridge.ts";
 import { type Details, type SingleResult, type Usage, SLASH_RESULT_TYPE } from "../shared/types.ts";
 
@@ -156,8 +157,9 @@ function buildChainInitialResult(params: SubagentParamsLike): AgentToolResult<De
 }
 
 function buildSingleInitialResult(params: SubagentParamsLike): AgentToolResult<Details> {
-	const agent = params.agent ?? "subagent";
-	const task = params.task ?? "";
+	const preview = previewSimpleWorkflowRun(params.workflowScript) ?? {};
+	const agent = params.agent ?? preview.agent ?? "subagent";
+	const task = params.task ?? preview.task ?? "";
 	return {
 		content: [{ type: "text", text: task }],
 		details: {
@@ -179,12 +181,28 @@ function buildSingleInitialResult(params: SubagentParamsLike): AgentToolResult<D
 	};
 }
 
+function buildWorkflowInitialResult(params: SubagentParamsLike): AgentToolResult<Details> {
+	const preview = previewSimpleWorkflowRun(params.workflowScript) ?? {};
+	const task = preview.task ?? "";
+	return {
+		content: [{ type: "text", text: task || "Workflow running." }],
+		details: {
+			mode: "workflow",
+			...(params.context ? { context: params.context } : {}),
+			results: [],
+			workflow: { trace: [], emits: [], console: [] },
+		},
+	};
+}
+
 export function buildSlashInitialResult(requestId: string, params: SubagentParamsLike): SlashMessageDetails {
 	const result = (params.tasks?.length ?? 0) > 0
 		? buildParallelInitialResult(params)
 		: (params.chain?.length ?? 0) > 0
 			? buildChainInitialResult(params)
-			: buildSingleInitialResult(params);
+			: params.workflowScript !== undefined
+				? buildWorkflowInitialResult(params)
+				: buildSingleInitialResult(params);
 	liveSnapshots.set(requestId, { result, version: nextVersion() });
 	finalSnapshots.delete(requestId);
 	return { requestId, result };
@@ -204,9 +222,22 @@ function cloneResultsWithProgress(
 
 export function applySlashUpdate(requestId: string, update: SlashSubagentUpdate): void {
 	const snapshot = liveSnapshots.get(requestId);
-	if (!snapshot) return;
+	if (!snapshot || !snapshot.result.details) return;
+	if (update.workflow) {
+		const nextDetails: Details = {
+			...snapshot.result.details,
+			mode: "workflow",
+			workflow: update.workflow,
+			...(update.chatProgress ? { chatProgress: update.chatProgress } : {}),
+		};
+		liveSnapshots.set(requestId, {
+			result: { ...snapshot.result, details: nextDetails },
+			version: nextVersion(),
+		});
+		return;
+	}
 	const progress = update.progress;
-	if (!progress || !snapshot.result.details) return;
+	if (!progress) return;
 	const currentStepIndex = progress.findIndex((entry) => entry.status === "running");
 	const nextDetails: Details = {
 		...snapshot.result.details,