@selesai/code 0.9.11 → 0.9.13

package/dist/extensions/pi-subagents/src/shared/watch-strategy.ts

@@ -0,0 +1,10 @@
+export type FileWatchPurpose =
+	| "result-delivery"
+	| "supervisor-channel"
+	| "async-job-tracker"
+	| "runner-control-inbox"
+	| "child-steering-inbox";
+
+export function shouldUseNativeFsWatch(_purpose: FileWatchPurpose, platform: NodeJS.Platform = process.platform): boolean {
+	return platform !== "darwin";
+}

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

@@ -2,9 +2,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 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 type { ChainStep } from "../shared/settings.ts";
 import { getPromptDirectories } from "../shared/prompt-resources.ts";
 
 interface PromptWorkflow {
@@ -247,75 +245,6 @@ 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;
@@ -355,95 +284,4 @@ export function registerPromptWorkflowCommands(input: {
 		},
 	});
 
-	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;
-				}
-				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

@@ -28,8 +28,6 @@ export interface SlashSubagentResponse {
 export interface SlashSubagentUpdate {
 	requestId: string;
 	progress?: Details["progress"];
-	workflow?: Details["workflow"];
-	chatProgress?: Details["chatProgress"];
 	currentTool?: string;
 	toolCount?: number;
 }
@@ -41,6 +39,7 @@ interface EventBus {
 
 interface SlashBridgeOptions {
 	events: EventBus;
+	asyncByDefault: boolean;
 	getContext: () => ExtensionContext | null;
 	execute: (
 		id: string,
@@ -81,7 +80,7 @@ export function registerSlashSubagentBridge(options: SlashBridgeOptions): {
 		const request = data as Partial<SlashSubagentRequest>;
 		if (typeof request.requestId !== "string" || !request.params) return;
 		const { requestId } = request as SlashSubagentRequest;
-		const normalized = normalizePublicSubagentExecution((request as SlashSubagentRequest).params);
+		const normalized = normalizePublicSubagentExecution((request as SlashSubagentRequest).params, { asyncByDefault: options.asyncByDefault });
 		if (!normalized.ok) {
 			options.events.emit(SLASH_SUBAGENT_RESPONSE_EVENT, {
 				requestId,
@@ -144,8 +143,6 @@ 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

@@ -3,8 +3,8 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { keyText, type ExtensionAPI, type ExtensionContext } from "@selesai/code";
 import { Key, matchesKey, truncateToWidth, type Component, type KeyId, type TUI } from "@earendil-works/pi-tui";
-import { BUILTIN_AGENT_NAMES, discoverAgents } from "../agents/agents.ts";
-import { registerInlineSubagentInvocation } from "./inline-subagents.ts";
+import { BUILTIN_AGENT_NAMES, discoverAgents, discoverAgentsAll, findBlockingAgentDiagnostic, resolveAgentName, type AgentConfig, type AgentDiscoveryDiagnostic, type AgentScope } from "../agents/agents.ts";
+import { listRuntimeAgentConfigs, mergeRuntimeAgents } from "../agents/runtime-agent-registry.ts";
 import { resolveExistingReadPaths } from "../shared/settings.ts";
 import {
 	DEFAULT_PROVIDER_MODELS_MAX_AGE_DAYS,
@@ -19,11 +19,14 @@ import type { SubagentParamsLike } from "../runs/foreground/subagent-executor.ts
 import { findModelInfo, toModelInfo } from "../shared/model-info.ts";
 import { formatTokens, shortenPath } from "../shared/formatters.ts";
 import { listAsyncRuns, formatAsyncRunProgressLabel, type AsyncRunSummary } from "../runs/background/async-status.ts";
+import { encodeInspectReply, handleInspectRpcArgs, INSPECT_WIDGET_KEY } from "../runs/background/inspect-rpc.ts";
+import { listScheduledRunSummaries } from "../runs/background/scheduled-runs.ts";
 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,
 	buildSlashInitialResult,
@@ -105,9 +108,22 @@ const extractExecutionFlags = (rawArgs: string): { args: string; bg: boolean; fo
 	return { args, bg, fork };
 };
 
-const makeAgentCompletions = (state: SubagentState) => (prefix: string) => {
+function discoverSlashAgents(pi: ExtensionAPI, cwd: string, scope: AgentScope): { agents: AgentConfig[]; agentDiagnostics?: AgentDiscoveryDiagnostic[] } {
+	const discovered = discoverAgents(cwd, scope);
+	if (listRuntimeAgentConfigs(pi).length === 0) return discovered;
+	const all = discoverAgentsAll(cwd);
+	const configuredAgents: AgentConfig[] = [
+		...all.builtin,
+		...all.package,
+		...(scope !== "project" ? all.user : []),
+		...(scope !== "user" ? all.project : []),
+	];
+	return mergeRuntimeAgents(pi, discovered, configuredAgents);
+}
+
+const makeAgentCompletions = (pi: ExtensionAPI, state: SubagentState) => (prefix: string) => {
 	if (!state.baseCwd || prefix.includes(" ")) return null;
-	return discoverAgents(state.baseCwd, "both").agents
+	return discoverSlashAgents(pi, state.baseCwd, "both").agents
 		.filter((agent) => agent.name.startsWith(prefix))
 		.map((agent) => ({ value: agent.name, label: agent.name }));
 };
@@ -152,7 +168,7 @@ async function withSlashStatus<T>(
 type Theme = ExtensionContext["ui"]["theme"];
 
 type StopSelectorTarget = {
-	kind: "async";
+	kind: "async" | "scheduled";
 	id: string;
 	label: string;
 	detail: string;
@@ -162,7 +178,9 @@ type StopSelectorTarget = {
 type StopSelectorResult = { confirmed: boolean; target?: StopSelectorTarget };
 
 function commandForTarget(target: StopSelectorTarget): string {
-	return `subagent({ action: "stop", id: ${JSON.stringify(target.id)} })`;
+	return target.kind === "scheduled"
+		? `subagent({ action: "schedule.pause", id: ${JSON.stringify(target.id)} })`
+		: `subagent({ action: "stop", id: ${JSON.stringify(target.id)} })`;
 }
 
 function formatAsyncStopTarget(run: AsyncRunSummary): StopSelectorTarget {
@@ -177,13 +195,30 @@ function formatAsyncStopTarget(run: AsyncRunSummary): StopSelectorTarget {
 	};
 }
 
+function scheduledStopTargets(ctx: ExtensionContext, _state: SubagentState): StopSelectorTarget[] {
+	try {
+		return listScheduledRunSummaries(ctx.cwd)
+			.filter((schedule) => !schedule.paused && !schedule.activeRunId && schedule.trigger.nextRunAt)
+			.sort((left, right) => left.trigger.nextRunAt!.localeCompare(right.trigger.nextRunAt!))
+			.map((schedule) => ({
+				kind: "scheduled" as const,
+				id: schedule.id,
+				label: `${schedule.id} · ${schedule.name}`,
+				detail: `scheduled · ${schedule.trigger.nextRunAt}`,
+				actionLabel: "pause schedule",
+			}));
+	} catch {
+		return [];
+	}
+}
+
 function discoverStopTargets(ctx: ExtensionContext, state: SubagentState): StopSelectorTarget[] {
 	const sessionId = state.currentSessionId ?? ctx.sessionManager.getSessionId() ?? undefined;
 	const asyncTargets = listAsyncRuns(DIRS.async, {
 		states: ["queued", "running"],
 		...(sessionId ? { sessionId } : {}),
 	}).map(formatAsyncStopTarget);
-	return asyncTargets;
+	return [...asyncTargets, ...scheduledStopTargets(ctx, state)];
 }
 
 function stopFallbackText(targets: StopSelectorTarget[]): string {
@@ -273,7 +308,7 @@ class SubagentsStopSelector implements Component {
 			const selected = index === this.selected;
 			const marker = selected ? "›" : " ";
 				const actionLabel = target.actionLabel;
-			const action = this.theme.fg("accent", actionLabel);
+			const action = target.kind === "scheduled" ? this.theme.fg("warning", actionLabel) : this.theme.fg("accent", actionLabel);
 			const labelWidth = Math.max(0, contentWidth - marker.length - actionLabel.length - 2);
 			lines.push(`${marker} ${action} ${target.label.slice(0, labelWidth)}`);
 			if (selected) lines.push(this.theme.fg("dim", `  ${target.detail}`.slice(0, contentWidth)));
@@ -613,7 +648,25 @@ export function registerSlashCommands(
 	state: SubagentState,
 	options: { fleetKeybindings?: FleetKeybindingsConfig; foregroundDetachShortcut?: string } = {},
 ): void {
-	registerInlineSubagentInvocation(pi, state);
+	let fleetOpen = false;
+	const showFleet = async (ctx: ExtensionContext) => {
+		state.lastUiContext = ctx;
+		if (!ctx.hasUI) {
+			await runSlashSubagent(pi, ctx, { action: "status", view: "fleet" });
+			return;
+		}
+		if (fleetOpen) {
+			ctx.ui.notify("Subagent fleet inspector is already open.", "info");
+			return;
+		}
+		fleetOpen = true;
+		try {
+			await openSubagentFleet(ctx, state, { asyncDirRoot: DIRS.async, resultsDir: DIRS.results, fleetKeybindings: options.fleetKeybindings });
+		} finally {
+			fleetOpen = false;
+		}
+	};
+
 	pi.registerCommand("subagents", {
 		description: "Administer subagents: inspect metadata and update models, thinking, or prompts",
 		handler: async (args, ctx) => {
@@ -623,7 +676,7 @@ export function registerSlashCommands(
 
 	pi.registerCommand("run", {
 		description: "Run one subagent through workflowScript: /run agent[output=file] [task] [--bg] [--fork]",
-		getArgumentCompletions: makeAgentCompletions(state),
+		getArgumentCompletions: makeAgentCompletions(pi, state),
 		handler: async (args, ctx) => {
 			const { args: cleanedArgs, bg, fork } = extractExecutionFlags(args);
 			const input = cleanedArgs.trim();
@@ -633,8 +686,16 @@ export function registerSlashCommands(
 			const task = firstSpace === -1 ? "" : input.slice(firstSpace + 1).trim();
 
 			if (!state.baseCwd) { ctx.ui.notify("Subagent session cwd is not initialized yet", "error"); return; }
-			const agents = discoverAgents(state.baseCwd, "both").agents;
-			if (!agents.find((a) => a.name === agentName)) { ctx.ui.notify(`Unknown agent: ${agentName}`, "error"); return; }
+			const discovered = discoverSlashAgents(pi, state.baseCwd, "both");
+			const resolvedAgent = resolveAgentName(agentName, discovered.agents);
+			const candidates = resolvedAgent.error
+				? discovered.agents.filter((agent) => resolveAgentName(agentName, [agent]).agent)
+				: resolvedAgent.agent;
+			const diagnostic = findBlockingAgentDiagnostic(agentName, candidates, discovered.agentDiagnostics);
+			if (diagnostic || resolvedAgent.error || !resolvedAgent.agent) {
+				ctx.ui.notify(diagnostic ? `Agent '${agentName}' has invalid configuration: ${diagnostic.error}` : resolvedAgent.error ?? `Unknown agent: ${agentName}`, "error");
+				return;
+			}
 
 			let finalTask = task;
 			if (inline.reads && Array.isArray(inline.reads) && inline.reads.length > 0) {
@@ -665,6 +726,23 @@ export function registerSlashCommands(
 		},
 	});
 
+	pi.registerCommand("subagents-inspect-rpc", {
+		description: "Host integration bridge: answer an async child inspection request with a correlated widget payload (no model turn)",
+		handler: async (args, ctx) => {
+			if (ctx.mode === "tui") {
+				ctx.ui.notify("Inspection replies are emitted only on RPC surfaces. Use /subagents or subagent({ action: \"status\", view: \"transcript\" }) interactively.", "info");
+				return;
+			}
+			if (!ctx.hasUI) return;
+			const reply = handleInspectRpcArgs(args, { state });
+			// Emit-then-retract in one handler: stdio delivers the two widget
+			// updates in order, the host buffers the payload by requestId, and
+			// the dedicated key never accumulates visible state.
+			ctx.ui.setWidget(INSPECT_WIDGET_KEY, encodeInspectReply(reply));
+			ctx.ui.setWidget(INSPECT_WIDGET_KEY, undefined);
+		},
+	});
+
 	pi.registerCommand("subagents-guide", {
 		description: "Show a packaged subagents guide topic",
 		getArgumentCompletions: (prefix) => prefix.includes(" ") ? null : SUBAGENT_GUIDE_TOPICS
@@ -682,7 +760,7 @@ export function registerSlashCommands(
 
 	pi.registerCommand("subagents-refine", {
 		description: "Generate a bounded project-local refinement overlay for one subagent",
-		getArgumentCompletions: makeAgentCompletions(state),
+		getArgumentCompletions: makeAgentCompletions(pi, state),
 		handler: async (args, ctx) => {
 			const parts = args.trim().split(/\s+/).filter(Boolean);
 			if (parts.length !== 1) {
@@ -693,6 +771,16 @@ export function registerSlashCommands(
 		},
 	});
 
+	pi.registerCommand("subagents-fleet", {
+		description: "Open the live subagent fleet inspector",
+		handler: async (_args, ctx) => showFleet(ctx),
+	});
+
+	pi.registerShortcut(Key.ctrlAlt("f"), {
+		description: "Open subagent fleet inspector",
+		handler: async (ctx) => showFleet(ctx),
+	});
+
 	const detachForegroundRun = (args: string, ctx: ExtensionContext): void => {
 		const id = args.trim();
 		let control: ReturnType<typeof selectForegroundDetachControl>;
@@ -765,6 +853,10 @@ export function registerSlashCommands(
 				{ overlay: true, overlayOptions: { anchor: "center", width: 88, maxHeight: "80%" } },
 			);
 			if (!result?.confirmed || !result.target) return;
+			if (result.target.kind === "scheduled") {
+				await runSlashSubagent(pi, ctx, { action: "schedule.pause", id: result.target.id });
+				return;
+			}
 			await runSlashSubagent(pi, ctx, { action: "stop", id: result.target.id });
 		},
 	});

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

@@ -82,7 +82,7 @@ function buildParallelInitialResult(params: SubagentParamsLike): AgentToolResult
 		details: {
 			mode: "parallel",
 			...(params.async ? { background: true } : {}),
-			...(params.context ? { context: params.context } : {}),
+			...(params.context === "fresh" || params.context === "fork" ? { context: params.context } : {}),
 			results: tasks.map((task, index) => createPlaceholderResult(task.agent, task.task, "running", index)),
 			progress: tasks.map((task, index) => ({
 				index,
@@ -138,7 +138,7 @@ function buildChainInitialResult(params: SubagentParamsLike): AgentToolResult<De
 		details: {
 			mode: "chain",
 			...(params.async ? { background: true } : {}),
-			...(params.context ? { context: params.context } : {}),
+			...(params.context === "fresh" || params.context === "fork" ? { context: params.context } : {}),
 			results,
 			progress: results.map((result, index) => ({
 				index,
@@ -167,7 +167,7 @@ function buildSingleInitialResult(params: SubagentParamsLike): AgentToolResult<D
 		details: {
 			mode: "single",
 			...(params.async ? { background: true } : {}),
-			...(params.context ? { context: params.context } : {}),
+			...(params.context === "fresh" || params.context === "fork" ? { context: params.context } : {}),
 			results: [createPlaceholderResult(agent, task, "running", 0)],
 			progress: [{
 				index: 0,
@@ -184,29 +184,12 @@ 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 } : {}),
-			...(params.async ? { background: true } : {}),
-			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)
-			: params.workflowScript !== undefined
-				? buildWorkflowInitialResult(params)
-				: buildSingleInitialResult(params);
+			: buildSingleInitialResult(params);
 	liveSnapshots.set(requestId, { result, version: nextVersion() });
 	finalSnapshots.delete(requestId);
 	return { requestId, result };
@@ -226,22 +209,9 @@ function cloneResultsWithProgress(
 
 export function applySlashUpdate(requestId: string, update: SlashSubagentUpdate): void {
 	const snapshot = liveSnapshots.get(requestId);
-	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;
-	}
+	if (!snapshot) return;
 	const progress = update.progress;
-	if (!progress) return;
+	if (!progress || !snapshot.result.details) return;
 	const currentStepIndex = progress.findIndex((entry) => entry.status === "running");
 	const nextDetails: Details = {
 		...snapshot.result.details,